diff --git a/autotests/abstractkeylistmodeltest.h b/autotests/abstractkeylistmodeltest.h
index a2b243b0d..697e5ce9b 100644
--- a/autotests/abstractkeylistmodeltest.h
+++ b/autotests/abstractkeylistmodeltest.h
@@ -1,40 +1,38 @@
 /*
     autotests/abstractkeylistmodeltest.h
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef ABSTRACTKEYLISTMODELTEST_H
-#define ABSTRACTKEYLISTMODELTEST_H
+#pragma once
 
 #include <QObject>
 
 namespace Kleo
 {
 class AbstractKeyListModel;
 }
 
 class AbstractKeyListModelTest: public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void testCreation();
     void testSetKeys();
     void testSetGroups();
     void testKeys();
     void testIndex();
     void testIndexForGroup();
     void testAddGroup();
     void testSetData();
     void testRemoveGroup();
     void testClear();
 
 private:
     virtual Kleo::AbstractKeyListModel *createModel() = 0;
 };
 
-#endif // ABSTRACTKEYLISTMODELTEST_H
diff --git a/src/kleo/checksumdefinition.h b/src/kleo/checksumdefinition.h
index 34ea079af..1ca9f8b02 100644
--- a/src/kleo/checksumdefinition.h
+++ b/src/kleo/checksumdefinition.h
@@ -1,110 +1,108 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     checksumdefinition.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_CHECKSUMDEFINITION_H__
-#define __KLEO_CHECKSUMDEFINITION_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <QString>
 #include <QStringList>
 
 #include <memory>
 #include <vector>
 
 class QProcess;
 
 namespace Kleo
 {
 
 class KLEO_EXPORT ChecksumDefinition
 {
 protected:
     ChecksumDefinition(const QString &id, const QString &label, const QString &outputFileName, const QStringList &extensions);
 public:
     virtual ~ChecksumDefinition();
 
     enum ArgumentPassingMethod {
         CommandLine,
         NewlineSeparatedInputFile,
         NullSeparatedInputFile,
 
         NumArgumentPassingMethods
     };
 
     QString id() const
     {
         return m_id;
     }
     QString label() const
     {
         return m_label;
     }
 
     const QStringList &patterns() const
     {
         return m_patterns;
     }
     QString outputFileName() const
     {
         return m_outputFileName;
     }
 
     QString createCommand() const;
     ArgumentPassingMethod createCommandArgumentPassingMethod() const
     {
         return m_createMethod;
     }
 
     QString verifyCommand() const;
     ArgumentPassingMethod verifyCommandArgumentPassingMethod() const
     {
         return m_verifyMethod;
     }
 
     bool startCreateCommand(QProcess *process, const QStringList &files) const;
     bool startVerifyCommand(QProcess *process, const QStringList &files) const;
 
     static QString installPath();
     static void setInstallPath(const QString &ip);
 
     static std::vector< std::shared_ptr<ChecksumDefinition> > getChecksumDefinitions();
     static std::vector< std::shared_ptr<ChecksumDefinition> > getChecksumDefinitions(QStringList &errors);
 
     static std::shared_ptr<ChecksumDefinition> getDefaultChecksumDefinition(const std::vector< std::shared_ptr<ChecksumDefinition> > &available);
     static void setDefaultChecksumDefinition(const std::shared_ptr<ChecksumDefinition> &checksumDefinition);
 
 protected:
     void setCreateCommandArgumentPassingMethod(ArgumentPassingMethod method)
     {
         m_createMethod = method;
     }
     void setVerifyCommandArgumentPassingMethod(ArgumentPassingMethod method)
     {
         m_verifyMethod = method;
     }
 
 private:
     virtual QString doGetCreateCommand() const = 0;
     virtual QString doGetVerifyCommand() const = 0;
     virtual QStringList doGetCreateArguments(const QStringList &files) const = 0;
     virtual QStringList doGetVerifyArguments(const QStringList &files) const = 0;
 private:
     const QString m_id;
     const QString m_label;
     const QString m_outputFileName;
     const QStringList m_patterns;
     ArgumentPassingMethod m_createMethod = CommandLine;
     ArgumentPassingMethod m_verifyMethod = CommandLine;
 };
 
 }
 
-#endif /* __KLEO_CHECKSUMDEFINITION_H__ */
 
diff --git a/src/kleo/debug.h b/src/kleo/debug.h
index 8f4fc0ba9..d108f4a81 100644
--- a/src/kleo/debug.h
+++ b/src/kleo/debug.h
@@ -1,25 +1,23 @@
 /*
     kleo/debug.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef LIBKLEO_DEBUG_H
-#define LIBKLEO_DEBUG_H
+#pragma once
 
 #include "kleo_export.h"
 
 namespace Kleo
 {
 class KeyGroup;
 }
 
 class QDebug;
 
 KLEO_EXPORT QDebug operator<<(QDebug debug, const Kleo::KeyGroup &group);
 
-#endif // LIBKLEO_DEBUG_H
diff --git a/src/kleo/defaultkeyfilter.h b/src/kleo/defaultkeyfilter.h
index f2d442efd..edba64a01 100644
--- a/src/kleo/defaultkeyfilter.h
+++ b/src/kleo/defaultkeyfilter.h
@@ -1,138 +1,136 @@
 /*
     defaultkeyfilter.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_DEFAULTKEYFILTER_H__
-#define __KLEO_DEFAULTKEYFILTER_H__
+#pragma once
 
 #include "keyfilter.h"
 
 #include "kleo_export.h"
 
 #include <QFont>
 #include <QString>
 #include <QColor>
 #include <QScopedPointer>
 
 #include <gpgme++/key.h>
 
 namespace Kleo
 {
 
 /** Default implementation of key filter class. */
 class KLEO_EXPORT DefaultKeyFilter : public KeyFilter
 {
 public:
     DefaultKeyFilter();
     ~DefaultKeyFilter() override;
 
     /** Used for bool checks */
     enum TriState {
         DoesNotMatter = 0,
         Set = 1,
         NotSet = 2
     };
 
     /** Used for level checks */
     enum LevelState {
         LevelDoesNotMatter = 0,
         Is = 1,
         IsNot = 2,
         IsAtLeast = 3,
         IsAtMost = 4
     };
 
     bool matches(const GpgME::Key &key, MatchContexts ctx) const override;
 
     unsigned int specificity() const override;
     void setSpecificity(unsigned int value) const;
     QString id() const override;
     void setId(const QString &value) const;
     KeyFilter::MatchContexts availableMatchContexts() const override;
     void setMatchContexts(KeyFilter::MatchContexts value) const;
 
     QColor fgColor() const override;
     void setFgColor(const QColor &value) const;
 
     QColor bgColor() const override;
     void setBgColor(const QColor &value) const;
 
     FontDescription  fontDescription() const override;
     QString name() const override;
     void setName(const QString &value) const;
     QString icon() const override;
     void setIcon(const QString &value) const;
     QFont font() const;
     void setFont(const QFont &value) const;
 
     TriState revoked() const;
     TriState expired() const;
     TriState invalid() const;
     TriState disabled() const;
     TriState root() const;
     TriState canEncrypt() const;
     TriState canSign() const;
     TriState canCertify() const;
     TriState canAuthenticate() const;
     TriState qualified() const;
     TriState cardKey() const;
     TriState hasSecret() const;
     TriState isOpenPGP() const;
     TriState wasValidated() const;
     TriState isDeVS() const;
     TriState isBad() const;
 
     LevelState ownerTrust() const;
     GpgME::Key::OwnerTrust ownerTrustReferenceLevel() const;
 
     LevelState validity() const;
     GpgME::UserID::Validity validityReferenceLevel() const;
     bool italic() const;
     bool bold() const;
     bool strikeOut() const;
     bool useFullFont() const;
 
     void setRevoked(const TriState) const;
     void setExpired(const TriState) const;
     void setInvalid(const TriState) const;
     void setDisabled(const TriState) const;
     void setRoot(const TriState) const;
     void setCanEncrypt(const TriState) const;
     void setCanSign(const TriState) const;
     void setCanCertify(const TriState) const;
     void setCanAuthenticate(const TriState) const;
     void setQualified(const TriState) const;
     void setCardKey(const TriState) const;
     void setHasSecret(const TriState) const;
     void setIsOpenPGP(const TriState) const;
     void setWasValidated(const TriState) const;
     void setIsDeVs(const TriState) const;
     void setIsBad(const TriState) const;
 
     void setOwnerTrust(const LevelState) const;
     void setOwnerTrustReferenceLevel(const GpgME::Key::OwnerTrust) const;
 
     void setValidity(const LevelState) const;
     void setValidityReferenceLevel(const GpgME::UserID::Validity) const;
 
     void setItalic(bool value) const;
     void setBold(bool value) const;
     void setStrikeOut(bool value) const;
     void setUseFullFont(bool value) const;
 
 
 private:
     class Private;
     const QScopedPointer<Private> d_ptr;
 };
 
 } // namespace Kleo
-#endif
diff --git a/src/kleo/defaultkeygenerationjob.h b/src/kleo/defaultkeygenerationjob.h
index ccea771e5..64f67a9ee 100644
--- a/src/kleo/defaultkeygenerationjob.h
+++ b/src/kleo/defaultkeygenerationjob.h
@@ -1,64 +1,62 @@
 /*  This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef LIBKLEO_DEFAULTKEYGENERATIONJOB_H
-#define LIBKLEO_DEFAULTKEYGENERATIONJOB_H
+#pragma once
 
 #include <qgpgme/job.h>
 
 #include <kleo_export.h>
 
 namespace GpgME {
 class KeyGenerationResult;
 }
 
 namespace Kleo {
 
 /**
  * Generates a PGP RSA/2048 bit key pair for given name and email address.
  *
  * @since 5.4
  */
 class KLEO_EXPORT DefaultKeyGenerationJob : public QGpgME::Job
 {
     Q_OBJECT
 public:
     explicit DefaultKeyGenerationJob(QObject *parent = nullptr);
     ~DefaultKeyGenerationJob() override;
 
     /**
      * Set key passphrase
      *
      * Use this method to specify custom passphrase, including an empty
      * one. If no passphrase (not even empty) is specified, gpg me will
      * automatically prompt for passphrase using Pinentry dialog.
      */
     void setPassphrase(const QString &passphrase);
 
     GpgME::Error start(const QString &email, const QString &name);
 
     QString auditLogAsHtml() const override;
     GpgME::Error auditLogError() const override;
 
 
 public Q_SLOTS:
     void slotCancel() override;
 
 Q_SIGNALS:
     void result(const GpgME::KeyGenerationResult &result, const QByteArray &pubkeyData,
                 const QString &auditLogAsHtml, const GpgME::Error &auditLogError);
 
 protected:
     bool eventFilter(QObject *watched, QEvent *event) override;
 
 private:
     class Private;
     Private * const d;
 };
 
 }
 
-#endif
diff --git a/src/kleo/dn.h b/src/kleo/dn.h
index 7d51b8207..3f1f52bad 100644
--- a/src/kleo/dn.h
+++ b/src/kleo/dn.h
@@ -1,140 +1,138 @@
 /*
     dn.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_DN_H__
-#define __KLEO_DN_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <QString>
 #include <QVector>
 
 #include <QStringList>
 class QWidget;
 
 namespace Kleo
 {
 class DNAttributeOrderConfigWidget;
 }
 
 namespace Kleo
 {
 
 /**
    @short DN Attribute mapper
 */
 class KLEO_EXPORT DNAttributeMapper
 {
     DNAttributeMapper();
     ~DNAttributeMapper();
 public:
     static const DNAttributeMapper *instance();
 
     QString name2label(const QString &s) const;
     QStringList names() const;
 
     const QStringList &attributeOrder() const;
 
     void setAttributeOrder(const QStringList &order);
 
     DNAttributeOrderConfigWidget *configWidget(QWidget *parent = nullptr) const;
 
 private:
     class Private;
     Private *d;
     static DNAttributeMapper *mSelf;
 };
 
 /**
    @short DN parser and reorderer
 */
 class KLEO_EXPORT DN
 {
 public:
     class Attribute;
     using AttributeList = QVector<Attribute>;
     using const_iterator = AttributeList::const_iterator;
 
     DN();
     explicit DN(const QString &dn);
     explicit DN(const char *utf8DN);
     DN(const DN &other);
     ~DN();
 
     const DN &operator=(const DN &other);
 
     /** @return the value in rfc-2253-escaped form */
     static QString escape(const QString &value);
 
     /** @return the DN in a reordered form, according to the settings in
         the [DN] group of the application's config file */
     QString prettyDN() const;
     /** @return the DN in the original form */
     QString dn() const;
     /**
        \overload
        Uses \a sep as separator (default: ,)
     */
     QString dn(const QString &sep) const;
 
     QString operator[](const QString &attr) const;
 
     void append(const Attribute &attr);
 
     const_iterator begin() const;
     const_iterator end() const;
 
 private:
     void detach();
 private:
     class Private;
     Private *d;
 };
 
 class KLEO_EXPORT DN::Attribute
 {
 public:
     using List = DN::AttributeList;
 
     explicit Attribute(const QString &name = QString(), const QString &value = QString())
         : mName(name.toUpper()), mValue(value) {}
     Attribute(const Attribute &other)
         : mName(other.name()), mValue(other.value()) {}
 
     const Attribute &operator=(const Attribute &other)
     {
         if (this != &other) {
             mName = other.name();
             mValue = other.value();
         }
         return *this;
     }
 
     const QString &name() const
     {
         return mName;
     }
     const QString &value() const
     {
         return mValue;
     }
 
     void setValue(const QString &value)
     {
         mValue = value;
     }
 
 private:
     QString mName;
     QString mValue;
 };
 
 }
 
-#endif // __KLEO_DN_H__
diff --git a/src/kleo/enum.h b/src/kleo/enum.h
index 236c5cfbc..30d40078b 100644
--- a/src/kleo/enum.h
+++ b/src/kleo/enum.h
@@ -1,89 +1,87 @@
 /*
     kleo/enum.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_ENUM_H__
-#define __KLEO_ENUM_H__
+#pragma once
 
 #include "kleo_export.h"
 
 class QString;
 #include <QStringList>
 
 namespace GpgME {
 class Key;
 class UserID;
 }
 
 namespace Kleo
 {
 
 enum CryptoMessageFormat {
     InlineOpenPGPFormat = 1,
     OpenPGPMIMEFormat = 2,
     SMIMEFormat = 4,
     SMIMEOpaqueFormat = 8,
     AnyOpenPGP = InlineOpenPGPFormat | OpenPGPMIMEFormat,
     AnySMIME = SMIMEOpaqueFormat | SMIMEFormat,
     AutoFormat = AnyOpenPGP | AnySMIME
 };
 
 KLEO_EXPORT QString cryptoMessageFormatToLabel(CryptoMessageFormat f);
 
 KLEO_EXPORT const char *cryptoMessageFormatToString(CryptoMessageFormat f);
 KLEO_EXPORT QStringList cryptoMessageFormatsToStringList(unsigned int f);
 KLEO_EXPORT CryptoMessageFormat stringToCryptoMessageFormat(const QString &s);
 KLEO_EXPORT unsigned int stringListToCryptoMessageFormats(const QStringList &sl);
 
 enum Action {
     Conflict, DoIt, DontDoIt, Ask, AskOpportunistic, Impossible
 };
 
 enum EncryptionPreference {
     UnknownPreference = 0,
     NeverEncrypt = 1,
     AlwaysEncrypt = 2,
     AlwaysEncryptIfPossible = 3,
     AlwaysAskForEncryption = 4,
     AskWheneverPossible = 5,
     MaxEncryptionPreference = AskWheneverPossible
 };
 
 KLEO_EXPORT QString encryptionPreferenceToLabel(EncryptionPreference pref);
 KLEO_EXPORT const char *encryptionPreferenceToString(EncryptionPreference pref);
 KLEO_EXPORT EncryptionPreference stringToEncryptionPreference(const QString &str);
 
 enum SigningPreference {
     UnknownSigningPreference = 0,
     NeverSign = 1,
     AlwaysSign = 2,
     AlwaysSignIfPossible = 3,
     AlwaysAskForSigning = 4,
     AskSigningWheneverPossible = 5,
     MaxSigningPreference = AskSigningWheneverPossible
 };
 
 KLEO_EXPORT QString signingPreferenceToLabel(SigningPreference pref);
 KLEO_EXPORT const char *signingPreferenceToString(SigningPreference pref);
 KLEO_EXPORT SigningPreference stringToSigningPreference(const QString &str);
 
 enum TrustLevel {
     Level0,
     Level1,
     Level2,
     Level3,
     Level4
 };
 
 KLEO_EXPORT TrustLevel trustLevel(const GpgME::Key &key);
 KLEO_EXPORT TrustLevel trustLevel(const GpgME::UserID &uid);
 
 
 }
 
-#endif // __KLEO_CRYPTOBACKEND_H__
diff --git a/src/kleo/kconfigbasedkeyfilter.h b/src/kleo/kconfigbasedkeyfilter.h
index c30712788..44adf37bb 100644
--- a/src/kleo/kconfigbasedkeyfilter.h
+++ b/src/kleo/kconfigbasedkeyfilter.h
@@ -1,28 +1,26 @@
 /*
     kconfigbasedkeyfilter.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_KCONFIGBASEDKEYFILTER_H__
-#define __KLEO_KCONFIGBASEDKEYFILTER_H__
+#pragma once
 
 #include "defaultkeyfilter.h"
 
 class KConfigGroup;
 
 namespace Kleo
 {
 
 class KLEO_EXPORT KConfigBasedKeyFilter : public DefaultKeyFilter
 {
 public:
     explicit KConfigBasedKeyFilter(const KConfigGroup &group);
 };
 
 }
 
-#endif // __KLEO_KCONFIGBASEDKEYFILTER_H__
diff --git a/src/kleo/keyfilter.h b/src/kleo/keyfilter.h
index 36994c64f..edb0b596d 100644
--- a/src/kleo/keyfilter.h
+++ b/src/kleo/keyfilter.h
@@ -1,98 +1,96 @@
 /*
     keyfilter.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_KEYFILTER_H__
-#define __KLEO_KEYFILTER_H__
+#pragma once
 
 #include <QFlags>
 
 #include <algorithm>
 
 #include <kleo_export.h>
 
 namespace GpgME
 {
 class Key;
 }
 
 class QFont;
 class QColor;
 class QString;
 
 namespace Kleo
 {
 
 /**
    @short An abstract base class key filters
 
 */
 class KLEO_EXPORT KeyFilter
 {
 public:
     virtual ~KeyFilter() {}
 
     enum MatchContext {
         NoMatchContext = 0x0,
         Appearance = 0x1,
         Filtering = 0x2,
 
         AnyMatchContext = Appearance | Filtering
     };
     Q_DECLARE_FLAGS(MatchContexts, MatchContext)
 
     virtual bool matches(const GpgME::Key &key, MatchContexts ctx) const = 0;
 
     virtual unsigned int specificity() const = 0;
     virtual QString id() const = 0;
     virtual MatchContexts availableMatchContexts() const = 0;
 
     // not sure if we want these here, but for the time being, it's
     // the easiest way:
     virtual QColor fgColor() const = 0;
     virtual QColor bgColor() const = 0;
     virtual QString name() const = 0;
     virtual QString icon() const = 0;
 
     class FontDescription
     {
     public:
         FontDescription();
         FontDescription(const FontDescription &other);
         FontDescription &operator=(const FontDescription &other)
         {
             FontDescription copy(other);
             swap(copy);
             return *this;
         }
         ~FontDescription();
 
         static FontDescription create(bool bold, bool italic, bool strikeOut);
         static FontDescription create(const QFont &font, bool bold, bool italic, bool strikeOut);
 
         QFont font(const QFont &base) const;
 
         FontDescription resolve(const FontDescription &other) const;
 
         void swap(FontDescription &other)
         {
             std::swap(this->d, other.d);
         }
         struct Private;
     private:
         Private *d;
     };
 
     virtual FontDescription fontDescription() const = 0;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(KeyFilter::MatchContexts)
 
 }
 
