diff --git a/src/kleo/dn.cpp b/src/kleo/dn.cpp
index c8f194e93..a20ab3924 100644
--- a/src/kleo/dn.cpp
+++ b/src/kleo/dn.cpp
@@ -1,603 +1,603 @@
 /*
     dn.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     DN parsing:
     Copyright (c) 2002 g10 Code GmbH
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "dn.h"
 
 #include "oidmap.h"
 
 #include "ui/dnattributeorderconfigwidget.h"
 
-#include <kconfig.h>
+#include <KConfig>
 #include <KLocalizedString>
 
 #include <QStringList>
 
 #include <iostream>
 #include <iterator>
 #include <algorithm>
 #include <map>
 
 #include <string.h>
 #include <ctype.h>
 #include <stdlib.h>
-#include <kconfiggroup.h>
+#include <KConfigGroup>
 #include <KSharedConfig>
 
 class Kleo::DN::Private
 {
 public:
     Private() : mRefCount(0) {}
     Private(const Private &other)
         : attributes(other.attributes),
           reorderedAttributes(other.reorderedAttributes),
           mRefCount(0)
     {
 
     }
 
     int ref()
     {
         return ++mRefCount;
     }
 
     int unref()
     {
         if (--mRefCount <= 0) {
             delete this;
             return 0;
         } else {
             return mRefCount;
         }
     }
 
     int refCount() const
     {
         return mRefCount;
     }
 
     DN::Attribute::List attributes;
     DN::Attribute::List reorderedAttributes;
 private:
     int mRefCount;
 };
 
 namespace
 {
 struct DnPair {
     char *key;
     char *value;
 };
 }
 
 // copied from CryptPlug and adapted to work on DN::Attribute::List:
 
 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
 #define hexdigitp(a) (digitp (a)                     \
                       || (*(a) >= 'A' && *(a) <= 'F')  \
                       || (*(a) >= 'a' && *(a) <= 'f'))
 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
 
 static char *
 trim_trailing_spaces(char *string)
 {
     char *p, *mark;
 
     for (mark = nullptr, p = string; *p; p++) {
         if (isspace(*p)) {
             if (!mark) {
                 mark = p;
             }
         } else {
             mark = nullptr;
         }
     }
     if (mark) {
         *mark = '\0';
     }
 
     return string;
 }
 
 /* Parse a DN and return an array-ized one.  This is not a validating
    parser and it does not support any old-stylish syntax; gpgme is
    expected to return only rfc2253 compatible strings. */
 static const unsigned char *
 parse_dn_part(DnPair *array, const unsigned char *string)
 {
     const unsigned char *s, *s1;
     size_t n;
     char *p;
 
     /* parse attributeType */
     for (s = string + 1; *s && *s != '='; s++)
         ;
     if (!*s) {
         return nullptr;    /* error */
     }
     n = s - string;
     if (!n) {
         return nullptr;    /* empty key */
     }
     p = (char *)malloc(n + 1);
 
     memcpy(p, string, n);
     p[n] = 0;
     trim_trailing_spaces((char *)p);
     // map OIDs to their names:
     for (unsigned int i = 0; i < numOidMaps; ++i)
         if (!strcasecmp((char *)p, oidmap[i].oid)) {
             free(p);
             p = strdup(oidmap[i].name);
             break;
         }
     array->key = p;
     string = s + 1;
 
     if (*string == '#') {
         /* hexstring */
         string++;
         for (s = string; hexdigitp(s); s++) {
             s++;
         }
         n = s - string;
         if (!n || (n & 1)) {
             return nullptr;    /* empty or odd number of digits */
         }
         n /= 2;
         array->value = p = (char *)malloc(n + 1);
 
         for (s1 = string; n; s1 += 2, n--) {
             *p++ = xtoi_2(s1);
         }
         *p = 0;
     } else {
         /* regular v3 quoted string */
         for (n = 0, s = string; *s; s++) {
             if (*s == '\\') {
                 /* pair */
                 s++;
                 if (*s == ',' || *s == '=' || *s == '+'
                         || *s == '<' || *s == '>' || *s == '#' || *s == ';'
                         || *s == '\\' || *s == '\"' || *s == ' ') {
                     n++;
                 } else if (hexdigitp(s) && hexdigitp(s + 1)) {
                     s++;
                     n++;
                 } else {
                     return nullptr;    /* invalid escape sequence */
                 }
             } else if (*s == '\"') {
                 return nullptr;    /* invalid encoding */
             } else if (*s == ',' || *s == '=' || *s == '+'
                        || *s == '<' || *s == '>' || *s == '#' || *s == ';') {
                 break;
             } else {
                 n++;
             }
         }
 
         array->value = p = (char *)malloc(n + 1);
 
         for (s = string; n; s++, n--) {
             if (*s == '\\') {
                 s++;
                 if (hexdigitp(s)) {
                     *p++ = xtoi_2(s);
                     s++;
                 } else {
                     *p++ = *s;
                 }
             } else {
                 *p++ = *s;
             }
         }
         *p = 0;
     }
     return s;
 }
 
 /* Parse a DN and return an array-ized one.  This is not a validating
    parser and it does not support any old-stylish syntax; gpgme is
    expected to return only rfc2253 compatible strings. */
 static Kleo::DN::Attribute::List
 parse_dn(const unsigned char *string)
 {
     if (!string) {
         return QVector<Kleo::DN::Attribute>();
     }
 
     QVector<Kleo::DN::Attribute> result;
     while (*string) {
         while (*string == ' ') {
             string++;
         }
         if (!*string) {
             break;    /* ready */
         }
 
         DnPair pair = { nullptr, nullptr };
         string = parse_dn_part(&pair, string);
         if (!string) {
             goto failure;
         }
         if (pair.key && pair.value)
             result.push_back(Kleo::DN::Attribute(QString::fromUtf8(pair.key),
                                                  QString::fromUtf8(pair.value)));
         free(pair.key);
         free(pair.value);
 
         while (*string == ' ') {
             string++;
         }
         if (*string && *string != ',' && *string != ';' && *string != '+') {
             goto failure;    /* invalid delimiter */
         }
         if (*string) {
             string++;
         }
     }
     return result;
 
 failure:
     return QVector<Kleo::DN::Attribute>();
 }
 
 static QVector<Kleo::DN::Attribute>
 parse_dn(const QString &dn)
 {
     return parse_dn((const unsigned char *)dn.toUtf8().data());
 }
 
 static QString dn_escape(const QString &s)
 {
     QString result;
     for (int i = 0, end = s.length(); i != end; ++i) {
         const QChar ch = s[i];
         switch (ch.unicode()) {
         case ',':
         case '+':
         case '"':
         case '\\':
         case '<':
         case '>':
         case ';':
             result += QLatin1Char('\\');
             // fall through
             Q_FALLTHROUGH();
         default:
             result += ch;
         }
     }
     return result;
 }
 
 static QString
 serialise(const QVector<Kleo::DN::Attribute> &dn, const QString &sep)
 {
     QStringList result;
     for (QVector<Kleo::DN::Attribute>::const_iterator it = dn.begin(); it != dn.end(); ++it)
         if (!(*it).name().isEmpty() && !(*it).value().isEmpty()) {
             result.push_back((*it).name().trimmed() + QLatin1Char('=') + dn_escape((*it).value().trimmed()));
         }
     return result.join(sep);
 }
 
 static Kleo::DN::Attribute::List
 reorder_dn(const Kleo::DN::Attribute::List &dn)
 {
     const QStringList &attrOrder = Kleo::DNAttributeMapper::instance()->attributeOrder();
 
     Kleo::DN::Attribute::List unknownEntries;
     Kleo::DN::Attribute::List result;
     unknownEntries.reserve(dn.size());
     result.reserve(dn.size());
 
     // find all unknown entries in their order of appearance
     for (Kleo::DN::const_iterator it = dn.begin(); it != dn.end(); ++it)
         if (!attrOrder.contains((*it).name())) {
             unknownEntries.push_back(*it);
         }
 
     // process the known attrs in the desired order
     for (QStringList::const_iterator oit = attrOrder.begin(); oit != attrOrder.end(); ++oit)
         if (*oit == QLatin1String("_X_")) {
             // insert the unknown attrs
             std::copy(unknownEntries.begin(), unknownEntries.end(),
                       std::back_inserter(result));
             unknownEntries.clear(); // don't produce dup's
         } else {
             for (Kleo::DN::const_iterator dnit = dn.begin(); dnit != dn.end(); ++dnit)
                 if ((*dnit).name() == *oit) {
                     result.push_back(*dnit);
                 }
         }
 
     return result;
 }
 
 //
 //
 // class DN
 //
 //
 
 Kleo::DN::DN()
 {
     d = new Private();
     d->ref();
 }
 
 Kleo::DN::DN(const QString &dn)
 {
     d = new Private();
     d->ref();
     d->attributes = parse_dn(dn);
 }
 
 Kleo::DN::DN(const char *utf8DN)
 {
     d = new Private();
     d->ref();
     if (utf8DN) {
         d->attributes = parse_dn((const unsigned char *)utf8DN);
     }
 }
 
 Kleo::DN::DN(const DN &other)
     : d(other.d)
 {
     if (d) {
         d->ref();
     }
 }
 
 Kleo::DN::~DN()
 {
     if (d) {
         d->unref();
     }
 }
 
 const Kleo::DN &Kleo::DN::operator=(const DN &that)
 {
     if (this->d == that.d) {
         return *this;
     }
 
     if (that.d) {
         that.d->ref();
     }
     if (this->d) {
         this->d->unref();
     }
 
     this->d = that.d;
 
     return *this;
 }
 
 QString Kleo::DN::prettyDN() const
 {
     if (!d) {
         return QString();
     }
     if (d->reorderedAttributes.empty()) {
         d->reorderedAttributes = reorder_dn(d->attributes);
     }
     return serialise(d->reorderedAttributes, QStringLiteral(","));
 }
 
 QString Kleo::DN::dn() const
 {
     return d ? serialise(d->attributes, QStringLiteral(",")) : QString();
 }
 
 QString Kleo::DN::dn(const QString &sep) const
 {
     return d ? serialise(d->attributes, sep) : QString();
 }
 
 // static
 QString Kleo::DN::escape(const QString &value)
 {
     return dn_escape(value);
 }
 
 void Kleo::DN::detach()
 {
     if (!d) {
         d = new Kleo::DN::Private();
         d->ref();
     } else if (d->refCount() > 1) {
         Kleo::DN::Private *d_save = d;
         d = new Kleo::DN::Private(*d);
         d->ref();
         d_save->unref();
     }
 }
 
 void Kleo::DN::append(const Attribute &attr)
 {
     detach();
     d->attributes.push_back(attr);
     d->reorderedAttributes.clear();
 }
 
 QString Kleo::DN::operator[](const QString &attr) const
 {
     if (!d) {
         return QString();
     }
     const QString attrUpper = attr.toUpper();
     for (QVector<Attribute>::const_iterator it = d->attributes.constBegin();
             it != d->attributes.constEnd(); ++it)
         if ((*it).name() == attrUpper) {
             return (*it).value();
         }
     return QString();
 }
 
 static QVector<Kleo::DN::Attribute> empty;
 
 Kleo::DN::const_iterator Kleo::DN::begin() const
 {
     return d ? d->attributes.constBegin() : empty.constBegin();
 }
 
 Kleo::DN::const_iterator Kleo::DN::end() const
 {
     return d ? d->attributes.constEnd() : empty.constEnd();
 }
 
 /////////////////////
 
 namespace
 {
 struct ltstr {
     bool operator()(const char *s1, const char *s2) const
     {
         return qstrcmp(s1, s2) < 0;
     }
 };
 }
 
 static const char *const defaultOrder[] = {
     "CN", "L", "_X_", "OU", "O", "C"
 };
 
 static std::pair<const char *, const char *> const attributeLabels[] = {
 #define MAKE_PAIR(x,y) std::pair<const char*,const char*>( x, y )
     MAKE_PAIR("CN", I18N_NOOP("Common name")),
     MAKE_PAIR("SN", I18N_NOOP("Surname")),
     MAKE_PAIR("GN", I18N_NOOP("Given name")),
     MAKE_PAIR("L",  I18N_NOOP("Location")),
     MAKE_PAIR("T",  I18N_NOOP("Title")),
     MAKE_PAIR("OU", I18N_NOOP("Organizational unit")),
     MAKE_PAIR("O",  I18N_NOOP("Organization")),
     MAKE_PAIR("PC", I18N_NOOP("Postal code")),
     MAKE_PAIR("C",  I18N_NOOP("Country code")),
     MAKE_PAIR("SP", I18N_NOOP("State or province")),
     MAKE_PAIR("DC", I18N_NOOP("Domain component")),
     MAKE_PAIR("BC", I18N_NOOP("Business category")),
     MAKE_PAIR("EMAIL", I18N_NOOP("Email address")),
     MAKE_PAIR("MAIL", I18N_NOOP("Mail address")),
     MAKE_PAIR("MOBILE", I18N_NOOP("Mobile phone number")),
     MAKE_PAIR("TEL", I18N_NOOP("Telephone number")),
     MAKE_PAIR("FAX", I18N_NOOP("Fax number")),
     MAKE_PAIR("STREET", I18N_NOOP("Street address")),
     MAKE_PAIR("UID", I18N_NOOP("Unique ID"))
 #undef MAKE_PAIR
 };
 static const unsigned int numAttributeLabels = sizeof attributeLabels / sizeof * attributeLabels;
 
 class Kleo::DNAttributeMapper::Private
 {
 public:
     Private();
     std::map<const char *, const char *, ltstr> map;
     QStringList attributeOrder;
 };
 
 Kleo::DNAttributeMapper::Private::Private()
     : map(attributeLabels, attributeLabels + numAttributeLabels) {}
 
 Kleo::DNAttributeMapper::DNAttributeMapper()
 {
     d = new Private();
     const KConfigGroup config(KSharedConfig::openConfig(), "DN");
     d->attributeOrder = config.readEntry("AttributeOrder", QStringList());
     if (d->attributeOrder.empty())
         std::copy(defaultOrder, defaultOrder + sizeof defaultOrder / sizeof * defaultOrder,
                   std::back_inserter(d->attributeOrder));
     mSelf = this;
 }
 
 Kleo::DNAttributeMapper::~DNAttributeMapper()
 {
     mSelf = nullptr;
     delete d; d = nullptr;
 }
 
 Kleo::DNAttributeMapper *Kleo::DNAttributeMapper::mSelf = nullptr;
 
 const Kleo::DNAttributeMapper *Kleo::DNAttributeMapper::instance()
 {
     if (!mSelf) {
         (void)new DNAttributeMapper();
     }
     return mSelf;
 }
 
 QString Kleo::DNAttributeMapper::name2label(const QString &s) const
 {
     const std::map<const char *, const char *, ltstr>::const_iterator it
         = d->map.find(s.trimmed().toUpper().toLatin1().constData());
     if (it == d->map.end()) {
         return QString();
     }
     return i18n(it->second);
 }
 
 QStringList Kleo::DNAttributeMapper::names() const
 {
     QStringList result;
     for (std::map<const char *, const char *, ltstr>::const_iterator it = d->map.begin(); it != d->map.end(); ++it) {
         result.push_back(QLatin1String(it->first));
     }
     return result;
 }
 
 const QStringList &Kleo::DNAttributeMapper::attributeOrder() const
 {
     return d->attributeOrder;
 }
 
 void Kleo::DNAttributeMapper::setAttributeOrder(const QStringList &order)
 {
     d->attributeOrder = order;
     if (order.empty())
         std::copy(defaultOrder, defaultOrder + sizeof defaultOrder / sizeof * defaultOrder,
                   std::back_inserter(d->attributeOrder));
     KConfigGroup config(KSharedConfig::openConfig(), "DN");
     config.writeEntry("AttributeOrder", order);
 }
 
 Kleo::DNAttributeOrderConfigWidget *Kleo::DNAttributeMapper::configWidget(QWidget *parent) const
 {
     return new DNAttributeOrderConfigWidget(mSelf, parent);
 }
