diff --git a/src/ui/cryptoconfigmodule.cpp b/src/ui/cryptoconfigmodule.cpp
index f9b1cb64e..66fa4258d 100644
--- a/src/ui/cryptoconfigmodule.cpp
+++ b/src/ui/cryptoconfigmodule.cpp
@@ -1,954 +1,954 @@
 /*
     cryptoconfigmodule.cpp
 
     This file is part of kgpgcertmanager
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "cryptoconfigmodule.h"
 #include "cryptoconfigmodule_p.h"
 #include "directoryserviceswidget.h"
 #include "kdhorizontalline.h"
 #include "filenamerequester.h"
 
 #include "kleo/keyserverconfig.h"
 
 #include <qgpgme/cryptoconfig.h>
 
 #include <KLineEdit>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include "kleo_ui_debug.h"
 #include <utils/formatting.h>
 #include <QIcon>
 #include <QDialogButtonBox>
 
 #include <QSpinBox>
 
 #include <QApplication>
 #include <QLabel>
 #include <QLayout>
 #include <QPushButton>
 #include <QRegExp>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QScrollArea>
 #include <QDesktopWidget>
 #include <QCheckBox>
 #include <QStyle>
 #include <QComboBox>
 #include <QGroupBox>
 
 #include <gpgme.h>
 
 #include <memory>
 #include <limits>
 #include <array>
 
 using namespace Kleo;
 
 namespace
 {
 
 class ScrollArea : public QScrollArea
 {
 public:
     explicit ScrollArea(QWidget *p) : QScrollArea(p) {}
     QSize sizeHint() const override
     {
         const QSize wsz = widget() ? widget()->sizeHint() : QSize();
         return {wsz.width() + style()->pixelMetric(QStyle::PM_ScrollBarExtent), QScrollArea::sizeHint().height()};
     }
 };
 
 }
 inline QIcon loadIcon(const QString &s)
 {
     QString ss = s;
     return QIcon::fromTheme(ss.replace(QRegExp(QLatin1String("[^a-zA-Z0-9_]")), QStringLiteral("-")));
 }
 
 static unsigned int num_components_with_options(const QGpgME::CryptoConfig *config)
 {
     if (!config) {
         return 0;
     }
     const QStringList components = config->componentList();
     unsigned int result = 0;
     for (QStringList::const_iterator it = components.begin(); it != components.end(); ++it) {
         if (const QGpgME::CryptoConfigComponent *const comp = config->component(*it)) {
             if (!comp->groupList().empty()) {
                 ++result;
             }
         }
     }
     return result;
 }
 
 static KPageView::FaceType determineJanusFace(const QGpgME::CryptoConfig *config, Kleo::CryptoConfigModule::Layout layout, bool &ok)
 {
     ok = true;
     if (num_components_with_options(config) < 2) {
         ok = false;
         return KPageView::Plain;
     }
     return
         layout == CryptoConfigModule::LinearizedLayout ? KPageView::Plain :
         layout == CryptoConfigModule::TabbedLayout     ? KPageView::Tabbed :
         /* else */                                       KPageView::List;
 }
 
 Kleo::CryptoConfigModule::CryptoConfigModule(QGpgME::CryptoConfig *config, QWidget *parent)
     : KPageWidget(parent), mConfig(config)
 {
     init(IconListLayout);
 }
 
 Kleo::CryptoConfigModule::CryptoConfigModule(QGpgME::CryptoConfig *config, Layout layout, QWidget *parent)
     : KPageWidget(parent), mConfig(config)
 {
     init(layout);
 }
 
 void Kleo::CryptoConfigModule::init(Layout layout)
 {
     if (QLayout *l = this->layout()) {
         l->setContentsMargins(0, 0, 0, 0);
     }
 
     QGpgME::CryptoConfig *const config = mConfig;
 
     bool configOK = false;
     const KPageView::FaceType type = determineJanusFace(config, layout, configOK);
 
     setFaceType(type);
 
     QVBoxLayout *vlay = nullptr;
     QWidget *vbox = nullptr;
 
     if (type == Plain) {
         QWidget *w = new QWidget(this);
         auto l = new QVBoxLayout(w);
         l->setContentsMargins(0, 0, 0, 0);
         auto s = new QScrollArea(w);
         s->setFrameStyle(QFrame::NoFrame);
         s->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
         s->setWidgetResizable(true);
         l->addWidget(s);
         vbox = new QWidget(s->viewport());
         vlay = new QVBoxLayout(vbox);
         vlay->setContentsMargins(0, 0, 0, 0);
         s->setWidget(vbox);
         addPage(w, configOK ? QString() : i18n("GpgConf Error"));
     }
 
     const QStringList components = sortComponentList(config->componentList());
     for (QStringList::const_iterator it = components.begin(); it != components.end(); ++it) {
         //qCDebug(KLEO_UI_LOG) <<"Component" << (*it).toLocal8Bit() <<":";
         QGpgME::CryptoConfigComponent *comp = config->component(*it);
         Q_ASSERT(comp);
         if (comp->groupList().empty()) {
             continue;
         }
 
         std::unique_ptr<CryptoConfigComponentGUI> compGUI(new CryptoConfigComponentGUI(this, comp));
         compGUI->setObjectName(*it);
         // KJanusWidget doesn't seem to have iterators, so we store a copy...
         mComponentGUIs.append(compGUI.get());
 
         if (type == Plain) {
             QGroupBox *gb = new QGroupBox(comp->description(), vbox);
             (new QVBoxLayout(gb))->addWidget(compGUI.release());
             vlay->addWidget(gb);
         } else {
             vbox = new QWidget(this);
             vlay = new QVBoxLayout(vbox);
             vlay->setContentsMargins(0, 0, 0, 0);
             KPageWidgetItem *pageItem = new KPageWidgetItem(vbox, comp->description());
             if (type != Tabbed) {
                 pageItem->setIcon(loadIcon(comp->iconName()));
             }
             addPage(pageItem);
 
             QScrollArea *scrollArea = type == Tabbed ? new QScrollArea(vbox) : new ScrollArea(vbox);
             scrollArea->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
             scrollArea->setWidgetResizable(true);
 
             vlay->addWidget(scrollArea);
             const QSize compGUISize = compGUI->sizeHint();
             scrollArea->setWidget(compGUI.release());
 
             // Set a nice startup size
             const int deskHeight = QApplication::desktop()->height();
             int dialogHeight;
             if (deskHeight > 1000) { // very big desktop ?
                 dialogHeight = 800;
             } else if (deskHeight > 650) { // big desktop ?
                 dialogHeight = 500;
             } else { // small (800x600, 640x480) desktop
                 dialogHeight = 400;
             }
             Q_ASSERT(scrollArea->widget());
             if (type != Tabbed) {
                 scrollArea->setMinimumHeight(qMin(compGUISize.height(), dialogHeight));
             }
         }
     }
     if (mComponentGUIs.empty()) {
         const QString msg = i18n("The gpgconf tool used to provide the information "
                                  "for this dialog does not seem to be installed "
                                  "properly. It did not return any components. "
                                  "Try running \"%1\" on the command line for more "
                                  "information.",
                                  components.empty() ? QLatin1String("gpgconf --list-components") : QLatin1String("gpgconf --list-options gpg"));
         QLabel *label = new QLabel(msg, vbox);
         label->setWordWrap(true);
         label->setMinimumHeight(fontMetrics().lineSpacing() * 5);
         vlay->addWidget(label);
     }
 }
 
 namespace
 {
 template<typename Iterator>
 QStringList sortConfigEntries(const Iterator orderBegin, const Iterator orderEnd, const QStringList &entries)
 {
     // components sorting algorithm:
     // 1. components with predefined order (provided via orderBegin / orderEnd)
     // 2. other components sorted alphabetically
     QStringList result;
     QStringList others;
     for (auto it = orderBegin; it != orderEnd; ++it) {
         if (entries.contains(*it)) {
             result.append(*it);
         }
     }
     for (const auto &item : entries) {
         if (!result.contains(item)) {
             others.append(item);
         }
     }
     others.sort();
     result.append(others);
     return result;
 }
 } // namespace
 
 QStringList Kleo::CryptoConfigModule::sortComponentList(const QStringList &components)
 {
     static const std::array<QString, 6> order = {
         QStringLiteral("gpg"),
         QStringLiteral("gpgsm"),
         QStringLiteral("gpg-agent"),
         QStringLiteral("dirmngr"),
         QStringLiteral("pinentry"),
         QStringLiteral("scdaemon")
     };
     return sortConfigEntries(order.begin(), order.end(), components);
 }
 
 QStringList Kleo::CryptoConfigModule::sortGroupList(const QString &moduleName, const QStringList &groups)
 {
     if (moduleName == QStringLiteral("gpg")) {
         static const std::array<QString, 4> order = {
             QStringLiteral("Keyserver"),
             QStringLiteral("Configuration"),
             QStringLiteral("Monitor"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else if (moduleName == QStringLiteral("gpgsm")) {
         static const std::array<QString, 4> order = {
             QStringLiteral("Security"),
             QStringLiteral("Configuration"),
             QStringLiteral("Monitor"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else if (moduleName == QStringLiteral("gpg-agent")) {
         static const std::array<QString, 5> order = {
             QStringLiteral("Security"),
             QStringLiteral("Passphrase policy"),
             QStringLiteral("Configuration"),
             QStringLiteral("Monitor"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else if (moduleName == QStringLiteral("dirmngr")) {
         static const std::array<QString, 10> order = {
             QStringLiteral("Keyserver"),
             QStringLiteral("HTTP"),
             QStringLiteral("LDAP"),
             QStringLiteral("OCSP"),
             QStringLiteral("Tor"),
             QStringLiteral("Enforcement"),
             QStringLiteral("Configuration"),
             QStringLiteral("Format"),
             QStringLiteral("Monitor"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else if (moduleName == QStringLiteral("scdaemon")) {
         static const std::array<QString, 4> order = {
             QStringLiteral("Monitor"),
             QStringLiteral("Configuration"),
             QStringLiteral("Security"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else {
         qCDebug(KLEO_UI_LOG) << "Configuration groups order is not defined for " << moduleName;
         QStringList result(groups);
         result.sort();
         return result;
     }
 }
 
 bool Kleo::CryptoConfigModule::hasError() const
 {
     return mComponentGUIs.empty();
 }
 
 void Kleo::CryptoConfigModule::save()
 {
     bool changed = false;
     QList<CryptoConfigComponentGUI *>::Iterator it = mComponentGUIs.begin();
     for (; it != mComponentGUIs.end(); ++it) {
         if ((*it)->save()) {
             changed = true;
         }
     }
     if (changed) {
         mConfig->sync(true /*runtime*/);
     }
 }
 
 void Kleo::CryptoConfigModule::reset()
 {
     QList<CryptoConfigComponentGUI *>::Iterator it = mComponentGUIs.begin();
     for (; it != mComponentGUIs.end(); ++it) {
         (*it)->load();
     }
 }
 
 void Kleo::CryptoConfigModule::defaults()
 {
     QList<CryptoConfigComponentGUI *>::Iterator it = mComponentGUIs.begin();
     for (; it != mComponentGUIs.end(); ++it) {
         (*it)->defaults();
     }
 }
 
 void Kleo::CryptoConfigModule::cancel()
 {
     mConfig->clear();
 }
 
 ////
 
 Kleo::CryptoConfigComponentGUI::CryptoConfigComponentGUI(
     CryptoConfigModule *module, QGpgME::CryptoConfigComponent *component,
     QWidget *parent)
     : QWidget(parent),
       mComponent(component)
 {
     auto glay = new QGridLayout(this);
     const QStringList groups = module->sortGroupList(mComponent->name(), mComponent->groupList());
     if (groups.size() > 1) {
         glay->setColumnMinimumWidth(0, KDHorizontalLine::indentHint());
         for (QStringList::const_iterator it = groups.begin(), end = groups.end(); it != end; ++it) {
             QGpgME::CryptoConfigGroup *group = mComponent->group(*it);
             Q_ASSERT(group);
             if (!group) {
                 continue;
             }
             const QString title = group->description();
             auto hl = new KDHorizontalLine(title.isEmpty() ? *it : title, this);
             const int row = glay->rowCount();
             glay->addWidget(hl, row, 0, 1, 3);
             mGroupGUIs.append(new CryptoConfigGroupGUI(module, group, glay, this));
         }
     } else if (!groups.empty()) {
         mGroupGUIs.append(new CryptoConfigGroupGUI(module, mComponent->group(groups.front()), glay, this));
     }
     glay->setRowStretch(glay->rowCount(), 1);
 }
 
 bool Kleo::CryptoConfigComponentGUI::save()
 {
     bool changed = false;
     QList<CryptoConfigGroupGUI *>::Iterator it = mGroupGUIs.begin();
     for (; it != mGroupGUIs.end(); ++it) {
         if ((*it)->save()) {
             changed = true;
         }
     }
     return changed;
 }
 
 void Kleo::CryptoConfigComponentGUI::load()
 {
     QList<CryptoConfigGroupGUI *>::Iterator it = mGroupGUIs.begin();
     for (; it != mGroupGUIs.end(); ++it) {
         (*it)->load();
     }
 }
 
 void Kleo::CryptoConfigComponentGUI::defaults()
 {
     QList<CryptoConfigGroupGUI *>::Iterator it = mGroupGUIs.begin();
     for (; it != mGroupGUIs.end(); ++it) {
         (*it)->defaults();
     }
 }
 
 ////
 
 Kleo::CryptoConfigGroupGUI::CryptoConfigGroupGUI(
     CryptoConfigModule *module, QGpgME::CryptoConfigGroup *group,
     QGridLayout *glay, QWidget *widget)
     : QObject(module), mGroup(group)
 {
     const bool de_vs = Kleo::Formatting::complianceMode() == QLatin1String("de-vs");
     const int startRow = glay->rowCount();
     const QStringList entries = mGroup->entryList();
     for (QStringList::const_iterator it = entries.begin(), end = entries.end(); it != end; ++it) {
         QGpgME::CryptoConfigEntry *entry = group->entry(*it);
         Q_ASSERT(entry);
         /* Skip "dangerous" options if we are running in CO_DE_VS.  */
         if (de_vs && entry->level() > QGpgME::CryptoConfigEntry::Level_Advanced) {
             qCDebug(KLEO_UI_LOG) << "entry" << *it << "too advanced, skipping";
             continue;
         }
         CryptoConfigEntryGUI *entryGUI =
             CryptoConfigEntryGUIFactory::createEntryGUI(module, entry, *it, glay, widget);
         if (entryGUI) {
             mEntryGUIs.append(entryGUI);
             entryGUI->load();
         }
     }
     const int endRow = glay->rowCount() - 1;
     if (endRow < startRow) {
         return;
     }
 
     const QString iconName = group->iconName();
     if (iconName.isEmpty()) {
         return;
     }
 
     QLabel *l = new QLabel(widget);
     l->setPixmap(loadIcon(iconName).pixmap(32, 32));
     glay->addWidget(l, startRow, 0, endRow - startRow + 1, 1, Qt::AlignTop);
 }
 
 bool Kleo::CryptoConfigGroupGUI::save()
 {
     bool changed = false;
     QList<CryptoConfigEntryGUI *>::Iterator it = mEntryGUIs.begin();
     for (; it != mEntryGUIs.end(); ++it) {
         if ((*it)->isChanged()) {
             (*it)->save();
             changed = true;
         }
     }
     return changed;
 }
 
 void Kleo::CryptoConfigGroupGUI::load()
 {
     QList<CryptoConfigEntryGUI *>::Iterator it = mEntryGUIs.begin();
     for (; it != mEntryGUIs.end(); ++it) {
         (*it)->load();
     }
 }
 
 void Kleo::CryptoConfigGroupGUI::defaults()
 {
     QList<CryptoConfigEntryGUI *>::Iterator it = mEntryGUIs.begin();
     for (; it != mEntryGUIs.end(); ++it) {
         (*it)->resetToDefault();
     }
 }
 
 ////
 
 using constructor = CryptoConfigEntryGUI *(*)(CryptoConfigModule *, QGpgME::CryptoConfigEntry *, const QString &, QGridLayout *, QWidget *);
 
 namespace
 {
 template <typename T_Widget>
 CryptoConfigEntryGUI *_create(CryptoConfigModule *m, QGpgME::CryptoConfigEntry *e, const QString &n, QGridLayout *l, QWidget *p)
 {
     return new T_Widget(m, e, n, l, p);
 }
 }
 
 static const struct WidgetsByEntryName {
     const char *entryGlob;
     constructor create;
 } widgetsByEntryName[] = {
     { "*/*/debug-level",   &_create<CryptoConfigEntryDebugLevel> }
 };
 static const unsigned int numWidgetsByEntryName = sizeof widgetsByEntryName / sizeof * widgetsByEntryName;
 
 static const constructor listWidgets[QGpgME::CryptoConfigEntry::NumArgType] = {
     // None: A list of options with no arguments (e.g. -v -v -v) is shown as a spinbox
     &_create<CryptoConfigEntrySpinBox>,
     nullptr, // String
     // Int/UInt: Let people type list of numbers (1,2,3....). Untested.
     &_create<CryptoConfigEntryLineEdit>,
     &_create<CryptoConfigEntryLineEdit>,
     nullptr, // Path
     nullptr, // Formerly URL
     &_create<CryptoConfigEntryLDAPURL>,
     nullptr, // DirPath
 };
 
 static const constructor scalarWidgets[QGpgME::CryptoConfigEntry::NumArgType] = {
     &_create<CryptoConfigEntryCheckBox>, // None
     &_create<CryptoConfigEntryLineEdit>, // String
     &_create<CryptoConfigEntrySpinBox>,  // Int
     &_create<CryptoConfigEntrySpinBox>,  // UInt
     &_create<CryptoConfigEntryPath>,     // Path
     nullptr,                                   // Formerly URL
     nullptr,                                   // LDAPURL
     &_create<CryptoConfigEntryDirPath>,  // DirPath
 };
 
 CryptoConfigEntryGUI *Kleo::CryptoConfigEntryGUIFactory::createEntryGUI(CryptoConfigModule *module, QGpgME::CryptoConfigEntry *entry, const QString &entryName, QGridLayout *glay, QWidget *widget)
 {
     Q_ASSERT(entry);
 
     // try to lookup by path:
     const QString path = entry->path();
     for (unsigned int i = 0; i < numWidgetsByEntryName; ++i) {
         if (QRegExp(QLatin1String(widgetsByEntryName[i].entryGlob), Qt::CaseSensitive, QRegExp::Wildcard).exactMatch(path)) {
             return widgetsByEntryName[i].create(module, entry, entryName, glay, widget);
         }
     }
 
     // none found, so look up by type:
     const unsigned int argType = entry->argType();
     Q_ASSERT(argType < QGpgME::CryptoConfigEntry::NumArgType);
     if (entry->isList()) {
         if (const constructor create = listWidgets[argType]) {
             return create(module, entry, entryName, glay, widget);
         } else {
             qCWarning(KLEO_UI_LOG) << "No widget implemented for list of type" << entry->argType();
         }
     } else if (const constructor create = scalarWidgets[argType]) {
         return create(module, entry, entryName, glay, widget);
     } else {
         qCWarning(KLEO_UI_LOG) << "No widget implemented for type" << entry->argType();
     }
 
     return nullptr;
 }
 
 ////
 
 Kleo::CryptoConfigEntryGUI::CryptoConfigEntryGUI(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry,
     const QString &entryName)
     : QObject(module), mEntry(entry), mName(entryName), mChanged(false)
 {
     connect(this, &CryptoConfigEntryGUI::changed, module, &CryptoConfigModule::changed);
 }
 
 QString Kleo::CryptoConfigEntryGUI::description() const
 {
     QString descr = mEntry->description();
     if (descr.isEmpty()) { // happens for expert options
         // String does not need to be translated because the options itself
         // are also not translated
         return QStringLiteral("\"%1\"").arg(mName);
     }
     if (i18nc("Translate this to 'yes' or 'no' (use the English words!) "
               "depending on whether your language uses "
               "Sentence style capitalization in GUI labels (yes) or not (no). "
               "Context: We get some backend strings in that have the wrong "
               "capitalization (in English, at least) so we need to force the "
               "first character to upper-case. It is this behaviour you can "
               "control for your language with this translation.", "yes") == QLatin1String("yes")) {
         descr[0] = descr[0].toUpper();
     }
     return descr;
 }
 
 void Kleo::CryptoConfigEntryGUI::resetToDefault()
 {
     mEntry->resetToDefault();
     load();
 }
 
 ////
 
 Kleo::CryptoConfigEntryLineEdit::CryptoConfigEntryLineEdit(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
     const int row = glay->rowCount();
     mLineEdit = new KLineEdit(widget);
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mLineEdit);
     glay->addWidget(label, row, 1);
     glay->addWidget(mLineEdit, row, 2);
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mLineEdit->setEnabled(false);
     } else {
         connect(mLineEdit, &KLineEdit::textChanged, this, &CryptoConfigEntryLineEdit::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntryLineEdit::doSave()
 {
     mEntry->setStringValue(mLineEdit->text());
 }
 
 void Kleo::CryptoConfigEntryLineEdit::doLoad()
 {
     mLineEdit->setText(mEntry->stringValue());
 }
 
 ////
 
 static const struct {
     const char *label;
     const char *name;
 } debugLevels[] = {
     { I18N_NOOP("0 - None"), "none"},
     { I18N_NOOP("1 - Basic"), "basic"},
     { I18N_NOOP("2 - Verbose"), "advanced"},
     { I18N_NOOP("3 - More Verbose"), "expert"},
     { I18N_NOOP("4 - All"), "guru"},
 };
 static const unsigned int numDebugLevels = sizeof debugLevels / sizeof * debugLevels;
 
 Kleo::CryptoConfigEntryDebugLevel::CryptoConfigEntryDebugLevel(CryptoConfigModule *module, QGpgME::CryptoConfigEntry *entry,
         const QString &entryName, QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName),
       mComboBox(new QComboBox(widget))
 {
     QLabel *label = new QLabel(i18n("Set the debugging level to"), widget);
     label->setBuddy(mComboBox);
 
     for (unsigned int i = 0; i < numDebugLevels; ++i) {
         mComboBox->addItem(i18n(debugLevels[i].label));
     }
 
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mComboBox->setEnabled(false);
     } else {
-        connect(mComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged),
+        connect(mComboBox, qOverload<int>(&QComboBox::currentIndexChanged),
                 this, &CryptoConfigEntryDebugLevel::slotChanged);
     }
 
     const int row = glay->rowCount();
     glay->addWidget(label, row, 1);
     glay->addWidget(mComboBox, row, 2);
 }
 
 void Kleo::CryptoConfigEntryDebugLevel::doSave()
 {
     const unsigned int idx = mComboBox->currentIndex();
     if (idx < numDebugLevels) {
         mEntry->setStringValue(QLatin1String(debugLevels[idx].name));
     } else {
         mEntry->setStringValue(QString());
     }
 }
 
 void Kleo::CryptoConfigEntryDebugLevel::doLoad()
 {
     const QString str = mEntry->stringValue();
     for (unsigned int i = 0; i < numDebugLevels; ++i) {
         if (str == QLatin1String(debugLevels[i].name)) {
             mComboBox->setCurrentIndex(i);
             return;
         }
     }
     mComboBox->setCurrentIndex(0);
 }
 
 ////
 
 Kleo::CryptoConfigEntryPath::CryptoConfigEntryPath(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName),
       mFileNameRequester(nullptr)
 {
     const int row = glay->rowCount();
     mFileNameRequester = new FileNameRequester(widget);
     mFileNameRequester->setExistingOnly(false);
     mFileNameRequester->setFilter(QDir::Files);
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mFileNameRequester);
     glay->addWidget(label, row, 1);
     glay->addWidget(mFileNameRequester, row, 2);
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mFileNameRequester->setEnabled(false);
     } else {
         connect(mFileNameRequester, &FileNameRequester::fileNameChanged, this, &CryptoConfigEntryPath::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntryPath::doSave()
 {
     mEntry->setURLValue(QUrl::fromLocalFile(mFileNameRequester->fileName()));
 }
 
 void Kleo::CryptoConfigEntryPath::doLoad()
 {
     if (mEntry->urlValue().isLocalFile()) {
         mFileNameRequester->setFileName(mEntry->urlValue().toLocalFile());
     } else {
         mFileNameRequester->setFileName(mEntry->urlValue().toString());
     }
 }
 
 ////
 
 Kleo::CryptoConfigEntryDirPath::CryptoConfigEntryDirPath(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName),
       mFileNameRequester(nullptr)
 {
     const int row = glay->rowCount();
     mFileNameRequester = new FileNameRequester(widget);
     mFileNameRequester->setExistingOnly(false);
     mFileNameRequester->setFilter(QDir::Dirs);
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mFileNameRequester);
     glay->addWidget(label, row, 1);
     glay->addWidget(mFileNameRequester, row, 2);
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mFileNameRequester->setEnabled(false);
     } else {
         connect(mFileNameRequester, &FileNameRequester::fileNameChanged, this, &CryptoConfigEntryDirPath::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntryDirPath::doSave()
 {
     mEntry->setURLValue(QUrl::fromLocalFile(mFileNameRequester->fileName()));
 }
 
 void Kleo::CryptoConfigEntryDirPath::doLoad()
 {
     mFileNameRequester->setFileName(mEntry->urlValue().toLocalFile());
 }
 
 ////
 
 Kleo::CryptoConfigEntrySpinBox::CryptoConfigEntrySpinBox(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
 
     if (entry->argType() == QGpgME::CryptoConfigEntry::ArgType_None && entry->isList()) {
         mKind = ListOfNone;
     } else if (entry->argType() == QGpgME::CryptoConfigEntry::ArgType_UInt) {
         mKind = UInt;
     } else {
         Q_ASSERT(entry->argType() == QGpgME::CryptoConfigEntry::ArgType_Int);
         mKind = Int;
     }
 
     const int row = glay->rowCount();
     mNumInput = new QSpinBox(widget);
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mNumInput);
     glay->addWidget(label, row, 1);
     glay->addWidget(mNumInput, row, 2);
 
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mNumInput->setEnabled(false);
     } else {
         mNumInput->setMinimum(mKind == Int ? std::numeric_limits<int>::min() : 0);
         mNumInput->setMaximum(std::numeric_limits<int>::max());
-        connect(mNumInput, QOverload<int>::of(&QSpinBox::valueChanged), this, &CryptoConfigEntrySpinBox::slotChanged);
+        connect(mNumInput, qOverload<int>(&QSpinBox::valueChanged), this, &CryptoConfigEntrySpinBox::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntrySpinBox::doSave()
 {
     int value = mNumInput->value();
     switch (mKind) {
     case ListOfNone:
         mEntry->setNumberOfTimesSet(value);
         break;
     case UInt:
         mEntry->setUIntValue(value);
         break;
     case Int:
         mEntry->setIntValue(value);
         break;
     }
 }
 
 void Kleo::CryptoConfigEntrySpinBox::doLoad()
 {
     int value = 0;
     switch (mKind) {
     case ListOfNone:
         value = mEntry->numberOfTimesSet();
         break;
     case UInt:
         value = mEntry->uintValue();
         break;
     case Int:
         value = mEntry->intValue();
         break;
     }
     mNumInput->setValue(value);
 }
 
 ////
 
 Kleo::CryptoConfigEntryCheckBox::CryptoConfigEntryCheckBox(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
     const int row = glay->rowCount();
     mCheckBox = new QCheckBox(widget);
     glay->addWidget(mCheckBox, row, 1, 1, 2);
     mCheckBox->setText(description());
     if (entry->isReadOnly()) {
         mCheckBox->setEnabled(false);
     } else {
         connect(mCheckBox, &QCheckBox::toggled, this, &CryptoConfigEntryCheckBox::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntryCheckBox::doSave()
 {
     mEntry->setBoolValue(mCheckBox->isChecked());
 }
 
 void Kleo::CryptoConfigEntryCheckBox::doLoad()
 {
     mCheckBox->setChecked(mEntry->boolValue());
 }
 
 Kleo::CryptoConfigEntryLDAPURL::CryptoConfigEntryLDAPURL(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry,
     const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
     mLabel = new QLabel(widget);
     mPushButton = new QPushButton(entry->isReadOnly() ? i18n("Show...") : i18n("Edit..."), widget);
 
     const int row = glay->rowCount();
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mPushButton);
     glay->addWidget(label, row, 1);
     auto hlay = new QHBoxLayout;
     glay->addLayout(hlay, row, 2);
     hlay->addWidget(mLabel, 1);
     hlay->addWidget(mPushButton);
 
     if (entry->isReadOnly()) {
         mLabel->setEnabled(false);
     }
     connect(mPushButton, &QPushButton::clicked, this, &CryptoConfigEntryLDAPURL::slotOpenDialog);
 }
 
 void Kleo::CryptoConfigEntryLDAPURL::doLoad()
 {
     setURLList(mEntry->urlValueList());
 }
 
 void Kleo::CryptoConfigEntryLDAPURL::doSave()
 {
     mEntry->setURLValueList(mURLList);
 }
 
 void prepareURLCfgDialog(QDialog *dialog, DirectoryServicesWidget *dirserv, bool readOnly)
 {
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok, dialog);
 
     if (!readOnly) {
         buttonBox->addButton(QDialogButtonBox::Cancel);
         buttonBox->addButton(QDialogButtonBox::RestoreDefaults);
 
         QPushButton *defaultsBtn = buttonBox->button(QDialogButtonBox::RestoreDefaults);
 
         QObject::connect(defaultsBtn, &QPushButton::clicked, dirserv, &DirectoryServicesWidget::clear);
         QObject::connect(buttonBox, &QDialogButtonBox::rejected, dialog, &QDialog::reject);
     }
 
     QObject::connect(buttonBox, &QDialogButtonBox::accepted, dialog, &QDialog::accept);
 
     auto layout = new QVBoxLayout;
     layout->addWidget(dirserv);
     layout->addWidget(buttonBox);
     dialog->setLayout(layout);
 }
 
 void Kleo::CryptoConfigEntryLDAPURL::slotOpenDialog()
 {
     if (!gpgme_check_version("1.16.0")) {
         KMessageBox::sorry(mPushButton->parentWidget(),
                            i18n("Configuration of directory services is not possible "
                                 "because the used gpgme libraries are too old."),
                            i18n("Sorry"));
         return;
     }
 
     // I'm a bad boy and I do it all on the stack. Enough classes already :)
     // This is just a simple dialog around the directory-services-widget
     QDialog dialog(mPushButton->parentWidget());
     dialog.setWindowTitle(i18nc("@title:window", "Configure Directory Services"));
 
     auto dirserv = new DirectoryServicesWidget(&dialog);
 
     prepareURLCfgDialog(&dialog, dirserv, mEntry->isReadOnly());
 
     dirserv->setReadOnly(mEntry->isReadOnly());
 
     std::vector<KeyserverConfig> servers;
     std::transform(std::cbegin(mURLList), std::cend(mURLList), std::back_inserter(servers), [](const auto &url) { return KeyserverConfig::fromUrl(url); });
     dirserv->setKeyservers(servers);
 
     if (dialog.exec()) {
         QList<QUrl> urls;
         const auto servers = dirserv->keyservers();
         std::transform(std::begin(servers), std::end(servers), std::back_inserter(urls), [](const auto &server) { return server.toUrl(); });
         setURLList(urls);
         slotChanged();
     }
 }
 
 void Kleo::CryptoConfigEntryLDAPURL::setURLList(const QList<QUrl> &urlList)
 {
     mURLList = urlList;
     if (mURLList.isEmpty()) {
         mLabel->setText(i18n("None configured"));
     } else {
         mLabel->setText(i18np("1 server configured", "%1 servers configured", mURLList.count()));
     }
 }
 
 #include "moc_cryptoconfigmodule_p.cpp"
diff --git a/src/ui/keyapprovaldialog.cpp b/src/ui/keyapprovaldialog.cpp
index d75ffb660..b66ed0ad9 100644
--- a/src/ui/keyapprovaldialog.cpp
+++ b/src/ui/keyapprovaldialog.cpp
@@ -1,197 +1,197 @@
 /*  -*- c++ -*-
     keyapprovaldialog.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.h
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keyapprovaldialog.h"
 
 #include "keyrequester.h"
 
 #include <KLocalizedString>
 #include <KSeparator>
 
 #include <QApplication>
 #include <QComboBox>
 #include <QDesktopWidget>
 #include <QDialogButtonBox>
 #include <QGridLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QScrollArea>
 #include <QStringList>
 #include <QVBoxLayout>
 
 #include <gpgme++/key.h>
 #include <qgpgme/protocol.h>
 
 static Kleo::EncryptionPreference cb2pref(int i)
 {
     switch (i) {
     default:
     case 0: return Kleo::UnknownPreference;
     case 1: return Kleo::NeverEncrypt;
     case 2: return Kleo::AlwaysEncrypt;
     case 3: return Kleo::AlwaysEncryptIfPossible;
     case 4: return Kleo::AlwaysAskForEncryption;
     case 5: return Kleo::AskWheneverPossible;
     }
 }
 
 static int pref2cb(Kleo::EncryptionPreference p)
 {
     switch (p) {
     default:                            return 0;
     case Kleo::NeverEncrypt:            return 1;
     case Kleo::AlwaysEncrypt:           return 2;
     case Kleo::AlwaysEncryptIfPossible: return 3;
     case Kleo::AlwaysAskForEncryption:  return 4;
     case Kleo::AskWheneverPossible:     return 5;
     }
 }
 
 static QStringList preferencesStrings()
 {
     return QStringList() << xi18n("<placeholder>none</placeholder>")
            << i18n("Never Encrypt with This Key")
            << i18n("Always Encrypt with This Key")
            << i18n("Encrypt Whenever Encryption is Possible")
            << i18n("Always Ask")
            << i18n("Ask Whenever Encryption is Possible");
 }
 
 class Q_DECL_HIDDEN Kleo::KeyApprovalDialog::Private
 {
 public:
     Private() {}
 
     Kleo::KeyRequester *selfRequester = nullptr;
     QStringList addresses;
     std::vector<Kleo::KeyRequester *> requesters;
     std::vector<QComboBox *> preferences;
     bool prefsChanged = false;
 };
 
 Kleo::KeyApprovalDialog::KeyApprovalDialog(const std::vector<Item> &recipients,
         const std::vector<GpgME::Key> &sender,
         QWidget *parent)
     : QDialog(parent),
       d(new Private())
 {
     setWindowTitle(i18nc("@title:window", "Encryption Key Approval"));
     auto mainLayout = new QVBoxLayout(this);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &KeyApprovalDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KeyApprovalDialog::reject);
     okButton->setDefault(true);
     Q_ASSERT(!recipients.empty());
 
     QFrame *page = new QFrame(this);
     mainLayout->addWidget(page);
     mainLayout->addWidget(buttonBox);
     auto vlay = new QVBoxLayout(page);
     vlay->setContentsMargins(0, 0, 0, 0);
 
     vlay->addWidget(new QLabel(i18n("The following keys will be used for encryption:"), page));
 
     auto sv = new QScrollArea(page);
     sv->setWidgetResizable(true);
     vlay->addWidget(sv);
 
     QWidget *view = new QWidget(sv->viewport());
 
     auto glay = new QGridLayout(view);
     glay->setColumnStretch(1, 1);
     sv->setWidget(view);
 
     int row = -1;
 
     if (!sender.empty()) {
         ++row;
         glay->addWidget(new QLabel(i18n("Your keys:"), view), row, 0);
         d->selfRequester = new EncryptionKeyRequester(true, EncryptionKeyRequester::AllProtocols, view);
         d->selfRequester->setKeys(sender);
         glay->addWidget(d->selfRequester, row, 1);
         ++row;
         glay->addWidget(new KSeparator(Qt::Horizontal, view), row, 0, 1, 2);
     }
 
     const QStringList prefs = preferencesStrings();
 
     for (auto it = recipients.begin(); it != recipients.end(); ++it) {
         ++row;
         glay->addWidget(new QLabel(i18n("Recipient:"), view), row, 0);
         glay->addWidget(new QLabel(it->address, view), row, 1);
         d->addresses.push_back(it->address);
 
         ++row;
         glay->addWidget(new QLabel(i18n("Encryption keys:"), view), row, 0);
         KeyRequester *req = new EncryptionKeyRequester(true, EncryptionKeyRequester::AllProtocols, view);
         req->setKeys(it->keys);
         glay->addWidget(req, row, 1);
         d->requesters.push_back(req);
 
         ++row;
         glay->addWidget(new QLabel(i18n("Encryption preference:"), view), row, 0);
         auto cb = new QComboBox(view);
         cb->setEditable(false);
         cb->addItems(prefs);
         glay->addWidget(cb, row, 1);
         cb->setCurrentIndex(pref2cb(it->pref));
-        connect(cb, QOverload<int>::of(&QComboBox::activated), this, &KeyApprovalDialog::slotPrefsChanged);
+        connect(cb, qOverload<int>(&QComboBox::activated), this, &KeyApprovalDialog::slotPrefsChanged);
         d->preferences.push_back(cb);
     }
 
     QSize size = sizeHint();
 
     // don't make the dialog too large
     const QRect desk = QApplication::desktop()->screenGeometry(this);
     resize(QSize(qMin(size.width(), 3 * desk.width() / 4),
                  qMin(size.height(), 7 * desk.height() / 8)));
 }
 
 Kleo::KeyApprovalDialog::~KeyApprovalDialog()
 {
     delete d;
 }
 
 std::vector<GpgME::Key> Kleo::KeyApprovalDialog::senderKeys() const
 {
     return d->selfRequester ? d->selfRequester->keys() : std::vector<GpgME::Key>();
 }
 
 std::vector<Kleo::KeyApprovalDialog::Item> Kleo::KeyApprovalDialog::items() const
 {
     Q_ASSERT(d->requesters.size() == static_cast<unsigned int>(d->addresses.size()));
     Q_ASSERT(d->requesters.size() == d->preferences.size());
 
     std::vector<Item> result;
     result.reserve(d->requesters.size());
     QStringList::const_iterator ait = d->addresses.constBegin();
     auto rit = d->requesters.begin();
     auto cit = d->preferences.begin();
     while (ait != d->addresses.constEnd()) {
         result.push_back(Item(*ait++, (*rit++)->keys(), cb2pref((*cit++)->currentIndex())));
     }
     return result;
 }
 
 bool Kleo::KeyApprovalDialog::preferencesChanged() const
 {
     return d->prefsChanged;
 }
 
 void Kleo::KeyApprovalDialog::slotPrefsChanged()
 {
     d->prefsChanged = true;
 }
 
diff --git a/src/ui/keyselectioncombo.cpp b/src/ui/keyselectioncombo.cpp
index b23edcd1b..3b50c8962 100644
--- a/src/ui/keyselectioncombo.cpp
+++ b/src/ui/keyselectioncombo.cpp
@@ -1,635 +1,635 @@
 /*  This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keyselectioncombo.h"
 #include <kleo_ui_debug.h>
 
 #include "kleo/dn.h"
 #include "models/keylist.h"
 #include "models/keylistmodel.h"
 #include "models/keylistsortfilterproxymodel.h"
 #include "models/keycache.h"
 #include "utils/formatting.h"
 #include "progressbar.h"
 #include "kleo/defaultkeyfilter.h"
 
 #include <gpgme++/key.h>
 
 #include <QSortFilterProxyModel>
 #include <QVector>
 #include <QTimer>
 
 #include <KLocalizedString>
 
 using namespace Kleo;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 namespace
 {
 class SortFilterProxyModel : public KeyListSortFilterProxyModel
 {
     Q_OBJECT
 
 public:
     using KeyListSortFilterProxyModel::KeyListSortFilterProxyModel;
 
     void setAlwaysAcceptedKey(const QString &fingerprint)
     {
         if (fingerprint == mFingerprint) {
             return;
         }
         mFingerprint = fingerprint;
         invalidate();
     }
 
 protected:
     bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override
     {
         if (!mFingerprint.isEmpty()) {
             const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
             const auto fingerprint = sourceModel()->data(index, KeyList::FingerprintRole).toString();
             if (fingerprint == mFingerprint) {
                 return true;
             }
         }
 
         return KeyListSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
     }
 
 private:
     QString mFingerprint;
 };
 
 class ProxyModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 
 private:
     struct CustomItem {
         QIcon icon;
         QString text;
         QVariant data;
         QString toolTip;
     };
 public:
     ProxyModel(QObject *parent = nullptr)
         : QSortFilterProxyModel(parent)
     {
     }
 
     ~ProxyModel() override
     {
         qDeleteAll(mFrontItems);
         qDeleteAll(mBackItems);
     }
 
     bool lessThan(const QModelIndex &left, const QModelIndex &right) const override
     {
         const auto leftKey =  sourceModel()->data(left, KeyList::KeyRole).value<GpgME::Key>();
         const auto rightKey = sourceModel()->data(right, KeyList::KeyRole).value<GpgME::Key>();
         if (leftKey.isNull()) {
             return false;
         }
         if (rightKey.isNull()) {
             return true;
         }
         // As we display UID(0) this is ok. We probably need a get Best UID at some point.
         const auto lUid = leftKey.userID(0);
         const auto rUid = rightKey.userID(0);
         if (lUid.isNull()) {
             return false;
         }
         if (rUid.isNull()) {
             return true;
         }
         int cmp = strcmp (lUid.id(), rUid.id());
         if (cmp) {
             return cmp < 0;
         }
 
         if (lUid.validity() == rUid.validity()) {
             /* Both are the same check which one is newer. */
             time_t oldTime = 0;
             for (const GpgME::Subkey &s: leftKey.subkeys()) {
                 if (s.isRevoked() || s.isInvalid() || s.isDisabled()) {
                     continue;
                 }
                 if (s.creationTime() > oldTime) {
                     oldTime= s.creationTime();
                 }
             }
             time_t newTime = 0;
             for (const GpgME::Subkey &s: rightKey.subkeys()) {
                 if (s.isRevoked() || s.isInvalid() || s.isDisabled()) {
                     continue;
                 }
                 if (s.creationTime() > newTime) {
                     newTime = s.creationTime();
                 }
             }
             return newTime < oldTime;
         }
         return lUid.validity() > rUid.validity();
     }
 
     bool isCustomItem(const int row) const
     {
         return row < mFrontItems.count() || row >= mFrontItems.count() + QSortFilterProxyModel::rowCount();
     }
 
     void prependItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip)
     {
         beginInsertRows(QModelIndex(), 0, 0);
         mFrontItems.push_front(new CustomItem{ icon, text, data, toolTip });
         endInsertRows();
     }
 
     void appendItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip)
     {
         beginInsertRows(QModelIndex(), rowCount(), rowCount());
         mBackItems.push_back(new CustomItem{ icon, text, data, toolTip });
         endInsertRows();
     }
 
     void removeCustomItem(const QVariant &data)
     {
         for (int i = 0; i < mFrontItems.count(); ++i) {
             if (mFrontItems[i]->data == data) {
                 beginRemoveRows(QModelIndex(), i, i);
                 delete mFrontItems.takeAt(i);
                 endRemoveRows();
                 return;
             }
         }
         for (int i = 0; i < mBackItems.count(); ++i) {
             if (mBackItems[i]->data == data) {
                 const int index = mFrontItems.count() + QSortFilterProxyModel::rowCount() + i;
                 beginRemoveRows(QModelIndex(), index, index);
                 delete mBackItems.takeAt(i);
                 endRemoveRows();
                 return;
             }
         }
     }
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override
     {
         return mFrontItems.count() + QSortFilterProxyModel::rowCount(parent) + mBackItems.count();
     }
 
     QModelIndex mapToSource(const QModelIndex &index) const override
     {
         if (!isCustomItem(index.row())) {
             const int row = index.row() - mFrontItems.count();
 
             return sourceModel()->index(row, index.column());
         } else {
             return {};
         }
     }
 
     QModelIndex mapFromSource(const QModelIndex &source_index) const override
     {
         const QModelIndex idx = QSortFilterProxyModel::mapFromSource(source_index);
         return createIndex(mFrontItems.count() + idx.row(), idx.column(), idx.internalPointer());
     }
 
     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override
     {
         if (row < 0 || row >= rowCount()) {
             return {};
         }
         if (row < mFrontItems.count()) {
             return createIndex(row, column, mFrontItems[row]);
         } else if (row >= mFrontItems.count() + QSortFilterProxyModel::rowCount()) {
             return createIndex(row, column, mBackItems[row - mFrontItems.count() - QSortFilterProxyModel::rowCount()]);
         } else {
             const QModelIndex mi = QSortFilterProxyModel::index(row - mFrontItems.count(), column, parent);
             return createIndex(row, column, mi.internalPointer());
         }
     }
 
     Qt::ItemFlags flags(const QModelIndex &index) const override
     {
         Q_UNUSED(index)
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemNeverHasChildren;
     }
 
     QModelIndex parent(const QModelIndex &) const override
     {
         // Flat list
         return {};
     }
 
     QVariant data(const QModelIndex &index, int role) const override
     {
         if (!index.isValid()) {
             return QVariant();
         }
 
         if (isCustomItem(index.row())) {
             Q_ASSERT(!mFrontItems.isEmpty() || !mBackItems.isEmpty());
             auto ci = static_cast<CustomItem*>(index.internalPointer());
             switch (role) {
             case Qt::DisplayRole:
                 return ci->text;
             case Qt::DecorationRole:
                 return ci->icon;
             case Qt::UserRole:
                 return ci->data;
             case Qt::ToolTipRole:
                 return ci->toolTip;
             default:
                 return QVariant();
             }
         }
 
         const auto key = QSortFilterProxyModel::data(index, KeyList::KeyRole).value<GpgME::Key>();
         Q_ASSERT(!key.isNull());
         if (key.isNull()) {
             return QVariant();
         }
 
         switch (role) {
         case Qt::DisplayRole: {
             const auto userID = key.userID(0);
             QString name;
             QString email;
 
             if (key.protocol() == GpgME::OpenPGP) {
                 name = QString::fromUtf8(userID.name());
                 email = QString::fromUtf8(userID.email());
             } else {
                 const Kleo::DN dn(userID.id());
                 name = dn[QStringLiteral("CN")];
                 email = dn[QStringLiteral("EMAIL")];
             }
             return i18nc("Name <email> (validity, type, created: date)", "%1 (%2, %3 created: %4)",
                          email.isEmpty() ? name : name.isEmpty() ? email : i18nc("Name <email>", "%1 <%2>", name, email),
                          Kleo::Formatting::complianceStringShort(key),
                          Kleo::KeyCache::instance()->pgpOnly() ? QString() :
                             key.protocol() == GpgME::OpenPGP ? i18n("OpenPGP") + QLatin1Char(',') : i18n("S/MIME") + QLatin1Char(','),
                          Kleo::Formatting::creationDateString(key));
         }
         case Qt::ToolTipRole:
             return Kleo::Formatting::toolTip(key, Kleo::Formatting::Validity |
                                                   Kleo::Formatting::Issuer |
                                                   Kleo::Formatting::Subject |
                                                   Kleo::Formatting::Fingerprint |
                                                   Kleo::Formatting::ExpiryDates |
                                                   Kleo::Formatting::UserIDs);
         case Qt::DecorationRole:
             return Kleo::Formatting::iconForUid(key.userID(0));
         default:
             return QSortFilterProxyModel::data(index, role);
         }
     }
 
 private:
     QVector<CustomItem*> mFrontItems;
     QVector<CustomItem*> mBackItems;
 };
 
 
 } // anonymous namespace
 
 namespace Kleo
 {
 class KeySelectionComboPrivate
 {
 public:
     KeySelectionComboPrivate(KeySelectionCombo *parent)
         : wasEnabled(true)
         , q(parent)
     {
     }
 
     /* Selects the first key with a UID addrSpec that matches
      * the mPerfectMatchMbox variable.
      *
      * The idea here is that if there are keys like:
      *
      * tom-store@abc.com
      * susi-store@abc.com
      * store@abc.com
      *
      * And the user wants to send a mail to "store@abc.com"
      * the filter should still show tom and susi (because they
      * both are part of store) but the key for "store" should
      * be preselected.
      *
      * Returns true if one was selected. False otherwise. */
     bool selectPerfectIdMatch() const
     {
         if (mPerfectMatchMbox.isEmpty()) {
             return false;
         }
 
         for (int i = 0; i < proxyModel->rowCount(); ++i) {
             const auto idx = proxyModel->index(i, 0, QModelIndex());
             const auto key = proxyModel->data(idx, KeyList::KeyRole).value<GpgME::Key>();
             if (key.isNull()) {
                 // WTF?
                 continue;
             }
             for (const auto &uid: key.userIDs()) {
                 if (QString::fromStdString(uid.addrSpec()) == mPerfectMatchMbox) {
                     q->setCurrentIndex(i);
                     return true;
                 }
             }
         }
         return false;
     }
 
     /* Updates the current key with the default key if the key matches
      * the current key filter. */
     void updateWithDefaultKey() {
         GpgME::Protocol filterProto = GpgME::UnknownProtocol;
 
         const auto filter = dynamic_cast<const DefaultKeyFilter*> (sortFilterProxy->keyFilter().get());
         if (filter && filter->isOpenPGP() == DefaultKeyFilter::Set) {
             filterProto = GpgME::OpenPGP;
         } else if (filter && filter->isOpenPGP() == DefaultKeyFilter::NotSet) {
             filterProto = GpgME::CMS;
         }
 
         QString defaultKey = defaultKeys.value (filterProto);
         if (defaultKey.isEmpty()) {
             // Fallback to unknown protocol
             defaultKey = defaultKeys.value (GpgME::UnknownProtocol);
         }
         // make sure that the default key is not filtered out unless it has the wrong protocol
         if (filterProto == GpgME::UnknownProtocol) {
             sortFilterProxy->setAlwaysAcceptedKey(defaultKey);
         } else {
             const auto key = KeyCache::instance()->findByFingerprint(defaultKey.toLatin1().constData());
             if (!key.isNull() && key.protocol() == filterProto) {
                 sortFilterProxy->setAlwaysAcceptedKey(defaultKey);
             } else {
                 sortFilterProxy->setAlwaysAcceptedKey({});
             }
         }
         q->setCurrentKey(defaultKey);
     }
 
     void storeCurrentSelectionBeforeModelChange()
     {
         keyBeforeModelChange = q->currentKey();
         customItemBeforeModelChange = q->currentData();
     }
 
     void restoreCurrentSelectionAfterModelChange()
     {
         if (!keyBeforeModelChange.isNull()) {
             q->setCurrentKey(keyBeforeModelChange);
         } else if (customItemBeforeModelChange.isValid()) {
             const auto index = q->findData(customItemBeforeModelChange);
             if (index != -1) {
                 q->setCurrentIndex(index);
             } else {
                 updateWithDefaultKey();
             }
         }
     }
 
     Kleo::AbstractKeyListModel *model = nullptr;
     SortFilterProxyModel *sortFilterProxy = nullptr;
     ProxyModel *proxyModel = nullptr;
     std::shared_ptr<Kleo::KeyCache> cache;
     QMap<GpgME::Protocol, QString> defaultKeys;
     bool wasEnabled = false;
     bool useWasEnabled = false;
     bool secretOnly = false;
     bool initialKeyListingDone = false;
     QString mPerfectMatchMbox;
     GpgME::Key keyBeforeModelChange;
     QVariant customItemBeforeModelChange;
 
 private:
     KeySelectionCombo * const q;
 };
 
 }
 
 using namespace Kleo;
 
 KeySelectionCombo::KeySelectionCombo(QWidget* parent)
     : KeySelectionCombo(true, parent)
 {}
 
 KeySelectionCombo::KeySelectionCombo(bool secretOnly, QWidget* parent)
     : QComboBox(parent)
     , d(new KeySelectionComboPrivate(this))
 {
     d->model = Kleo::AbstractKeyListModel::createFlatKeyListModel(this);
     d->secretOnly = secretOnly;
 
     d->sortFilterProxy = new SortFilterProxyModel(this);
     d->sortFilterProxy->setSourceModel(d->model);
 
     d->proxyModel = new ProxyModel(this);
     d->proxyModel->setSourceModel(d->sortFilterProxy);
 
     setModel(d->proxyModel);
-    connect(this, QOverload<int>::of(&QComboBox::currentIndexChanged),
+    connect(this, qOverload<int>(&QComboBox::currentIndexChanged),
             this, [this](int row) {
                 if (row >= 0 && row < d->proxyModel->rowCount()) {
                     if (d->proxyModel->isCustomItem(row)) {
                         Q_EMIT customItemSelected(currentData(Qt::UserRole));
                     } else {
                         Q_EMIT currentKeyChanged(currentKey());
                     }
                 }
             });
 
     d->cache = Kleo::KeyCache::mutableInstance();
 
     connect(model(), &QAbstractItemModel::rowsAboutToBeInserted,
             this, [this] () { d->storeCurrentSelectionBeforeModelChange(); });
     connect(model(), &QAbstractItemModel::rowsInserted,
             this, [this] () { d->restoreCurrentSelectionAfterModelChange(); });
     connect(model(), &QAbstractItemModel::rowsAboutToBeRemoved,
             this, [this] () { d->storeCurrentSelectionBeforeModelChange(); });
     connect(model(), &QAbstractItemModel::rowsRemoved,
             this, [this] () { d->restoreCurrentSelectionAfterModelChange(); });
     connect(model(), &QAbstractItemModel::modelAboutToBeReset,
             this, [this] () { d->storeCurrentSelectionBeforeModelChange(); });
     connect(model(), &QAbstractItemModel::modelReset,
             this, [this] () { d->restoreCurrentSelectionAfterModelChange(); });
 
     QTimer::singleShot(0, this, &KeySelectionCombo::init);
 }
 
 KeySelectionCombo::~KeySelectionCombo()
 {
     delete d;
 }
 
 void KeySelectionCombo::init()
 {
     connect(d->cache.get(), &Kleo::KeyCache::keyListingDone,
             this, [this]() {
                     // Set useKeyCache ensures that the cache is populated
                     // so this can be a blocking call if the cache is not initialized 
                     if (!d->initialKeyListingDone) {
                         d->model->useKeyCache(true, d->secretOnly ? KeyList::SecretKeysOnly : KeyList::AllKeys);
                         d->proxyModel->removeCustomItem(QStringLiteral("-libkleo-loading-keys"));
                     }
 
                     // We use the useWasEnabled state variable to decide if we should
                     // change the enable / disable state based on the keylist done signal.
                     // If we triggered the refresh useWasEnabled is true and we want to
                     // enable / disable again after our refresh, as the refresh disabled it.
                     //
                     // But if a keyListingDone signal comes from just a generic refresh
                     // triggered by someone else we don't want to change the enable / disable
                     // state.
                     if (d->useWasEnabled) {
                         setEnabled(d->wasEnabled);
                         d->useWasEnabled = false;
                     }
                     Q_EMIT keyListingFinished();
             });
 
     connect(this, &KeySelectionCombo::keyListingFinished, this, [this]() {
             if (!d->initialKeyListingDone) {
                 d->updateWithDefaultKey();
                 d->initialKeyListingDone = true;
             }
         });
 
     if (!d->cache->initialized()) {
         refreshKeys();
     } else {
         d->model->useKeyCache(true, d->secretOnly ? KeyList::SecretKeysOnly : KeyList::AllKeys);
         Q_EMIT keyListingFinished();
     }
 
-    connect(this, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this] () {
+    connect(this, qOverload<int>(&QComboBox::currentIndexChanged), this, [this] () {
             setToolTip(currentData(Qt::ToolTipRole).toString());
         });
 }
 
 
 void KeySelectionCombo::setKeyFilter(const std::shared_ptr<const KeyFilter> &kf)
 {
     d->sortFilterProxy->setKeyFilter(kf);
     d->proxyModel->sort(0);
     d->updateWithDefaultKey();
 }
 
 std::shared_ptr<const KeyFilter> KeySelectionCombo::keyFilter() const
 {
     return d->sortFilterProxy->keyFilter();
 }
 
 void KeySelectionCombo::setIdFilter(const QString &id)
 {
     d->sortFilterProxy->setFilterRegExp(id);
     d->mPerfectMatchMbox = id;
     d->updateWithDefaultKey();
 }
 
 QString KeySelectionCombo::idFilter() const
 {
     return d->sortFilterProxy->filterRegExp().pattern();
 }
 
 GpgME::Key Kleo::KeySelectionCombo::currentKey() const
 {
     return currentData(KeyList::KeyRole).value<GpgME::Key>();
 }
 
 void Kleo::KeySelectionCombo::setCurrentKey(const GpgME::Key &key)
 {
     const int idx = findData(QString::fromLatin1(key.primaryFingerprint()), KeyList::FingerprintRole, Qt::MatchExactly);
     if (idx > -1) {
         setCurrentIndex(idx);
     } else if (!d->selectPerfectIdMatch()) {
         d->updateWithDefaultKey();
     }
     setToolTip(currentData(Qt::ToolTipRole).toString());
 }
 
 void Kleo::KeySelectionCombo::setCurrentKey(const QString &fingerprint)
 {
     const auto cur = currentKey();
     if (!cur.isNull() && !fingerprint.isEmpty() &&
         fingerprint == QLatin1String(cur.primaryFingerprint())) {
         // already set; still emit a changed signal because the current key may
         // have become the item at the current index by changes in the underlying model
         Q_EMIT currentKeyChanged(cur);
         return;
     }
     const int idx = findData(fingerprint, KeyList::FingerprintRole, Qt::MatchExactly);
     if (idx > -1) {
         setCurrentIndex(idx);
     } else if (!d->selectPerfectIdMatch()) {
         setCurrentIndex(0);
     }
     setToolTip(currentData(Qt::ToolTipRole).toString());
 }
 
 void KeySelectionCombo::refreshKeys()
 {
     d->wasEnabled = isEnabled();
     d->useWasEnabled = true;
     setEnabled(false);
     const bool wasBlocked = blockSignals(true);
     prependCustomItem(QIcon(), i18n("Loading keys ..."), QStringLiteral("-libkleo-loading-keys"));
     setCurrentIndex(0);
     blockSignals(wasBlocked);
     d->cache->startKeyListing();
 }
 
 void KeySelectionCombo::appendCustomItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip)
 {
     d->proxyModel->appendItem(icon, text, data, toolTip);
 }
 
 void KeySelectionCombo::appendCustomItem(const QIcon &icon, const QString &text, const QVariant &data)
 {
     appendCustomItem(icon, text, data, QString());
 }
 
 void KeySelectionCombo::prependCustomItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip)
 {
     d->proxyModel->prependItem(icon, text, data, toolTip);
 }
 
 void KeySelectionCombo::prependCustomItem(const QIcon &icon, const QString &text, const QVariant &data)
 {
     prependCustomItem(icon, text, data, QString());
 }
 
 void KeySelectionCombo::removeCustomItem(const QVariant &data)
 {
     d->proxyModel->removeCustomItem(data);
 }
 
 void Kleo::KeySelectionCombo::setDefaultKey(const QString &fingerprint, GpgME::Protocol proto)
 {
     d->defaultKeys.insert(proto, fingerprint);
     d->updateWithDefaultKey();
 }
 
 void Kleo::KeySelectionCombo::setDefaultKey(const QString &fingerprint)
 {
     setDefaultKey(fingerprint, GpgME::UnknownProtocol);
 }
 
 QString Kleo::KeySelectionCombo::defaultKey(GpgME::Protocol proto) const
 {
     return d->defaultKeys.value(proto);
 }
 
 QString Kleo::KeySelectionCombo::defaultKey() const
 {
     return defaultKey(GpgME::UnknownProtocol);
 }
 #include "keyselectioncombo.moc"
diff --git a/src/ui/keyselectiondialog.cpp b/src/ui/keyselectiondialog.cpp
index 3580a3d19..6a2630eeb 100644
--- a/src/ui/keyselectiondialog.cpp
+++ b/src/ui/keyselectiondialog.cpp
@@ -1,998 +1,998 @@
 /*  -*- c++ -*-
     keyselectiondialog.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.cpp
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keyselectiondialog.h"
 
 #include "keylistview.h"
 #include "progressdialog.h"
 
 #include "libkleo/dn.h"
 #include "kleo_ui_debug.h"
 
 // gpgme++
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <qgpgme/keylistjob.h>
 
 // KDE
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 
 // Qt
 #include <QApplication>
 #include <QCheckBox>
 #include <QDateTime>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QProcess>
 #include <QPushButton>
 #include <QRegExp>
 #include <QScrollBar>
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include <algorithm>
 #include <iterator>
 #include <string.h>
 
 static bool checkKeyUsage(const GpgME::Key &key, unsigned int keyUsage, QString *statusString = nullptr)
 {
     auto setStatusString = [statusString](const QString &status) {
         if (statusString) {
             *statusString = status;
         }
     };
 
     if (keyUsage & Kleo::KeySelectionDialog::ValidKeys) {
         if (key.isInvalid()) {
             if (key.keyListMode() & GpgME::Validate) {
                 qCDebug(KLEO_UI_LOG) << "key is invalid";
                 setStatusString(i18n("The key is not valid."));
                 return false;
             } else {
                 qCDebug(KLEO_UI_LOG) << "key is invalid - ignoring";
             }
         }
         if (key.isExpired()) {
             qCDebug(KLEO_UI_LOG) << "key is expired";
             setStatusString(i18n("The key is expired."));
             return false;
         } else if (key.isRevoked()) {
             qCDebug(KLEO_UI_LOG) << "key is revoked";
             setStatusString(i18n("The key is revoked."));
             return false;
         } else if (key.isDisabled()) {
             qCDebug(KLEO_UI_LOG) << "key is disabled";
             setStatusString(i18n("The key is disabled."));
             return false;
         }
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::EncryptionKeys &&
             !key.canEncrypt()) {
         qCDebug(KLEO_UI_LOG) << "key can't encrypt";
         setStatusString(i18n("The key is not designated for encryption."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::SigningKeys &&
             !key.canSign()) {
         qCDebug(KLEO_UI_LOG) << "key can't sign";
         setStatusString(i18n("The key is not designated for signing."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::CertificationKeys &&
             !key.canCertify()) {
         qCDebug(KLEO_UI_LOG) << "key can't certify";
         setStatusString(i18n("The key is not designated for certifying."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::AuthenticationKeys &&
             !key.canAuthenticate()) {
         qCDebug(KLEO_UI_LOG) << "key can't authenticate";
         setStatusString(i18n("The key is not designated for authentication."));
         return false;
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::SecretKeys &&
             !(keyUsage & Kleo::KeySelectionDialog::PublicKeys) &&
             !key.hasSecret()) {
         qCDebug(KLEO_UI_LOG) << "key isn't secret";
         setStatusString(i18n("The key is not secret."));
         return false;
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::TrustedKeys &&
             key.protocol() == GpgME::OpenPGP &&
             // only check this for secret keys for now.
             // Seems validity isn't checked for secret keylistings...
             !key.hasSecret()) {
         std::vector<GpgME::UserID> uids = key.userIDs();
         for (std::vector<GpgME::UserID>::const_iterator it = uids.begin(); it != uids.end(); ++it) {
             if (!it->isRevoked() && it->validity() >= GpgME::UserID::Marginal) {
                 return true;
             }
         }
         qCDebug(KLEO_UI_LOG) << "key has no UIDs with validity >= Marginal";
         setStatusString(i18n("The key is not trusted enough."));
         return false;
     }
     // X.509 keys are always trusted, else they won't be the keybox.
     // PENDING(marc) check that this ^ is correct
 
     setStatusString(i18n("The key can be used."));
     return true;
 }
 
 static bool checkKeyUsage(const std::vector<GpgME::Key> &keys, unsigned int keyUsage)
 {
     for (auto it = keys.begin(); it != keys.end(); ++it) {
         if (!checkKeyUsage(*it, keyUsage)) {
             return false;
         }
     }
     return true;
 }
 
 static inline QString time_t2string(time_t t)
 {
     QDateTime dt;
     dt.setTime_t(t);
     return dt.toString();
 }
 
 namespace
 {
 
 class ColumnStrategy : public Kleo::KeyListView::ColumnStrategy
 {
 public:
     ColumnStrategy(unsigned int keyUsage);
 
     QString title(int col) const override;
     int width(int col, const QFontMetrics &fm) const override;
 
     QString text(const GpgME::Key &key, int col) const override;
     QString toolTip(const GpgME::Key &key, int col) const override;
     QIcon icon(const GpgME::Key &key, int col) const override;
 
 private:
     const QIcon mKeyGoodPix, mKeyBadPix, mKeyUnknownPix, mKeyValidPix;
     const unsigned int mKeyUsage;
 };
 
 static QString iconPath(const QString &name)
 {
     return QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("libkleopatra/pics/") + name + QStringLiteral(".png"));
 }
 
 ColumnStrategy::ColumnStrategy(unsigned int keyUsage)
     : Kleo::KeyListView::ColumnStrategy(),
       mKeyGoodPix(iconPath(QStringLiteral("key_ok"))),
       mKeyBadPix(iconPath(QStringLiteral("key_bad"))),
       mKeyUnknownPix(iconPath(QStringLiteral("key_unknown"))),
       mKeyValidPix(iconPath(QStringLiteral("key"))),
       mKeyUsage(keyUsage)
 {
     if (keyUsage == 0) {
         qCWarning(KLEO_UI_LOG)
                 << "KeySelectionDialog: keyUsage == 0. You want to use AllKeys instead.";
     }
 }
 
 QString ColumnStrategy::title(int col) const
 {
     switch (col) {
     case 0: return i18n("Key ID");
     case 1: return i18n("User ID");
     default: return QString();
     }
 }
 
 int ColumnStrategy::width(int col, const QFontMetrics &fm) const
 {
     if (col == 0) {
         static const char hexchars[] = "0123456789ABCDEF";
         int maxWidth = 0;
         for (unsigned int i = 0; i < 16; ++i) {
             maxWidth = qMax(fm.boundingRect(QLatin1Char(hexchars[i])).width(), maxWidth);
         }
         return 8 * maxWidth + 2 * 16 /* KIconLoader::SizeSmall */;
     }
     return Kleo::KeyListView::ColumnStrategy::width(col, fm);
 }
 
 QString ColumnStrategy::text(const GpgME::Key &key, int col) const
 {
     switch (col) {
     case 0: {
         if (key.shortKeyID()) {
             return QString::fromUtf8(key.shortKeyID());
         } else {
             return xi18n("<placeholder>unknown</placeholder>");
         }
     }
     case 1: {
         const char *uid = key.userID(0).id();
         if (key.protocol() == GpgME::OpenPGP) {
             return uid && *uid ? QString::fromUtf8(uid) : QString();
         } else { // CMS
             return Kleo::DN(uid).prettyDN();
         }
     }
     default: return QString();
     }
 }
 
 QString ColumnStrategy::toolTip(const GpgME::Key &key, int) const
 {
     const char *uid = key.userID(0).id();
     const char *fpr = key.primaryFingerprint();
     const char *issuer = key.issuerName();
     const GpgME::Subkey subkey = key.subkey(0);
     const QString expiry = subkey.neverExpires() ? i18n("never") : time_t2string(subkey.expirationTime());
     const QString creation = time_t2string(subkey.creationTime());
     QString keyStatusString;
     if (!checkKeyUsage(key, mKeyUsage, &keyStatusString)) {
         // Show the status in bold if there is a problem
         keyStatusString = QLatin1String("<b>") % keyStatusString % QLatin1String("</b>");
     }
 
     QString html = QStringLiteral("<qt><p style=\"style='white-space:pre'\">");
     if (key.protocol() == GpgME::OpenPGP) {
         html += i18n("OpenPGP key for <b>%1</b>", uid ? QString::fromUtf8(uid) : i18n("unknown"));
     } else {
         html += i18n("S/MIME key for <b>%1</b>", uid ? Kleo::DN(uid).prettyDN() : i18n("unknown"));
     }
     html += QStringLiteral("</p><table>");
 
     const auto addRow = [&html](const QString &name, const QString &value) {
         html += QStringLiteral("<tr><td align=\"right\"><b>%1: </b></td><td>%2</td></tr>").arg(name, value);
     };
     addRow(i18nc("Key creation date", "Created"), creation);
     addRow(i18nc("Key Expiration date", "Expiry"), expiry);
     addRow(i18nc("Key fingerprint", "Fingerprint"), fpr ? QString::fromLatin1(fpr) : i18n("unknown"));
     if (key.protocol() != GpgME::OpenPGP) {
         addRow(i18nc("Key issuer", "Issuer"), issuer ? Kleo::DN(issuer).prettyDN() : i18n("unknown"));
     }
     addRow(i18nc("Key status", "Status"), keyStatusString);
     html += QStringLiteral("</table></qt>");
 
     return html;
 }
 
 QIcon ColumnStrategy::icon(const GpgME::Key &key, int col) const
 {
     if (col != 0) {
         return QIcon();
     }
     // this key did not undergo a validating keylisting yet:
     if (!(key.keyListMode() & GpgME::Validate)) {
         return mKeyUnknownPix;
     }
 
     if (!checkKeyUsage(key, mKeyUsage)) {
         return mKeyBadPix;
     }
 
     if (key.protocol() == GpgME::CMS) {
         return mKeyGoodPix;
     }
 
     switch (key.userID(0).validity()) {
     default:
     case GpgME::UserID::Unknown:
     case GpgME::UserID::Undefined:
         return mKeyUnknownPix;
     case GpgME::UserID::Never:
         return mKeyValidPix;
     case GpgME::UserID::Marginal:
     case GpgME::UserID::Full:
     case GpgME::UserID::Ultimate:
         return mKeyGoodPix;
     }
 }
 
 }
 
 static const int sCheckSelectionDelay = 250;
 
 Kleo::KeySelectionDialog::KeySelectionDialog(QWidget *parent, Options options)
     : QDialog(parent),
       mOpenPGPBackend(QGpgME::openpgp()),
       mSMIMEBackend(QGpgME::smime()),
       mKeyUsage(AllKeys)
 {
         qCDebug(KLEO_UI_LOG) << "mTruncated:" << mTruncated << "mSavedOffsetY:" << mSavedOffsetY;
     setUpUI(options, QString());
 }
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const std::vector<GpgME::Key> &selectedKeys,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mSelectedKeys(selectedKeys),
       mKeyUsage(keyUsage)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, QString());
 }
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const QString &initialQuery,
         const std::vector<GpgME::Key> &selectedKeys,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mSelectedKeys(selectedKeys),
       mKeyUsage(keyUsage),
       mSearchText(initialQuery),
       mInitialQuery(initialQuery)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const QString &initialQuery,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mKeyUsage(keyUsage),
       mSearchText(initialQuery),
       mInitialQuery(initialQuery)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 void Kleo::KeySelectionDialog::setUpUI(Options options, const QString &initialQuery)
 {
     auto mainLayout = new QVBoxLayout(this);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     mOkButton = buttonBox->button(QDialogButtonBox::Ok);
     mOkButton->setDefault(true);
     mOkButton->setShortcut(Qt::CTRL | Qt::Key_Return);
 
     mCheckSelectionTimer = new QTimer(this);
     mStartSearchTimer = new QTimer(this);
 
     QFrame *page = new QFrame(this);
     mainLayout->addWidget(page);
     mainLayout->addWidget(buttonBox);
 
     mTopLayout = new QVBoxLayout(page);
     mTopLayout->setContentsMargins(0, 0, 0, 0);
 
     mTextLabel = new QLabel(page);
     mTextLabel->setWordWrap(true);
 
     // Setting the size policy is necessary as a workaround for https://issues.kolab.org/issue4429
     // and http://bugreports.qt.nokia.com/browse/QTBUG-8740
     mTextLabel->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
     connect(mTextLabel, &QLabel::linkActivated, this, &KeySelectionDialog::slotStartCertificateManager);
     mTopLayout->addWidget(mTextLabel);
     mTextLabel->hide();
 
     QPushButton *const searchExternalPB =
         new QPushButton(i18n("Search for &External Certificates"), page);
     mTopLayout->addWidget(searchExternalPB, 0, Qt::AlignLeft);
     connect(searchExternalPB, &QAbstractButton::clicked, this, &KeySelectionDialog::slotStartSearchForExternalCertificates);
     if (initialQuery.isEmpty()) {
         searchExternalPB->hide();
     }
 
     auto hlay = new QHBoxLayout();
     mTopLayout->addLayout(hlay);
 
     auto le = new QLineEdit(page);
     le->setClearButtonEnabled(true);
     le->setText(initialQuery);
 
     QLabel *lbSearchFor =  new QLabel(i18n("&Search for:"), page);
     lbSearchFor->setBuddy(le);
 
     hlay->addWidget(lbSearchFor);
     hlay->addWidget(le, 1);
     le->setFocus();
 
     connect(le, &QLineEdit::textChanged,
             this, [this] (const QString &s) { slotSearch(s); });
     connect(mStartSearchTimer, &QTimer::timeout, this, &KeySelectionDialog::slotFilter);
 
     mKeyListView = new KeyListView(new ColumnStrategy(mKeyUsage), nullptr, page);
     mKeyListView->setObjectName(QStringLiteral("mKeyListView"));
     mKeyListView->header()->stretchLastSection();
     mKeyListView->setRootIsDecorated(true);
     mKeyListView->setSortingEnabled(true);
     mKeyListView->header()->setSortIndicatorShown(true);
     mKeyListView->header()->setSortIndicator(1, Qt::AscendingOrder);   // sort by User ID
     if (options & ExtendedSelection) {
         mKeyListView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     }
     mTopLayout->addWidget(mKeyListView, 10);
 
     if (options & RememberChoice) {
         mRememberCB = new QCheckBox(i18n("&Remember choice"), page);
         mTopLayout->addWidget(mRememberCB);
         mRememberCB->setWhatsThis(
             i18n("<qt><p>If you check this box your choice will "
                  "be stored and you will not be asked again."
                  "</p></qt>"));
     }
 
     connect(mCheckSelectionTimer, &QTimer::timeout,
             this, [this] () { slotCheckSelection(); });
     connectSignals();
 
     connect(mKeyListView, &Kleo::KeyListView::doubleClicked, this, &KeySelectionDialog::slotTryOk);
     connect(mKeyListView, &KeyListView::contextMenu, this, &KeySelectionDialog::slotRMB);
 
     if (options & RereadKeys) {
         QPushButton *button = new QPushButton(i18n("&Reread Keys"));
         buttonBox->addButton(button, QDialogButtonBox::ActionRole);
         connect(button, &QPushButton::clicked, this, &KeySelectionDialog::slotRereadKeys);
     }
     if (options & ExternalCertificateManager) {
         QPushButton *button = new QPushButton(i18n("&Start Certificate Manager"));
         buttonBox->addButton(button, QDialogButtonBox::ActionRole);
         connect(button, &QPushButton::clicked, this, [this]() { slotStartCertificateManager(); });
     }
     connect(mOkButton, &QPushButton::clicked, this, &KeySelectionDialog::slotOk);
     connect(buttonBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &KeySelectionDialog::slotCancel);
 
     mTopLayout->activate();
 
     if (qApp) {
         QSize dialogSize(sizeHint());
         KConfigGroup dialogConfig(KSharedConfig::openStateConfig(), "Key Selection Dialog");
         dialogSize = dialogConfig.readEntry("Dialog size", dialogSize);
         const QByteArray headerState = dialogConfig.readEntry("header", QByteArray());
         if (!headerState.isEmpty()) {
             mKeyListView->header()->restoreState(headerState);
         }
         resize(dialogSize);
     }
 }
 
 void Kleo::KeySelectionDialog::init(bool rememberChoice, bool extendedSelection, const QString &text, const QString &initialQuery)
 {
     Options options = { RereadKeys, ExternalCertificateManager };
     options.setFlag(ExtendedSelection, extendedSelection);
     options.setFlag(RememberChoice, rememberChoice);
 
     setUpUI(options, initialQuery);
     setText(text);
 
     if (mKeyUsage & OpenPGPKeys) {
         mOpenPGPBackend = QGpgME::openpgp();
     }
     if (mKeyUsage & SMIMEKeys) {
         mSMIMEBackend = QGpgME::smime();
     }
 
     slotRereadKeys();
 }
 
 Kleo::KeySelectionDialog::~KeySelectionDialog()
 {
     disconnectSignals();
     KConfigGroup dialogConfig(KSharedConfig::openStateConfig(), "Key Selection Dialog");
     dialogConfig.writeEntry("Dialog size", size());
     dialogConfig.writeEntry("header", mKeyListView->header()->saveState());
     dialogConfig.sync();
 }
 
 void Kleo::KeySelectionDialog::setText(const QString &text)
 {
     mTextLabel->setText(text);
     mTextLabel->setVisible(!text.isEmpty());
 }
 
 void Kleo::KeySelectionDialog::setKeys(const std::vector<GpgME::Key> &keys)
 {
     for (const GpgME::Key &key : keys) {
         mKeyListView->slotAddKey(key);
     }
 }
 
 void Kleo::KeySelectionDialog::connectSignals()
 {
     if (mKeyListView->isMultiSelection()) {
         connect(mKeyListView, &QTreeWidget::itemSelectionChanged, this, &KeySelectionDialog::slotSelectionChanged);
     } else {
-        connect(mKeyListView, QOverload<KeyListViewItem*>::of(&KeyListView::selectionChanged),
-                this, QOverload<KeyListViewItem*>::of(&KeySelectionDialog::slotCheckSelection));
+        connect(mKeyListView, qOverload<KeyListViewItem*>(&KeyListView::selectionChanged),
+                this, qOverload<KeyListViewItem*>(&KeySelectionDialog::slotCheckSelection));
     }
 }
 
 void Kleo::KeySelectionDialog::disconnectSignals()
 {
     if (mKeyListView->isMultiSelection()) {
         disconnect(mKeyListView, &QTreeWidget::itemSelectionChanged,
                    this, &KeySelectionDialog::slotSelectionChanged);
     } else {
-        disconnect(mKeyListView, QOverload<KeyListViewItem*>::of(&KeyListView::selectionChanged),
-                   this, QOverload<KeyListViewItem*>::of(&KeySelectionDialog::slotCheckSelection));
+        disconnect(mKeyListView, qOverload<KeyListViewItem*>(&KeyListView::selectionChanged),
+                   this, qOverload<KeyListViewItem*>(&KeySelectionDialog::slotCheckSelection));
     }
 }
 
 const GpgME::Key &Kleo::KeySelectionDialog::selectedKey() const
 {
     static const GpgME::Key null = GpgME::Key::null;
     if (mKeyListView->isMultiSelection() || !mKeyListView->selectedItem()) {
         return null;
     }
     return mKeyListView->selectedItem()->key();
 }
 
 QString Kleo::KeySelectionDialog::fingerprint() const
 {
     return QLatin1String(selectedKey().primaryFingerprint());
 }
 
 QStringList Kleo::KeySelectionDialog::fingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (const char *fpr = it->primaryFingerprint()) {
             result.push_back(QLatin1String(fpr));
         }
     }
     return result;
 }
 
 QStringList Kleo::KeySelectionDialog::pgpKeyFingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (it->protocol() == GpgME::OpenPGP) {
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
         }
     }
     return result;
 }
 
 QStringList Kleo::KeySelectionDialog::smimeFingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (it->protocol() == GpgME::CMS) {
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
         }
     }
     return result;
 }
 
 void Kleo::KeySelectionDialog::slotRereadKeys()
 {
     mKeyListView->clear();
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     // FIXME: save current selection
     if (mOpenPGPBackend) {
         startKeyListJobForBackend(mOpenPGPBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
     if (mSMIMEBackend) {
         startKeyListJobForBackend(mSMIMEBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
 
     if (mListJobCount == 0) {
         mKeyListView->setEnabled(true);
         KMessageBox::information(this,
                                  i18n("No backends found for listing keys. "
                                       "Check your installation."),
                                  i18n("Key Listing Failed"));
         connectSignals();
     }
 }
 
 void Kleo::KeySelectionDialog::slotStartCertificateManager(const QString &query)
 {
     QStringList args;
 
     if (!query.isEmpty()) {
         args << QStringLiteral("--search") << query;
     }
     if (!QProcess::startDetached(QStringLiteral("kleopatra"), args)) {
         KMessageBox::error(this,
                            i18n("Could not start certificate manager; "
                                 "please check your installation."),
                            i18n("Certificate Manager Error"));
     } else {
         qCDebug(KLEO_UI_LOG) << "\nslotStartCertManager(): certificate manager started.";
     }
 }
 
 #ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 #define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 static void showKeyListError(QWidget *parent, const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n("<qt><p>An error occurred while fetching "
                              "the keys from the backend:</p>"
                              "<p><b>%1</b></p></qt>",
                              QString::fromLocal8Bit(err.asString()));
 
     KMessageBox::error(parent, msg, i18n("Key Listing Failed"));
 }
 #endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 
 namespace
 {
 struct ExtractFingerprint {
     QString operator()(const GpgME::Key &key)
     {
         return QLatin1String(key.primaryFingerprint());
     }
 };
 }
 
 void Kleo::KeySelectionDialog::startKeyListJobForBackend(const QGpgME::Protocol *backend, const std::vector<GpgME::Key> &keys, bool validate)
 {
     Q_ASSERT(backend);
     QGpgME::KeyListJob *job = backend->keyListJob(false, false, validate);    // local, w/o sigs, validation as given
     if (!job) {
         return;
     }
 
     connect(job, &QGpgME::KeyListJob::result, this, &KeySelectionDialog::slotKeyListResult);
     if (validate) {
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotRefreshKey);
     } else {
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotAddKey);
     }
 
     QStringList fprs;
     std::transform(keys.begin(), keys.end(), std::back_inserter(fprs), ExtractFingerprint());
     const GpgME::Error err = job->start(fprs, mKeyUsage & SecretKeys && !(mKeyUsage & PublicKeys));
 
     if (err) {
         return showKeyListError(this, err);
     }
 
 #ifndef LIBKLEO_NO_PROGRESSDIALOG
     // FIXME: create a MultiProgressDialog:
     (void)new ProgressDialog(job, validate ? i18n("Checking selected keys...") : i18n("Fetching keys..."), this);
 #endif
     ++mListJobCount;
 }
 
 static void selectKeys(Kleo::KeyListView *klv, const std::vector<GpgME::Key> &selectedKeys)
 {
     klv->clearSelection();
     if (selectedKeys.empty()) {
         return;
     }
     for (auto it = selectedKeys.begin(); it != selectedKeys.end(); ++it) {
         if (Kleo::KeyListViewItem *item = klv->itemByFingerprint(it->primaryFingerprint())) {
             item->setSelected(true);
         }
     }
 }
 
 void Kleo::KeySelectionDialog::slotKeyListResult(const GpgME::KeyListResult &res)
 {
     if (res.error()) {
         showKeyListError(this, res.error());
     } else if (res.isTruncated()) {
         ++mTruncated;
     }
 
     if (--mListJobCount > 0) {
         return;    // not yet finished...
     }
 
     if (mTruncated > 0) {
         KMessageBox::information(this,
                                  i18np("<qt>One backend returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        "<qt>%1 backends returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        mTruncated),
                                  i18n("Key List Result"));
     }
 
     mKeyListView->flushKeys();
 
     mKeyListView->setEnabled(true);
     mListJobCount = mTruncated = 0;
     mKeysToCheck.clear();
 
     selectKeys(mKeyListView, mSelectedKeys);
 
     slotFilter();
 
     connectSignals();
 
     slotSelectionChanged();
 
     // restore the saved position of the contents
     mKeyListView->verticalScrollBar()->setValue(mSavedOffsetY); mSavedOffsetY = 0;
 }
 
 void Kleo::KeySelectionDialog::slotSelectionChanged()
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotSelectionChanged()";
 
     // (re)start the check selection timer. Checking the selection is delayed
     // because else drag-selection doesn't work very good (checking key trust
     // is slow).
     mCheckSelectionTimer->start(sCheckSelectionDelay);
 }
 
 namespace
 {
 struct AlreadyChecked {
     bool operator()(const GpgME::Key &key) const
     {
         return key.keyListMode() & GpgME::Validate;
     }
 };
 }
 
 void Kleo::KeySelectionDialog::slotCheckSelection(KeyListViewItem *item)
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotCheckSelection()";
 
     mCheckSelectionTimer->stop();
 
     mSelectedKeys.clear();
 
     if (!mKeyListView->isMultiSelection()) {
         if (item) {
             mSelectedKeys.push_back(item->key());
         }
     }
 
     for (KeyListViewItem *it = mKeyListView->firstChild(); it; it = it->nextSibling()) {
         if (it->isSelected()) {
             mSelectedKeys.push_back(it->key());
         }
     }
 
     mKeysToCheck.clear();
     std::remove_copy_if(mSelectedKeys.begin(), mSelectedKeys.end(),
                         std::back_inserter(mKeysToCheck),
                         AlreadyChecked());
     if (mKeysToCheck.empty()) {
         mOkButton->setEnabled(!mSelectedKeys.empty() &&
                               checkKeyUsage(mSelectedKeys, mKeyUsage));
         return;
     }
 
     // performed all fast checks - now for validating key listing:
     startValidatingKeyListing();
 }
 
 void Kleo::KeySelectionDialog::startValidatingKeyListing()
 {
     if (mKeysToCheck.empty()) {
         return;
     }
 
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     std::vector<GpgME::Key> smime;
     std::vector<GpgME::Key> openpgp;
     for (std::vector<GpgME::Key>::const_iterator it = mKeysToCheck.begin(); it != mKeysToCheck.end(); ++it) {
         if (it->protocol() == GpgME::OpenPGP) {
             openpgp.push_back(*it);
         } else {
             smime.push_back(*it);
         }
     }
 
     if (!openpgp.empty()) {
         Q_ASSERT(mOpenPGPBackend);
         startKeyListJobForBackend(mOpenPGPBackend, openpgp, true /*validate*/);
     }
     if (!smime.empty()) {
         Q_ASSERT(mSMIMEBackend);
         startKeyListJobForBackend(mSMIMEBackend, smime, true /*validate*/);
     }
 
     Q_ASSERT(mListJobCount > 0);
 }
 
 bool Kleo::KeySelectionDialog::rememberSelection() const
 {
     return mRememberCB && mRememberCB->isChecked();
 }
 
 void Kleo::KeySelectionDialog::slotRMB(Kleo::KeyListViewItem *item, const QPoint &p)
 {
     if (!item) {
         return;
     }
 
     mCurrentContextMenuItem = item;
 
     QMenu menu;
     menu.addAction(i18n("Recheck Key"), this, &KeySelectionDialog::slotRecheckKey);
     menu.exec(p);
 }
 
 void Kleo::KeySelectionDialog::slotRecheckKey()
 {
     if (!mCurrentContextMenuItem || mCurrentContextMenuItem->key().isNull()) {
         return;
     }
 
     mKeysToCheck.clear();
     mKeysToCheck.push_back(mCurrentContextMenuItem->key());
 }
 
 void Kleo::KeySelectionDialog::slotTryOk()
 {
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         slotOk();
     }
 }
 
 void Kleo::KeySelectionDialog::slotOk()
 {
     if (mCheckSelectionTimer->isActive()) {
         slotCheckSelection();
     }
 #if 0 //Laurent I don't understand why we returns here.
     // button could be disabled again after checking the selected key1
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         return;
     }
 #endif
     mStartSearchTimer->stop();
     accept();
 }
 
 void Kleo::KeySelectionDialog::slotCancel()
 {
     mCheckSelectionTimer->stop();
     mStartSearchTimer->stop();
     reject();
 }
 
 void Kleo::KeySelectionDialog::slotSearch(const QString &text)
 {
     mSearchText = text.trimmed().toUpper();
     slotSearch();
 }
 
 void Kleo::KeySelectionDialog::slotSearch()
 {
     mStartSearchTimer->setSingleShot(true);
     mStartSearchTimer->start(sCheckSelectionDelay);
 }
 
 void Kleo::KeySelectionDialog::slotFilter()
 {
     if (mSearchText.isEmpty()) {
         showAllItems();
         return;
     }
 
     // OK, so we need to filter:
     QRegExp keyIdRegExp(QLatin1String("(?:0x)?[A-F0-9]{1,8}"), Qt::CaseInsensitive);
     if (keyIdRegExp.exactMatch(mSearchText)) {
         if (mSearchText.startsWith(QLatin1String("0X")))
             // search for keyID only:
         {
             filterByKeyID(mSearchText.mid(2));
         } else
             // search for UID and keyID:
         {
             filterByKeyIDOrUID(mSearchText);
         }
     } else {
         // search in UID:
         filterByUID(mSearchText);
     }
 }
 
 void Kleo::KeySelectionDialog::filterByKeyID(const QString &keyID)
 {
     Q_ASSERT(keyID.length() <= 8);
     Q_ASSERT(!keyID.isEmpty());   // regexp in slotFilter should prevent these
     if (keyID.isEmpty()) {
         showAllItems();
     } else {
         for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
             item->setHidden(!item->text(0).toUpper().startsWith(keyID));
         }
     }
 }
 
 static bool anyUIDMatches(const Kleo::KeyListViewItem *item, QRegExp &rx)
 {
     if (!item) {
         return false;
     }
 
     const std::vector<GpgME::UserID> uids = item->key().userIDs();
     for (auto it = uids.begin(); it != uids.end(); ++it) {
         if (it->id() && rx.indexIn(QString::fromUtf8(it->id())) >= 0) {
             return true;
         }
     }
     return false;
 }
 
 void Kleo::KeySelectionDialog::filterByKeyIDOrUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!item->text(0).toUpper().startsWith(str) && !anyUIDMatches(item, rx));
     }
 
 }
 
 void Kleo::KeySelectionDialog::filterByUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!anyUIDMatches(item, rx));
     }
 }
 
 void Kleo::KeySelectionDialog::showAllItems()
 {
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(false);
     }
 }
 
