diff --git a/src/kleo/keyresolver.h b/src/kleo/keyresolver.h
index c4aaac11c..ceb656f8c 100644
--- a/src/kleo/keyresolver.h
+++ b/src/kleo/keyresolver.h
@@ -1,255 +1,255 @@
 /*  -*- c++ -*-
     keyresolver.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2018 Intevation GmbH
 
     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_KEYRESOLVER_H__
 #define __KLEO_KEYRESOLVER_H__
 
 #include "kleo_export.h"
 #include <Libkleo/Enum>
 
 #include <gpgme++/key.h>
 
 #include <vector>
 #include <QMap>
 #include <QString>
 #include <QObject>
 
 #include <memory>
 
 class QStringList;
 
 namespace Kleo
 {
 /**
  * Class to find Keys for E-Mail encryption.
  *
  * The KeyResolver uses the Keycache to find keys for signing
  * or encryption.
  *
  * Overrides can be provided for address book integration if the
  * format is not Auto overrides will only be respected if they
  * match the format provided in the constructor.
  *
  * If no override key is provided for an address the key
  * with a uid that matches the address and has the highest
  * validity is used. If both keys have the same validity
  * the newest subkey is used.
  *
  * The KeyResolver also supports groups so the number of
  * encryption keys / hidden encryption keys does not necessarily
  * need to match the amount of sender addresses. For this reason
  * maps are used heavily to map:
  *
  * CryptoFormat
  *   - Addresses
  *   -- For each Address a List of Keys
  *
  * As a caller you should iterate over the CryptoFormats and
  * send one message for each format for the recipients and signed
  * by the signing keys.
  *
- * If the CryptoMessageFormat is Auto the minmum number
+ * If the CryptoMessageFormat is Auto the minimum number
  * of CryptoMessageFormats is returned that respects all overrides.
  *
  * -----
  * Planned:
  *
  * As the central place to manage mail encryption / signing keys
  * the Keyresolver will also show various warning / nagging messages
  * and offer solutions if nagging is not explicitly turned off.
  * These include:
  *
  * - If own keys or subkeys are about to expire:
  *   Offer to extend their expiration date.
  *
  * - (S/MIME) If they are about to expire: Offer
  *   to generate a new CSR.
  *
  * - If a user has not marked a key as backed up and
  *   uses it for encryption for several mails.
  *
  * - If a user has multiple keys for a sender address and they
  *   are not cross signed. Offer to cross sign / publish.
  */
 class KLEO_EXPORT KeyResolver : public QObject
 {
     Q_OBJECT
 
 public:
     /** Creates a new key resolver object.
      *
      * @param encrypt: Should encryption keys be selected.
      * @param sign: Should signing keys be selected.
      * @param format: A specific format for selection. Default Auto.
      * @param allowMixed: Specify if multiple message formats may be resolved.
      **/
     explicit KeyResolver(bool encrypt, bool sign,
                          CryptoMessageFormat format = AutoFormat,
                          bool allowMixed = true);
     ~KeyResolver() {}
 
     /**
      *  Set the list of (To/CC) recipient addresses. Also looks
      *  up possible keys, but doesn't interact with the user.
      *
      *  @param addresses: A list of unnormalized addresses
     */
     void setRecipients(const QStringList &addresses);
 
     /**
      * Set the senders address.
      *
      * Sender address will be added to encryption keys and used
      * for signing key resolution if the signing keys are not
      * explicitly set through setSigningKeys.
      *
      * @param sender: The sender of this message.
      */
     void setSender(const QString &sender);
 
     /**
      *  Set the list of hidden (BCC) recipient addresses. Also looks
      *  up possible keys, but doesn't interact with the user.
      *
      *  @param addresses: A list of unnormalized addresses.
     */
     void setHiddenRecipients(const QStringList &addresses);
 
     /**
      * Set up possible override keys for recipients / sender
      * addresses. The keys for the fingerprints are looked
      * up and used when found. Does not interact with the user.
      *
      * @param overrides: A map of \<cryptomessageformat\> -> (\<address\> \<fingerprints\>)
     */
     void setOverrideKeys(const QMap<CryptoMessageFormat, QMap<QString, QStringList> > &overrides);
 
     /**
      * Set explicit signing keys. If this was set for a
      * protocol the sender address will be only used as an additional encryption
      * recipient for that protocol. */
     void setSigningKeys(const QStringList &fingerprints);
 
     /**
      * Turn Nagging messages off or on, default on.
      * See class description about nagging.
      *
      * @param value: Turn nagging on or off.
      */
     void enableNagging(bool value);
 
     /**
      * Set the minimum user id validity for autoresolution.
      *
      * The default value is marginal
      *
      * @param validity int representation of a GpgME::UserID::Validity.
      */
     void setMinimumValidity(int validity);
 
     /**
      * Get the encryption keys after resolution.
      *
      * @return the resolved sender / key pairs for encryption by format.
      */
     QMap <CryptoMessageFormat, QMap<QString, std::vector<GpgME::Key> > > encryptionKeys() const;
 
     /**
      * Get the secondary encryption keys after resolution.
      * The Map will only contain values if hidden recipients
      * were set.
      *
      * @return the resolved resolved sender / key pairs for encryption
      *         by format.
      */
     QMap <CryptoMessageFormat, QMap<QString, std::vector<GpgME::Key> > > hiddenKeys() const;
 
     /**
      * Get the signing keys to use after resolution.
      *
      * @return the resolved resolved sender / key pairs for signing
      *         by format.
      */
     QMap <CryptoMessageFormat, std::vector<GpgME::Key> > signingKeys() const;
 
     /**
      * Starts the key resolving procedure. Emits keysResolved on success or
      * error.
      *
      * @param showApproval: If set to true a dialog listing the keys
      *                      will always be shown.
      * @param parentWidget: Optional, a Widget to use as parent for dialogs.
      */
     void start(bool showApproval, QWidget *parentWidget = nullptr);
 
     /**
      * Access possibly updated Override Keys
      *
      * @return A map of email's with new overrides and the according
      *         cryptoformat / fingerprint. Should be saved somehow.
      */
     QMap <CryptoMessageFormat, QMap<QString, QStringList> > overrideKeys() const;
 
     /**
      * Set window flags for a possible dialog.
      */
     void setDialogWindowFlags(Qt::WindowFlags flags);
 
     /**
      * Set the protocol that is preferred to be displayed first when
      * it is not clear from the keys. E.g. if both OpenPGP and S/MIME
      * can be resolved.
      */
     void setPreferredProtocol(GpgME::Protocol proto);
 
 Q_SIGNALS:
     /**
      * Emitted when key resolution finished.
      *
      * @param success: The general result. If true continue sending,
      *                 if false abort.
      * @param sendUnencrypted: If there could be no key found for one of
      *                         the recipients the user was queried if the
      *                         mail should be sent out unencrypted.
      *                         sendUnencrypted is true if the user agreed
      *                         to this.*/
     void keysResolved(bool success, bool sendUnencrypted);
 
 private:
     class Private;
     friend class Private;
     std::shared_ptr<Private> d;
 };
 } // namespace Kleo
 
 #endif // __KLEO_KEYRESOLVER_H__
 
diff --git a/src/ui/cryptoconfigmodule.cpp b/src/ui/cryptoconfigmodule.cpp
index 11c86cd34..1492b9054 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 <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 capitalisation in GUI labels (yes) or not (no). "
+              "Sentence style capitalization in GUI labels (yes) or not (no). "
               "Context: We get some backend strings in that have the wrong "