-#endif // __KLEO_KEYFILTER_H__
diff --git a/src/kleo/keyfiltermanager.h b/src/kleo/keyfiltermanager.h
index 65cdb3164..52738232d 100644
--- a/src/kleo/keyfiltermanager.h
+++ b/src/kleo/keyfiltermanager.h
@@ -1,69 +1,67 @@
 /*
     keyfiltermanager.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_KEYFILTERMANAGER_H__
-#define __KLEO_KEYFILTERMANAGER_H__
+#pragma once
 
 #include "kleo_export.h"
 #include <QObject>
 
 #include <libkleo/keyfilter.h>
 
 #include <memory>
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 }
 
 class QAbstractItemModel;
 class QModelIndex;
 class QFont;
 class QColor;
 class QIcon;
 
 namespace Kleo
 {
 
 class KLEO_EXPORT KeyFilterManager : public QObject
 {
     Q_OBJECT
 protected:
     explicit KeyFilterManager(QObject *parent = nullptr);
     ~KeyFilterManager();
 
 public:
     static KeyFilterManager *instance();
 
     const std::shared_ptr<KeyFilter> &filterMatching(const GpgME::Key &key, KeyFilter::MatchContexts contexts) const;
     std::vector<std::shared_ptr<KeyFilter>> filtersMatching(const GpgME::Key &key, KeyFilter::MatchContexts contexts) const;
 
     QAbstractItemModel *model() const;
 
     const std::shared_ptr<KeyFilter> &keyFilterByID(const QString &id) const;
     const std::shared_ptr<KeyFilter> &fromModelIndex(const QModelIndex &mi) const;
     QModelIndex toModelIndex(const std::shared_ptr<KeyFilter> &kf) const;
 
     void reload();
 
     QFont font(const GpgME::Key &key, const QFont &baseFont) const;
     QColor bgColor(const GpgME::Key &key) const;
     QColor fgColor(const GpgME::Key &key) const;
     QIcon icon(const GpgME::Key &key) const;
 
     class Private;
 private:
     Private *d;
     static KeyFilterManager *mSelf;
 };
 
 }
 
-#endif // __KLEO_KEYFILTERMANAGER_H__
diff --git a/src/kleo/keygroup.h b/src/kleo/keygroup.h
index 4e409f120..ccbbea679 100644
--- a/src/kleo/keygroup.h
+++ b/src/kleo/keygroup.h
@@ -1,81 +1,79 @@
 /*
     kleo/keygroup.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef LIBKLEO_KEYGROUP_H
-#define LIBKLEO_KEYGROUP_H
+#pragma once
 
 #include "kleo_export.h"
 
 #include <Libkleo/Predicates>
 
 #include <memory>
 #include <set>
 #include <vector>
 
 class QString;
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 
 class KLEO_EXPORT KeyGroup
 {
 public:
     typedef QString Id;
     typedef std::set<GpgME::Key, _detail::ByFingerprint<std::less>> Keys;
 
     enum Source {
         UnknownSource,
         ApplicationConfig,
         GnuPGConfig,
         Tags
     };
 
     KeyGroup();
     ~KeyGroup();
 
     explicit KeyGroup(Id id, const QString &name, const std::vector<GpgME::Key> &keys, Source source);
 
     KeyGroup(const KeyGroup &other);
     KeyGroup &operator=(const KeyGroup &other);
 
     KeyGroup(KeyGroup &&other);
     KeyGroup &operator=(KeyGroup &&other);
 
     bool isNull() const;
 
     Id id() const;
     Source source() const;
 
     void setName(const QString &name);
     QString name() const;
 
     void setKeys(const Keys &keys);
     void setKeys(const std::vector<GpgME::Key> &keys);
     const Keys &keys() const;
 
     void setIsImmutable(bool isImmutable);
     bool isImmutable() const;
 
     bool insert(const GpgME::Key &key);
     bool erase(const GpgME::Key &key);
 
 private:
     class Private;
     std::unique_ptr<Private> d;
 };
 
 }
 
-#endif // LIBKLEO_KEYGROUP_H
diff --git a/src/kleo/keyresolver.h b/src/kleo/keyresolver.h
index 1c1dd988e..2518f34b9 100644
--- a/src/kleo/keyresolver.h
+++ b/src/kleo/keyresolver.h
@@ -1,202 +1,200 @@
 /*  -*- c++ -*-
     keyresolver.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2018 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_KEYRESOLVER_H__
-#define __KLEO_KEYRESOLVER_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <Libkleo/Enum>
 
 #include <QMap>
 #include <QObject>
 #include <QString>
 #include <QStringList>
 
 #include <gpgme++/global.h>
 
 #include <memory>
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 /**
  * Class to find Keys for E-Mail encryption.
  *
  * The KeyResolver uses the Keycache to find keys for signing
  * or encryption.
  *
  * Overrides can be provided for address book integration if the
  * format is not Auto overrides will only be respected if they
  * match the format provided in the constructor.
  *
  * If no override key is provided for an address the key
  * with a uid that matches the address and has the highest
  * validity is used. If both keys have the same validity
  * the newest subkey is used.
  *
  * The KeyResolver also supports groups so the number of
  * encryption keys does not necessarily
  * need to match the amount of sender addresses. For this reason
  * maps are used heavily to map:
  *
  * CryptoFormat
  *   - Addresses
  *   -- For each Address a List of Keys
  *
  * As a caller you should iterate over the CryptoFormats and
  * send one message for each format for the recipients and signed
  * by the signing keys.
  *
  * If the CryptoMessageFormat is Auto the minimum number
  * of CryptoMessageFormats is returned that respects all overrides.
  *
  * -----
  * Planned:
  *
  * As the central place to manage mail encryption / signing keys
  * the Keyresolver will also show various warning / nagging messages
  * and offer solutions if nagging is not explicitly turned off.
  * These include:
  *
  * - If own keys or subkeys are about to expire:
  *   Offer to extend their expiration date.
  *
  * - (S/MIME) If they are about to expire: Offer
  *   to generate a new CSR.
  *
  * - If a user has not marked a key as backed up and
  *   uses it for encryption for several mails.
  *
  * - If a user has multiple keys for a sender address and they
  *   are not cross signed. Offer to cross sign / publish.
  */
 class KLEO_EXPORT KeyResolver : public QObject
 {
     Q_OBJECT
 
 public:
     /** Creates a new key resolver object.
      *
      * @param encrypt: Should encryption keys be selected.
      * @param sign: Should signing keys be selected.
      * @param format: A specific key protocol (OpenPGP, S/MIME) for selection. Default: Both protocols.
      * @param allowMixed: Specify if multiple message formats may be resolved.
      **/
     explicit KeyResolver(bool encrypt, bool sign,
                          GpgME::Protocol format = GpgME::UnknownProtocol,
                          bool allowMixed = true);
     ~KeyResolver() override;
 
     /**
      *  Set the list of recipient addresses. Also looks
      *  up possible keys, but doesn't interact with the user.
      *
      *  @param addresses: A list of unnormalized addresses
     */
     void setRecipients(const QStringList &addresses);
 
     /**
      * Set the senders address.
      *
      * Sender address will be added to encryption keys and used
      * for signing key resolution if the signing keys are not
      * explicitly set through setSigningKeys.
      *
      * @param sender: The sender of this message.
      */
     void setSender(const QString &sender);
 
     /**
      * Set up possible override keys for recipients / sender
      * addresses. The keys for the fingerprints are looked
      * up and used when found. Does not interact with the user.
      *
      * @param overrides: A map of \<protocol\> -> (\<address\> \<fingerprints\>)
     */
     void setOverrideKeys(const QMap<GpgME::Protocol, QMap<QString, QStringList> > &overrides);
 
     /**
      * Set explicit signing keys. If this was set for a
      * protocol the sender address will be only used as an additional encryption
      * recipient for that protocol. */
     void setSigningKeys(const QStringList &fingerprints);
 
     /**
      * Set the minimum user id validity for autoresolution.
      *
      * The default value is marginal
      *
      * @param validity int representation of a GpgME::UserID::Validity.
      */
     void setMinimumValidity(int validity);
 
     /**
      * Get the encryption keys after resolution.
      *
      * @return the resolved sender / key pairs for encryption by format.
      */
     QMap <GpgME::Protocol, QMap<QString, std::vector<GpgME::Key> > > encryptionKeys() const;
 
     /**
      * Get the signing keys to use after resolution.
      *
      * @return the resolved resolved sender / key pairs for signing
      *         by format.
      */
     QMap <GpgME::Protocol, std::vector<GpgME::Key> > signingKeys() const;
 
     /**
      * Starts the key resolving procedure. Emits keysResolved on success or
      * error.
      *
      * @param showApproval: If set to true a dialog listing the keys
      *                      will always be shown.
      * @param parentWidget: Optional, a Widget to use as parent for dialogs.
      */
     void start(bool showApproval, QWidget *parentWidget = nullptr);
 
     /**
      * Set window flags for a possible dialog.
      */
     void setDialogWindowFlags(Qt::WindowFlags flags);
 
     /**
      * Set the protocol that is preferred to be displayed first when
      * it is not clear from the keys. E.g. if both OpenPGP and S/MIME
      * can be resolved.
      */
     void setPreferredProtocol(GpgME::Protocol proto);
 
 Q_SIGNALS:
     /**
      * Emitted when key resolution finished.
      *
      * @param success: The general result. If true continue sending,
      *                 if false abort.
      * @param sendUnencrypted: If there could be no key found for one of
      *                         the recipients the user was queried if the
      *                         mail should be sent out unencrypted.
      *                         sendUnencrypted is true if the user agreed
      *                         to this.*/
     void keysResolved(bool success, bool sendUnencrypted);
 
 private:
     class Private;
     std::unique_ptr<Private> d;
 };
 } // namespace Kleo
 
-#endif // __KLEO_KEYRESOLVER_H__
 
