diff --git a/src/ui/keyrequester.h b/src/ui/keyrequester.h
index be7c8ebdf..8c10b84c1 100644
--- a/src/ui/keyrequester.h
+++ b/src/ui/keyrequester.h
@@ -1,202 +1,201 @@
 /*  -*- c++ -*-
     keyrequester.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
 
     This file is part of KPGP, the KDE PGP/GnuPG support library.
 
     SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #pragma once
 
 #include "kleo_export.h"
 
 #include <qgpgme/protocol.h>
 
 #include <QWidget>
 #include <QLabel>
 
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 class KeyListResult;
 }
 
 #include <QStringList>
 class QString;
 class QPushButton;
-class QLabel;
 
 namespace Kleo
 {
 
 /// Base class for SigningKeyRequester and EncryptionKeyRequester
 class KLEO_EXPORT KeyRequester : public QWidget
 {
     Q_OBJECT
 public:
     explicit KeyRequester(unsigned int allowedKeys, bool multipleKeys = false,
                           QWidget *parent = nullptr);
     // Constructor for Qt Designer
     explicit KeyRequester(QWidget *parent = nullptr);
     ~KeyRequester();
 
     const GpgME::Key &key() const;
     /** Preferred method to set a key for
         non-multi-KeyRequesters. Doesn't start a backend
         KeyListJob.
     */
     void setKey(const GpgME::Key &key);
 
     const std::vector<GpgME::Key> &keys() const;
     /** Preferred method to set a key for multi-KeyRequesters. Doesn't
         start a backend KeyListJob.
     */
     void setKeys(const std::vector<GpgME::Key> &keys);
 
     QString fingerprint() const;
     /** Set the key by fingerprint. Starts a background KeyListJob to
         retrieve the complete GpgME::Key object
     */
     void setFingerprint(const QString &fingerprint);
 
     QStringList fingerprints() const;
     /** Set the keys by fingerprint. Starts a background KeyListJob to
         retrieve the complete GpgME::Key objects
     */
     void setFingerprints(const QStringList &fingerprints);
 
     QPushButton *eraseButton();
     QPushButton *dialogButton();
 
     void setDialogCaption(const QString &caption);
     void setDialogMessage(const QString &message);
 
     bool isMultipleKeysEnabled() const;
     void setMultipleKeysEnabled(bool enable);
 
     unsigned int allowedKeys() const;
     void setAllowedKeys(unsigned int allowed);
 
     void setInitialQuery(const QString &s)
     {
         mInitialQuery = s;
     }
     const QString &initialQuery() const
     {
         return mInitialQuery;
     }
 
 Q_SIGNALS:
     void changed();
 
 private:
     void init();
     void startKeyListJob(const QStringList &fingerprints);
     void updateKeys();
 
 private Q_SLOTS:
     void slotNextKey(const GpgME::Key &key);
     void slotKeyListResult(const GpgME::KeyListResult &result);
     void slotDialogButtonClicked();
     void slotEraseButtonClicked();
 
 private:
     const QGpgME::Protocol *mOpenPGPBackend = nullptr;
     const QGpgME::Protocol *mSMIMEBackend = nullptr;
     QLabel *mLabel = nullptr;
     QPushButton *mEraseButton = nullptr;
     QPushButton *mDialogButton = nullptr;
     QString mDialogCaption, mDialogMessage, mInitialQuery;
     bool mMulti;
     unsigned int mKeyUsage;
     int mJobs;
     std::vector<GpgME::Key> mKeys;
     std::vector<GpgME::Key> mTmpKeys;
 
 private:
     class Private;
     Private *const d;
 protected:
     virtual void virtual_hook(int, void *);
 };
 
 class KLEO_EXPORT EncryptionKeyRequester : public KeyRequester
 {
     Q_OBJECT
 public:
     enum { OpenPGP = 1, SMIME = 2, AllProtocols = OpenPGP | SMIME };
 
     /**
      * Preferred constructor
      */
     explicit EncryptionKeyRequester(bool multipleKeys = false,
                                     unsigned int proto = AllProtocols,
                                     QWidget *parent = nullptr,
                                     bool onlyTrusted = true,
                                     bool onlyValid = true);
     /**
      * Constructor for Qt designer
      */
     explicit EncryptionKeyRequester(QWidget *parent);
     ~EncryptionKeyRequester();
 
     void setAllowedKeys(unsigned int proto, bool onlyTrusted = true, bool onlyValid = true);
 
 private:
     class Private;
     Private *const d;
 protected:
     void virtual_hook(int, void *) override;
 };
 
 class KLEO_EXPORT SigningKeyRequester : public KeyRequester
 {
     Q_OBJECT
 public:
     enum { OpenPGP = 1, SMIME = 2, AllProtocols = OpenPGP | SMIME };
 
     /**
      * Preferred constructor
      * @param multipleKeys whether multiple keys can be selected
      *
      * @param proto the allowed protocols, OpenPGP and/or SMIME
      * @param parent the parent widget
      * @param onlyTrusted only show trusted keys
      * @param onlyValid only show valid keys
      */
     explicit SigningKeyRequester(bool multipleKeys = false,
                                  unsigned int proto = AllProtocols,
                                  QWidget *parent = nullptr,
                                  bool onlyTrusted = true, bool onlyValid = true);
     /**
      * Constructor for Qt designer
      */
     explicit SigningKeyRequester(QWidget *parent);
     ~SigningKeyRequester();
 
     /*
      * Those parameters affect the parameters given to the key selection dialog.
      * @param proto the allowed protocols, OpenPGP and/or SMIME
      * @param onlyTrusted only show trusted keys
      * @param onlyValid only show valid keys
      */
     void setAllowedKeys(unsigned int proto, bool onlyTrusted = true, bool onlyValid = true);
 
 private:
     class Private;
     Private *const d;
 protected:
     void virtual_hook(int, void *) override;
 };
 
 }
 
