diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9f7761ed2..25363866e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,222 +1,222 @@
 # SPDX-FileCopyrightText: none
 # SPDX-License-Identifier: BSD-3-Clause
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 set(RELEASE_SERVICE_VERSION_MAJOR "22")
 set(RELEASE_SERVICE_VERSION_MINOR "07")
 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 "22")
 
 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")
 
 project(kleopatra VERSION ${kleopatra_version})
 
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF5_MIN_VERSION "5.94.0")
 set(KIDENTITYMANAGEMENT_VERSION "5.20.40")
 set(KMAILTRANSPORT_VERSION "5.20.40")
 set(KMIME_VERSION "5.20.40")
-set(LIBKLEO_VERSION "5.20.44")
+set(LIBKLEO_VERSION "5.20.45")
 set(QT_REQUIRED_VERSION "5.15.2")
 set(GPGME_REQUIRED_VERSION "1.16.0")
 
 if (WIN32)
   set(KF5_WANT_VERSION "5.70.0")
   set(KMIME_WANT_VERSION "5.12.0")
 else ()
   set(KF5_WANT_VERSION ${KF5_MIN_VERSION})
   set(KMIME_WANT_VERSION ${KMIME_VERSION})
 endif ()
 
 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)
 
 # Find KF5 packages
 find_package(KF5WidgetsAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5ConfigWidgets ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5CoreAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5Codecs ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5Config ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5I18n ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5IconThemes ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5ItemModels ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5XmlGui ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5WindowSystem ${KF5_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5DocTools ${KF5_WANT_VERSION} CONFIG)
 find_package(KF5Crash ${KF5_WANT_VERSION} REQUIRED)
 
 set_package_properties(KF5DocTools 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(KF5DBusAddons ${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(KF5DBusAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
   set(_kleopatra_dbusaddons_libs KF5::DBusAddons)
 endif()
 
 set(HAVE_QDBUS ${Qt${QT_MAJOR_VERSION}DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 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.17.2")
     set(QGPGME_SUPPORTS_KEY_REVOCATION 1)
     set(QGPGME_SUPPORTS_KEY_REFRESH 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(Assuan2 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)
 
 include (ConfigureChecks.cmake)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${ASSUAN2_INCLUDES}
     )
 
 add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
 ecm_set_disabled_deprecation_versions(QT 5.14.0 KF 5.95.0)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
 endif()
 add_definitions(-DQT_NO_EMIT)
 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(KF5DocTools_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/src/commands/lookupcertificatescommand.cpp b/src/commands/lookupcertificatescommand.cpp
index e28aca97a..e546ecddf 100644
--- a/src/commands/lookupcertificatescommand.cpp
+++ b/src/commands/lookupcertificatescommand.cpp
@@ -1,616 +1,609 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/lookupcertificatescommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008, 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "lookupcertificatescommand.h"
 
 #include "importcertificatescommand_p.h"
 
 #include "detailscommand.h"
 
 #include <settings.h>
 
 #include "view/tabwidget.h"
 
 #include <Libkleo/Compat>
+#include <Libkleo/Debug>
 #include <Libkleo/GnuPG>
 
 #include <dialogs/lookupcertificatesdialog.h>
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 #include <QGpgME/KeyListJob>
 #include <QGpgME/ImportFromKeyserverJob>
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
 # include <QGpgME/WKDLookupJob>
 # include <QGpgME/WKDLookupResult>
 #endif
 
 #include <gpgme++/data.h>
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <gpgme++/importresult.h>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include "kleopatra_debug.h"
 
 #include <QRegularExpression>
 
 #include <vector>
 #include <map>
 #include <set>
 #include <algorithm>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 using namespace QGpgME;
 
-static QDebug operator<<(QDebug s, const GpgME::Key &key)
-{
-    if (key.primaryFingerprint()) {
-        return s << Formatting::summaryLine(key) << "fpr:" << key.primaryFingerprint();
-    } else {
-        return s << Formatting::summaryLine(key) << "id:" << key.keyID();
-    }
-}
 class LookupCertificatesCommand::Private : public ImportCertificatesCommand::Private
 {
     friend class ::Kleo::Commands::LookupCertificatesCommand;
     LookupCertificatesCommand *q_func() const
     {
         return static_cast<LookupCertificatesCommand *>(q);
     }
 public:
     explicit Private(LookupCertificatesCommand *qq, KeyListController *c);
     ~Private() override;
 
     void init();
 
 private:
     void slotSearchTextChanged(const QString &str);
     void slotNextKey(const Key &key);
     void slotKeyListResult(const KeyListResult &result);
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
     void slotWKDLookupResult(const WKDLookupResult &result);
 #endif
     void tryToFinishKeyLookup();
     void slotImportRequested(const std::vector<Key> &keys);
     void slotDetailsRequested(const Key &key);
     void slotSaveAsRequested(const std::vector<Key> &keys);
     void slotDialogRejected()
     {
         canceled();
     }
 
 private:
     using ImportCertificatesCommand::Private::showError;
     void showError(QWidget *parent, const KeyListResult &result);
     void showResult(QWidget *parent, const KeyListResult &result);
     void createDialog();
     KeyListJob *createKeyListJob(GpgME::Protocol proto) const
     {
         const auto cbp = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
         return cbp ? cbp->keyListJob(true) : nullptr;
     }
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
     WKDLookupJob *createWKDLookupJob() const
     {
         const auto cbp = QGpgME::openpgp();
         return cbp ? cbp->wkdLookupJob() : nullptr;
     }
 #endif
     ImportFromKeyserverJob *createImportJob(GpgME::Protocol proto) const
     {
         const auto cbp = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
         return cbp ? cbp->importFromKeyserverJob() : nullptr;
     }
     void startKeyListJob(GpgME::Protocol proto, const QString &str);
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
     void startWKDLookupJob(const QString &str);
 #endif
     bool checkConfig() const;
 
     QWidget *dialogOrParentWidgetOrView() const
     {
         if (dialog) {
             return dialog;
         } else {
             return parentWidgetOrView();
         }
     }
 
 private:
     GpgME::Protocol protocol = GpgME::UnknownProtocol;
     QString query;
     bool autoStartLookup = false;
     QPointer<LookupCertificatesDialog> dialog;
     struct KeyListingVariables {
         QPointer<KeyListJob> cms, openpgp;
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
         QPointer<WKDLookupJob> wkdJob;
 #endif
         QString pattern;
         KeyListResult result;
         std::vector<Key> keys;
         int numKeysWithoutUserId = 0;
         std::set<std::string> wkdKeyFingerprints;
         QByteArray wkdKeyData;
         QString wkdSource;
         bool cmsKeysHaveNoFingerprints = false;
         bool openPgpKeysHaveNoFingerprints = false;
 
         void reset()
         {
             *this = KeyListingVariables();
         }
     } keyListing;
 };
 
 LookupCertificatesCommand::Private *LookupCertificatesCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const LookupCertificatesCommand::Private *LookupCertificatesCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 LookupCertificatesCommand::Private::Private(LookupCertificatesCommand *qq, KeyListController *c)
     : ImportCertificatesCommand::Private(qq, c),
       dialog()
 {
     if (!Settings{}.cmsEnabled()) {
         protocol = GpgME::OpenPGP;
     }
 }
 
 LookupCertificatesCommand::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
     delete dialog;
 }
 
 LookupCertificatesCommand::LookupCertificatesCommand(KeyListController *c)
     : ImportCertificatesCommand(new Private(this, c))
 {
     d->init();
 }
 
 LookupCertificatesCommand::LookupCertificatesCommand(const QString &query, KeyListController *c)
     : ImportCertificatesCommand(new Private(this, c))
 {
     d->init();
     d->query = query;
     d->autoStartLookup = true;
 }
 
 LookupCertificatesCommand::LookupCertificatesCommand(QAbstractItemView *v, KeyListController *c)
     : ImportCertificatesCommand(v, new Private(this, c))
 {
     d->init();
     if (c->tabWidget()) {
         d->query = c->tabWidget()->stringFilter();
         // do not start the lookup automatically to prevent unwanted leaking
         // of information
     }
 }
 
 void LookupCertificatesCommand::Private::init()
 {
 
 }
 
 LookupCertificatesCommand::~LookupCertificatesCommand()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void LookupCertificatesCommand::setProtocol(GpgME::Protocol protocol)
 {
     d->protocol = protocol;
 }
 
 GpgME::Protocol LookupCertificatesCommand::protocol() const
 {
     return d->protocol;
 }
 
 void LookupCertificatesCommand::doStart()
 {
 
     if (!d->checkConfig()) {
         d->finished();
         return;
     }
 
     d->createDialog();
     Q_ASSERT(d->dialog);
 
     // if we have a prespecified query, load it into find field
     // and start the search, if auto-start is enabled
     if (!d->query.isEmpty()) {
         d->dialog->setSearchText(d->query);
         if (d->autoStartLookup) {
             d->slotSearchTextChanged(d->query);
         }
     } else {
         d->dialog->setPassive(false);
     }
 
     d->dialog->show();
 
 }
 
 void LookupCertificatesCommand::Private::createDialog()
 {
     if (dialog) {
         return;
     }
     dialog = new LookupCertificatesDialog;
     applyWindowID(dialog);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     connect(dialog, &LookupCertificatesDialog::searchTextChanged, q, [this](const QString &text) { slotSearchTextChanged(text); });
     using CertsVec = std::vector<GpgME::Key>;
     connect(dialog, &LookupCertificatesDialog::saveAsRequested, q, [this](const CertsVec &certs) { slotSaveAsRequested(certs); });
     connect(dialog, &LookupCertificatesDialog::importRequested, q, [this](const CertsVec &certs) { slotImportRequested(certs); });
     connect(dialog, &LookupCertificatesDialog::detailsRequested, q, [this](const GpgME::Key &gpgKey) { slotDetailsRequested(gpgKey); });
     connect(dialog, &QDialog::rejected, q, [this]() { slotDialogRejected(); });
 }
 
 static auto searchTextToEmailAddress(const QString &s)
 {
     return QString::fromStdString(UserID::addrSpecFromString(s.toStdString().c_str()));
 }
 
 void LookupCertificatesCommand::Private::slotSearchTextChanged(const QString &str)
 {
     // pressing return might trigger both search and dialog destruction (search focused and default key set)
     // On Windows, the dialog is then destroyed before this slot is called
     if (dialog) {   //thus test
         dialog->setPassive(true);
         dialog->setCertificates(std::vector<Key>());
         dialog->showInformation({});
     }
 
     query = str;
 
     keyListing.reset();
     keyListing.pattern = str;
 
     if (protocol != GpgME::OpenPGP) {
         startKeyListJob(CMS, str);
     }
 
     if (protocol != GpgME::CMS) {
         static const QRegularExpression rx(QRegularExpression::anchoredPattern(QLatin1String("(?:0x|0X)?[0-9a-fA-F]{6,}")));
         if (rx.match(query).hasMatch() && !str.startsWith(QLatin1String("0x"), Qt::CaseInsensitive)) {
             qCDebug(KLEOPATRA_LOG) << "Adding 0x prefix to query";
             startKeyListJob(OpenPGP, QStringLiteral("0x") + str);
         } else {
             startKeyListJob(OpenPGP, str);
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
             if (str.contains(QLatin1Char{'@'}) && !searchTextToEmailAddress(str).isEmpty()) {
                 startWKDLookupJob(str);
             }
 #endif
         }
     }
 }
 
 void LookupCertificatesCommand::Private::startKeyListJob(GpgME::Protocol proto, const QString &str)
 {
     KeyListJob *const klj = createKeyListJob(proto);
     if (!klj) {
         return;
     }
     connect(klj, &QGpgME::KeyListJob::result, q, [this](const GpgME::KeyListResult &result) { slotKeyListResult(result); });
     connect(klj, &QGpgME::KeyListJob::nextKey, q, [this](const GpgME::Key &key) { slotNextKey(key); });
     if (const Error err = klj->start(QStringList(str))) {
         keyListing.result.mergeWith(KeyListResult(err));
     } else if (proto == CMS) {
         keyListing.cms     = klj;
     } else {
         keyListing.openpgp = klj;
     }
 }
 
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
 void LookupCertificatesCommand::Private::startWKDLookupJob(const QString &str)
 {
     const auto job = createWKDLookupJob();
     if (!job) {
         qCDebug(KLEOPATRA_LOG) << "Failed to create WKDLookupJob";
         return;
     }
     connect(job, &WKDLookupJob::result,
             q, [this](const WKDLookupResult &result) { slotWKDLookupResult(result); });
     if (const Error err = job->start(str)) {
         keyListing.result.mergeWith(KeyListResult{err});
     } else {
         keyListing.wkdJob = job;
     }
 }
 #endif
 
 void LookupCertificatesCommand::Private::slotNextKey(const Key &key)
 {
     if (!key.primaryFingerprint()) {
         qCDebug(KLEOPATRA_LOG) << __func__ << "ignoring key without fingerprint" << key;
         if (q->sender() == keyListing.cms) {
             keyListing.cmsKeysHaveNoFingerprints = true;
         } else if (q->sender() == keyListing.openpgp) {
             keyListing.openPgpKeysHaveNoFingerprints = true;
         }
     } else if (key.numUserIDs() == 0) {
         qCDebug(KLEOPATRA_LOG) << __func__ << "ignoring key without user IDs" << key;
         keyListing.numKeysWithoutUserId++;
     } else {
         qCDebug(KLEOPATRA_LOG) << __func__ << "got key" << key;
         keyListing.keys.push_back(key);
     }
 }
 
 void LookupCertificatesCommand::Private::slotKeyListResult(const KeyListResult &r)
 {
     if (q->sender() == keyListing.cms) {
         keyListing.cms = nullptr;
     } else if (q->sender() == keyListing.openpgp) {
         keyListing.openpgp = nullptr;
     } else {
         qCDebug(KLEOPATRA_LOG) << "unknown sender()" << q->sender();
     }
 
     keyListing.result.mergeWith(r);
 
     tryToFinishKeyLookup();
 }
 
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
 static auto removeKeysNotMatchingEmail(const std::vector<Key> &keys, const std::string &email)
 {
     std::vector<Key> filteredKeys;
 
     const auto addrSpec = UserID::addrSpecFromString(email.c_str());
     std::copy_if(std::begin(keys), std::end(keys),
                  std::back_inserter(filteredKeys),
                  [addrSpec](const auto &key) {
                      const auto uids = key.userIDs();
                      return std::any_of(std::begin(uids), std::end(uids),
                                         [addrSpec](const auto &uid) {
                                             return uid.addrSpec() == addrSpec;
                                         });
                  });
 
     return filteredKeys;
 }
 
 void LookupCertificatesCommand::Private::slotWKDLookupResult(const WKDLookupResult &result)
 {
     if (q->sender() == keyListing.wkdJob) {
         keyListing.wkdJob = nullptr;
     } else {
         qCDebug(KLEOPATRA_LOG) << __func__ << "unknown sender()" << q->sender();
     }
 
     keyListing.result.mergeWith(KeyListResult{result.error()});
 
     const auto keys = removeKeysNotMatchingEmail(result.keyData().toKeys(GpgME::OpenPGP), result.pattern());
     if (!keys.empty()) {
         keyListing.wkdKeyData = QByteArray::fromStdString(result.keyData().toString());
         keyListing.wkdSource = QString::fromStdString(result.source());
         std::copy(std::begin(keys), std::end(keys),
                   std::back_inserter(keyListing.keys));
         // remember the keys retrieved via WKD for import
         std::transform(std::begin(keys), std::end(keys),
                        std::inserter(keyListing.wkdKeyFingerprints, std::begin(keyListing.wkdKeyFingerprints)),
                        [](const auto &k) { return k.primaryFingerprint(); });
     }
 
     tryToFinishKeyLookup();
 }
 #endif
 
 namespace
 {
 void showKeysWithoutFingerprintsNotification(QWidget *parent, GpgME::Protocol protocol)
 {
     if (protocol != GpgME::CMS && protocol != GpgME::OpenPGP) {
         return;
     }
 
     QString message;
     if (protocol == GpgME::CMS) {
         message = xi18nc("@info",
                          "<para>One of the X.509 directory services returned certificates without "
                          "fingerprints. Those certificates are ignored because fingerprints "
                          "are required as unique identifiers for certificates.</para>"
                          "<para>You may want to configure a different X.509 directory service "
                          "in the configuration dialog.</para>");
     } else {
         message = xi18nc("@info",
                          "<para>The OpenPGP keyserver returned certificates without "
                          "fingerprints. Those certificates are ignored because fingerprints "
                          "are required as unique identifiers for certificates.</para>"
                          "<para>You may want to configure a different OpenPGP keyserver "
                          "in the configuration dialog.</para>");
     }
     KMessageBox::information(parent, message, i18nc("@title", "Invalid Server Reply"),
                              QStringLiteral("certificates-lookup-missing-fingerprints"));
 }
 }
 
 void LookupCertificatesCommand::Private::tryToFinishKeyLookup()
 {
     if (keyListing.cms || keyListing.openpgp
 #ifdef QGPGME_SUPPORTS_WKDLOOKUP
         || keyListing.wkdJob
 #endif
     ) {
         // still waiting for jobs to complete
         return;
     }
 
     if (keyListing.result.error() && !keyListing.result.error().isCanceled()) {
         showError(dialog, keyListing.result);
     }
 
     if (keyListing.result.isTruncated()) {
         showResult(dialog, keyListing.result);
     }
 
     if (keyListing.cmsKeysHaveNoFingerprints) {
         showKeysWithoutFingerprintsNotification(dialog, GpgME::CMS);
     }
     if (keyListing.openPgpKeysHaveNoFingerprints) {
         showKeysWithoutFingerprintsNotification(dialog, GpgME::OpenPGP);
     }
 
     if (dialog) {
         dialog->setPassive(false);
         dialog->setCertificates(keyListing.keys);
         if (keyListing.numKeysWithoutUserId > 0) {
             dialog->showInformation(i18ncp("@info",
                                            "One certificate without name and email address was ignored.",
                                            "%1 certificates without name and email address were ignored.",
                                            keyListing.numKeysWithoutUserId));
         }
     } else {
         finished();
     }
 }
 
 void LookupCertificatesCommand::Private::slotImportRequested(const std::vector<Key> &keys)
 {
     dialog = nullptr;
 
     Q_ASSERT(!keys.empty());
     Q_ASSERT(std::none_of(keys.cbegin(), keys.cend(), [](const Key &key) { return key.isNull(); }));
 
     std::vector<Key> wkdKeys, otherKeys;
     otherKeys.reserve(keys.size());
     kdtools::separate_if(std::begin(keys), std::end(keys),
                          std::back_inserter(wkdKeys),
                          std::back_inserter(otherKeys),
                          [this](const auto &key) {
                              return key.primaryFingerprint() &&
                                     keyListing.wkdKeyFingerprints.find(key.primaryFingerprint()) != std::end(keyListing.wkdKeyFingerprints);
                          });
 
     std::vector<Key> pgp, cms;
     pgp.reserve(otherKeys.size());
     cms.reserve(otherKeys.size());
     kdtools::separate_if(otherKeys.begin(), otherKeys.end(),
                          std::back_inserter(pgp),
                          std::back_inserter(cms),
                          [](const Key &key) {
                              return key.protocol() == GpgME::OpenPGP;
                          });
 
     setWaitForMoreJobs(true);
     if (!wkdKeys.empty()) {
         // set an import filter, so that only user IDs matching the email address used for the WKD lookup are imported
         const QString importFilter = QLatin1String{"keep-uid=mbox = "} + searchTextToEmailAddress(keyListing.pattern);
         startImport(OpenPGP, keyListing.wkdKeyData, keyListing.wkdSource,
                     {importFilter, Key::OriginWKD, keyListing.wkdSource});
     }
     if (!pgp.empty()) {
         startImport(OpenPGP, pgp,
                     i18nc(R"(@title %1:"OpenPGP" or "S/MIME")",
                           "%1 Certificate Server",
                           Formatting::displayName(OpenPGP)));
     }
     if (!cms.empty()) {
         startImport(CMS, cms,
                     i18nc(R"(@title %1:"OpenPGP" or "S/MIME")",
                           "%1 Certificate Server",
                           Formatting::displayName(CMS)));
     }
     setWaitForMoreJobs(false);
 }
 
 void LookupCertificatesCommand::Private::slotSaveAsRequested(const std::vector<Key> &keys)
 {
     Q_UNUSED(keys)
     qCDebug(KLEOPATRA_LOG) << "not implemented";
 }
 
 void LookupCertificatesCommand::Private::slotDetailsRequested(const Key &key)
 {
     Command *const cmd = new DetailsCommand(key, view(), controller());
     cmd->setParentWidget(dialogOrParentWidgetOrView());
     cmd->start();
 }
 
 void LookupCertificatesCommand::doCancel()
 {
     ImportCertificatesCommand::doCancel();
     if (QDialog *const dlg = d->dialog) {
         d->dialog = nullptr;
         dlg->close();
     }
 }
 
 void LookupCertificatesCommand::Private::showError(QWidget *parent, const KeyListResult &result)
 {
     if (!result.error()) {
         return;
     }
     KMessageBox::information(parent, i18nc("@info",
                                            "Failed to search on certificate server. The error returned was:\n%1",
                                            QString::fromLocal8Bit(result.error().asString())));
 }
 
 void LookupCertificatesCommand::Private::showResult(QWidget *parent, const KeyListResult &result)
 {
     if (result.isTruncated())
         KMessageBox::information(parent,
                                  xi18nc("@info",
                                         "<para>The query result has been truncated.</para>"
                                         "<para>Either the local or a remote limit on "
                                         "the maximum number of returned hits has "
                                         "been exceeded.</para>"
                                         "<para>You can try to increase the local limit "
                                         "in the configuration dialog, but if one "
                                         "of the configured servers is the limiting "
                                         "factor, you have to refine your search.</para>"),
                                  i18nc("@title", "Result Truncated"),
                                  QStringLiteral("lookup-certificates-truncated-result"));
 }
 
 bool LookupCertificatesCommand::Private::checkConfig() const
 {
     const bool haveOrDontNeedOpenPGPServer = haveKeyserverConfigured() || (protocol == GpgME::CMS);
     const bool haveOrDontNeedCMSServer = haveX509DirectoryServerConfigured() || (protocol == GpgME::OpenPGP);
     const bool ok = haveOrDontNeedOpenPGPServer || haveOrDontNeedCMSServer;
     if (!ok)
         information(xi18nc("@info",
                            "<para>You do not have any directory servers configured.</para>"
                            "<para>You need to configure at least one directory server to "
                            "search on one.</para>"
                            "<para>You can configure directory servers here: "
                            "<interface>Settings->Configure Kleopatra</interface>.</para>"),
                     i18nc("@title", "No Directory Servers Configured"));
     return ok;
 }
 
 #undef d
 #undef q
 
 #include "moc_lookupcertificatescommand.cpp"
diff --git a/src/crypto/gui/certificatelineedit.cpp b/src/crypto/gui/certificatelineedit.cpp
index e8366eaaa..13755189b 100644
--- a/src/crypto/gui/certificatelineedit.cpp
+++ b/src/crypto/gui/certificatelineedit.cpp
@@ -1,702 +1,695 @@
 /*  crypto/gui/certificatelineedit.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     SPDX-FileCopyrightText: 2021, 2022 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "certificatelineedit.h"
 
 #include "commands/detailscommand.h"
 #include "dialogs/groupdetailsdialog.h"
 #include "utils/accessibility.h"
 #include "view/errorlabel.h"
 
 #include <QAccessible>
 #include <QCompleter>
 #include <QPushButton>
 #include <QAction>
 #include <QSignalBlocker>
 
 #include "kleopatra_debug.h"
 
+#include <Libkleo/Debug>
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyFilter>
 #include <Libkleo/KeyGroup>
 #include <Libkleo/KeyList>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/Formatting>
 
 #include <KLocalizedString>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <QGpgME/KeyListJob>
 #include <QGpgME/Protocol>
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QToolButton>
 
 using namespace Kleo;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 Q_DECLARE_METATYPE(KeyGroup)
 
 static QStringList s_lookedUpKeys;
 
-static QDebug operator<<(QDebug debug, const GpgME::Key &key)
-{
-    const bool oldSetting = debug.autoInsertSpaces();
-    debug.nospace() << "Key(" << Formatting::summaryLine(key) << ", id: " << key.keyID() << ")";
-    debug.setAutoInsertSpaces(oldSetting);
-    return debug.maybeSpace();
-}
-
 namespace
 {
 class CompletionProxyModel : public KeyListSortFilterProxyModel
 {
     Q_OBJECT
 
 public:
     CompletionProxyModel(QObject *parent = nullptr)
         : KeyListSortFilterProxyModel(parent)
     {
     }
 
     int columnCount(const QModelIndex &parent = QModelIndex()) const override
     {
         Q_UNUSED(parent)
         // pretend that there is only one column to workaround a bug in
         // QAccessibleTable which provides the accessibility interface for the
         // completion pop-up
         return 1;
     }
 
     QVariant data(const QModelIndex &idx, int role) const override
     {
         if (!idx.isValid()) {
             return QVariant();
         }
 
         switch (role) {
         case Qt::DecorationRole: {
             const auto key = KeyListSortFilterProxyModel::data(idx, KeyList::KeyRole).value<GpgME::Key>();
             if (!key.isNull()) {
                 return Kleo::Formatting::iconForUid(key.userID(0));
             }
 
             const auto group = KeyListSortFilterProxyModel::data(idx, KeyList::GroupRole).value<KeyGroup>();
             if (!group.isNull()) {
                 return QIcon::fromTheme(QStringLiteral("group"));
             }
 
             Q_ASSERT(!key.isNull() || !group.isNull());
             return QVariant();
         }
         default:
             return KeyListSortFilterProxyModel::data(index(idx.row(), KeyList::Summary), role);
         }
     }
 };
 
 auto createSeparatorAction(QObject *parent)
 {
     auto action = new QAction{parent};
     action->setSeparator(true);
     return action;
 }
 } // namespace
 
 class CertificateLineEdit::Private
 {
     CertificateLineEdit *q;
 
 public:
     enum class Status
     {
         Empty,      //< text is empty
         Success,    //< a certificate or group is set
         None,       //< entered text does not match any certificates or groups
         Ambiguous,  //< entered text matches multiple certificates or groups
     };
 
     explicit Private(CertificateLineEdit *qq, AbstractKeyListModel *model, KeyFilter *filter);
 
     QString text() const;
 
     void setKey(const GpgME::Key &key);
 
     void setGroup(const KeyGroup &group);
 
     void setKeyFilter(const std::shared_ptr<KeyFilter> &filter);
 
     void setAccessibleName(const QString &s);
 
 private:
     void updateKey();
     void editChanged();
     void editFinished();
     void checkLocate();
     void onLocateJobResult(QGpgME::Job *job, const QString &email, const KeyListResult &result, const std::vector<GpgME::Key> &keys);
     void openDetailsDialog();
     void setTextWithBlockedSignals(const QString &s);
     void showContextMenu(const QPoint &pos);
     QString errorMessage() const;
     QIcon statusIcon() const;
     QString statusToolTip() const;
     void updateStatusAction();
     void updateErrorLabel();
     void updateAccessibleNameAndDescription();
 
 public:
     Status mStatus = Status::Empty;
     GpgME::Key mKey;
     KeyGroup mGroup;
 
     struct Ui {
         explicit Ui(QWidget *parent)
             : lineEdit{parent}
             , button{parent}
             , errorLabel{parent}
         {}
 
         QLineEdit lineEdit;
         QToolButton button;
         ErrorLabel errorLabel;
     } ui;
 
 private:
     QString mAccessibleName;
     KeyListSortFilterProxyModel *const mFilterModel;
     KeyListSortFilterProxyModel *const mCompleterFilterModel;
     QCompleter *mCompleter = nullptr;
     std::shared_ptr<KeyFilter> mFilter;
     bool mEditingInProgress = false;
     QAction *const mStatusAction;
     QAction *const mShowDetailsAction;
     QPointer<QGpgME::Job> mLocateJob;
 };
 
 CertificateLineEdit::Private::Private(CertificateLineEdit *qq, AbstractKeyListModel *model, KeyFilter *filter)
     : q{qq}
     , ui{qq}
     , mFilterModel{new KeyListSortFilterProxyModel{qq}}
     , mCompleterFilterModel{new CompletionProxyModel{qq}}
     , mCompleter{new QCompleter{qq}}
     , mFilter{std::shared_ptr<KeyFilter>{filter}}
     , mStatusAction{new QAction{qq}}
     , mShowDetailsAction{new QAction{qq}}
 {
     ui.lineEdit.setPlaceholderText(i18n("Please enter a name or email address..."));
     ui.lineEdit.setClearButtonEnabled(true);
     ui.lineEdit.setContextMenuPolicy(Qt::CustomContextMenu);
     ui.lineEdit.addAction(mStatusAction, QLineEdit::LeadingPosition);
 
     mCompleterFilterModel->setKeyFilter(mFilter);
     mCompleterFilterModel->setSourceModel(model);
     mCompleter->setModel(mCompleterFilterModel);
     mCompleter->setFilterMode(Qt::MatchContains);
     mCompleter->setCaseSensitivity(Qt::CaseInsensitive);
     ui.lineEdit.setCompleter(mCompleter);
 
     ui.button.setIcon(QIcon::fromTheme(QStringLiteral("resource-group-new")));
     ui.button.setToolTip(i18n("Show certificate list"));
     ui.button.setAccessibleName(i18n("Show certificate list"));
 
     ui.errorLabel.setVisible(false);
 
     auto vbox = new QVBoxLayout{q};
     vbox->setContentsMargins(0, 0, 0, 0);
 
     auto l = new QHBoxLayout;
     l->setContentsMargins(0, 0, 0, 0);
     l->addWidget(&ui.lineEdit);
     l->addWidget(&ui.button);
 
     vbox->addLayout(l);
     vbox->addWidget(&ui.errorLabel);
 
     q->setFocusPolicy(ui.lineEdit.focusPolicy());
     q->setFocusProxy(&ui.lineEdit);
 
     mShowDetailsAction->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     mShowDetailsAction->setText(i18nc("@action:inmenu", "Show Details"));
     mShowDetailsAction->setEnabled(false);
 
     mFilterModel->setSourceModel(model);
     mFilterModel->setFilterKeyColumn(KeyList::Summary);
     if (filter) {
         mFilterModel->setKeyFilter(mFilter);
     }
 
     connect(KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             q, [this]() { updateKey(); });
     connect(KeyCache::instance().get(), &Kleo::KeyCache::groupUpdated,
             q, [this](const KeyGroup &group) {
                 if (!mGroup.isNull() && mGroup.source() == group.source() && mGroup.id() == group.id()) {
                     setTextWithBlockedSignals(Formatting::summaryLine(group));
                     // queue the update to ensure that the model has been updated
                     QMetaObject::invokeMethod(q, [this]() { updateKey(); }, Qt::QueuedConnection);
                 }
             });
     connect(KeyCache::instance().get(), &Kleo::KeyCache::groupRemoved,
             q, [this](const KeyGroup &group) {
                 if (!mGroup.isNull() && mGroup.source() == group.source() && mGroup.id() == group.id()) {
                     mGroup = KeyGroup();
                     QSignalBlocker blocky{&ui.lineEdit};
                     ui.lineEdit.clear();
                     // queue the update to ensure that the model has been updated
                     QMetaObject::invokeMethod(q, [this]() { updateKey(); }, Qt::QueuedConnection);
                 }
             });
     connect(&ui.lineEdit, &QLineEdit::editingFinished,
             q, [this]() {
                 // queue the call of editFinished() to ensure that QCompleter::activated is handled first
                 QMetaObject::invokeMethod(q, [this]() { editFinished(); }, Qt::QueuedConnection);
             });
     connect(&ui.lineEdit, &QLineEdit::textChanged,
             q, [this]() { editChanged(); });
     connect(&ui.lineEdit, &QLineEdit::customContextMenuRequested,
             q, [this](const QPoint &pos) { showContextMenu(pos); });
     connect(mStatusAction, &QAction::triggered,
             q, [this]() { openDetailsDialog(); });
     connect(mShowDetailsAction, &QAction::triggered,
             q, [this]() { openDetailsDialog(); });
     connect(&ui.button, &QToolButton::clicked,
             q, &CertificateLineEdit::certificateSelectionRequested);
     connect(mCompleter, qOverload<const QModelIndex &>(&QCompleter::activated),
             q, [this] (const QModelIndex &index) {
                 Key key = mCompleter->completionModel()->data(index, KeyList::KeyRole).value<Key>();
                 auto group = mCompleter->completionModel()->data(index, KeyList::GroupRole).value<KeyGroup>();
                 if (!key.isNull()) {
                     q->setKey(key);
                 } else if (!group.isNull()) {
                     q->setGroup(group);
                 } else {
                     qCDebug(KLEOPATRA_LOG) << "Activated item is neither key nor group";
                 }
             });
     updateKey();
 }
 
 void CertificateLineEdit::Private::openDetailsDialog()
 {
     if (!q->key().isNull()) {
         auto cmd = new Commands::DetailsCommand{q->key(), nullptr};
         cmd->setParentWidget(q);
         cmd->start();
     } else if (!q->group().isNull()) {
         auto dlg = new Dialogs::GroupDetailsDialog{q};
         dlg->setAttribute(Qt::WA_DeleteOnClose);
         dlg->setGroup(q->group());
         dlg->show();
     }
 }
 
 void CertificateLineEdit::Private::setTextWithBlockedSignals(const QString &s)
 {
     QSignalBlocker blocky{&ui.lineEdit};
     ui.lineEdit.setText(s);
 }
 
 void CertificateLineEdit::Private::showContextMenu(const QPoint &pos)
 {
     if (QMenu *menu = ui.lineEdit.createStandardContextMenu()) {
         auto *const firstStandardAction = menu->actions().value(0);
         menu->insertActions(firstStandardAction,
                             {mShowDetailsAction, createSeparatorAction(menu)});
         menu->setAttribute(Qt::WA_DeleteOnClose);
         menu->popup(ui.lineEdit.mapToGlobal(pos));
     }
 }
 
 CertificateLineEdit::CertificateLineEdit(AbstractKeyListModel *model,
                                          KeyFilter *filter,
                                          QWidget *parent)
     : QWidget{parent}
     , d{new Private{this, model, filter}}
 {
     /* Take ownership of the model to prevent double deletion when the
      * filter models are deleted */
     model->setParent(parent ? parent : this);
 }
 
 CertificateLineEdit::~CertificateLineEdit() = default;
 
 void CertificateLineEdit::Private::editChanged()
 {
     const bool editingStarted = !mEditingInProgress;
     mEditingInProgress = true;
     updateKey();
     if (editingStarted) {
         Q_EMIT q->editingStarted();
     }
 }
 
 void CertificateLineEdit::Private::editFinished()
 {
     // perform a first update with the "editing in progress" flag still set
     updateKey();
     mEditingInProgress = false;
     checkLocate();
     // perform another update with the "editing in progress" flag cleared
     // after a key locate may have been started; this makes sure that displaying
     // an error is delayed until the key locate job has finished
     updateKey();
 }
 
 void CertificateLineEdit::Private::checkLocate()
 {
     if (mStatus != Status::None) {
         // try to locate key only if text matches no local certificates or groups
         return;
     }
 
     // Only check once per mailbox
     const auto mailText = ui.lineEdit.text().trimmed();
     if (mailText.isEmpty() || s_lookedUpKeys.contains(mailText)) {
         return;
     }
     s_lookedUpKeys << mailText;
     if (mLocateJob) {
         mLocateJob->slotCancel();
         mLocateJob.clear();
     }
     auto job = QGpgME::openpgp()->locateKeysJob();
     connect(job, &QGpgME::KeyListJob::result, q, [this, job, mailText](const KeyListResult &result, const std::vector<GpgME::Key> &keys) {
         onLocateJobResult(job, mailText, result, keys);
     });
     if (auto err = job->start({mailText}, /*secretOnly=*/false)) {
         qCDebug(KLEOPATRA_LOG) << __func__ << "Error: Starting" << job << "for" << mailText << "failed with" << err.asString();
     } else {
         mLocateJob = job;
         qCDebug(KLEOPATRA_LOG) << __func__ << "Started" << job << "for" << mailText;
 
     }
 }
 
 void CertificateLineEdit::Private::onLocateJobResult(QGpgME::Job *job, const QString &email, const KeyListResult &result, const std::vector<GpgME::Key> &keys)
 {
     if (mLocateJob != job) {
         qCDebug(KLEOPATRA_LOG) << __func__ << "Ignoring outdated finished" << job << "for" << email;
         return;
     }
     qCDebug(KLEOPATRA_LOG) << __func__ << job << "for" << email << "finished with" << result.error().asString() << "and keys" << keys;
     mLocateJob.clear();
     if (!keys.empty() && !keys.front().isNull()) {
         KeyCache::mutableInstance()->insert(keys.front());
         // inserting the key implicitly triggers an update
     } else {
         // explicitly trigger an update to display "no key" error
         updateKey();
     }
 }
 
 void CertificateLineEdit::Private::updateKey()
 {
     static const _detail::ByFingerprint<std::equal_to> keysHaveSameFingerprint;
 
     const auto mailText = ui.lineEdit.text().trimmed();
     auto newKey = Key();
     auto newGroup = KeyGroup();
     if (mailText.isEmpty()) {
         mStatus = Status::Empty;
     } else {
         mFilterModel->setFilterFixedString(mailText);
         if (mFilterModel->rowCount() > 1) {
             // keep current key or group if they still match
             if (!mKey.isNull()) {
                 for (int row = 0; row < mFilterModel->rowCount(); ++row) {
                     const QModelIndex index = mFilterModel->index(row, 0);
                     Key key = mFilterModel->key(index);
                     if (!key.isNull() && keysHaveSameFingerprint(key, mKey)) {
                         newKey = mKey;
                         break;
                     }
                 }
             } else if (!mGroup.isNull()) {
                 newGroup = mGroup;
                 for (int row = 0; row < mFilterModel->rowCount(); ++row) {
                     const QModelIndex index = mFilterModel->index(row, 0);
                     KeyGroup group = mFilterModel->group(index);
                     if (!group.isNull() && group.source() == mGroup.source() && group.id() == mGroup.id()) {
                         newGroup = mGroup;
                         break;
                     }
                 }
             }
             if (newKey.isNull() && newGroup.isNull()) {
                 mStatus = Status::Ambiguous;
             }
         } else if (mFilterModel->rowCount() == 1) {
             const auto index = mFilterModel->index(0, 0);
             newKey = mFilterModel->data(index, KeyList::KeyRole).value<Key>();
             newGroup = mFilterModel->data(index, KeyList::GroupRole).value<KeyGroup>();
             Q_ASSERT(!newKey.isNull() || !newGroup.isNull());
             if (newKey.isNull() && newGroup.isNull()) {
                 mStatus = Status::None;
             }
         } else {
             mStatus = Status::None;
         }
     }
     mKey = newKey;
     mGroup = newGroup;
 
     if (!mKey.isNull()) {
         /* FIXME: This needs to be solved by a multiple UID supporting model */
         mStatus = Status::Success;
         ui.lineEdit.setToolTip(Formatting::toolTip(mKey, Formatting::ToolTipOption::AllOptions));
         if (!mEditingInProgress) {
             setTextWithBlockedSignals(Formatting::summaryLine(mKey));
         }
     } else if (!mGroup.isNull()) {
         mStatus = Status::Success;
         ui.lineEdit.setToolTip(Formatting::toolTip(mGroup, Formatting::ToolTipOption::AllOptions));
         if (!mEditingInProgress) {
             setTextWithBlockedSignals(Formatting::summaryLine(mGroup));
         }
     } else {
         ui.lineEdit.setToolTip({});
     }
 
     mShowDetailsAction->setEnabled(mStatus == Status::Success);
     updateStatusAction();
     updateErrorLabel();
 
     Q_EMIT q->keyChanged();
 }
 
 QString CertificateLineEdit::Private::errorMessage() const
 {
     switch (mStatus) {
     case Status::Empty:
     case Status::Success:
         return {};
     case Status::None:
         return i18n("No matching certificates or groups found");
     case Status::Ambiguous:
         return i18n("Multiple matching certificates or groups found");
     default:
         qDebug(KLEOPATRA_LOG) << __func__ << "Invalid status:" << static_cast<int>(mStatus);
         Q_ASSERT(!"Invalid status");
     };
     return {};
 }
 
 QIcon CertificateLineEdit::Private::statusIcon() const
 {
     switch (mStatus) {
     case Status::Empty:
         return QIcon::fromTheme(QStringLiteral("emblem-unavailable"));
     case Status::Success:
         if (!mKey.isNull()) {
             return Formatting::iconForUid(mKey.userID(0));
         } else if (!mGroup.isNull()) {
             return Formatting::validityIcon(mGroup);
         } else {
             qDebug(KLEOPATRA_LOG) << __func__ << "Success, but neither key nor group.";
             return {};
         }
     case Status::None:
     case Status::Ambiguous:
         if (mEditingInProgress || mLocateJob) {
             return QIcon::fromTheme(QStringLiteral("emblem-question"));
         } else {
             return QIcon::fromTheme(QStringLiteral("emblem-error"));
         }
     default:
         qDebug(KLEOPATRA_LOG) << __func__ << "Invalid status:" << static_cast<int>(mStatus);
         Q_ASSERT(!"Invalid status");
     };
     return {};
 }
 
 QString CertificateLineEdit::Private::statusToolTip() const
 {
     switch (mStatus) {
     case Status::Empty:
         return {};
     case Status::Success:
         if (!mKey.isNull()) {
             return Formatting::validity(mKey.userID(0));
         } else if (!mGroup.isNull()) {
             return Formatting::validity(mGroup);
         } else {
             qDebug(KLEOPATRA_LOG) << __func__ << "Success, but neither key nor group.";
             return {};
         }
     case Status::None:
     case Status::Ambiguous:
         return errorMessage();
     default:
         qDebug(KLEOPATRA_LOG) << __func__ << "Invalid status:" << static_cast<int>(mStatus);
         Q_ASSERT(!"Invalid status");
     };
     return {};
 }
 
 void CertificateLineEdit::Private::updateStatusAction()
 {
     mStatusAction->setIcon(statusIcon());
     mStatusAction->setToolTip(statusToolTip());
 }
 
 namespace
 {
 QString decoratedError(const QString &text)
 {
     return text.isEmpty() ? QString() : i18nc("@info", "Error: %1", text);
 }
 }
 
 void CertificateLineEdit::Private::updateErrorLabel()
 {
     const auto currentErrorMessage = ui.errorLabel.text();
     const auto newErrorMessage = decoratedError(errorMessage());
     if (newErrorMessage == currentErrorMessage) {
         return;
     }
     if (currentErrorMessage.isEmpty() && (mEditingInProgress || mLocateJob)) {
         // delay showing the error message until editing is finished, so that we
         // do not annoy the user with an error message while they are still
         // entering the recipient;
         // on the other hand, we clear the error message immediately if it does
         // not apply anymore and we update the error message immediately if it
         // changed
         return;
     }
     ui.errorLabel.setVisible(!newErrorMessage.isEmpty());
     ui.errorLabel.setText(newErrorMessage);
     updateAccessibleNameAndDescription();
 }
 
 void CertificateLineEdit::Private::setAccessibleName(const QString &s)
 {
     mAccessibleName = s;
     updateAccessibleNameAndDescription();
 }
 
 void CertificateLineEdit::Private::updateAccessibleNameAndDescription()
 {
     // fall back to default accessible name if accessible name wasn't set explicitly
     if (mAccessibleName.isEmpty()) {
         mAccessibleName = getAccessibleName(&ui.lineEdit);
     }
     const bool errorShown = ui.errorLabel.isVisible();
 
     // Qt does not support "described-by" relations (like WCAG's "aria-describedby" relationship attribute);
     // emulate this by setting the error message as accessible description of the input field
     const auto description = errorShown ? ui.errorLabel.text() : QString{};
     if (ui.lineEdit.accessibleDescription() != description) {
         ui.lineEdit.setAccessibleDescription(description);
     }
 
     // Qt does not support IA2's "invalid entry" state (like WCAG's "aria-invalid" state attribute);
     // screen readers say something like "invalid data" if this state is set;
     // emulate this by adding "invalid data" to the accessible name of the input field
     const auto name = errorShown ? mAccessibleName + QLatin1String{", "} + invalidEntryText()
                                  : mAccessibleName;
     if (ui.lineEdit.accessibleName() != name) {
         ui.lineEdit.setAccessibleName(name);
     }
 }
 
 Key CertificateLineEdit::key() const
 {
     if (isEnabled()) {
         return d->mKey;
     } else {
         return Key();
     }
 }
 
 KeyGroup CertificateLineEdit::group() const
 {
     if (isEnabled()) {
         return d->mGroup;
     } else {
         return KeyGroup();
     }
 }
 
 QString CertificateLineEdit::Private::text() const
 {
     return ui.lineEdit.text().trimmed();
 }
 
 QString CertificateLineEdit::text() const
 {
     return d->text();
 }
 
 void CertificateLineEdit::Private::setKey(const Key &key)
 {
     mKey = key;
     mGroup = KeyGroup();
     qCDebug(KLEOPATRA_LOG) << "Setting Key. " << Formatting::summaryLine(key);
     setTextWithBlockedSignals(Formatting::summaryLine(key));
     updateKey();
 }
 
 void CertificateLineEdit::setKey(const Key &key)
 {
     d->setKey(key);
 }
 
 void CertificateLineEdit::Private::setGroup(const KeyGroup &group)
 {
     mGroup = group;
     mKey = Key();
     const QString summary = Formatting::summaryLine(group);
     qCDebug(KLEOPATRA_LOG) << "Setting KeyGroup. " << summary;
     setTextWithBlockedSignals(summary);
     updateKey();
 }
 
 void CertificateLineEdit::setGroup(const KeyGroup &group)
 {
     d->setGroup(group);
 }
 
 bool CertificateLineEdit::isEmpty() const
 {
     return d->mStatus == Private::Status::Empty;
 }
 
 bool CertificateLineEdit::hasAcceptableInput() const
 {
     return d->mStatus == Private::Status::Empty
         || d->mStatus == Private::Status::Success;
 }
 
 void CertificateLineEdit::Private::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     mFilter = filter;
     mFilterModel->setKeyFilter(filter);
     mCompleterFilterModel->setKeyFilter(mFilter);
     updateKey();
 }
 
 void CertificateLineEdit::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     d->setKeyFilter(filter);
 }
 
 void CertificateLineEdit::setAccessibleNameOfLineEdit(const QString &name)
 {
     d->setAccessibleName(name);
 }
 
 #include "certificatelineedit.moc"