diff --git a/src/kleo/keyresolvercore.h b/src/kleo/keyresolvercore.h
index f212b84f0..490d1c69d 100644
--- a/src/kleo/keyresolvercore.h
+++ b/src/kleo/keyresolvercore.h
@@ -1,72 +1,70 @@
 /*  -*- c++ -*-
     kleo/keyresolvercore.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2018 Intevation GmbH
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __LIBKLEO_KEYRESOLVERCORE_H__
-#define __LIBKLEO_KEYRESOLVERCORE_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <QMap>
 
 #include <gpgme++/global.h>
 
 #include <memory>
 #include <vector>
 
 class QString;
 class QStringList;
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 
 class KLEO_EXPORT KeyResolverCore
 {
 public:
     explicit KeyResolverCore(bool encrypt, bool sign,
                              GpgME::Protocol format = GpgME::UnknownProtocol);
     ~KeyResolverCore();
 
     void setSender(const QString &sender);
     QString normalizedSender() const;
 
     void setRecipients(const QStringList &addresses);
 
     void setSigningKeys(const QStringList &fingerprints);
 
     void setOverrideKeys(const QMap<GpgME::Protocol, QMap<QString, QStringList> > &overrides);
 
     void setAllowMixedProtocols(bool allowMixed);
 
     void setPreferredProtocol(GpgME::Protocol proto);
 
     void setMinimumValidity(int validity);
 
     bool resolve();
 
     QMap<GpgME::Protocol, std::vector<GpgME::Key> > signingKeys() const;
 
     QMap<GpgME::Protocol, QMap<QString, std::vector<GpgME::Key> > > encryptionKeys() const;
 
     QStringList unresolvedRecipients(GpgME::Protocol protocol) const;
 
 private:
     class Private;
     std::unique_ptr<Private> d;
 };
 
 } // namespace Kleo
 
-#endif // __LIBKLEO_KEYRESOLVER_H__
diff --git a/src/kleo/kleoexception.h b/src/kleo/kleoexception.h
index 63e69a48b..b6d11dad1 100644
--- a/src/kleo/kleoexception.h
+++ b/src/kleo/kleoexception.h
@@ -1,59 +1,57 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     exception.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_EXCEPTION_H__
-#define __KLEO_EXCEPTION_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <gpg-error.h>
 #include <gpgme++/exception.h>
 
 #include <QString>
 
 namespace Kleo
 {
 
 class KLEO_EXPORT Exception : public GpgME::Exception
 {
 public:
     Exception(gpg_error_t e, const std::string &msg, Options opt = NoOptions)
         : GpgME::Exception(GpgME::Error(e), msg, opt) {}
     Exception(gpg_error_t e, const char *msg, Options opt = NoOptions)
         : GpgME::Exception(GpgME::Error(e), msg, opt) {}
     Exception(gpg_error_t e, const QString &msg, Options opt = NoOptions)
         : GpgME::Exception(GpgME::Error(e), msg.toLocal8Bit().constData(), opt) {}
 
     Exception(const GpgME::Error &e, const std::string &msg)
         : GpgME::Exception(e, msg) {}
     Exception(const GpgME::Error &e, const char *msg)
         : GpgME::Exception(e, msg) {}
     Exception(const GpgME::Error &e, const QString &msg)
         : GpgME::Exception(e, msg.toLocal8Bit().constData()) {}
 
     ~Exception() throw ();
 
     const std::string &messageLocal8Bit() const
     {
         return GpgME::Exception::message();
     }
     gpg_error_t error_code() const
     {
         return error().encodedError();
     }
 
     QString message() const
     {
         return QString::fromLocal8Bit(GpgME::Exception::message().c_str());
     }
 };
 
 }
 
-#endif /* __KLEO_EXCEPTION_H__ */
diff --git a/src/kleo/oidmap.h b/src/kleo/oidmap.h
index 83b51db57..e4b39a49b 100644
--- a/src/kleo/oidmap.h
+++ b/src/kleo/oidmap.h
@@ -1,41 +1,39 @@
 /*
     oidmap.h
 
     This file is part of libkleo, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_OIDMAP_H__
-#define __KLEO_OIDMAP_H__
+#pragma once
 
 #include "kleo_export.h"
 
 class QString;
 
 static const struct {
     const char *name;
     const char *oid;
 } oidmap[] = {
     // keep them ordered by oid:
     { "SP", "ST" }, // hack to show the Sphinx-required/desired SP for
     // StateOrProvince, otherwise known as ST or even S
     { "NameDistinguisher", "0.2.262.1.10.7.20" },
     { "EMAIL", "1.2.840.113549.1.9.1" },
     { "SN", "2.5.4.4" },
     { "SerialNumber", "2.5.4.5" },
     { "T", "2.5.4.12" },
     { "D", "2.5.4.13" },
     { "BC", "2.5.4.15" },
     { "ADDR", "2.5.4.16" },
     { "PC", "2.5.4.17" },
     { "GN", "2.5.4.42" },
     { "Pseudo", "2.5.4.65" },
 };
 static const unsigned int numOidMaps = sizeof oidmap / sizeof * oidmap;
 
 KLEO_EXPORT const char *oidForAttributeName(const QString &attr);
 
-#endif // __KLEO_OIDMAP_H__
diff --git a/src/kleo/predicates.h b/src/kleo/predicates.h
index ebad33317..7e70a16bd 100644
--- a/src/kleo/predicates.h
+++ b/src/kleo/predicates.h
@@ -1,189 +1,187 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/predicates.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_MODELS_PREDICATES_H__
-#define __KLEOPATRA_MODELS_PREDICATES_H__
+#pragma once
 
 #include <gpgme++/key.h>
 
 #include <string>
 #include <cstring>
 #include <algorithm>
 #include <iterator>
 #include <functional>
 
 namespace Kleo
 {
 namespace _detail
 {
 
 inline int mystrcmp(const char *s1, const char *s2)
 {
     using namespace std;
     return s1 ? s2 ? strcmp(s1, s2) : 1 : s2 ? -1 : 0;
 }
 
 #define make_comparator_str_impl( Name, expr, cmp )                     \
     template <template <typename U> class Op>                           \
     struct Name {                                                       \
         typedef bool result_type;                                       \
         \
         bool operator()( const char * lhs, const char * rhs ) const {   \
             return Op<int>()( cmp, 0 );                                 \
         }                                                               \
         \
         bool operator()( const std::string & lhs, const std::string & rhs ) const { \
             return operator()( lhs.c_str(), rhs.c_str() );              \
         }                                                               \
         bool operator()( const char * lhs, const std::string & rhs ) const { \
             return operator()( lhs, rhs.c_str() );                      \
         }                                                               \
         bool operator()( const std::string & lhs, const char * rhs ) const { \
             return operator()( lhs.c_str(), rhs );                      \
         }                                                               \
         \
         template <typename T>                                           \
         bool operator()( const T & lhs, const T & rhs ) const {         \
             return operator()( (lhs expr), (rhs expr) );                \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const T & lhs, const char * rhs ) const {      \
             return operator()( (lhs expr), rhs );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const char * lhs, const T & rhs ) const {      \
             return operator()( lhs, (rhs expr) );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const T & lhs, const std::string & rhs ) const { \
             return operator()( (lhs expr), rhs );                       \
         }                                                               \
         template <typename T>                                           \
         bool operator()( const std::string & lhs, const T & rhs ) const {    \
             return operator()( lhs, (rhs expr) );                       \
         }                                                               \
     }
 
 #define make_comparator_str_fast( Name, expr )                          \
     make_comparator_str_impl( Name, expr, _detail::mystrcmp( lhs, rhs ) )
 #define make_comparator_str( Name, expr )                               \
     make_comparator_str_impl( Name, expr, qstricmp( lhs, rhs ) )
 
 make_comparator_str_fast(ByFingerprint, .primaryFingerprint());
 make_comparator_str_fast(ByKeyID, .keyID());
 make_comparator_str_fast(ByShortKeyID, .shortKeyID());
 make_comparator_str_fast(ByChainID, .chainID());
 make_comparator_str_fast(ByKeyGrip, .keyGrip());
 
 template <typename T>
 void sort_by_fpr(T &t)
 {
     std::sort(t.begin(), t.end(), ByFingerprint<std::less>());
 }
 
 template <typename T>
 void remove_duplicates_by_fpr(T &t)
 {
     t.erase(std::unique(t.begin(), t.end(), ByFingerprint<std::equal_to>()), t.end());
 }
 
 template <typename T>
 T union_by_fpr(const T &t1, const T &t2)
 {
     T result;
     result.reserve(t1.size() + t2.size());
     std::set_union(t1.begin(), t1.end(),
                    t2.begin(), t2.end(),
                    std::back_inserter(result),
                    ByFingerprint<std::less>());
     return result;
 }
 
 template <typename T>
 T union_by_fpr_dirty(const T &t1, const T &t2)
 {
     T cleaned(t1);
     sort_by_fpr(cleaned);
     remove_duplicates_by_fpr(cleaned);
     return union_by_fpr(cleaned, t2);
 }
 
 template <typename T>
 void grep_protocol(T &t, GpgME::Protocol proto)
 {
     t.erase(std::remove_if(t.begin(), t.end(),
                            [proto](const GpgME::Key &key) {
                                return key.protocol() != proto;
                            }), t.end());
 }
 
 template <typename T>
 bool any_protocol(const T &t, GpgME::Protocol proto)
 {
     return std::any_of(t.cbegin(), t.cend(),
                        [proto](const GpgME::Key &key) {
                            return key.protocol() == proto;
                        });
 }
 
 template <typename T>
 bool all_protocol(const T &t, GpgME::Protocol proto)
 {
     return std::all_of(t.cbegin(), t.cend(), 
                        [proto](const GpgME::Key &key) {
                          return key.protocol() == proto;
                        });
 }
 
 template <typename T>
 bool none_of_protocol(const T &t, GpgME::Protocol proto)
 {
     return std::none_of(t.cbegin(), t.cend(),
                         [proto](const GpgME::Key &key) {
                             return key.protocol() == proto;
                         });
 }
 
 template <typename T>
 void grep_secret(T &t)
 {
     t.erase(std::remove_if(t.begin(), t.end(), std::mem_fn(&GpgME::Key::hasSecret)), t.end());
 }
 
 template <typename T>
 bool any_secret(const T &t)
 {
     return std::any_of(t.cbegin(), t.cend(), std::mem_fn(&GpgME::Key::hasSecret));
 }
 
 template <typename T>
 bool all_secret(const T &t)
 {
     return std::all_of(t.cbegin(), t.cend(), std::mem_fn(&GpgME::Key::hasSecret));
 }
 
 template <typename T>
 bool none_of_secret(const T &t)
 {
     return std::none_of(t.cbegin(), t.cend(), std::mem_fn(&GpgME::Key::hasSecret));
 }
 
 template <typename T>
 void grep_can_encrypt(T &t)
 {
     t.erase(std::remove_if(t.begin(), t.end(),
                            [](const GpgME::Key &key) {
                                return !key.canEncrypt();
                            }), t.end());
 }
 
 }
 }
 
-#endif /* __KLEOPATRA_MODELS_PREDICATES_H__ */
diff --git a/src/kleo/stl_util.h b/src/kleo/stl_util.h
index 6c1b4eeaa..12cf0ff19 100644
--- a/src/kleo/stl_util.h
+++ b/src/kleo/stl_util.h
@@ -1,262 +1,260 @@
 /****************************************************************************
 ** SPDX-FileCopyrightText: 2001-2007 Klarälvdalens Datakonsult AB. All rights reserved.
 **
 ** This file is part of the KD Tools library.
 **
 ** SPDX-License-Identifier: GPL-2.0-or-later
 **
 **********************************************************************/
 
-#ifndef __KDTOOLSCORE_STL_UTIL_H__
-#define __KDTOOLSCORE_STL_UTIL_H__
+#pragma once
 
 #include <algorithm>
 #include <numeric>
 #include <utility>
 #include <iterator>
 #include <functional>
 
 namespace kdtools
 {
 template<typename _Iterator, typename UnaryPredicate>
 struct filter_iterator
 {
     using value_type = typename std::iterator_traits<_Iterator>::value_type;
     using reference = typename std::iterator_traits<_Iterator>::reference;
     using pointer = typename std::iterator_traits<_Iterator>::pointer;
     using difference_type = typename std::iterator_traits<_Iterator>::difference_type;
 
     filter_iterator(UnaryPredicate pred, _Iterator it, _Iterator last) : it(it), last(last), pred(pred) {}
     template<typename _OtherIter>
     filter_iterator(const filter_iterator<_OtherIter, UnaryPredicate> &other) : it(other.it), last(other.last), pred(other.pred) {}
     filter_iterator &operator++() { while (++it != last && !pred(*it)){} return *this; }
     filter_iterator operator++(int) { auto retval = *this; while(++it != last && !pred(*it)){} return retval; }
     bool operator==(filter_iterator other) const { return it == other.it; }
     bool operator!=(filter_iterator other) const { return it != other.it; }
     typename _Iterator::reference operator*() const { return *it; }
 private:
     _Iterator it, last;
     UnaryPredicate pred;
 };
 
 template<typename _Iterator, typename UnaryPredicate>
 filter_iterator<typename std::decay<_Iterator>::type,
                 UnaryPredicate>
 make_filter_iterator(UnaryPredicate &&pred, _Iterator &&it, _Iterator &&last)
 {
     return filter_iterator<typename std::decay<_Iterator>::type, 
                            UnaryPredicate>(
                 std::forward<UnaryPredicate>(pred),
                 std::forward<_Iterator>(it),
                 std::forward<_Iterator>(last));
 }
 
 template <typename InputIterator, typename OutputIterator, typename UnaryPredicate>
 OutputIterator copy_if(InputIterator first, InputIterator last, OutputIterator dest, UnaryPredicate pred)
 {
     while (first != last) {
         if (pred(*first)) {
             *dest = *first;
             ++dest;
         }
         ++first;
     }
     return dest;
 }
 
 template <typename OutputIterator, typename InputIterator, typename UnaryFunction, typename UnaryPredicate>
 void transform_if(InputIterator first, InputIterator last, OutputIterator dest, UnaryPredicate pred, UnaryFunction filter)
 {
     for (; first != last; ++first) {
         if (filter(*first)) {
             *dest++ = pred(*first);
         }
     }
 }
 
 template <typename InputIterator, typename OutputIterator, typename Predicate>
 OutputIterator copy_1st_if(InputIterator first, InputIterator last, OutputIterator dest, Predicate pred)
 {
     const auto trans = [](typename std::iterator_traits<InputIterator>::reference v) {
                             return std::get<0>(v);
                        };
     kdtools::transform_if(first, last, dest, trans,
                           [&pred, &trans](typename std::iterator_traits<InputIterator>::reference v) {
                             return pred(trans(v));
                           });
     return dest;
 }
 
 template <typename InputIterator, typename OutputIterator, typename Predicate>
 OutputIterator copy_2nd_if(InputIterator first, InputIterator last, OutputIterator dest, Predicate pred)
 {
     const auto trans = [](typename std::iterator_traits<InputIterator>::reference v) {
                             return std::get<1>(v);
                        };
     kdtools::transform_if(first, last, dest, trans,
                           [&pred, &trans](typename std::iterator_traits<InputIterator>::reference v) {
                             return pred(trans(v));
                           });
     return dest;
 }
 
 
 template <typename OutputIterator, typename InputIterator, typename UnaryFunction>
 OutputIterator transform_1st(InputIterator first, InputIterator last, OutputIterator dest, UnaryFunction func)
 {
     return std::transform(first, last, dest,
                           [func](typename std::iterator_traits<InputIterator>::reference v) {
                               return func(std::get<0>(v));
                           });
 }
 
 template <typename OutputIterator, typename InputIterator, typename UnaryFunction>
 OutputIterator transform_2nd(InputIterator first, InputIterator last, OutputIterator dest, UnaryFunction func)
 {
     return std::transform(first, last, dest,
                           [func](typename std::iterator_traits<InputIterator>::reference v) {
                               return func(std::get<1>(v));
                           });
 }
 
 template <typename Value, typename InputIterator, typename UnaryPredicate>
 Value accumulate_if(InputIterator first, InputIterator last, UnaryPredicate filter, const Value &value = Value())
 {
     return std::accumulate(make_filter_iterator(filter, first, last),
                            make_filter_iterator(filter, last,  last), value);
 }
 
 template <typename Value, typename InputIterator, typename UnaryPredicate, typename BinaryOperation>
 Value accumulate_if(InputIterator first, InputIterator last, UnaryPredicate filter, const Value &value, BinaryOperation op)
 {
     return std::accumulate(make_filter_iterator(filter, first, last),
                            make_filter_iterator(filter, last,  last), value, op);
 }
 
 template <typename Value, typename InputIterator, typename UnaryFunction>
 Value accumulate_transform(InputIterator first, InputIterator last, UnaryFunction map, const Value &value = Value())
 {
     return std::accumulate(first, last, value,
                            [map](Value lhs,
                                  typename std::iterator_traits<InputIterator>::reference rhs)
                            {
                                return lhs + map(rhs);
                            });
 }
 
 template <typename Value, typename InputIterator, typename UnaryFunction, typename BinaryOperation>
 Value accumulate_transform(InputIterator first, InputIterator last, UnaryFunction map, const Value &value, BinaryOperation op)
 {
     return std::accumulate(first, last, value,
                            [map, op](typename InputIterator::reference lhs,
                                      typename InputIterator::reference rhs) {
                                return op(map(lhs), map(rhs));
                            });
 }
 
 template <typename Value, typename InputIterator, typename UnaryFunction, typename UnaryPredicate, typename BinaryOperation>
 Value accumulate_transform_if(InputIterator first, InputIterator last, UnaryFunction map, UnaryPredicate filter, const Value &value, BinaryOperation op)
 {
     return accumulate_transform(make_filter_iterator(filter, first, last),
                                 make_filter_iterator(filter, last, last),
                                 map, value, op);
 }
 
 
 template <typename InputIterator, typename BinaryOperation>
 BinaryOperation for_each_adjacent_pair(InputIterator first, InputIterator last, BinaryOperation op)
 {
     using ValueType = typename std::iterator_traits<InputIterator>::value_type;
     if (first == last) {
         return op;
     }
     ValueType value = *first;
     while (++first != last) {
         ValueType tmp = *first;
         op(value, tmp);
         value = tmp;
     }
     return op;
 }
 
 
 template <typename InputIterator, typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate>
 std::pair<OutputIterator1, OutputIterator2> separate_if(InputIterator first, InputIterator last, OutputIterator1 dest1, OutputIterator2 dest2, UnaryPredicate pred)
 {
     while (first != last) {
         if (pred(*first)) {
             *dest1 = *first;
             ++dest1;
         } else {
             *dest2 = *first;
             ++dest2;
         }
         ++first;
     }
     return std::make_pair(dest1, dest2);
 }
 
 //@{
 /**
    Versions of std::set_intersection optimized for ForwardIterator's
 */
 template <typename ForwardIterator, typename ForwardIterator2, typename OutputIterator, typename BinaryPredicate>
 OutputIterator set_intersection(ForwardIterator first1, ForwardIterator last1, ForwardIterator2 first2, ForwardIterator2 last2, OutputIterator result)
 {
     while (first1 != last1 && first2 != last2) {
         if (*first1 < *first2) {
             first1 = std::lower_bound(++first1, last1, *first2);
         } else if (*first2 < *first1) {
             first2 = std::lower_bound(++first2, last2, *first1);
         } else {
             *result = *first1;
             ++first1;
             ++first2;
             ++result;
         }
     }
     return result;
 }
 
 template <typename ForwardIterator, typename ForwardIterator2, typename OutputIterator, typename BinaryPredicate>
 OutputIterator set_intersection(ForwardIterator first1, ForwardIterator last1, ForwardIterator2 first2, ForwardIterator2 last2, OutputIterator result, BinaryPredicate pred)
 {
     while (first1 != last1 && first2 != last2) {
         if (pred(*first1, *first2)) {
             first1 = std::lower_bound(++first1, last1, *first2, pred);
         } else if (pred(*first2, *first1)) {
             first2 = std::lower_bound(++first2, last2, *first1, pred);
         } else {
             *result = *first1;
             ++first1;
             ++first2;
             ++result;
         }
     }
     return result;
 }
 //@}
 
 template <typename ForwardIterator, typename ForwardIterator2, typename BinaryPredicate>
 bool set_intersects(ForwardIterator first1,  ForwardIterator last1,
                     ForwardIterator2 first2, ForwardIterator2 last2,
                     BinaryPredicate pred)
 {
     while (first1 != last1 && first2 != last2) {
         if (pred(*first1, *first2)) {
             first1 = std::lower_bound(++first1, last1, *first2, pred);
         } else if (pred(*first2, *first1)) {
             first2 = std::lower_bound(++first2, last2, *first1, pred);
         } else {
             return true;
         }
     }
     return false;
 }
 
 //@{
 
 }
 
-#endif /* __KDTOOLSCORE_STL_UTIL_H__ */
 
