diff --git a/CMakeLists.txt b/CMakeLists.txt
index 52e0f75ff..96814b6fb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,201 +1,202 @@
 # SPDX-License-Identifier: CC0-1.0
 # SPDX-FileCopyrightText: none
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 set(PIM_VERSION "5.23.43")
 
 project(libkleo VERSION ${PIM_VERSION})
 
 set(KF_MIN_VERSION "5.105.0")
 
 if (WIN32)
   set(KF5_WANT_VERSION "5.70.0")
 else ()
   set(KF5_WANT_VERSION ${KF_MIN_VERSION})
 endif ()
 
 find_package(ECM ${KF5_WANT_VERSION} CONFIG REQUIRED)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 
 include(ECMGenerateExportHeader)
 include(ECMSetupVersion)
 include(ECMGenerateHeaders)
 include(ECMGeneratePriFile)
 
 include(FeatureSummary)
 include(ECMQtDeclareLoggingCategory)
 include(ECMDeprecationSettings)
 include(ECMAddQch)
 include(KDEClangFormat)
 include(KDEGitCommitHooks)
 option(BUILD_WITH_COMPAT_LIBS "Generate compat cmake file (Set at false will allow to co-install lib)" ON)
 
 option(BUILD_QCH "Build API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)" OFF)
 add_feature_info(QCH ${BUILD_QCH} "API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)")
 
 set(LIBKLEO_LIB_VERSION ${PIM_VERSION})
 set(QT_REQUIRED_VERSION "5.15.2")
 if (QT_MAJOR_VERSION STREQUAL "6")
     set(QT_REQUIRED_VERSION "6.4.0")
     set(KF_MIN_VERSION "5.240.0")
     set(KF_MAJOR_VERSION "6")
 else()
     set(KF_MAJOR_VERSION "5")
 endif()
 
 set(KDEPIMTEXTEDIT_VERSION "5.23.40")
 set(GPGME_REQUIRED_VERSION "1.16.0")
 
 find_package(Qt${QT_MAJOR_VERSION} ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets)
 if (QT_MAJOR_VERSION STREQUAL "6")
     find_package(Qt6Core5Compat)
 endif()
 find_package(KF${KF_MAJOR_VERSION}I18n ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}Config ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}WidgetsAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}ConfigWidgets ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}Completion ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}CoreAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}Codecs ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}ItemModels ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KPim${KF_MAJOR_VERSION}TextEdit ${KDEPIMTEXTEDIT_VERSION} CONFIG)
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 set_package_properties(Gpgmepp PROPERTIES DESCRIPTION "GpgME++ Library" URL "https://www.gnupg.org" TYPE REQUIRED PURPOSE "GpgME++ is required for OpenPGP support")
 if (Gpgmepp_VERSION VERSION_GREATER_EQUAL "1.19.1")
     set(GPGMEPP_KEY_CANSIGN_IS_FIXED 1)
+    set(GPGMEPP_ERROR_ASSTRING_RETURNS_UTF8_ON_WINDOWS 1)
 endif()
 if (QT_MAJOR_VERSION STREQUAL "6")
     find_package(QGpgmeQt6 ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 else()
     find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 endif()
 message(STATUS "GpgME++ Version ${Gpgmepp_VERSION}")
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.18.1")
     set(QGPGME_LISTALLKEYSJOB_HAS_OPTIONS 1)
 endif()
 
 find_package(Boost 1.34.0)
 set_package_properties(Boost PROPERTIES DESCRIPTION "Boost C++ Libraries" URL "https://www.boost.org" TYPE REQUIRED PURPOSE "Boost is required for building most KDEPIM applications")
 
 
 set_package_properties(KPim${KF_MAJOR_VERSION}TextEdit PROPERTIES DESCRIPTION
                        "A textedit with PIM-specific features."
                        URL "https://commits.kde.org/kpimtextedit"
                        TYPE OPTIONAL PURPOSE "Improved audit log viewer.")
 
 ecm_setup_version(PROJECT VARIABLE_PREFIX LIBKLEO
                         VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/libkleo_version.h"
                         PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KPim${KF_MAJOR_VERSION}LibkleoConfigVersion.cmake"
                         SOVERSION 5
 )
 
 ########### Targets ###########
 ecm_set_disabled_deprecation_versions(QT 5.15.2  KF 5.105.0)
 
 remove_definitions(-DQT_NO_FOREACH)
 add_definitions(-DQT_NO_EMIT)
 ########### CMake Config Files ###########
 set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KPim${KF_MAJOR_VERSION}Libkleo")
 set(LIBKLEO_KF5_COMPAT FALSE)
 configure_package_config_file(
   "${CMAKE_CURRENT_SOURCE_DIR}/KPimLibkleoConfig.cmake.in"
   "${CMAKE_CURRENT_BINARY_DIR}/KPim${KF_MAJOR_VERSION}LibkleoConfig.cmake"
   INSTALL_DESTINATION  ${CMAKECONFIG_INSTALL_DIR}
 )
 
 install(FILES
   "${CMAKE_CURRENT_BINARY_DIR}/KPim${KF_MAJOR_VERSION}LibkleoConfig.cmake"
   "${CMAKE_CURRENT_BINARY_DIR}/KPim${KF_MAJOR_VERSION}LibkleoConfigVersion.cmake"
   DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
   COMPONENT Devel
 )
 
 install(EXPORT KPim${KF_MAJOR_VERSION}LibkleoTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE KPim${KF_MAJOR_VERSION}LibkleoTargets.cmake NAMESPACE KPim${KF_MAJOR_VERSION}::)
 
 install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/libkleo_version.h
   DESTINATION ${KDE_INSTALL_INCLUDEDIR}/KPim${KF_MAJOR_VERSION}/Libkleo COMPONENT Devel
 )
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-libkleo.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-libkleo.h)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" OFF)
 
 set(COMPILE_WITH_UNITY_CMAKE_SUPPORT OFF)
 if (USE_UNITY_CMAKE_SUPPORT)
     set(COMPILE_WITH_UNITY_CMAKE_SUPPORT ON)
 endif()
 
 
 add_subdirectory(src)
 if (BUILD_TESTING)
     add_subdirectory(autotests)
     add_subdirectory(tests)
 endif()
 
 ecm_qt_install_logging_categories(
         EXPORT LIBKLEO
         FILE libkleo.categories
         DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
         )
 
 ki18n_install(po)
 if (BUILD_QCH)
     ecm_install_qch_export(
         TARGETS KPim${KF_MAJOR_VERSION}Libkleo_QCH
         FILE KPim${KF_MAJOR_VERSION}LibkleoQchTargets.cmake
         DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
         COMPONENT Devel
     )
     set(PACKAGE_INCLUDE_QCHTARGETS "include(\"\${CMAKE_CURRENT_LIST_DIR}/KPim${KF_MAJOR_VERSION}LibkleoQchTargets.cmake\")")
 endif()
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 # add clang-format target for all our real source files
 file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h *.c)
 kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES})
 kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)
 
 if (BUILD_WITH_COMPAT_LIBS)
 #if (QT_MAJOR_VERSION STREQUAL "5")
 ##
 # TODO: Backwards compatiblity. Remove in next major version
 ##
 set(CMAKECONFIG_INSTALL_DIR_KF5 "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5Libkleo")
 set(LIBKLEO_KF5_COMPAT TRUE)
 configure_package_config_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/KPimLibkleoConfig.cmake.in"
     "${CMAKE_CURRENT_BINARY_DIR}/KF5LibkleoConfig.cmake"
     INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR_KF5}
 )
 
 install(FILES
     "${CMAKE_CURRENT_BINARY_DIR}/KF5LibkleoConfig.cmake"
     DESTINATION "${CMAKECONFIG_INSTALL_DIR_KF5}"
     COMPONENT Devel
 )
 install(FILES
     "${CMAKE_CURRENT_BINARY_DIR}/KPim${KF_MAJOR_VERSION}LibkleoConfigVersion.cmake"
     RENAME "KF5LibkleoConfigVersion.cmake"
     DESTINATION "${CMAKECONFIG_INSTALL_DIR_KF5}"
     COMPONENT Devel
 )
 install(EXPORT KPim${KF_MAJOR_VERSION}LibkleoTargets
     DESTINATION "${CMAKECONFIG_INSTALL_DIR_KF5}"
     FILE KPim${KF_MAJOR_VERSION}LibkleoTargets.cmake
     NAMESPACE KF5::
 )
 if (BUILD_QCH)
     install(FILES
         "${CMAKE_CURRENT_BINARY_DIR}/KPim${KF_MAJOR_VERSION}LibkleoQchTargets.cmake"
         DESTINATION "${CMAKECONFIG_INSTALL_DIR_KF5}"
         COMPONENT Devel
     )
 endif()
 #endif()
 endif()
diff --git a/config-libkleo.h.cmake b/config-libkleo.h.cmake
index 23405dd7f..3138caae9 100644
--- a/config-libkleo.h.cmake
+++ b/config-libkleo.h.cmake
@@ -1,5 +1,8 @@
 /* Defined if QGpgME::ListAllKeysJob supports setting options */
 #cmakedefine QGPGME_LISTALLKEYSJOB_HAS_OPTIONS 1
 
 /* Defined if Key::canSign should be used instead of deprecated Key::canReallySign */
 #cmakedefine01 GPGMEPP_KEY_CANSIGN_IS_FIXED
+
+/* Whether Error::asString() returns UTF-8 encoded strings on Windows */
+#cmakedefine01 GPGMEPP_ERROR_ASSTRING_RETURNS_UTF8_ON_WINDOWS
diff --git a/src/kleo/auditlogentry.cpp b/src/kleo/auditlogentry.cpp
index 5eaf7f68a..58446b7c4 100644
--- a/src/kleo/auditlogentry.cpp
+++ b/src/kleo/auditlogentry.cpp
@@ -1,117 +1,118 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     kleo/auditlogentry.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2022 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-libkleo.h>
 
 #include "auditlogentry.h"
 
+#include <libkleo/formatting.h>
 #include <libkleo_debug.h>
 
 #include <QGpgME/Job>
 
 #include <QUrl>
 #include <QUrlQuery>
 
 #include <gpgme++/error.h>
 
 using namespace Kleo;
 
 class AuditLogEntry::Private
 {
 public:
     QString text;
     GpgME::Error error;
 };
 
 AuditLogEntry::AuditLogEntry()
     : AuditLogEntry{QString{}, GpgME::Error{}}
 {
 }
 
 AuditLogEntry::AuditLogEntry(const GpgME::Error &error)
     : AuditLogEntry{QString{}, error}
 {
 }
 
 AuditLogEntry::AuditLogEntry(const QString &text, const GpgME::Error &error)
     : d{new Private{text, error}}
 {
 }
 
 AuditLogEntry::~AuditLogEntry() = default;
 
 AuditLogEntry::AuditLogEntry(const AuditLogEntry &other)
     : d{new Private{*other.d}}
 {
 }
 
 AuditLogEntry &AuditLogEntry::operator=(const AuditLogEntry &other)
 {
     *d = *other.d;
     return *this;
 }
 
 AuditLogEntry::AuditLogEntry(AuditLogEntry &&other) = default;
 AuditLogEntry &AuditLogEntry::operator=(AuditLogEntry &&other) = default;
 
 AuditLogEntry AuditLogEntry::fromJob(const QGpgME::Job *job)
 {
     if (job) {
         return AuditLogEntry{job->auditLogAsHtml(), job->auditLogError()};
     } else {
         return AuditLogEntry{};
     }
 }
 
 GpgME::Error AuditLogEntry::error() const
 {
     return d->error;
 }
 
 QString AuditLogEntry::text() const
 {
     return d->text;
 }
 
 QUrl AuditLogEntry::asUrl(const QUrl &urlTemplate) const
 {
     // more or less the same as
     // kmail/objecttreeparser.cpp:makeShowAuditLogLink(), so any bug
     // fixed here equally applies there:
     if (const int code = d->error.code()) {
         if (code == GPG_ERR_NOT_IMPLEMENTED) {
             qCDebug(LIBKLEO_LOG) << "not showing link (not implemented)";
         } else if (code == GPG_ERR_NO_DATA) {
             qCDebug(LIBKLEO_LOG) << "not showing link (not available)";
         } else {
-            qCDebug(LIBKLEO_LOG) << "Error Retrieving Audit Log:" << QString::fromLocal8Bit(d->error.asString());
+            qCDebug(LIBKLEO_LOG) << "Error Retrieving Audit Log:" << Formatting::errorAsString(d->error);
         }
         return {};
     }
 
     if (d->text.isEmpty()) {
         return {};
     }
 
     QUrl url = urlTemplate;
     QUrlQuery urlQuery{url};
     urlQuery.addQueryItem(QStringLiteral("log"), d->text);
     url.setQuery(urlQuery);
     return url;
 }
 
 QDebug operator<<(QDebug debug, const AuditLogEntry &auditLog)
 {
     const bool oldSetting = debug.autoInsertSpaces();
-    debug.nospace() << "AuditLogEntry(" << auditLog.error().asString() << ", " << auditLog.text() << ')';
+    debug.nospace() << "AuditLogEntry(" << Formatting::errorAsString(auditLog.error()) << ", " << auditLog.text() << ')';
     debug.setAutoInsertSpaces(oldSetting);
     return debug.maybeSpace();
 }
diff --git a/src/ui/auditlogviewer.cpp b/src/ui/auditlogviewer.cpp
index 6818b26b3..7a129716d 100644
--- a/src/ui/auditlogviewer.cpp
+++ b/src/ui/auditlogviewer.cpp
@@ -1,184 +1,185 @@
 /*
     SPDX-FileCopyrightText: 2015-2021 Laurent Montel <montel@kde.org>
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include <config-libkleo.h>
 
 #include "auditlogviewer.h"
 
-#include <kleo/auditlogentry.h>
+#include <libkleo/auditlogentry.h>
+#include <libkleo/formatting.h>
 
 #include <KConfigGroup>
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KStandardGuiItem>
 
 #ifdef HAVE_PIMTEXTEDIT
 #include <KPIMTextEdit/RichTextEditor>
 #else
 #include <QTextEdit>
 #endif
 
 #include <QDebug>
 #include <QDialogButtonBox>
 #include <QFileDialog>
 #include <QPushButton>
 #include <QSaveFile>
 #include <QStyle>
 #include <QTextStream>
 #include <QVBoxLayout>
 
 #include <gpgme++/error.h>
 
 using namespace Kleo;
 
 AuditLogViewer::AuditLogViewer(const QString &log, QWidget *parent)
     : QDialog(parent)
     , m_log(/* sic */)
     ,
 #ifdef HAVE_PIMTEXTEDIT
     m_textEdit(new KPIMTextEdit::RichTextEditorWidget(this))
 #else
     m_textEdit(new QTextEdit(this))
 #endif
 {
     setWindowTitle(i18nc("@title:window", "View GnuPG Audit Log"));
     QDialogButtonBox *buttonBox = new QDialogButtonBox{};
 
     auto copyClipBtn = buttonBox->addButton(i18n("&Copy to Clipboard"), QDialogButtonBox::ActionRole);
     copyClipBtn->setObjectName(QStringLiteral("copyClipBtn"));
     copyClipBtn->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
     connect(copyClipBtn, &QPushButton::clicked, this, &AuditLogViewer::slotCopyClip);
 
     auto saveAsBtn = buttonBox->addButton(i18n("&Save to Disk..."), QDialogButtonBox::ActionRole);
     saveAsBtn->setObjectName(QStringLiteral("saveAsBtn"));
     saveAsBtn->setIcon(QIcon::fromTheme(QStringLiteral("document-save-as")));
     connect(saveAsBtn, &QPushButton::clicked, this, &AuditLogViewer::slotSaveAs);
 
     auto closeBtn = buttonBox->addButton(QString{}, QDialogButtonBox::AcceptRole);
     closeBtn->setObjectName(QStringLiteral("Close"));
     KGuiItem::assign(closeBtn, KStandardGuiItem::close());
 
     m_textEdit->setObjectName(QStringLiteral("m_textEdit"));
     m_textEdit->setReadOnly(true);
 
     auto mainLayout = new QVBoxLayout(this);
     mainLayout->addWidget(m_textEdit);
     mainLayout->addWidget(buttonBox);
 
 #if 0
     qDebug() << "buttonBox->style()->styleHint(QStyle::SH_DialogButtonLayout, ...):" << buttonBox->style()->styleHint(QStyle::SH_DialogButtonLayout, nullptr, buttonBox);
     qDebug() << __func__ << "buttonBox->focusProxy():" << buttonBox->focusProxy();
     qDebug() << __func__ << "copyClipBtn->nextInFocusChain():" << copyClipBtn->nextInFocusChain();
     qDebug() << __func__ << "saveAsBtn->nextInFocusChain():" << saveAsBtn->nextInFocusChain();
     qDebug() << __func__ << "closeBtn->nextInFocusChain():" << closeBtn->nextInFocusChain();
 #endif
 
     connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
     setAuditLog(log);
 
     readConfig();
 }
 
 AuditLogViewer::~AuditLogViewer()
 {
     writeConfig();
 }
 
 // static
 void AuditLogViewer::showAuditLog(QWidget *parent, const AuditLogEntry &auditLog, const QString &title)
 {
     const GpgME::Error err = auditLog.error();
     if (err.code() == GPG_ERR_NOT_IMPLEMENTED) {
         KMessageBox::information(parent, i18n("Your system does not have support for GnuPG Audit Logs"), i18n("System Error"));
         return;
     }
     if (err && err.code() != GPG_ERR_NO_DATA) {
         KMessageBox::information(parent,
-                                 i18n("An error occurred while trying to retrieve the GnuPG Audit Log:\n%1", QString::fromLocal8Bit(err.asString())),
+                                 i18n("An error occurred while trying to retrieve the GnuPG Audit Log:\n%1", Formatting::errorAsString(err)),
                                  i18n("GnuPG Audit Log Error"));
         return;
     }
     if (auditLog.text().isEmpty()) {
         KMessageBox::information(parent, i18n("No GnuPG Audit Log available for this operation."), i18n("No GnuPG Audit Log"));
         return;
     }
 
     const auto alv = new AuditLogViewer{auditLog.text(), parent};
     alv->setAttribute(Qt::WA_DeleteOnClose);
     alv->setWindowTitle(title.isEmpty() ? i18n("GnuPG Audit Log Viewer") : title);
     alv->show();
 }
 
 void AuditLogViewer::setAuditLog(const QString &log)
 {
     if (log == m_log) {
         return;
     }
     m_log = log;
     m_textEdit->setHtml(QLatin1String("<qt>") + log + QLatin1String("</qt>"));
 }
 
 void AuditLogViewer::slotSaveAs()
 {
     const QString fileName = QFileDialog::getSaveFileName(this, i18n("Choose File to Save GnuPG Audit Log to"));
     if (fileName.isEmpty()) {
         return;
     }
 
     QSaveFile file(fileName);
 
     if (file.open(QIODevice::WriteOnly)) {
         QTextStream s(&file);
         s << "<html><head>";
         if (!windowTitle().isEmpty()) {
             s << "\n<title>" << windowTitle().toHtmlEscaped() << "</title>\n";
         }
         s << "</head><body>\n" << m_log << "\n</body></html>\n";
         s.flush();
         file.commit();
     }
 
     if (const int err = file.error()) {
         KMessageBox::error(this, i18n("Could not save to file \"%1\": %2", file.fileName(), QString::fromLocal8Bit(strerror(err))), i18n("File Save Error"));
     }
 }
 
 void AuditLogViewer::slotCopyClip()
 {
 #ifdef HAVE_PIMTEXTEDIT
     m_textEdit->editor()->selectAll();
     m_textEdit->editor()->copy();
     m_textEdit->editor()->textCursor().clearSelection();
 #else
     m_textEdit->selectAll();
     m_textEdit->copy();
     m_textEdit->textCursor().clearSelection();
 #endif
 }
 
 void AuditLogViewer::readConfig()
 {
     KConfigGroup group(KSharedConfig::openConfig(), "AuditLogViewer");
     const QSize size = group.readEntry("Size", QSize());
     if (size.isValid()) {
         resize(size);
     } else {
         resize(600, 400);
     }
 }
 
 void AuditLogViewer::writeConfig()
 {
     KConfigGroup group(KSharedConfig::openConfig(), "AuditLogViewer");
     group.writeEntry("Size", size());
     group.sync();
 }