-              "capitalizaion (in English, at least) so we need to force the "
+              "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/keyapprovaldialog.cpp b/src/ui/keyapprovaldialog.cpp
index fbf54e8cb..968daba6b 100644
--- a/src/ui/keyapprovaldialog.cpp
+++ b/src/ui/keyapprovaldialog.cpp
@@ -1,222 +1,220 @@
 /*  -*- c++ -*-
     keyapprovaldialog.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.h
     Copyright (C) 2001,2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     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 "keyapprovaldialog.h"
 
 #include "keyrequester.h"
 
-#include <QPushButton>
 #include <KLocalizedString>
-#include <kseparator.h>
+#include <KSeparator>
 
-#include <QStringList>
-#include <QLabel>
+#include <QApplication>
 #include <QComboBox>
-#include <QScrollArea>
+#include <QDesktopWidget>
+#include <QDialogButtonBox>
+#include <QGridLayout>
+#include <QLabel>
 #include <QPushButton>
+#include <QScrollArea>
+#include <QStringList>
 #include <QVBoxLayout>
-#include <QGridLayout>
 
 #include <gpgme++/key.h>
 #include <qgpgme/protocol.h>
 
-#include <QApplication>
-#include <QDesktopWidget>
-#include <QDialogButtonBox>
-
 static Kleo::EncryptionPreference cb2pref(int i)
 {
     switch (i) {
     default:
     case 0: return Kleo::UnknownPreference;
     case 1: return Kleo::NeverEncrypt;
     case 2: return Kleo::AlwaysEncrypt;
     case 3: return Kleo::AlwaysEncryptIfPossible;
     case 4: return Kleo::AlwaysAskForEncryption;
     case 5: return Kleo::AskWheneverPossible;
     }
 }
 
 static int pref2cb(Kleo::EncryptionPreference p)
 {
     switch (p) {
     default:                            return 0;
     case Kleo::NeverEncrypt:            return 1;
     case Kleo::AlwaysEncrypt:           return 2;
     case Kleo::AlwaysEncryptIfPossible: return 3;
     case Kleo::AlwaysAskForEncryption:  return 4;
     case Kleo::AskWheneverPossible:     return 5;
     }
 }
 
 static QStringList preferencesStrings()
 {
     return QStringList() << xi18n("<placeholder>none</placeholder>")
            << i18n("Never Encrypt with This Key")
            << i18n("Always Encrypt with This Key")
            << i18n("Encrypt Whenever Encryption is Possible")
            << i18n("Always Ask")
            << i18n("Ask Whenever Encryption is Possible");
 }
 
 class Q_DECL_HIDDEN Kleo::KeyApprovalDialog::Private
 {
 public:
     Private() {}
 
     Kleo::KeyRequester *selfRequester = nullptr;
     QStringList addresses;
     std::vector<Kleo::KeyRequester *> requesters;
     std::vector<QComboBox *> preferences;
     bool prefsChanged = false;
 };
 
 Kleo::KeyApprovalDialog::KeyApprovalDialog(const std::vector<Item> &recipients,
         const std::vector<GpgME::Key> &sender,
         QWidget *parent)
     : QDialog(parent),
       d(new Private())
 {
     setWindowTitle(i18n("Encryption Key Approval"));
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &KeyApprovalDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KeyApprovalDialog::reject);
     okButton->setDefault(true);
     Q_ASSERT(!recipients.empty());
 
     QFrame *page = new QFrame(this);
     mainLayout->addWidget(page);
     mainLayout->addWidget(buttonBox);
     QVBoxLayout *vlay = new QVBoxLayout(page);
     vlay->setContentsMargins(0, 0, 0, 0);
 
     vlay->addWidget(new QLabel(i18n("The following keys will be used for encryption:"), page));
 
     QScrollArea *sv = new QScrollArea(page);
     sv->setWidgetResizable(true);
     vlay->addWidget(sv);
 
     QWidget *view = new QWidget(sv->viewport());
 
     QGridLayout *glay = new QGridLayout(view);
     glay->setColumnStretch(1, 1);
     sv->setWidget(view);
 
     int row = -1;
 
     if (!sender.empty()) {
         ++row;
         glay->addWidget(new QLabel(i18n("Your keys:"), view), row, 0);
         d->selfRequester = new EncryptionKeyRequester(true, EncryptionKeyRequester::AllProtocols, view);
         d->selfRequester->setKeys(sender);
         glay->addWidget(d->selfRequester, row, 1);
         ++row;
         glay->addWidget(new KSeparator(Qt::Horizontal, view), row, 0, 1, 2);
     }
 
     const QStringList prefs = preferencesStrings();
 
     for (std::vector<Item>::const_iterator it = recipients.begin(); it != recipients.end(); ++it) {
         ++row;
         glay->addWidget(new QLabel(i18n("Recipient:"), view), row, 0);
         glay->addWidget(new QLabel(it->address, view), row, 1);
         d->addresses.push_back(it->address);
 
         ++row;
         glay->addWidget(new QLabel(i18n("Encryption keys:"), view), row, 0);
         KeyRequester *req = new EncryptionKeyRequester(true, EncryptionKeyRequester::AllProtocols, view);
         req->setKeys(it->keys);
         glay->addWidget(req, row, 1);
         d->requesters.push_back(req);
 
         ++row;
         glay->addWidget(new QLabel(i18n("Encryption preference:"), view), row, 0);
         QComboBox *cb = new QComboBox(view);
         cb->setEditable(false);
         cb->addItems(prefs);
         glay->addWidget(cb, row, 1);
         cb->setCurrentIndex(pref2cb(it->pref));
         connect(cb, QOverload<int>::of(&QComboBox::activated), this, &KeyApprovalDialog::slotPrefsChanged);
         d->preferences.push_back(cb);
     }
 
     QSize size = sizeHint();
 
     // don't make the dialog too large
     const QRect desk = QApplication::desktop()->screenGeometry(this);
     resize(QSize(qMin(size.width(), 3 * desk.width() / 4),
                  qMin(size.height(), 7 * desk.height() / 8)));
 }
 
 Kleo::KeyApprovalDialog::~KeyApprovalDialog()
 {
     delete d;
 }
 
 std::vector<GpgME::Key> Kleo::KeyApprovalDialog::senderKeys() const
 {
     return d->selfRequester ? d->selfRequester->keys() : std::vector<GpgME::Key>();
 }
 
 std::vector<Kleo::KeyApprovalDialog::Item> Kleo::KeyApprovalDialog::items() const
 {
     Q_ASSERT(d->requesters.size() == static_cast<unsigned int>(d->addresses.size()));
     Q_ASSERT(d->requesters.size() == d->preferences.size());
 
     std::vector<Item> result;
     result.reserve(d->requesters.size());
     QStringList::const_iterator ait = d->addresses.constBegin();
     std::vector<KeyRequester *>::iterator rit = d->requesters.begin();
     std::vector<QComboBox *>::iterator cit = d->preferences.begin();
     while (ait != d->addresses.constEnd()) {
         result.push_back(Item(*ait++, (*rit++)->keys(), cb2pref((*cit++)->currentIndex())));
     }
     return result;
 }
 
 bool Kleo::KeyApprovalDialog::preferencesChanged() const
 {
     return d->prefsChanged;
 }
 
 void Kleo::KeyApprovalDialog::slotPrefsChanged()
 {
     d->prefsChanged = true;
 }
 
diff --git a/src/ui/keyselectiondialog.cpp b/src/ui/keyselectiondialog.cpp
index 52fd32973..838c9d231 100644
--- a/src/ui/keyselectiondialog.cpp
+++ b/src/ui/keyselectiondialog.cpp
@@ -1,985 +1,981 @@
 /*  -*- c++ -*-
     keyselectiondialog.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
-    Copyright (c) 2004 Klar�vdalens Datakonsult AB
+    Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.cpp
     Copyright (C) 2001,2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     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 "keyselectiondialog.h"
 
 #include "keylistview.h"
 #include "progressdialog.h"
 
 #include "libkleo/dn.h"
 #include "kleo_ui_debug.h"
 
 // gpgme++
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/protocol.h>
 
 // KDE
+#include <KConfig>
+#include <KConfigGroup>
 #include <KLocalizedString>
-#include <kconfig.h>
-#include <kmessagebox.h>
-#include <QPushButton>
-#include <kconfiggroup.h>
-#include <QMenu>
-#include <QLineEdit>
+#include <KMessageBox>
+#include <KSharedConfig>
 
 // Qt
+#include <QApplication>
 #include <QCheckBox>
-#include <QLabel>
-#include <QTimer>
 #include <QDateTime>
-#include <QProcess>
-
-#include <QRegExp>
-#include <QPushButton>
+#include <QDialogButtonBox>
 #include <QFrame>
-#include <QApplication>
 #include <QHBoxLayout>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMenu>
+#include <QProcess>
+#include <QPushButton>
+#include <QRegExp>
+#include <QScrollBar>
+#include <QTimer>
 #include <QVBoxLayout>
 
 #include <algorithm>
 #include <iterator>
-
 #include <string.h>
-#include <QScrollBar>
-#include <KSharedConfig>
-#include <KConfigGroup>
-#include <QDialogButtonBox>
 
 static bool checkKeyUsage(const GpgME::Key &key, unsigned int keyUsage, QString *statusString = nullptr)
 {
     auto setStatusString = [statusString](const QString &status) {
         if (statusString) {
             *statusString = status;
         }
     };
 
     if (keyUsage & Kleo::KeySelectionDialog::ValidKeys) {
         if (key.isInvalid()) {
             if (key.keyListMode() & GpgME::Validate) {
                 qCDebug(KLEO_UI_LOG) << "key is invalid";
                 setStatusString(i18n("The key is not valid."));
                 return false;
             } else {
                 qCDebug(KLEO_UI_LOG) << "key is invalid - ignoring";
             }
         }
         if (key.isExpired()) {
             qCDebug(KLEO_UI_LOG) << "key is expired";
             setStatusString(i18n("The key is expired."));
             return false;
         } else if (key.isRevoked()) {
             qCDebug(KLEO_UI_LOG) << "key is revoked";
             setStatusString(i18n("The key is revoked."));
             return false;
         } else if (key.isDisabled()) {
             qCDebug(KLEO_UI_LOG) << "key is disabled";
             setStatusString(i18n("The key is disabled."));
             return false;
         }
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::EncryptionKeys &&
             !key.canEncrypt()) {
         qCDebug(KLEO_UI_LOG) << "key can't encrypt";
         setStatusString(i18n("The key is not designated for encryption."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::SigningKeys &&
             !key.canSign()) {
         qCDebug(KLEO_UI_LOG) << "key can't sign";
         setStatusString(i18n("The key is not designated for signing."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::CertificationKeys &&
             !key.canCertify()) {
         qCDebug(KLEO_UI_LOG) << "key can't certify";
         setStatusString(i18n("The key is not designated for certifying."));
         return false;
     }
     if (keyUsage & Kleo::KeySelectionDialog::AuthenticationKeys &&
             !key.canAuthenticate()) {
         qCDebug(KLEO_UI_LOG) << "key can't authenticate";
         setStatusString(i18n("The key is not designated for authentication."));
         return false;
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::SecretKeys &&
             !(keyUsage & Kleo::KeySelectionDialog::PublicKeys) &&
             !key.hasSecret()) {
         qCDebug(KLEO_UI_LOG) << "key isn't secret";
         setStatusString(i18n("The key is not secret."));
         return false;
     }
 
     if (keyUsage & Kleo::KeySelectionDialog::TrustedKeys &&
             key.protocol() == GpgME::OpenPGP &&
             // only check this for secret keys for now.
             // Seems validity isn't checked for secret keylistings...
             !key.hasSecret()) {
         std::vector<GpgME::UserID> uids = key.userIDs();
         for (std::vector<GpgME::UserID>::const_iterator it = uids.begin(); it != uids.end(); ++it)
             if (!it->isRevoked() && it->validity() >= GpgME::UserID::Marginal) {
                 return true;
             }
         qCDebug(KLEO_UI_LOG) << "key has no UIDs with validity >= Marginal";
         setStatusString(i18n("The key is not trusted enough."));
         return false;
     }
     // X.509 keys are always trusted, else they won't be the keybox.
     // PENDING(marc) check that this ^ is correct
 
     setStatusString(i18n("The key can be used."));
     return true;
 }
 
 static bool checkKeyUsage(const std::vector<GpgME::Key> &keys, unsigned int keyUsage)
 {
     for (std::vector<GpgME::Key>::const_iterator it = keys.begin(); it != keys.end(); ++it)
         if (!checkKeyUsage(*it, keyUsage)) {
             return false;
         }
     return true;
 }
 
 static inline QString time_t2string(time_t t)
 {
     QDateTime dt;
     dt.setTime_t(t);
     return dt.toString();
 }
 
 namespace
 {
 
 class ColumnStrategy : public Kleo::KeyListView::ColumnStrategy
 {
 public:
     ColumnStrategy(unsigned int keyUsage);
 
     QString title(int col) const override;
     int width(int col, const QFontMetrics &fm) const override;
 
     QString text(const GpgME::Key &key, int col) const override;
     QString toolTip(const GpgME::Key &key, int col) const override;
     QIcon icon(const GpgME::Key &key, int col) const override;
 
 private:
     const QIcon mKeyGoodPix, mKeyBadPix, mKeyUnknownPix, mKeyValidPix;
     const unsigned int mKeyUsage;
 };
 
 static QString iconPath(const QString &name)
 {
     return QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("libkleopatra/pics/") + name + QStringLiteral(".png"));
 }
 
 ColumnStrategy::ColumnStrategy(unsigned int keyUsage)
     : Kleo::KeyListView::ColumnStrategy(),
       mKeyGoodPix(iconPath(QStringLiteral("key_ok"))),
       mKeyBadPix(iconPath(QStringLiteral("key_bad"))),
       mKeyUnknownPix(iconPath(QStringLiteral("key_unknown"))),
       mKeyValidPix(iconPath(QStringLiteral("key"))),
       mKeyUsage(keyUsage)
 {
     if (keyUsage == 0)
         qCWarning(KLEO_UI_LOG)
                 << "KeySelectionDialog: keyUsage == 0. You want to use AllKeys instead.";
 }
 
 QString ColumnStrategy::title(int col) const
 {
     switch (col) {
     case 0: return i18n("Key ID");
     case 1: return i18n("User ID");
     default: return QString();
     }
 }
 
 int ColumnStrategy::width(int col, const QFontMetrics &fm) const
 {
     if (col == 0) {
         static const char hexchars[] = "0123456789ABCDEF";
         int maxWidth = 0;
         for (unsigned int i = 0; i < 16; ++i) {
             maxWidth = qMax(fm.boundingRect(QLatin1Char(hexchars[i])).width(), maxWidth);
         }
         return 8 * maxWidth + 2 * 16 /* KIconLoader::SizeSmall */;
     }
     return Kleo::KeyListView::ColumnStrategy::width(col, fm);
 }
 
 QString ColumnStrategy::text(const GpgME::Key &key, int col) const
 {
     switch (col) {
     case 0: {
         if (key.shortKeyID()) {
             return QString::fromUtf8(key.shortKeyID());
         } else {
             return xi18n("<placeholder>unknown</placeholder>");
         }
     }
     case 1: {
         const char *uid = key.userID(0).id();
         if (key.protocol() == GpgME::OpenPGP) {
             return uid && *uid ? QString::fromUtf8(uid) : QString();
         } else { // CMS
             return Kleo::DN(uid).prettyDN();
         }
     }
     default: return QString();
     }
 }
 
 QString ColumnStrategy::toolTip(const GpgME::Key &key, int) const
 {
     const char *uid = key.userID(0).id();
     const char *fpr = key.primaryFingerprint();
     const char *issuer = key.issuerName();
     const GpgME::Subkey subkey = key.subkey(0);
     const QString expiry = subkey.neverExpires() ? i18n("never") : time_t2string(subkey.expirationTime());
     const QString creation = time_t2string(subkey.creationTime());
     QString keyStatusString;
     if (!checkKeyUsage(key, mKeyUsage, &keyStatusString)) {
         // Show the status in bold if there is a problem
         keyStatusString = QLatin1String("<b>") % keyStatusString % QLatin1String("</b>");
     }
 
     QString html = QStringLiteral("<qt><p style=\"style='white-space:pre'\">");
     if (key.protocol() == GpgME::OpenPGP) {
         html += i18n("OpenPGP key for <b>%1</b>", uid ? QString::fromUtf8(uid) : i18n("unknown"));
     } else {
         html += i18n("S/MIME key for <b>%1</b>", uid ? Kleo::DN(uid).prettyDN() : i18n("unknown"));
     }
     html += QStringLiteral("</p><table>");
 
     const auto addRow = [&html](const QString &name, const QString &value) {
         html += QStringLiteral("<tr><td align=\"right\"><b>%1: </b></td><td>%2</td></tr>").arg(name, value);
     };
     addRow(i18nc("Key creation date", "Created"), creation);
     addRow(i18nc("Key Expiration date", "Expiry"), expiry);
     addRow(i18nc("Key fingerprint", "Fingerprint"), fpr ? QString::fromLatin1(fpr) : i18n("unknown"));
     if (key.protocol() != GpgME::OpenPGP) {
         addRow(i18nc("Key issuer", "Issuer"), issuer ? Kleo::DN(issuer).prettyDN() : i18n("unknown"));
     }
     addRow(i18nc("Key status", "Status"), keyStatusString);
     html += QStringLiteral("</table></qt>");
 
     return html;
 }
 
 QIcon ColumnStrategy::icon(const GpgME::Key &key, int col) const
 {
     if (col != 0) {
         return QIcon();
     }
     // this key did not undergo a validating keylisting yet:
     if (!(key.keyListMode() & GpgME::Validate)) {
         return mKeyUnknownPix;
     }
 
     if (!checkKeyUsage(key, mKeyUsage)) {
         return mKeyBadPix;
     }
 
     if (key.protocol() == GpgME::CMS) {
         return mKeyGoodPix;
     }
 
     switch (key.userID(0).validity()) {
     default:
     case GpgME::UserID::Unknown:
     case GpgME::UserID::Undefined:
         return mKeyUnknownPix;
     case GpgME::UserID::Never:
         return mKeyValidPix;
     case GpgME::UserID::Marginal:
     case GpgME::UserID::Full:
     case GpgME::UserID::Ultimate:
         return mKeyGoodPix;
     }
 }
 
 }
 
 static const int sCheckSelectionDelay = 250;
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const std::vector<GpgME::Key> &selectedKeys,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mOpenPGPBackend(nullptr),
       mSMIMEBackend(nullptr),
       mRememberCB(nullptr),
       mSelectedKeys(selectedKeys),
       mKeyUsage(keyUsage),
       mCurrentContextMenuItem(nullptr)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, QString());
 }
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const QString &initialQuery,
         const std::vector<GpgME::Key> &selectedKeys,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mOpenPGPBackend(nullptr),
       mSMIMEBackend(nullptr),
       mRememberCB(nullptr),
       mSelectedKeys(selectedKeys),
       mKeyUsage(keyUsage),
       mSearchText(initialQuery),
       mInitialQuery(initialQuery),
       mCurrentContextMenuItem(nullptr)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 Kleo::KeySelectionDialog::KeySelectionDialog(const QString &title,
         const QString &text,
         const QString &initialQuery,
         unsigned int keyUsage,
         bool extendedSelection,
         bool rememberChoice,
         QWidget *parent,
         bool modal)
     : QDialog(parent),
       mOpenPGPBackend(nullptr),
       mSMIMEBackend(nullptr),
       mRememberCB(nullptr),
       mKeyUsage(keyUsage),
       mSearchText(initialQuery),
       mInitialQuery(initialQuery),
       mCurrentContextMenuItem(nullptr)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 void Kleo::KeySelectionDialog::init(bool rememberChoice, bool extendedSelection,
                                     const QString &text, const QString &initialQuery)
 {
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     mOkButton = buttonBox->button(QDialogButtonBox::Ok);
     mOkButton->setDefault(true);
     mOkButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     QPushButton *user1Button = new QPushButton;
     buttonBox->addButton(user1Button, QDialogButtonBox::ActionRole);
     QPushButton *user2Button = new QPushButton;
     buttonBox->addButton(user2Button, QDialogButtonBox::ActionRole);
 
     if (mKeyUsage & OpenPGPKeys) {
         mOpenPGPBackend = QGpgME::openpgp();
     }
     if (mKeyUsage & SMIMEKeys) {
         mSMIMEBackend = QGpgME::smime();
     }
 
     mCheckSelectionTimer = new QTimer(this);
     mStartSearchTimer = new QTimer(this);
 
     QFrame *page = new QFrame(this);
     mainLayout->addWidget(page);
     mainLayout->addWidget(buttonBox);
 
     mTopLayout = new QVBoxLayout(page);
     mTopLayout->setContentsMargins(0, 0, 0, 0);
 
     if (!text.isEmpty()) {
         QLabel *textLabel = new QLabel(text, page);
         textLabel->setWordWrap(true);
 
         // Setting the size policy is necessary as a workaround for https://issues.kolab.org/issue4429
         // and http://bugreports.qt.nokia.com/browse/QTBUG-8740
         textLabel->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
         connect(textLabel, &QLabel::linkActivated, this, &KeySelectionDialog::slotStartCertificateManager);
         mTopLayout->addWidget(textLabel);
     }
 
     QPushButton *const searchExternalPB =
         new QPushButton(i18n("Search for &External Certificates"), page);
     mTopLayout->addWidget(searchExternalPB, 0, Qt::AlignLeft);
     connect(searchExternalPB, &QAbstractButton::clicked, this, &KeySelectionDialog::slotStartSearchForExternalCertificates);
     if (initialQuery.isEmpty()) {
         searchExternalPB->hide();
     }
 
     QHBoxLayout *hlay = new QHBoxLayout();
     mTopLayout->addLayout(hlay);
 
     QLineEdit *le = new QLineEdit(page);
     le->setClearButtonEnabled(true);
     le->setText(initialQuery);
 
     QLabel *lbSearchFor =  new QLabel(i18n("&Search for:"), page);
     lbSearchFor->setBuddy(le);
 
     hlay->addWidget(lbSearchFor);
     hlay->addWidget(le, 1);
     le->setFocus();
 
     connect(le, &QLineEdit::textChanged,
             this, static_cast<void(KeySelectionDialog::*)(const QString &)>(&KeySelectionDialog::slotSearch));
     connect(mStartSearchTimer, &QTimer::timeout, this, &KeySelectionDialog::slotFilter);
 
     mKeyListView = new KeyListView(new ColumnStrategy(mKeyUsage), nullptr, page);
     mKeyListView->setObjectName(QStringLiteral("mKeyListView"));
     mKeyListView->header()->stretchLastSection();
     mKeyListView->setRootIsDecorated(true);
     mKeyListView->setSortingEnabled(true);
     mKeyListView->header()->setSortIndicatorShown(true);
     mKeyListView->header()->setSortIndicator(1, Qt::AscendingOrder);   // sort by User ID
     if (extendedSelection) {
         mKeyListView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     }
     mTopLayout->addWidget(mKeyListView, 10);
 
     if (rememberChoice) {
         mRememberCB = new QCheckBox(i18n("&Remember choice"), page);
         mTopLayout->addWidget(mRememberCB);
         mRememberCB->setWhatsThis(
             i18n("<qt><p>If you check this box your choice will "
                  "be stored and you will not be asked again."
                  "</p></qt>"));
     }
 
     connect(mCheckSelectionTimer, &QTimer::timeout,
             this, static_cast<void(KeySelectionDialog::*)()>(&KeySelectionDialog::slotCheckSelection));
     connectSignals();
 
     connect(mKeyListView, &Kleo::KeyListView::doubleClicked, this, &KeySelectionDialog::slotTryOk);
     connect(mKeyListView, &KeyListView::contextMenu, this, &KeySelectionDialog::slotRMB);
 
     user1Button->setText(i18n("&Reread Keys"));
     user2Button->setText(i18n("&Start Certificate Manager"));
     connect(user1Button, &QPushButton::clicked, this, &KeySelectionDialog::slotRereadKeys);
     connect(user2Button, &QPushButton::clicked, this, [this]() { slotStartCertificateManager(); });
     connect(mOkButton, &QPushButton::clicked, this, &KeySelectionDialog::slotOk);
     connect(buttonBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &KeySelectionDialog::slotCancel);
     slotRereadKeys();
     mTopLayout->activate();
 
     if (qApp) {
         QSize dialogSize(sizeHint());
         KConfigGroup dialogConfig(KSharedConfig::openConfig(), "Key Selection Dialog");
         dialogSize = dialogConfig.readEntry("Dialog size", dialogSize);
         const QByteArray headerState = dialogConfig.readEntry("header", QByteArray());
         if (!headerState.isEmpty()) {
             mKeyListView->header()->restoreState(headerState);
         }
         resize(dialogSize);
     }
 }
 
 Kleo::KeySelectionDialog::~KeySelectionDialog()
 {
     disconnectSignals();
     KConfigGroup dialogConfig(KSharedConfig::openConfig(), "Key Selection Dialog");
     dialogConfig.writeEntry("Dialog size", size());
     dialogConfig.writeEntry("header", mKeyListView->header()->saveState());
     dialogConfig.sync();
 }
 
 void Kleo::KeySelectionDialog::connectSignals()
 {
     if (mKeyListView->isMultiSelection())
         connect(mKeyListView, &QTreeWidget::itemSelectionChanged, this, &KeySelectionDialog::slotSelectionChanged);
     else
         connect(mKeyListView, static_cast<void(KeyListView::*)(KeyListViewItem*)>(&KeyListView::selectionChanged),
                 this, static_cast<void(KeySelectionDialog::*)(KeyListViewItem*)>(&KeySelectionDialog::slotCheckSelection));
 }
 
 void Kleo::KeySelectionDialog::disconnectSignals()
 {
     if (mKeyListView->isMultiSelection())
         disconnect(mKeyListView, &QTreeWidget::itemSelectionChanged,
                    this, &KeySelectionDialog::slotSelectionChanged);
     else
         disconnect(mKeyListView, static_cast<void(KeyListView::*)(KeyListViewItem*)>(&KeyListView::selectionChanged),
                    this, static_cast<void(KeySelectionDialog::*)(KeyListViewItem*)>(&KeySelectionDialog::slotCheckSelection));
 }
 
 const GpgME::Key &Kleo::KeySelectionDialog::selectedKey() const
 {
     static const GpgME::Key null = GpgME::Key::null;
     if (mKeyListView->isMultiSelection() || !mKeyListView->selectedItem()) {
         return null;
     }
     return mKeyListView->selectedItem()->key();
 }
 
 QString Kleo::KeySelectionDialog::fingerprint() const
 {
     return QLatin1String(selectedKey().primaryFingerprint());
 }
 
 QStringList Kleo::KeySelectionDialog::fingerprints() const
 {
     QStringList result;
     for (std::vector<GpgME::Key>::const_iterator it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
         if (const char *fpr = it->primaryFingerprint()) {
             result.push_back(QLatin1String(fpr));
         }
     return result;
 }
 
 QStringList Kleo::KeySelectionDialog::pgpKeyFingerprints() const
 {
     QStringList result;
     for (std::vector<GpgME::Key>::const_iterator it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
         if (it->protocol() == GpgME::OpenPGP)
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
     return result;
 }
 
 QStringList Kleo::KeySelectionDialog::smimeFingerprints() const
 {
     QStringList result;
     for (std::vector<GpgME::Key>::const_iterator it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it)
         if (it->protocol() == GpgME::CMS)
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
     return result;
 }
 
 void Kleo::KeySelectionDialog::slotRereadKeys()
 {
     mKeyListView->clear();
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     // FIXME: save current selection
     if (mOpenPGPBackend) {
         startKeyListJobForBackend(mOpenPGPBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
     if (mSMIMEBackend) {
         startKeyListJobForBackend(mSMIMEBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
 
     if (mListJobCount == 0) {
         mKeyListView->setEnabled(true);
         KMessageBox::information(this,
                                  i18n("No backends found for listing keys. "
                                       "Check your installation."),
                                  i18n("Key Listing Failed"));
         connectSignals();
     }
 }
 
 void Kleo::KeySelectionDialog::slotStartCertificateManager(const QString &query)
 {
     QStringList args;
 
     if (!query.isEmpty()) {
         args << QStringLiteral("--search") << query;
     }
     if (!QProcess::startDetached(QStringLiteral("kleopatra"), args))
         KMessageBox::error(this,
                            i18n("Could not start certificate manager; "
                                 "please check your installation."),
                            i18n("Certificate Manager Error"));
     else {
         qCDebug(KLEO_UI_LOG) << "\nslotStartCertManager(): certificate manager started.";
     }
 }
 
 #ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 #define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 static void showKeyListError(QWidget *parent, const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n("<qt><p>An error occurred while fetching "
                              "the keys from the backend:</p>"
                              "<p><b>%1</b></p></qt>",
                              QString::fromLocal8Bit(err.asString()));
 
     KMessageBox::error(parent, msg, i18n("Key Listing Failed"));
 }
 #endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 
 namespace
 {
 struct ExtractFingerprint {
     QString operator()(const GpgME::Key &key)
     {
         return QLatin1String(key.primaryFingerprint());
     }
 };
 }
 
 void Kleo::KeySelectionDialog::startKeyListJobForBackend(const QGpgME::Protocol *backend, const std::vector<GpgME::Key> &keys, bool validate)
 {
     Q_ASSERT(backend);
     QGpgME::KeyListJob *job = backend->keyListJob(false, false, validate);    // local, w/o sigs, validation as givem
     if (!job) {
         return;
     }
 
     connect(job, &QGpgME::KeyListJob::result, this, &KeySelectionDialog::slotKeyListResult);
     if (validate)
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotRefreshKey);
     else
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotAddKey);
 
     QStringList fprs;
     std::transform(keys.begin(), keys.end(), std::back_inserter(fprs), ExtractFingerprint());
     const GpgME::Error err = job->start(fprs, mKeyUsage & SecretKeys && !(mKeyUsage & PublicKeys));
 
     if (err) {
         return showKeyListError(this, err);
     }
 
 #ifndef LIBKLEO_NO_PROGRESSDIALOG
     // FIXME: create a MultiProgressDialog:
     (void)new ProgressDialog(job, validate ? i18n("Checking selected keys...") : i18n("Fetching keys..."), this);
 #endif
     ++mListJobCount;
 }
 
 static void selectKeys(Kleo::KeyListView *klv, const std::vector<GpgME::Key> &selectedKeys)
 {
     klv->clearSelection();
     if (selectedKeys.empty()) {
         return;
     }
     for (std::vector<GpgME::Key>::const_iterator it = selectedKeys.begin(); it != selectedKeys.end(); ++it)
         if (Kleo::KeyListViewItem *item = klv->itemByFingerprint(it->primaryFingerprint())) {
             item->setSelected(true);
         }
 }
 
 void Kleo::KeySelectionDialog::slotKeyListResult(const GpgME::KeyListResult &res)
 {
     if (res.error()) {
         showKeyListError(this, res.error());
     } else if (res.isTruncated()) {
         ++mTruncated;
     }
 
     if (--mListJobCount > 0) {
         return;    // not yet finished...
     }
 
     if (mTruncated > 0)
         KMessageBox::information(this,
                                  i18np("<qt>One backend returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        "<qt>%1 backends returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        mTruncated),
                                  i18n("Key List Result"));
 
     mKeyListView->flushKeys();
 
     mKeyListView->setEnabled(true);
     mListJobCount = mTruncated = 0;
     mKeysToCheck.clear();
 
     selectKeys(mKeyListView, mSelectedKeys);
 
     slotFilter();
 
     connectSignals();
 
     slotSelectionChanged();
 
     // restore the saved position of the contents
     mKeyListView->verticalScrollBar()->setValue(mSavedOffsetY); mSavedOffsetY = 0;
 }
 
 void Kleo::KeySelectionDialog::slotSelectionChanged()
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotSelectionChanged()";
 
     // (re)start the check selection timer. Checking the selection is delayed
     // because else drag-selection doesn't work very good (checking key trust
     // is slow).
     mCheckSelectionTimer->start(sCheckSelectionDelay);
 }
 
 namespace
 {
 struct AlreadyChecked {
     bool operator()(const GpgME::Key &key) const
     {
         return key.keyListMode() & GpgME::Validate;
     }
 };
 }
 
 void Kleo::KeySelectionDialog::slotCheckSelection(KeyListViewItem *item)
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotCheckSelection()";
 
     mCheckSelectionTimer->stop();
 
     mSelectedKeys.clear();
 
     if (!mKeyListView->isMultiSelection()) {
         if (item) {
             mSelectedKeys.push_back(item->key());
         }
     }
 
     for (KeyListViewItem *it = mKeyListView->firstChild(); it; it = it->nextSibling())
         if (it->isSelected()) {
             mSelectedKeys.push_back(it->key());
         }
 
     mKeysToCheck.clear();
     std::remove_copy_if(mSelectedKeys.begin(), mSelectedKeys.end(),
                         std::back_inserter(mKeysToCheck),
                         AlreadyChecked());
     if (mKeysToCheck.empty()) {
         mOkButton->setEnabled(!mSelectedKeys.empty() &&
                               checkKeyUsage(mSelectedKeys, mKeyUsage));
         return;
     }
 
     // performed all fast checks - now for validating key listing:
     startValidatingKeyListing();
 }
 
 void Kleo::KeySelectionDialog::startValidatingKeyListing()
 {
     if (mKeysToCheck.empty()) {
         return;
     }
 
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     std::vector<GpgME::Key> smime, openpgp;
     for (std::vector<GpgME::Key>::const_iterator it = mKeysToCheck.begin(); it != mKeysToCheck.end(); ++it)
         if (it->protocol() == GpgME::OpenPGP) {
             openpgp.push_back(*it);
         } else {
             smime.push_back(*it);
         }
 
     if (!openpgp.empty()) {
         Q_ASSERT(mOpenPGPBackend);
         startKeyListJobForBackend(mOpenPGPBackend, openpgp, true /*validate*/);
     }
     if (!smime.empty()) {
         Q_ASSERT(mSMIMEBackend);
         startKeyListJobForBackend(mSMIMEBackend, smime, true /*validate*/);
     }
 
     Q_ASSERT(mListJobCount > 0);
 }
 
 bool Kleo::KeySelectionDialog::rememberSelection() const
 {
     return mRememberCB && mRememberCB->isChecked();
 }
 
 void Kleo::KeySelectionDialog::slotRMB(Kleo::KeyListViewItem *item, const QPoint &p)
 {
     if (!item) {
         return;
     }
 
     mCurrentContextMenuItem = item;
 
     QMenu menu;
     menu.addAction(i18n("Recheck Key"), this, &KeySelectionDialog::slotRecheckKey);
     menu.exec(p);
 }
 
 void Kleo::KeySelectionDialog::slotRecheckKey()
 {
     if (!mCurrentContextMenuItem || mCurrentContextMenuItem->key().isNull()) {
         return;
     }
 
     mKeysToCheck.clear();
     mKeysToCheck.push_back(mCurrentContextMenuItem->key());
 }
 
 void Kleo::KeySelectionDialog::slotTryOk()
 {
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         slotOk();
     }
 }
 
 void Kleo::KeySelectionDialog::slotOk()
 {
     if (mCheckSelectionTimer->isActive()) {
         slotCheckSelection();
     }
 #if 0 //Laurent I don't understand why we returns here.
     // button could be disabled again after checking the selected key1
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         return;
     }
 #endif
     mStartSearchTimer->stop();
     accept();
 }
 
 void Kleo::KeySelectionDialog::slotCancel()
 {
     mCheckSelectionTimer->stop();
     mStartSearchTimer->stop();
     reject();
 }
 
 void Kleo::KeySelectionDialog::slotSearch(const QString &text)
 {
     mSearchText = text.trimmed().toUpper();
     slotSearch();
 }
 
 void Kleo::KeySelectionDialog::slotSearch()
 {
     mStartSearchTimer->setSingleShot(true);
     mStartSearchTimer->start(sCheckSelectionDelay);
 }
 
 void Kleo::KeySelectionDialog::slotFilter()
 {
     if (mSearchText.isEmpty()) {
         showAllItems();
         return;
     }
 
     // OK, so we need to filter:
     QRegExp keyIdRegExp(QLatin1String("(?:0x)?[A-F0-9]{1,8}"), Qt::CaseInsensitive);
     if (keyIdRegExp.exactMatch(mSearchText)) {
         if (mSearchText.startsWith(QLatin1String("0X")))
             // search for keyID only:
         {
             filterByKeyID(mSearchText.mid(2));
         } else
             // search for UID and keyID:
         {
             filterByKeyIDOrUID(mSearchText);
         }
     } else {
         // search in UID:
         filterByUID(mSearchText);
     }
 }
 
 void Kleo::KeySelectionDialog::filterByKeyID(const QString &keyID)
 {
     Q_ASSERT(keyID.length() <= 8);
     Q_ASSERT(!keyID.isEmpty());   // regexp in slotFilter should prevent these
     if (keyID.isEmpty()) {
         showAllItems();
     } else
         for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
             item->setHidden(!item->text(0).toUpper().startsWith(keyID));
         }
 }
 
 static bool anyUIDMatches(const Kleo::KeyListViewItem *item, QRegExp &rx)
 {
     if (!item) {
         return false;
     }
 
     const std::vector<GpgME::UserID> uids = item->key().userIDs();
     for (std::vector<GpgME::UserID>::const_iterator it = uids.begin(); it != uids.end(); ++it)
         if (it->id() && rx.indexIn(QString::fromUtf8(it->id())) >= 0) {
             return true;
         }
     return false;
 }
 
 void Kleo::KeySelectionDialog::filterByKeyIDOrUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!item->text(0).toUpper().startsWith(str) && !anyUIDMatches(item, rx));
     }
 
 }
 
 void Kleo::KeySelectionDialog::filterByUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!anyUIDMatches(item, rx));
     }
 }
 
 void Kleo::KeySelectionDialog::showAllItems()
 {
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(false);
     }
 }
 