diff --git a/src/models/keycache.h b/src/models/keycache.h
index 8f7e63cf3..f6c191491 100644
--- a/src/models/keycache.h
+++ b/src/models/keycache.h
@@ -1,186 +1,184 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/keycache.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_MODELS_KEYCACHE_H__
-#define __KLEOPATRA_MODELS_KEYCACHE_H__
+#pragma once
 
 #include <QObject>
 
 #include <kleo_export.h>
 
 #include <gpgme++/global.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 class DecryptionResult;
 class VerificationResult;
 class KeyListResult;
 class Subkey;
 }
 
 namespace KMime
 {
 namespace Types
 {
 class Mailbox;
 }
 }
 
 namespace Kleo
 {
 
 class FileSystemWatcher;
 class KeyGroup;
 
 class KLEO_EXPORT KeyCache : public QObject
 {
     Q_OBJECT
 protected:
     explicit KeyCache();
 public:
     static std::shared_ptr<const KeyCache> instance();
     static std::shared_ptr<KeyCache> mutableInstance();
 
     ~KeyCache();
 
     void setGroupsEnabled(bool enabled);
     void setGroupsConfig(const QString &filename);
 
     void insert(const GpgME::Key &key);
     void insert(const std::vector<GpgME::Key> &keys);
     bool insert(const KeyGroup &group);
 
     void refresh(const std::vector<GpgME::Key> &keys);
     bool update(const KeyGroup &group);
 
     void remove(const GpgME::Key &key);
     void remove(const std::vector<GpgME::Key> &keys);
     bool remove(const KeyGroup &group);
 
     void addFileSystemWatcher(const std::shared_ptr<FileSystemWatcher> &watcher);
 
     void enableFileSystemWatcher(bool enable);
 
     void setRefreshInterval(int hours);
     int refreshInterval() const;
 
     void enableRemarks(bool enable);
     bool remarksEnabled() const;
 
     const std::vector<GpgME::Key> &keys() const;
     std::vector<GpgME::Key> secretKeys() const;
 
     std::vector<KeyGroup> groups() const;
     std::vector<KeyGroup> configurableGroups() const;
     void saveConfigurableGroups(const std::vector<KeyGroup> &groups);
 
     const GpgME::Key &findByFingerprint(const char *fpr) const;
     const GpgME::Key &findByFingerprint(const std::string &fpr) const;
 
     std::vector<GpgME::Key> findByEMailAddress(const char *email) const;
     std::vector<GpgME::Key> findByEMailAddress(const std::string &email) const;
 
     /** Look through the cache and search for the best key for a mailbox taking
      * groups into account.
      *
      * The best key is the key with a UID for the provided mailbox that
      * has the highest validity and a subkey that is capable for the given
      * usage.
      * If more then one key have a UID with the same validity
      * the most recently created key is taken.
      *
      * The return value is a list because of groups. A group is
      * a gnupg config entry that allows a user to configure multiple
      * keys for a single mailbox. Only supported for OpenPGP currently.
      *
      * @returns only the "best" key for the mailbox, or a list if it is a group. */
     std::vector<GpgME::Key> findBestByMailBox(const char *addr, GpgME::Protocol proto,
                                               bool needSign, bool needEncrypt) const;
 
     const GpgME::Key &findByShortKeyID(const char *id) const;
     const GpgME::Key &findByShortKeyID(const std::string &id) const;
 
     const GpgME::Key &findByKeyIDOrFingerprint(const char *id) const;
     const GpgME::Key &findByKeyIDOrFingerprint(const std::string &id) const;
 
     std::vector<GpgME::Key> findByKeyIDOrFingerprint(const std::vector<std::string> &ids) const;
 
     const GpgME::Subkey &findSubkeyByKeyGrip(const char *grip, GpgME::Protocol protocol = GpgME::UnknownProtocol) const;
     const GpgME::Subkey &findSubkeyByKeyGrip(const std::string &grip, GpgME::Protocol protocol = GpgME::UnknownProtocol) const;
 
     std::vector<GpgME::Subkey> findSubkeysByKeyID(const std::vector<std::string> &ids) const;
 
     std::vector<GpgME::Key> findRecipients(const GpgME::DecryptionResult &result) const;
     std::vector<GpgME::Key> findSigners(const GpgME::VerificationResult &result) const;
 
     std::vector<GpgME::Key> findSigningKeysByMailbox(const QString &mb) const;
     std::vector<GpgME::Key> findEncryptionKeysByMailbox(const QString &mb) const;
 
     /** Check for group keys.
      *
      * @returns A list of keys configured for groupName. Empty if no group cached.*/
     std::vector<GpgME::Key> getGroupKeys(const QString &groupName) const;
 
     enum Option {
         NoOption = 0,
         RecursiveSearch = 1,
         IncludeSubject = 2
     };
     Q_DECLARE_FLAGS(Options, Option)
 
     std::vector<GpgME::Key> findSubjects(const GpgME::Key &key, Options option = RecursiveSearch) const;
     std::vector<GpgME::Key> findSubjects(const std::vector<GpgME::Key> &keys, Options options = RecursiveSearch) const;
     std::vector<GpgME::Key> findSubjects(std::vector<GpgME::Key>::const_iterator first, std::vector<GpgME::Key>::const_iterator last, Options options = RecursiveSearch) const;
 
     std::vector<GpgME::Key> findIssuers(const GpgME::Key &key, Options options = RecursiveSearch) const;
     std::vector<GpgME::Key> findIssuers(const std::vector<GpgME::Key> &keys, Options options = RecursiveSearch) const;
     std::vector<GpgME::Key> findIssuers(std::vector<GpgME::Key>::const_iterator first, std::vector<GpgME::Key>::const_iterator last, Options options = RecursiveSearch) const;
 
     /** Check if at least one keylisting was finished. */
     bool initialized() const;
 
     /** Check if all keys have OpenPGP Protocol. */
     bool pgpOnly() const;
 
 public Q_SLOTS:
     void clear();
     void startKeyListing(GpgME::Protocol proto = GpgME::UnknownProtocol)
     {
         reload(proto);
     }
     void reload(GpgME::Protocol proto = GpgME::UnknownProtocol);
     void cancelKeyListing();
 
 Q_SIGNALS:
     //void changed( const GpgME::Key & key );
     void aboutToRemove(const GpgME::Key &key);
     void added(const GpgME::Key &key);
     void keyListingDone(const GpgME::KeyListResult &result);
     void keysMayHaveChanged();
     void groupAdded(const KeyGroup &group);
     void groupUpdated(const KeyGroup &group);
     void groupRemoved(const KeyGroup &group);
 
 private:
     class RefreshKeysJob;
 
     class Private;
     QScopedPointer<Private> const d;
 };
 
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Kleo::KeyCache::Options)
 
-#endif /* __KLEOPATRA_MODELS_KEYCACHE_H__ */
diff --git a/src/models/keycache_p.h b/src/models/keycache_p.h
index 11efd2a92..368c7552e 100644
--- a/src/models/keycache_p.h
+++ b/src/models/keycache_p.h
@@ -1,46 +1,44 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/keycache_p.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_KEYCACHE_P_H__
-#define __KLEOPATRA_KEYCACHE_P_H__
+#pragma once
 
 #include "keycache.h"
 
 namespace GpgME
 {
 class KeyListResult;
 }
 
 namespace Kleo
 {
 
 class KeyCache::RefreshKeysJob : public QObject
 {
     Q_OBJECT
 public:
 
     explicit RefreshKeysJob(KeyCache *cache, QObject *parent = nullptr);
     ~RefreshKeysJob();
 
     void start();
     void cancel();
 
 Q_SIGNALS:
     void done(const GpgME::KeyListResult &);
     void canceled();
 
 private:
     class Private;
     friend class Private;
     Private * const d;
     Q_PRIVATE_SLOT(d, void listAllKeysJobDone(GpgME::KeyListResult, std::vector<GpgME::Key>))
 };
 }
 
-#endif // __KLEOPATRA_KEYCACHE_P_H__
diff --git a/src/models/keylist.h b/src/models/keylist.h
index 1f648828d..2ace93a6b 100644
--- a/src/models/keylist.h
+++ b/src/models/keylist.h
@@ -1,52 +1,50 @@
 /*
     models/keylist.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef LIBKLEO_KEYLIST_H
-#define LIBKLEO_KEYLIST_H
+#pragma once
 
 namespace Kleo
 {
 namespace KeyList
 {
     static const int FingerprintRole = 0xF1;
     static const int KeyRole = 0xF2;
     static const int GroupRole = 0xF3;
 
     enum Columns {
         PrettyName,
         PrettyEMail,
         ValidFrom,
         ValidUntil,
         TechnicalDetails,
         ShortKeyID,
         KeyID,
         Fingerprint,
         Issuer,
         SerialNumber,
         OwnerTrust,
         Origin,
         LastUpdate,
         Validity,
         Summary, // Short summary line
         Remarks, // Additional remark notations
         NumColumns,
         Icon = PrettyName // which column shall the icon be displayed in?
     };
 
     enum Options {
         AllKeys,
         SecretKeysOnly,
         IncludeGroups
     };
 }
 }
 
-#endif /* LIBKLEO_KEYLIST_H */
diff --git a/src/models/keylistmodel.h b/src/models/keylistmodel.h
index d585a37ff..172f4e8c3 100644
--- a/src/models/keylistmodel.h
+++ b/src/models/keylistmodel.h
@@ -1,130 +1,128 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/keylistmodel.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_MODELS_KEYLISTMODEL_H__
-#define __KLEOPATRA_MODELS_KEYLISTMODEL_H__
+#pragma once
 
 #include <QAbstractItemModel>
 
 #include <kleo_export.h>
 
 #include "keylist.h"
 #include "keylistmodelinterface.h"
 
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 
 class KLEO_EXPORT AbstractKeyListModel : public QAbstractItemModel
                                        , public KeyListModelInterface
 {
     Q_OBJECT
 public:
     enum ItemType {
         Keys = 0x01,
         Groups = 0x02,
         All = Keys | Groups
     };
     Q_DECLARE_FLAGS(ItemTypes, ItemType)
 
     explicit AbstractKeyListModel(QObject *parent = nullptr);
     ~AbstractKeyListModel() override;
 
     static AbstractKeyListModel *createFlatKeyListModel(QObject *parent = nullptr);
     static AbstractKeyListModel *createHierarchicalKeyListModel(QObject *parent = nullptr);
 
     GpgME::Key key(const QModelIndex &idx) const override;
     std::vector<GpgME::Key> keys(const QList<QModelIndex> &indexes) const override;
 
     KeyGroup group(const QModelIndex &idx) const override;
 
     using QAbstractItemModel::index;
     QModelIndex index(const GpgME::Key &key) const override;
     QModelIndex index(const GpgME::Key &key, int col) const;
     QList<QModelIndex> indexes(const std::vector<GpgME::Key> &keys) const override;
 
     QModelIndex index(const KeyGroup &group) const override;
     QModelIndex index(const KeyGroup &group, int col) const;
 
 Q_SIGNALS:
     void rowAboutToBeMoved(const QModelIndex &old_parent, int old_row);
     void rowMoved(const QModelIndex &new_parent, int new_row);
 
 public Q_SLOTS:
     void setKeys(const std::vector<GpgME::Key> &keys);
     /* Set this to set all or only secret keys from the keycache. */
     void useKeyCache(bool value, Kleo::KeyList::Options options);
     QModelIndex addKey(const GpgME::Key &key);
     QList<QModelIndex> addKeys(const std::vector<GpgME::Key> &keys);
     void removeKey(const GpgME::Key &key);
 
     void setGroups(const std::vector<KeyGroup> &groups);
     QModelIndex addGroup(const KeyGroup &group);
     bool removeGroup(const KeyGroup &group);
 
     void clear(ItemTypes types = All);
 
 public:
     int columnCount(const QModelIndex &pidx) const override;
     QVariant headerData(int section, Qt::Orientation o, int role = Qt::DisplayRole) const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
     bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
 
     /**
      * defines which information is displayed in tooltips
      * see Kleo::Formatting::ToolTipOption
      */
     int toolTipOptions() const;
 
     void setToolTipOptions(int opts);
 
     /**
      * Set the keys to use for KeyListModelInterface::Remark column
      * to obtain remarks from this keys signature notations.
      * Needs at least GpgME 1.14 to work properly. Remarks are
      * joined by a semicolon and a space. */
     void setRemarkKeys(const std::vector<GpgME::Key> &remarkKeys);
     std::vector<GpgME::Key> remarkKeys() const;
 
 private:
     QVariant data(const GpgME::Key &key, int column, int role) const;
     QVariant data(const KeyGroup &group, int column, int role) const;
 
     virtual GpgME::Key doMapToKey(const QModelIndex &index) const = 0;
     virtual QModelIndex doMapFromKey(const GpgME::Key &key, int column) const = 0;
     virtual QList<QModelIndex> doAddKeys(const std::vector<GpgME::Key> &keys) = 0;
     virtual void doRemoveKey(const GpgME::Key &key) = 0;
 
     virtual KeyGroup doMapToGroup(const QModelIndex &index) const = 0;
     virtual QModelIndex doMapFromGroup(const KeyGroup &group, int column) const = 0;
     virtual void doSetGroups(const std::vector<KeyGroup> &groups) = 0;
     virtual QModelIndex doAddGroup(const KeyGroup &group) = 0;
     virtual bool doSetGroupData(const QModelIndex &index, const KeyGroup &group) = 0;
     virtual bool doRemoveGroup(const KeyGroup &group) = 0;
 
     virtual void doClear(ItemTypes types) = 0;
 
 private:
     class Private;
     QScopedPointer<Private> const d;
 };
 
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Kleo::AbstractKeyListModel::ItemTypes)
 
-#endif /* __KLEOPATRA_MODELS_KEYLISTMODEL_H__ */
diff --git a/src/models/keylistmodelinterface.h b/src/models/keylistmodelinterface.h
index 55cd18b50..612ca7a7c 100644
--- a/src/models/keylistmodelinterface.h
+++ b/src/models/keylistmodelinterface.h
@@ -1,48 +1,46 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/keylistmodelinterface.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_MODELS_KEYLISTMODELINTERFACE_H__
-#define __KLEOPATRA_MODELS_KEYLISTMODELINTERFACE_H__
+#pragma once
 
 #include <vector>
 
 #include <kleo_export.h>
 
 namespace GpgME
 {
 class Key;
 }
 
 class QModelIndex;
 template <typename T> class QList;
 
 namespace Kleo
 {
 class KeyGroup;
 
 class KLEO_EXPORT KeyListModelInterface
 {
 public:
     virtual ~KeyListModelInterface();
 
     virtual GpgME::Key key(const QModelIndex &idx) const = 0;
     virtual std::vector<GpgME::Key> keys(const QList<QModelIndex> &idxs) const = 0;
 
     virtual QModelIndex index(const GpgME::Key &key) const = 0;
     virtual QList<QModelIndex> indexes(const std::vector<GpgME::Key> &keys) const = 0;
 
     virtual KeyGroup group(const QModelIndex &idx) const = 0;
     virtual QModelIndex index(const KeyGroup &group) const = 0;
 };
 
 }
 
-#endif /* __KLEOPATRA_MODELS_KEYLISTMODELINTERFACE_H__ */
diff --git a/src/models/keylistsortfilterproxymodel.h b/src/models/keylistsortfilterproxymodel.h
index ae74bbad0..a78869801 100644
--- a/src/models/keylistsortfilterproxymodel.h
+++ b/src/models/keylistsortfilterproxymodel.h
@@ -1,82 +1,80 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/keylistsortfilterproxymodel.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_MODELS_KEYLISTSORTFILTERPROXYMODEL_H__
-#define __KLEOPATRA_MODELS_KEYLISTSORTFILTERPROXYMODEL_H__
+#pragma once
 
 #include <QSortFilterProxyModel>
 
 #include "keylistmodelinterface.h"
 
 #include <kleo_export.h>
 
 #include <memory>
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 
 class KeyFilter;
 
 class KLEO_EXPORT AbstractKeyListSortFilterProxyModel : public QSortFilterProxyModel
                                                       , public KeyListModelInterface
 {
     Q_OBJECT
 protected:
     AbstractKeyListSortFilterProxyModel(const AbstractKeyListSortFilterProxyModel &);
 public:
     explicit AbstractKeyListSortFilterProxyModel(QObject *parent = nullptr);
     ~AbstractKeyListSortFilterProxyModel() override;
 
     virtual AbstractKeyListSortFilterProxyModel *clone() const = 0;
 
     GpgME::Key key(const QModelIndex &idx) const override;
     std::vector<GpgME::Key> keys(const QList<QModelIndex> &indexes) const override;
 
     KeyGroup group(const QModelIndex &idx) const override;
 
     using QAbstractItemModel::index;
     QModelIndex index(const GpgME::Key &key) const override;
     QList<QModelIndex> indexes(const std::vector<GpgME::Key> &keys) const override;
 
     QModelIndex index(const KeyGroup &group) const override;
 
 private:
     void init();
 };
 
 class KLEO_EXPORT KeyListSortFilterProxyModel : public AbstractKeyListSortFilterProxyModel
 {
     Q_OBJECT
 protected:
     KeyListSortFilterProxyModel(const KeyListSortFilterProxyModel &);
 public:
     explicit KeyListSortFilterProxyModel(QObject *parent = nullptr);
     ~KeyListSortFilterProxyModel() override;
 
     std::shared_ptr<const KeyFilter> keyFilter() const;
     void setKeyFilter(const std::shared_ptr<const KeyFilter> &kf);
 
     KeyListSortFilterProxyModel *clone() const override;
 
 protected:
     bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
 
 private:
     class Private;
     QScopedPointer<Private> const d;
 };
 
 }
 
