diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5fe4d2ea1..0f947a759 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,269 +1,270 @@
 # SPDX-FileCopyrightText: none
 # SPDX-License-Identifier: BSD-3-Clause
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 set(RELEASE_SERVICE_VERSION_MAJOR "23")
 set(RELEASE_SERVICE_VERSION_MINOR "03")
 set(RELEASE_SERVICE_VERSION_MICRO "70")
 
 # The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
 if (NOT RELEASE_SERVICE_VERSION)
     set(RELEASE_SERVICE_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}.${RELEASE_SERVICE_VERSION_MINOR}.${RELEASE_SERVICE_VERSION_MICRO}")
 endif()
 if(RELEASE_SERVICE_VERSION_MICRO LESS 10)
     set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}0${RELEASE_SERVICE_VERSION_MICRO}")
 else()
     set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}${RELEASE_SERVICE_VERSION_MICRO}")
 endif()
 
 set(KLEOPATRA_VERSION_MAJOR "3")
 set(KLEOPATRA_VERSION_MINOR "1")
 set(KLEOPATRA_VERSION_MICRO "26")
 
 set(kleopatra_version "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}.${KDE_APPLICATIONS_COMPACT_VERSION}")
 # The following is for Windows
 set(kleopatra_version_win "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}")
 set(kleopatra_fileversion_win "${KLEOPATRA_VERSION_MAJOR},${KLEOPATRA_VERSION_MINOR},${KLEOPATRA_VERSION_MICRO},0")
 if (NOT KLEOPATRA_DISTRIBUTION_TEXT)
     # This is only used on Windows for the file attributes of Kleopatra
     set(KLEOPATRA_DISTRIBUTION_TEXT "KDE")
 endif()
 
 project(kleopatra VERSION ${kleopatra_version})
 
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF_MIN_VERSION "5.103.0")
 set(KIDENTITYMANAGEMENT_VERSION "5.22.40")
 set(KMAILTRANSPORT_VERSION "5.22.40")
 set(KMIME_VERSION "5.22.40")
 set(LIBKLEO_VERSION "5.22.45")
 set(QT_REQUIRED_VERSION "5.15.2")
 if (QT_MAJOR_VERSION STREQUAL "6")
     set(QT_REQUIRED_VERSION "6.4.0")
 endif()
 set(GPGME_REQUIRED_VERSION "1.16.0")
 set(LIBASSUAN_REQUIRED_VERSION "2.4.2")
 set(GPG_ERROR_REQUIRED_VERSION "1.36")
 
 if (WIN32)
   set(KF5_WANT_VERSION "5.70.0")
   set(KMIME_WANT_VERSION "5.12.0")
 else ()
   set(KF5_WANT_VERSION ${KF_MIN_VERSION})
   set(KMIME_WANT_VERSION ${KMIME_VERSION})
 endif ()
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 find_package(ECM ${KF5_WANT_VERSION} CONFIG REQUIRED)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 
 include(ECMInstallIcons)
 include(ECMSetupVersion)
 include(ECMAddTests)
 include(GenerateExportHeader)
 include(ECMGenerateHeaders)
 include(FeatureSummary)
 include(CheckFunctionExists)
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 include(ECMDeprecationSettings)
 include(KDEClangFormat)
 
 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_MIN_VERSION "5.100.0")
     set(KF_MAJOR_VERSION "5")
 endif()
 
 # Find KF5 packages
 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}CoreAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}Codecs ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}Config ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}I18n ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}IconThemes ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}ItemModels ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}XmlGui ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}WindowSystem ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF${KF_MAJOR_VERSION}DocTools ${KF5_WANT_VERSION} CONFIG)
 find_package(KF${KF_MAJOR_VERSION}Crash ${KF5_WANT_VERSION} REQUIRED)
 
 set_package_properties(KF${KF_MAJOR_VERSION}DocTools PROPERTIES
     DESCRIPTION "Documentation tools"
     PURPOSE "Required to generate Kleopatra documentation."
     TYPE OPTIONAL)
 
 # Optional packages
 if (WIN32)
   # Only a replacement available for Windows so this
   # is required on other platforms.
   find_package(KF${KF_MAJOR_VERSION}DBusAddons ${KF5_WANT_VERSION} CONFIG)
   set_package_properties(KF5DBusAddons PROPERTIES DESCRIPTION "Support library to work with DBus"
                          PURPOSE "DBus session integration"
                          URL "https://inqlude.org/libraries/kdbusaddons.html"
                          TYPE OPTIONAL)
 else()
   find_package(KF${KF_MAJOR_VERSION}DBusAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
   set(_kleopatra_dbusaddons_libs KF${KF_MAJOR_VERSION}::DBusAddons)
 endif()
 
 set(HAVE_QDBUS ${Qt${QT_MAJOR_VERSION}DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 if (Gpgmepp_VERSION VERSION_GREATER_EQUAL "1.19.0")
     set(GPGMEPP_SUPPORTS_SET_CURVE 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()
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.17.0")
     set(QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY 1)
     set(QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE 1)
     set(QGPGME_SUPPORTS_WKDLOOKUP 1)
     set(QGPGME_SUPPORTS_IMPORT_WITH_FILTER 1)
     set(QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN 1)
     set(QGPGME_SUPPORTS_SECRET_KEY_EXPORT 1)
     set(QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT 1)
     set(QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID 1)
 endif()
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.18.0")
     set(QGPGME_SUPPORTS_KEY_REVOCATION 1)
     set(QGPGME_SUPPORTS_KEY_REFRESH 1)
     set(QGPGME_SUPPORTS_SET_FILENAME 1)
     set(QGPGME_SUPPORTS_SET_PRIMARY_UID 1)
 endif()
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.19.0")
     set(QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB 1)
     set(QGPGME_SUPPORTS_ARCHIVE_JOBS 1)
+    set(QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS 1)
 endif()
 
 # Kdepimlibs packages
 find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KF5Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5IdentityManagement ${KIDENTITYMANAGEMENT_VERSION} CONFIG)
 find_package(KF5MailTransport ${KMAILTRANSPORT_VERSION} CONFIG)
 find_package(KF5MailTransportAkonadi ${KMAILTRANSPORT_VERSION} CONFIG)
 
 find_package(Qt${QT_MAJOR_VERSION} ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)
 
 find_package(LibAssuan ${LIBASSUAN_REQUIRED_VERSION} REQUIRED)
 set_package_properties(LibAssuan PROPERTIES
   TYPE REQUIRED
   PURPOSE "Needed for Kleopatra to act as the GnuPG UI Server"
 )
 find_package(LibGpgError ${GPG_ERROR_REQUIRED_VERSION} REQUIRED)
 set_package_properties(LibGpgError PROPERTIES
   TYPE REQUIRED
 )
 
 set(kleopatra_release FALSE)
 
 if(NOT kleopatra_release)
     find_package(Git)
     if(GIT_FOUND)
         execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse
                         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                         RESULT_VARIABLE rc
                         ERROR_QUIET)
         if(rc EQUAL 0)
             execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
                 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                 OUTPUT_VARIABLE Kleopatra_WC_REVISION)
             string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")
 
             execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%cI ${CMAKE_CURRENT_SOURCE_DIR}
                 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                 OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
             string(REGEX REPLACE "^([0-9]+)-([0-9]+)-([0-9]+)T([0-9]+):([0-9]+):([0-9]+).*$" "\\1\\2\\3T\\4\\5\\6"
                    Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")
 
             set(kleopatra_version "${kleopatra_version}+git${Kleopatra_WC_LAST_CHANGED_DATE}~${Kleopatra_WC_REVISION}")
         endif()
     endif()
 endif()
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
 
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
 if (WIN32)
 # On Windows, we need to use stuff deprecated since Qt 5.11, e.g. from QDesktopWidget
 ecm_set_disabled_deprecation_versions(QT 5.10.0  KF 5.103.0)
 else ()
 ecm_set_disabled_deprecation_versions(QT 6.4  KF 5.103.0)
 endif ()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
 endif()
 if(MINGW)
     # we do not care about different signedness of passed pointer arguments
     add_compile_options($<$<COMPILE_LANGUAGE:C>:-Wno-pointer-sign>)
 endif()
 
 add_definitions(-DQT_NO_EMIT)
 remove_definitions(-DQT_NO_FOREACH)
 
 # Disable the use of QStringBuilder for operator+ to prevent crashes when
 # returning the result of concatenating string temporaries in lambdas. We do
 # this for example in some std::transform expressions.
 # This is a known issue: https://bugreports.qt.io/browse/QTBUG-47066
 # Alternatively, one would always have to remember to force the lambdas to
 # return a QString instead of QStringBuilder, but that's just too easy to
 # forget and, unfortunately, the compiler doesn't issue a warning if one forgets
 # this. So, it's just too dangerous.
 # One can still use QStringBuilder explicitly with the operator% if necessary.
 remove_definitions(-DQT_USE_FAST_OPERATOR_PLUS)
 remove_definitions(-DQT_USE_QSTRINGBUILDER)
 
 kde_enable_exceptions()
 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(pics)
 add_subdirectory(src)
 
 if(BUILD_TESTING)
     add_subdirectory(tests)
     add_subdirectory(autotests)
 endif()
 
 ecm_qt_install_logging_categories(
         EXPORT KLEOPATRA
         FILE kleopatra.categories
         DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
         )
 
 ki18n_install(po)
 if(KF${KF_MAJOR_VERSION}DocTools_FOUND)
     kdoctools_install(po)
     add_subdirectory(doc)
 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})
diff --git a/config-kleopatra.h.cmake b/config-kleopatra.h.cmake
index b51b0e8f9..b0e93a71e 100644
--- a/config-kleopatra.h.cmake
+++ b/config-kleopatra.h.cmake
@@ -1,47 +1,50 @@
 /* DBus available */
 #cmakedefine01 HAVE_QDBUS
 
 /* Whether QGpgME supports changing the expiration date of the primary key and the subkeys simultaneously */
 #cmakedefine01 QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
 
 /* Whether QGpgME supports retrieving the default value of a config entry */
 #cmakedefine01 QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE
 
 /* Whether QGpgME supports WKD lookup */
 #cmakedefine01 QGPGME_SUPPORTS_WKDLOOKUP
 
 /* Whether QGpgME supports specifying an import filter when importing keys */
 #cmakedefine01 QGPGME_SUPPORTS_IMPORT_WITH_FILTER
 
 /* Whether QGpgME supports setting key origin when importing keys */
 #cmakedefine01 QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN
 
 /* Whether QGpgME supports the export of secret keys */
 #cmakedefine01 QGPGME_SUPPORTS_SECRET_KEY_EXPORT
 
 /* Whether QGpgME supports the export of secret subkeys */
 #cmakedefine01 QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
 
 /* Whether QGpgME supports receiving keys by their key ids */
 #cmakedefine01 QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
 
 /* Whether QGpgME supports revoking own OpenPGP keys */
 #cmakedefine01 QGPGME_SUPPORTS_KEY_REVOCATION
 
 /* Whether QGpgME supports refreshing keys */
 #cmakedefine01 QGPGME_SUPPORTS_KEY_REFRESH
 
 /* Whether QGpgME supports setting the file name of encrypted data */
 #cmakedefine01 QGPGME_SUPPORTS_SET_FILENAME
 
 /* Whether QGpgME supports setting the primary user id of a key */
 #cmakedefine01 QGPGME_SUPPORTS_SET_PRIMARY_UID
 
 /* Whether GpgME++ supports setting the curve when generating ECC card keys */
 #cmakedefine01 GPGMEPP_SUPPORTS_SET_CURVE
 
 /* Whether QGpgME supports deferred start of ImportJob */
 #cmakedefine01 QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
 
 /* Whether QGpgME supports the sign/encrypt/decrypt/verify archive jobs */
 #cmakedefine01 QGPGME_SUPPORTS_ARCHIVE_JOBS
+
+/* Whether QGpgME::Job provides the new progress signals */
+#cmakedefine01 QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
diff --git a/src/commands/adduseridcommand.cpp b/src/commands/adduseridcommand.cpp
index 97303d9df..68086a3bf 100644
--- a/src/commands/adduseridcommand.cpp
+++ b/src/commands/adduseridcommand.cpp
@@ -1,214 +1,219 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/adduseridcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     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-kleopatra.h>
 
 #include "adduseridcommand.h"
 
 #include "command_p.h"
 
 #include "dialogs/adduseriddialog.h"
 
 #include <Libkleo/Formatting>
 #include <QGpgME/Protocol>
 #include <QGpgME/QuickJob>
 
 #include <QObjectCleanupHandler>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 class AddUserIDCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::AddUserIDCommand;
     AddUserIDCommand *q_func() const
     {
         return static_cast<AddUserIDCommand *>(q);
     }
 public:
     explicit Private(AddUserIDCommand *qq, KeyListController *c);
     ~Private() override;
 
 private:
     void slotDialogAccepted();
     void slotDialogRejected();
     void slotResult(const Error &err);
 
 private:
     void ensureDialogCreated();
     void createJob();
     void showErrorDialog(const Error &error);
     void showSuccessDialog();
 
 private:
     GpgME::Key key;
     QObjectCleanupHandler cleaner;
     QPointer<AddUserIDDialog> dialog;
     QPointer<QGpgME::QuickJob> job;
 };
 
 AddUserIDCommand::Private *AddUserIDCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const AddUserIDCommand::Private *AddUserIDCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 AddUserIDCommand::Private::Private(AddUserIDCommand *qq, KeyListController *c)
     : Command::Private{qq, c}
 {
 }
 
 AddUserIDCommand::Private::~Private() = default;
 
 AddUserIDCommand::AddUserIDCommand(QAbstractItemView *v, KeyListController *c)
     : Command{v, new Private{this, c}}
 {
 }
 
 AddUserIDCommand::AddUserIDCommand(const GpgME::Key &key)
     : Command{key, new Private{this, nullptr}}
 {
 }
 
 AddUserIDCommand::~AddUserIDCommand()
 {
     qCDebug(KLEOPATRA_LOG).nospace() << this << "::" << __func__;
 }
 
 void AddUserIDCommand::doStart()
 {
     const std::vector<Key> keys = d->keys();
     if (keys.size() != 1) {
         d->finished();
         return;
     }
 
     d->key = keys.front();
     if (d->key.protocol() != GpgME::OpenPGP
         || !d->key.hasSecret()) {
         d->finished();
         return;
     }
 
     d->ensureDialogCreated();
 
     const UserID uid = d->key.userID(0);
 
     d->dialog->setName(QString::fromUtf8(uid.name()));
     d->dialog->setEmail(Formatting::prettyEMail(uid.email(), uid.id()));
 
     d->dialog->show();
 }
 
 void AddUserIDCommand::Private::slotDialogAccepted()
 {
     Q_ASSERT(dialog);
 
     createJob();
     if (!job) {
         finished();
         return;
     }
     job->startAddUid(key, dialog->userID());
 }
 
 void AddUserIDCommand::Private::slotDialogRejected()
 {
     Q_EMIT q->canceled();
     finished();
 }
 
 void AddUserIDCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled()) {
     } else if (err) {
         showErrorDialog(err);
     } else {
         showSuccessDialog();
     }
     finished();
 }
 
 void AddUserIDCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG).nospace() << this << "::" << __func__;
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 void AddUserIDCommand::Private::ensureDialogCreated()
 {
     if (dialog) {
         return;
     }
 
     dialog = new AddUserIDDialog;
     cleaner.add(dialog);
     applyWindowID(dialog);
 
     connect(dialog, &QDialog::accepted, q, [this]() { slotDialogAccepted(); });
     connect(dialog, &QDialog::rejected, q, [this]() { slotDialogRejected(); });
 }
 
 void AddUserIDCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     const auto backend = QGpgME::openpgp();
     if (!backend) {
         return;
     }
 
     const auto j = backend->quickJob();
     if (!j) {
         return;
     }
 
-    connect(j, &QGpgME::Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(j, &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(j, &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
     connect(j, &QGpgME::QuickJob::result,
             q, [this](const GpgME::Error &err) { slotResult(err); });
 
     job = j;
 }
 
 void AddUserIDCommand::Private::showErrorDialog(const Error &err)
 {
     error(xi18nc("@info",
                  "<para>An error occurred while trying to add the user ID: "
                  "<message>%1</message></para>",
                  QString::fromLocal8Bit(err.asString())),
           i18nc("@title:window", "Add User ID Error"));
 }
 
 void AddUserIDCommand::Private::showSuccessDialog()
 {
     information(i18nc("@info", "User ID successfully added."),
                 i18nc("@title:window", "Add User ID Succeeded"));
 }
 
 #undef d
 #undef q
 
 #include "moc_adduseridcommand.cpp"
diff --git a/src/commands/certifycertificatecommand.cpp b/src/commands/certifycertificatecommand.cpp
index 3d8a5b8d6..0af9f0fb7 100644
--- a/src/commands/certifycertificatecommand.cpp
+++ b/src/commands/certifycertificatecommand.cpp
@@ -1,341 +1,346 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/signcertificatecommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2019 g10code GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "certifycertificatecommand.h"
 #include "newopenpgpcertificatecommand.h"
 
 #include "command_p.h"
 
 #include "exportopenpgpcertstoservercommand.h"
 #include "dialogs/certifycertificatedialog.h"
 #include "utils/keys.h"
 #include "utils/tags.h"
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignKeyJob>
 
 #include <QDate>
 #include <QEventLoop>
 
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 using namespace QGpgME;
 
 class CertifyCertificateCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::CertifyCertificateCommand;
     CertifyCertificateCommand *q_func() const
     {
         return static_cast<CertifyCertificateCommand *>(q);
     }
 public:
     explicit Private(CertifyCertificateCommand *qq, KeyListController *c);
     ~Private() override;
 
     void init();
 
 private:
     void slotDialogRejected();
     void slotResult(const Error &err);
     void slotCertificationPrepared();
 
 private:
     void ensureDialogCreated();
     void createJob();
 
 private:
     GpgME::Key target;
     std::vector<UserID> uids;
     QPointer<CertifyCertificateDialog> dialog;
     QPointer<QGpgME::SignKeyJob> job;
 };
 
 CertifyCertificateCommand::Private *CertifyCertificateCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const CertifyCertificateCommand::Private *CertifyCertificateCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 CertifyCertificateCommand::Private::Private(CertifyCertificateCommand *qq, KeyListController *c)
     : Command::Private(qq, c),
       uids(),
       dialog(),
       job()
 {
 }
 
 CertifyCertificateCommand::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
     if (dialog) {
         delete dialog;
         dialog = nullptr;
     }
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(KeyListController *c)
     : Command(new Private(this, c))
 {
     d->init();
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(QAbstractItemView *v, KeyListController *c)
     : Command(v, new Private(this, c))
 {
     d->init();
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(const GpgME::Key &key)
     : Command(key, new Private(this, nullptr))
 {
     d->init();
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(const GpgME::UserID &uid)
     : Command(uid.parent(), new Private(this, nullptr))
 {
     std::vector<UserID>(1, uid).swap(d->uids);
     d->init();
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(const std::vector<GpgME::UserID> &uids)
     : Command(uids.empty() ? Key() : uids.front().parent(), new Private(this, nullptr))
 {
     d->uids = uids;
     d->init();
 }
 
 void CertifyCertificateCommand::Private::init()
 {
 }
 
 CertifyCertificateCommand::~CertifyCertificateCommand()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void CertifyCertificateCommand::doStart()
 {
     const std::vector<Key> keys = d->keys();
     if (keys.size() != 1 ||
             keys.front().protocol() != GpgME::OpenPGP) {
         d->finished();
         return;
     }
     // hold on to the key to certify to avoid invalidation during refreshes of the key cache
     d->target = keys.front();
 
     if (d->target.isExpired() || d->target.isRevoked()) {
         const auto title = d->target.isRevoked() ? i18nc("@title:window", "Key is Revoked") : i18nc("@title:window", "Key is Expired");
         const auto message = d->target.isRevoked() //
             ? i18nc("@info", "This key has been revoked. You cannot certify it.")
             : i18nc("@info", "This key has expired. You cannot certify it.");
         d->information(message, title);
         d->finished();
         return;
     }
 
     auto findAnyGoodKey = []() {
         const std::vector<Key> secKeys = KeyCache::instance()->secretKeys();
         return std::any_of(secKeys.cbegin(), secKeys.cend(), [](const Key &secKey) {
             return secKey.canCertify() && secKey.protocol() == OpenPGP && !secKey.isRevoked()
                    && !secKey.isExpired() && !secKey.isInvalid();
         });
     };
 
     if (!findAnyGoodKey()) {
         auto sel =
             KMessageBox::questionTwoActions(d->parentWidgetOrView(),
                                             xi18nc("@info", "To certify other certificates, you first need to create an OpenPGP certificate for yourself.")
                                                 + QStringLiteral("<br><br>") + i18n("Do you wish to create one now?"),
                                             i18n("Certification Not Possible"),
                                             KGuiItem(i18n("Create")),
                                             KStandardGuiItem::cancel());
         if (sel == KMessageBox::ButtonCode::PrimaryAction) {
             QEventLoop loop;
             auto cmd = new NewOpenPGPCertificateCommand;
             cmd->setParentWidget(d->parentWidgetOrView());
             connect(cmd, &Command::finished, &loop, &QEventLoop::quit);
             QMetaObject::invokeMethod(cmd, &NewOpenPGPCertificateCommand::start, Qt::QueuedConnection);
             loop.exec();
         } else {
             Q_EMIT(canceled());
             d->finished();
             return;
         }
 
         // Check again for secret keys
         if (!findAnyGoodKey()) {
             qCDebug(KLEOPATRA_LOG) << "Sec Keys still empty after keygen.";
             Q_EMIT(canceled());
             d->finished();
             return;
         }
     }
 
     const char *primary = keys.front().primaryFingerprint();
     const bool anyMismatch = std::any_of(d->uids.cbegin(), d->uids.cend(), [primary](const UserID &uid) {
         return qstricmp(uid.parent().primaryFingerprint(), primary) != 0;
     });
     if (anyMismatch) {
         qCWarning(KLEOPATRA_LOG) << "User ID <-> Key mismatch!";
         d->finished();
         return;
     }
 
     d->ensureDialogCreated();
     Q_ASSERT(d->dialog);
 
     if (!(d->target.keyListMode() & GpgME::SignatureNotations)) {
         d->target.update();
     }
     d->dialog->setCertificateToCertify(d->target);
     if (d->uids.size()) {
         d->dialog->setSelectedUserIDs(d->uids);
     }
     d->dialog->show();
 }
 
 void CertifyCertificateCommand::Private::slotDialogRejected()
 {
     Q_EMIT q->canceled();
     finished();
 }
 
 void CertifyCertificateCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled()) {
         // do nothing
     } else if (err) {
         error(i18n("<p>An error occurred while trying to certify<br/><br/>"
                    "<b>%1</b>:</p><p>\t%2</p>",
               Formatting::formatForComboBox(target),
               QString::fromUtf8(err.asString())),
               i18n("Certification Error"));
     } else if (dialog && dialog->exportableCertificationSelected() && dialog->sendToServer()) {
         auto const cmd = new ExportOpenPGPCertsToServerCommand(target);
         cmd->start();
     } else {
         information(i18n("Certification successful."),
                     i18n("Certification Succeeded"));
     }
 
     if (!dialog->tags().isEmpty()) {
         Tags::enableTags();
     }
     finished();
 }
 
 void CertifyCertificateCommand::Private::slotCertificationPrepared()
 {
     Q_ASSERT(dialog);
 
     const auto selectedUserIds = dialog->selectedUserIDs();
     std::vector<unsigned int> userIdIndexes;
     userIdIndexes.reserve(selectedUserIds.size());
     for (unsigned int i = 0, numUserIds = target.numUserIDs(); i < numUserIds; ++i) {
         const auto userId = target.userID(i);
         const bool userIdIsSelected = Kleo::any_of(selectedUserIds, [userId](const auto &uid) {
             return Kleo::userIDsAreEqual(userId, uid);
         });
         if (userIdIsSelected) {
             userIdIndexes.push_back(i);
         }
     }
 
     createJob();
     Q_ASSERT(job);
     job->setExportable(dialog->exportableCertificationSelected());
     job->setNonRevocable(dialog->nonRevocableCertificationSelected());
     job->setUserIDsToSign(userIdIndexes);
     job->setSigningKey(dialog->selectedSecretKey());
     if (!dialog->tags().isEmpty()) {
         // do not set an empty remark to avoid an empty signature notation (GnuPG bug T5142)
         job->setRemark(dialog->tags());
     }
     job->setDupeOk(true);
     if (dialog->trustSignatureSelected() && !dialog->trustSignatureDomain().isEmpty()) {
         // always create level 1 trust signatures with complete trust
         job->setTrustSignature(TrustSignatureTrust::Complete, 1, dialog->trustSignatureDomain());
     }
     if (!dialog->expirationDate().isNull()) {
         job->setExpirationDate(dialog->expirationDate());
     }
 
     if (const Error err = job->start(target)) {
         slotResult(err);
     }
 }
 
 void CertifyCertificateCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG);
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 void CertifyCertificateCommand::Private::ensureDialogCreated()
 {
     if (dialog) {
         return;
     }
 
     dialog = new CertifyCertificateDialog;
     applyWindowID(dialog);
 
     connect(dialog, &QDialog::rejected, q, [this]() { slotDialogRejected(); });
     connect(dialog, &QDialog::accepted, q, [this]() { slotCertificationPrepared(); });
 }
 
 void CertifyCertificateCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     Q_ASSERT(target.protocol() == OpenPGP);
     const auto backend = QGpgME::openpgp();
     if (!backend) {
         return;
     }
 
     SignKeyJob *const j = backend->signKeyJob();
     if (!j) {
         return;
     }
 
-    connect(j, &Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(j, &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(j, &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
     connect(j, &SignKeyJob::result, q, [this](const GpgME::Error &result) { slotResult(result); });
 
     job = j;
 }
 
 #undef d
 #undef q
 
 #include "moc_certifycertificatecommand.cpp"
diff --git a/src/commands/changeexpirycommand.cpp b/src/commands/changeexpirycommand.cpp
index c67c7ead3..c9f47c499 100644
--- a/src/commands/changeexpirycommand.cpp
+++ b/src/commands/changeexpirycommand.cpp
@@ -1,287 +1,292 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/changeexpirycommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "changeexpirycommand.h"
 #include "command_p.h"
 
 #include "dialogs/expirydialog.h"
 
 #include <Libkleo/Formatting>
 
 #include <KLocalizedString>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/ChangeExpiryJob>
 
 #include <QDateTime>
 
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 using namespace QGpgME;
 
 namespace
 {
 #if QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
 bool allNotRevokedSubkeysHaveSameExpirationAsPrimaryKey(const Key &key)
 {
     Q_ASSERT(!key.isNull() && key.numSubkeys() > 0);
     const auto subkeys = key.subkeys();
     const auto primaryKey = subkeys[0];
     if (primaryKey.neverExpires()) {
         return std::all_of(std::begin(subkeys), std::end(subkeys), [] (const auto &subkey) {
             // revoked subkeys are ignored by gpg --quick-set-expire when updating the expiration of all subkeys
             return subkey.isRevoked() || subkey.neverExpires();
         });
     }
 
     const auto primaryExpiration = quint32(primaryKey.expirationTime());
     const auto range = std::make_pair(primaryExpiration > 10 ? primaryExpiration - 10 : 0,
                                       primaryExpiration < std::numeric_limits<quint32>::max() - 10 ? primaryExpiration + 10 : std::numeric_limits<quint32>::max());
     return std::all_of(std::begin(subkeys), std::end(subkeys), [range](const auto &subkey) {
         // revoked subkeys are ignored by gpg --quick-set-expire when updating the expiration of all subkeys;
         // check if expiration of subkey is (more or less) the same as the expiration of the primary key
         return subkey.isRevoked() ||
             (range.first <= quint32(subkey.expirationTime()) && quint32(subkey.expirationTime()) <= range.second);
     });
 }
 #endif
 }
 
 class ChangeExpiryCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::ChangeExpiryCommand;
     ChangeExpiryCommand *q_func() const
     {
         return static_cast<ChangeExpiryCommand *>(q);
     }
 public:
     explicit Private(ChangeExpiryCommand *qq, KeyListController *c);
     ~Private() override;
 
 private:
     void slotDialogAccepted();
     void slotDialogRejected();
     void slotResult(const Error &err);
 
 private:
     void ensureDialogCreated(ExpiryDialog::Mode mode);
     void createJob();
     void showErrorDialog(const Error &error);
     void showSuccessDialog();
 
 private:
     GpgME::Key key;
     GpgME::Subkey subkey;
     QPointer<ExpiryDialog> dialog;
     QPointer<ChangeExpiryJob> job;
 };
 
 ChangeExpiryCommand::Private *ChangeExpiryCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ChangeExpiryCommand::Private *ChangeExpiryCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ChangeExpiryCommand::Private::Private(ChangeExpiryCommand *qq, KeyListController *c)
     : Command::Private{qq, c}
 {
 }
 
 ChangeExpiryCommand::Private::~Private() = default;
 
 void ChangeExpiryCommand::Private::slotDialogAccepted()
 {
     Q_ASSERT(dialog);
 
     static const QTime END_OF_DAY{23, 59, 59};
 
     const QDateTime expiry{dialog->dateOfExpiry(), END_OF_DAY};
 
     qCDebug(KLEOPATRA_LOG) << "expiry" << expiry;
 
     createJob();
     Q_ASSERT(job);
 
 #if QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
     if (subkey.isNull() && dialog->updateExpirationOfAllSubkeys()) {
         job->setOptions(ChangeExpiryJob::UpdateAllSubkeys);
     }
 #endif
 
     std::vector<Subkey> subkeys;
     if (!subkey.isNull() && subkey.keyID() != key.keyID()) { // ignore the primary subkey
         subkeys.push_back(subkey);
     }
 
     if (const Error err = job->start(key, expiry, subkeys)) {
         showErrorDialog(err);
         finished();
     }
 }
 
 void ChangeExpiryCommand::Private::slotDialogRejected()
 {
     Q_EMIT q->canceled();
     finished();
 }
 
 void ChangeExpiryCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled())
         ;
     else if (err) {
         showErrorDialog(err);
     } else {
         showSuccessDialog();
     }
     finished();
 }
 
 void ChangeExpiryCommand::Private::ensureDialogCreated(ExpiryDialog::Mode mode)
 {
     if (dialog) {
         return;
     }
 
     dialog = new ExpiryDialog{mode};
     applyWindowID(dialog);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
 
     connect(dialog, &QDialog::accepted, q, [this]() { slotDialogAccepted(); });
     connect(dialog, &QDialog::rejected, q, [this]() { slotDialogRejected(); });
 }
 
 void ChangeExpiryCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     const auto backend = (key.protocol() == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     if (!backend) {
         return;
     }
 
     ChangeExpiryJob *const j = backend->changeExpiryJob();
     if (!j) {
         return;
     }
 
-    connect(j, &Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(j, &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(j, &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
     connect(j, &ChangeExpiryJob::result,
             q, [this] (const auto &err) { slotResult(err); });
 
     job = j;
 }
 
 void ChangeExpiryCommand::Private::showErrorDialog(const Error &err)
 {
     error(i18n("<p>An error occurred while trying to change "
                "the end of the validity period for <b>%1</b>:</p><p>%2</p>",
                Formatting::formatForComboBox(key),
                QString::fromLocal8Bit(err.asString())));
 }
 
 void ChangeExpiryCommand::Private::showSuccessDialog()
 {
     success(i18n("End of validity period changed successfully."));
 }
 
 ChangeExpiryCommand::ChangeExpiryCommand(KeyListController *c)
     : Command{new Private{this, c}}
 {
 }
 
 ChangeExpiryCommand::ChangeExpiryCommand(QAbstractItemView *v, KeyListController *c)
     : Command{v, new Private{this, c}}
 {
 }
 
 ChangeExpiryCommand::ChangeExpiryCommand(const GpgME::Key &key)
     : Command{key, new Private{this, nullptr}}
 {
 }
 
 ChangeExpiryCommand::~ChangeExpiryCommand() = default;
 
 void ChangeExpiryCommand::setSubkey(const GpgME::Subkey &subkey)
 {
     d->subkey = subkey;
 }
 
 void ChangeExpiryCommand::doStart()
 {
     const std::vector<Key> keys = d->keys();
     if (keys.size() != 1 ||
             keys.front().protocol() != GpgME::OpenPGP ||
             !keys.front().hasSecret() ||
             keys.front().subkey(0).isNull()) {
         d->finished();
         return;
     }
 
     d->key = keys.front();
 
     if (!d->subkey.isNull() &&
             d->subkey.parent().primaryFingerprint() != d->key.primaryFingerprint()) {
         qDebug() << "Invalid subkey" << d->subkey.fingerprint()
                  << ": Not a subkey of key" << d->key.primaryFingerprint();
         d->finished();
         return;
     }
 
     ExpiryDialog::Mode mode;
     if (!d->subkey.isNull()) {
         mode = ExpiryDialog::Mode::UpdateIndividualSubkey;
     } else if (d->key.numSubkeys() == 1) {
         mode = ExpiryDialog::Mode::UpdateCertificateWithoutSubkeys;
     } else {
         mode = ExpiryDialog::Mode::UpdateCertificateWithSubkeys;
     }
     d->ensureDialogCreated(mode);
     Q_ASSERT(d->dialog);
     const Subkey subkey = !d->subkey.isNull() ? d->subkey : d->key.subkey(0);
     d->dialog->setDateOfExpiry(subkey.neverExpires() ? QDate() :
                                QDateTime::fromSecsSinceEpoch(quint32(subkey.expirationTime())).date());
 #if QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY
     if (mode == ExpiryDialog::Mode::UpdateCertificateWithSubkeys) {
         d->dialog->setUpdateExpirationOfAllSubkeys(allNotRevokedSubkeysHaveSameExpirationAsPrimaryKey(d->key));
     }
 #endif
 
     d->dialog->show();
 
 }
 
 void ChangeExpiryCommand::doCancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 #undef d
 #undef q
 
 #include "moc_changeexpirycommand.cpp"
diff --git a/src/commands/changeownertrustcommand.cpp b/src/commands/changeownertrustcommand.cpp
index da272befd..d6f6c19b8 100644
--- a/src/commands/changeownertrustcommand.cpp
+++ b/src/commands/changeownertrustcommand.cpp
@@ -1,276 +1,281 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/changeownertrustcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     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-kleopatra.h>
 
 #include "changeownertrustcommand.h"
 
 #include "command_p.h"
 
 #include <Libkleo/Compliance>
 #include <Libkleo/Formatting>
 #include <Libkleo/KeyCache>
 
 #include <KLocalizedString>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/ChangeOwnerTrustJob>
 
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 using namespace QGpgME;
 
 class ChangeOwnerTrustCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::ChangeOwnerTrustCommand;
     ChangeOwnerTrustCommand *q_func() const
     {
         return static_cast<ChangeOwnerTrustCommand *>(q);
     }
 public:
     Private(ChangeOwnerTrustCommand *qq, KeyListController *c);
 
 private:
     void startJob(Key::OwnerTrust trust);
     void createJob();
     void slotResult(const Error &err);
     void showErrorDialog(const Error &error);
     void showSuccessDialog();
 
 private:
     QPointer<ChangeOwnerTrustJob> job;
     Key::OwnerTrust trustToSet = Key::OwnerTrust::Unknown;
 };
 
 ChangeOwnerTrustCommand::Private *ChangeOwnerTrustCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ChangeOwnerTrustCommand::Private *ChangeOwnerTrustCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ChangeOwnerTrustCommand::Private::Private(ChangeOwnerTrustCommand *qq, KeyListController *c)
     : Command::Private{qq, c}
 {
 }
 
 ChangeOwnerTrustCommand::ChangeOwnerTrustCommand(QAbstractItemView *v, KeyListController *c)
     : Command{v, new Private{this, c}}
 {
 }
 
 ChangeOwnerTrustCommand::~ChangeOwnerTrustCommand()
 {
     qCDebug(KLEOPATRA_LOG) << this << __func__;
 }
 
 void ChangeOwnerTrustCommand::doStart()
 {
     if (d->keys().size() != 1) {
         d->finished();
         return;
     }
 
     const Key key = d->key();
     if (key.protocol() != GpgME::OpenPGP) {
         d->finished();
         return;
     }
 
     const auto keyInfo = Formatting::formatForComboBox(key);
 
     if (key.hasSecret()) {
         const auto answer = KMessageBox::questionTwoActionsCancel(d->parentWidgetOrView(),
                                                              xi18nc("@info", "Is '%1' your own certificate?", keyInfo),
                                                              i18nc("@title:window", "Mark Own Certificate"),
                                                              KGuiItem(i18nc("@action:button", "Yes, it's mine")),
                                                              KGuiItem(i18nc("@action:button", "No, it's not mine")),
                                                              KStandardGuiItem::cancel());
         switch (answer) {
         case KMessageBox::ButtonCode::PrimaryAction: {
             if (key.ownerTrust() < Key::Ultimate) {
                 d->startJob(Key::OwnerTrust::Ultimate);
             }
             return;
         }
         case KMessageBox::ButtonCode::SecondaryAction: {
             if (key.ownerTrust() == Key::Ultimate) {
                 d->startJob(Key::OwnerTrust::Unknown);
                 return;
             }
             // else ask next question
             break;
         }
         case KMessageBox::Cancel: {
             d->canceled();
             return;
         }
         default:; // cannot happen
         }
     }
 
     if (key.ownerTrust() < Key::OwnerTrust::Full) {
         const auto text = (DeVSCompliance::isCompliant() && Formatting::isKeyDeVs(key))
             ? xi18nc("@info %1: a certificate, %2: name of a compliance mode",
                      "<para>Do you want to grant '%1' the power to mark certificates as %2 for you?</para>"
                      "<para><emphasis>This means that the owner of this certificate properly checks fingerprints "
                      "and confirms the identities of others.</emphasis></para>",
                      keyInfo,
                      DeVSCompliance::name())
             : xi18nc("@info %1: a certificate",
                      "<para>Do you want to grant '%1' the power to mark certificates as valid for you?</para>"
                      "<para><emphasis>This means that the owner of this certificate properly checks fingerprints "
                      "and confirms the identities of others.</emphasis></para>",
                      keyInfo);
         const auto answer = KMessageBox::questionTwoActions(d->parentWidgetOrView(),
                                                        text,
                                                        i18nc("@title:window", "Grant Certification Power"),
                                                        KGuiItem(i18nc("@action:button", "Grant Power")),
                                                        KStandardGuiItem::cancel());
         if (answer == KMessageBox::ButtonCode::PrimaryAction) {
             d->startJob(Key::OwnerTrust::Full);
         } else {
             d->canceled();
         }
     } else {
         const auto text = (DeVSCompliance::isCompliant() && Formatting::isKeyDeVs(key))
             ? xi18nc("@info %1: a certificate, %2: name of a compliance mode",
                      "<para>The certificate '%1' is empowered to mark other certificates as %2 for you.</para>"
                      "<para>Do you want to revoke this power?</para>",
                      keyInfo,
                      DeVSCompliance::name())
             : xi18nc("@info %1: a certificate",
                      "<para>The certificate '%1' is empowered to mark other certificates as valid for you.</para>"
                      "<para>Do you want to revoke this power?</para>",
                      keyInfo);
         const auto answer = KMessageBox::questionTwoActions(d->parentWidgetOrView(),
                                                        text,
                                                        i18nc("@title:window", "Revoke Certification Power"),
                                                        KGuiItem(i18nc("@action:button", "Revoke Power")),
                                                        KStandardGuiItem::cancel());
         if (answer == KMessageBox::ButtonCode::PrimaryAction) {
             d->startJob(Key::OwnerTrust::Unknown);
         } else {
             d->canceled();
         }
     }
 }
 
 void ChangeOwnerTrustCommand::Private::startJob(Key::OwnerTrust trust)
 {
     trustToSet = trust;
 
     createJob();
     Q_ASSERT(job);
 
     if (const Error err = job->start(key(), trust)) {
         showErrorDialog(err);
         finished();
     }
 }
 
 void ChangeOwnerTrustCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled())
         ;
     else if (err) {
         showErrorDialog(err);
     } else {
         showSuccessDialog();
     }
     finished();
 }
 
 void ChangeOwnerTrustCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG) << this << __func__;
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 void ChangeOwnerTrustCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     ChangeOwnerTrustJob *const j = QGpgME::openpgp()->changeOwnerTrustJob();
     if (!j) {
         return;
     }
 