diff --git a/src/ui/keyrequester.cpp b/src/ui/keyrequester.cpp
index bb55264a5..d62a6a352 100644
--- a/src/ui/keyrequester.cpp
+++ b/src/ui/keyrequester.cpp
@@ -1,513 +1,513 @@
 /*  -*- c++ -*-
     keyrequester.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.cpp
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     This file is part of KPGP, the KDE PGP/GnuPG support library.
 
     SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include <config-libkleo.h>
 
 #include "keyrequester.h"
 
 #include "keyselectiondialog.h"
 
 #include <libkleo/algorithm.h>
 #include <libkleo/compliance.h>
 #include <libkleo/dn.h>
 #include <libkleo/formatting.h>
 #include <libkleo/keyhelpers.h>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QGpgME/KeyListJob>
 
 #include <QApplication>
 #include <QDialog>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QString>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 using namespace QGpgME;
 using namespace Kleo;
 
 Kleo::KeyRequester::KeyRequester(unsigned int allowedKeys, bool multipleKeys, QWidget *parent)
     : QWidget(parent)
     , mOpenPGPBackend(nullptr)
     , mSMIMEBackend(nullptr)
     , mMulti(multipleKeys)
     , mKeyUsage(allowedKeys)
     , mJobs(0)
     , d(nullptr)
 {
     init();
 }
 
 Kleo::KeyRequester::KeyRequester(QWidget *parent)
     : QWidget(parent)
     , mOpenPGPBackend(nullptr)
     , mSMIMEBackend(nullptr)
     , mMulti(false)
     , mKeyUsage(0)
     , mJobs(0)
     , d(nullptr)
 {
     init();
 }
 
 void Kleo::KeyRequester::init()
 {
     auto hlay = new QHBoxLayout(this);
     hlay->setContentsMargins(0, 0, 0, 0);
 
     if (DeVSCompliance::isCompliant()) {
         mComplianceIcon = new QLabel{this};
         mComplianceIcon->setPixmap(QIcon::fromTheme(QStringLiteral("emblem-question")).pixmap(22));
     }
 
     // the label where the key id is to be displayed:
     mLabel = new QLabel(this);
     mLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
 
     // the button to unset any key:
     mEraseButton = new QPushButton(this);
     mEraseButton->setAutoDefault(false);
     mEraseButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum));
     mEraseButton->setIcon(
         QIcon::fromTheme(QApplication::isRightToLeft() ? QStringLiteral("edit-clear-locationbar-ltr") : QStringLiteral("edit-clear-locationbar-rtl")));
     mEraseButton->setToolTip(i18n("Clear"));
 
     // the button to call the KeySelectionDialog:
     mDialogButton = new QPushButton(i18n("Change..."), this);
     mDialogButton->setAutoDefault(false);
 
     if (mComplianceIcon) {
         hlay->addWidget(mComplianceIcon);
     }
     hlay->addWidget(mLabel, 1);
     hlay->addWidget(mEraseButton);
     hlay->addWidget(mDialogButton);
 
     connect(mEraseButton, &QPushButton::clicked, this, &SigningKeyRequester::slotEraseButtonClicked);
     connect(mDialogButton, &QPushButton::clicked, this, &SigningKeyRequester::slotDialogButtonClicked);
 
     setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed));
 
     setAllowedKeys(mKeyUsage);
 }
 
 Kleo::KeyRequester::~KeyRequester()
 {
 }
 
 const std::vector<GpgME::Key> &Kleo::KeyRequester::keys() const
 {
     return mKeys;
 }
 
 const GpgME::Key &Kleo::KeyRequester::key() const
 {
     static const GpgME::Key null = GpgME::Key::null;
     if (mKeys.empty()) {
         return null;
     } else {
         return mKeys.front();
     }
 }
 
 void Kleo::KeyRequester::setKeys(const std::vector<GpgME::Key> &keys)
 {
     mKeys.clear();
     for (auto it = keys.begin(); it != keys.end(); ++it) {
         if (!it->isNull()) {
             mKeys.push_back(*it);
         }
     }
     updateKeys();
 }
 
 void Kleo::KeyRequester::setKey(const GpgME::Key &key)
 {
     mKeys.clear();
     if (!key.isNull()) {
         mKeys.push_back(key);
     }
     updateKeys();
 }
 
 QString Kleo::KeyRequester::fingerprint() const
 {
     if (mKeys.empty()) {
         return QString();
     } else {
         return QLatin1String(mKeys.front().primaryFingerprint());
     }
 }
 
 QStringList Kleo::KeyRequester::fingerprints() const
 {
     QStringList result;
     for (auto it = mKeys.begin(); it != mKeys.end(); ++it) {
         if (!it->isNull()) {
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
         }
     }
     return result;
 }
 
 void Kleo::KeyRequester::setFingerprint(const QString &fingerprint)
 {
     startKeyListJob(QStringList(fingerprint));
 }
 
 void Kleo::KeyRequester::setFingerprints(const QStringList &fingerprints)
 {
     startKeyListJob(fingerprints);
 }
 
 void Kleo::KeyRequester::updateKeys()
 {
     if (mKeys.empty()) {
         if (mComplianceIcon) {
             mComplianceIcon->setPixmap(QIcon::fromTheme(QStringLiteral("emblem-unavailable")).pixmap(22));
             mComplianceIcon->setToolTip(QString{});
         }
         mLabel->clear();
         return;
     }
     if (mKeys.size() > 1) {
         setMultipleKeysEnabled(true);
     }
 
     QStringList labelTexts;
     QString toolTipText;
     for (std::vector<GpgME::Key>::const_iterator it = mKeys.begin(); it != mKeys.end(); ++it) {
         if (it->isNull()) {
             continue;
         }
         const QString fpr = QLatin1String(it->primaryFingerprint());
         labelTexts.push_back(fpr.right(8));
         toolTipText += fpr.right(8) + QLatin1String(": ");
         if (const char *uid = it->userID(0).id()) {
             if (it->protocol() == GpgME::OpenPGP) {
                 toolTipText += QString::fromUtf8(uid);
             } else {
                 toolTipText += Kleo::DN(uid).prettyDN();
             }
         } else {
             toolTipText += xi18n("<placeholder>unknown</placeholder>");
         }
         toolTipText += QLatin1Char('\n');
     }
     if (mComplianceIcon) {
         if (Kleo::all_of(mKeys, &Kleo::DeVSCompliance::keyIsCompliant)) {
             mComplianceIcon->setPixmap(QIcon::fromTheme(QStringLiteral("emblem-success")).pixmap(22));
             mComplianceIcon->setToolTip(DeVSCompliance::name(true));
         } else {
             mComplianceIcon->setPixmap(QIcon::fromTheme(QStringLiteral("emblem-warning")).pixmap(22));
             mComplianceIcon->setToolTip(DeVSCompliance::name(false));
         }
     }
     mLabel->setText(labelTexts.join(QLatin1String(", ")));
     mLabel->setToolTip(toolTipText);
 }
 
 #ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 #define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 static void showKeyListError(QWidget *parent, const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n(
         "<qt><p>An error occurred while fetching "
         "the keys from the backend:</p>"
         "<p><b>%1</b></p></qt>",
-        QString::fromLocal8Bit(err.asString()));
+        Formatting::errorAsString(err));
 
     KMessageBox::error(parent, msg, i18n("Key Listing Failed"));
 }
 #endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 
 void Kleo::KeyRequester::startKeyListJob(const QStringList &fingerprints)
 {
     if (!mSMIMEBackend && !mOpenPGPBackend) {
         return;
     }
 
     mTmpKeys.clear();
     mJobs = 0;
 
     unsigned int count = 0;
     for (QStringList::const_iterator it = fingerprints.begin(); it != fingerprints.end(); ++it) {
         if (!(*it).trimmed().isEmpty()) {
             ++count;
         }
     }
 
     if (!count) {
         // don't fall into the trap that an empty pattern means
         // "return all keys" :)
         setKey(GpgME::Key::null);
         return;
     }
 
     if (mOpenPGPBackend) {
         KeyListJob *job = mOpenPGPBackend->keyListJob(false); // local, no sigs
         if (!job) {
             KMessageBox::error(this,
                                i18n("The OpenPGP backend does not support listing keys. "
                                     "Check your installation."),
                                i18n("Key Listing Failed"));
         } else {
             connect(job, &KeyListJob::result, this, &SigningKeyRequester::slotKeyListResult);
             connect(job, &KeyListJob::nextKey, this, &SigningKeyRequester::slotNextKey);
 
             const GpgME::Error err =
                 job->start(fingerprints, mKeyUsage & Kleo::KeySelectionDialog::SecretKeys && !(mKeyUsage & Kleo::KeySelectionDialog::PublicKeys));
 
             if (err) {
                 showKeyListError(this, err);
             } else {
                 ++mJobs;
             }
         }
     }
 
     if (mSMIMEBackend) {
         KeyListJob *job = mSMIMEBackend->keyListJob(false); // local, no sigs
         if (!job) {
             KMessageBox::error(this,
                                i18n("The S/MIME backend does not support listing keys. "
                                     "Check your installation."),
                                i18n("Key Listing Failed"));
         } else {
             connect(job, &KeyListJob::result, this, &SigningKeyRequester::slotKeyListResult);
             connect(job, &KeyListJob::nextKey, this, &SigningKeyRequester::slotNextKey);
 
             const GpgME::Error err =
                 job->start(fingerprints, mKeyUsage & Kleo::KeySelectionDialog::SecretKeys && !(mKeyUsage & Kleo::KeySelectionDialog::PublicKeys));
 
             if (err) {
                 showKeyListError(this, err);
             } else {
                 ++mJobs;
             }
         }
     }
 
     if (mJobs > 0) {
         mEraseButton->setEnabled(false);
         mDialogButton->setEnabled(false);
     }
 }
 
 void Kleo::KeyRequester::slotNextKey(const GpgME::Key &key)
 {
     if (!key.isNull()) {
         mTmpKeys.push_back(key);
     }
 }
 
 void Kleo::KeyRequester::slotKeyListResult(const GpgME::KeyListResult &res)
 {
     if (res.error()) {
         showKeyListError(this, res.error());
     }
 
     if (--mJobs <= 0) {
         mEraseButton->setEnabled(true);
         mDialogButton->setEnabled(true);
 
         setKeys(mTmpKeys);
         mTmpKeys.clear();
     }
 }
 
 void Kleo::KeyRequester::slotDialogButtonClicked()
 {
     KeySelectionDialog *dlg = mKeys.empty() ? new KeySelectionDialog(mDialogCaption, mDialogMessage, mInitialQuery, mKeyUsage, mMulti, false, this)
                                             : new KeySelectionDialog(mDialogCaption, mDialogCaption, mKeys, mKeyUsage, mMulti, false, this);
 
     if (dlg->exec() == QDialog::Accepted) {
         if (mMulti) {
             setKeys(dlg->selectedKeys());
         } else {
             setKey(dlg->selectedKey());
         }
         Q_EMIT changed();
     }
 
     delete dlg;
 }
 
 void Kleo::KeyRequester::slotEraseButtonClicked()
 {
     if (!mKeys.empty()) {
         Q_EMIT changed();
     }
     mKeys.clear();
     updateKeys();
 }
 
 void Kleo::KeyRequester::setDialogCaption(const QString &caption)
 {
     mDialogCaption = caption;
 }
 
 void Kleo::KeyRequester::setDialogMessage(const QString &msg)
 {
     mDialogMessage = msg;
 }
 
 bool Kleo::KeyRequester::isMultipleKeysEnabled() const
 {
     return mMulti;
 }
 
 void Kleo::KeyRequester::setMultipleKeysEnabled(bool multi)
 {
     if (multi == mMulti) {
         return;
     }
 
     if (!multi && !mKeys.empty()) {
         mKeys.erase(mKeys.begin() + 1, mKeys.end());
     }
 
     mMulti = multi;
     updateKeys();
 }
 
 unsigned int Kleo::KeyRequester::allowedKeys() const
 {
     return mKeyUsage;
 }
 
 void Kleo::KeyRequester::setAllowedKeys(unsigned int keyUsage)
 {
     mKeyUsage = keyUsage;
     mOpenPGPBackend = nullptr;
     mSMIMEBackend = nullptr;
 
     if (mKeyUsage & KeySelectionDialog::OpenPGPKeys) {
         mOpenPGPBackend = openpgp();
     }
     if (mKeyUsage & KeySelectionDialog::SMIMEKeys) {
         mSMIMEBackend = smime();
     }
 
     if (mOpenPGPBackend && !mSMIMEBackend) {
         mDialogCaption = i18n("OpenPGP Key Selection");
         mDialogMessage = i18n("Please select an OpenPGP key to use.");
     } else if (!mOpenPGPBackend && mSMIMEBackend) {
         mDialogCaption = i18n("S/MIME Key Selection");
         mDialogMessage = i18n("Please select an S/MIME key to use.");
     } else {
         mDialogCaption = i18n("Key Selection");
         mDialogMessage = i18n("Please select an (OpenPGP or S/MIME) key to use.");
     }
 }
 
 QPushButton *Kleo::KeyRequester::dialogButton()
 {
     return mDialogButton;
 }
 
 QPushButton *Kleo::KeyRequester::eraseButton()
 {
     return mEraseButton;
 }
 
 static inline unsigned int foo(bool openpgp, bool smime, bool trusted, bool valid)
 {
     unsigned int result = 0;
     if (openpgp) {
         result |= Kleo::KeySelectionDialog::OpenPGPKeys;
     }
     if (smime) {
         result |= Kleo::KeySelectionDialog::SMIMEKeys;
     }
     if (trusted) {
         result |= Kleo::KeySelectionDialog::TrustedKeys;
     }
     if (valid) {
         result |= Kleo::KeySelectionDialog::ValidKeys;
     }
     return result;
 }
 
 static inline unsigned int encryptionKeyUsage(bool openpgp, bool smime, bool trusted, bool valid)
 {
     return foo(openpgp, smime, trusted, valid) | Kleo::KeySelectionDialog::EncryptionKeys | Kleo::KeySelectionDialog::PublicKeys;
 }
 
 static inline unsigned int signingKeyUsage(bool openpgp, bool smime, bool trusted, bool valid)
 {
     return foo(openpgp, smime, trusted, valid) | Kleo::KeySelectionDialog::SigningKeys | Kleo::KeySelectionDialog::SecretKeys;
 }
 
 Kleo::EncryptionKeyRequester::EncryptionKeyRequester(bool multi, unsigned int proto, QWidget *parent, bool onlyTrusted, bool onlyValid)
     : KeyRequester(encryptionKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid), multi, parent)
     , d(nullptr)
 {
 }
 
 Kleo::EncryptionKeyRequester::EncryptionKeyRequester(QWidget *parent)
     : KeyRequester(0, false, parent)
     , d(nullptr)
 {
 }
 
 Kleo::EncryptionKeyRequester::~EncryptionKeyRequester()
 {
 }
 
 void Kleo::EncryptionKeyRequester::setAllowedKeys(unsigned int proto, bool onlyTrusted, bool onlyValid)
 {
     KeyRequester::setAllowedKeys(encryptionKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid));
 }
 
 Kleo::SigningKeyRequester::SigningKeyRequester(bool multi, unsigned int proto, QWidget *parent, bool onlyTrusted, bool onlyValid)
     : KeyRequester(signingKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid), multi, parent)
     , d(nullptr)
 {
 }
 
 Kleo::SigningKeyRequester::SigningKeyRequester(QWidget *parent)
     : KeyRequester(0, false, parent)
     , d(nullptr)
 {
 }
 
 Kleo::SigningKeyRequester::~SigningKeyRequester()
 {
 }
 
 void Kleo::SigningKeyRequester::setAllowedKeys(unsigned int proto, bool onlyTrusted, bool onlyValid)
 {
     KeyRequester::setAllowedKeys(signingKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid));
 }
 
 void Kleo::KeyRequester::virtual_hook(int, void *)
 {
 }
 void Kleo::EncryptionKeyRequester::virtual_hook(int id, void *data)
 {
     KeyRequester::virtual_hook(id, data);
 }
 void Kleo::SigningKeyRequester::virtual_hook(int id, void *data)
 {
     KeyRequester::virtual_hook(id, data);
 }
diff --git a/src/ui/keyselectiondialog.cpp b/src/ui/keyselectiondialog.cpp
index 2a2121674..336b269c4 100644
--- a/src/ui/keyselectiondialog.cpp
+++ b/src/ui/keyselectiondialog.cpp
@@ -1,1019 +1,1019 @@
 /*  -*- c++ -*-
     keyselectiondialog.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.cpp
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-libkleo.h>
 
 #include "keyselectiondialog.h"
 
 #include "keylistview.h"
 #include "progressdialog.h"
 
 #include <libkleo/compliance.h>
 #include <libkleo/dn.h>
 #include <libkleo/formatting.h>
 
 #include <kleo_ui_debug.h>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 
 #include <QGpgME/KeyListJob>
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QProcess>
 #include <QPushButton>
 #include <QRegExp>
 #include <QScrollBar>
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <algorithm>
 #include <iterator>
 #include <string.h>
 
 using namespace Kleo;
 
 static bool checkKeyUsage(const GpgME::Key &key, unsigned int keyUsage, QString *statusString = nullptr)
 {
     auto setStatusString = [statusString](const QString &status) {
         if (statusString) {
             *statusString = status;
         }
     };
 
     if (keyUsage & KeySelectionDialog::ValidKeys) {
         if (key.isInvalid()) {
             if (key.keyListMode() & GpgME::Validate) {
                 qCDebug(KLEO_UI_LOG) << "key is invalid";
                 setStatusString(i18n("The key is not valid."));
                 return false;
             } else {
                 qCDebug(KLEO_UI_LOG) << "key is invalid - ignoring";
             }
         }
         if (key.isExpired()) {
             qCDebug(KLEO_UI_LOG) << "key is expired";
             setStatusString(i18n("The key is expired."));
             return false;
         } else if (key.isRevoked()) {
             qCDebug(KLEO_UI_LOG) << "key is revoked";
             setStatusString(i18n("The key is revoked."));
             return false;
         } else if (key.isDisabled()) {
             qCDebug(KLEO_UI_LOG) << "key is disabled";
             setStatusString(i18n("The key is disabled."));
             return false;
         }
     }
 
     if (keyUsage & KeySelectionDialog::EncryptionKeys && !key.canEncrypt()) {
         qCDebug(KLEO_UI_LOG) << "key can't encrypt";
         setStatusString(i18n("The key is not designated for encryption."));
         return false;
     }
     if (keyUsage & KeySelectionDialog::SigningKeys && !key.canSign()) {
         qCDebug(KLEO_UI_LOG) << "key can't sign";
         setStatusString(i18n("The key is not designated for signing."));
         return false;
     }
     if (keyUsage & KeySelectionDialog::CertificationKeys && !key.canCertify()) {
         qCDebug(KLEO_UI_LOG) << "key can't certify";
         setStatusString(i18n("The key is not designated for certifying."));
         return false;
     }
     if (keyUsage & KeySelectionDialog::AuthenticationKeys && !key.canAuthenticate()) {
         qCDebug(KLEO_UI_LOG) << "key can't authenticate";
         setStatusString(i18n("The key is not designated for authentication."));
         return false;
     }
 
     if (keyUsage & KeySelectionDialog::SecretKeys && !(keyUsage & KeySelectionDialog::PublicKeys) && !key.hasSecret()) {
         qCDebug(KLEO_UI_LOG) << "key isn't secret";
         setStatusString(i18n("The key is not secret."));
         return false;
     }
 
     if (keyUsage & KeySelectionDialog::TrustedKeys && key.protocol() == GpgME::OpenPGP &&
         // only check this for secret keys for now.
         // Seems validity isn't checked for secret keylistings...
         !key.hasSecret()) {
         std::vector<GpgME::UserID> uids = key.userIDs();
         for (std::vector<GpgME::UserID>::const_iterator it = uids.begin(); it != uids.end(); ++it) {
             if (!it->isRevoked() && it->validity() >= GpgME::UserID::Marginal) {
                 setStatusString(i18n("The key can be used."));
                 return true;
             }
         }
         qCDebug(KLEO_UI_LOG) << "key has no UIDs with validity >= Marginal";
         setStatusString(i18n("The key is not trusted enough."));
         return false;
     }
     // X.509 keys are always trusted, else they won't be the keybox.
     // PENDING(marc) check that this ^ is correct
 
     setStatusString(i18n("The key can be used."));
     return true;
 }
 
 static bool checkKeyUsage(const std::vector<GpgME::Key> &keys, unsigned int keyUsage)
 {
     for (auto it = keys.begin(); it != keys.end(); ++it) {
         if (!checkKeyUsage(*it, keyUsage)) {
             return false;
         }
     }
     return true;
 }
 
 namespace
 {
 
 class ColumnStrategy : public KeyListView::ColumnStrategy
 {
 public:
     ColumnStrategy(unsigned int keyUsage);
 
     QString title(int col) const override;
     int width(int col, const QFontMetrics &fm) const override;
 
     QString text(const GpgME::Key &key, int col) const override;
     QString accessibleText(const GpgME::Key &key, int column) const override;
     QString toolTip(const GpgME::Key &key, int col) const override;
     QIcon icon(const GpgME::Key &key, int col) const override;
 
 private:
     const QIcon mKeyGoodPix, mKeyBadPix, mKeyUnknownPix, mKeyValidPix;
     const unsigned int mKeyUsage;
 };
 
 static QString iconPath(const QString &name)
 {
     return QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("libkleopatra/pics/") + name + QStringLiteral(".png"));
 }
 
 ColumnStrategy::ColumnStrategy(unsigned int keyUsage)
     : KeyListView::ColumnStrategy()
     , mKeyGoodPix(iconPath(QStringLiteral("key_ok")))
     , mKeyBadPix(iconPath(QStringLiteral("key_bad")))
     , mKeyUnknownPix(iconPath(QStringLiteral("key_unknown")))
     , mKeyValidPix(iconPath(QStringLiteral("key")))
     , mKeyUsage(keyUsage)
 {
     if (keyUsage == 0) {
         qCWarning(KLEO_UI_LOG) << "KeySelectionDialog: keyUsage == 0. You want to use AllKeys instead.";
     }
 }
 
 QString ColumnStrategy::title(int col) const
 {
     switch (col) {
     case 0:
         return i18n("Key ID");
     case 1:
         return i18n("User ID");
     default:
         return QString();
     }
 }
 
 int ColumnStrategy::width(int col, const QFontMetrics &fm) const
 {
     if (col == 0) {
         static const char hexchars[] = "0123456789ABCDEF";
         int maxWidth = 0;
         for (unsigned int i = 0; i < 16; ++i) {
             maxWidth = qMax(fm.boundingRect(QLatin1Char(hexchars[i])).width(), maxWidth);
         }
         return 8 * maxWidth + 2 * 16 /* KIconLoader::SizeSmall */;
     }
     return KeyListView::ColumnStrategy::width(col, fm);
 }
 
 QString ColumnStrategy::text(const GpgME::Key &key, int col) const
 {
     switch (col) {
     case 0: {
         if (key.shortKeyID()) {
             return Formatting::prettyID(key.shortKeyID());
         } else {
             return xi18n("<placeholder>unknown</placeholder>");
         }
     }
     case 1: {
         const char *uid = key.userID(0).id();
         if (key.protocol() == GpgME::OpenPGP) {
             return uid && *uid ? QString::fromUtf8(uid) : QString();
         } else { // CMS
             return DN(uid).prettyDN();
         }
     }
     default:
         return QString();
     }
 }
 
 QString ColumnStrategy::accessibleText(const GpgME::Key &key, int col) const
 {
     switch (col) {
     case 0: {
         if (key.shortKeyID()) {
             return Formatting::accessibleHexID(key.shortKeyID());
         }
         [[fallthrough]];
     }
     default:
         return {};
     }
 }
 
 QString ColumnStrategy::toolTip(const GpgME::Key &key, int) const
 {
     const char *uid = key.userID(0).id();
     const char *fpr = key.primaryFingerprint();
     const char *issuer = key.issuerName();
     const GpgME::Subkey subkey = key.subkey(0);
     const QString expiry = Formatting::expirationDateString(subkey);
     const QString creation = Formatting::creationDateString(subkey);
     QString keyStatusString;
     if (!checkKeyUsage(key, mKeyUsage, &keyStatusString)) {
         // Show the status in bold if there is a problem
         keyStatusString = QLatin1String("<b>") % keyStatusString % QLatin1String("</b>");
     }
 
     QString html = QStringLiteral("<qt><p style=\"style='white-space:pre'\">");
     if (key.protocol() == GpgME::OpenPGP) {
         html += i18n("OpenPGP key for <b>%1</b>", uid ? QString::fromUtf8(uid) : i18n("unknown"));
     } else {
         html += i18n("S/MIME key for <b>%1</b>", uid ? DN(uid).prettyDN() : i18n("unknown"));
     }
     html += QStringLiteral("</p><table>");
 
     const auto addRow = [&html](const QString &name, const QString &value) {
         html += QStringLiteral("<tr><td align=\"right\"><b>%1: </b></td><td>%2</td></tr>").arg(name, value);
     };
     addRow(i18n("Valid from"), creation);
     addRow(i18n("Valid until"), expiry);
     addRow(i18nc("Key fingerprint", "Fingerprint"), fpr ? QString::fromLatin1(fpr) : i18n("unknown"));
     if (key.protocol() != GpgME::OpenPGP) {
         addRow(i18nc("Key issuer", "Issuer"), issuer ? DN(issuer).prettyDN() : i18n("unknown"));
     }
     addRow(i18nc("Key status", "Status"), keyStatusString);
     if (DeVSCompliance::isActive()) {
         addRow(i18nc("Compliance of key", "Compliance"), DeVSCompliance::name(key.isDeVs()));
     }
     html += QStringLiteral("</table></qt>");
 
     return html;
 }
 
 QIcon ColumnStrategy::icon(const GpgME::Key &key, int col) const
 {
     if (col != 0) {
         return QIcon();
     }
     // this key did not undergo a validating keylisting yet:
     if (!(key.keyListMode() & GpgME::Validate)) {
         return mKeyUnknownPix;
     }
 
     if (!checkKeyUsage(key, mKeyUsage)) {
         return mKeyBadPix;
     }
 
     if (key.protocol() == GpgME::CMS) {
         return mKeyGoodPix;
     }
 
     switch (key.userID(0).validity()) {
     default:
     case GpgME::UserID::Unknown:
     case GpgME::UserID::Undefined:
         return mKeyUnknownPix;
     case GpgME::UserID::Never:
         return mKeyValidPix;
     case GpgME::UserID::Marginal:
     case GpgME::UserID::Full:
     case GpgME::UserID::Ultimate: {
         if (DeVSCompliance::isActive() && !key.isDeVs()) {
             return mKeyValidPix;
         }
         return mKeyGoodPix;
     }
     }
 }
 
 }
 
 static const int sCheckSelectionDelay = 250;
 
 KeySelectionDialog::KeySelectionDialog(QWidget *parent, Options options)
     : QDialog(parent)
     , mOpenPGPBackend(QGpgME::openpgp())
     , mSMIMEBackend(QGpgME::smime())
     , mKeyUsage(AllKeys)
 {
     qCDebug(KLEO_UI_LOG) << "mTruncated:" << mTruncated << "mSavedOffsetY:" << mSavedOffsetY;
     setUpUI(options, QString());
 }
 
 KeySelectionDialog::KeySelectionDialog(const QString &title,
                                        const QString &text,
                                        const std::vector<GpgME::Key> &selectedKeys,
                                        unsigned int keyUsage,
                                        bool extendedSelection,
                                        bool rememberChoice,
                                        QWidget *parent,
                                        bool modal)
     : QDialog(parent)
     , mSelectedKeys(selectedKeys)
     , mKeyUsage(keyUsage)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, QString());
 }
 
 KeySelectionDialog::KeySelectionDialog(const QString &title,
                                        const QString &text,
                                        const QString &initialQuery,
                                        const std::vector<GpgME::Key> &selectedKeys,
                                        unsigned int keyUsage,
                                        bool extendedSelection,
                                        bool rememberChoice,
                                        QWidget *parent,
                                        bool modal)
     : QDialog(parent)
     , mSelectedKeys(selectedKeys)
     , mKeyUsage(keyUsage)
     , mSearchText(initialQuery)
     , mInitialQuery(initialQuery)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 KeySelectionDialog::KeySelectionDialog(const QString &title,
                                        const QString &text,
                                        const QString &initialQuery,
                                        unsigned int keyUsage,
                                        bool extendedSelection,
                                        bool rememberChoice,
                                        QWidget *parent,
                                        bool modal)
     : QDialog(parent)
     , mKeyUsage(keyUsage)
     , mSearchText(initialQuery)
     , mInitialQuery(initialQuery)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 void KeySelectionDialog::setUpUI(Options options, const QString &initialQuery)
 {
     auto mainLayout = new QVBoxLayout(this);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     mOkButton = buttonBox->button(QDialogButtonBox::Ok);
     mOkButton->setDefault(true);
     mOkButton->setShortcut(Qt::CTRL | Qt::Key_Return);
 
     mCheckSelectionTimer = new QTimer(this);
     mStartSearchTimer = new QTimer(this);
 
     QFrame *page = new QFrame(this);
     mainLayout->addWidget(page);
     mainLayout->addWidget(buttonBox);
 
     mTopLayout = new QVBoxLayout(page);
     mTopLayout->setContentsMargins(0, 0, 0, 0);
 
     mTextLabel = new QLabel(page);
     mTextLabel->setWordWrap(true);
 
     // Setting the size policy is necessary as a workaround for https://issues.kolab.org/issue4429
     // and http://bugreports.qt.nokia.com/browse/QTBUG-8740
     mTextLabel->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
     connect(mTextLabel, &QLabel::linkActivated, this, &KeySelectionDialog::slotStartCertificateManager);
     mTopLayout->addWidget(mTextLabel);
     mTextLabel->hide();
 
     QPushButton *const searchExternalPB = new QPushButton(i18n("Search for &External Certificates"), page);
     mTopLayout->addWidget(searchExternalPB, 0, Qt::AlignLeft);
     connect(searchExternalPB, &QAbstractButton::clicked, this, &KeySelectionDialog::slotStartSearchForExternalCertificates);
     if (initialQuery.isEmpty()) {
         searchExternalPB->hide();
     }
 
     auto hlay = new QHBoxLayout();
     mTopLayout->addLayout(hlay);
 
     auto le = new QLineEdit(page);
     le->setClearButtonEnabled(true);
     le->setText(initialQuery);
 
     QLabel *lbSearchFor = new QLabel(i18n("&Search for:"), page);
     lbSearchFor->setBuddy(le);
 
     hlay->addWidget(lbSearchFor);
     hlay->addWidget(le, 1);
     le->setFocus();
 
     connect(le, &QLineEdit::textChanged, this, [this](const QString &s) {
         slotSearch(s);
     });
     connect(mStartSearchTimer, &QTimer::timeout, this, &KeySelectionDialog::slotFilter);
 
     mKeyListView = new KeyListView(new ColumnStrategy(mKeyUsage), nullptr, page);
     mKeyListView->setObjectName(QStringLiteral("mKeyListView"));
     mKeyListView->header()->stretchLastSection();
     mKeyListView->setRootIsDecorated(true);
     mKeyListView->setSortingEnabled(true);
     mKeyListView->header()->setSortIndicatorShown(true);
     mKeyListView->header()->setSortIndicator(1, Qt::AscendingOrder); // sort by User ID
     if (options & ExtendedSelection) {
         mKeyListView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     }
     mTopLayout->addWidget(mKeyListView, 10);
 
     if (options & RememberChoice) {
         mRememberCB = new QCheckBox(i18n("&Remember choice"), page);
         mTopLayout->addWidget(mRememberCB);
         mRememberCB->setWhatsThis(
             i18n("<qt><p>If you check this box your choice will "
                  "be stored and you will not be asked again."
                  "</p></qt>"));
     }
 
     connect(mCheckSelectionTimer, &QTimer::timeout, this, [this]() {
         slotCheckSelection();
     });
     connectSignals();
 
     connect(mKeyListView, &KeyListView::doubleClicked, this, &KeySelectionDialog::slotTryOk);
     connect(mKeyListView, &KeyListView::contextMenu, this, &KeySelectionDialog::slotRMB);
 
     if (options & RereadKeys) {
         QPushButton *button = new QPushButton(i18n("&Reread Keys"));
         buttonBox->addButton(button, QDialogButtonBox::ActionRole);
         connect(button, &QPushButton::clicked, this, &KeySelectionDialog::slotRereadKeys);
     }
     if (options & ExternalCertificateManager) {
         QPushButton *button = new QPushButton(i18n("&Start Certificate Manager"));
         buttonBox->addButton(button, QDialogButtonBox::ActionRole);
         connect(button, &QPushButton::clicked, this, [this]() {
             slotStartCertificateManager();
         });
     }
     connect(mOkButton, &QPushButton::clicked, this, &KeySelectionDialog::slotOk);
     connect(buttonBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &KeySelectionDialog::slotCancel);
 
     mTopLayout->activate();
 
     if (qApp) {
         QSize dialogSize(sizeHint());
         KConfigGroup dialogConfig(KSharedConfig::openStateConfig(), "Key Selection Dialog");
         dialogSize = dialogConfig.readEntry("Dialog size", dialogSize);
         const QByteArray headerState = dialogConfig.readEntry("header", QByteArray());
         if (!headerState.isEmpty()) {
             mKeyListView->header()->restoreState(headerState);
         }
         resize(dialogSize);
     }
 }
 
 void KeySelectionDialog::init(bool rememberChoice, bool extendedSelection, const QString &text, const QString &initialQuery)
 {
     Options options = {RereadKeys, ExternalCertificateManager};
     options.setFlag(ExtendedSelection, extendedSelection);
     options.setFlag(RememberChoice, rememberChoice);
 
     setUpUI(options, initialQuery);
     setText(text);
 
     if (mKeyUsage & OpenPGPKeys) {
         mOpenPGPBackend = QGpgME::openpgp();
     }
     if (mKeyUsage & SMIMEKeys) {
         mSMIMEBackend = QGpgME::smime();
     }
 
     slotRereadKeys();
 }
 
 KeySelectionDialog::~KeySelectionDialog()
 {
     disconnectSignals();
     KConfigGroup dialogConfig(KSharedConfig::openStateConfig(), "Key Selection Dialog");
     dialogConfig.writeEntry("Dialog size", size());
     dialogConfig.writeEntry("header", mKeyListView->header()->saveState());
     dialogConfig.sync();
 }
 
 void KeySelectionDialog::setText(const QString &text)
 {
     mTextLabel->setText(text);
     mTextLabel->setVisible(!text.isEmpty());
 }
 
 void KeySelectionDialog::setKeys(const std::vector<GpgME::Key> &keys)
 {
     for (const GpgME::Key &key : keys) {
         mKeyListView->slotAddKey(key);
     }
 }
 
 void KeySelectionDialog::connectSignals()
 {
     if (mKeyListView->isMultiSelection()) {
         connect(mKeyListView, &QTreeWidget::itemSelectionChanged, this, &KeySelectionDialog::slotSelectionChanged);
     } else {
         connect(mKeyListView,
                 qOverload<KeyListViewItem *>(&KeyListView::selectionChanged),
                 this,
                 qOverload<KeyListViewItem *>(&KeySelectionDialog::slotCheckSelection));
     }
 }
 
 void KeySelectionDialog::disconnectSignals()
 {
     if (mKeyListView->isMultiSelection()) {
         disconnect(mKeyListView, &QTreeWidget::itemSelectionChanged, this, &KeySelectionDialog::slotSelectionChanged);
     } else {
         disconnect(mKeyListView,
                    qOverload<KeyListViewItem *>(&KeyListView::selectionChanged),
                    this,
                    qOverload<KeyListViewItem *>(&KeySelectionDialog::slotCheckSelection));
     }
 }
 
 const GpgME::Key &KeySelectionDialog::selectedKey() const
 {
     static const GpgME::Key null = GpgME::Key::null;
     if (mKeyListView->isMultiSelection() || !mKeyListView->selectedItem()) {
         return null;
     }
     return mKeyListView->selectedItem()->key();
 }
 
 QString KeySelectionDialog::fingerprint() const
 {
     return QLatin1String(selectedKey().primaryFingerprint());
 }
 
 QStringList KeySelectionDialog::fingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (const char *fpr = it->primaryFingerprint()) {
             result.push_back(QLatin1String(fpr));
         }
     }
     return result;
 }
 
 QStringList KeySelectionDialog::pgpKeyFingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (it->protocol() == GpgME::OpenPGP) {
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
         }
     }
     return result;
 }
 
 QStringList KeySelectionDialog::smimeFingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (it->protocol() == GpgME::CMS) {
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
         }
     }
     return result;
 }
 
 void KeySelectionDialog::slotRereadKeys()
 {
     mKeyListView->clear();
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     // FIXME: save current selection
     if (mOpenPGPBackend) {
         startKeyListJobForBackend(mOpenPGPBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
     if (mSMIMEBackend) {
         startKeyListJobForBackend(mSMIMEBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
 
     if (mListJobCount == 0) {
         mKeyListView->setEnabled(true);
         KMessageBox::information(this,
                                  i18n("No backends found for listing keys. "
                                       "Check your installation."),
                                  i18n("Key Listing Failed"));
         connectSignals();
     }
 }
 
 void KeySelectionDialog::slotStartCertificateManager(const QString &query)
 {
     QStringList args;
 
     if (!query.isEmpty()) {
         args << QStringLiteral("--search") << query;
     }
     const QString exec = QStandardPaths::findExecutable(QStringLiteral("kleopatra"));
     if (exec.isEmpty()) {
         qCWarning(KLEO_UI_LOG) << "Could not find kleopatra executable in PATH";
         KMessageBox::error(this,
                            i18n("Could not start certificate manager; "
                                 "please check your installation."),
                            i18n("Certificate Manager Error"));
     } else {
         QProcess::startDetached(QStringLiteral("kleopatra"), args);
         qCDebug(KLEO_UI_LOG) << "\nslotStartCertManager(): certificate manager started.";
     }
 }
 
 #ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 #define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 static void showKeyListError(QWidget *parent, const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n(
         "<qt><p>An error occurred while fetching "
         "the keys from the backend:</p>"
         "<p><b>%1</b></p></qt>",
-        QString::fromLocal8Bit(err.asString()));
+        Formatting::errorAsString(err));
 
     KMessageBox::error(parent, msg, i18n("Key Listing Failed"));
 }
 #endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 
 namespace
 {
 struct ExtractFingerprint {
     QString operator()(const GpgME::Key &key)
     {
         return QLatin1String(key.primaryFingerprint());
     }
 };
 }
 
 void KeySelectionDialog::startKeyListJobForBackend(const QGpgME::Protocol *backend, const std::vector<GpgME::Key> &keys, bool validate)
 {
     Q_ASSERT(backend);
     QGpgME::KeyListJob *job = backend->keyListJob(false, false, validate); // local, w/o sigs, validation as given
     if (!job) {
         return;
     }
 
     connect(job, &QGpgME::KeyListJob::result, this, &KeySelectionDialog::slotKeyListResult);
     if (validate) {
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotRefreshKey);
     } else {
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotAddKey);
     }
 
     QStringList fprs;
     std::transform(keys.begin(), keys.end(), std::back_inserter(fprs), ExtractFingerprint());
     const GpgME::Error err = job->start(fprs, mKeyUsage & SecretKeys && !(mKeyUsage & PublicKeys));
 
     if (err) {
         return showKeyListError(this, err);
     }
 
 #ifndef LIBKLEO_NO_PROGRESSDIALOG
     // FIXME: create a MultiProgressDialog:
     (void)new ProgressDialog(job, validate ? i18n("Checking selected keys...") : i18n("Fetching keys..."), this);
 #endif
     ++mListJobCount;
 }
 
 static void selectKeys(KeyListView *klv, const std::vector<GpgME::Key> &selectedKeys)
 {
     klv->clearSelection();
     if (selectedKeys.empty()) {
         return;
     }
     for (auto it = selectedKeys.begin(); it != selectedKeys.end(); ++it) {
         if (KeyListViewItem *item = klv->itemByFingerprint(it->primaryFingerprint())) {
             item->setSelected(true);
         }
     }
 }
 
 void KeySelectionDialog::slotKeyListResult(const GpgME::KeyListResult &res)
 {
     if (res.error()) {
         showKeyListError(this, res.error());
     } else if (res.isTruncated()) {
         ++mTruncated;
     }
 
     if (--mListJobCount > 0) {
         return; // not yet finished...
     }
 
     if (mTruncated > 0) {
         KMessageBox::information(this,
                                  i18np("<qt>One backend returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        "<qt>%1 backends returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        mTruncated),
                                  i18n("Key List Result"));
     }
 
     mKeyListView->flushKeys();
 
     mKeyListView->setEnabled(true);
     mListJobCount = mTruncated = 0;
     mKeysToCheck.clear();
 
     selectKeys(mKeyListView, mSelectedKeys);
 
     slotFilter();
 
     connectSignals();
 
     slotSelectionChanged();
 
     // restore the saved position of the contents
     mKeyListView->verticalScrollBar()->setValue(mSavedOffsetY);
     mSavedOffsetY = 0;
 }
 
 void KeySelectionDialog::slotSelectionChanged()
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotSelectionChanged()";
 
     // (re)start the check selection timer. Checking the selection is delayed
     // because else drag-selection doesn't work very good (checking key trust
     // is slow).
     mCheckSelectionTimer->start(sCheckSelectionDelay);
 }
 
 namespace
 {
 struct AlreadyChecked {
     bool operator()(const GpgME::Key &key) const
     {
         return key.keyListMode() & GpgME::Validate;
     }
 };
 }
 
 void KeySelectionDialog::slotCheckSelection(KeyListViewItem *item)
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotCheckSelection()";
 
     mCheckSelectionTimer->stop();
 
     mSelectedKeys.clear();
 
     if (!mKeyListView->isMultiSelection()) {
         if (item) {
             mSelectedKeys.push_back(item->key());
         }
     }
 
     for (KeyListViewItem *it = mKeyListView->firstChild(); it; it = it->nextSibling()) {
         if (it->isSelected()) {
             mSelectedKeys.push_back(it->key());
         }
     }
 
     mKeysToCheck.clear();
     std::remove_copy_if(mSelectedKeys.begin(), mSelectedKeys.end(), std::back_inserter(mKeysToCheck), AlreadyChecked());
     if (mKeysToCheck.empty()) {
         mOkButton->setEnabled(!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage));
         return;
     }
 
     // performed all fast checks - now for validating key listing:
     startValidatingKeyListing();
 }
 
 void KeySelectionDialog::startValidatingKeyListing()
 {
     if (mKeysToCheck.empty()) {
         return;
     }
 
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     std::vector<GpgME::Key> smime;
     std::vector<GpgME::Key> openpgp;
     for (std::vector<GpgME::Key>::const_iterator it = mKeysToCheck.begin(); it != mKeysToCheck.end(); ++it) {
         if (it->protocol() == GpgME::OpenPGP) {
             openpgp.push_back(*it);
         } else {
             smime.push_back(*it);
         }
     }
 
     if (!openpgp.empty()) {
         Q_ASSERT(mOpenPGPBackend);
         startKeyListJobForBackend(mOpenPGPBackend, openpgp, true /*validate*/);
     }
     if (!smime.empty()) {
         Q_ASSERT(mSMIMEBackend);
         startKeyListJobForBackend(mSMIMEBackend, smime, true /*validate*/);
     }
 
     Q_ASSERT(mListJobCount > 0);
 }
 
 bool KeySelectionDialog::rememberSelection() const
 {
     return mRememberCB && mRememberCB->isChecked();
 }
 
 void KeySelectionDialog::slotRMB(KeyListViewItem *item, const QPoint &p)
 {
     if (!item) {
         return;
     }
 
     mCurrentContextMenuItem = item;
 
     QMenu menu;
     menu.addAction(i18n("Recheck Key"), this, &KeySelectionDialog::slotRecheckKey);
     menu.exec(p);
 }
 
 void KeySelectionDialog::slotRecheckKey()
 {
     if (!mCurrentContextMenuItem || mCurrentContextMenuItem->key().isNull()) {
         return;
     }
 
     mKeysToCheck.clear();
     mKeysToCheck.push_back(mCurrentContextMenuItem->key());
 }
 
 void KeySelectionDialog::slotTryOk()
 {
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         slotOk();
     }
 }
 
 void KeySelectionDialog::slotOk()
 {
     if (mCheckSelectionTimer->isActive()) {
         slotCheckSelection();
     }
 #if 0 // Laurent I don't understand why we returns here.
     // button could be disabled again after checking the selected key1
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         return;
     }
 #endif
     mStartSearchTimer->stop();
     accept();
 }
 
 void KeySelectionDialog::slotCancel()
 {
     mCheckSelectionTimer->stop();
     mStartSearchTimer->stop();
     reject();
 }
 
 void KeySelectionDialog::slotSearch(const QString &text)
 {
     mSearchText = text.trimmed().toUpper();
     slotSearch();
 }
 
 void KeySelectionDialog::slotSearch()
 {
     mStartSearchTimer->setSingleShot(true);
     mStartSearchTimer->start(sCheckSelectionDelay);
 }
 
 void KeySelectionDialog::slotFilter()
 {
     if (mSearchText.isEmpty()) {
         showAllItems();
         return;
     }
 
     // OK, so we need to filter:
     QRegExp keyIdRegExp(QLatin1String("(?:0x)?[A-F0-9]{1,8}"), Qt::CaseInsensitive);
     if (keyIdRegExp.exactMatch(mSearchText)) {
         if (mSearchText.startsWith(QLatin1String("0X")))
         // search for keyID only:
         {
             filterByKeyID(mSearchText.mid(2));
         } else
         // search for UID and keyID:
         {
             filterByKeyIDOrUID(mSearchText);
         }
     } else {
         // search in UID:
         filterByUID(mSearchText);
     }
 }
 
 void KeySelectionDialog::filterByKeyID(const QString &keyID)
 {
     Q_ASSERT(keyID.length() <= 8);
     Q_ASSERT(!keyID.isEmpty()); // regexp in slotFilter should prevent these
     if (keyID.isEmpty()) {
         showAllItems();
     } else {
         for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
             item->setHidden(!item->text(0).toUpper().startsWith(keyID));
         }
     }
 }
 
 static bool anyUIDMatches(const KeyListViewItem *item, QRegExp &rx)
 {
     if (!item) {
         return false;
     }
 
     const std::vector<GpgME::UserID> uids = item->key().userIDs();
     for (auto it = uids.begin(); it != uids.end(); ++it) {
         if (it->id() && rx.indexIn(QString::fromUtf8(it->id())) >= 0) {
             return true;
         }
     }
     return false;
 }
 
 void KeySelectionDialog::filterByKeyIDOrUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!item->text(0).toUpper().startsWith(str) && !anyUIDMatches(item, rx));
     }
 }
 
 void KeySelectionDialog::filterByUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!anyUIDMatches(item, rx));
     }
 }
 
 void KeySelectionDialog::showAllItems()
 {
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(false);
     }
 }