-#endif /* __KLEOPATRA_MODELS_KEYLISTMODEL_H__ */
diff --git a/src/models/keyrearrangecolumnsproxymodel.h b/src/models/keyrearrangecolumnsproxymodel.h
index 273e0e261..ed1ac8b87 100644
--- a/src/models/keyrearrangecolumnsproxymodel.h
+++ b/src/models/keyrearrangecolumnsproxymodel.h
@@ -1,45 +1,43 @@
 /*  models/keyrearangecolumnsproxymodel.h
 
     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
 */
 
-#ifndef KEYREARRANGECOLUMNSPROXYMODEL_H
-#define KEYREARRANGECOLUMNSPROXYMODEL_H
+#pragma once
 
 #include "keylistmodelinterface.h"
 
 #include <kleo_export.h>
 
 #include <KRearrangeColumnsProxyModel>
 
 namespace Kleo
 {
 /** KRearrangeColumnsProxymodel that implements the KeyListModelInterface. */
 class KLEO_EXPORT KeyRearrangeColumnsProxyModel: public KRearrangeColumnsProxyModel,
                                                  public KeyListModelInterface
 {
 public:
     explicit KeyRearrangeColumnsProxyModel(QObject *parent = nullptr);
 
     GpgME::Key key(const QModelIndex &idx) const override;
     std::vector<GpgME::Key> keys(const QList<QModelIndex> &idxs) const override;
 
     KeyGroup group(const QModelIndex &idx) const override;
 
     using KRearrangeColumnsProxyModel::index;
 
     QModelIndex index(const GpgME::Key &key) const override;
     QList<QModelIndex> indexes(const std::vector<GpgME::Key> &keys) const override;
 
     QModelIndex index(const KeyGroup &group) const override;
 
     void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) override;
 private:
     KeyListModelInterface *klm() const;
 };
 } // namespace Kleo
-#endif // KEYREARRANGECOLUMNSPROXYMODEL_H
diff --git a/src/models/subkeylistmodel.h b/src/models/subkeylistmodel.h
index 7d479e14c..2ee130892 100644
--- a/src/models/subkeylistmodel.h
+++ b/src/models/subkeylistmodel.h
@@ -1,74 +1,72 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/subkeylistmodel.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_MODELS_SUBKEYLISTMODEL_H__
-#define __KLEOPATRA_MODELS_SUBKEYLISTMODEL_H__
+#pragma once
 
 #include <QAbstractTableModel>
 
 #include <kleo_export.h>
 
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 class Subkey;
 }
 
 namespace Kleo
 {
 
 class KLEO_EXPORT SubkeyListModel : public QAbstractTableModel
 {
     Q_OBJECT
 public:
     explicit SubkeyListModel(QObject *parent = nullptr);
     ~SubkeyListModel() override;
 
     GpgME::Key key() const;
 
     enum Columns {
         ID,
         Type,
         ValidFrom,
         ValidUntil,
         Status,
         Strength,
         Usage,
 
         NumColumns,
         Icon = ID // which column shall the icon be displayed in?
     };
 
     GpgME::Subkey subkey(const QModelIndex &idx) const;
     std::vector<GpgME::Subkey> subkeys(const QList<QModelIndex> &indexes) const;
 
     using QAbstractTableModel::index;
     QModelIndex index(const GpgME::Subkey &subkey, int col = 0) const;
     QList<QModelIndex> indexes(const std::vector<GpgME::Subkey> &subkeys) const;
 
 public Q_SLOTS:
     void setKey(const GpgME::Key &key);
     void clear();
 
 public:
     int columnCount(const QModelIndex &pidx = QModelIndex()) const override;
     int rowCount(const QModelIndex &pidx = QModelIndex()) const override;
     QVariant headerData(int section, Qt::Orientation o, int role = Qt::DisplayRole) const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
 private:
     class Private;
     QScopedPointer<Private> const d;
 };
 
 }
 
-#endif /* __KLEOPATRA_MODELS_SUBKEYLISTMODEL_H__ */
diff --git a/src/models/useridlistmodel.h b/src/models/useridlistmodel.h
index 6f23a5224..b2f19eab2 100644
--- a/src/models/useridlistmodel.h
+++ b/src/models/useridlistmodel.h
@@ -1,61 +1,59 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/useridlistmodel.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2016 Andre Heinecke <aheinecke@gnupg.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_MODELS_USERIDLISTMODEL_H__
-#define __KLEOPATRA_MODELS_USERIDLISTMODEL_H__
+#pragma once
 
 #include <QAbstractItemModel>
 
 #include <kleo_export.h>
 
 #include <gpgme++/key.h> // since Signature is nested in UserID...
 
 class UIDModelItem;
 
 namespace Kleo
 {
 
 class KLEO_EXPORT UserIDListModel : public QAbstractItemModel
 {
     Q_OBJECT
 public:
     explicit UserIDListModel(QObject *parent = nullptr);
     ~UserIDListModel() override;
 
     GpgME::Key key() const;
 
 public:
     GpgME::UserID userID(const QModelIndex &index) const;
     QVector<GpgME::UserID> userIDs(const QModelIndexList &indexs) const;
     GpgME::UserID::Signature signature(const QModelIndex &index) const;
     QVector<GpgME::UserID::Signature> signatures(const QModelIndexList &indexs) const;
     void enableRemarks(bool value);
 
 public Q_SLOTS:
     void setKey(const GpgME::Key &key);
 
 public:
     int columnCount(const QModelIndex &pindex = QModelIndex()) const override;
     int rowCount(const QModelIndex &pindex = QModelIndex()) const override;
     QVariant headerData(int section, Qt::Orientation o, int role = Qt::DisplayRole) const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
     QModelIndex index(int row, int col, const QModelIndex &parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex &index) const override;
 
 private:
     GpgME::Key mKey;
     bool mRemarksEnabled = false;
     UIDModelItem *mRootItem = nullptr;
 };
 
 }
 
-#endif /* __KLEOPATRA_MODELS_USERIDLISTMODEL_H__ */
diff --git a/src/tests/gnupgviewer.h b/src/tests/gnupgviewer.h
index accabb409..954dfe4f6 100644
--- a/src/tests/gnupgviewer.h
+++ b/src/tests/gnupgviewer.h
@@ -1,42 +1,40 @@
 /*
     gnupgviewer.h
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_TESTS_GNUPGVIEWER_H__
-#define __KLEO_TESTS_GNUPGVIEWER_H__
+#pragma once
 
 #include <QTextEdit>
 #include <QString>
 #include <QProcess>
 namespace Kleo
 {
 class GnuPGProcessBase;
 }
 #include <QStringList>
 
 class GnuPGViewer : public QTextEdit
 {
     Q_OBJECT
 public:
     GnuPGViewer(QWidget *parent = nullptr);
     ~GnuPGViewer();
 
     void setProcess(Kleo::GnuPGProcessBase *process);
 
 private Q_SLOTS:
     void slotStdout();
     void slotStderr();
     void slotStatus(Kleo::GnuPGProcessBase *, const QString &, const QStringList &);
     void slotProcessExited(int, QProcess::ExitStatus);
 
 private:
     Kleo::GnuPGProcessBase *mProcess = nullptr;
     QString mLastStdout, mLastStderr, mLastStatus;
 };
 
-#endif // __KLEO_TESTS_GNUPGVIEWER_H__
diff --git a/src/tests/test_keygen.h b/src/tests/test_keygen.h
index ef8ef76ce..97b957f9f 100644
--- a/src/tests/test_keygen.h
+++ b/src/tests/test_keygen.h
@@ -1,42 +1,40 @@
 /*
     test_keygen.h
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
-#ifndef __KLEO_TEST_KEYGEN_H__
-#define __KLEO_TEST_KEYGEN_H__
+#pragma once
 
 #include <QDialog>
 
 #include <QByteArray>
 
 namespace GpgME
 {
 class Error;
 class KeyGenerationResult;
 }
 
 class QLineEdit;
 
 class KeyGenerator : public QDialog
 {
     Q_OBJECT
 public:
     KeyGenerator(QWidget *parent = nullptr);
     ~KeyGenerator();
 
 public Q_SLOTS:
     void slotStartKeyGeneration();
     void slotResult(const GpgME::KeyGenerationResult &res, const QByteArray &keyData);
 private:
     void showError(const GpgME::Error &err);
 
 private:
     QLineEdit *mLineEdits[20];
 };
 
-#endif // __KLEO_TEST_KEYGEN_H__
diff --git a/src/tests/test_keylister.h b/src/tests/test_keylister.h
index 01da90f47..95abda91c 100644
--- a/src/tests/test_keylister.h
+++ b/src/tests/test_keylister.h
@@ -1,33 +1,31 @@
 /*
     test_keylister.h
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
-#ifndef __KLEO_TEST_KEYLISTER_H__
-#define __KLEO_TEST_KEYLISTER_H__
+#pragma once
 
 #include "ui/keylistview.h"
 
 namespace GpgME
 {
 class Key;
 class KeyListResult;
 }
 
 class CertListView : public Kleo::KeyListView
 {
     Q_OBJECT
 public:
     explicit CertListView(QWidget *parent = nullptr, Qt::WindowFlags f = {});
     ~CertListView();
 
 public Q_SLOTS:
     void slotResult(const GpgME::KeyListResult &result);
     void slotStart();
 };
 
-#endif // __KLEO_TEST_KEYLISTER_H__
diff --git a/src/ui/auditlogviewer.h b/src/ui/auditlogviewer.h
index c965f785d..842ff461c 100644
--- a/src/ui/auditlogviewer.h
+++ b/src/ui/auditlogviewer.h
@@ -1,59 +1,57 @@
 /*
   SPDX-FileCopyrightText: 2015-2021 Laurent Montel <montel@kde.org>
 
   SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
-#ifndef AUDITLOGVIEWER_H
-#define AUDITLOGVIEWER_H
+#pragma once
 
 #include <QDialog>
 
 #include <kleo_export.h>
 
 #ifdef HAVE_PIMTEXTEDIT
 #include <KPIMTextEdit/RichTextEditorWidget>
 
 namespace KPIMTextEdit
 {
 class RichTextEditorWidget;
 }
 #else
 
 class QTextEdit;
 #endif // HAVE_PIMTEXTEDIT
 
 namespace Kleo
 {
 namespace Private
 {
 
 class KLEO_EXPORT AuditLogViewer : public QDialog
 {
     Q_OBJECT
 public:
     explicit AuditLogViewer(const QString &log, QWidget *parent = nullptr);
 
     ~AuditLogViewer();
 
     void setAuditLog(const QString &log);
 
 private Q_SLOTS:
     void slotSaveAs();
     void slotCopyClip();
 
 private:
     void writeConfig();
     void readConfig();
 
     QString m_log;
 #ifdef HAVE_PIMTEXTEDIT
     KPIMTextEdit::RichTextEditorWidget *m_textEdit = nullptr;
 #else
     QTextEdit *m_textEdit = nullptr;
 #endif
 };
 
 }
 }
-#endif // AUDITLOGVIEWER_H
diff --git a/src/ui/cryptoconfigdialog.h b/src/ui/cryptoconfigdialog.h
index 351cc1fce..ab9ac5e1f 100644
--- a/src/ui/cryptoconfigdialog.h
+++ b/src/ui/cryptoconfigdialog.h
@@ -1,54 +1,52 @@
 /*
     cryptoconfigdialog.h
 
     This file is part of kgpgcertmanager
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef CRYPTOCONFIGDIALOG_H
-#define CRYPTOCONFIGDIALOG_H
+#pragma once
 
 #include "kleo_export.h"
 #include <QDialog>
 class QDialogButtonBox;
 
 namespace QGpgME
 {
 class CryptoConfig;
 } // namespace QGpgME
 
 namespace Kleo
 {
 
 class CryptoConfigModule;
 
 /**
  * Simple QDialog wrapper around CryptoConfigModule
  */
 class KLEO_EXPORT CryptoConfigDialog : public QDialog
 {
     Q_OBJECT
 public:
     explicit CryptoConfigDialog(QGpgME::CryptoConfig *config, QWidget *parent = nullptr);
 
 protected Q_SLOTS:
     void slotOk();
     void slotCancel();
     void slotDefault();
     void slotApply();
     void slotUser1(); // reset
 
 public Q_SLOTS:
     void slotChanged();
 
 private:
     CryptoConfigModule *mMainWidget = nullptr;
     QDialogButtonBox *mButtonBox = nullptr;
 };
 
 }
 
-#endif /* CRYPTOCONFIGDIALOG_H */
 
diff --git a/src/ui/cryptoconfigmodule.h b/src/ui/cryptoconfigmodule.h
index 069e4d4af..49947a85b 100644
--- a/src/ui/cryptoconfigmodule.h
+++ b/src/ui/cryptoconfigmodule.h
@@ -1,69 +1,67 @@
 /*
     cryptoconfigmodule.h
 
     This file is part of libkleopatra
     SPDX-FileCopyrightText: 2004, 2005 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef CRYPTOCONFIGMODULE_H
-#define CRYPTOCONFIGMODULE_H
+#pragma once
 
 #include "kleo_export.h"
 #include <kpagedialog.h>
 #include <QList>
 
 namespace QGpgME
 {
 class CryptoConfig;
 } // namespace QGpgME
 
 namespace Kleo
 {
 class CryptoConfigComponentGUI;
 struct ParsedKeyserver {
     QString url;
     QVector< QPair<QString, QString> > options;
 };
 
 KLEO_EXPORT ParsedKeyserver parseKeyserver(const QString &str);
 KLEO_EXPORT QString assembleKeyserver(const ParsedKeyserver &keyserver);
 
 /**
  * Crypto Config Module widget, dynamically generated from CryptoConfig
  * It's a simple QWidget so that it can be embedded into a dialog or into a KCModule.
  */
 class KLEO_EXPORT CryptoConfigModule : public KPageWidget
 {
     Q_OBJECT
 public:
     enum Layout { TabbedLayout, IconListLayout, LinearizedLayout };
     explicit CryptoConfigModule(QGpgME::CryptoConfig *config, QWidget *parent = nullptr);
     explicit CryptoConfigModule(QGpgME::CryptoConfig *config, Layout layout, QWidget *parent = nullptr);
 
     bool hasError() const;
 
     void save();
     void reset(); // i.e. reload current settings, discarding user input
     void defaults();
     void cancel();
 
 Q_SIGNALS:
     void changed();
 
 private:
     void init(Layout layout);
     static QStringList sortComponentList(const QStringList &components);
 
 public:
     static QStringList sortGroupList(const QString &moduleName, const QStringList &groups);
 
 private:
     QGpgME::CryptoConfig *mConfig = nullptr;
     QList<CryptoConfigComponentGUI *> mComponentGUIs;
 };
 
 }
 
