diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9e161a060..d65d32849 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,177 +1,177 @@
 set(kleopatra_version 3.1.15)
 # The following is for Windows. Keep in line with kleopatra_version.
 set(kleopatra_fileversion 3,1,15,0)
 cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
 project(kleopatra VERSION ${kleopatra_version})
 
 # The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
 if (NOT RELEASE_SERVICE_VERSION)
     set (RELEASE_SERVICE_VERSION "21.07.40")
 endif()
 
 option(FORCE_DISABLE_KCMUTILS "Force building Kleopatra without KCMUtils. Doing this will disable configuration KCM Plugins. [default=OFF]" OFF)
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF5_MIN_VERSION "5.80.0")
 set(KMIME_VERSION "5.17.40")
-set(LIBKLEO_VERSION "5.17.40")
+set(LIBKLEO_VERSION "5.17.41")
 set(QT_REQUIRED_VERSION "5.14.0")
 set(GPGME_REQUIRED_VERSION "1.13.1")
 
 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(ECMGeneratePriFile)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 
 # Find KF5 packages
 if (NOT FORCE_DISABLE_KCMUTILS)
   find_package(KF5KCMUtils ${KF5_WANT_VERSION} CONFIG REQUIRED)
 endif()
 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" TYPE OPTIONAL PURPOSE "Required to generate Kleopatra documentation.")
 
 # Optional packages
 if (WIN32)
   # Only a replacement available for Windows so this
   # is required on other platforms.
   find_package(KF5DBusAddons ${KF5_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 ${Qt5DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 
 # Kdepimlibs packages
 find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KF5Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)
 
 find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)
 
 find_package(Assuan2 REQUIRED)
 
 set(HAVE_KCMUTILS ${KF5KCMUtils_FOUND})
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 
 find_package(Boost 1.34.0 REQUIRED)
 
 find_path(Boost_TOPOLOGICAL_SORT_DIR NAMES boost/graph/topological_sort.hpp PATHS ${Boost_INCLUDE_DIRS})
 if(NOT Boost_TOPOLOGICAL_SORT_DIR)
     message(FATAL_ERROR "The Boost Topological_sort header was NOT found. Should be part of Boost graph module.")
 endif()
 
 set(kleopatra_release FALSE)
 
 if(NOT kleopatra_release)
     if(GIT_FOUND)
         execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
             WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
             OUTPUT_VARIABLE Kleopatra_WC_REVISION)
         string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")
 
         execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%ci ${CMAKE_CURRENT_SOURCE_DIR}
             WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
             OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
         string(REGEX REPLACE " [-0-9:+ ]*\n" "" Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")
 
         set(kleopatra_version "${kleopatra_version}-git${Kleopatra_WC_REVISION} (${Kleopatra_WC_LAST_CHANGED_DATE})")
     endif()
 endif()
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
 
 include (ConfigureChecks.cmake)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${Boost_INCLUDE_DIR}
     ${ASSUAN2_INCLUDES}
     )
 
 add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
 #add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050f00)
 add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x055100)
 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)
 
 kde_enable_exceptions()
 option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" FALSE)
 
 set(COMPILE_WITH_UNITY_CMAKE_SUPPORT false)
 if (USE_UNITY_CMAKE_SUPPORT)
     if(${CMAKE_VERSION} VERSION_LESS "3.16.0")
         message(STATUS "CMAKE version is less than 3.16.0 . We can't use cmake unify build support")
     else()
         set(COMPILE_WITH_UNITY_CMAKE_SUPPORT true)
     endif()
 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}
         )
 
 if(KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
diff --git a/src/commands/importcertificatescommand.cpp b/src/commands/importcertificatescommand.cpp
index a8bc69a62..8919df0df 100644
--- a/src/commands/importcertificatescommand.cpp
+++ b/src/commands/importcertificatescommand.cpp
@@ -1,677 +1,678 @@
 /* -*- 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-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "importcertificatescommand.h"
 #include "importcertificatescommand_p.h"
 #include "certifycertificatecommand.h"
 #include "kleopatra_debug.h"
 
+#include <Libkleo/Algorithm>
 #include <Libkleo/KeyList>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Predicates>
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/KeyListJob>
 #include <QGpgME/Protocol>
 #include <QGpgME/ImportJob>
 #include <QGpgME/ImportFromKeyserverJob>
 #include <QGpgME/ChangeOwnerTrustJob>
 
 #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 <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;
 
 namespace
 {
 
 make_comparator_str(ByImportFingerprint, .fingerprint());
 
 class ImportResultProxyModel : public AbstractKeyListSortFilterProxyModel
 {
     Q_OBJECT
 public:
     ImportResultProxyModel(const std::vector<ImportResult> &results, const QStringList &ids, QObject *parent = nullptr)
         : AbstractKeyListSortFilterProxyModel(parent)
     {
         updateFindCache(results, ids);
     }
 
     ~ImportResultProxyModel() override {}
 
     ImportResultProxyModel *clone() const override
     {
         // compiler-generated copy ctor is fine!
         return new ImportResultProxyModel(*this);
     }
 
     void setImportResults(const std::vector<ImportResult> &results, const QStringList &ids)
     {
         updateFindCache(results, ids);
         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
-            = qBinaryFind(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
-                          fpr.toLatin1().constData(),
-                          ByImportFingerprint<std::less>());
+            = 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<ImportResult> &results, const QStringList &ids)
     {
         Q_ASSERT(results.size() == static_cast<unsigned>(ids.size()));
         m_importsByFingerprint.clear();
         m_idsByFingerprint.clear();
         m_results = results;
         for (unsigned int i = 0, end = results.size(); i != end; ++i) {
             const std::vector<Import> imports = results[i].imports();
             m_importsByFingerprint.insert(m_importsByFingerprint.end(), imports.begin(), imports.end());
             const QString &id = ids[i];
             for (std::vector<Import>::const_iterator it = imports.begin(), end = imports.end(); it != end; ++it) {
                 m_idsByFingerprint[it->fingerprint()].insert(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<ImportResult> m_results;
 };
 
 }
 
 ImportCertificatesCommand::Private::Private(ImportCertificatesCommand *qq, KeyListController *c)
     : Command::Private(qq, c),
       waitForMoreJobs(false),
       containedExternalCMSCerts(false),
       nonWorkingProtocols(),
       idsByJob(),
       jobs(),
       results(),
       ids()
 {
 
 }
 
 ImportCertificatesCommand::Private::~Private() {}
 
 #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() {}
 
 static QString format_ids(const QStringList &ids)
 {
     QStringList escapedIds;
     for (const QString &id : ids) {
         if (!id.isEmpty()) {
             escapedIds << id.toHtmlEscaped();
         }
     }
     return escapedIds.join(QLatin1String("<br>"));
 }
 
 static QString make_tooltip(const QStringList &ids)
 {
     if (ids.empty()) {
         return QString();
     }
     if (ids.size() == 1)
         if (ids.front().isEmpty()) {
             return QString();
         } 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<ImportResult> &results, const QStringList &ids)
 {
     if (std::none_of(results.cbegin(), results.cend(), std::mem_fn(&ImportResult::numConsidered))) {
         return;
     }
     q->addTemporaryView(i18nc("@title:tab", "Imported Certificates"),
                         new ImportResultProxyModel(results, ids),
                         make_tooltip(ids));
     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<ImportResult> &res, const QString &id = QString())
 {
 
     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>");
 
 #define SUM( x ) sum( res, &ImportResult::x )
 
     QStringList lines;
     if (!id.isEmpty()) {
         lines.push_back(headerLine.subs(id).toString());
     }
     lines.push_back(normalLine.subs(i18n("Total number processed:"))
                     .subs(SUM(numConsidered)).toString());
     lines.push_back(normalLine.subs(i18n("Imported:"))
                     .subs(SUM(numImported)).toString());
     if (const int n = SUM(newSignatures))
         lines.push_back(normalLine.subs(i18n("New signatures:"))
                         .subs(n).toString());
     if (const int n = SUM(newUserIDs))
         lines.push_back(normalLine.subs(i18n("New user IDs:"))
                         .subs(n).toString());
     if (const int n = SUM(numKeysWithoutUserID))
         lines.push_back(normalLine.subs(i18n("Certificates without user IDs:"))
                         .subs(n).toString());
     if (const int n = SUM(newSubkeys))
         lines.push_back(normalLine.subs(i18n("New subkeys:"))
                         .subs(n).toString());
     if (const int n = SUM(newRevocations))
         lines.push_back(boldLine.subs(i18n("Newly revoked:"))
                         .subs(n).toString());
     if (const int n = SUM(notImported))
         lines.push_back(boldLine.subs(i18n("Not imported:"))
                         .subs(n).toString());
     if (const int n = SUM(numUnchanged))
         lines.push_back(normalLine.subs(i18n("Unchanged:"))
                         .subs(n).toString());
     if (const int n = SUM(numSecretKeysConsidered))
         lines.push_back(normalLine.subs(i18n("Secret keys processed:"))
                         .subs(n).toString());
     if (const int n = SUM(numSecretKeysImported))
         lines.push_back(normalLine.subs(i18n("Secret keys imported:"))
                         .subs(n).toString());
     if (const int n = SUM(numSecretKeysConsidered) - SUM(numSecretKeysImported) - SUM(numSecretKeysUnchanged))
         if (n > 0)
             lines.push_back(boldLine.subs(i18n("Secret keys <em>not</em> imported:"))
                             .subs(n).toString());
     if (const int n = SUM(numSecretKeysUnchanged))
         lines.push_back(normalLine.subs(i18n("Secret keys unchanged:"))
                         .subs(n).toString());
     if (const int n = SUM(numV3KeysSkipped))
         lines.push_back(normalLine.subs(i18n("Deprecated PGP-2 keys skipped:"))
                         .subs(n).toString());
 
 #undef sum
 
     return lines.join(QString());
 }
 
 static QString make_message_report(const std::vector<ImportResult> &res, const QStringList &ids)
 {
 
     Q_ASSERT(res.size() == static_cast<unsigned>(ids.size()));
 
     if (res.empty()) {
         return i18n("No imports (should not happen, please report a bug).");
     }
 
     if (res.size() == 1)
         return ids.front().isEmpty()
                ? i18n("<qt><p>Detailed results of certificate import:</p>"
                       "<table width=\"100%\">%1</table></qt>", make_report(res))
                : i18n("<qt><p>Detailed results of importing %1:</p>"
                       "<table width=\"100%\">%2</table></qt>", ids.front(), make_report(res));
 
     return i18n("<qt><p>Detailed results of certificate import:</p>"
                 "<table width=\"100%\">%1</table></qt>", make_report(res, i18n("Totals")));
 }
 
 // Returns false on error, true if please certify was shown.
 bool ImportCertificatesCommand::Private::showPleaseCertify(const GpgME::Import &imp)
 {
     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 = GpgME::Context::createForProtocol(GpgME::OpenPGP);
     if (!ctx) {
         // WTF
         qCWarning(KLEOPATRA_LOG) << "Failed to create OpenPGP proto";
         return false;
     }
     GpgME::Error err;
     auto key = ctx->key(fpr, err, false);
     delete ctx;
 
     if (key.isNull() || err) {
         // No such key most likely not OpenPGP
         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::questionYesNo(parentWidgetOrView(),
                 i18n("In order to mark the certificate as valid (green) 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)"),
                 KStandardGuiItem::yes(), KStandardGuiItem::no(), QStringLiteral("CertifyQuestion"));
     if (sel == KMessageBox::Yes) {
         QEventLoop loop;
         auto cmd = new Commands::CertifyCertificateCommand(key);
         cmd->setParentWidget(parentWidgetOrView());
         loop.connect(cmd, SIGNAL(finished()), SLOT(quit()));
         QMetaObject::invokeMethod(cmd, &Commands::CertifyCertificateCommand::start, Qt::QueuedConnection);
         loop.exec();
     }
     return true;
 }
 
 void ImportCertificatesCommand::Private::showDetails(QWidget *parent, const std::vector<ImportResult> &res, const QStringList &ids)
 {
     if (res.size() == 1 && res[0].numImported() == 1 && res[0].imports().size() == 1) {
         if (showPleaseCertify(res[0].imports()[0])) {
             return;
         }
     }
     setImportResultProxyModel(res, ids);
     KMessageBox::information(parent, make_message_report(res, ids), i18n("Certificate Import Result"));
 }
 
 void ImportCertificatesCommand::Private::showDetails(const std::vector<ImportResult> &res, const QStringList &ids)
 {
     showDetails(parentWidgetOrView(), res, ids);
 }
 
 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(QWidget *parent, const Error &err, const QString &id)
 {
     if (parent) {
         KMessageBox::error(parent, make_error_message(err, id), i18n("Certificate Import Failed"));
     } else {
         showError(err, id);
     }
 }
 
 void ImportCertificatesCommand::Private::showError(const Error &err, const QString &id)
 {
     error(make_error_message(err, id), i18n("Certificate Import Failed"));
 }
 
 void ImportCertificatesCommand::Private::setWaitForMoreJobs(bool wait)
 {
     if (wait == waitForMoreJobs) {
         return;
     }
     waitForMoreJobs = wait;
     tryToFinish();
 }
 
 void ImportCertificatesCommand::Private::importResult(const ImportResult &result)
 {
 
     jobs.erase(std::remove(jobs.begin(), jobs.end(), q->sender()), jobs.end());
 
     importResult(result, idsByJob[q->sender()]);
 }
 
 void ImportCertificatesCommand::Private::importResult(const ImportResult &result, const QString &id)
 {
 
     results.push_back(result);
     ids.push_back(id);
 
     tryToFinish();
 }
 
 static void handleOwnerTrust(const std::vector<GpgME::ImportResult> &results)
 {
     //iterate over all imported certificates
     for (const ImportResult &result : results) {
         //when a new certificate got a secret key
         if (result.numSecretKeysImported() >= 1) {
             const char *fingerPr = result.imports()[0].fingerprint();
             GpgME::Error err;
             QScopedPointer<Context>
                 ctx(Context::createForProtocol(GpgME::Protocol::OpenPGP));
 
             if (!ctx){
                 qCWarning(KLEOPATRA_LOG) << "Failed to get context";
                 continue;
             }
 
             const Key toTrustOwner = ctx->key(fingerPr, err , false);
 
             if (toTrustOwner.isNull()) {
                 return;
             }
 
             QStringList uids;
             uids.reserve(toTrustOwner.userIDs().size());
             Q_FOREACH (const UserID &uid, toTrustOwner.userIDs()) {
                 uids << Formatting::prettyNameAndEMail(uid);
             }
 
             const QString str = xi18nc("@info",
                 "<title>You have imported a Secret Key.</title>"
                 "<para>The key has the fingerprint:<nl/>"
                 "<numid>%1</numid>"
                 "</para>"
                 "<para>And claims the User IDs:"
                 "<list><item>%2</item></list>"
                 "</para>"
                 "Is this your own key? (Set trust level to ultimate)",
                 QString::fromUtf8(fingerPr),
                 uids.join(QLatin1String("</item><item>")));
 
             int k = KMessageBox::questionYesNo(nullptr, str, i18nc("@title:window",
                                                                "Secret key imported"));
 
             if (k == KMessageBox::Yes) {
                 //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);
             }
         }
     }
 }
 
 void ImportCertificatesCommand::Private::handleExternalCMSImports()
 {
     QStringList fingerprints;
     // 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 ImportResult &result : qAsConst(results)) {
         const auto imports = result.imports();
         for (const Import &import : imports) {
             if (!import.fingerprint()) {
                 continue;
             }
             fingerprints << QString::fromLatin1(import.fingerprint());
         }
     }
 
     auto job = QGpgME::smime()->keyListJob(false, true, true);
 
     // Old connect here because of Windows.
     connect(job, SIGNAL(result(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)),
             q, SLOT(keyListDone(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)));
     job->start(fingerprints, false);
 }
 
 void ImportCertificatesCommand::Private::keyListDone(const GpgME::KeyListResult &,
                                                      const std::vector<GpgME::Key> &keys,
                                                      const QString &, const GpgME::Error&)
 {
     KeyCache::mutableInstance()->refresh(keys);
     showDetails(results, ids);
 
     auto tv = dynamic_cast<QTreeView *> (view());
     if (!tv) {
         qCDebug(KLEOPATRA_LOG) << "Failed to find treeview";
     } else {
         tv->expandAll();
     }
     finished();
 }
 
 void ImportCertificatesCommand::Private::tryToFinish()
 {
 
     if (waitForMoreJobs || !jobs.empty()) {
         return;
     }
 
     if (std::any_of(results.cbegin(), results.cend(),
                     [](const GpgME::ImportResult &result) {
                         return result.error().code();
                     })) {
         setImportResultProxyModel(results, ids);
         if (std::all_of(results.cbegin(), results.cend(),
                         [](const GpgME::ImportResult &result) {
                             return result.error().isCanceled();
                         })) {
             Q_EMIT q->canceled();
         } else {
             for (unsigned int i = 0, end = results.size(); i != end; ++i)
                 if (const Error err = results[i].error()) {
                     showError(err, ids[i]);
                 }
         }
     } else {
         if (containedExternalCMSCerts) {
             handleExternalCMSImports();
             // We emit finished and do show details
             // after the keylisting.
             return;
         } else {
             handleOwnerTrust(results);
         }
         showDetails(results, ids);
     }
     finished();
 }
 
 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)
 {
     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"));
         importResult(ImportResult(), id);
         return;
     }
 
     connect(job.get(), SIGNAL(result(GpgME::ImportResult)),
             q, SLOT(importResult(GpgME::ImportResult)));
     connect(job.get(), &Job::progress,
             q, &Command::progress);
     const GpgME::Error err = job->start(data);
     if (err.code()) {
         importResult(ImportResult(err), id);
     } else {
         jobs.push_back(job.release());
         idsByJob[jobs.back()] = id;
     }
 }
 
 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"));
         importResult(ImportResult(), id);
         return;
     }
 
     if (protocol == GpgME::CMS) {
         containedExternalCMSCerts = true;
     }
 
     connect(job.get(), SIGNAL(result(GpgME::ImportResult)),
             q, SLOT(importResult(GpgME::ImportResult)));
     connect(job.get(), &Job::progress,
             q, &Command::progress);
     const GpgME::Error err = job->start(keys);
     if (err.code()) {
         importResult(ImportResult(err), id);
     } else {
         jobs.push_back(job.release());
         idsByJob[jobs.back()] = id;
     }
 }
 
 void ImportCertificatesCommand::doCancel()
 {
     std::for_each(d->jobs.begin(), d->jobs.end(), [](Job *job) { job->slotCancel(); });
 }
 
 #undef d
 #undef q
 
 #include "moc_importcertificatescommand.cpp"
 #include "importcertificatescommand.moc"
 
diff --git a/src/crypto/gui/wizard.cpp b/src/crypto/gui/wizard.cpp
index 10273b258..3b2265ad2 100644
--- a/src/crypto/gui/wizard.cpp
+++ b/src/crypto/gui/wizard.cpp
@@ -1,347 +1,349 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/wizard.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 "wizard.h"
 #include "wizardpage.h"
 
 #include <utils/kleo_assert.h>
 
+#include <Libkleo/Algorithm>
+
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <QPushButton>
 #include <KStandardGuiItem>
 
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QLabel>
 #include <QStackedWidget>
 #include <QTimer>
 #include <QVBoxLayout>
 #include "kleopatra_debug.h"
 
 #include <map>
 #include <set>
 
 
 using namespace Kleo::Crypto::Gui;
 
 class Wizard::Private
 {
     friend class ::Wizard;
     Wizard *const q;
 public:
     explicit Private(Wizard *qq);
     ~Private();
 
     void updateButtonStates();
     bool isLastPage(int id) const;
     int previousPage() const;
     void updateHeader();
 
 private:
     std::vector<int> pageOrder;
     std::set<int> hiddenPages;
     std::map<int, WizardPage *> idToPage;
     int currentId = -1;
     QStackedWidget *const stack;
     QPushButton *nextButton = nullptr;
     QPushButton *backButton = nullptr;
     QPushButton *cancelButton = nullptr;
     KGuiItem finishItem;
     KGuiItem nextItem;
     QFrame *titleFrame = nullptr;
     QLabel *titleLabel = nullptr;
     QLabel *subTitleLabel = nullptr;
     QFrame *explanationFrame = nullptr;
     QLabel *explanationLabel = nullptr;
     QTimer *nextPageTimer = nullptr;
 };
 
 Wizard::Private::Private(Wizard *qq)
     : q(qq), stack(new QStackedWidget)
 {
     nextPageTimer = new QTimer(q);
     nextPageTimer->setInterval(0);
     connect(nextPageTimer, &QTimer::timeout, q, &Wizard::next);
     nextItem = KGuiItem(i18n("&Next"));
     finishItem = KStandardGuiItem::ok();
     QVBoxLayout *const top = new QVBoxLayout(q);
     top->setContentsMargins(0, 0, 0, 0);
     titleFrame = new QFrame;
     titleFrame->setFrameShape(QFrame::StyledPanel);
     titleFrame->setAutoFillBackground(true);
     titleFrame->setBackgroundRole(QPalette::Base);
     QVBoxLayout *const titleLayout = new QVBoxLayout(titleFrame);
     titleLabel = new QLabel;
     titleLayout->addWidget(titleLabel);
     subTitleLabel = new QLabel;
     subTitleLabel->setWordWrap(true);
     titleLayout->addWidget(subTitleLabel);
     top->addWidget(titleFrame);
     titleFrame->setVisible(false);
 
     top->addWidget(stack);
 
     explanationFrame = new QFrame;
     explanationFrame->setFrameShape(QFrame::StyledPanel);
     explanationFrame->setAutoFillBackground(true);
     explanationFrame->setBackgroundRole(QPalette::Base);
     QVBoxLayout *const explanationLayout = new QVBoxLayout(explanationFrame);
     explanationLabel = new QLabel;
     explanationLabel->setWordWrap(true);
     explanationLayout->addWidget(explanationLabel);
     top->addWidget(explanationFrame);
     explanationFrame->setVisible(false);
 
     QWidget *buttonWidget = new QWidget;
     QHBoxLayout *buttonLayout = new QHBoxLayout(buttonWidget);
     QDialogButtonBox *const box = new QDialogButtonBox;
 
     cancelButton = box->addButton(QDialogButtonBox::Cancel);
     q->connect(cancelButton, &QPushButton::clicked, q, &Wizard::reject);
 
     backButton = new QPushButton;
     backButton->setText(i18n("Back"));
     q->connect(backButton, &QPushButton::clicked, q, &Wizard::back);
     box->addButton(backButton, QDialogButtonBox::ActionRole);
 
     nextButton = new QPushButton;
     KGuiItem::assign(nextButton, nextItem);
     q->connect(nextButton, &QPushButton::clicked, q, &Wizard::next);
     box->addButton(nextButton, QDialogButtonBox::ActionRole);
     buttonLayout->addWidget(box);
 
     top->addWidget(buttonWidget);
 
     q->connect(q, &Wizard::rejected, q, &Wizard::canceled);
 }
 
 Wizard::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 bool Wizard::Private::isLastPage(int id) const
 {
     return !pageOrder.empty() ? pageOrder.back() == id : false;
 }
 
 void Wizard::Private::updateButtonStates()
 {
     const bool isLast = isLastPage(currentId);
     const bool canGoToNext = q->canGoToNextPage();
     WizardPage *const page = q->page(currentId);
     const KGuiItem customNext = page ? page->customNextButton() : KGuiItem();
     if (customNext.text().isEmpty() && customNext.icon().isNull()) {
         KGuiItem::assign(nextButton, isLast ? finishItem : nextItem);
     } else {
         KGuiItem::assign(nextButton, customNext);
     }
     nextButton->setEnabled(canGoToNext);
     cancelButton->setEnabled(!isLast || !canGoToNext);
     backButton->setEnabled(q->canGoToPreviousPage());
     if (page && page->autoAdvance() && page->isComplete()) {
         nextPageTimer->start();
     }
 }
 
 void Wizard::Private::updateHeader()
 {
     WizardPage *const widget = q->page(currentId);
     Q_ASSERT(!widget || stack->indexOf(widget) != -1);
     if (widget) {
         stack->setCurrentWidget(widget);
     }
     const QString title = widget ? widget->title() : QString();
     const QString subTitle = widget ? widget->subTitle() : QString();
     const QString explanation = widget ? widget->explanation() : QString();
     titleFrame->setVisible(!title.isEmpty() || !subTitle.isEmpty() || !explanation.isEmpty());
     titleLabel->setVisible(!title.isEmpty());
     titleLabel->setText(title);
     subTitleLabel->setText(subTitle);
     subTitleLabel->setVisible(!subTitle.isEmpty());
     explanationFrame->setVisible(!explanation.isEmpty());
     explanationLabel->setVisible(!explanation.isEmpty());
     explanationLabel->setText(explanation);
     q->resize(q->sizeHint().expandedTo(q->size()));
 }
 
 Wizard::Wizard(QWidget *parent, Qt::WindowFlags f)
     : QDialog(parent, f), d(new Private(this))
 {
 
 }
 
 Wizard::~Wizard()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void Wizard::setPage(int id, WizardPage *widget)
 {
     kleo_assert(id != InvalidPage);
     kleo_assert(d->idToPage.find(id) == d->idToPage.end());
     d->idToPage[id] = widget;
     d->stack->addWidget(widget);
     connect(widget, SIGNAL(completeChanged()), this, SLOT(updateButtonStates()));
     connect(widget, SIGNAL(titleChanged()), this, SLOT(updateHeader()));
     connect(widget, SIGNAL(subTitleChanged()), this, SLOT(updateHeader()));
     connect(widget, SIGNAL(explanationChanged()), this, SLOT(updateHeader()));
     connect(widget, SIGNAL(autoAdvanceChanged()), this, SLOT(updateButtonStates()));
     connect(widget, SIGNAL(windowTitleChanged(QString)), this, SLOT(setWindowTitle(QString)));
 }
 
 void Wizard::setPageOrder(const std::vector<int> &pageOrder)
 {
     d->pageOrder = pageOrder;
     d->hiddenPages.clear();
     if (pageOrder.empty()) {
         return;
     }
     setCurrentPage(pageOrder.front());
 }
 
 void Wizard::setCurrentPage(int id)
 {
     d->currentId = id;
     if (id == InvalidPage) {
         return;
     }
     d->updateHeader();
     d->updateButtonStates();
 }
 
 void Wizard::setPageVisible(int id, bool visible)
 {
     if (visible) {
         d->hiddenPages.erase(id);
     } else {
         d->hiddenPages.insert(id);
     }
     if (currentPage() == id && !visible) {
         next();
     }
 }
 
 int Wizard::currentPage() const
 {
     return d->currentId;
 }
 
 bool Wizard::canGoToNextPage() const
 {
     const WizardPage *const current = currentPageWidget();
     return current ? current->isComplete() : false;
 }
 
 bool Wizard::canGoToPreviousPage() const
 {
     const int prev = d->previousPage();
     if (prev == InvalidPage) {
         return false;
     }
     const WizardPage *const prevPage = page(prev);
     Q_ASSERT(prevPage);
     return !prevPage->isCommitPage();
 }
 
 void Wizard::next()
 {
     WizardPage *const current = currentPageWidget();
     if (current) {
         current->onNext();
     }
     onNext(d->currentId);
-    std::vector<int>::const_iterator it = qBinaryFind(d->pageOrder.begin(), d->pageOrder.end(), d->currentId);
+    std::vector<int>::const_iterator it = Kleo::binary_find(d->pageOrder.begin(), d->pageOrder.end(), d->currentId);
     Q_ASSERT(it != d->pageOrder.end());
 
     do {
         ++it;
     } while (d->hiddenPages.find(*it) != d->hiddenPages.end());
 
     if (it == d->pageOrder.end()) { // "Finish"
         d->currentId = InvalidPage;
         close();
     } else { // "next"
         setCurrentPage(*it);
     }
 }
 
 int Wizard::Private::previousPage() const
 {
     if (pageOrder.empty()) {
         return InvalidPage;
     }
 
-    std::vector<int>::const_iterator it = qBinaryFind(pageOrder.begin(), pageOrder.end(), currentId);
+    std::vector<int>::const_iterator it = Kleo::binary_find(pageOrder.begin(), pageOrder.end(), currentId);
     if (it == pageOrder.begin() || it == pageOrder.end()) {
         return InvalidPage;
     }
 
     do {
         --it;
     } while (it != pageOrder.begin() && hiddenPages.find(*it) != hiddenPages.end());
     return *it;
 }
 
 void Wizard::back()
 {
     onBack(d->currentId);
     const int prev = d->previousPage();
     if (prev == InvalidPage) {
         return;
     }
     setCurrentPage(prev);
 }
 
 const WizardPage *Wizard::page(int id) const
 {
     if (id == InvalidPage) {
         return nullptr;
     }
 
     const std::map<int, WizardPage *>::const_iterator it = d->idToPage.find(id);
     kleo_assert(it != d->idToPage.end());
     return (*it).second;
 }
 
 const WizardPage *Wizard::currentPageWidget() const
 {
     return page(d->currentId);
 }
 
 WizardPage *Wizard::currentPageWidget()
 {
     return page(d->currentId);
 }
 
 void Wizard::onNext(int currentId)
 {
     Q_UNUSED(currentId)
 }
 
 void Wizard::onBack(int currentId)
 {
     Q_UNUSED(currentId)
 }
 
 WizardPage *Wizard::page(int id)
 {
     if (id == InvalidPage) {
         return nullptr;
     }
 
     const std::map<int, WizardPage *>::const_iterator it = d->idToPage.find(id);
     kleo_assert(it != d->idToPage.end());
     return (*it).second;
 }
 
 #include "moc_wizard.cpp"