diff --git a/src/kleo/kconfigbasedkeyfilter.cpp b/src/kleo/kconfigbasedkeyfilter.cpp
index 1aa39256a..6ac17012b 100644
--- a/src/kleo/kconfigbasedkeyfilter.cpp
+++ b/src/kleo/kconfigbasedkeyfilter.cpp
@@ -1,255 +1,255 @@
 /*
     kconfigbasedkeyfilter.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "kconfigbasedkeyfilter.h"
 
-#include <kconfigbase.h>
-#include <kconfiggroup.h>
+#include <KConfigBase>
+#include <KConfigGroup>
 
 #include <algorithm>
 #include <QDebug>
 
 using namespace Kleo;
 using namespace GpgME;
 
 //
 //
 // FontDescription - intuitive font property resolving
 //                   (QFont::resolve doesn't work for us)
 //
 //
 struct KeyFilter::FontDescription::Private {
     bool bold, italic, strikeOut, fullFont;
     QFont font;
 };
 
 KeyFilter::FontDescription::FontDescription()
     : d(new Private)
 {
     d->bold = d->italic = d->strikeOut = d->fullFont = false;
 }
 
 KeyFilter::FontDescription::FontDescription(const FontDescription &other)
     : d(new Private(*other.d))
 {
 
 }
 
 KeyFilter::FontDescription::~FontDescription()
 {
     delete d;
 }
 
 KeyFilter::FontDescription KeyFilter::FontDescription::create(bool b, bool i, bool s)
 {
     FontDescription fd;
     fd.d->bold = b;
     fd.d->italic = i;
     fd.d->strikeOut = s;
     return fd;
 }
 
 KeyFilter::FontDescription KeyFilter::FontDescription::create(const QFont &f, bool b, bool i, bool s)
 {
     FontDescription fd;
     fd.d->fullFont = true;
     fd.d->font = f;
     fd.d->bold = b;
     fd.d->italic = i;
     fd.d->strikeOut = s;
     return fd;
 }
 
 QFont KeyFilter::FontDescription::font(const QFont &base) const
 {
     QFont font;
     if (d->fullFont) {
         font = d->font;
         font.setPointSize(base.pointSize());
     } else {
         font = base;
     }
     if (d->bold) {
         font.setBold(true);
     }
     if (d->italic) {
         font.setItalic(true);
     }
     if (d->strikeOut) {
         font.setStrikeOut(true);
     }
     return font;
 }
 
 KeyFilter::FontDescription KeyFilter::FontDescription::resolve(const FontDescription &other) const
 {
     FontDescription fd;
     fd.d->fullFont = this->d->fullFont || other.d->fullFont;
     if (fd.d->fullFont) {
         fd.d->font = this->d->fullFont ? this->d->font : other.d->font;
     }
     fd.d->bold = this->d->bold || other.d->bold;
     fd.d->italic = this->d->italic || other.d->italic;
     fd.d->strikeOut = this->d->strikeOut || other.d->strikeOut;
     return fd;
 }
 
 static const struct {
     const char *name;
     Key::OwnerTrust trust;
     UserID::Validity validity;
 } ownerTrustAndValidityMap[] = {
     { "unknown",   Key::Unknown,   UserID::Unknown   },
     { "undefined", Key::Undefined, UserID::Undefined },
     { "never",     Key::Never,     UserID::Never     },
     { "marginal",  Key::Marginal,  UserID::Marginal  },
     { "full",      Key::Full,      UserID::Full      },
     { "ultimate",  Key::Ultimate,  UserID::Ultimate  },
 };
 
 static Key::OwnerTrust map2OwnerTrust(const QString &s)
 {
     for (unsigned int i = 0; i < sizeof ownerTrustAndValidityMap / sizeof * ownerTrustAndValidityMap; ++i)
         if (s.toLower() == QLatin1String(ownerTrustAndValidityMap[i].name)) {
             return ownerTrustAndValidityMap[i].trust;
         }
     return ownerTrustAndValidityMap[0].trust;
 }
 
 static UserID::Validity map2Validity(const QString &s)
 {
     for (unsigned int i = 0; i < sizeof ownerTrustAndValidityMap / sizeof * ownerTrustAndValidityMap; ++i)
         if (s.toLower() == QLatin1String(ownerTrustAndValidityMap[i].name)) {
             return ownerTrustAndValidityMap[i].validity;
         }
     return ownerTrustAndValidityMap[0].validity;
 }
 
 KConfigBasedKeyFilter::KConfigBasedKeyFilter(const KConfigGroup &config)
     : DefaultKeyFilter()
 {
     setFgColor(config.readEntry<QColor>("foreground-color", QColor()));
     setBgColor(config.readEntry<QColor>("background-color", QColor()));
     setName(config.readEntry("Name", config.name()));
     setIcon(config.readEntry("icon"));
     setId(config.readEntry("id", config.name()));
     if (config.hasKey("font")) {
         setUseFullFont(true);
         setFont(config.readEntry("font"));
     } else {
         setUseFullFont(false);
         setItalic(config.readEntry("font-italic", false));
         setBold(config.readEntry("font-bold", false));
     }
     setStrikeOut(config.readEntry("font-strikeout", false));
 #ifdef SET
 #undef SET
 #endif
 #define SET(member,key) \
     if ( config.hasKey( key ) ) { \
         set##member(config.readEntry( key, false ) ? Set : NotSet); \
         setSpecificity(specificity() + 1); \
     }
     SET(Revoked, "is-revoked");
     SET(Expired, "is-expired");
     SET(Disabled, "is-disabled");
     SET(Root, "is-root-certificate");
     SET(CanEncrypt, "can-encrypt");
     SET(CanSign, "can-sign");
     SET(CanCertify, "can-certify");
     SET(CanAuthenticate, "can-authenticate");
     SET(Qualified, "is-qualified");
     SET(CardKey, "is-cardkey");
     SET(HasSecret, "has-secret-key");
     SET(IsOpenPGP, "is-openpgp-key");
     SET(WasValidated, "was-validated");
     SET(IsDeVs, "is-de-vs");
 #undef SET
     static const struct {
         const char *prefix;
         LevelState state;
     } prefixMap[] = {
         { "is-", Is },
         { "is-not-", IsNot },
         { "is-at-least-", IsAtLeast },
         { "is-at-most-", IsAtMost },
     };
     for (unsigned int i = 0; i < sizeof prefixMap / sizeof * prefixMap; ++i) {
         const QString key = QLatin1String(prefixMap[i].prefix) + QLatin1String("ownertrust");
         if (config.hasKey(key)) {
             setOwnerTrust(prefixMap[i].state);
             setOwnerTrustReferenceLevel(map2OwnerTrust(config.readEntry(key, QString())));
             setSpecificity(specificity() + 1);
             break;
         }
     }
     for (unsigned int i = 0; i < sizeof prefixMap / sizeof * prefixMap; ++i) {
         const QString key = QLatin1String(prefixMap[i].prefix) + QLatin1String("validity");
         if (config.hasKey(key)) {
             setValidity(prefixMap[i].state);
             setValidityReferenceLevel(map2Validity(config.readEntry(key, QString())));
             setSpecificity(specificity() + 1);
             break;
         }
     }
     static const struct {
         const char *key;
         MatchContext context;
     } matchMap[] = {
         { "any", AnyMatchContext },
         { "appearance", Appearance },
         { "filtering", Filtering },
     };
     const QStringList contexts = config.readEntry("match-contexts", "any").toLower().split(QRegExp(QLatin1String("[^a-zA-Z0-9_-!]+")), QString::SkipEmptyParts);
     setMatchContexts(NoMatchContext);
     for (const QString & ctx : contexts) {
         bool found = false;
         for (unsigned int i = 0; i < sizeof matchMap / sizeof * matchMap; ++i)
             if (ctx == QLatin1String(matchMap[i].key)) {
                 setMatchContexts(availableMatchContexts() |= matchMap[i].context);
                 found = true;
                 break;
             } else if (ctx.startsWith(QLatin1Char('!')) && ctx.mid(1) == QLatin1String(matchMap[i].key)) {
                 setMatchContexts(availableMatchContexts() &= matchMap[i].context);
                 found = true;
                 break;
             }
         if (!found) {
             qWarning() << QStringLiteral("KConfigBasedKeyFilter: found unknown match context '%1' in group '%2'").arg(ctx, config.name());
         }
     }
     if (availableMatchContexts() == NoMatchContext) {
         qWarning() << QStringLiteral("KConfigBasedKeyFilter: match context in group '%1' evaluates to NoMatchContext, "
                                      "replaced by AnyMatchContext").arg(config.name());
         setMatchContexts(AnyMatchContext);
     }
 }
diff --git a/src/kleo/keyfiltermanager.cpp b/src/kleo/keyfiltermanager.cpp
index 8a98d2dbe..c56c35ebf 100644
--- a/src/kleo/keyfiltermanager.cpp
+++ b/src/kleo/keyfiltermanager.cpp
@@ -1,449 +1,449 @@
 /*
     keyfiltermanager.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "keyfiltermanager.h"
 #include "kconfigbasedkeyfilter.h"
 #include "defaultkeyfilter.h"
 
 #include "stl_util.h"
 
 #include "libkleo_debug.h"
 #include "utils/formatting.h"
 
-#include <kconfig.h>
-#include <kconfiggroup.h>
+#include <KConfig>
+#include <KConfigGroup>
 #include <KSharedConfig>
 #include <KLocalizedString>
 #include <QIcon>
 
 #include <QCoreApplication>
 #include <QRegularExpression>
 #include <QStringList>
 #include <QAbstractListModel>
 #include <QModelIndex>
 
 #include <algorithm>
 #include <vector>
 #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::reset;
 };
 
 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()
     {
         filters.clear();
         appearanceFilters.clear();
         model.reset();
     }
 
     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();
     }
     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();
     } 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/tests/test_keygen.cpp b/src/tests/test_keygen.cpp
index c6808f876..da16b3820 100644
--- a/src/tests/test_keygen.cpp
+++ b/src/tests/test_keygen.cpp
@@ -1,183 +1,183 @@
 /*
     test_keygen.cpp
 
     This file is part of libkleopatra's test suite.
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License,
     version 2, as published by the Free Software Foundation.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #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.h>
+#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);
     mainLayout->addWidget(mainWidget);
     QPushButton *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);
 
     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);
     keygen->setObjectName(QStringLiteral("KeyGenerator top-level"));
     keygen->show();
 
     return app.exec();
 }
 
diff --git a/src/ui/cryptoconfigdialog.cpp b/src/ui/cryptoconfigdialog.cpp
index 07893ad1d..5ac4774ec 100644
--- a/src/ui/cryptoconfigdialog.cpp
+++ b/src/ui/cryptoconfigdialog.cpp
@@ -1,114 +1,114 @@
 /*
     cryptoconfigdialog.h
 
     This file is part of kgpgcertmanager
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "cryptoconfigdialog.h"
 #include "cryptoconfigmodule.h"
 #include <KLocalizedString>
-#include <kacceleratormanager.h>
+#include <KAcceleratorManager>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <KGuiItem>
 #include <QVBoxLayout>
 
 Kleo::CryptoConfigDialog::CryptoConfigDialog(QGpgME::CryptoConfig *config, QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18n("Configure GnuPG Backend"));
     QVBoxLayout *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);
     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 1492b9054..4d891c36b 100644
--- a/src/ui/cryptoconfigmodule.cpp
+++ b/src/ui/cryptoconfigmodule.cpp
@@ -1,978 +1,978 @@
 /*
     cryptoconfigmodule.cpp
 
     This file is part of kgpgcertmanager
     Copyright (c) 2004 Klar�vdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "cryptoconfigmodule.h"
 #include "cryptoconfigmodule_p.h"
 #include "directoryserviceswidget.h"
 #include "kdhorizontalline.h"
 #include "filenamerequester.h"
 
 #include <qgpgme/cryptoconfig.h>
 
-#include <klineedit.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 <QList>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QScrollArea>
 #include <QDesktopWidget>
 #include <QCheckBox>
 #include <QStyle>
 #include <QComboBox>
 #include <QGroupBox>
 
 #include <memory>
 #include <limits>
 
 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());
     }
 };
 
 }
 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);
         l->setContentsMargins(0, 0, 0, 0);
         QScrollArea *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 = 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);
     }
 }
 
 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);
     const QStringList groups = 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);
             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 *);
 
 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;
     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;
     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(i18n("Configure LDAP Servers"));
 
     DirectoryServicesWidget *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;
     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)
 {
     const QStringList list = str.split(QRegExp(QLatin1String("[\\s,]")), QString::SkipEmptyParts);
     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(i18n("Configure Keyservers"));
 
     DirectoryServicesWidget *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/dnattributeorderconfigwidget.cpp b/src/ui/dnattributeorderconfigwidget.cpp
index 2767dd201..9ba8aef27 100644
--- a/src/ui/dnattributeorderconfigwidget.cpp
+++ b/src/ui/dnattributeorderconfigwidget.cpp
@@ -1,377 +1,377 @@
 /*  -*- c++ -*-
     dnattributeorderconfigwidget.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klarävdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
  */
 
 #include "dnattributeorderconfigwidget.h"
 #include "libkleo_debug.h"
 #include "libkleo/dn.h"
 
 #include <KLocalizedString>