-#endif
diff --git a/src/ui/cryptoconfigmodule_p.h b/src/ui/cryptoconfigmodule_p.h
index a257c0b1c..568277165 100644
--- a/src/ui/cryptoconfigmodule_p.h
+++ b/src/ui/cryptoconfigmodule_p.h
@@ -1,310 +1,308 @@
 /*
     cryptoconfigmodule_p.h
 
     This file is part of libkleopatra
     SPDX-FileCopyrightText: 2004, 2005 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef CRYPTOCONFIGMODULE_P_H
-#define CRYPTOCONFIGMODULE_P_H
+#pragma once
 
 #include <QWidget>
 
 #include <QList>
 
 class KLineEdit;
 class QSpinBox;
 
 class QPushButton;
 class QGridLayout;
 class QLabel;
 class QCheckBox;
 class QComboBox;
 
 namespace Kleo
 {
 class FileNameRequester;
 }
 
 namespace QGpgME
 {
 class CryptoConfig;
 class CryptoConfigComponent;
 class CryptoConfigGroup;
 class CryptoConfigEntry;
 } // namespace QGpgME
 
 namespace Kleo
 {
 class CryptoConfigComponentGUI;
 class CryptoConfigGroupGUI;
 class CryptoConfigEntryGUI;
 
 /**
  * A widget corresponding to a component in the crypto config
  */
 class CryptoConfigComponentGUI : public QWidget
 {
     Q_OBJECT
 
 public:
     CryptoConfigComponentGUI(CryptoConfigModule *module, QGpgME::CryptoConfigComponent *component,
                              QWidget *parent = nullptr);
 
     bool save();
     void load();
     void defaults();
 
 private:
     QGpgME::CryptoConfigComponent *mComponent = nullptr;
     QList<CryptoConfigGroupGUI *> mGroupGUIs;
 };
 
 /**
  * A class managing widgets corresponding to a group in the crypto config
  */
 class CryptoConfigGroupGUI : public QObject
 {
     Q_OBJECT
 
 public:
     CryptoConfigGroupGUI(CryptoConfigModule *module, QGpgME::CryptoConfigGroup *group,
                          QGridLayout *layout, QWidget *parent = nullptr);
 
     bool save();
     void load();
     void defaults();
 
 private:
     QGpgME::CryptoConfigGroup *mGroup = nullptr;
     QList<CryptoConfigEntryGUI *> mEntryGUIs;
 };
 
 /**
  * Factory for CryptoConfigEntryGUI instances
  * Not a real factory, but can become one later.
  */
 class CryptoConfigEntryGUIFactory
 {
 public:
     static CryptoConfigEntryGUI *createEntryGUI(
         CryptoConfigModule *module,
         QGpgME::CryptoConfigEntry *entry, const QString &entryName,
         QGridLayout *layout, QWidget *widget);
 };
 
 /**
  * Base class for the widget managers tied to an entry in the crypto config
  */
 class CryptoConfigEntryGUI : public QObject
 {
     Q_OBJECT
 public:
     CryptoConfigEntryGUI(CryptoConfigModule *module,
                          QGpgME::CryptoConfigEntry *entry,
                          const QString &entryName);
 
     void load()
     {
         doLoad();
         mChanged = false;
     }
     void save()
     {
         Q_ASSERT(mChanged);
         doSave();
         mChanged = false;
     }
     void resetToDefault();
 
     QString description() const;
     bool isChanged() const
     {
         return mChanged;
     }
 
 Q_SIGNALS:
     void changed();
 
 protected Q_SLOTS:
     void slotChanged()
     {
         mChanged = true;
         Q_EMIT changed();
     }
 
 protected:
     virtual void doSave() = 0;
     virtual void doLoad() = 0;
 
     QGpgME::CryptoConfigEntry *mEntry = nullptr;
     QString mName;
     bool mChanged = false;
 };
 
 /**
  * A widget manager for a string entry in the crypto config
  */
 class CryptoConfigEntryLineEdit : public CryptoConfigEntryGUI
 {
     Q_OBJECT
 
 public:
     CryptoConfigEntryLineEdit(CryptoConfigModule *module,
                               QGpgME::CryptoConfigEntry *entry,
                               const QString &entryName,
                               QGridLayout *layout,
                               QWidget *parent = nullptr);
 
     void doSave() override;
     void doLoad() override;
 private:
     KLineEdit *mLineEdit = nullptr;
 };
 
 /**
  * A widget manager for a debug-level entry in the crypto config
  */
 class CryptoConfigEntryDebugLevel : public CryptoConfigEntryGUI
 {
     Q_OBJECT
 public:
     CryptoConfigEntryDebugLevel(CryptoConfigModule *module, QGpgME::CryptoConfigEntry *entry,
                                 const QString &entryName, QGridLayout *layout, QWidget *parent = nullptr);
 
     void doSave() override;
     void doLoad() override;
 private:
     QComboBox *mComboBox = nullptr;
 };
 
 /**
  * A widget manager for a path entry in the crypto config
  */
 class CryptoConfigEntryPath : public CryptoConfigEntryGUI
 {
     Q_OBJECT
 
 public:
     CryptoConfigEntryPath(CryptoConfigModule *module,
                           QGpgME::CryptoConfigEntry *entry,
                           const QString &entryName,
                           QGridLayout *layout,
                           QWidget *parent = nullptr);
 
     void doSave() override;
     void doLoad() override;
 private:
     Kleo::FileNameRequester *mFileNameRequester = nullptr;
 };
 
 /**
  * A widget manager for a directory path entry in the crypto config
  */
 class CryptoConfigEntryDirPath : public CryptoConfigEntryGUI
 {
     Q_OBJECT
 
 public:
     CryptoConfigEntryDirPath(CryptoConfigModule *module,
                              QGpgME::CryptoConfigEntry *entry,
                              const QString &entryName,
                              QGridLayout *layout,
                              QWidget *parent = nullptr);
 
     void doSave() override;
     void doLoad() override;
 private:
     Kleo::FileNameRequester *mFileNameRequester = nullptr;
 };
 
 /**
  * A widget manager for an int/uint entry in the crypto config
  */
 class CryptoConfigEntrySpinBox : public CryptoConfigEntryGUI
 {
     Q_OBJECT
 
 public:
     CryptoConfigEntrySpinBox(CryptoConfigModule *module,
                              QGpgME::CryptoConfigEntry *entry,
                              const QString &entryName,
                              QGridLayout *layout,
                              QWidget *parent = nullptr);
     void doSave() override;
     void doLoad() override;
 private:
     enum { Int, UInt, ListOfNone } mKind;
     QSpinBox *mNumInput = nullptr;
 };
 
 /**
  * A widget manager for a bool entry in the crypto config
  */
 class CryptoConfigEntryCheckBox : public CryptoConfigEntryGUI
 {
     Q_OBJECT
 
 public:
     CryptoConfigEntryCheckBox(CryptoConfigModule *module,
                               QGpgME::CryptoConfigEntry *entry,
                               const QString &entryName,
                               QGridLayout *layout,
                               QWidget *parent = nullptr);
     void doSave() override;
     void doLoad() override;
 private:
     QCheckBox *mCheckBox = nullptr;
 };
 
 /**
  * A widget manager for an LDAP list entry in the crypto config
  */
 class CryptoConfigEntryLDAPURL : public CryptoConfigEntryGUI
 {
     Q_OBJECT
 
 public:
     CryptoConfigEntryLDAPURL(CryptoConfigModule *module,
                              QGpgME::CryptoConfigEntry *entry,
                              const QString &entryName,
                              QGridLayout *layout,
                              QWidget *parent = nullptr);
     void doSave() override;
     void doLoad() override;
 private Q_SLOTS:
     void slotOpenDialog();
 private:
     void setURLList(const QList<QUrl> &urlList);
     QLabel *mLabel = nullptr;
     QPushButton *mPushButton = nullptr;
     QList<QUrl> mURLList;
 };
 
 /**
  * A widget manager for a (OpenPGP) keyserver entry in the crypto config
  */
 class CryptoConfigEntryKeyserver : public CryptoConfigEntryGUI
 {
     Q_OBJECT
 
 public:
     CryptoConfigEntryKeyserver(CryptoConfigModule *module,
                                QGpgME::CryptoConfigEntry *entry,
                                const QString &entryName,
                                QGridLayout *layout,
                                QWidget *parent = nullptr);
     void doSave() override;
     void doLoad() override;
 private Q_SLOTS:
     void slotOpenDialog();
 private:
     QLabel *mLabel = nullptr;
     QPushButton *mPushButton = nullptr;
     ParsedKeyserver mParsedKeyserver;
 };
 }
 
-#endif // CRYPTOCONFIGMODULE_P_H
diff --git a/src/ui/directoryserviceswidget.h b/src/ui/directoryserviceswidget.h
index 571e8fc6b..a85f29ddd 100644
--- a/src/ui/directoryserviceswidget.h
+++ b/src/ui/directoryserviceswidget.h
@@ -1,121 +1,119 @@
 /*
     directoryserviceswidget.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2001, 2002, 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef DIRECTORYSERVICESWIDGET_H
-#define DIRECTORYSERVICESWIDGET_H
+#pragma once
 
 #include "kleo_export.h"
 #include <QUrl>
 #include <QWidget>
 
 namespace Kleo
 {
 
 class KLEO_EXPORT DirectoryServicesWidget : public QWidget
 {
     Q_OBJECT
 public:
     explicit DirectoryServicesWidget(QWidget *parent = nullptr, Qt::WindowFlags f = {});
     ~DirectoryServicesWidget();
 
     enum Scheme {
         NoScheme = 0,
         HKP      = 1,
         HTTP     = 2,
         FTP      = 4,
         LDAP     = 8,
 
         AllSchemes = HKP | HTTP | FTP | LDAP
     };
     Q_DECLARE_FLAGS(Schemes, Scheme)
 
     enum Protocol {
         NoProtocol = 0,
         X509Protocol = 1,
         OpenPGPProtocol = 2,
 
         AllProtocols = X509Protocol | OpenPGPProtocol
     };
     Q_DECLARE_FLAGS(Protocols, Protocol)
 
     void setAllowedSchemes(Schemes schemes);
     Schemes allowedSchemes() const;
 
     void setAllowedProtocols(Protocols protocols);
     Protocols allowedProtocols() const;
 
     void setX509Allowed(bool allowed);
     void setOpenPGPAllowed(bool allowed);
 
     void setReadOnlyProtocols(Protocols protocols);
     Protocols readOnlyProtocols() const;
 
     void setOpenPGPReadOnly(bool ro);
     void setX509ReadOnly(bool ro);
 
     void addOpenPGPServices(const QList<QUrl> &urls);
     QList<QUrl> openPGPServices() const;
 
     void addX509Services(const QList<QUrl> &urls);
     QList<QUrl> x509Services() const;
 
 public Q_SLOTS:
     void clear();
 
 Q_SIGNALS:
     void changed();
 
 private:
     class Private;
     Private *const d;
     Q_PRIVATE_SLOT(d, void slotNewX509Clicked())
     Q_PRIVATE_SLOT(d, void slotDeleteClicked())
     Q_PRIVATE_SLOT(d, void slotSelectionChanged())
     Q_PRIVATE_SLOT(d, void slotShowUserAndPasswordToggled(bool))
 };
 
 }
 
 inline void Kleo::DirectoryServicesWidget::setOpenPGPAllowed(bool allowed)
 {
     if (allowed) {
         setAllowedProtocols(allowedProtocols() | OpenPGPProtocol);
     } else {
         setAllowedProtocols(allowedProtocols() & ~OpenPGPProtocol);
     }
 }
 
 inline void Kleo::DirectoryServicesWidget::setX509Allowed(bool allowed)
 {
     if (allowed) {
         setAllowedProtocols(allowedProtocols() | X509Protocol);
     } else {
         setAllowedProtocols(allowedProtocols() & ~X509Protocol);
     }
 }
 
 inline void Kleo::DirectoryServicesWidget::setOpenPGPReadOnly(bool ro)
 {
     if (ro) {
         setReadOnlyProtocols(readOnlyProtocols() | OpenPGPProtocol);
     } else {
         setReadOnlyProtocols(readOnlyProtocols() & ~OpenPGPProtocol);
     }
 }
 
 inline void Kleo::DirectoryServicesWidget::setX509ReadOnly(bool ro)
 {
     if (ro) {
         setReadOnlyProtocols(readOnlyProtocols() | X509Protocol);
     } else {
         setReadOnlyProtocols(readOnlyProtocols() & ~X509Protocol);
     }
 }
 
-#endif // DIRECTORYSERVICESWIDGET_H
diff --git a/src/ui/dnattributeorderconfigwidget.h b/src/ui/dnattributeorderconfigwidget.h
index be0c7d399..e935bae0f 100644
--- a/src/ui/dnattributeorderconfigwidget.h
+++ b/src/ui/dnattributeorderconfigwidget.h
@@ -1,69 +1,67 @@
 /*  -*- c++ -*-
     dnattributeorderconfigwidget.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_UI_DNATTRIBUTEORDERCONFIGWIDGET_H__
-#define __KLEO_UI_DNATTRIBUTEORDERCONFIGWIDGET_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <QWidget>
 
 namespace Kleo
 {
 class DNAttributeMapper;
 }
 
 class QTreeWidgetItem;
 
 namespace Kleo
 {
 
 class KLEO_EXPORT DNAttributeOrderConfigWidget : public QWidget
 {
     Q_OBJECT
 public:
     /*! Use Kleo::DNAttributeMapper::instance()->configWidget( parent, name ) instead. */
     explicit DNAttributeOrderConfigWidget(DNAttributeMapper *mapper, QWidget *parent = nullptr, Qt::WindowFlags f = {});
     ~DNAttributeOrderConfigWidget();
 
     void load();
     void save() const;
     void defaults();
 
 Q_SIGNALS:
     void changed();
 
     //
     // only boring stuff below...
     //
 
 private Q_SLOTS:
     void slotAvailableSelectionChanged(QTreeWidgetItem *);
     void slotCurrentOrderSelectionChanged(QTreeWidgetItem *);
     void slotDoubleUpButtonClicked();
     void slotUpButtonClicked();
     void slotDownButtonClicked();
     void slotDoubleDownButtonClicked();
     void slotLeftButtonClicked();
     void slotRightButtonClicked();
 
 private:
     void takePlaceHolderItem();
     void enableDisableButtons(QTreeWidgetItem *);
 
 private:
     class Private;
     Private *const d;
 protected:
     virtual void virtual_hook(int, void *);
 };
 
 }
 
-#endif // __KLEO_UI_DNATTRIBUTEORDERCONFIGWIDGET_H__
diff --git a/src/ui/filenamerequester.h b/src/ui/filenamerequester.h
index 0a72100ef..c5d310e75 100644
--- a/src/ui/filenamerequester.h
+++ b/src/ui/filenamerequester.h
@@ -1,57 +1,55 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     ui/filenamerequester.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_UI_FILENAMEREQUESTER_H__
-#define __KLEOPATRA_UI_FILENAMEREQUESTER_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <QWidget>
 
 #include <QDir>
 
 namespace Kleo
 {
 
 class KLEO_EXPORT FileNameRequester : public QWidget
 {
     Q_OBJECT
     Q_PROPERTY(QString fileName READ fileName WRITE setFileName)
     Q_PROPERTY(bool existingOnly READ existingOnly WRITE setExistingOnly)
 public:
     explicit FileNameRequester(QWidget *parent = nullptr);
     explicit FileNameRequester(QDir::Filters filter, QWidget *parent = nullptr);
     ~FileNameRequester();
 
     void setFileName(const QString &name);
     QString fileName() const;
 
     void setExistingOnly(bool on);
     bool existingOnly() const;
 
     void setFilter(QDir::Filters f);
     QDir::Filters filter() const;
 
     void setNameFilter(const QString &nameFilter);
     QString nameFilter() const;
 
 Q_SIGNALS:
     void fileNameChanged(const QString &filename);
 
 private:
     virtual QString requestFileName();
 
 private:
     class Private;
     Private *d;
 };
 
 }
 
-#endif /* __KLEOPATRA_UI_FILENAMEREQUESTER_H__ */
diff --git a/src/ui/kdhorizontalline.h b/src/ui/kdhorizontalline.h
index 75e7caafe..d168b3825 100644
--- a/src/ui/kdhorizontalline.h
+++ b/src/ui/kdhorizontalline.h
@@ -1,60 +1,58 @@
 /* -*- Mode: C++ -*-
    KD Tools - a set of useful widgets for Qt
 */
 
 /****************************************************************************
 ** SPDX-FileCopyrightText: 2005 Klarälvdalens Datakonsult AB. All rights reserved.
 **
 ** This file is part of the KD Tools library.
 **
 ** SPDX-License-Identifier: GPL-2.0-or-later
 **
 **********************************************************************/
 
-#ifndef __KDTOOLS__KDHORIZONTALLINE_H__
-#define __KDTOOLS__KDHORIZONTALLINE_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <QFrame>
 
 class KLEO_EXPORT KDHorizontalLine : public QFrame
 {
     Q_OBJECT
     Q_PROPERTY(QString title READ title WRITE setTitle)
 public:
     explicit KDHorizontalLine(QWidget *parent = nullptr, const char *name = nullptr,  Qt::WindowFlags f = {});
     explicit KDHorizontalLine(const QString &title, QWidget *parent = nullptr, const char *name = nullptr,  Qt::WindowFlags f = {});
     ~KDHorizontalLine() override;
 
     QString title() const
     {
         return mTitle;
     }
 
     /*! \reimp to hard-code the frame shape */
     void setFrameStyle(int style);
 
     QSize sizeHint() const override;
     QSize minimumSizeHint() const override;
     QSizePolicy sizePolicy() const;
 
     static int indentHint();
 
 public Q_SLOTS:
     virtual void setTitle(const QString &title);
 
 protected:
     void paintEvent(QPaintEvent *) override;
 
 private:
     void calculateFrame();
 
 private:
     QString mTitle;
     Qt::Alignment mAlign;
     int mLenVisible;
 };
 
-#endif /* __KDTOOLS__KDHORIZONTALLINE_H__ */
 
