diff --git a/src/crypto/gui/resolverecipientspage.cpp b/src/crypto/gui/resolverecipientspage.cpp
index a76b8674e..ad8d7baa0 100644
--- a/src/crypto/gui/resolverecipientspage.cpp
+++ b/src/crypto/gui/resolverecipientspage.cpp
@@ -1,704 +1,695 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resolverecipientspage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "resolverecipientspage.h"
 #include "resolverecipientspage_p.h"
 
 #include <dialogs/certificateselectiondialog.h>
 
 #include <crypto/certificateresolver.h>
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <kmime/kmime_header_parsing.h>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QButtonGroup>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QListWidget>
 #include <QPointer>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QToolButton>
 #include <QStringList>
 #include <QVBoxLayout>
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace KMime::Types;
 
 ResolveRecipientsPage::ListWidget::ListWidget(QWidget *parent, Qt::WindowFlags flags) : QWidget(parent, flags), m_protocol(UnknownProtocol)
 {
     m_listWidget = new QListWidget;
     m_listWidget->setSelectionMode(QAbstractItemView::MultiSelection);
     QVBoxLayout *const layout = new QVBoxLayout(this);
     layout->addWidget(m_listWidget);
     connect(m_listWidget, &QListWidget::itemSelectionChanged, this, &ListWidget::onSelectionChange);
 }
 
 ResolveRecipientsPage::ListWidget::~ListWidget()
 {
 }
 
 void ResolveRecipientsPage::ListWidget::onSelectionChange()
 {
     const auto widgetskeys = widgets.keys();
     for (const QString &i : widgetskeys) {
         Q_ASSERT(items.contains(i));
         widgets[i]->setSelected(items[i]->isSelected());
     }
     Q_EMIT selectionChanged();
 }
 
 void ResolveRecipientsPage::ListWidget::addEntry(const Mailbox &mbox)
 {
     addEntry(mbox.prettyAddress(), mbox.prettyAddress(), mbox);
 }
 
 void ResolveRecipientsPage::ListWidget::addEntry(const QString &id, const QString &name)
 {
     addEntry(id, name, Mailbox());
 }
 
 void ResolveRecipientsPage::ListWidget::addEntry(const QString &id, const QString &name, const Mailbox &mbox)
 {
     Q_ASSERT(!widgets.contains(id) && !items.contains(id));
     QListWidgetItem *item = new QListWidgetItem;
     item->setData(IdRole, id);
     ItemWidget *wid = new ItemWidget(id, name, mbox, this);
     connect(wid, &ItemWidget::changed, this, &ListWidget::completeChanged);
     wid->setProtocol(m_protocol);
     item->setSizeHint(wid->sizeHint());
     m_listWidget->addItem(item);
     m_listWidget->setItemWidget(item, wid);
     widgets[id] = wid;
     items[id] = item;
 }
 
 Mailbox ResolveRecipientsPage::ListWidget::mailbox(const QString &id) const
 {
     return widgets.contains(id) ? widgets[id]->mailbox() : Mailbox();
 }
 
 void ResolveRecipientsPage::ListWidget::setCertificates(const QString &id, const std::vector<Key> &pgp, const std::vector<Key> &cms)
 {
     Q_ASSERT(widgets.contains(id));
     widgets[id]->setCertificates(pgp, cms);
 }
 
 Key ResolveRecipientsPage::ListWidget::selectedCertificate(const QString &id) const
 {
     return widgets.contains(id) ? widgets[id]->selectedCertificate() : Key();
 }
 
 GpgME::Key ResolveRecipientsPage::ListWidget::selectedCertificate(const QString &id, GpgME::Protocol prot) const
 {
     return  widgets.contains(id) ? widgets[id]->selectedCertificate(prot) : Key();
 }
 
 QStringList ResolveRecipientsPage::ListWidget::identifiers() const
 {
     return widgets.keys();
 }
 
 void ResolveRecipientsPage::ListWidget::setProtocol(GpgME::Protocol prot)
 {
     if (m_protocol == prot) {
         return;
     }
     m_protocol = prot;
     for (ItemWidget *i : qAsConst(widgets)) {
         i->setProtocol(prot);
     }
 }
 
 void ResolveRecipientsPage::ListWidget::removeEntry(const QString &id)
 {
     if (!widgets.contains(id)) {
         return;
     }
     delete items[id];
     items.remove(id);
     delete widgets[id];
     widgets.remove(id);
 }
 
 void ResolveRecipientsPage::ListWidget::showSelectionDialog(const QString &id)
 {
     if (!widgets.contains(id)) {
         return;
     }
     widgets[id]->showSelectionDialog();
 }
 
 QStringList ResolveRecipientsPage::ListWidget::selectedEntries() const
 {
     QStringList entries;
     const QList<QListWidgetItem *> items = m_listWidget->selectedItems();
     entries.reserve(items.count());
     for (const QListWidgetItem *i : items) {
         entries.append(i->data(IdRole).toString());
     }
     return entries;
 }
 
 ResolveRecipientsPage::ItemWidget::ItemWidget(const QString &id, const QString &name, const Mailbox &mbox,
         QWidget *parent, Qt::WindowFlags flags) : QWidget(parent, flags), m_id(id), m_mailbox(mbox), m_protocol(UnknownProtocol), m_selected(false)
 {
     Q_ASSERT(!m_id.isEmpty());
     setAutoFillBackground(true);
     QHBoxLayout *layout = new QHBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->addSpacing(15);
     m_nameLabel = new QLabel;
     m_nameLabel->setText(name);
     layout->addWidget(m_nameLabel);
     layout->addStretch();
     m_certLabel = new QLabel;
     m_certLabel->setText(i18n("<i>No certificate selected</i>"));
     layout->addWidget(m_certLabel);
     m_certCombo = new QComboBox;
     connect(m_certCombo, SIGNAL(currentIndexChanged(int)),
             this, SIGNAL(changed()));
     layout->addWidget(m_certCombo);
     m_selectButton = new QToolButton;
     m_selectButton->setText(i18n("..."));
     connect(m_selectButton, &QAbstractButton::clicked,
             this, &ItemWidget::showSelectionDialog);
     layout->addWidget(m_selectButton);
     layout->addSpacing(15);
     setCertificates(std::vector<Key>(), std::vector<Key>());
 }
 
 void ResolveRecipientsPage::ItemWidget::updateVisibility()
 {
     m_certLabel->setVisible(m_certCombo->count() == 0);
     m_certCombo->setVisible(m_certCombo->count() > 0);
 }
 
 ResolveRecipientsPage::ItemWidget::~ItemWidget()
 {
 }
 
 QString ResolveRecipientsPage::ItemWidget::id() const
 {
     return m_id;
 }
 
 void ResolveRecipientsPage::ItemWidget::setSelected(bool selected)
 {
     if (m_selected == selected) {
         return;
     }
     m_selected = selected;
     setBackgroundRole(selected ? QPalette::Highlight : QPalette::Base);
     const QPalette::ColorRole foreground = selected ? QPalette::HighlightedText : QPalette::Text;
     setForegroundRole(foreground);
     m_nameLabel->setForegroundRole(foreground);
     m_certLabel->setForegroundRole(foreground);
 }
 
 bool ResolveRecipientsPage::ItemWidget::isSelected() const
 {
     return m_selected;
 }
 