diff --git a/src/ui/newkeyapprovaldialog.cpp b/src/ui/newkeyapprovaldialog.cpp
index 3d4463854..cd9225d42 100644
--- a/src/ui/newkeyapprovaldialog.cpp
+++ b/src/ui/newkeyapprovaldialog.cpp
@@ -1,913 +1,913 @@
 /*  -*- c++ -*-
     newkeyapprovaldialog.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2018 Intevation GmbH
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "newkeyapprovaldialog.h"
 
 #include "keyselectioncombo.h"
 #include "progressdialog.h"
 #include "kleo/defaultkeyfilter.h"
 #include "utils/formatting.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QApplication>
 #include <QButtonGroup>
 #include <QCheckBox>
 #include <QDesktopWidget>
 #include <QDialogButtonBox>
 #include <QGroupBox>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QMap>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QScrollArea>
 #include <QToolTip>
 #include <QVBoxLayout>
 
 #include <QGpgME/DefaultKeyGenerationJob>
 #include <QGpgME/Job>
 
 #include <gpgme++/keygenerationresult.h>
 #include <gpgme++/key.h>
 
 #include "libkleo_debug.h"
 
 using namespace Kleo;
 using namespace GpgME;
 
 QDebug operator<<(QDebug debug, const GpgME::Key &key)
 {
     if (key.isNull()) {
         debug << "Null";
     } else {
         debug << Formatting::summaryLine(key);
     }
     return debug.maybeSpace();
 }
 
 namespace {
 class EncryptFilter: public DefaultKeyFilter
 {
 public:
     EncryptFilter() : DefaultKeyFilter()
     {
         setCanEncrypt(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_encryptFilter = std::shared_ptr<KeyFilter>(new EncryptFilter);
 
 class OpenPGPFilter: public DefaultKeyFilter
 {
 public:
     OpenPGPFilter() : DefaultKeyFilter()
     {
         setIsOpenPGP(DefaultKeyFilter::Set);
         setCanEncrypt(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_pgpEncryptFilter = std::shared_ptr<KeyFilter> (new OpenPGPFilter);
 
 class OpenPGPSignFilter: public DefaultKeyFilter
 {
 public:
     OpenPGPSignFilter() : DefaultKeyFilter()
     {
         /* Also list unusable keys to make it transparent why they are unusable */
         setDisabled(DefaultKeyFilter::NotSet);
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanSign(DefaultKeyFilter::Set);
         setHasSecret(DefaultKeyFilter::Set);
         setIsOpenPGP(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_pgpSignFilter = std::shared_ptr<KeyFilter> (new OpenPGPSignFilter);
 
 class SMIMEFilter: public DefaultKeyFilter
 {
 public:
     SMIMEFilter(): DefaultKeyFilter()
     {
         setIsOpenPGP(DefaultKeyFilter::NotSet);
         setCanEncrypt(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_smimeEncryptFilter = std::shared_ptr<KeyFilter> (new SMIMEFilter);
 
 class SMIMESignFilter: public DefaultKeyFilter
 {
 public:
     SMIMESignFilter(): DefaultKeyFilter()
     {
         setDisabled(DefaultKeyFilter::NotSet);
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanSign(DefaultKeyFilter::Set);
         setIsOpenPGP(DefaultKeyFilter::NotSet);
         setHasSecret(DefaultKeyFilter::Set);
     }
 };
 static std::shared_ptr<KeyFilter> s_smimeSignFilter = std::shared_ptr<KeyFilter> (new SMIMESignFilter);
 
 /* Some decoration and a button to remove the filter for a keyselectioncombo */
 class ComboWidget: public QWidget
 {
     Q_OBJECT
 public:
     explicit ComboWidget(KeySelectionCombo *combo):
         mCombo(combo),
         mFilterBtn(new QPushButton)
     {
         auto hLay = new QHBoxLayout(this);
         auto infoBtn = new QPushButton;
         infoBtn->setIcon(QIcon::fromTheme(QStringLiteral("help-contextual")));
         infoBtn->setIconSize(QSize(22,22));
         infoBtn->setFlat(true);
         hLay->addWidget(infoBtn);
         hLay->addWidget(combo, 1);
         hLay->addWidget(mFilterBtn, 0);
 
         connect(infoBtn, &QPushButton::clicked, this, [this, infoBtn] () {
             QToolTip::showText(infoBtn->mapToGlobal(QPoint()) + QPoint(infoBtn->width(), 0),
                     mCombo->currentData(Qt::ToolTipRole).toString(), infoBtn, QRect(), 30000);
         });
 
         // FIXME: This is ugly to enforce but otherwise the
         // icon is broken.
         combo->setMinimumHeight(22);
         mFilterBtn->setMinimumHeight(23);
 
         updateFilterButton();
 
         connect(mFilterBtn, &QPushButton::clicked, this, [this] () {
             const QString curFilter = mCombo->idFilter();
             if (curFilter.isEmpty()) {
                 setIdFilter(mLastIdFilter);
                 mLastIdFilter = QString();
             } else {
                 setIdFilter(QString());
                 mLastIdFilter = curFilter;
             }
         });
     }
 
     void setIdFilter(const QString &id)
     {
         mCombo->setIdFilter(id);
         updateFilterButton();
     }
 
     void updateFilterButton()
     {
         if (mCombo->idFilter().isEmpty()) {
             mFilterBtn->setIcon(QIcon::fromTheme(QStringLiteral("kt-add-filters")));
             mFilterBtn->setToolTip(i18n("Show keys matching the email address"));
         } else {
             mFilterBtn->setIcon(QIcon::fromTheme(QStringLiteral("kt-remove-filters")));
             mFilterBtn->setToolTip(i18n("Show all keys"));
         }
     }
 
     KeySelectionCombo *combo()
     {
         return mCombo;
     }
 
     GpgME::Protocol fixedProtocol() const
     {
         return mFixedProtocol;
     }
 
     void setFixedProtocol(GpgME::Protocol proto)
     {
         mFixedProtocol = proto;
     }
 
 private:
     KeySelectionCombo *mCombo;
     QPushButton *mFilterBtn;
     QString mLastIdFilter;
     GpgME::Protocol mFixedProtocol = GpgME::UnknownProtocol;
 };
 
 static enum GpgME::UserID::Validity keyValidity(const GpgME::Key &key)
 {
     enum GpgME::UserID::Validity validity = GpgME::UserID::Validity::Unknown;
 
     for (const auto &uid: key.userIDs()) {
         if (validity == GpgME::UserID::Validity::Unknown
             || validity > uid.validity()) {
             validity = uid.validity();
         }
     }
 
     return validity;
 }
 
 static bool key_has_addr(const GpgME::Key &key, const QString &addr)
 {
     for (const auto &uid: key.userIDs()) {
         if (QString::fromStdString(uid.addrSpec()).toLower() == addr.toLower()) {
             return true;
         }
     }
     return false;
 }
 
 bool anyKeyHasProtocol(const std::vector<Key> &keys, Protocol protocol)
 {
     return std::any_of(std::begin(keys), std::end(keys), [protocol] (const auto &key) { return key.protocol() == protocol; });
 }
 
 Key findfirstKeyOfType(const std::vector<Key> &keys, Protocol protocol)
 {
     const auto it = std::find_if(std::begin(keys), std::end(keys), [protocol] (const auto &key) { return key.protocol() == protocol; });
     return it != std::end(keys) ? *it : Key();
 }
 
 } // namespace
 
 class NewKeyApprovalDialog::Private
 {
 private:
     enum Action {
         Unset,
         GenerateKey,
         IgnoreKey,
     };
 public:
     enum {
         OpenPGPButtonId = 1,
         SMIMEButtonId = 2
     };
 
     Private(NewKeyApprovalDialog *qq,
             bool encrypt,
             bool sign,
             GpgME::Protocol forcedProtocol,
             GpgME::Protocol presetProtocol,
             const QString &sender,
             bool allowMixed)
         : mForcedProtocol{forcedProtocol}
         , mSender{sender}
         , mSign{sign}
         , mEncrypt{encrypt}
         , mAllowMixed{allowMixed}
         , q{qq}
     {
         Q_ASSERT(forcedProtocol == GpgME::UnknownProtocol || presetProtocol == GpgME::UnknownProtocol || presetProtocol == forcedProtocol);
         Q_ASSERT(!allowMixed || (allowMixed && forcedProtocol == GpgME::UnknownProtocol));
         Q_ASSERT(!(!allowMixed && presetProtocol == GpgME::UnknownProtocol));
 
         // We do the translation here to avoid having the same string multiple times.
         mGenerateTooltip = i18nc("@info:tooltip for a 'Generate new key pair' action "
                                  "in a combobox when a user does not yet have an OpenPGP or S/MIME key.",
                                  "Generate a new key using your E-Mail address.<br/><br/>"
                                  "The key is necessary to decrypt and sign E-Mails. "
                                  "You will be asked for a passphrase to protect this key and the protected key "
                                  "will be stored in your home directory.");
         mMainLay = new QVBoxLayout;
 
         QDialogButtonBox *btnBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
         mOkButton = btnBox->button(QDialogButtonBox::Ok);
 #ifndef NDEBUG
         mOkButton->setObjectName(QStringLiteral("ok button"));
 #endif
         QObject::connect (btnBox, &QDialogButtonBox::accepted, q, [this] () {
                 accepted();
             });
         QObject::connect (btnBox, &QDialogButtonBox::rejected, q, &QDialog::reject);
 
         mScrollArea = new QScrollArea;
         mScrollArea->setWidget(new QWidget);
         mScrollLayout = new QVBoxLayout;
         mScrollArea->widget()->setLayout(mScrollLayout);
         mScrollArea->setWidgetResizable(true);
         mScrollArea->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow);
         mScrollArea->setFrameStyle(QFrame::NoFrame);
         mScrollLayout->setContentsMargins(0, 0, 0, 0);
 
         q->setWindowTitle(i18nc("@title:window", "Security approval"));
 
         auto fmtLayout = new QHBoxLayout;
         mFormatBtns = new QButtonGroup(qq);
         QAbstractButton *pgpBtn;
         QAbstractButton *smimeBtn;
         if (mAllowMixed) {
             pgpBtn = new QCheckBox(i18n("OpenPGP"));
             smimeBtn = new QCheckBox(i18n("S/MIME"));
         } else {
             pgpBtn = new QRadioButton(i18n("OpenPGP"));
             smimeBtn = new QRadioButton(i18n("S/MIME"));
         }
 #ifndef NDEBUG
         pgpBtn->setObjectName(QStringLiteral("openpgp button"));
         smimeBtn->setObjectName(QStringLiteral("smime button"));
 #endif
         mFormatBtns->addButton(pgpBtn, OpenPGPButtonId);
         mFormatBtns->addButton(smimeBtn, SMIMEButtonId);
         mFormatBtns->setExclusive(!mAllowMixed);
 
         fmtLayout->addStretch(-1);
         fmtLayout->addWidget(pgpBtn);
         fmtLayout->addWidget(smimeBtn);
         mMainLay->addLayout(fmtLayout);
 
         if (mForcedProtocol != GpgME::UnknownProtocol) {
             pgpBtn->setChecked(mForcedProtocol == GpgME::OpenPGP);
             smimeBtn->setChecked(mForcedProtocol == GpgME::CMS);
             pgpBtn->setVisible(false);
             smimeBtn->setVisible(false);
         } else {
             pgpBtn->setChecked(presetProtocol == GpgME::OpenPGP || presetProtocol == GpgME::UnknownProtocol);
             smimeBtn->setChecked(presetProtocol == GpgME::CMS || presetProtocol == GpgME::UnknownProtocol);
         }
 
         QObject::connect(mFormatBtns, &QButtonGroup::idClicked,
                          q, [this](int buttonId) {
                              // ensure that at least one protocol button is checked
                              if (mAllowMixed
                                     && !mFormatBtns->button(OpenPGPButtonId)->isChecked()
                                     && !mFormatBtns->button(SMIMEButtonId)->isChecked()) {
                                  mFormatBtns->button(buttonId == OpenPGPButtonId ? SMIMEButtonId : OpenPGPButtonId)->setChecked(true);
                              }
                              updateWidgets();
                         });
 
         mMainLay->addWidget(mScrollArea);
 
         mComplianceLbl = new QLabel;
         mComplianceLbl->setVisible(false);
 #ifndef NDEBUG
         mComplianceLbl->setObjectName(QStringLiteral("compliance label"));
 #endif
 
         auto btnLayout = new QHBoxLayout;
         btnLayout->addWidget(mComplianceLbl);
         btnLayout->addWidget(btnBox);
         mMainLay->addLayout(btnLayout);
 
         q->setLayout(mMainLay);
     }
 
     ~Private() = default;
 
     Protocol currentProtocol()
     {
         const bool openPGPButtonChecked = mFormatBtns->button(OpenPGPButtonId)->isChecked();
         const bool smimeButtonChecked = mFormatBtns->button(SMIMEButtonId)->isChecked();
         if (mAllowMixed) {
             if (openPGPButtonChecked && !smimeButtonChecked) {
                 return OpenPGP;
             }
             if (!openPGPButtonChecked && smimeButtonChecked) {
                 return CMS;
             }
         } else if (openPGPButtonChecked) {
             return OpenPGP;
         } else if (smimeButtonChecked) {
             return CMS;
         }
         return UnknownProtocol;
     }
 
     auto findVisibleKeySelectionComboWithGenerateKey()
     {
         const auto it = std::find_if(std::begin(mAllCombos), std::end(mAllCombos),
                                      [] (auto combo) {
                                          return combo->isVisible()
                                              && combo->currentData(Qt::UserRole).toInt() == GenerateKey;
                                      });
         return it != std::end(mAllCombos) ? *it : nullptr;
     }
 
     void generateKey(KeySelectionCombo *combo)
     {
         const auto &addr = combo->property("address").toString();
         auto job = new QGpgME::DefaultKeyGenerationJob(q);
         auto progress = new Kleo::ProgressDialog(job, i18n("Generating key for '%1'...", addr) + QStringLiteral("\n\n") +
                                                  i18n("This can take several minutes."), q);
         progress->setWindowFlags(progress->windowFlags() & ~Qt::WindowContextHelpButtonHint);
         progress->setWindowTitle(i18nc("@title:window", "Key generation"));
         progress->setModal(true);
         progress->setAutoClose(true);
         progress->setMinimumDuration(0);
         progress->setValue(0);
 
         mRunningJobs << job;
         connect (job, &QGpgME::DefaultKeyGenerationJob::result, q,
             [this, job, combo] (const GpgME::KeyGenerationResult &result) {
                 handleKeyGenResult(result, job, combo);
             });
         job->start(addr, QString());
         return;
     }
 
     void handleKeyGenResult(const GpgME::KeyGenerationResult &result, QGpgME::Job *job, KeySelectionCombo *combo)
     {
         mLastError = result.error();
         if (!mLastError || mLastError.isCanceled()) {
             combo->setDefaultKey(QString::fromLatin1(result.fingerprint()), GpgME::OpenPGP);
             connect (combo, &KeySelectionCombo::keyListingFinished, q, [this, job] () {
                     mRunningJobs.removeAll(job);
                 });
             combo->refreshKeys();
         } else {
             mRunningJobs.removeAll(job);
         }
     }
 
     void checkAccepted()
     {
         if (mLastError || mLastError.isCanceled()) {
             KMessageBox::error(q, QString::fromLocal8Bit(mLastError.asString()), i18n("Operation Failed"));
             mRunningJobs.clear();
             return;
         }
 
         if (!mRunningJobs.empty()) {
             return;
         }
 
         /* Save the keys */
         mAcceptedResult.protocol = currentProtocol();
         for (const auto combo: std::as_const(mEncCombos)) {
             const auto addr = combo->property("address").toString();
             const auto key = combo->currentKey();
             if (!combo->isVisible() || key.isNull()) {
                 continue;
             }
             mAcceptedResult.encryptionKeys[addr].push_back(key);
         }
         for (const auto combo: std::as_const(mSigningCombos)) {
             const auto key = combo->currentKey();
             if (!combo->isVisible() || key.isNull()) {
                 continue;
             }
             mAcceptedResult.signingKeys.push_back(key);
         }
 
         q->accept();
     }
 
     void accepted()
     {
         // We can assume everything was validly resolved, otherwise
         // the OK button would have been disabled.
         // Handle custom items now.
         if (auto combo = findVisibleKeySelectionComboWithGenerateKey()) {
             generateKey(combo);
             return;
         }
         checkAccepted();
     }
 
     auto encryptionKeyFilter(Protocol protocol)
     {
         switch (protocol) {
         case OpenPGP:
             return s_pgpEncryptFilter;
         case CMS:
             return s_smimeEncryptFilter;
         default:
             return s_encryptFilter;
         }
     }
 
     void updateWidgets()
     {
         const Protocol protocol = currentProtocol();
         const auto encryptionFilter = encryptionKeyFilter(protocol);
 
         for (auto combo: std::as_const(mSigningCombos)) {
             auto widget = qobject_cast<ComboWidget *>(combo->parentWidget());
             if (!widget) {
                 qCDebug(LIBKLEO_LOG) << "Failed to find signature combo widget";
                 continue;
             }
             widget->setVisible(protocol == UnknownProtocol || widget->fixedProtocol() == UnknownProtocol || widget->fixedProtocol() == protocol);
         }
         for (auto combo: std::as_const(mEncCombos)) {
             auto widget = qobject_cast<ComboWidget *>(combo->parentWidget());
             if (!widget) {
                 qCDebug(LIBKLEO_LOG) << "Failed to find combo widget";
                 continue;
             }
             widget->setVisible(protocol == UnknownProtocol || widget->fixedProtocol() == UnknownProtocol || widget->fixedProtocol() == protocol);
             if (widget->isVisible() && combo->property("address") != mSender) {
                 combo->setKeyFilter(encryptionFilter);
             }
         }
         // hide the labels indicating the protocol of the sender's keys if only a single protocol is active
         const auto protocolLabels = q->findChildren<QLabel *>(QStringLiteral("protocol label"));
         for (auto label: protocolLabels) {
             label->setVisible(protocol == UnknownProtocol);
         }
     }
 
     auto createProtocolLabel(Protocol protocol)
     {
         auto label = new QLabel(Formatting::displayName(protocol));
         label->setObjectName(QStringLiteral("protocol label"));
         return label;
     }
 
     ComboWidget *createSigningCombo(const QString &addr, const GpgME::Key &key, Protocol protocol = UnknownProtocol)
     {
         Q_ASSERT(!key.isNull() || protocol != UnknownProtocol);
         protocol = !key.isNull() ? key.protocol() : protocol;
 
         auto combo = new KeySelectionCombo();
         auto comboWidget = new ComboWidget(combo);
 #ifndef NDEBUG
         combo->setObjectName(QStringLiteral("signing key"));
 #endif
         if (protocol == GpgME::OpenPGP) {
             combo->setKeyFilter(s_pgpSignFilter);
         } else if (protocol == GpgME::CMS) {
             combo->setKeyFilter(s_smimeSignFilter);
         }
         if (key.isNull() || key_has_addr(key, mSender)) {
             comboWidget->setIdFilter(mSender);
         }
         comboWidget->setFixedProtocol(protocol);
         if (!key.isNull()) {
             combo->setDefaultKey(QString::fromLatin1(key.primaryFingerprint()), protocol);
         }
         if (key.isNull() && protocol == OpenPGP) {
             combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("document-new")),
                                     i18n("Generate a new key pair"), GenerateKey,
                                     mGenerateTooltip);
         }
         combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("emblem-unavailable")),
                 i18n("Don't confirm identity and integrity"), IgnoreKey,
                 i18nc("@info:tooltip for not selecting a key for signing.",
                       "The E-Mail will not be cryptographically signed."));
 
         mSigningCombos << combo;
         mAllCombos << combo;
         combo->setProperty("address", addr);
 
         connect(combo, &KeySelectionCombo::currentKeyChanged, q, [this] () {
             updateOkButton();
         });