diff --git a/src/ui/keyapprovaldialog.h b/src/ui/keyapprovaldialog.h
index c5a792cfb..911150b1b 100644
--- a/src/ui/keyapprovaldialog.h
+++ b/src/ui/keyapprovaldialog.h
@@ -1,68 +1,66 @@
 /*  -*- c++ -*-
     keyapprovaldialog.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.h
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_KEYAPPROVALDIALOG_H__
-#define __KLEO_KEYAPPROVALDIALOG_H__
+#pragma once
 
 #include "kleo_export.h"
 #include "libkleo/enum.h"
 
 #include <QDialog>
 
 #include <gpgme++/key.h>
 
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 
 class KLEO_EXPORT KeyApprovalDialog : public QDialog
 {
     Q_OBJECT
 public:
     struct Item {
         Item() : pref(UnknownPreference) {}
         Item(const QString &a, const std::vector<GpgME::Key> &k,
              EncryptionPreference p = UnknownPreference)
             : address(a), keys(k), pref(p) {}
         QString address;
         std::vector<GpgME::Key> keys;
         EncryptionPreference pref;
     };
 
     KeyApprovalDialog(const std::vector<Item> &recipients,
                       const std::vector<GpgME::Key> &sender,
                       QWidget *parent = nullptr);
     ~KeyApprovalDialog();
 
     std::vector<Item> items() const;
     std::vector<GpgME::Key> senderKeys() const;
 
     bool preferencesChanged() const;
 
 private Q_SLOTS:
     void slotPrefsChanged();
 
 private:
     class Private;
     Private *const d;
 };
 
 } // namespace Kleo
 
-#endif // __KLEO_KEYAPPROVALDIALOG_H__
diff --git a/src/ui/keylistview.h b/src/ui/keylistview.h
index 9e7e6530f..0ee2482b7 100644
--- a/src/ui/keylistview.h
+++ b/src/ui/keylistview.h
@@ -1,204 +1,202 @@
 /*
     keylistview.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_KEYLISTVIEW_H__
-#define __KLEO_KEYLISTVIEW_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <gpgme++/key.h>
 
 #include <QByteArray>
 #include <QTreeWidget>
 #include <QHeaderView>
 #include <QIcon>
 
 class QFont;
 class QColor;
 
 namespace Kleo
 {
 
 // work around moc parser bug...
 #define TEMPLATE_TYPENAME(T) template <typename T>
 TEMPLATE_TYPENAME(T)
 inline T *lvi_cast(QTreeWidgetItem *item)
 {
     return item && (item->type() == T::RTTI)
            ? static_cast<T *>(item) : nullptr;
 }
 
 TEMPLATE_TYPENAME(T)
 inline const T *lvi_cast(const QTreeWidgetItem *item)
 {
     return item && (item->type() == T::RTTI)
            ? static_cast<const T *>(item) : nullptr;
 }
 #undef TEMPLATE_TYPENAME
 
 class KeyListView;
 
 class KeyListViewItem : public QTreeWidgetItem
 {
 public:
     KeyListViewItem(KeyListView *parent, const GpgME::Key &key);
     KeyListViewItem(KeyListView *parent, KeyListViewItem *after, const GpgME::Key &key);
     KeyListViewItem(KeyListViewItem *parent, const GpgME::Key &key);
     KeyListViewItem(KeyListViewItem *parent, KeyListViewItem *after, const GpgME::Key &key);
     ~KeyListViewItem() override;
 
     void setKey(const GpgME::Key &key);
     const GpgME::Key &key() const
     {
         return mKey;
     }
 
     enum { RTTI = QTreeWidgetItem::UserType + 1 };
 
     //
     // only boring stuff below:
     //
     virtual QString toolTip(int column) const;
 
     /*! \reimp for covariant return */
     KeyListView *listView() const;
     /*! \reimp for covariant return */
     KeyListViewItem *nextSibling() const;
     /*! \reimp */
     bool operator<(const QTreeWidgetItem &other) const override;
     /*! \reimp */
     void takeItem(QTreeWidgetItem *item);
 
 private:
     GpgME::Key mKey;
 };
 
 class KLEO_EXPORT KeyListView : public QTreeWidget
 {
     Q_OBJECT
     friend class KeyListViewItem;
 public:
 
     class KLEO_EXPORT ColumnStrategy
     {
     public:
         virtual ~ColumnStrategy();
         virtual QString title(int column) const = 0;
         virtual int width(int column, const QFontMetrics &fm) const;
         virtual QHeaderView::ResizeMode resizeMode(int) const
         {
             return QHeaderView::Interactive;
         }
 
         virtual QString text(const GpgME::Key &key, int column) const = 0;
         virtual QString toolTip(const GpgME::Key &key, int column) const;
         virtual QIcon icon(const GpgME::Key &, int) const
         {
             return QIcon();
         }
         virtual int compare(const GpgME::Key &key1, const GpgME::Key &key2, const int column) const;
     };
 
     class KLEO_EXPORT DisplayStrategy
     {
     public:
         virtual ~DisplayStrategy();
         //font
         virtual QFont keyFont(const GpgME::Key &, const QFont &) const;
         //foreground
         virtual QColor keyForeground(const GpgME::Key &, const QColor &) const;
         //background
         virtual QColor keyBackground(const GpgME::Key &, const QColor &) const;
     };
 
     explicit KeyListView(const ColumnStrategy *strategy,
                          const DisplayStrategy *display = nullptr,
                          QWidget *parent = nullptr, Qt::WindowFlags f = {});
 
     ~KeyListView();
 
     const ColumnStrategy *columnStrategy() const
     {
         return mColumnStrategy;
     }
     const DisplayStrategy *displayStrategy() const
     {
         return mDisplayStrategy;
     }
 
     bool hierarchical() const
     {
         return mHierarchical;
     }
     virtual void setHierarchical(bool hier);
 
     void flushKeys()
     {
         slotUpdateTimeout();
     }
 
     bool isMultiSelection() const;
 
     KeyListViewItem *itemByFingerprint(const QByteArray &) const;
 
 public:
     using QTreeWidget::selectionChanged; // for below, but moc doesn't like it to be in the Q_SIGNALS: section
 Q_SIGNALS:
     void doubleClicked(Kleo::KeyListViewItem *, int);
     void returnPressed(Kleo::KeyListViewItem *);
     void selectionChanged(Kleo::KeyListViewItem *);
     void contextMenu(Kleo::KeyListViewItem *, const QPoint &);
 
 protected:
     void keyPressEvent(QKeyEvent *event) override;
 
 public Q_SLOTS:
     virtual void slotAddKey(const GpgME::Key &key);
     virtual void slotRefreshKey(const GpgME::Key &key);
 
     //
     // Only boring stuff below:
     //
 private Q_SLOTS:
     void slotEmitDoubleClicked(QTreeWidgetItem *, int);
     void slotEmitReturnPressed(QTreeWidgetItem *);
     void slotEmitSelectionChanged();
     void slotEmitContextMenu(const QPoint &pos);
     void slotUpdateTimeout();
 
 public:
     /*! \reimp for covariant return */
     KeyListViewItem *selectedItem() const;
     /*! \reimp */
     QList<KeyListViewItem *> selectedItems() const;
     /*! \reimp for covariant return */
     KeyListViewItem *firstChild() const;
     /*! \reimp */
     void clear();
     /*! \reimp */
     void takeItem(QTreeWidgetItem *);
 
 private:
     void doHierarchicalInsert(const GpgME::Key &);
     void gatherScattered();
     void scatterGathered(KeyListViewItem *);
     void registerItem(KeyListViewItem *);
     void deregisterItem(const KeyListViewItem *);
 
 private:
     const ColumnStrategy *mColumnStrategy = nullptr;
     const DisplayStrategy *mDisplayStrategy = nullptr;
     bool mHierarchical = false;
 
     class Private;
     Private *const d;
 };
 }
 
-#endif // __KLEO_KEYLISTVIEW_H__
diff --git a/src/ui/keyrequester.h b/src/ui/keyrequester.h
index 7e5204302..be7c8ebdf 100644
--- a/src/ui/keyrequester.h
+++ b/src/ui/keyrequester.h
@@ -1,204 +1,202 @@
 /*  -*- 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
  */
 
-#ifndef __KLEO_UI_KEYREQUESTER_H__
-#define __KLEO_UI_KEYREQUESTER_H__
+#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;
 };
 
 }
 
-#endif // __KLEO_UI_KEYREQUESTER_H__
diff --git a/src/ui/keyselectioncombo.h b/src/ui/keyselectioncombo.h
index 17d3cd219..43b4410f0 100644
--- a/src/ui/keyselectioncombo.h
+++ b/src/ui/keyselectioncombo.h
@@ -1,73 +1,71 @@
 /*  This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef KLEO_KEYSELECTIONCOMBO_H
-#define KLEO_KEYSELECTIONCOMBO_H
+#pragma once
 
 #include <QComboBox>
 
 #include <gpgme++/global.h>
 
 #include <kleo_export.h>
 #include <libkleo/enum.h>
 
 #include <memory>
 
 namespace GpgME
 {
 class Key;
 }
 
 namespace Kleo
 {
 class KeyFilter;
 class KeySelectionComboPrivate;
 
 class KLEO_EXPORT KeySelectionCombo : public QComboBox
 {
     Q_OBJECT
 
 public:
     explicit KeySelectionCombo(QWidget *parent = nullptr);
     explicit KeySelectionCombo(bool secretOnly, QWidget *parent = nullptr);
     ~KeySelectionCombo() override;
 
     void setKeyFilter(const std::shared_ptr<const KeyFilter> &kf);
     std::shared_ptr<const KeyFilter> keyFilter() const;
 
     void setIdFilter(const QString &id);
     QString idFilter() const;
 
     void refreshKeys();
 
     GpgME::Key currentKey() const;
     void setCurrentKey(const GpgME::Key &key);
     void setCurrentKey(const QString &fingerprint);
 
     void setDefaultKey(const QString &fingerprint);
     void setDefaultKey(const QString &fingerprint, GpgME::Protocol proto);
     QString defaultKey() const;
     QString defaultKey(GpgME::Protocol proto) const;
 
     void prependCustomItem(const QIcon &icon, const QString &text, const QVariant &data);
     void appendCustomItem(const QIcon &icon, const QString &text, const QVariant &data);
     void prependCustomItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip);
     void appendCustomItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip);
 
 Q_SIGNALS:
     void customItemSelected(const QVariant &data);
     void currentKeyChanged(const GpgME::Key &key);
     void keyListingFinished();
 
 protected:
     virtual void init();
 
 private:
     KeySelectionComboPrivate * const d;
 };
 
 }
-#endif
diff --git a/src/ui/keyselectiondialog.h b/src/ui/keyselectiondialog.h
index 290985094..8ed9a07fa 100644
--- a/src/ui/keyselectiondialog.h
+++ b/src/ui/keyselectiondialog.h
@@ -1,202 +1,200 @@
 /*  -*- 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
 */
 
-#ifndef __KLEO_UI_KEYSELECTIONDIALOG_H__
-#define __KLEO_UI_KEYSELECTIONDIALOG_H__
+#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)
 
-#endif // __KLEO_UI_KEYSELECTIONDIALOG_H__
diff --git a/src/ui/messagebox.h b/src/ui/messagebox.h
index e25013a25..e09c647be 100644
--- a/src/ui/messagebox.h
+++ b/src/ui/messagebox.h
@@ -1,67 +1,65 @@
 /*
     messagebox.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_UI_MESSAGEBOX_H__
-#define __KLEO_UI_MESSAGEBOX_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <KMessageBox>
 
 #undef MessageBox // Windows
 
 namespace GpgME
 {
 class SigningResult;
 class EncryptionResult;
 }
 
 namespace QGpgME
 {
 class Job;
 }
 
 class QWidget;
 class QString;
 
 namespace Kleo
 {
 
 class KLEO_EXPORT MessageBox
 {
 public:
     static void information(QWidget *parent, const GpgME::SigningResult &result, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void information(QWidget *parent, const GpgME::SigningResult &result, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::SigningResult &result, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::SigningResult &result, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
 
     static void information(QWidget *parent, const GpgME::EncryptionResult &result, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void information(QWidget *parent, const GpgME::EncryptionResult &result, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::EncryptionResult &result, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::EncryptionResult &result, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
 
     static void information(QWidget *parent, const GpgME::SigningResult &sresult, const GpgME::EncryptionResult &eresult, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void information(QWidget *parent, const GpgME::SigningResult &sresult, const GpgME::EncryptionResult &eresult, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::SigningResult &sresult, const GpgME::EncryptionResult &eresult, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::SigningResult &sresult, const GpgME::EncryptionResult &eresult, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
 
     static void auditLog(QWidget *parent, const QGpgME::Job *job, const QString &caption);
     static void auditLog(QWidget *parent, const QGpgME::Job *job);
     static void auditLog(QWidget *parent, const QString &log, const QString &caption);
     static void auditLog(QWidget *parent, const QString &log);
 
     static bool showAuditLogButton(const QGpgME::Job *job);
 
 private:
     static void make(QWidget *parent, QMessageBox::Icon icon, const QString &text, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options);
 };
 
 }
 
-#endif /* __KLEO_UI_MESSAGEBOX_H__ */
diff --git a/src/ui/newkeyapprovaldialog.h b/src/ui/newkeyapprovaldialog.h
index 61f90ea92..e185223ba 100644
--- a/src/ui/newkeyapprovaldialog.h
+++ b/src/ui/newkeyapprovaldialog.h
@@ -1,92 +1,90 @@
 /*  -*- c++ -*-
     newkeyapprovaldialog.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2018 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_NEWKEYAPPROVALDIALOG_H__
-#define __KLEO_NEWKEYAPPROVALDIALOG_H__
+#pragma once
 
 #include "kleo_export.h"
 
 #include <QDialog>
 
 #include <gpgme++/key.h>
 
 #include <vector>
 
 namespace Kleo
 {
 
 /** @brief A dialog to show for encryption / signing key approval or selection.
  *
  * This class is intended to replace the old KeyApprovalDialog with a new
  * and simpler interface.
  *
  * Resolved recipients in this API means a recipient could be resolved
  * to a single useful key. An unresolved recipient is a recipient for
  * whom no key could be found. Import / Search will be offered for such
  * a recipient. Multiple keys for signing / recipient can come e.g. from
  * group configuration or Addressbook / Identity configuration.
  *
  * The Dialog uses the Level System for validity display and shows an
  * overall outgoing level.
  *
  */
 class KLEO_EXPORT NewKeyApprovalDialog : public QDialog
 {
     Q_OBJECT
 public:
     /** @brief Create a new Key Approval Dialog.
      *
      * @param resolvedSigningKeys: A map of signing addresses and Keys. Usually the
      *                             map would contain a single element and a single key
      *                             but configuration may allow more.
      * @param resolvedRecp: A map of a recipient address and the keys for that address. Multiple
      *                      keys could for example be configured through Address book or GnuPG
      *                      Groups.
      * @param unresolvedSigKeys: A list of signing addresses for which no key was found. Should
      *                           usually be only one. If resolved and unresolved sig keys are
      *                           empty it is assumed signing was not selected.
      * @param unresolvedRecp: A list of encryption target addresses if both unresolved and
      *                        resolved recipients are empty it is assumed no encryption should
      *                        take place.
      * @param senderAddr: The address of the sender, this may be used if singing is not
      *                    specified to identify a recipient for which "Generate Key" should
      *                    be offered.
      * @param allowMixed: Whether or not the dialog should allow mixed CMS / PGP key selection.
      * @param forcedProtocol: A specific forced protocol.
      * @param presetProtocol: A specific preselected protocol. If Protocol is unknown it will allow
      *               both (depending on allowMixed) S/MIME and OpenPGP.
      * @param parent: The parent widget.
      * @param f: The Qt window flags.
      */
     explicit NewKeyApprovalDialog(const QMap<QString, std::vector<GpgME::Key> > &resolvedSigningKeys,
                                   const QMap<QString, std::vector<GpgME::Key> > &resolvedRecp,
                                   const QStringList &unresolvedSigKeys,
                                   const QStringList &unresolvedRecp,
                                   const QString &senderAddr,
                                   bool allowMixed,
                                   GpgME::Protocol forcedProtocol,
                                   GpgME::Protocol presetProtocol,
                                   QWidget *parent = nullptr,
                                   Qt::WindowFlags f = Qt::WindowFlags());
 
     ~NewKeyApprovalDialog() override;
 
     /** @brief The selected signing Keys. Only valid after Dialog was accepted. */
     std::vector<GpgME::Key> signingKeys();
     /** @brief The selected encryption Keys. Only valid after Dialog was accepted. */
     QMap<QString, std::vector<GpgME::Key> > encryptionKeys();
 
 private:
     class Private;
     std::unique_ptr<Private> d;
 };
 
 } // namespace kleo
 
-#endif //__KLEO_NEWKEYAPPROVALDIALOG_H__
diff --git a/src/ui/progressbar.h b/src/ui/progressbar.h
index 0c24fa1ea..75204aaf4 100644
--- a/src/ui/progressbar.h
+++ b/src/ui/progressbar.h
@@ -1,56 +1,54 @@
 /*
     progressbar.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_PROGRESSBAR_H__
-#define __KLEO_PROGRESSBAR_H__
+#pragma once
 
 #include "kleo_export.h"
 #include <QProgressBar>
 class QTimer;
 
 namespace Kleo
 {
 
 /**
    @short A QProgressBar with self-powered busy indicator
 */
 class KLEO_EXPORT ProgressBar : public QProgressBar
 {
     Q_OBJECT
 public:
     explicit ProgressBar(QWidget *parent = nullptr);
 
 public Q_SLOTS:
     void slotProgress(const QString &message, int type, int current, int total);
     void slotProgress(const QString &message, int current, int total);
     /*! reimplementation to support self-powered busy indicator */
     void setValue(int progress);
     /*! reimplementation to support self-powered busy indicator */
     void setMaximum(int total);
     /*! reimplementation to support self-powered busy indicator */
     void reset();
     /*! reimplementation to preserve visibility */
     void setRange(int cur, int tot)
     {
         QProgressBar::setRange(cur, tot);
     }
 
 private Q_SLOTS:
     void slotBusyTimerTick();
 
 private:
     void fixup(bool);
 
 private:
     QTimer *mBusyTimer = nullptr;
     int mRealProgress;
 };
 }
 