diff --git a/src/utils/classify.cpp b/src/utils/classify.cpp
index 2634fad93..fe5375760 100644
--- a/src/utils/classify.cpp
+++ b/src/utils/classify.cpp
@@ -1,439 +1,439 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/classify.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2007 Klarälvdalens Datakonsult AB
 
     Kleopatra 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.
 
     Kleopatra 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 "classify.h"
 
 #include "libkleo_debug.h"
 #include "kleo/checksumdefinition.h"
 
 #include <QString>
 #include <QStringList>
 #include <QFile>
 #include <QFileInfo>
 #include <QtAlgorithms>
 #include <QByteArrayMatcher>
 #include <QMap>
 #include <QRegularExpression>
 
 #include <gpgme++/data.h>
 #include <qgpgme/dataprovider.h>
 
 #include <iterator>
 #include <functional>
 
 using namespace Kleo::Class;
 
 namespace
 {
 
 const unsigned int ExamineContentHint = 0x8000;
 
 static const struct _classification {
     char extension[4];
     unsigned int classification;
 } classifications[] = {
     // ordered by extension
     { "arl", CMS    | Binary  | CertificateRevocationList },
     { "asc", OpenPGP |  Ascii  | OpaqueSignature | DetachedSignature | CipherText | AnyCertStoreType | ExamineContentHint },
     { "cer", CMS    | Binary  | Certificate },
     { "crl", CMS    | Binary  | CertificateRevocationList },
     { "crt", CMS    | Binary  | Certificate },
     { "der", CMS    | Binary  | Certificate | CertificateRevocationList },
     { "gpg", OpenPGP | Binary  | OpaqueSignature | CipherText | AnyCertStoreType | ExamineContentHint},
     { "p10", CMS    |  Ascii  | CertificateRequest },
     { "p12", CMS    | Binary  | ExportedPSM },
     { "p7c", CMS    | Binary  | Certificate  },
     { "p7m", CMS    | AnyFormat | CipherText },
     { "p7s", CMS    | AnyFormat | AnySignature },
     { "pem", CMS    |  Ascii  | AnyType | ExamineContentHint },
     { "pfx", CMS    | Binary  | Certificate },
     { "pgp", OpenPGP | Binary  | OpaqueSignature | CipherText | AnyCertStoreType | ExamineContentHint},
     { "sig", OpenPGP | AnyFormat | DetachedSignature },
 };
 
 static const QMap<GpgME::Data::Type, unsigned int> gpgmeTypeMap {
     { GpgME::Data::PGPSigned, OpenPGP | OpaqueSignature },
     /* PGPOther might be just an unencrypted unsigned pgp message. Decrypt
      * would yield the plaintext anyway so for us this is CipherText. */
     { GpgME::Data::PGPOther, OpenPGP | CipherText },
     { GpgME::Data::PGPKey, OpenPGP | Certificate },
     { GpgME::Data::CMSSigned, CMS | AnySignature },
     { GpgME::Data::CMSEncrypted, CMS | CipherText },
     /* See PGPOther */
     { GpgME::Data::CMSOther, CMS | CipherText },
     { GpgME::Data::X509Cert, CMS | Certificate},
     { GpgME::Data::PKCS12, CMS | Binary | ExportedPSM },
     { GpgME::Data::PGPEncrypted, OpenPGP | CipherText },
     { GpgME::Data::PGPSignature, OpenPGP | DetachedSignature },
 };
 
 static const unsigned int defaultClassification = NoClass;
 
 template <template <typename U> class Op>
 struct ByExtension {
     typedef bool result_type;
 
     template <typename T>
     bool operator()(const T &lhs, const T &rhs) const
     {
         return Op<int>()(qstricmp(lhs.extension, rhs.extension), 0);
     }
     template <typename T>
     bool operator()(const T &lhs, const char *rhs) const
     {
         return Op<int>()(qstricmp(lhs.extension, rhs), 0);
     }
     template <typename T>
     bool operator()(const char *lhs, const T &rhs) const
     {
         return Op<int>()(qstricmp(lhs, rhs.extension), 0);
     }
     bool operator()(const char *lhs, const char *rhs) const
     {
         return Op<int>()(qstricmp(lhs, rhs), 0);
     }
 };
 
 static const struct _content_classification {
     char content[28];
     unsigned int classification;
 } content_classifications[] = {
     { "CERTIFICATE",       Certificate },
     { "ENCRYPTED MESSAGE", CipherText  },
     { "MESSAGE",           OpaqueSignature | CipherText },
     { "PKCS12",            ExportedPSM },
     { "PRIVATE KEY BLOCK", ExportedPSM },
     { "PUBLIC KEY BLOCK",  Certificate },
     { "SIGNATURE",         DetachedSignature },
     { "SIGNED MESSAGE",    ClearsignedMessage | DetachedSignature },
 };
 
 template <template <typename U> class Op>
 struct ByContent {
     typedef bool result_type;
 
     const unsigned int N;
     explicit ByContent(unsigned int n) : N(n) {}
 
     template <typename T>
     bool operator()(const T &lhs, const T &rhs) const
     {
         return Op<int>()(qstrncmp(lhs.content, rhs.content, N), 0);
     }
     template <typename T>
     bool operator()(const T &lhs, const char *rhs) const
     {
         return Op<int>()(qstrncmp(lhs.content, rhs, N), 0);
     }
     template <typename T>
     bool operator()(const char *lhs, const T &rhs) const
     {
         return Op<int>()(qstrncmp(lhs, rhs.content, N), 0);
     }
     bool operator()(const char *lhs, const char *rhs) const
     {
         return Op<int>()(qstrncmp(lhs, rhs, N), 0);
     }
 };
 
 }
 
 unsigned int Kleo::classify(const QStringList &fileNames)
 {
     if (fileNames.empty()) {
         return 0;
     }
     unsigned int result = classify(fileNames.front());
     for (const QString &fileName : fileNames) {
         result &= classify(fileName);
     }
     return result;
 }
 
 static unsigned int classifyExtension(const QFileInfo &fi)
 {
     const _classification *const it = qBinaryFind(std::begin(classifications), std::end(classifications),
                                       fi.suffix().toLatin1().constData(),
                                       ByExtension<std::less>());
     if (it != std::end(classifications))
         if (!(it->classification & ExamineContentHint)) {
             return it->classification;
         }
 
     return it == std::end(classifications) ? defaultClassification
                                         : it->classification;
 }
 
 unsigned int Kleo::classify(const QString &filename)
 {
     Q_ASSERT(std::is_sorted(std::begin(classifications), std::end(classifications), ByExtension<std::less>()));
 
     const QFileInfo fi(filename);
 
     if (!fi.exists()) {
         return 0;
     }
 
     QFile file(filename);
     /* The least reliable but always available classification */
     const unsigned int extClass = classifyExtension(fi);
     if (!GpgME::hasFeature(0, GpgME::BinaryAndFineGrainedIdentify) &&
         !(extClass & ExamineContentHint)) {
         /* GpgME's identify and our internal Classify were so incomplete
          * before BinaryAndFineGrainedIdentify that we are better of
          * to just use the file extension if ExamineContentHint is not set. */
         qCDebug(LIBKLEO_LOG) << "Classified based only on extension.";
         return extClass;
     }
 
     if (!file.open(QIODevice::ReadOnly)) {
         qCDebug(LIBKLEO_LOG) << "Failed to open file: " << filename << " for classification.";
         return extClass;
     }
 
     /* More reliable */
     const unsigned int contentClass = classifyContent(file.read(4096));
     if (contentClass != defaultClassification) {
         qCDebug(LIBKLEO_LOG) << "Classified based on content as:" << contentClass;
         return contentClass;
     }
 
     /* Probably some X509 Stuff that GpgME in it's wisdom does not handle. Again
      * file extension is probably more reliable as the last resort. */
     qCDebug(LIBKLEO_LOG) << "No classification based on content.";
     return extClass;
 }
 
 static unsigned int classifyContentInteral(const QByteArray &data)
 {
     Q_ASSERT(std::is_sorted(std::begin(content_classifications), std::end(content_classifications), ByContent<std::less>(100)));
 
     static const char beginString[] = "-----BEGIN ";
     static const QByteArrayMatcher beginMatcher(beginString);
     int pos = beginMatcher.indexIn(data);
     if (pos < 0) {
         return defaultClassification;
     }
     pos += sizeof beginString - 1;
 
     const bool pgp = qstrncmp(data.data() + pos, "PGP ", 4) == 0;
     if (pgp) {
         pos += 4;
     }
 
     const int epos = data.indexOf("-----\n", pos);
     if (epos < 0) {
         return defaultClassification;
     }
 
     const _content_classification *const cit
         = qBinaryFind(std::begin(content_classifications), std::end(content_classifications),
                       data.data() + pos, ByContent<std::less>(epos - pos));
 
     if (cit != std::end(content_classifications)) {
         return cit->classification | (pgp ? OpenPGP : CMS);
     }
     return defaultClassification;
 }
 
 unsigned int Kleo::classifyContent(const QByteArray &data)
 {
     /* As of Version 1.6.0 GpgME does not distinguish between detached
      * signatures and signatures. So we prefer kleo's classification and
      * only use gpgme as fallback.
      * With newer versions we have a better identify that really inspects
      * the PGP Packages. Which is by far the most reliable classification.
      * So this is already used for the default classification. File extensions
      * and our classifyinternal is only used as a fallback.
      */
     if (!GpgME::hasFeature(0, GpgME::BinaryAndFineGrainedIdentify)) {
         unsigned int ourClassification = classifyContentInteral(data);
         if (ourClassification != defaultClassification) {
             return ourClassification;
         }
     }
     QGpgME::QByteArrayDataProvider dp(data);
     GpgME::Data gpgmeData(&dp);
     GpgME::Data::Type type = gpgmeData.type();
 
     return gpgmeTypeMap.value(type, defaultClassification);
 }
 
 QString Kleo::printableClassification(unsigned int classification)
 {
     QStringList parts;
     if (classification & CMS) {
         parts.push_back(QStringLiteral("CMS"));
     }
     if (classification & OpenPGP) {
         parts.push_back(QStringLiteral("OpenPGP"));
     }
     if (classification & Binary) {
         parts.push_back(QStringLiteral("Binary"));
     }
     if (classification & Ascii) {
         parts.push_back(QStringLiteral("Ascii"));
     }
     if (classification & DetachedSignature) {
         parts.push_back(QStringLiteral("DetachedSignature"));
     }
     if (classification & OpaqueSignature) {
         parts.push_back(QStringLiteral("OpaqueSignature"));
     }
     if (classification & ClearsignedMessage) {
         parts.push_back(QStringLiteral("ClearsignedMessage"));
     }
     if (classification & CipherText) {
         parts.push_back(QStringLiteral("CipherText"));
     }
     if (classification & Certificate) {
         parts.push_back(QStringLiteral("Certificate"));
     }
     if (classification & ExportedPSM) {
         parts.push_back(QStringLiteral("ExportedPSM"));
     }
     if (classification & CertificateRequest) {
         parts.push_back(QStringLiteral("CertificateRequest"));
     }
     return parts.join(QLatin1String(", "));
 }
 
 static QString chopped(QString s, unsigned int n)
 {
     s.chop(n);
     return s;
 }
 
 /*!
   \return the data file that corresponds to the signature file \a
   signatureFileName, or QString(), if no such file can be found.
 */
 QString Kleo::findSignedData(const QString &signatureFileName)
 {
     if (!mayBeDetachedSignature(signatureFileName)) {
         return QString();
     }
     const QString baseName = chopped(signatureFileName, 4);
     return QFile::exists(baseName) ? baseName : QString();
 }
 
 /*!
-  \return all (existing) candiate signature files for \a signedDataFileName
+  \return all (existing) candidate signature files for \a signedDataFileName
 
   Note that there can very well be more than one such file, e.g. if
   the same data file was signed by both CMS and OpenPGP certificates.
 */
 QStringList Kleo::findSignatures(const QString &signedDataFileName)
 {
     QStringList result;
     for (unsigned int i = 0, end = sizeof(classifications) / sizeof(_classification); i < end; ++i)
         if (classifications[i].classification & DetachedSignature) {
-            const QString candiate = signedDataFileName + QLatin1Char('.') + QLatin1String(classifications[i].extension);
-            if (QFile::exists(candiate)) {
-                result.push_back(candiate);
+            const QString candidate = signedDataFileName + QLatin1Char('.') + QLatin1String(classifications[i].extension);
+            if (QFile::exists(candidate)) {
+                result.push_back(candidate);
             }
         }
     return result;
 }
 
 /*!
   \return the (likely) output filename for \a inputFileName, or
   "inputFileName.out" if none can be determined.
 */
 QString Kleo::outputFileName(const QString &inputFileName)
 {
     const QFileInfo fi(inputFileName);
 
     if (qBinaryFind(std::begin(classifications), std::end(classifications),
                     fi.suffix().toLatin1().constData(),
                     ByExtension<std::less>()) == std::end(classifications)) {
         return inputFileName + QLatin1String(".out");
     } else {
         return chopped(inputFileName, 4);
     }
 }
 
 /*!
   \return the commonly used extension for files of type
   \a classification, or NULL if none such exists.
 */
 const char *Kleo::outputFileExtension(unsigned int classification, bool usePGPFileExt)
 {
 
     if (classification & OpenPGP && usePGPFileExt) {
         return "pgp";
     }
 
     for (unsigned int i = 0; i < sizeof classifications / sizeof * classifications; ++i)
         if ((classifications[i].classification & classification) == classification) {
             return classifications[i].extension;
         }
     return nullptr;
 }
 
 bool Kleo::isFingerprint(const QString &fpr)
 {
     static QRegularExpression fprRegex(QStringLiteral("[0-9a-fA-F]{40}"));
     return fprRegex.match(fpr).hasMatch();
 }
 
 bool Kleo::isChecksumFile(const QString &file)
 {
     static bool initialized;
     static QList<QRegExp> patterns;
     const QFileInfo fi(file);
     if (!fi.exists()) {
         return false;
     }
     if (!initialized) {
         Q_FOREACH (const std::shared_ptr<ChecksumDefinition> &cd, ChecksumDefinition::getChecksumDefinitions()) {
             if (cd) {
                 Q_FOREACH (const QString &pattern, cd->patterns()) {
 #ifdef Q_OS_WIN
                     patterns << QRegExp(pattern, Qt::CaseInsensitive);
 #else
                     patterns << QRegExp(pattern, Qt::CaseSensitive);
 #endif
                 }
             }
         }
         initialized = true;
     }
 
     const QString fileName = fi.fileName();
     for (const QRegExp &pattern : qAsConst(patterns)) {
         if (pattern.exactMatch(fileName)) {
             return true;
         }
     }
     return false;
 }
diff --git a/src/utils/classify.h b/src/utils/classify.h
index 399fee97a..f9f003b92 100644
--- a/src/utils/classify.h
+++ b/src/utils/classify.h
@@ -1,156 +1,156 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/classify.h
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2007 Klarälvdalens Datakonsult AB
 
     Kleopatra 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.
 
     Kleopatra 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 <gpgme++/global.h>
 
 #ifndef LIBKLEO_CLASSIFY_H
 #define LIBKLEO_CLASSIFY_H
 
 #include <QByteArray>
 
 #include <kleo_export.h>
 
 class QString;
 class QStringList;
 
 namespace Kleo
 {
 
 namespace Class
 {
 enum {
     NoClass = 0,
 
     // protocol:
     CMS          = 0x01,
     OpenPGP      = 0x02,
 
     AnyProtocol  = OpenPGP | CMS,
     ProtocolMask = AnyProtocol,
 
     // format:
     Binary     = 0x04,
     Ascii      = 0x08,
 
     AnyFormat  = Binary | Ascii,
     FormatMask = AnyFormat,
 
     // type:
     DetachedSignature  = 0x010,
     OpaqueSignature    = 0x020,
     ClearsignedMessage = 0x040,
 
     AnySignature       = DetachedSignature | OpaqueSignature | ClearsignedMessage,
 
     CipherText         = 0x080,
 
     AnyMessageType     = AnySignature | CipherText,
 
     Importable         = 0x100,
     Certificate        = 0x200 | Importable,
     ExportedPSM        = 0x400 | Importable,
 
     AnyCertStoreType   = Certificate | ExportedPSM,
 
     CertificateRequest = 0x800,
 
     CertificateRevocationList = 0x1000,
 
     AnyType            = AnyMessageType | AnyCertStoreType | CertificateRequest | CertificateRevocationList,
     TypeMask           = AnyType
 };
 }
 
 KLEO_EXPORT unsigned int classify(const QString &filename);
 KLEO_EXPORT unsigned int classify(const QStringList &fileNames);
 KLEO_EXPORT unsigned int classifyContent(const QByteArray &data);
 
 KLEO_EXPORT QString findSignedData(const QString &signatureFileName);
 KLEO_EXPORT QStringList findSignatures(const QString &signedDataFileName);
 KLEO_EXPORT QString outputFileName(const QString &input);
 
 /** Check if a string looks like a fingerprint (SHA1 sum) */
 KLEO_EXPORT bool isFingerprint(const QString &fpr);
 
 /** Check if a filename matches a ChecksumDefinition pattern */
 KLEO_EXPORT bool isChecksumFile(const QString &file);
 
 KLEO_EXPORT const char *outputFileExtension(unsigned int classification, bool usePGPFileExt);
 
 KLEO_EXPORT QString printableClassification(unsigned int classification);
 
 #define make_convenience( What, Mask )                                  \
     inline bool is##What( const QString & filename ) {                  \
         return ( classify( filename ) & Class::Mask ) == Class::What ;  \
     }                                                                   \
-    inline bool is##What( const unsigned int classifcation ) {          \
-        return ( classifcation & Class::Mask ) == Class::What ;         \
+    inline bool is##What( const unsigned int classification ) {         \
+        return ( classification & Class::Mask ) == Class::What ;        \
     }                                                                   \
     inline bool mayBe##What( const QString & filename ) {               \
         return classify( filename ) & Class::What ;                     \
     }                                                                   \