-static CertificateSelectionDialog::Option protocol2option(GpgME::Protocol proto)
-{
-    switch (proto) {
-    case OpenPGP: return CertificateSelectionDialog::OpenPGPFormat;
-    case CMS:     return CertificateSelectionDialog::CMSFormat;
-    default:      return CertificateSelectionDialog::AnyFormat;
-    }
-}
-
 static CertificateSelectionDialog *createCertificateSelectionDialog(QWidget *parent, GpgME::Protocol prot)
 {
     CertificateSelectionDialog *const dlg = new CertificateSelectionDialog(parent);
     const CertificateSelectionDialog::Options options =
         CertificateSelectionDialog::SingleSelection |
         CertificateSelectionDialog::EncryptOnly |
         CertificateSelectionDialog::MultiSelection |
-        protocol2option(prot);
+        CertificateSelectionDialog::optionsFromProtocol(prot);
     dlg->setOptions(options);
     return dlg;
 }
 
 void ResolveRecipientsPage::ItemWidget::showSelectionDialog()
 {
     QPointer<CertificateSelectionDialog> dlg = createCertificateSelectionDialog(this, m_protocol);
 
     if (dlg->exec() == QDialog::Accepted && dlg /* still with us? */) {
         const GpgME::Key cert = dlg->selectedCertificate();
         if (!cert.isNull()) {
             addCertificateToComboBox(cert);
             selectCertificateInComboBox(cert);
         }
     }
     delete dlg;
 }
 
 Mailbox ResolveRecipientsPage::ItemWidget::mailbox() const
 {
     return m_mailbox;
 }
 
 void ResolveRecipientsPage::ItemWidget::selectCertificateInComboBox(const Key &key)
 {
     m_certCombo->setCurrentIndex(m_certCombo->findData(QLatin1String(key.keyID())));
 }
 
 void ResolveRecipientsPage::ItemWidget::addCertificateToComboBox(const GpgME::Key &key)
 {
     m_certCombo->addItem(Formatting::formatForComboBox(key), QByteArray(key.keyID()));
     if (m_certCombo->count() == 1) {
         m_certCombo->setCurrentIndex(0);
     }
     updateVisibility();
 }
 
 void ResolveRecipientsPage::ItemWidget::resetCertificates()
 {
     std::vector<Key> certs;
     Key selected;
     switch (m_protocol) {
     case OpenPGP:
         certs = m_pgp;
         break;
     case CMS:
         certs = m_cms;
         break;
     case UnknownProtocol:
         certs = m_cms;
         certs.insert(certs.end(), m_pgp.begin(), m_pgp.end());
     }
 
     m_certCombo->clear();
     for (const Key &i : qAsConst(certs)) {
         addCertificateToComboBox(i);
     }
     if (!m_selectedCertificates[m_protocol].isNull()) {
         selectCertificateInComboBox(m_selectedCertificates[m_protocol]);
     } else if (m_certCombo->count() > 0) {
         m_certCombo->setCurrentIndex(0);
     }
     updateVisibility();
     Q_EMIT changed();
 }
 
 void ResolveRecipientsPage::ItemWidget::setProtocol(Protocol prot)
 {
     if (m_protocol == prot) {
         return;
     }
     m_selectedCertificates[m_protocol] = selectedCertificate();
     if (m_protocol != UnknownProtocol) {
         (m_protocol == OpenPGP ? m_pgp : m_cms) = certificates();
     }
     m_protocol = prot;
     resetCertificates();
 }
 
 void ResolveRecipientsPage::ItemWidget::setCertificates(const std::vector<Key> &pgp, const std::vector<Key> &cms)
 {
     m_pgp = pgp;
     m_cms = cms;
     resetCertificates();
 }
 
 Key ResolveRecipientsPage::ItemWidget::selectedCertificate() const
 {
     return KeyCache::instance()->findByKeyIDOrFingerprint(m_certCombo->itemData(m_certCombo->currentIndex(), ListWidget::IdRole).toString().toStdString());
 }
 
 GpgME::Key ResolveRecipientsPage::ItemWidget::selectedCertificate(GpgME::Protocol prot) const
 {
     return prot == m_protocol ? selectedCertificate() : m_selectedCertificates.value(prot);
 }
 
 std::vector<Key> ResolveRecipientsPage::ItemWidget::certificates() const
 {
     std::vector<Key> certs;
     for (int i = 0; i < m_certCombo->count(); ++i) {
         certs.push_back(KeyCache::instance()->findByKeyIDOrFingerprint(m_certCombo->itemData(i, ListWidget::IdRole).toString().toStdString()));
     }
     return certs;
 }
 
 class ResolveRecipientsPage::Private
 {
     friend class ::Kleo::Crypto::Gui::ResolveRecipientsPage;
     ResolveRecipientsPage *const q;
 public:
     explicit Private(ResolveRecipientsPage *qq);
     ~Private();
 
     void setSelectedProtocol(Protocol protocol);
     void selectionChanged();
     void removeSelectedEntries();
     void addRecipient();
     void addRecipient(const Mailbox &mbox);
     void addRecipient(const QString &id, const QString &name);
     void updateProtocolRBVisibility();
     void protocolSelected(int prot);
     void writeSelectedCertificatesToPreferences();
     void completeChangedInternal();
 
 private:
     ListWidget *m_listWidget;
     QPushButton *m_addButton;
     QPushButton *m_removeButton;
     QRadioButton *m_pgpRB;
     QRadioButton *m_cmsRB;
     QLabel *m_additionalRecipientsLabel;
     Protocol m_presetProtocol;
     Protocol m_selectedProtocol;
     bool m_multipleProtocolsAllowed;
     std::shared_ptr<RecipientPreferences> m_recipientPreferences;
 };
 
 ResolveRecipientsPage::Private::Private(ResolveRecipientsPage *qq)
     : q(qq), m_presetProtocol(UnknownProtocol), m_selectedProtocol(m_presetProtocol), m_multipleProtocolsAllowed(false), m_recipientPreferences()
 {
     connect(q, SIGNAL(completeChanged()), q, SLOT(completeChangedInternal()));
     q->setTitle(i18n("<b>Recipients</b>"));
     QVBoxLayout *const layout = new QVBoxLayout(q);
     m_listWidget = new ListWidget;
     connect(m_listWidget, SIGNAL(selectionChanged()), q, SLOT(selectionChanged()));
     connect(m_listWidget, &ListWidget::completeChanged, q, &WizardPage::completeChanged);
     layout->addWidget(m_listWidget);
     m_additionalRecipientsLabel = new QLabel;
     m_additionalRecipientsLabel->setWordWrap(true);
     layout->addWidget(m_additionalRecipientsLabel);
     m_additionalRecipientsLabel->setVisible(false);
     QWidget *buttonWidget = new QWidget;
     QHBoxLayout *buttonLayout = new QHBoxLayout(buttonWidget);
     buttonLayout->setContentsMargins(0, 0, 0, 0);
     m_addButton = new QPushButton;
     connect(m_addButton, SIGNAL(clicked()), q, SLOT(addRecipient()));
     m_addButton->setText(i18n("Add Recipient..."));
     buttonLayout->addWidget(m_addButton);
     m_removeButton = new QPushButton;
     m_removeButton->setEnabled(false);
     m_removeButton->setText(i18n("Remove Selected"));
     connect(m_removeButton, SIGNAL(clicked()),
             q, SLOT(removeSelectedEntries()));
     buttonLayout->addWidget(m_removeButton);
     buttonLayout->addStretch();
     layout->addWidget(buttonWidget);
     QWidget *protocolWidget = new QWidget;
     QHBoxLayout *protocolLayout = new QHBoxLayout(protocolWidget);
     QButtonGroup *protocolGroup = new QButtonGroup(q);
     connect(protocolGroup, SIGNAL(buttonClicked(int)), q, SLOT(protocolSelected(int)));
     m_pgpRB = new QRadioButton;
     m_pgpRB->setText(i18n("OpenPGP"));
     protocolGroup->addButton(m_pgpRB, OpenPGP);
     protocolLayout->addWidget(m_pgpRB);
     m_cmsRB = new QRadioButton;
     m_cmsRB->setText(i18n("S/MIME"));
     protocolGroup->addButton(m_cmsRB, CMS);
     protocolLayout->addWidget(m_cmsRB);
     protocolLayout->addStretch();
     layout->addWidget(protocolWidget);
 }
 
 ResolveRecipientsPage::Private::~Private() {}
 
 void ResolveRecipientsPage::Private::completeChangedInternal()
 {
     const bool isComplete = q->isComplete();
     const std::vector<Key> keys = q->resolvedCertificates();
     const bool haveSecret = std::find_if(keys.begin(), keys.end(),
                                          [](const Key &key) {
                                              return key.hasSecret();
                                         }) != keys.end();
     if (isComplete && !haveSecret) {
         q->setExplanation(i18n("<b>Warning:</b> None of the selected certificates seem to be your own. You will not be able to decrypt the encrypted data again."));
     } else {
         q->setExplanation(QString());
     }
 }
 
 void ResolveRecipientsPage::Private::updateProtocolRBVisibility()
 {
     const bool visible = !m_multipleProtocolsAllowed && m_presetProtocol == UnknownProtocol;
     m_cmsRB->setVisible(visible);
     m_pgpRB->setVisible(visible);
     if (visible) {
         if (m_selectedProtocol == CMS) {
             m_cmsRB->click();
         } else {
             m_pgpRB->click();
         }
     }
 }
 
 bool ResolveRecipientsPage::isComplete() const
 {
     const QStringList ids = d->m_listWidget->identifiers();
     if (ids.isEmpty()) {
         return false;
     }
 
     for (const QString &i : ids) {
         if (d->m_listWidget->selectedCertificate(i).isNull()) {
             return false;
         }
     }
 
     return true;
 }
 
 ResolveRecipientsPage::ResolveRecipientsPage(QWidget *parent)
     : WizardPage(parent), d(new Private(this))
 {
 }
 
 ResolveRecipientsPage::~ResolveRecipientsPage() {}
 
 Protocol ResolveRecipientsPage::selectedProtocol() const
 {
     return d->m_selectedProtocol;
 }
 
 void ResolveRecipientsPage::Private::setSelectedProtocol(Protocol protocol)
 {
     if (m_selectedProtocol == protocol) {
         return;
     }
     m_selectedProtocol = protocol;
     m_listWidget->setProtocol(m_selectedProtocol);
     Q_EMIT q->selectedProtocolChanged();
 }
 
 void ResolveRecipientsPage::Private::protocolSelected(int p)
 {
     const Protocol protocol = static_cast<Protocol>(p);
     Q_ASSERT(protocol != UnknownProtocol);
     setSelectedProtocol(protocol);
 }
 
 void ResolveRecipientsPage::setPresetProtocol(Protocol prot)
 {
     if (d->m_presetProtocol == prot) {
         return;
     }
     d->m_presetProtocol = prot;
     d->setSelectedProtocol(prot);
     if (prot != UnknownProtocol) {
         d->m_multipleProtocolsAllowed = false;
     }
     d->updateProtocolRBVisibility();
 }
 
 Protocol ResolveRecipientsPage::presetProtocol() const
 {
     return d->m_presetProtocol;
 }
 
 bool ResolveRecipientsPage::multipleProtocolsAllowed() const
 {
     return d->m_multipleProtocolsAllowed;
 }
 
 void ResolveRecipientsPage::setMultipleProtocolsAllowed(bool allowed)
 {
     if (d->m_multipleProtocolsAllowed == allowed) {
         return;
     }
     d->m_multipleProtocolsAllowed = allowed;
     if (d->m_multipleProtocolsAllowed) {
         setPresetProtocol(UnknownProtocol);
         d->setSelectedProtocol(UnknownProtocol);
     }
     d->updateProtocolRBVisibility();
 }
 
 void ResolveRecipientsPage::Private::addRecipient(const QString &id, const QString &name)
 {
     m_listWidget->addEntry(id, name);
 }
 
 void ResolveRecipientsPage::Private::addRecipient(const Mailbox &mbox)
 {
     m_listWidget->addEntry(mbox);
 }
 
 void ResolveRecipientsPage::Private::addRecipient()
 {
     QPointer<CertificateSelectionDialog> dlg = createCertificateSelectionDialog(q, q->selectedProtocol());
     if (dlg->exec() != QDialog::Accepted || !dlg /*q already deleted*/) {
         return;
     }
     const std::vector<Key> keys = dlg->selectedCertificates();
 
     int i = 0;
     for (const Key &key : keys) {
         const QStringList existing = m_listWidget->identifiers();
         QString rec = i18n("Recipient");
         while (existing.contains(rec)) {
             rec = i18nc("%1 == number", "Recipient (%1)", ++i);
         }
         addRecipient(rec, rec);
         const std::vector<Key> pgp = key.protocol() == OpenPGP ? std::vector<Key>(1, key) : std::vector<Key>();
         const std::vector<Key> cms = key.protocol() == CMS ? std::vector<Key>(1, key) : std::vector<Key>();
         m_listWidget->setCertificates(rec, pgp, cms);
     }
     Q_EMIT q->completeChanged();
 }
 
 namespace
 {
 
 std::vector<Key> makeSuggestions(const std::shared_ptr<RecipientPreferences> &prefs, const Mailbox &mb, GpgME::Protocol prot)
 {
     std::vector<Key> suggestions;
     const Key remembered = prefs ? prefs->preferredCertificate(mb, prot) : Key();
     if (!remembered.isNull()) {
         suggestions.push_back(remembered);
     } else {
         suggestions = CertificateResolver::resolveRecipient(mb, prot);
     }
     return suggestions;
 }
 }
 
 static QString listKeysForInfo(const std::vector<Key> &keys)
 {
     QStringList list;
     std::transform(keys.begin(), keys.end(), list.begin(), &Formatting::formatKeyLink);
     return list.join(QLatin1String("<br/>"));
 }
 
 void ResolveRecipientsPage::setAdditionalRecipientsInfo(const std::vector<Key> &recipients)
 {
     d->m_additionalRecipientsLabel->setVisible(!recipients.empty());
     if (recipients.empty()) {
         return;
     }
     d->m_additionalRecipientsLabel->setText(
         i18n("<qt><p>Recipients predefined via GnuPG settings:</p>%1</qt>",
              listKeysForInfo(recipients)));
 }
 
 void ResolveRecipientsPage::setRecipients(const std::vector<Mailbox> &recipients, const std::vector<Mailbox> &encryptToSelfRecipients)
 {
     uint cmsCount = 0;
     uint pgpCount = 0;
     uint senders = 0;
     for (const Mailbox &mb : encryptToSelfRecipients) {
         const QString id = QLatin1String("sender-") + QString::number(++senders);
         d->m_listWidget->addEntry(id, i18n("Sender"), mb);
         const std::vector<Key> pgp = makeSuggestions(d->m_recipientPreferences, mb, OpenPGP);
         const std::vector<Key> cms = makeSuggestions(d->m_recipientPreferences, mb, CMS);
         pgpCount += !pgp.empty();
         cmsCount += !cms.empty();
         d->m_listWidget->setCertificates(id, pgp, cms);
     }
     for (const Mailbox &i : recipients) {
         //TODO:
         const QString address = i.prettyAddress();
         d->addRecipient(i);
         const std::vector<Key> pgp = makeSuggestions(d->m_recipientPreferences, i, OpenPGP);
         const std::vector<Key> cms = makeSuggestions(d->m_recipientPreferences, i, CMS);
         pgpCount += pgp.empty() ? 0 : 1;
         cmsCount += cms.empty() ? 0 : 1;
         d->m_listWidget->setCertificates(address, pgp, cms);
     }
     if (d->m_presetProtocol == UnknownProtocol && !d->m_multipleProtocolsAllowed) {
         (cmsCount > pgpCount ? d->m_cmsRB : d->m_pgpRB)->click();
     }
 }
 
 std::vector<Key> ResolveRecipientsPage::resolvedCertificates() const
 {
     std::vector<Key> certs;
     Q_FOREACH (const QString &i, d->m_listWidget->identifiers()) {
         const GpgME::Key cert = d->m_listWidget->selectedCertificate(i);
         if (!cert.isNull()) {
             certs.push_back(cert);
         }
     }
     return certs;
 }
 
 void ResolveRecipientsPage::Private::selectionChanged()
 {
     m_removeButton->setEnabled(!m_listWidget->selectedEntries().isEmpty());
 }
 
 void ResolveRecipientsPage::Private::removeSelectedEntries()
 {
     Q_FOREACH (const QString &i, m_listWidget->selectedEntries()) {
         m_listWidget->removeEntry(i);
     }
     Q_EMIT q->completeChanged();
 }
 
 void ResolveRecipientsPage::setRecipientsUserMutable(bool isMutable)
 {
     d->m_addButton->setVisible(isMutable);
     d->m_removeButton->setVisible(isMutable);
 }
 
 bool ResolveRecipientsPage::recipientsUserMutable() const
 {
     return d->m_addButton->isVisible();
 }
 
 std::shared_ptr<RecipientPreferences> ResolveRecipientsPage::recipientPreferences() const
 {
     return d->m_recipientPreferences;
 }
 
 void ResolveRecipientsPage::setRecipientPreferences(const std::shared_ptr<RecipientPreferences> &prefs)
 {
     d->m_recipientPreferences = prefs;
 }
 
 void ResolveRecipientsPage::Private::writeSelectedCertificatesToPreferences()
 {
     if (!m_recipientPreferences) {
         return;
     }
 
     Q_FOREACH (const QString &i, m_listWidget->identifiers()) {
         const Mailbox mbox = m_listWidget->mailbox(i);
         if (!mbox.hasAddress()) {
             continue;
         }
         const Key pgp = m_listWidget->selectedCertificate(i, OpenPGP);
         if (!pgp.isNull()) {
             m_recipientPreferences->setPreferredCertificate(mbox, OpenPGP, pgp);
         }
         const Key cms = m_listWidget->selectedCertificate(i, CMS);
         if (!cms.isNull()) {
             m_recipientPreferences->setPreferredCertificate(mbox, CMS, cms);
         }
     }
 }
 
 void ResolveRecipientsPage::onNext()
 {
     d->writeSelectedCertificatesToPreferences();
 }
 
 #include "moc_resolverecipientspage_p.cpp"
 #include "moc_resolverecipientspage.cpp"
