diff --git a/src/crypto/gui/signencryptwidget.cpp b/src/crypto/gui/signencryptwidget.cpp
index e50137251..54210bb3d 100644
--- a/src/crypto/gui/signencryptwidget.cpp
+++ b/src/crypto/gui/signencryptwidget.cpp
@@ -1,691 +1,690 @@
 /*  crypto/gui/signencryptwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "signencryptwidget.h"
 
 #include "kleopatra_debug.h"
 
 #include "certificatelineedit.h"
 #include "fileoperationspreferences.h"
 #include "kleopatraapplication.h"
 #include "settings.h"
 #include "unknownrecipientwidget.h"
 
 #include "dialogs/certificateselectiondialog.h"
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QScrollArea>
 #include <QScrollBar>
 
 #include <Libkleo/DefaultKeyFilter>
 #include <Libkleo/KeyCache>
-#include <Libkleo/KeyGroup>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeySelectionCombo>
 #include <Libkleo/KeyListSortFilterProxyModel>
 
 #include <Libkleo/GnuPG>
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KMessageBox>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 namespace {
 class SignCertificateFilter: public DefaultKeyFilter
 {
 public:
     SignCertificateFilter(GpgME::Protocol proto) : DefaultKeyFilter()
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setHasSecret(DefaultKeyFilter::Set);
         setCanSign(DefaultKeyFilter::Set);
 
         if (proto == GpgME::OpenPGP) {
             setIsOpenPGP(DefaultKeyFilter::Set);
         } else if (proto == GpgME::CMS) {
             setIsOpenPGP(DefaultKeyFilter::NotSet);
         }
     }
 };
 class EncryptCertificateFilter: public DefaultKeyFilter
 {
 public:
     EncryptCertificateFilter(GpgME::Protocol proto): DefaultKeyFilter()
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanEncrypt(DefaultKeyFilter::Set);
 
         if (proto == GpgME::OpenPGP) {
             setIsOpenPGP(DefaultKeyFilter::Set);
         } else if (proto == GpgME::CMS) {
             setIsOpenPGP(DefaultKeyFilter::NotSet);
         }
     }
 };
 class EncryptSelfCertificateFilter: public EncryptCertificateFilter
 {
 public:
     EncryptSelfCertificateFilter(GpgME::Protocol proto): EncryptCertificateFilter(proto)
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanEncrypt(DefaultKeyFilter::Set);
         setHasSecret(DefaultKeyFilter::Set);
     }
 };
 }
 
 SignEncryptWidget::SignEncryptWidget(QWidget *parent, bool sigEncExclusive)
     : QWidget(parent),
       mModel(AbstractKeyListModel::createFlatKeyListModel(this)),
       mIsExclusive(sigEncExclusive)
 {
     auto lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
 
     mModel->useKeyCache(true, KeyList::IncludeGroups);
 
     const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
     const bool havePublicKeys = !KeyCache::instance()->keys().empty();
     const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
 
     /* The signature selection */
     auto sigLay = new QHBoxLayout;
     auto sigGrp = new QGroupBox(i18nc("@title:group", "Prove authenticity (sign)"));
     mSigChk = new QCheckBox(i18n("Sign as:"));
     mSigChk->setEnabled(haveSecretKeys);
     mSigChk->setChecked(haveSecretKeys);
 
     mSigSelect = new KeySelectionCombo();
     mSigSelect->setEnabled(mSigChk->isChecked());
 
     sigLay->addWidget(mSigChk);
     sigLay->addWidget(mSigSelect, 1);
     sigGrp->setLayout(sigLay);
     lay->addWidget(sigGrp);
 
     connect(mSigChk, &QCheckBox::toggled, mSigSelect, &QWidget::setEnabled);
     connect(mSigChk, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSigSelect, &KeySelectionCombo::currentKeyChanged,
             this, &SignEncryptWidget::updateOp);
 
     // Recipient selection
     auto encBoxLay = new QVBoxLayout;
     auto encBox = new QGroupBox(i18nc("@title:group", "Encrypt"));
     encBox->setLayout(encBoxLay);
     auto recipientGrid = new QGridLayout;
 
     // Own key
     mEncSelfChk = new QCheckBox(i18n("Encrypt for me:"));
     mEncSelfChk->setEnabled(haveSecretKeys && !symmetricOnly);
     mEncSelfChk->setChecked(haveSecretKeys && !symmetricOnly);
     mSelfSelect = new KeySelectionCombo();
     mSelfSelect->setEnabled(mEncSelfChk->isChecked());
     recipientGrid->addWidget(mEncSelfChk, 0, 0);
     recipientGrid->addWidget(mSelfSelect, 0, 1);
 
     // Checkbox for other keys
     mEncOtherChk = new QCheckBox(i18n("Encrypt for others:"));
     mEncOtherChk->setEnabled(havePublicKeys && !symmetricOnly);
     mEncOtherChk->setChecked(havePublicKeys && !symmetricOnly);
     recipientGrid->addWidget(mEncOtherChk, 1, 0, Qt::AlignTop);
     connect(mEncOtherChk, &QCheckBox::toggled, this,
         [this](bool toggled) {
             for (CertificateLineEdit *edit : std::as_const(mRecpWidgets)) {
                 edit->setEnabled(toggled);
             }
             updateOp();
         });
     mRecpLayout = new QVBoxLayout;
     recipientGrid->addLayout(mRecpLayout, 1, 1);
     recipientGrid->setRowStretch(2, 1);
 
     // Scroll area for other keys
     auto recipientWidget = new QWidget;
     auto recipientScroll = new QScrollArea;
     recipientWidget->setLayout(recipientGrid);
     recipientScroll->setWidget(recipientWidget);
     recipientScroll->setWidgetResizable(true);
     recipientScroll->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow);
     recipientScroll->setFrameStyle(QFrame::NoFrame);
     recipientScroll->setFocusPolicy(Qt::NoFocus);
     recipientGrid->setContentsMargins(0, 0, 0, 0);
     encBoxLay->addWidget(recipientScroll, 1);
 
     auto bar = recipientScroll->verticalScrollBar();
     connect (bar, &QScrollBar::rangeChanged, this, [bar] (int, int max) {
             bar->setValue(max);
         });
 
     addRecipientWidget();
 
     // Checkbox for password
     mSymmetric = new QCheckBox(i18n("Encrypt with password. Anyone you share the password with can read the data."));
     mSymmetric->setToolTip(i18nc("Tooltip information for symmetric encryption",
                                  "Additionally to the keys of the recipients you can encrypt your data with a password. "
                                  "Anyone who has the password can read the data without any secret key. "
                                  "Using a password is <b>less secure</b> then public key cryptography. Even if you pick a very strong password."));
     mSymmetric->setChecked(symmetricOnly || !havePublicKeys);
     encBoxLay->addWidget(mSymmetric);
 
     // Connect it
     connect(mEncSelfChk, &QCheckBox::toggled, mSelfSelect, &QWidget::setEnabled);
     connect(mEncSelfChk, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSymmetric, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSelfSelect, &KeySelectionCombo::currentKeyChanged,
             this, &SignEncryptWidget::updateOp);
 
     if (mIsExclusive) {
         connect(mEncOtherChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mSigChk->setChecked(false);
             }
         });
         connect(mEncSelfChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mSigChk->setChecked(false);
             }
         });
         connect(mSigChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mEncSelfChk->setChecked(false);
                 mEncOtherChk->setChecked(false);
             }
         });
     }
 
     // Ensure that the mSigChk is aligned togehter with the encryption check boxes.
     mSigChk->setMinimumWidth(qMax(mEncOtherChk->width(), mEncSelfChk->width()));
 
     lay->addWidget(encBox);
 
     connect(KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, &SignEncryptWidget::updateCheckBoxes);
     connect(KleopatraApplication::instance(), &KleopatraApplication::configurationChanged,
             this, &SignEncryptWidget::updateCheckBoxes);
 
     loadKeys();
     onProtocolChanged();
     updateOp();
 }
 
 void SignEncryptWidget::setSignAsText(const QString &text)
 {
     mSigChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptForMeText(const QString &text)
 {
     mEncSelfChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptForOthersText(const QString &text)
 {
     mEncOtherChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptWithPasswordText(const QString& text)
 {
     mSymmetric->setText(text);
 }
 
 CertificateLineEdit *SignEncryptWidget::addRecipientWidget()
 {
     return insertRecipientWidget(nullptr);
 }
 
 CertificateLineEdit *SignEncryptWidget::insertRecipientWidget(CertificateLineEdit *after)
 {
     Q_ASSERT(!after || mRecpLayout->indexOf(after) != -1);
 
     const auto index = after ? mRecpLayout->indexOf(after) + 1 : mRecpLayout->count();
 
     auto certSel = new CertificateLineEdit(mModel,
                                            new EncryptCertificateFilter(mCurrentProto),
                                            this);
     certSel->setAccessibleNameOfLineEdit(i18nc("text for screen readers", "recipient key"));
     certSel->setEnabled(mEncOtherChk->isChecked());
     mRecpWidgets.insert(index, certSel);
 
     if (mRecpLayout->count() > 0) {
         auto prevWidget = after ? after : mRecpLayout->itemAt(mRecpLayout->count() - 1)->widget();
         setTabOrder(prevWidget, certSel);
     }
     mRecpLayout->insertWidget(index, certSel);
 
     connect(certSel, &CertificateLineEdit::keyChanged,
             this, &SignEncryptWidget::recipientsChanged);
     connect(certSel, &CertificateLineEdit::editingStarted,
             this, &SignEncryptWidget::recipientsChanged);
     connect(certSel, &CertificateLineEdit::certificateSelectionRequested,
             this, [this, certSel]() { certificateSelectionRequested(certSel); });
 
     return certSel;
 }
 
 void SignEncryptWidget::addRecipient(const Key &key)
 {
     CertificateLineEdit *certSel = addRecipientWidget();
     if (!key.isNull()) {
         certSel->setKey(key);
         mAddedKeys << key;
     }
 }
 
 void SignEncryptWidget::addRecipient(const KeyGroup &group)
 {
     CertificateLineEdit *certSel = addRecipientWidget();
     if (!group.isNull()) {
         certSel->setGroup(group);
         mAddedGroups << group;
     }
 }
 
 void SignEncryptWidget::certificateSelectionRequested(CertificateLineEdit *certificateLineEdit)
 {
     CertificateSelectionDialog dlg{this};
 
     dlg.setOptions(CertificateSelectionDialog::Options(
         CertificateSelectionDialog::MultiSelection |
         CertificateSelectionDialog::EncryptOnly |
         CertificateSelectionDialog::optionsFromProtocol(mCurrentProto) |
         CertificateSelectionDialog::IncludeGroups));
 
     if (!certificateLineEdit->key().isNull()) {
         const auto key = certificateLineEdit->key();
         const auto name = QString::fromUtf8(key.userID(0).name());
         const auto email = QString::fromUtf8(key.userID(0).email());
         dlg.setStringFilter(!name.isEmpty() ? name : email);
     } else if (!certificateLineEdit->group().isNull()) {
         dlg.setStringFilter(certificateLineEdit->group().name());
     } else {
         dlg.setStringFilter(certificateLineEdit->text());
     }
 
     if (dlg.exec()) {
         const std::vector<Key> keys = dlg.selectedCertificates();
         const std::vector<KeyGroup> groups = dlg.selectedGroups();
         if (keys.size() == 0 && groups.size() == 0) {
             return;
         }
         CertificateLineEdit *certWidget = nullptr;
         for (const Key &key : keys) {
             if (!certWidget) {
                 certWidget = certificateLineEdit;
             } else {
                 certWidget = insertRecipientWidget(certWidget);
             }
             certWidget->setKey(key);
         }
         for (const KeyGroup &group : groups) {
             if (!certWidget) {
                 certWidget = certificateLineEdit;
             } else {
                 certWidget = insertRecipientWidget(certWidget);
             }
             certWidget->setGroup(group);
         }
     }
 
     recipientsChanged();
 }
 
 void SignEncryptWidget::clearAddedRecipients()
 {
     for (auto w: std::as_const(mUnknownWidgets)) {
         mRecpLayout->removeWidget(w);
         delete w;
     }
 
     for (auto &key: std::as_const(mAddedKeys)) {
         removeRecipient(key);
     }
 
     for (auto &group: std::as_const(mAddedGroups)) {
         removeRecipient(group);
     }
 }
 
 void SignEncryptWidget::addUnknownRecipient(const char *keyID)
 {
     auto unknownWidget = new UnknownRecipientWidget(keyID);
     mUnknownWidgets << unknownWidget;
 
     if (mRecpLayout->count() > 0) {
         auto lastWidget = mRecpLayout->itemAt(mRecpLayout->count() - 1)->widget();
         setTabOrder(lastWidget, unknownWidget);
     }
     mRecpLayout->addWidget(unknownWidget);
 
     connect(KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, [this] () {
         // Check if any unknown recipient can now be found.
         for (auto w: mUnknownWidgets) {
             auto key = KeyCache::instance()->findByKeyIDOrFingerprint(w->keyID().toLatin1().constData());
             if (key.isNull()) {
                 std::vector<std::string> subids;
                 subids.push_back(std::string(w->keyID().toLatin1().constData()));
                 for (const auto &subkey: KeyCache::instance()->findSubkeysByKeyID(subids)) {
                     key = subkey.parent();
                 }
             }
             if (key.isNull()) {
                 continue;
             }
             // Key is now available replace by line edit.
             qCDebug(KLEOPATRA_LOG) << "Removing widget for keyid: " << w->keyID();
             mRecpLayout->removeWidget(w);
             mUnknownWidgets.removeAll(w);
             delete w;
             addRecipient(key);
         }
     });
 }
 
 void SignEncryptWidget::recipientsChanged()
 {
     const bool hasEmptyRecpWidget =
         std::any_of(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                     [](auto w) { return w->isEmpty(); });
     if (!hasEmptyRecpWidget) {
         addRecipientWidget();
     }
     updateOp();
 }
 
 Key SignEncryptWidget::signKey() const
 {
     if (mSigSelect->isEnabled()) {
         return mSigSelect->currentKey();
     }
     return Key();
 }
 
 Key SignEncryptWidget::selfKey() const
 {
     if (mSelfSelect->isEnabled()) {
         return mSelfSelect->currentKey();
     }
     return Key();
 }
 
 std::vector<Key> SignEncryptWidget::recipients() const
 {
     std::vector<Key> ret;
     for (const CertificateLineEdit *w : std::as_const(mRecpWidgets)) {
         if (!w->isEnabled()) {
             // If one is disabled, all are disabled.
             break;
         }
         const Key k = w->key();
         const KeyGroup g = w->group();
         if (!k.isNull()) {
             ret.push_back(k);
         } else if (!g.isNull()) {
             const auto keys = g.keys();
             std::copy(keys.begin(), keys.end(), std::back_inserter(ret));
         }
     }
     const Key k = selfKey();
     if (!k.isNull()) {
         ret.push_back(k);
     }
     return ret;
 }
 
 bool SignEncryptWidget::isDeVsAndValid() const
 {
     if (!signKey().isNull()
         && (!IS_DE_VS(signKey()) || keyValidity(signKey()) < GpgME::UserID::Validity::Full)) {
         return false;
     }
 
     if (!selfKey().isNull()
         && (!IS_DE_VS(selfKey()) || keyValidity(selfKey()) < GpgME::UserID::Validity::Full)) {
         return false;
     }
 
     for (const auto &key: recipients()) {
         if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
             return false;
         }
     }
 
     return true;
 }
 
 void SignEncryptWidget::updateOp()
 {
     const Key sigKey = signKey();
     const std::vector<Key> recp = recipients();
 
     QString newOp;
     if (!sigKey.isNull() && (!recp.empty() || encryptSymmetric())) {
         newOp = i18nc("@action", "Sign / Encrypt");
     } else if (!recp.empty() || encryptSymmetric()) {
         newOp = i18nc("@action", "Encrypt");
     } else if (!sigKey.isNull()) {
         newOp = i18nc("@action", "Sign");
     } else {
         newOp = QString();
     }
     mOp = newOp;
     Q_EMIT operationChanged(mOp);
     Q_EMIT keysChanged();
 }
 
 QString SignEncryptWidget::currentOp() const
 {
     return mOp;
 }
 
 namespace
 {
 bool recipientWidgetHasFocus(CertificateLineEdit *w)
 {
     // check if w (or its focus proxy) or a child widget of w has focus
     return w->hasFocus() || w->isAncestorOf(qApp->focusWidget());
 }
 }
 
 void SignEncryptWidget::recpRemovalRequested(CertificateLineEdit *w)
 {
     if (!w) {
         return;
     }
     const int emptyEdits =
         std::count_if(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                       [](auto w) { return w->isEmpty(); });
     if (emptyEdits > 1) {
         if (recipientWidgetHasFocus(w)) {
             const int index = mRecpLayout->indexOf(w);
             const auto focusWidget = (index < mRecpLayout->count() - 1) ?
                 mRecpLayout->itemAt(index + 1)->widget() :
                 mRecpLayout->itemAt(mRecpLayout->count() - 2)->widget();
             focusWidget->setFocus();
         }
         mRecpLayout->removeWidget(w);
         mRecpWidgets.removeAll(w);
         w->deleteLater();
     }
 }
 
 void SignEncryptWidget::removeRecipient(const GpgME::Key &key)
 {
     for (CertificateLineEdit *edit: std::as_const(mRecpWidgets)) {
         const auto editKey = edit->key();
         if (key.isNull() && editKey.isNull()) {
             recpRemovalRequested(edit);
             return;
         }
         if (editKey.primaryFingerprint() &&
             key.primaryFingerprint() &&
             !strcmp(editKey.primaryFingerprint(), key.primaryFingerprint())) {
             recpRemovalRequested(edit);
             return;
         }
     }
 }
 
 void SignEncryptWidget::removeRecipient(const KeyGroup &group)
 {
     for (CertificateLineEdit *edit: std::as_const(mRecpWidgets)) {
         const auto editGroup = edit->group();
         if (group.isNull() && editGroup.isNull()) {
             recpRemovalRequested(edit);
             return;
         }
         if (editGroup.name() == group.name()) {
             recpRemovalRequested(edit);
             return;
         }
     }
 }
 
 bool SignEncryptWidget::encryptSymmetric() const
 {
     return mSymmetric->isChecked();
 }
 
 void SignEncryptWidget::loadKeys()
 {
     KConfigGroup keys(KSharedConfig::openConfig(), "SignEncryptKeys");
     auto cache = KeyCache::instance();
     mSigSelect->setDefaultKey(keys.readEntry("SigningKey", QString()));
     mSelfSelect->setDefaultKey(keys.readEntry("EncryptKey", QString()));
 }
 
 void SignEncryptWidget::saveOwnKeys() const
 {
     KConfigGroup keys(KSharedConfig::openConfig(), "SignEncryptKeys");
     auto sigKey = mSigSelect->currentKey();
     auto encKey = mSelfSelect->currentKey();
     if (!sigKey.isNull()) {
         keys.writeEntry("SigningKey", sigKey.primaryFingerprint());
     }
     if (!encKey.isNull()) {
         keys.writeEntry("EncryptKey", encKey.primaryFingerprint());
     }
 }
 
 void SignEncryptWidget::setSigningChecked(bool value)
 {
     mSigChk->setChecked(value && !KeyCache::instance()->secretKeys().empty());
 }
 
 void SignEncryptWidget::setEncryptionChecked(bool checked)
 {
     if (checked) {
         const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
         const bool havePublicKeys = !KeyCache::instance()->keys().empty();
         const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
         mEncSelfChk->setChecked(haveSecretKeys && !symmetricOnly);
         mEncOtherChk->setChecked(havePublicKeys && !symmetricOnly);
         mSymmetric->setChecked(symmetricOnly || !havePublicKeys);
     } else {
         mEncSelfChk->setChecked(false);
         mEncOtherChk->setChecked(false);
         mSymmetric->setChecked(false);
     }
 }
 
 void SignEncryptWidget::setProtocol(GpgME::Protocol proto)
 {
     if (mCurrentProto == proto) {
         return;
     }
     mCurrentProto = proto;
     onProtocolChanged();
 }
 
 void Kleo::SignEncryptWidget::onProtocolChanged()
 {
     mSigSelect->setKeyFilter(std::shared_ptr<KeyFilter>(new SignCertificateFilter(mCurrentProto)));
     mSelfSelect->setKeyFilter(std::shared_ptr<KeyFilter>(new EncryptSelfCertificateFilter(mCurrentProto)));
     const auto encFilter = std::shared_ptr<KeyFilter>(new EncryptCertificateFilter(mCurrentProto));
     for (CertificateLineEdit *edit : std::as_const(mRecpWidgets)) {
         edit->setKeyFilter(encFilter);
     }
 
     if (mIsExclusive) {
         mSymmetric->setDisabled(mCurrentProto == GpgME::CMS);
         if (mSymmetric->isChecked() && mCurrentProto == GpgME::CMS) {
             mSymmetric->setChecked(false);
         }
         if (mSigChk->isChecked() && mCurrentProto == GpgME::CMS &&
                 (mEncSelfChk->isChecked() || mEncOtherChk->isChecked())) {
             mSigChk->setChecked(false);
         }
     }
 }
 
 bool SignEncryptWidget::isComplete() const
 {
     return !currentOp().isEmpty()
         && std::all_of(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                         [](auto w) { return !w->isEnabled() || w->hasAcceptableInput(); });
 }
 
 bool SignEncryptWidget::validate()
 {
     CertificateLineEdit *firstUnresolvedRecipient = nullptr;
     QStringList unresolvedRecipients;
     for (const auto edit: std::as_const(mRecpWidgets)) {
         if (edit->isEnabled() && !edit->hasAcceptableInput()) {
             if (!firstUnresolvedRecipient) {
                 firstUnresolvedRecipient = edit;
             }
             unresolvedRecipients.push_back(edit->text().toHtmlEscaped());
         }
     }
     if (!unresolvedRecipients.isEmpty()) {
         KMessageBox::errorList(this,
                                i18n("Could not find a key for the following recipients:"),
                                unresolvedRecipients,
                                i18n("Failed to find some keys"));
     }
     if (firstUnresolvedRecipient) {
         firstUnresolvedRecipient->setFocus();
     }
     return unresolvedRecipients.isEmpty();
 }
 
 void SignEncryptWidget::updateCheckBoxes()
 {
     const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
     const bool havePublicKeys = !KeyCache::instance()->keys().empty();
     const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
     mSigChk->setEnabled(haveSecretKeys);
     mEncSelfChk->setEnabled(haveSecretKeys && !symmetricOnly);
     mEncOtherChk->setEnabled(havePublicKeys && !symmetricOnly);
     if (symmetricOnly) {
         mEncSelfChk->setChecked(false);
         mEncOtherChk->setChecked(false);
         mSymmetric->setChecked(true);
     }
 }
diff --git a/src/dialogs/lookupcertificatesdialog.cpp b/src/dialogs/lookupcertificatesdialog.cpp
index dde4ae1c6..94c4f66e0 100644
--- a/src/dialogs/lookupcertificatesdialog.cpp
+++ b/src/dialogs/lookupcertificatesdialog.cpp
@@ -1,349 +1,348 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/lookupcertificatesdialog.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 "lookupcertificatesdialog.h"
 
 #include "view/keytreeview.h"
 
 #include <Libkleo/KeyListModel>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageWidget>
 #include <KSeparator>
 #include <KSharedConfig>
 
-#include <QDialog>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QGridLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QSpacerItem>
 #include <QTreeView>
 #include <QVBoxLayout>
 
 #include <gpgme++/key.h>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 static const int minimalSearchTextLength = 2;
 
 class LookupCertificatesDialog::Private
 {
     friend class ::Kleo::Dialogs::LookupCertificatesDialog;
     LookupCertificatesDialog *const q;
 public:
     explicit Private(LookupCertificatesDialog *qq);
     ~Private();
 
 private:
     void slotSelectionChanged()
     {
         enableDisableWidgets();
     }
     void slotSearchTextChanged()
     {
         enableDisableWidgets();
     }
     void slotSearchClicked()
     {
         Q_EMIT q->searchTextChanged(ui.findED->text());
     }
     void slotDetailsClicked()
     {
         Q_ASSERT(q->selectedCertificates().size() == 1);
         Q_EMIT q->detailsRequested(q->selectedCertificates().front());
     }
     void slotSaveAsClicked()
     {
         Q_EMIT q->saveAsRequested(q->selectedCertificates());
     }
 
     void readConfig();
     void writeConfig();
     void enableDisableWidgets();
 
     QString searchText() const
     {
         return ui.findED->text().trimmed();
     }
 
     std::vector<Key> selectedCertificates() const
     {
         const QAbstractItemView *const view = ui.resultTV->view();
         if (!view) {
             return std::vector<Key>();
         }
         const auto *const model = dynamic_cast<KeyListModelInterface*>(view->model());
         Q_ASSERT(model);
         const QItemSelectionModel *const sm = view->selectionModel();
         Q_ASSERT(sm);
         return model->keys(sm->selectedRows());
     }
 
     int numSelectedCertificates() const
     {
         return ui.resultTV->selectedKeys().size();
     }
 private:
     bool passive;
 
     struct Ui {
         QLabel *findLB;
         QLineEdit *findED;
         QPushButton *findPB;
         Kleo::KeyTreeView *resultTV;
         QPushButton *selectAllPB;
         QPushButton *deselectAllPB;
         QPushButton *detailsPB;
         QPushButton *saveAsPB;
         KMessageWidget *messageWidget;
         QDialogButtonBox *buttonBox;
 
         void setupUi(QDialog *dialog)
         {
             auto verticalLayout = new QVBoxLayout{dialog};
             auto gridLayout = new QGridLayout{};
 
             int row = 0;
             findLB = new QLabel{i18n("Find:"), dialog};
             gridLayout->addWidget(findLB, row, 0, 1, 1);
 
             findED = new QLineEdit{dialog};
             findLB->setBuddy(findED);
             gridLayout->addWidget(findED, row, 1, 1, 1);
 
             findPB = new QPushButton{i18n("Search"), dialog};
             findPB->setAutoDefault(false);
             gridLayout->addWidget(findPB, row, 2, 1, 1);
 
             row++;
             gridLayout->addWidget(new KSeparator{Qt::Horizontal, dialog}, row, 0, 1, 3);
 
             row++;
             resultTV = new Kleo::KeyTreeView(dialog);
             resultTV->setEnabled(true);
             resultTV->setMinimumSize(QSize(400, 0));
             gridLayout->addWidget(resultTV, row, 0, 1, 2);
 
             auto buttonLayout = new QVBoxLayout{};
 
             selectAllPB = new QPushButton{i18n("Select All"), dialog};
             selectAllPB->setEnabled(false);
             selectAllPB->setAutoDefault(false);
             buttonLayout->addWidget(selectAllPB);
 
             deselectAllPB = new QPushButton{i18n("Deselect All"), dialog};
             deselectAllPB->setEnabled(false);
             deselectAllPB->setAutoDefault(false);
             buttonLayout->addWidget(deselectAllPB);
 
             buttonLayout->addStretch();
 
             detailsPB = new QPushButton{i18n("Details..."), dialog};
             detailsPB->setEnabled(false);
             detailsPB->setAutoDefault(false);
             buttonLayout->addWidget(detailsPB);
 
             saveAsPB = new QPushButton{i18n("Save As..."), dialog};
             saveAsPB->setEnabled(false);
             saveAsPB->setAutoDefault(false);
             buttonLayout->addWidget(saveAsPB);
 
             gridLayout->addLayout(buttonLayout, row, 2, 1, 1);
 
             row++;
             messageWidget = new KMessageWidget{dialog};
             messageWidget->setMessageType(KMessageWidget::Information);
             messageWidget->setVisible(false);
             gridLayout->addWidget(messageWidget, row, 0, 1, 3);
 
             verticalLayout->addLayout(gridLayout);
 
             buttonBox = new QDialogButtonBox{dialog};
             buttonBox->setStandardButtons(QDialogButtonBox::Close|QDialogButtonBox::Save);
             verticalLayout->addWidget(buttonBox);
 
             QObject::connect(findED, SIGNAL(returnPressed()), findPB, SLOT(animateClick()));
             QObject::connect(buttonBox, SIGNAL(accepted()), dialog, SLOT(accept()));
             QObject::connect(buttonBox, SIGNAL(rejected()), dialog, SLOT(reject()));
             QObject::connect(findPB, SIGNAL(clicked()), dialog, SLOT(slotSearchClicked()));
             QObject::connect(detailsPB, SIGNAL(clicked()), dialog, SLOT(slotDetailsClicked()));
             QObject::connect(saveAsPB, SIGNAL(clicked()), dialog, SLOT(slotSaveAsClicked()));
             QObject::connect(findED, SIGNAL(textChanged(QString)), dialog, SLOT(slotSearchTextChanged()));
 
             QMetaObject::connectSlotsByName(dialog);
         }
 
         explicit Ui(LookupCertificatesDialog *q)
         {
             q->setWindowTitle(i18n("Lookup on Server"));
             setupUi(q);
 
             saveAsPB->hide(); // ### not yet implemented in LookupCertificatesCommand
 
             findED->setClearButtonEnabled(true);
 
             resultTV->setFlatModel(AbstractKeyListModel::createFlatKeyListModel(q));
             resultTV->setHierarchicalView(false);
 
             importPB()->setText(i18n("Import"));
             importPB()->setEnabled(false);
 
             connect(resultTV->view(), SIGNAL(doubleClicked(QModelIndex)),
                     importPB(), SLOT(animateClick()));
 
             findED->setFocus();
 
             connect(selectAllPB, &QPushButton::clicked,
                     resultTV->view(), &QTreeView::selectAll);
             connect(deselectAllPB, &QPushButton::clicked,
                     resultTV->view(), &QTreeView::clearSelection);
         }
 
         QPushButton *importPB() const
         {
             return buttonBox->button(QDialogButtonBox::Save);
         }
         QPushButton *closePB()  const
         {
             return buttonBox->button(QDialogButtonBox::Close);
         }
     } ui;
 };
 
 LookupCertificatesDialog::Private::Private(LookupCertificatesDialog *qq)
     : q(qq),
       passive(false),
       ui(q)
 {
     connect(ui.resultTV->view()->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
             q, SLOT(slotSelectionChanged()));
 }
 
 LookupCertificatesDialog::Private::~Private() {}
 
 void LookupCertificatesDialog::Private::readConfig()
 {
     KConfigGroup configGroup(KSharedConfig::openConfig(), "LookupCertificatesDialog");
 
     KConfigGroup resultKeysConfig = configGroup.group("ResultKeysView");
     ui.resultTV->restoreLayout(resultKeysConfig);
 
     const QSize size = configGroup.readEntry("Size", QSize(600, 400));
     if (size.isValid()) {
         q->resize(size);
     }
 }
 
 void LookupCertificatesDialog::Private::writeConfig()
 {
     KConfigGroup configGroup(KSharedConfig::openConfig(), "LookupCertificatesDialog");
     configGroup.writeEntry("Size", q->size());
 
     KConfigGroup resultKeysConfig = configGroup.group("ResultKeysView");
     ui.resultTV->saveLayout(resultKeysConfig);
 
     configGroup.sync();
 }
 
 LookupCertificatesDialog::LookupCertificatesDialog(QWidget *p, Qt::WindowFlags f)
     : QDialog(p, f), d(new Private(this))
 {
     d->ui.findPB->setEnabled(false);
     d->readConfig();
 }
 
 LookupCertificatesDialog::~LookupCertificatesDialog()
 {
     d->writeConfig();
 }
 
 void LookupCertificatesDialog::setCertificates(const std::vector<Key> &certs)
 {
     d->ui.resultTV->view()->setFocus();
     d->ui.resultTV->setKeys(certs);
 }
 
 std::vector<Key> LookupCertificatesDialog::selectedCertificates() const
 {
     return d->selectedCertificates();
 }
 
 void LookupCertificatesDialog::setPassive(bool on)
 {
     if (d->passive == on) {
         return;
     }
     d->passive = on;
     d->enableDisableWidgets();
 }
 
 bool LookupCertificatesDialog::isPassive() const
 {
     return d->passive;
 }
 
 void LookupCertificatesDialog::setSearchText(const QString &text)
 {
     d->ui.findED->setText(text);
 }
 
 QString LookupCertificatesDialog::searchText() const
 {
     return d->ui.findED->text();
 }
 
 void LookupCertificatesDialog::showInformation(const QString &message)
 {
     d->ui.messageWidget->setText(message);
     if (message.isEmpty()) {
         d->ui.messageWidget->animatedHide();
     } else {
         d->ui.messageWidget->animatedShow();
     }
 }
 
 void LookupCertificatesDialog::accept()
 {
     Q_ASSERT(!selectedCertificates().empty());
     Q_EMIT importRequested(selectedCertificates());
     QDialog::accept();
 }
 
 void LookupCertificatesDialog::Private::enableDisableWidgets()
 {
     // enable/disable everything except 'close', based on passive:
     Q_FOREACH (QObject *const o, q->children())
         if (QWidget *const w = qobject_cast<QWidget *>(o)) {
             w->setDisabled(passive && w != ui.closePB() && w != ui.buttonBox);
         }
 
     if (passive) {
         return;
     }
 
     ui.findPB->setEnabled(searchText().length() > minimalSearchTextLength);
 
     const int n = q->selectedCertificates().size();
 
     ui.detailsPB->setEnabled(n == 1);
     ui.saveAsPB->setEnabled(n == 1);
     ui.importPB()->setEnabled(n != 0);
     ui.importPB()->setDefault(false);   // otherwise Import becomes default button if enabled and return triggers both a search and accept()
 }
 
 #include "moc_lookupcertificatesdialog.cpp"
 
diff --git a/src/dialogs/revokekeydialog.cpp b/src/dialogs/revokekeydialog.cpp
index 5435cf3f7..eaf764f09 100644
--- a/src/dialogs/revokekeydialog.cpp
+++ b/src/dialogs/revokekeydialog.cpp
@@ -1,300 +1,299 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/revokekeydialog.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2022 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#include <config-kleopatra.h>
 
 #include "revokekeydialog.h"
 #include "utils/accessibility.h"
 #include "view/errorlabel.h"
 
 #include <Libkleo/Formatting>
 
 #include <KConfigGroup>
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSeparator>
 #include <KSharedConfig>
 #include <KStandardGuiItem>
 
 #include <QAccessible>
 #include <QApplication>
 #include <QButtonGroup>
 #include <QDialogButtonBox>
 #include <QFocusEvent>
 #include <QGroupBox>
 #include <QLabel>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QRegularExpression>
 #include <QTextEdit>
 #include <QVBoxLayout>
 
 #ifdef QGPGME_SUPPORTS_KEY_REVOCATION
 #include <gpgme++/global.h>
 #endif
 #include <gpgme++/key.h>
 
 #include <kleopatra_debug.h>
 
 using namespace Kleo;
 using namespace GpgME;
 
 namespace
 {
 class TextEdit : public QTextEdit
 {
     Q_OBJECT
 public:
     using QTextEdit::QTextEdit;
 
 Q_SIGNALS:
     void editingFinished();
 
 protected:
     void focusOutEvent(QFocusEvent *event) override
     {
         Qt::FocusReason reason = event->reason();
         if (reason != Qt::PopupFocusReason
                 || !(QApplication::activePopupWidget() && QApplication::activePopupWidget()->parentWidget() == this)) {
             Q_EMIT editingFinished();
         }
 
         QTextEdit::focusOutEvent(event);
     }
 };
 }
 
 class RevokeKeyDialog::Private
 {
     friend class ::Kleo::RevokeKeyDialog;
     RevokeKeyDialog *const q;
 
     struct {
         QLabel *infoLabel = nullptr;
         QLabel *descriptionLabel = nullptr;
         TextEdit *description = nullptr;
         ErrorLabel *descriptionError = nullptr;
         QDialogButtonBox *buttonBox = nullptr;
     } ui;
 
     Key key;
     QButtonGroup reasonGroup;
     bool descriptionEditingInProgress = false;
     QString descriptionAccessibleName;
 
 public:
     Private(RevokeKeyDialog *qq)
         : q(qq)
     {
         q->setWindowTitle(i18nc("title:window", "Revoke Key"));
 
         auto mainLayout = new QVBoxLayout{q};
 
         ui.infoLabel = new QLabel{q};
         mainLayout->addWidget(ui.infoLabel);
 
 #ifdef QGPGME_SUPPORTS_KEY_REVOCATION
         auto groupBox = new QGroupBox{i18nc("@title:group", "Reason for revocation"), q};
 
         reasonGroup.addButton(new QRadioButton{i18nc("@option:radio", "No reason specified"), q},
                               static_cast<int>(RevocationReason::Unspecified));
         reasonGroup.addButton(new QRadioButton{i18nc("@option:radio", "Key has been compromised"), q},
                               static_cast<int>(RevocationReason::Compromised));
         reasonGroup.addButton(new QRadioButton{i18nc("@option:radio", "Key is superseded"), q},
                               static_cast<int>(RevocationReason::Superseded));
         reasonGroup.addButton(new QRadioButton{i18nc("@option:radio", "Key is no longer used"), q},
                               static_cast<int>(RevocationReason::NoLongerUsed));
         reasonGroup.button(static_cast<int>(RevocationReason::Unspecified))->setChecked(true);
 
         {
             auto boxLayout = new QVBoxLayout{groupBox};
             for (auto radio : reasonGroup.buttons()) {
                 boxLayout->addWidget(radio);
             }
         }
 
         mainLayout->addWidget(groupBox);
 #endif
 
         {
             ui.descriptionLabel = new QLabel{i18nc("@label:textbox", "Description (optional):"), q};
             ui.description = new TextEdit{q};
             ui.description->setAcceptRichText(false);
             // do not accept Tab as input; this is better for accessibility and
             // tabulators are not really that useful in the description
             ui.description->setTabChangesFocus(true);
             ui.descriptionLabel->setBuddy(ui.description);
             ui.descriptionError = new ErrorLabel{q};
             ui.descriptionError->setVisible(false);
 
             mainLayout->addWidget(ui.descriptionLabel);
             mainLayout->addWidget(ui.description);
             mainLayout->addWidget(ui.descriptionError);
         }
 
         connect(ui.description, &TextEdit::editingFinished,
                 q, [this]() { onDescriptionEditingFinished(); });
         connect(ui.description, &TextEdit::textChanged,
                 q, [this]() { onDescriptionTextChanged(); });
 
         ui.buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
         auto okButton = ui.buttonBox->button(QDialogButtonBox::Ok);
         okButton->setText(i18nc("@action:button", "Revoke Key"));
         okButton->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete-remove")));
 
         mainLayout->addWidget(ui.buttonBox);
 
         connect(ui.buttonBox, &QDialogButtonBox::accepted, q, [this]() { checkAccept(); });
         connect(ui.buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject);
 
         restoreGeometry();
     }
 
     ~Private()
     {
         saveGeometry();
     }
 
 private:
     void saveGeometry()
     {
         KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "RevokeKeyDialog");
         cfgGroup.writeEntry("Size", q->size());
         cfgGroup.sync();
     }
 
     void restoreGeometry(const QSize &defaultSize = {})
     {
         KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "RevokeKeyDialog");
         const QSize size = cfgGroup.readEntry("Size", defaultSize);
         if (size.isValid()) {
             q->resize(size);
         }
     }
 
     void checkAccept()
     {
         if (!descriptionHasAcceptableInput()) {
             KMessageBox::sorry(q, descriptionErrorMessage());
         } else {
             q->accept();
         }
     }
 
     bool descriptionHasAcceptableInput() const
     {
         return !q->description().contains(QLatin1String{"\n\n"});
     }
 
     QString descriptionErrorMessage() const
     {
         QString message;
 
         if (!descriptionHasAcceptableInput()) {
             message = i18n("Error: The description must not contain empty lines.");
         }
         return message;
     }
 
     void updateDescriptionError()
     {
         const auto currentErrorMessage = ui.descriptionError->text();
         const auto newErrorMessage = descriptionErrorMessage();
         if (newErrorMessage == currentErrorMessage) {
             return;
         }
         if (currentErrorMessage.isEmpty() && descriptionEditingInProgress) {
             // delay showing the error message until editing is finished, so that we
             // do not annoy the user with an error message while they are still
             // entering the recipient;
             // on the other hand, we clear the error message immediately if it does
             // not apply anymore and we update the error message immediately if it
             // changed
             return;
         }
         ui.descriptionError->setVisible(!newErrorMessage.isEmpty());
         ui.descriptionError->setText(newErrorMessage);
         updateAccessibleNameAndDescription();
     }
 
     void updateAccessibleNameAndDescription()
     {
         // fall back to default accessible name if accessible name wasn't set explicitly
         if (descriptionAccessibleName.isEmpty()) {
             descriptionAccessibleName = getAccessibleName(ui.description);
         }
         const bool errorShown = ui.descriptionError->isVisible();
 
         // Qt does not support "described-by" relations (like WCAG's "aria-describedby" relationship attribute);
         // emulate this by setting the error message as accessible description of the input field
         const auto description = errorShown ? ui.descriptionError->text() : QString{};
         if (ui.description->accessibleDescription() != description) {
             ui.description->setAccessibleDescription(description);
         }
 
         // Qt does not support IA2's "invalid entry" state (like WCAG's "aria-invalid" state attribute);
         // screen readers say something like "invalid entry" if this state is set;
         // emulate this by adding "invalid entry" to the accessible name of the input field
         // and its label
         const auto name = errorShown ? descriptionAccessibleName + QLatin1String{", "} + invalidEntryText()
                                      : descriptionAccessibleName;
         if (ui.descriptionLabel->accessibleName() != name) {
             ui.descriptionLabel->setAccessibleName(name);
         }
         if (ui.description->accessibleName() != name) {
             ui.description->setAccessibleName(name);
         }
     }
 
     void onDescriptionTextChanged()
     {
         descriptionEditingInProgress = true;
         updateDescriptionError();
     }
 
     void onDescriptionEditingFinished()
     {
         descriptionEditingInProgress = false;
         updateDescriptionError();
     }
 };
 
 RevokeKeyDialog::RevokeKeyDialog(QWidget *parent, Qt::WindowFlags f)
     : QDialog{parent, f}
     , d{new Private{this}}
 {
 }
 
 RevokeKeyDialog::~RevokeKeyDialog() = default;
 
 void RevokeKeyDialog::setKey(const GpgME::Key &key)
 {
     d->key = key;
     d->ui.infoLabel->setText(
         xi18n("<para>You are about to revoke the following key:<nl/>%1</para>")
         .arg(Formatting::summaryLine(key)));
 }
 
 #ifdef QGPGME_SUPPORTS_KEY_REVOCATION
 GpgME::RevocationReason RevokeKeyDialog::reason() const
 {
     return static_cast<RevocationReason>(d->reasonGroup.checkedId());
 }
 #endif
 
 QString RevokeKeyDialog::description() const
 {
     static const QRegularExpression whitespaceAtEndOfLine{QStringLiteral(R"([ \t\r]+\n)")};
     static const QRegularExpression trailingWhitespace{QStringLiteral(R"(\s*$)")};
     return d->ui.description->toPlainText().remove(whitespaceAtEndOfLine).remove(trailingWhitespace);
 }
 
 #include "revokekeydialog.moc"