-    inline bool mayBe##What( const unsigned int classifcation ) {       \
-        return classifcation & Class::What ;                            \
+    inline bool mayBe##What( const unsigned int classification ) {      \
+        return classification & Class::What ;                           \
     }
 
 make_convenience(CMS,     ProtocolMask)
 make_convenience(OpenPGP, ProtocolMask)
 
 make_convenience(Binary, FormatMask)
 make_convenience(Ascii,  FormatMask)
 
 make_convenience(DetachedSignature, TypeMask)
 make_convenience(OpaqueSignature,   TypeMask)
 make_convenience(CipherText,        TypeMask)
 make_convenience(AnyMessageType,    TypeMask)
 make_convenience(CertificateRevocationList, TypeMask)
 make_convenience(AnyCertStoreType,  TypeMask)
 #undef make_convenience
 
-inline GpgME::Protocol findProtocol(const unsigned int classifcation)
+inline GpgME::Protocol findProtocol(const unsigned int classification)
 {
-    if (isOpenPGP(classifcation)) {
+    if (isOpenPGP(classification)) {
         return GpgME::OpenPGP;
-    } else if (isCMS(classifcation)) {
+    } else if (isCMS(classification)) {
         return GpgME::CMS;
     } else {
         return GpgME::UnknownProtocol;
     }
 }
 inline GpgME::Protocol findProtocol(const QString &filename)
 {
     return findProtocol(classify(filename));
 }
 
 }
 
 #endif /* __KLEOPATRA_UISERVER_CLASSIFY_H__ */