diff --git a/src/ui/keyselectiondialog.h b/src/ui/keyselectiondialog.h
index 8ed9a07fa..c2837fb3e 100644
--- a/src/ui/keyselectiondialog.h
+++ b/src/ui/keyselectiondialog.h
@@ -1,200 +1,199 @@
 /*  -*- c++ -*-
     keyselectiondialog.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
 */
 
 #pragma once
 
 #include "kleo_export.h"
 
 #include <gpgme++/key.h>
 #include <qgpgme/protocol.h>
 
 #include <QDialog>
 #include <QPixmap>
 
 #include <vector>
 
 class QCheckBox;
 class QLabel;
-class QPixmap;
 class QPoint;
 class QRegExp;
 class QTimer;
 class QVBoxLayout;
 
 namespace Kleo
 {
 class KeyListView;
 class KeyListViewItem;
 }
 
 namespace GpgME
 {
 class KeyListResult;
 }
 
 namespace Kleo
 {
 
 class KLEO_EXPORT KeySelectionDialog : public QDialog
 {
     Q_OBJECT
 public:
     enum Option {
         RereadKeys = 0x01,
         ExternalCertificateManager = 0x02,
         ExtendedSelection = 0x04,
         RememberChoice = 0x08
     };
     Q_DECLARE_FLAGS(Options, Option)
 
     enum KeyUsage {
         PublicKeys = 1,
         SecretKeys = 2,
         EncryptionKeys = 4,
         SigningKeys = 8,
         ValidKeys = 16,
         TrustedKeys = 32,
         CertificationKeys = 64,
         AuthenticationKeys = 128,
         OpenPGPKeys = 256,
         SMIMEKeys = 512,
         AllKeys = PublicKeys | SecretKeys | OpenPGPKeys | SMIMEKeys,
         ValidEncryptionKeys = AllKeys | EncryptionKeys | ValidKeys,
         ValidTrustedEncryptionKeys = AllKeys | EncryptionKeys | ValidKeys | TrustedKeys
     };
 
     explicit KeySelectionDialog(QWidget *parent = nullptr, Options options = Options());
 
     KeySelectionDialog(const QString &title,
                        const QString &text,
                        const std::vector<GpgME::Key> &selectedKeys = std::vector<GpgME::Key>(),
                        unsigned int keyUsage = AllKeys,
                        bool extendedSelection = false,
                        bool rememberChoice = false,
                        QWidget *parent = nullptr,
                        bool modal = true);
     KeySelectionDialog(const QString &title,
                        const QString &text,
                        const QString &initialPattern,
                        const std::vector<GpgME::Key> &selectedKeys,
                        unsigned int keyUsage = AllKeys,
                        bool extendedSelection = false,
                        bool rememberChoice = false,
                        QWidget *parent = nullptr,
                        bool modal = true);
     KeySelectionDialog(const QString &title,
                        const QString &text,
                        const QString &initialPattern,
                        unsigned int keyUsage = AllKeys,
                        bool extendedSelection = false,
                        bool rememberChoice = false,
                        QWidget *parent = nullptr,
                        bool modal = true);
     ~KeySelectionDialog();
 
     void setText(const QString &text);
 
     void setKeys(const std::vector<GpgME::Key> &keys);
 
     /** Returns the key ID of the selected key in single selection mode.
         Otherwise it returns a null key. */
     const GpgME::Key &selectedKey() const;
 
     QString fingerprint() const;
 
     /** Returns a list of selected key IDs. */
     const std::vector<GpgME::Key> &selectedKeys() const
     {
         return mSelectedKeys;
     }
 
     /// Return all the selected fingerprints
     QStringList fingerprints() const;
 
     /// Return the selected openpgp fingerprints
     QStringList pgpKeyFingerprints() const;
     /// Return the selected smime fingerprints
     QStringList smimeFingerprints() const;
 
     bool rememberSelection() const;
 
     // Could be used by derived classes to insert their own widget
     QVBoxLayout *topLayout() const
     {
         return mTopLayout;
     }
 
 private Q_SLOTS:
     void slotRereadKeys();
     void slotStartCertificateManager(const QString &query = QString());
     void slotStartSearchForExternalCertificates()
     {
         slotStartCertificateManager(mInitialQuery);
     }
     void slotKeyListResult(const GpgME::KeyListResult &);
     void slotSelectionChanged();
     void slotCheckSelection()
     {
         slotCheckSelection(nullptr);
     }
     void slotCheckSelection(Kleo::KeyListViewItem *);
     void slotRMB(Kleo::KeyListViewItem *, const QPoint &);
     void slotRecheckKey();
     void slotTryOk();
     void slotOk();
     void slotCancel();
     void slotSearch(const QString &text);
     void slotSearch();
     void slotFilter();
 
 private:
     void filterByKeyID(const QString &keyID);
     void filterByKeyIDOrUID(const QString &keyID);
     void filterByUID(const QString &uid);
     void showAllItems();
 
     void connectSignals();
     void disconnectSignals();
 
     void startKeyListJobForBackend(const QGpgME::Protocol *, const std::vector<GpgME::Key> &, bool);
     void startValidatingKeyListing();
 
     void setUpUI(Options options, const QString &);
     void init(bool, bool, const QString &, const QString &);
 
 private:
     QVBoxLayout *mTopLayout = nullptr;
     QLabel *mTextLabel = nullptr;
     Kleo::KeyListView *mKeyListView = nullptr;
     Kleo::KeyListViewItem *mCurrentContextMenuItem = nullptr;
     QCheckBox *mRememberCB = nullptr;
     QPushButton *mOkButton = nullptr;
 
     const QGpgME::Protocol *mOpenPGPBackend = nullptr;
     const QGpgME::Protocol *mSMIMEBackend = nullptr;
     std::vector<GpgME::Key> mSelectedKeys, mKeysToCheck;
     unsigned int mKeyUsage;
     QTimer *mCheckSelectionTimer = nullptr;
     QTimer *mStartSearchTimer = nullptr;
     // cross-eventloop temporaries:
     QString mSearchText;
     const QString mInitialQuery;
     int mTruncated = 0,
         mListJobCount = 0,
         mSavedOffsetY = 0;
 };
 
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Kleo::KeySelectionDialog::Options)