diff --git a/src/ui/newkeyapprovaldialog.cpp b/src/ui/newkeyapprovaldialog.cpp
index 7e03b7ad7..4b9d5086a 100644
--- a/src/ui/newkeyapprovaldialog.cpp
+++ b/src/ui/newkeyapprovaldialog.cpp
@@ -1,907 +1,907 @@
 /*  -*- c++ -*-
     newkeyapprovaldialog.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2018 Intevation GmbH
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-libkleo.h>
 
 #include "newkeyapprovaldialog.h"
 
 #include "keyselectioncombo.h"
 #include "progressdialog.h"
 
 #include <libkleo/compliance.h>
 #include <libkleo/debug.h>
 #include <libkleo/defaultkeyfilter.h>
 #include <libkleo/formatting.h>
 #include <libkleo/gnupg.h>
 #include <libkleo/keyhelpers.h>
 #include <libkleo/systeminfo.h>
 
 #include <libkleo_debug.h>
 
 #include <KColorScheme>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QGpgME/DefaultKeyGenerationJob>
 #include <QGpgME/Job>
 
 #include <QButtonGroup>
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QGroupBox>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QMap>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QScreen>
 #include <QScrollArea>
 #include <QToolTip>
 #include <QVBoxLayout>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keygenerationresult.h>
 
 using namespace Kleo;
 using namespace GpgME;
 
 namespace
 {
 class EncryptFilter : public DefaultKeyFilter
 {
 public:
     EncryptFilter()
         : DefaultKeyFilter()
     {
         setCanEncrypt(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_encryptFilter = std::shared_ptr<KeyFilter>(new EncryptFilter);
 
 class OpenPGPFilter : public DefaultKeyFilter
 {
 public:
     OpenPGPFilter()
         : DefaultKeyFilter()
     {
         setIsOpenPGP(DefaultKeyFilter::Set);
         setCanEncrypt(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_pgpEncryptFilter = std::shared_ptr<KeyFilter>(new OpenPGPFilter);
 
 class OpenPGPSignFilter : public DefaultKeyFilter
 {
 public:
     OpenPGPSignFilter()
         : DefaultKeyFilter()
     {
         /* Also list unusable keys to make it transparent why they are unusable */
         setDisabled(DefaultKeyFilter::NotSet);
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanSign(DefaultKeyFilter::Set);
         setHasSecret(DefaultKeyFilter::Set);
         setIsOpenPGP(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_pgpSignFilter = std::shared_ptr<KeyFilter>(new OpenPGPSignFilter);
 
 class SMIMEFilter : public DefaultKeyFilter
 {
 public:
     SMIMEFilter()
         : DefaultKeyFilter()
     {
         setIsOpenPGP(DefaultKeyFilter::NotSet);
         setCanEncrypt(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_smimeEncryptFilter = std::shared_ptr<KeyFilter>(new SMIMEFilter);
 
 class SMIMESignFilter : public DefaultKeyFilter
 {
 public:
     SMIMESignFilter()
         : DefaultKeyFilter()
     {
         setDisabled(DefaultKeyFilter::NotSet);
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanSign(DefaultKeyFilter::Set);
         setIsOpenPGP(DefaultKeyFilter::NotSet);
         setHasSecret(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_smimeSignFilter = std::shared_ptr<KeyFilter>(new SMIMESignFilter);
 
 /* Some decoration and a button to remove the filter for a keyselectioncombo */
 class ComboWidget : public QWidget
 {
     Q_OBJECT
 public:
     explicit ComboWidget(KeySelectionCombo *combo)
         : mCombo(combo)
         , mFilterBtn(new QPushButton)
     {
         auto hLay = new QHBoxLayout(this);
         auto infoBtn = new QPushButton;
         infoBtn->setIcon(QIcon::fromTheme(QStringLiteral("help-contextual")));
         infoBtn->setIconSize(QSize(22, 22));
         infoBtn->setFlat(true);
         infoBtn->setAccessibleName(i18nc("@action:button", "Show Details"));
         hLay->addWidget(infoBtn);
         hLay->addWidget(combo, 1);
         hLay->addWidget(mFilterBtn, 0);
 
         connect(infoBtn, &QPushButton::clicked, this, [this, infoBtn]() {
             QToolTip::showText(infoBtn->mapToGlobal(QPoint()) + QPoint(infoBtn->width(), 0),
                                mCombo->currentData(Qt::ToolTipRole).toString(),
                                infoBtn,
                                QRect(),
                                30000);
         });
 
         // FIXME: This is ugly to enforce but otherwise the
         // icon is broken.
         combo->setMinimumHeight(22);
         mFilterBtn->setMinimumHeight(23);
 
         updateFilterButton();
 
         connect(mFilterBtn, &QPushButton::clicked, this, [this]() {
             const QString curFilter = mCombo->idFilter();
             if (curFilter.isEmpty()) {
                 setIdFilter(mLastIdFilter);
                 mLastIdFilter = QString();
             } else {
                 setIdFilter(QString());
                 mLastIdFilter = curFilter;
             }
         });
     }
 
     void setIdFilter(const QString &id)
     {
         mCombo->setIdFilter(id);
         updateFilterButton();
     }
 
     void updateFilterButton()
     {
         if (mCombo->idFilter().isEmpty()) {
             mFilterBtn->setIcon(QIcon::fromTheme(QStringLiteral("kt-add-filters")));
             mFilterBtn->setAccessibleName(i18nc("@action:button", "Show Matching Keys"));
             mFilterBtn->setToolTip(i18n("Show keys matching the email address"));
         } else {
             mFilterBtn->setIcon(QIcon::fromTheme(QStringLiteral("kt-remove-filters")));
             mFilterBtn->setAccessibleName(i18nc("@action:button short for 'Show all keys'", "Show All"));
             mFilterBtn->setToolTip(i18n("Show all keys"));
         }
     }
 
     KeySelectionCombo *combo()
     {
         return mCombo;
     }
 
     GpgME::Protocol fixedProtocol() const
     {
         return mFixedProtocol;
     }
 
     void setFixedProtocol(GpgME::Protocol proto)
     {
         mFixedProtocol = proto;
     }
 
 private:
     KeySelectionCombo *mCombo;
     QPushButton *mFilterBtn;
     QString mLastIdFilter;
     GpgME::Protocol mFixedProtocol = GpgME::UnknownProtocol;
 };
 
 static bool key_has_addr(const GpgME::Key &key, const QString &addr)
 {
     for (const auto &uid : key.userIDs()) {
         if (QString::fromStdString(uid.addrSpec()).toLower() == addr.toLower()) {
             return true;
         }
     }
     return false;
 }
 
 bool anyKeyHasProtocol(const std::vector<Key> &keys, GpgME::Protocol protocol)
 {
     return std::any_of(std::begin(keys), std::end(keys), [protocol](const auto &key) {
         return key.protocol() == protocol;
     });
 }
 
 Key findfirstKeyOfType(const std::vector<Key> &keys, GpgME::Protocol protocol)
 {
     const auto it = std::find_if(std::begin(keys), std::end(keys), [protocol](const auto &key) {
         return key.protocol() == protocol;
     });
     return it != std::end(keys) ? *it : Key();
 }
 
 } // namespace
 
 class NewKeyApprovalDialog::Private
 {
 private:
     enum Action {
         Unset,
         GenerateKey,
         IgnoreKey,
     };
 
 public:
     enum {
         OpenPGPButtonId = 1,
         SMIMEButtonId = 2,
     };
 
     Private(NewKeyApprovalDialog *qq,
             bool encrypt,
             bool sign,
             GpgME::Protocol forcedProtocol,
             GpgME::Protocol presetProtocol,
             const QString &sender,
             bool allowMixed)
         : mForcedProtocol{forcedProtocol}
         , mSender{sender}
         , mSign{sign}
         , mEncrypt{encrypt}
         , mAllowMixed{allowMixed}
         , q{qq}
     {
         Q_ASSERT(forcedProtocol == GpgME::UnknownProtocol || presetProtocol == GpgME::UnknownProtocol || presetProtocol == forcedProtocol);
         Q_ASSERT(!allowMixed || (allowMixed && forcedProtocol == GpgME::UnknownProtocol));
         Q_ASSERT(!(!allowMixed && presetProtocol == GpgME::UnknownProtocol));
 
         // We do the translation here to avoid having the same string multiple times.
         mGenerateTooltip = i18nc(
             "@info:tooltip for a 'Generate new key pair' action "
             "in a combobox when a user does not yet have an OpenPGP or S/MIME key.",
             "Generate a new key using your E-Mail address.<br/><br/>"
             "The key is necessary to decrypt and sign E-Mails. "
             "You will be asked for a passphrase to protect this key and the protected key "
             "will be stored in your home directory.");
         mMainLay = new QVBoxLayout;
 
         QDialogButtonBox *btnBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
         mOkButton = btnBox->button(QDialogButtonBox::Ok);
 #ifndef NDEBUG
         mOkButton->setObjectName(QStringLiteral("ok button"));
 #endif
         QObject::connect(btnBox, &QDialogButtonBox::accepted, q, [this]() {
             accepted();
         });
         QObject::connect(btnBox, &QDialogButtonBox::rejected, q, &QDialog::reject);
 
         mScrollArea = new QScrollArea;
         mScrollArea->setWidget(new QWidget);
         mScrollLayout = new QVBoxLayout;
         mScrollArea->widget()->setLayout(mScrollLayout);
         mScrollArea->setWidgetResizable(true);
         mScrollArea->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow);
         mScrollArea->setFrameStyle(QFrame::NoFrame);
         mScrollLayout->setContentsMargins(0, 0, 0, 0);
 
         q->setWindowTitle(i18nc("@title:window", "Security approval"));
 
         auto fmtLayout = new QHBoxLayout;
         mFormatBtns = new QButtonGroup(qq);
         QAbstractButton *pgpBtn;
         QAbstractButton *smimeBtn;
         if (mAllowMixed) {
             pgpBtn = new QCheckBox(i18n("OpenPGP"));
             smimeBtn = new QCheckBox(i18n("S/MIME"));
         } else {
             pgpBtn = new QRadioButton(i18n("OpenPGP"));
             smimeBtn = new QRadioButton(i18n("S/MIME"));
         }
 #ifndef NDEBUG
         pgpBtn->setObjectName(QStringLiteral("openpgp button"));
         smimeBtn->setObjectName(QStringLiteral("smime button"));
 #endif
         mFormatBtns->addButton(pgpBtn, OpenPGPButtonId);
         mFormatBtns->addButton(smimeBtn, SMIMEButtonId);
         mFormatBtns->setExclusive(!mAllowMixed);
 
         fmtLayout->addStretch(-1);
         fmtLayout->addWidget(pgpBtn);
         fmtLayout->addWidget(smimeBtn);
         mMainLay->addLayout(fmtLayout);
 
         if (mForcedProtocol != GpgME::UnknownProtocol) {
             pgpBtn->setChecked(mForcedProtocol == GpgME::OpenPGP);
             smimeBtn->setChecked(mForcedProtocol == GpgME::CMS);
             pgpBtn->setVisible(false);
             smimeBtn->setVisible(false);
         } else {
             pgpBtn->setChecked(presetProtocol == GpgME::OpenPGP || presetProtocol == GpgME::UnknownProtocol);
             smimeBtn->setChecked(presetProtocol == GpgME::CMS || presetProtocol == GpgME::UnknownProtocol);
         }
 
         QObject::connect(mFormatBtns, &QButtonGroup::idClicked, q, [this](int buttonId) {
             // ensure that at least one protocol button is checked
             if (mAllowMixed && !mFormatBtns->button(OpenPGPButtonId)->isChecked() && !mFormatBtns->button(SMIMEButtonId)->isChecked()) {
                 mFormatBtns->button(buttonId == OpenPGPButtonId ? SMIMEButtonId : OpenPGPButtonId)->setChecked(true);
             }
             updateWidgets();
         });
 
         mMainLay->addWidget(mScrollArea);
 
         mComplianceLbl = new QLabel;
         mComplianceLbl->setVisible(false);
 #ifndef NDEBUG
         mComplianceLbl->setObjectName(QStringLiteral("compliance label"));
 #endif
 
         auto btnLayout = new QHBoxLayout;
         btnLayout->addWidget(mComplianceLbl);
         btnLayout->addWidget(btnBox);
         mMainLay->addLayout(btnLayout);
 
         q->setLayout(mMainLay);
     }
 
     ~Private() = default;
 
     GpgME::Protocol currentProtocol()
     {
         const bool openPGPButtonChecked = mFormatBtns->button(OpenPGPButtonId)->isChecked();
         const bool smimeButtonChecked = mFormatBtns->button(SMIMEButtonId)->isChecked();
         if (mAllowMixed) {
             if (openPGPButtonChecked && !smimeButtonChecked) {
                 return GpgME::OpenPGP;
             }
             if (!openPGPButtonChecked && smimeButtonChecked) {
                 return GpgME::CMS;
             }
         } else if (openPGPButtonChecked) {
             return GpgME::OpenPGP;
         } else if (smimeButtonChecked) {
             return GpgME::CMS;
         }
         return GpgME::UnknownProtocol;
     }
 
     auto findVisibleKeySelectionComboWithGenerateKey()
     {
         const auto it = std::find_if(std::begin(mAllCombos), std::end(mAllCombos), [](auto combo) {
             return combo->isVisible() && combo->currentData(Qt::UserRole).toInt() == GenerateKey;
         });
         return it != std::end(mAllCombos) ? *it : nullptr;
     }
 
     void generateKey(KeySelectionCombo *combo)
     {
         const auto &addr = combo->property("address").toString();
         auto job = new QGpgME::DefaultKeyGenerationJob(q);
         auto progress =
             new Kleo::ProgressDialog(job, i18n("Generating key for '%1'...", addr) + QStringLiteral("\n\n") + i18n("This can take several minutes."), q);
         progress->setWindowFlags(progress->windowFlags() & ~Qt::WindowContextHelpButtonHint);
         progress->setWindowTitle(i18nc("@title:window", "Key generation"));
         progress->setModal(true);
         progress->setAutoClose(true);
         progress->setMinimumDuration(0);
         progress->setValue(0);
 
         mRunningJobs << job;
         connect(job, &QGpgME::DefaultKeyGenerationJob::result, q, [this, job, combo](const GpgME::KeyGenerationResult &result) {
             handleKeyGenResult(result, job, combo);
         });
         job->start(addr, QString());
         return;
     }
 
     void handleKeyGenResult(const GpgME::KeyGenerationResult &result, QGpgME::Job *job, KeySelectionCombo *combo)
     {
         mLastError = result.error();
         if (!mLastError || mLastError.isCanceled()) {
             combo->setDefaultKey(QString::fromLatin1(result.fingerprint()), GpgME::OpenPGP);
             connect(combo, &KeySelectionCombo::keyListingFinished, q, [this, job]() {
                 mRunningJobs.removeAll(job);
             });
             combo->refreshKeys();
         } else {
             mRunningJobs.removeAll(job);
         }
     }
 
     void checkAccepted()
     {
         if (mLastError || mLastError.isCanceled()) {
-            KMessageBox::error(q, QString::fromLocal8Bit(mLastError.asString()), i18n("Operation Failed"));
+            KMessageBox::error(q, Formatting::errorAsString(mLastError), i18n("Operation Failed"));
             mRunningJobs.clear();
             return;
         }
 
         if (!mRunningJobs.empty()) {
             return;
         }
 
         /* Save the keys */
         mAcceptedResult.protocol = currentProtocol();
         for (const auto combo : std::as_const(mEncCombos)) {
             const auto addr = combo->property("address").toString();
             const auto key = combo->currentKey();
             if (!combo->isVisible() || key.isNull()) {
                 continue;
             }
             mAcceptedResult.encryptionKeys[addr].push_back(key);
         }
         for (const auto combo : std::as_const(mSigningCombos)) {
             const auto key = combo->currentKey();
             if (!combo->isVisible() || key.isNull()) {
                 continue;
             }
             mAcceptedResult.signingKeys.push_back(key);
         }
 
         q->accept();
     }
 
     void accepted()
     {
         // We can assume everything was validly resolved, otherwise
         // the OK button would have been disabled.
         // Handle custom items now.
         if (auto combo = findVisibleKeySelectionComboWithGenerateKey()) {
             generateKey(combo);
             return;
         }
         checkAccepted();
     }
 
     auto encryptionKeyFilter(GpgME::Protocol protocol)
     {
         switch (protocol) {
         case OpenPGP:
             return s_pgpEncryptFilter;
         case CMS:
             return s_smimeEncryptFilter;
         default:
             return s_encryptFilter;
         }
     }
 
     void updateWidgets()
     {
         const GpgME::Protocol protocol = currentProtocol();
         const auto encryptionFilter = encryptionKeyFilter(protocol);
 
         for (auto combo : std::as_const(mSigningCombos)) {
             auto widget = qobject_cast<ComboWidget *>(combo->parentWidget());
             if (!widget) {
                 qCDebug(LIBKLEO_LOG) << "Failed to find signature combo widget";
                 continue;
             }
             widget->setVisible(protocol == GpgME::UnknownProtocol || widget->fixedProtocol() == GpgME::UnknownProtocol || widget->fixedProtocol() == protocol);
         }
         for (auto combo : std::as_const(mEncCombos)) {
             auto widget = qobject_cast<ComboWidget *>(combo->parentWidget());
             if (!widget) {
                 qCDebug(LIBKLEO_LOG) << "Failed to find combo widget";
                 continue;
             }
             widget->setVisible(protocol == GpgME::UnknownProtocol || widget->fixedProtocol() == GpgME::UnknownProtocol || widget->fixedProtocol() == protocol);
             if (widget->isVisible() && combo->property("address") != mSender) {
                 combo->setKeyFilter(encryptionFilter);
             }
         }
         // hide the labels indicating the protocol of the sender's keys if only a single protocol is active
         const auto protocolLabels = q->findChildren<QLabel *>(QStringLiteral("protocol label"));
         for (auto label : protocolLabels) {
             label->setVisible(protocol == GpgME::UnknownProtocol);
         }
     }
 
     auto createProtocolLabel(GpgME::Protocol protocol)
     {
         auto label = new QLabel(Formatting::displayName(protocol));
         label->setObjectName(QStringLiteral("protocol label"));
         return label;
     }
 
     ComboWidget *createSigningCombo(const QString &addr, const GpgME::Key &key, GpgME::Protocol protocol = GpgME::UnknownProtocol)
     {
         Q_ASSERT(!key.isNull() || protocol != UnknownProtocol);
         protocol = !key.isNull() ? key.protocol() : protocol;
 
         auto combo = new KeySelectionCombo();
         auto comboWidget = new ComboWidget(combo);
 #ifndef NDEBUG
         combo->setObjectName(QStringLiteral("signing key"));
 #endif
         if (protocol == GpgME::OpenPGP) {
             combo->setKeyFilter(s_pgpSignFilter);
         } else if (protocol == GpgME::CMS) {
             combo->setKeyFilter(s_smimeSignFilter);
         }
         if (key.isNull() || key_has_addr(key, mSender)) {
             comboWidget->setIdFilter(mSender);
         }
         comboWidget->setFixedProtocol(protocol);
         if (!key.isNull()) {
             combo->setDefaultKey(QString::fromLatin1(key.primaryFingerprint()), protocol);
         }
         if (key.isNull() && protocol == OpenPGP) {
             combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Generate a new key pair"), GenerateKey, mGenerateTooltip);
         }
         combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("emblem-unavailable")),
                                 i18n("Don't confirm identity and integrity"),
                                 IgnoreKey,
                                 i18nc("@info:tooltip for not selecting a key for signing.", "The E-Mail will not be cryptographically signed."));
 
         mSigningCombos << combo;
         mAllCombos << combo;
         combo->setProperty("address", addr);
 
         connect(combo, &KeySelectionCombo::currentKeyChanged, q, [this]() {
             updateOkButton();
         });
         connect(combo, qOverload<int>(&QComboBox::currentIndexChanged), q, [this]() {
             updateOkButton();
         });
 
         return comboWidget;
     }
 
     void setSigningKeys(const std::vector<GpgME::Key> &preferredKeys, const std::vector<GpgME::Key> &alternativeKeys)
     {
         auto group = new QGroupBox(i18nc("Caption for signing key selection", "Confirm identity '%1' as:", mSender));
         group->setAlignment(Qt::AlignLeft);
         auto sigLayout = new QVBoxLayout(group);
 
         const bool mayNeedOpenPGP = mForcedProtocol != CMS;
         const bool mayNeedCMS = mForcedProtocol != OpenPGP;
         if (mayNeedOpenPGP) {
             if (mAllowMixed) {
                 sigLayout->addWidget(createProtocolLabel(OpenPGP));
             }
             const Key preferredKey = findfirstKeyOfType(preferredKeys, OpenPGP);
             const Key alternativeKey = findfirstKeyOfType(alternativeKeys, OpenPGP);
             if (!preferredKey.isNull()) {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << preferredKey;
                 auto comboWidget = createSigningCombo(mSender, preferredKey);
                 sigLayout->addWidget(comboWidget);
             } else if (!alternativeKey.isNull()) {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << alternativeKey;
                 auto comboWidget = createSigningCombo(mSender, alternativeKey);
                 sigLayout->addWidget(comboWidget);
             } else {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for OpenPGP key";
                 auto comboWidget = createSigningCombo(mSender, Key(), OpenPGP);
                 sigLayout->addWidget(comboWidget);
             }
         }
         if (mayNeedCMS) {
             if (mAllowMixed) {
                 sigLayout->addWidget(createProtocolLabel(CMS));
             }
             const Key preferredKey = findfirstKeyOfType(preferredKeys, CMS);
             const Key alternativeKey = findfirstKeyOfType(alternativeKeys, CMS);
             if (!preferredKey.isNull()) {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << preferredKey;
                 auto comboWidget = createSigningCombo(mSender, preferredKey);
                 sigLayout->addWidget(comboWidget);
             } else if (!alternativeKey.isNull()) {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << alternativeKey;
                 auto comboWidget = createSigningCombo(mSender, alternativeKey);
                 sigLayout->addWidget(comboWidget);
             } else {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for S/MIME key";
                 auto comboWidget = createSigningCombo(mSender, Key(), CMS);
                 sigLayout->addWidget(comboWidget);
             }
         }
 
         mScrollLayout->addWidget(group);
     }
 
     ComboWidget *createEncryptionCombo(const QString &addr, const GpgME::Key &key, GpgME::Protocol fixedProtocol)
     {
         auto combo = new KeySelectionCombo(false);
         auto comboWidget = new ComboWidget(combo);
 #ifndef NDEBUG
         combo->setObjectName(QStringLiteral("encryption key"));
 #endif
         if (fixedProtocol == GpgME::OpenPGP) {
             combo->setKeyFilter(s_pgpEncryptFilter);
         } else if (fixedProtocol == GpgME::CMS) {
             combo->setKeyFilter(s_smimeEncryptFilter);
         } else {
             combo->setKeyFilter(s_encryptFilter);
         }
         if (key.isNull() || key_has_addr(key, addr)) {
             comboWidget->setIdFilter(addr);
         }
         comboWidget->setFixedProtocol(fixedProtocol);
         if (!key.isNull()) {
             combo->setDefaultKey(QString::fromLatin1(key.primaryFingerprint()), fixedProtocol);
         }
 
         if (addr == mSender && key.isNull() && fixedProtocol == OpenPGP) {
             combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Generate a new key pair"), GenerateKey, mGenerateTooltip);
         }
 
         combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("emblem-unavailable")),
                                 i18n("No key. Recipient will be unable to decrypt."),
                                 IgnoreKey,
                                 i18nc("@info:tooltip for No Key selected for a specific recipient.",
                                       "Do not select a key for this recipient.<br/><br/>"
                                       "The recipient will receive the encrypted E-Mail, but it can only "
                                       "be decrypted with the other keys selected in this dialog."));
 
         connect(combo, &KeySelectionCombo::currentKeyChanged, q, [this]() {
             updateOkButton();
         });
         connect(combo, qOverload<int>(&QComboBox::currentIndexChanged), q, [this]() {
             updateOkButton();
         });
 
         mEncCombos << combo;
         mAllCombos << combo;
         combo->setProperty("address", addr);
         return comboWidget;
     }
 
     void addEncryptionAddr(const QString &addr,
                            GpgME::Protocol preferredKeysProtocol,
                            const std::vector<GpgME::Key> &preferredKeys,
                            GpgME::Protocol alternativeKeysProtocol,
                            const std::vector<GpgME::Key> &alternativeKeys,
                            QGridLayout *encGrid)
     {
         if (addr == mSender) {
             const bool mayNeedOpenPGP = mForcedProtocol != CMS;
             const bool mayNeedCMS = mForcedProtocol != OpenPGP;
             if (mayNeedOpenPGP) {
                 if (mAllowMixed) {
                     encGrid->addWidget(createProtocolLabel(OpenPGP), encGrid->rowCount(), 0);
                 }
                 for (const auto &key : preferredKeys) {
                     if (key.protocol() == OpenPGP) {
                         qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                         auto comboWidget = createEncryptionCombo(addr, key, OpenPGP);
                         encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                     }
                 }
                 for (const auto &key : alternativeKeys) {
                     if (key.protocol() == OpenPGP) {
                         qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                         auto comboWidget = createEncryptionCombo(addr, key, OpenPGP);
                         encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                     }
                 }
                 if (!anyKeyHasProtocol(preferredKeys, OpenPGP) && !anyKeyHasProtocol(alternativeKeys, OpenPGP)) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for OpenPGP key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), OpenPGP);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
             }
             if (mayNeedCMS) {
                 if (mAllowMixed) {
                     encGrid->addWidget(createProtocolLabel(CMS), encGrid->rowCount(), 0);
                 }
                 for (const auto &key : preferredKeys) {
                     if (key.protocol() == CMS) {
                         qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                         auto comboWidget = createEncryptionCombo(addr, key, CMS);
                         encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                     }
                 }
                 for (const auto &key : alternativeKeys) {
                     if (key.protocol() == CMS) {
                         qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                         auto comboWidget = createEncryptionCombo(addr, key, CMS);
                         encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                     }
                 }
                 if (!anyKeyHasProtocol(preferredKeys, CMS) && !anyKeyHasProtocol(alternativeKeys, CMS)) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for S/MIME key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), CMS);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
             }
         } else {
             encGrid->addWidget(new QLabel(addr), encGrid->rowCount(), 0);
 
             for (const auto &key : preferredKeys) {
                 qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                 auto comboWidget = createEncryptionCombo(addr, key, preferredKeysProtocol);
                 encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
             }
             for (const auto &key : alternativeKeys) {
                 qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                 auto comboWidget = createEncryptionCombo(addr, key, alternativeKeysProtocol);
                 encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
             }
             if (!mAllowMixed) {
                 if (preferredKeys.empty()) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << Formatting::displayName(preferredKeysProtocol)
                                          << "key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), preferredKeysProtocol);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
                 if (alternativeKeys.empty() && alternativeKeysProtocol != UnknownProtocol) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for"
                                          << Formatting::displayName(alternativeKeysProtocol) << "key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), alternativeKeysProtocol);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
             } else {
                 if (preferredKeys.empty() && alternativeKeys.empty()) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for any key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), UnknownProtocol);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
             }
         }
     }
 
     void setEncryptionKeys(GpgME::Protocol preferredKeysProtocol,
                            const QMap<QString, std::vector<GpgME::Key>> &preferredKeys,
                            GpgME::Protocol alternativeKeysProtocol,
                            const QMap<QString, std::vector<GpgME::Key>> &alternativeKeys)
     {
         {
             auto group = new QGroupBox(i18nc("Encrypt to self (email address):", "Encrypt to self (%1):", mSender));
 #ifndef NDEBUG
             group->setObjectName(QStringLiteral("encrypt-to-self box"));
 #endif
             group->setAlignment(Qt::AlignLeft);
             auto encGrid = new QGridLayout(group);
 
             addEncryptionAddr(mSender, preferredKeysProtocol, preferredKeys.value(mSender), alternativeKeysProtocol, alternativeKeys.value(mSender), encGrid);
 
             encGrid->setColumnStretch(1, -1);
             mScrollLayout->addWidget(group);
         }
 
         const bool hasOtherRecipients = std::any_of(preferredKeys.keyBegin(), preferredKeys.keyEnd(), [this](const auto &recipient) {
             return recipient != mSender;
         });
         if (hasOtherRecipients) {
             auto group = new QGroupBox(i18n("Encrypt to others:"));
 #ifndef NDEBUG
             group->setObjectName(QStringLiteral("encrypt-to-others box"));
 #endif
             group->setAlignment(Qt::AlignLeft);
             auto encGrid = new QGridLayout{group};
 
             for (auto it = std::begin(preferredKeys); it != std::end(preferredKeys); ++it) {
                 const auto &address = it.key();
                 const auto &keys = it.value();
                 if (address != mSender) {
                     addEncryptionAddr(address, preferredKeysProtocol, keys, alternativeKeysProtocol, alternativeKeys.value(address), encGrid);
                 }
             }
 
             encGrid->setColumnStretch(1, -1);
             mScrollLayout->addWidget(group);
         }
 
         mScrollLayout->addStretch(-1);
     }
 
     void updateOkButton()
     {
         static QString origOkText = mOkButton->text();
         const bool isGenerate = bool(findVisibleKeySelectionComboWithGenerateKey());
         const bool allVisibleEncryptionKeysAreIgnored = std::all_of(std::begin(mEncCombos), std::end(mEncCombos), [](auto combo) {
             return !combo->isVisible() || combo->currentData(Qt::UserRole).toInt() == IgnoreKey;
         });
 
         // If we don't encrypt the ok button is always enabled. But otherwise
         // we only enable it if we encrypt to at least one recipient.
         mOkButton->setEnabled(!mEncrypt || !allVisibleEncryptionKeysAreIgnored);
 
         mOkButton->setText(isGenerate ? i18n("Generate") : origOkText);
 
         if (!DeVSCompliance::isActive()) {
             return;
         }
 
         // Handle compliance
         bool de_vs = DeVSCompliance::isCompliant();
 
         if (de_vs) {
             const GpgME::Protocol protocol = currentProtocol();
 
             for (const auto combo : std::as_const(mAllCombos)) {
                 if (!combo->isVisible()) {
                     continue;
                 }
                 const auto key = combo->currentKey();
                 if (key.isNull()) {
                     continue;
                 }
                 if (protocol != GpgME::UnknownProtocol && key.protocol() != protocol) {
                     continue;
                 }
                 if (!DeVSCompliance::keyIsCompliant(key)) {
                     de_vs = false;
                     break;
                 }
             }
         }
 
         DeVSCompliance::decorate(mOkButton, de_vs);
         mComplianceLbl->setText(DeVSCompliance::name(de_vs));
         mComplianceLbl->setVisible(true);
     }
 
     GpgME::Protocol mForcedProtocol;
     QList<KeySelectionCombo *> mSigningCombos;
     QList<KeySelectionCombo *> mEncCombos;
     QList<KeySelectionCombo *> mAllCombos;
     QScrollArea *mScrollArea;
     QVBoxLayout *mScrollLayout;
     QPushButton *mOkButton;
     QVBoxLayout *mMainLay;
     QButtonGroup *mFormatBtns;
     QString mSender;
     bool mSign;
     bool mEncrypt;
     bool mAllowMixed;
     NewKeyApprovalDialog *q;
     QList<QGpgME::Job *> mRunningJobs;
     GpgME::Error mLastError;
     QLabel *mComplianceLbl;
     KeyResolver::Solution mAcceptedResult;
     QString mGenerateTooltip;
 };
 
 NewKeyApprovalDialog::NewKeyApprovalDialog(bool encrypt,
                                            bool sign,
                                            const QString &sender,
                                            KeyResolver::Solution preferredSolution,
                                            KeyResolver::Solution alternativeSolution,
                                            bool allowMixed,
                                            GpgME::Protocol forcedProtocol,
                                            QWidget *parent,
                                            Qt::WindowFlags f)
     : QDialog(parent, f)
     , d{std::make_unique<Private>(this, encrypt, sign, forcedProtocol, preferredSolution.protocol, sender, allowMixed)}
 {
     if (sign) {
         d->setSigningKeys(std::move(preferredSolution.signingKeys), std::move(alternativeSolution.signingKeys));
     }
     if (encrypt) {
         d->setEncryptionKeys(allowMixed ? UnknownProtocol : preferredSolution.protocol,
                              std::move(preferredSolution.encryptionKeys),
                              allowMixed ? UnknownProtocol : alternativeSolution.protocol,
                              std::move(alternativeSolution.encryptionKeys));
     }
     d->updateWidgets();
     d->updateOkButton();
 
     const auto size = sizeHint();
     const auto desk = screen()->size();
     resize(QSize(desk.width() / 3, qMin(size.height(), desk.height() / 2)));
 }
 
 Kleo::NewKeyApprovalDialog::~NewKeyApprovalDialog() = default;
 
 KeyResolver::Solution NewKeyApprovalDialog::result()
 {
     return d->mAcceptedResult;
 }
 
 #include "newkeyapprovaldialog.moc"