-    connect(j, &Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(j, &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(j, &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
     connect(j, &ChangeOwnerTrustJob::result, q, [this](const GpgME::Error &result) { slotResult(result); });
 
     job = j;
 }
 
 void ChangeOwnerTrustCommand::Private::showErrorDialog(const Error &err)
 {
     const auto keyInfo = Formatting::formatForComboBox(key());
     switch (trustToSet) {
     case Key::OwnerTrust::Ultimate:
         error(xi18nc("@info",
                      "<para>An error occurred while marking certificate '%1' as your certificate.</para>"
                      "<para><message>%2</message></para>",
                      keyInfo,
                      QString::fromUtf8(err.asString())));
         break;
     case Key::OwnerTrust::Full:
         error(xi18nc("@info",
                      "<para>An error occurred while granting certification power to '%1'.</para>"
                      "<para><message>%2</message></para>",
                      keyInfo,
                      QString::fromUtf8(err.asString())));
         break;
     default:
         error(xi18nc("@info",
                      "<para>An error occurred while revoking the certification power of '%1'.</para>"
                      "<para><message>%2</message></para>",
                      keyInfo,
                      QString::fromUtf8(err.asString())));
     }
 }
 
 void ChangeOwnerTrustCommand::Private::showSuccessDialog()
 {
     auto updatedKey = key();
     updatedKey.update();
     KeyCache::mutableInstance()->insert(updatedKey);
 
     const auto keyInfo = Formatting::formatForComboBox(updatedKey);
     switch (updatedKey.ownerTrust()) {
     case Key::OwnerTrust::Ultimate:
         success(i18nc("@info", "Certificate '%1' was marked as your certificate.", keyInfo));
         break;
     case Key::OwnerTrust::Full:
         success(i18nc("@info", "Certification power was granted to '%1'.", keyInfo));
         break;
     default:
         success(i18nc("@info", "The certification power of '%1' was revoked.", keyInfo));
     }
 }
 
 #undef d
 #undef q
 
 #include "moc_changeownertrustcommand.cpp"
diff --git a/src/commands/changepassphrasecommand.cpp b/src/commands/changepassphrasecommand.cpp
index 3252b7a8b..e58fef554 100644
--- a/src/commands/changepassphrasecommand.cpp
+++ b/src/commands/changepassphrasecommand.cpp
@@ -1,201 +1,206 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/changepassphrasecommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "changepassphrasecommand.h"
 
 #include "command_p.h"
 
 #include <Libkleo/Formatting>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/ChangePasswdJob>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 
 #include <gpg-error.h>
 
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 using namespace QGpgME;
 
 class ChangePassphraseCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::ChangePassphraseCommand;
     ChangePassphraseCommand *q_func() const
     {
         return static_cast<ChangePassphraseCommand *>(q);
     }
 public:
     explicit Private(ChangePassphraseCommand *qq, KeyListController *c);
     ~Private() override;
 
     void init();
 
 private:
     void slotResult(const Error &err);
 
 private:
     void createJob();
     void startJob();
     void showErrorDialog(const Error &error);
     void showSuccessDialog();
 
 private:
     GpgME::Key key;
     QPointer<ChangePasswdJob> job;
 };
 
 ChangePassphraseCommand::Private *ChangePassphraseCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ChangePassphraseCommand::Private *ChangePassphraseCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ChangePassphraseCommand::Private::Private(ChangePassphraseCommand *qq, KeyListController *c)
     : Command::Private(qq, c),
       key(),
       job()
 {
 
 }
 
 ChangePassphraseCommand::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 ChangePassphraseCommand::ChangePassphraseCommand(KeyListController *c)
     : Command(new Private(this, c))
 {
     d->init();
 }
 
 ChangePassphraseCommand::ChangePassphraseCommand(QAbstractItemView *v, KeyListController *c)
     : Command(v, new Private(this, c))
 {
     d->init();
 }
 
 ChangePassphraseCommand::ChangePassphraseCommand(const GpgME::Key &key)
     : Command(key, new Private(this, nullptr))
 {
     d->init();
 }
 
 void ChangePassphraseCommand::Private::init()
 {
 
 }
 
 ChangePassphraseCommand::~ChangePassphraseCommand()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void ChangePassphraseCommand::doStart()
 {
 
     const std::vector<Key> keys = d->keys();
     if (keys.size() != 1 || !keys.front().hasSecret()) {
         d->finished();
         return;
     }
 
     d->key = keys.front();
 
     d->createJob();
     d->startJob();
 
 }
 
 void ChangePassphraseCommand::Private::startJob()
 {
     const Error err = job
                       ? job->start(key)
                       : Error::fromCode(GPG_ERR_NOT_SUPPORTED)
                       ;
     if (err) {
         showErrorDialog(err);
         finished();
     }
 }
 
 void ChangePassphraseCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled())
         ;
     else if (err) {
         showErrorDialog(err);
     } else {
         showSuccessDialog();
     }
     finished();
 }
 
 void ChangePassphraseCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG);
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 void ChangePassphraseCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     const auto backend = (key.protocol() == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     if (!backend) {
         return;
     }
 
     ChangePasswdJob *const j = backend->changePasswdJob();
     if (!j) {
         return;
     }
 
-    connect(j, &Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(j, &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(j, &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
     connect(j, &ChangePasswdJob::result, q, [this](const GpgME::Error &result) { slotResult(result); });
 
     job = j;
 }
 
 void ChangePassphraseCommand::Private::showErrorDialog(const Error &err)
 {
     error(i18n("<p>An error occurred while trying to change "
                "the passphrase for <b>%1</b>:</p><p>%2</p>",
                Formatting::formatForComboBox(key),
                QString::fromLocal8Bit(err.asString())),
           i18n("Passphrase Change Error"));
 }
 
 void ChangePassphraseCommand::Private::showSuccessDialog()
 {
     information(i18n("Passphrase changed successfully."),
                 i18n("Passphrase Change Succeeded"));
 }
 
 #undef d
 #undef q
 
 #include "moc_changepassphrasecommand.cpp"
diff --git a/src/commands/command.h b/src/commands/command.h
index 773bec9d2..135dcff18 100644
--- a/src/commands/command.h
+++ b/src/commands/command.h
@@ -1,137 +1,137 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/command.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QObject>
 
 #include <qwindowdefs.h> // for WId
 
 #include <utils/pimpl_ptr.h>
 #include <utils/types.h> // for ExecutionContext
 
 #include <vector>
 
 class QModelIndex;
 template <typename T> class QList;
 class QAbstractItemView;
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 
 class KeyListController;
 class AbstractKeyListSortFilterProxyModel;
 
 class Command : public QObject, public ExecutionContext
 {
     Q_OBJECT
 public:
     explicit Command(KeyListController *parent);
     explicit Command(QAbstractItemView *view, KeyListController *parent);
     explicit Command(const GpgME::Key &key);
     explicit Command(const std::vector<GpgME::Key> &keys);
     ~Command() override;
 
     enum Restriction {
         NoRestriction      = 0x0000,
         NeedSelection      = 0x0001,
         OnlyOneKey         = 0x0002,
         NeedSecretKey      = 0x0004, //< command performs secret key operations
         NeedSecretKeyData  = 0x0008, //< command needs access to the secret key data
         MustBeOpenPGP      = 0x0010,
         MustBeCMS          = 0x0020,
 
         // esoteric:
         MayOnlyBeSecretKeyIfOwnerTrustIsNotYetUltimate = 0x0040, // for set-owner-trust
 
         AnyCardHasNullPin   = 0x0080,
         AnyCardCanLearnKeys = 0x0100,
 
         MustBeRoot          = 0x0200,
         MustBeTrustedRoot   = 0x0400 | MustBeRoot,
         MustBeUntrustedRoot = 0x0800 | MustBeRoot,
 
         MustBeValid         = 0x1000, //< key is neither revoked nor expired nor otherwise "bad"
 
         _AllRestrictions_Helper,
         AllRestrictions = 2 * (_AllRestrictions_Helper - 1) - 1
     };
 
     Q_DECLARE_FLAGS(Restrictions, Restriction)
 
     static Restrictions restrictions()
     {
         return NoRestriction;
     }
 
     /** Classify the files and return the most appropriate commands.
      *
      * @param files: A list of files.
      *
      * @returns null QString on success. Error message otherwise.
      */
     static QVector<Command *>commandsForFiles(const QStringList &files);
 
     /** Get a command for a query.
      *
      * @param query: A keyid / fingerprint or any string to use in the search.
      */
     static Command *commandForQuery(const QString &query);
 
     void setParentWidget(QWidget *widget);
     void setParentWId(WId wid);
     void setView(QAbstractItemView *view);
     void setKey(const GpgME::Key &key);
     void setKeys(const std::vector<GpgME::Key> &keys);
 
     void setAutoDelete(bool on);
     bool autoDelete() const;
 
     void setWarnWhenRunningAtShutdown(bool warn);
     bool warnWhenRunningAtShutdown() const;
 
 public Q_SLOTS:
     void start();
     void cancel();
 
 Q_SIGNALS:
     void info(const QString &message, int timeout = 0);
-    void progress(const QString &message, int current, int total);
+    void progress(int current, int total);
     void finished();
     void canceled();
 
 private:
     virtual void doStart() = 0;
     virtual void doCancel() = 0;
 
 private:
     void applyWindowID(QWidget *wid) const override;
 
 protected:
     void addTemporaryView(const QString &title, AbstractKeyListSortFilterProxyModel *proxy = nullptr, const QString &tabToolTip = QString());
 
 protected:
     class Private;
     kdtools::pimpl_ptr<Private> d;
 protected:
     explicit Command(Private *pp);
     explicit Command(QAbstractItemView *view, Private *pp);
     explicit Command(const std::vector<GpgME::Key> &keys, Private *pp);
     explicit Command(const GpgME::Key &key, Private *pp);
 };
 
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Kleo::Command::Restrictions)
 
diff --git a/src/commands/deletecertificatescommand.cpp b/src/commands/deletecertificatescommand.cpp
index a25e08c38..9a346bae7 100644
--- a/src/commands/deletecertificatescommand.cpp
+++ b/src/commands/deletecertificatescommand.cpp
@@ -1,390 +1,395 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     deleteCertificatescommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "deletecertificatescommand.h"
 
 #include "command_p.h"
 
 #include <dialogs/deletecertificatesdialog.h>
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/Predicates>
 
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/MultiDeleteJob>
 #include <QGpgME/DeleteJob>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QAbstractItemView>
 
 #include <algorithm>
 #include <vector>
 #include <KLazyLocalizedString>
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace QGpgME;
 
 class DeleteCertificatesCommand::Private : public Command::Private
 {
     friend class ::Kleo::DeleteCertificatesCommand;
     DeleteCertificatesCommand *q_func() const
     {
         return static_cast<DeleteCertificatesCommand *>(q);
     }
 public:
     explicit Private(DeleteCertificatesCommand *qq, KeyListController *c);
     ~Private() override;
 
     void startDeleteJob(GpgME::Protocol protocol);
 
     void cancelJobs();
     void pgpDeleteResult(const GpgME::Error &);
     void cmsDeleteResult(const GpgME::Error &);
     void showErrorsAndFinish();
 
     bool canDelete(GpgME::Protocol proto) const
     {
         if (const auto cbp = (proto == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime()))
             if (DeleteJob *const job = cbp->deleteJob()) {
                 job->slotCancel();
                 return true;
             }
         return false;
     }
 
     void ensureDialogCreated()
     {
         if (dialog) {
             return;
         }
         dialog = new DeleteCertificatesDialog;
         applyWindowID(dialog);
         dialog->setAttribute(Qt::WA_DeleteOnClose);
         dialog->setWindowTitle(i18nc("@title:window", "Delete Certificates"));
         connect(dialog, &QDialog::accepted, q_func(), [this]() { slotDialogAccepted(); });
         connect(dialog, &QDialog::rejected, q_func(), [this]() { slotDialogRejected(); });
     }
     void ensureDialogShown()
     {
         if (dialog) {
             dialog->show();
         }
     }
 
     void slotDialogAccepted();
     void slotDialogRejected()
     {
         canceled();
     }
 
 private:
     QPointer<DeleteCertificatesDialog> dialog;
     QPointer<MultiDeleteJob> cmsJob, pgpJob;
     GpgME::Error cmsError, pgpError;
     std::vector<Key> cmsKeys, pgpKeys;
 };
 
 DeleteCertificatesCommand::Private *DeleteCertificatesCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const DeleteCertificatesCommand::Private *DeleteCertificatesCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 DeleteCertificatesCommand::Private::Private(DeleteCertificatesCommand *qq, KeyListController *c)
     : Command::Private(qq, c)
 {
 
 }
 
 DeleteCertificatesCommand::Private::~Private() {}
 
 DeleteCertificatesCommand::DeleteCertificatesCommand(KeyListController *p)
     : Command(new Private(this, p))
 {
 
 }
 
 DeleteCertificatesCommand::DeleteCertificatesCommand(QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
 
 }
 
 DeleteCertificatesCommand::~DeleteCertificatesCommand() {}
 
 namespace
 {
 
 enum Action { Nothing = 0, Failure = 1, ClearCMS = 2, ClearPGP = 4 };
 
 // const unsigned int errorCase =
 //    openpgp.empty() << 3U | d->canDelete( OpenPGP ) << 2U |
 //        cms.empty() << 1U |     d->canDelete( CMS ) << 0U ;
 
 static const struct {
     const KLazyLocalizedString text;
     Action actions;
 } deletionErrorCases[16] = {
     // if havePGP
     //   if cantPGP
     //     if haveCMS
     {kli18n("Neither the OpenPGP nor the CMS "
             "backends support certificate deletion.\n"
             "Check your installation."),
      Failure}, // cantCMS
     {kli18n("The OpenPGP backend does not support "
             "certificate deletion.\n"
             "Check your installation.\n"
             "Only the selected CMS certificates "
             "will be deleted."),
      ClearPGP}, // canCMS
     //     if !haveCMS
     {kli18n("The OpenPGP backend does not support "
             "certificate deletion.\n"
             "Check your installation."),
      Failure},
     {kli18n("The OpenPGP backend does not support "
             "certificate deletion.\n"
             "Check your installation."),
      Failure},
     //   if canPGP
     //      if haveCMS
     {kli18n("The CMS backend does not support "
             "certificate deletion.\n"
             "Check your installation.\n"
             "Only the selected OpenPGP certificates "
             "will be deleted."),
      ClearCMS},                        // cantCMS
     {KLazyLocalizedString(), Nothing}, // canCMS
     //      if !haveCMS
     {KLazyLocalizedString(), Nothing}, // cantCMS
     {KLazyLocalizedString(), Nothing}, // canCMS
     // if !havePGP
     //   if cantPGP
     //     if haveCMS
     {kli18n("The CMS backend does not support "
             "certificate deletion.\n"
             "Check your installation."),
      Failure},                         // cantCMS
     {KLazyLocalizedString(), Nothing}, // canCMS
     //     if !haveCMS
     {KLazyLocalizedString(), Nothing}, // cantCMS
     {KLazyLocalizedString(), Nothing}, // canCMS
     //  if canPGP
     //     if haveCMS
     {kli18n("The CMS backend does not support "
             "certificate deletion.\n"
             "Check your installation."),
      Failure},                         // cantCMS
     {KLazyLocalizedString(), Nothing}, // canCMS
     //     if !haveCMS
     {KLazyLocalizedString(), Nothing}, // cantCMS
     {KLazyLocalizedString(), Nothing}, // canCMS
 };
 } // anon namespace
 
 void DeleteCertificatesCommand::doStart()
 {
 
     std::vector<Key> selected = d->keys();
     if (selected.empty()) {
         d->finished();
         return;
     }
 
     std::sort(selected.begin(), selected.end(), _detail::ByFingerprint<std::less>());
 
     // Calculate the closure of the selected keys (those that need to
     // be deleted with them, though not selected themselves):
 
     std::vector<Key> toBeDeleted = KeyCache::instance()->findSubjects(selected);
     std::sort(toBeDeleted.begin(), toBeDeleted.end(), _detail::ByFingerprint<std::less>());
 
     std::vector<Key> unselected;
     unselected.reserve(toBeDeleted.size());
     std::set_difference(toBeDeleted.begin(), toBeDeleted.end(),
                         selected.begin(), selected.end(),
                         std::back_inserter(unselected),
                         _detail::ByFingerprint<std::less>());
 
     d->ensureDialogCreated();
 
     d->dialog->setSelectedKeys(selected);
     d->dialog->setUnselectedKeys(unselected);
 
     d->ensureDialogShown();
 
 }
 
 void DeleteCertificatesCommand::Private::slotDialogAccepted()
 {
     std::vector<Key> keys = dialog->keys();
     Q_ASSERT(!keys.empty());
 
     auto pgpBegin = keys.begin();
     auto pgpEnd = std::stable_partition(pgpBegin, keys.end(),
                                         [](const GpgME::Key &key) {
                                             return key.protocol() != GpgME::CMS;
                                         });
     auto cmsBegin = pgpEnd;
     auto cmsEnd = keys.end();
 
     std::vector<Key> openpgp(pgpBegin, pgpEnd);
     std::vector<Key>     cms(cmsBegin, cmsEnd);
 
     const unsigned int errorCase =
         openpgp.empty() << 3U | canDelete(OpenPGP) << 2U |
         cms.empty() << 1U |     canDelete(CMS) << 0U;
 
     if (const unsigned int actions = deletionErrorCases[errorCase].actions) {
         information(KLocalizedString(deletionErrorCases[errorCase].text).toString(),
                     (actions & Failure)
                         ? i18n("Certificate Deletion Failed")
                         : i18n("Certificate Deletion Problem"));
 
         if (actions & ClearCMS) {
             cms.clear();
         }
         if (actions & ClearPGP) {
             openpgp.clear();
         }
         if (actions & Failure) {
             canceled();
             return;
         }
     }
 
     Q_ASSERT(!openpgp.empty() || !cms.empty());
 
     pgpKeys.swap(openpgp);
     cmsKeys.swap(cms);
 
     if (!pgpKeys.empty()) {
         startDeleteJob(GpgME::OpenPGP);
     }
     if (!cmsKeys.empty()) {
         startDeleteJob(GpgME::CMS);
     }
 
     if ((pgpKeys.empty() || pgpError.code()) &&
             (cmsKeys.empty() || cmsError.code())) {
         showErrorsAndFinish();
     }
 }
 
 void DeleteCertificatesCommand::Private::startDeleteJob(GpgME::Protocol protocol)
 {
     Q_ASSERT(protocol != GpgME::UnknownProtocol);
 
     const std::vector<Key> &keys = protocol == CMS ? cmsKeys : pgpKeys;
 
     const auto backend = (protocol == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     Q_ASSERT(backend);
 
     std::unique_ptr<MultiDeleteJob> job(new MultiDeleteJob(backend));
 
     connect(job.get(), &QGpgME::MultiDeleteJob::result, q_func(), [this, protocol](const GpgME::Error &result) {
         if (protocol == CMS) {
             cmsDeleteResult(result);
         } else {
             pgpDeleteResult(result);
         }
     });
 
-    connect(job.get(), &Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(job.get(), &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(job.get(), &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
 
     if (const Error err = job->start(keys, true /*allowSecretKeyDeletion*/)) {
         (protocol == CMS ? cmsError : pgpError) = err;
     } else {
         (protocol == CMS ? cmsJob : pgpJob) = job.release();
     }
 }
 
 void DeleteCertificatesCommand::Private::showErrorsAndFinish()
 {
 
     Q_ASSERT(!pgpJob); Q_ASSERT(!cmsJob);
 
     if (pgpError || cmsError) {
         QString pgpErrorString;
         if (pgpError) {
             pgpErrorString = i18n("OpenPGP backend: %1", QString::fromLocal8Bit(pgpError.asString()));
         }
         QString cmsErrorString;
         if (cmsError) {
             cmsErrorString = i18n("CMS backend: %1", QString::fromLocal8Bit(cmsError.asString()));
         }
 
         const QString msg = i18n("<qt><p>An error occurred while trying to delete "
                                  "the certificate:</p>"
                                  "<p><b>%1</b></p></qt>",
                                  pgpError ? cmsError ? pgpErrorString + QLatin1String("</br>") + cmsErrorString : pgpErrorString : cmsErrorString);
         error(msg, i18n("Certificate Deletion Failed"));
     } else if (!pgpError.isCanceled() && !cmsError.isCanceled()) {
         std::vector<Key> keys = pgpKeys;
         keys.insert(keys.end(), cmsKeys.begin(), cmsKeys.end());
         KeyCache::mutableInstance()->remove(keys);
     }
 
     finished();
 }
 
 void DeleteCertificatesCommand::doCancel()
 {
     d->cancelJobs();
 }
 
 void DeleteCertificatesCommand::Private::pgpDeleteResult(const Error &err)
 {
     pgpError = err;
     pgpJob = nullptr;
     if (!cmsJob) {
         showErrorsAndFinish();
     }
 }
 
 void DeleteCertificatesCommand::Private::cmsDeleteResult(const Error &err)
 {
     cmsError = err;
     cmsJob = nullptr;
     if (!pgpJob) {
         showErrorsAndFinish();
     }
 }
 
 void DeleteCertificatesCommand::Private::cancelJobs()
 {
     if (cmsJob) {
         cmsJob->slotCancel();
     }
     if (pgpJob) {
         pgpJob->slotCancel();
     }
 }
 
 #undef d
 #undef q
 
 #include "moc_deletecertificatescommand.cpp"
diff --git a/src/commands/exportcertificatecommand.cpp b/src/commands/exportcertificatecommand.cpp
index e85051234..c8365ab09 100644
--- a/src/commands/exportcertificatecommand.cpp
+++ b/src/commands/exportcertificatecommand.cpp
@@ -1,364 +1,369 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     exportcertificatecommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "exportcertificatecommand.h"
 #include "fileoperationspreferences.h"
 
 #include "command_p.h"
 
 #include <utils/applicationstate.h>
 #include <utils/filedialog.h>
 
 #include <Libkleo/Classify>
 #include <Libkleo/Formatting>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/ExportJob>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 #include <QSaveFile>
 
 #include <QMap>
 #include <QPointer>
 #include <QFileInfo>
 
 #include <algorithm>
 #include <vector>
 
 using namespace Kleo;
 using namespace GpgME;
 using namespace QGpgME;
 
 class ExportCertificateCommand::Private : public Command::Private
 {
     friend class ::ExportCertificateCommand;
     ExportCertificateCommand *q_func() const
     {
         return static_cast<ExportCertificateCommand *>(q);
     }
 public:
     explicit Private(ExportCertificateCommand *qq, KeyListController *c);
     ~Private() override;
     void startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys);
     void cancelJobs();
     void exportResult(const GpgME::Error &, const QByteArray &);
     void showError(const GpgME::Error &error);
 
     bool requestFileNames(GpgME::Protocol prot);
     void finishedIfLastJob();
 
 private:
     QMap<GpgME::Protocol, QString> fileNames;
     uint jobsPending = 0;
     QMap<QObject *, QString> outFileForSender;
     QPointer<ExportJob> cmsJob;
     QPointer<ExportJob> pgpJob;
 };
 
 ExportCertificateCommand::Private *ExportCertificateCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ExportCertificateCommand::Private *ExportCertificateCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ExportCertificateCommand::Private::Private(ExportCertificateCommand *qq, KeyListController *c)
     : Command::Private(qq, c)
 {
 
 }
 
 ExportCertificateCommand::Private::~Private() {}
 
 ExportCertificateCommand::ExportCertificateCommand(KeyListController *p)
     : Command(new Private(this, p))
 {
 
 }
 
 ExportCertificateCommand::ExportCertificateCommand(QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
 
 }
 
 ExportCertificateCommand::ExportCertificateCommand(const Key &key)
     : Command(key, new Private(this, nullptr))
 {
 
 }
 
 ExportCertificateCommand::~ExportCertificateCommand() {}
 
 void ExportCertificateCommand::setOpenPGPFileName(const QString &fileName)
 {
     if (!d->jobsPending) {
         d->fileNames[OpenPGP] = fileName;
     }
 }
 
 QString ExportCertificateCommand::openPGPFileName() const
 {
     return d->fileNames[OpenPGP];
 }
 
 void ExportCertificateCommand::setX509FileName(const QString &fileName)
 {
     if (!d->jobsPending) {
         d->fileNames[CMS] = fileName;
     }
 }
 
 QString ExportCertificateCommand::x509FileName() const
 {
     return d->fileNames[CMS];
 }
 
 void ExportCertificateCommand::doStart()
 {
     std::vector<Key> keys = d->keys();
     if (keys.empty()) {
         return;
     }
 
     const auto firstCms = std::partition(keys.begin(), keys.end(),
                                          [](const GpgME::Key &key) {
                                             return key.protocol() != GpgME::CMS;
                                          });
     std::vector<Key> openpgp, cms;
     std::copy(keys.begin(), firstCms, std::back_inserter(openpgp));
     std::copy(firstCms, keys.end(), std::back_inserter(cms));
     Q_ASSERT(!openpgp.empty() || !cms.empty());
     const bool haveBoth = !cms.empty() && !openpgp.empty();
     const GpgME::Protocol prot = haveBoth ? UnknownProtocol : (!cms.empty() ? CMS : OpenPGP);
     if (!d->requestFileNames(prot)) {
         Q_EMIT canceled();
         d->finished();
     } else {
         if (!openpgp.empty()) {
             d->startExportJob(GpgME::OpenPGP, openpgp);
         }
         if (!cms.empty()) {
             d->startExportJob(GpgME::CMS, cms);
         }
     }
 }
 
 bool ExportCertificateCommand::Private::requestFileNames(GpgME::Protocol protocol)
 {
     if (protocol == UnknownProtocol) {
         if (!fileNames[GpgME::OpenPGP].isEmpty() && !fileNames[GpgME::CMS].isEmpty()) {
             return true;
         }
 
         /* Unknown protocol ask for first PGP Export file name */
         if (fileNames[GpgME::OpenPGP].isEmpty() && !requestFileNames(GpgME::OpenPGP)) {
             return false;
         }
         /* And then for CMS */
         return requestFileNames(GpgME::CMS);
     }
 
     if (!fileNames[protocol].isEmpty()) {
         return true;
     }
 
     const auto lastDir = ApplicationState::lastUsedExportDirectory();
 
     QString proposedFileName = lastDir + QLatin1Char('/');
     if (keys().size() == 1) {
         const bool usePGPFileExt = FileOperationsPreferences().usePGPFileExt();
         const auto key = keys().front();
         auto name = Formatting::prettyName(key);
         if (name.isEmpty()) {
             name = Formatting::prettyEMail(key);
         }
         /* Not translated so it's better to use in tutorials etc. */
         proposedFileName += QStringLiteral("%1_%2_public.%3").arg(name).arg(
                 Formatting::prettyKeyID(key.shortKeyID())).arg(
                 QString::fromLatin1(outputFileExtension(protocol == OpenPGP
                         ? Class::OpenPGP | Class::Ascii | Class::Certificate
                         : Class::CMS | Class::Ascii | Class::Certificate, usePGPFileExt)));
     }
     if (protocol == GpgME::CMS) {
         if (!fileNames[GpgME::OpenPGP].isEmpty()) {
             /* If the user has already selected a PGP file name then use that as basis
              * for a proposal for the S/MIME file. */
             proposedFileName = fileNames[GpgME::OpenPGP];
             const int idx = proposedFileName.size() - 4;
             if (proposedFileName.endsWith(QLatin1String(".asc"))) {
                 proposedFileName.replace(idx, 4, QLatin1String(".pem"));
             }
             if (proposedFileName.endsWith(QLatin1String(".gpg")) || proposedFileName.endsWith(QLatin1String(".pgp"))) {
                 proposedFileName.replace(idx, 4, QLatin1String(".der"));
             }
         }
     }
 
     if (proposedFileName.isEmpty()) {
         proposedFileName = lastDir;
         proposedFileName += i18nc("A generic filename for exported certificates", "certificates");
         proposedFileName += protocol == GpgME::OpenPGP ? QStringLiteral(".asc") : QStringLiteral(".pem");
     }
 
     auto fname = FileDialog::getSaveFileNameEx(parentWidgetOrView(),
                           i18nc("1 is protocol", "Export %1 Certificates", Formatting::displayName(protocol)),
                           QStringLiteral("imp"),
                           proposedFileName,
                           protocol == GpgME::OpenPGP
                           ? i18n("OpenPGP Certificates") + QLatin1String(" (*.asc *.gpg *.pgp)")
                           : i18n("S/MIME Certificates")  + QLatin1String(" (*.pem *.der)"));
 
     if (!fname.isEmpty() && protocol == GpgME::CMS && fileNames[GpgME::OpenPGP] == fname) {
         KMessageBox::error(parentWidgetOrView(),
                          i18n("You have to select different filenames for different protocols."),
                          i18n("Export Error"));
         return false;
     }
     const QFileInfo fi(fname);
     if (fi.suffix().isEmpty()) {
         fname += protocol == GpgME::OpenPGP ? QStringLiteral(".asc") : QStringLiteral(".pem");
     }
 
     fileNames[protocol] = fname;
     ApplicationState::setLastUsedExportDirectory(fi.absolutePath());
     return !fname.isEmpty();
 }
 
 void ExportCertificateCommand::Private::startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys)
 {
     Q_ASSERT(protocol != GpgME::UnknownProtocol);
 
     const QGpgME::Protocol *const backend = (protocol == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     Q_ASSERT(backend);
     const QString fileName = fileNames[protocol];
     const bool binary = protocol == GpgME::OpenPGP
                         ? fileName.endsWith(QLatin1String(".gpg"), Qt::CaseInsensitive) || fileName.endsWith(QLatin1String(".pgp"), Qt::CaseInsensitive)
                         : fileName.endsWith(QLatin1String(".der"), Qt::CaseInsensitive);
     std::unique_ptr<ExportJob> job(backend->publicKeyExportJob(!binary));
     Q_ASSERT(job.get());
 
     connect(job.get(), &QGpgME::ExportJob::result, q, [this](const GpgME::Error &result, const QByteArray &keyData) {
         exportResult(result, keyData);
     });
 
-    connect(job.get(), &Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(job.get(), &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(job.get(), &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
 
     QStringList fingerprints;
     fingerprints.reserve(keys.size());
     for (const Key &i : keys) {
         fingerprints << QLatin1String(i.primaryFingerprint());
     }
 
     const GpgME::Error err = job->start(fingerprints);
     if (err) {
         showError(err);
         finished();
         return;
     }
     Q_EMIT q->info(i18n("Exporting certificates..."));
     ++jobsPending;
     const QPointer<ExportJob> exportJob(job.release());
 
     outFileForSender[exportJob.data()] = fileName;
     (protocol == CMS ? cmsJob : pgpJob) = exportJob;
 }
 
 void ExportCertificateCommand::Private::showError(const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n("<qt><p>An error occurred while trying to export "
                              "the certificate:</p>"
                              "<p><b>%1</b></p></qt>",
                              QString::fromLocal8Bit(err.asString()));
     error(msg, i18n("Certificate Export Failed"));
 }
 
 void ExportCertificateCommand::doCancel()
 {
     d->cancelJobs();
 }
 
 void ExportCertificateCommand::Private::finishedIfLastJob()
 {
     if (jobsPending <= 0) {
         finished();
     }
 }
 
 static bool write_complete(QIODevice &iod, const QByteArray &data)
 {
     qint64 total = 0;
     qint64 toWrite = data.size();
     while (total < toWrite) {
         const qint64 written = iod.write(data.data() + total, toWrite);
         if (written < 0) {
             return false;
         }
         total += written;
         toWrite -= written;
     }
     return true;
 }
 
 void ExportCertificateCommand::Private::exportResult(const GpgME::Error &err, const QByteArray &data)
 {
     Q_ASSERT(jobsPending > 0);
     --jobsPending;
 
     Q_ASSERT(outFileForSender.contains(q->sender()));
     const QString outFile = outFileForSender[q->sender()];
 
     if (err) {
         showError(err);
         finishedIfLastJob();
         return;
     }
     QSaveFile savefile(outFile);
     //TODO: use KIO
     const QString writeErrorMsg = i18n("Could not write to file %1.",  outFile);
     const QString errorCaption = i18n("Certificate Export Failed");
     if (!savefile.open(QIODevice::WriteOnly)) {
         error(writeErrorMsg, errorCaption);
         finishedIfLastJob();
         return;
     }
 
     if (!write_complete(savefile, data) ||
             !savefile.commit()) {
         error(writeErrorMsg, errorCaption);
     }
     finishedIfLastJob();
 }
 
 void ExportCertificateCommand::Private::cancelJobs()
 {
     if (cmsJob) {
         cmsJob->slotCancel();
     }
     if (pgpJob) {
         pgpJob->slotCancel();
     }
 }
 
 #undef d
 #undef q
 
 #include "moc_exportcertificatecommand.cpp"
diff --git a/src/commands/exportgroupscommand.cpp b/src/commands/exportgroupscommand.cpp
index 6de8b1bc0..c63fdcc8b 100644
--- a/src/commands/exportgroupscommand.cpp
+++ b/src/commands/exportgroupscommand.cpp
@@ -1,297 +1,302 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     exportgroupscommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "exportgroupscommand.h"
 #include "command_p.h"
 
 #include <utils/applicationstate.h>
 #include "utils/filedialog.h"
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/KeyGroup>
 #include <Libkleo/KeyGroupImportExport>
 #include <Libkleo/KeyHelpers>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/ExportJob>
 
 #include <QFileInfo>
 #include <QStandardPaths>
 
 #include <memory>
 #include <vector>
 
 using namespace Kleo;
 using namespace GpgME;
 using namespace QGpgME;
 
 namespace
 {
 
 static const QString certificateGroupFileExtension{QLatin1String{".kgrp"}};
 
 QString proposeFilename(const std::vector<KeyGroup> &groups)
 {
     QString filename;
 
     filename = ApplicationState::lastUsedExportDirectory() + QLatin1Char{'/'};
     if (groups.size() == 1) {
         filename += groups.front().name().replace(QLatin1Char{'/'}, QLatin1Char{'_'});
     } else {
         filename += i18nc("A generic filename for exported certificate groups", "certificate groups");
     }
 
     return filename + certificateGroupFileExtension;
 }
 
 QString requestFilename(QWidget *parent, const std::vector<KeyGroup> &groups)
 {
     const QString proposedFilename = proposeFilename(groups);
 
     auto filename = FileDialog::getSaveFileNameEx(
         parent,
         i18ncp("@title:window", "Export Certificate Group", "Export Certificate Groups", groups.size()),
         QStringLiteral("imp"),
         proposedFilename,
         i18nc("filename filter like Certificate Groups (*.foo)", "Certificate Groups (*%1)", certificateGroupFileExtension));
     if (!filename.isEmpty()) {
         const QFileInfo fi{filename};
         if (fi.suffix().isEmpty()) {
             filename += certificateGroupFileExtension;
         }
         ApplicationState::setLastUsedExportDirectory(filename);
     }
 
     return filename;
 }
 
 }
 
 class ExportGroupsCommand::Private : public Command::Private
 {
     friend class ::ExportGroupsCommand;
     ExportGroupsCommand *q_func() const
     {
         return static_cast<ExportGroupsCommand *>(q);
     }
 public:
     explicit Private(ExportGroupsCommand *qq);
     ~Private() override;
 
     void start();
 
     bool exportGroups();
     bool startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys);
 
     void onExportJobResult(const QGpgME::Job *job, const GpgME::Error &err, const QByteArray &keyData);
 
     void cancelJobs();
     void showError(const GpgME::Error &err);
 
     void finishedIfLastJob(const QGpgME::Job *job);
 
 private:
     std::vector<KeyGroup> groups;
     QString filename;
     std::vector<QPointer<QGpgME::Job>> exportJobs;
 };
 
 ExportGroupsCommand::Private *ExportGroupsCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ExportGroupsCommand::Private *ExportGroupsCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ExportGroupsCommand::Private::Private(ExportGroupsCommand *qq)
     : Command::Private(qq)
 {
 }
 
 ExportGroupsCommand::Private::~Private() = default;
 
 void ExportGroupsCommand::Private::start()
 {
     if (groups.empty()) {
         finished();
         return;
     }
 
     filename = requestFilename(parentWidgetOrView(), groups);
     if (filename.isEmpty()) {
         canceled();
         return;
     }
 
     const auto groupKeys = std::accumulate(std::begin(groups), std::end(groups),
                                            KeyGroup::Keys{},
                                            [](auto allKeys, const auto &group) {
                                                 const auto keys = group.keys();
                                                 allKeys.insert(std::begin(keys), std::end(keys));
                                                 return allKeys;
                                            });
 
     std::vector<Key> openpgpKeys;
     std::vector<Key> cmsKeys;
     std::partition_copy(std::begin(groupKeys), std::end(groupKeys),
                         std::back_inserter(openpgpKeys),
                         std::back_inserter(cmsKeys),
                         [](const GpgME::Key &key) {
                             return key.protocol() == GpgME::OpenPGP;
                         });
 
     // remove/overwrite existing file
     if (QFile::exists(filename) && !QFile::remove(filename)) {
         error(xi18n("Cannot overwrite existing <filename>%1</filename>.", filename),
               i18nc("@title:window", "Export Failed"));
         finished();
         return;
     }
     if (!exportGroups()) {
         finished();
         return;
     }
     if (!openpgpKeys.empty()) {
         if (!startExportJob(GpgME::OpenPGP, openpgpKeys)) {
             finished();
             return;
         }
     }
     if (!cmsKeys.empty()) {
         if (!startExportJob(GpgME::CMS, cmsKeys)) {
             finishedIfLastJob(nullptr);
         }
     }
 }
 
 bool ExportGroupsCommand::Private::exportGroups()
 {
     const auto result = writeKeyGroups(filename, groups);
     if (result != WriteKeyGroups::Success) {
         error(xi18n("Writing groups to file <filename>%1</filename> failed.", filename),
               i18nc("@title:window", "Export Failed"));
     }
     return result == WriteKeyGroups::Success;
 }
 
 bool ExportGroupsCommand::Private::startExportJob(GpgME::Protocol protocol, const std::vector<Key> &keys)
 {
     const QGpgME::Protocol *const backend = (protocol == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     Q_ASSERT(backend);
     std::unique_ptr<ExportJob> jobOwner(backend->publicKeyExportJob(/*armor=*/ true));
     auto job = jobOwner.get();
     Q_ASSERT(job);
 
     connect(job, &ExportJob::result,
             q, [this, job](const GpgME::Error &err, const QByteArray &keyData) {
                 onExportJobResult(job, err, keyData);
             });
-    connect(job, &Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(job, &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(job, &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
 
     const GpgME::Error err = job->start(Kleo::getFingerprints(keys));
     if (err) {
         showError(err);
         return false;
     }
     Q_EMIT q->info(i18n("Exporting certificate groups..."));
 
     exportJobs.push_back(jobOwner.release());
     return true;
 }
 
 void ExportGroupsCommand::Private::onExportJobResult(const QGpgME::Job *job, const GpgME::Error &err, const QByteArray &keyData)
 {
     Q_ASSERT(Kleo::contains(exportJobs, job));
 
     if (err) {
         showError(err);
         finishedIfLastJob(job);
         return;
     }
 
     QFile f{filename};
     if (!f.open(QIODevice::WriteOnly | QIODevice::Append)) {
         error(xi18n("Cannot open file <filename>%1</filename> for writing.", filename),
               i18nc("@title:window", "Export Failed"));
         finishedIfLastJob(job);
         return;
     }
 
     const auto bytesWritten = f.write(keyData);
     if (bytesWritten != keyData.size()) {
         error(xi18n("Writing certificates to file <filename>%1</filename> failed.", filename),
               i18nc("@title:window", "Export Failed"));
     }
 
     finishedIfLastJob(job);
 }
 
 void ExportGroupsCommand::Private::showError(const GpgME::Error &err)
 {
     error(xi18n("<para>An error occurred during the export:</para>"
                 "<para><message>%1</message></para>",
                 QString::fromLocal8Bit(err.asString())),
           i18nc("@title:window", "Export Failed"));
 }
 
 void ExportGroupsCommand::Private::finishedIfLastJob(const QGpgME::Job *job)
 {
     if (job) {
         exportJobs.erase(std::remove(exportJobs.begin(), exportJobs.end(), job), exportJobs.end());
     }
     if (exportJobs.size() == 0) {
         finished();
     }
 }
 
 void ExportGroupsCommand::Private::cancelJobs()
 {
     std::for_each(std::cbegin(exportJobs), std::cend(exportJobs),
                   [](const auto &job) {
                       if (job) {
                           job->slotCancel();
                       }
                   });
     exportJobs.clear();
 }
 
 ExportGroupsCommand::ExportGroupsCommand(const std::vector<KeyGroup> &groups)
     : Command{new Private{this}}
 {
     d->groups = groups;
 }
 
 ExportGroupsCommand::~ExportGroupsCommand() = default;
 
 void ExportGroupsCommand::doStart()
 {
     d->start();
 }
 
 void ExportGroupsCommand::doCancel()
 {
     d->cancelJobs();
 }
 
 #undef d
 #undef q
 
 #include "moc_exportgroupscommand.cpp"
diff --git a/src/commands/exportsecretkeycommand.cpp b/src/commands/exportsecretkeycommand.cpp
index ba3b91d15..cf8cf9ee9 100644
--- a/src/commands/exportsecretkeycommand.cpp
+++ b/src/commands/exportsecretkeycommand.cpp
@@ -1,311 +1,316 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/exportsecretkeycommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     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-kleopatra.h>
 
 #include "exportsecretkeycommand.h"
 #include "command_p.h"
 
 #include "fileoperationspreferences.h"
 #include <utils/applicationstate.h>
 #include "utils/filedialog.h"
 
 #include <Libkleo/Classify>
 #include <Libkleo/Formatting>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/ExportJob>
 
 #include <QFileInfo>
 #include <QStandardPaths>
 
 #include <gpgme++/context.h>
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include <kleopatra_debug.h>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 namespace
 {
 
 QString openPGPCertificateFileExtension()
 {
     return QLatin1String{outputFileExtension(Class::OpenPGP | Class::Ascii | Class::Certificate,
                                              FileOperationsPreferences().usePGPFileExt())};
 }
 
 QString cmsCertificateFileExtension()
 {
     return QLatin1String{outputFileExtension(Class::CMS | Class::Binary | Class::ExportedPSM,
                                              /*usePGPFileExt=*/false)};
 }
 
 QString certificateFileExtension(GpgME::Protocol protocol)
 {
     switch (protocol) {
     case GpgME::OpenPGP:
         return openPGPCertificateFileExtension();
     case GpgME::CMS:
         return cmsCertificateFileExtension();
     default:
         qCWarning(KLEOPATRA_LOG) << __func__ << "Error: Unknown protocol" << protocol;
         return QStringLiteral("txt");
     }
 }
 
 QString proposeFilename(const Key &key)
 {
     QString filename;
 
     auto name = Formatting::prettyName(key);
     if (name.isEmpty()) {
         name = Formatting::prettyEMail(key);
     }
     const auto shortKeyID = Formatting::prettyKeyID(key.shortKeyID());
     /* Not translated so it's better to use in tutorials etc. */
     filename = QStringView{u"%1_%2_SECRET"}.arg(name, shortKeyID);
     filename.replace(u'/', u'_');
 
     return ApplicationState::lastUsedExportDirectory() + u'/' + filename + u'.' + certificateFileExtension(key.protocol());
 }
 
 QString secretKeyFileFilters(GpgME::Protocol protocol)
 {
     switch (protocol) {
     case GpgME::OpenPGP:
         return i18nc("description of filename filter", "Secret Key Files") + QLatin1String{" (*.asc *.gpg *.pgp)"};
     case GpgME::CMS:
         return i18nc("description of filename filter", "Secret Key Files") + QLatin1String{" (*.p12)"};
     default:
         qCWarning(KLEOPATRA_LOG) << __func__ << "Error: Unknown protocol" << protocol;
         return i18nc("description of filename filter", "All Files") + QLatin1String{" (*)"};
     }
 }
 
 QString requestFilename(const Key &key, const QString &proposedFilename, QWidget *parent)
 {
     auto filename = FileDialog::getSaveFileNameEx(
         parent,
         i18nc("@title:window", "Secret Key Backup"),
         QStringLiteral("imp"),
         proposedFilename,
         secretKeyFileFilters(key.protocol()));
 
     if (!filename.isEmpty()) {
         const QFileInfo fi{filename};
         if (fi.suffix().isEmpty()) {
             filename += u'.' + certificateFileExtension(key.protocol());
         }
         ApplicationState::setLastUsedExportDirectory(filename);
     }
 
     return filename;
 }
 
 QString errorCaption()
 {
     return i18nc("@title:window", "Secret Key Backup Error");
 }
 
 }
 
 class ExportSecretKeyCommand::Private : public Command::Private
 {
     friend class ::ExportSecretKeyCommand;
     ExportSecretKeyCommand *q_func() const
     {
         return static_cast<ExportSecretKeyCommand *>(q);
     }
 public:
     explicit Private(ExportSecretKeyCommand *qq, KeyListController *c = nullptr);
     ~Private() override;
 
     void start();
     void cancel();
 
 private:
     std::unique_ptr<QGpgME::ExportJob> startExportJob(const Key &key);
     void onExportJobResult(const Error &err, const QByteArray &keyData);
     void showError(const Error &err);
 
 private:
     QString filename;
     QPointer<QGpgME::ExportJob> job;
 };
 
 ExportSecretKeyCommand::Private *ExportSecretKeyCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ExportSecretKeyCommand::Private *ExportSecretKeyCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ExportSecretKeyCommand::Private::Private(ExportSecretKeyCommand *qq, KeyListController *c)
     : Command::Private{qq, c}
 {
 }
 
 ExportSecretKeyCommand::Private::~Private() = default;
 
 void ExportSecretKeyCommand::Private::start()
 {
     const Key key = this->key();
 
     if (key.isNull()) {
         finished();
         return;
     }
 
     filename = requestFilename(key, proposeFilename(key), parentWidgetOrView());
     if (filename.isEmpty()) {
         canceled();
         return;
     }
 
     auto exportJob = startExportJob(key);
     if (!exportJob) {
         finished();
         return;
     }
     job = exportJob.release();
 }
 
 void ExportSecretKeyCommand::Private::cancel()
 {
     if (job) {
         job->slotCancel();
     }
     job.clear();
 }
 
 std::unique_ptr<QGpgME::ExportJob> ExportSecretKeyCommand::Private::startExportJob(const Key &key)
 {
 #if QGPGME_SUPPORTS_SECRET_KEY_EXPORT
     const bool armor = key.protocol() == GpgME::OpenPGP && filename.endsWith(u".asc", Qt::CaseInsensitive);
     const QGpgME::Protocol *const backend = (key.protocol() == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     Q_ASSERT(backend);
     std::unique_ptr<QGpgME::ExportJob> exportJob{backend->secretKeyExportJob(armor)};
     Q_ASSERT(exportJob);
 
     if (key.protocol() == GpgME::CMS) {
         exportJob->setExportFlags(GpgME::Context::ExportPKCS12);
     }
 
     connect(exportJob.get(), &QGpgME::ExportJob::result,
             q, [this](const GpgME::Error &err, const QByteArray &keyData) {
                 onExportJobResult(err, keyData);
             });
-    connect(exportJob.get(), &QGpgME::Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(exportJob.get(), &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(exportJob.get(), &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
 
     const GpgME::Error err = exportJob->start({QLatin1String{key.primaryFingerprint()}});
     if (err) {
         showError(err);
         return {};
     }
     Q_EMIT q->info(i18nc("@info:status", "Backing up secret key..."));
 
     return exportJob;
 #else
     Q_UNUSED(key)
     return {};
 #endif
 }
 
 void ExportSecretKeyCommand::Private::onExportJobResult(const Error &err, const QByteArray &keyData)
 {
     if (err.isCanceled()) {
         finished();
         return;
     }
 
     if (err) {
         showError(err);
         finished();
         return;
     }
 
     if (keyData.isEmpty()) {
         error(i18nc("@info", "The result of the backup is empty. Maybe you entered an empty or a wrong passphrase."),
               errorCaption());
         finished();
         return;
     }
 
     QFile f{filename};
     if (!f.open(QIODevice::WriteOnly)) {
         error(xi18nc("@info", "Cannot open file <filename>%1</filename> for writing.", filename),
               errorCaption());
         finished();
         return;
     }
 
     const auto bytesWritten = f.write(keyData);
     if (bytesWritten != keyData.size()) {
         error(xi18nc("@info", "Writing key to file <filename>%1</filename> failed.", filename),
               errorCaption());
         finished();
         return;
     }
 
     information(i18nc("@info", "The backup of the secret key was created successfully."),
                 i18nc("@title:window", "Secret Key Backup"));
     finished();
 }
 
 void ExportSecretKeyCommand::Private::showError(const Error &err)
 {
     error(xi18nc("@info",
                  "<para>An error occurred during the backup of the secret key:</para>"
                  "<para><message>%1</message></para>",
                  QString::fromLocal8Bit(err.asString())),
           errorCaption());
 }
 
 ExportSecretKeyCommand::ExportSecretKeyCommand(QAbstractItemView *view, KeyListController *controller)
     : Command{view, new Private{this, controller}}
 {
 }
 
 ExportSecretKeyCommand::ExportSecretKeyCommand(const GpgME::Key &key)
     : Command{key, new Private{this}}
 {
 }
 
 ExportSecretKeyCommand::~ExportSecretKeyCommand() = default;
 
 void ExportSecretKeyCommand::doStart()
 {
     d->start();
 }
 
 void ExportSecretKeyCommand::doCancel()
 {
     d->cancel();
 }
 
 #undef d
 #undef q
 
 #include "moc_exportsecretkeycommand.cpp"
diff --git a/src/commands/exportsecretsubkeycommand.cpp b/src/commands/exportsecretsubkeycommand.cpp
index a35293cb2..88db09164 100644
--- a/src/commands/exportsecretsubkeycommand.cpp
+++ b/src/commands/exportsecretsubkeycommand.cpp
@@ -1,293 +1,298 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/exportsecretsubkeycommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     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-kleopatra.h>
 
 #include "exportsecretsubkeycommand.h"
 #include "command_p.h"
 
 #include "fileoperationspreferences.h"
 #include <utils/applicationstate.h>
 #if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
 #include "utils/filedialog.h"
 #endif
 
 #include <Libkleo/Classify>
 #include <Libkleo/Formatting>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <QGpgME/ExportJob>
 #include <QGpgME/Protocol>
 
 #include <QFileInfo>
 #include <QStandardPaths>
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 using namespace Kleo;
 using namespace GpgME;
 
 namespace
 {
 
 #if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
 QString openPGPCertificateFileExtension()
 {
     return QLatin1String{outputFileExtension(Class::OpenPGP | Class::Ascii | Class::Certificate,
                                              FileOperationsPreferences().usePGPFileExt())};
 }
 
 QString proposeFilename(const std::vector<Subkey> &subkeys)
 {
     QString filename;
 
     if (subkeys.size() == 1) {
         const auto subkey = subkeys.front();
         const auto key = subkey.parent();
         auto name = Formatting::prettyName(key);
         if (name.isEmpty()) {
             name = Formatting::prettyEMail(key);
         }
         const auto shortKeyID = Formatting::prettyKeyID(key.shortKeyID());
         const auto shortSubkeyID = Formatting::prettyKeyID(QByteArray{subkey.keyID()}.right(8).constData());
         const auto usage = Formatting::usageString(subkey).replace(QLatin1String{", "}, QLatin1String{"_"});
         /* Not translated so it's better to use in tutorials etc. */
         filename = QStringView{u"%1_%2_SECRET_SUBKEY_%3_%4"}.arg(
             name, shortKeyID, shortSubkeyID, usage);
     } else {
         filename = i18nc("Generic filename for exported subkeys", "subkeys");
     }
     filename.replace(u'/', u'_');
 
     return ApplicationState::lastUsedExportDirectory() + u'/' + filename + u'.' + openPGPCertificateFileExtension();
 }
 
 QString requestFilename(const std::vector<Subkey> &subkeys, const QString &proposedFilename, QWidget *parent)
 {
     auto filename = FileDialog::getSaveFileNameEx(
         parent,
         i18ncp("@title:window", "Export Subkey", "Export Subkeys", subkeys.size()),
         QStringLiteral("imp"),
         proposedFilename,
         i18nc("description of filename filter", "Secret Key Files") + QLatin1String{" (*.asc *.gpg *.pgp)"});
 
     if (!filename.isEmpty()) {
         const QFileInfo fi{filename};
         if (fi.suffix().isEmpty()) {
             filename += u'.' + openPGPCertificateFileExtension();
         }
         ApplicationState::setLastUsedExportDirectory(filename);
     }
 
     return filename;
 }
 
 template<typename SubkeyContainer>
 QStringList getSubkeyFingerprints(const SubkeyContainer &subkeys)
 {
     QStringList fingerprints;
 
     fingerprints.reserve(subkeys.size());
     std::transform(std::begin(subkeys), std::end(subkeys),
                    std::back_inserter(fingerprints),
                    [](const auto &subkey) {
                        return QLatin1String{subkey.fingerprint()} + u'!';
                    });
 
     return fingerprints;
 }
 #endif
 
 }
 
 class ExportSecretSubkeyCommand::Private : public Command::Private
 {
     friend class ::ExportSecretSubkeyCommand;
     ExportSecretSubkeyCommand *q_func() const
     {
         return static_cast<ExportSecretSubkeyCommand *>(q);
     }
 public:
     explicit Private(ExportSecretSubkeyCommand *qq);
     ~Private() override;
 
     void start();
     void cancel();
 
 private:
     std::unique_ptr<QGpgME::ExportJob> startExportJob(const std::vector<Subkey> &subkeys);
     void onExportJobResult(const Error &err, const QByteArray &keyData);
     void showError(const Error &err);
 
 private:
     std::vector<Subkey> subkeys;
     QString filename;
     QPointer<QGpgME::ExportJob> job;
 };
 
 ExportSecretSubkeyCommand::Private *ExportSecretSubkeyCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ExportSecretSubkeyCommand::Private *ExportSecretSubkeyCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ExportSecretSubkeyCommand::Private::Private(ExportSecretSubkeyCommand *qq)
     : Command::Private{qq}
 {
 }
 
 ExportSecretSubkeyCommand::Private::~Private() = default;
 
 void ExportSecretSubkeyCommand::Private::start()
 {
 #if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
     if (subkeys.empty()) {
         finished();
         return;
     }
 
     filename = requestFilename(subkeys, proposeFilename(subkeys), parentWidgetOrView());
     if (filename.isEmpty()) {
         canceled();
         return;
     }
 
     auto exportJob = startExportJob(subkeys);
     if (!exportJob) {
         finished();
         return;
     }
     job = exportJob.release();
 #else
     Q_ASSERT(!"This command is not supported by the backend it was compiled against");
     finished();
     return;
 #endif
 }
 
 void ExportSecretSubkeyCommand::Private::cancel()
 {
     if (job) {
         job->slotCancel();
     }
     job.clear();
 }
 
 std::unique_ptr<QGpgME::ExportJob> ExportSecretSubkeyCommand::Private::startExportJob(const std::vector<Subkey> &subkeys)
 {
 #if QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT
     const bool armor = filename.endsWith(u".asc", Qt::CaseInsensitive);
     std::unique_ptr<QGpgME::ExportJob> exportJob{QGpgME::openpgp()->secretSubkeyExportJob(armor)};
     Q_ASSERT(exportJob);
 
     connect(exportJob.get(), &QGpgME::ExportJob::result,
             q, [this](const GpgME::Error &err, const QByteArray &keyData) {
                 onExportJobResult(err, keyData);
             });
-    connect(exportJob.get(), &QGpgME::Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(exportJob.get(), &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(exportJob.get(), &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
 
     const GpgME::Error err = exportJob->start(getSubkeyFingerprints(subkeys));
     if (err) {
         showError(err);
         return {};
     }
     Q_EMIT q->info(i18nc("@info:status", "Exporting subkeys..."));
 
     return exportJob;
 #else
     Q_UNUSED(subkeys)
     return {};
 #endif
 }
 
 void ExportSecretSubkeyCommand::Private::onExportJobResult(const Error &err, const QByteArray &keyData)
 {
     if (err) {
         showError(err);
         finished();
         return;
     }
 
     if (keyData.isEmpty()) {
         error(i18nc("@info", "The result of the export is empty."),
               i18nc("@title:window", "Export Failed"));
         finished();
         return;
     }
 
     QFile f{filename};
     if (!f.open(QIODevice::WriteOnly)) {
         error(xi18nc("@info", "Cannot open file <filename>%1</filename> for writing.", filename),
               i18nc("@title:window", "Export Failed"));
         finished();
         return;
     }
 
     const auto bytesWritten = f.write(keyData);
     if (bytesWritten != keyData.size()) {
         error(xi18ncp("@info",
                       "Writing subkey to file <filename>%2</filename> failed.",
                       "Writing subkeys to file <filename>%2</filename> failed.",
                       subkeys.size(), filename),
               i18nc("@title:window", "Export Failed"));
         finished();
         return;
     }
 
     information(i18ncp("@info",
                        "The subkey was exported successfully.",
                        "%1 subkeys were exported successfully.",
                        subkeys.size()),
                 i18nc("@title:window", "Secret Key Backup"));
     finished();
 }
 
 void ExportSecretSubkeyCommand::Private::showError(const Error &err)
 {
     error(xi18nc("@info",
                  "<para>An error occurred during the export:</para>"
                  "<para><message>%1</message></para>",
                  QString::fromLocal8Bit(err.asString())),
           i18nc("@title:window", "Export Failed"));
 }
 
 ExportSecretSubkeyCommand::ExportSecretSubkeyCommand(const std::vector<GpgME::Subkey> &subkeys)
     : Command{new Private{this}}
 {
     d->subkeys = subkeys;
 }
 
 ExportSecretSubkeyCommand::~ExportSecretSubkeyCommand() = default;
 
 void ExportSecretSubkeyCommand::doStart()
 {
     d->start();
 }
 
 void ExportSecretSubkeyCommand::doCancel()
 {
     d->cancel();
 }
 
 #undef d
 #undef q
 
 #include "moc_exportsecretsubkeycommand.cpp"
diff --git a/src/commands/importcertificatescommand.cpp b/src/commands/importcertificatescommand.cpp
index 10ed3ee15..d74a2b4ef 100644
--- a/src/commands/importcertificatescommand.cpp
+++ b/src/commands/importcertificatescommand.cpp
@@ -1,1124 +1,1139 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/importcertificatescommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007, 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     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-kleopatra.h>
 
 #include "importcertificatescommand.h"
 #include "importcertificatescommand_p.h"
 
 #include "certifycertificatecommand.h"
 #include <utils/keys.h>
 #include <utils/memory-helpers.h>
 #include <settings.h>
 #include "kleopatra_debug.h"
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/KeyList>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyGroupImportExport>
 #include <Libkleo/KeyHelpers>
 #include <Libkleo/MessageBox>
 #include <Libkleo/Predicates>
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/ImportJob>
 #include <QGpgME/ImportFromKeyserverJob>
 #include <QGpgME/ChangeOwnerTrustJob>
 #if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
 #include <QGpgME/ReceiveKeysJob>
 #endif
 
 #include <gpgme++/global.h>
 #include <gpgme++/importresult.h>
 #include <gpgme++/context.h>
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QByteArray>
 #include <QEventLoop>
 #include <QProgressDialog>
 #include <QString>
 #include <QWidget>
 #include <QTreeView>
 #include <QTextDocument> // for Qt::escape
 
 #include <memory>
 #include <algorithm>
 #include <map>
 #include <set>
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace QGpgME;
 
 static void disconnectConnection(const QMetaObject::Connection &connection)
 {
     // trivial function for disconnecting a signal-slot connection
     QObject::disconnect(connection);
 }
 
 bool operator==(const ImportJobData &lhs, const ImportJobData &rhs)
 {
     return lhs.job == rhs.job;
 }
 
 namespace
 {
 
 make_comparator_str(ByImportFingerprint, .fingerprint());
 
 class ImportResultProxyModel : public AbstractKeyListSortFilterProxyModel
 {
     Q_OBJECT
 public:
     ImportResultProxyModel(const std::vector<ImportResultData> &results, QObject *parent = nullptr)
         : AbstractKeyListSortFilterProxyModel(parent)
     {
         updateFindCache(results);
     }
 
     ~ImportResultProxyModel() override {}
 
     ImportResultProxyModel *clone() const override
     {
         // compiler-generated copy ctor is fine!
         return new ImportResultProxyModel(*this);
     }
 
     void setImportResults(const std::vector<ImportResultData> &results)
     {
         updateFindCache(results);
         invalidateFilter();
     }
 
 protected:
     QVariant data(const QModelIndex &index, int role) const override
     {
         if (!index.isValid() || role != Qt::ToolTipRole) {
             return AbstractKeyListSortFilterProxyModel::data(index, role);
         }
         const QString fpr = index.data(KeyList::FingerprintRole).toString();
         // find information:
         const std::vector<Import>::const_iterator it
             = Kleo::binary_find(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                                 fpr.toLatin1().constData(),
                                 ByImportFingerprint<std::less>());
         if (it == m_importsByFingerprint.end()) {
             return AbstractKeyListSortFilterProxyModel::data(index, role);
         } else {
             QStringList rv;
             const auto ids = m_idsByFingerprint[it->fingerprint()];
             rv.reserve(ids.size());
             std::copy(ids.cbegin(), ids.cend(), std::back_inserter(rv));
             return Formatting::importMetaData(*it, rv);
         }
     }
     bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override
     {
         //
         // 0. Keep parents of matching children:
         //
         const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
         Q_ASSERT(index.isValid());
         for (int i = 0, end = sourceModel()->rowCount(index); i != end; ++i)
             if (filterAcceptsRow(i, index)) {
                 return true;
             }
         //
         // 1. Check that this is an imported key:
         //
         const QString fpr = index.data(KeyList::FingerprintRole).toString();
 
         return std::binary_search(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                                   fpr.toLatin1().constData(),
                                   ByImportFingerprint<std::less>());
     }
 
 private:
     void updateFindCache(const std::vector<ImportResultData> &results)
     {
         m_importsByFingerprint.clear();
         m_idsByFingerprint.clear();
         m_results = results;
         for (const auto &r : results) {
             const std::vector<Import> imports = r.result.imports();
             m_importsByFingerprint.insert(m_importsByFingerprint.end(), imports.begin(), imports.end());
             for (std::vector<Import>::const_iterator it = imports.begin(), end = imports.end(); it != end; ++it) {
                 m_idsByFingerprint[it->fingerprint()].insert(r.id);
             }
         }
         std::sort(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                   ByImportFingerprint<std::less>());
     }
 
 private:
     mutable std::vector<Import> m_importsByFingerprint;
     mutable std::map< const char *, std::set<QString>, ByImportFingerprint<std::less> > m_idsByFingerprint;
     std::vector<ImportResultData> m_results;
 };
 
 bool importFailed(const ImportResultData &r)
 {
     // ignore GPG_ERR_EOF error to handle the "failed" import of files
     // without X.509 certificates by gpgsm gracefully
     return r.result.error() && r.result.error().code() != GPG_ERR_EOF;
 }
 
 bool importWasCanceled(const ImportResultData &r)
 {
     return r.result.error().isCanceled();
 }
 
 }
 
 ImportCertificatesCommand::Private::Private(ImportCertificatesCommand *qq, KeyListController *c)
     : Command::Private(qq, c)
     , progressWindowTitle{i18nc("@title:window", "Importing Certificates")}
     , progressLabelText{i18n("Importing certificates... (this can take a while)")}
 {
 }
 
 ImportCertificatesCommand::Private::~Private()
 {
     if (progressDialog) {
         delete progressDialog;
     }
 }
 
 #define d d_func()
 #define q q_func()
 
 ImportCertificatesCommand::ImportCertificatesCommand(KeyListController *p)
     : Command(new Private(this, p))
 {
 }
 
 ImportCertificatesCommand::ImportCertificatesCommand(QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
 }
 
 ImportCertificatesCommand::~ImportCertificatesCommand() = default;
 
 static QString format_ids(const std::vector<QString> &ids)
 {
     QStringList escapedIds;
     for (const QString &id : ids) {
         if (!id.isEmpty()) {
             escapedIds << id.toHtmlEscaped();
         }
     }
     return escapedIds.join(QLatin1String("<br>"));
 }
 
 static QString make_tooltip(const std::vector<ImportResultData> &results)
 {
     if (results.empty()) {
         return {};
     }
 
     std::vector<QString> ids;
     ids.reserve(results.size());
     std::transform(std::begin(results), std::end(results),
                    std::back_inserter(ids),
                    [](const auto &r) { return r.id; });
     std::sort(std::begin(ids), std::end(ids));
     ids.erase(std::unique(std::begin(ids), std::end(ids)), std::end(ids));
 
     if (ids.size() == 1)
         if (ids.front().isEmpty()) {
             return {};
         } else
             return i18nc("@info:tooltip",
                          "Imported Certificates from %1",
                          ids.front().toHtmlEscaped());
     else
         return i18nc("@info:tooltip",
                      "Imported certificates from these sources:<br/>%1",
                      format_ids(ids));
 }
 
 void ImportCertificatesCommand::Private::setImportResultProxyModel(const std::vector<ImportResultData> &results)
 {
     if (std::none_of(std::begin(results), std::end(results),
                      [](const auto &r) { return r.result.numConsidered() > 0; })) {
         return;
     }
     q->addTemporaryView(i18nc("@title:tab", "Imported Certificates"),
                         new ImportResultProxyModel(results),
                         make_tooltip(results));
     if (QTreeView *const tv = qobject_cast<QTreeView *>(parentWidgetOrView())) {
         tv->expandAll();
     }
 }
 
 int sum(const std::vector<ImportResult> &res, int (ImportResult::*fun)() const)
 {
     return kdtools::accumulate_transform(res.begin(), res.end(), std::mem_fn(fun), 0);
 }
 
 static QString make_report(const std::vector<ImportResultData> &results,
                            const std::vector<ImportedGroup> &groups)
 {
     const KLocalizedString normalLine = ki18n("<tr><td align=\"right\">%1</td><td>%2</td></tr>");
     const KLocalizedString boldLine = ki18n("<tr><td align=\"right\"><b>%1</b></td><td>%2</td></tr>");
     const KLocalizedString headerLine = ki18n("<tr><th colspan=\"2\" align=\"center\">%1</th></tr>");
 
     std::vector<ImportResult> res;
     res.reserve(results.size());
     std::transform(std::begin(results), std::end(results),
                    std::back_inserter(res),
                    [](const auto &r) { return r.result; });
 
     const auto numProcessedCertificates = sum(res, &ImportResult::numConsidered);
 
     QStringList lines;
 
     if (numProcessedCertificates > 0 || groups.size() == 0) {
         lines.push_back(headerLine.subs(i18n("Certificates")).toString());
         lines.push_back(normalLine.subs(i18n("Total number processed:"))
                         .subs(numProcessedCertificates).toString());
         lines.push_back(normalLine.subs(i18n("Imported:"))
                         .subs(sum(res, &ImportResult::numImported)).toString());
         if (const int n = sum(res, &ImportResult::newSignatures))
             lines.push_back(normalLine.subs(i18n("New signatures:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::newUserIDs))
             lines.push_back(normalLine.subs(i18n("New user IDs:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numKeysWithoutUserID))
             lines.push_back(normalLine.subs(i18n("Certificates without user IDs:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::newSubkeys))
             lines.push_back(normalLine.subs(i18n("New subkeys:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::newRevocations))
             lines.push_back(boldLine.subs(i18n("Newly revoked:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::notImported))
             lines.push_back(boldLine.subs(i18n("Not imported:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numUnchanged))
             lines.push_back(normalLine.subs(i18n("Unchanged:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numSecretKeysConsidered))
             lines.push_back(normalLine.subs(i18n("Secret keys processed:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numSecretKeysImported))
             lines.push_back(normalLine.subs(i18n("Secret keys imported:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numSecretKeysConsidered) - sum(res, &ImportResult::numSecretKeysImported) - sum(res, &ImportResult::numSecretKeysUnchanged))
             if (n > 0)
                 lines.push_back(boldLine.subs(i18n("Secret keys <em>not</em> imported:"))
                                 .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numSecretKeysUnchanged))
             lines.push_back(normalLine.subs(i18n("Secret keys unchanged:"))
                             .subs(n).toString());
         if (const int n = sum(res, &ImportResult::numV3KeysSkipped))
             lines.push_back(normalLine.subs(i18n("Deprecated PGP-2 keys skipped:"))
                             .subs(n).toString());
     }
 
     if (!lines.empty()) {
         lines.push_back(headerLine.subs(QLatin1String{"&nbsp;"}).toString());
     }
 
     if (groups.size() > 0) {
         const auto newGroups = std::count_if(std::begin(groups), std::end(groups),
                                              [](const auto &g) {
                                                  return g.status == ImportedGroup::Status::New;
                                              });
         const auto updatedGroups = groups.size() - newGroups;
         lines.push_back(headerLine.subs(i18n("Certificate Groups")).toString());
         lines.push_back(normalLine.subs(i18n("Total number processed:"))
                         .subs(groups.size()).toString());
         lines.push_back(normalLine.subs(i18n("New groups:"))
                         .subs(newGroups).toString());
         lines.push_back(normalLine.subs(i18n("Updated groups:"))
                         .subs(updatedGroups).toString());
     }
 
     return lines.join(QLatin1String{});
 }
 
 static bool isImportFromSingleSource(const std::vector<ImportResultData> &res)
 {
     return (res.size() == 1) || (res.size() == 2 && res[0].id == res[1].id);
 }
 
 static QString make_message_report(const std::vector<ImportResultData> &res,
                                    const std::vector<ImportedGroup> &groups)
 {
     QString report{QLatin1String{"<html>"}};
     if (res.empty()) {
         report += i18n("No imports (should not happen, please report a bug).");
     } else {
         const QString title = isImportFromSingleSource(res) && !res.front().id.isEmpty() ?
                               i18n("Detailed results of importing %1:", res.front().id) :
                               i18n("Detailed results of import:");
         report += QLatin1String{"<p>"} + title + QLatin1String{"</p>"};
         report += QLatin1String{"<p><table width=\"100%\">"};
         report += make_report(res, groups);
         report += QLatin1String{"</table></p>"};
     }
     report += QLatin1String{"</html>"};
     return report;
 }
 
 // Returns false on error, true if please certify was shown.
 bool ImportCertificatesCommand::Private::showPleaseCertify(const GpgME::Import &imp)
 {
     if (!Kleo::userHasCertificationKey()) {
         qCDebug(KLEOPATRA_LOG) << q << __func__ << "No certification key available";
         return false;
     }
 
     const char *fpr = imp.fingerprint();
     if (!fpr) {
         // WTF
         qCWarning(KLEOPATRA_LOG) << "Import without fingerprint";
         return false;
     }
     // Exactly one public key imported. Let's see if it is openpgp. We are async here so
     // we can just fetch it.
 
     auto ctx = wrap_unique(GpgME::Context::createForProtocol(GpgME::OpenPGP));
     if (!ctx) {
         // WTF
         qCWarning(KLEOPATRA_LOG) << "Failed to create OpenPGP proto";
         return false;
     }
     ctx->addKeyListMode(KeyListMode::WithSecret);
     GpgME::Error err;
     const auto key = ctx->key(fpr, err, false);
 
     if (key.isNull() || err) {
         // No such key most likely not OpenPGP
         return false;
     }
     if (!Kleo::canBeCertified(key)) {
         // key is expired or revoked
         return false;
     }
     if (key.hasSecret()) {
         qCDebug(KLEOPATRA_LOG) << q << __func__ << "Secret key is available -> skipping certification";
         return false;
     }
 
     for (const auto &uid: key.userIDs()) {
         if (uid.validity() >= GpgME::UserID::Marginal) {
             // Already marginal so don't bug the user
             return false;
         }
     }
 
     const QStringList suggestions = QStringList() << i18n("A phone call to the person.")
         << i18n("Using a business card.")
         << i18n("Confirming it on a trusted website.");
 
     auto sel = KMessageBox::questionTwoActions(parentWidgetOrView(),
                                                i18n("In order to mark the certificate as valid it needs to be certified.") + QStringLiteral("<br>")
                                                    + i18n("Certifying means that you check the Fingerprint.") + QStringLiteral("<br>")
                                                    + i18n("Some suggestions to do this are:")
                                                    + QStringLiteral("<li><ul>%1").arg(suggestions.join(QStringLiteral("</ul><ul>")))
                                                    + QStringLiteral("</ul></li>") + i18n("Do you wish to start this process now?"),
                                                i18nc("@title", "You have imported a new certificate (public key)"),
                                                KGuiItem(i18nc("@action:button", "Certify")),
                                                KStandardGuiItem::cancel(),
                                                QStringLiteral("CertifyQuestion"));
     if (sel == KMessageBox::ButtonCode::PrimaryAction) {
         QEventLoop loop;
         auto cmd = new Commands::CertifyCertificateCommand(key);
         cmd->setParentWidget(parentWidgetOrView());
         connect(cmd, &Command::finished, &loop, &QEventLoop::quit);
         QMetaObject::invokeMethod(cmd, &Commands::CertifyCertificateCommand::start, Qt::QueuedConnection);
         loop.exec();
     }
     return true;
 }
 
 namespace
 {
 /**
  * Returns the Import of an OpenPGP key, if a single certificate was imported and this was an OpenPGP key.
  * Otherwise, returns a null Import.
  */
 auto getSingleOpenPGPImport(const std::vector<ImportResultData> &res)
 {
     static const Import nullImport;
     if (!isImportFromSingleSource(res)) {
         return nullImport;
     }
     const auto numImported = std::accumulate(res.cbegin(), res.cend(), 0, [](auto s, const auto &r) {
         return s + r.result.numImported();
     });
     if (numImported > 1) {
         return nullImport;
     }
     if ((res.size() >= 1) && (res[0].protocol == GpgME::OpenPGP) && (res[0].result.numImported() == 1) && (res[0].result.imports().size() == 1)) {
         return res[0].result.imports()[0];
     } else if ((res.size() == 2) && (res[1].protocol == GpgME::OpenPGP) && (res[1].result.numImported() == 1) && (res[1].result.imports().size() == 1)) {
         return res[1].result.imports()[0];
     }
     return nullImport;
 }
 
 auto consolidatedAuditLogEntries(const std::vector<ImportResultData> &res)
 {
     static const QString gpg = QStringLiteral("gpg");
     static const QString gpgsm = QStringLiteral("gpgsm");
 
     if (res.size() == 1) {
         return res.front().auditLog;
     }
     QStringList auditLogs;
     auto extractAndAnnotateAuditLog = [](const ImportResultData &r) {
         QString s;
         if (!r.id.isEmpty()) {
             const auto program = r.protocol == GpgME::OpenPGP ? gpg : gpgsm;
             const auto headerLine = i18nc("file name (imported with gpg/gpgsm)", "%1 (imported with %2)").arg(r.id, program);
             s += QStringLiteral("<div><b>%1</b></div>").arg(headerLine);
         }
         if (r.auditLog.error().code() == GPG_ERR_NO_DATA) {
             s += QStringLiteral("<em>") + i18nc("@info", "Audit log is empty.") + QStringLiteral("</em>");
         } else if (r.result.error().isCanceled()) {
             s += QStringLiteral("<em>") + i18nc("@info", "Import was canceled.") + QStringLiteral("</em>");
         } else {
             s += r.auditLog.text();
         }
         return s;
     };
     std::transform(res.cbegin(), res.cend(), std::back_inserter(auditLogs), extractAndAnnotateAuditLog);
     return AuditLogEntry{auditLogs.join(QLatin1String{"<hr>"}), Error{}};
 }
 }
 
 void ImportCertificatesCommand::Private::showDetails(const std::vector<ImportResultData> &res,
                                                      const std::vector<ImportedGroup> &groups)
 {
     const auto singleOpenPGPImport = getSingleOpenPGPImport(res);
     if (!singleOpenPGPImport.isNull()) {
         if (showPleaseCertify(singleOpenPGPImport)) {
             return;
         }
     }
     setImportResultProxyModel(res);
     MessageBox::information(parentWidgetOrView(), make_message_report(res, groups), consolidatedAuditLogEntries(res), i18n("Certificate Import Result"));
 }
 
 static QString make_error_message(const Error &err, const QString &id)
 {
     Q_ASSERT(err);
     Q_ASSERT(!err.isCanceled());
     return id.isEmpty()
            ? i18n("<qt><p>An error occurred while trying "
                   "to import the certificate:</p>"
                   "<p><b>%1</b></p></qt>",
                   QString::fromLocal8Bit(err.asString()))
            : i18n("<qt><p>An error occurred while trying "
                   "to import the certificate %1:</p>"
                   "<p><b>%2</b></p></qt>",
                   id, QString::fromLocal8Bit(err.asString()));
 }
 
 void ImportCertificatesCommand::Private::showError(const ImportResultData &result)
 {
     MessageBox::error(parentWidgetOrView(), make_error_message(result.result.error(), result.id), result.auditLog);
 }
 
 void ImportCertificatesCommand::Private::setWaitForMoreJobs(bool wait)
 {
     if (wait == waitForMoreJobs) {
         return;
     }
     waitForMoreJobs = wait;
     if (!waitForMoreJobs) {
         tryToFinish();
     }
 }
 
 void ImportCertificatesCommand::Private::onImportResult(const ImportResult &result, QGpgME::Job *finishedJob)
 {
     if (!finishedJob) {
         finishedJob = qobject_cast<QGpgME::Job *>(q->sender());
     }
     Q_ASSERT(finishedJob);
     qCDebug(KLEOPATRA_LOG) << q << __func__ << finishedJob;
 
     auto it = std::find_if(std::begin(runningJobs), std::end(runningJobs),
                            [finishedJob](const auto &job) { return job.job == finishedJob; });
     Q_ASSERT(it != std::end(runningJobs));
     if (it == std::end(runningJobs)) {
         qCWarning(KLEOPATRA_LOG) << __func__ << "Error: Finished job not found";
         return;
     }
 
     Kleo::for_each(it->connections, &disconnectConnection);
     it->connections.clear();
 
     increaseProgressValue();
 
     const auto job = *it;
     addImportResult({job.id, job.protocol, job.type, result, AuditLogEntry::fromJob(finishedJob)}, job);
 }
 
 void ImportCertificatesCommand::Private::addImportResult(const ImportResultData &result, const ImportJobData &job)
 {
     qCDebug(KLEOPATRA_LOG) << q << __func__ << result.id << "Result:" << result.result.error().asString();
     results.push_back(result);
 
     if (importFailed(result)) {
         showError(result);
     }
 
     if (job.job) {
         const auto count = std::erase(runningJobs, job);
         Q_ASSERT(count == 1);
     }
 
     tryToFinish();
 }
 
 static void handleOwnerTrust(const std::vector<ImportResultData> &results, QWidget *dialog)
 {
     for (const auto &r: results) {
         if (r.protocol != GpgME::Protocol::OpenPGP) {
             qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping non-OpenPGP import";
             continue;
         }
         const auto imports = r.result.imports();
         for (const auto &import : imports) {
             if (!(import.status() & (Import::Status::NewKey | Import::Status::ContainedSecretKey))) {
                 qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping already known imported public key";
                 continue;
             }
             const char *fpr = import.fingerprint();
             if (!fpr) {
                 qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping import without fingerprint";
                 continue;
             }
 
             GpgME::Error err;
             auto ctx = wrap_unique(Context::createForProtocol(GpgME::Protocol::OpenPGP));
             if (!ctx){
                 qCWarning(KLEOPATRA_LOG) << "Failed to get context";
                 continue;
             }
 
             ctx->addKeyListMode(KeyListMode::WithSecret);
             const Key toTrustOwner = ctx->key(fpr, err, false);
 
             if (toTrustOwner.isNull() || !toTrustOwner.hasSecret()) {
                 continue;
             }
             if (toTrustOwner.ownerTrust() == Key::OwnerTrust::Ultimate) {
                 qCDebug(KLEOPATRA_LOG) << __func__ << "Skipping key with ultimate ownertrust";
                 continue;
             }
 
             const auto toTrustOwnerUserIDs{toTrustOwner.userIDs()};
             // ki18n(" ") as initializer because initializing with empty string leads to
             // (I18N_EMPTY_MESSAGE)
             const KLocalizedString uids = std::accumulate(toTrustOwnerUserIDs.cbegin(), toTrustOwnerUserIDs.cend(), KLocalizedString{ki18n(" ")}, [](KLocalizedString temp, const auto &uid) {
                 return kxi18nc("@info", "%1<item>%2</item>").subs(temp).subs(Formatting::prettyNameAndEMail(uid));
             });
 
             const QString str = xi18nc("@info",
                 "<para>You have imported a certificate with fingerprint</para>"
                 "<para><numid>%1</numid></para>"
                 "<para>"
                 "and user IDs"
                 "<list>%2</list>"
                 "</para>"
                 "<para>Is this your own certificate?</para>",
                 Formatting::prettyID(fpr),
                 uids);
 
             int k = KMessageBox::questionTwoActionsCancel(dialog,
                                                           str,
                                                           i18nc("@title:window", "Mark Own Certificate"),
                                                           KGuiItem{i18nc("@action:button", "Yes, It's Mine")},
                                                           KGuiItem{i18nc("@action:button", "No, It's Not Mine")});
 
             if (k == KMessageBox::ButtonCode::PrimaryAction) {
                 //To use the ChangeOwnerTrustJob over
                 //the CryptoBackendFactory
                 const QGpgME::Protocol *const backend = QGpgME::openpgp();
 
                 if (!backend){
                     qCWarning(KLEOPATRA_LOG) << "Failed to get CryptoBackend";
                     return;
                 }
 
                 ChangeOwnerTrustJob *const j = backend->changeOwnerTrustJob();
                 j->start(toTrustOwner, Key::Ultimate);
             } else if (k == KMessageBox::ButtonCode::Cancel) {
                 // do not bother the user with further "Is this yours?" questions
                 return;
             }
         }
     }
 }
 
 static void validateImportedCertificate(const GpgME::Import &import)
 {
     if (const auto fpr = import.fingerprint()) {
         auto key = KeyCache::instance()->findByFingerprint(fpr);
         if (!key.isNull()) {
             // this triggers a keylisting with validation for this certificate
             key.update();
         } else {
             qCWarning(KLEOPATRA_LOG) << __func__ << "Certificate with fingerprint" << fpr << "not found";
         }
     }
 }
 
 static void handleExternalCMSImports(const std::vector<ImportResultData> &results)
 {
     // For external CMS Imports we have to manually do a keylist
     // with validation to get the intermediate and root ca imported
     // automatically if trusted-certs and extra-certs are used.
     for (const auto &r : results) {
         if (r.protocol == GpgME::CMS && r.type == ImportType::External
                 && !importFailed(r) && !importWasCanceled(r)) {
             const auto imports = r.result.imports();
             std::for_each(std::begin(imports), std::end(imports), &validateImportedCertificate);
         }
     }
 }
 
 void ImportCertificatesCommand::Private::processResults()
 {
     importGroups();
 
 #if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
     if (Settings{}.retrieveSignerKeysAfterImport() && !importingSignerKeys) {
         importingSignerKeys = true;
         const auto missingSignerKeys = getMissingSignerKeyIds(results);
         if (!missingSignerKeys.empty()) {
             importSignerKeys(missingSignerKeys);
             return;
         }
     }
 #endif
 
     handleExternalCMSImports(results);
 
     // ensure that the progress dialog is closed before we show any other dialogs
     setProgressToMaximum();
 
     handleOwnerTrust(results, parentWidgetOrView());
 
     showDetails(results, importedGroups);
 
     auto tv = dynamic_cast<QTreeView *> (view());
     if (!tv) {
         qCDebug(KLEOPATRA_LOG) << "Failed to find treeview";
     } else {
         tv->expandAll();
     }
     finished();
 }
 
 void ImportCertificatesCommand::Private::tryToFinish()
 {
     qCDebug(KLEOPATRA_LOG) << q << __func__;
     if (waitForMoreJobs) {
         qCDebug(KLEOPATRA_LOG) << q << __func__ << "Waiting for more jobs -> keep going";
         return;
     }
     if (!runningJobs.empty()) {
         qCDebug(KLEOPATRA_LOG) << q << __func__ << "There are unfinished jobs -> keep going";
         return;
     }
 #if QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
     if (!pendingJobs.empty()) {
         qCDebug(KLEOPATRA_LOG) << q << __func__ << "There are pending jobs -> start the next one";
         auto job = pendingJobs.front();
         pendingJobs.pop();
         job.job->startNow();
         runningJobs.push_back(job);
         return;
     }
 #endif
 
     if (keyListConnection) {
         qCWarning(KLEOPATRA_LOG) << q << __func__ << "There is already a valid keyListConnection!";
     } else {
         auto keyCache = KeyCache::mutableInstance();
         keyListConnection = connect(keyCache.get(), &KeyCache::keyListingDone,
                                     q, [this]() { keyCacheUpdated(); });
         keyCache->startKeyListing();
     }
 }
 
 void ImportCertificatesCommand::Private::keyCacheUpdated()
 {
     qCDebug(KLEOPATRA_LOG) << q << __func__;
     if (!disconnect(keyListConnection)) {
         qCWarning(KLEOPATRA_LOG) << q << __func__ << "Failed to disconnect keyListConnection";
     }
 
     keyCacheAutoRefreshSuspension.reset();
 
     const auto allIds = std::accumulate(std::cbegin(results), std::cend(results),
                                         std::set<QString>{},
                                         [](auto allIds, const auto &r) {
                                             allIds.insert(r.id);
                                             return allIds;
                                         });
     const auto canceledIds = std::accumulate(std::cbegin(results), std::cend(results),
                                              std::set<QString>{},
                                              [](auto canceledIds, const auto &r) {
                                                  if (importWasCanceled(r)) {
                                                      canceledIds.insert(r.id);
                                                  }
                                                  return canceledIds;
                                              });
     const auto totalConsidered = std::accumulate(std::cbegin(results), std::cend(results),
                                                  0,
                                                  [](auto totalConsidered, const auto &r) {
                                                      return totalConsidered + r.result.numConsidered();
                                                  });
     if (totalConsidered == 0 && canceledIds.size() == allIds.size()) {
         // nothing was considered for import and at least one import per id was
         // canceled => treat the command as canceled
         canceled();
         return;
     }
 
     processResults();
 }
 
 static ImportedGroup storeGroup(const KeyGroup &group, const QString &id)
 {
     const auto status = KeyCache::instance()->group(group.id()).isNull() ?
                         ImportedGroup::Status::New :
                         ImportedGroup::Status::Updated;
     if (status == ImportedGroup::Status::New) {
         KeyCache::mutableInstance()->insert(group);
     } else {
         KeyCache::mutableInstance()->update(group);
     }
     return {id, group, status};
 }
 
 void ImportCertificatesCommand::Private::importGroups()
 {
     for (const auto &path : filesToImportGroupsFrom) {
         const bool certificateImportSucceeded =
             std::any_of(std::cbegin(results), std::cend(results),
                         [path](const auto &r) {
                             return r.id == path && !importFailed(r) && !importWasCanceled(r);
                         });
         if (certificateImportSucceeded) {
             qCDebug(KLEOPATRA_LOG) << __func__ << "Importing groups from file" << path;
             const auto groups = readKeyGroups(path);
             std::transform(std::begin(groups), std::end(groups),
                            std::back_inserter(importedGroups),
                            [path](const auto &group) {
                                return storeGroup(group, path);
                            });
         }
         increaseProgressValue();
     }
     filesToImportGroupsFrom.clear();
 }
 
 static auto accumulateNewKeys(std::vector<std::string> &fingerprints, const std::vector<GpgME::Import> &imports)
 {
     return std::accumulate(std::begin(imports), std::end(imports),
                            fingerprints,
                            [](auto fingerprints, const auto &import) {
                                if (import.status() == Import::NewKey) {
                                    fingerprints.push_back(import.fingerprint());
                                }
                                return fingerprints;
                            });
 }
 
 static auto accumulateNewOpenPGPKeys(const std::vector<ImportResultData> &results)
 {
     return std::accumulate(std::begin(results), std::end(results),
                            std::vector<std::string>{},
                            [](auto fingerprints, const auto &r) {
                                if (r.protocol == GpgME::OpenPGP) {
                                    fingerprints = accumulateNewKeys(fingerprints, r.result.imports());
                                }
                                return fingerprints;
                            });
 }
 
 std::set<QString> ImportCertificatesCommand::Private::getMissingSignerKeyIds(const std::vector<ImportResultData> &results)
 {
     auto newOpenPGPKeys = KeyCache::instance()->findByFingerprint(accumulateNewOpenPGPKeys(results));
     // update all new OpenPGP keys to get information about certifications
     std::for_each(std::begin(newOpenPGPKeys), std::end(newOpenPGPKeys), std::mem_fn(&Key::update));
     auto missingSignerKeyIds = Kleo::getMissingSignerKeyIds(newOpenPGPKeys);
     return missingSignerKeyIds;
 }
 
 void ImportCertificatesCommand::Private::importSignerKeys(const std::set<QString> &keyIds)
 {
     Q_ASSERT(!keyIds.empty());
 
     setProgressLabelText(i18np("Fetching 1 signer key... (this can take a while)",
                                "Fetching %1 signer keys... (this can take a while)",
                                keyIds.size()));
 
     setWaitForMoreJobs(true);
     // start one import per key id to allow canceling the key retrieval without
     // losing already retrieved keys
     for (const auto &keyId : keyIds) {
         startImport(GpgME::OpenPGP, {keyId}, QStringLiteral("Retrieve Signer Keys"));
     }
     setWaitForMoreJobs(false);
 }
 
 static std::unique_ptr<ImportJob> get_import_job(GpgME::Protocol protocol)
 {
     Q_ASSERT(protocol != UnknownProtocol);
     if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
         return std::unique_ptr<ImportJob>(backend->importJob());
     } else {
         return std::unique_ptr<ImportJob>();
     }
 }
 
 void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const QByteArray &data, const QString &id,
                                                      [[maybe_unused]] const ImportOptions &options)
 {
     Q_ASSERT(protocol != UnknownProtocol);
 
     if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) {
         return;
     }
 
     std::unique_ptr<ImportJob> job = get_import_job(protocol);
     if (!job.get()) {
         nonWorkingProtocols.push_back(protocol);
         error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.",
                    Formatting::displayName(protocol)),
               i18n("Certificate Import Failed"));
         addImportResult({id, protocol, ImportType::Local, ImportResult{}, AuditLogEntry{}});
         return;
     }
 
     keyCacheAutoRefreshSuspension = KeyCache::mutableInstance()->suspendAutoRefresh();
 
     std::vector<QMetaObject::Connection> connections = {
         connect(job.get(), &AbstractImportJob::result, q, [this](const GpgME::ImportResult &result) { onImportResult(result); }),
-        connect(job.get(), &Job::progress,
-                q, &Command::progress)
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+        connect(job.get(), &QGpgME::Job::jobProgress,
+                q, &Command::progress),
+#else
+        connect(job.get(), &QGpgME::Job::progress,
+                q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); }),
+#endif
     };
 
 #if QGPGME_SUPPORTS_IMPORT_WITH_FILTER
     job->setImportFilter(options.importFilter);
 #endif
 #if QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN
     job->setKeyOrigin(options.keyOrigin, options.keyOriginUrl);
 #endif
 #if QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
     const GpgME::Error err = job->startLater(data);
 #else
     const GpgME::Error err = job->start(data);
 #endif
     if (err.code()) {
         addImportResult({id, protocol, ImportType::Local, ImportResult{err}, AuditLogEntry{}});
     } else {
         increaseProgressMaximum();
 #if QGPGME_SUPPORTS_DEFERRED_IMPORT_JOB
         pendingJobs.push({id, protocol, ImportType::Local, job.release(), connections});
 #else
         runningJobs.push_back({id, protocol, ImportType::Local, job.release(), connections});
 #endif
     }
 }
 
 static std::unique_ptr<ImportFromKeyserverJob> get_import_from_keyserver_job(GpgME::Protocol protocol)
 {
     Q_ASSERT(protocol != UnknownProtocol);
     if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
         return std::unique_ptr<ImportFromKeyserverJob>(backend->importFromKeyserverJob());
     } else {
         return std::unique_ptr<ImportFromKeyserverJob>();
     }
 }
 
 void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const std::vector<Key> &keys, const QString &id)
 {
     Q_ASSERT(protocol != UnknownProtocol);
 
     if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) {
         return;
     }
 
     std::unique_ptr<ImportFromKeyserverJob> job = get_import_from_keyserver_job(protocol);
     if (!job.get()) {
         nonWorkingProtocols.push_back(protocol);
         error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.",
                    Formatting::displayName(protocol)),
               i18n("Certificate Import Failed"));
         addImportResult({id, protocol, ImportType::External, ImportResult{}, AuditLogEntry{}});
         return;
     }
 
     keyCacheAutoRefreshSuspension = KeyCache::mutableInstance()->suspendAutoRefresh();
 
     std::vector<QMetaObject::Connection> connections = {
         connect(job.get(), &AbstractImportJob::result, q, [this](const GpgME::ImportResult &result) { onImportResult(result); }),
-        connect(job.get(), &Job::progress,
-                q, &Command::progress)
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+        connect(job.get(), &QGpgME::Job::jobProgress,
+                q, &Command::progress),
+#else
+        connect(job.get(), &QGpgME::Job::progress,
+                q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); }),
+#endif
     };
 
     const GpgME::Error err = job->start(keys);
     if (err.code()) {
         addImportResult({id, protocol, ImportType::External, ImportResult{err}, AuditLogEntry{}});
     } else {
         increaseProgressMaximum();
         runningJobs.push_back({id, protocol, ImportType::External, job.release(), connections});
     }
 }
 
 static auto get_receive_keys_job(GpgME::Protocol protocol)
 {
     Q_ASSERT(protocol != UnknownProtocol);
 
 #if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
     std::unique_ptr<ReceiveKeysJob> job{};
     if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
         job.reset(backend->receiveKeysJob());
     }
     return job;
 #else
     return std::unique_ptr<Job>{};
 #endif
 }
 
 void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, [[maybe_unused]] const QStringList &keyIds, const QString &id)
 {
     Q_ASSERT(protocol != UnknownProtocol);
 
     auto job = get_receive_keys_job(protocol);
     if (!job.get()) {
         qCWarning(KLEOPATRA_LOG) << "Failed to get ReceiveKeysJob for protocol" << Formatting::displayName(protocol);
         addImportResult({id, protocol, ImportType::External, ImportResult{}, AuditLogEntry{}});
         return;
     }
 
 #if QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID
     keyCacheAutoRefreshSuspension = KeyCache::mutableInstance()->suspendAutoRefresh();
 
     std::vector<QMetaObject::Connection> connections = {
         connect(job.get(), &AbstractImportJob::result, q, [this](const GpgME::ImportResult &result) {
             onImportResult(result);
         }),
-        connect(job.get(), &Job::progress,
-                q, &Command::progress)
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+        connect(job.get(), &QGpgME::Job::jobProgress,
+                q, &Command::progress),
+#else
+        connect(job.get(), &QGpgME::Job::progress,
+                q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); }),
+#endif
     };
 
     const GpgME::Error err = job->start(keyIds);
     if (err.code()) {
         addImportResult({id, protocol, ImportType::External, ImportResult{err}, AuditLogEntry{}});
     } else {
         increaseProgressMaximum();
         runningJobs.push_back({id, protocol, ImportType::External, job.release(), connections});
     }
 #endif
 }
 
 void ImportCertificatesCommand::Private::importGroupsFromFile(const QString &filename)
 {
     increaseProgressMaximum();
     filesToImportGroupsFrom.push_back(filename);
 }
 
 void ImportCertificatesCommand::Private::setUpProgressDialog()
 {
     if (progressDialog) {
         return;
     }
     progressDialog = new QProgressDialog{parentWidgetOrView()};
     // use a non-modal progress dialog to avoid reentrancy problems (and crashes) if multiple jobs finish in the same event loop cycle
     // (cf. the warning for QProgressDialog::setValue() in the API documentation)
     progressDialog->setModal(false);
     progressDialog->setWindowTitle(progressWindowTitle);
     progressDialog->setLabelText(progressLabelText);
     progressDialog->setMinimumDuration(1000);
     progressDialog->setMaximum(1);
     progressDialog->setValue(0);
     connect(progressDialog, &QProgressDialog::canceled, q, &Command::cancel);
     connect(q, &Command::finished, progressDialog, [this]() { progressDialog->accept(); });
 }
 
 void ImportCertificatesCommand::Private::setProgressWindowTitle(const QString &title)
 {
     if (progressDialog) {
         progressDialog->setWindowTitle(title);
     } else {
         progressWindowTitle = title;
     }
 }
 
 void ImportCertificatesCommand::Private::setProgressLabelText(const QString &text)
 {
     if (progressDialog) {
         progressDialog->setLabelText(text);
     } else {
         progressLabelText = text;
     }
 }
 
 void ImportCertificatesCommand::Private::increaseProgressMaximum()
 {
     setUpProgressDialog();
     progressDialog->setMaximum(progressDialog->maximum() + 1);
     qCDebug(KLEOPATRA_LOG) << __func__ << "progress:" << progressDialog->value() << "/" << progressDialog->maximum();
 }
 
 void ImportCertificatesCommand::Private::increaseProgressValue()
 {
     progressDialog->setValue(progressDialog->value() + 1);
     qCDebug(KLEOPATRA_LOG) << __func__ << "progress:" << progressDialog->value() << "/" << progressDialog->maximum();
 }
 
 void ImportCertificatesCommand::Private::setProgressToMaximum()
 {
     qCDebug(KLEOPATRA_LOG) << __func__;
     progressDialog->setValue(progressDialog->maximum());
 }
 
 void ImportCertificatesCommand::doCancel()
 {
     const auto jobsToCancel = d->runningJobs;
     std::for_each(std::begin(jobsToCancel), std::end(jobsToCancel), [this](const auto &job) {
         if (!job.connections.empty()) {
             // ignore jobs without connections; they are already completed
             qCDebug(KLEOPATRA_LOG) << "Canceling job" << job.job;
             job.job->slotCancel();
             d->onImportResult(ImportResult{Error::fromCode(GPG_ERR_CANCELED)}, job.job);
         }
     });
 }
 
 #undef d
 #undef q
 
 #include "importcertificatescommand.moc"
 #include "moc_importcertificatescommand.cpp"
diff --git a/src/commands/refreshcertificatecommand.cpp b/src/commands/refreshcertificatecommand.cpp
index 6e7fe9e65..7d0a1e7d4 100644
--- a/src/commands/refreshcertificatecommand.cpp
+++ b/src/commands/refreshcertificatecommand.cpp
@@ -1,293 +1,303 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/refreshcertificatecommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     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-kleopatra.h>
 
 #include "refreshcertificatecommand.h"
 #include "command_p.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QGpgME/Protocol>
 #if QGPGME_SUPPORTS_KEY_REFRESH
 #include <QGpgME/RefreshKeysJob>
 #include <QGpgME/ReceiveKeysJob>
 #endif
 
 #include <gpgme++/importresult.h>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace GpgME;
 
 class RefreshCertificateCommand::Private : public Command::Private
 {
     friend class ::RefreshCertificateCommand;
     RefreshCertificateCommand *q_func() const
     {
         return static_cast<RefreshCertificateCommand *>(q);
     }
 public:
     explicit Private(RefreshCertificateCommand *qq);
     ~Private() override;
 
     void start();
     void cancel();
 
 #if QGPGME_SUPPORTS_KEY_REFRESH
     std::unique_ptr<QGpgME::ReceiveKeysJob> startOpenPGPJob();
     std::unique_ptr<QGpgME::RefreshKeysJob> startSMIMEJob();
 #endif
     void onOpenPGPJobResult(const ImportResult &result);
     void onSMIMEJobResult(const Error &err);
     void showError(const Error &err);
 
 private:
     Key key;
 #if QGPGME_SUPPORTS_KEY_REFRESH
     QPointer<QGpgME::Job> job;
 #endif
 };
 
 RefreshCertificateCommand::Private *RefreshCertificateCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const RefreshCertificateCommand::Private *RefreshCertificateCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 RefreshCertificateCommand::Private::Private(RefreshCertificateCommand *qq)
     : Command::Private{qq}
 {
 }
 
 RefreshCertificateCommand::Private::~Private() = default;
 
 namespace
 {
 Key getKey(const std::vector<Key> &keys)
 {
     if (keys.size() != 1) {
         qCWarning(KLEOPATRA_LOG) << "Expected exactly one key, but got" << keys.size();
         return {};
     }
     const Key key = keys.front();
     if (key.protocol() == GpgME::UnknownProtocol) {
         qCWarning(KLEOPATRA_LOG) << "Key has unknown protocol";
         return {};
     }
     return key;
 }
 }
 
 void RefreshCertificateCommand::Private::start()
 {
     key = getKey(keys());
     if (key.isNull()) {
         finished();
         return;
     }
 
 #if QGPGME_SUPPORTS_KEY_REFRESH
     std::unique_ptr<QGpgME::Job> refreshJob;
     switch (key.protocol()) {
     case GpgME::OpenPGP:
         refreshJob = startOpenPGPJob();
         break;
     case GpgME::CMS:
         refreshJob = startSMIMEJob();
         break;
     default:
         ; // cannot happen ;-)
     }
     if (!refreshJob) {
         finished();
         return;
     }
     job = refreshJob.release();
 #else
     KMessageBox::error(parentWidgetOrView(), i18n("The backend does not support updating individual certificates."));
     finished();
 #endif
 }
 
 void RefreshCertificateCommand::Private::cancel()
 {
 #if QGPGME_SUPPORTS_KEY_REFRESH
     if (job) {
         job->slotCancel();
     }
     job.clear();
 #endif
 }
 
 #if QGPGME_SUPPORTS_KEY_REFRESH
 std::unique_ptr<QGpgME::ReceiveKeysJob> RefreshCertificateCommand::Private::startOpenPGPJob()
 {
     std::unique_ptr<QGpgME::ReceiveKeysJob> refreshJob{QGpgME::openpgp()->receiveKeysJob()};
     Q_ASSERT(refreshJob);
 
     connect(refreshJob.get(), &QGpgME::ReceiveKeysJob::result,
             q, [this](const GpgME::ImportResult &result) {
                 onOpenPGPJobResult(result);
             });
-    connect(refreshJob.get(), &QGpgME::Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(refreshJob.get(), &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(refreshJob.get(), &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
 
     const GpgME::Error err = refreshJob->start({QString::fromLatin1(key.primaryFingerprint())});
     if (err) {
         showError(err);
         return {};
     }
     Q_EMIT q->info(i18nc("@info:status", "Updating key..."));
 
     return refreshJob;
 }
 
 std::unique_ptr<QGpgME::RefreshKeysJob> RefreshCertificateCommand::Private::startSMIMEJob()
 {
     std::unique_ptr<QGpgME::RefreshKeysJob> refreshJob{QGpgME::smime()->refreshKeysJob()};
     Q_ASSERT(refreshJob);
 
     connect(refreshJob.get(), &QGpgME::RefreshKeysJob::result,
             q, [this](const GpgME::Error &err) {
                 onSMIMEJobResult(err);
             });
-    connect(refreshJob.get(), &QGpgME::Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(refreshJob.get(), &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(refreshJob.get(), &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
 
     const GpgME::Error err = refreshJob->start({key});
     if (err) {
         showError(err);
         return {};
     }
     Q_EMIT q->info(i18nc("@info:status", "Updating certificate..."));
 
     return refreshJob;
 }
 #endif
 
 namespace
 {
 static auto informationOnChanges(const ImportResult &result)
 {
     QString text;
 
     // if additional keys have been retrieved via WKD, then most of the below
     // details are just a guess and may concern the additional keys instead of
     // the refresh keys; this could only be clarified by a thorough comparison of
     // unrefreshed and refreshed key
 
     if (result.numUnchanged() == result.numConsidered()) {
         // if numUnchanged < numConsidered, then it is not clear whether the refreshed key
         // hasn't changed or whether another key retrieved via WKD hasn't changed
         text = i18n("The key hasn't changed.");
     } else if (result.newRevocations() > 0) {
         // it is possible that a revoked key has been newly imported via WKD,
         // but it is much more likely that the refreshed key was revoked
         text = i18n("The key has been revoked.");
     } else {
         // it doesn't make much sense to list below details if the key has been revoked
         text = i18n("The key has been updated.");
 
         QStringList details;
         if (result.newUserIDs() > 0) {
             details.push_back(i18n("New user IDs: %1", result.newUserIDs()));
         }
         if (result.newSubkeys() > 0) {
             details.push_back(i18n("New subkeys: %1", result.newSubkeys()));
         }
         if (result.newSignatures() > 0) {
             details.push_back(i18n("New signatures: %1", result.newSignatures()));
         }
         if (!details.empty()) {
             text += QLatin1String{"<br><br>"} + details.join(QLatin1String{"<br>"});
         }
     }
 
     text = QLatin1String{"<p>"} + text + QLatin1String{"</p>"};
     if (result.numImported() > 0) {
         text += QLatin1String{"<p>"} + i18np("Additionally, one new key has been retrieved.",
                                              "Additionally, %1 new keys have been retrieved.",
                                              result.numImported()) + QLatin1String{"</p>"};
     }
 
     return text;
 }
 
 }
 
 void RefreshCertificateCommand::Private::onOpenPGPJobResult(const ImportResult &result)
 {
     if (result.error()) {
         showError(result.error());
         finished();
         return;
     }
 
     if (!result.error().isCanceled()) {
         information(informationOnChanges(result),
                     i18nc("@title:window", "Key Updated"));
     }
     finished();
 }
 
 void RefreshCertificateCommand::Private::onSMIMEJobResult(const Error &err)
 {
     if (err) {
         showError(err);
         finished();
         return;
     }
 
     if (!err.isCanceled()) {
         information(i18nc("@info", "The certificate has been updated."),
                     i18nc("@title:window", "Certificate Updated"));
     }
     finished();
 }
 
 void RefreshCertificateCommand::Private::showError(const Error &err)
 {
     error(xi18nc("@info",
                  "<para>An error occurred while updating the certificate:</para>"
                  "<para><message>%1</message></para>",
                  QString::fromLocal8Bit(err.asString())),
           i18nc("@title:window", "Update Failed"));
 }
 
 RefreshCertificateCommand::RefreshCertificateCommand(const GpgME::Key &key)
     : Command{key, new Private{this}}
 {
 }
 
 RefreshCertificateCommand::~RefreshCertificateCommand() = default;
 
 void RefreshCertificateCommand::doStart()
 {
     d->start();
 }
 
 void RefreshCertificateCommand::doCancel()
 {
     d->cancel();
 }
 
 #undef d
 #undef q
 
 #include "moc_refreshcertificatecommand.cpp"
diff --git a/src/commands/revokecertificationcommand.cpp b/src/commands/revokecertificationcommand.cpp
index 8d58fad22..2b7ec2698 100644
--- a/src/commands/revokecertificationcommand.cpp
+++ b/src/commands/revokecertificationcommand.cpp
@@ -1,360 +1,366 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/revokecertificationcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020, 2022 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "revokecertificationcommand.h"
 
 #include "command_p.h"
 
 #include "exportopenpgpcertstoservercommand.h"
 
 #include <kleopatra_debug.h>
 #include <utils/keys.h>
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/Formatting>
 #include <Libkleo/KeyCache>
 
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/QuickJob>
 
 #include <gpgme++/engineinfo.h>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 using namespace QGpgME;
 
 namespace
 {
 
 enum class InputType {
     Key,
     UserIDs,
     Certifications,
 };
 
 struct CertificationData {
     UserID userId;
     Key certificationKey;
 };
 
 static std::vector<Key> getCertificationKeys(const GpgME::UserID &userId)
 {
     std::vector<Key> keys;
     if (userId.numSignatures() == 0) {
         qCWarning(KLEOPATRA_LOG) << __func__ << "- Error: Signatures of user ID" << QString::fromUtf8(userId.id()) << "not available";
         return keys;
     }
     std::vector<GpgME::UserID::Signature> revokableCertifications;
     Kleo::copy_if(userId.signatures(), std::back_inserter(revokableCertifications), [](const auto &certification) {
         return userCanRevokeCertification(certification) == CertificationCanBeRevoked;
     });
     Kleo::transform(revokableCertifications, std::back_inserter(keys), [](const auto &certification) {
         return KeyCache::instance()->findByKeyIDOrFingerprint(certification.signerKeyID());
     });
     return keys;
 }
 
 static bool confirmRevocations(QWidget *parent, const std::vector<CertificationData> &certifications)
 {
     KMessageBox::ButtonCode answer;
     if (certifications.size() == 1) {
         const auto [userId, certificationKey] = certifications.front();
         const auto message = xi18nc("@info",
                                     "<para>You are about to revoke the certification of user ID<nl/>%1<nl/>made with the key<nl/>%2.</para>",
                                     QString::fromUtf8(userId.id()),
                                     Formatting::formatForComboBox(certificationKey));
         answer = KMessageBox::questionTwoActions(parent,
                                                  message,
                                                  i18nc("@title:window", "Confirm Revocation"),
                                                  KGuiItem{i18n("Revoke Certification")},
                                                  KStandardGuiItem::cancel());
     } else {
         QStringList l;
         Kleo::transform(certifications, std::back_inserter(l), [](const auto &c) {
             return i18n("User ID '%1' certified with key %2", QString::fromUtf8(c.userId.id()), Formatting::formatForComboBox(c.certificationKey));
         });
         const auto message = i18np("You are about to revoke the following certification:", //
                                    "You are about to revoke the following %1 certifications:",
                                    certifications.size());
         answer = KMessageBox::questionTwoActionsList(parent,
                                                      message,
                                                      l,
                                                      i18nc("@title:window", "Confirm Revocation"),
                                                      KGuiItem{i18n("Revoke Certifications")},
                                                      KStandardGuiItem::cancel());
     }
     return answer == KMessageBox::ButtonCode::PrimaryAction;
 }
 
 }
 
 class RevokeCertificationCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::RevokeCertificationCommand;
     RevokeCertificationCommand *q_func() const
     {
         return static_cast<RevokeCertificationCommand *>(q);
     }
 public:
     Private(InputType i, RevokeCertificationCommand *qq, KeyListController *c = nullptr);
 
     void init();
 
 private:
     std::vector<CertificationData> getCertificationsToRevoke();
     void scheduleNextRevocation();
     QGpgME::QuickJob *createJob();
     void slotResult(const Error &err);
 
 private:
     InputType inputType = InputType::Key;
     Key certificationTarget;
     std::vector<UserID> uids;
     std::vector<CertificationData> certificationsToRevoke;
     std::vector<CertificationData> completedRevocations;
     QPointer<QGpgME::QuickJob> job;
 };
 
 RevokeCertificationCommand::Private *RevokeCertificationCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const RevokeCertificationCommand::Private *RevokeCertificationCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 RevokeCertificationCommand::Private::Private(InputType i, RevokeCertificationCommand *qq, KeyListController *c)
     : Command::Private{qq, c}
     , inputType{i}
 {
 }
 
 void RevokeCertificationCommand::Private::init()
 {
     const std::vector<Key> keys_ = keys();
     if (keys_.size() != 1) {
         qCWarning(KLEOPATRA_LOG) << q << "Expected exactly one key, but got" << keys_.size();
         return;
     }
     if (keys_.front().protocol() != GpgME::OpenPGP) {
         qCWarning(KLEOPATRA_LOG) << q << "Expected OpenPGP key, but got" << keys_.front().protocolAsString();
         return;
     }
     certificationTarget = keys_.front();
 }
 
 std::vector<CertificationData> RevokeCertificationCommand::Private::getCertificationsToRevoke()
 {
     if (inputType != InputType::Certifications) {
         // ensure that the certifications of the key have been loaded
         if (certificationTarget.userID(0).numSignatures() == 0) {
             certificationTarget.update();
         }
 
         // build list of user IDs and revokable certifications
         const auto userIDsToConsider = (inputType == InputType::Key) ? certificationTarget.userIDs() : uids;
         for (const auto &userId : userIDsToConsider) {
             Kleo::transform(getCertificationKeys(userId), std::back_inserter(certificationsToRevoke), [userId](const auto &k) {
                 return CertificationData{userId, k};
             });
         }
     }
 
     Kleo::erase_if(certificationsToRevoke, [](const auto &c) {
         return c.certificationKey.isNull();
     });
 
     return certificationsToRevoke;
 }
 
 void RevokeCertificationCommand::Private::scheduleNextRevocation()
 {
     if (!certificationsToRevoke.empty()) {
         const auto nextCertification = certificationsToRevoke.back();
         job = createJob();
         if (!job) {
             qCWarning(KLEOPATRA_LOG) << q << "Failed to create job";
             finished();
             return;
         }
         job->startRevokeSignature(certificationTarget, nextCertification.certificationKey, {nextCertification.userId});
     } else {
         const auto message = xi18ncp("@info",
                                      "<para>The certification has been revoked successfully.</para>"
                                      "<para>Do you want to publish the revocation?</para>",
                                      "<para>%1 certifications have been revoked successfully.</para>"
                                      "<para>Do you want to publish the revocations?</para>",
                                      completedRevocations.size());
         const auto yesButton = KGuiItem{i18ncp("@action:button", "Publish Revocation", "Publish Revocations", completedRevocations.size()),
                                         QIcon::fromTheme(QStringLiteral("view-certificate-export-server"))};
         const auto answer = KMessageBox::questionTwoActions(parentWidgetOrView(),
                                                             message,
                                                             i18nc("@title:window", "Confirm Publication"),
                                                             yesButton,
                                                             KStandardGuiItem::cancel(),
                                                             {},
                                                             KMessageBox::Notify | KMessageBox::Dangerous);
         if (answer == KMessageBox::ButtonCode::PrimaryAction) {
             const auto cmd = new ExportOpenPGPCertsToServerCommand{certificationTarget};
             cmd->start();
         }
         finished();
     }
 }
 
 void RevokeCertificationCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled()) {
         canceled();
         return;
     }
 
     if (err) {
         const auto failedRevocation = certificationsToRevoke.back();
         error(xi18nc("@info",
                      "<para>The revocation of the certification of user ID<nl/>%1<nl/>made with key<nl/>%2<nl/>failed:</para>"
                      "<para><message>%3</message></para>",
                      Formatting::prettyNameAndEMail(failedRevocation.userId),
                      Formatting::formatForComboBox(failedRevocation.certificationKey),
                      QString::fromUtf8(err.asString())));
         finished();
         return;
     }
 
     completedRevocations.push_back(certificationsToRevoke.back());
     certificationsToRevoke.pop_back();
     scheduleNextRevocation();
 }
 
 QGpgME::QuickJob *RevokeCertificationCommand::Private::createJob()
 {
     const auto j = QGpgME::openpgp()->quickJob();
     if (j) {
-        connect(j, &Job::progress, q, &Command::progress);
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+        connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
+#else
+        connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
+            Q_EMIT q->progress(current, total);
+        });
+#endif
         connect(j, &QGpgME::QuickJob::result, q, [this](const GpgME::Error &error) {
             slotResult(error);
         });
     }
 
     return j;
 }
 
 RevokeCertificationCommand::RevokeCertificationCommand(QAbstractItemView *v, KeyListController *c)
     : Command{v, new Private{InputType::Key, this, c}}
 {
     d->init();
 }
 
 RevokeCertificationCommand::RevokeCertificationCommand(const GpgME::Key &key)
     : Command{key, new Private{InputType::Key, this}}
 {
     d->init();
 }
 
 RevokeCertificationCommand::RevokeCertificationCommand(const GpgME::UserID &uid)
     : Command{uid.parent(), new Private{InputType::UserIDs, this}}
 {
     std::vector<UserID>(1, uid).swap(d->uids);
     d->init();
 }
 
 RevokeCertificationCommand::RevokeCertificationCommand(const std::vector<GpgME::UserID> &uids)
     : Command{uids.empty() ? Key{} : uids.front().parent(), new Private{InputType::UserIDs, this}}
 {
     d->uids = uids;
     d->init();
 }
 
 RevokeCertificationCommand::RevokeCertificationCommand(const GpgME::UserID::Signature &signature)
     : Command{signature.parent().parent(), new Private{InputType::Certifications, this}}
 {
     if (!signature.isNull()) {
         const Key certificationKey = KeyCache::instance()->findByKeyIDOrFingerprint(signature.signerKeyID());
         d->certificationsToRevoke = {{signature.parent(), certificationKey}};
     }
     d->init();
 }
 
 RevokeCertificationCommand::~RevokeCertificationCommand()
 {
     qCDebug(KLEOPATRA_LOG) << this << __func__;
 }
 
 // static
 bool RevokeCertificationCommand::isSupported()
 {
     return engineInfo(GpgEngine).engineVersion() >= "2.2.24";
 }
 
 void RevokeCertificationCommand::doStart()
 {
     if (d->certificationTarget.isNull()) {
         d->finished();
         return;
     }
 
     if (!Kleo::all_of(d->uids, userIDBelongsToKey(d->certificationTarget))) {
         qCWarning(KLEOPATRA_LOG) << this << "User ID <-> Key mismatch!";
         d->finished();
         return;
     }
 
     const auto certificationsToRevoke = d->getCertificationsToRevoke();
     if (certificationsToRevoke.empty()) {
         switch (d->inputType) {
         case InputType::Key:
             d->information(i18n("You cannot revoke any certifications of this key."));
             break;
         case InputType::UserIDs:
             d->information(i18np("You cannot revoke any certifications of this user ID.", //
                                  "You cannot revoke any certifications of these user IDs.",
                                  d->uids.size()));
             break;
         case InputType::Certifications:
             d->information(i18n("You cannot revoke this certification."));
             break;
         }
         d->finished();
         return;
     }
 
     if (!confirmRevocations(d->parentWidgetOrView(), certificationsToRevoke)) {
         d->canceled();
         return;
     }
 
     d->scheduleNextRevocation();
 }
 
 void RevokeCertificationCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG) << this << __func__;
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 #undef d
 #undef q
 
 #include "moc_revokecertificationcommand.cpp"
 
diff --git a/src/commands/revokekeycommand.cpp b/src/commands/revokekeycommand.cpp
index db4bec7f1..3c3484f8c 100644
--- a/src/commands/revokekeycommand.cpp
+++ b/src/commands/revokekeycommand.cpp
@@ -1,258 +1,263 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/revokekeycommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     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-kleopatra.h>
 
 #include "revokekeycommand.h"
 #include "command_p.h"
 #include "dialogs/revokekeydialog.h"
 
 #include <Libkleo/Formatting>
 
 #include <KLocalizedString>
 
 #if QGPGME_SUPPORTS_KEY_REVOCATION
 #include <QGpgME/RevokeKeyJob>
 #endif
 
 #include "kleopatra_debug.h"
 #include <QGpgME/Protocol>
 
 using namespace Kleo;
 using namespace GpgME;
 
 class RevokeKeyCommand::Private : public Command::Private
 {
     friend class ::RevokeKeyCommand;
     RevokeKeyCommand *q_func() const
     {
         return static_cast<RevokeKeyCommand *>(q);
     }
 public:
     explicit Private(RevokeKeyCommand *qq, KeyListController *c = nullptr);
     ~Private() override;
 
     void start();
     void cancel();
 
 private:
     void ensureDialogCreated();
     void onDialogAccepted();
     void onDialogRejected();
 
 #if QGPGME_SUPPORTS_KEY_REVOCATION
     std::unique_ptr<QGpgME::RevokeKeyJob> startJob();
 #endif
     void onJobResult(const Error &err);
     void showError(const Error &err);
 
 private:
     Key key;
     QPointer<RevokeKeyDialog> dialog;
 #if QGPGME_SUPPORTS_KEY_REVOCATION
     QPointer<QGpgME::RevokeKeyJob> job;
 #endif
 };
 
 RevokeKeyCommand::Private *RevokeKeyCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const RevokeKeyCommand::Private *RevokeKeyCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 RevokeKeyCommand::Private::Private(RevokeKeyCommand *qq, KeyListController *c)
     : Command::Private{qq, c}
 {
 }
 
 RevokeKeyCommand::Private::~Private() = default;
 
 namespace
 {
 Key getKey(const std::vector<Key> &keys)
 {
     if (keys.size() != 1) {
         qCWarning(KLEOPATRA_LOG) << "Expected exactly one key, but got" << keys.size();
         return {};
     }
     const Key key = keys.front();
     if (key.protocol() != GpgME::OpenPGP) {
         qCWarning(KLEOPATRA_LOG) << "Expected OpenPGP key, but got" << Formatting::displayName(key.protocol()) << "key";
         return {};
     }
     return key;
 }
 }
 
 void RevokeKeyCommand::Private::start()
 {
     key = getKey(keys());
     if (key.isNull()) {
         finished();
         return;
     }
 
     if (key.isRevoked()) {
         information(i18nc("@info", "This key has already been revoked."));
         finished();
         return;
     }
 
     ensureDialogCreated();
     Q_ASSERT(dialog);
 
     dialog->setKey(key);
     dialog->show();
 }
 
 void RevokeKeyCommand::Private::cancel()
 {
 #if QGPGME_SUPPORTS_KEY_REVOCATION
     if (job) {
         job->slotCancel();
     }
     job.clear();
 #endif
 }
 
 void RevokeKeyCommand::Private::ensureDialogCreated()
 {
     if (dialog) {
         return;
     }
 
     dialog = new RevokeKeyDialog;
     applyWindowID(dialog);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
 
     connect(dialog, &QDialog::accepted, q, [this]() { onDialogAccepted(); });
     connect(dialog, &QDialog::rejected, q, [this]() { onDialogRejected(); });
 }
 
 void RevokeKeyCommand::Private::onDialogAccepted()
 {
 #if QGPGME_SUPPORTS_KEY_REVOCATION
     auto revokeJob = startJob();
     if (!revokeJob) {
         finished();
         return;
     }
     job = revokeJob.release();
 #endif
 }
 
 void RevokeKeyCommand::Private::onDialogRejected()
 {
     canceled();
 }
 
 namespace
 {
 std::vector<std::string> toStdStrings(const QStringList &l)
 {
     std::vector<std::string> v;
     v.reserve(l.size());
     std::transform(std::begin(l), std::end(l),
                    std::back_inserter(v),
                    std::mem_fn(&QString::toStdString));
     return v;
 }
 
 auto descriptionToLines(const QString &description)
 {
     std::vector<std::string> lines;
     if (!description.isEmpty()) {
         lines = toStdStrings(description.split(QLatin1Char('\n')));
     }
     return lines;
 }
 }
 
 #if QGPGME_SUPPORTS_KEY_REVOCATION
 std::unique_ptr<QGpgME::RevokeKeyJob> RevokeKeyCommand::Private::startJob()
 {
     std::unique_ptr<QGpgME::RevokeKeyJob> revokeJob{QGpgME::openpgp()->revokeKeyJob()};
     Q_ASSERT(revokeJob);
 
     connect(revokeJob.get(), &QGpgME::RevokeKeyJob::result,
             q, [this](const GpgME::Error &err) {
                 onJobResult(err);
             });
-    connect(revokeJob.get(), &QGpgME::Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(revokeJob.get(), &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(revokeJob.get(), &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
 
     const auto description = descriptionToLines(dialog->description());
     const GpgME::Error err = revokeJob->start(key, dialog->reason(), description);
     if (err) {
         showError(err);
         return {};
     }
     Q_EMIT q->info(i18nc("@info:status", "Revoking key..."));
 
     return revokeJob;
 }
 #endif
 
 void RevokeKeyCommand::Private::onJobResult(const Error &err)
 {
     if (err) {
         showError(err);
         finished();
         return;
     }
 
     if (!err.isCanceled()) {
         information(i18nc("@info", "The key was revoked successfully."),
                     i18nc("@title:window", "Key Revoked"));
     }
     finished();
 }
 
 void RevokeKeyCommand::Private::showError(const Error &err)
 {
     error(xi18nc("@info",
                  "<para>An error occurred during the revocation:</para>"
                  "<para><message>%1</message></para>",
                  QString::fromLocal8Bit(err.asString())),
           i18nc("@title:window", "Revocation Failed"));
 }
 
 RevokeKeyCommand::RevokeKeyCommand(QAbstractItemView *v, KeyListController *c)
     : Command{v, new Private{this, c}}
 {
 }
 
 RevokeKeyCommand::RevokeKeyCommand(const GpgME::Key &key)
     : Command{key, new Private{this}}
 {
 }
 
 RevokeKeyCommand::~RevokeKeyCommand() = default;
 
 void RevokeKeyCommand::doStart()
 {
     d->start();
 }
 
 void RevokeKeyCommand::doCancel()
 {
     d->cancel();
 }
 
 #undef d
 #undef q
 
 #include "moc_revokekeycommand.cpp"
diff --git a/src/commands/revokeuseridcommand.cpp b/src/commands/revokeuseridcommand.cpp
index 1480f39c8..afce4b589 100644
--- a/src/commands/revokeuseridcommand.cpp
+++ b/src/commands/revokeuseridcommand.cpp
@@ -1,171 +1,176 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/revokeuseridcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     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-kleopatra.h>
 
 #include "revokeuseridcommand.h"
 
 #include "command_p.h"
 
 #include <Libkleo/GnuPG>
 
 #include <KLocalizedString>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/QuickJob>
 
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 class RevokeUserIDCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::RevokeUserIDCommand;
     RevokeUserIDCommand *q_func() const
     {
         return static_cast<RevokeUserIDCommand *>(q);
     }
 public:
     explicit Private(RevokeUserIDCommand *qq, const UserID &userId);
     ~Private() override;
 
     void startJob();
 
 private:
     void createJob();
     void slotResult(const Error &err);
     void showErrorDialog(const Error &error);
     void showSuccessDialog();
 
 private:
     GpgME::UserID userId;
     QPointer<QGpgME::QuickJob> job;
 };
 
 RevokeUserIDCommand::Private *RevokeUserIDCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const RevokeUserIDCommand::Private *RevokeUserIDCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 RevokeUserIDCommand::Private::Private(RevokeUserIDCommand *qq, const UserID &userId)
     : Command::Private{qq}
     , userId{userId}
 {
 }
 
 RevokeUserIDCommand::Private::~Private() = default;
 
 void Commands::RevokeUserIDCommand::Private::startJob()
 {
     createJob();
     if (!job) {
         finished();
         return;
     }
     const QString uidToRevoke = QString::fromUtf8(engineIsVersion(2, 3, 7) ? userId.uidhash() : userId.id());
     job->startRevUid(userId.parent(), uidToRevoke);
 }
 
 void RevokeUserIDCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     const auto backend = QGpgME::openpgp();
     if (!backend) {
         return;
     }
 
     const auto j = backend->quickJob();
     if (!j) {
         return;
     }
 
-    connect(j, &QGpgME::Job::progress,
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(j, &QGpgME::Job::jobProgress,
             q, &Command::progress);
+#else
+    connect(j, &QGpgME::Job::progress,
+            q, [this](const QString &, int current, int total) { Q_EMIT q->progress(current, total); });
+#endif
     connect(j, &QGpgME::QuickJob::result,
             q, [this](const GpgME::Error &err) { slotResult(err); });
 
     job = j;
 }
 
 void RevokeUserIDCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled()) {
     } else if (err) {
         showErrorDialog(err);
     } else {
         showSuccessDialog();
     }
     finished();
 }
 
 void RevokeUserIDCommand::Private::showErrorDialog(const Error &err)
 {
     error(xi18nc("@info",
                  "<para>An error occurred while trying to revoke the user ID<nl/><emphasis>%1</emphasis>.</para>"
                  "<para><message>%2</message></para>",
                  QString::fromUtf8(userId.id()), QString::fromLocal8Bit(err.asString())),
           i18nc("@title:window", "Revocation Failed"));
 }
 
 void RevokeUserIDCommand::Private::showSuccessDialog()
 {
     information(xi18nc("@info", "<para>The user ID<nl/><emphasis>%1</emphasis><nl/>has been revoked successfully.</para>",
                        QString::fromUtf8(userId.id())),
                 i18nc("@title:window", "Revocation Succeeded"));
 }
 
 RevokeUserIDCommand::RevokeUserIDCommand(const GpgME::UserID &userId)
     : Command{new Private{this, userId}}
 {
 }
 
 RevokeUserIDCommand::~RevokeUserIDCommand()
 {
 }
 
 void RevokeUserIDCommand::doStart()
 {
     if (d->userId.isNull()) {
         d->finished();
         return;
     }
 
     const auto key = d->userId.parent();
     if (key.protocol() != GpgME::OpenPGP || !key.hasSecret()) {
         d->finished();
         return;
     }
 
     d->startJob();
 }
 
 void RevokeUserIDCommand::doCancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 #undef d
 #undef q
 
 #include "moc_revokeuseridcommand.cpp"
diff --git a/src/commands/setprimaryuseridcommand.cpp b/src/commands/setprimaryuseridcommand.cpp
index 5c0735d3f..8957c92db 100644
--- a/src/commands/setprimaryuseridcommand.cpp
+++ b/src/commands/setprimaryuseridcommand.cpp
@@ -1,181 +1,187 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/setprimaryuseridcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     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-kleopatra.h>
 
 #include "setprimaryuseridcommand.h"
 
 #include "command_p.h"
 
 #include <KLocalizedString>
 
 #if QGPGME_SUPPORTS_SET_PRIMARY_UID
 #include <QGpgME/SetPrimaryUserIDJob>
 #endif
 
 #include <QGpgME/Protocol>
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 class SetPrimaryUserIDCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::SetPrimaryUserIDCommand;
     SetPrimaryUserIDCommand *q_func() const
     {
         return static_cast<SetPrimaryUserIDCommand *>(q);
     }
 
 public:
     explicit Private(SetPrimaryUserIDCommand *qq, const UserID &userId);
     ~Private() override;
 
     void startJob();
 
 private:
     void createJob();
     void slotResult(const Error &err);
     void showErrorDialog(const Error &error);
     void showSuccessDialog();
 
 private:
     GpgME::UserID userId;
 #if QGPGME_SUPPORTS_SET_PRIMARY_UID
     QPointer<QGpgME::SetPrimaryUserIDJob> job;
 #endif
 };
 
 SetPrimaryUserIDCommand::Private *SetPrimaryUserIDCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const SetPrimaryUserIDCommand::Private *SetPrimaryUserIDCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 SetPrimaryUserIDCommand::Private::Private(SetPrimaryUserIDCommand *qq, const UserID &userId)
     : Command::Private{qq}
     , userId{userId}
 {
 }
 
 SetPrimaryUserIDCommand::Private::~Private() = default;
 
 void Commands::SetPrimaryUserIDCommand::Private::startJob()
 {
 #if QGPGME_SUPPORTS_SET_PRIMARY_UID
     createJob();
     if (!job) {
         finished();
         return;
     }
     job->start(userId);
 #else
     error(i18nc("@info", "The backend does not support this operation."));
 #endif
 }
 
 void SetPrimaryUserIDCommand::Private::createJob()
 {
 #if QGPGME_SUPPORTS_SET_PRIMARY_UID
     Q_ASSERT(!job);
 
     const auto backend = QGpgME::openpgp();
     if (!backend) {
         return;
     }
 
     const auto j = backend->setPrimaryUserIDJob();
     if (!j) {
         return;
     }
 
-    connect(j, &QGpgME::Job::progress, q, &Command::progress);
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(j, &QGpgME::Job::jobProgress, q, &Command::progress);
+#else
+    connect(j, &QGpgME::Job::progress, q, [this](const QString &, int current, int total) {
+        Q_EMIT q->progress(current, total);
+    });
+#endif
     connect(j, &QGpgME::SetPrimaryUserIDJob::result, q, [this](const GpgME::Error &err) {
         slotResult(err);
     });
 
     job = j;
 #endif
 }
 
 void SetPrimaryUserIDCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled()) {
     } else if (err) {
         showErrorDialog(err);
     } else {
         showSuccessDialog();
     }
     finished();
 }
 
 void SetPrimaryUserIDCommand::Private::showErrorDialog(const Error &err)
 {
     error(xi18nc("@info",
                  "<para>An error occurred while trying to flag the user ID<nl/><emphasis>%1</emphasis><nl/>as the primary user ID.</para>"
                  "<para><message>%2</message></para>",
                  QString::fromUtf8(userId.id()),
                  QString::fromLocal8Bit(err.asString())));
 }
 
 void SetPrimaryUserIDCommand::Private::showSuccessDialog()
 {
     success(xi18nc("@info",
                    "<para>The user ID<nl/><emphasis>%1</emphasis><nl/>has been flagged successfully as the primary user ID.</para>",
                    QString::fromUtf8(userId.id())));
 }
 
 SetPrimaryUserIDCommand::SetPrimaryUserIDCommand(const GpgME::UserID &userId)
     : Command{new Private{this, userId}}
 {
 }
 
 SetPrimaryUserIDCommand::~SetPrimaryUserIDCommand()
 {
     qCDebug(KLEOPATRA_LOG).nospace() << this << "::" << __func__;
 }
 
 void SetPrimaryUserIDCommand::doStart()
 {
     if (d->userId.isNull()) {
         d->finished();
         return;
     }
 
     const auto key = d->userId.parent();
     if (key.protocol() != GpgME::OpenPGP || !key.hasSecret()) {
         d->finished();
         return;
     }
 
     d->startJob();
 }
 
 void SetPrimaryUserIDCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG).nospace() << this << "::" << __func__;
 #if QGPGME_SUPPORTS_SET_PRIMARY_UID
     if (d->job) {
         d->job->slotCancel();
     }
 #endif
 }
 
 #undef d
 #undef q
diff --git a/src/crypto/decryptverifytask.cpp b/src/crypto/decryptverifytask.cpp
index 39d51cec0..59e24707c 100644
--- a/src/crypto/decryptverifytask.cpp
+++ b/src/crypto/decryptverifytask.cpp
@@ -1,1706 +1,1726 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     decryptverifytask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "decryptverifytask.h"
 
 #include <QGpgME/Protocol>
 #include <QGpgME/VerifyOpaqueJob>
 #include <QGpgME/VerifyDetachedJob>
 #include <QGpgME/DecryptJob>
 #include <QGpgME/DecryptVerifyJob>
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 #include <QGpgME/DecryptVerifyArchiveJob>
 #endif
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/Compliance>
 #include <Libkleo/Dn>
 #include <Libkleo/KleoException>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Predicates>
 #include <Libkleo/Formatting>
 #include <Libkleo/Classify>
 
 #include <utils/detail_p.h>
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 #include <Libkleo/GnuPG>
 
 #include <KMime/HeaderParsing>
 
 #include <gpgme++/error.h>
 #include <gpgme++/key.h>
 #include <gpgme++/verificationresult.h>
 #include <gpgme++/decryptionresult.h>
 #include <gpgme++/context.h>
 
 #include <gpg-error.h>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 #include <QLocale>
 
 #include <QByteArray>
 #include <QDateTime>
 #include <QIODevice>
 #include <QStringList>
 #include <QTextDocument> // Qt::escape
 
 #include <algorithm>
 #include <sstream>
 
 using namespace Kleo::Crypto;
 using namespace Kleo;
 using namespace GpgME;
 using namespace KMime::Types;
 
 namespace
 {
 
 static AuditLogEntry auditLogFromSender(QObject *sender)
 {
     return AuditLogEntry::fromJob(qobject_cast<const QGpgME::Job *>(sender));
 }
 
 static bool addrspec_equal(const AddrSpec &lhs, const AddrSpec &rhs, Qt::CaseSensitivity cs)
 {
     return lhs.localPart.compare(rhs.localPart, cs) == 0 && lhs.domain.compare(rhs.domain, Qt::CaseInsensitive) == 0;
 }
 
 static bool mailbox_equal(const Mailbox &lhs, const Mailbox &rhs, Qt::CaseSensitivity cs)
 {
     return addrspec_equal(lhs.addrSpec(), rhs.addrSpec(), cs);
 }
 
 static std::string stripAngleBrackets(const std::string &str)
 {
     if (str.empty()) {
         return str;
     }
     if (str[0] == '<' && str[str.size() - 1] == '>') {
         return str.substr(1, str.size() - 2);
     }
     return str;
 }
 
 static std::string email(const UserID &uid)
 {
 
     if (uid.parent().protocol() == OpenPGP) {
         if (const char *const email = uid.email()) {
             return stripAngleBrackets(email);
         } else {
             return std::string();
         }
     }
 
     Q_ASSERT(uid.parent().protocol() == CMS);
 
     if (const char *const id = uid.id())
         if (*id == '<') {
             return stripAngleBrackets(id);
         } else {
             return DN(id)[QStringLiteral("EMAIL")].trimmed().toUtf8().constData();
         }
     else {
         return std::string();
     }
 }
 
 static Mailbox mailbox(const UserID &uid)
 {
     const std::string e = email(uid);
     Mailbox mbox;
     if (!e.empty()) {
         mbox.setAddress(e.c_str());
     }
     return mbox;
 }
 
 static std::vector<Mailbox> extractMailboxes(const Key &key)
 {
     std::vector<Mailbox> res;
     const auto userIDs{key.userIDs()};
     for (const UserID &id : userIDs) {
         const Mailbox mbox = mailbox(id);
         if (!mbox.addrSpec().isEmpty()) {
             res.push_back(mbox);
         }
     }
     return res;
 }
 
 static std::vector<Mailbox> extractMailboxes(const std::vector<Key> &signers)
 {
     std::vector<Mailbox> res;
     for (const Key &i : signers) {
         const std::vector<Mailbox> bxs = extractMailboxes(i);
         res.insert(res.end(), bxs.begin(), bxs.end());
     }
     return res;
 }
 
 static bool keyContainsMailbox(const Key &key, const Mailbox &mbox)
 {
     const std::vector<Mailbox> mbxs = extractMailboxes(key);
     return std::find_if(mbxs.cbegin(), mbxs.cend(), 
                         [mbox](const Mailbox &m) {
                             return mailbox_equal(mbox, m, Qt::CaseInsensitive);
                         }) != mbxs.cend();
 }
 
 static bool keysContainMailbox(const std::vector<Key> &keys, const Mailbox &mbox)
 {
     return std::find_if(keys.cbegin(), keys.cend(), 
                         [mbox](const Key &key) {
                             return keyContainsMailbox(key, mbox);
                         }) != keys.cend();
 }
 
 static bool relevantInDecryptVerifyContext(const VerificationResult &r)
 {
     // for D/V operations, we ignore verification results which are not errors and contain
     // no signatures (which means that the data was just not signed)
 
     return (r.error() && r.error().code() != GPG_ERR_DECRYPT_FAILED) || r.numSignatures() > 0;
 }
 
 static QString signatureSummaryToString(int summary)
 {
     if (summary & Signature::None) {
         return i18n("Error: Signature not verified");
     } else if (summary & Signature::Valid || summary & Signature::Green) {
         return i18n("Good signature");
     } else if (summary & Signature::KeyRevoked) {
         return i18n("Signing certificate was revoked");
     } else if (summary & Signature::KeyExpired) {
         return i18n("Signing certificate is expired");
     } else if (summary & Signature::KeyMissing) {
         return i18n("Certificate is not available");
     } else if (summary & Signature::SigExpired) {
         return i18n("Signature expired");
     } else if (summary & Signature::CrlMissing) {
         return i18n("CRL missing");
     } else if (summary & Signature::CrlTooOld) {
         return i18n("CRL too old");
     } else if (summary & Signature::BadPolicy) {
         return i18n("Bad policy");
     } else if (summary & Signature::SysError) {
         return i18n("System error");    //### retrieve system error details?
     } else if (summary & Signature::Red) {
         return i18n("Bad signature");
     }return QString();
 }
 
 static QString formatValidSignatureWithTrustLevel(const UserID &id)
 {
     if (id.isNull()) {
         return QString();
     }
     switch (id.validity()) {
     case UserID::Marginal:
         return i18n("The signature is valid but the trust in the certificate's validity is only marginal.");
     case UserID::Full:
         return i18n("The signature is valid and the certificate's validity is fully trusted.");
     case UserID::Ultimate:
         return i18n("The signature is valid and the certificate's validity is ultimately trusted.");
     case UserID::Never:
         return i18n("The signature is valid but the certificate's validity is <em>not trusted</em>.");
     case UserID::Unknown:
         return i18n("The signature is valid but the certificate's validity is unknown.");
     case UserID::Undefined:
     default:
         return i18n("The signature is valid but the certificate's validity is undefined.");
     }
 }
 
 static QString renderKeyLink(const QString &fpr, const QString &text)
 {
     return QStringLiteral("<a href=\"key:%1\">%2</a>").arg(fpr, text);
 }
 
 static QString renderKey(const Key &key)
 {
     if (key.isNull()) {
         return i18n("Unknown certificate");
     }
 
     if (key.primaryFingerprint() && strlen(key.primaryFingerprint()) > 16 && key.numUserIDs()) {
         const QString text = QStringLiteral("%1 (%2)").arg(Formatting::prettyNameAndEMail(key).toHtmlEscaped()).arg(
             Formatting::prettyID(QString::fromLocal8Bit(key.primaryFingerprint()).right(16).toLatin1().constData()));
         return renderKeyLink(QLatin1String(key.primaryFingerprint()), text);
     }
 
     return renderKeyLink(QLatin1String(key.primaryFingerprint()), Formatting::prettyID(key.primaryFingerprint()));
 }
 
 static QString renderKeyEMailOnlyNameAsFallback(const Key &key)
 {
     if (key.isNull()) {
         return i18n("Unknown certificate");
     }
     const QString email = Formatting::prettyEMail(key);
     const QString user = !email.isEmpty() ? email : Formatting::prettyName(key);
     return renderKeyLink(QLatin1String(key.primaryFingerprint()), user);
 }
 
 static QString formatDate(const QDateTime &dt)
 {
     return QLocale().toString(dt);
 }
 static QString formatSigningInformation(const Signature &sig)
 {
     if (sig.isNull()) {
         return QString();
     }
     const QDateTime dt = sig.creationTime() != 0 ? QDateTime::fromSecsSinceEpoch(quint32(sig.creationTime())) : QDateTime();
     QString text;
     Key key = sig.key();
     if (dt.isValid()) {
         text = i18nc("1 is a date", "Signature created on %1", formatDate(dt)) + QStringLiteral("<br>");
     }
     if (key.isNull()) {
         return text += i18n("With unavailable certificate:") + QStringLiteral("<br>ID: 0x%1").arg(QString::fromLatin1(sig.fingerprint()).toUpper());
     }
     text += i18n("With certificate:") + QStringLiteral("<br>") + renderKey(key);
 
     if (DeVSCompliance::isCompliant()) {
         text +=
             (QStringLiteral("<br/>")
              + (sig.isDeVs()
                 ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                         "The signature is %1", DeVSCompliance::name(true))
                 : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                         "The signature <b>is not</b> %1.", DeVSCompliance::name(true))));
     }
 
     return text;
 }
 
 static QString strikeOut(const QString &str, bool strike)
 {
     return QString(strike ? QStringLiteral("<s>%1</s>") : QStringLiteral("%1")).arg(str.toHtmlEscaped());
 }
 
 static QString formatInputOutputLabel(const QString &input, const QString &output, bool inputDeleted, bool outputDeleted)
 {
     if (output.isEmpty()) {
         return strikeOut(input, inputDeleted);
     }
     return i18nc("Input file --> Output file (rarr is arrow", "%1 &rarr; %2",
                  strikeOut(input, inputDeleted),
                  strikeOut(output, outputDeleted));
 }
 
 static bool IsErrorOrCanceled(const GpgME::Error &err)
 {
     return err || err.isCanceled();
 }
 
 static bool IsErrorOrCanceled(const Result &res)
 {
     return IsErrorOrCanceled(res.error());
 }
 
 static bool IsBad(const Signature &sig)
 {
     return sig.summary() & Signature::Red;
 }
 
 static bool IsGoodOrValid(const Signature &sig)
 {
     return (sig.summary() & Signature::Valid) || (sig.summary() & Signature::Green);
 }
 
 static UserID findUserIDByMailbox(const Key &key, const Mailbox &mbox)
 {
     const auto userIDs{key.userIDs()};
     for (const UserID &id : userIDs)
         if (mailbox_equal(mailbox(id), mbox, Qt::CaseInsensitive)) {
             return id;
         }
     return UserID();
 }
 
 static void updateKeys(const VerificationResult &result) {
     // This little hack works around the problem that GnuPG / GpgME does not
     // provide Key information in a verification result. The Key object is
     // a dummy just holding the KeyID. This hack ensures that all available
     // keys are fetched from the backend and are populated
     for (const auto &sig: result.signatures()) {
         // Update key information
         sig.key(true, true);
     }
 }
 
 }
 
 class DecryptVerifyResult::SenderInfo
 {
 public:
     explicit SenderInfo(const Mailbox &infSender, const std::vector<Key> &signers_) : informativeSender(infSender), signers(signers_) {}
     const Mailbox informativeSender;
     const std::vector<Key> signers;
     bool hasInformativeSender() const
     {
         return !informativeSender.addrSpec().isEmpty();
     }
     bool conflicts() const
     {
         return hasInformativeSender() && hasKeys() && !keysContainMailbox(signers, informativeSender);
     }
     bool hasKeys() const
     {
         return std::any_of(signers.cbegin(), signers.cend(), [](const Key &key) { return !key.isNull(); });
     }
     std::vector<Mailbox> signerMailboxes() const
     {
         return extractMailboxes(signers);
     }
 };
 
 namespace
 {
 
 static Task::Result::VisualCode codeForVerificationResult(const VerificationResult &res)
 {
     if (res.isNull()) {
         return Task::Result::NeutralSuccess;
     }
 
     const std::vector<Signature> sigs = res.signatures();
     if (sigs.empty()) {
         return Task::Result::Warning;
     }
 
     if (std::find_if(sigs.begin(), sigs.end(), IsBad) != sigs.end()) {
         return Task::Result::Danger;
     }
 
     if ((size_t)std::count_if(sigs.begin(), sigs.end(), IsGoodOrValid) == sigs.size()) {
         return Task::Result::AllGood;
     }
 
     return Task::Result::Warning;
 }
 
 static QString formatVerificationResultOverview(const VerificationResult &res, const DecryptVerifyResult::SenderInfo &info)
 {
     if (res.isNull()) {
         return QString();
     }
 
     const Error err = res.error();
 
     if (err.isCanceled()) {
         return i18n("<b>Verification canceled.</b>");
     } else if (err) {
         return i18n("<b>Verification failed: %1.</b>", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
 
     const std::vector<Signature> sigs = res.signatures();
 
     if (sigs.empty()) {
         return i18n("<b>No signatures found.</b>");
     }
 
     const uint bad = std::count_if(sigs.cbegin(), sigs.cend(), IsBad);
     if (bad > 0) {
         return i18np("<b>Invalid signature.</b>", "<b>%1 invalid signatures.</b>", bad);
     }
     const uint warn = std::count_if(sigs.cbegin(), sigs.cend(), [](const Signature &sig) { return !IsGoodOrValid(sig); });
     if (warn == sigs.size()) {
         return i18np("<b>The data could not be verified.</b>", "<b>%1 signatures could not be verified.</b>", warn);
     }
 
     //Good signature:
     QString text;
     if (sigs.size() == 1) {
         text = i18n("<b>Valid signature by %1</b>", renderKeyEMailOnlyNameAsFallback(sigs[0].key()));
         if (info.conflicts())
             text += i18n("<br/><b>Warning:</b> The sender's mail address is not stored in the %1 used for signing.",
                          renderKeyLink(QLatin1String(sigs[0].key().primaryFingerprint()), i18n("certificate")));
     } else {
         text = i18np("<b>Valid signature.</b>", "<b>%1 valid signatures.</b>", sigs.size());
         if (info.conflicts()) {
             text += i18n("<br/><b>Warning:</b> The sender's mail address is not stored in the certificates used for signing.");
         }
     }
 
     return text;
 }
 
 static QString formatDecryptionResultOverview(const DecryptionResult &result, const QString &errorString = QString())
 {
     const Error err = result.error();
 
     if (err.isCanceled()) {
         return i18n("<b>Decryption canceled.</b>");
     }
     else if (result.isLegacyCipherNoMDC()) {
         return i18n("<b>Decryption failed: %1.</b>", i18n("No integrity protection (MDC)."));
     }
     else if (!errorString.isEmpty()) {
         return i18n("<b>Decryption failed: %1.</b>", errorString.toHtmlEscaped());
     } else if (err) {
         return i18n("<b>Decryption failed: %1.</b>", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
     return i18n("<b>Decryption succeeded.</b>");
 }
 
 static QString formatSignature(const Signature &sig, const DecryptVerifyResult::SenderInfo &info)
 {
     if (sig.isNull()) {
         return QString();
     }
 
     const QString text = formatSigningInformation(sig) + QLatin1String("<br/>");
     const Key key = sig.key();
 
     // Green
     if (sig.summary() & Signature::Valid) {
         const UserID id = findUserIDByMailbox(key, info.informativeSender);
         return text + formatValidSignatureWithTrustLevel(!id.isNull() ? id : key.userID(0));
     }
 
     // Red
     if ((sig.summary() & Signature::Red)) {
         const QString ret = text + i18n("The signature is invalid: %1", signatureSummaryToString(sig.summary()));
         if (sig.summary() & Signature::SysError) {
             return ret + QStringLiteral(" (%1)").arg(QString::fromLocal8Bit(sig.status().asString()));
         }
         return ret;
     }
 
     // Key missing
     if ((sig.summary() & Signature::KeyMissing)) {
         return text + i18n("You can search the certificate on a keyserver or import it from a file.");
     }
 
     // Yellow
     if ((sig.validity() & Signature::Validity::Undefined) ||
         (sig.validity() & Signature::Validity::Unknown) ||
         (sig.summary() == Signature::Summary::None)) {
         return text + (key.protocol() == OpenPGP ? i18n("The used key is not certified by you or any trusted person.") :
                i18n("The used certificate is not certified by a trustworthy Certificate Authority or the Certificate Authority is unknown."));
     }
 
     // Catch all fall through
     const QString ret = text + i18n("The signature is invalid: %1", signatureSummaryToString(sig.summary()));
     if (sig.summary() & Signature::SysError) {
         return ret + QStringLiteral(" (%1)").arg(QString::fromLocal8Bit(sig.status().asString()));
     }
     return ret;
 }
 
 static QStringList format(const std::vector<Mailbox> &mbxs)
 {
     QStringList res;
     std::transform(mbxs.cbegin(), mbxs.cend(), std::back_inserter(res),
                    [](const Mailbox &mbox) {
                        return mbox.prettyAddress();
                    });
     return res;
 }
 
 static QString formatVerificationResultDetails(const VerificationResult &res, const DecryptVerifyResult::SenderInfo &info, const QString &errorString)
 {
     if ((res.error().code() == GPG_ERR_EIO || res.error().code() == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
         return i18n("Input error: %1", errorString);
     }
 
     const std::vector<Signature> sigs = res.signatures();
     QString details;
     for (const Signature &sig : sigs) {
         details += formatSignature(sig, info) + QLatin1Char('\n');
     }
     details = details.trimmed();
     details.replace(QLatin1Char('\n'), QStringLiteral("<br/><br/>"));
     if (info.conflicts()) {
         details += i18n("<p>The sender's address %1 is not stored in the certificate. Stored: %2</p>", info.informativeSender.prettyAddress(), format(info.signerMailboxes()).join(i18nc("separator for a list of e-mail addresses", ", ")));
     }
     return details;
 }
 
 static QString formatRecipientsDetails(const std::vector<Key> &knownRecipients, unsigned int numRecipients)
 {
     if (numRecipients == 0) {
         return {};
     }
 
     if (knownRecipients.empty()) {
         return QLatin1String("<i>") +
                i18np("One unknown recipient.", "%1 unknown recipients.", numRecipients) +
                QLatin1String("</i>");
     }
 
     QString details = i18np("Recipient:", "Recipients:", numRecipients);
 
     if (numRecipients == 1) {
         details += QLatin1Char(' ') + renderKey(knownRecipients.front());
     } else {
         details += QLatin1String("<ul>");
         for (const Key &key : knownRecipients) {
             details += QLatin1String("<li>") + renderKey(key) + QLatin1String("</li>");
         }
         if (knownRecipients.size() < numRecipients) {
             details += QLatin1String("<li><i>") +
                        i18np("One unknown recipient", "%1 unknown recipients",
                              numRecipients - knownRecipients.size()) +
                        QLatin1String("</i></li>");
         }
         details += QLatin1String("</ul>");
     }
 
     return details;
 }
 
 static QString formatDecryptionResultDetails(const DecryptionResult &res, const std::vector<Key> &recipients,
                                              const QString &errorString, bool isSigned, const QPointer<Task> &task)
 {
     if ((res.error().code() == GPG_ERR_EIO || res.error().code() == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
         return i18n("Input error: %1", errorString);
     }
 
     if (res.isNull() || res.error() || res.error().isCanceled()) {
         return formatRecipientsDetails(recipients, res.numRecipients());
     }
 
     QString details;
 
     if (DeVSCompliance::isCompliant()) {
         details += ((res.isDeVs()
                      ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                              "The decryption is %1.", DeVSCompliance::name(true))
                      : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                              "The decryption <b>is not</b> %1.", DeVSCompliance::name(true)))
                     + QStringLiteral("<br/>"));
     }
 
     if (res.fileName()) {
         const auto decVerifyTask = qobject_cast<AbstractDecryptVerifyTask*> (task.data());
         if (decVerifyTask) {
             const auto embedFileName = QString::fromUtf8(res.fileName()).toHtmlEscaped();
 
             if (embedFileName != decVerifyTask->outputLabel()) {
                 details += i18n("Embedded file name: '%1'", embedFileName);
                 details += QStringLiteral("<br/>");
             }
         }
     }
 
     if (!isSigned) {
         details += i18n("<b>Note:</b> You cannot be sure who encrypted this message as it is not signed.")
                    + QLatin1String("<br/>");
     }
 
     if (res.isLegacyCipherNoMDC()) {
         details += i18nc("Integrity protection was missing because an old cipher was used.",
                          "<b>Hint:</b> If this file was encrypted before the year 2003 it is "
                          "likely that the file is legitimate.  This is because back "
                          "then integrity protection was not widely used.") + QStringLiteral("<br/><br/>") +
                    i18nc("The user is offered to force decrypt a non integrity protected message. With the strong advice to re-encrypt it.",
                          "If you are confident that the file was not manipulated you should re-encrypt it after you have forced the decryption.") +
                    QStringLiteral("<br/><br/>");
     }
 
     details += formatRecipientsDetails(recipients, res.numRecipients());
 
     return details;
 }
 
 static QString formatDecryptVerifyResultOverview(const DecryptionResult &dr, const VerificationResult &vr, const  DecryptVerifyResult::SenderInfo &info)
 {
     if (IsErrorOrCanceled(dr) || !relevantInDecryptVerifyContext(vr)) {
         return formatDecryptionResultOverview(dr);
     }
     return formatVerificationResultOverview(vr, info);
 }
 
 static QString formatDecryptVerifyResultDetails(const DecryptionResult &dr,
         const VerificationResult &vr,
         const std::vector<Key> &recipients,
         const DecryptVerifyResult::SenderInfo &info,
         const QString &errorString,
         const QPointer<Task> &task)
 {
     const QString drDetails = formatDecryptionResultDetails(dr, recipients, errorString, relevantInDecryptVerifyContext(vr), task);
     if (IsErrorOrCanceled(dr) || !relevantInDecryptVerifyContext(vr)) {
         return drDetails;
     }
     return drDetails + (drDetails.isEmpty() ? QString() : QStringLiteral("<br/>")) + formatVerificationResultDetails(vr, info, errorString);
 }
 
 } // anon namespace
 
 class DecryptVerifyResult::Private
 {
     DecryptVerifyResult *const q;
 public:
     Private(DecryptVerifyOperation type,
             const VerificationResult &vr,
             const DecryptionResult &dr,
             const QByteArray &stuff,
             const QString &fileName,
             const GpgME::Error &error,
             const QString &errString,
             const QString &input,
             const QString &output,
             const AuditLogEntry &auditLog,
             Task *parentTask,
             const Mailbox &informativeSender,
             DecryptVerifyResult *qq) :
         q(qq),
         m_type(type),
         m_verificationResult(vr),
         m_decryptionResult(dr),
         m_stuff(stuff),
         m_fileName(fileName),
         m_error(error),
         m_errorString(errString),
         m_inputLabel(input),
         m_outputLabel(output),
         m_auditLog(auditLog),
         m_parentTask(QPointer<Task>(parentTask)),
         m_informativeSender(informativeSender)
     {
     }
 
     QString label() const
     {
         return formatInputOutputLabel(m_inputLabel, m_outputLabel, false, q->hasError());
     }
 
     DecryptVerifyResult::SenderInfo makeSenderInfo() const;
 
     bool isDecryptOnly() const
     {
         return m_type == Decrypt;
     }
     bool isVerifyOnly() const
     {
         return m_type == Verify;
     }
     bool isDecryptVerify() const
     {
         return m_type == DecryptVerify;
     }
     DecryptVerifyOperation m_type;
     VerificationResult m_verificationResult;
     DecryptionResult m_decryptionResult;
     QByteArray m_stuff;
     QString m_fileName;
     GpgME::Error m_error;
     QString m_errorString;
     QString m_inputLabel;
     QString m_outputLabel;
     const AuditLogEntry m_auditLog;
     QPointer <Task> m_parentTask;
     const Mailbox m_informativeSender;
 };
 
 DecryptVerifyResult::SenderInfo DecryptVerifyResult::Private::makeSenderInfo() const
 {
     return SenderInfo(m_informativeSender, KeyCache::instance()->findSigners(m_verificationResult));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const DecryptionResult &dr, const QByteArray &plaintext, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Decrypt,
             VerificationResult(),
             dr,
             plaintext,
             {},
             {},
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const GpgME::Error &err, const QString &what, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Decrypt,
             VerificationResult(),
             DecryptionResult(err),
             QByteArray(),
             {},
             err,
             what,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plaintext, const QString &fileName, const AuditLogEntry &auditLog)
 {
     const auto err = dr.error().code() ? dr.error() : vr.error();
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             DecryptVerify,
             vr,
             dr,
             plaintext,
             fileName,
             err,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const GpgME::Error &err, const QString &details, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             DecryptVerify,
             VerificationResult(),
             DecryptionResult(err),
             QByteArray(),
             {},
             err,
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const VerificationResult &vr, const QByteArray &plaintext, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             vr,
             DecryptionResult(),
             plaintext,
             {},
             {},
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const GpgME::Error &err, const QString &details, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             VerificationResult(err),
             DecryptionResult(),
             QByteArray(),
             {},
             err,
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const VerificationResult &vr, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             vr,
             DecryptionResult(),
             QByteArray(),
             {},
             {},
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const GpgME::Error &err, const QString &details, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             VerificationResult(err),
             DecryptionResult(),
             QByteArray(),
             {},
             err,
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 DecryptVerifyResult::DecryptVerifyResult(DecryptVerifyOperation type,
         const VerificationResult &vr,
         const DecryptionResult &dr,
         const QByteArray &stuff,
         const QString &fileName,
         const GpgME::Error &error,
         const QString &errString,
         const QString &inputLabel,
         const QString &outputLabel,
         const AuditLogEntry &auditLog,
         Task *parentTask,
         const Mailbox &informativeSender)
     : Task::Result(), d(new Private(type, vr, dr, stuff, fileName, error, errString, inputLabel, outputLabel, auditLog, parentTask, informativeSender, this))
 {
 }
 
 QString DecryptVerifyResult::overview() const
 {
     QString ov;
     if (d->isDecryptOnly()) {
         ov += formatDecryptionResultOverview(d->m_decryptionResult);
     } else if (d->isVerifyOnly()) {
         ov += formatVerificationResultOverview(d->m_verificationResult, d->makeSenderInfo());
     } else {
         ov += formatDecryptVerifyResultOverview(d->m_decryptionResult, d->m_verificationResult, d->makeSenderInfo());
     }
     if (ov.size() + d->label().size() > 120) {
         // Avoid ugly breaks
         ov = QStringLiteral("<br>") + ov;
     }
     return i18nc("label: result example: foo.sig: Verification failed. ", "%1: %2", d->label(), ov);
 }
 
 QString DecryptVerifyResult::details() const
 {
     if (d->isDecryptOnly()) {
         return formatDecryptionResultDetails(d->m_decryptionResult,
                 KeyCache::instance()->findRecipients(d->m_decryptionResult),
                 errorString(), false, d->m_parentTask);
     }
     if (d->isVerifyOnly()) {
         return formatVerificationResultDetails(d->m_verificationResult, d->makeSenderInfo(), errorString());
     }
     return formatDecryptVerifyResultDetails(d->m_decryptionResult,
                                             d->m_verificationResult, KeyCache::instance()->findRecipients(
                                                     d->m_decryptionResult), d->makeSenderInfo(), errorString(),
                                             d->m_parentTask);
 }
 
 GpgME::Error DecryptVerifyResult::error() const
 {
     return d->m_error;
 }
 
 QString DecryptVerifyResult::errorString() const
 {
     return d->m_errorString;
 }
 
 AuditLogEntry DecryptVerifyResult::auditLog() const
 {
     return d->m_auditLog;
 }
 
 QPointer<Task> DecryptVerifyResult::parentTask() const
 {
     return d->m_parentTask;
 }
 
 Task::Result::VisualCode DecryptVerifyResult::code() const
 {
     if ((d->m_type == DecryptVerify || d->m_type == Verify) && relevantInDecryptVerifyContext(verificationResult())) {
         return codeForVerificationResult(verificationResult());
     }
     return hasError() ? NeutralError : NeutralSuccess;
 }
 
 GpgME::VerificationResult DecryptVerifyResult::verificationResult() const
 {
     return d->m_verificationResult;
 }
 
 GpgME::DecryptionResult DecryptVerifyResult::decryptionResult() const
 {
     return d->m_decryptionResult;
 }
 
 QString DecryptVerifyResult::fileName() const
 {
     return d->m_fileName;
 }
 
 class AbstractDecryptVerifyTask::Private
 {
 public:
     Mailbox informativeSender;
 };
 
 AbstractDecryptVerifyTask::AbstractDecryptVerifyTask(QObject *parent) : Task(parent), d(new Private) {}
 
 AbstractDecryptVerifyTask::~AbstractDecryptVerifyTask() {}
 
 Mailbox AbstractDecryptVerifyTask::informativeSender() const
 {
     return d->informativeSender;
 }
 
 void AbstractDecryptVerifyTask::setInformativeSender(const Mailbox &sender)
 {
     d->informativeSender = sender;
 }
 
 class DecryptVerifyTask::Private
 {
     DecryptVerifyTask *const q;
 public:
     explicit Private(DecryptVerifyTask *qq)
         : q{qq}
     {
     }
 
     void startDecryptVerifyJob();
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     void startDecryptVerifyArchiveJob();
 #endif
 
     void slotResult(const DecryptionResult &, const VerificationResult &, const QByteArray & = {});
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend = nullptr;
     Protocol m_protocol = UnknownProtocol;
     bool m_ignoreMDCError = false;
     bool m_extractArchive = false;
     QString m_outputDirectory;
 };
 
 void DecryptVerifyTask::Private::slotResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plainText)
 {
     updateKeys(vr);
     {
         std::stringstream ss;
         ss << dr << '\n' << vr;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLogEntry auditLog = auditLogFromSender(q->sender());
     if (m_output) {
         if (dr.error().code() || vr.error().code()) {
             m_output->cancel();
         } else {
             try {
                 kleo_assert(!dr.isNull() || !vr.isNull());
                 m_output->finalize();
             } catch (const GpgME::Exception &e) {
                 q->emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
                 return;
             } catch (const std::exception &e) {
                 q->emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
                 return;
             } catch (...) {
                 q->emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
                 return;
             }
         }
     }
     const int drErr = dr.error().code();
     const QString errorString = m_output ? m_output->errorString() : QString{};
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           (m_output && m_output->failed())) {
         q->emitResult(q->fromDecryptResult(drErr ? dr.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     q->emitResult(q->fromDecryptVerifyResult(dr, vr, plainText, m_output ? m_output->fileName() : QString{}, auditLog));
 }
 
 DecryptVerifyTask::DecryptVerifyTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 DecryptVerifyTask::~DecryptVerifyTask()
 {
 }
 
 void DecryptVerifyTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void DecryptVerifyTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void DecryptVerifyTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = prot == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void DecryptVerifyTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature/ciphertext - maybe it is neither ciphertext nor a signature?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString DecryptVerifyTask::label() const
 {
     return i18n("Decrypting: %1...", d->m_input->label());
 }
 
 unsigned long long DecryptVerifyTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString DecryptVerifyTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString DecryptVerifyTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : d->m_outputDirectory;
 }
 
 Protocol DecryptVerifyTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void DecryptVerifyTask::cancel()
 {
 
 }
 
 static void ensureIOOpen(QIODevice *input, QIODevice *output)
 {
     if (input && !input->isOpen()) {
         input->open(QIODevice::ReadOnly);
     }
     if (output && !output->isOpen()) {
         output->open(QIODevice::WriteOnly);
     }
 }
 
 void DecryptVerifyTask::setIgnoreMDCError(bool value)
 {
     d->m_ignoreMDCError = value;
 }
 
 void DecryptVerifyTask::setExtractArchive(bool extract)
 {
     d->m_extractArchive = extract;
 }
 
 void DecryptVerifyTask::setOutputDirectory(const QString &directory)
 {
     d->m_outputDirectory = directory;
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 static bool archiveJobsCanBeUsed(GpgME::Protocol protocol)
 {
     return (protocol == GpgME::OpenPGP) && QGpgME::DecryptVerifyArchiveJob::isSupported();
 }
 #endif
 
 void DecryptVerifyTask::doStart()
 {
     kleo_assert(d->m_backend);
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     if (d->m_extractArchive && archiveJobsCanBeUsed(d->m_protocol)) {
         d->startDecryptVerifyArchiveJob();
     } else
 #endif
     {
         d->startDecryptVerifyJob();
     }
 }
 
 static void setIgnoreMDCErrorFlag(QGpgME::Job *job, bool ignoreMDCError)
 {
     if (ignoreMDCError) {
         qCDebug(KLEOPATRA_LOG) << "Modifying job to ignore MDC errors.";
         auto ctx = QGpgME::Job::context(job);
         if (!ctx) {
             qCWarning(KLEOPATRA_LOG) << "Failed to get context for job";
         } else {
             const auto err = ctx->setFlag("ignore-mdc-error", "1");
             if (err) {
                 qCWarning(KLEOPATRA_LOG) << "Failed to set ignore mdc errors" << err.asString();
             }
         }
     }
 }
 
 void DecryptVerifyTask::Private::startDecryptVerifyJob()
 {
     try {
         QGpgME::DecryptVerifyJob *const job = m_backend->decryptVerifyJob();
         kleo_assert(job);
         setIgnoreMDCErrorFlag(job, m_ignoreMDCError);
         QObject::connect(job, &QGpgME::DecryptVerifyJob::result, q, [this](const GpgME::DecryptionResult &decryptResult, const GpgME::VerificationResult &verifyResult, const QByteArray &plainText) {
             slotResult(decryptResult, verifyResult, plainText);
         });
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+        connect(job, &QGpgME::Job::jobProgress, q, &DecryptVerifyTask::setProgress);
+#else
         QObject::connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
             q->setProgress(processed, total);
         });
+#endif
         ensureIOOpen(m_input->ioDevice().get(), m_output->ioDevice().get());
         job->start(m_input->ioDevice(), m_output->ioDevice());
     } catch (const GpgME::Exception &e) {
         q->emitResult(q->fromDecryptVerifyResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
     } catch (const std::exception &e) {
         q->emitResult(q->fromDecryptVerifyResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
     } catch (...) {
         q->emitResult(q->fromDecryptVerifyResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
     }
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 void DecryptVerifyTask::Private::startDecryptVerifyArchiveJob()
 {
     auto *const job = m_backend->decryptVerifyArchiveJob();
     kleo_assert(job);
     setIgnoreMDCErrorFlag(job, m_ignoreMDCError);
     job->setOutputDirectory(m_outputDirectory);
     connect(job, &QGpgME::DecryptVerifyArchiveJob::result, q, [this](const GpgME::DecryptionResult &decryptResult, const GpgME::VerificationResult &verifyResult) {
         slotResult(decryptResult, verifyResult);
     });
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(job, &QGpgME::Job::jobProgress, q, &DecryptVerifyTask::setProgress);
+#else
     connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
         q->setProgress(processed, total);
     });
+#endif
     ensureIOOpen(m_input->ioDevice().get(), nullptr);
     const auto err = job->start(m_input->ioDevice());
     if (err) {
         q->emitResult(q->fromDecryptVerifyResult(err, {}, {}));
     }
 }
 #endif
 
 class DecryptTask::Private
 {
     DecryptTask *const q;
 public:
     explicit Private(DecryptTask *qq)
         : q{qq}
     {
     }
 
     void slotResult(const DecryptionResult &, const QByteArray &);
 
     void registerJob(QGpgME::DecryptJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::DecryptionResult,QByteArray)),
                    q, SLOT(slotResult(GpgME::DecryptionResult,QByteArray)));
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+        q->connect(job, &QGpgME::Job::jobProgress, q, &DecryptTask::setProgress);
+#else
         q->connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
             q->setProgress(processed, total);
         });
+#endif
     }
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend = nullptr;
     Protocol m_protocol = UnknownProtocol;
 };
 
 void DecryptTask::Private::slotResult(const DecryptionResult &result, const QByteArray &plainText)
 {
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLogEntry auditLog = auditLogFromSender(q->sender());
     if (result.error().code()) {
         m_output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             m_output->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         } catch (const std::exception &e) {
             q->emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
             return;
         } catch (...) {
             q->emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
             return;
         }
     }
 
     const int drErr = result.error().code();
     const QString errorString = m_output->errorString();
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           m_output->failed()) {
         q->emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     q->emitResult(q->fromDecryptResult(result, plainText, auditLog));
 }
 
 DecryptTask::DecryptTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 DecryptTask::~DecryptTask()
 {
 }
 
 void DecryptTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void DecryptTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void DecryptTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void DecryptTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this was S/MIME- or OpenPGP-encrypted - maybe it is not ciphertext at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString DecryptTask::label() const
 {
     return i18n("Decrypting: %1...", d->m_input->label());
 }
 
 unsigned long long DecryptTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString DecryptTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString DecryptTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : QString();
 }
 
 Protocol DecryptTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void DecryptTask::cancel()
 {
 
 }
 
 void DecryptTask::doStart()
 {
     kleo_assert(d->m_backend);
 
     try {
         QGpgME::DecryptJob *const job = d->m_backend->decryptJob();
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), d->m_output->ioDevice().get());
         job->start(d->m_input->ioDevice(), d->m_output->ioDevice());
     } catch (const GpgME::Exception &e) {
         emitResult(fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
     } catch (const std::exception &e) {
         emitResult(fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
     } catch (...) {
         emitResult(fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
     }
 }
 
 class VerifyOpaqueTask::Private
 {
     VerifyOpaqueTask *const q;
 public:
     explicit Private(VerifyOpaqueTask *qq)
         : q{qq}
     {
     }
 
     void startVerifyOpaqueJob();
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     void startDecryptVerifyArchiveJob();
 #endif
 
     void slotResult(const VerificationResult &, const QByteArray & = {});
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend = nullptr;
     Protocol m_protocol = UnknownProtocol;
     bool m_extractArchive = false;
     QString m_outputDirectory;
 };
 
 void VerifyOpaqueTask::Private::slotResult(const VerificationResult &result, const QByteArray &plainText)
 {
     updateKeys(result);
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLogEntry auditLog = auditLogFromSender(q->sender());
     if (m_output) {
         if (result.error().code()) {
             m_output->cancel();
         } else {
             try {
                 kleo_assert(!result.isNull());
                 m_output->finalize();
             } catch (const GpgME::Exception &e) {
                 q->emitResult(q->fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
                 return;
             } catch (const std::exception &e) {
                 q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
                 return;
             } catch (...) {
                 q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
                 return;
             }
         }
     }
 
     const int drErr = result.error().code();
     const QString errorString = m_output ? m_output->errorString() : QString{};
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           (m_output && m_output->failed())) {
         q->emitResult(q->fromVerifyOpaqueResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     q->emitResult(q->fromVerifyOpaqueResult(result, plainText, auditLog));
 }
 
 VerifyOpaqueTask::VerifyOpaqueTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 VerifyOpaqueTask::~VerifyOpaqueTask()
 {
 }
 
 void VerifyOpaqueTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void VerifyOpaqueTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void VerifyOpaqueTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void VerifyOpaqueTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature - maybe it is not a signature at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString VerifyOpaqueTask::label() const
 {
     return i18n("Verifying: %1...", d->m_input->label());
 }
 
 unsigned long long VerifyOpaqueTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString VerifyOpaqueTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString VerifyOpaqueTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : d->m_outputDirectory;
 }
 
 Protocol VerifyOpaqueTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void VerifyOpaqueTask::setExtractArchive(bool extract)
 {
     d->m_extractArchive = extract;
 }
 
 void VerifyOpaqueTask::setOutputDirectory(const QString &directory)
 {
     d->m_outputDirectory = directory;
 }
 
 void VerifyOpaqueTask::cancel()
 {
 
 }
 
 void VerifyOpaqueTask::doStart()
 {
     kleo_assert(d->m_backend);
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     if (d->m_extractArchive && archiveJobsCanBeUsed(d->m_protocol)) {
         d->startDecryptVerifyArchiveJob();
     } else
 #endif
     {
         d->startVerifyOpaqueJob();
     }
 }
 
 void VerifyOpaqueTask::Private::startVerifyOpaqueJob()
 {
     try {
         QGpgME::VerifyOpaqueJob *const job = m_backend->verifyOpaqueJob();
         kleo_assert(job);
         connect(job, &QGpgME::VerifyOpaqueJob::result, q, [this](const GpgME::VerificationResult &result, const QByteArray &plainText) {
             slotResult(result, plainText);
         });
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+        connect(job, &QGpgME::Job::jobProgress, q, &VerifyOpaqueTask::setProgress);
+#else
         connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
             q->setProgress(processed, total);
         });
+#endif
         ensureIOOpen(m_input->ioDevice().get(), m_output ? m_output->ioDevice().get() : nullptr);
         job->start(m_input->ioDevice(), m_output ? m_output->ioDevice() : std::shared_ptr<QIODevice>());
     } catch (const GpgME::Exception &e) {
         q->emitResult(q->fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
     } catch (const std::exception &e) {
         q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
     } catch (...) {
         q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
     }
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 void VerifyOpaqueTask::Private::startDecryptVerifyArchiveJob()
 {
     auto *const job = m_backend->decryptVerifyArchiveJob();
     kleo_assert(job);
     job->setOutputDirectory(m_outputDirectory);
     connect(job, &QGpgME::DecryptVerifyArchiveJob::result, q, [this](const DecryptionResult &, const VerificationResult &verifyResult) {
         slotResult(verifyResult);
     });
     connect(job, &QGpgME::DecryptVerifyArchiveJob::dataProgress, q, &VerifyOpaqueTask::setProgress);
     ensureIOOpen(m_input->ioDevice().get(), nullptr);
     const auto err = job->start(m_input->ioDevice());
     if (err) {
         q->emitResult(q->fromVerifyOpaqueResult(err, {}, {}));
     }
 }
 #endif
 
 class VerifyDetachedTask::Private
 {
     VerifyDetachedTask *const q;
 public:
     explicit Private(VerifyDetachedTask *qq)
         : q{qq}
     {
     }
 
     void slotResult(const VerificationResult &);
 
     void registerJob(QGpgME::VerifyDetachedJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::VerificationResult)),
                    q, SLOT(slotResult(GpgME::VerificationResult)));
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+        q->connect(job, &QGpgME::Job::jobProgress, q, &VerifyDetachedTask::setProgress);
+#else
         q->connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
             q->setProgress(processed, total);
         });
+#endif
     }
 
     std::shared_ptr<Input> m_input, m_signedData;
     const QGpgME::Protocol *m_backend = nullptr;
     Protocol m_protocol = UnknownProtocol;
 };
 
 void VerifyDetachedTask::Private::slotResult(const VerificationResult &result)
 {
     updateKeys(result);
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLogEntry auditLog = auditLogFromSender(q->sender());
     try {
         kleo_assert(!result.isNull());
         q->emitResult(q->fromVerifyDetachedResult(result, auditLog));
     } catch (const GpgME::Exception &e) {
         q->emitResult(q->fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
     } catch (const std::exception &e) {
         q->emitResult(q->fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
     } catch (...) {
         q->emitResult(q->fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
     }
 }
 
 VerifyDetachedTask::VerifyDetachedTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 VerifyDetachedTask::~VerifyDetachedTask()
 {
 }
 
 void VerifyDetachedTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void VerifyDetachedTask::setSignedData(const std::shared_ptr<Input> &signedData)
 {
     d->m_signedData = signedData;
     kleo_assert(d->m_signedData && d->m_signedData->ioDevice());
 }
 
 void VerifyDetachedTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void VerifyDetachedTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature - maybe it is not a signature at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 unsigned long long VerifyDetachedTask::inputSize() const
 {
     return d->m_signedData ? d->m_signedData->size() : 0;
 }
 
 QString VerifyDetachedTask::label() const
 {
     if (d->m_signedData) {
         return xi18nc("Verification of a detached signature in progress. The first file contains the data."
                       "The second file is the signature file.",
                       "Verifying: <filename>%1</filename> with <filename>%2</filename>...",
                       d->m_signedData->label(),
                       d->m_input->label());
 
     }
     return i18n("Verifying signature: %1...", d->m_input->label());
 }
 
 QString VerifyDetachedTask::inputLabel() const
 {
     if (d->m_signedData && d->m_input) {
         return xi18nc("Verification of a detached signature summary. The first file contains the data."
                       "The second file is signature.",
                       "Verified <filename>%1</filename> with <filename>%2</filename>",
                       d->m_signedData->label(),
                       d->m_input->label());
 
     }
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString VerifyDetachedTask::outputLabel() const
 {
     return QString();
 }
 
 Protocol VerifyDetachedTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void VerifyDetachedTask::cancel()
 {
 
 }
 
 void VerifyDetachedTask::doStart()
 {
     kleo_assert(d->m_backend);
     try {
         QGpgME::VerifyDetachedJob *const job = d->m_backend->verifyDetachedJob();
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), nullptr);
         ensureIOOpen(d->m_signedData->ioDevice().get(), nullptr);
         job->start(d->m_input->ioDevice(), d->m_signedData->ioDevice());
     } catch (const GpgME::Exception &e) {
         emitResult(fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
     } catch (const std::exception &e) {
         emitResult(fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
     } catch (...) {
         emitResult(fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
     }
 }
 
 #include "moc_decryptverifytask.cpp"
diff --git a/src/crypto/encryptemailtask.cpp b/src/crypto/encryptemailtask.cpp
index a014c915f..8abdeac75 100644
--- a/src/crypto/encryptemailtask.cpp
+++ b/src/crypto/encryptemailtask.cpp
@@ -1,233 +1,237 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/encryptemailtask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "encryptemailtask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/Stl_Util>
 #include <QGpgME/Protocol>
 #include <QGpgME/EncryptJob>
 
 #include <gpgme++/encryptionresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 class EncryptEMailResult : public Task::Result
 {
     const EncryptionResult m_result;
     const AuditLogEntry m_auditLog;
 public:
     EncryptEMailResult(const EncryptionResult &r, const AuditLogEntry &auditLog)
         : Task::Result(), m_result(r), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     GpgME::Error error() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLogEntry auditLog() const override;
 };
 
 QString makeResultString(const EncryptionResult &res)
 {
     const Error err = res.error();
 
     if (err.isCanceled()) {
         return i18n("Encryption canceled.");
     }
 
     if (err) {
         return i18n("Encryption failed: %1", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
 
     return i18n("Encryption succeeded.");
 }
 
 }
 
 class EncryptEMailTask::Private
 {
     friend class ::Kleo::Crypto::EncryptEMailTask;
     EncryptEMailTask *const q;
 public:
     explicit Private(EncryptEMailTask *qq);
 
 private:
     std::unique_ptr<QGpgME::EncryptJob> createJob(GpgME::Protocol proto);
 
 private:
     void slotResult(const EncryptionResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     std::vector<Key> recipients;
 
     QPointer<QGpgME::EncryptJob> job;
 };
 
 EncryptEMailTask::Private::Private(EncryptEMailTask *qq)
     : q(qq),
       input(),
       output(),
       job(nullptr)
 {
 
 }
 
 EncryptEMailTask::EncryptEMailTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 EncryptEMailTask::~EncryptEMailTask() {}
 
 void EncryptEMailTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void EncryptEMailTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void EncryptEMailTask::setRecipients(const std::vector<Key> &recipients)
 {
     kleo_assert(!d->job);
     kleo_assert(!recipients.empty());
     d->recipients = recipients;
 }
 
 Protocol EncryptEMailTask::protocol() const
 {
     kleo_assert(!d->recipients.empty());
     return d->recipients.front().protocol();
 }
 
 QString EncryptEMailTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 unsigned long long EncryptEMailTask::inputSize() const
 {
     return d->input ? d->input->size() : 0;
 }
 
 void EncryptEMailTask::doStart()
 {
     kleo_assert(!d->job);
     kleo_assert(d->input);
     kleo_assert(d->output);
     kleo_assert(!d->recipients.empty());
 
     std::unique_ptr<QGpgME::EncryptJob> job = d->createJob(protocol());
     kleo_assert(job.get());
 
     job->start(d->recipients,
                d->input->ioDevice(), d->output->ioDevice(),
                /*alwaysTrust=*/true);
 
     d->job = job.release();
 }
 
 void EncryptEMailTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::EncryptJob> EncryptEMailTask::Private::createJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     bool shouldArmor = (proto == OpenPGP || q->asciiArmor()) && !output->binaryOpt();
     std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(shouldArmor, /*textmode=*/false));
     kleo_assert(encryptJob.get());
     if (proto == CMS && !q->asciiArmor() && !output->binaryOpt()) {
         encryptJob->setOutputIsBase64Encoded(true);
     }
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(encryptJob.get(), &QGpgME::Job::jobProgress, q, &EncryptEMailTask::setProgress);
+#else
     connect(encryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
         q->setProgress(processed, total);
     });
+#endif
     connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::EncryptionResult)));
     return encryptJob;
 }
 
 void EncryptEMailTask::Private::slotResult(const EncryptionResult &result)
 {
     const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     if (result.error().code()) {
         output->cancel();
     } else {
         output->finalize();
     }
     q->emitResult(std::shared_ptr<Result>(new EncryptEMailResult(result, AuditLogEntry::fromJob(job))));
 }
 
 QString EncryptEMailResult::overview() const
 {
     return makeOverview(makeResultString(m_result));
 }
 
 QString EncryptEMailResult::details() const
 {
     return QString();
 }
 
 GpgME::Error EncryptEMailResult::error() const
 {
     return m_result.error();
 }
 
 QString EncryptEMailResult::errorString() const
 {
     return hasError() ? makeResultString(m_result) : QString();
 }
 
 AuditLogEntry EncryptEMailResult::auditLog() const
 {
     return m_auditLog;
 }
 
 Task::Result::VisualCode EncryptEMailResult::code() const
 {
     if (m_result.error().isCanceled()) {
         return Warning;
     }
     return m_result.error().code() ? NeutralError : NeutralSuccess;
 }
 
 #include "moc_encryptemailtask.cpp"
 
diff --git a/src/crypto/signemailtask.cpp b/src/crypto/signemailtask.cpp
index 5a7fed171..05027517b 100644
--- a/src/crypto/signemailtask.cpp
+++ b/src/crypto/signemailtask.cpp
@@ -1,285 +1,289 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signemailtask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signemailtask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignJob>
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 #include <algorithm>
 #include <functional>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 class SignEMailResult : public Task::Result
 {
     const SigningResult m_result;
     const AuditLogEntry m_auditLog;
 public:
     explicit SignEMailResult(const SigningResult &r, const AuditLogEntry &auditLog)
         : Task::Result(), m_result(r), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     GpgME::Error error() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLogEntry auditLog() const override;
 };
 
 QString makeResultString(const SigningResult &res)
 {
     const Error err = res.error();
 
     if (err.isCanceled()) {
         return i18n("Signing canceled.");
     }
 
     if (err) {
         return i18n("Signing failed: %1", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
 
     return i18n("Signing succeeded.");
 }
 }
 
 class SignEMailTask::Private
 {
     friend class ::Kleo::Crypto::SignEMailTask;
     SignEMailTask *const q;
 public:
     explicit Private(SignEMailTask *qq);
 
 private:
     std::unique_ptr<QGpgME::SignJob> createJob(GpgME::Protocol proto);
 
 private:
     void slotResult(const SigningResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     std::vector<Key> signers;
     bool detached;
     bool clearsign;
 
     QString micAlg;
 
     QPointer<QGpgME::SignJob> job;
 };
 
 SignEMailTask::Private::Private(SignEMailTask *qq)
     : q(qq),
       input(),
       output(),
       signers(),
       detached(false),
       clearsign(false),
       micAlg(),
       job(nullptr)
 {
 
 }
 
 SignEMailTask::SignEMailTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 SignEMailTask::~SignEMailTask() {}
 
 void SignEMailTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void SignEMailTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void SignEMailTask::setSigners(const std::vector<Key> &signers)
 {
     kleo_assert(!d->job);
     kleo_assert(!signers.empty());
     kleo_assert(std::none_of(signers.cbegin(), signers.cend(), std::mem_fn(&Key::isNull)));
     d->signers = signers;
 }
 
 void SignEMailTask::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->job);
     d->detached = detached;
     d->clearsign = false;
 }
 
 void SignEMailTask::setClearsign(bool clear)
 {
     kleo_assert(!d->job);
     d->clearsign = clear;
     d->detached = false;
 }
 
 Protocol SignEMailTask::protocol() const
 {
     kleo_assert(!d->signers.empty());
     return d->signers.front().protocol();
 }
 
 QString SignEMailTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 unsigned long long SignEMailTask::inputSize() const
 {
     return d->input ? d->input->size() : 0;
 }
 
 void SignEMailTask::doStart()
 {
     kleo_assert(!d->job);
     kleo_assert(d->input);
     kleo_assert(d->output);
     kleo_assert(!d->signers.empty());
 
     d->micAlg.clear();
 
     std::unique_ptr<QGpgME::SignJob> job = d->createJob(protocol());
     kleo_assert(job.get());
 
     job->start(d->signers,
                d->input->ioDevice(), d->output->ioDevice(),
                d->clearsign ? GpgME::Clearsigned : d->detached ? GpgME::Detached : GpgME::NormalSignatureMode);
 
     d->job = job.release();
 }
 
 void SignEMailTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::SignJob> SignEMailTask::Private::createJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     bool shouldArmor = (proto == OpenPGP || q->asciiArmor()) && !output->binaryOpt();
     std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(/*armor=*/ shouldArmor, /*textmode=*/false));
     kleo_assert(signJob.get());
     if (proto == CMS && !q->asciiArmor() && !output->binaryOpt()) {
         signJob->setOutputIsBase64Encoded(true);
     }
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(signJob.get(), &QGpgME::Job::jobProgress, q, &SignEMailTask::setProgress);
+#else
     connect(signJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
         q->setProgress(processed, total);
     });
+#endif
     connect(signJob.get(), SIGNAL(result(GpgME::SigningResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult)));
     return signJob;
 }
 
 static QString collect_micalgs(const GpgME::SigningResult &result, GpgME::Protocol proto)
 {
     const std::vector<GpgME::CreatedSignature> css = result.createdSignatures();
     QStringList micalgs;
     std::transform(css.begin(), css.end(),
                    std::back_inserter(micalgs),
                    [](const GpgME::CreatedSignature &sig) {
                        return QString::fromLatin1(sig.hashAlgorithmAsString()).toLower();
                    });
     if (proto == GpgME::OpenPGP)
         for (QStringList::iterator it = micalgs.begin(), end = micalgs.end(); it != end; ++it) {
             it->prepend(QLatin1String("pgp-"));
         }
     micalgs.sort();
     micalgs.erase(std::unique(micalgs.begin(), micalgs.end()), micalgs.end());
     return micalgs.join(QLatin1Char(','));
 }
 
 void SignEMailTask::Private::slotResult(const SigningResult &result)
 {
     const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     if (result.error().code()) {
         output->cancel();
     } else {
         output->finalize();
         micAlg = collect_micalgs(result, q->protocol());
     }
     q->emitResult(std::shared_ptr<Result>(new SignEMailResult(result, AuditLogEntry::fromJob(job))));
 }
 
 QString SignEMailTask::micAlg() const
 {
     return d->micAlg;
 }
 
 QString SignEMailResult::overview() const
 {
     return makeOverview(makeResultString(m_result));
 }
 
 QString SignEMailResult::details() const
 {
     return QString();
 }
 
 GpgME::Error SignEMailResult::error() const
 {
     return m_result.error();
 }
 
 QString SignEMailResult::errorString() const
 {
     return hasError() ? makeResultString(m_result) : QString();
 }
 
 Task::Result::VisualCode SignEMailResult::code() const
 {
     if (m_result.error().isCanceled()) {
         return Warning;
     }
     return m_result.error().code() ? NeutralError : NeutralSuccess;
 }
 
 AuditLogEntry SignEMailResult::auditLog() const
 {
     return m_auditLog;
 }
 
 #include "moc_signemailtask.cpp"
 
diff --git a/src/crypto/signencrypttask.cpp b/src/crypto/signencrypttask.cpp
index d3b1a105c..75f4e4d3f 100644
--- a/src/crypto/signencrypttask.cpp
+++ b/src/crypto/signencrypttask.cpp
@@ -1,800 +1,812 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signencrypttask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencrypttask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/path-helper.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KleoException>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignJob>
 #include <QGpgME/SignEncryptJob>
 #include <QGpgME/EncryptJob>
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 #include <QGpgME/EncryptArchiveJob>
 #include <QGpgME/SignArchiveJob>
 #include <QGpgME/SignEncryptArchiveJob>
 #endif
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/encryptionresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 #include <QFileInfo>
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 QString formatInputOutputLabel(const QString &input, const QString &output, bool outputDeleted)
 {
     return i18nc("Input file --> Output file (rarr is arrow", "%1 &rarr; %2",
                  input.toHtmlEscaped(),
                  outputDeleted ? QStringLiteral("<s>%1</s>").arg(output.toHtmlEscaped()) : output.toHtmlEscaped());
 }
 
 class ErrorResult : public Task::Result
 {
 public:
     ErrorResult(bool sign, bool encrypt, const Error &err, const QString &errStr, const QString &input, const QString &output, const AuditLogEntry &auditLog)
         : Task::Result(), m_sign(sign), m_encrypt(encrypt), m_error(err), m_errString(errStr), m_inputLabel(input), m_outputLabel(output), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     GpgME::Error error() const override
     {
         return m_error;
     }
     QString errorString() const override
     {
         return m_errString;
     }
     VisualCode code() const override
     {
         return NeutralError;
     }
     AuditLogEntry auditLog() const override
     {
         return m_auditLog;
     }
 private:
     const bool m_sign;
     const bool m_encrypt;
     const Error m_error;
     const QString m_errString;
     const QString m_inputLabel;
     const QString m_outputLabel;
     const AuditLogEntry m_auditLog;
 };
 
 namespace
 {
 struct LabelAndError
 {
     QString label;
     QString errorString;
 };
 }
 
 class SignEncryptFilesResult : public Task::Result
 {
 public:
     SignEncryptFilesResult(const SigningResult &sr, const LabelAndError &input, const LabelAndError &output, bool outputCreated, const AuditLogEntry &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_input{input},
           m_output{output},
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString
                                << "\noutputError:" << m_output.errorString;
         Q_ASSERT(!m_sresult.isNull());
     }
     SignEncryptFilesResult(const EncryptionResult &er, const LabelAndError &input, const LabelAndError &output, bool outputCreated, const AuditLogEntry &auditLog)
         : Task::Result(),
           m_eresult(er),
           m_input{input},
           m_output{output},
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString
                                << "\noutputError:" << m_output.errorString;
         Q_ASSERT(!m_eresult.isNull());
     }
     SignEncryptFilesResult(const SigningResult &sr, const EncryptionResult &er, const LabelAndError &input, const LabelAndError &output, bool outputCreated,  const AuditLogEntry &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_eresult(er),
           m_input{input},
           m_output{output},
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString
                                << "\noutputError:" << m_output.errorString;
         Q_ASSERT(!m_sresult.isNull() || !m_eresult.isNull());
     }
 
     QString overview() const override;
     QString details() const override;
     GpgME::Error error() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLogEntry auditLog() const override;
 
 private:
     const SigningResult m_sresult;
     const EncryptionResult m_eresult;
     const LabelAndError m_input;
     const LabelAndError m_output;
     const bool m_outputCreated;
     const AuditLogEntry m_auditLog;
 };
 
 static QString makeSigningOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Signing canceled.");
     }
 
     if (err) {
         return i18n("Signing failed.");
     }
     return i18n("Signing succeeded.");
 }
 
 static QString makeResultOverview(const SigningResult &result)
 {
     return makeSigningOverview(result.error());
 }
 
 static QString makeEncryptionOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Encryption canceled.");
     }
 
     if (err) {
         return i18n("Encryption failed.");
     }
 
     return i18n("Encryption succeeded.");
 }
 
 static QString makeResultOverview(const EncryptionResult &result)
 {
     return makeEncryptionOverview(result.error());
 }
 
 static QString makeResultOverview(const SigningResult &sr, const EncryptionResult &er)
 {
     if (er.isNull() && sr.isNull()) {
         return QString();
     }
     if (er.isNull()) {
         return makeResultOverview(sr);
     }
     if (sr.isNull()) {
         return makeResultOverview(er);
     }
     if (sr.error().isCanceled() || sr.error()) {
         return makeResultOverview(sr);
     }
     if (er.error().isCanceled() || er.error()) {
         return makeResultOverview(er);
     }
     return i18n("Signing and encryption succeeded.");
 }
 
 static QString escape(QString s)
 {
     s = s.toHtmlEscaped();
     s.replace(QLatin1Char('\n'), QStringLiteral("<br>"));
     return s;
 }
 
 static QString makeResultDetails(const SigningResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err || err.isCanceled()) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return QString();
 }
 
 static QString makeResultDetails(const EncryptionResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err || err.isCanceled()) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return i18n(" Encryption succeeded.");
 }
 
 }
 
 QString ErrorResult::overview() const
 {
     Q_ASSERT(m_error || m_error.isCanceled());
     Q_ASSERT(m_sign || m_encrypt);
     const QString label = formatInputOutputLabel(m_inputLabel, m_outputLabel, true);
     const bool canceled = m_error.isCanceled();
     if (m_sign && m_encrypt) {
         return canceled ? i18n("%1: <b>Sign/encrypt canceled.</b>", label) : i18n(" %1: Sign/encrypt failed.", label);
     }
     return i18nc("label: result. Example: foo -> foo.gpg: Encryption failed.", "%1: <b>%2</b>", label,
                  m_sign ? makeSigningOverview(m_error) : makeEncryptionOverview(m_error));
 }
 
 QString ErrorResult::details() const
 {
     return m_errString;
 }
 
 class SignEncryptTask::Private
 {
     friend class ::Kleo::Crypto::SignEncryptTask;
     SignEncryptTask *const q;
 public:
     explicit Private(SignEncryptTask *qq);
 
 private:
     void startSignEncryptJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignJob> createSignJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignEncryptJob> createSignEncryptJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::EncryptJob> createEncryptJob(GpgME::Protocol proto);
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     void startSignEncryptArchiveJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignArchiveJob> createSignArchiveJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignEncryptArchiveJob> createSignEncryptArchiveJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::EncryptArchiveJob> createEncryptArchiveJob(GpgME::Protocol proto);
 #endif
 
     std::shared_ptr<const Task::Result> makeErrorResult(const Error &err, const QString &errStr, const AuditLogEntry &auditLog);
 
 private:
     void slotResult(const SigningResult &);
     void slotResult(const SigningResult &, const EncryptionResult &);
     void slotResult(const EncryptionResult &);
 
     void slotResult(const QGpgME::Job *, const SigningResult &, const EncryptionResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     QStringList inputFileNames;
     QString outputFileName;
     std::vector<Key> signers;
     std::vector<Key> recipients;
 
     bool sign     : 1;
     bool encrypt  : 1;
     bool detached : 1;
     bool symmetric: 1;
     bool clearsign: 1;
     bool archive  : 1;
 
     QPointer<QGpgME::Job> job;
     std::shared_ptr<OverwritePolicy> m_overwritePolicy;
 };
 
 SignEncryptTask::Private::Private(SignEncryptTask *qq)
     : q{qq}
     , sign{true}
     , encrypt{true}
     , detached{false}
     , clearsign{false}
     , archive{false}
     , m_overwritePolicy{new OverwritePolicy{nullptr}}
 {
     q->setAsciiArmor(true);
 }
 
 std::shared_ptr<const Task::Result> SignEncryptTask::Private::makeErrorResult(const Error &err, const QString &errStr, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<const ErrorResult>(new ErrorResult(sign, encrypt, err, errStr, q->label(), output ? output->label() : QString{}, auditLog));
 }
 
 SignEncryptTask::SignEncryptTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 SignEncryptTask::~SignEncryptTask() {}
 
 void SignEncryptTask::setInputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->inputFileNames = QStringList(fileName);
 }
 
 void SignEncryptTask::setInputFileNames(const QStringList &fileNames)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileNames.empty());
     d->inputFileNames = fileNames;
 }
 
 void SignEncryptTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void SignEncryptTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void SignEncryptTask::setOutputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->outputFileName = fileName;
 }
 
 void SignEncryptTask::setSigners(const std::vector<Key> &signers)
 {
     kleo_assert(!d->job);
     d->signers = signers;
 }
 
 void SignEncryptTask::setRecipients(const std::vector<Key> &recipients)
 {
     kleo_assert(!d->job);
     d->recipients = recipients;
 }
 
 void SignEncryptTask::setOverwritePolicy(const std::shared_ptr<OverwritePolicy> &policy)
 {
     kleo_assert(!d->job);
     d->m_overwritePolicy = policy;
 }
 
 void SignEncryptTask::setSign(bool sign)
 {
     kleo_assert(!d->job);
     d->sign = sign;
 }
 
 void SignEncryptTask::setEncrypt(bool encrypt)
 {
     kleo_assert(!d->job);
     d->encrypt = encrypt;
 }
 
 void SignEncryptTask::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->job);
     d->detached = detached;
 }
 
 void SignEncryptTask::setEncryptSymmetric(bool symmetric)
 {
     kleo_assert(!d->job);
     d->symmetric = symmetric;
 }
 
 void SignEncryptTask::setClearsign(bool clearsign)
 {
     kleo_assert(!d->job);
     d->clearsign = clearsign;
 }
 
 void SignEncryptTask::setCreateArchive(bool archive)
 {
     kleo_assert(!d->job);
     d->archive = archive;
 }
 
 Protocol SignEncryptTask::protocol() const
 {
     if (d->sign && !d->signers.empty()) {
         return d->signers.front().protocol();
     }
     if (d->encrypt || d->symmetric) {
         if (!d->recipients.empty()) {
             return d->recipients.front().protocol();
         } else {
             return GpgME::OpenPGP;    // symmetric OpenPGP encryption
         }
     }
     throw Kleo::Exception(gpg_error(GPG_ERR_INTERNAL),
                           i18n("Cannot determine protocol for task"));
 }
 
 QString SignEncryptTask::label() const
 {
     if (d->input) {
         return d->input->label();
     } else if (!d->inputFileNames.empty()) {
         const auto firstFile = QFileInfo{d->inputFileNames.front()}.fileName();
         return d->inputFileNames.size() == 1 ? firstFile : i18nc("<name of first file>, ...", "%1, ...", firstFile);
     }
     return {};
 }
 
 QString SignEncryptTask::tag() const
 {
     return Formatting::displayName(protocol());
 }
 
 unsigned long long SignEncryptTask::inputSize() const
 {
     return d->input ? d->input->size() : 0U;
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 static bool archiveJobsCanBeUsed(GpgME::Protocol protocol)
 {
     return (protocol == GpgME::OpenPGP) && QGpgME::SignEncryptArchiveJob::isSupported();
 }
 #endif
 
 void SignEncryptTask::doStart()
 {
     kleo_assert(!d->job);
     if (d->sign) {
         kleo_assert(!d->signers.empty());
         if (d->archive) {
             kleo_assert(!d->detached && !d->clearsign);
         }
     }
 
     if (!d->output) {
         d->output = Output::createFromFile(d->outputFileName, d->m_overwritePolicy);
     }
 
     const auto proto = protocol();
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     if (d->archive && archiveJobsCanBeUsed(proto)) {
         d->startSignEncryptArchiveJob(proto);
     } else
 #endif
     {
         d->startSignEncryptJob(proto);
     }
 }
 
 void SignEncryptTask::Private::startSignEncryptJob(GpgME::Protocol proto)
 {
     kleo_assert(input);
 
     if (encrypt || symmetric) {
         Context::EncryptionFlags flags = Context::AlwaysTrust;
         if (symmetric) {
             flags = static_cast<Context::EncryptionFlags>(flags | Context::Symmetric);
             qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
         }
         if (sign) {
             std::unique_ptr<QGpgME::SignEncryptJob> job = createSignEncryptJob(proto);
             kleo_assert(job.get());
 #if QGPGME_SUPPORTS_SET_FILENAME
             if (inputFileNames.size() == 1) {
                 job->setFileName(inputFileNames.front());
             }
 #endif
 
             job->start(signers, recipients,
                        input->ioDevice(), output->ioDevice(), flags);
 
             this->job = job.release();
         } else {
             std::unique_ptr<QGpgME::EncryptJob> job = createEncryptJob(proto);
             kleo_assert(job.get());
 #if QGPGME_SUPPORTS_SET_FILENAME
             if (inputFileNames.size() == 1) {
                 job->setFileName(inputFileNames.front());
             }
 #endif
 
             job->start(recipients, input->ioDevice(), output->ioDevice(), flags);
 
             this->job = job.release();
         }
     } else if (sign) {
         std::unique_ptr<QGpgME::SignJob> job = createSignJob(proto);
         kleo_assert(job.get());
         kleo_assert(! (detached && clearsign));
 
         job->start(signers,
                    input->ioDevice(), output->ioDevice(),
                    detached ? GpgME::Detached : clearsign ?
                               GpgME::Clearsigned : GpgME::NormalSignatureMode);
 
         this->job = job.release();
     } else {
         kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
     }
 }
 
 void SignEncryptTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::SignJob> SignEncryptTask::Private::createSignJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signJob.get());
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(signJob.get(), &QGpgME::Job::jobProgress, q, &SignEncryptTask::setProgress);
+#else
     connect(signJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
         q->setProgress(processed, total);
     });