diff --git a/src/utils/formatting.cpp b/src/utils/formatting.cpp
index c57c85d41..401ebaec2 100644
--- a/src/utils/formatting.cpp
+++ b/src/utils/formatting.cpp
@@ -1,1058 +1,1058 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; -*-
 
     utils/formatting.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2007 Klarälvdalens Datakonsult AB
 
     Kleopatra 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.
 
     Kleopatra 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 "formatting.h"
 #include "kleo/dn.h"
 
 #include <gpgme++/key.h>
 #include <gpgme++/importresult.h>
 
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 
 #include <KLocalizedString>
 #include <KEmailAddress>
 
 #include <QString>
 #include <QStringList>
 #include <QDateTime>
 #include <QTextDocument> // for Qt::escape
 #include <QLocale>
 #include <QIcon>
 #include <QRegularExpression>
 
 #include "models/keycache.h"
 
 using namespace GpgME;
 using namespace Kleo;
 
 //
 // Name
 //
 
 QString Formatting::prettyName(int proto, const char *id, const char *name_, const char *comment_)
 {
 
     if (proto == OpenPGP) {
         const QString name = QString::fromUtf8(name_);
         if (name.isEmpty()) {
             return QString();
         }
         const QString comment = QString::fromUtf8(comment_);
         if (comment.isEmpty()) {
             return name;
         }
         return QStringLiteral("%1 (%2)").arg(name, comment);
     }
 
     if (proto == CMS) {
         const DN subject(id);
         const QString cn = subject[QStringLiteral("CN")].trimmed();
         if (cn.isEmpty()) {
             return subject.prettyDN();
         }
         return cn;
     }
 
     return QString();
 }
 
 QString Formatting::prettyNameAndEMail(int proto, const char *id, const char *name_, const char *email_, const char *comment_)
 {
     return prettyNameAndEMail(proto, QString::fromUtf8(id), QString::fromUtf8(name_), prettyEMail(email_, id), QString::fromUtf8(comment_));
 }
 
 QString Formatting::prettyNameAndEMail(int proto, const QString &id, const QString &name, const QString &email, const QString &comment)
 {
 
     if (proto == OpenPGP) {
         if (name.isEmpty()) {
             if (email.isEmpty()) {
                 return QString();
             } else if (comment.isEmpty()) {
                 return QStringLiteral("<%1>").arg(email);
             } else {
                 return QStringLiteral("(%2) <%1>").arg(email, comment);
             }
         }
         if (email.isEmpty()) {
             if (comment.isEmpty()) {
                 return name;
             } else {
                 return QStringLiteral("%1 (%2)").arg(name, comment);
             }
         }
         if (comment.isEmpty()) {
             return QStringLiteral("%1 <%2>").arg(name, email);
         } else {
             return QStringLiteral("%1 (%3) <%2>").arg(name, email, comment);
         }
     }
 
     if (proto == CMS) {
         const DN subject(id);
         const QString cn = subject[QStringLiteral("CN")].trimmed();
         if (cn.isEmpty()) {
             return subject.prettyDN();
         }
         return cn;
     }
     return QString();
 }
 
 QString Formatting::prettyUserID(const UserID &uid)
 {
     if (uid.parent().protocol() == OpenPGP) {
         return prettyNameAndEMail(uid);
     }
     const QByteArray id = QByteArray(uid.id()).trimmed();
     if (id.startsWith('<')) {
         return prettyEMail(uid.email(), uid.id());
     }
     if (id.startsWith('('))
         // ### parse uri/dns:
     {
         return QString::fromUtf8(uid.id());
     } else {
         return DN(uid.id()).prettyDN();
     }
 }
 
 QString Formatting::prettyKeyID(const char *id)
 {
     if (!id) {
         return QString();
     }
     return QLatin1String("0x") + QString::fromLatin1(id).toUpper();
 }
 
 QString Formatting::prettyNameAndEMail(const UserID &uid)
 {
     return prettyNameAndEMail(uid.parent().protocol(), uid.id(), uid.name(), uid.email(), uid.comment());
 }
 
 QString Formatting::prettyNameAndEMail(const Key &key)
 {
     return prettyNameAndEMail(key.userID(0));
 }
 
 QString Formatting::prettyName(const Key &key)
 {
     return prettyName(key.userID(0));
 }
 
 QString Formatting::prettyName(const UserID &uid)
 {
     return prettyName(uid.parent().protocol(), uid.id(), uid.name(), uid.comment());
 }
 
 QString Formatting::prettyName(const UserID::Signature &sig)
 {
     return prettyName(OpenPGP, sig.signerUserID(), sig.signerName(), sig.signerComment());
 }
 
 //
 // EMail
 //
 
 QString Formatting::prettyEMail(const Key &key)
 {
     for (unsigned int i = 0, end = key.numUserIDs(); i < end; ++i) {
         const QString email = prettyEMail(key.userID(i));
         if (!email.isEmpty()) {
             return email;
         }
     }
     return QString();
 }
 
 QString Formatting::prettyEMail(const UserID &uid)
 {
     return prettyEMail(uid.email(), uid.id());
 }
 
 QString Formatting::prettyEMail(const UserID::Signature &sig)
 {
     return prettyEMail(sig.signerEmail(), sig.signerUserID());
 }
 
 QString Formatting::prettyEMail(const char *email_, const char *id)
 {
     QString email, name, comment;
     if (email_ && KEmailAddress::splitAddress(QString::fromUtf8(email_),
                                               name, email, comment) == KEmailAddress::AddressOk) {
         return email;
     } else {
         return DN(id)[QStringLiteral("EMAIL")].trimmed();
     }
 }
 
 //
 // Tooltip
 //
 
 namespace
 {
 
 static QString protect_whitespace(QString s)
 {
     static const QLatin1Char SP(' '), NBSP('\xA0');
     return s.replace(SP, NBSP);
 }
 
 template <typename T_arg>
 QString format_row(const QString &field, const T_arg &arg)
 {
     return QStringLiteral("<tr><th>%1:</th><td>%2</td></tr>").arg(protect_whitespace(field), arg);
 }
 QString format_row(const QString &field, const QString &arg)
 {
     return QStringLiteral("<tr><th>%1:</th><td>%2</td></tr>").arg(protect_whitespace(field), arg.toHtmlEscaped());
 }
 QString format_row(const QString &field, const char *arg)
 {
     return format_row(field, QString::fromUtf8(arg));
 }
 
 QString format_keytype(const Key &key)
 {
     const Subkey subkey = key.subkey(0);
     if (key.hasSecret()) {
         return i18n("%1-bit %2 (secret key available)", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
     } else {
         return i18n("%1-bit %2", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
     }
 }
 
 QString format_subkeytype(const Subkey &subkey)
 {
     const auto algo = subkey.publicKeyAlgorithm();
 
     if (algo == Subkey::AlgoECC ||
         algo == Subkey::AlgoECDSA ||
         algo == Subkey::AlgoECDH ||
         algo == Subkey::AlgoEDDSA) {
         return QString::fromStdString(subkey.algoName());
     }
     return i18n("%1-bit %2", subkey.length(), QLatin1String(subkey.publicKeyAlgorithmAsString()));
 }
 
 QString format_keyusage(const Key &key)
 {
     QStringList capabilities;
     if (key.canReallySign()) {
         if (key.isQualified()) {
             capabilities.push_back(i18n("Signing (Qualified)"));
         } else {
             capabilities.push_back(i18n("Signing"));
         }
     }
     if (key.canEncrypt()) {
         capabilities.push_back(i18n("Encryption"));
     }
     if (key.canCertify()) {
         capabilities.push_back(i18n("Certifying User-IDs"));
     }
     if (key.canAuthenticate()) {
         capabilities.push_back(i18n("SSH Authentication"));
     }
     return capabilities.join(QLatin1String(", "));
 }
 
 QString format_subkeyusage(const Subkey &subkey)
 {
     QStringList capabilities;
     if (subkey.canSign()) {
         if (subkey.isQualified()) {
             capabilities.push_back(i18n("Signing (Qualified)"));
         } else {
             capabilities.push_back(i18n("Signing"));
         }
     }
     if (subkey.canEncrypt()) {
         capabilities.push_back(i18n("Encryption"));
     }
     if (subkey.canCertify()) {
         capabilities.push_back(i18n("Certifying User-IDs"));
     }
     if (subkey.canAuthenticate()) {
         capabilities.push_back(i18n("SSH Authentication"));
     }
     return capabilities.join(QLatin1String(", "));
 }
 
 static QString time_t2string(time_t t)
 {
     QDateTime dt;
     dt.setTime_t(t);
     return QLocale().toString(dt, QLocale::ShortFormat);
 }
 
 static QString make_red(const QString &txt)
 {
     return QLatin1String("<font color=\"red\">") + txt.toHtmlEscaped() + QLatin1String("</font>");
 }
 
 }
 
 QString Formatting::toolTip(const Key &key, int flags)
 {
     if (flags == 0 || (key.protocol() != CMS && key.protocol() != OpenPGP)) {
         return QString();
     }
 
     const Subkey subkey = key.subkey(0);
 
     QString result;
     if (flags & Validity) {
         if (key.protocol() == OpenPGP || (key.keyListMode() & Validate))
             if (key.isRevoked()) {
                 result = make_red(i18n("Revoked"));
             } else if (key.isExpired()) {
                 result = make_red(i18n("Expired"));
             } else if (key.isDisabled()) {
                 result = i18n("Disabled");
             } else {
                 unsigned int fullyTrusted = 0;
                 for (const auto &uid: key.userIDs()) {
                     if (uid.validity() >= UserID::Validity::Full) {
                         fullyTrusted++;
                     }
                 }
                 if (fullyTrusted == key.numUserIDs()) {
                     result = i18n("All User-IDs are certified.");
                     const auto compliance = complianceStringForKey(key);
                     if (!compliance.isEmpty()) {
                         result += QStringLiteral("<br>") + compliance;
                     }
                 } else {
                     result = i18np("One User-ID is not certified.", "%1 User-IDs are not certified.", key.numUserIDs() - fullyTrusted);
                 }
             }
         else {
             result = i18n("The validity cannot be checked at the moment.");
         }
     }
     if (flags == Validity) {
         return result;
     }
 
     result += QLatin1String("<table border=\"0\">");
     if (key.protocol() == CMS) {
         if (flags & SerialNumber) {
             result += format_row(i18n("Serial number"), key.issuerSerial());
         }
         if (flags & Issuer) {
             result += format_row(i18n("Issuer"), key.issuerName());
         }
     }
     if (flags & UserIDs) {
         const std::vector<UserID> uids = key.userIDs();
         if (!uids.empty())
             result += format_row(key.protocol() == CMS
                                  ? i18n("Subject")
                                  : i18n("User-ID"), prettyUserID(uids.front()));
         if (uids.size() > 1)
             for (std::vector<UserID>::const_iterator it = uids.begin() + 1, end = uids.end(); it != end; ++it)
                 if (!it->isRevoked() && !it->isInvalid()) {
                     result += format_row(i18n("a.k.a."), prettyUserID(*it));
                 }
     }
     if (flags & ExpiryDates) {
         result += format_row(i18n("Created"), time_t2string(subkey.creationTime()));
 
         if (key.isExpired()) {
             result += format_row(i18n("Expired"), time_t2string(subkey.expirationTime()));
         } else if (!subkey.neverExpires()) {
             result += format_row(i18n("Expires"), time_t2string(subkey.expirationTime()));
         }
     }
     if (flags & CertificateType) {
         result += format_row(i18n("Type"), format_keytype(key));
     }
     if (flags & CertificateUsage) {
         result += format_row(i18n("Usage"), format_keyusage(key));
     }
     if (flags & KeyID) {
         result += format_row(i18n("Key-ID"), QString::fromLatin1(key.shortKeyID()));
     }
     if (flags & Fingerprint) {
         result += format_row(i18n("Fingerprint"), key.primaryFingerprint());
     }
     if (flags & OwnerTrust) {
         if (key.protocol() == OpenPGP) {
             result += format_row(i18n("Certification trust"), ownerTrustShort(key));
         } else if (key.isRoot()) {
             result += format_row(i18n("Trusted issuer?"),
                                  key.userID(0).validity() == UserID::Ultimate ? i18n("Yes") :
                                  /* else */                                     i18n("No"));
         }
     }
 
     if (flags & StorageLocation) {
         if (const char *card = subkey.cardSerialNumber()) {
             result += format_row(i18n("Stored"), i18nc("stored...", "on SmartCard with serial no. %1", QString::fromUtf8(card)));
         } else {
             result += format_row(i18n("Stored"), i18nc("stored...", "on this computer"));
         }
     }
     if (flags & Subkeys) {
         for (const auto &sub: key.subkeys()) {
             result += QLatin1String("<hr/>");
             result += format_row(i18n("Subkey"), sub.fingerprint());
             if (sub.isRevoked()) {
                 result += format_row(i18n("Status"), i18n("Revoked"));
             } else if (sub.isExpired()) {
                 result += format_row(i18n("Status"), i18n("Expired"));
             }
             if (flags & ExpiryDates) {
                 result += format_row(i18n("Created"), time_t2string(sub.creationTime()));
 
                 if (key.isExpired()) {
                     result += format_row(i18n("Expired"), time_t2string(sub.expirationTime()));
                 } else if (!subkey.neverExpires()) {
                     result += format_row(i18n("Expires"), time_t2string(sub.expirationTime()));
                 }
             }
 
             if (flags & CertificateType) {
                 result += format_row(i18n("Type"), format_subkeytype(sub));
             }
             if (flags & CertificateUsage) {
                 result += format_row(i18n("Usage"), format_subkeyusage(sub));
             }
             if (flags & StorageLocation) {
                 if (const char *card = sub.cardSerialNumber()) {
                     result += format_row(i18n("Stored"), i18nc("stored...", "on SmartCard with serial no. %1", QString::fromUtf8(card)));
                 } else {
                     result += format_row(i18n("Stored"), i18nc("stored...", "on this computer"));
                 }
             }
         }
     }
     result += QLatin1String("</table>");
 
     return result;
 }
 
 //
 // Creation and Expiration
 //
 
 namespace
 {
 static QDate time_t2date(time_t t)
 {
     if (!t) {
         return QDate();
     }
     QDateTime dt;
     dt.setTime_t(t);
     return dt.date();
 }
 static QString date2string(const QDate &date)
 {
     return QLocale().toString(date, QLocale::ShortFormat);
 }
 
 template <typename T>
 QString expiration_date_string(const T &tee)
 {
     return tee.neverExpires() ? QString() : date2string(time_t2date(tee.expirationTime()));
 }
 template <typename T>
 QDate creation_date(const T &tee)
 {
     return time_t2date(tee.creationTime());
 }
 template <typename T>
 QDate expiration_date(const T &tee)
 {
     return time_t2date(tee.expirationTime());
 }
 }
 
 QString Formatting::dateString(time_t t)
 {
     return date2string(time_t2date(t));
 }
 
 QString Formatting::expirationDateString(const Key &key)
 {
     return expiration_date_string(key.subkey(0));
 }
 
 QString Formatting::expirationDateString(const Subkey &subkey)
 {
     return expiration_date_string(subkey);
 }
 
 QString Formatting::expirationDateString(const UserID::Signature &sig)
 {
     return expiration_date_string(sig);
 }
 
 QDate Formatting::expirationDate(const Key &key)
 {
     return expiration_date(key.subkey(0));
 }
 
 QDate Formatting::expirationDate(const Subkey &subkey)
 {
     return expiration_date(subkey);
 }
 
 QDate Formatting::expirationDate(const UserID::Signature &sig)
 {
     return expiration_date(sig);
 }
 
 QString Formatting::creationDateString(const Key &key)
 {
     return date2string(creation_date(key.subkey(0)));
 }
 
 QString Formatting::creationDateString(const Subkey &subkey)
 {
     return date2string(creation_date(subkey));
 }
 
 QString Formatting::creationDateString(const UserID::Signature &sig)
 {
     return date2string(creation_date(sig));
 }
 
 QDate Formatting::creationDate(const Key &key)
 {
     return creation_date(key.subkey(0));
 }
 
 QDate Formatting::creationDate(const Subkey &subkey)
 {
     return creation_date(subkey);
 }
 
 QDate Formatting::creationDate(const UserID::Signature &sig)
 {
     return creation_date(sig);
 }
 
 //
 // Types
 //
 
 QString Formatting::displayName(Protocol p)
 {
     if (p == CMS) {
         return i18nc("X.509/CMS encryption standard", "X.509");
     }
     if (p == OpenPGP) {
         return i18n("OpenPGP");
     }
     return i18nc("Unknown encryption protocol", "Unknown");
 }
 
 QString Formatting::type(const Key &key)
 {
     return displayName(key.protocol());
 }
 
 QString Formatting::type(const Subkey &subkey)
 {
     return QString::fromUtf8(subkey.publicKeyAlgorithmAsString());
 }
 
 //
 // Status / Validity
 //
 
 QString Formatting::ownerTrustShort(const Key &key)
 {
     return ownerTrustShort(key.ownerTrust());
 }
 
 QString Formatting::ownerTrustShort(Key::OwnerTrust trust)
 {
     switch (trust) {
     case Key::Unknown:   return i18nc("unknown trust level", "unknown");
     case Key::Never:     return i18n("untrusted");
     case Key::Marginal:  return i18nc("marginal trust", "marginal");
     case Key::Full:      return i18nc("full trust", "full");
     case Key::Ultimate:  return i18nc("ultimate trust", "ultimate");
     case Key::Undefined: return i18nc("undefined trust", "undefined");
     default:
         Q_ASSERT(!"unexpected owner trust value");
         break;
     }
     return QString();
 }
 
 QString Formatting::validityShort(const Subkey &subkey)
 {
     if (subkey.isRevoked()) {
         return i18n("revoked");
     }
     if (subkey.isExpired()) {
         return i18n("expired");
     }
     if (subkey.isDisabled()) {
         return i18n("disabled");
     }
     if (subkey.isInvalid()) {
         return i18n("invalid");
     }
     return i18nc("as in good/valid signature", "good");
 }
 
 QString Formatting::validityShort(const UserID &uid)
 {
     if (uid.isRevoked()) {
         return i18n("revoked");
     }
     if (uid.isInvalid()) {
         return i18n("invalid");
     }
     switch (uid.validity()) {
     case UserID::Unknown:   return i18nc("unknown trust level", "unknown");
     case UserID::Undefined: return i18nc("undefined trust", "undefined");
     case UserID::Never:     return i18n("untrusted");
     case UserID::Marginal:  return i18nc("marginal trust", "marginal");
     case UserID::Full:      return i18nc("full trust", "full");
     case UserID::Ultimate:  return i18nc("ultimate trust", "ultimate");
     }
     return QString();
 }
 
 QString Formatting::validityShort(const UserID::Signature &sig)
 {
     switch (sig.status()) {
     case UserID::Signature::NoError:
         if (!sig.isInvalid()) {
             /* See RFC 4880 Section 5.2.1 */
             switch (sig.certClass()) {
             case 0x10: /* Generic */
             case 0x11: /* Persona */
             case 0x12: /* Casual */
             case 0x13: /* Positive */
                 return i18n("valid");
             case 0x30:
                 return i18n("revoked");
             default:
                 return i18n("class %1", sig.certClass());
             }
         }
         Q_FALLTHROUGH();
         // fall through:
     case UserID::Signature::GeneralError:
         return i18n("invalid");
     case UserID::Signature::SigExpired:   return i18n("expired");
     case UserID::Signature::KeyExpired:   return i18n("certificate expired");
     case UserID::Signature::BadSignature: return i18nc("fake/invalid signature", "bad");
     case UserID::Signature::NoPublicKey: {
             /* GnuPG returns the same error for no public key as for expired
              * or revoked certificates. */
             const auto key = KeyCache::instance()->findByKeyIDOrFingerprint (sig.signerKeyID());
             if (key.isNull()) {
                 return i18n("no public key");
             } else if (key.isExpired()) {
                 return i18n("key expired");
             } else if (key.isRevoked()) {
                 return i18n("key revoked");
             } else if (key.isDisabled()) {
                 return i18n("key disabled");
             }
             /* can't happen */
-            return QStringLiteral("unknwon");
+            return QStringLiteral("unknown");
         }
     }
     return QString();
 }
 
 QIcon Formatting::validityIcon(const UserID::Signature &sig)
 {
     switch (sig.status()) {
     case UserID::Signature::NoError:
         if (!sig.isInvalid()) {
             /* See RFC 4880 Section 5.2.1 */
             switch (sig.certClass()) {
             case 0x10: /* Generic */
             case 0x11: /* Persona */
             case 0x12: /* Casual */
             case 0x13: /* Positive */
                 return QIcon::fromTheme(QStringLiteral("emblem-success"));
             case 0x30:
                 return QIcon::fromTheme(QStringLiteral("emblem-error"));
             default:
                 return QIcon();
             }
         }
         Q_FALLTHROUGH();
         // fall through:
     case UserID::Signature::BadSignature:
     case UserID::Signature::GeneralError:
         return QIcon::fromTheme(QStringLiteral("emblem-error"));
     case UserID::Signature::SigExpired:
     case UserID::Signature::KeyExpired:
         return QIcon::fromTheme(QStringLiteral("emblem-information"));
     case UserID::Signature::NoPublicKey:
         return QIcon::fromTheme(QStringLiteral("emblem-question"));
     }
     return QIcon();
 }
 
 QString Formatting::formatKeyLink(const Key &key)
 {
     if (key.isNull()) {
         return QString();
     }
     return QStringLiteral("<a href=\"key:%1\">%2</a>").arg(QLatin1String(key.primaryFingerprint()), Formatting::prettyName(key));
 }
 
 QString Formatting::formatForComboBox(const GpgME::Key &key)
 {
     const QString name = prettyName(key);
     QString mail = prettyEMail(key);
     if (!mail.isEmpty()) {
         mail = QLatin1Char('<') + mail + QLatin1Char('>');
     }
     return i18nc("name, email, key id", "%1 %2 (%3)", name, mail, QLatin1String(key.shortKeyID())).simplified();
 }
 
 namespace
 {
 
 static QString keyToString(const Key &key)
 {
 
     Q_ASSERT(!key.isNull());
 
     const QString email = Formatting::prettyEMail(key);
     const QString name = Formatting::prettyName(key);
 
     if (name.isEmpty()) {
         return email;
     } else if (email.isEmpty()) {
         return name;
     } else {
         return QStringLiteral("%1 <%2>").arg(name, email);
     }
 }
 
 }
 
 const char *Formatting::summaryToString(const Signature::Summary summary)
 {
     if (summary & Signature::Red) {
         return "RED";
     }
     if (summary & Signature::Green) {
         return "GREEN";
     }
     return "YELLOW";
 }
 
 QString Formatting::signatureToString(const Signature &sig, const Key &key)
 {
     if (sig.isNull()) {
         return QString();
     }
 
     const bool red   = (sig.summary() & Signature::Red);
     const bool valid = (sig.summary() & Signature::Valid);
 
     if (red)
         if (key.isNull())
             if (const char *fpr = sig.fingerprint()) {
                 return i18n("Bad signature by unknown certificate %1: %2", QString::fromLatin1(fpr), QString::fromLocal8Bit(sig.status().asString()));
             } else {
                 return i18n("Bad signature by an unknown certificate: %1", QString::fromLocal8Bit(sig.status().asString()));
             }
         else {
             return i18n("Bad signature by %1: %2", keyToString(key), QString::fromLocal8Bit(sig.status().asString()));
         }
 
     else if (valid)
         if (key.isNull())
             if (const char *fpr = sig.fingerprint()) {
                 return i18n("Good signature by unknown certificate %1.", QString::fromLatin1(fpr));
             } else {
                 return i18n("Good signature by an unknown certificate.");
             }
         else {
             return i18n("Good signature by %1.", keyToString(key));
         }
 
     else if (key.isNull())
         if (const char *fpr = sig.fingerprint()) {
             return i18n("Invalid signature by unknown certificate %1: %2", QString::fromLatin1(fpr), QString::fromLocal8Bit(sig.status().asString()));
         } else {
             return i18n("Invalid signature by an unknown certificate: %1", QString::fromLocal8Bit(sig.status().asString()));
         }
     else {
         return i18n("Invalid signature by %1: %2", keyToString(key), QString::fromLocal8Bit(sig.status().asString()));
     }
 }
 
 //
 // ImportResult
 //
 
 QString Formatting::importMetaData(const Import &import, const QStringList &ids)
 {
     const QString result = importMetaData(import);
     if (result.isEmpty()) {
         return QString();
     } else
         return result + QLatin1Char('\n') +
                i18n("This certificate was imported from the following sources:") + QLatin1Char('\n') +
                ids.join(QLatin1Char('\n'));
 }
 
 QString Formatting::importMetaData(const Import &import)
 {
 
     if (import.isNull()) {
         return QString();
     }
 
     if (import.error().isCanceled()) {
         return i18n("The import of this certificate was canceled.");
     }
     if (import.error())
         return i18n("An error occurred importing this certificate: %1",
                     QString::fromLocal8Bit(import.error().asString()));
 
     const unsigned int status = import.status();
     if (status & Import::NewKey)
         return (status & Import::ContainedSecretKey)
                ? i18n("This certificate was new to your keystore. The secret key is available.")
                : i18n("This certificate is new to your keystore.");
 
     QStringList results;
     if (status & Import::NewUserIDs) {
         results.push_back(i18n("New user-ids were added to this certificate by the import."));
     }
     if (status & Import::NewSignatures) {
         results.push_back(i18n("New signatures were added to this certificate by the import."));
     }
     if (status & Import::NewSubkeys) {
         results.push_back(i18n("New subkeys were added to this certificate by the import."));
     }
 
     return results.empty()
            ? i18n("The import contained no new data for this certificate. It is unchanged.")
            : results.join(QLatin1Char('\n'));
 }
 
 //
 // Overview in CertificateDetailsDialog
 //
 
 QString Formatting::formatOverview(const Key &key)
 {
     return toolTip(key, AllOptions);
 }
 
 QString Formatting::usageString(const Subkey &sub)
 {
     QStringList usageStrings;
     if (sub.canCertify()) {
         usageStrings << i18n("Certify");
     }
     if (sub.canSign()) {
         usageStrings << i18n("Sign");
     }
     if (sub.canEncrypt()) {
         usageStrings << i18n("Encrypt");
     }
     if (sub.canAuthenticate()) {
         usageStrings << i18n("Authenticate");
     }
     return usageStrings.join(QLatin1String(", "));
 }
 
 QString Formatting::summaryLine(const Key &key)
 {
     return keyToString(key) + QLatin1Char(' ') +
            i18nc("(validity, protocol, creation date)",
                  "(%1, %2, created: %3)",
 		 Formatting::complianceStringShort(key),
 		 displayName(key.protocol()),
                  Formatting::creationDateString(key));
 }
 
 // Icon for certificate selection indication
 QIcon Formatting::iconForUid(const UserID &uid)
 {
     switch (uid.validity()) {
         case UserID::Ultimate:
         case UserID::Full:
         case UserID::Marginal:
             return QIcon::fromTheme(QStringLiteral("emblem-success"));
         case UserID::Never:
             return QIcon::fromTheme(QStringLiteral("emblem-error"));
         case UserID::Undefined:
         case UserID::Unknown:
         default:
             return QIcon::fromTheme(QStringLiteral("emblem-information"));
     }
 }
 
 QString Formatting::validity(const UserID &uid)
 {
     switch (uid.validity()) {
         case UserID::Ultimate:
             return i18n("The certificate is marked as your own.");
         case UserID::Full:
             return i18n("The certificate belongs to this recipient.");
         case UserID::Marginal:
             return i18n("The trust model indicates marginally that the certificate belongs to this recipient.");
         case UserID::Never:
             return i18n("This certificate should not be used.");
         case UserID::Undefined:
         case UserID::Unknown:
         default:
             return i18n("There is no indication that this certificate belongs to this recipient.");
     }
 }
 
 bool Formatting::uidsHaveFullValidity(const GpgME::Key &key)
 {
     bool oneValid = false;
     for (const auto &uid: key.userIDs()) {
         if (uid.isRevoked()) {
             /* Skip revoked uids */
             continue;
         }
         if (uid.validity() < UserID::Validity::Full) {
             return false;
         }
         /* Only return true if we have found at least one
          * valid uid. E.g. if all uids are revoked we do
          * not want to return true here. */
         oneValid = true;
     }
     return oneValid;
 }
 
 QString Formatting::complianceMode()
 {
     const QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
     if (!config) {
         return QString();
     }
     const QGpgME::CryptoConfigEntry *const entry = config->entry(QStringLiteral("gpg"), QStringLiteral("Configuration"), QStringLiteral("compliance"));
 
     if (!entry || entry->stringValue() == QLatin1String("gnupg")) {
         return QString();
     }
     return entry->stringValue();
 }
 
 bool Formatting::isKeyDeVs(const GpgME::Key &key)
 {
     for (const auto &sub: key.subkeys()) {
         if (sub.isExpired() || sub.isRevoked()) {
             // Ignore old subkeys
             continue;
         }
         if (!sub.isDeVs()) {
             return false;
         }
     }
     return true;
 }
 
 QString Formatting::complianceStringForKey(const GpgME::Key &key)
 {
     // There will likely be more in the future for other institutions
     // for now we only have DE-VS
     if (complianceMode() == QLatin1String("de-vs")) {
         if (uidsHaveFullValidity(key) && isKeyDeVs(key)) {
             return i18nc("VS-NfD conforming is a German standard for restricted documents. For which special restrictions about algorithms apply. The string describes if a key is compliant with that..",
                          "May be used for VS-NfD-compliant communication.");
         } else {
             return i18nc("VS-NfD-conforming is a German standard for restricted documents. For which special restrictions about algorithms apply. The string describes if a key is compliant to that..",
                          "May <b>not</b> be used for VS-NfD-compliant communication.");
         }
     }
     return QString();
 }
 
 QString Formatting::complianceStringShort(const GpgME::Key &key)
 {
     if (Formatting::uidsHaveFullValidity(key)) {
         if (complianceMode() == QLatin1String("de-vs")
             && Formatting::isKeyDeVs(key)) {
             return QStringLiteral("★ ") +
                 i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that a key is compliant with that.",
                       "VS-NfD-compliant");
         }
         return i18nc("As in all user IDs are valid.", "certified");
     }
     if (key.isExpired()) {
         return i18n("expired");
     }
 
     return i18nc("As in not all user IDs are valid.", "not certified");
 }
 
 QString Formatting::prettyID(const char *id)
 {
     if (!id) {
         return QString();
     }
     return QString::fromLatin1(id).toUpper().replace(QRegularExpression(QStringLiteral("(....)")), QStringLiteral("\\1 ")).trimmed();
 }
 
 QString Formatting::origin(int o)
 {
     switch (o) {
         case Key::OriginKS:
             return i18n("Keyserver");
         case Key::OriginDane:
             return QStringLiteral("DANE");
         case Key::OriginWKD:
             return QStringLiteral("WKD");
         case Key::OriginURL:
             return QStringLiteral("URL");
         case Key::OriginFile:
             return i18n("File import");
         case Key::OriginSelf:
             return i18n("Generated");
         case Key::OriginOther:
         case Key::OriginUnknown:
         default:
           return i18n("Unknown");
     }
 }