diff --git a/src/utils/formatting.cpp b/src/utils/formatting.cpp
index 82b590936..ef7545493 100644
--- a/src/utils/formatting.cpp
+++ b/src/utils/formatting.cpp
@@ -1,1305 +1,1314 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; -*-
     utils/formatting.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2021, 2022 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-libkleo.h>
 
 #include "formatting.h"
 
 #include "compliance.h"
 #include "cryptoconfig.h"
 #include "gnupg.h"
 #include "keyhelpers.h"
 
 #include <libkleo/dn.h>
 #include <libkleo/keycache.h>
 #include <libkleo/keygroup.h>
 
 #include <KEmailAddress>
 #include <KLocalizedString>
 
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 
 #include <QDateTime>
 #include <QIcon>
 #include <QLocale>
 #include <QRegularExpression>
 #include <QString>
 #include <QTextDocument> // for Qt::escape
 
 #include <gpgme++/importresult.h>
 #include <gpgme++/key.h>
 
 using namespace GpgME;
 using namespace Kleo;
 
 //
 // Name
 //
 
 QString Formatting::prettyName(int proto, const char *id, const char *name_, const char *comment_)
 {
     if (proto == GpgME::OpenPGP) {
         const QString name = QString::fromUtf8(name_);
         if (name.isEmpty()) {
             return QString();
         }
         const QString comment = QString::fromUtf8(comment_);
         if (comment.isEmpty()) {
             return name;
         }
         return QStringLiteral("%1 (%2)").arg(name, comment);
     }
 
     if (proto == GpgME::CMS) {
         const DN subject(id);
         const QString cn = subject[QStringLiteral("CN")].trimmed();
         if (cn.isEmpty()) {
             return subject.prettyDN();
         }
         return cn;
     }
 
     return QString();
 }
 
 QString Formatting::prettyNameAndEMail(int proto, const char *id, const char *name_, const char *email_, const char *comment_)
 {
     return prettyNameAndEMail(proto, QString::fromUtf8(id), QString::fromUtf8(name_), prettyEMail(email_, id), QString::fromUtf8(comment_));
 }
 
 QString Formatting::prettyNameAndEMail(int proto, const QString &id, const QString &name, const QString &email, const QString &comment)
 {
     if (proto == GpgME::OpenPGP) {
         if (name.isEmpty()) {
             if (email.isEmpty()) {
                 return QString();
             } else if (comment.isEmpty()) {
                 return QStringLiteral("<%1>").arg(email);
             } else {
                 return QStringLiteral("(%2) <%1>").arg(email, comment);
             }
         }
         if (email.isEmpty()) {
             if (comment.isEmpty()) {
                 return name;
             } else {
                 return QStringLiteral("%1 (%2)").arg(name, comment);
             }
         }
         if (comment.isEmpty()) {
             return QStringLiteral("%1 <%2>").arg(name, email);
         } else {
             return QStringLiteral("%1 (%3) <%2>").arg(name, email, comment);
         }
     }
 
     if (proto == GpgME::CMS) {
         const DN subject(id);
         const QString cn = subject[QStringLiteral("CN")].trimmed();
         if (cn.isEmpty()) {
             return subject.prettyDN();
         }
         return cn;
     }
     return QString();
 }
 
 QString Formatting::prettyUserID(const UserID &uid)
 {
     if (uid.parent().protocol() == GpgME::OpenPGP) {
         return prettyNameAndEMail(uid);
     }
     const QByteArray id = QByteArray(uid.id()).trimmed();
     if (id.startsWith('<')) {
         return prettyEMail(uid.email(), uid.id());
     }
     if (id.startsWith('(')) {
         // ### parse uri/dns:
         return QString::fromUtf8(uid.id());
     } else {
         return DN(uid.id()).prettyDN();
     }
 }
 
 QString Formatting::prettyKeyID(const char *id)
 {
     if (!id) {
         return QString();
     }
     return QLatin1String("0x") + QString::fromLatin1(id).toUpper();
 }
 
 QString Formatting::prettyNameAndEMail(const UserID &uid)
 {
     return prettyNameAndEMail(uid.parent().protocol(), uid.id(), uid.name(), uid.email(), uid.comment());
 }
 
 QString Formatting::prettyNameAndEMail(const Key &key)
 {
     return prettyNameAndEMail(key.userID(0));
 }
 
 QString Formatting::prettyName(const Key &key)
 {
     return prettyName(key.userID(0));
 }
 
 QString Formatting::prettyName(const UserID &uid)
 {
     return prettyName(uid.parent().protocol(), uid.id(), uid.name(), uid.comment());
 }
 
 QString Formatting::prettyName(const UserID::Signature &sig)
 {
     return prettyName(GpgME::OpenPGP, sig.signerUserID(), sig.signerName(), sig.signerComment());
 }
 
 //
 // EMail
 //
 
 QString Formatting::prettyEMail(const Key &key)
 {
     for (unsigned int i = 0, end = key.numUserIDs(); i < end; ++i) {
         const QString email = prettyEMail(key.userID(i));
         if (!email.isEmpty()) {
             return email;
         }
     }
     return QString();
 }
 
 QString Formatting::prettyEMail(const UserID &uid)
 {
     return prettyEMail(uid.email(), uid.id());
 }
 
 QString Formatting::prettyEMail(const UserID::Signature &sig)
 {
     return prettyEMail(sig.signerEmail(), sig.signerUserID());
 }
 
 QString Formatting::prettyEMail(const char *email_, const char *id)
 {
     QString email;
     QString name;
     QString comment;
     if (email_ && KEmailAddress::splitAddress(QString::fromUtf8(email_), name, email, comment) == KEmailAddress::AddressOk) {
         return email;
     } else {
         return DN(id)[QStringLiteral("EMAIL")].trimmed();
     }
 }
 
 //
 // Tooltip
 //
 
 namespace
 {
 
 static QString protect_whitespace(QString s)
 {
     static const QLatin1Char SP(' ');
     static const QLatin1Char NBSP('\xA0');
     return s.replace(SP, NBSP);
 }
 
 template<typename T_arg>
 QString format_row(const QString &field, const T_arg &arg)
 {
     return QStringLiteral("<tr><th>%1:</th><td>%2</td></tr>").arg(protect_whitespace(field), arg);
 }
 QString format_row(const QString &field, const QString &arg)
 {
     return QStringLiteral("<tr><th>%1:</th><td>%2</td></tr>").arg(protect_whitespace(field), arg.toHtmlEscaped());
 }
 QString format_row(const QString &field, const char *arg)
 {
     return format_row(field, QString::fromUtf8(arg));
 }
 
 QString format_keytype(const Key &key)
 {
     const Subkey subkey = key.subkey(0);
     if (key.hasSecret()) {
         return i18n("%1-bit %2 (secret key available)", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
     } else {
         return i18n("%1-bit %2", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
     }
 }
 
 QString format_subkeytype(const Subkey &subkey)
 {
     const auto algo = subkey.publicKeyAlgorithm();
 
     if (algo == Subkey::AlgoECC || algo == Subkey::AlgoECDSA || algo == Subkey::AlgoECDH || algo == Subkey::AlgoEDDSA) {
         return QString::fromStdString(subkey.algoName());
     }
     return i18n("%1-bit %2", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
 }
 
 QString format_keyusage(const Key &key)
 {
     QStringList capabilities;
 #if GPGMEPP_KEY_CANSIGN_IS_FIXED
     if (key.canSign()) {
 #else
     if (key.canReallySign()) {
 #endif
         if (key.isQualified()) {
             capabilities.push_back(i18n("Signing (Qualified)"));
         } else {
             capabilities.push_back(i18n("Signing"));
         }
     }
     if (key.canEncrypt()) {
         capabilities.push_back(i18n("Encryption"));
     }
     if (key.canCertify()) {
         capabilities.push_back(i18n("Certifying User-IDs"));
     }
     if (key.canAuthenticate()) {
         capabilities.push_back(i18n("SSH Authentication"));
     }
     return capabilities.join(QLatin1String(", "));
 }
 
 QString format_subkeyusage(const Subkey &subkey)
 {
     QStringList capabilities;
     if (subkey.canSign()) {
         if (subkey.isQualified()) {
             capabilities.push_back(i18n("Signing (Qualified)"));
         } else {
             capabilities.push_back(i18n("Signing"));
         }
     }
     if (subkey.canEncrypt()) {
         capabilities.push_back(i18n("Encryption"));
     }
     if (subkey.canCertify()) {
         capabilities.push_back(i18n("Certifying User-IDs"));
     }
     if (subkey.canAuthenticate()) {
         capabilities.push_back(i18n("SSH Authentication"));
     }
     return capabilities.join(QLatin1String(", "));
 }
 
 static QString time_t2string(time_t t)
 {
     const QDateTime dt = QDateTime::fromSecsSinceEpoch(quint32(t));
     return QLocale().toString(dt, QLocale::ShortFormat);
 }
 
 static QString make_red(const QString &txt)
 {
     return QLatin1String("<font color=\"red\">") + txt.toHtmlEscaped() + QLatin1String("</font>");
 }
 
 }
 
 QString Formatting::toolTip(const Key &key, int flags)
 {
     if (flags == 0 || (key.protocol() != GpgME::CMS && key.protocol() != GpgME::OpenPGP)) {
         return QString();
     }
 
     const Subkey subkey = key.subkey(0);
 
     QString result;
     if (flags & Validity) {
         if (key.protocol() == GpgME::OpenPGP || (key.keyListMode() & Validate)) {
             if (key.isRevoked()) {
                 result = make_red(i18n("Revoked"));
             } else if (key.isExpired()) {
                 result = make_red(i18n("Expired"));
             } else if (key.isDisabled()) {
                 result = i18n("Disabled");
             } else if (key.keyListMode() & GpgME::Validate) {
                 unsigned int fullyTrusted = 0;
                 for (const auto &uid : key.userIDs()) {
                     if (uid.validity() >= UserID::Validity::Full) {
                         fullyTrusted++;
                     }
                 }
                 if (fullyTrusted == key.numUserIDs()) {
                     result = i18n("All User-IDs are certified.");
                     const auto compliance = complianceStringForKey(key);
                     if (!compliance.isEmpty()) {
                         result += QStringLiteral("<br>") + compliance;
                     }
                 } else {
                     result = i18np("One User-ID is not certified.", "%1 User-IDs are not certified.", key.numUserIDs() - fullyTrusted);
                 }
             } else {
                 result = i18n("The validity cannot be checked at the moment.");
             }
         } else {
             result = i18n("The validity cannot be checked at the moment.");
         }
     }
     if (flags == Validity) {
         return result;
     }
 
     result += QLatin1String("<table border=\"0\">");
     if (key.protocol() == GpgME::CMS) {
         if (flags & SerialNumber) {
             result += format_row(i18n("Serial number"), key.issuerSerial());
         }
         if (flags & Issuer) {
             result += format_row(i18n("Issuer"), key.issuerName());
         }
     }
     if (flags & UserIDs) {
         const std::vector<UserID> uids = key.userIDs();
         if (!uids.empty()) {
             result += format_row(key.protocol() == GpgME::CMS ? i18n("Subject") : i18n("User-ID"), prettyUserID(uids.front()));
         }
         if (uids.size() > 1) {
             for (auto it = uids.begin() + 1, end = uids.end(); it != end; ++it) {
                 if (!it->isRevoked() && !it->isInvalid()) {
                     result += format_row(i18n("a.k.a."), prettyUserID(*it));
                 }
             }
         }
     }
     if (flags & ExpiryDates) {
         result += format_row(i18n("Valid from"), time_t2string(subkey.creationTime()));
 
         if (!subkey.neverExpires()) {
             result += format_row(i18n("Valid until"), time_t2string(subkey.expirationTime()));
         }
     }
     if (flags & CertificateType) {
         result += format_row(i18n("Type"), format_keytype(key));
     }
     if (flags & CertificateUsage) {
         result += format_row(i18n("Usage"), format_keyusage(key));
     }
     if (flags & KeyID) {
         result += format_row(i18n("Key-ID"), QString::fromLatin1(key.shortKeyID()));
     }
     if (flags & Fingerprint) {
         result += format_row(i18n("Fingerprint"), key.primaryFingerprint());
     }
     if (flags & OwnerTrust) {
         if (key.protocol() == GpgME::OpenPGP) {
             result += format_row(i18n("Certification trust"), ownerTrustShort(key));
         } else if (key.isRoot()) {
             result += format_row(i18n("Trusted issuer?"), key.userID(0).validity() == UserID::Ultimate ? i18n("Yes") : i18n("No"));
         }
     }
 
     if (flags & StorageLocation) {
         if (const char *card = subkey.cardSerialNumber()) {
             result += format_row(i18n("Stored"), i18nc("stored...", "on SmartCard with serial no. %1", QString::fromUtf8(card)));
         } else {
             result += format_row(i18n("Stored"), i18nc("stored...", "on this computer"));
         }
     }
     if (flags & Subkeys) {
         for (const auto &sub : key.subkeys()) {
             result += QLatin1String("<hr/>");
             result += format_row(i18n("Subkey"), sub.fingerprint());
             if (sub.isRevoked()) {
                 result += format_row(i18n("Status"), i18n("Revoked"));
             } else if (sub.isExpired()) {
                 result += format_row(i18n("Status"), i18n("Expired"));
             }
             if (flags & ExpiryDates) {
                 result += format_row(i18n("Valid from"), time_t2string(sub.creationTime()));
 
                 if (!sub.neverExpires()) {
                     result += format_row(i18n("Valid until"), time_t2string(sub.expirationTime()));
                 }
             }
 
             if (flags & CertificateType) {
                 result += format_row(i18n("Type"), format_subkeytype(sub));
             }
             if (flags & CertificateUsage) {
                 result += format_row(i18n("Usage"), format_subkeyusage(sub));
             }
             if (flags & StorageLocation) {
                 if (const char *card = sub.cardSerialNumber()) {
                     result += format_row(i18n("Stored"), i18nc("stored...", "on SmartCard with serial no. %1", QString::fromUtf8(card)));
                 } else {
                     result += format_row(i18n("Stored"), i18nc("stored...", "on this computer"));
                 }
             }
         }
     }
     result += QLatin1String("</table>");
 
     return result;
 }
 
 namespace
 {
 template<typename Container>
 QString getValidityStatement(const Container &keys)
 {
     const bool allKeysAreOpenPGP = std::all_of(keys.cbegin(), keys.cend(), [](const Key &key) {
         return key.protocol() == GpgME::OpenPGP;
     });
     const bool allKeysAreValidated = std::all_of(keys.cbegin(), keys.cend(), [](const Key &key) {
         return key.keyListMode() & Validate;
     });
     if (allKeysAreOpenPGP || allKeysAreValidated) {
         const bool someKeysAreBad = std::any_of(keys.cbegin(), keys.cend(), std::mem_fn(&Key::isBad));
         if (someKeysAreBad) {
             return i18n("Some keys are revoked, expired, disabled, or invalid.");
         } else {
             const bool allKeysAreFullyValid = std::all_of(keys.cbegin(), keys.cend(), &Kleo::allUserIDsHaveFullValidity);
             if (allKeysAreFullyValid) {
                 return i18n("All keys are certified.");
             } else {
                 return i18n("Some keys are not certified.");
             }
         }
     }
     return i18n("The validity of the keys cannot be checked at the moment.");
 }
 }
 
 QString Formatting::toolTip(const KeyGroup &group, int flags)
 {
     static const unsigned int maxNumKeysForTooltip = 20;
 
     if (group.isNull()) {
         return QString();
     }
 
     const KeyGroup::Keys &keys = group.keys();
     if (keys.size() == 0) {
         return i18nc("@info:tooltip", "This group does not contain any keys.");
     }
 
     const QString validity = (flags & Validity) ? getValidityStatement(keys) : QString();
     if (flags == Validity) {
         return validity;
     }
 
     // list either up to maxNumKeysForTooltip keys or (maxNumKeysForTooltip-1) keys followed by "and n more keys"
     const unsigned int numKeysForTooltip = keys.size() > maxNumKeysForTooltip ? maxNumKeysForTooltip - 1 : keys.size();
 
     QStringList result;
     result.reserve(3 + 2 + numKeysForTooltip + 2);
     if (!validity.isEmpty()) {
         result.push_back(QStringLiteral("<p>"));
         result.push_back(validity.toHtmlEscaped());
         result.push_back(QStringLiteral("</p>"));
     }
 
     result.push_back(QStringLiteral("<p>"));
     result.push_back(i18n("Keys:"));
     {
         auto it = keys.cbegin();
         for (unsigned int i = 0; i < numKeysForTooltip; ++i, ++it) {
             result.push_back(QLatin1String("<br>") + Formatting::summaryLine(*it).toHtmlEscaped());
         }
     }
     if (keys.size() > numKeysForTooltip) {
         result.push_back(QLatin1String("<br>") + i18ncp("this follows a list of keys", "and 1 more key", "and %1 more keys", keys.size() - numKeysForTooltip));
     }
     result.push_back(QStringLiteral("</p>"));
 
     return result.join(QLatin1Char('\n'));
 }
 
 //
 // Creation and Expiration
 //
 
 namespace
 {
 static QDate time_t2date(time_t t)
 {
     if (!t) {
         return {};
     }
     const QDateTime dt = QDateTime::fromSecsSinceEpoch(quint32(t));
     return dt.date();
 }
 static QString accessible_date_format()
 {
     return i18nc(
         "date format suitable for screen readers; "
         "d: day as a number without a leading zero, "
         "MMMM: localized month name, "
         "yyyy: year as a four digit number",
         "MMMM d, yyyy");
 }
 
 template<typename T>
 QString expiration_date_string(const T &tee, const QString &noExpiration)
 {
     return tee.neverExpires() ? noExpiration : Formatting::dateString(time_t2date(tee.expirationTime()));
 }
 template<typename T>
 QDate creation_date(const T &tee)
 {
     return time_t2date(tee.creationTime());
 }
 template<typename T>
 QDate expiration_date(const T &tee)
 {
     return time_t2date(tee.expirationTime());
 }
 }
 
 QString Formatting::dateString(time_t t)
 {
     return dateString(time_t2date(t));
 }
 
 QString Formatting::dateString(const QDate &date)
 {
     return QLocale().toString(date, QLocale::ShortFormat);
 }
 
 QString Formatting::accessibleDate(time_t t)
 {
     return accessibleDate(time_t2date(t));
 }
 
 QString Formatting::accessibleDate(const QDate &date)
 {
     return QLocale().toString(date, accessible_date_format());
 }
 
 QString Formatting::expirationDateString(const Key &key, const QString &noExpiration)
 {
     // if key is remote but has a non-zero expiration date (e.g. a key looked up via WKD),
     // then we assume that the date is valid; if the date is zero for a remote key, then
     // we don't know if it's unknown or unlimited
     return isRemoteKey(key) && (key.subkey(0).expirationTime() == 0) //
         ? i18nc("@info the expiration date of the key is unknown", "unknown")
         : expiration_date_string(key.subkey(0), noExpiration);
 }
 
 QString Formatting::expirationDateString(const Subkey &subkey, const QString &noExpiration)
 {
     return expiration_date_string(subkey, noExpiration);
 }
 
 QString Formatting::expirationDateString(const UserID::Signature &sig, const QString &noExpiration)
 {
     return expiration_date_string(sig, noExpiration);
 }
 
 QDate Formatting::expirationDate(const Key &key)
 {
     return expiration_date(key.subkey(0));
 }
 
 QDate Formatting::expirationDate(const Subkey &subkey)
 {
     return expiration_date(subkey);
 }
 
 QDate Formatting::expirationDate(const UserID::Signature &sig)
 {
     return expiration_date(sig);
 }
 
 QString Formatting::accessibleExpirationDate(const Key &key, const QString &noExpiration)
 {
     // if key is remote but has a non-zero expiration date (e.g. a key looked up via WKD),
     // then we assume that the date is valid; if the date is zero for a remote key, then
     // we don't know if it's unknown or unlimited
     return isRemoteKey(key) && (key.subkey(0).expirationTime() == 0) //
         ? i18nc("@info the expiration date of the key is unknown", "unknown")
         : accessibleExpirationDate(key.subkey(0), noExpiration);
 }
 
 QString Formatting::accessibleExpirationDate(const Subkey &subkey, const QString &noExpiration)
 {
     if (subkey.neverExpires()) {
         return noExpiration.isEmpty() ? i18n("unlimited") : noExpiration;
     } else {
         return accessibleDate(expirationDate(subkey));
     }
 }
 
 QString Formatting::accessibleExpirationDate(const UserID::Signature &sig, const QString &noExpiration)
 {
     if (sig.neverExpires()) {
         return noExpiration.isEmpty() ? i18n("unlimited") : noExpiration;
     } else {
         return accessibleDate(expirationDate(sig));
     }
 }
 
 QString Formatting::creationDateString(const Key &key)
 {
     return dateString(creation_date(key.subkey(0)));
 }
 
 QString Formatting::creationDateString(const Subkey &subkey)
 {
     return dateString(creation_date(subkey));
 }
 
 QString Formatting::creationDateString(const UserID::Signature &sig)
 {
     return dateString(creation_date(sig));
 }
 
 QDate Formatting::creationDate(const Key &key)
 {
     return creation_date(key.subkey(0));
 }
 
 QDate Formatting::creationDate(const Subkey &subkey)
 {
     return creation_date(subkey);
 }
 
 QDate Formatting::creationDate(const UserID::Signature &sig)
 {
     return creation_date(sig);
 }
 
 QString Formatting::accessibleCreationDate(const Key &key)
 {
     return accessibleDate(creationDate(key));
 }
 
 QString Formatting::accessibleCreationDate(const Subkey &subkey)
 {
     return accessibleDate(creationDate(subkey));
 }
 
 //
 // Types
 //
 
 QString Formatting::displayName(GpgME::Protocol p)
 {
     if (p == GpgME::CMS) {
         return i18nc("X.509/CMS encryption standard", "S/MIME");
     }
     if (p == GpgME::OpenPGP) {
         return i18n("OpenPGP");
     }
     return i18nc("Unknown encryption protocol", "Unknown");
 }
 
 QString Formatting::type(const Key &key)
 {
     return displayName(key.protocol());
 }
 
 QString Formatting::type(const Subkey &subkey)
 {
     return QString::fromUtf8(subkey.publicKeyAlgorithmAsString());
 }
 
 QString Formatting::type(const KeyGroup &group)
 {
     Q_UNUSED(group)
     return i18nc("a group of keys/certificates", "Group");
 }
 
 //
 // Status / Validity
 //
 
 QString Formatting::ownerTrustShort(const Key &key)
 {
     return ownerTrustShort(key.ownerTrust());
 }
 
 QString Formatting::ownerTrustShort(Key::OwnerTrust trust)
 {
     switch (trust) {
     case Key::Unknown:
         return i18nc("unknown trust level", "unknown");
     case Key::Never:
         return i18n("untrusted");
     case Key::Marginal:
         return i18nc("marginal trust", "marginal");
     case Key::Full:
         return i18nc("full trust", "full");
     case Key::Ultimate:
         return i18nc("ultimate trust", "ultimate");
     case Key::Undefined:
         return i18nc("undefined trust", "undefined");
     default:
         Q_ASSERT(!"unexpected owner trust value");
         break;
     }
     return QString();
 }
 
 QString Formatting::validityShort(const Subkey &subkey)
 {
     if (subkey.isRevoked()) {
         return i18n("revoked");
     }
     if (subkey.isExpired()) {
         return i18n("expired");
     }
     if (subkey.isDisabled()) {
         return i18n("disabled");
     }
     if (subkey.isInvalid()) {
         return i18n("invalid");
     }
     return i18nc("as in good/valid signature", "good");
 }
 
 QString Formatting::validityShort(const UserID &uid)
 {
     if (uid.isRevoked()) {
         return i18n("revoked");
     }
     if (uid.isInvalid()) {
         return i18n("invalid");
     }
     switch (uid.validity()) {
     case UserID::Unknown:
         return i18nc("unknown trust level", "unknown");
     case UserID::Undefined:
         return i18nc("undefined trust", "undefined");
     case UserID::Never:
         return i18n("untrusted");
     case UserID::Marginal:
         return i18nc("marginal trust", "marginal");
     case UserID::Full:
         return i18nc("full trust", "full");
     case UserID::Ultimate:
         return i18nc("ultimate trust", "ultimate");
     }
     return QString();
 }
 
 QString Formatting::validityShort(const UserID::Signature &sig)
 {
     switch (sig.status()) {
     case UserID::Signature::NoError:
         if (!sig.isInvalid()) {
             /* See RFC 4880 Section 5.2.1 */
             switch (sig.certClass()) {
             case 0x10: /* Generic */
             case 0x11: /* Persona */
             case 0x12: /* Casual */
             case 0x13: /* Positive */
                 return i18n("valid");
             case 0x30:
                 return i18n("revoked");
             default:
                 return i18n("class %1", sig.certClass());
             }
         }
         Q_FALLTHROUGH();
         // fall through:
     case UserID::Signature::GeneralError:
         return i18n("invalid");
     case UserID::Signature::SigExpired:
         return i18n("expired");
     case UserID::Signature::KeyExpired:
         return i18n("certificate expired");
     case UserID::Signature::BadSignature:
         return i18nc("fake/invalid signature", "bad");
     case UserID::Signature::NoPublicKey: {
         /* GnuPG returns the same error for no public key as for expired
          * or revoked certificates. */
         const auto key = KeyCache::instance()->findByKeyIDOrFingerprint(sig.signerKeyID());
         if (key.isNull()) {
             return i18n("no public key");
         } else if (key.isExpired()) {
             return i18n("key expired");
         } else if (key.isRevoked()) {
             return i18n("key revoked");
         } else if (key.isDisabled()) {
             return i18n("key disabled");
         }
         /* can't happen */
         return QStringLiteral("unknown");
     }
     }
     return QString();
 }
 
 QIcon Formatting::validityIcon(const UserID::Signature &sig)
 {
     switch (sig.status()) {
     case UserID::Signature::NoError:
         if (!sig.isInvalid()) {
             /* See RFC 4880 Section 5.2.1 */
             switch (sig.certClass()) {
             case 0x10: /* Generic */
             case 0x11: /* Persona */
             case 0x12: /* Casual */
             case 0x13: /* Positive */
                 return QIcon::fromTheme(QStringLiteral("emblem-success"));
             case 0x30:
                 return QIcon::fromTheme(QStringLiteral("emblem-error"));
             default:
                 return QIcon();
             }
         }
         Q_FALLTHROUGH();
         // fall through:
     case UserID::Signature::BadSignature:
     case UserID::Signature::GeneralError:
         return QIcon::fromTheme(QStringLiteral("emblem-error"));
     case UserID::Signature::SigExpired:
     case UserID::Signature::KeyExpired:
         return QIcon::fromTheme(QStringLiteral("emblem-information"));
     case UserID::Signature::NoPublicKey:
         return QIcon::fromTheme(QStringLiteral("emblem-question"));
     }
     return QIcon();
 }
 
 QString Formatting::formatKeyLink(const Key &key)
 {
     if (key.isNull()) {
         return QString();
     }
     return QStringLiteral("<a href=\"key:%1\">%2</a>").arg(QLatin1String(key.primaryFingerprint()), Formatting::prettyName(key));
 }
 
 QString Formatting::formatForComboBox(const GpgME::Key &key)
 {
     const QString name = prettyName(key);
     QString mail = prettyEMail(key);
     if (!mail.isEmpty()) {
         mail = QLatin1Char('<') + mail + QLatin1Char('>');
     }
     return i18nc("name, email, key id", "%1 %2 (%3)", name, mail, QLatin1String(key.shortKeyID())).simplified();
 }
 
 namespace
 {
 
 static QString keyToString(const Key &key)
 {
     Q_ASSERT(!key.isNull());
 
     const QString email = Formatting::prettyEMail(key);
     const QString name = Formatting::prettyName(key);
 
     if (name.isEmpty()) {
         return email;
     } else if (email.isEmpty()) {
         return name;
     } else {
         return QStringLiteral("%1 <%2>").arg(name, email);
     }
 }
 
 }
 
 const char *Formatting::summaryToString(const Signature::Summary summary)
 {
     if (summary & Signature::Red) {
         return "RED";
     }
     if (summary & Signature::Green) {
         return "GREEN";
     }
     return "YELLOW";
 }
 
 QString Formatting::signatureToString(const Signature &sig, const Key &key)
 {
     if (sig.isNull()) {
         return QString();
     }
 
     const bool red = (sig.summary() & Signature::Red);
     const bool valid = (sig.summary() & Signature::Valid);
 
     if (red) {
         if (key.isNull()) {
             if (const char *fpr = sig.fingerprint()) {
-                return i18n("Bad signature by unknown certificate %1: %2", QString::fromLatin1(fpr), QString::fromLocal8Bit(sig.status().asString()));
+                return i18n("Bad signature by unknown certificate %1: %2", QString::fromLatin1(fpr), Formatting::errorAsString(sig.status()));
             } else {
-                return i18n("Bad signature by an unknown certificate: %1", QString::fromLocal8Bit(sig.status().asString()));
+                return i18n("Bad signature by an unknown certificate: %1", Formatting::errorAsString(sig.status()));
             }
         } else {
-            return i18n("Bad signature by %1: %2", keyToString(key), QString::fromLocal8Bit(sig.status().asString()));
+            return i18n("Bad signature by %1: %2", keyToString(key), Formatting::errorAsString(sig.status()));
         }
 
     } else if (valid) {
         if (key.isNull()) {
             if (const char *fpr = sig.fingerprint()) {
                 return i18n("Good signature by unknown certificate %1.", QString::fromLatin1(fpr));
             } else {
                 return i18n("Good signature by an unknown certificate.");
             }
         } else {
             return i18n("Good signature by %1.", keyToString(key));
         }
 
     } else if (key.isNull()) {
         if (const char *fpr = sig.fingerprint()) {
-            return i18n("Invalid signature by unknown certificate %1: %2", QString::fromLatin1(fpr), QString::fromLocal8Bit(sig.status().asString()));
+            return i18n("Invalid signature by unknown certificate %1: %2", QString::fromLatin1(fpr), Formatting::errorAsString(sig.status()));
         } else {
-            return i18n("Invalid signature by an unknown certificate: %1", QString::fromLocal8Bit(sig.status().asString()));
+            return i18n("Invalid signature by an unknown certificate: %1", Formatting::errorAsString(sig.status()));
         }
     } else {
-        return i18n("Invalid signature by %1: %2", keyToString(key), QString::fromLocal8Bit(sig.status().asString()));
+        return i18n("Invalid signature by %1: %2", keyToString(key), Formatting::errorAsString(sig.status()));
     }
 }
 
 //
 // ImportResult
 //
 
 QString Formatting::importMetaData(const Import &import, const QStringList &ids)
 {
     const QString result = importMetaData(import);
     if (result.isEmpty()) {
         return QString();
     } else {
         return result + QLatin1Char('\n') + i18n("This certificate was imported from the following sources:") + QLatin1Char('\n') + ids.join(QLatin1Char('\n'));
     }
 }
 
 QString Formatting::importMetaData(const Import &import)
 {
     if (import.isNull()) {
         return QString();
     }
 
     if (import.error().isCanceled()) {
         return i18n("The import of this certificate was canceled.");
     }
     if (import.error()) {
-        return i18n("An error occurred importing this certificate: %1", QString::fromLocal8Bit(import.error().asString()));
+        return i18n("An error occurred importing this certificate: %1", Formatting::errorAsString(import.error()));
     }
 
     const unsigned int status = import.status();
     if (status & Import::NewKey) {
         return (status & Import::ContainedSecretKey) ? i18n("This certificate was new to your keystore. The secret key is available.")
                                                      : i18n("This certificate is new to your keystore.");
     }
 
     QStringList results;
     if (status & Import::NewUserIDs) {
         results.push_back(i18n("New user-ids were added to this certificate by the import."));
     }
     if (status & Import::NewSignatures) {
         results.push_back(i18n("New signatures were added to this certificate by the import."));
     }
     if (status & Import::NewSubkeys) {
         results.push_back(i18n("New subkeys were added to this certificate by the import."));
     }
 
     return results.empty() ? i18n("The import contained no new data for this certificate. It is unchanged.") : results.join(QLatin1Char('\n'));
 }
 
 //
 // Overview in CertificateDetailsDialog
 //
 
 QString Formatting::formatOverview(const Key &key)
 {
     return toolTip(key, AllOptions);
 }
 
 QString Formatting::usageString(const Subkey &sub)
 {
     QStringList usageStrings;
     if (sub.canCertify()) {
         usageStrings << i18n("Certify");
     }
     if (sub.canSign()) {
         usageStrings << i18n("Sign");
     }
     if (sub.canEncrypt()) {
         usageStrings << i18n("Encrypt");
     }
     if (sub.canAuthenticate()) {
         usageStrings << i18n("Authenticate");
     }
     return usageStrings.join(QLatin1String(", "));
 }
 
 QString Formatting::summaryLine(const Key &key)
 {
     return keyToString(key) + QLatin1Char(' ')
         + i18nc("(validity, protocol, creation date)",
                 "(%1, %2, created: %3)",
                 Formatting::complianceStringShort(key),
                 displayName(key.protocol()),
                 Formatting::creationDateString(key));
 }
 
 QString Formatting::summaryLine(const KeyGroup &group)
 {
     switch (group.source()) {
     case KeyGroup::ApplicationConfig:
     case KeyGroup::GnuPGConfig:
         return i18ncp("name of group of keys (n key(s), validity)",
                       "%2 (1 key, %3)",
                       "%2 (%1 keys, %3)",
                       group.keys().size(),
                       group.name(),
                       Formatting::complianceStringShort(group));
     case KeyGroup::Tags:
         return i18ncp("name of group of keys (n key(s), validity, tag)",
                       "%2 (1 key, %3, tag)",
                       "%2 (%1 keys, %3, tag)",
                       group.keys().size(),
                       group.name(),
                       Formatting::complianceStringShort(group));
     default:
         return i18ncp("name of group of keys (n key(s), validity, group ...)",
                       "%2 (1 key, %3, unknown origin)",
                       "%2 (%1 keys, %3, unknown origin)",
                       group.keys().size(),
                       group.name(),
                       Formatting::complianceStringShort(group));
     }
 }
 
 namespace
 {
 QIcon iconForValidity(UserID::Validity validity)
 {
     switch (validity) {
     case UserID::Ultimate:
     case UserID::Full:
     case UserID::Marginal:
         return QIcon::fromTheme(QStringLiteral("emblem-success"));
     case UserID::Never:
         return QIcon::fromTheme(QStringLiteral("emblem-error"));
     case UserID::Undefined:
     case UserID::Unknown:
     default:
         return QIcon::fromTheme(QStringLiteral("emblem-information"));
     }
 }
 }
 
 // Icon for certificate selection indication
 QIcon Formatting::iconForUid(const UserID &uid)
 {
     return iconForValidity(uid.validity());
 }
 
 QString Formatting::validity(const UserID &uid)
 {
     switch (uid.validity()) {
     case UserID::Ultimate:
         return i18n("The certificate is marked as your own.");
     case UserID::Full:
         return i18n("The certificate belongs to this recipient.");
     case UserID::Marginal:
         return i18n("The trust model indicates marginally that the certificate belongs to this recipient.");
     case UserID::Never:
         return i18n("This certificate should not be used.");
     case UserID::Undefined:
     case UserID::Unknown:
     default:
         return i18n("There is no indication that this certificate belongs to this recipient.");
     }
 }
 
 QString Formatting::validity(const KeyGroup &group)
 {
     if (group.isNull()) {
         return QString();
     }
 
     const KeyGroup::Keys &keys = group.keys();
     if (keys.size() == 0) {
         return i18n("This group does not contain any keys.");
     }
 
     return getValidityStatement(keys);
 }
 
 namespace
 {
 template<typename Container>
 UserID::Validity minimalValidity(const Container &keys)
 {
     const int minValidity = std::accumulate(keys.cbegin(), keys.cend(), UserID::Ultimate + 1, [](int validity, const Key &key) {
         return std::min<int>(validity, minimalValidityOfNotRevokedUserIDs(key));
     });
     return minValidity <= UserID::Ultimate ? static_cast<UserID::Validity>(minValidity) : UserID::Unknown;
 }
 }
 
 QIcon Formatting::validityIcon(const KeyGroup &group)
 {
     return iconForValidity(minimalValidity(group.keys()));
 }
 
 bool Formatting::uidsHaveFullValidity(const Key &key)
 {
     return allUserIDsHaveFullValidity(key);
 }
 
 QString Formatting::complianceMode()
 {
     const auto complianceValue = getCryptoConfigStringValue("gpg", "compliance");
     return complianceValue == QLatin1String("gnupg") ? QString() : complianceValue;
 }
 
 bool Formatting::isKeyDeVs(const GpgME::Key &key)
 {
     return DeVSCompliance::allSubkeysAreCompliant(key);
 }
 
 QString Formatting::complianceStringForKey(const GpgME::Key &key)
 {
     // There will likely be more in the future for other institutions
     // for now we only have DE-VS
     if (DeVSCompliance::isCompliant()) {
         return isRemoteKey(key) //
             ? i18nc("@info the compliance of the key with certain requirements is unknown", "unknown")
             : DeVSCompliance::name(DeVSCompliance::keyIsCompliant(key));
     }
     return QString();
 }
 
 QString Formatting::complianceStringShort(const GpgME::Key &key)
 {
     if (DeVSCompliance::isCompliant() && DeVSCompliance::keyIsCompliant(key)) {
         return QStringLiteral("★ ") + DeVSCompliance::name(true);
     }
     const bool keyValidityChecked = (key.keyListMode() & GpgME::Validate);
     if (keyValidityChecked && Kleo::allUserIDsHaveFullValidity(key)) {
         return i18nc("As in all user IDs are valid.", "certified");
     }
     if (key.isExpired()) {
         return i18n("expired");
     }
     if (key.isRevoked()) {
         return i18n("revoked");
     }
     if (key.isDisabled()) {
         return i18n("disabled");
     }
     if (key.isInvalid()) {
         return i18n("invalid");
     }
     if (keyValidityChecked) {
         return i18nc("As in not all user IDs are valid.", "not certified");
     }
 
     return i18nc("The validity of the user IDs has not been/could not be checked", "not checked");
 }
 
 QString Formatting::complianceStringShort(const KeyGroup &group)
 {
     const KeyGroup::Keys &keys = group.keys();
 
     const bool allKeysFullyValid = std::all_of(keys.cbegin(), keys.cend(), &Kleo::allUserIDsHaveFullValidity);
     if (allKeysFullyValid) {
         return i18nc("As in all keys are valid.", "all certified");
     }
 
     return i18nc("As in not all keys are valid.", "not all certified");
 }
 
 QString Formatting::prettyID(const char *id)
 {
     if (!id) {
         return QString();
     }
     QString ret = QString::fromLatin1(id).toUpper().replace(QRegularExpression(QStringLiteral("(....)")), QStringLiteral("\\1 ")).trimmed();
     // For the standard 10 group fingerprint let us use a double space in the
     // middle to increase readability
     if (ret.size() == 49) {
         ret.insert(24, QLatin1Char(' '));
     }
     return ret;
 }
 
 QString Formatting::accessibleHexID(const char *id)
 {
     static const QRegularExpression groupOfFourRegExp{QStringLiteral("(?:(.)(.)(.)(.))")};
 
     QString ret;
     ret = QString::fromLatin1(id);
     if (!ret.isEmpty() && (ret.size() % 4 == 0)) {
         ret = ret.replace(groupOfFourRegExp, QStringLiteral("\\1 \\2 \\3 \\4, ")).chopped(2);
     }
     return ret;
 }
 
 QString Formatting::origin(int o)
 {
     switch (o) {
     case Key::OriginKS:
         return i18n("Keyserver");
     case Key::OriginDane:
         return QStringLiteral("DANE");
     case Key::OriginWKD:
         return QStringLiteral("WKD");
     case Key::OriginURL:
         return QStringLiteral("URL");
     case Key::OriginFile:
         return i18n("File import");
     case Key::OriginSelf:
         return i18n("Generated");
     case Key::OriginOther:
     case Key::OriginUnknown:
     default:
         return i18n("Unknown");
     }
 }
 
 QString Formatting::deVsString(bool compliant)
 {
     return DeVSCompliance::name(compliant);
 }
 
 namespace
 {
 QString formatTrustScope(const char *trustScope)
 {
     static const QRegularExpression escapedNonAlphaNum{QStringLiteral(R"(\\([^0-9A-Za-z]))")};
 
     const auto scopeRegExp = QString::fromUtf8(trustScope);
     if (scopeRegExp.startsWith(u"<[^>]+[@.]") && scopeRegExp.endsWith(u">$")) {
         // looks like a trust scope regular expression created by gpg
         auto domain = scopeRegExp.mid(10, scopeRegExp.size() - 10 - 2);
         domain.replace(escapedNonAlphaNum, QStringLiteral(R"(\1)"));
         return domain;
     }
     return scopeRegExp;
 }
 }
 
 QString Formatting::trustSignatureDomain(const GpgME::UserID::Signature &sig)
 {
     return formatTrustScope(sig.trustScope());
 }
 
 QString Formatting::trustSignature(const GpgME::UserID::Signature &sig)
 {
     switch (sig.trustValue()) {
     case TrustSignatureTrust::Partial:
         return i18nc("Certifies this key as partially trusted introducer for 'domain name'.",
                      "Certifies this key as partially trusted introducer for '%1'.",
                      trustSignatureDomain(sig));
     case TrustSignatureTrust::Complete:
         return i18nc("Certifies this key as fully trusted introducer for 'domain name'.",
                      "Certifies this key as fully trusted introducer for '%1'.",
                      trustSignatureDomain(sig));
     default:
         return {};
     }
 }
+
+QString Formatting::errorAsString(const GpgME::Error &error)
+{
+#if defined(Q_OS_WIN) && GPGMEPP_ERROR_ASSTRING_RETURNS_UTF8_ON_WINDOWS
+    return QString::fromUtf8(error.asString());
+#else
+    return QString::fromLocal8Bit(error.asString());
+#endif
+}
diff --git a/src/utils/formatting.h b/src/utils/formatting.h
index af4c7ead6..b081020f8 100644
--- a/src/utils/formatting.h
+++ b/src/utils/formatting.h
@@ -1,193 +1,199 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/formatting.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2021, 2022 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include "kleo_export.h"
 
 #include <QStringList>
 
 #include <gpgme++/key.h>
 
 class QString;
 class QDate;
 class QIcon;
 
 namespace GpgME
 {
+class Error;
 class Import;
 }
 
 namespace Kleo
 {
 class KeyGroup;
 
 namespace Formatting
 {
 
 KLEO_EXPORT QString prettyNameAndEMail(int proto, const char *id, const char *name, const char *email, const char *comment = nullptr);
 KLEO_EXPORT QString prettyNameAndEMail(int proto, const QString &id, const QString &name, const QString &email, const QString &comment = {});
 KLEO_EXPORT QString prettyNameAndEMail(const GpgME::Key &key);
 KLEO_EXPORT QString prettyNameAndEMail(const GpgME::UserID &key);
 
 KLEO_EXPORT QString prettyUserID(const GpgME::UserID &uid);
 KLEO_EXPORT QString prettyKeyID(const char *id);
 
 KLEO_EXPORT QString prettyName(int proto, const char *id, const char *name, const char *comment = nullptr);
 KLEO_EXPORT QString prettyName(const GpgME::Key &key);
 KLEO_EXPORT QString prettyName(const GpgME::UserID &uid);
 KLEO_EXPORT QString prettyName(const GpgME::UserID::Signature &sig);
 
 KLEO_EXPORT QString prettyEMail(const char *email, const char *id);
 KLEO_EXPORT QString prettyEMail(const GpgME::Key &key);
 KLEO_EXPORT QString prettyEMail(const GpgME::UserID &uid);
 KLEO_EXPORT QString prettyEMail(const GpgME::UserID::Signature &sig);
 
 /* Formats a fingerprint or keyid into groups of four */
 KLEO_EXPORT QString prettyID(const char *id);
 KLEO_EXPORT QString accessibleHexID(const char *id);
 
 // clang-format off
 enum ToolTipOption {
     KeyID            = 0x001,
     Validity         = 0x002,
     StorageLocation  = 0x004,
     SerialNumber     = 0x008,
     Issuer           = 0x010,
     Subject          = 0x020,
     ExpiryDates      = 0x040,
     CertificateType  = 0x080,
     CertificateUsage = 0x100,
     Fingerprint      = 0x200,
     UserIDs          = 0x400,
     OwnerTrust       = 0x800,
     Subkeys          = 0x1000,
 
     AllOptions       = 0xffff
 };
 // clang-format on
 
 KLEO_EXPORT QString toolTip(const GpgME::Key &key, int opts);
 KLEO_EXPORT QString toolTip(const Kleo::KeyGroup &group, int opts);
 
 /// Returns expiration date of @p key as string, or @p noExpiration if the key doesn't expire.
 KLEO_EXPORT QString expirationDateString(const GpgME::Key &key, const QString &noExpiration = {});
 /// Returns expiration date of @p subkey as string, or @p noExpiration if the subkey doesn't expire.
 KLEO_EXPORT QString expirationDateString(const GpgME::Subkey &subkey, const QString &noExpiration = {});
 /// Returns expiration date of @p sig as string, or @p noExpiration if the signature doesn't expire.
 KLEO_EXPORT QString expirationDateString(const GpgME::UserID::Signature &sig, const QString &noExpiration = {});
 KLEO_EXPORT QDate expirationDate(const GpgME::Key &key);
 KLEO_EXPORT QDate expirationDate(const GpgME::Subkey &subkey);
 KLEO_EXPORT QDate expirationDate(const GpgME::UserID::Signature &sig);
 /**
  * Returns expiration date of @p key as string suitable for screen readers.
  * If the key doesn't expire, then it returns @p noExpiration if @p noExpiration is not empty. Otherwise,
  * returns the localization of "unlimited".
  */
 KLEO_EXPORT QString accessibleExpirationDate(const GpgME::Key &key, const QString &noExpiration = {});
 /**
  * Returns expiration date of @p subkey as string suitable for screen readers.
  * If the subkey doesn't expire, then it returns @p noExpiration if @p noExpiration is not empty. Otherwise,
  * returns the localization of "unlimited".
  */
 KLEO_EXPORT QString accessibleExpirationDate(const GpgME::Subkey &subkey, const QString &noExpiration = {});
 /**
  * Returns expiration date of @p sig as string suitable for screen readers.
  * If the signature doesn't expire, then it returns @p noExpiration if @p noExpiration is not empty. Otherwise,
  * returns the localization of "unlimited".
  */
 KLEO_EXPORT QString accessibleExpirationDate(const GpgME::UserID::Signature &sig, const QString &noExpiration = {});
 
 KLEO_EXPORT QString creationDateString(const GpgME::Key &key);
 KLEO_EXPORT QString creationDateString(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString creationDateString(const GpgME::UserID::Signature &sig);
 KLEO_EXPORT QDate creationDate(const GpgME::Key &key);
 KLEO_EXPORT QDate creationDate(const GpgME::Subkey &subkey);
 KLEO_EXPORT QDate creationDate(const GpgME::UserID::Signature &sig);
 KLEO_EXPORT QString accessibleCreationDate(const GpgME::Key &key);
 KLEO_EXPORT QString accessibleCreationDate(const GpgME::Subkey &subkey);
 
 /* Convert a GPGME style time or a QDate to a localized string */
 KLEO_EXPORT QString dateString(time_t t);
 KLEO_EXPORT QString dateString(const QDate &date);
 KLEO_EXPORT QString accessibleDate(time_t t);
 KLEO_EXPORT QString accessibleDate(const QDate &date);
 
 KLEO_EXPORT QString displayName(GpgME::Protocol prot);
 KLEO_EXPORT QString type(const GpgME::Key &key);
 KLEO_EXPORT QString type(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString type(const Kleo::KeyGroup &group);
 
 KLEO_EXPORT QString ownerTrustShort(const GpgME::Key &key);
 KLEO_EXPORT QString ownerTrustShort(GpgME::Key::OwnerTrust trust);
 
 KLEO_EXPORT QString validityShort(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString validityShort(const GpgME::UserID &uid);
 KLEO_EXPORT QString validityShort(const GpgME::UserID::Signature &sig);
 KLEO_EXPORT QIcon validityIcon(const GpgME::UserID::Signature &sig);
 /* A sentence about the validity of the UserID */
 KLEO_EXPORT QString validity(const GpgME::UserID &uid);
 KLEO_EXPORT QString validity(const Kleo::KeyGroup &group);
 KLEO_EXPORT QIcon validityIcon(const Kleo::KeyGroup &group);
 
 KLEO_EXPORT QString formatForComboBox(const GpgME::Key &key);
 
 KLEO_EXPORT QString formatKeyLink(const GpgME::Key &key);
 
 KLEO_EXPORT QString signatureToString(const GpgME::Signature &sig, const GpgME::Key &key);
 
 KLEO_EXPORT const char *summaryToString(const GpgME::Signature::Summary summary);
 
 KLEO_EXPORT QString importMetaData(const GpgME::Import &import);
 KLEO_EXPORT QString importMetaData(const GpgME::Import &import, const QStringList &sources);
 
 KLEO_EXPORT QString formatOverview(const GpgME::Key &key);
 KLEO_EXPORT QString usageString(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString summaryLine(const GpgME::Key &key);
 KLEO_EXPORT QString summaryLine(const KeyGroup &group);
 
 KLEO_EXPORT QIcon iconForUid(const GpgME::UserID &uid);
 
 /* Is the key valid i.e. are all uids fully trusted?  */
 KLEO_EXPORT bool uidsHaveFullValidity(const GpgME::Key &key);
 
 /* The compliance mode of the gnupg system. Empty if compliance
  * mode is not set.
  * Use Kleo::gnupgComplianceMode() instead.
  */
 KLEO_DEPRECATED_EXPORT QString complianceMode();
 
 /* Is the given key in compliance with CO_DE_VS?  */
 KLEO_EXPORT bool isKeyDeVs(const GpgME::Key &key);
 
 /**
  * Use Kleo::DeVSCompliance::name(bool) instead.
  */
 KLEO_DEPRECATED_EXPORT QString deVsString(bool compliant = true);
 
 /* A sentence if the key confirms to the current compliance mode */
 KLEO_EXPORT QString complianceStringForKey(const GpgME::Key &key);
 
 /* A single word for use in keylists to describe the validity of the
  * given key, including any conformance statements relevant to the
  * current conformance mode.  */
 KLEO_EXPORT QString complianceStringShort(const GpgME::Key &key);
 KLEO_EXPORT QString complianceStringShort(const Kleo::KeyGroup &group);
 
 /* The origin of the key mapped to a localized string */
 KLEO_EXPORT QString origin(int o);
 
 /* Human-readable trust signature scope (for trust signature regexp created by GnuPG) */
 KLEO_EXPORT QString trustSignatureDomain(const GpgME::UserID::Signature &sig);
 /* Summary of trust signature properties */
 KLEO_EXPORT QString trustSignature(const GpgME::UserID::Signature &sig);
+
+/**
+ * Returns the value of Error::asString() for the error \p error as Unicode string.
+ */
+KLEO_EXPORT QString errorAsString(const GpgME::Error &error);
 }
 }
diff --git a/tests/test_jobs.cpp b/tests/test_jobs.cpp
index 061d52778..6ab68bf8a 100644
--- a/tests/test_jobs.cpp
+++ b/tests/test_jobs.cpp
@@ -1,82 +1,84 @@
 /*
     test_jobs.cpp
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
+#include <libkleo/formatting.h>
+
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/protocol.h>
 #include <qgpgme/signjob.h>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <gpgme++/signingresult.h>
 
 #include <KAboutData>
 #include <QDebug>
 
 #include <KLocalizedString>
 #include <QApplication>
 #include <QCommandLineParser>
 #include <memory>
 
 static const char *protocol = nullptr;
 
 static void testSign()
 {
     const QGpgME::Protocol *proto = !strcmp(protocol, "openpgp") ? QGpgME::openpgp() : QGpgME::smime();
     Q_ASSERT(proto);
 
     qDebug() << "Using protocol" << proto->name();
 
     std::vector<GpgME::Key> signingKeys;
 
     std::unique_ptr<QGpgME::KeyListJob> listJob(proto->keyListJob(false, false, true)); // use validating keylisting
     if (listJob.get()) {
         // ##### Adjust this to your own identity
         listJob->exec(QStringList(QStringLiteral("kloecker@kde.org")), true /*secret*/, signingKeys);
         Q_ASSERT(!signingKeys.empty());
     } else {
         Q_ASSERT(0); // job failed
     }
 
     QGpgME::SignJob *job = proto->signJob(true, true);
 
     QByteArray plainText = "Hallo Leute\n"; // like gpgme's t-sign.c
     qDebug() << "plainText=" << plainText;
 
     qDebug() << " signing with" << signingKeys[0].primaryFingerprint();
 
     QByteArray signature;
     const GpgME::SigningResult res = job->exec(signingKeys, plainText, GpgME::Clearsigned, signature);
     if (res.error().isCanceled()) {
         qDebug() << "signing was canceled by user";
         return;
     }
     if (res.error()) {
-        qDebug() << "signing failed:" << res.error().asString();
+        qDebug() << "signing failed:" << Kleo::Formatting::errorAsString(res.error());
         return;
     }
     qDebug() << "signing resulted in signature=" << signature;
 }
 
 int main(int argc, char **argv)
 {
     protocol = "openpgp";
     if (argc == 2) {
         protocol = argv[1];
         argc = 1; // hide from KDE
     }
     QApplication app(argc, argv);
     KAboutData aboutData(QStringLiteral("test_jobs"), i18n("Signing Job Test"), QStringLiteral("0.1"));
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     testSign();
 }
diff --git a/tests/test_keygen.cpp b/tests/test_keygen.cpp
index 2cffcc330..0cd78be2e 100644
--- a/tests/test_keygen.cpp
+++ b/tests/test_keygen.cpp
@@ -1,171 +1,172 @@
 /*
     test_keygen.cpp
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 #include "test_keygen.h"
 
-#include <ui/progressdialog.h>
+#include <libkleo/formatting.h>
+#include <libkleo/progressdialog.h>
 
 #include <qgpgme/keygenerationjob.h>
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/protocol.h>
 
 #include <gpgme++/keygenerationresult.h>
 
 #include <KAboutData>
 
 #include <KMessageBox>
 #include <QDebug>
 
 #include <QGridLayout>
 #include <QLabel>
 #include <QLineEdit>
 
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 static const char *const keyParams[] = {
     "Key-Type",
     "Key-Length",
     "Subkey-Type",
     "Subkey-Length",
     "Name-Real",
     "Name-Comment",
     "Name-Email",
     "Name-DN",
     "Expire-Date",
     "Passphrase",
 };
 static const int numKeyParams = sizeof keyParams / sizeof *keyParams;
 
 static const char *protocol = nullptr;
 
 KeyGenerator::KeyGenerator(QWidget *parent)
     : QDialog(parent)
 {
     setModal(true);
     setWindowTitle(QStringLiteral("KeyGenerationJob test"));
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     QWidget *mainWidget = new QWidget(this);
     auto mainLayout = new QVBoxLayout(this);
     mainLayout->addWidget(mainWidget);
     auto user1Button = new QPushButton;
     buttonBox->addButton(user1Button, QDialogButtonBox::ActionRole);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KeyGenerator::reject);
     user1Button->setDefault(true);
     KGuiItem::assign(user1Button, KGuiItem(QStringLiteral("Create")));
 
     QWidget *w = new QWidget(this);
     mainLayout->addWidget(w);
     mainLayout->addWidget(buttonBox);
 
     auto glay = new QGridLayout(w);
 
     int row = -1;
 
     ++row;
     glay->addWidget(new QLabel(QStringLiteral("<GnupgKeyParms format=\"internal\">"), w), row, 0, 1, 2);
     for (int i = 0; i < numKeyParams; ++i) {
         ++row;
         glay->addWidget(new QLabel(QString::fromLatin1(keyParams[i]), w), row, 0);
         glay->addWidget(mLineEdits[i] = new QLineEdit(w), row, 1);
     }
 
     ++row;
     glay->addWidget(new QLabel(QStringLiteral("</GnupgKeyParms>"), w), row, 0, 1, 2);
     ++row;
     glay->setRowStretch(row, 1);
     glay->setColumnStretch(1, 1);
 
     connect(user1Button, &QPushButton::clicked, this, &KeyGenerator::slotStartKeyGeneration);
 }
 
 KeyGenerator::~KeyGenerator()
 {
 }
 
 void KeyGenerator::slotStartKeyGeneration()
 {
     QString params = QStringLiteral("<GnupgKeyParms format=\"internal\">\n");
     for (int i = 0; i < numKeyParams; ++i) {
         if (mLineEdits[i] && !mLineEdits[i]->text().trimmed().isEmpty()) {
             params += QString::fromLatin1(keyParams[i]) + (QStringLiteral(": ") + mLineEdits[i]->text().trimmed()) + QLatin1Char('\n');
         }
     }
     params += QStringLiteral("</GnupgKeyParms>\n");
 
     const QGpgME::Protocol *proto = nullptr;
     if (protocol) {
         proto = !strcmp(protocol, "openpgp") ? QGpgME::openpgp() : QGpgME::smime();
     }
     if (!proto) {
         proto = QGpgME::smime();
     }
     Q_ASSERT(proto);
 
     qDebug() << "Using protocol" << proto->name();
 
     QGpgME::KeyGenerationJob *job = proto->keyGenerationJob();
     Q_ASSERT(job);
 
     connect(job, &QGpgME::KeyGenerationJob::result, this, &KeyGenerator::slotResult);
 
     const GpgME::Error err = job->start(params);
     if (err) {
         showError(err);
     }
 #ifndef LIBKLEO_NO_PROGRESSDIALOG
     else {
         (void)new Kleo::ProgressDialog(job, QStringLiteral("Generating key"), this);
     }
 #endif
 }
 
 void KeyGenerator::showError(const GpgME::Error &err)
 {
     KMessageBox::error(this,
-                       QStringLiteral("Could not start key generation: %1").arg(QString::fromLocal8Bit(err.asString())),
+                       QStringLiteral("Could not start key generation: %1").arg(Kleo::Formatting::errorAsString(err)),
                        QStringLiteral("Key Generation Error"));
 }
 
 void KeyGenerator::slotResult(const GpgME::KeyGenerationResult &res, const QByteArray &keyData)
 {
     if (res.error()) {
         showError(res.error());
     } else {
         KMessageBox::information(this,
                                  QStringLiteral("Key generated successfully, %1 bytes long").arg(keyData.size()),
                                  QStringLiteral("Key Generation Finished"));
     }
 }
 
 int main(int argc, char **argv)
 {
     if (argc == 2) {
         protocol = argv[1];
         argc = 1; // hide from KDE
     }
     QApplication app(argc, argv);
     KAboutData aboutData(QStringLiteral("test_keygen"), i18n("KeyGenerationJob Test"), QStringLiteral("0.1"));
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     auto keygen = new KeyGenerator(nullptr);
     keygen->setObjectName(QStringLiteral("KeyGenerator top-level"));
     keygen->show();
 
     return app.exec();
 }
diff --git a/tests/test_keylister.cpp b/tests/test_keylister.cpp
index e2d7e1a7a..bbb6ff0f1 100644
--- a/tests/test_keylister.cpp
+++ b/tests/test_keylister.cpp
@@ -1,160 +1,162 @@
 /*
     test_keylister.cpp
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 #include "test_keylister.h"
 
+#include <libkleo/formatting.h>
+
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/protocol.h>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <KAboutData>
 
 #include <QDebug>
 
 #include <QMessageBox>
 #include <QStringList>
 #include <QTimer>
 
 #include <KLocalizedString>
 #include <QApplication>
 #include <QCommandLineParser>
 #include <chrono>
 
 using namespace std::chrono_literals;
 
 namespace
 {
 class TestColumnStrategy : public Kleo::KeyListView::ColumnStrategy
 {
 public:
     ~TestColumnStrategy() override
     {
     }
     QString title(int col) const override;
     QString toolTip(const GpgME::Key &key, int col) const override;
     QString text(const GpgME::Key &key, int col) const override;
     QString accessibleText(const GpgME::Key &key, int col) const override;
 };
 
 QString TestColumnStrategy::title(int col) const
 {
     switch (col) {
     case 0:
         return QStringLiteral("Subject");
     case 1:
         return QStringLiteral("EMail");
     case 2:
         return QStringLiteral("Issuer");
     case 3:
         return QStringLiteral("Serial");
     case 4:
         return QStringLiteral("Protocol");
     case 5:
         return QStringLiteral("Validity");
     default:
         return QString();
     }
 }
 
 QString TestColumnStrategy::toolTip(const GpgME::Key &key, int) const
 {
     return QStringLiteral("Fingerprint: ") + QString::fromUtf8(key.primaryFingerprint());
 }
 
 QString TestColumnStrategy::text(const GpgME::Key &key, int col) const
 {
     if (key.isNull()) {
         return QStringLiteral("<null>");
     }
     switch (col) {
     case 0:
         return QString::fromUtf8(key.userID(0).id());
     case 1:
         return QString::fromUtf8(key.userID(0).email());
     case 2:
         return QString::fromUtf8(key.issuerName());
     case 3:
         return QString::fromLatin1(key.issuerSerial());
     case 4:
         return QString::fromLatin1(key.protocolAsString());
     case 5:
         return QString(QLatin1Char(key.userID(0).validityAsString()));
     default:
         return QString();
     }
 }
 
 QString TestColumnStrategy::accessibleText(const GpgME::Key &, int) const
 {
     return {};
 }
 }
 
 CertListView::CertListView(QWidget *parent, Qt::WindowFlags f)
     : Kleo::KeyListView(new TestColumnStrategy(), nullptr, parent, f)
 {
     setHierarchical(true);
     setRootIsDecorated(true);
 }
 
 CertListView::~CertListView()
 {
 }
 
 void CertListView::slotResult(const GpgME::KeyListResult &result)
 {
     qDebug() << "CertListView::slotResult()";
     if (result.isNull()) {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("KeyListResult is null!"));
     } else if (result.error()) {
         QMessageBox::critical(this,
                               QStringLiteral("Key Listing Result"),
-                              QStringLiteral("KeyListResult Error: %1").arg(QString::fromLatin1(result.error().asString())));
+                              QStringLiteral("KeyListResult Error: %1").arg(Kleo::Formatting::errorAsString(result.error())));
     } else if (result.isTruncated()) {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("KeyListResult is truncated!"));
     } else {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("Key listing successful"));
     }
 }
 
 void CertListView::slotStart()
 {
     qDebug() << "CertListView::slotStart()";
     QGpgME::KeyListJob *job = QGpgME::smime()->keyListJob(false);
     Q_ASSERT(job);
     QObject::connect(job, &QGpgME::KeyListJob::nextKey, this, &CertListView::slotAddKey);
     QObject::connect(job, &QGpgME::KeyListJob::result, this, &CertListView::slotResult);
 #if 0
     QStringList l;
     l << "Marc";
     job->start(l, false);
 #else
     job->start(QStringList(), false);
 #endif
 }
 
 int main(int argc, char **argv)
 {
     QApplication app(argc, argv);
     KAboutData aboutData(QStringLiteral("test_keylister"), i18n("KeyLister Test"), QStringLiteral("0.1"));
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     auto clv = new CertListView;
     clv->show();
 
     QTimer::singleShot(5s, clv, &CertListView::slotStart);
 
     return app.exec();
 }