diff --git a/src/dialogs/certificateselectiondialog.cpp b/src/dialogs/certificateselectiondialog.cpp
index 5b048ffe0..7a17c000b 100644
--- a/src/dialogs/certificateselectiondialog.cpp
+++ b/src/dialogs/certificateselectiondialog.cpp
@@ -1,463 +1,473 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/certificateselectiondialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "certificateselectiondialog.h"
 
 #include "settings.h"
 
 #include "conf/groupsconfigdialog.h"
 
 #include <view/keytreeview.h>
 #include <view/searchbar.h>
 #include <view/tabwidget.h>
 
 #include "utils/tags.h"
 
 #include <Libkleo/KeyGroup>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyCache>
 
 #include <commands/reloadkeyscommand.h>
 #include <commands/lookupcertificatescommand.h>
 #include <commands/newcertificatecommand.h>
 #include <commands/importcertificatefromfilecommand.h>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 #include <KConfigDialog>
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include <QLabel>
 #include <QPushButton>
 #include <QDialogButtonBox>
 #include <QItemSelectionModel>
 #include <QAbstractItemView>
 #include <QPointer>
 #include <QVBoxLayout>
 
 #include <algorithm>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
+
+CertificateSelectionDialog::Option CertificateSelectionDialog::optionsFromProtocol(Protocol proto)
+{
+    switch (proto) {
+    case OpenPGP: return CertificateSelectionDialog::OpenPGPFormat;
+    case CMS:     return CertificateSelectionDialog::CMSFormat;
+    default:      return CertificateSelectionDialog::AnyFormat;
+    }
+}
+
 class CertificateSelectionDialog::Private
 {
     friend class ::Kleo::Dialogs::CertificateSelectionDialog;
     CertificateSelectionDialog *const q;
 public:
     explicit Private(CertificateSelectionDialog *qq);
 
 private:
     void reload()
     {
         Command *const cmd = new ReloadKeysCommand(nullptr);
         cmd->setParentWidget(q);
         cmd->start();
     }
     void create()
     {
         NewCertificateCommand *cmd = new NewCertificateCommand(nullptr);
         cmd->setParentWidget(q);
         if ((options & AnyFormat) != AnyFormat) {
             cmd->setProtocol((options & OpenPGPFormat) ? OpenPGP : CMS);
         }
         cmd->start();
     }
     void lookup()
     {
         Command *const cmd = new LookupCertificatesCommand(nullptr);
         cmd->setParentWidget(q);
         cmd->start();
     }
     void manageGroups()
     {
         KConfigDialog *dialog = KConfigDialog::exists(GroupsConfigDialog::dialogName());
         if (dialog) {
             // reparent the dialog to ensure it's shown on top of the modal CertificateSelectionDialog
             dialog->setParent(q, Qt::Dialog);
         } else {
             dialog = new GroupsConfigDialog(q);
         }
         dialog->show();
     }
     void slotKeysMayHaveChanged();
     void slotCurrentViewChanged(QAbstractItemView *newView);
     void slotSelectionChanged();
     void slotDoubleClicked(const QModelIndex &idx);
 
 private:
     bool acceptable(const std::vector<Key> &keys, const std::vector<KeyGroup> &groups)
     {
         return !keys.empty() || !groups.empty();
     }
     void updateLabelText()
     {
         ui.label.setText(!customLabelText.isEmpty() ? customLabelText :
                          (options & MultiSelection)
                          ? i18n("Please select one or more of the following certificates:")
                          : i18n("Please select one of the following certificates:"));
     }
 
 private:
     QSet<QAbstractItemView *> connectedViews;
     QString customLabelText;
     Options options = AnyCertificate | AnyFormat;
 
     struct UI {
         QLabel label;
         SearchBar searchBar;
         TabWidget tabWidget;
         QDialogButtonBox buttonBox;
     } ui;
 
     void setUpUI(CertificateSelectionDialog *q)
     {
         KDAB_SET_OBJECT_NAME(ui.label);
         KDAB_SET_OBJECT_NAME(ui.searchBar);
         KDAB_SET_OBJECT_NAME(ui.tabWidget);
         KDAB_SET_OBJECT_NAME(ui.buttonBox);
 
         auto *vlay = new QVBoxLayout(q);
         vlay->addWidget(&ui.label);
         vlay->addWidget(&ui.searchBar);
         vlay->addWidget(&ui.tabWidget, 1);
         vlay->addWidget(&ui.buttonBox);
 
         QPushButton *const okButton = ui.buttonBox.addButton(QDialogButtonBox::Ok);
         okButton->setEnabled(false);
         ui.buttonBox.addButton(QDialogButtonBox::Close);
         QPushButton *const reloadButton = ui.buttonBox.addButton(i18n("Reload"), QDialogButtonBox::ActionRole);
         QPushButton *const importButton = ui.buttonBox.addButton(i18n("Import..."), QDialogButtonBox::ActionRole);
         QPushButton *const lookupButton = ui.buttonBox.addButton(i18n("Lookup..."), QDialogButtonBox::ActionRole);
         QPushButton *const createButton = ui.buttonBox.addButton(i18n("New..."), QDialogButtonBox::ActionRole);
         QPushButton *const groupsButton = ui.buttonBox.addButton(i18n("Groups..."), QDialogButtonBox::ActionRole);
         groupsButton->setVisible(Settings().groupsEnabled());
 
         importButton->setToolTip(i18nc("@info:tooltip", "Import certificate from file"));
         lookupButton->setToolTip(i18nc("@info:tooltip", "Lookup certificates on server"));
         reloadButton->setToolTip(i18nc("@info:tooltip", "Refresh certificate list"));
         createButton->setToolTip(i18nc("@info:tooltip", "Create a new certificate"));
         groupsButton->setToolTip(i18nc("@info:tooltip", "Manage certificate groups"));
 
         connect(&ui.buttonBox, &QDialogButtonBox::accepted, q, &CertificateSelectionDialog::accept);
         connect(&ui.buttonBox, &QDialogButtonBox::rejected, q, &CertificateSelectionDialog::reject);
         connect(reloadButton, &QPushButton::clicked, q, [this] () { reload(); });
         connect(lookupButton, &QPushButton::clicked, q, [this] () { lookup(); });
         connect(createButton, &QPushButton::clicked, q, [this] () { create(); });
         connect(groupsButton, &QPushButton::clicked, q, [this] () { manageGroups(); });
         connect(KeyCache::instance().get(), &KeyCache::keysMayHaveChanged,
                 q, [this] () { slotKeysMayHaveChanged(); });
 
         connect(importButton, &QPushButton::clicked, q, [importButton, q] () {
             importButton->setEnabled(false);
             auto cmd = new Kleo::ImportCertificateFromFileCommand();
             connect(cmd, &Kleo::ImportCertificateFromFileCommand::finished,
                     q, [importButton]() {
                 importButton->setEnabled(true);
             });
             cmd->setParentWidget(q);
             cmd->start();
         });
     }
 };
 
 CertificateSelectionDialog::Private::Private(CertificateSelectionDialog *qq)
     : q(qq)
 {
     setUpUI(q);
     ui.tabWidget.setFlatModel(AbstractKeyListModel::createFlatKeyListModel(q));
     ui.tabWidget.setHierarchicalModel(AbstractKeyListModel::createHierarchicalKeyListModel(q));
 #ifdef GPGME_HAS_REMARKS
     const auto tagKeys = Tags::tagKeys();
     ui.tabWidget.flatModel()->setRemarkKeys(tagKeys);
     ui.tabWidget.hierarchicalModel()->setRemarkKeys(tagKeys);
 #endif
     ui.tabWidget.connectSearchBar(&ui.searchBar);
 
     connect(&ui.tabWidget, &TabWidget::currentViewChanged,
             q, [this] (QAbstractItemView *view) { slotCurrentViewChanged(view); });
 
     updateLabelText();
     q->setWindowTitle(i18nc("@title:window", "Certificate Selection"));
 }
 
 CertificateSelectionDialog::CertificateSelectionDialog(QWidget *parent)
     : QDialog(parent), d(new Private(this))
 {
     const KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kleopatracertificateselectiondialogrc"));
     d->ui.tabWidget.loadViews(config.data());
     const KConfigGroup geometry(config, "Geometry");
     resize(geometry.readEntry("size", size()));
     d->slotKeysMayHaveChanged();
 }
 
 CertificateSelectionDialog::~CertificateSelectionDialog() {}
 
 void CertificateSelectionDialog::setCustomLabelText(const QString &txt)
 {
     if (txt == d->customLabelText) {
         return;
     }
     d->customLabelText = txt;
     d->updateLabelText();
 }
 
 QString CertificateSelectionDialog::customLabelText() const
 {
     return d->customLabelText;
 }
 
 void CertificateSelectionDialog::setOptions(Options options)
 {
     Q_ASSERT((options & CertificateSelectionDialog::AnyCertificate) != 0);
     Q_ASSERT((options & CertificateSelectionDialog::AnyFormat) != 0);
     if (d->options == options) {
         return;
     }
     d->options = options;
 
     d->ui.tabWidget.setMultiSelection(options & MultiSelection);
 
     d->slotKeysMayHaveChanged();
 }
 
 CertificateSelectionDialog::Options CertificateSelectionDialog::options() const
 {
     return d->options;
 }
 
 void CertificateSelectionDialog::setStringFilter(const QString &filter)
 {
     d->ui.tabWidget.setStringFilter(filter);
 }
 
 void CertificateSelectionDialog::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     d->ui.tabWidget.setKeyFilter(filter);
 }
 
 namespace
 {
 
 void selectRows(const QAbstractItemView *view, const QModelIndexList &indexes)
 {
     if (!view) {
         return;
     }
     QItemSelectionModel *const sm = view->selectionModel();
     Q_ASSERT(sm);
 
     for (const QModelIndex &idx : qAsConst(indexes)) {
         if (idx.isValid()) {
             sm->select(idx, QItemSelectionModel::Select | QItemSelectionModel::Rows);
         }
     }
 }
 
 QModelIndexList getGroupIndexes(const KeyListModelInterface *model, const std::vector<KeyGroup> &groups)
 {
     QModelIndexList indexes;
     indexes.reserve(groups.size());
     std::transform(groups.begin(), groups.end(),
                    std::back_inserter(indexes),
                    [model] (const KeyGroup &group) {
                        return model->index(group);
                    });
     indexes.erase(std::remove_if(indexes.begin(), indexes.end(),
                                  [] (const QModelIndex &index) { return !index.isValid(); }),
                   indexes.end());
     return indexes;
 }
 
 }
 
 void CertificateSelectionDialog::selectCertificates(const std::vector<Key> &keys)
 {
     const auto *const model = d->ui.tabWidget.currentModel();
     Q_ASSERT(model);
     selectRows(d->ui.tabWidget.currentView(), model->indexes(keys));
 }
 
 void CertificateSelectionDialog::selectCertificate(const Key &key)
 {
     selectCertificates(std::vector<Key>(1, key));
 }
 
 void CertificateSelectionDialog::selectGroups(const std::vector<KeyGroup> &groups)
 {
     const auto *const model = d->ui.tabWidget.currentModel();
     Q_ASSERT(model);
     selectRows(d->ui.tabWidget.currentView(), getGroupIndexes(model, groups));
 }
 
 namespace
 {
 
 QModelIndexList getSelectedRows(const QAbstractItemView *view)
 {
     if (!view) {
         return {};
     }
     const QItemSelectionModel *const sm = view->selectionModel();
     Q_ASSERT(sm);
     return sm->selectedRows();
 }
 
 std::vector<KeyGroup> getGroups(const KeyListModelInterface *model, const QModelIndexList &indexes)
 {
     std::vector<KeyGroup> groups;
     groups.reserve(indexes.size());
     std::transform(indexes.begin(), indexes.end(),
                    std::back_inserter(groups),
                    [model](const QModelIndex &idx) {
                        return model->group(idx);
                    });
     groups.erase(std::remove_if(groups.begin(), groups.end(), std::mem_fn(&Kleo::KeyGroup::isNull)), groups.end());
     return groups;
 }
 
 }
 
 std::vector<Key> CertificateSelectionDialog::selectedCertificates() const
 {
     const KeyListModelInterface *const model = d->ui.tabWidget.currentModel();
     Q_ASSERT(model);
     return model->keys(getSelectedRows(d->ui.tabWidget.currentView()));
 }
 
 Key CertificateSelectionDialog::selectedCertificate() const
 {
     const std::vector<Key> keys = selectedCertificates();
     return keys.empty() ? Key() : keys.front();
 }
 
 std::vector<KeyGroup> CertificateSelectionDialog::selectedGroups() const
 {
     const KeyListModelInterface *const model = d->ui.tabWidget.currentModel();
     Q_ASSERT(model);
     return getGroups(model, getSelectedRows(d->ui.tabWidget.currentView()));
 }
 
 void CertificateSelectionDialog::hideEvent(QHideEvent *e)
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kleopatracertificateselectiondialogrc"));
     d->ui.tabWidget.saveViews(config.data());
     KConfigGroup geometry(config, "Geometry");
     geometry.writeEntry("size", size());
     QDialog::hideEvent(e);
 }
 
 void CertificateSelectionDialog::Private::slotKeysMayHaveChanged()
 {
     q->setEnabled(true);
     std::vector<Key> keys = (options & SecretKeys) ? KeyCache::instance()->secretKeys() : KeyCache::instance()->keys();
     q->filterAllowedKeys(keys, options);
     const std::vector<KeyGroup> groups = (options & IncludeGroups) ? KeyCache::instance()->groups() : std::vector<KeyGroup>();
 
     const std::vector<Key> selectedKeys = q->selectedCertificates();
     const std::vector<KeyGroup> selectedGroups = q->selectedGroups();
     if (AbstractKeyListModel *const model = ui.tabWidget.flatModel()) {
         model->setKeys(keys);
         model->setGroups(groups);
     }
     if (AbstractKeyListModel *const model = ui.tabWidget.hierarchicalModel()) {
         model->setKeys(keys);
         model->setGroups(groups);
     }
     q->selectCertificates(selectedKeys);
     q->selectGroups(selectedGroups);
 }
 
 void CertificateSelectionDialog::filterAllowedKeys(std::vector<Key> &keys, int options)
 {
     std::vector<Key>::iterator end = keys.end();
 
     switch (options & AnyFormat) {
     case OpenPGPFormat:
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return key.protocol() != OpenPGP; });
         break;
     case CMSFormat:
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return key.protocol() != CMS; });
         break;
     default:
     case AnyFormat:
         ;
     }
 
     switch (options & AnyCertificate) {
     case SignOnly:
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return !key.canReallySign(); });
         break;
     case EncryptOnly:
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return !key.canEncrypt(); });
         break;
     default:
     case AnyCertificate:
         ;
     }
 
     if (options & SecretKeys) {
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return !key.hasSecret(); });
     }
 
     keys.erase(end, keys.end());
 }
 
 void CertificateSelectionDialog::Private::slotCurrentViewChanged(QAbstractItemView *newView)
 {
     if (!connectedViews.contains(newView)) {
         connectedViews.insert(newView);
         connect(newView, &QAbstractItemView::doubleClicked,
                 q, [this] (const QModelIndex &index) { slotDoubleClicked(index); });
         Q_ASSERT(newView->selectionModel());
         connect(newView->selectionModel(), &QItemSelectionModel::selectionChanged,
                 q, [this] (const QItemSelection &, const QItemSelection &) { slotSelectionChanged(); });
     }
     slotSelectionChanged();
 }
 
 void CertificateSelectionDialog::Private::slotSelectionChanged()
 {
     if (QPushButton *const pb = ui.buttonBox.button(QDialogButtonBox::Ok)) {
         pb->setEnabled(acceptable(q->selectedCertificates(), q->selectedGroups()));
     }
 }
 
 void CertificateSelectionDialog::Private::slotDoubleClicked(const QModelIndex &idx)
 {
     QAbstractItemView *const view = ui.tabWidget.currentView();
     Q_ASSERT(view);
     const auto *const model = ui.tabWidget.currentModel();
     Q_ASSERT(model);
     Q_UNUSED(model)
     QItemSelectionModel *const sm = view->selectionModel();
     Q_ASSERT(sm);
     sm->select(idx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
     QMetaObject::invokeMethod(q, [this]() {q->accept();}, Qt::QueuedConnection);
 }
 
 void CertificateSelectionDialog::accept()
 {
     if (d->acceptable(selectedCertificates(), selectedGroups())) {
         QDialog::accept();
     }
 }
 
 #include "moc_certificateselectiondialog.cpp"
diff --git a/src/dialogs/certificateselectiondialog.h b/src/dialogs/certificateselectiondialog.h
index 909d3284d..f531cfcec 100644
--- a/src/dialogs/certificateselectiondialog.h
+++ b/src/dialogs/certificateselectiondialog.h
@@ -1,98 +1,102 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/certificateselectiondialog.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef __KLEOPATRA_DIALOGS_CERTIFICATESELECTIONDIALOG_H__
 #define __KLEOPATRA_DIALOGS_CERTIFICATESELECTIONDIALOG_H__
 
 #include <QDialog>
 
 #include <utils/pimpl_ptr.h>
 
+#include <gpgme++/global.h>
+
 #include <memory>
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 
 class KeyFilter;
 class KeyGroup;
 
 namespace Dialogs
 {
 
 class CertificateSelectionDialog : public QDialog
 {
     Q_OBJECT
     Q_FLAGS(Options)
 public:
     enum Option {
         SingleSelection = 0x00,
         MultiSelection  = 0x01,
 
         SignOnly        = 0x02,
         EncryptOnly     = 0x04,
         AnyCertificate  = 0x06,
 
         OpenPGPFormat   = 0x08,
         CMSFormat       = 0x10,
         AnyFormat       = 0x18,
 
         Certificates    = 0x00,
         SecretKeys      = 0x20,
 
         IncludeGroups   = 0x40,
 
         OptionMask
     };
     Q_DECLARE_FLAGS(Options, Option)
 
+    static Option optionsFromProtocol(GpgME::Protocol proto);
+
     explicit CertificateSelectionDialog(QWidget *parent = nullptr);
     ~CertificateSelectionDialog() override;
 
     void setCustomLabelText(const QString &text);
     QString customLabelText() const;
 
     void setOptions(Options options);
     Options options() const;
 
     void selectCertificates(const std::vector<GpgME::Key> &certs);
     void selectCertificate(const GpgME::Key &key);
 
     std::vector<GpgME::Key> selectedCertificates() const;
     GpgME::Key selectedCertificate() const;
 
     void selectGroups(const std::vector<Kleo::KeyGroup> &groups);
     std::vector<Kleo::KeyGroup> selectedGroups() const;
 
     static void filterAllowedKeys(std::vector<GpgME::Key> &keys, int options);
 
 public Q_SLOTS:
     void setStringFilter(const QString &text);
     void setKeyFilter(const std::shared_ptr<Kleo::KeyFilter> &filter);
     void accept() override;
 
 protected:
     void hideEvent(QHideEvent *) override;
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
 };
 
 }
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Kleo::Dialogs::CertificateSelectionDialog::Options)
 
 #endif /* __KLEOPATRA_DIALOGS_CERTIFICATESELECTIONDIALOG_H__ */