diff --git a/src/kleo/dn.h b/src/kleo/dn.h
index e24a94a10..c121f3ee5 100644
--- a/src/kleo/dn.h
+++ b/src/kleo/dn.h
@@ -1,140 +1,140 @@
 /*
     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__
 
 #include "kleo_export.h"
 
 #include <QString>
 #include <QVector>
 
 class 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;
-    typedef QVector<Attribute> AttributeList;
-    typedef AttributeList::const_iterator const_iterator;
+    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:
-    typedef DN::AttributeList List;
+    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/keyfiltermanager.cpp b/src/kleo/keyfiltermanager.cpp
index ad82898c6..9e0e769c2 100644
--- a/src/kleo/keyfiltermanager.cpp
+++ b/src/kleo/keyfiltermanager.cpp
@@ -1,427 +1,427 @@
 /*
     keyfiltermanager.cpp
 
     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
 */
 
 #include "keyfiltermanager.h"
 #include "kconfigbasedkeyfilter.h"
 #include "defaultkeyfilter.h"
 
 #include "stl_util.h"
 
 #include "libkleo_debug.h"
 #include "utils/formatting.h"
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KLocalizedString>
 #include <QIcon>
 
 #include <QCoreApplication>
 #include <QRegularExpression>
 #include <QStringList>
 #include <QAbstractListModel>
 #include <QModelIndex>
 
 #include <algorithm>
 #include <climits>
 #include <functional>
 
 using namespace Kleo;
 using namespace GpgME;
 
 namespace
 {
 
 class Model : public QAbstractListModel
 {
     KeyFilterManager::Private *m_keyFilterManagerPrivate;
 public:
     explicit Model(KeyFilterManager::Private *p)
         : QAbstractListModel(nullptr), m_keyFilterManagerPrivate(p) {}
 
     int rowCount(const QModelIndex &) const override;
     QVariant data(const QModelIndex &idx, int role) const override;
     /* upgrade to public */ using QAbstractListModel::beginResetModel;
     /* upgrade to public */ using QAbstractListModel::endResetModel;
 };
 
 class AllCertificatesKeyFilter : public DefaultKeyFilter
 {
 public:
     AllCertificatesKeyFilter()
         : DefaultKeyFilter()
     {
         setSpecificity(UINT_MAX); // overly high for ordering
         setName(i18n("All Certificates"));
         setId(QStringLiteral("all-certificates"));
         setMatchContexts(Filtering);
     }
 };
 
 class MyCertificatesKeyFilter : public DefaultKeyFilter
 {
 public:
     MyCertificatesKeyFilter()
         : DefaultKeyFilter()
     {
         setHasSecret(Set);
         setSpecificity(UINT_MAX - 1); // overly high for ordering
 
         setName(i18n("My Certificates"));
         setId(QStringLiteral("my-certificates"));
         setMatchContexts(AnyMatchContext);
         setBold(true);
     }
 };
 
 class TrustedCertificatesKeyFilter : public DefaultKeyFilter
 {
 public:
     TrustedCertificatesKeyFilter()
         : DefaultKeyFilter()
     {
         setRevoked(NotSet);
         setValidity(IsAtLeast);
         setValidityReferenceLevel(UserID::Marginal);
         setSpecificity(UINT_MAX - 2); // overly high for ordering
 
         setName(i18n("Trusted Certificates"));
         setId(QStringLiteral("trusted-certificates"));
         setMatchContexts(Filtering);
     }
 };
 
 class FullCertificatesKeyFilter : public DefaultKeyFilter
 {
 public:
     FullCertificatesKeyFilter()
         : DefaultKeyFilter()
     {
         setRevoked(NotSet);
         setValidity(IsAtLeast);
         setValidityReferenceLevel(UserID::Full);
         setSpecificity(UINT_MAX - 3);
 
         setName(i18n("Fully Trusted Certificates"));
         setId(QStringLiteral("full-certificates"));
         setMatchContexts(Filtering);
     }
 };
 
 class OtherCertificatesKeyFilter : public DefaultKeyFilter
 {
 public:
     OtherCertificatesKeyFilter()
         : DefaultKeyFilter()
     {
         setHasSecret(NotSet);
         setValidity(IsAtMost);
         setValidityReferenceLevel(UserID::Never);
         setSpecificity(UINT_MAX - 4); // overly high for ordering
 
         setName(i18n("Other Certificates"));
         setId(QStringLiteral("other-certificates"));
         setMatchContexts(Filtering);
     }
 };
 
 /* This filter selects only invalid keys (i.e. those where not all
  * UIDs are at least fully valid).  */
 class KeyNotValidFilter : public DefaultKeyFilter
 {
 public:
     KeyNotValidFilter()
         : DefaultKeyFilter()
     {
         setName(i18n("Not validated Certificates"));
         setId(QStringLiteral("not-validated-certificates"));
         setSpecificity(UINT_MAX - 6); // overly high for ordering
     }
     bool matches (const Key &key, MatchContexts contexts) const override
     {
         return (contexts & Filtering) && !Formatting::uidsHaveFullValidity(key);
     }
 };
 
 }
 
 static std::vector<std::shared_ptr<KeyFilter>> defaultFilters()
 {
     std::vector<std::shared_ptr<KeyFilter> > result;
     result.reserve(6);
     result.push_back(std::shared_ptr<KeyFilter>(new MyCertificatesKeyFilter));
     result.push_back(std::shared_ptr<KeyFilter>(new TrustedCertificatesKeyFilter));
     result.push_back(std::shared_ptr<KeyFilter>(new FullCertificatesKeyFilter));
     result.push_back(std::shared_ptr<KeyFilter>(new OtherCertificatesKeyFilter));
     result.push_back(std::shared_ptr<KeyFilter>(new AllCertificatesKeyFilter));
     result.push_back(std::shared_ptr<KeyFilter>(new KeyNotValidFilter));
     return result;
 }
 
 class KeyFilterManager::Private
 {
 public:
     Private() : filters(), appearanceFilters(), model(this) {}
     void clear()
     {
         model.beginResetModel();
         filters.clear();
         appearanceFilters.clear();
         model.endResetModel();
     }
 
     std::vector<std::shared_ptr<KeyFilter>> filters;
     std::vector<std::shared_ptr<KeyFilter>> appearanceFilters;
     Model model;
 };
 
 KeyFilterManager *KeyFilterManager::mSelf = nullptr;
 
 KeyFilterManager::KeyFilterManager(QObject *parent)
     : QObject(parent), d(new Private)
 {
     mSelf = this;
     // ### DF: doesn't a KStaticDeleter work more reliably?
     if (QCoreApplication *app = QCoreApplication::instance()) {
         connect(app, &QCoreApplication::aboutToQuit, this, &QObject::deleteLater);
     }
     reload();
 }
 
 KeyFilterManager::~KeyFilterManager()
 {
     mSelf = nullptr;
     if (d) {
         d->clear();
     }
     delete d; d = nullptr;
 }
 
 KeyFilterManager *KeyFilterManager::instance()
 {
     if (!mSelf) {
         mSelf = new KeyFilterManager();
     }
     return mSelf;
 }
 
 const std::shared_ptr<KeyFilter> &KeyFilterManager::filterMatching(const Key &key, KeyFilter::MatchContexts contexts) const
 {
     const auto it = std::find_if(d->filters.cbegin(), d->filters.cend(),
                                  [&key, contexts](const std::shared_ptr<KeyFilter> &filter) {
                                      return filter->matches(key, contexts);
                                  });
     if (it != d->filters.cend()) {
         return *it;
     }
     static const std::shared_ptr<KeyFilter> null;
     return null;
 }
 
 std::vector<std::shared_ptr<KeyFilter>> KeyFilterManager::filtersMatching(const Key &key, KeyFilter::MatchContexts contexts) const
 {
     std::vector<std::shared_ptr<KeyFilter>> result;
     result.reserve(d->filters.size());
     std::remove_copy_if(d->filters.begin(), d->filters.end(),
                         std::back_inserter(result),
                         [&key, contexts](const std::shared_ptr<KeyFilter> &filter) {
                             return !filter->matches(key, contexts);
                         });
     return result;
 }
 
 namespace
 {
 struct ByDecreasingSpecificity : std::binary_function<std::shared_ptr<KeyFilter>, std::shared_ptr<KeyFilter>, bool> {
     bool operator()(const std::shared_ptr<KeyFilter> &lhs, const std::shared_ptr<KeyFilter> &rhs) const
     {
         return lhs->specificity() > rhs->specificity();
     }
 };
 }
 
 void KeyFilterManager::reload()
 {
     d->clear();
 
     d->filters = defaultFilters();
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("libkleopatrarc"));
 
     const QStringList groups = config->groupList().filter(QRegularExpression(QStringLiteral("^Key Filter #\\d+$")));
     bool ignoreDeVs = Formatting::complianceMode() != QLatin1String("de-vs");
     for (QStringList::const_iterator it = groups.begin(); it != groups.end(); ++it) {
         const KConfigGroup cfg(config, *it);
         if (cfg.hasKey("is-de-vs") && ignoreDeVs) {
             /* Don't show de-vs filters in other compliance modes */
             continue;
         }
         d->filters.push_back(std::shared_ptr<KeyFilter>(new KConfigBasedKeyFilter(cfg)));
     }
     std::stable_sort(d->filters.begin(), d->filters.end(), ByDecreasingSpecificity());
     qCDebug(LIBKLEO_LOG) << "final filter count is" << d->filters.size();
 }
 
 QAbstractItemModel *KeyFilterManager::model() const
 {
     return &d->model;
 }
 
 const std::shared_ptr<KeyFilter> &KeyFilterManager::keyFilterByID(const QString &id) const
 {
     const auto it = std::find_if(d->filters.begin(), d->filters.end(),
                                  [id](const std::shared_ptr<KeyFilter> &filter) {
                                     return filter->id() == id;
                                  });
     if (it != d->filters.end()) {
         return *it;
     }
     static const std::shared_ptr<KeyFilter> null;
     return null;
 }
 
 const std::shared_ptr<KeyFilter> &KeyFilterManager::fromModelIndex(const QModelIndex &idx) const
 {
     if (!idx.isValid() || idx.model() != &d->model || idx.row() < 0 ||
             static_cast<unsigned>(idx.row()) >= d->filters.size()) {
         static const std::shared_ptr<KeyFilter> null;
         return null;
     }
     return d->filters[idx.row()];
 }
 
 QModelIndex KeyFilterManager::toModelIndex(const std::shared_ptr<KeyFilter> &kf) const
 {
     if (!kf) {
-        return QModelIndex();
+        return {};
     }
     const auto pair = std::equal_range(d->filters.cbegin(), d->filters.cend(), kf, ByDecreasingSpecificity());
     const auto it = std::find(pair.first, pair.second, kf);
     if (it != pair.second) {
         return d->model.index(it - d->filters.begin());
     } else {
         return QModelIndex();
     }
 }
 
 int Model::rowCount(const QModelIndex &) const
 {
     return m_keyFilterManagerPrivate->filters.size();
 }
 
 QVariant Model::data(const QModelIndex &idx, int role) const
 {
     if (!idx.isValid()
         || idx.model() != this
         || idx.row() < 0
         || static_cast<unsigned>(idx.row()) >  m_keyFilterManagerPrivate->filters.size()) {
         return QVariant();
     }
 
     const auto filter = m_keyFilterManagerPrivate->filters[idx.row()];
     switch (role) {
     case Qt::DecorationRole:
         return filter->icon();
 
     case Qt::DisplayRole:
     case Qt::EditRole:
     case Qt::ToolTipRole:  /* Most useless tooltip ever.  */
         return filter->name();
 
     case Qt::UserRole:
         return filter->id();
 
     default:
         return QVariant();
     }
 }
 
 static KeyFilter::FontDescription get_fontdescription(const std::vector<std::shared_ptr<KeyFilter>> &filters, const Key &key, const KeyFilter::FontDescription &initial)
 {
     return kdtools::accumulate_if(filters.begin(), filters.end(),
                                   [&key](const std::shared_ptr<KeyFilter> &filter) {
                                       return filter->matches(key, KeyFilter::Appearance);
                                   },
                                   initial,
                                   [](const KeyFilter::FontDescription &lhs,
                                      const std::shared_ptr<KeyFilter> &rhs) {
                                       return lhs.resolve(rhs->fontDescription());
                                   });
 }
 
 QFont KeyFilterManager::font(const Key &key, const QFont &baseFont) const
 {
     KeyFilter::FontDescription fd;
 
     fd = get_fontdescription(d->appearanceFilters, key, KeyFilter::FontDescription());
     fd = get_fontdescription(d->filters, key, fd);
 
     return fd.font(baseFont);
 }
 
 static QColor get_color(const std::vector<std::shared_ptr<KeyFilter>> &filters, const Key &key, QColor(KeyFilter::*fun)() const)
 {
     const auto it = std::find_if(filters.cbegin(), filters.cend(),
                                  [&fun, &key](const std::shared_ptr<KeyFilter> &filter) {
                                     return filter->matches(key, KeyFilter::Appearance)
                                     && (filter.get()->*fun)().isValid();
                                  });
     if (it == filters.cend()) {
-        return QColor();
+        return {};
     } else {
         return (it->get()->*fun)();
     }
 }
 
 static QString get_string(const std::vector<std::shared_ptr<KeyFilter>> &filters, const Key &key, QString(KeyFilter::*fun)() const)
 {
     const auto it = std::find_if(filters.cbegin(), filters.cend(),
                                  [&fun, &key](const std::shared_ptr<KeyFilter> &filter) {
                                      return filter->matches(key, KeyFilter::Appearance)
                                             && !(filter.get()->*fun)().isEmpty();
                                  });
     if (it == filters.cend()) {
         return QString();
     } else {
         return (*it)->icon();
     }
 }
 
 QColor KeyFilterManager::bgColor(const Key &key) const
 {
     QColor color;
 
     color = get_color(d->appearanceFilters, key, &KeyFilter::bgColor);
     if (!color.isValid()) {
         color = get_color(d->filters, key, &KeyFilter::bgColor);
     }
     return color;
 }
 
 QColor KeyFilterManager::fgColor(const Key &key) const
 {
     QColor color;
 
     color = get_color(d->appearanceFilters, key, &KeyFilter::fgColor);
     if (!color.isValid()) {
         color = get_color(d->filters, key, &KeyFilter::fgColor);
     }
     return color;
 }
 
 QIcon KeyFilterManager::icon(const Key &key) const
 {
     QString icon;
 
     icon = get_string(d->appearanceFilters, key, &KeyFilter::icon);
     if (icon.isEmpty()) {
         icon = get_string(d->filters, key, &KeyFilter::icon);
     }
     return icon.isEmpty() ? QIcon() : QIcon::fromTheme(icon);
 }
 
diff --git a/src/kleo/stl_util.h b/src/kleo/stl_util.h
index 01ce8b212..6c1b4eeaa 100644
--- a/src/kleo/stl_util.h
+++ b/src/kleo/stl_util.h
@@ -1,262 +1,262 @@
 /****************************************************************************
 ** 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__
 
 #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)
 {
-    typedef typename std::iterator_traits<InputIterator>::value_type ValueType;
+    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.cpp b/src/models/keycache.cpp
index 67ec27149..72c7e30f5 100644
--- a/src/models/keycache.cpp
+++ b/src/models/keycache.cpp
@@ -1,1355 +1,1355 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/keycache.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007, 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2018 Intevation GmbH
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keycache.h"
 #include "keycache_p.h"
 
 #include "libkleo_debug.h"
 
 #include "kleo/predicates.h"
 #include "kleo/stl_util.h"
 #include "kleo/dn.h"
 #include "utils/filesystemwatcher.h"
 
 #include <gpgme++/error.h>
 #include <gpgme++/context.h>
 #include <gpgme++/key.h>
 #include <gpgme++/decryptionresult.h>
 #include <gpgme++/verificationresult.h>
 #include <gpgme++/keylistresult.h>
 
 #include <qgpgme/protocol.h>
 #include <qgpgme/listallkeysjob.h>
 #include <qgpgme/cryptoconfig.h>
 
 #include <gpg-error.h>
 
 //#include <kmime/kmime_header_parsing.h>
 
 
 #include <QPointer>
 #include <QTimer>
 #include <QEventLoop>
 
 #include <utility>
 #include <algorithm>
 #include <functional>
 #include <iterator>
 
 using namespace Kleo;
 using namespace GpgME;
 using namespace KMime::Types;
 
 static const unsigned int hours2ms = 1000 * 60 * 60;
 
 //
 //
 // KeyCache
 //
 //
 
 namespace
 {
 
 make_comparator_str(ByEMail, .first.c_str());
 
 }
 
 class KeyCache::Private
 {
     friend class ::Kleo::KeyCache;
     KeyCache *const q;
 public:
     explicit Private(KeyCache *qq) : q(qq), m_refreshInterval(1), m_initalized(false), m_pgpOnly(true), m_remarks_enabled(false)
     {
         connect(&m_autoKeyListingTimer, &QTimer::timeout, q, [this]() { q->startKeyListing(); });
         updateAutoKeyListingTimer();
     }
 
     ~Private()
     {
         if (m_refreshJob) {
             m_refreshJob->cancel();
         }
     }
 
     template < template <template <typename U> class Op> class Comp>
     std::vector<Key>::const_iterator find(const std::vector<Key> &keys, const char *key) const
     {
         ensureCachePopulated();
-        const std::vector<Key>::const_iterator it =
+        const auto it =
             std::lower_bound(keys.begin(), keys.end(), key, Comp<std::less>());
         if (it == keys.end() || Comp<std::equal_to>()(*it, key)) {
             return it;
         } else {
             return keys.end();
         }
     }
 
     template < template <template <typename U> class Op> class Comp>
     std::vector<Subkey>::const_iterator find(const std::vector<Subkey> &keys, const char *key) const
     {
         ensureCachePopulated();
-        const std::vector<Subkey>::const_iterator it =
+        const auto it =
             std::lower_bound(keys.begin(), keys.end(), key, Comp<std::less>());
         if (it == keys.end() || Comp<std::equal_to>()(*it, key)) {
             return it;
         } else {
             return keys.end();
         }
     }
 
     std::vector<Key>::const_iterator find_fpr(const char *fpr) const
     {
         return find<_detail::ByFingerprint>(by.fpr, fpr);
     }
 
     std::pair< std::vector< std::pair<std::string, Key> >::const_iterator,
         std::vector< std::pair<std::string, Key> >::const_iterator >
         find_email(const char *email) const
     {
         ensureCachePopulated();
         return std::equal_range(by.email.begin(), by.email.end(),
                                 email, ByEMail<std::less>());
     }
 
     std::vector<Key> find_mailbox(const QString &email, bool sign) const;
 
     std::vector<Subkey>::const_iterator find_keygrip(const char *keygrip) const
     {
         return find<_detail::ByKeyGrip>(by.keygrip, keygrip);
     }
 
     std::vector<Subkey>::const_iterator find_subkeyid(const char *subkeyid) const
     {
         return find<_detail::ByKeyID>(by.subkeyid, subkeyid);
     }
 
     std::vector<Key>::const_iterator find_keyid(const char *keyid) const
     {
         return find<_detail::ByKeyID>(by.keyid, keyid);
     }
 
     std::vector<Key>::const_iterator find_shortkeyid(const char *shortkeyid) const
     {
         return find<_detail::ByShortKeyID>(by.shortkeyid, shortkeyid);
     }
 
     std::pair <
     std::vector<Key>::const_iterator,
         std::vector<Key>::const_iterator
         > find_subjects(const char *chain_id) const
     {
         ensureCachePopulated();
         return std::equal_range(by.chainid.begin(), by.chainid.end(),
                                 chain_id, _detail::ByChainID<std::less>());
     }
 
     void refreshJobDone(const KeyListResult &result);
 
     void setRefreshInterval(int interval)
     {
         m_refreshInterval = interval;
         updateAutoKeyListingTimer();
     }
 
     int refreshInterval() const
     {
         return m_refreshInterval;
     }
 
     void updateAutoKeyListingTimer()
     {
         setAutoKeyListingInterval(hours2ms * m_refreshInterval);
     }
     void setAutoKeyListingInterval(int ms)
     {
         m_autoKeyListingTimer.stop();
         m_autoKeyListingTimer.setInterval(ms);
         if (ms != 0) {
             m_autoKeyListingTimer.start();
         }
     }
 
     void ensureCachePopulated() const;
 
     void updateGroupCache() {
         // Update Group Keys
         // this is a quick thing as it only involves reading the config
         // so no need for a job.
 
         // According to Werner Koch groups are more of a hack to solve
         // a valid usecase (e.g. several keys defined for an internal mailing list)
         // that won't make it in the proper keylist interface. And using gpgconf
         // was the suggested way to support groups.
         auto conf = QGpgME::cryptoConfig();
         if (!conf) {
             return;
         }
 
         auto entry = conf->entry(QStringLiteral("gpg"),
                                  QStringLiteral("Configuration"),
                                  QStringLiteral("group"));
         if (!entry) {
             return;
         }
 
         m_groups.clear();
         for (const auto &value: entry->stringValueList()) {
             const auto split = value.split(QLatin1Char('='));
             if (split.size() != 2) {
                 qCDebug (LIBKLEO_LOG) << "Ignoring invalid group config:" << value;
                 continue;
             }
             const auto name = split[0];
             const auto key = q->findByFingerprint(split[1].toLatin1().constData());
             if (key.isNull()) {
                 qCDebug (LIBKLEO_LOG) << "Ignoring unknown fingerprint:" << split[1] << "in group" << name;
                 continue;
             }
             auto vec = m_groups.value(name);
             vec.push_back(key);
             m_groups.insert(name, vec);
         }
     }
 
 private:
     QPointer<RefreshKeysJob> m_refreshJob;
     std::vector<std::shared_ptr<FileSystemWatcher> > m_fsWatchers;
     QTimer m_autoKeyListingTimer;
     int m_refreshInterval;
 
     struct By {
         std::vector<Key> fpr, keyid, shortkeyid, chainid;
         std::vector< std::pair<std::string, Key> > email;
         std::vector<Subkey> subkeyid, keygrip;
     } by;
     bool m_initalized;
     bool m_pgpOnly;
     bool m_remarks_enabled;
     QMap <QString, std::vector<Key> > m_groups;
 };
 
 std::shared_ptr<const KeyCache> KeyCache::instance()
 {
     return mutableInstance();
 }
 
 std::shared_ptr<KeyCache> KeyCache::mutableInstance()
 {
     static std::weak_ptr<KeyCache> self;
     try {
         return std::shared_ptr<KeyCache>(self);
     } catch (const std::bad_weak_ptr &) {
         const std::shared_ptr<KeyCache> s(new KeyCache);
         self = s;
         return s;
     }
 }
 
 KeyCache::KeyCache()
     : QObject(), d(new Private(this))
 {
 
 }
 
 KeyCache::~KeyCache() {}
 
 void KeyCache::enableFileSystemWatcher(bool enable)
 {
     for (const auto &i : qAsConst(d->m_fsWatchers)) {
         i->setEnabled(enable);
     }
 }
 
 void KeyCache::setRefreshInterval(int hours)
 {
     d->setRefreshInterval(hours);
 }
 
 int KeyCache::refreshInterval() const
 {
     return d->refreshInterval();
 }
 
 void KeyCache::reload(GpgME::Protocol /*proto*/)
 {
     if (d->m_refreshJob) {
         return;
     }
 
     d->updateAutoKeyListingTimer();
 
     enableFileSystemWatcher(false);
     d->m_refreshJob = new RefreshKeysJob(this);
     connect(d->m_refreshJob.data(), &RefreshKeysJob::done,
             this, [this](const GpgME::KeyListResult &r) {
                 d->refreshJobDone(r);
             });
     d->m_refreshJob->start();
 }
 
 void KeyCache::cancelKeyListing()
 {
     if (!d->m_refreshJob) {
         return;
     }
     d->m_refreshJob->cancel();
 }
 
 void KeyCache::addFileSystemWatcher(const std::shared_ptr<FileSystemWatcher> &watcher)
 {
     if (!watcher) {
         return;
     }
     d->m_fsWatchers.push_back(watcher);
     connect(watcher.get(), &FileSystemWatcher::directoryChanged,
             this, [this]() { startKeyListing(); });
     connect(watcher.get(), &FileSystemWatcher::fileChanged,
             this, [this]() { startKeyListing(); });
 
     watcher->setEnabled(d->m_refreshJob.isNull());
 }
 
 void KeyCache::enableRemarks(bool value)
 {
     if (!d->m_remarks_enabled && value) {
         d->m_remarks_enabled = value;
         if (d->m_initalized && !d->m_refreshJob) {
             qCDebug(LIBKLEO_LOG) << "Reloading keycache with remarks enabled";
             reload();
         } else {
             connect(d->m_refreshJob.data(), &RefreshKeysJob::done,
                     this, [this](const GpgME::KeyListResult &) {
                 qCDebug(LIBKLEO_LOG) << "Reloading keycache with remarks enabled";
                 QTimer::singleShot(1000, this, [this](){ reload(); });
             });
         }
     } else {
         d->m_remarks_enabled = value;
     }
 }
 
 bool KeyCache::remarksEnabled() const
 {
     return d->m_remarks_enabled;
 }
 
 void KeyCache::Private::refreshJobDone(const KeyListResult &result)
 {
     q->enableFileSystemWatcher(true);
     m_initalized = true;
     updateGroupCache();
     Q_EMIT q->keyListingDone(result);
 }
 
 const Key &KeyCache::findByFingerprint(const char *fpr) const
 {
     const std::vector<Key>::const_iterator it = d->find_fpr(fpr);
     if (it == d->by.fpr.end()) {
         static const Key null;
         return null;
     } else {
         return *it;
     }
 }
 
 const Key &KeyCache::findByFingerprint(const std::string &fpr) const
 {
     return findByFingerprint(fpr.c_str());
 }
 
 std::vector<Key> KeyCache::findByEMailAddress(const char *email) const
 {
     const auto pair = d->find_email(email);
     std::vector<Key> result;
     result.reserve(std::distance(pair.first, pair.second));
     std::transform(pair.first, pair.second,
                    std::back_inserter(result),
                    [](const std::pair<std::string, Key> &pair) {
                        return pair.second;
                    });
     return result;
 }
 
 std::vector<Key> KeyCache::findByEMailAddress(const std::string &email) const
 {
     return findByEMailAddress(email.c_str());
 }
 
 const Key &KeyCache::findByShortKeyID(const char *id) const
 {
     const std::vector<Key>::const_iterator it = d->find_shortkeyid(id);
     if (it != d->by.shortkeyid.end()) {
         return *it;
     }
     static const Key null;
     return null;
 }
 
 const Key &KeyCache::findByShortKeyID(const std::string &id) const
 {
     return findByShortKeyID(id.c_str());
 }
 
 const Key &KeyCache::findByKeyIDOrFingerprint(const char *id) const
 {
     {
         // try by.fpr first:
         const std::vector<Key>::const_iterator it = d->find_fpr(id);
         if (it != d->by.fpr.end()) {
             return *it;
         }
     }{
         // try by.keyid next:
         const std::vector<Key>::const_iterator it = d->find_keyid(id);
         if (it != d->by.keyid.end()) {
             return *it;
         }
     }
     static const Key null;
     return null;
 }
 
 const Key &KeyCache::findByKeyIDOrFingerprint(const std::string &id) const
 {
     return findByKeyIDOrFingerprint(id.c_str());
 }
 
 std::vector<Key> KeyCache::findByKeyIDOrFingerprint(const std::vector<std::string> &ids) const
 {
 
     std::vector<std::string> keyids;
     std::remove_copy_if(ids.begin(), ids.end(), std::back_inserter(keyids),
                         [](const std::string &str) {
                             return !str.c_str() || !*str.c_str();
                         });
 
     // this is just case-insensitive string search:
     std::sort(keyids.begin(), keyids.end(), _detail::ByFingerprint<std::less>());
 
     std::vector<Key> result;
     result.reserve(keyids.size());   // dups shouldn't happen
     d->ensureCachePopulated();
 
     kdtools::set_intersection(d->by.fpr.begin(), d->by.fpr.end(),
                               keyids.begin(), keyids.end(),
                               std::back_inserter(result),
                               _detail::ByFingerprint<std::less>());
     if (result.size() < keyids.size()) {
         // note that By{Fingerprint,KeyID,ShortKeyID} define the same
         // order for _strings_
         kdtools::set_intersection(d->by.keyid.begin(), d->by.keyid.end(),
                                   keyids.begin(), keyids.end(),
                                   std::back_inserter(result),
                                   _detail::ByKeyID<std::less>());
     }
     // duplicates shouldn't happen, but make sure nonetheless:
     std::sort(result.begin(), result.end(), _detail::ByFingerprint<std::less>());
     result.erase(std::unique(result.begin(), result.end(), _detail::ByFingerprint<std::equal_to>()), result.end());
 
     // we skip looking into short key ids here, as it's highly
     // unlikely they're used for this purpose. We might need to revise
     // this decision, but only after testing.
     return result;
 }
 
 const Subkey &KeyCache::findSubkeyByKeyGrip(const char *grip) const
 {
     const std::vector<Subkey>::const_iterator it = d->find_keygrip(grip);
     if (it == d->by.keygrip.end()) {
         static const Subkey null;
         return null;
     } else {
         return *it;
     }
 }
 
 const Subkey &KeyCache::findSubkeyByKeyGrip(const std::string &grip) const
 {
     return findSubkeyByKeyGrip(grip.c_str());
 }
 
 std::vector<Subkey> KeyCache::findSubkeysByKeyID(const std::vector<std::string> &ids) const
 {
     std::vector<std::string> sorted;
     sorted.reserve(ids.size());
     std::remove_copy_if(ids.begin(), ids.end(), std::back_inserter(sorted),
                         [](const std::string &str) {
                             return !str.c_str() || !*str.c_str();
                         });
 
     std::sort(sorted.begin(), sorted.end(), _detail::ByKeyID<std::less>());
 
     std::vector<Subkey> result;
     d->ensureCachePopulated();
     kdtools::set_intersection(d->by.subkeyid.begin(), d->by.subkeyid.end(),
                               sorted.begin(), sorted.end(),
                               std::back_inserter(result),
                               _detail::ByKeyID<std::less>());
     return result;
 }
 
 std::vector<Key> KeyCache::findRecipients(const DecryptionResult &res) const
 {
     std::vector<std::string> keyids;
     Q_FOREACH (const DecryptionResult::Recipient &r, res.recipients())
         if (const char *kid = r.keyID()) {
             keyids.push_back(kid);
         }
     const std::vector<Subkey> subkeys = findSubkeysByKeyID(keyids);
     std::vector<Key> result;
     result.reserve(subkeys.size());
     std::transform(subkeys.begin(), subkeys.end(), std::back_inserter(result),
                    std::mem_fn(&Subkey::parent));
 
     std::sort(result.begin(), result.end(), _detail::ByFingerprint<std::less>());
     result.erase(std::unique(result.begin(), result.end(), _detail::ByFingerprint<std::equal_to>()), result.end());
     return result;
 }
 
 std::vector<Key> KeyCache::findSigners(const VerificationResult &res) const
 {
     std::vector<std::string> fprs;
     Q_FOREACH (const Signature &s, res.signatures())
         if (const char *fpr = s.fingerprint()) {
             fprs.push_back(fpr);
         }
     return findByKeyIDOrFingerprint(fprs);
 }
 
 std::vector<Key> KeyCache::findSigningKeysByMailbox(const QString &mb) const
 {
     return d->find_mailbox(mb, true);
 }
 
 std::vector<Key> KeyCache::findEncryptionKeysByMailbox(const QString &mb) const
 {
     return d->find_mailbox(mb, false);
 }
 
 namespace
 {
 #define DO( op, meth, meth2 ) if ( op key.meth() ) {} else { qDebug( "rejecting for signing: %s: %s", #meth2, key.primaryFingerprint() ); return false; }
 #define ACCEPT( meth ) DO( !!, meth, !meth )
 #define REJECT( meth ) DO( !, meth, meth )
 struct ready_for_signing : std::unary_function<Key, bool> {
     bool operator()(const Key &key) const
     {
 #if 1
         ACCEPT(hasSecret);
         ACCEPT(canReallySign);
         REJECT(isRevoked);
         REJECT(isExpired);
         REJECT(isDisabled);
         REJECT(isInvalid);
         return true;
 #else
         return key.hasSecret() &&
                key.canReallySign() && !key.isRevoked() && !key.isExpired() && !key.isDisabled() && !key.isInvalid();
 #endif
 #undef DO
     }
 };
 
 struct ready_for_encryption : std::unary_function<Key, bool> {
 #define DO( op, meth, meth2 ) if ( op key.meth() ) {} else { qDebug( "rejecting for encrypting: %s: %s", #meth2, key.primaryFingerprint() ); return false; }
     bool operator()(const Key &key) const
     {
 #if 1
         ACCEPT(canEncrypt);
         REJECT(isRevoked);
         REJECT(isExpired);
         REJECT(isDisabled);
         REJECT(isInvalid);
         return true;
 #else
         return
             key.canEncrypt()    && !key.isRevoked() && !key.isExpired() && !key.isDisabled() && !key.isInvalid();
 #endif
     }
 #undef DO
 #undef ACCEPT
 #undef REJECT
 };
 }
 
 std::vector<Key> KeyCache::Private::find_mailbox(const QString &email, bool sign) const
 {
     if (email.isEmpty()) {
         return std::vector<Key>();
     }
 
     const auto pair = find_email(email.toUtf8().constData());
     std::vector<Key> result;
     result.reserve(std::distance(pair.first, pair.second));
     if (sign)
         kdtools::copy_2nd_if(pair.first, pair.second,
                              std::back_inserter(result),
                              ready_for_signing());
     else
         kdtools::copy_2nd_if(pair.first, pair.second,
                              std::back_inserter(result),
                              ready_for_encryption());
 
     return result;
 }
 
 std::vector<Key> KeyCache::findSubjects(const GpgME::Key &key, Options options) const
 {
     return findSubjects(std::vector<Key>(1, key), options);
 }
 
 std::vector<Key> KeyCache::findSubjects(const std::vector<Key> &keys, Options options) const
 {
     return findSubjects(keys.begin(), keys.end(), options);
 }
 
 std::vector<Key> KeyCache::findSubjects(std::vector<Key>::const_iterator first, std::vector<Key>::const_iterator last, Options options) const
 {
 
     if (first == last) {
         return std::vector<Key>();
     }
 
     std::vector<Key> result;
     while (first != last) {
         const auto pair = d->find_subjects(first->primaryFingerprint());
         result.insert(result.end(), pair.first, pair.second);
         ++first;
     }
 
     std::sort(result.begin(), result.end(), _detail::ByFingerprint<std::less>());
     result.erase(std::unique(result.begin(), result.end(), _detail::ByFingerprint<std::equal_to>()), result.end());
 
     if (options & RecursiveSearch) {
         const std::vector<Key> furtherSubjects = findSubjects(result, options);
         std::vector<Key> combined;
         combined.reserve(result.size() + furtherSubjects.size());
         std::merge(result.begin(), result.end(),
                    furtherSubjects.begin(), furtherSubjects.end(),
                    std::back_inserter(combined),
                    _detail::ByFingerprint<std::less>());
         combined.erase(std::unique(combined.begin(), combined.end(), _detail::ByFingerprint<std::equal_to>()), combined.end());
         result.swap(combined);
     }
 
     return result;
 }
 
 std::vector<Key> KeyCache::findIssuers(const Key &key, Options options) const
 {
 
     if (key.isNull()) {
         return std::vector<Key>();
     }
 
     std::vector<Key> result;
     if (options & IncludeSubject) {
         result.push_back(key);
     }
 
     if (key.isRoot()) {
         return result;
     }
 
     const Key &issuer = findByFingerprint(key.chainID());
 
     if (issuer.isNull()) {
         return result;
     }
 
     result.push_back(issuer);
 
     if (!(options & RecursiveSearch)) {
         return result;
     }
 
     while (!result.back().isNull() && !result.back().isRoot()) {
         result.push_back(findByFingerprint(result.back().chainID()));
     }
 
     if (result.back().isNull()) {
         result.pop_back();
     }
 
     return result;
 }
 
 std::vector<Key> KeyCache::findIssuers(const std::vector<Key> &keys, Options options) const
 {
     return findIssuers(keys.begin(), keys.end(), options);
 }
 
 std::vector<Key> KeyCache::findIssuers(std::vector<Key>::const_iterator first, std::vector<Key>::const_iterator last, Options options) const
 {
 
     if (first == last) {
         return std::vector<Key>();
     }
 
     // extract chain-ids, identifying issuers:
     std::vector<const char *> chainIDs;
     chainIDs.reserve(last - first);
     kdtools::transform_if(first, last, std::back_inserter(chainIDs),
                           std::mem_fn(&Key::chainID),
                           [](const Key &key) { return !key.isRoot(); });
     std::sort(chainIDs.begin(), chainIDs.end(), _detail::ByFingerprint<std::less>());
 
     const auto lastUniqueChainID = std::unique(chainIDs.begin(), chainIDs.end(), _detail::ByFingerprint<std::less>());
 
     std::vector<Key> result;
     result.reserve(lastUniqueChainID - chainIDs.begin());
 
     d->ensureCachePopulated();
 
     kdtools::set_intersection(d->by.fpr.begin(), d->by.fpr.end(),
                               chainIDs.begin(), lastUniqueChainID,
                               std::back_inserter(result),
                               _detail::ByFingerprint<std::less>());
 
     if (options & IncludeSubject) {
         const unsigned int rs = result.size();
         result.insert(result.end(), first, last);
         std::inplace_merge(result.begin(), result.begin() + rs, result.end(),
                            _detail::ByFingerprint<std::less>());
     }
 
     if (!(options & RecursiveSearch)) {
         return result;
     }
 
     const std::vector<Key> l2result = findIssuers(result, options & ~IncludeSubject);
 
     const unsigned long result_size = result.size();
     result.insert(result.end(), l2result.begin(), l2result.end());
     std::inplace_merge(result.begin(), result.begin() + result_size, result.end(),
                        _detail::ByFingerprint<std::less>());
     return result;
 }
 
 static std::string email(const UserID &uid)
 {
     // Prefer the gnupg normalized one
     const std::string addr = uid.addrSpec();
     if (!addr.empty()) {
         return addr;
     }
     const std::string email = uid.email();
     if (email.empty()) {
         return DN(uid.id())[QStringLiteral("EMAIL")].trimmed().toUtf8().constData();
     }
     if (email[0] == '<' && email[email.size() - 1] == '>') {
         return email.substr(1, email.size() - 2);
     } else {
         return email;
     }
 }
 
 static std::vector<std::string> emails(const Key &key)
 {
     std::vector<std::string> emails;
     Q_FOREACH (const UserID &uid, key.userIDs()) {
         const std::string e = email(uid);
         if (!e.empty()) {
             emails.push_back(e);
         }
     }
     std::sort(emails.begin(), emails.end(), ByEMail<std::less>());
     emails.erase(std::unique(emails.begin(), emails.end(), ByEMail<std::equal_to>()), emails.end());
     return emails;
 }
 
 void KeyCache::remove(const Key &key)
 {
     if (key.isNull()) {
         return;
     }
 
     const char *fpr = key.primaryFingerprint();
     if (!fpr) {
         return;
     }
 
     Q_EMIT aboutToRemove(key);
 
     {
         const auto range = std::equal_range(d->by.fpr.begin(), d->by.fpr.end(), fpr,
                                             _detail::ByFingerprint<std::less>());
         d->by.fpr.erase(range.first, range.second);
     }
 
     if (const char *keyid = key.keyID()) {
         const auto range = std::equal_range(d->by.keyid.begin(), d->by.keyid.end(), keyid,
                                             _detail::ByKeyID<std::less>());
         const auto it = std::remove_if(range.first, range.second,
                                        [fpr](const GpgME::Key &key) {
                                            return _detail::ByFingerprint<std::equal_to>()(fpr, key);
                                        });
         d->by.keyid.erase(it, range.second);
     }
 
     if (const char *shortkeyid = key.shortKeyID()) {
         const auto range = std::equal_range(d->by.shortkeyid.begin(), d->by.shortkeyid.end(), shortkeyid,
                                             _detail::ByShortKeyID<std::less>());
         const auto it = std::remove_if(range.first, range.second,
                                        [fpr](const GpgME::Key &key) {
                                            return _detail::ByFingerprint<std::equal_to>()(fpr, key);
                                        });
         d->by.shortkeyid.erase(it, range.second);
     }
 
     if (const char *chainid = key.chainID()) {
         const auto range = std::equal_range(d->by.chainid.begin(), d->by.chainid.end(), chainid,
                                             _detail::ByChainID<std::less>());
         const auto range2 = std::equal_range(range.first, range.second, fpr, _detail::ByFingerprint<std::less>());
         d->by.chainid.erase(range2.first, range2.second);
     }
 
     Q_FOREACH (const std::string &email, emails(key)) {
         const auto range = std::equal_range(d->by.email.begin(), d->by.email.end(), email, ByEMail<std::less>());
         const auto it = std::remove_if(range.first, range.second,
                                        [fpr](const std::pair<std::string, Key> &pair) {
                                            return qstricmp(fpr, pair.second.primaryFingerprint()) == 0;
                                        });
         d->by.email.erase(it, range.second);
     }
 
     Q_FOREACH (const Subkey &subkey, key.subkeys()) {
         if (const char *keyid = subkey.keyID()) {
             const auto range = std::equal_range(d->by.subkeyid.begin(), d->by.subkeyid.end(), keyid,
                                                 _detail::ByKeyID<std::less>());
             const auto it = std::remove_if(range.first, range.second,
                                            [fpr] (const Subkey &subkey) {
                                                return !qstricmp(fpr, subkey.parent().primaryFingerprint());
                                            });
             d->by.subkeyid.erase(it, range.second);
         }
         if (const char *keygrip = subkey.keyGrip()) {
             const auto range = std::equal_range(d->by.keygrip.begin(), d->by.keygrip.end(), keygrip,
                                                 _detail::ByKeyGrip<std::less>());
             const auto it = std::remove_if(range.first, range.second,
                                            [fpr] (const Subkey &subkey) {
                                                return !qstricmp(fpr, subkey.parent().primaryFingerprint());
                                            });
             d->by.keygrip.erase(it, range.second);
         }
     }
 }
 
 void KeyCache::remove(const std::vector<Key> &keys)
 {
     for (const Key &key : keys) {
         remove(key);
     }
 }
 
 const std::vector<GpgME::Key> &KeyCache::keys() const
 {
     d->ensureCachePopulated();
     return d->by.fpr;
 }
 
 std::vector<Key> KeyCache::secretKeys() const
 {
     std::vector<Key> keys = this->keys();
     keys.erase(std::remove_if(keys.begin(), keys.end(),
                               [](const Key &key) { return !key.hasSecret(); }),
                keys.end());
     return keys;
 }
 
 void KeyCache::refresh(const std::vector<Key> &keys)
 {
     // make this better...
     clear();
     insert(keys);
 }
 
 void KeyCache::insert(const Key &key)
 {
     insert(std::vector<Key>(1, key));
 }
 
 namespace
 {
 
 template <
     template <template <typename T> class Op> class T1,
     template <template <typename T> class Op> class T2
     > struct lexicographically
 {
-    typedef bool result_type;
+    using result_type = bool;
 
     template <typename U, typename V>
     bool operator()(const U &lhs, const V &rhs) const
     {
         return
             T1<std::less>()(lhs, rhs) ||
             (T1<std::equal_to>()(lhs, rhs) &&
              T2<std::less>()(lhs, rhs))
             ;
     }
 };
 
 }
 
 void KeyCache::insert(const std::vector<Key> &keys)
 {
 
     // 1. remove those with empty fingerprints:
     std::vector<Key> sorted;
     sorted.reserve(keys.size());
     std::remove_copy_if(keys.begin(), keys.end(),
                         std::back_inserter(sorted),
                         [](const Key &key) {
                             auto fp = key.primaryFingerprint();
                             return !fp|| !*fp;
                         });
 
     Q_FOREACH (const Key &key, sorted) {
         remove(key);    // this is sub-optimal, but makes implementation from here on much easier
     }
 
     // 2. sort by fingerprint:
     std::sort(sorted.begin(), sorted.end(), _detail::ByFingerprint<std::less>());
 
     // 2a. insert into fpr index:
     std::vector<Key> by_fpr;
     by_fpr.reserve(sorted.size() + d->by.fpr.size());
     std::merge(sorted.begin(), sorted.end(),
                d->by.fpr.begin(), d->by.fpr.end(),
                std::back_inserter(by_fpr),
                _detail::ByFingerprint<std::less>());
 
     // 3. build email index:
     std::vector< std::pair<std::string, Key> > pairs;
     pairs.reserve(sorted.size());
     Q_FOREACH (const Key &key, sorted) {
         const std::vector<std::string> emails = ::emails(key);
         for (const std::string &e : emails) {
             pairs.push_back(std::make_pair(e, key));
         }
     }
     std::sort(pairs.begin(), pairs.end(), ByEMail<std::less>());
 
     // 3a. insert into email index:
     std::vector< std::pair<std::string, Key> > by_email;
     by_email.reserve(pairs.size() + d->by.email.size());
     std::merge(pairs.begin(), pairs.end(),
                d->by.email.begin(), d->by.email.end(),
                std::back_inserter(by_email),
                ByEMail<std::less>());
 
     // 3.5: stable-sort by chain-id (effectively lexicographically<ByChainID,ByFingerprint>)
     std::stable_sort(sorted.begin(), sorted.end(), _detail::ByChainID<std::less>());
 
     // 3.5a: insert into chain-id index:
     std::vector<Key> nonroot;
     nonroot.reserve(sorted.size());
     std::vector<Key> by_chainid;
     by_chainid.reserve(sorted.size() + d->by.chainid.size());
     std::copy_if(sorted.cbegin(), sorted.cend(),
                  std::back_inserter(nonroot),
                  [](const Key &key) { return !key.isRoot(); });
     std::merge(nonroot.cbegin(), nonroot.cend(),
                d->by.chainid.cbegin(), d->by.chainid.cend(),
                std::back_inserter(by_chainid),
                lexicographically<_detail::ByChainID, _detail::ByFingerprint>());
 
     // 4. sort by key id:
     std::sort(sorted.begin(), sorted.end(), _detail::ByKeyID<std::less>());
 
     // 4a. insert into keyid index:
     std::vector<Key> by_keyid;
     by_keyid.reserve(sorted.size() + d->by.keyid.size());
     std::merge(sorted.begin(), sorted.end(),
                d->by.keyid.begin(), d->by.keyid.end(),
                std::back_inserter(by_keyid),
                _detail::ByKeyID<std::less>());
 
     // 5. sort by short key id:
     std::sort(sorted.begin(), sorted.end(), _detail::ByShortKeyID<std::less>());
 
     // 5a. insert into short keyid index:
     std::vector<Key> by_shortkeyid;
     by_shortkeyid.reserve(sorted.size() + d->by.shortkeyid.size());
     std::merge(sorted.begin(), sorted.end(),
                d->by.shortkeyid.begin(), d->by.shortkeyid.end(),
                std::back_inserter(by_shortkeyid),
                _detail::ByShortKeyID<std::less>());
 
     // 6. build subkey ID index:
     std::vector<Subkey> subkeys;
     subkeys.reserve(sorted.size());
     Q_FOREACH (const Key &key, sorted)
         Q_FOREACH (const Subkey &subkey, key.subkeys()) {
             subkeys.push_back(subkey);
         }
 
     // 6a sort by key id:
     std::sort(subkeys.begin(), subkeys.end(), _detail::ByKeyID<std::less>());
 
     // 6b. insert into subkey ID index:
     std::vector<Subkey> by_subkeyid;
     by_subkeyid.reserve(subkeys.size() + d->by.subkeyid.size());
     std::merge(subkeys.begin(), subkeys.end(),
                d->by.subkeyid.begin(), d->by.subkeyid.end(),
                std::back_inserter(by_subkeyid),
                _detail::ByKeyID<std::less>());
 
     // 6c. sort by key grip
     std::sort(subkeys.begin(), subkeys.end(), _detail::ByKeyGrip<std::less>());
 
     // 6d. insert into subkey keygrip index:
     std::vector<Subkey> by_keygrip;
     by_keygrip.reserve(subkeys.size() + d->by.keygrip.size());
     std::merge(subkeys.begin(), subkeys.end(),
                d->by.keygrip.begin(), d->by.keygrip.end(),
                std::back_inserter(by_keygrip),
                _detail::ByKeyGrip<std::less>());
 
     // now commit (well, we already removed keys...)
     by_fpr.swap(d->by.fpr);
     by_keyid.swap(d->by.keyid);
     by_shortkeyid.swap(d->by.shortkeyid);
     by_email.swap(d->by.email);
     by_subkeyid.swap(d->by.subkeyid);
     by_keygrip.swap(d->by.keygrip);
     by_chainid.swap(d->by.chainid);
 
     for (const Key &key : qAsConst(sorted)) {
         d->m_pgpOnly &= key.protocol() == GpgME::OpenPGP;
         Q_EMIT added(key);
     }
 
     Q_EMIT keysMayHaveChanged();
 }
 
 void KeyCache::clear()
 {
     d->by = Private::By();
 }
 
 //
 //
 // RefreshKeysJob
 //
 //
 
 class KeyCache::RefreshKeysJob::Private
 {
     RefreshKeysJob *const q;
 public:
     Private(KeyCache *cache, RefreshKeysJob *qq);
     void doStart();
     Error startKeyListing(GpgME::Protocol protocol);
     void listAllKeysJobDone(const KeyListResult &res, const std::vector<Key> &nextKeys)
     {
         std::vector<Key> keys;
         keys.reserve(m_keys.size() + nextKeys.size());
         if (m_keys.empty()) {
             keys = nextKeys;
         } else
             std::merge(m_keys.begin(), m_keys.end(),
                        nextKeys.begin(), nextKeys.end(),
                        std::back_inserter(keys),
                        _detail::ByFingerprint<std::less>());
         m_keys.swap(keys);
         jobDone(res);
     }
     void emitDone(const KeyListResult &result);
     void updateKeyCache();
 
     QPointer<KeyCache> m_cache;
     QVector<QGpgME::ListAllKeysJob*> m_jobsPending;
     std::vector<Key> m_keys;
     KeyListResult m_mergedResult;
     bool m_canceled;
 
 private:
     void jobDone(const KeyListResult &res);
 };
 
 KeyCache::RefreshKeysJob::Private::Private(KeyCache *cache, RefreshKeysJob *qq)
     : q(qq)
     , m_cache(cache)
     , m_canceled(false)
 {
     Q_ASSERT(m_cache);
 }
 
 void KeyCache::RefreshKeysJob::Private::jobDone(const KeyListResult &result)
 {
     if (m_canceled) {
         q->deleteLater();
         return;
     }
 
     QObject *const sender = q->sender();
     if (sender) {
         sender->disconnect(q);
     }
     Q_ASSERT(m_jobsPending.size() > 0);
     m_jobsPending.removeOne(qobject_cast<QGpgME::ListAllKeysJob*>(sender));
     m_mergedResult.mergeWith(result);
     if (m_jobsPending.size() > 0) {
         return;
     }
     updateKeyCache();
     emitDone(m_mergedResult);
 }
 
 void KeyCache::RefreshKeysJob::Private::emitDone(const KeyListResult &res)
 {
     q->deleteLater();
     Q_EMIT q->done(res);
 }
 
 KeyCache::RefreshKeysJob::RefreshKeysJob(KeyCache *cache, QObject *parent) : QObject(parent), d(new Private(cache, this))
 {
 }
 
 KeyCache::RefreshKeysJob::~RefreshKeysJob()
 {
     delete d;
 }
 
 void KeyCache::RefreshKeysJob::start()
 {
     QTimer::singleShot(0, this, [this](){ d->doStart(); });
 }
 
 void KeyCache::RefreshKeysJob::cancel()
 {
     d->m_canceled = true;
     std::for_each(d->m_jobsPending.begin(), d->m_jobsPending.end(),
                   std::mem_fn(&QGpgME::ListAllKeysJob::slotCancel));
     Q_EMIT canceled();
 }
 
 void KeyCache::RefreshKeysJob::Private::doStart()
 {
     if (m_canceled) {
         q->deleteLater();
         return;
     }
 
     Q_ASSERT(m_jobsPending.size() == 0);
     m_mergedResult.mergeWith(KeyListResult(startKeyListing(GpgME::OpenPGP)));
     m_mergedResult.mergeWith(KeyListResult(startKeyListing(GpgME::CMS)));
 
     if (m_jobsPending.size() != 0) {
         return;
     }
 
     const bool hasError = m_mergedResult.error() || m_mergedResult.error().isCanceled();
     emitDone(hasError ? m_mergedResult : KeyListResult(Error(GPG_ERR_UNSUPPORTED_OPERATION)));
 }
 
 void KeyCache::RefreshKeysJob::Private::updateKeyCache()
 {
     if (!m_cache || m_canceled) {
         q->deleteLater();
         return;
     }
 
     std::vector<Key> cachedKeys = m_cache->initialized() ? m_cache->keys() : std::vector<Key>();
     std::sort(cachedKeys.begin(), cachedKeys.end(), _detail::ByFingerprint<std::less>());
     std::vector<Key> keysToRemove;
     std::set_difference(cachedKeys.begin(), cachedKeys.end(),
                         m_keys.begin(), m_keys.end(),
                         std::back_inserter(keysToRemove),
                         _detail::ByFingerprint<std::less>());
     m_cache->remove(keysToRemove);
     m_cache->refresh(m_keys);
 }
 
 Error KeyCache::RefreshKeysJob::Private::startKeyListing(GpgME::Protocol proto)
 {
     const auto * const protocol = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     if (!protocol) {
         return Error();
     }
     QGpgME::ListAllKeysJob *const job = protocol->listAllKeysJob(/*includeSigs*/false, /*validate*/true);
     if (!job) {
         return Error();
     }
 
 #if 0
     aheinecke: 2017.01.12:
 
     For unknown reasons the new style connect fails at runtime
     over library borders into QGpgME from the GpgME repo
     when cross compiled for Windows and default arguments
     are used in the Signal.
 
     This was tested with gcc 4.9 (Mingw 3.0.2) and we could not
     find an explanation for this. So until this is fixed or we understand
     the problem we need to use the old style connect for QGpgME signals.
 
     The new style connect of the canceled signal right below
     works fine.
 
     connect(job, &QGpgME::ListAllKeysJob::result,
             q, [this](const GpgME::KeyListResult &res, const std::vector<GpgME::Key> &keys) {
                 listAllKeysJobDone(res, keys);
             });
 #endif
     connect(job, SIGNAL(result(GpgME::KeyListResult,std::vector<GpgME::Key>)),
             q, SLOT(listAllKeysJobDone(GpgME::KeyListResult,std::vector<GpgME::Key>)));
 
     connect(q, &RefreshKeysJob::canceled, job, &QGpgME::Job::slotCancel);
 
     // Only do this for initialized keycaches to avoid huge waits for
     // signature notations during initial keylisting.
     if (proto == GpgME::OpenPGP && m_cache->remarksEnabled() && m_cache->initialized()) {
         auto ctx = QGpgME::Job::context(job);
         if (ctx) {
             ctx->addKeyListMode(KeyListMode::Signatures |
                                 KeyListMode::SignatureNotations);
         }
     }
 
     const Error error = job->start(true);
 
     if (!error && !error.isCanceled()) {
         m_jobsPending.push_back(job);
     }
     return error;
 }
 
 bool KeyCache::initialized() const
 {
     return d->m_initalized;
 }
 
 void KeyCache::Private::ensureCachePopulated() const
 {
     if (!m_initalized) {
         q->startKeyListing();
         QEventLoop loop;
         loop.connect(q, &KeyCache::keyListingDone,
                      &loop, &QEventLoop::quit);
         qCDebug(LIBKLEO_LOG) << "Waiting for keycache.";
         loop.exec();
         qCDebug(LIBKLEO_LOG) << "Keycache available.";
     }
 }
 
 bool KeyCache::pgpOnly() const
 {
     return d->m_pgpOnly;
 }
 
 static bool keyIsOk(const Key &k)
 {
     return !k.isExpired() && !k.isRevoked() && !k.isInvalid() && !k.isDisabled();
 }
 
 static bool uidIsOk(const UserID &uid)
 {
     return keyIsOk(uid.parent()) && !uid.isRevoked() && !uid.isInvalid();
 }
 
 static bool subkeyIsOk(const Subkey &s)
 {
     return !s.isRevoked() && !s.isInvalid() && !s.isDisabled();
 }
 
 std::vector<GpgME::Key> KeyCache::findBestByMailBox(const char *addr, GpgME::Protocol proto,
                                                     bool needSign, bool needEncrypt) const
 {
     d->ensureCachePopulated();
     std::vector<GpgME::Key> ret;
     if (!addr) {
         return ret;
     }
     if (proto == Protocol::OpenPGP) {
         // Groups take precedence over automatic keys. We return all here
         // so if a group key for example is expired we can show that.
         ret = getGroupKeys(QString::fromUtf8(addr));
         if (!ret.empty()) {
             return ret;
         }
     }
     Key keyC;
     UserID uidC;
     for (const Key &k: findByEMailAddress(addr)) {
         if (proto != Protocol::UnknownProtocol && k.protocol() != proto) {
             continue;
         }
         if (needEncrypt && !k.canEncrypt()) {
             continue;
         }
         if (needSign && (!k.canSign() || !k.hasSecret())) {
             continue;
         }
         /* First get the uid that matches the mailbox */
         for (const UserID &u: k.userIDs()) {
             if (QString::fromStdString(u.addrSpec()).toLower() != QString::fromUtf8(addr).toLower()) {
                 continue;
             }
             if (uidC.isNull()) {
                 keyC = k;
                 uidC = u;
             } else if ((!uidIsOk(uidC) && uidIsOk(u)) || uidC.validity() < u.validity()) {
                 /* Validity of the new key is better. */
                 uidC = u;
                 keyC = k;
             } else if (uidC.validity() == u.validity() && uidIsOk(u)) {
                 /* Both are the same check which one is newer. */
                 time_t oldTime = 0;
                 for (const Subkey &s: keyC.subkeys()) {
                     if (!subkeyIsOk(s)) {
                         continue;
                     }
                     if (needSign && s.canSign()) {
                         oldTime = s.creationTime();
                     } else if (needEncrypt && s.canEncrypt()) {
                         oldTime = s.creationTime();
                     } else if (s.canSign() || s.canEncrypt()) {
                         oldTime = s.creationTime();
                     }
                 }
                 time_t newTime = 0;
                 for (const Subkey &s: k.subkeys()) {
                     if (!subkeyIsOk(s)) {
                         continue;
                     }
                     if (needSign && s.canSign()) {
                         newTime = s.creationTime();
                     } else if (needEncrypt && s.canEncrypt()) {
                         newTime = s.creationTime();
                     } else if (s.canSign() || s.canEncrypt()) {
                         newTime = s.creationTime();
                     }
                 }
                 if (newTime > oldTime) {
                     uidC = u;
                     keyC = k;
                 }
             }
         }
     }
     ret.push_back(keyC);
     return ret;
 }
 
 std::vector<GpgME::Key> KeyCache::getGroupKeys(const QString &groupName) const
 {
     return d->m_groups.value(groupName);
 }
 
 #include "moc_keycache_p.cpp"
 #include "moc_keycache.cpp"
 
diff --git a/src/models/keylistmodel.cpp b/src/models/keylistmodel.cpp
index 7a1d0b574..e4ffd6bf3 100644
--- a/src/models/keylistmodel.cpp
+++ b/src/models/keylistmodel.cpp
@@ -1,1004 +1,1004 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/keylistmodel.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keylistmodel.h"
 #include "keycache.h"
 #include "kleo/predicates.h"
 #include "kleo/keyfiltermanager.h"
 #include "kleo/keyfilter.h"
 #include "utils/formatting.h"
 
 #ifdef KLEO_MODEL_TEST
 # include <QAbstractItemModelTester>
 #endif
 
 #include <Libkleo/KeyFilterManager>
 #include <Libkleo/KeyFilter>
 
 #include <KLocalizedString>
 
 #include <QFont>
 #include <QColor>
 #include <QHash>
 #include <QIcon>
 #include <QDate>
 #include <gpgme++/key.h>
 
 #ifndef Q_MOC_RUN // QTBUG-22829
 #include <boost/graph/topological_sort.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #endif
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <iterator>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 using namespace GpgME;
 using namespace Kleo;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 class AbstractKeyListModel::Private
 {
 public:
     int m_toolTipOptions = Formatting::Validity;
     mutable QHash<const char *, QVariant> prettyEMailCache;
     mutable QHash<const char *, QVariant> remarksCache;
     bool m_useKeyCache = false;
     bool m_secretOnly = false;
     std::vector<GpgME::Key> m_remarkKeys;
 };
 AbstractKeyListModel::AbstractKeyListModel(QObject *p)
     : QAbstractItemModel(p), KeyListModelInterface(), d(new Private)
 {
 
 }
 
 AbstractKeyListModel::~AbstractKeyListModel() {}
 
 void AbstractKeyListModel::setToolTipOptions(int opts)
 {
     d->m_toolTipOptions = opts;
 }
 
 int AbstractKeyListModel::toolTipOptions() const
 {
     return d->m_toolTipOptions;
 }
 
 void AbstractKeyListModel::setRemarkKeys(const std::vector<GpgME::Key> &keys)
 {
     d->m_remarkKeys = keys;
 }
 
 std::vector<GpgME::Key> AbstractKeyListModel::remarkKeys() const
 {
     return d->m_remarkKeys;
 }
 
 Key AbstractKeyListModel::key(const QModelIndex &idx) const
 {
     if (idx.isValid()) {
         return doMapToKey(idx);
     } else {
         return Key::null;
     }
 }
 
 std::vector<Key> AbstractKeyListModel::keys(const QList<QModelIndex> &indexes) const
 {
     std::vector<Key> result;
     result.reserve(indexes.size());
     std::transform(indexes.begin(), indexes.end(),
                    std::back_inserter(result),
                    [this](const QModelIndex &idx) {
                        return this->key(idx);
                    });
     result.erase(std::unique(result.begin(), result.end(), _detail::ByFingerprint<std::equal_to>()), result.end());
     return result;
 }
 
 QModelIndex AbstractKeyListModel::index(const Key &key, int col) const
 {
     if (key.isNull() || col < 0 || col >= NumColumns) {
-        return QModelIndex();
+        return {};
     } else {
         return doMapFromKey(key, col);
     }
 }
 
 QList<QModelIndex> AbstractKeyListModel::indexes(const std::vector<Key> &keys) const
 {
     QList<QModelIndex> result;
     result.reserve(keys.size());
     std::transform(keys.begin(), keys.end(),
                    std::back_inserter(result),
                    [this](const Key &key) {
                        return this->index(key);
                    });
     return result;
 }
 
 void AbstractKeyListModel::setKeys(const std::vector<Key> &keys)
 {
     clear();
     addKeys(keys);
 }
 
 QModelIndex AbstractKeyListModel::addKey(const Key &key)
 {
     const std::vector<Key> vec(1, key);
     const QList<QModelIndex> l = doAddKeys(vec);
     return l.empty() ? QModelIndex() : l.front();
 }
 
 void AbstractKeyListModel::removeKey(const Key &key)
 {
     if (key.isNull()) {
         return;
     }
     doRemoveKey(key);
     d->prettyEMailCache.remove(key.primaryFingerprint());
     d->remarksCache.remove(key.primaryFingerprint());
 }
 
 QList<QModelIndex> AbstractKeyListModel::addKeys(const std::vector<Key> &keys)
 {
     std::vector<Key> sorted;
     sorted.reserve(keys.size());
     std::remove_copy_if(keys.begin(), keys.end(),
                         std::back_inserter(sorted),
                         std::mem_fn(&Key::isNull));
     std::sort(sorted.begin(), sorted.end(), _detail::ByFingerprint<std::less>());
     return doAddKeys(sorted);
 }
 
 void AbstractKeyListModel::clear()
 {
     beginResetModel();
     doClear();
     d->prettyEMailCache.clear();
     d->remarksCache.clear();
     endResetModel();
 }
 
 int AbstractKeyListModel::columnCount(const QModelIndex &) const
 {
     return NumColumns;
 }
 
 QVariant AbstractKeyListModel::headerData(int section, Qt::Orientation o, int role) const
 {
     if (o == Qt::Horizontal)
         if (role == Qt::DisplayRole || role == Qt::EditRole || role == Qt::ToolTipRole)
             switch (section) {
             case PrettyName:       return i18n("Name");
             case PrettyEMail:      return i18n("E-Mail");
             case Validity:         return i18n("User-IDs");
             case ValidFrom:        return i18n("Valid From");
             case ValidUntil:       return i18n("Valid Until");
             case TechnicalDetails: return i18n("Protocol");
             case ShortKeyID:       return i18n("Key-ID");
             case KeyID:            return i18n("Key-ID");
             case Fingerprint:      return i18n("Fingerprint");
             case Issuer:           return i18n("Issuer");
             case SerialNumber:     return i18n("Serial Number");
             case Origin:           return i18n("Origin");
             case LastUpdate:       return i18n("Last Update");
             case OwnerTrust:       return i18n("Certification Trust");
             case Remarks:          return i18n("Tags");
             case NumColumns:;
             }
     return QVariant();
 }
 
 static QVariant returnIfValid(const QColor &t)
 {
     if (t.isValid()) {
         return t;
     } else {
         return QVariant();
     }
 }
 
 static QVariant returnIfValid(const QIcon &t)
 {
     if (!t.isNull()) {
         return t;
     } else {
         return QVariant();
     }
 }
 
 QVariant AbstractKeyListModel::data(const QModelIndex &index, int role) const
 {
     const Key key = this->key(index);
     if (key.isNull()) {
         return QVariant();
     }
 
     const int column = index.column();
 
     if (role == Qt::DisplayRole || role == Qt::EditRole) {
         switch (column) {
         case PrettyName:
             return Formatting::prettyName(key);
         case PrettyEMail:
             if (const char *const fpr = key.primaryFingerprint()) {
                 const QHash<const char *, QVariant>::const_iterator it = d->prettyEMailCache.constFind(fpr);
                 if (it != d->prettyEMailCache.constEnd()) {
                     return *it;
                 } else {
                     return d->prettyEMailCache[fpr] = Formatting::prettyEMail(key);
                 }
             } else {
                 return QVariant();
             }
         case Validity:
             return Formatting::complianceStringShort(key);
         case ValidFrom:
             if (role == Qt::EditRole) {
                 return Formatting::creationDate(key);
             } else {
                 return Formatting::creationDateString(key);
             }
         case ValidUntil:
             if (role == Qt::EditRole) {
                 return Formatting::expirationDate(key);
             } else {
                 return Formatting::expirationDateString(key);
             }
         case TechnicalDetails:
             return Formatting::type(key);
         case ShortKeyID:
             return QString::fromLatin1(key.shortKeyID());
         case KeyID:
             return Formatting::prettyID(key.keyID());
         case Summary:
             return Formatting::summaryLine(key);
         case Fingerprint:
             return Formatting::prettyID(key.primaryFingerprint());
         case Issuer:
             return QString::fromUtf8(key.issuerName());
         case Origin:
             return Formatting::origin(key.origin());
         case LastUpdate:
             return Formatting::dateString(key.lastUpdate());
         case SerialNumber:
             return QString::fromUtf8(key.issuerSerial());
         case OwnerTrust:
             return Formatting::ownerTrustShort(key.ownerTrust());
         case Remarks:
 #ifdef GPGME_HAS_REMARKS
             {
                 const char *const fpr = key.primaryFingerprint();
                 if (fpr && key.protocol() == GpgME::OpenPGP && key.numUserIDs() &&
                         d->m_remarkKeys.size()) {
                     if (!(key.keyListMode() & GpgME::SignatureNotations)) {
                         return i18n("Loading...");
                     }
                     const QHash<const char *, QVariant>::const_iterator it = d->remarksCache.constFind(fpr);
                     if (it != d->remarksCache.constEnd()) {
                         return *it;
                     } else {
                         GpgME::Error err;
                         const auto remarks = key.userID(0).remarks(d->m_remarkKeys, err);
                         if (remarks.size() == 1) {
                             const auto remark = QString::fromStdString(remarks[0]);
                             return d->remarksCache[fpr] = remark;
                         } else {
                             QStringList remarkList;
                             remarkList.reserve(remarks.size());
                             for (const auto &rem: remarks) {
                                 remarkList << QString::fromStdString(rem);
                             }
                             const auto remark = remarkList.join(QStringLiteral("; "));
                             return d->remarksCache[fpr] = remark;
                         }
                     }
                 } else {
                     return QVariant();
                 }
             }
 #endif
             return QVariant();
         case NumColumns:
             break;
         }
     } else if (role == Qt::ToolTipRole) {
         return Formatting::toolTip(key, toolTipOptions());
     } else if (role == Qt::FontRole) {
         return KeyFilterManager::instance()->font(key, (column == ShortKeyID || column == KeyID || column == Fingerprint) ? QFont(QStringLiteral("monospace")) : QFont());
     } else if (role == Qt::DecorationRole) {
         return column == Icon ? returnIfValid(KeyFilterManager::instance()->icon(key)) : QVariant();
     } else if (role == Qt::BackgroundRole) {
         return returnIfValid(KeyFilterManager::instance()->bgColor(key));
     } else if (role == Qt::ForegroundRole) {
         return returnIfValid(KeyFilterManager::instance()->fgColor(key));
     } else if (role == FingerprintRole) {
         return QString::fromLatin1(key.primaryFingerprint());
     } else if (role == KeyRole) {
         return QVariant::fromValue(key);
     }
     return QVariant();
 }
 
 namespace
 {
 template <typename Base>
 class TableModelMixin : public Base
 {
 public:
     explicit TableModelMixin(QObject *p = nullptr) : Base(p) {}
     ~TableModelMixin() {}
 
     using Base::index;
     QModelIndex index(int row, int column, const QModelIndex &pidx = QModelIndex()) const override
     {
         return this->hasIndex(row, column, pidx) ? this->createIndex(row, column, nullptr) : QModelIndex();
     }
 
 private:
     QModelIndex parent(const QModelIndex &) const override
     {
         return QModelIndex();
     }
     bool hasChildren(const QModelIndex &pidx) const override
     {
         return (pidx.model() == this || !pidx.isValid()) && this->rowCount(pidx) > 0 && this->columnCount(pidx) > 0;
     }
 };
 
 class FlatKeyListModel
 #ifndef Q_MOC_RUN
     : public TableModelMixin<AbstractKeyListModel>
 #else
     : public AbstractKeyListModel
 #endif
 {
     Q_OBJECT
 public:
     explicit FlatKeyListModel(QObject *parent = nullptr);
     ~FlatKeyListModel() override;
 
     int rowCount(const QModelIndex &pidx) const override
     {
         return pidx.isValid() ? 0 : mKeysByFingerprint.size();
     }
 
 private:
     Key doMapToKey(const QModelIndex &index) const override;
     QModelIndex doMapFromKey(const Key &key, int col) const override;
     QList<QModelIndex> doAddKeys(const std::vector<Key> &keys) override;
     void doRemoveKey(const Key &key) override;
     void doClear() override {
         mKeysByFingerprint.clear();
     }
 
 private:
     std::vector<Key> mKeysByFingerprint;
 };
 
 class HierarchicalKeyListModel : public AbstractKeyListModel
 {
     Q_OBJECT
 public:
     explicit HierarchicalKeyListModel(QObject *parent = nullptr);
     ~HierarchicalKeyListModel() override;
 
     int rowCount(const QModelIndex &pidx) const override;
     using AbstractKeyListModel::index;
     QModelIndex index(int row, int col, const QModelIndex &pidx) const override;
     QModelIndex parent(const QModelIndex &idx) const override;
 
     bool hasChildren(const QModelIndex &pidx) const override
     {
         return rowCount(pidx) > 0;
     }
 
 private:
     Key doMapToKey(const QModelIndex &index) const override;
     QModelIndex doMapFromKey(const Key &key, int col) const override;
     QList<QModelIndex> doAddKeys(const std::vector<Key> &keys) override;
     void doRemoveKey(const Key &key) override;
     void doClear() override {
         mTopLevels.clear();
         mKeysByFingerprint.clear();
         mKeysByExistingParent.clear();
         mKeysByNonExistingParent.clear();
     }
 
 private:
     void addTopLevelKey(const Key &key);
     void addKeyWithParent(const char *issuer_fpr, const Key &key);
     void addKeyWithoutParent(const char *issuer_fpr, const Key &key);
 
 private:
     typedef std::map< std::string, std::vector<Key> > Map;
     std::vector<Key> mKeysByFingerprint; // all keys
     Map mKeysByExistingParent, mKeysByNonExistingParent; // parent->child map
     std::vector<Key> mTopLevels; // all roots + parent-less
 };
 
 static const char *cleanChainID(const Key &key)
 {
     if (key.isRoot()) {
         return "";
     }
     if (const char *chid = key.chainID()) {
         return chid;
     }
     return "";
 }
 
 }
 
 FlatKeyListModel::FlatKeyListModel(QObject *p)
     : TableModelMixin<AbstractKeyListModel>(p),
       mKeysByFingerprint()
 {
 
 }
 
 FlatKeyListModel::~FlatKeyListModel() {}
 
 Key FlatKeyListModel::doMapToKey(const QModelIndex &idx) const
 {
     Q_ASSERT(idx.isValid());
     if (static_cast<unsigned>(idx.row()) < mKeysByFingerprint.size() && idx.column() < NumColumns) {
         return mKeysByFingerprint[ idx.row() ];
     } else {
         return Key::null;
     }
 }
 
 QModelIndex FlatKeyListModel::doMapFromKey(const Key &key, int col) const
 {
     Q_ASSERT(!key.isNull());
     const std::vector<Key>::const_iterator it
         = std::lower_bound(mKeysByFingerprint.begin(), mKeysByFingerprint.end(),
                            key, _detail::ByFingerprint<std::less>());
     if (it == mKeysByFingerprint.end() || !_detail::ByFingerprint<std::equal_to>()(*it, key)) {
-        return QModelIndex();
+        return {};
     } else {
         return createIndex(it - mKeysByFingerprint.begin(), col);
     }
 }
 
 QList<QModelIndex> FlatKeyListModel::doAddKeys(const std::vector<Key> &keys)
 {
     Q_ASSERT(std::is_sorted(keys.begin(), keys.end(), _detail::ByFingerprint<std::less>()));
 
     if (keys.empty()) {
         return QList<QModelIndex>();
     }
 
-    for (std::vector<Key>::const_iterator it = keys.begin(), end = keys.end(); it != end; ++it) {
+    for (auto it = keys.begin(), end = keys.end(); it != end; ++it) {
 
         // find an insertion point:
         const std::vector<Key>::iterator pos = std::upper_bound(mKeysByFingerprint.begin(), mKeysByFingerprint.end(), *it, _detail::ByFingerprint<std::less>());
         const unsigned int idx = std::distance(mKeysByFingerprint.begin(), pos);
 
         if (idx > 0 && qstrcmp(mKeysByFingerprint[idx - 1].primaryFingerprint(), it->primaryFingerprint()) == 0) {
             // key existed before - replace with new one:
             mKeysByFingerprint[idx - 1] = *it;
             Q_EMIT dataChanged(createIndex(idx - 1, 0), createIndex(idx - 1, NumColumns - 1));
         } else {
             // new key - insert:
             beginInsertRows(QModelIndex(), idx, idx);
             mKeysByFingerprint.insert(pos, *it);
             endInsertRows();
         }
     }
 
     return indexes(keys);
 }
 
 void FlatKeyListModel::doRemoveKey(const Key &key)
 {
     const std::vector<Key>::iterator it
         = qBinaryFind(mKeysByFingerprint.begin(), mKeysByFingerprint.end(),
                       key, _detail::ByFingerprint<std::less>());
     if (it == mKeysByFingerprint.end()) {
         return;
     }
 
     const unsigned int row = std::distance(mKeysByFingerprint.begin(), it);
     beginRemoveRows(QModelIndex(), row, row);
     mKeysByFingerprint.erase(it);
     endRemoveRows();
 }
 
 HierarchicalKeyListModel::HierarchicalKeyListModel(QObject *p)
     : AbstractKeyListModel(p),
       mKeysByFingerprint(),
       mKeysByExistingParent(),
       mKeysByNonExistingParent(),
       mTopLevels()
 {
 
 }
 
 HierarchicalKeyListModel::~HierarchicalKeyListModel() {}
 
 int HierarchicalKeyListModel::rowCount(const QModelIndex &pidx) const
 {
 
     // toplevel item:
     if (!pidx.isValid()) {
         return mTopLevels.size();
     }
 
     if (pidx.column() != 0) {
         return 0;
     }
 
     // non-toplevel item - find the number of subjects for this issuer:
     const Key issuer = this->key(pidx);
     const char *const fpr = issuer.primaryFingerprint();
     if (!fpr || !*fpr) {
         return 0;
     }
     const Map::const_iterator it = mKeysByExistingParent.find(fpr);
     if (it == mKeysByExistingParent.end()) {
         return 0;
     }
     return it->second.size();
 }
 
 QModelIndex HierarchicalKeyListModel::index(int row, int col, const QModelIndex &pidx) const
 {
 
     if (row < 0 || col < 0 || col >= NumColumns) {
-        return QModelIndex();
+        return {};
     }
 
     // toplevel item:
     if (!pidx.isValid()) {
         if (static_cast<unsigned>(row) < mTopLevels.size()) {
             return index(mTopLevels[row], col);
         } else {
             return QModelIndex();
         }
     }
 
     // non-toplevel item - find the row'th subject of this key:
     const Key issuer = this->key(pidx);
     const char *const fpr = issuer.primaryFingerprint();
     if (!fpr || !*fpr) {
         return QModelIndex();
     }
     const Map::const_iterator it = mKeysByExistingParent.find(fpr);
     if (it == mKeysByExistingParent.end() || static_cast<unsigned>(row) >= it->second.size()) {
         return QModelIndex();
     }
     return index(it->second[row], col);
 }
 
 QModelIndex HierarchicalKeyListModel::parent(const QModelIndex &idx) const
 {
     const Key key = this->key(idx);
     if (key.isNull() || key.isRoot()) {
-        return QModelIndex();
+        return {};
     }
     const std::vector<Key>::const_iterator it
         = qBinaryFind(mKeysByFingerprint.begin(), mKeysByFingerprint.end(),
                       cleanChainID(key), _detail::ByFingerprint<std::less>());
     return it != mKeysByFingerprint.end() ? index(*it) : QModelIndex();
 }
 
 Key HierarchicalKeyListModel::doMapToKey(const QModelIndex &idx) const
 {
 
     if (!idx.isValid()) {
         return Key::null;
     }
 
     const char *const issuer_fpr = static_cast<const char *>(idx.internalPointer());
     if (!issuer_fpr || !*issuer_fpr) {
         // top-level:
         if (static_cast<unsigned>(idx.row()) >= mTopLevels.size()) {
             return Key::null;
         } else {
             return mTopLevels[idx.row()];
         }
     }
 
     // non-toplevel:
     const Map::const_iterator it
         = mKeysByExistingParent.find(issuer_fpr);
     if (it == mKeysByExistingParent.end() || static_cast<unsigned>(idx.row()) >= it->second.size()) {
         return Key::null;
     }
     return it->second[idx.row()];
 }
 
 QModelIndex HierarchicalKeyListModel::doMapFromKey(const Key &key, int col) const
 {
 
     if (key.isNull()) {
-        return QModelIndex();
+        return {};
     }
 
     const char *issuer_fpr = cleanChainID(key);
 
     // we need to look in the toplevels list,...
     const std::vector<Key> *v = &mTopLevels;
     if (issuer_fpr && *issuer_fpr) {
         const std::map< std::string, std::vector<Key> >::const_iterator it
             = mKeysByExistingParent.find(issuer_fpr);
         // ...unless we find an existing parent:
         if (it != mKeysByExistingParent.end()) {
             v = &it->second;
         } else {
             issuer_fpr = nullptr;    // force internalPointer to zero for toplevels
         }
     }
 
     const std::vector<Key>::const_iterator it
         = std::lower_bound(v->begin(), v->end(), key, _detail::ByFingerprint<std::less>());
     if (it == v->end() || !_detail::ByFingerprint<std::equal_to>()(*it, key)) {
         return QModelIndex();
     }
 
     const unsigned int row = std::distance(v->begin(), it);
     return createIndex(row, col, const_cast<char * /* thanks, Trolls :/ */ >(issuer_fpr));
 }
 
 void HierarchicalKeyListModel::addKeyWithParent(const char *issuer_fpr, const Key &key)
 {
 
     Q_ASSERT(issuer_fpr); Q_ASSERT(*issuer_fpr); Q_ASSERT(!key.isNull());
 
     std::vector<Key> &subjects = mKeysByExistingParent[issuer_fpr];
 
     // find insertion point:
     const std::vector<Key>::iterator it = std::lower_bound(subjects.begin(), subjects.end(), key, _detail::ByFingerprint<std::less>());
     const int row = std::distance(subjects.begin(), it);
 
     if (it != subjects.end() && qstricmp(it->primaryFingerprint(), key.primaryFingerprint()) == 0) {
         // exists -> replace
         *it = key;
         Q_EMIT dataChanged(createIndex(row, 0, const_cast<char *>(issuer_fpr)), createIndex(row, NumColumns - 1, const_cast<char *>(issuer_fpr)));
     } else {
         // doesn't exist -> insert
         const std::vector<Key>::const_iterator pos = qBinaryFind(mKeysByFingerprint.begin(), mKeysByFingerprint.end(), issuer_fpr, _detail::ByFingerprint<std::less>());
         Q_ASSERT(pos != mKeysByFingerprint.end());
         beginInsertRows(index(*pos), row, row);
         subjects.insert(it, key);
         endInsertRows();
     }
 }
 
 void HierarchicalKeyListModel::addKeyWithoutParent(const char *issuer_fpr, const Key &key)
 {
 
     Q_ASSERT(issuer_fpr); Q_ASSERT(*issuer_fpr); Q_ASSERT(!key.isNull());
 
     std::vector<Key> &subjects = mKeysByNonExistingParent[issuer_fpr];
 
     // find insertion point:
     const std::vector<Key>::iterator it = std::lower_bound(subjects.begin(), subjects.end(), key, _detail::ByFingerprint<std::less>());
 
     if (it != subjects.end() && qstricmp(it->primaryFingerprint(), key.primaryFingerprint()) == 0)
         // exists -> replace
     {
         *it = key;
     } else
         // doesn't exist -> insert
     {
         subjects.insert(it, key);
     }
 
     addTopLevelKey(key);
 }
 
 void HierarchicalKeyListModel::addTopLevelKey(const Key &key)
 {
 
     // find insertion point:
     const std::vector<Key>::iterator it = std::lower_bound(mTopLevels.begin(), mTopLevels.end(), key, _detail::ByFingerprint<std::less>());
     const int row = std::distance(mTopLevels.begin(), it);
 
     if (it != mTopLevels.end() && qstricmp(it->primaryFingerprint(), key.primaryFingerprint()) == 0) {
         // exists -> replace
         *it = key;
         Q_EMIT dataChanged(createIndex(row, 0), createIndex(row, NumColumns - 1));
     } else {
         // doesn't exist -> insert
         beginInsertRows(QModelIndex(), row, row);
         mTopLevels.insert(it, key);
         endInsertRows();
     }
 
 }
 
 // sorts 'keys' such that parent always come before their children:
 static std::vector<Key> topological_sort(const std::vector<Key> &keys)
 {
 
     boost::adjacency_list<> graph(keys.size());
 
     // add edges from children to parents:
     for (unsigned int i = 0, end = keys.size(); i != end; ++i) {
         const char *const issuer_fpr = cleanChainID(keys[i]);
         if (!issuer_fpr || !*issuer_fpr) {
             continue;
         }
         const std::vector<Key>::const_iterator it
             = qBinaryFind(keys.begin(), keys.end(), issuer_fpr, _detail::ByFingerprint<std::less>());
         if (it == keys.end()) {
             continue;
         }
         add_edge(i, std::distance(keys.begin(), it), graph);
     }
 
     std::vector<int> order;
     order.reserve(keys.size());
     topological_sort(graph, std::back_inserter(order));
 
     Q_ASSERT(order.size() == keys.size());
 
     std::vector<Key> result;
     result.reserve(keys.size());
     for (int i : qAsConst(order)) {
         result.push_back(keys[i]);
     }
     return result;
 }
 
 QList<QModelIndex> HierarchicalKeyListModel::doAddKeys(const std::vector<Key> &keys)
 {
     Q_ASSERT(std::is_sorted(keys.begin(), keys.end(), _detail::ByFingerprint<std::less>()));
 
     if (keys.empty()) {
         return QList<QModelIndex>();
     }
 
     const std::vector<Key> oldKeys = mKeysByFingerprint;
 
     std::vector<Key> merged;
     merged.reserve(keys.size() + mKeysByFingerprint.size());
     std::set_union(keys.begin(), keys.end(),
                    mKeysByFingerprint.begin(), mKeysByFingerprint.end(),
                    std::back_inserter(merged), _detail::ByFingerprint<std::less>());
 
     mKeysByFingerprint = merged;
 
     std::set<Key, _detail::ByFingerprint<std::less> > changedParents;
 
     Q_FOREACH (const Key &key, topological_sort(keys)) {
 
         // check to see whether this key is a parent for a previously parent-less group:
         const char *const fpr = key.primaryFingerprint();
         if (!fpr || !*fpr) {
             continue;
         }
 
         const bool keyAlreadyExisted = qBinaryFind(oldKeys.begin(), oldKeys.end(), key, _detail::ByFingerprint<std::less>()) != oldKeys.end();
 
         const Map::iterator it = mKeysByNonExistingParent.find(fpr);
         const std::vector<Key> children = it != mKeysByNonExistingParent.end() ? it->second : std::vector<Key>();
         if (it != mKeysByNonExistingParent.end()) {
             mKeysByNonExistingParent.erase(it);
         }
 
         // Step 1: For new keys, remove children from toplevel:
 
         if (!keyAlreadyExisted) {
-            std::vector<Key>::iterator last = mTopLevels.begin();
-            std::vector<Key>::iterator lastFP = mKeysByFingerprint.begin();
+            auto last = mTopLevels.begin();
+            auto lastFP = mKeysByFingerprint.begin();
 
             for (const Key &k : qAsConst(children)) {
                 last = qBinaryFind(last, mTopLevels.end(), k, _detail::ByFingerprint<std::less>());
                 Q_ASSERT(last != mTopLevels.end());
                 const int row = std::distance(mTopLevels.begin(), last);
 
                 lastFP = qBinaryFind(lastFP, mKeysByFingerprint.end(), k, _detail::ByFingerprint<std::less>());
                 Q_ASSERT(lastFP != mKeysByFingerprint.end());
 
                 Q_EMIT rowAboutToBeMoved(QModelIndex(), row);
                 beginRemoveRows(QModelIndex(), row, row);
                 last = mTopLevels.erase(last);
                 lastFP = mKeysByFingerprint.erase(lastFP);
                 endRemoveRows();
             }
         }
         // Step 2: add/update key
 
         const char *const issuer_fpr = cleanChainID(key);
         if (!issuer_fpr || !*issuer_fpr)
             // root or something...
         {
             addTopLevelKey(key);
         } else if (std::binary_search(mKeysByFingerprint.begin(), mKeysByFingerprint.end(), issuer_fpr, _detail::ByFingerprint<std::less>()))
             // parent exists...
         {
             addKeyWithParent(issuer_fpr, key);
         } else
             // parent doesn't exist yet...
         {
             addKeyWithoutParent(issuer_fpr, key);
         }
 
         const QModelIndex key_idx = index(key);
         QModelIndex key_parent = key_idx.parent();
         while (key_parent.isValid()) {
             changedParents.insert(doMapToKey(key_parent));
             key_parent = key_parent.parent();
         }
 
         // Step 3: Add children to new parent ( == key )
 
         if (!keyAlreadyExisted && !children.empty()) {
             addKeys(children);
             const QModelIndex new_parent = index(key);
             // Q_EMIT the rowMoved() signals in reversed direction, so the
             // implementation can use a stack for mapping.
             for (int i = children.size() - 1; i >= 0; --i) {
                 Q_EMIT rowMoved(new_parent, i);
             }
         }
     }
     //Q_EMIT dataChanged for all parents with new children. This triggers KeyListSortFilterProxyModel to
     //show a parent node if it just got children matching the proxy's filter
     for (const Key &i : qAsConst(changedParents)) {
         const QModelIndex idx = index(i);
         if (idx.isValid()) {
             Q_EMIT dataChanged(idx.sibling(idx.row(), 0), idx.sibling(idx.row(), NumColumns - 1));
         }
     }
     return indexes(keys);
 }
 
 void HierarchicalKeyListModel::doRemoveKey(const Key &key)
 {
     const QModelIndex idx = index(key);
     if (!idx.isValid()) {
         return;
     }
 
     const char *const fpr = key.primaryFingerprint();
     if (mKeysByExistingParent.find(fpr) != mKeysByExistingParent.end()) {
         //handle non-leave nodes:
         std::vector<Key> keys = mKeysByFingerprint;
         const std::vector<Key>::iterator it = qBinaryFind(keys.begin(), keys.end(),
                                               key, _detail::ByFingerprint<std::less>());
         if (it == keys.end()) {
             return;
         }
         keys.erase(it);
         // FIXME for simplicity, we just clear the model and re-add all keys minus the removed one. This is suboptimal,
         // but acceptable given that deletion of non-leave nodes is rather rare.
         clear();
         addKeys(keys);
         return;
     }
 
     //handle leave nodes:
 
     const std::vector<Key>::iterator it = qBinaryFind(mKeysByFingerprint.begin(), mKeysByFingerprint.end(),
                                           key, _detail::ByFingerprint<std::less>());
 
     Q_ASSERT(it != mKeysByFingerprint.end());
     Q_ASSERT(mKeysByNonExistingParent.find(fpr) == mKeysByNonExistingParent.end());
     Q_ASSERT(mKeysByExistingParent.find(fpr) == mKeysByExistingParent.end());
 
     beginRemoveRows(parent(idx), idx.row(), idx.row());
     mKeysByFingerprint.erase(it);
 
     const char *const issuer_fpr = cleanChainID(key);
 
     const std::vector<Key>::iterator tlIt = qBinaryFind(mTopLevels.begin(), mTopLevels.end(), key, _detail::ByFingerprint<std::less>());
     if (tlIt != mTopLevels.end()) {
         mTopLevels.erase(tlIt);
     }
 
     if (issuer_fpr && *issuer_fpr) {
         const Map::iterator nexIt = mKeysByNonExistingParent.find(issuer_fpr);
         if (nexIt != mKeysByNonExistingParent.end()) {
             const std::vector<Key>::iterator eit = qBinaryFind(nexIt->second.begin(), nexIt->second.end(), key, _detail::ByFingerprint<std::less>());
             if (eit != nexIt->second.end()) {
                 nexIt->second.erase(eit);
             }
             if (nexIt->second.empty()) {
                 mKeysByNonExistingParent.erase(nexIt);
             }
         }
 
         const Map::iterator exIt = mKeysByExistingParent.find(issuer_fpr);
         if (exIt != mKeysByExistingParent.end()) {
             const std::vector<Key>::iterator eit = qBinaryFind(exIt->second.begin(), exIt->second.end(), key, _detail::ByFingerprint<std::less>());
             if (eit != exIt->second.end()) {
                 exIt->second.erase(eit);
             }
             if (exIt->second.empty()) {
                 mKeysByExistingParent.erase(exIt);
             }
         }
     }
     endRemoveRows();
 }
 
 void AbstractKeyListModel::useKeyCache(bool value, bool secretOnly)
 {
     d->m_secretOnly = secretOnly;
     d->m_useKeyCache = value;
     if (value) {
         setKeys(d->m_secretOnly ? KeyCache::instance()->secretKeys() : KeyCache::instance()->keys());
     } else {
         setKeys(std::vector<Key>());
     }
     connect(KeyCache::instance().get(), &KeyCache::keysMayHaveChanged, this, [this] { if (d->m_useKeyCache) { setKeys(d->m_secretOnly ? KeyCache::instance()->secretKeys() : KeyCache::instance()->keys()); } });
 }
 
 // static
 AbstractKeyListModel *AbstractKeyListModel::createFlatKeyListModel(QObject *p)
 {
     AbstractKeyListModel *const m = new FlatKeyListModel(p);
 #ifdef KLEO_MODEL_TEST
     new QAbstractItemModelTester(m, p);
 #endif
     return m;
 }
 
 // static
 AbstractKeyListModel *AbstractKeyListModel::createHierarchicalKeyListModel(QObject *p)
 {
     AbstractKeyListModel *const m = new HierarchicalKeyListModel(p);
 #ifdef KLEO_MODEL_TEST
     new QAbstractItemModelTester(m, p);
 #endif
     return m;
 }
 
 #include "keylistmodel.moc"
 
 /*!
   \fn AbstractKeyListModel::rowAboutToBeMoved( const QModelIndex & old_parent, int old_row )
 
   Emitted before the removal of a row from that model. It will later
   be added to the model again, in response to which rowMoved() will be
   emitted. If multiple rows are moved in one go, multiple
   rowAboutToBeMoved() signals are emitted before the corresponding
   number of rowMoved() signals is emitted - in reverse order.
 
   This works around the absence of move semantics in
   QAbstractItemModel. Clients can maintain a stack to perform the
   QModelIndex-mapping themselves, or, e.g., to preserve the selection
   status of the row:
 
   \code
   std::vector<bool> mMovingRowWasSelected; // transient, used when rows are moved
   // ...
   void slotRowAboutToBeMoved( const QModelIndex & p, int row ) {
       mMovingRowWasSelected.push_back( selectionModel()->isSelected( model()->index( row, 0, p ) ) );
   }
   void slotRowMoved( const QModelIndex & p, int row ) {
       const bool wasSelected = mMovingRowWasSelected.back();
       mMovingRowWasSelected.pop_back();
       if ( wasSelected )
           selectionModel()->select( model()->index( row, 0, p ), Select|Rows );
   }
   \endcode
 
   A similar mechanism could be used to preserve the current item during moves.
 */
 
 /*!
   \fn AbstractKeyListModel::rowMoved( const QModelIndex & new_parent, int new_parent )
 
   See rowAboutToBeMoved()
 */
diff --git a/src/models/keylistsortfilterproxymodel.cpp b/src/models/keylistsortfilterproxymodel.cpp
index 358f2fac5..2ffdabeb4 100644
--- a/src/models/keylistsortfilterproxymodel.cpp
+++ b/src/models/keylistsortfilterproxymodel.cpp
@@ -1,214 +1,214 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/keylistsortfilterproxymodel.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keylistsortfilterproxymodel.h"
 
 #include "keylistmodel.h"
 #include "kleo/keyfilter.h"
 #include "kleo/stl_util.h"
 
 #include <libkleo_debug.h>
 
 #include <gpgme++/key.h>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 using namespace Kleo;
 using namespace GpgME;
 
 AbstractKeyListSortFilterProxyModel::AbstractKeyListSortFilterProxyModel(QObject *p)
     : QSortFilterProxyModel(p), KeyListModelInterface()
 {
     init();
 }
 
 AbstractKeyListSortFilterProxyModel::AbstractKeyListSortFilterProxyModel(const AbstractKeyListSortFilterProxyModel &other)
     : QSortFilterProxyModel(), KeyListModelInterface()
 {
     Q_UNUSED(other);
     init();
 }
 
 void AbstractKeyListSortFilterProxyModel::init()
 {
     setDynamicSortFilter(true);
     setSortRole(Qt::EditRole);    // EditRole can be expected to be in a less formatted way, better for sorting
     setFilterRole(Qt::DisplayRole);
     setFilterCaseSensitivity(Qt::CaseInsensitive);
 }
 
 AbstractKeyListSortFilterProxyModel::~AbstractKeyListSortFilterProxyModel() {}
 
 Key AbstractKeyListSortFilterProxyModel::key(const QModelIndex &idx) const
 {
     const KeyListModelInterface *const klmi = dynamic_cast<KeyListModelInterface *>(sourceModel());
     if (!klmi) {
         static Key null;
         return null;
     }
     return klmi->key(mapToSource(idx));
 }
 
 std::vector<Key> AbstractKeyListSortFilterProxyModel::keys(const QList<QModelIndex> &indexes) const
 {
     const KeyListModelInterface *const klmi = dynamic_cast<KeyListModelInterface *>(sourceModel());
     if (!klmi) {
         return std::vector<Key>();
     }
     QList<QModelIndex> mapped;
     mapped.reserve(indexes.size());
     std::transform(indexes.begin(), indexes.end(),
                    std::back_inserter(mapped),
                    [this](const QModelIndex &idx) {
                        return mapToSource(idx);
                    });
     return klmi->keys(mapped);
 }
 
 QModelIndex AbstractKeyListSortFilterProxyModel::index(const Key &key) const
 {
     if (const KeyListModelInterface *const klmi = dynamic_cast<KeyListModelInterface *>(sourceModel())) {
         return mapFromSource(klmi->index(key));
     } else {
-        return QModelIndex();
+        return {};
     }
 }
 
 QList<QModelIndex> AbstractKeyListSortFilterProxyModel::indexes(const std::vector<Key> &keys) const
 {
     if (const KeyListModelInterface *const klmi = dynamic_cast<KeyListModelInterface *>(sourceModel())) {
         const QList<QModelIndex> source = klmi->indexes(keys);
         QList<QModelIndex> mapped;
         mapped.reserve(source.size());
         std::transform(source.begin(), source.end(),
                        std::back_inserter(mapped),
                        [this](const QModelIndex &idx) {
                            return mapFromSource(idx);
                        });
         return mapped;
     } else {
         return QList<QModelIndex>();
     }
 }
 
 class KeyListSortFilterProxyModel::Private
 {
     friend class ::Kleo::KeyListSortFilterProxyModel;
 public:
     explicit Private()
         : keyFilter() {}
     ~Private() {}
 
 private:
     std::shared_ptr<const KeyFilter> keyFilter;
 };
 
 KeyListSortFilterProxyModel::KeyListSortFilterProxyModel(QObject *p)
     : AbstractKeyListSortFilterProxyModel(p), d(new Private)
 {
 
 }
 
 KeyListSortFilterProxyModel::KeyListSortFilterProxyModel(const KeyListSortFilterProxyModel &other)
     : AbstractKeyListSortFilterProxyModel(other), d(new Private(*other.d))
 {
 
 }
 
 KeyListSortFilterProxyModel::~KeyListSortFilterProxyModel() {}
 
 KeyListSortFilterProxyModel *KeyListSortFilterProxyModel::clone() const
 {
     return new KeyListSortFilterProxyModel(*this);
 }
 
 std::shared_ptr<const KeyFilter> KeyListSortFilterProxyModel::keyFilter() const
 {
     return d->keyFilter;
 }
 
 void KeyListSortFilterProxyModel::setKeyFilter(const std::shared_ptr<const KeyFilter> &kf)
 {
     if (kf == d->keyFilter) {
         return;
     }
     d->keyFilter = kf;
     invalidate();
 }
 
 bool KeyListSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
 {
 
     //
     // 0. Keep parents of matching children:
     //
     const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
     for (int i = 0, end = sourceModel()->rowCount(index); i != end; ++i)
         if (filterAcceptsRow(i, index)) {
             return true;
         }
 
     //
     // 1. Check filterRegExp
     //
     const int role = filterRole();
     const int col = filterKeyColumn();
     const QRegExp rx = filterRegExp();
     const QModelIndex nameIndex = sourceModel()->index(source_row, PrettyName, source_parent);
 
     const KeyListModelInterface *const klm = dynamic_cast<KeyListModelInterface *>(sourceModel());
     Q_ASSERT(klm);
     const Key key = klm->key(nameIndex);
 
     if (col) {
         const QModelIndex colIdx = sourceModel()->index(source_row, col, source_parent);
         const QString content = colIdx.data(role).toString();
         if (!content.contains(rx)) {
             return false;
         }
     } else {
         // By default match against the full uid data (name / email / comment / dn)
         bool match = false;
         for (const auto &uid: key.userIDs()) {
             const auto id = QString::fromUtf8(uid.id());
             if (id.contains(rx)) {
                 match = true;
                 break;
             }
 #ifdef GPGME_HAS_REMARKS
             // Also match against remarks (search tags)
             const auto alm = dynamic_cast<AbstractKeyListModel *>(sourceModel());
             if (alm) {
                 const auto remarks = alm->data(alm->index(key, KeyListModelInterface::Remarks));
                 if (!remarks.isNull() && remarks.toString().contains(rx)) {
                     match = true;
                     break;
                 }
             }
 #endif
         }
         if (!match) {
             return false;
         }
     }
 
     //
     // 2. Check that key filters match (if any are defined)
     //
     if (d->keyFilter) {   // avoid artifacts when no filters are defined
         return d->keyFilter->matches(key, KeyFilter::Filtering);
     }
 
     // 3. match by default:
     return true;
 }
 
diff --git a/src/models/keyrearrangecolumnsproxymodel.cpp b/src/models/keyrearrangecolumnsproxymodel.cpp
index 6d4d0683d..1e22c7e5d 100644
--- a/src/models/keyrearrangecolumnsproxymodel.cpp
+++ b/src/models/keyrearrangecolumnsproxymodel.cpp
@@ -1,73 +1,73 @@
 /*  models/keyrearangecolumnsproxymodel.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keyrearrangecolumnsproxymodel.h"
 
 #include <gpgme++/key.h>
 
 using namespace Kleo;
 using namespace GpgME;
 
 KeyRearrangeColumnsProxyModel::KeyRearrangeColumnsProxyModel(QObject *parent) :
     KRearrangeColumnsProxyModel(parent),
     KeyListModelInterface()
 {
 
 }
 
 KeyListModelInterface *KeyRearrangeColumnsProxyModel::klm() const
 {
-    KeyListModelInterface *ret = dynamic_cast<KeyListModelInterface *>(sourceModel());
+    auto *ret = dynamic_cast<KeyListModelInterface *>(sourceModel());
     Q_ASSERT(ret);
     return ret;
 }
 
 Key KeyRearrangeColumnsProxyModel::key(const QModelIndex &idx) const
 {
     return klm()->key(mapToSource(idx));
 }
 
 std::vector<GpgME::Key> KeyRearrangeColumnsProxyModel::keys(const QList<QModelIndex> &idxs) const
 {
     QList<QModelIndex> srcIdxs;
     srcIdxs.reserve(idxs.count());
     for (const QModelIndex &idx : idxs) {
         srcIdxs << mapToSource(idx);
     }
     return klm()->keys(srcIdxs);
 }
 
 
 QModelIndex KeyRearrangeColumnsProxyModel::index(const GpgME::Key &key) const
 {
     return mapFromSource(klm()->index(key));
 }
 
 QList<QModelIndex> KeyRearrangeColumnsProxyModel::indexes(const std::vector<GpgME::Key> &keys) const
 {
     QList<QModelIndex> myIdxs;
     const QList <QModelIndex> srcIdxs = klm()->indexes(keys);
     myIdxs.reserve(srcIdxs.count());
     for (const QModelIndex &idx : srcIdxs) {
         myIdxs << mapFromSource(idx);
     }
     return myIdxs;
 }
 
 void KeyRearrangeColumnsProxyModel::sort(int column, Qt::SortOrder order)
 {
     const auto fakeIdx = createIndex(0, column);
     if (!fakeIdx.isValid()) {
         // Empty model?
         KRearrangeColumnsProxyModel::sort(column, order);
         return;
     }
     const auto remappedIdx = mapToSource(fakeIdx);
     KRearrangeColumnsProxyModel::sort(remappedIdx.column(), order);
 }
diff --git a/src/models/subkeylistmodel.cpp b/src/models/subkeylistmodel.cpp
index 2db9b6274..b41bebe70 100644
--- a/src/models/subkeylistmodel.cpp
+++ b/src/models/subkeylistmodel.cpp
@@ -1,198 +1,198 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/subkeylistmodel.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "subkeylistmodel.h"
 #include "utils/formatting.h"
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QVariant>
 #include <QDate>
 
 #include <algorithm>
 #include <iterator>
 
 using namespace GpgME;
 using namespace Kleo;
 
 class SubkeyListModel::Private
 {
     friend class ::Kleo::SubkeyListModel;
     SubkeyListModel *const q;
 public:
     explicit Private(SubkeyListModel *qq)
         : q(qq), key() {}
 
 private:
     Key key;
 };
 
 SubkeyListModel::SubkeyListModel(QObject *p)
     : QAbstractTableModel(p), d(new Private(this))
 {
 
 }
 
 SubkeyListModel::~SubkeyListModel() {}
 
 Key SubkeyListModel::key() const
 {
     return d->key;
 }
 
 // slot
 void SubkeyListModel::setKey(const Key &key)
 {
 
     const Key oldKey = d->key;
 
 
     if (qstricmp(key.primaryFingerprint(), oldKey.primaryFingerprint()) != 0) {
         // different key -> reset
         beginResetModel();
         d->key = key;
         endResetModel();
         return;
     }
 
     d->key = key;
 
     // ### diff them, and signal more fine-grained than this:
 
     if (key.numSubkeys() > 0 && oldKey.numSubkeys() == key.numSubkeys()) {
         Q_EMIT dataChanged(index(0, 0), index(key.numSubkeys() - 1, NumColumns - 1));
     } else {
         Q_EMIT layoutAboutToBeChanged();
         Q_EMIT layoutChanged();
     }
 }
 
 Subkey SubkeyListModel::subkey(const QModelIndex &idx) const
 {
     if (idx.isValid()) {
         return d->key.subkey(idx.row());
     } else {
         return Subkey();
     }
 }
 
 std::vector<Subkey> SubkeyListModel::subkeys(const QList<QModelIndex> &indexes) const
 {
     std::vector<Subkey> result;
     result.reserve(indexes.size());
     std::transform(indexes.begin(), indexes.end(),
                    std::back_inserter(result),
                    [this](const QModelIndex &idx) {
                        return subkey(idx);
                    });
     return result;
 }
 
 QModelIndex SubkeyListModel::index(const Subkey &subkey, int col) const
 {
     // O(N), but not sorted, so no better way...
     for (unsigned int row = 0, end = d->key.numSubkeys(); row != end; ++row)
         if (qstricmp(subkey.keyID(), d->key.subkey(row).keyID()) == 0) {
             return index(row, col);
         }
-    return QModelIndex();
+    return {};
 }
 
 QList<QModelIndex> SubkeyListModel::indexes(const std::vector<Subkey> &subkeys) const
 {
     QList<QModelIndex> result;
     result.reserve(subkeys.size());
     // O(N*M), but who cares...?
     std::transform(subkeys.begin(), subkeys.end(),
                    std::back_inserter(result),
                    [this](const Subkey &key) {
                        return index(key);
                    });
     return result;
 }
 
 void SubkeyListModel::clear()
 {
     beginResetModel();
     d->key = Key::null;
     endResetModel();
 }
 
 int SubkeyListModel::columnCount(const QModelIndex &) const
 {
     return NumColumns;
 }
 
 int SubkeyListModel::rowCount(const QModelIndex &pidx) const
 {
     return pidx.isValid() ? 0 : d->key.numSubkeys();
 }
 
 QVariant SubkeyListModel::headerData(int section, Qt::Orientation o, int role) const
 {
     if (o == Qt::Horizontal)
         if (role == Qt::DisplayRole || role == Qt::EditRole || role == Qt::ToolTipRole)
             switch (section) {
             case ID:         return i18n("ID");
             case Type:       return i18n("Type");
             case ValidFrom:  return i18n("Valid From");
             case ValidUntil: return i18n("Valid Until");
             case Status:     return i18n("Status");
             case Strength:   return i18n("Strength");
             case Usage:      return i18n("Usage");
             case NumColumns:;
             }
     return QVariant();
 }
 
 QVariant SubkeyListModel::data(const QModelIndex &idx, int role) const
 {
 
     if (role != Qt::DisplayRole && role != Qt::EditRole && role != Qt::ToolTipRole) {
         return QVariant();
     }
 
     const Subkey subkey = this->subkey(idx);
     if (subkey.isNull()) {
         return QVariant();
     }
 
     switch (idx.column()) {
     case ID:
         return QString::fromLatin1(subkey.keyID());
     case Type:
         return Formatting::type(subkey);
     case ValidFrom:
         if (role == Qt::EditRole) {
             return Formatting::creationDate(subkey);
         } else {
             return Formatting::creationDateString(subkey);
         }
     case ValidUntil:
         if (role == Qt::EditRole) {
             return Formatting::expirationDate(subkey);
         } else {
             return Formatting::expirationDateString(subkey);
         }
     case Status:
         return Formatting::validityShort(subkey);
     case Usage:
         return Formatting::usageString(subkey);
     case Strength:
         const QString algName = QString::fromStdString(subkey.algoName());
         // For ECC keys the algo name is something like bp512 and directly
         // indicated the "strength"
         return algName.isEmpty() ? QVariant(subkey.length()) : algName;
     }
 
     return QVariant();
 }
 
diff --git a/src/models/useridlistmodel.cpp b/src/models/useridlistmodel.cpp
index d4d66570a..afa43553c 100644
--- a/src/models/useridlistmodel.cpp
+++ b/src/models/useridlistmodel.cpp
@@ -1,345 +1,345 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     models/useridlistmodel.cpp
 
     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
 */
 
 #include "useridlistmodel.h"
 #include "utils/formatting.h"
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QVariant>
 #include <QIcon>
 
 #include "keycache.h"
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 #if GPGMEPP_VERSION >= 0x10E01 // 1.14.1
 # define GPGME_USERID_SIGNATURES_ARE_SORTABLE
 #endif
 
 using namespace GpgME;
 using namespace Kleo;
 
 class UIDModelItem
 {
     // A uid model item can either be a UserID::Signature or a UserID.
     // you can find out which it is if the uid or the signature return
     // null values. (Not null but isNull)
     //
 public:
     explicit UIDModelItem(const UserID::Signature &sig, UIDModelItem *parentItem, bool showRemarks)
     {
         mItemData  << QString::fromUtf8(sig.signerKeyID())
                    << Formatting::prettyName(sig)
                    << Formatting::prettyEMail(sig)
                    << Formatting::creationDateString(sig)
                    << Formatting::expirationDateString(sig)
                    << Formatting::validityShort(sig)
                    << (sig.isExportable() ? QStringLiteral("✓") : QString());
         mSig = sig;
         mParentItem = parentItem;
 
         if (showRemarks && parentItem) {
             QString lastNotation;
             for (const auto &notation: sig.notations()) {
                 if (notation.name() && !strcmp(notation.name(), "rem@gnupg.org")) {
                     lastNotation = QString::fromUtf8(notation.value());
                 }
             }
             mItemData << lastNotation;
         }
     }
 
     explicit UIDModelItem(const UserID &uid, UIDModelItem *parentItem)
     {
         mItemData << Formatting::prettyUserID(uid);
         mUid = uid;
         mParentItem = parentItem;
     }
 
     // The root item
     explicit UIDModelItem(bool showRemarks) : mParentItem(nullptr)
     {
         mItemData << i18n("ID")
                   << i18n("Name")
                   << i18n("E-Mail")
                   << i18n("Valid From")
                   << i18n("Valid Until")
                   << i18n("Status")
                   << i18n("Exportable");
 
         if (showRemarks) {
             mItemData << i18n("Tags");
         }
     }
 
     ~UIDModelItem()
     {
         qDeleteAll(mChildItems);
     }
 
     void appendChild(UIDModelItem *child)
     {
         mChildItems << child;
     }
 
     UIDModelItem *child(int row) const
     {
         return mChildItems.value(row);
     }
 
     const UIDModelItem *constChild(int row) const
     {
         return mChildItems.value(row);
     }
 
     int childCount() const
     {
         return mChildItems.count();
     }
 
     int columnCount() const
     {
         if (childCount()) {
             // We take the value from the first child
             // as we are likely a UID and our children
             // are UID Signatures.
             return constChild(0)->columnCount();
         }
         return mItemData.count();
     }
 
     QVariant data(int column) const
     {
         return mItemData.value(column);
     }
 
     QVariant toolTip(int column) const
     {
         if (column == 5 /*Status*/) {
             return i18n("class %1", mSig.certClass());
         }
         return mItemData.value(column);
     }
 
     QVariant icon(int column) const
     {
         if (!mSig.isNull() && column == 5 /*Status*/) {
             return Formatting::validityIcon(mSig);
         }
         return QVariant();
     }
 
     int row() const
     {
         if (mParentItem) {
             return mParentItem->mChildItems.indexOf(const_cast<UIDModelItem*>(this));
         }
         return 0;
     }
 
     UIDModelItem *parentItem() const
     {
         return mParentItem;
     }
 
     UserID::Signature signature() const
     {
         return mSig;
     }
 
     UserID uid() const
     {
         return mUid;
     }
 
 private:
     QList<UIDModelItem*> mChildItems;
     QList<QVariant> mItemData;
     UIDModelItem *mParentItem = nullptr;
     UserID::Signature mSig;
     UserID mUid;
 };
 
 UserIDListModel::UserIDListModel(QObject *p)
     : QAbstractItemModel(p), mRootItem(nullptr)
 {
 }
 
 UserIDListModel::~UserIDListModel()
 {
     delete mRootItem;
 }
 
 Key UserIDListModel::key() const
 {
     return mKey;
 }
 
 void UserIDListModel::setKey(const Key &key)
 {
     beginResetModel();
     delete mRootItem;
     mKey = key;
 
     mRootItem = new UIDModelItem(mRemarksEnabled);
     for (int i = 0, ids = key.numUserIDs(); i < ids; ++i) {
         UserID uid = key.userID(i);
-        UIDModelItem *uidItem = new UIDModelItem(uid, mRootItem);
+        auto *uidItem = new UIDModelItem(uid, mRootItem);
         mRootItem->appendChild(uidItem);
         std::vector<UserID::Signature> sigs = uid.signatures();
 #ifdef GPGME_USERID_SIGNATURES_ARE_SORTABLE
         std::sort(sigs.begin(), sigs.end());
 #endif
         for (const auto &sig : sigs) {
-            UIDModelItem *sigItem = new UIDModelItem(sig, uidItem, mRemarksEnabled);
+            auto *sigItem = new UIDModelItem(sig, uidItem, mRemarksEnabled);
             uidItem->appendChild(sigItem);
         }
     }
 
     endResetModel();
 }
 
 int UserIDListModel::columnCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return static_cast<UIDModelItem*>(parent.internalPointer())->columnCount();
     }
 
     if (!mRootItem) {
         return 0;
     }
 
     return mRootItem->columnCount();
 }
 
 int UserIDListModel::rowCount(const QModelIndex &parent) const
 {
     UIDModelItem *parentItem = nullptr;
     if (parent.column() > 0 || !mRootItem) {
         return 0;
     }
 
     if (!parent.isValid()) {
         parentItem = mRootItem;
     } else {
         parentItem = static_cast<UIDModelItem*>(parent.internalPointer());
     }
 
     return parentItem->childCount();
 }
 
 QModelIndex UserIDListModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!hasIndex(row, column, parent)) {
-        return QModelIndex();
+        return {};
     }
 
     UIDModelItem *parentItem = nullptr;
 
     if (!parent.isValid()) {
         parentItem = mRootItem;
     } else {
         parentItem = static_cast<UIDModelItem*>(parent.internalPointer());
     }
 
     UIDModelItem *childItem = parentItem->child(row);
     if (childItem) {
         return createIndex(row, column, childItem);
     } else {
         return QModelIndex();
     }
 }
 
 QModelIndex UserIDListModel::parent(const QModelIndex &index) const
 {
     if (!index.isValid()) {
-        return QModelIndex();
+        return {};
     }
-    UIDModelItem *childItem = static_cast<UIDModelItem*>(index.internalPointer());
+    auto *childItem = static_cast<UIDModelItem*>(index.internalPointer());
     UIDModelItem *parentItem = childItem->parentItem();
 
     if (parentItem == mRootItem) {
         return QModelIndex();
     }
 
     return createIndex(parentItem->row(), 0, parentItem);
 }
 
 QVariant UserIDListModel::headerData(int section, Qt::Orientation o, int role) const
 {
     if (o == Qt::Horizontal && mRootItem) {
         if (role == Qt::DisplayRole || role == Qt::EditRole || role == Qt::ToolTipRole) {
             return mRootItem->data(section);
         }
     }
     return QVariant();
 }
 
 QVariant UserIDListModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     if (role != Qt::DisplayRole && role != Qt::EditRole && role != Qt::ToolTipRole &&
         role != Qt::DecorationRole) {
         return QVariant();
     }
 
-    UIDModelItem *item = static_cast<UIDModelItem*>(index.internalPointer());
+    auto *item = static_cast<UIDModelItem*>(index.internalPointer());
 
     if (role == Qt::ToolTipRole) {
         return item->toolTip(index.column());
     }
 
     if (role == Qt::DecorationRole) {
         return item->icon(index.column());
     }
 
     return item->data(index.column());
 }
 
 QVector<UserID> UserIDListModel::userIDs (const QModelIndexList &indexs) const {
     QVector<GpgME::UserID> ret;
     for (const QModelIndex &idx : indexs) {
         if (!idx.isValid()) {
             continue;
         }
-        UIDModelItem *item = static_cast<UIDModelItem*>(idx.internalPointer());
+        auto *item = static_cast<UIDModelItem*>(idx.internalPointer());
         if (!item->uid().isNull()) {
             ret << item->uid();
         }
     }
     return ret;
 }
 
 QVector<UserID::Signature> UserIDListModel::signatures (const QModelIndexList &indexs) const {
     QVector<GpgME::UserID::Signature> ret;
     for (const QModelIndex &idx : indexs) {
         if (!idx.isValid()) {
             continue;
         }
-        UIDModelItem *item = static_cast<UIDModelItem*>(idx.internalPointer());
+        auto *item = static_cast<UIDModelItem*>(idx.internalPointer());
         if (!item->signature().isNull()) {
             ret << item->signature();
         }
     }
     return ret;
 }
 
 void UserIDListModel::enableRemarks(bool value)
 {
     mRemarksEnabled = value;
 }
diff --git a/src/tests/test_keygen.cpp b/src/tests/test_keygen.cpp
index bfe358ec7..451bd8a1b 100644
--- a/src/tests/test_keygen.cpp
+++ b/src/tests/test_keygen.cpp
@@ -1,161 +1,161 @@
 /*
     test_keygen.cpp
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 #include "test_keygen.h"
 
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/keygenerationjob.h>
 #include <qgpgme/protocol.h>
 #include "ui/progressdialog.h"
 
 #include <gpgme++/keygenerationresult.h>
 
 #include <KAboutData>
 
 #include <KMessageBox>
 #include <QDebug>
 
 #include <QLineEdit>
 #include <QLabel>
 #include <QGridLayout>
 
 #include <QApplication>
 #include <KLocalizedString>
 #include <QCommandLineParser>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <KGuiItem>
 #include <QVBoxLayout>
 
 static const char *const keyParams[] = {
     "Key-Type", "Key-Length",
     "Subkey-Type", "Subkey-Length",
     "Name-Real", "Name-Comment", "Name-Email", "Name-DN",
     "Expire-Date",
     "Passphrase"
 };
 static const int numKeyParams = sizeof keyParams / sizeof * keyParams;
 
 static const char *protocol = nullptr;
 
 KeyGenerator::KeyGenerator(QWidget *parent)
     : QDialog(parent)
 {
     setModal(true);
     setWindowTitle(QStringLiteral("KeyGenerationJob test"));
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     QWidget *mainWidget = new QWidget(this);
-    QVBoxLayout *mainLayout = new QVBoxLayout(this);
+    auto *mainLayout = new QVBoxLayout(this);
     mainLayout->addWidget(mainWidget);
-    QPushButton *user1Button = new QPushButton;
+    auto *user1Button = new QPushButton;
     buttonBox->addButton(user1Button, QDialogButtonBox::ActionRole);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KeyGenerator::reject);
     user1Button->setDefault(true);
     KGuiItem::assign(user1Button, KGuiItem(QStringLiteral("Create")));
 
     QWidget *w = new QWidget(this);
     mainLayout->addWidget(w);
     mainLayout->addWidget(buttonBox);
 
-    QGridLayout *glay = new QGridLayout(w);
+    auto *glay = new QGridLayout(w);
 
     int row = -1;
 
     ++row;
     glay->addWidget(new QLabel(QStringLiteral("<GnupgKeyParms format=\"internal\">"), w),
                     row, 0, 1, 2);
     for (int i = 0; i < numKeyParams; ++i) {
         ++row;
         glay->addWidget(new QLabel(QString::fromLatin1(keyParams[i]), w), row, 0);
         glay->addWidget(mLineEdits[i] = new QLineEdit(w), row, 1);
     }
 
     ++row;
     glay->addWidget(new QLabel(QStringLiteral("</GnupgKeyParms>"), w), row, 0, 1, 2);
     ++row;
     glay->setRowStretch(row, 1);
     glay->setColumnStretch(1, 1);
 
     connect(user1Button, &QPushButton::clicked, this, &KeyGenerator::slotStartKeyGeneration);
 }
 
 KeyGenerator::~KeyGenerator() {}
 
 void KeyGenerator::slotStartKeyGeneration()
 {
     QString params = QStringLiteral("<GnupgKeyParms format=\"internal\">\n");
     for (int i = 0; i < numKeyParams; ++i)
         if (mLineEdits[i] && !mLineEdits[i]->text().trimmed().isEmpty()) {
             params += QString::fromLatin1(keyParams[i]) + (QStringLiteral(": ") + mLineEdits[i]->text().trimmed()) + QLatin1Char('\n');
         }
     params += QStringLiteral("</GnupgKeyParms>\n");
 
     const QGpgME::Protocol *proto = nullptr;
     if (protocol) {
         proto = !strcmp(protocol, "openpgp") ? QGpgME::openpgp() : QGpgME::smime();
     }
     if (!proto) {
         proto = QGpgME::smime();
     }
     Q_ASSERT(proto);
 
     qDebug() << "Using protocol" << proto->name();
 
     QGpgME::KeyGenerationJob *job = proto->keyGenerationJob();
     Q_ASSERT(job);
 
     connect(job, &QGpgME::KeyGenerationJob::result, this, &KeyGenerator::slotResult);
 
     const GpgME::Error err = job->start(params);
     if (err) {
         showError(err);
     }
 #ifndef LIBKLEO_NO_PROGRESSDIALOG
     else {
         (void)new Kleo::ProgressDialog(job, QStringLiteral("Generating key"), this);
     }
 #endif
 }
 
 void KeyGenerator::showError(const GpgME::Error &err)
 {
     KMessageBox::error(this, QStringLiteral("Could not start key generation: %1").arg(QString::fromLocal8Bit(err.asString())),
                        QStringLiteral("Key Generation Error"));
 }
 
 void KeyGenerator::slotResult(const GpgME::KeyGenerationResult &res, const QByteArray &keyData)
 {
     if (res.error()) {
         showError(res.error());
     } else
         KMessageBox::information(this, QStringLiteral("Key generated successfully, %1 bytes long").arg(keyData.size()),
                                  QStringLiteral("Key Generation Finished"));
 }
 
 int main(int argc, char **argv)
 {
     if (argc == 2) {
         protocol = argv[1];
         argc = 1; // hide from KDE
     }
     QApplication app(argc, argv);
     KAboutData aboutData(QStringLiteral("test_keygen"), i18n("KeyGenerationJob Test"), QStringLiteral("0.1"));
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
-    KeyGenerator *keygen = new KeyGenerator(nullptr);
+    auto *keygen = new KeyGenerator(nullptr);
     keygen->setObjectName(QStringLiteral("KeyGenerator top-level"));
     keygen->show();
 
     return app.exec();
 }
 
diff --git a/src/tests/test_keylister.cpp b/src/tests/test_keylister.cpp
index 013abd5f2..ae56188c7 100644
--- a/src/tests/test_keylister.cpp
+++ b/src/tests/test_keylister.cpp
@@ -1,133 +1,133 @@
 /*
     test_keylister.cpp
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 #include "test_keylister.h"
 
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/protocol.h>
 
 #include <gpgme++/keylistresult.h>
 #include <gpgme++/key.h>
 
 #include <KAboutData>
 
 #include <QDebug>
 
 #include <QMessageBox>
 #include <QStringList>
 #include <QTimer>
 
 #include <QApplication>
 #include <KLocalizedString>
 #include <QCommandLineParser>
 
 namespace
 {
 class TestColumnStrategy : public Kleo::KeyListView::ColumnStrategy
 {
 public:
     ~TestColumnStrategy() {}
     QString title(int col) const override;
     QString toolTip(const GpgME::Key &key, int col) const override;
     QString text(const GpgME::Key &key, int col) const override;
 };
 
 QString TestColumnStrategy::title(int col) const
 {
     switch (col) {
     case 0: return QStringLiteral("Subject");
     case 1: return QStringLiteral("EMail");
     case 2: return QStringLiteral("Issuer");
     case 3: return QStringLiteral("Serial");
     case 4: return QStringLiteral("Protocol");
     case 5: return QStringLiteral("Validity");
     default: return QString();
     }
 }
 
 QString TestColumnStrategy::toolTip(const GpgME::Key &key, int) const
 {
     return QStringLiteral("Fingerprint: ") + QString::fromUtf8(key.primaryFingerprint());
 }
 
 QString TestColumnStrategy::text(const GpgME::Key &key, int col) const
 {
     if (key.isNull()) {
         return QStringLiteral("<null>");
     }
     switch (col) {
     case 0: return QString::fromUtf8(key.userID(0).id());
     case 1: return QString::fromUtf8(key.userID(0).email());
     case 2: return QString::fromUtf8(key.issuerName());
     case 3: return QString::fromLatin1(key.issuerSerial());
     case 4: return QString::fromLatin1(key.protocolAsString());
     case 5: return QString(QLatin1Char(key.userID(0).validityAsString()));
     default: return QString();
     }
 }
 }
 
 CertListView::CertListView(QWidget *parent, Qt::WindowFlags f)
     : Kleo::KeyListView(new TestColumnStrategy(), nullptr, parent, f)
 {
     setHierarchical(true);
     setRootIsDecorated(true);
 }
 
 CertListView::~CertListView() {}
 
 void CertListView::slotResult(const GpgME::KeyListResult &result)
 {
     qDebug() << "CertListView::slotResult()";
     if (result.isNull()) {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("KeyListResult is null!"));
     } else if (result.error())
         QMessageBox::critical(this, QStringLiteral("Key Listing Result"),
                               QStringLiteral("KeyListResult Error: %1").arg(QString::fromLatin1(result.error().asString())));
     else if (result.isTruncated()) {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("KeyListResult is truncated!"));
     } else {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("Key listing successful"));
     }
 }
 
 void CertListView::slotStart()
 {
     qDebug() << "CertListView::slotStart()";
     QGpgME::KeyListJob *job = QGpgME::smime()->keyListJob(false);
     Q_ASSERT(job);
     QObject::connect(job, &QGpgME::KeyListJob::nextKey, this, &CertListView::slotAddKey);
     QObject::connect(job, &QGpgME::KeyListJob::result, this, &CertListView::slotResult);
 #if 0
     QStringList l;
     l << "Marc";
     job->start(l, false);
 #else
     job->start(QStringList(), false);
 #endif
 }
 
 int main(int argc, char **argv)
 {
 
     QApplication app(argc, argv);
     KAboutData aboutData(QStringLiteral("test_keylister"), i18n("KeyLister Test"), QStringLiteral("0.1"));
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
-    CertListView *clv = new CertListView;
+    auto *clv = new CertListView;
     clv->show();
 
     QTimer::singleShot(5000, clv, &CertListView::slotStart);
 
     return app.exec();
 }
diff --git a/src/tests/test_keyresolver.cpp b/src/tests/test_keyresolver.cpp
index 9bb2f714e..17e6ebc89 100644
--- a/src/tests/test_keyresolver.cpp
+++ b/src/tests/test_keyresolver.cpp
@@ -1,168 +1,168 @@
 /*
     test_keyresolver.cpp
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2018 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 
 #include "kleo/keyresolver.h"
 
 #include <QCommandLineParser>
 #include <QApplication>
 #include <QDebug>
 #include <QTimer>
 
 using namespace Kleo;
 
 void dumpKeys(const QMap <CryptoMessageFormat, QMap<QString, std::vector<GpgME::Key> > > &fmtMap)
 {
     for (const CryptoMessageFormat fmt: fmtMap.keys()) {
         qDebug () << "Format:" << cryptoMessageFormatToLabel(fmt) << fmt;
         for (const auto &mbox: fmtMap[fmt].keys()) {
             qDebug() << "Address:" << mbox;
             qDebug() << "Keys:";
             for (const auto &key: fmtMap[fmt][mbox]) {
                 qDebug () << key.primaryFingerprint();
             }
         }
     }
 }
 
 void dumpSigKeys(const QMap <CryptoMessageFormat, std::vector<GpgME::Key> > &fmtMap)
 {
     for (const CryptoMessageFormat fmt: fmtMap.keys()) {
         qDebug () << "Format:" << cryptoMessageFormatToLabel(fmt) << fmt;
         qDebug() << "Keys:";
         for (const auto &key: fmtMap[fmt]) {
             qDebug () << key.primaryFingerprint();
         }
     }
 }
 
 class SignalRecipient: public QObject
 {
     Q_OBJECT
 public:
     SignalRecipient(KeyResolver *res) : resolver(res) {}
 
     void keysResolved(bool success, bool sendUnencrypted)
     {
         if (!success) {
             qDebug() << "Canceled";
             exit(1);
         }
         qDebug() << "Resolved Signing keys:";
         dumpSigKeys (resolver->signingKeys());
         qDebug() << "Resolved Encryption keys:";
         dumpKeys (resolver->encryptionKeys());
         qDebug() << "Resolved Hidden keys:";
         dumpKeys (resolver->hiddenKeys());
         qDebug() << "Send Unencrypted:" << sendUnencrypted;
         exit(0);
     }
 private:
     KeyResolver *resolver;
 };
 
 int main(int argc, char **argv)
 {
     QApplication app(argc, argv);
     QCommandLineParser parser;
     parser.setApplicationDescription(QStringLiteral("Test KeyResolver class"));
     parser.addHelpOption();
     parser.addPositionalArgument(QStringLiteral("recipients"),
                                   QStringLiteral("Recipients to resolve"),
                                   QStringLiteral("[mailboxes]"));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("overrides")
                                         << QStringLiteral("o"),
                                         QStringLiteral("Override where format can be:\n"
                                                        "InlineOpenPGP\n"
                                                        "OpenPGPMIME\n"
                                                        "SMIME\n"
                                                        "SMIMEOpaque\n"
                                                        "AnyOpenPGP\n"
                                                        "AnySMIME\n"
                                                        "Auto"),
                                         QStringLiteral("mailbox:fpr,fpr,..:format")));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("sender")
                                         << QStringLiteral("s"),
                                         QStringLiteral("Mailbox of the sender"),
                                         QStringLiteral("mailbox")));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("hidden")
                                         << QStringLiteral("h"),
                                         QStringLiteral("hidden recipients"),
                                         QStringLiteral("A hidden / bcc recipient")));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("sigkeys")
                                         << QStringLiteral("k"),
                                         QStringLiteral("signing key"),
                                         QStringLiteral("Explicit signing keys")));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("encrypt")
                                         << QStringLiteral("e"),
                                         QStringLiteral("Only select encryption keys")));
     parser.addOption(QCommandLineOption(QStringList() << QStringLiteral("approval")
                                         << QStringLiteral("a"),
                                         QStringLiteral("Always show approval dlg")));
 
     parser.process(app);
 
     const QStringList recps = parser.positionalArguments();
     if (recps.size() < 1) {
         parser.showHelp(1);
     }
 
     KeyResolver resolver(true, !parser.isSet(QStringLiteral("encrypt")));
     resolver.setRecipients(recps);
     resolver.setSender(parser.value(QStringLiteral("sender")));
 
     QMap <CryptoMessageFormat, QMap <QString, QStringList> > overrides;
 
     for (const QString &oride: parser.values(QStringLiteral("overrides"))) {
         const QStringList split = oride.split(QLatin1Char(':'));
         CryptoMessageFormat fmt = AutoFormat;
         if (split.size() < 2 || split.size() > 3) {
             parser.showHelp(1);
         }
 
         if (split.size() == 3) {
             const QString fmtStr = split[2].toLower();
             if (fmtStr == QLatin1String("inlineopenpgp")) {
                 fmt = InlineOpenPGPFormat;
             } else if (fmtStr == QLatin1String("openpgpmime")) {
                 fmt = OpenPGPMIMEFormat;
             } else if (fmtStr == QLatin1String("smime")) {
                 fmt = SMIMEFormat;
             } else if (fmtStr == QLatin1String("smimeopaque")) {
                 fmt = SMIMEOpaqueFormat;
             } else if (fmtStr == QLatin1String("anyopenpgp")) {
                 fmt = AnyOpenPGP;
             } else if (fmtStr == QLatin1String("anysmime")) {
                 fmt = AnySMIME;
             } else if (fmtStr == QLatin1String("auto")) {
                 fmt = AutoFormat;
             } else {
                 parser.showHelp(1);
             }
         }
         const QStringList fingerprints = split[1].split(QLatin1Char(','));
 
         auto map = overrides.value(fmt);
         map.insert(split[0], fingerprints);
         overrides.insert(fmt, map);
     }
     resolver.setOverrideKeys(overrides);
 
-    SignalRecipient * recp = new SignalRecipient(&resolver);
+    auto * recp = new SignalRecipient(&resolver);
     QObject::connect (&resolver, &KeyResolver::keysResolved, recp, &SignalRecipient::keysResolved);
 
     QTimer::singleShot(1000, [&parser, &resolver]() {
         resolver.start(parser.isSet(QStringLiteral("approval")));
     });
 
     app.exec();
     return 0;
 }
 
 #include "test_keyresolver.moc"
diff --git a/src/tests/test_keyselectiondialog.cpp b/src/tests/test_keyselectiondialog.cpp
index 3128ee012..ac333fc54 100644
--- a/src/tests/test_keyselectiondialog.cpp
+++ b/src/tests/test_keyselectiondialog.cpp
@@ -1,46 +1,46 @@
 /*
     test_keygen.cpp
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 #include "ui/keyselectiondialog.h"
 #include <gpgme++/key.h>
 
 #include <KAboutData>
 #include <QDebug>
 
 #include <vector>
 #include <QApplication>
 #include <KLocalizedString>
 #include <QCommandLineParser>
 
 int main(int argc, char **argv)
 {
     QApplication app(argc, argv);
     KAboutData aboutData(QStringLiteral("test_keyselectiondialog"), i18n("KeySelectionDialog Test"), QStringLiteral("0.1"));
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     Kleo::KeySelectionDialog dlg(QStringLiteral("Kleo::KeySelectionDialog Test"),
                                  QStringLiteral("Please select a key:"),
                                  std::vector<GpgME::Key>(),
                                  Kleo::KeySelectionDialog::AllKeys, true, true);
 
     if (dlg.exec() == QDialog::Accepted) {
         qDebug() << "accepted; selected key:" << (dlg.selectedKey().userID(0).id() ? dlg.selectedKey().userID(0).id() : "<null>") << "\nselected _keys_:";
-        for (std::vector<GpgME::Key>::const_iterator it = dlg.selectedKeys().begin(); it != dlg.selectedKeys().end(); ++it) {
+        for (auto it = dlg.selectedKeys().begin(); it != dlg.selectedKeys().end(); ++it) {
             qDebug() << (it->userID(0).id() ? it->userID(0).id() : "<null>");
         }
     } else {
         qDebug() << "rejected";
     }
 
     return 0;
 }
diff --git a/src/ui/auditlogviewer.cpp b/src/ui/auditlogviewer.cpp
index 932bfa6a4..c6721854f 100644
--- a/src/ui/auditlogviewer.cpp
+++ b/src/ui/auditlogviewer.cpp
@@ -1,139 +1,139 @@
 /*
   SPDX-FileCopyrightText: 2015-2020 Laurent Montel <montel@kde.org>
 
   SPDX-License-Identifier: LGPL-2.0-or-later
 
 */
 #include "auditlogviewer.h"
 
 #ifdef HAVE_PIMTEXTEDIT
 # include "kpimtextedit/richtexteditor.h"
 #else
 # include <QTextEdit>
 #endif
 #include <QSaveFile>
 #include <QFileDialog>
 #include <KConfigGroup>
 #include <KMessageBox>
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <QTextStream>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 using namespace Kleo::Private;
 
 AuditLogViewer::AuditLogViewer(const QString &log, QWidget *parent)
     : QDialog(parent),
       m_log(/* sic */),
 #ifdef HAVE_PIMTEXTEDIT
       m_textEdit(new KPIMTextEdit::RichTextEditorWidget(this))
 #else
       m_textEdit(new QTextEdit(this))
 #endif
 {
     setWindowTitle(i18nc("@title:window", "View GnuPG Audit Log"));
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
 
-    QPushButton *copyClipBtn = new QPushButton;
+    auto *copyClipBtn = new QPushButton;
     copyClipBtn->setText(i18n("&Copy to Clipboard"));
     copyClipBtn->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
     buttonBox->addButton(copyClipBtn, QDialogButtonBox::ActionRole);
     connect(copyClipBtn, &QPushButton::clicked, this, &AuditLogViewer::slotCopyClip);
 
-    QPushButton *saveAsBtn = new QPushButton;
+    auto *saveAsBtn = new QPushButton;
     saveAsBtn->setText(i18n("&Save to Disk..."));
     saveAsBtn->setIcon(QIcon::fromTheme(QStringLiteral("document-save-as")));
     buttonBox->addButton(saveAsBtn, QDialogButtonBox::ActionRole);
     connect(saveAsBtn, &QPushButton::clicked, this, &AuditLogViewer::slotSaveAs);
 
     m_textEdit->setObjectName(QStringLiteral("m_textEdit"));
     m_textEdit->setReadOnly(true);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout(this);
+    auto *mainLayout = new QVBoxLayout(this);
     mainLayout->addWidget(m_textEdit);
     mainLayout->addWidget(buttonBox);
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
     setAuditLog(log);
 
     readConfig();
 }
 
 AuditLogViewer::~AuditLogViewer()
 {
     writeConfig();
 }
 
 void AuditLogViewer::setAuditLog(const QString &log)
 {
     if (log == m_log) {
         return;
     }
     m_log = log;
     m_textEdit->setHtml(QLatin1String("<qt>") + log + QLatin1String("</qt>"));
 }
 
 void AuditLogViewer::slotSaveAs()
 {
     const QString fileName = QFileDialog::getSaveFileName(this, i18n("Choose File to Save GnuPG Audit Log to"));
     if (fileName.isEmpty()) {
         return;
     }
 
     QSaveFile file(fileName);
 
     if (file.open(QIODevice::WriteOnly)) {
         QTextStream s(&file);
         s << "<html><head>";
         if (!windowTitle().isEmpty()) {
             s << "\n<title>"
               << windowTitle().toHtmlEscaped()
               << "</title>\n";
         }
         s << "</head><body>\n"
           << m_log
           << "\n</body></html>\n";
         s.flush();
         file.commit();
     }
 
     if (const int err = file.error())
         KMessageBox::error(this, i18n("Could not save to file \"%1\": %2",
                                       file.fileName(), QString::fromLocal8Bit(strerror(err))),
                            i18n("File Save Error"));
 }
 
 void AuditLogViewer::slotCopyClip()
 {
 #ifdef HAVE_PIMTEXTEDIT
     m_textEdit->editor()->selectAll();
     m_textEdit->editor()->copy();
     m_textEdit->editor()->textCursor().clearSelection();
 #else
     m_textEdit->selectAll();
     m_textEdit->copy();
     m_textEdit->textCursor().clearSelection();
 #endif
 }
 
 void AuditLogViewer::readConfig()
 {
     KConfigGroup group(KSharedConfig::openConfig(), "AuditLogViewer");
     const QSize size = group.readEntry("Size", QSize());
     if (size.isValid()) {
         resize(size);
     } else {
         resize(600, 400);
     }
 }
 
 void AuditLogViewer::writeConfig()
 {
     KConfigGroup group(KSharedConfig::openConfig(), "AuditLogViewer");
     group.writeEntry("Size", size());
     group.sync();
 }
 
diff --git a/src/ui/cryptoconfigdialog.cpp b/src/ui/cryptoconfigdialog.cpp
index e27699373..da96d38b7 100644
--- a/src/ui/cryptoconfigdialog.cpp
+++ b/src/ui/cryptoconfigdialog.cpp
@@ -1,91 +1,91 @@
 /*
     cryptoconfigdialog.h
 
     This file is part of kgpgcertmanager
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "cryptoconfigdialog.h"
 #include "cryptoconfigmodule.h"
 #include <KLocalizedString>
 #include <KAcceleratorManager>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <KGuiItem>
 #include <QVBoxLayout>
 
 Kleo::CryptoConfigDialog::CryptoConfigDialog(QGpgME::CryptoConfig *config, QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window", "Configure GnuPG Backend"));
-    QVBoxLayout *mainLayout = new QVBoxLayout(this);
+    auto *mainLayout = new QVBoxLayout(this);
     mButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::RestoreDefaults | QDialogButtonBox::Apply, this);
     QPushButton *okButton = mButtonBox->button(QDialogButtonBox::Ok);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
-    QPushButton *user1Button = new QPushButton(this);
+    auto *user1Button = new QPushButton(this);
     mButtonBox->addButton(user1Button, QDialogButtonBox::ActionRole);
     connect(mButtonBox, &QDialogButtonBox::accepted, this, &CryptoConfigDialog::accept);
     connect(mButtonBox, &QDialogButtonBox::rejected, this, &CryptoConfigDialog::reject);
     okButton->setDefault(true);
     setModal(true);
     KGuiItem::assign(user1Button, KGuiItem(i18n("&Reset")));
 
     mMainWidget = new CryptoConfigModule(config, this);
     mainLayout->addWidget(mMainWidget);
     mainLayout->addWidget(mButtonBox);
 
     connect(mMainWidget, &CryptoConfigModule::changed, this, &CryptoConfigDialog::slotChanged);
     mButtonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
     if (mMainWidget->hasError()) {
         mButtonBox->button(QDialogButtonBox::RestoreDefaults)->setVisible(false);
         user1Button->setVisible(false);
         mButtonBox->button(QDialogButtonBox::Apply)->setVisible(false);
         okButton->setVisible(false);
     }
 
     // Automatically assign accelerators
     KAcceleratorManager::manage(this);
     connect(user1Button, &QPushButton::clicked, this, &CryptoConfigDialog::slotUser1);
     connect(mButtonBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &CryptoConfigDialog::slotCancel);
     connect(okButton, &QPushButton::clicked, this, &CryptoConfigDialog::slotOk);
     connect(mButtonBox->button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked, this, &CryptoConfigDialog::slotDefault);
     connect(mButtonBox->button(QDialogButtonBox::Apply), &QPushButton::clicked, this, &CryptoConfigDialog::slotApply);
 }
 
 void Kleo::CryptoConfigDialog::slotOk()
 {
     slotApply();
     accept();
 }
 
 void Kleo::CryptoConfigDialog::slotCancel()
 {
     mMainWidget->cancel();
     reject();
 }
 
 void Kleo::CryptoConfigDialog::slotDefault()
 {
     mMainWidget->defaults();
     slotChanged();
 }
 
 void Kleo::CryptoConfigDialog::slotApply()
 {
     mMainWidget->save();
     mButtonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 }
 
 void Kleo::CryptoConfigDialog::slotUser1() // reset
 {
     mMainWidget->reset();
     mButtonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 }
 
 void Kleo::CryptoConfigDialog::slotChanged()
 {
     mButtonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 }
 
diff --git a/src/ui/cryptoconfigmodule.cpp b/src/ui/cryptoconfigmodule.cpp
index b8d3b316b..f60dfc446 100644
--- a/src/ui/cryptoconfigmodule.cpp
+++ b/src/ui/cryptoconfigmodule.cpp
@@ -1,1054 +1,1054 @@
 /*
     cryptoconfigmodule.cpp
 
     This file is part of kgpgcertmanager
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "cryptoconfigmodule.h"
 #include "cryptoconfigmodule_p.h"
 #include "directoryserviceswidget.h"
 #include "kdhorizontalline.h"
 #include "filenamerequester.h"
 
 #include <qgpgme/cryptoconfig.h>
 
 #include <KLineEdit>
 #include <KLocalizedString>
 #include "kleo_ui_debug.h"
 #include <utils/formatting.h>
 #include <QIcon>
 #include <QDialogButtonBox>
 
 #include <QSpinBox>
 
 #include <QApplication>
 #include <QLabel>
 #include <QLayout>
 #include <QPushButton>
 #include <QRegExp>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QScrollArea>
 #include <QDesktopWidget>
 #include <QCheckBox>
 #include <QStyle>
 #include <QComboBox>
 #include <QGroupBox>
 
 #include <memory>
 #include <limits>
 #include <array>
 
 using namespace Kleo;
 
 namespace
 {
 
 class ScrollArea : public QScrollArea
 {
 public:
     explicit ScrollArea(QWidget *p) : QScrollArea(p) {}
     QSize sizeHint() const override
     {
         const QSize wsz = widget() ? widget()->sizeHint() : QSize();
-        return QSize(wsz.width() + style()->pixelMetric(QStyle::PM_ScrollBarExtent), QScrollArea::sizeHint().height());
+        return {wsz.width() + style()->pixelMetric(QStyle::PM_ScrollBarExtent), QScrollArea::sizeHint().height()};
     }
 };
 
 }
 inline QIcon loadIcon(const QString &s)
 {
     QString ss = s;
     return QIcon::fromTheme(ss.replace(QRegExp(QLatin1String("[^a-zA-Z0-9_]")), QStringLiteral("-")));
 }
 
 static unsigned int num_components_with_options(const QGpgME::CryptoConfig *config)
 {
     if (!config) {
         return 0;
     }
     const QStringList components = config->componentList();
     unsigned int result = 0;
     for (QStringList::const_iterator it = components.begin(); it != components.end(); ++it)
         if (const QGpgME::CryptoConfigComponent *const comp = config->component(*it))
             if (!comp->groupList().empty()) {
                 ++result;
             }
     return result;
 }
 
 static KPageView::FaceType determineJanusFace(const QGpgME::CryptoConfig *config, Kleo::CryptoConfigModule::Layout layout, bool &ok)
 {
     ok = true;
     if (num_components_with_options(config) < 2) {
         ok = false;
         return KPageView::Plain;
     }
     return
         layout == CryptoConfigModule::LinearizedLayout ? KPageView::Plain :
         layout == CryptoConfigModule::TabbedLayout     ? KPageView::Tabbed :
         /* else */                                       KPageView::List;
 }
 
 Kleo::CryptoConfigModule::CryptoConfigModule(QGpgME::CryptoConfig *config, QWidget *parent)
     : KPageWidget(parent), mConfig(config)
 {
     init(IconListLayout);
 }
 
 Kleo::CryptoConfigModule::CryptoConfigModule(QGpgME::CryptoConfig *config, Layout layout, QWidget *parent)
     : KPageWidget(parent), mConfig(config)
 {
     init(layout);
 }
 
 void Kleo::CryptoConfigModule::init(Layout layout)
 {
     if (QLayout *l = this->layout()) {
         l->setContentsMargins(0, 0, 0, 0);
     }
 
     QGpgME::CryptoConfig *const config = mConfig;
 
     bool configOK = false;
     const KPageView::FaceType type = determineJanusFace(config, layout, configOK);
 
     setFaceType(type);
 
     QVBoxLayout *vlay = nullptr;
     QWidget *vbox = nullptr;
 
     if (type == Plain) {
         QWidget *w = new QWidget(this);
-        QVBoxLayout *l = new QVBoxLayout(w);
+        auto *l = new QVBoxLayout(w);
         l->setContentsMargins(0, 0, 0, 0);
-        QScrollArea *s = new QScrollArea(w);
+        auto *s = new QScrollArea(w);
         s->setFrameStyle(QFrame::NoFrame);
         s->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
         s->setWidgetResizable(true);
         l->addWidget(s);
         vbox = new QWidget(s->viewport());
         vlay = new QVBoxLayout(vbox);
         vlay->setContentsMargins(0, 0, 0, 0);
         s->setWidget(vbox);
         addPage(w, configOK ? QString() : i18n("GpgConf Error"));
     }
 
     const QStringList components = sortComponentList(config->componentList());
     for (QStringList::const_iterator it = components.begin(); it != components.end(); ++it) {
         //qCDebug(KLEO_UI_LOG) <<"Component" << (*it).toLocal8Bit() <<":";
         QGpgME::CryptoConfigComponent *comp = config->component(*it);
         Q_ASSERT(comp);
         if (comp->groupList().empty()) {
             continue;
         }
 
         std::unique_ptr<CryptoConfigComponentGUI> compGUI(new CryptoConfigComponentGUI(this, comp));
         compGUI->setObjectName(*it);
         // KJanusWidget doesn't seem to have iterators, so we store a copy...
         mComponentGUIs.append(compGUI.get());
 
         if (type == Plain) {
             QGroupBox *gb = new QGroupBox(comp->description(), vbox);
             (new QVBoxLayout(gb))->addWidget(compGUI.release());
             vlay->addWidget(gb);
         } else {
             vbox = new QWidget(this);
             vlay = new QVBoxLayout(vbox);
             vlay->setContentsMargins(0, 0, 0, 0);
             KPageWidgetItem *pageItem = new KPageWidgetItem(vbox, comp->description());
             if (type != Tabbed) {
                 pageItem->setIcon(loadIcon(comp->iconName()));
             }
             addPage(pageItem);
 
             QScrollArea *scrollArea = type == Tabbed ? new QScrollArea(vbox) : new ScrollArea(vbox);
             scrollArea->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
             scrollArea->setWidgetResizable(true);
 
             vlay->addWidget(scrollArea);
             const QSize compGUISize = compGUI->sizeHint();
             scrollArea->setWidget(compGUI.release());
 
             // Set a nice startup size
             const int deskHeight = QApplication::desktop()->height();
             int dialogHeight;
             if (deskHeight > 1000) { // very big desktop ?
                 dialogHeight = 800;
             } else if (deskHeight > 650) { // big desktop ?
                 dialogHeight = 500;
             } else { // small (800x600, 640x480) desktop
                 dialogHeight = 400;
             }
             Q_ASSERT(scrollArea->widget());
             if (type != Tabbed) {
                 scrollArea->setMinimumHeight(qMin(compGUISize.height(), dialogHeight));
             }
         }
     }
     if (mComponentGUIs.empty()) {
         const QString msg = i18n("The gpgconf tool used to provide the information "
                                  "for this dialog does not seem to be installed "
                                  "properly. It did not return any components. "
                                  "Try running \"%1\" on the command line for more "
                                  "information.",
                                  components.empty() ? QLatin1String("gpgconf --list-components") : QLatin1String("gpgconf --list-options gpg"));
         QLabel *label = new QLabel(msg, vbox);
         label->setWordWrap(true);
         label->setMinimumHeight(fontMetrics().lineSpacing() * 5);
         vlay->addWidget(label);
     }
 }
 
 namespace
 {
 template<typename Iterator>
 QStringList sortConfigEntries(const Iterator orderBegin, const Iterator orderEnd, const QStringList &entries)
 {
     // components sorting algorithm:
     // 1. components with predefined order (provided via orderBegin / orderEnd)
     // 2. other components sorted alphabetically
     QStringList result, others;
     for (auto it = orderBegin; it != orderEnd; ++it) {
         if (entries.contains(*it)) {
             result.append(*it);
         }
     }
     for (const auto &item : entries) {
         if (!result.contains(item)) {
             others.append(item);
         }
     }
     others.sort();
     result.append(others);
     return result;
 }
 } // namespace
 
 QStringList Kleo::CryptoConfigModule::sortComponentList(const QStringList &components)
 {
     static const std::array<QString, 6> order = {
         QStringLiteral("gpg"),
         QStringLiteral("gpgsm"),
         QStringLiteral("gpg-agent"),
         QStringLiteral("dirmngr"),
         QStringLiteral("pinentry"),
         QStringLiteral("scdaemon")
     };
     return sortConfigEntries(order.begin(), order.end(), components);
 }
 
 QStringList Kleo::CryptoConfigModule::sortGroupList(const QString &moduleName, const QStringList &groups)
 {
     if (moduleName == QStringLiteral("gpg")) {
         static const std::array<QString, 4> order = {
             QStringLiteral("Keyserver"),
             QStringLiteral("Configuration"),
             QStringLiteral("Monitor"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else if (moduleName == QStringLiteral("gpgsm")) {
         static const std::array<QString, 4> order = {
             QStringLiteral("Security"),
             QStringLiteral("Configuration"),
             QStringLiteral("Monitor"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else if (moduleName == QStringLiteral("gpg-agent")) {
         static const std::array<QString, 5> order = {
             QStringLiteral("Security"),
             QStringLiteral("Passphrase policy"),
             QStringLiteral("Configuration"),
             QStringLiteral("Monitor"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else if (moduleName == QStringLiteral("dirmngr")) {
         static const std::array<QString, 10> order = {
             QStringLiteral("Keyserver"),
             QStringLiteral("HTTP"),
             QStringLiteral("LDAP"),
             QStringLiteral("OCSP"),
             QStringLiteral("Tor"),
             QStringLiteral("Enforcement"),
             QStringLiteral("Configuration"),
             QStringLiteral("Format"),
             QStringLiteral("Monitor"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else if (moduleName == QStringLiteral("scdaemon")) {
         static const std::array<QString, 4> order = {
             QStringLiteral("Monitor"),
             QStringLiteral("Configuration"),
             QStringLiteral("Security"),
             QStringLiteral("Debug"),
         };
         return sortConfigEntries(order.begin(), order.end(), groups);
     } else {
         qCDebug(KLEO_UI_LOG) << "Configuration groups order is not defined for " << moduleName;
         QStringList result(groups);
         result.sort();
         return result;
     }
 }
 
 bool Kleo::CryptoConfigModule::hasError() const
 {
     return mComponentGUIs.empty();
 }
 
 void Kleo::CryptoConfigModule::save()
 {
     bool changed = false;
     QList<CryptoConfigComponentGUI *>::Iterator it = mComponentGUIs.begin();
     for (; it != mComponentGUIs.end(); ++it) {
         if ((*it)->save()) {
             changed = true;
         }
     }
     if (changed) {
         mConfig->sync(true /*runtime*/);
     }
 }
 
 void Kleo::CryptoConfigModule::reset()
 {
     QList<CryptoConfigComponentGUI *>::Iterator it = mComponentGUIs.begin();
     for (; it != mComponentGUIs.end(); ++it) {
         (*it)->load();
     }
 }
 
 void Kleo::CryptoConfigModule::defaults()
 {
     QList<CryptoConfigComponentGUI *>::Iterator it = mComponentGUIs.begin();
     for (; it != mComponentGUIs.end(); ++it) {
         (*it)->defaults();
     }
 }
 
 void Kleo::CryptoConfigModule::cancel()
 {
     mConfig->clear();
 }
 
 ////
 
 Kleo::CryptoConfigComponentGUI::CryptoConfigComponentGUI(
     CryptoConfigModule *module, QGpgME::CryptoConfigComponent *component,
     QWidget *parent)
     : QWidget(parent),
       mComponent(component)
 {
-    QGridLayout *glay = new QGridLayout(this);
+    auto *glay = new QGridLayout(this);
     const QStringList groups = module->sortGroupList(mComponent->name(), mComponent->groupList());
     if (groups.size() > 1) {
         glay->setColumnMinimumWidth(0, KDHorizontalLine::indentHint());
         for (QStringList::const_iterator it = groups.begin(), end = groups.end(); it != end; ++it) {
             QGpgME::CryptoConfigGroup *group = mComponent->group(*it);
             Q_ASSERT(group);
             if (!group) {
                 continue;
             }
             const QString title = group->description();
-            KDHorizontalLine *hl = new KDHorizontalLine(title.isEmpty() ? *it : title, this);
+            auto *hl = new KDHorizontalLine(title.isEmpty() ? *it : title, this);
             const int row = glay->rowCount();
             glay->addWidget(hl, row, 0, 1, 3);
             mGroupGUIs.append(new CryptoConfigGroupGUI(module, group, glay, this));
         }
     } else if (!groups.empty()) {
         mGroupGUIs.append(new CryptoConfigGroupGUI(module, mComponent->group(groups.front()), glay, this));
     }
     glay->setRowStretch(glay->rowCount(), 1);
 }
 
 bool Kleo::CryptoConfigComponentGUI::save()
 {
     bool changed = false;
     QList<CryptoConfigGroupGUI *>::Iterator it = mGroupGUIs.begin();
     for (; it != mGroupGUIs.end(); ++it) {
         if ((*it)->save()) {
             changed = true;
         }
     }
     return changed;
 }
 
 void Kleo::CryptoConfigComponentGUI::load()
 {
     QList<CryptoConfigGroupGUI *>::Iterator it = mGroupGUIs.begin();
     for (; it != mGroupGUIs.end(); ++it) {
         (*it)->load();
     }
 }
 
 void Kleo::CryptoConfigComponentGUI::defaults()
 {
     QList<CryptoConfigGroupGUI *>::Iterator it = mGroupGUIs.begin();
     for (; it != mGroupGUIs.end(); ++it) {
         (*it)->defaults();
     }
 }
 
 ////
 
 Kleo::CryptoConfigGroupGUI::CryptoConfigGroupGUI(
     CryptoConfigModule *module, QGpgME::CryptoConfigGroup *group,
     QGridLayout *glay, QWidget *widget)
     : QObject(module), mGroup(group)
 {
     const bool de_vs = Kleo::Formatting::complianceMode() == QLatin1String("de-vs");
     const int startRow = glay->rowCount();
     const QStringList entries = mGroup->entryList();
     for (QStringList::const_iterator it = entries.begin(), end = entries.end(); it != end; ++it) {
         QGpgME::CryptoConfigEntry *entry = group->entry(*it);
         Q_ASSERT(entry);
         /* Skip "dangerous" options if we are running in CO_DE_VS.  */
         if (de_vs && entry->level() > QGpgME::CryptoConfigEntry::Level_Advanced) {
             qCDebug(KLEO_UI_LOG) << "entry" << *it << "too advanced, skipping";
             continue;
         }
         CryptoConfigEntryGUI *entryGUI =
             CryptoConfigEntryGUIFactory::createEntryGUI(module, entry, *it, glay, widget);
         if (entryGUI) {
             mEntryGUIs.append(entryGUI);
             entryGUI->load();
         }
     }
     const int endRow = glay->rowCount() - 1;
     if (endRow < startRow) {
         return;
     }
 
     const QString iconName = group->iconName();
     if (iconName.isEmpty()) {
         return;
     }
 
     QLabel *l = new QLabel(widget);
     l->setPixmap(loadIcon(iconName).pixmap(32, 32));
     glay->addWidget(l, startRow, 0, endRow - startRow + 1, 1, Qt::AlignTop);
 }
 
 bool Kleo::CryptoConfigGroupGUI::save()
 {
     bool changed = false;
     QList<CryptoConfigEntryGUI *>::Iterator it = mEntryGUIs.begin();
     for (; it != mEntryGUIs.end(); ++it) {
         if ((*it)->isChanged()) {
             (*it)->save();
             changed = true;
         }
     }
     return changed;
 }
 
 void Kleo::CryptoConfigGroupGUI::load()
 {
     QList<CryptoConfigEntryGUI *>::Iterator it = mEntryGUIs.begin();
     for (; it != mEntryGUIs.end(); ++it) {
         (*it)->load();
     }
 }
 
 void Kleo::CryptoConfigGroupGUI::defaults()
 {
     QList<CryptoConfigEntryGUI *>::Iterator it = mEntryGUIs.begin();
     for (; it != mEntryGUIs.end(); ++it) {
         (*it)->resetToDefault();
     }
 }
 
 ////
 
-typedef CryptoConfigEntryGUI *(*constructor)(CryptoConfigModule *, QGpgME::CryptoConfigEntry *, const QString &, QGridLayout *, QWidget *);
+using constructor = CryptoConfigEntryGUI *(*)(CryptoConfigModule *, QGpgME::CryptoConfigEntry *, const QString &, QGridLayout *, QWidget *);
 
 namespace
 {
 template <typename T_Widget>
 CryptoConfigEntryGUI *_create(CryptoConfigModule *m, QGpgME::CryptoConfigEntry *e, const QString &n, QGridLayout *l, QWidget *p)
 {
     return new T_Widget(m, e, n, l, p);
 }
 }
 
 static const struct WidgetsByEntryName {
     const char *entryGlob;
     constructor create;
 } widgetsByEntryName[] = {
     { "*/*/debug-level",   &_create<CryptoConfigEntryDebugLevel> },
     { "gpg/*/keyserver",   &_create<CryptoConfigEntryKeyserver>  }
 };
 static const unsigned int numWidgetsByEntryName = sizeof widgetsByEntryName / sizeof * widgetsByEntryName;
 
 static const constructor listWidgets[QGpgME::CryptoConfigEntry::NumArgType] = {
     // None: A list of options with no arguments (e.g. -v -v -v) is shown as a spinbox
     &_create<CryptoConfigEntrySpinBox>,
     nullptr, // String
     // Int/UInt: Let people type list of numbers (1,2,3....). Untested.
     &_create<CryptoConfigEntryLineEdit>,
     &_create<CryptoConfigEntryLineEdit>,
     nullptr, // Path
     nullptr, // Formerly URL
     &_create<CryptoConfigEntryLDAPURL>,
     nullptr, // DirPath
 };
 
 static const constructor scalarWidgets[QGpgME::CryptoConfigEntry::NumArgType] = {
     &_create<CryptoConfigEntryCheckBox>, // None
     &_create<CryptoConfigEntryLineEdit>, // String
     &_create<CryptoConfigEntrySpinBox>,  // Int
     &_create<CryptoConfigEntrySpinBox>,  // UInt
     &_create<CryptoConfigEntryPath>,     // Path
     nullptr,                                   // Formerly URL
     nullptr,                                   // LDAPURL
     &_create<CryptoConfigEntryDirPath>,  // DirPath
 };
 
 CryptoConfigEntryGUI *Kleo::CryptoConfigEntryGUIFactory::createEntryGUI(CryptoConfigModule *module, QGpgME::CryptoConfigEntry *entry, const QString &entryName, QGridLayout *glay, QWidget *widget)
 {
     Q_ASSERT(entry);
 
     // try to lookup by path:
     const QString path = entry->path();
     for (unsigned int i = 0; i < numWidgetsByEntryName; ++i)
         if (QRegExp(QLatin1String(widgetsByEntryName[i].entryGlob), Qt::CaseSensitive, QRegExp::Wildcard).exactMatch(path)) {
             return widgetsByEntryName[i].create(module, entry, entryName, glay, widget);
         }
 
     // none found, so look up by type:
     const unsigned int argType = entry->argType();
     Q_ASSERT(argType < QGpgME::CryptoConfigEntry::NumArgType);
     if (entry->isList())
         if (const constructor create = listWidgets[argType]) {
             return create(module, entry, entryName, glay, widget);
         } else {
             qCWarning(KLEO_UI_LOG) << "No widget implemented for list of type" << entry->argType();
         }
     else if (const constructor create = scalarWidgets[argType]) {
         return create(module, entry, entryName, glay, widget);
     } else {
         qCWarning(KLEO_UI_LOG) << "No widget implemented for type" << entry->argType();
     }
 
     return nullptr;
 }
 
 ////
 
 Kleo::CryptoConfigEntryGUI::CryptoConfigEntryGUI(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry,
     const QString &entryName)
     : QObject(module), mEntry(entry), mName(entryName), mChanged(false)
 {
     connect(this, &CryptoConfigEntryGUI::changed, module, &CryptoConfigModule::changed);
 }
 
 QString Kleo::CryptoConfigEntryGUI::description() const
 {
     QString descr = mEntry->description();
     if (descr.isEmpty()) { // happens for expert options
         // String does not need to be translated because the options itself
         // are also not translated
         return QStringLiteral("\"%1\"").arg(mName);
     }
     if (i18nc("Translate this to 'yes' or 'no' (use the English words!) "
               "depending on whether your language uses "
               "Sentence style capitalization in GUI labels (yes) or not (no). "
               "Context: We get some backend strings in that have the wrong "
               "capitalization (in English, at least) so we need to force the "
               "first character to upper-case. It is this behaviour you can "
               "control for your language with this translation.", "yes") == QLatin1String("yes")) {
         descr[0] = descr[0].toUpper();
     }
     return descr;
 }
 
 void Kleo::CryptoConfigEntryGUI::resetToDefault()
 {
     mEntry->resetToDefault();
     load();
 }
 
 ////
 
 Kleo::CryptoConfigEntryLineEdit::CryptoConfigEntryLineEdit(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
     const int row = glay->rowCount();
     mLineEdit = new KLineEdit(widget);
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mLineEdit);
     glay->addWidget(label, row, 1);
     glay->addWidget(mLineEdit, row, 2);
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mLineEdit->setEnabled(false);
     } else {
         connect(mLineEdit, &KLineEdit::textChanged, this, &CryptoConfigEntryLineEdit::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntryLineEdit::doSave()
 {
     mEntry->setStringValue(mLineEdit->text());
 }
 
 void Kleo::CryptoConfigEntryLineEdit::doLoad()
 {
     mLineEdit->setText(mEntry->stringValue());
 }
 
 ////
 
 static const struct {
     const char *label;
     const char *name;
 } debugLevels[] = {
     { I18N_NOOP("0 - None"), "none"},
     { I18N_NOOP("1 - Basic"), "basic"},
     { I18N_NOOP("2 - Verbose"), "advanced"},
     { I18N_NOOP("3 - More Verbose"), "expert"},
     { I18N_NOOP("4 - All"), "guru"},
 };
 static const unsigned int numDebugLevels = sizeof debugLevels / sizeof * debugLevels;
 
 Kleo::CryptoConfigEntryDebugLevel::CryptoConfigEntryDebugLevel(CryptoConfigModule *module, QGpgME::CryptoConfigEntry *entry,
         const QString &entryName, QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName),
       mComboBox(new QComboBox(widget))
 {
     QLabel *label = new QLabel(i18n("Set the debugging level to"), widget);
     label->setBuddy(mComboBox);
 
     for (unsigned int i = 0; i < numDebugLevels; ++i) {
         mComboBox->addItem(i18n(debugLevels[i].label));
     }
 
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mComboBox->setEnabled(false);
     } else {
         connect(mComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged),
                 this, &CryptoConfigEntryDebugLevel::slotChanged);
     }
 
     const int row = glay->rowCount();
     glay->addWidget(label, row, 1);
     glay->addWidget(mComboBox, row, 2);
 }
 
 void Kleo::CryptoConfigEntryDebugLevel::doSave()
 {
     const unsigned int idx = mComboBox->currentIndex();
     if (idx < numDebugLevels) {
         mEntry->setStringValue(QLatin1String(debugLevels[idx].name));
     } else {
         mEntry->setStringValue(QString());
     }
 }
 
 void Kleo::CryptoConfigEntryDebugLevel::doLoad()
 {
     const QString str = mEntry->stringValue();
     for (unsigned int i = 0; i < numDebugLevels; ++i)
         if (str == QLatin1String(debugLevels[i].name)) {
             mComboBox->setCurrentIndex(i);
             return;
         }
     mComboBox->setCurrentIndex(0);
 }
 
 ////
 
 Kleo::CryptoConfigEntryPath::CryptoConfigEntryPath(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName),
       mFileNameRequester(nullptr)
 {
     const int row = glay->rowCount();
     mFileNameRequester = new FileNameRequester(widget);
     mFileNameRequester->setExistingOnly(false);
     mFileNameRequester->setFilter(QDir::Files);
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mFileNameRequester);
     glay->addWidget(label, row, 1);
     glay->addWidget(mFileNameRequester, row, 2);
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mFileNameRequester->setEnabled(false);
     } else {
         connect(mFileNameRequester, &FileNameRequester::fileNameChanged, this, &CryptoConfigEntryPath::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntryPath::doSave()
 {
     mEntry->setURLValue(QUrl::fromLocalFile(mFileNameRequester->fileName()));
 }
 
 void Kleo::CryptoConfigEntryPath::doLoad()
 {
     if (mEntry->urlValue().isLocalFile()) {
         mFileNameRequester->setFileName(mEntry->urlValue().toLocalFile());
     } else {
         mFileNameRequester->setFileName(mEntry->urlValue().toString());
     }
 }
 
 ////
 
 Kleo::CryptoConfigEntryDirPath::CryptoConfigEntryDirPath(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName),
       mFileNameRequester(nullptr)
 {
     const int row = glay->rowCount();
     mFileNameRequester = new FileNameRequester(widget);
     mFileNameRequester->setExistingOnly(false);
     mFileNameRequester->setFilter(QDir::Dirs);
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mFileNameRequester);
     glay->addWidget(label, row, 1);
     glay->addWidget(mFileNameRequester, row, 2);
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mFileNameRequester->setEnabled(false);
     } else {
         connect(mFileNameRequester, &FileNameRequester::fileNameChanged, this, &CryptoConfigEntryDirPath::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntryDirPath::doSave()
 {
     mEntry->setURLValue(QUrl::fromLocalFile(mFileNameRequester->fileName()));
 }
 
 void Kleo::CryptoConfigEntryDirPath::doLoad()
 {
     mFileNameRequester->setFileName(mEntry->urlValue().toLocalFile());
 }
 
 ////
 
 Kleo::CryptoConfigEntrySpinBox::CryptoConfigEntrySpinBox(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
 
     if (entry->argType() == QGpgME::CryptoConfigEntry::ArgType_None && entry->isList()) {
         mKind = ListOfNone;
     } else if (entry->argType() == QGpgME::CryptoConfigEntry::ArgType_UInt) {
         mKind = UInt;
     } else {
         Q_ASSERT(entry->argType() == QGpgME::CryptoConfigEntry::ArgType_Int);
         mKind = Int;
     }
 
     const int row = glay->rowCount();
     mNumInput = new QSpinBox(widget);
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mNumInput);
     glay->addWidget(label, row, 1);
     glay->addWidget(mNumInput, row, 2);
 
     if (entry->isReadOnly()) {
         label->setEnabled(false);
         mNumInput->setEnabled(false);
     } else {
         mNumInput->setMinimum(mKind == Int ? std::numeric_limits<int>::min() : 0);
         mNumInput->setMaximum(std::numeric_limits<int>::max());
         connect(mNumInput, QOverload<int>::of(&QSpinBox::valueChanged), this, &CryptoConfigEntrySpinBox::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntrySpinBox::doSave()
 {
     int value = mNumInput->value();
     switch (mKind) {
     case ListOfNone:
         mEntry->setNumberOfTimesSet(value);
         break;
     case UInt:
         mEntry->setUIntValue(value);
         break;
     case Int:
         mEntry->setIntValue(value);
         break;
     }
 }
 
 void Kleo::CryptoConfigEntrySpinBox::doLoad()
 {
     int value = 0;
     switch (mKind) {
     case ListOfNone:
         value = mEntry->numberOfTimesSet();
         break;
     case UInt:
         value = mEntry->uintValue();
         break;
     case Int:
         value = mEntry->intValue();
         break;
     }
     mNumInput->setValue(value);
 }
 
 ////
 
 Kleo::CryptoConfigEntryCheckBox::CryptoConfigEntryCheckBox(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry, const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
     const int row = glay->rowCount();
     mCheckBox = new QCheckBox(widget);
     glay->addWidget(mCheckBox, row, 1, 1, 2);
     mCheckBox->setText(description());
     if (entry->isReadOnly()) {
         mCheckBox->setEnabled(false);
     } else {
         connect(mCheckBox, &QCheckBox::toggled, this, &CryptoConfigEntryCheckBox::slotChanged);
     }
 }
 
 void Kleo::CryptoConfigEntryCheckBox::doSave()
 {
     mEntry->setBoolValue(mCheckBox->isChecked());
 }
 
 void Kleo::CryptoConfigEntryCheckBox::doLoad()
 {
     mCheckBox->setChecked(mEntry->boolValue());
 }
 
 Kleo::CryptoConfigEntryLDAPURL::CryptoConfigEntryLDAPURL(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry,
     const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
     mLabel = new QLabel(widget);
     mPushButton = new QPushButton(entry->isReadOnly() ? i18n("Show...") : i18n("Edit..."), widget);
 
     const int row = glay->rowCount();
     QLabel *label = new QLabel(description(), widget);
     label->setBuddy(mPushButton);
     glay->addWidget(label, row, 1);
-    QHBoxLayout *hlay = new QHBoxLayout;
+    auto *hlay = new QHBoxLayout;
     glay->addLayout(hlay, row, 2);
     hlay->addWidget(mLabel, 1);
     hlay->addWidget(mPushButton);
 
     if (entry->isReadOnly()) {
         mLabel->setEnabled(false);
     }
     connect(mPushButton, &QPushButton::clicked, this, &CryptoConfigEntryLDAPURL::slotOpenDialog);
 }
 
 void Kleo::CryptoConfigEntryLDAPURL::doLoad()
 {
     setURLList(mEntry->urlValueList());
 }
 
 void Kleo::CryptoConfigEntryLDAPURL::doSave()
 {
     mEntry->setURLValueList(mURLList);
 }
 
 void prepareURLCfgDialog(QDialog *dialog, DirectoryServicesWidget *dirserv, bool readOnly)
 {
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok, dialog);
 
     if (!readOnly) {
         buttonBox->addButton(QDialogButtonBox::Cancel);
         buttonBox->addButton(QDialogButtonBox::RestoreDefaults);
 
         QPushButton *defaultsBtn = buttonBox->button(QDialogButtonBox::RestoreDefaults);
 
         QObject::connect(defaultsBtn, &QPushButton::clicked, dirserv, &DirectoryServicesWidget::clear);
         QObject::connect(buttonBox, &QDialogButtonBox::rejected, dialog, &QDialog::reject);
     }
 
     QObject::connect(buttonBox, &QDialogButtonBox::accepted, dialog, &QDialog::accept);
 
-    QVBoxLayout *layout = new QVBoxLayout;
+    auto *layout = new QVBoxLayout;
     layout->addWidget(dirserv);
     layout->addWidget(buttonBox);
     dialog->setLayout(layout);
 }
 
 void Kleo::CryptoConfigEntryLDAPURL::slotOpenDialog()
 {
     // I'm a bad boy and I do it all on the stack. Enough classes already :)
     // This is just a simple dialog around the directory-services-widget
     QDialog dialog(mPushButton->parentWidget());
     dialog.setWindowTitle(i18nc("@title:window", "Configure LDAP Servers"));
 
-    DirectoryServicesWidget *dirserv = new DirectoryServicesWidget(&dialog);
+    auto *dirserv = new DirectoryServicesWidget(&dialog);
 
     prepareURLCfgDialog(&dialog, dirserv, mEntry->isReadOnly());
 
     dirserv->setX509ReadOnly(mEntry->isReadOnly());
     dirserv->setAllowedSchemes(DirectoryServicesWidget::LDAP);
     dirserv->setAllowedProtocols(DirectoryServicesWidget::X509Protocol);
     dirserv->addX509Services(mURLList);
 
     if (dialog.exec()) {
         setURLList(dirserv->x509Services());
         slotChanged();
     }
 }
 
 void Kleo::CryptoConfigEntryLDAPURL::setURLList(const QList<QUrl> &urlList)
 {
     mURLList = urlList;
     if (mURLList.isEmpty()) {
         mLabel->setText(i18n("None configured"));
     } else {
         mLabel->setText(i18np("1 server configured", "%1 servers configured", mURLList.count()));
     }
 }
 
 Kleo::CryptoConfigEntryKeyserver::CryptoConfigEntryKeyserver(
     CryptoConfigModule *module,
     QGpgME::CryptoConfigEntry *entry,
     const QString &entryName,
     QGridLayout *glay, QWidget *widget)
     : CryptoConfigEntryGUI(module, entry, entryName)
 {
     mLabel = new QLabel(widget);
     mPushButton = new QPushButton(i18n("Edit..."), widget);
 
     const int row = glay->rowCount();
     QLabel *label = new QLabel(i18n("Use keyserver at"), widget);
     label->setBuddy(mPushButton);
     glay->addWidget(label, row, 1);
-    QHBoxLayout *hlay = new QHBoxLayout;
+    auto *hlay = new QHBoxLayout;
     glay->addLayout(hlay, row, 2);
     hlay->addWidget(mLabel, 1);
     hlay->addWidget(mPushButton);
 
     if (entry->isReadOnly()) {
         mLabel->setEnabled(false);
         mPushButton->hide();
     } else {
         connect(mPushButton, &QPushButton::clicked, this, &CryptoConfigEntryKeyserver::slotOpenDialog);
     }
 }
 
 Kleo::ParsedKeyserver Kleo::parseKeyserver(const QString &str)
 {
 #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     const QStringList list = str.split(QRegExp(QLatin1String("[\\s,]")), QString::SkipEmptyParts);
 #else
     const QStringList list = str.split(QRegExp(QLatin1String("[\\s,]")), Qt::SkipEmptyParts);
 #endif
     if (list.empty()) {
         return Kleo::ParsedKeyserver();
     }
     Kleo::ParsedKeyserver result;
     result.url = list.front();
     Q_FOREACH (const QString &kvpair, list.mid(1)) {
         const int idx = kvpair.indexOf(QLatin1Char('='));
         if (idx < 0) {
             result.options.push_back(qMakePair(kvpair, QString()));     // null QString
         } else {
             const QString key = kvpair.left(idx);
             const QString value = kvpair.mid(idx + 1);
             if (value.isEmpty()) {
                 result.options.push_back(qMakePair(key, QStringLiteral("")));    // make sure it's not a null QString, only an empty one
             } else {
                 result.options.push_back(qMakePair(key, value));
             }
         }
     }
     return result;
 }
 
 QString Kleo::assembleKeyserver(const ParsedKeyserver &keyserver)
 {
     if (keyserver.options.empty()) {
         return keyserver.url;
     }
     QString result = keyserver.url;
     typedef QPair<QString, QString> Pair;
     for (const Pair &pair : qAsConst(keyserver.options))
         if (pair.second.isNull()) {
             result += QLatin1Char(' ') + pair.first;
         } else {
             result += QLatin1Char(' ') + pair.first + QLatin1Char('=') + pair.second;
         }
     return result;
 }
 
 void Kleo::CryptoConfigEntryKeyserver::doLoad()
 {
     mParsedKeyserver = parseKeyserver(mEntry->stringValue());
     mLabel->setText(mParsedKeyserver.url);
 }
 
 void Kleo::CryptoConfigEntryKeyserver::doSave()
 {
     mParsedKeyserver.url = mLabel->text();
     mEntry->setStringValue(assembleKeyserver(mParsedKeyserver));
 }
 
 static QList<QUrl> string2urls(const QString &str)
 {
     QList<QUrl> ret;
     if (str.isEmpty()) {
         return ret;
     }
     ret << QUrl::fromUserInput(str);
     return ret;
 }
 
 static QString urls2string(const QList<QUrl> &urls)
 {
     return urls.empty() ? QString() : urls.front().url();
 }
 
 void Kleo::CryptoConfigEntryKeyserver::slotOpenDialog()
 {
     // I'm a bad boy and I do it all on the stack. Enough classes already :)
     // This is just a simple dialog around the directory-services-widget
     QDialog dialog(mPushButton->parentWidget());
     dialog.setWindowTitle(i18nc("@title:window", "Configure Keyservers"));
 
-    DirectoryServicesWidget *dirserv = new DirectoryServicesWidget(&dialog);
+    auto *dirserv = new DirectoryServicesWidget(&dialog);
 
     prepareURLCfgDialog(&dialog, dirserv, mEntry->isReadOnly());
 
     dirserv->setOpenPGPReadOnly(mEntry->isReadOnly());
     dirserv->setAllowedSchemes(DirectoryServicesWidget::AllSchemes);
     dirserv->setAllowedProtocols(DirectoryServicesWidget::OpenPGPProtocol);
     dirserv->addOpenPGPServices(string2urls(mLabel->text()));
 
     if (dialog.exec()) {
         mLabel->setText(urls2string(dirserv->openPGPServices()));
         slotChanged();
     }
 }
 
 #include "moc_cryptoconfigmodule_p.cpp"
diff --git a/src/ui/directoryserviceswidget.cpp b/src/ui/directoryserviceswidget.cpp
index 5b56a249f..e88998b9b 100644
--- a/src/ui/directoryserviceswidget.cpp
+++ b/src/ui/directoryserviceswidget.cpp
@@ -1,733 +1,733 @@
 /*
     directoryserviceswidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2001, 2002, 2004 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2017 Bundesamnt für Sicherheit in der Informationstechnik
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "directoryserviceswidget.h"
 
 #include "ui_directoryserviceswidget.h"
 
 #include "kleo_ui_debug.h"
 
 #include <KLocalizedString>
 
 #include <QItemDelegate>
 #include <QAbstractTableModel>
 #include <QSpinBox>
 #include <QHeaderView>
 
 #include <vector>
 
 #include <climits>
 #include <algorithm>
 #include <functional>
 
 #include <gpgme++/engineinfo.h>
 
 using namespace Kleo;
 
 namespace
 {
 
 static QUrl defaultX509Service()
 {
     QUrl url;
     url.setScheme(QStringLiteral("ldap"));
     url.setHost(i18nc("default server name, keep it a valid domain name, ie. no spaces", "server"));
     return url;
 }
 static QUrl defaultOpenPGPService()
 {
     QUrl url;
     if (GpgME::engineInfo(GpgME::GpgEngine).engineVersion() < "2.1.16") {
         url.setScheme(QStringLiteral("hkp"));
         url.setHost(QStringLiteral("keys.gnupg.net"));
     } else {
         url.setScheme(QStringLiteral("hkps"));
         url.setHost(QStringLiteral("hkps.pool.sks-keyservers.net"));
     }
    return url;
 }
 
 static bool is_ldap_scheme(const QUrl &url)
 {
     const QString scheme = url.scheme();
     return QString::compare(scheme, QStringLiteral("ldap"),  Qt::CaseInsensitive) == 0
            || QString::compare(scheme, QStringLiteral("ldaps"), Qt::CaseInsensitive) == 0;
 }
 
 static const struct {
     const char label[6];
     unsigned short port;
     DirectoryServicesWidget::Scheme base;
 } protocols[] = {
     { I18N_NOOP("hkp"), 11371, DirectoryServicesWidget::HKP  },
     { I18N_NOOP("http"),   80, DirectoryServicesWidget::HTTP },
     { I18N_NOOP("https"), 443, DirectoryServicesWidget::HTTP },
     { I18N_NOOP("ftp"),    21, DirectoryServicesWidget::FTP  },
     { I18N_NOOP("ftps"),  990, DirectoryServicesWidget::FTP  },
     { I18N_NOOP("ldap"),  389, DirectoryServicesWidget::LDAP },
     { I18N_NOOP("ldaps"), 636, DirectoryServicesWidget::LDAP },
 };
 static const unsigned int numProtocols = sizeof protocols / sizeof * protocols;
 
 static unsigned short default_port(const QString &scheme)
 {
     for (unsigned int i = 0; i < numProtocols; ++i)
         if (QString::compare(scheme, QLatin1String(protocols[i].label), Qt::CaseInsensitive) == 0) {
             return protocols[i].port;
         }
     return 0;
 }
 
 static QString display_scheme(const QUrl &url)
 {
     if (url.scheme().isEmpty()) {
         return QStringLiteral("hkp");
     } else {
         return url.scheme();
     }
 }
 
 static QString display_host(const QUrl &url)
 {
     // work around "subkeys.pgp.net" being interpreted as a path, not host
     if (url.host().isEmpty()) {
         return url.path();
     } else {
         return url.host();
     }
 }
 
 static unsigned short display_port(const QUrl &url)
 {
     if (url.port() > 0) {
         return url.port();
     } else {
         return default_port(display_scheme(url));
     }
 }
 
 static QRect calculate_geometry(const QRect &cell, const QSize &sizeHint)
 {
     const int height = qMax(cell.height(), sizeHint.height());
-    return QRect(cell.left(), cell.top() - (height - cell.height()) / 2,
-                 cell.width(), height);
+    return {cell.left(), cell.top() - (height - cell.height()) / 2,
+                 cell.width(), height};
 }
 
 /* The Model contains a bit historic cruft because in the past it was
  * thought to be a good idea to combine openPGP and X509 in a single
  * table although while you can have multiple X509 Keyservers there can
  * only be one OpenPGP Keyserver. So the OpenPGP Keyserver is now a
  * single lineedit. */
 class Model : public QAbstractTableModel
 {
     Q_OBJECT
 public:
     explicit Model(QObject *parent = nullptr)
         : QAbstractTableModel(parent),
           m_items(),
           m_x509ReadOnly(false),
           m_schemes(DirectoryServicesWidget::LDAP)
     {
 
     }
 
     void setX509ReadOnly(bool ro)
     {
         if (ro == m_x509ReadOnly) {
             return;
         }
         m_x509ReadOnly = ro;
         for (int row = 0, end = rowCount(); row != end; ++row) {
             Q_EMIT dataChanged(index(row, 0), index(row, NumColumns));
         }
     }
 
     QModelIndex addX509Service(const QUrl &url, bool force = false)
     {
         const auto it = force ? m_items.end() : findExistingUrl(url);
         unsigned int row;
         if (it != m_items.end()) {
             // existing item:
             row = it - m_items.begin();
             Q_EMIT dataChanged(index(row, 0), index(row, NumColumns));
         } else {
             // append new item
             row = m_items.size();
             beginInsertRows(QModelIndex(), row, row);
             m_items.push_back(url);
             endInsertRows();
         }
         return index(row, firstEditableColumn(row));
     }
 
     unsigned int numServices() const
     {
         return m_items.size();
     }
     QUrl          service(unsigned int row) const
     {
         return row < m_items.size() ?  m_items[row] : QUrl();
     }
 
     enum Columns {
         Host,
         Port,
         BaseDN,
         UserName,
         Password,
 
         NumColumns
     };
 
     QModelIndex duplicateRow(unsigned int row)
     {
         if (row >= m_items.size()) {
-            return QModelIndex();
+            return {};
         }
 
         beginInsertRows(QModelIndex(), row + 1, row + 1);
         m_items.insert(m_items.begin() + row + 1, m_items[row]);
         endInsertRows();
         return index(row + 1, 0);
     }
 
     void deleteRow(unsigned int row)
     {
         if (row >= m_items.size()) {
             return;
         }
 
         beginRemoveRows(QModelIndex(), row, row);
         m_items.erase(m_items.begin() + row);
         endInsertRows();
     }
 
     void clear()
     {
         if (m_items.empty()) {
             return;
         }
         beginRemoveRows(QModelIndex(), 0, m_items.size() - 1);
         m_items.clear();
         endRemoveRows();
     }
 
     int columnCount(const QModelIndex & = QModelIndex()) const override
     {
         return NumColumns;
     }
     int rowCount(const QModelIndex & = QModelIndex()) const override
     {
         return m_items.size();
     }
 
     QVariant data(const QModelIndex &idx, int role) const override;
     QVariant headerData(int section, Qt::Orientation o, int role) const override;
 
     Qt::ItemFlags flags(const QModelIndex &idx) const override;
     bool setData(const QModelIndex &idx, const QVariant &value, int role) override;
 
 private:
     bool doSetData(unsigned int row, unsigned int column, const QVariant &value, int role);
 
     static QString toolTipForColumn(int column);
     bool isLdapRow(unsigned int row) const;
     int firstEditableColumn(unsigned int) const
     {
         return Host;
     }
 
 private:
     std::vector<QUrl> m_items;
     bool m_x509ReadOnly    : 1;
     DirectoryServicesWidget::Schemes m_schemes;
 
 private:
     std::vector<QUrl>::iterator findExistingUrl(const QUrl &url)
     {
         return std::find_if(m_items.begin(), m_items.end(),
                             [&url](const QUrl &item) {
                                 const QUrl &lhs = url;
                                 const QUrl &rhs = item;
                                 return QString::compare(display_scheme(lhs), display_scheme(rhs), Qt::CaseInsensitive) == 0
                                     && QString::compare(display_host(lhs), display_host(rhs), Qt::CaseInsensitive) == 0
                                     && lhs.port() == rhs.port()
                                     && lhs.userName() == rhs.userName()
                                     // ... ignore password...
                                     && (!is_ldap_scheme(lhs)
                                         || lhs.query() == rhs.query());
                             });
     }
 };
 
 class Delegate : public QItemDelegate
 {
     Q_OBJECT
 public:
     explicit Delegate(QObject *parent = nullptr)
         : QItemDelegate(parent),
           m_schemes(DirectoryServicesWidget::LDAP)
     {
 
     }
 
     void setAllowedSchemes(const DirectoryServicesWidget::Schemes schemes)
     {
         m_schemes = schemes;
     }
     DirectoryServicesWidget::Schemes allowedSchemes() const
     {
         return m_schemes;
     }
 
     QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &idx) const override
     {
         switch (idx.column()) {
         case Model::Port:
             return createPortWidget(parent);
         }
         return QItemDelegate::createEditor(parent, option, idx);
     }
 
     void setEditorData(QWidget *editor, const QModelIndex &idx) const override
     {
         switch (idx.column()) {
         case Model::Port:
             setPortEditorData(qobject_cast<QSpinBox *>(editor), idx.data(Qt::EditRole).toInt());
             break;
         default:
             QItemDelegate::setEditorData(editor, idx);
             break;
         }
     }
 
     void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &idx) const override
     {
         switch (idx.column()) {
         case Model::Port:
             setPortModelData(qobject_cast<QSpinBox *>(editor), model, idx);
             break;
         default:
             QItemDelegate::setModelData(editor, model, idx);
             break;
         }
     }
 
     void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override
     {
         if (index.column() == Model::Port) {
             editor->setGeometry(calculate_geometry(option.rect, editor->sizeHint()));
         } else {
             QItemDelegate::updateEditorGeometry(editor, option, index);
         }
     }
 
 private:
     QWidget *createPortWidget(QWidget *parent) const
     {
-        QSpinBox *sb = new QSpinBox(parent);
+        auto *sb = new QSpinBox(parent);
         sb->setRange(1, USHRT_MAX);   // valid port numbers
         return sb;
     }
     void setPortEditorData(QSpinBox *sb, unsigned short port) const
     {
         Q_ASSERT(sb);
         sb->setValue(port);
     }
     void setPortModelData(const QSpinBox *sb, QAbstractItemModel *model, const QModelIndex &idx) const
     {
         Q_ASSERT(sb);
         Q_ASSERT(model);
         model->setData(idx, sb->value());
     }
 
 private:
     DirectoryServicesWidget::Schemes m_schemes;
 };
 
 }
 
 class DirectoryServicesWidget::Private
 {
     friend class ::Kleo::DirectoryServicesWidget;
     DirectoryServicesWidget *const q;
 public:
     explicit Private(DirectoryServicesWidget *qq)
         : q(qq),
           protocols(AllProtocols),
           readOnlyProtocols(NoProtocol),
           model(),
           delegate(),
           ui(q)
     {
         ui.treeView->setModel(&model);
         ui.treeView->setItemDelegate(&delegate);
 
         ui.pgpKeyserver->setPlaceholderText(defaultOpenPGPService().toString());
 
         connect(&model, &QAbstractItemModel::dataChanged, q, &DirectoryServicesWidget::changed);
         connect(&model, &QAbstractItemModel::rowsInserted, q, &DirectoryServicesWidget::changed);
         connect(&model, &QAbstractItemModel::rowsRemoved, q, &DirectoryServicesWidget::changed);
         connect(ui.treeView->selectionModel(), &QItemSelectionModel::selectionChanged,
                 q, [this]() { slotSelectionChanged(); });
         connect(ui.pgpKeyserver, &QLineEdit::textChanged, q, &DirectoryServicesWidget::changed);
 
         slotShowUserAndPasswordToggled(false);
     }
 
 private:
     void edit(const QModelIndex &index)
     {
         if (index.isValid()) {
             ui.treeView->clearSelection();
             ui.treeView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::Select | QItemSelectionModel::Rows);
             ui.treeView->edit(index);
         }
     }
     void slotNewX509Clicked()
     {
         edit(model.addX509Service(defaultX509Service(), true));
     }
     void slotDeleteClicked()
     {
         model.deleteRow(selectedRow());
     }
     void slotSelectionChanged()
     {
         enableDisableActions();
     }
     void slotShowUserAndPasswordToggled(bool on)
     {
         QHeaderView *const hv = ui.treeView->header();
         Q_ASSERT(hv);
         hv->setSectionHidden(Model::UserName, !on);
         hv->setSectionHidden(Model::Password, !on);
     }
 
     int selectedRow() const
     {
         const QModelIndexList mil = ui.treeView->selectionModel()->selectedRows();
         return mil.empty() ? -1 : mil.front().row();
     }
     int currentRow() const
     {
         const QModelIndex idx = ui.treeView->selectionModel()->currentIndex();
         return idx.isValid() ? idx.row() : -1;
     }
 
     void enableDisableActions()
     {
         const bool x509 = (protocols & X509Protocol) && !(readOnlyProtocols & X509Protocol);
         const bool pgp  = (protocols & OpenPGPProtocol) && !(readOnlyProtocols & OpenPGPProtocol);
         ui.newTB->setEnabled(x509);
         ui.pgpKeyserver->setEnabled(pgp);
         const int row = selectedRow();
         ui.deleteTB->setEnabled(row >= 0 && !(readOnlyProtocols & X509Protocol));
     }
 
 private:
     Protocols protocols;
     Protocols readOnlyProtocols;
     Model model;
     Delegate delegate;
     struct UI : Ui_DirectoryServicesWidget {
 
         explicit UI(DirectoryServicesWidget *q)
             : Ui_DirectoryServicesWidget()
         {
             setupUi(q);
         }
 
     } ui;
 };
 
 DirectoryServicesWidget::DirectoryServicesWidget(QWidget *p, Qt::WindowFlags f)
     : QWidget(p, f), d(new Private(this))
 {
 
 }
 
 DirectoryServicesWidget::~DirectoryServicesWidget()
 {
     delete d;
 }
 
 void DirectoryServicesWidget::setAllowedSchemes(Schemes schemes)
 {
     d->delegate.setAllowedSchemes(schemes);
 }
 
 DirectoryServicesWidget::Schemes DirectoryServicesWidget::allowedSchemes() const
 {
     return d->delegate.allowedSchemes();
 }
 
 void DirectoryServicesWidget::setAllowedProtocols(Protocols protocols)
 {
     if (d->protocols == protocols) {
         return;
     }
     d->protocols = protocols;
     d->enableDisableActions();
 }
 
 DirectoryServicesWidget::Protocols DirectoryServicesWidget::allowedProtocols() const
 {
     return d->protocols;
 }
 
 void DirectoryServicesWidget::setReadOnlyProtocols(Protocols protocols)
 {
     if (d->readOnlyProtocols == protocols) {
         return;
     }
     d->readOnlyProtocols = protocols;
     d->model.setX509ReadOnly(protocols & X509Protocol);
     d->enableDisableActions();
 }
 
 DirectoryServicesWidget::Protocols DirectoryServicesWidget::readOnlyProtocols() const
 {
     return d->readOnlyProtocols;
 }
 
 void DirectoryServicesWidget::addOpenPGPServices(const QList<QUrl> &urls)
 {
     if (urls.size() > 1) {
         qCWarning(KLEO_UI_LOG) << "More then one PGP Server, Ignoring all others.";
     }
     if (urls.size()) {
         d->ui.pgpKeyserver->setText(urls[0].toString());
     }
 }
 
 QList<QUrl> DirectoryServicesWidget::openPGPServices() const
 {
     QList<QUrl> result;
     const QString pgpStr = d->ui.pgpKeyserver->text();
     if (pgpStr.contains(QLatin1String("://"))) {
         // Maybe validate here? Otoh maybe gnupg adds support for more schemes
         // then we know about in the future.
         result.push_back(QUrl::fromUserInput(pgpStr));
     } else if (!pgpStr.isEmpty()) {
         result.push_back(QUrl::fromUserInput(QStringLiteral("hkp://") + pgpStr));
     }
     return result;
 }
 
 void DirectoryServicesWidget::addX509Services(const QList<QUrl> &urls)
 {
     for (const QUrl &url : urls) {
         d->model.addX509Service(url);
     }
 }
 
 QList<QUrl> DirectoryServicesWidget::x509Services() const
 {
     QList<QUrl> result;
     for (unsigned int i = 0, end = d->model.numServices(); i != end; ++i) {
         result.push_back(d->model.service(i));
     }
     return result;
 }
 
 void DirectoryServicesWidget::clear()
 {
     if (!d->model.numServices()) {
         return;
     }
     d->model.clear();
     d->ui.pgpKeyserver->setText(QString());
     Q_EMIT changed();
 }
 
 //
 // Model
 //
 
 QVariant Model::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal)
         if (role == Qt::ToolTipRole) {
             return toolTipForColumn(section);
         } else if (role == Qt::DisplayRole)
             switch (section) {
             case Host:     return i18n("Server Name");
             case Port:     return i18n("Server Port");
             case BaseDN:   return i18n("Base DN");
             case UserName: return i18n("User Name");
             case Password: return i18n("Password");
             default:       return QVariant();
             }
         else {
             return QVariant();
         }
     else {
         return QAbstractTableModel::headerData(section, orientation, role);
     }
 }
 
 QVariant Model::data(const QModelIndex &index, int role) const
 {
     const unsigned int row = index.row();
     if (index.isValid() && row < m_items.size())
         switch (role) {
         case Qt::ToolTipRole: {
             const QString tt = toolTipForColumn(index.column());
             if (!m_x509ReadOnly) {
                 return tt;
             } else
                 return tt.isEmpty()
                        ? i18n("(read-only)")
                        : i18nc("amended tooltip; %1: original tooltip",
                                "%1 (read-only)", tt);
         }
         case Qt::DisplayRole:
         case Qt::EditRole:
             switch (index.column()) {
             case Host:
                 return display_host(m_items[row]);
             case Port:
                 return display_port(m_items[row]);
             case BaseDN:
                 if (isLdapRow(row)) {
                     return m_items[row].query();
                 } else {
                     return QVariant();
                 }
             case UserName:
                 return m_items[row].userName();
             case Password:
                 return m_items[row].password();
             default:
                 return QVariant();
             }
         }
     return QVariant();
 }
 
 bool Model::isLdapRow(unsigned int row) const
 {
     if (row >= m_items.size()) {
         return false;
     }
     return is_ldap_scheme(m_items[row]);
 }
 
 Qt::ItemFlags Model::flags(const QModelIndex &index) const
 {
     const unsigned int row = index.row();
     Qt::ItemFlags flags = QAbstractTableModel::flags(index);
     if (m_x509ReadOnly) {
         flags &= ~Qt::ItemIsSelectable;
     }
     if (index.isValid() && row < m_items.size())
         switch (index.column()) {
         case Host:
         case Port:
             if (m_x509ReadOnly) {
                 return flags & ~(Qt::ItemIsEditable | Qt::ItemIsEnabled);
             } else {
                 return flags | Qt::ItemIsEditable;
             }
         case BaseDN:
             if (isLdapRow(row) && !m_x509ReadOnly) {
                 return flags | Qt::ItemIsEditable;
             } else {
                 return flags & ~(Qt::ItemIsEditable | Qt::ItemIsEnabled);
             }
         case UserName:
         case Password:
             if (m_x509ReadOnly) {
                 return flags & ~(Qt::ItemIsEditable | Qt::ItemIsEnabled);
             } else {
                 return flags | Qt::ItemIsEditable;
             }
         }
     return flags;
 }
 
 bool Model::setData(const QModelIndex &idx, const QVariant &value, int role)
 {
     const unsigned int row = idx.row();
     if (!idx.isValid() || row >= m_items.size()) {
         return false;
     }
     if (m_x509ReadOnly) {
         return false;
     }
     if (!doSetData(row, idx.column(), value, role)) {
         return false;
     }
     Q_EMIT dataChanged(idx, idx);
     return true;
 }
 
 bool Model::doSetData(unsigned int row, unsigned int column, const QVariant &value, int role)
 {
     if (role == Qt::EditRole)
         switch (column) {
         case Host:
             if (display_host(m_items[row]) != m_items[row].host()) {
                 m_items[row].setScheme(display_scheme(m_items[row]));
             }
             m_items[row].setHost(value.toString());
             return true;
         case Port:
             if (value.toUInt() == default_port(display_scheme(m_items[row]))) {
                 m_items[row].setPort(-1);
             } else {
                 m_items[row].setPort(value.toUInt());
             }
             return true;
         case BaseDN:
             if (value.toString().isEmpty()) {
                 m_items[row].setPath(QString());
                 m_items[row].setQuery(QString());
             } else {
                 m_items[row].setQuery(value.toString());
             }
             return true;
         case UserName:
             m_items[row].setUserName(value.toString());
             return true;
         case Password:
             m_items[row].setPassword(value.toString());
             return true;
         }
     return false;
 }
 
 
 // static
 QString Model::toolTipForColumn(int column)
 {
     switch (column) {
     case Host:     return i18n("Enter the name or IP address of the server "
                                    "hosting the directory service.");
     case Port:     return i18n("<b>(Optional, the default is fine in most cases)</b> "
                                    "Pick the port number the directory service is "
                                    "listening on.");
     case BaseDN:   return i18n("<b>(Only for LDAP)</b> "
                                    "Enter the base DN for this LDAP server to "
                                    "limit searches to only that subtree of the directory.");
     case UserName: return i18n("<b>(Optional)</b> "
                                    "Enter your user name here, if needed.");
     case Password: return i18n("<b>(Optional, not recommended)</b> "
                                    "Enter your password here, if needed. "
                                    "Note that the password will be saved in the clear "
                                    "in a config file in your home directory.");
     default:
         return QString();
     }
 }
 
 #include "directoryserviceswidget.moc"
 #include "moc_directoryserviceswidget.cpp"
diff --git a/src/ui/dnattributeorderconfigwidget.cpp b/src/ui/dnattributeorderconfigwidget.cpp
index 2d9cf0216..7c637518a 100644
--- a/src/ui/dnattributeorderconfigwidget.cpp
+++ b/src/ui/dnattributeorderconfigwidget.cpp
@@ -1,354 +1,354 @@
 /*  -*- c++ -*-
     dnattributeorderconfigwidget.cpp
 
     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
 */
 
 #include "dnattributeorderconfigwidget.h"
 #include "libkleo_debug.h"
 #include "libkleo/dn.h"
 
 #include <KLocalizedString>
 #include <KConfig>
 #include <QIcon>
 
 #include <QToolButton>
 #include <QGridLayout>
 #include <QLabel>
 
 #include <QTreeWidget>
 #include <QHeaderView>
 
 
 class Kleo::DNAttributeOrderConfigWidget::Private
 {
 public:
     enum { UUp = 0, Up = 1, Left = 2, Right = 3, Down = 4, DDown = 5 };
 
 #ifndef QT_NO_TREEWIDGET
     QTreeWidget *availableLV = nullptr;
     QTreeWidget *currentLV = nullptr;
 #endif
     QToolButton *navTB[6];
 
 #ifndef QT_NO_TREEWIDGET
     QTreeWidgetItem *placeHolderItem = nullptr;
 #endif
 
     Kleo::DNAttributeMapper *mapper = nullptr;
 };
 
 #ifndef QT_NO_TREEWIDGET
 static void prepare(QTreeWidget *lv)
 {
     lv->setAllColumnsShowFocus(true);
     lv->header()->setStretchLastSection(true);
     lv->setHeaderLabels(QStringList() << QString() << i18n("Description"));
 }
 #endif
 
 Kleo::DNAttributeOrderConfigWidget::DNAttributeOrderConfigWidget(DNAttributeMapper *mapper, QWidget *parent, Qt::WindowFlags f)
     : QWidget(parent, f), d(new Private)
 {
     Q_ASSERT(mapper);
     d->mapper = mapper;
 
-    QGridLayout *glay = new QGridLayout(this);
+    auto *glay = new QGridLayout(this);
     glay->setContentsMargins(0, 0, 0, 0);
     glay->setColumnStretch(0, 1);
     glay->setColumnStretch(2, 1);
 
     int row = -1;
 
     ++row;
     glay->addWidget(new QLabel(i18n("Available attributes:"), this), row, 0);
     glay->addWidget(new QLabel(i18n("Current attribute order:"), this), row, 2);
 
     ++row;
     glay->setRowStretch(row, 1);
 
 #ifndef QT_NO_TREEWIDGET
     d->availableLV = new QTreeWidget(this);
     prepare(d->availableLV);
     d->availableLV->sortItems(0, Qt::AscendingOrder);
     glay->addWidget(d->availableLV, row, 0);
 
     d->currentLV = new QTreeWidget(this);
     prepare(d->currentLV);
     glay->addWidget(d->currentLV, row, 2);
 
     connect(d->availableLV, &QTreeWidget::itemClicked, this, &DNAttributeOrderConfigWidget::slotAvailableSelectionChanged);
     connect(d->currentLV, &QTreeWidget::itemClicked, this, &DNAttributeOrderConfigWidget::slotCurrentOrderSelectionChanged);
 
     d->placeHolderItem = new QTreeWidgetItem(d->availableLV);
     d->placeHolderItem->setText(0, QStringLiteral("_X_"));
     d->placeHolderItem->setText(1, i18n("All others"));
 #endif
 
     // the up/down/left/right arrow cross:
 
-    QGridLayout *xlay = new QGridLayout();
+    auto *xlay = new QGridLayout();
     xlay->setSpacing(0);
     xlay->setObjectName(QStringLiteral("xlay"));
     xlay->setAlignment(Qt::AlignCenter);
 
     static const struct {
         const char *icon;
         int row, col;
         const char *tooltip;
         void(DNAttributeOrderConfigWidget::*slot)();
         bool autorepeat;
     } navButtons[] = {
         { "go-top",    0, 1, I18N_NOOP("Move to top"),   &DNAttributeOrderConfigWidget::slotDoubleUpButtonClicked, false },
         { "go-up",    1, 1, I18N_NOOP("Move one up"),    &DNAttributeOrderConfigWidget::slotUpButtonClicked, true },
         { "go-previous",  2, 0, I18N_NOOP("Remove from current attribute order"), &DNAttributeOrderConfigWidget::slotLeftButtonClicked, false },
         { "go-next", 2, 2, I18N_NOOP("Add to current attribute order"), &DNAttributeOrderConfigWidget::slotRightButtonClicked, false },
         { "go-down",  3, 1, I18N_NOOP("Move one down"),  &DNAttributeOrderConfigWidget::slotDownButtonClicked, true },
         { "go-bottom",  4, 1, I18N_NOOP("Move to bottom"), &DNAttributeOrderConfigWidget::slotDoubleDownButtonClicked, false }
     };
 
     for (unsigned int i = 0; i < sizeof navButtons / sizeof * navButtons; ++i) {
         QToolButton *tb = d->navTB[i] = new QToolButton(this);
         tb->setIcon(QIcon::fromTheme(QLatin1String(navButtons[i].icon)));
         tb->setEnabled(false);
         tb->setToolTip(i18n(navButtons[i].tooltip));
         xlay->addWidget(tb, navButtons[i].row, navButtons[i].col);
         tb->setAutoRepeat(navButtons[i].autorepeat);
         connect(tb, &QToolButton::clicked, this, navButtons[i].slot);
     }
 
     glay->addLayout(xlay, row, 1);
 }
 
 Kleo::DNAttributeOrderConfigWidget::~DNAttributeOrderConfigWidget()
 {
     delete d;
 }
 
 void Kleo::DNAttributeOrderConfigWidget::load()
 {
 #ifndef QT_NO_TREEWIDGET
     // save the _X_ item:
     takePlaceHolderItem();
     // clear the rest:
     d->availableLV->clear();
     d->currentLV->clear();
 
     const QStringList order = d->mapper->attributeOrder();
 
     // fill the RHS listview:
     QTreeWidgetItem *last = nullptr;
     for (QStringList::const_iterator it = order.begin(); it != order.end(); ++it) {
         const QString attr = (*it).toUpper();
         if (attr == QLatin1String("_X_")) {
             takePlaceHolderItem();
             d->currentLV->insertTopLevelItem(d->currentLV->topLevelItemCount(), d->placeHolderItem);
             last = d->placeHolderItem;
         } else {
             last = new QTreeWidgetItem(d->currentLV, last);
             last->setText(0, attr);
             last->setText(1, d->mapper->name2label(attr));
         }
     }
 
     // fill the LHS listview with what's left:
 
     const QStringList all = Kleo::DNAttributeMapper::instance()->names();
     const QStringList::const_iterator end(all.end());
     for (QStringList::const_iterator it = all.begin(); it != end; ++it) {
         if (!order.contains(*it)) {
-            QTreeWidgetItem *item = new QTreeWidgetItem(d->availableLV);
+            auto *item = new QTreeWidgetItem(d->availableLV);
             item->setText(0, *it);
             item->setText(1, d->mapper->name2label(*it));
         }
     }
 
     if (!d->placeHolderItem->treeWidget()) {
         d->availableLV->addTopLevelItem(d->placeHolderItem);
     }
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::takePlaceHolderItem()
 {
 #ifndef QT_NO_TREEWIDGET
     if (QTreeWidget *lv = d->placeHolderItem->treeWidget()) {
         lv->takeTopLevelItem(lv->indexOfTopLevelItem(d->placeHolderItem));
     }
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::save() const
 {
 #ifndef QT_NO_TREEWIDGET
     QStringList order;
     for (QTreeWidgetItemIterator it(d->currentLV); (*it); ++it) {
         order.push_back((*it)->text(0));
     }
 
     d->mapper->setAttributeOrder(order);
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::defaults()
 {
      qCDebug (LIBKLEO_LOG) << "Sorry, not implemented: Kleo::DNAttributeOrderConfigWidget::defaults()";
 }
 
 void Kleo::DNAttributeOrderConfigWidget::slotAvailableSelectionChanged(QTreeWidgetItem *item)
 {
     d->navTB[Private::Right]->setEnabled(item);
 }
 
 void Kleo::DNAttributeOrderConfigWidget::slotCurrentOrderSelectionChanged(QTreeWidgetItem *item)
 {
     enableDisableButtons(item);
 }
 
 void Kleo::DNAttributeOrderConfigWidget::enableDisableButtons(QTreeWidgetItem *item)
 {
 #ifndef QT_NO_TREEWIDGET
     d->navTB[Private::UUp  ]->setEnabled(item && d->currentLV->itemAbove(item));
     d->navTB[Private::Up   ]->setEnabled(item && d->currentLV->itemAbove(item));
     d->navTB[Private::Left ]->setEnabled(item);
     d->navTB[Private::Down ]->setEnabled(item && d->currentLV->itemBelow(item));
     d->navTB[Private::DDown]->setEnabled(item && d->currentLV->itemBelow(item));
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::slotUpButtonClicked()
 {
 #ifndef QT_NO_TREEWIDGET
     if (d->currentLV->selectedItems().isEmpty()) {
         return;
     }
     QTreeWidgetItem *item = d->currentLV->selectedItems().first();
     int itemIndex = d->currentLV->indexOfTopLevelItem(item);
     if (itemIndex <= 0) {
         return;
     }
     d->currentLV->takeTopLevelItem(itemIndex);
     d->currentLV->insertTopLevelItem(itemIndex - 1, item);
     d->currentLV->clearSelection();
     item->setSelected(true);
     enableDisableButtons(item);
     Q_EMIT changed();
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::slotDoubleUpButtonClicked()
 {
 #ifndef QT_NO_TREEWIDGET
     if (d->currentLV->selectedItems().isEmpty()) {
         return;
     }
     QTreeWidgetItem *item = d->currentLV->selectedItems().first();
     int itemIndex = d->currentLV->indexOfTopLevelItem(item);
     if (itemIndex == 0) {
         return;
     }
     d->currentLV->takeTopLevelItem(itemIndex);
     d->currentLV->insertTopLevelItem(0, item);
     d->currentLV->clearSelection();
     item->setSelected(true);
     enableDisableButtons(item);
     Q_EMIT changed();
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::slotDownButtonClicked()
 {
 #ifndef QT_NO_TREEWIDGET
     if (d->currentLV->selectedItems().isEmpty()) {
         return;
     }
     QTreeWidgetItem *item = d->currentLV->selectedItems().first();
     int itemIndex = d->currentLV->indexOfTopLevelItem(item);
     if (itemIndex + 1 >= d->currentLV->topLevelItemCount()) {
         return;
     }
     d->currentLV->takeTopLevelItem(itemIndex);
     d->currentLV->insertTopLevelItem(itemIndex + 1, item);
     d->currentLV->clearSelection();
     item->setSelected(true);
     enableDisableButtons(item);
     Q_EMIT changed();
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::slotDoubleDownButtonClicked()
 {
 #ifndef QT_NO_TREEWIDGET
     if (d->currentLV->selectedItems().isEmpty()) {
         return;
     }
     QTreeWidgetItem *item = d->currentLV->selectedItems().first();
     const int itemIndex = d->currentLV->indexOfTopLevelItem(item);
     if (itemIndex + 1 >= d->currentLV->topLevelItemCount()) {
         return;
     }
     d->currentLV->takeTopLevelItem(itemIndex);
     d->currentLV->addTopLevelItem(item);
     d->currentLV->clearSelection();
     item->setSelected(true);
     enableDisableButtons(item);
     Q_EMIT changed();
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::slotLeftButtonClicked()
 {
 #ifndef QT_NO_TREEWIDGET
     if (d->currentLV->selectedItems().isEmpty()) {
         return;
     }
     QTreeWidgetItem *right = d->currentLV->selectedItems().first();
     QTreeWidgetItem *next = d->currentLV->itemBelow(right);
     if (!next) {
         next = d->currentLV->itemAbove(right);
     }
     d->currentLV->takeTopLevelItem(d->currentLV->indexOfTopLevelItem(right));
     d->availableLV->addTopLevelItem(right);
     d->availableLV->sortItems(0, Qt::AscendingOrder);
     if (next) {
         next->setSelected(true);
     }
     enableDisableButtons(next);
     Q_EMIT changed();
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::slotRightButtonClicked()
 {
 #ifndef QT_NO_TREEWIDGET
     if (d->availableLV->selectedItems().isEmpty()) {
         return;
     }
     QTreeWidgetItem *left = d->availableLV->selectedItems().first();
     QTreeWidgetItem *next = d->availableLV->itemBelow(left);
     if (!next) {
         next = d->availableLV->itemAbove(left);
     }
     d->availableLV->takeTopLevelItem(d->availableLV->indexOfTopLevelItem(left));
     int newRightIndex = d->currentLV->topLevelItemCount();
     if (!d->currentLV->selectedItems().isEmpty()) {
         QTreeWidgetItem *right = d->currentLV->selectedItems().first();
         newRightIndex = d->currentLV->indexOfTopLevelItem(right);
         right->setSelected(false);
     }
     d->currentLV->insertTopLevelItem(newRightIndex, left);
     left->setSelected(true);
     enableDisableButtons(left);
     d->navTB[Private::Right]->setEnabled(next);
     if (next) {
         next->setSelected(true);
     }
     Q_EMIT changed();
 #endif
 }
 
 void Kleo::DNAttributeOrderConfigWidget::virtual_hook(int, void *) {}
 
diff --git a/src/ui/kdhorizontalline.cpp b/src/ui/kdhorizontalline.cpp
index 7e72c9746..3e12bda27 100644
--- a/src/ui/kdhorizontalline.cpp
+++ b/src/ui/kdhorizontalline.cpp
@@ -1,157 +1,157 @@
 /* -*- 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
 **
 **********************************************************************/
 
 #include "kdhorizontalline.h"
 
 #include <QStyle>
 #include <QPainter>
 #ifdef QT_ACCESSIBILITY_SUPPORT
 #include <QAccessible>
 #endif
 #include <QFontMetrics>
 #include <QApplication>
 #include <QPaintEvent>
 
 KDHorizontalLine::KDHorizontalLine(QWidget *parent, const char *name, Qt::WindowFlags f)
     : QFrame(parent, f),
       mAlign(Qt::AlignLeft),
       mLenVisible(0)
 {
     setObjectName(QLatin1String(name));
     QFrame::setFrameStyle(HLine | Sunken);
 }
 
 KDHorizontalLine::KDHorizontalLine(const QString &title, QWidget *parent, const char *name, Qt::WindowFlags f)
     : QFrame(parent, f),
       mAlign(Qt::AlignLeft),
       mLenVisible(0)
 {
     setObjectName(QLatin1String(name));
     QFrame::setFrameStyle(HLine | Sunken);
     setTitle(title);
 }
 
 KDHorizontalLine::~KDHorizontalLine() {}
 
 void KDHorizontalLine::setFrameStyle(int style)
 {
     QFrame::setFrameStyle((style & ~Shape_Mask) | HLine);     // force HLine
 }
 
 void KDHorizontalLine::setTitle(const QString &title)
 {
     if (mTitle == title) {
         return;
     }
     mTitle = title;
     calculateFrame();
     update();
     updateGeometry();
 #ifdef QT_ACCESSIBILITY_SUPPORT
     QAccessible::updateAccessibility(this, 0, QAccessible::NameChanged);
 #endif
 }
 
 void KDHorizontalLine::calculateFrame()
 {
     mLenVisible = mTitle.length();
 #if 0
     if (mLenVisible) {
         const QFontMetrics fm = fontMetrics();
         while (mLenVisible) {
             const int tw = fm.width(mTitle, mLenVisible) + 4 * fm.width(QChar(' '));
             if (tw < width()) {
                 break;
             }
             mLenVisible--;
         }
         qDebug("mLenVisible = %d (of %d)", mLenVisible, mTitle.length());
         if (mLenVisible) {   // but do we also have a visible label?
             QRect r = rect();
             const int va = style().styleHint(QStyle::SH_GroupBox_TextLabelVerticalAlignment, this);
             if (va & Qt::AlignVCenter) {
                 r.setTop(fm.height() / 2);    // frame rect should be
             } else if (va & Qt::AlignTop) {
                 r.setTop(fm.ascent());
             }
             setFrameRect(r);                          //   smaller than client rect
             return;
         }
     }
     // no visible label
     setFrameRect(QRect(0, 0, 0, 0));               //  then use client rect
 #endif
 }
 
 QSizePolicy KDHorizontalLine::sizePolicy() const
 {
-    return QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
+    return {QSizePolicy::Minimum, QSizePolicy::Fixed};
 }
 
 QSize KDHorizontalLine::sizeHint() const
 {
     return minimumSizeHint();
 }
 
 QSize KDHorizontalLine::minimumSizeHint() const
 {
     const int w = fontMetrics().width(mTitle, mLenVisible) +
                   fontMetrics().boundingRect(QLatin1Char(' ')).width();
     const int h = fontMetrics().height();
     return QSize(qMax(w, indentHint()), h).expandedTo(qApp->globalStrut());
 }
 
 void KDHorizontalLine::paintEvent(QPaintEvent *e)
 {
     QPainter paint(this);
 
     if (mLenVisible) {          // draw title
         const QFontMetrics &fm = paint.fontMetrics();
         const int h = fm.height();
         const int tw = fm.width(mTitle, mLenVisible) + fm.width(QLatin1Char(' '));
         int x;
         if (mAlign & Qt::AlignHCenter) {                // center alignment
             x = frameRect().width() / 2 - tw / 2;
         } else if (mAlign & Qt::AlignRight) {      // right alignment
             x = frameRect().width() - tw;
         } else if (mAlign & Qt::AlignLeft) {     // left alignment
             x = 0;
         } else { // auto align
             if (QApplication::isRightToLeft()) {
                 x = frameRect().width() - tw;
             } else {
                 x = 0;
             }
         }
         QRect r(x, 0, tw, h);
         int va = style()->styleHint(QStyle::SH_GroupBox_TextLabelVerticalAlignment, nullptr, this);
         if (va & Qt::AlignTop) {
             r.translate(0, fm.descent());
         }
         const QColor pen((QRgb) style()->styleHint(QStyle::SH_GroupBox_TextLabelColor, nullptr, this));
         if (!style()->styleHint(QStyle::SH_UnderlineShortcut, nullptr, this)) {
             va |= Qt::TextHideMnemonic;
         }
         style()->drawItemText(&paint, r, Qt::TextShowMnemonic | Qt::AlignHCenter | va, palette(),
                               isEnabled(), mTitle);
         paint.setClipRegion(e->region().subtracted(r));     // clip everything but title
     }
     drawFrame(&paint);
 }
 
 // static
 int KDHorizontalLine::indentHint()
 {
     return 30;
 }
 
diff --git a/src/ui/keyapprovaldialog.cpp b/src/ui/keyapprovaldialog.cpp
index 9d132f769..b185a22e7 100644
--- a/src/ui/keyapprovaldialog.cpp
+++ b/src/ui/keyapprovaldialog.cpp
@@ -1,197 +1,197 @@
 /*  -*- c++ -*-
     keyapprovaldialog.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.h
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keyapprovaldialog.h"
 
 #include "keyrequester.h"
 
 #include <KLocalizedString>
 #include <KSeparator>
 
 #include <QApplication>
 #include <QComboBox>
 #include <QDesktopWidget>
 #include <QDialogButtonBox>
 #include <QGridLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QScrollArea>
 #include <QStringList>
 #include <QVBoxLayout>
 
 #include <gpgme++/key.h>
 #include <qgpgme/protocol.h>
 
 static Kleo::EncryptionPreference cb2pref(int i)
 {
     switch (i) {
     default:
     case 0: return Kleo::UnknownPreference;
     case 1: return Kleo::NeverEncrypt;
     case 2: return Kleo::AlwaysEncrypt;
     case 3: return Kleo::AlwaysEncryptIfPossible;
     case 4: return Kleo::AlwaysAskForEncryption;
     case 5: return Kleo::AskWheneverPossible;
     }
 }
 
 static int pref2cb(Kleo::EncryptionPreference p)
 {
     switch (p) {
     default:                            return 0;
     case Kleo::NeverEncrypt:            return 1;
     case Kleo::AlwaysEncrypt:           return 2;
     case Kleo::AlwaysEncryptIfPossible: return 3;
     case Kleo::AlwaysAskForEncryption:  return 4;
     case Kleo::AskWheneverPossible:     return 5;
     }
 }
 
 static QStringList preferencesStrings()
 {
     return QStringList() << xi18n("<placeholder>none</placeholder>")
            << i18n("Never Encrypt with This Key")
            << i18n("Always Encrypt with This Key")
            << i18n("Encrypt Whenever Encryption is Possible")
            << i18n("Always Ask")
            << i18n("Ask Whenever Encryption is Possible");
 }
 
 class Q_DECL_HIDDEN Kleo::KeyApprovalDialog::Private
 {
 public:
     Private() {}
 
     Kleo::KeyRequester *selfRequester = nullptr;
     QStringList addresses;
     std::vector<Kleo::KeyRequester *> requesters;
     std::vector<QComboBox *> preferences;
     bool prefsChanged = false;
 };
 
 Kleo::KeyApprovalDialog::KeyApprovalDialog(const std::vector<Item> &recipients,
         const std::vector<GpgME::Key> &sender,
         QWidget *parent)
     : QDialog(parent),
       d(new Private())
 {
     setWindowTitle(i18nc("@title:window", "Encryption Key Approval"));
-    QVBoxLayout *mainLayout = new QVBoxLayout(this);
+    auto *mainLayout = new QVBoxLayout(this);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &KeyApprovalDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KeyApprovalDialog::reject);
     okButton->setDefault(true);
     Q_ASSERT(!recipients.empty());
 
     QFrame *page = new QFrame(this);
     mainLayout->addWidget(page);
     mainLayout->addWidget(buttonBox);
-    QVBoxLayout *vlay = new QVBoxLayout(page);
+    auto *vlay = new QVBoxLayout(page);
     vlay->setContentsMargins(0, 0, 0, 0);
 
     vlay->addWidget(new QLabel(i18n("The following keys will be used for encryption:"), page));
 
-    QScrollArea *sv = new QScrollArea(page);
+    auto *sv = new QScrollArea(page);
     sv->setWidgetResizable(true);
     vlay->addWidget(sv);
 
     QWidget *view = new QWidget(sv->viewport());
 
-    QGridLayout *glay = new QGridLayout(view);
+    auto *glay = new QGridLayout(view);
     glay->setColumnStretch(1, 1);
     sv->setWidget(view);
 
     int row = -1;
 
     if (!sender.empty()) {
         ++row;
         glay->addWidget(new QLabel(i18n("Your keys:"), view), row, 0);
         d->selfRequester = new EncryptionKeyRequester(true, EncryptionKeyRequester::AllProtocols, view);
         d->selfRequester->setKeys(sender);
         glay->addWidget(d->selfRequester, row, 1);
         ++row;
         glay->addWidget(new KSeparator(Qt::Horizontal, view), row, 0, 1, 2);
     }
 
     const QStringList prefs = preferencesStrings();
 
-    for (std::vector<Item>::const_iterator it = recipients.begin(); it != recipients.end(); ++it) {
+    for (auto it = recipients.begin(); it != recipients.end(); ++it) {
         ++row;
         glay->addWidget(new QLabel(i18n("Recipient:"), view), row, 0);
         glay->addWidget(new QLabel(it->address, view), row, 1);
         d->addresses.push_back(it->address);
 
         ++row;
         glay->addWidget(new QLabel(i18n("Encryption keys:"), view), row, 0);
         KeyRequester *req = new EncryptionKeyRequester(true, EncryptionKeyRequester::AllProtocols, view);
         req->setKeys(it->keys);
         glay->addWidget(req, row, 1);
         d->requesters.push_back(req);
 
         ++row;
         glay->addWidget(new QLabel(i18n("Encryption preference:"), view), row, 0);
-        QComboBox *cb = new QComboBox(view);
+        auto *cb = new QComboBox(view);
         cb->setEditable(false);
         cb->addItems(prefs);
         glay->addWidget(cb, row, 1);
         cb->setCurrentIndex(pref2cb(it->pref));
         connect(cb, QOverload<int>::of(&QComboBox::activated), this, &KeyApprovalDialog::slotPrefsChanged);
         d->preferences.push_back(cb);
     }
 
     QSize size = sizeHint();
 
     // don't make the dialog too large
     const QRect desk = QApplication::desktop()->screenGeometry(this);
     resize(QSize(qMin(size.width(), 3 * desk.width() / 4),
                  qMin(size.height(), 7 * desk.height() / 8)));
 }
 
 Kleo::KeyApprovalDialog::~KeyApprovalDialog()
 {
     delete d;
 }
 
 std::vector<GpgME::Key> Kleo::KeyApprovalDialog::senderKeys() const
 {
     return d->selfRequester ? d->selfRequester->keys() : std::vector<GpgME::Key>();
 }
 
 std::vector<Kleo::KeyApprovalDialog::Item> Kleo::KeyApprovalDialog::items() const
 {
     Q_ASSERT(d->requesters.size() == static_cast<unsigned int>(d->addresses.size()));
     Q_ASSERT(d->requesters.size() == d->preferences.size());
 
     std::vector<Item> result;
     result.reserve(d->requesters.size());
     QStringList::const_iterator ait = d->addresses.constBegin();
-    std::vector<KeyRequester *>::iterator rit = d->requesters.begin();
-    std::vector<QComboBox *>::iterator cit = d->preferences.begin();
+    auto rit = d->requesters.begin();
+    auto cit = d->preferences.begin();
     while (ait != d->addresses.constEnd()) {
         result.push_back(Item(*ait++, (*rit++)->keys(), cb2pref((*cit++)->currentIndex())));
     }
     return result;
 }
 
 bool Kleo::KeyApprovalDialog::preferencesChanged() const
 {
     return d->prefsChanged;
 }
 
 void Kleo::KeyApprovalDialog::slotPrefsChanged()
 {
     d->prefsChanged = true;
 }
 
diff --git a/src/ui/keylistview.cpp b/src/ui/keylistview.cpp
index 83f98fbfd..255689266 100644
--- a/src/ui/keylistview.cpp
+++ b/src/ui/keylistview.cpp
@@ -1,551 +1,551 @@
 /*
     keylistview.cpp
 
     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
 */
 
 #include "keylistview.h"
 
 #include "kleo_ui_debug.h"
 
 #include <QFontMetrics>
 #include <QToolTip>
 #include <QPoint>
 #include <QFont>
 #include <QColor>
 #include <QTimer>
 #include <gpgme++/key.h>
 
 #include <vector>
 #include <map>
 
 #include <QKeyEvent>
 
 static const int updateDelayMilliSecs = 500;
 
 class Q_DECL_HIDDEN Kleo::KeyListView::Private
 {
 public:
     Private() : updateTimer(nullptr) {}
 
     std::vector<GpgME::Key> keyBuffer;
     QTimer *updateTimer = nullptr;
     std::map<QByteArray, KeyListViewItem *> itemMap;
 };
 
 // a list of signals where we want to replace QListViewItem with
 // Kleo:KeyListViewItem:
 static const struct {
     const char *source;
     const char *target;
 } signalReplacements[] = {
     {
         SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),
         SLOT(slotEmitDoubleClicked(QTreeWidgetItem*,int))
     },
     {
         SIGNAL(itemSelectionChanged()),
         SLOT(slotEmitSelectionChanged())
     },
     {
         SIGNAL(customContextMenuRequested(QPoint)),
         SLOT(slotEmitContextMenu(QPoint))
     },
 };
 static const int numSignalReplacements = sizeof signalReplacements / sizeof * signalReplacements;
 
 Kleo::KeyListView::KeyListView(const ColumnStrategy *columnStrategy, const DisplayStrategy *displayStrategy, QWidget *parent, Qt::WindowFlags f)
     : QTreeWidget(parent),
       mColumnStrategy(columnStrategy),
       mDisplayStrategy(displayStrategy),
       mHierarchical(false), d(new Private())
 {
     setWindowFlags(f);
     setContextMenuPolicy(Qt::CustomContextMenu);
 
     d->updateTimer = new QTimer(this);
     d->updateTimer->setSingleShot(true);
     connect(d->updateTimer, &QTimer::timeout, this, &KeyListView::slotUpdateTimeout);
     if (!columnStrategy) {
         qCWarning(KLEO_UI_LOG) << "Kleo::KeyListView: need a column strategy to work with!";
         return;
     }
 
     const QFontMetrics fm = fontMetrics();
 
     for (int col = 0; !columnStrategy->title(col).isEmpty(); ++col) {
         headerItem()->setText(col, columnStrategy->title(col));
         header()->resizeSection(col, columnStrategy->width(col, fm));
         header()->setSectionResizeMode(col, columnStrategy->resizeMode(col));
     }
 
     setAllColumnsShowFocus(true);
 
     for (int i = 0; i < numSignalReplacements; ++i) {
         connect(this, signalReplacements[i].source, signalReplacements[i].target);
     }
 
     this->setToolTip(QString());
     viewport()->setToolTip(QString()); // make double sure :)
 }
 
 Kleo::KeyListView::~KeyListView()
 {
     d->updateTimer->stop();
     // need to clear here, since in ~QListView, our children won't have
     // a valid listView() pointing to us anymore, and their dtors try to
     // unregister from us.
     clear();
     Q_ASSERT(d->itemMap.size() == 0);
     // need to delete the tooltip ourselves, as ~QToolTip isn't virtual :o
     delete d;
     delete mColumnStrategy; mColumnStrategy = nullptr;
     delete mDisplayStrategy; mDisplayStrategy = nullptr;
 }
 
 void Kleo::KeyListView::takeItem(QTreeWidgetItem *qlvi)
 {
     //qCDebug(KLEO_UI_LOG) <<"Kleo::KeyListView::takeItem(" << qlvi <<" )";
-    if (KeyListViewItem *item = lvi_cast<KeyListViewItem>(qlvi)) {
+    if (auto *item = lvi_cast<KeyListViewItem>(qlvi)) {
         deregisterItem(item);
     }
     takeTopLevelItem(indexOfTopLevelItem(qlvi));
 }
 
 void Kleo::KeyListView::setHierarchical(bool hier)
 {
     if (hier == mHierarchical) {
         return;
     }
     mHierarchical = hier;
     if (hier) {
         gatherScattered();
     } else {
         scatterGathered(firstChild());
     }
 }
 
 void Kleo::KeyListView::slotAddKey(const GpgME::Key &key)
 {
     if (key.isNull()) {
         return;
     }
 
     d->keyBuffer.push_back(key);
     if (!d->updateTimer->isActive()) {
         d->updateTimer->start(updateDelayMilliSecs);
     }
 }
 
 void Kleo::KeyListView::slotUpdateTimeout()
 {
     if (d->keyBuffer.empty()) {
         return;
     }
 
     const bool wasUpdatesEnabled = viewport()->updatesEnabled();
     if (wasUpdatesEnabled) {
         viewport()->setUpdatesEnabled(false);
     }
     qCDebug(KLEO_UI_LOG) << "Kleo::KeyListView::slotUpdateTimeout(): processing"
                          << d->keyBuffer.size() << "items en block";
     if (hierarchical()) {
         for (std::vector<GpgME::Key>::const_iterator it = d->keyBuffer.begin(); it != d->keyBuffer.end(); ++it) {
             doHierarchicalInsert(*it);
         }
         gatherScattered();
     } else {
         for (std::vector<GpgME::Key>::const_iterator it = d->keyBuffer.begin(); it != d->keyBuffer.end(); ++it) {
             (void)new KeyListViewItem(this, *it);
         }
     }
     if (wasUpdatesEnabled) {
         viewport()->setUpdatesEnabled(true);
     }
     d->keyBuffer.clear();
 }
 
 void Kleo::KeyListView::clear()
 {
     d->updateTimer->stop();
     d->keyBuffer.clear();
     while (QTreeWidgetItem *item = topLevelItem(0)) {
         delete item;
     }
     QTreeWidget::clear();
 }
 
 void Kleo::KeyListView::registerItem(KeyListViewItem *item)
 {
     //qCDebug(KLEO_UI_LOG) <<"registerItem(" << item <<" )";
     if (!item) {
         return;
     }
     const QByteArray fpr = item->key().primaryFingerprint();
     if (!fpr.isEmpty()) {
         d->itemMap.insert(std::make_pair(fpr, item));
     }
 }
 
 void Kleo::KeyListView::deregisterItem(const KeyListViewItem *item)
 {
     //qCDebug(KLEO_UI_LOG) <<"deregisterItem( KeyLVI:" << item <<" )";
     if (!item) {
         return;
     }
-    std::map<QByteArray, KeyListViewItem *>::iterator it
+    auto it
         = d->itemMap.find(item->key().primaryFingerprint());
     if (it == d->itemMap.end()) {
         return;
     }
     // This Q_ASSERT triggers, though it shouldn't. Print some more
     // information when it happens.
     //Q_ASSERT( it->second == item );
     if (it->second != item) {
         qCWarning(KLEO_UI_LOG) << "deregisterItem:"
                                << "item      " << item->key().primaryFingerprint()
                                << "it->second" << (it->second ? it->second->key().primaryFingerprint() : "is null");
         return;
     }
     d->itemMap.erase(it);
 }
 
 void Kleo::KeyListView::doHierarchicalInsert(const GpgME::Key &key)
 {
     const QByteArray fpr = key.primaryFingerprint();
     if (fpr.isEmpty()) {
         return;
     }
     KeyListViewItem *item = nullptr;
     if (!key.isRoot())
         if (KeyListViewItem *parent = itemByFingerprint(key.chainID())) {
             item = new KeyListViewItem(parent, key);
             parent->setExpanded(true);
         }
     if (!item) {
         item = new KeyListViewItem(this, key);    // top-level (for now)
     }
 
     d->itemMap.insert(std::make_pair(fpr, item));
 }
 
 void Kleo::KeyListView::gatherScattered()
 {
     KeyListViewItem *item = firstChild();
     while (item) {
         KeyListViewItem *cur = item;
         item = item->nextSibling();
         if (cur->key().isRoot()) {
             continue;
         }
         if (KeyListViewItem *parent = itemByFingerprint(cur->key().chainID())) {
             // found a new parent...
             // ### todo: optimize by suppressing removing/adding the item to the itemMap...
             takeTopLevelItem(indexOfTopLevelItem(cur));
             parent->addChild(cur);
             parent->setExpanded(true);
         }
     }
 }
 
 void Kleo::KeyListView::scatterGathered(KeyListViewItem *start)
 {
     KeyListViewItem *item = start;
     while (item) {
         KeyListViewItem *cur = item;
         item = item->nextSibling();
 
         scatterGathered(Kleo::lvi_cast<Kleo::KeyListViewItem>(cur->child(0)));
         Q_ASSERT(cur->childCount() == 0);
 
         // ### todo: optimize by suppressing removing/adding the item to the itemMap...
         if (cur->parent()) {
             static_cast<Kleo::KeyListViewItem *>(cur->parent())->takeItem(cur);
         } else {
             takeItem(cur);
         }
         addTopLevelItem(cur);
     }
 }
 
 Kleo::KeyListViewItem *Kleo::KeyListView::itemByFingerprint(const QByteArray &s) const
 {
     if (s.isEmpty()) {
         return nullptr;
     }
     const std::map<QByteArray, KeyListViewItem *>::const_iterator it = d->itemMap.find(s);
     if (it == d->itemMap.end()) {
         return nullptr;
     }
     return it->second;
 }
 
 void Kleo::KeyListView::slotRefreshKey(const GpgME::Key &key)
 {
     const char *fpr = key.primaryFingerprint();
     if (!fpr) {
         return;
     }
     if (KeyListViewItem *item = itemByFingerprint(fpr)) {
         item->setKey(key);
     } else
         // none found -> add it
     {
         slotAddKey(key);
     }
 }
 
 // slots for the emission of covariant Q_SIGNALS:
 
 void Kleo::KeyListView::slotEmitDoubleClicked(QTreeWidgetItem *item, int col)
 {
     if (!item || lvi_cast<KeyListViewItem>(item)) {
         Q_EMIT doubleClicked(static_cast<KeyListViewItem *>(item), col);
     }
 }
 
 void Kleo::KeyListView::slotEmitReturnPressed(QTreeWidgetItem *item)
 {
     if (!item || lvi_cast<KeyListViewItem>(item)) {
         Q_EMIT returnPressed(static_cast<KeyListViewItem *>(item));
     }
 }
 
 void Kleo::KeyListView::slotEmitSelectionChanged()
 {
     Q_EMIT selectionChanged(selectedItem());
 }
 
 void Kleo::KeyListView::slotEmitContextMenu(const QPoint &pos)
 {
     QTreeWidgetItem *item = itemAt(pos);
     if (!item || lvi_cast<KeyListViewItem>(item)) {
         Q_EMIT contextMenu(static_cast<KeyListViewItem *>(item), viewport()->mapToGlobal(pos));
     }
 }
 
 //
 //
 // KeyListViewItem
 //
 //
 
 Kleo::KeyListViewItem::KeyListViewItem(KeyListView *parent, const GpgME::Key &key)
     : QTreeWidgetItem(parent, RTTI)
 {
     Q_ASSERT(parent);
     setKey(key);
 }
 
 Kleo::KeyListViewItem::KeyListViewItem(KeyListView *parent, KeyListViewItem *after, const GpgME::Key &key)
     : QTreeWidgetItem(parent, after, RTTI)
 {
     Q_ASSERT(parent);
     setKey(key);
 }
 
 Kleo::KeyListViewItem::KeyListViewItem(KeyListViewItem *parent, const GpgME::Key &key)
     : QTreeWidgetItem(parent, RTTI)
 {
     Q_ASSERT(parent && parent->listView());
     setKey(key);
 }
 
 Kleo::KeyListViewItem::KeyListViewItem(KeyListViewItem *parent, KeyListViewItem *after, const GpgME::Key &key)
     : QTreeWidgetItem(parent, after, RTTI)
 {
     Q_ASSERT(parent && parent->listView());
     setKey(key);
 }
 
 Kleo::KeyListViewItem::~KeyListViewItem()
 {
     // delete the children first... When children are deleted in the
     // QLVI dtor, they don't have listView() anymore, thus they don't
     // call deregister( this ), leading to stale entries in the
     // itemMap...
     while (QTreeWidgetItem *item = child(0)) {
         delete item;
     }
     // better do this here, too, since deletion is top-down and thus
     // we're deleted when our parent item is no longer a
     // KeyListViewItem, but a mere QListViewItem, so our takeItem()
     // overload is gone by that time...
     if (KeyListView *lv = listView()) {
         lv->deregisterItem(this);
     }
 }
 
 void Kleo::KeyListViewItem::setKey(const GpgME::Key &key)
 {
     KeyListView *lv = listView();
     if (lv) {
         lv->deregisterItem(this);
     }
     mKey = key;
     if (lv) {
         lv->registerItem(this);
     }
 
     // the ColumnStrategy operations might be very slow, so cache their
     // result here, where we're non-const :)
     const Kleo::KeyListView::ColumnStrategy *cs = lv ? lv->columnStrategy() : nullptr;
     if (!cs) {
         return;
     }
     const KeyListView::DisplayStrategy *ds = lv->displayStrategy();
     const int numCols = lv ? lv->columnCount() : 0;
     for (int i = 0; i < numCols; ++i) {
         setText(i, cs->text(key, i));
         setToolTip(i, cs->toolTip(key, i));
         const QIcon icon = cs->icon(key, i);
         if (!icon.isNull()) {
             setIcon(i, icon);
         }
         if (ds) {
             setForeground(i, QBrush(ds->keyForeground(key, foreground(i).color())));
             setBackgroundColor(i, ds->keyBackground(key, backgroundColor(i)));
             setFont(i, ds->keyFont(key, font(i)));
         }
     }
 }
 
 QString Kleo::KeyListViewItem::toolTip(int col) const
 {
     return listView() && listView()->columnStrategy()
            ? listView()->columnStrategy()->toolTip(key(), col)
            : QString();
 }
 
 bool Kleo::KeyListViewItem::operator<(const QTreeWidgetItem &other) const
 {
     if (other.type() != RTTI || !listView() || !listView()->columnStrategy()) {
         return QTreeWidgetItem::operator<(other);
     }
-    const KeyListViewItem *that = static_cast<const KeyListViewItem *>(&other);
+    const auto *that = static_cast<const KeyListViewItem *>(&other);
     return listView()->columnStrategy()->compare(this->key(), that->key(), treeWidget()->sortColumn()) < 0;
 }
 
 void Kleo::KeyListViewItem::takeItem(QTreeWidgetItem *qlvi)
 {
     //qCDebug(KLEO_UI_LOG) <<"Kleo::KeyListViewItem::takeItem(" << qlvi <<" )";
-    if (KeyListViewItem *item = lvi_cast<KeyListViewItem>(qlvi)) {
+    if (auto *item = lvi_cast<KeyListViewItem>(qlvi)) {
         listView()->deregisterItem(item);
     }
     takeChild(indexOfChild(qlvi));
 }
 
 //
 //
 // ColumnStrategy
 //
 //
 
 Kleo::KeyListView::ColumnStrategy::~ColumnStrategy() {}
 
 int Kleo::KeyListView::ColumnStrategy::compare(const GpgME::Key &key1, const GpgME::Key &key2, const int col) const
 {
     return QString::localeAwareCompare(text(key1, col), text(key2, col));
 }
 
 int Kleo::KeyListView::ColumnStrategy::width(int col, const QFontMetrics &fm) const
 {
     return fm.width(title(col)) * 2;
 }
 
 QString Kleo::KeyListView::ColumnStrategy::toolTip(const GpgME::Key &key, int col) const
 {
     return text(key, col);
 }
 
 //
 //
 // DisplayStrategy
 //
 //
 
 Kleo::KeyListView::DisplayStrategy::~DisplayStrategy() {}
 
 //font
 QFont Kleo::KeyListView::DisplayStrategy::keyFont(const GpgME::Key &, const QFont &font) const
 {
     return font;
 }
 
 //foreground
 QColor Kleo::KeyListView::DisplayStrategy::keyForeground(const GpgME::Key &, const QColor &fg)const
 {
     return fg;
 }
 
 //background
 QColor Kleo::KeyListView::DisplayStrategy::keyBackground(const GpgME::Key &, const QColor &bg)const
 {
     return bg;
 }
 
 //
 //
 // Collection of covariant return reimplementations of QListView(Item)
 // members:
 //
 //
 
 Kleo::KeyListView *Kleo::KeyListViewItem::listView() const
 {
     return static_cast<Kleo::KeyListView *>(QTreeWidgetItem::treeWidget());
 }
 
 Kleo::KeyListViewItem *Kleo::KeyListViewItem::nextSibling() const
 {
     if (parent()) {
         const int myIndex = parent()->indexOfChild(const_cast<KeyListViewItem *>(this));
         return static_cast<Kleo::KeyListViewItem *>(parent()->child(myIndex + 1));
     }
     const int myIndex = treeWidget()->indexOfTopLevelItem(const_cast<KeyListViewItem *>(this));
     return static_cast<Kleo::KeyListViewItem *>(treeWidget()->topLevelItem(myIndex + 1));
 }
 
 Kleo::KeyListViewItem *Kleo::KeyListView::firstChild() const
 {
     return static_cast<Kleo::KeyListViewItem *>(topLevelItem(0));
 }
 
 Kleo::KeyListViewItem *Kleo::KeyListView::selectedItem() const
 {
     QList<KeyListViewItem *> selection = selectedItems();
     if (selection.isEmpty()) {
         return nullptr;
     }
     return selection.first();
 }
 
 QList<Kleo::KeyListViewItem *> Kleo::KeyListView::selectedItems() const
 {
     QList<KeyListViewItem *> result;
     foreach (QTreeWidgetItem *selectedItem, QTreeWidget::selectedItems()) {
-        if (Kleo::KeyListViewItem *i = Kleo::lvi_cast<Kleo::KeyListViewItem>(selectedItem)) {
+        if (auto *i = Kleo::lvi_cast<Kleo::KeyListViewItem>(selectedItem)) {
             result.append(i);
         }
     }
     return result;
 }
 
 bool Kleo::KeyListView::isMultiSelection() const
 {
     return selectionMode() == ExtendedSelection || selectionMode() == MultiSelection;
 }
 
 void Kleo::KeyListView::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) {
         if (selectedItem()) {
             slotEmitReturnPressed(selectedItem());
         }
     }
     QTreeView::keyPressEvent(event);
 }
 
diff --git a/src/ui/keyrequester.cpp b/src/ui/keyrequester.cpp
index b3f351c8b..73d9461c3 100644
--- a/src/ui/keyrequester.cpp
+++ b/src/ui/keyrequester.cpp
@@ -1,490 +1,490 @@
 /*  -*- c++ -*-
     keyrequester.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.cpp
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     This file is part of KPGP, the KDE PGP/GnuPG support library.
 
     SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "keyrequester.h"
 
 #include "keyselectiondialog.h"
 
 #include "libkleo/dn.h"
 
 // gpgme++
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <qgpgme/keylistjob.h>
 
 // KDE
 #include <KLocalizedString>
 #include <QDialog>
 #include <KMessageBox>
 #include <QPushButton>
 
 // Qt
 #include <QApplication>
 
 #include <QString>
 #include <QStringList>
 
 #include <QHBoxLayout>
 
 
 using namespace QGpgME;
 
 Kleo::KeyRequester::KeyRequester(unsigned int allowedKeys, bool multipleKeys,
                                  QWidget *parent)
     : QWidget(parent),
       mOpenPGPBackend(nullptr),
       mSMIMEBackend(nullptr),
       mMulti(multipleKeys),
       mKeyUsage(allowedKeys),
       mJobs(0),
       d(nullptr)
 {
     init();
 }
 
 Kleo::KeyRequester::KeyRequester(QWidget *parent)
     : QWidget(parent),
       mOpenPGPBackend(nullptr),
       mSMIMEBackend(nullptr),
       mMulti(false),
       mKeyUsage(0),
       mJobs(0),
       d(nullptr)
 {
     init();
 }
 
 void Kleo::KeyRequester::init()
 {
-    QHBoxLayout *hlay = new QHBoxLayout(this);
+    auto *hlay = new QHBoxLayout(this);
     hlay->setContentsMargins(0, 0, 0, 0);
 
     // the label where the key id is to be displayed:
     mLabel = new QLabel(this);
     mLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
 
     // the button to unset any key:
     mEraseButton = new QPushButton(this);
     mEraseButton->setAutoDefault(false);
     mEraseButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
                                             QSizePolicy::Minimum));
     mEraseButton->setIcon(QIcon::fromTheme(QApplication::isRightToLeft() ? QStringLiteral("edit-clear-locationbar-ltr") : QStringLiteral("edit-clear-locationbar-rtl")));
     mEraseButton->setToolTip(i18n("Clear"));
 
     // the button to call the KeySelectionDialog:
     mDialogButton = new QPushButton(i18n("Change..."), this);
     mDialogButton->setAutoDefault(false);
 
     hlay->addWidget(mLabel, 1);
     hlay->addWidget(mEraseButton);
     hlay->addWidget(mDialogButton);
 
     connect(mEraseButton, &QPushButton::clicked, this, &SigningKeyRequester::slotEraseButtonClicked);
     connect(mDialogButton, &QPushButton::clicked, this, &SigningKeyRequester::slotDialogButtonClicked);
 
     setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,
                               QSizePolicy::Fixed));
 
     setAllowedKeys(mKeyUsage);
 }
 
 Kleo::KeyRequester::~KeyRequester()
 {
 
 }
 
 const std::vector<GpgME::Key> &Kleo::KeyRequester::keys() const
 {
     return mKeys;
 }
 
 const GpgME::Key &Kleo::KeyRequester::key() const
 {
     static const GpgME::Key null = GpgME::Key::null;
     if (mKeys.empty()) {
         return null;
     } else {
         return mKeys.front();
     }
 }
 
 void Kleo::KeyRequester::setKeys(const std::vector<GpgME::Key> &keys)
 {
     mKeys.clear();
-    for (std::vector<GpgME::Key>::const_iterator it = keys.begin(); it != keys.end(); ++it)
+    for (auto it = keys.begin(); it != keys.end(); ++it)
         if (!it->isNull()) {
             mKeys.push_back(*it);
         }
     updateKeys();
 }
 
 void Kleo::KeyRequester::setKey(const GpgME::Key &key)
 {
     mKeys.clear();
     if (!key.isNull()) {
         mKeys.push_back(key);
     }
     updateKeys();
 }
 
 QString Kleo::KeyRequester::fingerprint() const
 {
     if (mKeys.empty()) {
         return QString();
     } else {
         return QLatin1String(mKeys.front().primaryFingerprint());
     }
 }
 
 QStringList Kleo::KeyRequester::fingerprints() const
 {
     QStringList result;
-    for (std::vector<GpgME::Key>::const_iterator it = mKeys.begin(); it != mKeys.end(); ++it)
+    for (auto it = mKeys.begin(); it != mKeys.end(); ++it)
         if (!it->isNull())
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
     return result;
 }
 
 void Kleo::KeyRequester::setFingerprint(const QString &fingerprint)
 {
     startKeyListJob(QStringList(fingerprint));
 }
 
 void Kleo::KeyRequester::setFingerprints(const QStringList &fingerprints)
 {
     startKeyListJob(fingerprints);
 }
 
 void Kleo::KeyRequester::updateKeys()
 {
     if (mKeys.empty()) {
         mLabel->clear();
         return;
     }
     if (mKeys.size() > 1) {
         setMultipleKeysEnabled(true);
     }
 
     QStringList labelTexts;
     QString toolTipText;
     for (std::vector<GpgME::Key>::const_iterator it = mKeys.begin(); it != mKeys.end(); ++it) {
         if (it->isNull()) {
             continue;
         }
         const QString fpr = QLatin1String(it->primaryFingerprint());
         labelTexts.push_back(fpr.right(8));
         toolTipText += fpr.right(8) + QLatin1String(": ");
         if (const char *uid = it->userID(0).id())
             if (it->protocol() == GpgME::OpenPGP) {
                 toolTipText += QString::fromUtf8(uid);
             } else {
                 toolTipText += Kleo::DN(uid).prettyDN();
             }
         else {
             toolTipText += xi18n("<placeholder>unknown</placeholder>");
         }
         toolTipText += QLatin1Char('\n');
     }
 
     mLabel->setText(labelTexts.join(QLatin1String(", ")));
     mLabel->setToolTip(toolTipText);
 }
 
 #ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 #define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 static void showKeyListError(QWidget *parent, const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n("<qt><p>An error occurred while fetching "
                              "the keys from the backend:</p>"
                              "<p><b>%1</b></p></qt>",
                              QString::fromLocal8Bit(err.asString()));
 
     KMessageBox::error(parent, msg, i18n("Key Listing Failed"));
 }
 #endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 
 void Kleo::KeyRequester::startKeyListJob(const QStringList &fingerprints)
 {
     if (!mSMIMEBackend && !mOpenPGPBackend) {
         return;
     }
 
     mTmpKeys.clear();
     mJobs = 0;
 
     unsigned int count = 0;
     for (QStringList::const_iterator it = fingerprints.begin(); it != fingerprints.end(); ++it)
         if (!(*it).trimmed().isEmpty()) {
             ++count;
         }
 
     if (!count) {
         // don't fall into the trap that an empty pattern means
         // "return all keys" :)
         setKey(GpgME::Key::null);
         return;
     }
 
     if (mOpenPGPBackend) {
         KeyListJob *job = mOpenPGPBackend->keyListJob(false);    // local, no sigs
         if (!job) {
             KMessageBox::error(this,
                                i18n("The OpenPGP backend does not support listing keys. "
                                     "Check your installation."),
                                i18n("Key Listing Failed"));
         } else {
             connect(job, &KeyListJob::result, this, &SigningKeyRequester::slotKeyListResult);
             connect(job, &KeyListJob::nextKey, this, &SigningKeyRequester::slotNextKey);
 
             const GpgME::Error err = job->start(fingerprints,
                                                 mKeyUsage & Kleo::KeySelectionDialog::SecretKeys &&
                                                 !(mKeyUsage & Kleo::KeySelectionDialog::PublicKeys));
 
             if (err) {
                 showKeyListError(this, err);
             } else {
                 ++mJobs;
             }
         }
     }
 
     if (mSMIMEBackend) {
         KeyListJob *job = mSMIMEBackend->keyListJob(false);    // local, no sigs
         if (!job) {
             KMessageBox::error(this,
                                i18n("The S/MIME backend does not support listing keys. "
                                     "Check your installation."),
                                i18n("Key Listing Failed"));
         } else {
             connect(job, &KeyListJob::result, this, &SigningKeyRequester::slotKeyListResult);
             connect(job, &KeyListJob::nextKey, this, &SigningKeyRequester::slotNextKey);
 
             const GpgME::Error err = job->start(fingerprints,
                                                 mKeyUsage & Kleo::KeySelectionDialog::SecretKeys &&
                                                 !(mKeyUsage & Kleo::KeySelectionDialog::PublicKeys));
 
             if (err) {
                 showKeyListError(this, err);
             } else {
                 ++mJobs;
             }
         }
     }
 
     if (mJobs > 0) {
         mEraseButton->setEnabled(false);
         mDialogButton->setEnabled(false);
     }
 }
 
 void Kleo::KeyRequester::slotNextKey(const GpgME::Key &key)
 {
     if (!key.isNull()) {
         mTmpKeys.push_back(key);
     }
 }
 
 void Kleo::KeyRequester::slotKeyListResult(const GpgME::KeyListResult &res)
 {
     if (res.error()) {
         showKeyListError(this, res.error());
     }
 
     if (--mJobs <= 0) {
         mEraseButton->setEnabled(true);
         mDialogButton->setEnabled(true);
 
         setKeys(mTmpKeys);
         mTmpKeys.clear();
     }
 }
 
 void Kleo::KeyRequester::slotDialogButtonClicked()
 {
     KeySelectionDialog *dlg = mKeys.empty()
                               ? new KeySelectionDialog(mDialogCaption, mDialogMessage, mInitialQuery, mKeyUsage, mMulti, false, this)
                               : new KeySelectionDialog(mDialogCaption, mDialogCaption, mKeys, mKeyUsage, mMulti, false, this);
 
     if (dlg->exec() == QDialog::Accepted) {
         if (mMulti) {
             setKeys(dlg->selectedKeys());
         } else {
             setKey(dlg->selectedKey());
         }
         Q_EMIT changed();
     }
 
     delete dlg;
 }
 
 void Kleo::KeyRequester::slotEraseButtonClicked()
 {
     if (!mKeys.empty()) {
         Q_EMIT changed();
     }
     mKeys.clear();
     updateKeys();
 }
 
 void Kleo::KeyRequester::setDialogCaption(const QString &caption)
 {
     mDialogCaption = caption;
 }
 
 void Kleo::KeyRequester::setDialogMessage(const QString &msg)
 {
     mDialogMessage = msg;
 }
 
 bool Kleo::KeyRequester::isMultipleKeysEnabled() const
 {
     return mMulti;
 }
 
 void Kleo::KeyRequester::setMultipleKeysEnabled(bool multi)
 {
     if (multi == mMulti) {
         return;
     }
 
     if (!multi && !mKeys.empty()) {
         mKeys.erase(mKeys.begin() + 1, mKeys.end());
     }
 
     mMulti = multi;
     updateKeys();
 }
 
 unsigned int Kleo::KeyRequester::allowedKeys() const
 {
     return mKeyUsage;
 }
 
 void Kleo::KeyRequester::setAllowedKeys(unsigned int keyUsage)
 {
     mKeyUsage = keyUsage;
     mOpenPGPBackend = nullptr;
     mSMIMEBackend = nullptr;
 
     if (mKeyUsage & KeySelectionDialog::OpenPGPKeys) {
         mOpenPGPBackend = openpgp();
     }
     if (mKeyUsage & KeySelectionDialog::SMIMEKeys) {
         mSMIMEBackend = smime();
     }
 
     if (mOpenPGPBackend && !mSMIMEBackend) {
         mDialogCaption = i18n("OpenPGP Key Selection");
         mDialogMessage = i18n("Please select an OpenPGP key to use.");
     } else if (!mOpenPGPBackend && mSMIMEBackend) {
         mDialogCaption = i18n("S/MIME Key Selection");
         mDialogMessage = i18n("Please select an S/MIME key to use.");
     } else {
         mDialogCaption = i18n("Key Selection");
         mDialogMessage = i18n("Please select an (OpenPGP or S/MIME) key to use.");
     }
 }
 
 QPushButton *Kleo::KeyRequester::dialogButton()
 {
     return mDialogButton;
 }
 
 QPushButton *Kleo::KeyRequester::eraseButton()
 {
     return mEraseButton;
 }
 
 static inline unsigned int foo(bool openpgp, bool smime, bool trusted, bool valid)
 {
     unsigned int result = 0;
     if (openpgp) {
         result |= Kleo::KeySelectionDialog::OpenPGPKeys;
     }
     if (smime) {
         result |= Kleo::KeySelectionDialog::SMIMEKeys;
     }
     if (trusted) {
         result |= Kleo::KeySelectionDialog::TrustedKeys;
     }
     if (valid) {
         result |= Kleo::KeySelectionDialog::ValidKeys;
     }
     return result;
 }
 
 static inline unsigned int encryptionKeyUsage(bool openpgp, bool smime, bool trusted, bool valid)
 {
     return foo(openpgp, smime, trusted, valid) | Kleo::KeySelectionDialog::EncryptionKeys | Kleo::KeySelectionDialog::PublicKeys;
 }
 
 static inline unsigned int signingKeyUsage(bool openpgp, bool smime, bool trusted, bool valid)
 {
     return foo(openpgp, smime, trusted, valid) | Kleo::KeySelectionDialog::SigningKeys | Kleo::KeySelectionDialog::SecretKeys;
 }
 
 Kleo::EncryptionKeyRequester::EncryptionKeyRequester(bool multi, unsigned int proto,
         QWidget *parent,
         bool onlyTrusted, bool onlyValid)
     : KeyRequester(encryptionKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid), multi,
                    parent), d(nullptr)
 {
 }
 
 Kleo::EncryptionKeyRequester::EncryptionKeyRequester(QWidget *parent)
     : KeyRequester(0, false, parent), d(nullptr)
 {
 }
 
 Kleo::EncryptionKeyRequester::~EncryptionKeyRequester() {}
 
 void Kleo::EncryptionKeyRequester::setAllowedKeys(unsigned int proto, bool onlyTrusted, bool onlyValid)
 {
     KeyRequester::setAllowedKeys(encryptionKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid));
 }
 
 Kleo::SigningKeyRequester::SigningKeyRequester(bool multi, unsigned int proto,
         QWidget *parent,
         bool onlyTrusted, bool onlyValid)
     : KeyRequester(signingKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid), multi,
                    parent), d(nullptr)
 {
 }
 
 Kleo::SigningKeyRequester::SigningKeyRequester(QWidget *parent)
     : KeyRequester(0, false, parent), d(nullptr)
 {
 }
 
 Kleo::SigningKeyRequester::~SigningKeyRequester() {}
 
 void Kleo::SigningKeyRequester::setAllowedKeys(unsigned int proto, bool onlyTrusted, bool onlyValid)
 {
     KeyRequester::setAllowedKeys(signingKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid));
 }
 
 void Kleo::KeyRequester::virtual_hook(int, void *) {}
 void Kleo::EncryptionKeyRequester::virtual_hook(int id, void *data)
 {
     KeyRequester::virtual_hook(id, data);
 }
 void Kleo::SigningKeyRequester::virtual_hook(int id, void *data)
 {
     KeyRequester::virtual_hook(id, data);
 }
 
diff --git a/src/ui/keyselectioncombo.cpp b/src/ui/keyselectioncombo.cpp
index aef6e9ba5..8085e2d39 100644
--- a/src/ui/keyselectioncombo.cpp
+++ b/src/ui/keyselectioncombo.cpp
@@ -1,544 +1,544 @@
 /*  This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keyselectioncombo.h"
 #include <kleo_ui_debug.h>
 
 #include "kleo/dn.h"
 #include "models/keylistmodel.h"
 #include "models/keylistsortfilterproxymodel.h"
 #include "models/keycache.h"
 #include "utils/formatting.h"
 #include "progressbar.h"
 #include "kleo/defaultkeyfilter.h"
 
 #include <gpgme++/key.h>
 
 #include <QSortFilterProxyModel>
 #include <QVector>
 #include <QTimer>
 
 #include <KLocalizedString>
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 namespace
 {
 class ProxyModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 
 private:
     struct CustomItem {
         QIcon icon;
         QString text;
         QVariant data;
         QString toolTip;
     };
 public:
     ProxyModel(QObject *parent = nullptr)
         : QSortFilterProxyModel(parent)
     {
     }
 
     ~ProxyModel() override
     {
         qDeleteAll(mFrontItems);
         qDeleteAll(mBackItems);
     }
 
     bool lessThan(const QModelIndex &left, const QModelIndex &right) const override
     {
         const auto leftKey =  sourceModel()->data(left, Kleo::KeyListModelInterface::KeyRole).value<GpgME::Key>();
         const auto rightKey = sourceModel()->data(right, Kleo::KeyListModelInterface::KeyRole).value<GpgME::Key>();
         if (leftKey.isNull()) {
             return false;
         }
         if (rightKey.isNull()) {
             return true;
         }
         // As we display UID(0) this is ok. We probably need a get Best UID at some point.
         const auto lUid = leftKey.userID(0);
         const auto rUid = rightKey.userID(0);
         if (lUid.isNull()) {
             return false;
         }
         if (rUid.isNull()) {
             return true;
         }
         int cmp = strcmp (lUid.id(), rUid.id());
         if (cmp) {
             return cmp < 0;
         }
 
         if (lUid.validity() == rUid.validity()) {
             /* Both are the same check which one is newer. */
             time_t oldTime = 0;
             for (const GpgME::Subkey &s: leftKey.subkeys()) {
                 if (s.isRevoked() || s.isInvalid() || s.isDisabled()) {
                     continue;
                 }
                 if (s.creationTime() > oldTime) {
                     oldTime= s.creationTime();
                 }
             }
             time_t newTime = 0;
             for (const GpgME::Subkey &s: rightKey.subkeys()) {
                 if (s.isRevoked() || s.isInvalid() || s.isDisabled()) {
                     continue;
                 }
                 if (s.creationTime() > newTime) {
                     newTime = s.creationTime();
                 }
             }
             return newTime < oldTime;
         }
         return lUid.validity() > rUid.validity();
     }
 
     bool isCustomItem(const int row) const
     {
         return row < mFrontItems.count() || row >= mFrontItems.count() + QSortFilterProxyModel::rowCount();
     }
 
     void prependItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip)
     {
         beginInsertRows(QModelIndex(), 0, 0);
         mFrontItems.push_front(new CustomItem{ icon, text, data, toolTip });
         endInsertRows();
     }
 
     void appendItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip)
     {
         beginInsertRows(QModelIndex(), rowCount(), rowCount());
         mBackItems.push_back(new CustomItem{ icon, text, data, toolTip });
         endInsertRows();
     }
 
     void removeCustomItem(const QVariant &data)
     {
         for (int i = 0; i < mFrontItems.count(); ++i) {
             if (mFrontItems[i]->data == data) {
                 beginRemoveRows(QModelIndex(), i, i);
                 delete mFrontItems.takeAt(i);
                 endRemoveRows();
                 return;
             }
         }
         for (int i = 0; i < mBackItems.count(); ++i) {
             if (mBackItems[i]->data == data) {
                 const int index = mFrontItems.count() + QSortFilterProxyModel::rowCount() + i;
                 beginRemoveRows(QModelIndex(), index, index);
                 delete mBackItems.takeAt(i);
                 endRemoveRows();
                 return;
             }
         }
     }
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override
     {
         return mFrontItems.count() + QSortFilterProxyModel::rowCount(parent) + mBackItems.count();
     }
 
     QModelIndex mapToSource(const QModelIndex &index) const override
     {
         if (!isCustomItem(index.row())) {
             const int row = index.row() - mFrontItems.count();
 
             return sourceModel()->index(row, index.column());
         } else {
-            return QModelIndex();
+            return {};
         }
     }
 
     QModelIndex mapFromSource(const QModelIndex &source_index) const override
     {
         const QModelIndex idx = QSortFilterProxyModel::mapFromSource(source_index);
         return createIndex(mFrontItems.count() + idx.row(), idx.column(), idx.internalPointer());
     }
 
     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override
     {
         if (row < 0 || row >= rowCount()) {
-            return QModelIndex();
+            return {};
         }
         if (row < mFrontItems.count()) {
             return createIndex(row, column, mFrontItems[row]);
         } else if (row >= mFrontItems.count() + QSortFilterProxyModel::rowCount()) {
             return createIndex(row, column, mBackItems[row - mFrontItems.count() - QSortFilterProxyModel::rowCount()]);
         } else {
             const QModelIndex mi = QSortFilterProxyModel::index(row - mFrontItems.count(), column, parent);
             return createIndex(row, column, mi.internalPointer());
         }
     }
 
     Qt::ItemFlags flags(const QModelIndex &index) const override
     {
         Q_UNUSED(index);
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemNeverHasChildren;
     }
 
     QModelIndex parent(const QModelIndex &) const override
     {
         // Flat list
-        return QModelIndex();
+        return {};
     }
 
     QVariant data(const QModelIndex &index, int role) const override
     {
         if (!index.isValid()) {
             return QVariant();
         }
 
         if (isCustomItem(index.row())) {
             Q_ASSERT(!mFrontItems.isEmpty() || !mBackItems.isEmpty());
-            CustomItem *ci = static_cast<CustomItem*>(index.internalPointer());
+            auto *ci = static_cast<CustomItem*>(index.internalPointer());
             switch (role) {
             case Qt::DisplayRole:
                 return ci->text;
             case Qt::DecorationRole:
                 return ci->icon;
             case Qt::UserRole:
                 return ci->data;
             case Qt::ToolTipRole:
                 return ci->toolTip;
             default:
                 return QVariant();
             }
         }
 
         const auto key = QSortFilterProxyModel::data(index, Kleo::KeyListModelInterface::KeyRole).value<GpgME::Key>();
         Q_ASSERT(!key.isNull());
         if (key.isNull()) {
             return QVariant();
         }
 
         switch (role) {
         case Qt::DisplayRole: {
             const auto userID = key.userID(0);
             QString name, email;
 
             if (key.protocol() == GpgME::OpenPGP) {
                 name = QString::fromUtf8(userID.name());
                 email = QString::fromUtf8(userID.email());
             } else {
                 const Kleo::DN dn(userID.id());
                 name = dn[QStringLiteral("CN")];
                 email = dn[QStringLiteral("EMAIL")];
             }
             return i18nc("Name <email> (validity, type, created: date)", "%1 (%2, %3 created: %4)",
                          email.isEmpty() ? name : name.isEmpty() ? email : i18nc("Name <email>", "%1 <%2>", name, email),
                          Kleo::Formatting::complianceStringShort(key),
                          Kleo::KeyCache::instance()->pgpOnly() ? QString() :
                             key.protocol() == GpgME::OpenPGP ? i18n("OpenPGP") + QLatin1Char(',') : i18n("S/MIME") + QLatin1Char(','),
                          Kleo::Formatting::creationDateString(key));
         }
         case Qt::ToolTipRole:
             return Kleo::Formatting::toolTip(key, Kleo::Formatting::Validity |
                                                   Kleo::Formatting::Issuer |
                                                   Kleo::Formatting::Subject |
                                                   Kleo::Formatting::Fingerprint |
                                                   Kleo::Formatting::ExpiryDates |
                                                   Kleo::Formatting::UserIDs);
         case Qt::DecorationRole:
             return Kleo::Formatting::iconForUid(key.userID(0));
         default:
             return QSortFilterProxyModel::data(index, role);
         }
     }
 
 private:
     QVector<CustomItem*> mFrontItems;
     QVector<CustomItem*> mBackItems;
 };
 
 
 } // anonymous namespace
 
 namespace Kleo
 {
 class KeySelectionComboPrivate
 {
 public:
     KeySelectionComboPrivate(KeySelectionCombo *parent)
         : wasEnabled(true)
         , q(parent)
     {
     }
 
     /* Selects the first key with a UID addrSpec that matches
      * the mPerfectMatchMbox variable.
      *
      * The idea here is that if there are keys like:
      *
      * tom-store@abc.com
      * susi-store@abc.com
      * store@abc.com
      *
      * And the user wants to send a mail to "store@abc.com"
      * the filter should still show tom and susi (because they
      * both are part of store) but the key for "store" should
      * be preselected.
      *
      * Returns true if one was selected. False otherwise. */
     bool selectPerfectIdMatch() const
     {
         if (mPerfectMatchMbox.isEmpty()) {
             return false;
         }
 
         for (int i = 0; i < proxyModel->rowCount(); ++i) {
             const auto idx = proxyModel->index(i, 0, QModelIndex());
             const auto key = proxyModel->data(idx, Kleo::KeyListModelInterface::KeyRole).value<GpgME::Key>();
             if (key.isNull()) {
                 // WTF?
                 continue;
             }
             for (const auto &uid: key.userIDs()) {
                 if (QString::fromStdString(uid.addrSpec()) == mPerfectMatchMbox) {
                     q->setCurrentIndex(i);
                     return true;
                 }
             }
         }
         return false;
     }
 
     /* Updates the current key with the default key if the key matches
      * the current key filter. */
     void updateWithDefaultKey() const {
         GpgME::Protocol filterProto = GpgME::UnknownProtocol;
 
         const auto filter = dynamic_cast<const DefaultKeyFilter*> (sortFilterProxy->keyFilter().get());
         if (filter && filter->isOpenPGP() == DefaultKeyFilter::Set) {
             filterProto = GpgME::OpenPGP;
         } else if (filter && filter->isOpenPGP() == DefaultKeyFilter::NotSet) {
             filterProto = GpgME::CMS;
         }
 
         QString defaultKey = defaultKeys.value (filterProto);
         if (defaultKey.isEmpty()) {
             // Fallback to unknown protocol
             defaultKey = defaultKeys.value (GpgME::UnknownProtocol);
         }
         q->setCurrentKey(defaultKey);
     }
 
     Kleo::AbstractKeyListModel *model = nullptr;
     Kleo::KeyListSortFilterProxyModel *sortFilterProxy = nullptr;
     ProxyModel *proxyModel = nullptr;
     std::shared_ptr<Kleo::KeyCache> cache;
     QMap<GpgME::Protocol, QString> defaultKeys;
     bool wasEnabled = false;
     bool useWasEnabled = false;
     bool secretOnly;
     QString mPerfectMatchMbox;
 
 private:
     KeySelectionCombo * const q;
 };
 
 }
 
 using namespace Kleo;
 
 KeySelectionCombo::KeySelectionCombo(QWidget* parent)
     : KeySelectionCombo(true, parent)
 {}
 
 KeySelectionCombo::KeySelectionCombo(bool secretOnly, QWidget* parent)
     : QComboBox(parent)
     , d(new KeySelectionComboPrivate(this))
 {
     d->model = Kleo::AbstractKeyListModel::createFlatKeyListModel(this);
     d->secretOnly = secretOnly;
 
     d->sortFilterProxy = new Kleo::KeyListSortFilterProxyModel(this);
     d->sortFilterProxy->setSourceModel(d->model);
 
     d->proxyModel = new ProxyModel(this);
     d->proxyModel->setSourceModel(d->sortFilterProxy);
 
     setModel(d->proxyModel);
     connect(this, static_cast<void(KeySelectionCombo::*)(int)>(&KeySelectionCombo::currentIndexChanged),
             this, [this](int row) {
                 if (row >= 0 && row < d->proxyModel->rowCount()) {
                     if (d->proxyModel->isCustomItem(row)) {
                         Q_EMIT customItemSelected(d->proxyModel->index(row, 0).data(Qt::UserRole));
                     } else {
                         Q_EMIT currentKeyChanged(currentKey());
                     }
                 }
             });
 
     d->cache = Kleo::KeyCache::mutableInstance();
 
     QTimer::singleShot(0, this, &KeySelectionCombo::init);
 }
 
 KeySelectionCombo::~KeySelectionCombo()
 {
     delete d;
 }
 
 void KeySelectionCombo::init()
 {
     connect(d->cache.get(), &Kleo::KeyCache::keyListingDone,
             this, [this]() {
                     // Set useKeyCache ensures that the cache is populated
                     // so this can be a blocking call if the cache is not initialized 
                     d->model->useKeyCache(true, d->secretOnly);
                     d->proxyModel->removeCustomItem(QStringLiteral("-libkleo-loading-keys"));
 
                     // We use the useWasEnabled state variable to decide if we should
                     // change the enable / disable state based on the keylist done signal.
                     // If we triggered the refresh useWasEnabled is true and we want to
                     // enable / disable again after our refresh, as the refresh disabled it.
                     //
                     // But if a keyListingDone signal comes from just a generic refresh
                     // triggered by someone else we don't want to change the enable / disable
                     // state.
                     if (d->useWasEnabled) {
                         setEnabled(d->wasEnabled);
                         d->useWasEnabled = false;
                     }
                     Q_EMIT keyListingFinished();
             });
 
     connect(this, &KeySelectionCombo::keyListingFinished, this, [this]() {
             d->updateWithDefaultKey();
         });
 
     if (!d->cache->initialized()) {
         refreshKeys();
     } else {
         d->model->useKeyCache(true, d->secretOnly);
         Q_EMIT keyListingFinished();
     }
 
     connect(this, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this] () {
             setToolTip(currentData(Qt::ToolTipRole).toString());
         });
 }
 
 
 void KeySelectionCombo::setKeyFilter(const std::shared_ptr<const KeyFilter> &kf)
 {
     d->sortFilterProxy->setKeyFilter(kf);
     d->proxyModel->sort(0);
     d->updateWithDefaultKey();
 }
 
 std::shared_ptr<const KeyFilter> KeySelectionCombo::keyFilter() const
 {
     return d->sortFilterProxy->keyFilter();
 }
 
 void KeySelectionCombo::setIdFilter(const QString &id)
 {
     d->sortFilterProxy->setFilterRegExp(id);
     d->mPerfectMatchMbox = id;
     d->updateWithDefaultKey();
 }
 
 QString KeySelectionCombo::idFilter() const
 {
     return d->sortFilterProxy->filterRegExp().pattern();
 }
 
 GpgME::Key Kleo::KeySelectionCombo::currentKey() const
 {
     return currentData(Kleo::KeyListModelInterface::KeyRole).value<GpgME::Key>();
 }
 
 void Kleo::KeySelectionCombo::setCurrentKey(const GpgME::Key &key)
 {
     const int idx = findData(QVariant::fromValue(key), Kleo::KeyListModelInterface::KeyRole, Qt::MatchExactly);
     if (idx > -1) {
         setCurrentIndex(idx);
     } else {
         d->selectPerfectIdMatch();
     }
     setToolTip(currentData(Qt::ToolTipRole).toString());
 }
 
 void Kleo::KeySelectionCombo::setCurrentKey(const QString &fingerprint)
 {
     const auto cur = currentKey();
     if (!cur.isNull() && !fingerprint.isEmpty() &&
         fingerprint == QLatin1String(cur.primaryFingerprint())) {
         // Already set
         return;
     }
     for (int i = 0; i < d->proxyModel->rowCount(); ++i) {
         const auto idx = d->proxyModel->index(i, 0, QModelIndex());
         const auto key = d->proxyModel->data(idx, Kleo::KeyListModelInterface::KeyRole).value<GpgME::Key>();
         if (!key.isNull() && fingerprint == QString::fromLatin1(key.primaryFingerprint())) {
             setCurrentIndex(i);
             setToolTip(currentData(Qt::ToolTipRole).toString());
             return;
         }
     }
     if (!d->selectPerfectIdMatch()) {
         setCurrentIndex(0);
     }
     setToolTip(currentData(Qt::ToolTipRole).toString());
 }
 
 void KeySelectionCombo::refreshKeys()
 {
     d->wasEnabled = isEnabled();
     d->useWasEnabled = true;
     setEnabled(false);
     const bool wasBlocked = blockSignals(true);
     prependCustomItem(QIcon(), i18n("Loading keys ..."), QStringLiteral("-libkleo-loading-keys"));
     setCurrentIndex(0);
     blockSignals(wasBlocked);
     d->cache->startKeyListing();
 }
 
 void KeySelectionCombo::appendCustomItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip)
 {
     d->proxyModel->appendItem(icon, text, data, toolTip);
 }
 
 void KeySelectionCombo::appendCustomItem(const QIcon &icon, const QString &text, const QVariant &data)
 {
     appendCustomItem(icon, text, data, QString());
 }
 
 void KeySelectionCombo::prependCustomItem(const QIcon &icon, const QString &text, const QVariant &data, const QString &toolTip)
 {
     d->proxyModel->prependItem(icon, text, data, toolTip);
 }
 
 void KeySelectionCombo::prependCustomItem(const QIcon &icon, const QString &text, const QVariant &data)
 {
     prependCustomItem(icon, text, data, QString());
 }
 
 void Kleo::KeySelectionCombo::setDefaultKey(const QString &fingerprint, GpgME::Protocol proto)
 {
     d->defaultKeys.insert(proto, fingerprint);
     d->updateWithDefaultKey();
 }
 
 void Kleo::KeySelectionCombo::setDefaultKey(const QString &fingerprint)
 {
     setDefaultKey(fingerprint, GpgME::UnknownProtocol);
 }
 
 QString Kleo::KeySelectionCombo::defaultKey(GpgME::Protocol proto) const
 {
     return d->defaultKeys.value(proto);
 }
 
 QString Kleo::KeySelectionCombo::defaultKey() const
 {
     return defaultKey(GpgME::UnknownProtocol);
 }
 #include "keyselectioncombo.moc"
diff --git a/src/ui/keyselectiondialog.cpp b/src/ui/keyselectiondialog.cpp
index 0e54620bc..e11a72e9c 100644
--- a/src/ui/keyselectiondialog.cpp
+++ b/src/ui/keyselectiondialog.cpp
@@ -1,980 +1,980 @@
 /*  -*- c++ -*-
     keyselectiondialog.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.cpp
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "keyselectiondialog.h"
 
 #include "keylistview.h"
 #include "progressdialog.h"
 
 #include "libkleo/dn.h"
 #include "kleo_ui_debug.h"
 
 // gpgme++
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <qgpgme/keylistjob.h>
 
 // KDE
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 
 // Qt
 #include <QApplication>
 #include <QCheckBox>
 #include <QDateTime>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QProcess>
 #include <QPushButton>
 #include <QRegExp>
 #include <QScrollBar>
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include <algorithm>
 #include <iterator>
 #include <string.h>
 
 static bool checkKeyUsage(const GpgME::Key &key, unsigned int keyUsage, QString *statusString = nullptr)
 {
     auto setStatusString = [statusString](const QString &status) {
         if (statusString) {
             *statusString = status;
         }
     };
 
     if (keyUsage & Kleo::KeySelectionDialog::ValidKeys) {
         if (key.isInvalid()) {
             if (key.keyListMode() & GpgME::Validate) {
                 qCDebug(KLEO_UI_LOG) << "key is invalid";
                 setStatusString(i18n("The key is not valid."));
                 return false;
             } else {
                 qCDebug(KLEO_UI_LOG) << "key is invalid - ignoring";
             }
         }
         if (key.isExpired()) {
             qCDebug(KLEO_UI_LOG) << "key is expired";
             setStatusString(i18n("The key is expired."));
             return false;
         } else if (key.isRevoked()) {
             qCDebug(KLEO_UI_LOG) << "key is revoked";
             setStatusString(i18n("The key is revoked."));
             return false;
         } else if (key.isDisabled()) {
             qCDebug(KLEO_UI_LOG) << "key is disabled";
             setStatusString(i18n("The key is disabled."));
             return false;
         }
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::EncryptionKeys &&
             !key.canEncrypt()) {
         qCDebug(KLEO_UI_LOG) << "key can't encrypt";
         setStatusString(i18n("The key is not designated for encryption."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::SigningKeys &&
             !key.canSign()) {
         qCDebug(KLEO_UI_LOG) << "key can't sign";
         setStatusString(i18n("The key is not designated for signing."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::CertificationKeys &&
             !key.canCertify()) {
         qCDebug(KLEO_UI_LOG) << "key can't certify";
         setStatusString(i18n("The key is not designated for certifying."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::AuthenticationKeys &&
             !key.canAuthenticate()) {
         qCDebug(KLEO_UI_LOG) << "key can't authenticate";
         setStatusString(i18n("The key is not designated for authentication."));
         return false;
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::SecretKeys &&
             !(keyUsage & Kleo::KeySelectionDialog::PublicKeys) &&
             !key.hasSecret()) {
         qCDebug(KLEO_UI_LOG) << "key isn't secret";
         setStatusString(i18n("The key is not secret."));
         return false;
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::TrustedKeys &&
             key.protocol() == GpgME::OpenPGP &&
             // only check this for secret keys for now.
             // Seems validity isn't checked for secret keylistings...
             !key.hasSecret()) {
         std::vector<GpgME::UserID> uids = key.userIDs();
         for (std::vector<GpgME::UserID>::const_iterator it = uids.begin(); it != uids.end(); ++it)
             if (!it->isRevoked() && it->validity() >= GpgME::UserID::Marginal) {
                 return true;
             }
         qCDebug(KLEO_UI_LOG) << "key has no UIDs with validity >= Marginal";
         setStatusString(i18n("The key is not trusted enough."));
         return false;
     }
     // X.509 keys are always trusted, else they won't be the keybox.
     // PENDING(marc) check that this ^ is correct
 
     setStatusString(i18n("The key can be used."));
     return true;
 }
 
 static bool checkKeyUsage(const std::vector<GpgME::Key> &keys, unsigned int keyUsage)
 {
-    for (std::vector<GpgME::Key>::const_iterator it = keys.begin(); it != keys.end(); ++it)
+    for (auto it = keys.begin(); it != keys.end(); ++it)
         if (!checkKeyUsage(*it, keyUsage)) {
             return false;
         }
     return true;
 }
 
 static inline QString time_t2string(time_t t)
 {
     QDateTime dt;
     dt.setTime_t(t);
     return dt.toString();
 }
 
 namespace
 {
 
 class ColumnStrategy : public Kleo::KeyListView::ColumnStrategy
 {
 public:
     ColumnStrategy(unsigned int keyUsage);
 
     QString title(int col) const override;
     int width(int col, const QFontMetrics &fm) const override;
 
     QString text(const GpgME::Key &key, int col) const override;
     QString toolTip(const GpgME::Key &key, int col) const override;
     QIcon icon(const GpgME::Key &key, int col) const override;
 
 private:
     const QIcon mKeyGoodPix, mKeyBadPix, mKeyUnknownPix, mKeyValidPix;
     const unsigned int mKeyUsage;
 };
 
 static QString iconPath(const QString &name)
 {
     return QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("libkleopatra/pics/") + name + QStringLiteral(".png"));
 }
 
 ColumnStrategy::ColumnStrategy(unsigned int keyUsage)
     : Kleo::KeyListView::ColumnStrategy(),
       mKeyGoodPix(iconPath(QStringLiteral("key_ok"))),
       mKeyBadPix(iconPath(QStringLiteral("key_bad"))),
       mKeyUnknownPix(iconPath(QStringLiteral("key_unknown"))),
       mKeyValidPix(iconPath(QStringLiteral("key"))),
       mKeyUsage(keyUsage)
 {
     if (keyUsage == 0)
         qCWarning(KLEO_UI_LOG)
                 << "KeySelectionDialog: keyUsage == 0. You want to use AllKeys instead.";
 }
 
 QString ColumnStrategy::title(int col) const
 {
     switch (col) {
     case 0: return i18n("Key ID");
     case 1: return i18n("User ID");
     default: return QString();
     }
 }
 
 int ColumnStrategy::width(int col, const QFontMetrics &fm) const
 {
     if (col == 0) {
         static const char hexchars[] = "0123456789ABCDEF";
         int maxWidth = 0;
         for (unsigned int i = 0; i < 16; ++i) {
             maxWidth = qMax(fm.boundingRect(QLatin1Char(hexchars[i])).width(), maxWidth);
         }
         return 8 * maxWidth + 2 * 16 /* KIconLoader::SizeSmall */;
     }
     return Kleo::KeyListView::ColumnStrategy::width(col, fm);
 }
 
 QString ColumnStrategy::text(const GpgME::Key &key, int col) const
 {
     switch (col) {
     case 0: {
         if (key.shortKeyID()) {
             return QString::fromUtf8(key.shortKeyID());
         } else {
             return xi18n("<placeholder>unknown</placeholder>");
         }
     }
     case 1: {
         const char *uid = key.userID(0).id();
         if (key.protocol() == GpgME::OpenPGP) {
             return uid && *uid ? QString::fromUtf8(uid) : QString();
         } else { // CMS
             return Kleo::DN(uid).prettyDN();
         }
     }
     default: return QString();
     }
 }
 
 QString ColumnStrategy::toolTip(const GpgME::Key &key, int) const
 {
     const char *uid = key.userID(0).id();
     const char *fpr = key.primaryFingerprint();
     const char *issuer = key.issuerName();
     const GpgME::Subkey subkey = key.subkey(0);
     const QString expiry = subkey.neverExpires() ? i18n("never") : time_t2string(subkey.expirationTime());
     const QString creation = time_t2string(subkey.creationTime());
     QString keyStatusString;
     if (!checkKeyUsage(key, mKeyUsage, &keyStatusString)) {
         // Show the status in bold if there is a problem
         keyStatusString = QLatin1String("<b>") % keyStatusString % QLatin1String("</b>");
     }
 
     QString html = QStringLiteral("<qt><p style=\"style='white-space:pre'\">");
     if (key.protocol() == GpgME::OpenPGP) {
         html += i18n("OpenPGP key for <b>%1</b>", uid ? QString::fromUtf8(uid) : i18n("unknown"));
     } else {
         html += i18n("S/MIME key for <b>%1</b>", uid ? Kleo::DN(uid).prettyDN() : i18n("unknown"));
     }
     html += QStringLiteral("</p><table>");
 
     const auto addRow = [&html](const QString &name, const QString &value) {
         html += QStringLiteral("<tr><td align=\"right\"><b>%1: </b></td><td>%2</td></tr>").arg(name, value);
     };
     addRow(i18nc("Key creation date", "Created"), creation);
     addRow(i18nc("Key Expiration date", "Expiry"), expiry);
     addRow(i18nc("Key fingerprint", "Fingerprint"), fpr ? QString::fromLatin1(fpr) : i18n("unknown"));
     if (key.protocol() != GpgME::OpenPGP) {
         addRow(i18nc("Key issuer", "Issuer"), issuer ? Kleo::DN(issuer).prettyDN() : i18n("unknown"));
     }
     addRow(i18nc("Key status", "Status"), keyStatusString);
     html += QStringLiteral("</table></qt>");
 
     return html;
 }
 
 QIcon ColumnStrategy::icon(const GpgME::Key &key, int col) const
 {
     if (col != 0) {
         return QIcon();
     }
     // this key did not undergo a validating keylisting yet:
     if (!(key.keyListMode() & GpgME::Validate)) {
         return mKeyUnknownPix;
     }
 
     if (!checkKeyUsage(key, mKeyUsage)) {
         return mKeyBadPix;
     }
 
     if (key.protocol() == GpgME::CMS) {
         return mKeyGoodPix;
     }
 
     switch (key.userID(0).validity()) {
     default:
     case GpgME::UserID::Unknown:
     case GpgME::UserID::Undefined:
         return mKeyUnknownPix;
     case GpgME::UserID::Never:
         return mKeyValidPix;
     case GpgME::UserID::Marginal:
     case GpgME::UserID::Full:
     case GpgME::UserID::Ultimate:
         return mKeyGoodPix;
     }
 }
 
 }
 
 static const int sCheckSelectionDelay = 250;
 
 Kleo::KeySelectionDialog::KeySelectionDialog(QWidget *parent, Options options)
     : QDialog(parent),
       mOpenPGPBackend(QGpgME::openpgp()),
       mSMIMEBackend(QGpgME::smime()),
       mKeyUsage(AllKeys)
 {
         qCDebug(KLEO_UI_LOG) << "mTruncated:" << mTruncated << "mSavedOffsetY:" << mSavedOffsetY;
     setUpUI(options, QString());
 }
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const std::vector<GpgME::Key> &selectedKeys,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mSelectedKeys(selectedKeys),
       mKeyUsage(keyUsage)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, QString());
 }
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const QString &initialQuery,
         const std::vector<GpgME::Key> &selectedKeys,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mSelectedKeys(selectedKeys),
       mKeyUsage(keyUsage),
       mSearchText(initialQuery),
       mInitialQuery(initialQuery)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const QString &initialQuery,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mKeyUsage(keyUsage),
       mSearchText(initialQuery),
       mInitialQuery(initialQuery)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 void Kleo::KeySelectionDialog::setUpUI(Options options, const QString &initialQuery)
 {
-    QVBoxLayout *mainLayout = new QVBoxLayout(this);
+    auto *mainLayout = new QVBoxLayout(this);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     mOkButton = buttonBox->button(QDialogButtonBox::Ok);
     mOkButton->setDefault(true);
     mOkButton->setShortcut(Qt::CTRL | Qt::Key_Return);
 
     mCheckSelectionTimer = new QTimer(this);
     mStartSearchTimer = new QTimer(this);
 
     QFrame *page = new QFrame(this);
     mainLayout->addWidget(page);
     mainLayout->addWidget(buttonBox);
 
     mTopLayout = new QVBoxLayout(page);
     mTopLayout->setContentsMargins(0, 0, 0, 0);
 
     mTextLabel = new QLabel(page);
     mTextLabel->setWordWrap(true);
 
     // Setting the size policy is necessary as a workaround for https://issues.kolab.org/issue4429
     // and http://bugreports.qt.nokia.com/browse/QTBUG-8740
     mTextLabel->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
     connect(mTextLabel, &QLabel::linkActivated, this, &KeySelectionDialog::slotStartCertificateManager);
     mTopLayout->addWidget(mTextLabel);
     mTextLabel->hide();
 
     QPushButton *const searchExternalPB =
         new QPushButton(i18n("Search for &External Certificates"), page);
     mTopLayout->addWidget(searchExternalPB, 0, Qt::AlignLeft);
     connect(searchExternalPB, &QAbstractButton::clicked, this, &KeySelectionDialog::slotStartSearchForExternalCertificates);
     if (initialQuery.isEmpty()) {
         searchExternalPB->hide();
     }
 
-    QHBoxLayout *hlay = new QHBoxLayout();
+    auto *hlay = new QHBoxLayout();
     mTopLayout->addLayout(hlay);
 
-    QLineEdit *le = new QLineEdit(page);
+    auto *le = new QLineEdit(page);
     le->setClearButtonEnabled(true);
     le->setText(initialQuery);
 
     QLabel *lbSearchFor =  new QLabel(i18n("&Search for:"), page);
     lbSearchFor->setBuddy(le);
 
     hlay->addWidget(lbSearchFor);
     hlay->addWidget(le, 1);
     le->setFocus();
 
     connect(le, &QLineEdit::textChanged,
             this, static_cast<void(KeySelectionDialog::*)(const QString &)>(&KeySelectionDialog::slotSearch));
     connect(mStartSearchTimer, &QTimer::timeout, this, &KeySelectionDialog::slotFilter);
 
     mKeyListView = new KeyListView(new ColumnStrategy(mKeyUsage), nullptr, page);
     mKeyListView->setObjectName(QStringLiteral("mKeyListView"));
     mKeyListView->header()->stretchLastSection();
     mKeyListView->setRootIsDecorated(true);
     mKeyListView->setSortingEnabled(true);
     mKeyListView->header()->setSortIndicatorShown(true);
     mKeyListView->header()->setSortIndicator(1, Qt::AscendingOrder);   // sort by User ID
     if (options & ExtendedSelection) {
         mKeyListView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     }
     mTopLayout->addWidget(mKeyListView, 10);
 
     if (options & RememberChoice) {
         mRememberCB = new QCheckBox(i18n("&Remember choice"), page);
         mTopLayout->addWidget(mRememberCB);
         mRememberCB->setWhatsThis(
             i18n("<qt><p>If you check this box your choice will "
                  "be stored and you will not be asked again."
                  "</p></qt>"));
     }
 
     connect(mCheckSelectionTimer, &QTimer::timeout,
             this, static_cast<void(KeySelectionDialog::*)()>(&KeySelectionDialog::slotCheckSelection));
     connectSignals();
 
     connect(mKeyListView, &Kleo::KeyListView::doubleClicked, this, &KeySelectionDialog::slotTryOk);
     connect(mKeyListView, &KeyListView::contextMenu, this, &KeySelectionDialog::slotRMB);
 
     if (options & RereadKeys) {
         QPushButton *button = new QPushButton(i18n("&Reread Keys"));
         buttonBox->addButton(button, QDialogButtonBox::ActionRole);
         connect(button, &QPushButton::clicked, this, &KeySelectionDialog::slotRereadKeys);
     }
     if (options & ExternalCertificateManager) {
         QPushButton *button = new QPushButton(i18n("&Start Certificate Manager"));
         buttonBox->addButton(button, QDialogButtonBox::ActionRole);
         connect(button, &QPushButton::clicked, this, [this]() { slotStartCertificateManager(); });
     }
     connect(mOkButton, &QPushButton::clicked, this, &KeySelectionDialog::slotOk);
     connect(buttonBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &KeySelectionDialog::slotCancel);
 
     mTopLayout->activate();
 
     if (qApp) {
         QSize dialogSize(sizeHint());
         KConfigGroup dialogConfig(KSharedConfig::openConfig(), "Key Selection Dialog");
         dialogSize = dialogConfig.readEntry("Dialog size", dialogSize);
         const QByteArray headerState = dialogConfig.readEntry("header", QByteArray());
         if (!headerState.isEmpty()) {
             mKeyListView->header()->restoreState(headerState);
         }
         resize(dialogSize);
     }
 }
 
 void Kleo::KeySelectionDialog::init(bool rememberChoice, bool extendedSelection, const QString &text, const QString &initialQuery)
 {
     Options options = { RereadKeys, ExternalCertificateManager };
     options.setFlag(ExtendedSelection, extendedSelection);
     options.setFlag(RememberChoice, rememberChoice);
 
     setUpUI(options, initialQuery);
     setText(text);
 
     if (mKeyUsage & OpenPGPKeys) {
         mOpenPGPBackend = QGpgME::openpgp();
     }
     if (mKeyUsage & SMIMEKeys) {
         mSMIMEBackend = QGpgME::smime();
     }
 
     slotRereadKeys();
 }
 
 Kleo::KeySelectionDialog::~KeySelectionDialog()
 {
     disconnectSignals();
     KConfigGroup dialogConfig(KSharedConfig::openConfig(), "Key Selection Dialog");
     dialogConfig.writeEntry("Dialog size", size());
     dialogConfig.writeEntry("header", mKeyListView->header()->saveState());
     dialogConfig.sync();
 }
 
 void Kleo::KeySelectionDialog::setText(const QString &text)
 {
     mTextLabel->setText(text);
     mTextLabel->setVisible(!text.isEmpty());
 }
 
 void Kleo::KeySelectionDialog::setKeys(const std::vector<GpgME::Key> &keys)
 {
     for (const GpgME::Key &key : keys) {
         mKeyListView->slotAddKey(key);
     }
 }
 
 void Kleo::KeySelectionDialog::connectSignals()
 {
     if (mKeyListView->isMultiSelection())
         connect(mKeyListView, &QTreeWidget::itemSelectionChanged, this, &KeySelectionDialog::slotSelectionChanged);
     else
         connect(mKeyListView, static_cast<void(KeyListView::*)(KeyListViewItem*)>(&KeyListView::selectionChanged),
                 this, static_cast<void(KeySelectionDialog::*)(KeyListViewItem*)>(&KeySelectionDialog::slotCheckSelection));
 }
 
 void Kleo::KeySelectionDialog::disconnectSignals()
 {
     if (mKeyListView->isMultiSelection())
         disconnect(mKeyListView, &QTreeWidget::itemSelectionChanged,
                    this, &KeySelectionDialog::slotSelectionChanged);
     else
         disconnect(mKeyListView, static_cast<void(KeyListView::*)(KeyListViewItem*)>(&KeyListView::selectionChanged),
                    this, static_cast<void(KeySelectionDialog::*)(KeyListViewItem*)>(&KeySelectionDialog::slotCheckSelection));
 }
 
 const GpgME::Key &Kleo::KeySelectionDialog::selectedKey() const
 {
     static const GpgME::Key null = GpgME::Key::null;
     if (mKeyListView->isMultiSelection() || !mKeyListView->selectedItem()) {
         return null;
     }
     return mKeyListView->selectedItem()->key();
 }
 
 QString Kleo::KeySelectionDialog::fingerprint() const
 {
     return QLatin1String(selectedKey().primaryFingerprint());
 }
 
 QStringList Kleo::KeySelectionDialog::fingerprints() const
 {
     QStringList result;
-    for (std::vector<GpgME::Key>::const_iterator it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
+    for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
         if (const char *fpr = it->primaryFingerprint()) {
             result.push_back(QLatin1String(fpr));
         }
     return result;
 }
 
 QStringList Kleo::KeySelectionDialog::pgpKeyFingerprints() const
 {
     QStringList result;
-    for (std::vector<GpgME::Key>::const_iterator it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
+    for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
         if (it->protocol() == GpgME::OpenPGP)
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
     return result;
 }
 
 QStringList Kleo::KeySelectionDialog::smimeFingerprints() const
 {
     QStringList result;
-    for (std::vector<GpgME::Key>::const_iterator it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
+    for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
         if (it->protocol() == GpgME::CMS)
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
     return result;
 }
 
 void Kleo::KeySelectionDialog::slotRereadKeys()
 {
     mKeyListView->clear();
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     // FIXME: save current selection
     if (mOpenPGPBackend) {
         startKeyListJobForBackend(mOpenPGPBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
     if (mSMIMEBackend) {
         startKeyListJobForBackend(mSMIMEBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
 
     if (mListJobCount == 0) {
         mKeyListView->setEnabled(true);
         KMessageBox::information(this,
                                  i18n("No backends found for listing keys. "
                                       "Check your installation."),
                                  i18n("Key Listing Failed"));
         connectSignals();
     }
 }
 
 void Kleo::KeySelectionDialog::slotStartCertificateManager(const QString &query)
 {
     QStringList args;
 
     if (!query.isEmpty()) {
         args << QStringLiteral("--search") << query;
     }
     if (!QProcess::startDetached(QStringLiteral("kleopatra"), args))
         KMessageBox::error(this,
                            i18n("Could not start certificate manager; "
                                 "please check your installation."),
                            i18n("Certificate Manager Error"));
     else {
         qCDebug(KLEO_UI_LOG) << "\nslotStartCertManager(): certificate manager started.";
     }
 }
 
 #ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 #define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 static void showKeyListError(QWidget *parent, const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n("<qt><p>An error occurred while fetching "
                              "the keys from the backend:</p>"
                              "<p><b>%1</b></p></qt>",
                              QString::fromLocal8Bit(err.asString()));
 
     KMessageBox::error(parent, msg, i18n("Key Listing Failed"));
 }
 #endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 
 namespace
 {
 struct ExtractFingerprint {
     QString operator()(const GpgME::Key &key)
     {
         return QLatin1String(key.primaryFingerprint());
     }
 };
 }
 
 void Kleo::KeySelectionDialog::startKeyListJobForBackend(const QGpgME::Protocol *backend, const std::vector<GpgME::Key> &keys, bool validate)
 {
     Q_ASSERT(backend);
     QGpgME::KeyListJob *job = backend->keyListJob(false, false, validate);    // local, w/o sigs, validation as givem
     if (!job) {
         return;
     }
 
     connect(job, &QGpgME::KeyListJob::result, this, &KeySelectionDialog::slotKeyListResult);
     if (validate)
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotRefreshKey);
     else
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotAddKey);
 
     QStringList fprs;
     std::transform(keys.begin(), keys.end(), std::back_inserter(fprs), ExtractFingerprint());
     const GpgME::Error err = job->start(fprs, mKeyUsage & SecretKeys && !(mKeyUsage & PublicKeys));
 
     if (err) {
         return showKeyListError(this, err);
     }
 
 #ifndef LIBKLEO_NO_PROGRESSDIALOG
     // FIXME: create a MultiProgressDialog:
     (void)new ProgressDialog(job, validate ? i18n("Checking selected keys...") : i18n("Fetching keys..."), this);
 #endif
     ++mListJobCount;
 }
 
 static void selectKeys(Kleo::KeyListView *klv, const std::vector<GpgME::Key> &selectedKeys)
 {
     klv->clearSelection();
     if (selectedKeys.empty()) {
         return;
     }
-    for (std::vector<GpgME::Key>::const_iterator it = selectedKeys.begin(); it != selectedKeys.end(); ++it)
+    for (auto it = selectedKeys.begin(); it != selectedKeys.end(); ++it)
         if (Kleo::KeyListViewItem *item = klv->itemByFingerprint(it->primaryFingerprint())) {
             item->setSelected(true);
         }
 }
 
 void Kleo::KeySelectionDialog::slotKeyListResult(const GpgME::KeyListResult &res)
 {
     if (res.error()) {
         showKeyListError(this, res.error());
     } else if (res.isTruncated()) {
         ++mTruncated;
     }
 
     if (--mListJobCount > 0) {
         return;    // not yet finished...
     }
 
     if (mTruncated > 0)
         KMessageBox::information(this,
                                  i18np("<qt>One backend returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        "<qt>%1 backends returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        mTruncated),
                                  i18n("Key List Result"));
 
     mKeyListView->flushKeys();
 
     mKeyListView->setEnabled(true);
     mListJobCount = mTruncated = 0;
     mKeysToCheck.clear();
 
     selectKeys(mKeyListView, mSelectedKeys);
 
     slotFilter();
 
     connectSignals();
 
     slotSelectionChanged();
 
     // restore the saved position of the contents
     mKeyListView->verticalScrollBar()->setValue(mSavedOffsetY); mSavedOffsetY = 0;
 }
 
 void Kleo::KeySelectionDialog::slotSelectionChanged()
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotSelectionChanged()";
 
     // (re)start the check selection timer. Checking the selection is delayed
     // because else drag-selection doesn't work very good (checking key trust
     // is slow).
     mCheckSelectionTimer->start(sCheckSelectionDelay);
 }
 
 namespace
 {
 struct AlreadyChecked {
     bool operator()(const GpgME::Key &key) const
     {
         return key.keyListMode() & GpgME::Validate;
     }
 };
 }
 
 void Kleo::KeySelectionDialog::slotCheckSelection(KeyListViewItem *item)
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotCheckSelection()";
 
     mCheckSelectionTimer->stop();
 
     mSelectedKeys.clear();
 
     if (!mKeyListView->isMultiSelection()) {
         if (item) {
             mSelectedKeys.push_back(item->key());
         }
     }
 
     for (KeyListViewItem *it = mKeyListView->firstChild(); it; it = it->nextSibling())
         if (it->isSelected()) {
             mSelectedKeys.push_back(it->key());
         }
 
     mKeysToCheck.clear();
     std::remove_copy_if(mSelectedKeys.begin(), mSelectedKeys.end(),
                         std::back_inserter(mKeysToCheck),
                         AlreadyChecked());
     if (mKeysToCheck.empty()) {
         mOkButton->setEnabled(!mSelectedKeys.empty() &&
                               checkKeyUsage(mSelectedKeys, mKeyUsage));
         return;
     }
 
     // performed all fast checks - now for validating key listing:
     startValidatingKeyListing();
 }
 
 void Kleo::KeySelectionDialog::startValidatingKeyListing()
 {
     if (mKeysToCheck.empty()) {
         return;
     }
 
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     std::vector<GpgME::Key> smime, openpgp;
     for (std::vector<GpgME::Key>::const_iterator it = mKeysToCheck.begin(); it != mKeysToCheck.end(); ++it)
         if (it->protocol() == GpgME::OpenPGP) {
             openpgp.push_back(*it);
         } else {
             smime.push_back(*it);
         }
 
     if (!openpgp.empty()) {
         Q_ASSERT(mOpenPGPBackend);
         startKeyListJobForBackend(mOpenPGPBackend, openpgp, true /*validate*/);
     }
     if (!smime.empty()) {
         Q_ASSERT(mSMIMEBackend);
         startKeyListJobForBackend(mSMIMEBackend, smime, true /*validate*/);
     }
 
     Q_ASSERT(mListJobCount > 0);
 }
 
 bool Kleo::KeySelectionDialog::rememberSelection() const
 {
     return mRememberCB && mRememberCB->isChecked();
 }
 
 void Kleo::KeySelectionDialog::slotRMB(Kleo::KeyListViewItem *item, const QPoint &p)
 {
     if (!item) {
         return;
     }
 
     mCurrentContextMenuItem = item;
 
     QMenu menu;
     menu.addAction(i18n("Recheck Key"), this, &KeySelectionDialog::slotRecheckKey);
     menu.exec(p);
 }
 
 void Kleo::KeySelectionDialog::slotRecheckKey()
 {
     if (!mCurrentContextMenuItem || mCurrentContextMenuItem->key().isNull()) {
         return;
     }
 
     mKeysToCheck.clear();
     mKeysToCheck.push_back(mCurrentContextMenuItem->key());
 }
 
 void Kleo::KeySelectionDialog::slotTryOk()
 {
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         slotOk();
     }
 }
 
 void Kleo::KeySelectionDialog::slotOk()
 {
     if (mCheckSelectionTimer->isActive()) {
         slotCheckSelection();
     }
 #if 0 //Laurent I don't understand why we returns here.
     // button could be disabled again after checking the selected key1
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         return;
     }
 #endif
     mStartSearchTimer->stop();
     accept();
 }
 
 void Kleo::KeySelectionDialog::slotCancel()
 {
     mCheckSelectionTimer->stop();
     mStartSearchTimer->stop();
     reject();
 }
 
 void Kleo::KeySelectionDialog::slotSearch(const QString &text)
 {
     mSearchText = text.trimmed().toUpper();
     slotSearch();
 }
 
 void Kleo::KeySelectionDialog::slotSearch()
 {
     mStartSearchTimer->setSingleShot(true);
     mStartSearchTimer->start(sCheckSelectionDelay);
 }
 
 void Kleo::KeySelectionDialog::slotFilter()
 {
     if (mSearchText.isEmpty()) {
         showAllItems();
         return;
     }
 
     // OK, so we need to filter:
     QRegExp keyIdRegExp(QLatin1String("(?:0x)?[A-F0-9]{1,8}"), Qt::CaseInsensitive);
     if (keyIdRegExp.exactMatch(mSearchText)) {
         if (mSearchText.startsWith(QLatin1String("0X")))
             // search for keyID only:
         {
             filterByKeyID(mSearchText.mid(2));
         } else
             // search for UID and keyID:
         {
             filterByKeyIDOrUID(mSearchText);
         }
     } else {
         // search in UID:
         filterByUID(mSearchText);
     }
 }
 
 void Kleo::KeySelectionDialog::filterByKeyID(const QString &keyID)
 {
     Q_ASSERT(keyID.length() <= 8);
     Q_ASSERT(!keyID.isEmpty());   // regexp in slotFilter should prevent these
     if (keyID.isEmpty()) {
         showAllItems();
     } else
         for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
             item->setHidden(!item->text(0).toUpper().startsWith(keyID));
         }
 }
 
 static bool anyUIDMatches(const Kleo::KeyListViewItem *item, QRegExp &rx)
 {
     if (!item) {
         return false;
     }
 
     const std::vector<GpgME::UserID> uids = item->key().userIDs();
-    for (std::vector<GpgME::UserID>::const_iterator it = uids.begin(); it != uids.end(); ++it)
+    for (auto it = uids.begin(); it != uids.end(); ++it)
         if (it->id() && rx.indexIn(QString::fromUtf8(it->id())) >= 0) {
             return true;
         }
     return false;
 }
 
 void Kleo::KeySelectionDialog::filterByKeyIDOrUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!item->text(0).toUpper().startsWith(str) && !anyUIDMatches(item, rx));
     }
 
 }
 
 void Kleo::KeySelectionDialog::filterByUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!anyUIDMatches(item, rx));
     }
 }
 
 void Kleo::KeySelectionDialog::showAllItems()
 {
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(false);
     }
 }
 
diff --git a/src/ui/messagebox.cpp b/src/ui/messagebox.cpp
index 626b11ef6..9fcc0127b 100644
--- a/src/ui/messagebox.cpp
+++ b/src/ui/messagebox.cpp
@@ -1,242 +1,242 @@
 /*
     messagebox.cpp
 
     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
 */
 
 #include "messagebox.h"
 #include "auditlogviewer.h"
 
 #include "kleo_ui_debug.h"
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/encryptionresult.h>
 #include <qgpgme/job.h>
 
 
 #include <QPushButton>
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <KLocalizedString>
 #include <KGuiItem>
 
 
 #include <gpg-error.h>
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Private;
 using namespace GpgME;
 using namespace QGpgME;
 
 // static
 void MessageBox::auditLog(QWidget *parent, const Job *job, const QString &caption)
 {
 
     if (!job) {
         return;
     }
 
     if (!GpgME::hasFeature(AuditLogFeature, 0) || !job->isAuditLogSupported()) {
         KMessageBox::information(parent, i18n("Your system does not have support for GnuPG Audit Logs"),
                                  i18n("System Error"));
         return;
     }
 
     const GpgME::Error err = job->auditLogError();
 
     if (err && err.code() != GPG_ERR_NO_DATA) {
         KMessageBox::information(parent, i18n("An error occurred while trying to retrieve the GnuPG Audit Log:\n%1",
                                               QString::fromLocal8Bit(err.asString())),
                                  i18n("GnuPG Audit Log Error"));
         return;
     }
 
     const QString log = job->auditLogAsHtml();
 
     if (log.isEmpty()) {
         KMessageBox::information(parent, i18n("No GnuPG Audit Log available for this operation."),
                                  i18n("No GnuPG Audit Log"));
         return;
     }
 
     auditLog(parent, log, caption);
 }
 
 // static
 void MessageBox::auditLog(QWidget *parent, const QString &log, const QString &caption)
 {
-    AuditLogViewer *const alv = new AuditLogViewer(log, parent);
+    auto *const alv = new AuditLogViewer(log, parent);
     alv->setAttribute(Qt::WA_DeleteOnClose);
     alv->setObjectName(QStringLiteral("alv"));
     alv->setWindowTitle(caption);
     alv->show();
 }
 
 // static
 void MessageBox::auditLog(QWidget *parent, const Job *job)
 {
     auditLog(parent, job, i18n("GnuPG Audit Log Viewer"));
 }
 
 // static
 void MessageBox::auditLog(QWidget *parent, const QString &log)
 {
     auditLog(parent, log, i18n("GnuPG Audit Log Viewer"));
 }
 
 static QString to_information_string(const SigningResult &result)
 {
     return result.error()
            ? i18n("Signing failed: %1", QString::fromLocal8Bit(result.error().asString()))
            : i18n("Signing successful");
 }
 
 static QString to_error_string(const SigningResult &result)
 {
     return to_information_string(result);
 }
 
 static QString to_information_string(const EncryptionResult &result)
 {
     return result.error()
            ? i18n("Encryption failed: %1", QString::fromLocal8Bit(result.error().asString()))
            : i18n("Encryption successful");
 }
 
 static QString to_error_string(const EncryptionResult &result)
 {
     return to_information_string(result);
 }
 
 static QString to_information_string(const SigningResult &sresult, const EncryptionResult &eresult)
 {
     return to_information_string(sresult) + QLatin1Char('\n') + to_information_string(eresult);
 }
 
 static QString to_error_string(const SigningResult &sresult, const EncryptionResult &eresult)
 {
     return to_information_string(sresult, eresult);
 }
 
 // static
 void MessageBox::information(QWidget *parent, const SigningResult &result, const Job *job, KMessageBox::Options options)
 {
     information(parent, result, job, i18n("Signing Result"), options);
 }
 
 // static
 void MessageBox::information(QWidget *parent, const SigningResult &result, const Job *job, const QString &caption, KMessageBox::Options options)
 {
     make(parent, QMessageBox::Information, to_information_string(result), job, caption, options);
 }
 
 // static
 void MessageBox::error(QWidget *parent, const SigningResult &result, const Job *job, KMessageBox::Options options)
 {
     error(parent, result, job, i18n("Signing Error"), options);
 }
 
 // static
 void MessageBox::error(QWidget *parent, const SigningResult &result, const Job *job, const QString &caption, KMessageBox::Options options)
 {
     make(parent, QMessageBox::Critical, to_error_string(result), job, caption, options);
 }
 
 // static
 void MessageBox::information(QWidget *parent, const EncryptionResult &result, const Job *job, KMessageBox::Options options)
 {
     information(parent, result, job, i18n("Encryption Result"), options);
 }
 
 // static
 void MessageBox::information(QWidget *parent, const EncryptionResult &result, const Job *job, const QString &caption, KMessageBox::Options options)
 {
     make(parent, QMessageBox::Information, to_information_string(result), job, caption, options);
 }
 
 // static
 void MessageBox::error(QWidget *parent, const EncryptionResult &result, const Job *job, KMessageBox::Options options)
 {
     error(parent, result, job, i18n("Encryption Error"), options);
 }
 
 // static
 void MessageBox::error(QWidget *parent, const EncryptionResult &result, const Job *job, const QString &caption, KMessageBox::Options options)
 {
     make(parent, QMessageBox::Critical, to_error_string(result), job, caption, options);
 }
 
 // static
 void MessageBox::information(QWidget *parent, const SigningResult &sresult, const EncryptionResult &eresult, const Job *job, KMessageBox::Options options)
 {
     information(parent, sresult, eresult, job, i18n("Encryption Result"), options);
 }
 
 // static
 void MessageBox::information(QWidget *parent, const SigningResult &sresult, const EncryptionResult &eresult, const Job *job, const QString &caption, KMessageBox::Options options)
 {
     make(parent, QMessageBox::Information, to_information_string(sresult, eresult), job, caption, options);
 }
 
 // static
 void MessageBox::error(QWidget *parent, const SigningResult &sresult, const EncryptionResult &eresult, const Job *job, KMessageBox::Options options)
 {
     error(parent, sresult, eresult, job, i18n("Encryption Error"), options);
 }
 
 // static
 void MessageBox::error(QWidget *parent, const SigningResult &sresult, const EncryptionResult &eresult, const Job *job, const QString &caption, KMessageBox::Options options)
 {
     make(parent, QMessageBox::Critical, to_error_string(sresult, eresult), job, caption, options);
 }
 
 // static
 bool MessageBox::showAuditLogButton(const QGpgME::Job *job)
 {
     if (!job) {
         qCDebug(KLEO_UI_LOG) << "not showing audit log button (no job instance)";
         return false;
     }
     if (!GpgME::hasFeature(GpgME::AuditLogFeature, 0)) {
         qCDebug(KLEO_UI_LOG) << "not showing audit log button (gpgme too old)";
         return false;
     }
     if (!job->isAuditLogSupported()) {
         qCDebug(KLEO_UI_LOG) << "not showing audit log button (not supported)";
         return false;
     }
     if (job->auditLogError().code() == GPG_ERR_NO_DATA) {
         qCDebug(KLEO_UI_LOG) << "not showing audit log button (GPG_ERR_NO_DATA)";
         return false;
     }
     if (!job->auditLogError() && job->auditLogAsHtml().isEmpty()) {
         qCDebug(KLEO_UI_LOG) << "not showing audit log button (success, but result empty)";
         return false;
     }
     return true;
 }
 
 // static
 void MessageBox::make(QWidget *parent, QMessageBox::Icon icon, const QString &text, const Job *job, const QString &caption, KMessageBox::Options options)
 {
     QDialog *dialog = new QDialog(parent);
     dialog->setWindowTitle(caption);
     QDialogButtonBox *box = new QDialogButtonBox(showAuditLogButton(job) ? (QDialogButtonBox::Yes | QDialogButtonBox::No) : QDialogButtonBox::Yes, parent);
     QPushButton *yesButton = box->button(QDialogButtonBox::Yes);
     yesButton->setDefault(true);
     //dialog->setEscapeButton(KDialog::Yes);
     dialog->setObjectName(QStringLiteral("error"));
     dialog->setModal(true);
     KGuiItem::assign(yesButton, KStandardGuiItem::ok());
     if (GpgME::hasFeature(GpgME::AuditLogFeature, 0)) {
         KGuiItem::assign(box->button(QDialogButtonBox::No), KGuiItem(i18n("&Show Audit Log")));
     }
 
     if (QDialogButtonBox::No == KMessageBox::createKMessageBox(dialog, box, icon, text, QStringList(), QString(), nullptr, options)) {
         auditLog(nullptr, job);
     }
 }
diff --git a/src/utils/classify.cpp b/src/utils/classify.cpp
index fbccef411..69e6e3b6d 100644
--- a/src/utils/classify.cpp
+++ b/src/utils/classify.cpp
@@ -1,416 +1,416 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/classify.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "classify.h"
 
 #include "libkleo_debug.h"
 #include "kleo/checksumdefinition.h"
 
 #include <QString>
 #include <QStringList>
 #include <QFile>
 #include <QFileInfo>
 #include <QtAlgorithms>
 #include <QByteArrayMatcher>
 #include <QMap>
 #include <QRegularExpression>
 
 #include <gpgme++/data.h>
 #include <qgpgme/dataprovider.h>
 
 #include <iterator>
 #include <functional>
 
 using namespace Kleo::Class;
 
 namespace
 {
 
 const unsigned int ExamineContentHint = 0x8000;
 
 static const struct _classification {
     char extension[4];
     unsigned int classification;
 } classifications[] = {
     // ordered by extension
     { "arl", CMS    | Binary  | CertificateRevocationList },
     { "asc", OpenPGP |  Ascii  | OpaqueSignature | DetachedSignature | CipherText | AnyCertStoreType | ExamineContentHint },
     { "cer", CMS    | Binary  | Certificate },
     { "crl", CMS    | Binary  | CertificateRevocationList },
     { "crt", CMS    | Binary  | Certificate },
     { "der", CMS    | Binary  | Certificate | CertificateRevocationList },
     { "gpg", OpenPGP | Binary  | OpaqueSignature | CipherText | AnyCertStoreType | ExamineContentHint},
     { "p10", CMS    |  Ascii  | CertificateRequest },
     { "p12", CMS    | Binary  | ExportedPSM },
     { "p7c", CMS    | Binary  | Certificate  },
     { "p7m", CMS    | AnyFormat | CipherText },
     { "p7s", CMS    | AnyFormat | AnySignature },
     { "pem", CMS    |  Ascii  | AnyType | ExamineContentHint },
     { "pfx", CMS    | Binary  | Certificate },
     { "pgp", OpenPGP | Binary  | OpaqueSignature | CipherText | AnyCertStoreType | ExamineContentHint},
     { "sig", OpenPGP | AnyFormat | DetachedSignature },
 };
 
 static const QMap<GpgME::Data::Type, unsigned int> gpgmeTypeMap {
     { GpgME::Data::PGPSigned, OpenPGP | OpaqueSignature },
     /* PGPOther might be just an unencrypted unsigned pgp message. Decrypt
      * would yield the plaintext anyway so for us this is CipherText. */
     { GpgME::Data::PGPOther, OpenPGP | CipherText },
     { GpgME::Data::PGPKey, OpenPGP | Certificate },
     { GpgME::Data::CMSSigned, CMS | AnySignature },
     { GpgME::Data::CMSEncrypted, CMS | CipherText },
     /* See PGPOther */
     { GpgME::Data::CMSOther, CMS | CipherText },
     { GpgME::Data::X509Cert, CMS | Certificate},
     { GpgME::Data::PKCS12, CMS | Binary | ExportedPSM },
     { GpgME::Data::PGPEncrypted, OpenPGP | CipherText },
     { GpgME::Data::PGPSignature, OpenPGP | DetachedSignature },
 };
 
 static const unsigned int defaultClassification = NoClass;
 
 template <template <typename U> class Op>
 struct ByExtension {
-    typedef bool result_type;
+    using result_type = bool;
 
     template <typename T>
     bool operator()(const T &lhs, const T &rhs) const
     {
         return Op<int>()(qstricmp(lhs.extension, rhs.extension), 0);
     }
     template <typename T>
     bool operator()(const T &lhs, const char *rhs) const
     {
         return Op<int>()(qstricmp(lhs.extension, rhs), 0);
     }
     template <typename T>
     bool operator()(const char *lhs, const T &rhs) const
     {
         return Op<int>()(qstricmp(lhs, rhs.extension), 0);
     }
     bool operator()(const char *lhs, const char *rhs) const
     {
         return Op<int>()(qstricmp(lhs, rhs), 0);
     }
 };
 
 static const struct _content_classification {
     char content[28];
     unsigned int classification;
 } content_classifications[] = {
     { "CERTIFICATE",       Certificate },
     { "ENCRYPTED MESSAGE", CipherText  },
     { "MESSAGE",           OpaqueSignature | CipherText },
     { "PKCS12",            ExportedPSM },
     { "PRIVATE KEY BLOCK", ExportedPSM },
     { "PUBLIC KEY BLOCK",  Certificate },
     { "SIGNATURE",         DetachedSignature },
     { "SIGNED MESSAGE",    ClearsignedMessage | DetachedSignature },
 };
 
 template <template <typename U> class Op>
 struct ByContent {
-    typedef bool result_type;
+    using result_type = bool;
 
     const unsigned int N;
     explicit ByContent(unsigned int n) : N(n) {}
 
     template <typename T>
     bool operator()(const T &lhs, const T &rhs) const
     {
         return Op<int>()(qstrncmp(lhs.content, rhs.content, N), 0);
     }
     template <typename T>
     bool operator()(const T &lhs, const char *rhs) const
     {
         return Op<int>()(qstrncmp(lhs.content, rhs, N), 0);
     }
     template <typename T>
     bool operator()(const char *lhs, const T &rhs) const
     {
         return Op<int>()(qstrncmp(lhs, rhs.content, N), 0);
     }
     bool operator()(const char *lhs, const char *rhs) const
     {
         return Op<int>()(qstrncmp(lhs, rhs, N), 0);
     }
 };
 
 }
 
 unsigned int Kleo::classify(const QStringList &fileNames)
 {
     if (fileNames.empty()) {
         return 0;
     }
     unsigned int result = classify(fileNames.front());
     for (const QString &fileName : fileNames) {
         result &= classify(fileName);
     }
     return result;
 }
 
 static unsigned int classifyExtension(const QFileInfo &fi)
 {
     const _classification *const it = qBinaryFind(std::begin(classifications), std::end(classifications),
                                       fi.suffix().toLatin1().constData(),
                                       ByExtension<std::less>());
     if (it != std::end(classifications))
         if (!(it->classification & ExamineContentHint)) {
             return it->classification;
         }
 
     return it == std::end(classifications) ? defaultClassification
                                         : it->classification;
 }
 
 unsigned int Kleo::classify(const QString &filename)
 {
     Q_ASSERT(std::is_sorted(std::begin(classifications), std::end(classifications), ByExtension<std::less>()));
 
     const QFileInfo fi(filename);
 
     if (!fi.exists()) {
         return 0;
     }
 
     QFile file(filename);
     /* The least reliable but always available classification */
     const unsigned int extClass = classifyExtension(fi);
     if (!GpgME::hasFeature(0, GpgME::BinaryAndFineGrainedIdentify) &&
         !(extClass & ExamineContentHint)) {
         /* GpgME's identify and our internal Classify were so incomplete
          * before BinaryAndFineGrainedIdentify that we are better of
          * to just use the file extension if ExamineContentHint is not set. */
         qCDebug(LIBKLEO_LOG) << "Classified based only on extension.";
         return extClass;
     }
 
     if (!file.open(QIODevice::ReadOnly)) {
         qCDebug(LIBKLEO_LOG) << "Failed to open file: " << filename << " for classification.";
         return extClass;
     }
 
     /* More reliable */
     const unsigned int contentClass = classifyContent(file.read(4096));
     if (contentClass != defaultClassification) {
         qCDebug(LIBKLEO_LOG) << "Classified based on content as:" << contentClass;
         return contentClass;
     }
 
     /* Probably some X509 Stuff that GpgME in it's wisdom does not handle. Again
      * file extension is probably more reliable as the last resort. */
     qCDebug(LIBKLEO_LOG) << "No classification based on content.";
     return extClass;
 }
 
 static unsigned int classifyContentInteral(const QByteArray &data)
 {
     Q_ASSERT(std::is_sorted(std::begin(content_classifications), std::end(content_classifications), ByContent<std::less>(100)));
 
     static const char beginString[] = "-----BEGIN ";
     static const QByteArrayMatcher beginMatcher(beginString);
     int pos = beginMatcher.indexIn(data);
     if (pos < 0) {
         return defaultClassification;
     }
     pos += sizeof beginString - 1;
 
     const bool pgp = qstrncmp(data.data() + pos, "PGP ", 4) == 0;
     if (pgp) {
         pos += 4;
     }
 
     const int epos = data.indexOf("-----\n", pos);
     if (epos < 0) {
         return defaultClassification;
     }
 
     const _content_classification *const cit
         = qBinaryFind(std::begin(content_classifications), std::end(content_classifications),
                       data.data() + pos, ByContent<std::less>(epos - pos));
 
     if (cit != std::end(content_classifications)) {
         return cit->classification | (pgp ? OpenPGP : CMS);
     }
     return defaultClassification;
 }
 
 unsigned int Kleo::classifyContent(const QByteArray &data)
 {
     /* As of Version 1.6.0 GpgME does not distinguish between detached
      * signatures and signatures. So we prefer kleo's classification and
      * only use gpgme as fallback.
      * With newer versions we have a better identify that really inspects
      * the PGP Packages. Which is by far the most reliable classification.
      * So this is already used for the default classification. File extensions
      * and our classifyinternal is only used as a fallback.
      */
     if (!GpgME::hasFeature(0, GpgME::BinaryAndFineGrainedIdentify)) {
         unsigned int ourClassification = classifyContentInteral(data);
         if (ourClassification != defaultClassification) {
             return ourClassification;
         }
     }
     QGpgME::QByteArrayDataProvider dp(data);
     GpgME::Data gpgmeData(&dp);
     GpgME::Data::Type type = gpgmeData.type();
 
     return gpgmeTypeMap.value(type, defaultClassification);
 }
 
 QString Kleo::printableClassification(unsigned int classification)
 {
     QStringList parts;
     if (classification & CMS) {
         parts.push_back(QStringLiteral("CMS"));
     }
     if (classification & OpenPGP) {
         parts.push_back(QStringLiteral("OpenPGP"));
     }
     if (classification & Binary) {
         parts.push_back(QStringLiteral("Binary"));
     }
     if (classification & Ascii) {
         parts.push_back(QStringLiteral("Ascii"));
     }
     if (classification & DetachedSignature) {
         parts.push_back(QStringLiteral("DetachedSignature"));
     }
     if (classification & OpaqueSignature) {
         parts.push_back(QStringLiteral("OpaqueSignature"));
     }
     if (classification & ClearsignedMessage) {
         parts.push_back(QStringLiteral("ClearsignedMessage"));
     }
     if (classification & CipherText) {
         parts.push_back(QStringLiteral("CipherText"));
     }
     if (classification & Certificate) {
         parts.push_back(QStringLiteral("Certificate"));
     }
     if (classification & ExportedPSM) {
         parts.push_back(QStringLiteral("ExportedPSM"));
     }
     if (classification & CertificateRequest) {
         parts.push_back(QStringLiteral("CertificateRequest"));
     }
     return parts.join(QLatin1String(", "));
 }
 
 static QString chopped(QString s, unsigned int n)
 {
     s.chop(n);
     return s;
 }
 
 /*!
   \return the data file that corresponds to the signature file \a
   signatureFileName, or QString(), if no such file can be found.
 */
 QString Kleo::findSignedData(const QString &signatureFileName)
 {
     if (!mayBeDetachedSignature(signatureFileName)) {
         return QString();
     }
     const QString baseName = chopped(signatureFileName, 4);
     return QFile::exists(baseName) ? baseName : QString();
 }
 
 /*!
   \return all (existing) candidate signature files for \a signedDataFileName
 
   Note that there can very well be more than one such file, e.g. if
   the same data file was signed by both CMS and OpenPGP certificates.
 */
 QStringList Kleo::findSignatures(const QString &signedDataFileName)
 {
     QStringList result;
     for (unsigned int i = 0, end = sizeof(classifications) / sizeof(_classification); i < end; ++i)
         if (classifications[i].classification & DetachedSignature) {
             const QString candidate = signedDataFileName + QLatin1Char('.') + QLatin1String(classifications[i].extension);
             if (QFile::exists(candidate)) {
                 result.push_back(candidate);
             }
         }
     return result;
 }
 
 /*!
   \return the (likely) output filename for \a inputFileName, or
   "inputFileName.out" if none can be determined.
 */
 QString Kleo::outputFileName(const QString &inputFileName)
 {
     const QFileInfo fi(inputFileName);
 
     if (qBinaryFind(std::begin(classifications), std::end(classifications),
                     fi.suffix().toLatin1().constData(),
                     ByExtension<std::less>()) == std::end(classifications)) {
         return inputFileName + QLatin1String(".out");
     } else {
         return chopped(inputFileName, 4);
     }
 }
 
 /*!
   \return the commonly used extension for files of type
   \a classification, or NULL if none such exists.
 */
 const char *Kleo::outputFileExtension(unsigned int classification, bool usePGPFileExt)
 {
 
     if (classification & OpenPGP && usePGPFileExt) {
         return "pgp";
     }
 
     for (unsigned int i = 0; i < sizeof classifications / sizeof * classifications; ++i)
         if ((classifications[i].classification & classification) == classification) {
             return classifications[i].extension;
         }
     return nullptr;
 }
 
 bool Kleo::isFingerprint(const QString &fpr)
 {
     static QRegularExpression fprRegex(QStringLiteral("[0-9a-fA-F]{40}"));
     return fprRegex.match(fpr).hasMatch();
 }
 
 bool Kleo::isChecksumFile(const QString &file)
 {
     static bool initialized;
     static QList<QRegExp> patterns;
     const QFileInfo fi(file);
     if (!fi.exists()) {
         return false;
     }
     if (!initialized) {
         Q_FOREACH (const std::shared_ptr<ChecksumDefinition> &cd, ChecksumDefinition::getChecksumDefinitions()) {
             if (cd) {
                 Q_FOREACH (const QString &pattern, cd->patterns()) {
 #ifdef Q_OS_WIN
                     patterns << QRegExp(pattern, Qt::CaseInsensitive);
 #else
                     patterns << QRegExp(pattern, Qt::CaseSensitive);
 #endif
                 }
             }
         }
         initialized = true;
     }
 
     const QString fileName = fi.fileName();
     for (const QRegExp &pattern : qAsConst(patterns)) {
         if (pattern.exactMatch(fileName)) {
             return true;
         }
     }
     return false;
 }
diff --git a/src/utils/formatting.cpp b/src/utils/formatting.cpp
index bacff1a01..302bfe105 100644
--- a/src/utils/formatting.cpp
+++ b/src/utils/formatting.cpp
@@ -1,1061 +1,1061 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; -*-
 
     utils/formatting.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "formatting.h"
 #include "kleo/dn.h"
 #include "kleo/keyfiltermanager.h"
 
 #include <gpgme++/key.h>
 #include <gpgme++/importresult.h>
 
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 
 #include <KLocalizedString>
 #include <KEmailAddress>
 
 #include <QString>
 #include <QStringList>
 #include <QDateTime>
 #include <QTextDocument> // for Qt::escape
 #include <QLocale>
 #include <QIcon>
 #include <QRegularExpression>
 
 #include "models/keycache.h"
 
 using namespace GpgME;
 using namespace Kleo;
 
 //
 // Name
 //
 
 QString Formatting::prettyName(int proto, const char *id, const char *name_, const char *comment_)
 {
 
     if (proto == OpenPGP) {
         const QString name = QString::fromUtf8(name_);
         if (name.isEmpty()) {
             return QString();
         }
         const QString comment = QString::fromUtf8(comment_);
         if (comment.isEmpty()) {
             return name;
         }
         return QStringLiteral("%1 (%2)").arg(name, comment);
     }
 
     if (proto == CMS) {
         const DN subject(id);
         const QString cn = subject[QStringLiteral("CN")].trimmed();
         if (cn.isEmpty()) {
             return subject.prettyDN();
         }
         return cn;
     }
 
     return QString();
 }
 
 QString Formatting::prettyNameAndEMail(int proto, const char *id, const char *name_, const char *email_, const char *comment_)
 {
     return prettyNameAndEMail(proto, QString::fromUtf8(id), QString::fromUtf8(name_), prettyEMail(email_, id), QString::fromUtf8(comment_));
 }
 
 QString Formatting::prettyNameAndEMail(int proto, const QString &id, const QString &name, const QString &email, const QString &comment)
 {
 
     if (proto == OpenPGP) {
         if (name.isEmpty()) {
             if (email.isEmpty()) {
                 return QString();
             } else if (comment.isEmpty()) {
                 return QStringLiteral("<%1>").arg(email);
             } else {
                 return QStringLiteral("(%2) <%1>").arg(email, comment);
             }
         }
         if (email.isEmpty()) {
             if (comment.isEmpty()) {
                 return name;
             } else {
                 return QStringLiteral("%1 (%2)").arg(name, comment);
             }
         }
         if (comment.isEmpty()) {
             return QStringLiteral("%1 <%2>").arg(name, email);
         } else {
             return QStringLiteral("%1 (%3) <%2>").arg(name, email, comment);
         }
     }
 
     if (proto == CMS) {
         const DN subject(id);
         const QString cn = subject[QStringLiteral("CN")].trimmed();
         if (cn.isEmpty()) {
             return subject.prettyDN();
         }
         return cn;
     }
     return QString();
 }
 
 QString Formatting::prettyUserID(const UserID &uid)
 {
     if (uid.parent().protocol() == OpenPGP) {
         return prettyNameAndEMail(uid);
     }
     const QByteArray id = QByteArray(uid.id()).trimmed();
     if (id.startsWith('<')) {
         return prettyEMail(uid.email(), uid.id());
     }
     if (id.startsWith('('))
         // ### parse uri/dns:
     {
         return QString::fromUtf8(uid.id());
     } else {
         return DN(uid.id()).prettyDN();
     }
 }
 
 QString Formatting::prettyKeyID(const char *id)
 {
     if (!id) {
         return QString();
     }
     return QLatin1String("0x") + QString::fromLatin1(id).toUpper();
 }
 
 QString Formatting::prettyNameAndEMail(const UserID &uid)
 {
     return prettyNameAndEMail(uid.parent().protocol(), uid.id(), uid.name(), uid.email(), uid.comment());
 }
 
 QString Formatting::prettyNameAndEMail(const Key &key)
 {
     return prettyNameAndEMail(key.userID(0));
 }
 
 QString Formatting::prettyName(const Key &key)
 {
     return prettyName(key.userID(0));
 }
 
 QString Formatting::prettyName(const UserID &uid)
 {
     return prettyName(uid.parent().protocol(), uid.id(), uid.name(), uid.comment());
 }
 
 QString Formatting::prettyName(const UserID::Signature &sig)
 {
     return prettyName(OpenPGP, sig.signerUserID(), sig.signerName(), sig.signerComment());
 }
 
 //
 // EMail
 //
 
 QString Formatting::prettyEMail(const Key &key)
 {
     for (unsigned int i = 0, end = key.numUserIDs(); i < end; ++i) {
         const QString email = prettyEMail(key.userID(i));
         if (!email.isEmpty()) {
             return email;
         }
     }
     return QString();
 }
 
 QString Formatting::prettyEMail(const UserID &uid)
 {
     return prettyEMail(uid.email(), uid.id());
 }
 
 QString Formatting::prettyEMail(const UserID::Signature &sig)
 {
     return prettyEMail(sig.signerEmail(), sig.signerUserID());
 }
 
 QString Formatting::prettyEMail(const char *email_, const char *id)
 {
     QString email, name, comment;
     if (email_ && KEmailAddress::splitAddress(QString::fromUtf8(email_),
                                               name, email, comment) == KEmailAddress::AddressOk) {
         return email;
     } else {
         return DN(id)[QStringLiteral("EMAIL")].trimmed();
     }
 }
 
 //
 // Tooltip
 //
 
 namespace
 {
 
 static QString protect_whitespace(QString s)
 {
     static const QLatin1Char SP(' '), NBSP('\xA0');
     return s.replace(SP, NBSP);
 }
 
 template <typename T_arg>
 QString format_row(const QString &field, const T_arg &arg)
 {
     return QStringLiteral("<tr><th>%1:</th><td>%2</td></tr>").arg(protect_whitespace(field), arg);
 }
 QString format_row(const QString &field, const QString &arg)
 {
     return QStringLiteral("<tr><th>%1:</th><td>%2</td></tr>").arg(protect_whitespace(field), arg.toHtmlEscaped());
 }
 QString format_row(const QString &field, const char *arg)
 {
     return format_row(field, QString::fromUtf8(arg));
 }
 
 QString format_keytype(const Key &key)
 {
     const Subkey subkey = key.subkey(0);
     if (key.hasSecret()) {
         return i18n("%1-bit %2 (secret key available)", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
     } else {
         return i18n("%1-bit %2", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
     }
 }
 
 QString format_subkeytype(const Subkey &subkey)
 {
     const auto algo = subkey.publicKeyAlgorithm();
 
     if (algo == Subkey::AlgoECC ||
         algo == Subkey::AlgoECDSA ||
         algo == Subkey::AlgoECDH ||
         algo == Subkey::AlgoEDDSA) {
         return QString::fromStdString(subkey.algoName());
     }
     return i18n("%1-bit %2", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
 }
 
 QString format_keyusage(const Key &key)
 {
     QStringList capabilities;
     if (key.canReallySign()) {
         if (key.isQualified()) {
             capabilities.push_back(i18n("Signing (Qualified)"));
         } else {
             capabilities.push_back(i18n("Signing"));
         }
     }
     if (key.canEncrypt()) {
         capabilities.push_back(i18n("Encryption"));
     }
     if (key.canCertify()) {
         capabilities.push_back(i18n("Certifying User-IDs"));
     }
     if (key.canAuthenticate()) {
         capabilities.push_back(i18n("SSH Authentication"));
     }
     return capabilities.join(QLatin1String(", "));
 }
 
 QString format_subkeyusage(const Subkey &subkey)
 {
     QStringList capabilities;
     if (subkey.canSign()) {
         if (subkey.isQualified()) {
             capabilities.push_back(i18n("Signing (Qualified)"));
         } else {
             capabilities.push_back(i18n("Signing"));
         }
     }
     if (subkey.canEncrypt()) {
         capabilities.push_back(i18n("Encryption"));
     }
     if (subkey.canCertify()) {
         capabilities.push_back(i18n("Certifying User-IDs"));
     }
     if (subkey.canAuthenticate()) {
         capabilities.push_back(i18n("SSH Authentication"));
     }
     return capabilities.join(QLatin1String(", "));
 }
 
 static QString time_t2string(time_t t)
 {
     QDateTime dt;
     dt.setTime_t(t);
     return QLocale().toString(dt, QLocale::ShortFormat);
 }
 
 static QString make_red(const QString &txt)
 {
     return QLatin1String("<font color=\"red\">") + txt.toHtmlEscaped() + QLatin1String("</font>");
 }
 
 }
 
 QString Formatting::toolTip(const Key &key, int flags)
 {
     if (flags == 0 || (key.protocol() != CMS && key.protocol() != OpenPGP)) {
         return QString();
     }
 
     const Subkey subkey = key.subkey(0);
 
     QString result;
     if (flags & Validity) {
         if (key.protocol() == OpenPGP || (key.keyListMode() & Validate))
             if (key.isRevoked()) {
                 result = make_red(i18n("Revoked"));
             } else if (key.isExpired()) {
                 result = make_red(i18n("Expired"));
             } else if (key.isDisabled()) {
                 result = i18n("Disabled");
             } else {
                 unsigned int fullyTrusted = 0;
                 for (const auto &uid: key.userIDs()) {
                     if (uid.validity() >= UserID::Validity::Full) {
                         fullyTrusted++;
                     }
                 }
                 if (fullyTrusted == key.numUserIDs()) {
                     result = i18n("All User-IDs are certified.");
                     const auto compliance = complianceStringForKey(key);
                     if (!compliance.isEmpty()) {
                         result += QStringLiteral("<br>") + compliance;
                     }
                 } else {
                     result = i18np("One User-ID is not certified.", "%1 User-IDs are not certified.", key.numUserIDs() - fullyTrusted);
                 }
             }
         else {
             result = i18n("The validity cannot be checked at the moment.");
         }
     }
     if (flags == Validity) {
         return result;
     }
 
     result += QLatin1String("<table border=\"0\">");
     if (key.protocol() == CMS) {
         if (flags & SerialNumber) {
             result += format_row(i18n("Serial number"), key.issuerSerial());
         }
         if (flags & Issuer) {
             result += format_row(i18n("Issuer"), key.issuerName());
         }
     }
     if (flags & UserIDs) {
         const std::vector<UserID> uids = key.userIDs();
         if (!uids.empty())
             result += format_row(key.protocol() == CMS
                                  ? i18n("Subject")
                                  : i18n("User-ID"), prettyUserID(uids.front()));
         if (uids.size() > 1)
-            for (std::vector<UserID>::const_iterator it = uids.begin() + 1, end = uids.end(); it != end; ++it)
+            for (auto it = uids.begin() + 1, end = uids.end(); it != end; ++it)
                 if (!it->isRevoked() && !it->isInvalid()) {
                     result += format_row(i18n("a.k.a."), prettyUserID(*it));
                 }
     }
     if (flags & ExpiryDates) {
         result += format_row(i18n("Created"), time_t2string(subkey.creationTime()));
 
         if (key.isExpired()) {
             result += format_row(i18n("Expired"), time_t2string(subkey.expirationTime()));
         } else if (!subkey.neverExpires()) {
             result += format_row(i18n("Expires"), time_t2string(subkey.expirationTime()));
         }
     }
     if (flags & CertificateType) {
         result += format_row(i18n("Type"), format_keytype(key));
     }
     if (flags & CertificateUsage) {
         result += format_row(i18n("Usage"), format_keyusage(key));
     }
     if (flags & KeyID) {
         result += format_row(i18n("Key-ID"), QString::fromLatin1(key.shortKeyID()));
     }
     if (flags & Fingerprint) {
         result += format_row(i18n("Fingerprint"), key.primaryFingerprint());
     }
     if (flags & OwnerTrust) {
         if (key.protocol() == OpenPGP) {
             result += format_row(i18n("Certification trust"), ownerTrustShort(key));
         } else if (key.isRoot()) {
             result += format_row(i18n("Trusted issuer?"),
                                  key.userID(0).validity() == UserID::Ultimate ? i18n("Yes") :
                                  /* else */                                     i18n("No"));
         }
     }
 
     if (flags & StorageLocation) {
         if (const char *card = subkey.cardSerialNumber()) {
             result += format_row(i18n("Stored"), i18nc("stored...", "on SmartCard with serial no. %1", QString::fromUtf8(card)));
         } else {
             result += format_row(i18n("Stored"), i18nc("stored...", "on this computer"));
         }
     }
     if (flags & Subkeys) {
         for (const auto &sub: key.subkeys()) {
             result += QLatin1String("<hr/>");
             result += format_row(i18n("Subkey"), sub.fingerprint());
             if (sub.isRevoked()) {
                 result += format_row(i18n("Status"), i18n("Revoked"));
             } else if (sub.isExpired()) {
                 result += format_row(i18n("Status"), i18n("Expired"));
             }
             if (flags & ExpiryDates) {
                 result += format_row(i18n("Created"), time_t2string(sub.creationTime()));
 
                 if (key.isExpired()) {
                     result += format_row(i18n("Expired"), time_t2string(sub.expirationTime()));
                 } else if (!subkey.neverExpires()) {
                     result += format_row(i18n("Expires"), time_t2string(sub.expirationTime()));
                 }
             }
 
             if (flags & CertificateType) {
                 result += format_row(i18n("Type"), format_subkeytype(sub));
             }
             if (flags & CertificateUsage) {
                 result += format_row(i18n("Usage"), format_subkeyusage(sub));
             }
             if (flags & StorageLocation) {
                 if (const char *card = sub.cardSerialNumber()) {
                     result += format_row(i18n("Stored"), i18nc("stored...", "on SmartCard with serial no. %1", QString::fromUtf8(card)));
                 } else {
                     result += format_row(i18n("Stored"), i18nc("stored...", "on this computer"));
                 }
             }
         }
     }
     result += QLatin1String("</table>");
 
     return result;
 }
 
 //
 // Creation and Expiration
 //
 
 namespace
 {
 static QDate time_t2date(time_t t)
 {
     if (!t) {
-        return QDate();
+        return {};
     }
     QDateTime dt;
     dt.setTime_t(t);
     return dt.date();
 }
 static QString date2string(const QDate &date)
 {
     return QLocale().toString(date, QLocale::ShortFormat);
 }
 
 template <typename T>
 QString expiration_date_string(const T &tee)
 {
     return tee.neverExpires() ? QString() : date2string(time_t2date(tee.expirationTime()));
 }
 template <typename T>
 QDate creation_date(const T &tee)
 {
     return time_t2date(tee.creationTime());
 }
 template <typename T>
 QDate expiration_date(const T &tee)
 {
     return time_t2date(tee.expirationTime());
 }
 }
 
 QString Formatting::dateString(time_t t)
 {
     return date2string(time_t2date(t));
 }
 
 QString Formatting::expirationDateString(const Key &key)
 {
     return expiration_date_string(key.subkey(0));
 }
 
 QString Formatting::expirationDateString(const Subkey &subkey)
 {
     return expiration_date_string(subkey);
 }
 
 QString Formatting::expirationDateString(const UserID::Signature &sig)
 {
     return expiration_date_string(sig);
 }
 
 QDate Formatting::expirationDate(const Key &key)
 {
     return expiration_date(key.subkey(0));
 }
 
 QDate Formatting::expirationDate(const Subkey &subkey)
 {
     return expiration_date(subkey);
 }
 
 QDate Formatting::expirationDate(const UserID::Signature &sig)
 {
     return expiration_date(sig);
 }
 
 QString Formatting::creationDateString(const Key &key)
 {
     return date2string(creation_date(key.subkey(0)));
 }
 
 QString Formatting::creationDateString(const Subkey &subkey)
 {
     return date2string(creation_date(subkey));
 }
 
 QString Formatting::creationDateString(const UserID::Signature &sig)
 {
     return date2string(creation_date(sig));
 }
 
 QDate Formatting::creationDate(const Key &key)
 {
     return creation_date(key.subkey(0));
 }
 
 QDate Formatting::creationDate(const Subkey &subkey)
 {
     return creation_date(subkey);
 }
 
 QDate Formatting::creationDate(const UserID::Signature &sig)
 {
     return creation_date(sig);
 }
 
 //
 // Types
 //
 
 QString Formatting::displayName(Protocol p)
 {
     if (p == CMS) {
         return i18nc("X.509/CMS encryption standard", "S/MIME");
     }
     if (p == OpenPGP) {
         return i18n("OpenPGP");
     }
     return i18nc("Unknown encryption protocol", "Unknown");
 }
 
 QString Formatting::type(const Key &key)
 {
     return displayName(key.protocol());
 }
 
 QString Formatting::type(const Subkey &subkey)
 {
     return QString::fromUtf8(subkey.publicKeyAlgorithmAsString());
 }
 
 //
 // Status / Validity
 //
 
 QString Formatting::ownerTrustShort(const Key &key)
 {
     return ownerTrustShort(key.ownerTrust());
 }
 
 QString Formatting::ownerTrustShort(Key::OwnerTrust trust)
 {
     switch (trust) {
     case Key::Unknown:   return i18nc("unknown trust level", "unknown");
     case Key::Never:     return i18n("untrusted");
     case Key::Marginal:  return i18nc("marginal trust", "marginal");
     case Key::Full:      return i18nc("full trust", "full");
     case Key::Ultimate:  return i18nc("ultimate trust", "ultimate");
     case Key::Undefined: return i18nc("undefined trust", "undefined");
     default:
         Q_ASSERT(!"unexpected owner trust value");
         break;
     }
     return QString();
 }
 
 QString Formatting::validityShort(const Subkey &subkey)
 {
     if (subkey.isRevoked()) {
         return i18n("revoked");
     }
     if (subkey.isExpired()) {
         return i18n("expired");
     }
     if (subkey.isDisabled()) {
         return i18n("disabled");
     }
     if (subkey.isInvalid()) {
         return i18n("invalid");
     }
     return i18nc("as in good/valid signature", "good");
 }
 
 QString Formatting::validityShort(const UserID &uid)
 {
     if (uid.isRevoked()) {
         return i18n("revoked");
     }
     if (uid.isInvalid()) {
         return i18n("invalid");
     }
     switch (uid.validity()) {
     case UserID::Unknown:   return i18nc("unknown trust level", "unknown");
     case UserID::Undefined: return i18nc("undefined trust", "undefined");
     case UserID::Never:     return i18n("untrusted");
     case UserID::Marginal:  return i18nc("marginal trust", "marginal");
     case UserID::Full:      return i18nc("full trust", "full");
     case UserID::Ultimate:  return i18nc("ultimate trust", "ultimate");
     }
     return QString();
 }
 
 QString Formatting::validityShort(const UserID::Signature &sig)
 {
     switch (sig.status()) {
     case UserID::Signature::NoError:
         if (!sig.isInvalid()) {
             /* See RFC 4880 Section 5.2.1 */
             switch (sig.certClass()) {
             case 0x10: /* Generic */
             case 0x11: /* Persona */
             case 0x12: /* Casual */
             case 0x13: /* Positive */
                 return i18n("valid");
             case 0x30:
                 return i18n("revoked");
             default:
                 return i18n("class %1", sig.certClass());
             }
         }
         Q_FALLTHROUGH();
         // fall through:
     case UserID::Signature::GeneralError:
         return i18n("invalid");
     case UserID::Signature::SigExpired:   return i18n("expired");
     case UserID::Signature::KeyExpired:   return i18n("certificate expired");
     case UserID::Signature::BadSignature: return i18nc("fake/invalid signature", "bad");
     case UserID::Signature::NoPublicKey: {
             /* GnuPG returns the same error for no public key as for expired
              * or revoked certificates. */
             const auto key = KeyCache::instance()->findByKeyIDOrFingerprint (sig.signerKeyID());
             if (key.isNull()) {
                 return i18n("no public key");
             } else if (key.isExpired()) {
                 return i18n("key expired");
             } else if (key.isRevoked()) {
                 return i18n("key revoked");
             } else if (key.isDisabled()) {
                 return i18n("key disabled");
             }
             /* can't happen */
             return QStringLiteral("unknown");
         }
     }
     return QString();
 }
 
 QIcon Formatting::validityIcon(const UserID::Signature &sig)
 {
     switch (sig.status()) {
     case UserID::Signature::NoError:
         if (!sig.isInvalid()) {
             /* See RFC 4880 Section 5.2.1 */
             switch (sig.certClass()) {
             case 0x10: /* Generic */
             case 0x11: /* Persona */
             case 0x12: /* Casual */
             case 0x13: /* Positive */
                 return QIcon::fromTheme(QStringLiteral("emblem-success"));
             case 0x30:
                 return QIcon::fromTheme(QStringLiteral("emblem-error"));
             default:
                 return QIcon();
             }
         }
         Q_FALLTHROUGH();
         // fall through:
     case UserID::Signature::BadSignature:
     case UserID::Signature::GeneralError:
         return QIcon::fromTheme(QStringLiteral("emblem-error"));
     case UserID::Signature::SigExpired:
     case UserID::Signature::KeyExpired:
         return QIcon::fromTheme(QStringLiteral("emblem-information"));
     case UserID::Signature::NoPublicKey:
         return QIcon::fromTheme(QStringLiteral("emblem-question"));
     }
     return QIcon();
 }
 
 QString Formatting::formatKeyLink(const Key &key)
 {
     if (key.isNull()) {
         return QString();
     }
     return QStringLiteral("<a href=\"key:%1\">%2</a>").arg(QLatin1String(key.primaryFingerprint()), Formatting::prettyName(key));
 }
 
 QString Formatting::formatForComboBox(const GpgME::Key &key)
 {
     const QString name = prettyName(key);
     QString mail = prettyEMail(key);
     if (!mail.isEmpty()) {
         mail = QLatin1Char('<') + mail + QLatin1Char('>');
     }
     return i18nc("name, email, key id", "%1 %2 (%3)", name, mail, QLatin1String(key.shortKeyID())).simplified();
 }
 
 namespace
 {
 
 static QString keyToString(const Key &key)
 {
 
     Q_ASSERT(!key.isNull());
 
     const QString email = Formatting::prettyEMail(key);
     const QString name = Formatting::prettyName(key);
 
     if (name.isEmpty()) {
         return email;
     } else if (email.isEmpty()) {
         return name;
     } else {
         return QStringLiteral("%1 <%2>").arg(name, email);
     }
 }
 
 }
 
 const char *Formatting::summaryToString(const Signature::Summary summary)
 {
     if (summary & Signature::Red) {
         return "RED";
     }
     if (summary & Signature::Green) {
         return "GREEN";
     }
     return "YELLOW";
 }
 
 QString Formatting::signatureToString(const Signature &sig, const Key &key)
 {
     if (sig.isNull()) {
         return QString();
     }
 
     const bool red   = (sig.summary() & Signature::Red);
     const bool valid = (sig.summary() & Signature::Valid);
 
     if (red)
         if (key.isNull())
             if (const char *fpr = sig.fingerprint()) {
                 return i18n("Bad signature by unknown certificate %1: %2", QString::fromLatin1(fpr), QString::fromLocal8Bit(sig.status().asString()));
             } else {
                 return i18n("Bad signature by an unknown certificate: %1", QString::fromLocal8Bit(sig.status().asString()));
             }
         else {
             return i18n("Bad signature by %1: %2", keyToString(key), QString::fromLocal8Bit(sig.status().asString()));
         }
 
     else if (valid)
         if (key.isNull())
             if (const char *fpr = sig.fingerprint()) {
                 return i18n("Good signature by unknown certificate %1.", QString::fromLatin1(fpr));
             } else {
                 return i18n("Good signature by an unknown certificate.");
             }
         else {
             return i18n("Good signature by %1.", keyToString(key));
         }
 
     else if (key.isNull())
         if (const char *fpr = sig.fingerprint()) {
             return i18n("Invalid signature by unknown certificate %1: %2", QString::fromLatin1(fpr), QString::fromLocal8Bit(sig.status().asString()));
         } else {
             return i18n("Invalid signature by an unknown certificate: %1", QString::fromLocal8Bit(sig.status().asString()));
         }
     else {
         return i18n("Invalid signature by %1: %2", keyToString(key), QString::fromLocal8Bit(sig.status().asString()));
     }
 }
 
 //
 // ImportResult
 //
 
 QString Formatting::importMetaData(const Import &import, const QStringList &ids)
 {
     const QString result = importMetaData(import);
     if (result.isEmpty()) {
         return QString();
     } else
         return result + QLatin1Char('\n') +
                i18n("This certificate was imported from the following sources:") + QLatin1Char('\n') +
                ids.join(QLatin1Char('\n'));
 }
 
 QString Formatting::importMetaData(const Import &import)
 {
 
     if (import.isNull()) {
         return QString();
     }
 
     if (import.error().isCanceled()) {
         return i18n("The import of this certificate was canceled.");
     }
     if (import.error())
         return i18n("An error occurred importing this certificate: %1",
                     QString::fromLocal8Bit(import.error().asString()));
 
     const unsigned int status = import.status();
     if (status & Import::NewKey)
         return (status & Import::ContainedSecretKey)
                ? i18n("This certificate was new to your keystore. The secret key is available.")
                : i18n("This certificate is new to your keystore.");
 
     QStringList results;
     if (status & Import::NewUserIDs) {
         results.push_back(i18n("New user-ids were added to this certificate by the import."));
     }
     if (status & Import::NewSignatures) {
         results.push_back(i18n("New signatures were added to this certificate by the import."));
     }
     if (status & Import::NewSubkeys) {
         results.push_back(i18n("New subkeys were added to this certificate by the import."));
     }
 
     return results.empty()
            ? i18n("The import contained no new data for this certificate. It is unchanged.")
            : results.join(QLatin1Char('\n'));
 }
 
 //
 // Overview in CertificateDetailsDialog
 //
 
 QString Formatting::formatOverview(const Key &key)
 {
     return toolTip(key, AllOptions);
 }
 
 QString Formatting::usageString(const Subkey &sub)
 {
     QStringList usageStrings;
     if (sub.canCertify()) {
         usageStrings << i18n("Certify");
     }
     if (sub.canSign()) {
         usageStrings << i18n("Sign");
     }
     if (sub.canEncrypt()) {
         usageStrings << i18n("Encrypt");
     }
     if (sub.canAuthenticate()) {
         usageStrings << i18n("Authenticate");
     }
     return usageStrings.join(QLatin1String(", "));
 }
 
 QString Formatting::summaryLine(const Key &key)
 {
     return keyToString(key) + QLatin1Char(' ') +
            i18nc("(validity, protocol, creation date)",
                  "(%1, %2, created: %3)",
 		 Formatting::complianceStringShort(key),
 		 displayName(key.protocol()),
                  Formatting::creationDateString(key));
 }
 
 // Icon for certificate selection indication
 QIcon Formatting::iconForUid(const UserID &uid)
 {
     switch (uid.validity()) {
         case UserID::Ultimate:
         case UserID::Full:
         case UserID::Marginal:
             return QIcon::fromTheme(QStringLiteral("emblem-success"));
         case UserID::Never:
             return QIcon::fromTheme(QStringLiteral("emblem-error"));
         case UserID::Undefined:
         case UserID::Unknown:
         default:
             return QIcon::fromTheme(QStringLiteral("emblem-information"));
     }
 }
 
 QString Formatting::validity(const UserID &uid)
 {
     switch (uid.validity()) {
         case UserID::Ultimate:
             return i18n("The certificate is marked as your own.");
         case UserID::Full:
             return i18n("The certificate belongs to this recipient.");
         case UserID::Marginal:
             return i18n("The trust model indicates marginally that the certificate belongs to this recipient.");
         case UserID::Never:
             return i18n("This certificate should not be used.");
         case UserID::Undefined:
         case UserID::Unknown:
         default:
             return i18n("There is no indication that this certificate belongs to this recipient.");
     }
 }
 
 bool Formatting::uidsHaveFullValidity(const GpgME::Key &key)
 {
     bool oneValid = false;
     for (const auto &uid: key.userIDs()) {
         if (uid.isRevoked()) {
             /* Skip revoked uids */
             continue;
         }
         if (uid.validity() < UserID::Validity::Full) {
             return false;
         }
         /* Only return true if we have found at least one
          * valid uid. E.g. if all uids are revoked we do
          * not want to return true here. */
         oneValid = true;
     }
     return oneValid;
 }
 
 QString Formatting::complianceMode()
 {
     const QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
     if (!config) {
         return QString();
     }
     const QGpgME::CryptoConfigEntry *const entry = config->entry(QStringLiteral("gpg"), QStringLiteral("Configuration"), QStringLiteral("compliance"));
 
     if (!entry || entry->stringValue() == QLatin1String("gnupg")) {
         return QString();
     }
     return entry->stringValue();
 }
 
 bool Formatting::isKeyDeVs(const GpgME::Key &key)
 {
     for (const auto &sub: key.subkeys()) {
         if (sub.isExpired() || sub.isRevoked()) {
             // Ignore old subkeys
             continue;
         }
         if (!sub.isDeVs()) {
             return false;
         }
     }
     return true;
 }
 
 QString Formatting::complianceStringForKey(const GpgME::Key &key)
 {
     // There will likely be more in the future for other institutions
     // for now we only have DE-VS
     if (complianceMode() == QLatin1String("de-vs")) {
         if (uidsHaveFullValidity(key) && isKeyDeVs(key)) {
             return i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                          "May be used for %1 communication.", deVsString());
         } else {
             return i18nc("VS-NfD-conforming is a German standard for restricted documents. For which special restrictions about algorithms apply. The string describes if a key is compliant to that..",
                          "May <b>not</b> be used for %1 communication.", deVsString());
         }
     }
     return QString();
 }
 
 QString Formatting::complianceStringShort(const GpgME::Key &key)
 {
     if (Formatting::uidsHaveFullValidity(key)) {
         if (complianceMode() == QLatin1String("de-vs")
             && Formatting::isKeyDeVs(key)) {
             return QStringLiteral("★ ") + deVsString(true);
         }
         return i18nc("As in all user IDs are valid.", "certified");
     }
     if (key.isExpired()) {
         return i18n("expired");
     }
     if (key.isRevoked()) {
         return i18n("revoked");
     }
     if (key.isDisabled()) {
         return i18n("disabled");
     }
     if (key.isInvalid()) {
         return i18n("invalid");
     }
 
     return i18nc("As in not all user IDs are valid.", "not certified");
 }
 
 QString Formatting::prettyID(const char *id)
 {
     if (!id) {
         return QString();
     }
     QString ret = QString::fromLatin1(id).toUpper().replace(QRegularExpression(QStringLiteral("(....)")),
                                                             QStringLiteral("\\1 ")).trimmed();
     // For the standard 10 group fingerprint let us use a double space in the
     // middle to increase readability
     if (ret.size() == 49) {
         ret.insert(24, QLatin1Char(' '));
     }
     return ret;
 }
 
 QString Formatting::origin(int o)
 {
     switch (o) {
         case Key::OriginKS:
             return i18n("Keyserver");
         case Key::OriginDane:
             return QStringLiteral("DANE");
         case Key::OriginWKD:
             return QStringLiteral("WKD");
         case Key::OriginURL:
             return QStringLiteral("URL");
         case Key::OriginFile:
             return i18n("File import");
         case Key::OriginSelf:
             return i18n("Generated");
         case Key::OriginOther:
         case Key::OriginUnknown:
         default:
           return i18n("Unknown");
     }
 }
 
 QString Formatting::deVsString(bool compliant)
 {
     const auto filter = KeyFilterManager::instance()->keyFilterByID(compliant ?
             QStringLiteral("de-vs-filter") :
             QStringLiteral("not-de-vs-filter"));
     if (!filter) {
         return compliant ? i18n("VS-NfD compliant") : i18n("Not VS-NfD compliant");
     }
     return filter->name();
 }
diff --git a/src/utils/gnupg.cpp b/src/utils/gnupg.cpp
index ccc852972..586f8ec31 100644
--- a/src/utils/gnupg.cpp
+++ b/src/utils/gnupg.cpp
@@ -1,509 +1,509 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/gnupg.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "gnupg.h"
 
 #include "utils/hex.h"
 
 #include <gpgme++/engineinfo.h>
 #include <gpgme++/error.h>
 #include <gpgme++/key.h>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/CryptoConfig>
 
 #include "libkleo_debug.h"
 
 #include <QDir>
 #include <QFile>
 #include <QString>
 #include <QProcess>
 #include <QByteArray>
 #include <QStandardPaths>
 #include <QCoreApplication>
 #include <gpg-error.h>
 
 #ifdef Q_OS_WIN
 #include "gnupg-registry.h"
 #endif // Q_OS_WIN
 
 #include <algorithm>
 #include <array>
 
 #include <KLocalizedString>
 
 using namespace GpgME;
 
 QString Kleo::gnupgHomeDirectory()
 {
 #ifdef Q_OS_WIN
     return QFile::decodeName(default_homedir());
 #else
     const QByteArray gnupgHome = qgetenv("GNUPGHOME");
     if (!gnupgHome.isEmpty()) {
         return QFile::decodeName(gnupgHome);
     } else {
         return QDir::homePath() + QLatin1String("/.gnupg");
     }
 #endif
 }
 
 int Kleo::makeGnuPGError(int code)
 {
     return gpg_error(static_cast<gpg_err_code_t>(code));
 }
 
 static QString findGpgExe(GpgME::Engine engine, const QString &exe)
 {
     const GpgME::EngineInfo info = GpgME::engineInfo(engine);
     return info.fileName() ? QFile::decodeName(info.fileName()) : QStandardPaths::findExecutable(exe);
 }
 
 QString Kleo::gpgConfPath()
 {
     static const auto path = findGpgExe(GpgME::GpgConfEngine, QStringLiteral("gpgconf"));
     return path;
 }
 
 QString Kleo::gpgSmPath()
 {
     static const auto path = findGpgExe(GpgME::GpgSMEngine, QStringLiteral("gpgsm"));
     return path;
 }
 
 QString Kleo::gpgPath()
 {
     static const auto path = findGpgExe(GpgME::GpgEngine, QStringLiteral("gpg"));
     return path;
 }
 
 QStringList Kleo::gnupgFileWhitelist()
 {
     return QStringList()
            // The obvious pubring
            << QStringLiteral("pubring.gpg")
            // GnuPG 2.1 pubring
            << QStringLiteral("pubring.kbx")
            // Trust in X509 Certificates
            << QStringLiteral("trustlist.txt")
            // Trustdb controls ownertrust and thus WOT validity
            << QStringLiteral("trustdb.gpg")
            // We want to update when smartcard status changes
            << QStringLiteral("reader*.status")
            // No longer used in 2.1 but for 2.0 we want this
            << QStringLiteral("secring.gpg")
            // Changes to the trustmodel / compliance mode might
            // affect validity so we check this, too.
            // Globbing for gpg.conf* here will trigger too often
            // as gpgconf creates files like gpg.conf.bak or
            // gpg.conf.tmp12312.gpgconf that should not trigger
            // a change.
            << QStringLiteral("gpg.conf")
            << QStringLiteral("gpg.conf-?")
            << QStringLiteral("gpg.conf-?.?")
            ;
 }
 
 namespace
 {
 class Gpg4win
 {
 public:
     static const Gpg4win *instance()
     {
         // We use singleton to do the signature check only once.
         static Gpg4win *inst = nullptr;
         if (!inst) {
             inst = new Gpg4win();
         }
         return inst;
     }
 
 private:
     QString mVersion;
     QString mDescription;
     QString mDescLong;
     bool mSignedVersion;
 
     Gpg4win() :
         mVersion(QStringLiteral("Unknown Windows Version")),
         mDescription(i18n("Certificate Manager and Unified Crypto GUI")),
         mDescLong(QStringLiteral("<a href=https://www.gpg4win.org>Visit the Gpg4win homepage</a>")),
         mSignedVersion(false)
     {
         const QString instPath = Kleo::gpg4winInstallPath();
         const QString verPath = instPath + QStringLiteral("/../VERSION");
         QFile versionFile(verPath);
 
         QString versVersion;
         QString versDescription;
         QString versDescLong;
         // Open the file first to avoid a verify and then read issue where
         // "auditors" might say its an issue,...
         if (!versionFile.open(QIODevice::ReadOnly)) {
             // No need to translate this should only be the case in development
             // builds.
             return;
         } else {
             // Expect a three line format of three HTML strings.
             versVersion = QString::fromUtf8(versionFile.readLine()).trimmed();
             versDescription = QString::fromUtf8(versionFile.readLine()).trimmed();
             versDescLong = QString::fromUtf8(versionFile.readLine()).trimmed();
         }
 
         const QString sigPath = verPath + QStringLiteral(".sig");
         QFileInfo versionSig(instPath + QStringLiteral("/../VERSION.sig"));
         QString signedVersion;
         if (versionSig.exists()) {
             /* We have a signed version so let us check it against the GnuPG
              * release keys. */
             QProcess gpgv;
             gpgv.setProgram(Kleo::gpgPath().replace(QStringLiteral("gpg.exe"), QStringLiteral("gpgv.exe")));
             const QString keyringPath(QStringLiteral("%1/../share/gnupg/distsigkey.gpg").arg(Kleo::gnupgInstallPath()));
             gpgv.setArguments(QStringList() << QStringLiteral("--keyring")
                                             << keyringPath
                                             << QStringLiteral("--")
                                             << sigPath
                                             << verPath);
             gpgv.start();
             gpgv.waitForFinished();
             if (gpgv.exitStatus() == QProcess::NormalExit &&
                 !gpgv.exitCode()) {
                 qCDebug(LIBKLEO_LOG) << "Valid Version: " << versVersion;
                 mVersion = versVersion;
                 mDescription = versDescription;
                 mDescLong = versDescLong;
                 mSignedVersion = true;
             } else {
                 qCDebug(LIBKLEO_LOG) << "gpgv failed with stderr: " << gpgv.readAllStandardError();
                 qCDebug(LIBKLEO_LOG) << "gpgv stdout" << gpgv.readAllStandardOutput();
             }
         } else {
             qCDebug(LIBKLEO_LOG) << "No signed VERSION file found.";
         }
         // Also take Version information from unsigned Versions.
         mVersion = versVersion;
     }
 public:
     const QString &version() const
     {
         return mVersion;
     }
     const QString &description() const
     {
         return mDescription;
     }
     const QString &longDescription() const
     {
         return mDescLong;
     }
     bool isSignedVersion() const
     {
         return mSignedVersion;
     }
 };
 } // namespace
 
 bool Kleo::gpg4winSignedversion()
 {
     return Gpg4win::instance()->isSignedVersion();
 }
 
 QString Kleo::gpg4winVersion()
 {
     return Gpg4win::instance()->version();
 }
 QString Kleo::gpg4winDescription()
 {
     return Gpg4win::instance()->description();
 }
 QString Kleo::gpg4winLongDescription()
 {
     return Gpg4win::instance()->longDescription();
 }
 
 QString Kleo::gpg4winInstallPath()
 {
 #ifdef Q_OS_WIN
     // QApplication::applicationDirPath is only used as a fallback
     // to support the case where Kleopatra is not installed from
     // Gpg4win but Gpg4win is also installed.
     char *instDir = read_w32_registry_string("HKEY_LOCAL_MACHINE",
                                              "Software\\GPG4Win",
                                              "Install Directory");
     if (!instDir) {
         // Fallback to HKCU
         instDir = read_w32_registry_string("HKEY_CURRENT_USER",
                                            "Software\\GPG4Win",
                                            "Install Directory");
     }
     if (instDir) {
         QString ret = QString::fromLocal8Bit(instDir) + QStringLiteral("/bin");
         free(instDir);
         return ret;
     }
     qCDebug(LIBKLEO_LOG) << "Gpg4win not found. Falling back to Kleopatra instdir.";
 #endif
     return QCoreApplication::applicationDirPath();
 }
 
 QString Kleo::gnupgInstallPath()
 {
 
 #ifdef Q_OS_WIN
     // QApplication::applicationDirPath is only used as a fallback
     // to support the case where Kleopatra is not installed from
     // Gpg4win but Gpg4win is also installed.
     char *instDir = read_w32_registry_string("HKEY_LOCAL_MACHINE",
                                              "Software\\GnuPG",
                                              "Install Directory");
     if (!instDir) {
         // Fallback to HKCU
         instDir = read_w32_registry_string("HKEY_CURRENT_USER",
                                            "Software\\GnuPG",
                                            "Install Directory");
     }
     if (instDir) {
         QString ret = QString::fromLocal8Bit(instDir) + QStringLiteral("/bin");
         free(instDir);
         return ret;
     }
     qCDebug(LIBKLEO_LOG) << "GnuPG not found. Falling back to gpgconf list dir.";
 #endif
     return gpgConfListDir("bindir");
 }
 
 QString Kleo::gpgConfListDir(const char *which)
 {
     if (!which || !*which) {
         return QString();
     }
     const QString gpgConfPath = Kleo::gpgConfPath();
     if (gpgConfPath.isEmpty()) {
         return QString();
     }
     QProcess gpgConf;
     qCDebug(LIBKLEO_LOG) << "gpgConfListDir: starting " << qPrintable(gpgConfPath) << " --list-dirs";
     gpgConf.start(gpgConfPath, QStringList() << QStringLiteral("--list-dirs"));
     if (!gpgConf.waitForFinished()) {
         qCDebug(LIBKLEO_LOG) << "gpgConfListDir(): failed to execute gpgconf: " << qPrintable(gpgConf.errorString());
         qCDebug(LIBKLEO_LOG) << "output was:\n" << gpgConf.readAllStandardError().constData();
         return QString();
     }
     const QList<QByteArray> lines = gpgConf.readAllStandardOutput().split('\n');
     for (const QByteArray &line : lines)
         if (line.startsWith(which) && line[qstrlen(which)] == ':') {
             const int begin = qstrlen(which) + 1;
             int end = line.size();
             while (end && (line[end - 1] == '\n' || line[end - 1] == '\r')) {
                 --end;
             }
             const QString result = QDir::fromNativeSeparators(QFile::decodeName(hexdecode(line.mid(begin, end - begin))));
             qCDebug(LIBKLEO_LOG) << "gpgConfListDir: found " << qPrintable(result)
                                    << " for '" << which << "'entry";
             return result;
         }
     qCDebug(LIBKLEO_LOG) << "gpgConfListDir(): didn't find '" << which << "'"
                            << "entry in output:\n" << gpgConf.readAllStandardError().constData();
     return QString();
 }
 
 static std::array<int, 3> getVersionFromString(const char *actual, bool &ok)
 {
     std::array<int, 3> ret;
     ok = false;
 
     if (!actual) {
         return ret;
     }
 
     QString versionString = QString::fromLatin1(actual);
 
     // Try to fix it up
-    QRegExp rx(QLatin1String("(\\d+)\\.(\\d+)\\.(\\d+)(?:-svn\\d+)?.*"));
+    QRegExp rx(QLatin1String(R"((\d+)\.(\d+)\.(\d+)(?:-svn\d+)?.*)"));
     for (int i = 0; i < 3; i++) {
         if (!rx.exactMatch(versionString)) {
             versionString += QStringLiteral(".0");
         } else {
             ok = true;
             break;
         }
     }
 
     if (!ok) {
         qCDebug(LIBKLEO_LOG) << "Can't parse version " << actual;
         return ret;
     }
 
     for (int i = 0; i < 3; ++i) {
         ret[i] = rx.cap(i + 1).toUInt(&ok);
         if (!ok) {
             return ret;
         }
     }
 
     ok = true;
     return ret;
 }
 
 bool Kleo::versionIsAtLeast(const char *minimum, const char *actual)
 {
     if (!minimum || !actual) {
         return false;
     }
     bool ok;
     const auto minimum_version = getVersionFromString(minimum, ok);
     if (!ok) {
         return false;
     }
     const auto actual_version = getVersionFromString(actual, ok);
     if (!ok) {
         return false;
     }
 
     return !std::lexicographical_compare(std::begin(actual_version), std::end(actual_version),
                                          std::begin(minimum_version), std::end(minimum_version));
 
 }
 
 bool Kleo::engineIsVersion(int major, int minor, int patch, GpgME::Engine engine)
 {
     static QMap<Engine, std::array<int, 3> > cachedVersions;
     const int required_version[] = {major, minor, patch};
     // Gpgconf means spawning processes which is expensive on windows.
     std::array<int, 3> actual_version;
     if (!cachedVersions.contains(engine)) {
         const Error err = checkEngine(engine);
         if (err.code() == GPG_ERR_INV_ENGINE) {
             qCDebug(LIBKLEO_LOG) << "isVersion: invalid engine. '";
             return false;
         }
 
         const char *actual = GpgME::engineInfo(engine).version();
         bool ok;
         actual_version = getVersionFromString(actual, ok);
 
         qCDebug(LIBKLEO_LOG) << "Parsed" << actual << "as: "
                                << actual_version[0] << '.'
                                << actual_version[1] << '.'
                                << actual_version[2] << '.';
         if (!ok) {
             return false;
         }
         cachedVersions.insert(engine, actual_version);
     } else {
         actual_version = cachedVersions.value(engine);
     }
 
     // return ! ( actual_version < required_version )
     return !std::lexicographical_compare(std::begin(actual_version), std::end(actual_version),
                                          std::begin(required_version), std::end(required_version));
 }
 
 const QString& Kleo::paperKeyInstallPath()
 {
     static const QString pkPath = QStandardPaths::findExecutable(QStringLiteral("paperkey"), QStringList() << QCoreApplication::applicationDirPath()).isEmpty() ?
                                   QStandardPaths::findExecutable(QStringLiteral("paperkey")) :
                                   QStandardPaths::findExecutable(QStringLiteral("paperkey"), QStringList() << QCoreApplication::applicationDirPath());
     return pkPath;
 }
 
 bool Kleo::haveKeyserverConfigured()
 {
     if (engineIsVersion(2, 1, 19)) {
         // since 2.1.19 there is a builtin keyserver
         return true;
     }
     const QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
     if (!config) {
         return false;
     }
     const QGpgME::CryptoConfigEntry *const entry = config->entry(QStringLiteral("gpg"), QStringLiteral("Keyserver"), QStringLiteral("keyserver"));
     return entry && !entry->stringValue().isEmpty();
 }
 
 bool Kleo::gpgComplianceP(const char *mode)
 {
     const auto conf = QGpgME::cryptoConfig();
     const auto entry = conf->entry(QStringLiteral("gpg"),
                                    QStringLiteral("Configuration"),
                                    QStringLiteral("compliance"));
 
     return entry && entry->stringValue() == QString::fromLatin1(mode);
 }
 
 enum GpgME::UserID::Validity Kleo::keyValidity(const GpgME::Key &key)
 {
     enum UserID::Validity validity = UserID::Validity::Unknown;
 
     for (const auto &uid: key.userIDs()) {
         if (validity == UserID::Validity::Unknown
             || validity > uid.validity()) {
             validity = uid.validity();
         }
     }
 
     return validity;
 }
 
 #ifdef Q_OS_WIN
 static QString fromEncoding (unsigned int src_encoding, const char *data)
 {
     int n = MultiByteToWideChar(src_encoding, 0, data, -1, NULL, 0);
     if (n < 0) {
         return QString();
     }
 
     wchar_t *result = (wchar_t *) malloc ((n+1) * sizeof *result);
 
     n = MultiByteToWideChar(src_encoding, 0, data, -1, result, n);
     if (n < 0) {
         free(result);
         return QString();
     }
     const auto ret = QString::fromWCharArray(result, n);
     free(result);
     return ret;
 }
 #endif
 
 QString Kleo::stringFromGpgOutput(const QByteArray &ba)
 {
 #ifdef Q_OS_WIN
     /* Qt on Windows uses GetACP while GnuPG prefers
      * GetConsoleOutputCP.
      *
      * As we are not a console application GetConsoleOutputCP
      * usually returns 0.
      * From experience the closest thing that let's us guess
      * what GetConsoleOutputCP returns for a console application
      * it appears to be the OEMCP.
      */
     unsigned int cpno = GetConsoleOutputCP ();
     if (!cpno) {
         cpno = GetOEMCP();
     }
     if (!cpno) {
         cpno = GetACP();
     }
     if (!cpno) {
         qCDebug(LIBKLEO_LOG) << "Failed to find native codepage";
         return QString();
     }
 
     return fromEncoding(cpno, ba.constData());
 #else
     return QString::fromLocal8Bit(ba);
 #endif
 }