-#endif // __KLEO_PROGRESSBAR_H__
diff --git a/src/ui/progressdialog.h b/src/ui/progressdialog.h
index b23df3e8f..1e2819ffb 100644
--- a/src/ui/progressdialog.h
+++ b/src/ui/progressdialog.h
@@ -1,54 +1,52 @@
 /*
     progressdialog.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEO_PROGRESSDIALOG_H__
-#define __KLEO_PROGRESSDIALOG_H__
+#pragma once
 
 #include "kleo_export.h"
 #include <QProgressDialog>
 
 #ifndef QT_NO_PROGRESSDIALOG
 
 #include <QString>
 
 #include <qgpgme/job.h>
 namespace Kleo
 {
 
 /**
    @short A progress dialog for Kleo::Jobs
 */
 class KLEO_EXPORT ProgressDialog : public QProgressDialog
 {
     Q_OBJECT
 public:
     ProgressDialog(QGpgME::Job *job, const QString &baseText,
                    QWidget *widget = nullptr, Qt::WindowFlags f = {});
     ~ProgressDialog();
 
 public Q_SLOTS:
     /*! reimplementation */
     void setMinimumDuration(int ms);
 
 private Q_SLOTS:
     void slotProgress(const QString &what, int current, int total);
     void slotDone();
 private:
     QString mBaseText;
 };
 
 }
 
 #else
 # ifndef LIBKLEO_NO_PROGRESSDIALOG
 #  define LIBKLEO_NO_PROGRESSDIALOG
 # endif
 #endif // QT_NO_PROGRESSDIALOG
 
-#endif // __KLEO_PROGRESSDIALOG_H__
diff --git a/src/utils/algorithm.h b/src/utils/algorithm.h
index 0fbb71b4c..e6005d7ac 100644
--- a/src/utils/algorithm.h
+++ b/src/utils/algorithm.h
@@ -1,35 +1,33 @@
 /*
     utils/algorithm.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef LIBKLEO_ALGORITHM_H
-#define LIBKLEO_ALGORITHM_H
+#pragma once
 
 #include <algorithm>
 
 namespace Kleo
 {
 
 template<typename ForwardIterator, typename T>
 ForwardIterator binary_find(ForwardIterator first, ForwardIterator last, const T &value)
 {
     const ForwardIterator it = std::lower_bound(first, last, value);
     return (it == last || value < *it) ? last : it;
 }
 
 template<typename ForwardIterator, typename T, typename Compare>
 ForwardIterator binary_find(ForwardIterator first, ForwardIterator last, const T &value, Compare comp)
 {
     const ForwardIterator it = std::lower_bound(first, last, value, comp);
     return (it == last || comp(value, *it)) ? last : it;
 }
 
 }
 
-#endif // LIBKLEO_ALGORITHM_H
diff --git a/src/utils/compat.h b/src/utils/compat.h
index 89472e38b..cf2f20917 100644
--- a/src/utils/compat.h
+++ b/src/utils/compat.h
@@ -1,29 +1,27 @@
 /*
     utils/compat.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef LIBKLEO_COMPAT_H
-#define LIBKLEO_COMPAT_H
+#pragma once
 
 #include "kleo_export.h"
 
 namespace QGpgME
 {
 class CryptoConfig;
 class CryptoConfigEntry;
 }
 
 namespace Kleo
 {
 
 KLEO_EXPORT QGpgME::CryptoConfigEntry *getCryptoConfigEntry(const QGpgME::CryptoConfig *config, const char *componentName, const char *entryName);
 
 }
 
-#endif // LIBKLEO_COMPAT_H
diff --git a/src/utils/filesystemwatcher.h b/src/utils/filesystemwatcher.h
index e90eb2fce..804b87e0a 100644
--- a/src/utils/filesystemwatcher.h
+++ b/src/utils/filesystemwatcher.h
@@ -1,58 +1,56 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     filesystemwatcher.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_UTILS_FILESYSTEMWATCHER_H__
-#define __KLEOPATRA_UTILS_FILESYSTEMWATCHER_H__
+#pragma once
 
 #include <QObject>
 
 #include <kleo_export.h>
 
 class QString;
 #include <QStringList>
 
 namespace Kleo
 {
 
 class KLEO_EXPORT FileSystemWatcher : public QObject
 {
     Q_OBJECT
 public:
     explicit FileSystemWatcher(QObject *parent = nullptr);
     explicit FileSystemWatcher(const QStringList &paths, QObject *parent = nullptr);
     ~FileSystemWatcher();
 
     void setDelay(int ms);
     int delay() const;
 
     void setEnabled(bool enable);
     bool isEnabled() const;
 
     void addPaths(const QStringList &paths);
     void addPath(const QString &path);
 
     void blacklistFiles(const QStringList &patterns);
     void whitelistFiles(const QStringList &patterns);
 
     QStringList files() const;
     void removePaths(const QStringList &path);
     void removePath(const QString &path);
 
 Q_SIGNALS:
     void directoryChanged(const QString &path);
     void fileChanged(const QString &path);
     void triggered();
 
 private:
     class Private;
     QScopedPointer<Private> const d;
 };
 }
 
-#endif // __KLEOPATRA_UTILS_FILESYSTEMWATCHER_H__
diff --git a/src/utils/formatting.h b/src/utils/formatting.h
index 47befcfe6..4407ffdb3 100644
--- a/src/utils/formatting.h
+++ b/src/utils/formatting.h
@@ -1,160 +1,158 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/formatting.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_UTILS_FORMATTING_H__
-#define __KLEOPATRA_UTILS_FORMATTING_H__
+#pragma once
 
 #include <gpgme++/key.h>
 
 #include <kleo_export.h>
 
 class QString;
 #include <QStringList>
 class QDate;
 class QIcon;
 
 namespace GpgME
 {
 class Import;
 }
 
 namespace Kleo
 {
 class KeyGroup;
 
 namespace Formatting
 {
 
 KLEO_EXPORT QString prettyNameAndEMail(int proto, const char *id, const char *name, const char *email, const char *comment);
 KLEO_EXPORT QString prettyNameAndEMail(int proto, const QString &id, const QString &name, const QString &email, const QString &comment);
 KLEO_EXPORT QString prettyNameAndEMail(const GpgME::Key &key);
 KLEO_EXPORT QString prettyNameAndEMail(const GpgME::UserID &key);
 
 KLEO_EXPORT QString prettyUserID(const GpgME::UserID &uid);
 KLEO_EXPORT QString prettyKeyID(const char *id);
 
 KLEO_EXPORT QString prettyName(int proto, const char *id, const char *name, const char *comment);
 KLEO_EXPORT QString prettyName(const GpgME::Key &key);
 KLEO_EXPORT QString prettyName(const GpgME::UserID &uid);
 KLEO_EXPORT QString prettyName(const GpgME::UserID::Signature &sig);
 
 KLEO_EXPORT QString prettyEMail(const char *email, const char *id);
 KLEO_EXPORT QString prettyEMail(const GpgME::Key &key);
 KLEO_EXPORT QString prettyEMail(const GpgME::UserID &uid);
 KLEO_EXPORT QString prettyEMail(const GpgME::UserID::Signature &sig);
 
 /* Formats a fingerprint or keyid into groups of four */
 KLEO_EXPORT QString prettyID(const char *id);
 
 enum ToolTipOption {
     KeyID            = 0x001,
     Validity         = 0x002,
     StorageLocation  = 0x004,
     SerialNumber     = 0x008,
     Issuer           = 0x010,
     Subject          = 0x020,
     ExpiryDates      = 0x040,
     CertificateType  = 0x080,
     CertificateUsage = 0x100,
     Fingerprint      = 0x200,
     UserIDs          = 0x400,
     OwnerTrust       = 0x800,
     Subkeys          = 0x1000,
 
     AllOptions = 0xffff
 };
 
 KLEO_EXPORT QString toolTip(const GpgME::Key &key, int opts);
 KLEO_EXPORT QString toolTip(const Kleo::KeyGroup &group, int opts);
 
 KLEO_EXPORT QString expirationDateString(const GpgME::Key &key);
 KLEO_EXPORT QString expirationDateString(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString expirationDateString(const GpgME::UserID::Signature &sig);
 KLEO_EXPORT QDate expirationDate(const GpgME::Key &key);
 KLEO_EXPORT QDate expirationDate(const GpgME::Subkey &subkey);
 KLEO_EXPORT QDate expirationDate(const GpgME::UserID::Signature &sig);
 
 KLEO_EXPORT QString creationDateString(const GpgME::Key &key);
 KLEO_EXPORT QString creationDateString(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString creationDateString(const GpgME::UserID::Signature &sig);
 KLEO_EXPORT QDate creationDate(const GpgME::Key &key);
 KLEO_EXPORT QDate creationDate(const GpgME::Subkey &subkey);
 KLEO_EXPORT QDate creationDate(const GpgME::UserID::Signature &sig);
 
 /* Convert a GPGME style time to a localized string */
 KLEO_EXPORT QString dateString(time_t t);
 
 KLEO_EXPORT QString displayName(GpgME::Protocol prot);
 KLEO_EXPORT QString type(const GpgME::Key &key);
 KLEO_EXPORT QString type(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString type(const Kleo::KeyGroup &group);
 
 KLEO_EXPORT QString ownerTrustShort(const GpgME::Key &key);
 KLEO_EXPORT QString ownerTrustShort(GpgME::Key::OwnerTrust trust);
 
 KLEO_EXPORT QString validityShort(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString validityShort(const GpgME::UserID &uid);
 KLEO_EXPORT QString validityShort(const GpgME::UserID::Signature &sig);
 KLEO_EXPORT QIcon   validityIcon(const GpgME::UserID::Signature &sig);
 /* A sentence about the validity of the UserID */
 KLEO_EXPORT QString validity(const GpgME::UserID &uid);
 KLEO_EXPORT QString validity(const Kleo::KeyGroup &group);
 KLEO_EXPORT QIcon validityIcon(const Kleo::KeyGroup &group);
 
 KLEO_EXPORT QString formatForComboBox(const GpgME::Key &key);
 
 KLEO_EXPORT QString formatKeyLink(const GpgME::Key &key);
 
 KLEO_EXPORT QString signatureToString(const GpgME::Signature &sig, const GpgME::Key &key);
 
 KLEO_EXPORT const char *summaryToString(const GpgME::Signature::Summary summary);
 
 KLEO_EXPORT QString importMetaData(const GpgME::Import &import);
 KLEO_EXPORT QString importMetaData(const GpgME::Import &import, const QStringList &sources);
 
 KLEO_EXPORT QString formatOverview(const GpgME::Key &key);
 KLEO_EXPORT QString usageString(const GpgME::Subkey &subkey);
 KLEO_EXPORT QString summaryLine(const GpgME::Key &key);
 KLEO_EXPORT QString summaryLine(const KeyGroup &group);
 
 KLEO_EXPORT QIcon iconForUid(const GpgME::UserID &uid);
 
 /* Is the key valid i.e. are all uids fully trusted?  */
 KLEO_EXPORT bool uidsHaveFullValidity(const GpgME::Key &key);
 
 /* The compliance mode of the gnupg system. Empty if compliance
  * mode is not set. */
 KLEO_EXPORT QString complianceMode();
 
 /* Is the given key in compliance with CO_DE_VS?  */
 KLEO_EXPORT bool isKeyDeVs(const GpgME::Key &key);
 /* Localized string describing the name of the VS-NfD Compliance filter. If
  * compliant is false the name of the not Compliant filter.
  *
  * This is required to make the string configurable which is
  * a common request from users because VS-NfD compliance is called
  * differently in different enviornments. E.g NATO RESTRICTED or
  * EU RESTRICTED. */
 KLEO_EXPORT QString deVsString (bool compliant = true);
 
 /* A sentence if the key confirms to the current compliance mode */
 KLEO_EXPORT QString complianceStringForKey(const GpgME::Key &key);
 
 /* A single word for use in keylists to describe the validity of the
  * given key, including any conformance statements relevant to the
  * current conformance mode.  */
 KLEO_EXPORT QString complianceStringShort(const GpgME::Key &key);
 KLEO_EXPORT QString complianceStringShort(const Kleo::KeyGroup &group);
 
 /* The origin of the key mapped to a localized string */
 KLEO_EXPORT QString origin(int o);
 }
 }
 
-#endif /* __KLEOPATRA_UTILS_FORMATTING_H__ */
diff --git a/src/utils/gnupg-registry.h b/src/utils/gnupg-registry.h
index ce0e354db..2deb6a216 100644
--- a/src/utils/gnupg-registry.h
+++ b/src/utils/gnupg-registry.h
@@ -1,43 +1,41 @@
 /* registry.h - registry prototypes
    SPDX-FileCopyrightText: 2006, 2007 g 10 Code GmbH
 
    This file is part of GpgEX.
 
    SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 /* keep this in sync with svn://cvs.gnupg.org/gpgex/trunk/src/registry.h (last checked against rev. 19) */
 
-#ifndef REGISTRY_H
-#define REGISTRY_H
+#pragma once
 
 #include <windows.h>
 
 #ifdef __cplusplus
 extern "C" {
 #if 0
 }
 #endif
 #endif
 
 /* This is a helper function to load a Windows function from either of
    one DLLs. */
 HRESULT w32_shgetfolderpath(HWND a, int b, HANDLE c, DWORD d, LPSTR e);
 
 /* Return a string from the Win32 Registry or NULL in case of error.
    Caller must release the return value.  A NULL for root is an alias
    for HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE in turn.  */
 char *read_w32_registry_string(const char *root, const char *dir,
                                const char *name);
 
 /* Retrieve the default home directory.  */
 char *default_homedir(void);
 
 #ifdef __cplusplus
 #if 0
 {
 #endif
 }
 #endif
 
-#endif /* ! REGISTRY_H */
diff --git a/src/utils/gnupg.h b/src/utils/gnupg.h
index a521f5453..27994e594 100644
--- a/src/utils/gnupg.h
+++ b/src/utils/gnupg.h
@@ -1,64 +1,62 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/gnupg.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_GNUPGHELPER_H__
-#define __KLEOPATRA_GNUPGHELPER_H__
+#pragma once
 
 #include <gpgme++/engineinfo.h>
 #include <gpgme++/key.h>
 
 /* Does the given object comply with DE_VS?  This macro can be used to
    ensure that we can still build against older versions of GPGME
    without cluttering the code with preprocessor conditionals.  */
 #define IS_DE_VS(x)	(x).isDeVs()
 
 #include <kleo_export.h>
 
 class QString;
 #include <QStringList>
 class QByteArray;
 
 namespace Kleo
 {
 
 KLEO_EXPORT QString gnupgHomeDirectory();
 
 KLEO_EXPORT QString gpgConfPath();
 KLEO_EXPORT QString gpgSmPath();
 KLEO_EXPORT QString gpgPath();
 
 KLEO_EXPORT QString gpgConfListDir(const char *which);
 KLEO_EXPORT QString gpg4winInstallPath();
 KLEO_EXPORT QString gpg4winVersion();
 KLEO_EXPORT bool gpg4winSignedversion();
 KLEO_EXPORT QString gpg4winDescription();
 KLEO_EXPORT QString gpg4winLongDescription();
 KLEO_EXPORT QString gnupgInstallPath();
 KLEO_EXPORT const QString& paperKeyInstallPath();
 
 KLEO_EXPORT QStringList gnupgFileWhitelist();
 KLEO_EXPORT int makeGnuPGError(int code);
 
 KLEO_EXPORT bool engineIsVersion(int major, int minor, int patch, GpgME::Engine = GpgME::GpgConfEngine);
 KLEO_EXPORT bool haveKeyserverConfigured();
 KLEO_EXPORT bool gpgComplianceP(const char *mode);
 KLEO_EXPORT enum GpgME::UserID::Validity keyValidity(const GpgME::Key &key);
 
 /* Convert GnuPG output to a QString with proper encoding.
  * Takes Gpg Quirks into account and might handle future
  * changes in GnuPG Output. */
 KLEO_EXPORT QString stringFromGpgOutput(const QByteArray &ba);
 
 /* Check if a minimum version is there. Strings should be in the format:
  * 1.2.3 */
 KLEO_EXPORT bool versionIsAtLeast(const char *minimum, const char *actual);
 }
 
-#endif // __KLEOPATRA_GNUPGHELPER_H__
diff --git a/src/utils/hex.h b/src/utils/hex.h
index 7fd21cdad..d9420aadf 100644
--- a/src/utils/hex.h
+++ b/src/utils/hex.h
@@ -1,31 +1,29 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/hex.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
-#ifndef __KLEOPATRA_UTILS_HEX_H__
-#define __KLEOPATRA_UTILS_HEX_H__
+#pragma once
 
 #include <string>
 
 class QByteArray;
 
 namespace Kleo
 {
 
 std::string hexencode(const char *s);
 std::string hexdecode(const char *s);
 
 std::string hexencode(const std::string &s);
 std::string hexdecode(const std::string &s);
 
 QByteArray hexencode(const QByteArray &s);
 QByteArray hexdecode(const QByteArray &s);
 
 }
 
-#endif /* __KLEOPATRA_UTILS_HEX_H__ */