-        connect(combo, QOverload<int>::of(&QComboBox::currentIndexChanged), q, [this] () {
+        connect(combo, qOverload<int>(&QComboBox::currentIndexChanged), q, [this] () {
             updateOkButton();
         });
 
         return comboWidget;
     }
 
     void setSigningKeys(const std::vector<GpgME::Key> &preferredKeys, const std::vector<GpgME::Key> &alternativeKeys)
     {
         auto group = new QGroupBox(i18nc("Caption for signing key selection", "Confirm identity '%1' as:", mSender));
         group->setAlignment(Qt::AlignLeft);
         auto sigLayout = new QVBoxLayout(group);
 
         const bool mayNeedOpenPGP = mForcedProtocol != CMS;
         const bool mayNeedCMS = mForcedProtocol != OpenPGP;
         if (mayNeedOpenPGP) {
             if (mAllowMixed) {
                 sigLayout->addWidget(createProtocolLabel(OpenPGP));
             }
             const Key preferredKey = findfirstKeyOfType(preferredKeys, OpenPGP);
             const Key alternativeKey = findfirstKeyOfType(alternativeKeys, OpenPGP);
             if (!preferredKey.isNull()) {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << preferredKey;
                 auto comboWidget = createSigningCombo(mSender, preferredKey);
                 sigLayout->addWidget(comboWidget);
             } else if (!alternativeKey.isNull()) {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << alternativeKey;
                 auto comboWidget = createSigningCombo(mSender, alternativeKey);
                 sigLayout->addWidget(comboWidget);
             } else {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for OpenPGP key";
                 auto comboWidget = createSigningCombo(mSender, Key(), OpenPGP);
                 sigLayout->addWidget(comboWidget);
             }
         }
         if (mayNeedCMS) {
             if (mAllowMixed) {
                 sigLayout->addWidget(createProtocolLabel(CMS));
             }
             const Key preferredKey = findfirstKeyOfType(preferredKeys, CMS);
             const Key alternativeKey = findfirstKeyOfType(alternativeKeys, CMS);
             if (!preferredKey.isNull()) {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << preferredKey;
                 auto comboWidget = createSigningCombo(mSender, preferredKey);
                 sigLayout->addWidget(comboWidget);
             } else if (!alternativeKey.isNull()) {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << alternativeKey;
                 auto comboWidget = createSigningCombo(mSender, alternativeKey);
                 sigLayout->addWidget(comboWidget);
             } else {
                 qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for S/MIME key";
                 auto comboWidget = createSigningCombo(mSender, Key(), CMS);
                 sigLayout->addWidget(comboWidget);
             }
         }
 
         mScrollLayout->addWidget(group);
     }
 
     ComboWidget *createEncryptionCombo(const QString &addr, const GpgME::Key &key, Protocol fixedProtocol)
     {
         auto combo = new KeySelectionCombo(false);
         auto comboWidget = new ComboWidget(combo);
 #ifndef NDEBUG
         combo->setObjectName(QStringLiteral("encryption key"));
 #endif
         if (fixedProtocol == GpgME::OpenPGP) {
             combo->setKeyFilter(s_pgpEncryptFilter);
         } else if (fixedProtocol == GpgME::CMS) {
             combo->setKeyFilter(s_smimeEncryptFilter);
         } else {
             combo->setKeyFilter(s_encryptFilter);
         }
         if (key.isNull() || key_has_addr (key, addr)) {
             comboWidget->setIdFilter(addr);
         }
         comboWidget->setFixedProtocol(fixedProtocol);
         if (!key.isNull()) {
             combo->setDefaultKey(QString::fromLatin1(key.primaryFingerprint()), fixedProtocol);
         }
 
         if (addr == mSender && key.isNull() && fixedProtocol == OpenPGP) {
             combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("document-new")),
                                     i18n("Generate a new key pair"), GenerateKey,
                                     mGenerateTooltip);
         }
 
         combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("emblem-unavailable")),
                 i18n("No key. Recipient will be unable to decrypt."), IgnoreKey,
                 i18nc("@info:tooltip for No Key selected for a specific recipient.",
                         "Do not select a key for this recipient.<br/><br/>"
                         "The recipient will receive the encrypted E-Mail, but it can only "
                         "be decrypted with the other keys selected in this dialog."));
 
         connect(combo, &KeySelectionCombo::currentKeyChanged, q, [this] () {
             updateOkButton();
         });