+#endif
     connect(signJob.get(), SIGNAL(result(GpgME::SigningResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult)));
     return signJob;
 }
 
 std::unique_ptr<QGpgME::SignEncryptJob> SignEncryptTask::Private::createSignEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignEncryptJob> signEncryptJob(backend->signEncryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signEncryptJob.get());
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(signEncryptJob.get(), &QGpgME::Job::jobProgress, q, &SignEncryptTask::setProgress);
+#else
     connect(signEncryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
         q->setProgress(processed, total);
     });
+#endif
     connect(signEncryptJob.get(), SIGNAL(result(GpgME::SigningResult,GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult,GpgME::EncryptionResult)));
     return signEncryptJob;
 }
 
 std::unique_ptr<QGpgME::EncryptJob> SignEncryptTask::Private::createEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(encryptJob.get());
+#if QGPGME_JOB_HAS_NEW_PROGRESS_SIGNALS
+    connect(encryptJob.get(), &QGpgME::Job::jobProgress, q, &SignEncryptTask::setProgress);
+#else
     connect(encryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
         q->setProgress(processed, total);
     });
+#endif
     connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::EncryptionResult)));
     return encryptJob;
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 void SignEncryptTask::Private::startSignEncryptArchiveJob(GpgME::Protocol proto)
 {
     kleo_assert(!input);
 
     const auto baseDirectory = heuristicBaseDirectory(inputFileNames);
     if (baseDirectory.isEmpty()) {
         throw Kleo::Exception(GPG_ERR_CONFLICT, i18n("Cannot find common base directory for these files:\n%1", inputFileNames.join(QLatin1Char('\n'))));
     }
     qCDebug(KLEOPATRA_LOG) << "heuristicBaseDirectory(" << inputFileNames << ") ->" << baseDirectory;
     const auto tempPaths = makeRelativeTo(baseDirectory, inputFileNames);
     const auto relativePaths = std::vector<QString>{tempPaths.begin(), tempPaths.end()};
     qCDebug(KLEOPATRA_LOG) << "relative paths:" << relativePaths;
 
     if (encrypt || symmetric) {
         Context::EncryptionFlags flags = Context::AlwaysTrust;
         if (symmetric) {
             flags = static_cast<Context::EncryptionFlags>(flags | Context::Symmetric);
             qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
         }
         if (sign) {
             std::unique_ptr<QGpgME::SignEncryptArchiveJob> job = createSignEncryptArchiveJob(proto);
             kleo_assert(job.get());
             job->setBaseDirectory(baseDirectory);
 
             job->start(signers, recipients, relativePaths, output->ioDevice(), flags);
 
             this->job = job.release();
         } else {
             std::unique_ptr<QGpgME::EncryptArchiveJob> job = createEncryptArchiveJob(proto);
             kleo_assert(job.get());
             job->setBaseDirectory(baseDirectory);
 
             job->start(recipients, relativePaths, output->ioDevice(), flags);
 
             this->job = job.release();
         }
     } else if (sign) {
         std::unique_ptr<QGpgME::SignArchiveJob> job = createSignArchiveJob(proto);
         kleo_assert(job.get());
         job->setBaseDirectory(baseDirectory);
 
         job->start(signers, relativePaths, output->ioDevice());
 
         this->job = job.release();
     } else {
         kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
     }
 }
 
 std::unique_ptr<QGpgME::SignArchiveJob> SignEncryptTask::Private::createSignArchiveJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignArchiveJob> signJob(backend->signArchiveJob(q->asciiArmor()));
     auto job = signJob.get();
     kleo_assert(job);
     connect(job, &QGpgME::SignArchiveJob::dataProgress, q, &SignEncryptTask::setProgress);
     connect(job, &QGpgME::SignArchiveJob::result, q, [this, job](const GpgME::SigningResult &signResult) {
         slotResult(job, signResult, EncryptionResult{});
     });
     return signJob;
 }
 
 std::unique_ptr<QGpgME::SignEncryptArchiveJob> SignEncryptTask::Private::createSignEncryptArchiveJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignEncryptArchiveJob> signEncryptJob(backend->signEncryptArchiveJob(q->asciiArmor()));
     auto job = signEncryptJob.get();
     kleo_assert(job);
     connect(job, &QGpgME::SignEncryptArchiveJob::dataProgress, q, &SignEncryptTask::setProgress);
     connect(job, &QGpgME::SignEncryptArchiveJob::result, q, [this, job](const GpgME::SigningResult &signResult, const GpgME::EncryptionResult &encryptResult) {
         slotResult(job, signResult, encryptResult);
     });
     return signEncryptJob;
 }
 
 std::unique_ptr<QGpgME::EncryptArchiveJob> SignEncryptTask::Private::createEncryptArchiveJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::EncryptArchiveJob> encryptJob(backend->encryptArchiveJob(q->asciiArmor()));
     auto job = encryptJob.get();
     kleo_assert(job);
     connect(job, &QGpgME::EncryptArchiveJob::dataProgress, q, &SignEncryptTask::setProgress);
     connect(job, &QGpgME::EncryptArchiveJob::result, q, [this, job](const GpgME::EncryptionResult &encryptResult) {
         slotResult(job, SigningResult{}, encryptResult);
     });
     return encryptJob;
 }
 #endif
 
 void SignEncryptTask::Private::slotResult(const SigningResult &result)
 {
     slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), result, EncryptionResult{});
 }
 
 void SignEncryptTask::Private::slotResult(const SigningResult &sresult, const EncryptionResult &eresult)
 {
     slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), sresult, eresult);
 }
 
 void SignEncryptTask::Private::slotResult(const EncryptionResult &result)
 {
     slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), SigningResult{}, result);
 }
 
 void SignEncryptTask::Private::slotResult(const QGpgME::Job *job, const SigningResult &sresult, const EncryptionResult &eresult)
 {
     const AuditLogEntry auditLog = AuditLogEntry::fromJob(job);
     bool outputCreated = false;
     if (input && input->failed()) {
         output->cancel();
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape( input->errorString())),
                                       auditLog));
         return;
     } else if (sresult.error().code() || eresult.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!sresult.isNull() || !eresult.isNull());
             output->finalize();
             outputCreated = true;
             if (input) {
                 input->finalize();
             }
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
 
     const LabelAndError inputInfo{q->label(), input ? input->errorString() : QString{}};
     const LabelAndError outputInfo{output->label(), output->errorString()};
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(sresult, eresult, inputInfo, outputInfo, outputCreated, auditLog)));
 }
 
 QString SignEncryptFilesResult::overview() const
 {
     const QString files = formatInputOutputLabel(m_input.label, m_output.label, !m_outputCreated);
     return files + QLatin1String(": ") + makeOverview(makeResultOverview(m_sresult, m_eresult));
 }
 
 QString SignEncryptFilesResult::details() const
 {
     return errorString();
 }
 
 GpgME::Error SignEncryptFilesResult::error() const
 {
     if (m_sresult.error().code()) {
         return m_sresult.error();
     }
     if (m_eresult.error().code()) {
         return m_eresult.error();
     }
     return {};
 }
 
 QString SignEncryptFilesResult::errorString() const
 {
     const bool sign = !m_sresult.isNull();
     const bool encrypt = !m_eresult.isNull();
 
     kleo_assert(sign || encrypt);
 
     if (sign && encrypt) {
         return
             m_sresult.error().code() ? makeResultDetails(m_sresult, m_input.errorString, m_output.errorString) :
             m_eresult.error().code() ? makeResultDetails(m_eresult, m_input.errorString, m_output.errorString) :
             QString();
     }
 
     return
         sign   ? makeResultDetails(m_sresult, m_input.errorString, m_output.errorString) :
         /*else*/ makeResultDetails(m_eresult, m_input.errorString, m_output.errorString);
 }
 
 Task::Result::VisualCode SignEncryptFilesResult::code() const
 {
     if (m_sresult.error().isCanceled() || m_eresult.error().isCanceled()) {
         return Warning;
     }
     return (m_sresult.error().code() || m_eresult.error().code()) ? NeutralError : NeutralSuccess;
 }
 
 AuditLogEntry SignEncryptFilesResult::auditLog() const
 {
     return m_auditLog;
 }
 
 #include "moc_signencrypttask.cpp"