-#include <kconfig.h>
+#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);
     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();
     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);
             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/keyrequester.cpp b/src/ui/keyrequester.cpp
index 2f595d02f..64ce7d80f 100644
--- a/src/ui/keyrequester.cpp
+++ b/src/ui/keyrequester.cpp
@@ -1,524 +1,524 @@
 /*  -*- c++ -*-
     keyrequester.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klar�vdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 
     Based on kpgpui.cpp
     Copyright (C) 2001,2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     This file is part of KPGP, the KDE PGP/GnuPG support library.
 
     KPGP is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software Foundation,
     Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
 #include "keyrequester.h"
 
 #include "keyselectiondialog.h"
 
 #include "libkleo/dn.h"
 
 // gpgme++
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <qgpgme/protocol.h>
 #include <qgpgme/keylistjob.h>
 
 // KDE
 #include <KLocalizedString>
 #include <QDialog>
-#include <kmessagebox.h>
+#include <KMessageBox>
 #include <QPushButton>
 
 // Qt
 #include <QApplication>
 
 #include <QString>
 #include <QStringList>
 #include <QLabel>
 
 #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);
     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)
         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)
         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/messagebox.cpp b/src/ui/messagebox.cpp
index 267a4914a..cc0481321 100644
--- a/src/ui/messagebox.cpp
+++ b/src/ui/messagebox.cpp
@@ -1,265 +1,265 @@
 /*
     messagebox.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #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.h>
+#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);
     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/ui/messagebox.h b/src/ui/messagebox.h
index af4749a22..381ad7549 100644
--- a/src/ui/messagebox.h
+++ b/src/ui/messagebox.h
@@ -1,90 +1,90 @@
 /*
     messagebox.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2007 Klarälvdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #ifndef __KLEO_UI_MESSAGEBOX_H__
 #define __KLEO_UI_MESSAGEBOX_H__
 
 #include "kleo_export.h"
 
-#include <kmessagebox.h>
+#include <KMessageBox>
 
 #undef MessageBox // Windows
 
 namespace GpgME
 {
 class SigningResult;
 class EncryptionResult;
 }
 
 namespace QGpgME
 {
 class Job;
 }
 
 class QWidget;
 class QString;
 
 namespace Kleo
 {
 
 class KLEO_EXPORT MessageBox
 {
 public:
     static void information(QWidget *parent, const GpgME::SigningResult &result, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void information(QWidget *parent, const GpgME::SigningResult &result, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::SigningResult &result, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::SigningResult &result, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
 
     static void information(QWidget *parent, const GpgME::EncryptionResult &result, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void information(QWidget *parent, const GpgME::EncryptionResult &result, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::EncryptionResult &result, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::EncryptionResult &result, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
 
     static void information(QWidget *parent, const GpgME::SigningResult &sresult, const GpgME::EncryptionResult &eresult, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void information(QWidget *parent, const GpgME::SigningResult &sresult, const GpgME::EncryptionResult &eresult, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::SigningResult &sresult, const GpgME::EncryptionResult &eresult, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options = KMessageBox::Notify);
     static void error(QWidget *parent, const GpgME::SigningResult &sresult, const GpgME::EncryptionResult &eresult, const QGpgME::Job *job, KMessageBox::Options options = KMessageBox::Notify);
 
     static void auditLog(QWidget *parent, const QGpgME::Job *job, const QString &caption);
     static void auditLog(QWidget *parent, const QGpgME::Job *job);
     static void auditLog(QWidget *parent, const QString &log, const QString &caption);
     static void auditLog(QWidget *parent, const QString &log);
 
     static bool showAuditLogButton(const QGpgME::Job *job);
 
 private:
     static void make(QWidget *parent, QMessageBox::Icon icon, const QString &text, const QGpgME::Job *job, const QString &caption, KMessageBox::Options options);
 };
 
 }
 
 #endif /* __KLEO_UI_MESSAGEBOX_H__ */