-        connect(combo, QOverload<int>::of(&QComboBox::currentIndexChanged), q, [this] () {
+        connect(combo, qOverload<int>(&QComboBox::currentIndexChanged), q, [this] () {
             updateOkButton();
         });
 
         mEncCombos << combo;
         mAllCombos << combo;
         combo->setProperty("address", addr);
         return comboWidget;
     }
 
     void addEncryptionAddr(const QString &addr,
                            Protocol preferredKeysProtocol, const std::vector<GpgME::Key> &preferredKeys,
                            Protocol alternativeKeysProtocol, const std::vector<GpgME::Key> &alternativeKeys,
                            QGridLayout *encGrid)
     {
         if (addr == mSender) {
             const bool mayNeedOpenPGP = mForcedProtocol != CMS;
             const bool mayNeedCMS = mForcedProtocol != OpenPGP;
             if (mayNeedOpenPGP) {
                 if (mAllowMixed) {
                     encGrid->addWidget(createProtocolLabel(OpenPGP), encGrid->rowCount(), 0);
                 }
                 for (const auto &key : preferredKeys) {
                     if (key.protocol() == OpenPGP) {
                         qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                         auto comboWidget = createEncryptionCombo(addr, key, OpenPGP);
                         encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                     }
                 }
                 for (const auto &key : alternativeKeys) {
                     if (key.protocol() == OpenPGP) {
                         qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                         auto comboWidget = createEncryptionCombo(addr, key, OpenPGP);
                         encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                     }
                 }
                 if (!anyKeyHasProtocol(preferredKeys, OpenPGP) && !anyKeyHasProtocol(alternativeKeys, OpenPGP)) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for OpenPGP key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), OpenPGP);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
             }
             if (mayNeedCMS) {
                 if (mAllowMixed) {
                     encGrid->addWidget(createProtocolLabel(CMS), encGrid->rowCount(), 0);
                 }
                 for (const auto &key : preferredKeys) {
                     if (key.protocol() == CMS) {
                         qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                         auto comboWidget = createEncryptionCombo(addr, key, CMS);
                         encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                     }
                 }
                 for (const auto &key : alternativeKeys) {
                     if (key.protocol() == CMS) {
                         qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                         auto comboWidget = createEncryptionCombo(addr, key, CMS);
                         encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                     }
                 }
                 if (!anyKeyHasProtocol(preferredKeys, CMS) && !anyKeyHasProtocol(alternativeKeys, CMS)) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for S/MIME key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), CMS);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
             }
         } else {
             encGrid->addWidget(new QLabel(addr), encGrid->rowCount(), 0);
 
             for (const auto &key : preferredKeys) {
                 qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                 auto comboWidget = createEncryptionCombo(addr, key, preferredKeysProtocol);
                 encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
             }
             for (const auto &key : alternativeKeys) {
                 qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
                 auto comboWidget = createEncryptionCombo(addr, key, alternativeKeysProtocol);
                 encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
             }
             if (!mAllowMixed) {
                 if (preferredKeys.empty()) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << Formatting::displayName(preferredKeysProtocol) << "key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), preferredKeysProtocol);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
                 if (alternativeKeys.empty() && alternativeKeysProtocol != UnknownProtocol) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << Formatting::displayName(alternativeKeysProtocol) << "key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), alternativeKeysProtocol);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
             } else {
                 if (preferredKeys.empty() && alternativeKeys.empty()) {
                     qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for any key";
                     auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), UnknownProtocol);
                     encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
                 }
             }
         }
     }
 
     void setEncryptionKeys(Protocol preferredKeysProtocol, const QMap<QString, std::vector<GpgME::Key>> &preferredKeys,
                            Protocol alternativeKeysProtocol, const QMap<QString, std::vector<GpgME::Key>> &alternativeKeys)
     {
         {
             auto group = new QGroupBox(i18nc("Encrypt to self (email address):", "Encrypt to self (%1):", mSender));
 #ifndef NDEBUG
             group->setObjectName(QStringLiteral("encrypt-to-self box"));
 #endif
             group->setAlignment(Qt::AlignLeft);
             auto encGrid = new QGridLayout(group);
 
             addEncryptionAddr(mSender, preferredKeysProtocol, preferredKeys.value(mSender), alternativeKeysProtocol, alternativeKeys.value(mSender), encGrid);
 
             encGrid->setColumnStretch(1, -1);
             mScrollLayout->addWidget(group);
         }
 
         const bool hasOtherRecipients = std::any_of(preferredKeys.keyBegin(), preferredKeys.keyEnd(), [this](const auto &recipient) { return recipient != mSender; });
         if (hasOtherRecipients) {
             auto group = new QGroupBox(i18n("Encrypt to others:"));
 #ifndef NDEBUG
             group->setObjectName(QStringLiteral("encrypt-to-others box"));
 #endif
             group->setAlignment(Qt::AlignLeft);
             auto encGrid = new QGridLayout{group};
 
             for (auto it = std::begin(preferredKeys); it != std::end(preferredKeys); ++it) {
                 const auto &address = it.key();
                 const auto &keys = it.value();
                 if (address != mSender) {
                     addEncryptionAddr(address, preferredKeysProtocol, keys, alternativeKeysProtocol, alternativeKeys.value(address), encGrid);
                 }
             }
 
             encGrid->setColumnStretch(1, -1);
             mScrollLayout->addWidget(group);
         }
 
         mScrollLayout->addStretch(-1);
     }
 
     void updateOkButton()
     {
         static QString origOkText = mOkButton->text();
         const bool isGenerate = bool(findVisibleKeySelectionComboWithGenerateKey());
         const bool allVisibleEncryptionKeysAreIgnored = std::all_of(std::begin(mEncCombos), std::end(mEncCombos),
                                                                     [] (auto combo) {
                                                                         return !combo->isVisible()
                                                                             || combo->currentData(Qt::UserRole).toInt() == IgnoreKey;
                                                                     });
 
         // If we don't encrypt the ok button is always enabled. But otherwise
         // we only enable it if we encrypt to at least one recipient.
         mOkButton->setEnabled(!mEncrypt || !allVisibleEncryptionKeysAreIgnored);
 
         mOkButton->setText(isGenerate ? i18n("Generate") : origOkText);
 
         if (Formatting::complianceMode() != QLatin1String("de-vs")) {
             return;
         }
 
         // Handle compliance
         bool de_vs = true;
 
         const Protocol protocol = currentProtocol();
 
         for (const auto combo: std::as_const(mAllCombos)) {
             if (!combo->isVisible()) {
                 continue;
             }
             const auto key = combo->currentKey();
             if (key.isNull()) {
                 continue;
             }
             if (protocol != UnknownProtocol && key.protocol() != protocol) {
                 continue;
             }
             if (!Formatting::isKeyDeVs(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 de_vs = false;
                 break;
             }
         }
 
         mOkButton->setIcon(QIcon::fromTheme(de_vs
                     ? QStringLiteral("security-high")
                     : QStringLiteral("security-medium")));
         mOkButton->setStyleSheet(QStringLiteral("background-color: ") + (de_vs
                     ? QStringLiteral("#D5FAE2")  // KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name()
                     : QStringLiteral("#FAE9EB"))); //KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name()));
         mComplianceLbl->setText(de_vs
                 ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                     "%1 communication possible.", Formatting::deVsString())
                 : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                     "%1 communication not possible.", Formatting::deVsString()));
         mComplianceLbl->setVisible(true);
     }
 
     GpgME::Protocol mForcedProtocol;
     QList<KeySelectionCombo *> mSigningCombos;
     QList<KeySelectionCombo *> mEncCombos;
     QList<KeySelectionCombo *> mAllCombos;
     QScrollArea *mScrollArea;
     QVBoxLayout *mScrollLayout;
     QPushButton *mOkButton;
     QVBoxLayout *mMainLay;
     QButtonGroup *mFormatBtns;
     QString mSender;
     bool mSign;
     bool mEncrypt;
     bool mAllowMixed;
     NewKeyApprovalDialog *q;
     QList <QGpgME::Job *> mRunningJobs;
     GpgME::Error mLastError;
     QLabel *mComplianceLbl;
     KeyResolver::Solution mAcceptedResult;
     QString mGenerateTooltip;
 };
 
 NewKeyApprovalDialog::NewKeyApprovalDialog(bool encrypt,
                                            bool sign,
                                            const QString &sender,
                                            KeyResolver::Solution preferredSolution,
                                            KeyResolver::Solution alternativeSolution,
                                            bool allowMixed,
                                            GpgME::Protocol forcedProtocol,
                                            QWidget *parent,
                                            Qt::WindowFlags f)
     : QDialog(parent, f)
     , d{std::make_unique<Private>(this, encrypt, sign, forcedProtocol, preferredSolution.protocol, sender, allowMixed)}
 {
     if (sign) {
         d->setSigningKeys(std::move(preferredSolution.signingKeys), std::move(alternativeSolution.signingKeys));
     }
     if (encrypt) {
         d->setEncryptionKeys(allowMixed ? UnknownProtocol : preferredSolution.protocol, std::move(preferredSolution.encryptionKeys),
                              allowMixed ? UnknownProtocol : alternativeSolution.protocol, std::move(alternativeSolution.encryptionKeys));
     }
     d->updateWidgets();
     d->updateOkButton();
 
     const auto size = sizeHint();
     const auto desk = QApplication::desktop()->screenGeometry(this);
     resize(QSize(desk.width() / 3, qMin(size.height(), desk.height() / 2)));
 }
 
 Kleo::NewKeyApprovalDialog::~NewKeyApprovalDialog() = default;
 
 KeyResolver::Solution NewKeyApprovalDialog::result()
 {
     return d->mAcceptedResult;
 }
 
 #include "newkeyapprovaldialog.moc"