diff --git a/src/view/keylistcontroller.cpp b/src/view/keylistcontroller.cpp
index ea85a4828..28adbf571 100644
--- a/src/view/keylistcontroller.cpp
+++ b/src/view/keylistcontroller.cpp
@@ -1,865 +1,861 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     controllers/keylistcontroller.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2022 Felix Tiede
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "keylistcontroller.h"
 #include "tabwidget.h"
 
 #include <smartcard/readerstatus.h>
 
 #include <utils/action_data.h>
 
 #include <settings.h>
 #include "tooltippreferences.h"
 #include "kleopatra_debug.h"
 #include "commands/exportcertificatecommand.h"
 #include "commands/exportopenpgpcertstoservercommand.h"
 #ifdef MAILAKONADI_ENABLED
 #include "commands/exportopenpgpcerttoprovidercommand.h"
 #endif // MAILAKONADI_ENABLED
 #if QGPGME_SUPPORTS_SECRET_KEY_EXPORT
 # include "commands/exportsecretkeycommand.h"
 #else
 # include "commands/exportsecretkeycommand_old.h"
 #endif
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/changepassphrasecommand.h"
 #include "commands/lookupcertificatescommand.h"
 #include "commands/reloadkeyscommand.h"
 #include "commands/refreshx509certscommand.h"
 #include "commands/refreshopenpgpcertscommand.h"
 #include "commands/detailscommand.h"
 #include "commands/deletecertificatescommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/signencryptfilescommand.h"
 #include "commands/signencryptfoldercommand.h"
 #include "commands/clearcrlcachecommand.h"
 #include "commands/dumpcrlcachecommand.h"
 #include "commands/dumpcertificatecommand.h"
 #include "commands/importcrlcommand.h"
 #include "commands/changeexpirycommand.h"
 #include "commands/changeownertrustcommand.h"
 #include "commands/changeroottrustcommand.h"
 #include "commands/certifycertificatecommand.h"
 #include "commands/revokecertificationcommand.h"
 #include "commands/adduseridcommand.h"
 #include "commands/newcertificatesigningrequestcommand.h"
 #include "commands/newopenpgpcertificatecommand.h"
 #include "commands/checksumverifyfilescommand.h"
 #include "commands/checksumcreatefilescommand.h"
 #include "commands/exportpaperkeycommand.h"
 #include "commands/revokekeycommand.h"
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/Formatting>
 
 #include <gpgme++/key.h>
 
 #include <KActionCollection>
 #include <KLocalizedString>
 
 #include <QAbstractItemView>
 #include <QPointer>
 #include <QItemSelectionModel>
 #include <QAction>
 
 #include <algorithm>
 #include <iterator>
 
 // needed for GPGME_VERSION_NUMBER
 #include <gpgme.h>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::SmartCard;
 using namespace GpgME;
 #if !QGPGME_SUPPORTS_SECRET_KEY_EXPORT
 using Kleo::Commands::Compat::ExportSecretKeyCommand;
 #endif
 
 class KeyListController::Private
 {
     friend class ::Kleo::KeyListController;
     KeyListController *const q;
 public:
     explicit Private(KeyListController *qq);
     ~Private();
 
     void connectView(QAbstractItemView *view);
     void connectCommand(Command *cmd);
 
     void connectTabWidget();
     void disconnectTabWidget();
 
     void addCommand(Command *cmd)
     {
         connectCommand(cmd);
         commands.insert(std::lower_bound(commands.begin(), commands.end(), cmd), cmd);
     }
     void addView(QAbstractItemView *view)
     {
         connectView(view);
         views.insert(std::lower_bound(views.begin(), views.end(), view), view);
     }
     void removeView(QAbstractItemView *view)
     {
         view->disconnect(q);
         view->selectionModel()->disconnect(q);
         views.erase(std::remove(views.begin(), views.end(), view), views.end());
     }
 
 public:
     void slotDestroyed(QObject *o)
     {
         qCDebug(KLEOPATRA_LOG) << (void *)o;
         views.erase(std::remove(views.begin(), views.end(), o), views.end());
         commands.erase(std::remove(commands.begin(), commands.end(), o), commands.end());
     }
     void slotDoubleClicked(const QModelIndex &idx);
     void slotActivated(const QModelIndex &idx);
     void slotSelectionChanged(const QItemSelection &old, const QItemSelection &new_);
     void slotContextMenu(const QPoint &pos);
     void slotCommandFinished();
     void slotAddKey(const Key &key);
     void slotAboutToRemoveKey(const Key &key);
-    void slotProgress(int current, int total)
-    {
-        Q_EMIT q->progress(current, total);
-    }
     void slotActionTriggered(QAction *action);
     void slotCurrentViewChanged(QAbstractItemView *view)
     {
         if (view && !std::binary_search(views.cbegin(), views.cend(), view)) {
             qCDebug(KLEOPATRA_LOG) << "you need to register view" << view << "before trying to set it as the current view!";
             addView(view);
         }
         currentView = view;
         q->enableDisableActions(view ? view->selectionModel() : nullptr);
     }
 
 private:
     int toolTipOptions() const;
 
 private:
     static Command::Restrictions calculateRestrictionsMask(const QItemSelectionModel *sm);
 
 private:
     struct action_item {
         QPointer<QAction> action;
         Command::Restrictions restrictions;
         Command *(*createCommand)(QAbstractItemView *, KeyListController *);
     };
     std::vector<action_item> actions;
     std::vector<QAbstractItemView *> views;
     std::vector<Command *> commands;
     QPointer<QWidget> parentWidget;
     QPointer<TabWidget> tabWidget;
     QPointer<QAbstractItemView> currentView;
     QPointer<AbstractKeyListModel> flatModel, hierarchicalModel;
     std::vector<QMetaObject::Connection> m_connections;
 };
 
 KeyListController::Private::Private(KeyListController *qq)
     : q(qq),
       actions(),
       views(),
       commands(),
       parentWidget(),
       tabWidget(),
       flatModel(),
       hierarchicalModel()
 {
     connect(KeyCache::instance().get(), &KeyCache::added, q, [this](const GpgME::Key &key) { slotAddKey(key); });
     connect(KeyCache::instance().get(), &KeyCache::aboutToRemove, q, [this](const GpgME::Key &key) { slotAboutToRemoveKey(key); });
 }
 
 KeyListController::Private::~Private() {}
 
 KeyListController::KeyListController(QObject *p)
     : QObject(p), d(new Private(this))
 {
 
 }
 
 KeyListController::~KeyListController() {}
 
 void KeyListController::Private::slotAddKey(const Key &key)
 {
     // ### make model act on keycache directly...
     if (flatModel) {
         flatModel->addKey(key);
     }
     if (hierarchicalModel) {
         hierarchicalModel->addKey(key);
     }
 }
 
 void KeyListController::Private::slotAboutToRemoveKey(const Key &key)
 {
     // ### make model act on keycache directly...
     if (flatModel) {
         flatModel->removeKey(key);
     }
     if (hierarchicalModel) {
         hierarchicalModel->removeKey(key);
     }
 }
 
 void KeyListController::addView(QAbstractItemView *view)
 {
     if (!view || std::binary_search(d->views.cbegin(), d->views.cend(), view)) {
         return;
     }
     d->addView(view);
 }
 
 void KeyListController::removeView(QAbstractItemView *view)
 {
     if (!view || !std::binary_search(d->views.cbegin(), d->views.cend(), view)) {
         return;
     }
     d->removeView(view);
 }
 
 void KeyListController::setCurrentView(QAbstractItemView *view)
 {
     d->slotCurrentViewChanged(view);
 }
 
 std::vector<QAbstractItemView *> KeyListController::views() const
 {
     return d->views;
 }
 
 void KeyListController::setFlatModel(AbstractKeyListModel *model)
 {
     if (model == d->flatModel) {
         return;
     }
 
     d->flatModel = model;
 
     if (model) {
         model->clear();
         if (KeyCache::instance()->initialized()) {
             model->addKeys(KeyCache::instance()->keys());
         }
         model->setToolTipOptions(d->toolTipOptions());
     }
 }
 
 void KeyListController::setHierarchicalModel(AbstractKeyListModel *model)
 {
     if (model == d->hierarchicalModel) {
         return;
     }
 
     d->hierarchicalModel = model;
 
     if (model) {
         model->clear();
         if (KeyCache::instance()->initialized()) {
             model->addKeys(KeyCache::instance()->keys());
         }
         model->setToolTipOptions(d->toolTipOptions());
     }
 }
 
 void KeyListController::setTabWidget(TabWidget *tabWidget)
 {
     if (tabWidget == d->tabWidget) {
         return;
     }
 
     d->disconnectTabWidget();
 
     d->tabWidget = tabWidget;
 
     d->connectTabWidget();
 
     d->slotCurrentViewChanged(tabWidget ? tabWidget->currentView() : nullptr);
 }
 
 void KeyListController::setParentWidget(QWidget *parent)
 {
     d->parentWidget = parent;
 }
 
 QWidget *KeyListController::parentWidget() const
 {
     return d->parentWidget;
 }
 
 void KeyListController::Private::connectTabWidget()
 {
     if (!tabWidget) {
         return;
     }
     const auto views = tabWidget->views();
     std::for_each(views.cbegin(), views.cend(),
                   [this](QAbstractItemView *view) { addView(view); });
 
     m_connections.reserve(3);
     m_connections.push_back(connect(tabWidget, &TabWidget::viewAdded, q, &KeyListController::addView));
     m_connections.push_back(connect(tabWidget, &TabWidget::viewAboutToBeRemoved, q, &KeyListController::removeView));
     m_connections.push_back(connect(tabWidget, &TabWidget::currentViewChanged, q, [this](QAbstractItemView *view) { slotCurrentViewChanged(view); }));
 }
 
 void KeyListController::Private::disconnectTabWidget()
 {
     if (!tabWidget) {
         return;
     }
     for (const auto &connection : m_connections) {
         disconnect(connection);
     }
     m_connections.clear();
 
     const auto views = tabWidget->views();
     std::for_each(views.cbegin(), views.cend(),
                   [this](QAbstractItemView *view) { removeView(view); });
 }
 
 AbstractKeyListModel *KeyListController::flatModel() const
 {
     return d->flatModel;
 }
 
 AbstractKeyListModel *KeyListController::hierarchicalModel() const
 {
     return d->hierarchicalModel;
 }
 
 QAbstractItemView *KeyListController::currentView() const
 {
     return d->currentView;
 }
 
 TabWidget *KeyListController::tabWidget() const
 {
     return d->tabWidget;
 }
 
 void KeyListController::createActions(KActionCollection *coll)
 {
     const std::vector<action_data> common_and_openpgp_action_data = {
         // File menu
         {
             "file_new_certificate", i18n("New OpenPGP Key Pair..."), i18n("Create a new OpenPGP certificate"),
             "view-certificate-add", nullptr, nullptr, QStringLiteral("Ctrl+N")
         },
         {
             "file_export_certificates", i18n("Export..."), i18n("Export the selected certificate (public key) to a file"),
             "view-certificate-export", nullptr, nullptr, QStringLiteral("Ctrl+E")
         },
         {
             "file_export_certificates_to_server", i18n("Publish on Server..."), i18n("Publish the selected certificate (public key) on a public keyserver"),
             "view-certificate-export-server", nullptr, nullptr, QStringLiteral("Ctrl+Shift+E")
         },
 #ifdef MAILAKONADI_ENABLED
         {
             "file_export_certificate_to_provider", i18n("Publish at Mail Provider..."), i18n("Publish the selected certificate (public key) at mail provider's Web Key Directory if offered"),
             "view-certificate-export", nullptr, nullptr, QString()
         },
 #endif // MAILAKONADI_ENABLED
         {
             "file_export_secret_keys", i18n("Backup Secret Keys..."), QString(),
             "view-certificate-export-secret", nullptr, nullptr, QString()
         },
         {
             "file_export_paper_key", i18n("Print Secret Key..."), QString(),
             "document-print", nullptr, nullptr, QString()
         },
         {
             "file_lookup_certificates", i18n("Lookup on Server..."), i18n("Search for certificates online using a public keyserver"),
             "edit-find", nullptr, nullptr, QStringLiteral("Shift+Ctrl+I")
         },
         {
             "file_import_certificates", i18n("Import..."), i18n("Import a certificate from a file"),
             "view-certificate-import", nullptr, nullptr, QStringLiteral("Ctrl+I")
         },
         {
             "file_decrypt_verify_files", i18n("Decrypt/Verify..."), i18n("Decrypt and/or verify files"),
             "document-edit-decrypt-verify", nullptr, nullptr, QString()
         },
         {
             "file_sign_encrypt_files", i18n("Sign/Encrypt..."), i18n("Encrypt and/or sign files"),
             "document-edit-sign-encrypt", nullptr, nullptr, QString()
         },
         {
             "file_sign_encrypt_folder", i18n("Sign/Encrypt Folder..."), i18n("Encrypt and/or sign folders"),
             nullptr/*"folder-edit-sign-encrypt"*/, nullptr, nullptr, QString()
         },
         {
             "file_checksum_create_files", i18n("Create Checksum Files..."), QString(),
             nullptr/*"document-checksum-create"*/, nullptr, nullptr, QString()
         },
         {
             "file_checksum_verify_files", i18n("Verify Checksum Files..."), QString(),
             nullptr/*"document-checksum-verify"*/, nullptr, nullptr, QString()
         },
         // View menu
         {
             "view_redisplay", i18n("Redisplay"), QString(),
             "view-refresh", nullptr, nullptr, QStringLiteral("F5")
         },
         {
             "view_stop_operations", i18n("Stop Operation"), QString(),
             "process-stop", this, [this](bool) { cancelCommands(); }, QStringLiteral("Escape"), RegularQAction, Disabled
         },
         {
             "view_certificate_details", i18n("Details"), QString(),
             "dialog-information", nullptr, nullptr, QString()
         },
         // Certificate menu
 #if QGPGME_SUPPORTS_KEY_REVOCATION
         {
             "certificates_revoke", i18n("Revoke Certificate..."), i18n("Revoke the selected OpenPGP certificate"),
             "view-certificate-revoke", nullptr, nullptr, {}
         },
 #endif
         {
             "certificates_delete", i18n("Delete"), i18n("Delete selected certificates"),
             "edit-delete", nullptr, nullptr, QStringLiteral("Delete")
         },
         {
             "certificates_certify_certificate", i18n("Certify..."), i18n("Certify the validity of the selected certificate"),
             "view-certificate-sign", nullptr, nullptr, QString()
         },
         {
             "certificates_revoke_certification", i18n("Revoke Certification..."), i18n("Revoke the certification of the selected certificate"),
             "view-certificate-revoke", nullptr, nullptr, QString()
         },
         {
             "certificates_change_expiry", i18n("Change End of Validity Period..."), QString(),
             nullptr, nullptr, nullptr, QString()
         },
         {
             "certificates_change_owner_trust", i18nc("@action:inmenu", "Change Certification Power..."),
             i18nc("@info:tooltip", "Grant or revoke the certification power of the selected certificate"),
             nullptr, nullptr, nullptr, QString()
         },
         {
             "certificates_change_passphrase", i18n("Change Passphrase..."), QString(),
             nullptr, nullptr, nullptr, QString()
         },
         {
             "certificates_add_userid", i18n("Add User ID..."), QString(),
             nullptr, nullptr, nullptr, QString()
         },
         // Tools menu
         {
             "tools_refresh_openpgp_certificates", i18n("Refresh OpenPGP Certificates"), QString(),
             "view-refresh", nullptr, nullptr, QString()
         },
         // Window menu
         // (come from TabWidget)
         // Help menu
         // (come from MainWindow)
     };
 
     static const action_data cms_create_csr_action_data = {
         "file_new_certificate_signing_request", i18n("New S/MIME Certification Request..."), i18n("Create a new S/MIME certificate signing request (CSR)"),
         "view-certificate-add", nullptr, nullptr, {},
     };
 
     static const std::vector<action_data> cms_action_data = {
         // Certificate menu
         {
             "certificates_trust_root", i18n("Trust Root Certificate"), QString(),
             nullptr, nullptr, nullptr, QString()
         },
         {
             "certificates_distrust_root", i18n("Distrust Root Certificate"), QString(),
             nullptr, nullptr, nullptr, QString()
         },
         {
             "certificates_dump_certificate", i18n("Technical Details"), QString(),
             nullptr, nullptr, nullptr, QString()
         },
         // Tools menu
         {
             "tools_refresh_x509_certificates", i18n("Refresh S/MIME Certificates"), QString(),
             "view-refresh", nullptr, nullptr, QString()
         },
         {
             "crl_clear_crl_cache", i18n("Clear CRL Cache"), QString(),
             nullptr, nullptr, nullptr, QString()
         },
         {
             "crl_dump_crl_cache", i18n("Dump CRL Cache"), QString(),
             nullptr, nullptr, nullptr, QString()
         },
         {
             "crl_import_crl", i18n("Import CRL From File..."), QString(),
             nullptr, nullptr, nullptr, QString()
         },
     };
 
     std::vector<action_data> action_data = common_and_openpgp_action_data;
 
     if (const Kleo::Settings settings{}; settings.cmsEnabled()) {
         if (settings.cmsCertificateCreationAllowed()) {
             action_data.push_back(cms_create_csr_action_data);
         }
         action_data.reserve(action_data.size() + cms_action_data.size());
         std::copy(std::begin(cms_action_data), std::end(cms_action_data),
                   std::back_inserter(action_data));
     }
 
     make_actions_from_data(action_data, coll);
 
     if (QAction *action = coll->action(QStringLiteral("view_stop_operations"))) {
         connect(this, &KeyListController::commandsExecuting, action, &QAction::setEnabled);
     }
 
     // ### somehow make this better...
     registerActionForCommand<NewOpenPGPCertificateCommand>(coll->action(QStringLiteral("file_new_certificate")));
     registerActionForCommand<NewCertificateSigningRequestCommand>(coll->action(QStringLiteral("file_new_certificate_signing_request")));
     //---
     registerActionForCommand<LookupCertificatesCommand>(coll->action(QStringLiteral("file_lookup_certificates")));
     registerActionForCommand<ImportCertificateFromFileCommand>(coll->action(QStringLiteral("file_import_certificates")));
     //---
     registerActionForCommand<ExportCertificateCommand>(coll->action(QStringLiteral("file_export_certificates")));
     registerActionForCommand<ExportSecretKeyCommand>(coll->action(QStringLiteral("file_export_secret_keys")));
     registerActionForCommand<ExportPaperKeyCommand>(coll->action(QStringLiteral("file_export_paper_key")));
     registerActionForCommand<ExportOpenPGPCertsToServerCommand>(coll->action(QStringLiteral("file_export_certificates_to_server")));
 #ifdef MAILAKONADI_ENABLED
     registerActionForCommand<ExportOpenPGPCertToProviderCommand>(coll->action(QStringLiteral("file_export_certificate_to_provider")));
 #endif // MAILAKONADI_ENABLED
     //---
     registerActionForCommand<DecryptVerifyFilesCommand>(coll->action(QStringLiteral("file_decrypt_verify_files")));
     registerActionForCommand<SignEncryptFilesCommand>(coll->action(QStringLiteral("file_sign_encrypt_files")));
     registerActionForCommand<SignEncryptFolderCommand>(coll->action(QStringLiteral("file_sign_encrypt_folder")));
     //---
     registerActionForCommand<ChecksumCreateFilesCommand>(coll->action(QStringLiteral("file_checksum_create_files")));
     registerActionForCommand<ChecksumVerifyFilesCommand>(coll->action(QStringLiteral("file_checksum_verify_files")));
 
     registerActionForCommand<ReloadKeysCommand>(coll->action(QStringLiteral("view_redisplay")));
     //coll->action( "view_stop_operations" ) <-- already dealt with in make_actions_from_data()
     registerActionForCommand<DetailsCommand>(coll->action(QStringLiteral("view_certificate_details")));
 
     registerActionForCommand<ChangeOwnerTrustCommand>(coll->action(QStringLiteral("certificates_change_owner_trust")));
     registerActionForCommand<TrustRootCommand>(coll->action(QStringLiteral("certificates_trust_root")));
     registerActionForCommand<DistrustRootCommand>(coll->action(QStringLiteral("certificates_distrust_root")));
     //---
     registerActionForCommand<CertifyCertificateCommand>(coll->action(QStringLiteral("certificates_certify_certificate")));
     if (RevokeCertificationCommand::isSupported()) {
         registerActionForCommand<RevokeCertificationCommand>(coll->action(QStringLiteral("certificates_revoke_certification")));
     }
     //---
     registerActionForCommand<ChangeExpiryCommand>(coll->action(QStringLiteral("certificates_change_expiry")));
     registerActionForCommand<ChangePassphraseCommand>(coll->action(QStringLiteral("certificates_change_passphrase")));
     registerActionForCommand<AddUserIDCommand>(coll->action(QStringLiteral("certificates_add_userid")));
     //---
 #if QGPGME_SUPPORTS_KEY_REVOCATION
     registerActionForCommand<RevokeKeyCommand>(coll->action(QStringLiteral("certificates_revoke")));
 #endif
     registerActionForCommand<DeleteCertificatesCommand>(coll->action(QStringLiteral("certificates_delete")));
     //---
     registerActionForCommand<DumpCertificateCommand>(coll->action(QStringLiteral("certificates_dump_certificate")));
 
     registerActionForCommand<RefreshX509CertsCommand>(coll->action(QStringLiteral("tools_refresh_x509_certificates")));
     registerActionForCommand<RefreshOpenPGPCertsCommand>(coll->action(QStringLiteral("tools_refresh_openpgp_certificates")));
     //---
     registerActionForCommand<ImportCrlCommand>(coll->action(QStringLiteral("crl_import_crl")));
     //---
     registerActionForCommand<ClearCrlCacheCommand>(coll->action(QStringLiteral("crl_clear_crl_cache")));
     registerActionForCommand<DumpCrlCacheCommand>(coll->action(QStringLiteral("crl_dump_crl_cache")));
 
     enableDisableActions(nullptr);
 }
 
 void KeyListController::registerAction(QAction *action, Command::Restrictions restrictions, Command * (*create)(QAbstractItemView *, KeyListController *))
 {
     if (!action) {
         return;
     }
     Q_ASSERT(!action->isCheckable());   // can be added later, for now, disallow
 
     const Private::action_item ai = {
         action, restrictions, create
     };
     connect(action, &QAction::triggered, this, [this, action]() { d->slotActionTriggered(action); });
     d->actions.push_back(ai);
 }
 
 void KeyListController::registerCommand(Command *cmd)
 {
     if (!cmd || std::binary_search(d->commands.cbegin(), d->commands.cend(), cmd)) {
         return;
     }
     d->addCommand(cmd);
     qCDebug(KLEOPATRA_LOG) << (void *)cmd;
     if (d->commands.size() == 1) {
         Q_EMIT commandsExecuting(true);
     }
 }
 
 bool KeyListController::hasRunningCommands() const
 {
     return !d->commands.empty();
 }
 
 bool KeyListController::shutdownWarningRequired() const
 {
     return std::any_of(d->commands.cbegin(), d->commands.cend(), std::mem_fn(&Command::warnWhenRunningAtShutdown));
 }
 
 // slot
 void KeyListController::cancelCommands()
 {
     std::for_each(d->commands.begin(), d->commands.end(), std::mem_fn(&Command::cancel));
 }
 
 void KeyListController::Private::connectView(QAbstractItemView *view)
 {
 
     connect(view, &QObject::destroyed, q, [this](QObject *obj) { slotDestroyed(obj); });
     connect(view, &QAbstractItemView::doubleClicked, q, [this](const QModelIndex &index) { slotDoubleClicked(index); });
     connect(view, &QAbstractItemView::activated, q, [this](const QModelIndex &index) { slotActivated(index); });
     connect(view->selectionModel(), &QItemSelectionModel::selectionChanged,
             q, [this](const QItemSelection &oldSel, const QItemSelection &newSel) {
         slotSelectionChanged(oldSel, newSel);
     });
 
     view->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(view, &QWidget::customContextMenuRequested, q, [this](const QPoint &pos) { slotContextMenu(pos); });
 }
 
 void KeyListController::Private::connectCommand(Command *cmd)
 {
     if (!cmd) {
         return;
     }
     connect(cmd, &QObject::destroyed, q, [this](QObject *obj) { slotDestroyed(obj); });
     connect(cmd, &Command::finished, q, [this] { slotCommandFinished(); });
     //connect( cmd, SIGNAL(canceled()), q, SLOT(slotCommandCanceled()) );
-    connect(cmd, &Command::progress, q, [this](const QString &, int current, int total) { slotProgress(current, total); });
+    connect(cmd, &Command::progress, q, &KeyListController::progress);
 }
 
 void KeyListController::Private::slotDoubleClicked(const QModelIndex &idx)
 {
     QAbstractItemView *const view = qobject_cast<QAbstractItemView *>(q->sender());
     if (!view || !std::binary_search(views.cbegin(), views.cend(), view)) {
         return;
     }
 
     if (const auto *const keyListModel = dynamic_cast<KeyListModelInterface *>(view->model())) {
         DetailsCommand *const c = new DetailsCommand{keyListModel->key(idx)};
         c->setParentWidget(parentWidget ? parentWidget : view);
         c->start();
     }
 }
 
 void KeyListController::Private::slotActivated(const QModelIndex &idx)
 {
     Q_UNUSED(idx)
     QAbstractItemView *const view = qobject_cast<QAbstractItemView *>(q->sender());
     if (!view || !std::binary_search(views.cbegin(), views.cend(), view)) {
         return;
     }
 
 }
 
 void KeyListController::Private::slotSelectionChanged(const QItemSelection &old, const QItemSelection &new_)
 {
     Q_UNUSED(old)
     Q_UNUSED(new_)
 
     const QItemSelectionModel *const sm = qobject_cast<QItemSelectionModel *>(q->sender());
     if (!sm) {
         return;
     }
     q->enableDisableActions(sm);
 }
 
 void KeyListController::Private::slotContextMenu(const QPoint &p)
 {
     QAbstractItemView *const view = qobject_cast<QAbstractItemView *>(q->sender());
     if (view && std::binary_search(views.cbegin(), views.cend(), view)) {
         Q_EMIT q->contextMenuRequested(view, view->viewport()->mapToGlobal(p));
     } else {
         qCDebug(KLEOPATRA_LOG) << "sender is not a QAbstractItemView*!";
     }
 }
 
 void KeyListController::Private::slotCommandFinished()
 {
     Command *const cmd = qobject_cast<Command *>(q->sender());
     if (!cmd || !std::binary_search(commands.cbegin(), commands.cend(), cmd)) {
         return;
     }
     qCDebug(KLEOPATRA_LOG) << (void *)cmd;
     if (commands.size() == 1) {
         Q_EMIT q->commandsExecuting(false);
     }
 }
 
 void KeyListController::enableDisableActions(const QItemSelectionModel *sm) const
 {
     const Command::Restrictions restrictionsMask = d->calculateRestrictionsMask(sm);
     for (const Private::action_item &ai : std::as_const(d->actions))
         if (ai.action) {
             ai.action->setEnabled(ai.restrictions == (ai.restrictions & restrictionsMask));
         }
 }
 
 static bool all_secret_are_not_owner_trust_ultimate(const std::vector<Key> &keys)
 {
     for (const Key &key : keys)
         if (key.hasSecret() && key.ownerTrust() == Key::Ultimate) {
             return false;
         }
     return true;
 }
 
 Command::Restrictions find_root_restrictions(const std::vector<Key> &keys)
 {
     bool trusted = false, untrusted = false;
     for (const Key &key : keys)
         if (key.isRoot())
             if (key.userID(0).validity() == UserID::Ultimate) {
                 trusted = true;
             } else {
                 untrusted = true;
             }
         else {
             return Command::NoRestriction;
         }
     if (trusted)
         if (untrusted) {
             return Command::NoRestriction;
         } else {
             return Command::MustBeTrustedRoot;
         }
     else if (untrusted) {
         return Command::MustBeUntrustedRoot;
     } else {
         return Command::NoRestriction;
     }
 }
 
 Command::Restrictions KeyListController::Private::calculateRestrictionsMask(const QItemSelectionModel *sm)
 {
     if (!sm) {
         return Command::NoRestriction;
     }
 
     const KeyListModelInterface *const m = dynamic_cast<const KeyListModelInterface *>(sm->model());
     if (!m) {
         return Command::NoRestriction;
     }
 
     const std::vector<Key> keys = m->keys(sm->selectedRows());
     if (keys.empty()) {
         return Command::NoRestriction;
     }
 
     Command::Restrictions result = Command::NeedSelection;
 
     if (keys.size() == 1) {
         result |= Command::OnlyOneKey;
     }
 
 #if GPGME_VERSION_NUMBER >= 0x011102 // 1.17.2
     // we need to check the primary subkey because Key::hasSecret() is also true if just the secret key stub of an offline key is available
     const auto primaryKeyCanBeUsedForSecretKeyOperations = [](const auto &k) { return k.subkey(0).isSecret(); };
 #else
     // older versions of GpgME did not always set the secret flag for card keys
     const auto primaryKeyCanBeUsedForSecretKeyOperations = [](const auto &k) { return k.subkey(0).isSecret() || k.subkey(0).isCardKey(); };
 #endif
     if (std::all_of(keys.cbegin(), keys.cend(), primaryKeyCanBeUsedForSecretKeyOperations)) {
         result |= Command::NeedSecretKey;
     }
 
     if (std::all_of(std::begin(keys), std::end(keys), [](const auto &k) { return k.subkey(0).isSecret() && !k.subkey(0).isCardKey(); })) {
         result |= Command::NeedSecretKeyData;
     }
 
     if (std::all_of(keys.cbegin(), keys.cend(), [](const Key &key) { return key.protocol() == OpenPGP; })) {
         result |= Command::MustBeOpenPGP;
     } else if (std::all_of(keys.cbegin(), keys.cend(), [](const Key &key) { return key.protocol() == CMS; })) {
         result |= Command::MustBeCMS;
     }
 
     if (Kleo::all_of(keys, [](const auto &key) {
         return !key.isBad();
     })) {
         result |= Command::MustBeValid;
     }
 
     if (all_secret_are_not_owner_trust_ultimate(keys)) {
         result |= Command::MayOnlyBeSecretKeyIfOwnerTrustIsNotYetUltimate;
     }
 
     result |= find_root_restrictions(keys);
 
     if (const ReaderStatus *rs = ReaderStatus::instance()) {
         if (!rs->firstCardWithNullPin().empty()) {
             result |= Command::AnyCardHasNullPin;
         }
         if (rs->anyCardCanLearnKeys()) {
             result |= Command::AnyCardCanLearnKeys;
         }
     }
 
     return result;
 }
 
 void KeyListController::Private::slotActionTriggered(QAction *sender)
 {
     const auto it = std::find_if(actions.cbegin(), actions.cend(),
                                  [sender](const action_item &item) { return item.action == sender; });
     if (it != actions.end())
         if (Command *const c = it->createCommand(this->currentView, q)) {
             if (parentWidget) {
                 c->setParentWidget(parentWidget);
             }
             c->start();
         } else
             qCDebug(KLEOPATRA_LOG) << "createCommand() == NULL for action(?) \""
                                     << qPrintable(sender->objectName()) << "\"";
     else {
         qCDebug(KLEOPATRA_LOG) << "I don't know anything about action(?) \"%s\"", qPrintable(sender->objectName());
     }
 }
 
 int KeyListController::Private::toolTipOptions() const
 {
     using namespace Kleo::Formatting;
     static const int validityFlags = Validity | Issuer | ExpiryDates | CertificateUsage;
     static const int ownerFlags = Subject | UserIDs | OwnerTrust;
     static const int detailsFlags = StorageLocation | CertificateType | SerialNumber | Fingerprint;
 
     const TooltipPreferences prefs;
 
     int flags = KeyID;
     flags |= prefs.showValidity() ? validityFlags : 0;
     flags |= prefs.showOwnerInformation() ? ownerFlags : 0;
     flags |= prefs.showCertificateDetails() ? detailsFlags : 0;
     return flags;
 }
 
 void KeyListController::updateConfig()
 {
     const int opts = d->toolTipOptions();
     if (d->flatModel) {
         d->flatModel->setToolTipOptions(opts);
     }
     if (d->hierarchicalModel) {
         d->hierarchicalModel->setToolTipOptions(opts);
     }
 }
 
 #include "moc_keylistcontroller.cpp"