diff --git a/src/ui/directoryserviceswidget.cpp b/src/ui/directoryserviceswidget.cpp
index 1ac645101..48212c115 100644
--- a/src/ui/directoryserviceswidget.cpp
+++ b/src/ui/directoryserviceswidget.cpp
@@ -1,756 +1,756 @@
 /*
     directoryserviceswidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2001,2002,2004 Klarävdalens Datakonsult AB
     Copyright (c) 2017 Bundesamnt für Sicherheit in der Informationstechnik
 
     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 "directoryserviceswidget.h"
 
 #include "ui_directoryserviceswidget.h"
 
 #include "kleo_ui_debug.h"
 
 #include <KLocalizedString>
 
 #include <QItemDelegate>
 #include <QAbstractTableModel>
 #include <QSpinBox>
 #include <QHeaderView>
 
 #include <vector>
 
 #include <climits>
 #include <algorithm>
 #include <functional>
 
 #include <gpgme++/engineinfo.h>
 
 using namespace Kleo;
 
 namespace
 {
 
 static QUrl defaultX509Service()
 {
     QUrl url;
     url.setScheme(QStringLiteral("ldap"));
     url.setHost(i18nc("default server name, keep it a valid domain name, ie. no spaces", "server"));
     return url;
 }
 static QUrl defaultOpenPGPService()
 {
     QUrl url;
     if (GpgME::engineInfo(GpgME::GpgEngine).engineVersion() < "2.1.16") {
         url.setScheme(QStringLiteral("hkp"));
         url.setHost(QStringLiteral("keys.gnupg.net"));
     } else {
         url.setScheme(QStringLiteral("hkps"));
         url.setHost(QStringLiteral("hkps.pool.sks-keyservers.net"));
     }
    return url;
 }
 
 static bool is_ldap_scheme(const QUrl &url)
 {
     const QString scheme = url.scheme();
     return QString::compare(scheme, QStringLiteral("ldap"),  Qt::CaseInsensitive) == 0
            || QString::compare(scheme, QStringLiteral("ldaps"), Qt::CaseInsensitive) == 0;
 }
 
 static const struct {
     const char label[6];
     unsigned short port;
     DirectoryServicesWidget::Scheme base;
 } protocols[] = {
     { I18N_NOOP("hkp"), 11371, DirectoryServicesWidget::HKP  },
     { I18N_NOOP("http"),   80, DirectoryServicesWidget::HTTP },
     { I18N_NOOP("https"), 443, DirectoryServicesWidget::HTTP },
     { I18N_NOOP("ftp"),    21, DirectoryServicesWidget::FTP  },
     { I18N_NOOP("ftps"),  990, DirectoryServicesWidget::FTP  },
     { I18N_NOOP("ldap"),  389, DirectoryServicesWidget::LDAP },
     { I18N_NOOP("ldaps"), 636, DirectoryServicesWidget::LDAP },
 };
 static const unsigned int numProtocols = sizeof protocols / sizeof * protocols;
 
 static unsigned short default_port(const QString &scheme)
 {
     for (unsigned int i = 0; i < numProtocols; ++i)
         if (QString::compare(scheme, QLatin1String(protocols[i].label), Qt::CaseInsensitive) == 0) {
             return protocols[i].port;
         }
     return 0;
 }
 
 static QString display_scheme(const QUrl &url)
 {
     if (url.scheme().isEmpty()) {
         return QStringLiteral("hkp");
     } else {
         return url.scheme();
     }
 }
 
 static QString display_host(const QUrl &url)
 {
     // work around "subkeys.pgp.net" being interpreted as a path, not host
     if (url.host().isEmpty()) {
         return url.path();
     } else {
         return url.host();
     }
 }
 
 static unsigned short display_port(const QUrl &url)
 {
     if (url.port() > 0) {
         return url.port();
     } else {
         return default_port(display_scheme(url));
     }
 }
 
 static QRect calculate_geometry(const QRect &cell, const QSize &sizeHint)
 {
     const int height = qMax(cell.height(), sizeHint.height());
     return QRect(cell.left(), cell.top() - (height - cell.height()) / 2,
                  cell.width(), height);
 }
 
 /* The Model contains a bit historic cruft because in the past it was
  * thought to be a good idea to combine openPGP and X509 in a single
  * table although while you can have multiple X509 Keyservers there can
  * only be one OpenPGP Keyserver. So the OpenPGP Keyserver is now a
  * single lineedit. */
 class Model : public QAbstractTableModel
 {
     Q_OBJECT
 public:
     explicit Model(QObject *parent = nullptr)
         : QAbstractTableModel(parent),
           m_items(),
           m_x509ReadOnly(false),
           m_schemes(DirectoryServicesWidget::LDAP)
     {
 
     }
 
     void setX509ReadOnly(bool ro)
     {
         if (ro == m_x509ReadOnly) {
             return;
         }
         m_x509ReadOnly = ro;
         for (int row = 0, end = rowCount(); row != end; ++row) {
             Q_EMIT dataChanged(index(row, 0), index(row, NumColumns));
         }
     }
 
     QModelIndex addX509Service(const QUrl &url, bool force = false)
     {
         const auto it = force ? m_items.end() : findExistingUrl(url);
         unsigned int row;
         if (it != m_items.end()) {
             // existing item:
             row = it - m_items.begin();
             Q_EMIT dataChanged(index(row, 0), index(row, NumColumns));
         } else {
             // append new item
             row = m_items.size();
             beginInsertRows(QModelIndex(), row, row);
             m_items.push_back(url);
             endInsertRows();
         }
         return index(row, firstEditableColumn(row));
     }
 
     unsigned int numServices() const
     {
         return m_items.size();
     }
     QUrl          service(unsigned int row) const
     {
         return row < m_items.size() ?  m_items[row] : QUrl();
     }
 
     enum Columns {
         Host,
         Port,
         BaseDN,
         UserName,
         Password,
 
         NumColumns
     };
 
     QModelIndex duplicateRow(unsigned int row)
     {
         if (row >= m_items.size()) {
             return QModelIndex();
         }
 
         beginInsertRows(QModelIndex(), row + 1, row + 1);
         m_items.insert(m_items.begin() + row + 1, m_items[row]);
         endInsertRows();
         return index(row + 1, 0);
     }
 
     void deleteRow(unsigned int row)
     {
         if (row >= m_items.size()) {
             return;
         }
 
         beginRemoveRows(QModelIndex(), row, row);
         m_items.erase(m_items.begin() + row);
         endInsertRows();
     }
 
     void clear()
     {
         if (m_items.empty()) {
             return;
         }
         beginRemoveRows(QModelIndex(), 0, m_items.size() - 1);
         m_items.clear();
         endRemoveRows();
     }
 
     int columnCount(const QModelIndex & = QModelIndex()) const override
     {
         return NumColumns;
     }
     int rowCount(const QModelIndex & = QModelIndex()) const override
     {
         return m_items.size();
     }
 
     QVariant data(const QModelIndex &idx, int role) const override;
     QVariant headerData(int section, Qt::Orientation o, int role) const override;
 
     Qt::ItemFlags flags(const QModelIndex &idx) const override;
     bool setData(const QModelIndex &idx, const QVariant &value, int role) override;
 
 private:
     bool doSetData(unsigned int row, unsigned int column, const QVariant &value, int role);
 
     static QString toolTipForColumn(int column);
     bool isLdapRow(unsigned int row) const;
     int firstEditableColumn(unsigned int) const
     {
         return Host;
     }
 
 private:
     std::vector<QUrl> m_items;
     bool m_x509ReadOnly    : 1;
     DirectoryServicesWidget::Schemes m_schemes;
 
 private:
     std::vector<QUrl>::iterator findExistingUrl(const QUrl &url)
     {
         return std::find_if(m_items.begin(), m_items.end(),
                             [&url](const QUrl &item) {
                                 const QUrl &lhs = url;
                                 const QUrl &rhs = item;
                                 return QString::compare(display_scheme(lhs), display_scheme(rhs), Qt::CaseInsensitive) == 0
                                     && QString::compare(display_host(lhs), display_host(rhs), Qt::CaseInsensitive) == 0
                                     && lhs.port() == rhs.port()
                                     && lhs.userName() == rhs.userName()
                                     // ... ignore password...
                                     && (!is_ldap_scheme(lhs)
                                         || lhs.query() == rhs.query());
                             });
     }
 };
 
 class Delegate : public QItemDelegate
 {
     Q_OBJECT
 public:
     explicit Delegate(QObject *parent = nullptr)
         : QItemDelegate(parent),
           m_schemes(DirectoryServicesWidget::LDAP)
     {
 
     }
 
     void setAllowedSchemes(const DirectoryServicesWidget::Schemes schemes)
     {
         m_schemes = schemes;
     }
     DirectoryServicesWidget::Schemes allowedSchemes() const
     {
         return m_schemes;
     }
 
     QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &idx) const override
     {
         switch (idx.column()) {
         case Model::Port:
             return createPortWidget(parent);
         }
         return QItemDelegate::createEditor(parent, option, idx);
     }
 
     void setEditorData(QWidget *editor, const QModelIndex &idx) const override
     {
         switch (idx.column()) {
         case Model::Port:
             setPortEditorData(qobject_cast<QSpinBox *>(editor), idx.data(Qt::EditRole).toInt());
             break;
         default:
             QItemDelegate::setEditorData(editor, idx);
             break;
         }
     }
 
     void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &idx) const override
     {
         switch (idx.column()) {
         case Model::Port:
             setPortModelData(qobject_cast<QSpinBox *>(editor), model, idx);
             break;
         default:
             QItemDelegate::setModelData(editor, model, idx);
             break;
         }
     }
 
     void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override
     {
         if (index.column() == Model::Port) {
             editor->setGeometry(calculate_geometry(option.rect, editor->sizeHint()));
         } else {
             QItemDelegate::updateEditorGeometry(editor, option, index);
         }
     }
 
 private:
     QWidget *createPortWidget(QWidget *parent) const
     {
         QSpinBox *sb = new QSpinBox(parent);
         sb->setRange(1, USHRT_MAX);   // valid port numbers
         return sb;
     }
     void setPortEditorData(QSpinBox *sb, unsigned short port) const
     {
         Q_ASSERT(sb);
         sb->setValue(port);
     }
     void setPortModelData(const QSpinBox *sb, QAbstractItemModel *model, const QModelIndex &idx) const
     {
         Q_ASSERT(sb);
         Q_ASSERT(model);
         model->setData(idx, sb->value());
     }
 
 private:
     DirectoryServicesWidget::Schemes m_schemes;
 };
 
 }
 
 class DirectoryServicesWidget::Private
 {
     friend class ::Kleo::DirectoryServicesWidget;
     DirectoryServicesWidget *const q;
 public:
     explicit Private(DirectoryServicesWidget *qq)
         : q(qq),
           protocols(AllProtocols),
           readOnlyProtocols(NoProtocol),
           model(),
           delegate(),
           ui(q)
     {
         ui.treeView->setModel(&model);
         ui.treeView->setItemDelegate(&delegate);
 
         ui.pgpKeyserver->setPlaceholderText(defaultOpenPGPService().toString());
 
         connect(&model, &QAbstractItemModel::dataChanged, q, &DirectoryServicesWidget::changed);
         connect(&model, &QAbstractItemModel::rowsInserted, q, &DirectoryServicesWidget::changed);
         connect(&model, &QAbstractItemModel::rowsRemoved, q, &DirectoryServicesWidget::changed);
         connect(ui.treeView->selectionModel(), &QItemSelectionModel::selectionChanged,
                 q, [this]() { slotSelectionChanged(); });
         connect(ui.pgpKeyserver, &QLineEdit::textChanged, q, &DirectoryServicesWidget::changed);
 
         slotShowUserAndPasswordToggled(false);
     }
 
 private:
     void edit(const QModelIndex &index)
     {
         if (index.isValid()) {
             ui.treeView->clearSelection();
             ui.treeView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::Select | QItemSelectionModel::Rows);
             ui.treeView->edit(index);
         }
     }
     void slotNewX509Clicked()
     {
         edit(model.addX509Service(defaultX509Service(), true));
     }
     void slotDeleteClicked()
     {
         model.deleteRow(selectedRow());
     }
     void slotSelectionChanged()
     {
         enableDisableActions();
     }
     void slotShowUserAndPasswordToggled(bool on)
     {
         QHeaderView *const hv = ui.treeView->header();
         Q_ASSERT(hv);
         hv->setSectionHidden(Model::UserName, !on);
         hv->setSectionHidden(Model::Password, !on);
     }
 
     int selectedRow() const
     {
         const QModelIndexList mil = ui.treeView->selectionModel()->selectedRows();
         return mil.empty() ? -1 : mil.front().row();
     }
     int currentRow() const
     {
         const QModelIndex idx = ui.treeView->selectionModel()->currentIndex();
         return idx.isValid() ? idx.row() : -1;
     }
 
     void enableDisableActions()
     {
         const bool x509 = (protocols & X509Protocol) && !(readOnlyProtocols & X509Protocol);
         const bool pgp  = (protocols & OpenPGPProtocol) && !(readOnlyProtocols & OpenPGPProtocol);
         ui.newTB->setEnabled(x509);
         ui.pgpKeyserver->setEnabled(pgp);
         const int row = selectedRow();
         ui.deleteTB->setEnabled(row >= 0 && !(readOnlyProtocols & X509Protocol));
     }
 
 private:
     Protocols protocols;
     Protocols readOnlyProtocols;
     Model model;
     Delegate delegate;
     struct UI : Ui_DirectoryServicesWidget {
 
         explicit UI(DirectoryServicesWidget *q)
             : Ui_DirectoryServicesWidget()
         {
             setupUi(q);
         }
 
     } ui;
 };
 
 DirectoryServicesWidget::DirectoryServicesWidget(QWidget *p, Qt::WindowFlags f)
     : QWidget(p, f), d(new Private(this))
 {
 
 }
 
 DirectoryServicesWidget::~DirectoryServicesWidget()
 {
     delete d;
 }
 
 void DirectoryServicesWidget::setAllowedSchemes(Schemes schemes)
 {
     d->delegate.setAllowedSchemes(schemes);
 }
 
 DirectoryServicesWidget::Schemes DirectoryServicesWidget::allowedSchemes() const
 {
     return d->delegate.allowedSchemes();
 }
 
 void DirectoryServicesWidget::setAllowedProtocols(Protocols protocols)
 {
     if (d->protocols == protocols) {
         return;
     }
     d->protocols = protocols;
     d->enableDisableActions();
 }
 
 DirectoryServicesWidget::Protocols DirectoryServicesWidget::allowedProtocols() const
 {
     return d->protocols;
 }
 
 void DirectoryServicesWidget::setReadOnlyProtocols(Protocols protocols)
 {
     if (d->readOnlyProtocols == protocols) {
         return;
     }
     d->readOnlyProtocols = protocols;
     d->model.setX509ReadOnly(protocols & X509Protocol);
     d->enableDisableActions();
 }
 
 DirectoryServicesWidget::Protocols DirectoryServicesWidget::readOnlyProtocols() const
 {
     return d->readOnlyProtocols;
 }
 
 void DirectoryServicesWidget::addOpenPGPServices(const QList<QUrl> &urls)
 {
     if (urls.size() > 1) {
         qCWarning(KLEO_UI_LOG) << "More then one PGP Server, Ignoring all others.";
     }
     if (urls.size()) {
         d->ui.pgpKeyserver->setText(urls[0].toString());
     }
 }
 
 QList<QUrl> DirectoryServicesWidget::openPGPServices() const
 {
     QList<QUrl> result;
     const QString pgpStr = d->ui.pgpKeyserver->text();
-    if (pgpStr.contains(QStringLiteral("://"))) {
+    if (pgpStr.contains(QLatin1String("://"))) {
         // Maybe validate here? Otoh maybe gnupg adds support for more schemes
         // then we know about in the future.
         result.push_back(QUrl::fromUserInput(pgpStr));
     } else if (!pgpStr.isEmpty()) {
         result.push_back(QUrl::fromUserInput(QStringLiteral("hkp://") + pgpStr));
     }
     return result;
 }
 
 void DirectoryServicesWidget::addX509Services(const QList<QUrl> &urls)
 {
     for (const QUrl &url : urls) {
         d->model.addX509Service(url);
     }
 }
 
 QList<QUrl> DirectoryServicesWidget::x509Services() const
 {
     QList<QUrl> result;
     for (unsigned int i = 0, end = d->model.numServices(); i != end; ++i) {
         result.push_back(d->model.service(i));
     }
     return result;
 }
 
 void DirectoryServicesWidget::clear()
 {
     if (!d->model.numServices()) {
         return;
     }
     d->model.clear();
     d->ui.pgpKeyserver->setText(QString());
     Q_EMIT changed();
 }
 
 //
 // Model
 //
 
 QVariant Model::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal)
         if (role == Qt::ToolTipRole) {
             return toolTipForColumn(section);
         } else if (role == Qt::DisplayRole)
             switch (section) {
             case Host:     return i18n("Server Name");
             case Port:     return i18n("Server Port");
             case BaseDN:   return i18n("Base DN");
             case UserName: return i18n("User Name");
             case Password: return i18n("Password");
             default:       return QVariant();
             }
         else {
             return QVariant();
         }
     else {
         return QAbstractTableModel::headerData(section, orientation, role);
     }
 }
 
 QVariant Model::data(const QModelIndex &index, int role) const
 {
     const unsigned int row = index.row();
     if (index.isValid() && row < m_items.size())
         switch (role) {
         case Qt::ToolTipRole: {
             const QString tt = toolTipForColumn(index.column());
             if (!m_x509ReadOnly) {
                 return tt;
             } else
                 return tt.isEmpty()
                        ? i18n("(read-only)")
                        : i18nc("amended tooltip; %1: original tooltip",
                                "%1 (read-only)", tt);
         }
         case Qt::DisplayRole:
         case Qt::EditRole:
             switch (index.column()) {
             case Host:
                 return display_host(m_items[row]);
             case Port:
                 return display_port(m_items[row]);
             case BaseDN:
                 if (isLdapRow(row)) {
                     return m_items[row].query();
                 } else {
                     return QVariant();
                 }
             case UserName:
                 return m_items[row].userName();
             case Password:
                 return m_items[row].password();
             default:
                 return QVariant();
             }
         }
     return QVariant();
 }
 
 bool Model::isLdapRow(unsigned int row) const
 {
     if (row >= m_items.size()) {
         return false;
     }
     return is_ldap_scheme(m_items[row]);
 }
 
 Qt::ItemFlags Model::flags(const QModelIndex &index) const
 {
     const unsigned int row = index.row();
     Qt::ItemFlags flags = QAbstractTableModel::flags(index);
     if (m_x509ReadOnly) {
         flags &= ~Qt::ItemIsSelectable;
     }
     if (index.isValid() && row < m_items.size())
         switch (index.column()) {
         case Host:
         case Port:
             if (m_x509ReadOnly) {
                 return flags & ~(Qt::ItemIsEditable | Qt::ItemIsEnabled);
             } else {
                 return flags | Qt::ItemIsEditable;
             }
         case BaseDN:
             if (isLdapRow(row) && !m_x509ReadOnly) {
                 return flags | Qt::ItemIsEditable;
             } else {
                 return flags & ~(Qt::ItemIsEditable | Qt::ItemIsEnabled);
             }
         case UserName:
         case Password:
             if (m_x509ReadOnly) {
                 return flags & ~(Qt::ItemIsEditable | Qt::ItemIsEnabled);
             } else {
                 return flags | Qt::ItemIsEditable;
             }
         }
     return flags;
 }
 
 bool Model::setData(const QModelIndex &idx, const QVariant &value, int role)
 {
     const unsigned int row = idx.row();
     if (!idx.isValid() || row >= m_items.size()) {
         return false;
     }
     if (m_x509ReadOnly) {
         return false;
     }
     if (!doSetData(row, idx.column(), value, role)) {
         return false;
     }
     Q_EMIT dataChanged(idx, idx);
     return true;
 }
 
 bool Model::doSetData(unsigned int row, unsigned int column, const QVariant &value, int role)
 {
     if (role == Qt::EditRole)
         switch (column) {
         case Host:
             if (display_host(m_items[row]) != m_items[row].host()) {
                 m_items[row].setScheme(display_scheme(m_items[row]));
             }
             m_items[row].setHost(value.toString());
             return true;
         case Port:
             if (value.toUInt() == default_port(display_scheme(m_items[row]))) {
                 m_items[row].setPort(-1);
             } else {
                 m_items[row].setPort(value.toUInt());
             }
             return true;
         case BaseDN:
             if (value.toString().isEmpty()) {
                 m_items[row].setPath(QString());
                 m_items[row].setQuery(QString());
             } else {
                 m_items[row].setQuery(value.toString());
             }
             return true;
         case UserName:
             m_items[row].setUserName(value.toString());
             return true;
         case Password:
             m_items[row].setPassword(value.toString());
             return true;
         }
     return false;
 }
 
 
 // static
 QString Model::toolTipForColumn(int column)
 {
     switch (column) {
     case Host:     return i18n("Enter the name or IP address of the server "
                                    "hosting the directory service.");
     case Port:     return i18n("<b>(Optional, the default is fine in most cases)</b> "
                                    "Pick the port number the directory service is "
                                    "listening on.");
     case BaseDN:   return i18n("<b>(Only for LDAP)</b> "
                                    "Enter the base DN for this LDAP server to "
                                    "limit searches to only that subtree of the directory.");
     case UserName: return i18n("<b>(Optional)</b> "
                                    "Enter your user name here, if needed.");
     case Password: return i18n("<b>(Optional, not recommended)</b> "
                                    "Enter your password here, if needed. "
                                    "Note that the password will be saved in the clear "
                                    "in a config file in your home directory.");
     default:
         return QString();
     }
 }
 
 #include "directoryserviceswidget.moc"
 #include "moc_directoryserviceswidget.cpp"
diff --git a/src/ui/keyrequester.cpp b/src/ui/keyrequester.cpp
index 0da6aa61b..2f595d02f 100644
--- a/src/ui/keyrequester.cpp
+++ b/src/ui/keyrequester.cpp
@@ -1,524 +1,524 @@
 /*  -*- c++ -*-
     keyrequester.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klar�vdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 
     Based on kpgpui.cpp
     Copyright (C) 2001,2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     This file is part of KPGP, the KDE PGP/GnuPG support library.
 
     KPGP is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software Foundation,
     Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
 #include "keyrequester.h"
 
 #include "keyselectiondialog.h"
 
 #include "libkleo/dn.h"
 
 // gpgme++
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <qgpgme/protocol.h>
 #include <qgpgme/keylistjob.h>
 
 // KDE
 #include <KLocalizedString>
 #include <QDialog>
 #include <kmessagebox.h>
 #include <QPushButton>
 
 // Qt
 #include <QApplication>
 
 #include <QString>
 #include <QStringList>
 #include <QLabel>
 
 #include <QHBoxLayout>
 
 
 using namespace QGpgME;
 
 Kleo::KeyRequester::KeyRequester(unsigned int allowedKeys, bool multipleKeys,
                                  QWidget *parent)
     : QWidget(parent),
       mOpenPGPBackend(nullptr),
       mSMIMEBackend(nullptr),
       mMulti(multipleKeys),
       mKeyUsage(allowedKeys),
       mJobs(0),
       d(nullptr)
 {
     init();
 }
 
 Kleo::KeyRequester::KeyRequester(QWidget *parent)
     : QWidget(parent),
       mOpenPGPBackend(nullptr),
       mSMIMEBackend(nullptr),
       mMulti(false),
       mKeyUsage(0),
       mJobs(0),
       d(nullptr)
 {
     init();
 }
 
 void Kleo::KeyRequester::init()
 {
     QHBoxLayout *hlay = new QHBoxLayout(this);
     hlay->setContentsMargins(0, 0, 0, 0);
 
     // the label where the key id is to be displayed:
     mLabel = new QLabel(this);
     mLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
 
     // the button to unset any key:
     mEraseButton = new QPushButton(this);
     mEraseButton->setAutoDefault(false);
     mEraseButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum,
                                             QSizePolicy::Minimum));
     mEraseButton->setIcon(QIcon::fromTheme(QApplication::isRightToLeft() ? QStringLiteral("edit-clear-locationbar-ltr") : QStringLiteral("edit-clear-locationbar-rtl")));
     mEraseButton->setToolTip(i18n("Clear"));
 
     // the button to call the KeySelectionDialog:
     mDialogButton = new QPushButton(i18n("Change..."), this);
     mDialogButton->setAutoDefault(false);
 
     hlay->addWidget(mLabel, 1);
     hlay->addWidget(mEraseButton);
     hlay->addWidget(mDialogButton);
 
     connect(mEraseButton, &QPushButton::clicked, this, &SigningKeyRequester::slotEraseButtonClicked);
     connect(mDialogButton, &QPushButton::clicked, this, &SigningKeyRequester::slotDialogButtonClicked);
 
     setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,
                               QSizePolicy::Fixed));
 
     setAllowedKeys(mKeyUsage);
 }
 
 Kleo::KeyRequester::~KeyRequester()
 {
 
 }
 
 const std::vector<GpgME::Key> &Kleo::KeyRequester::keys() const
 {
     return mKeys;
 }
 
 const GpgME::Key &Kleo::KeyRequester::key() const
 {
     static const GpgME::Key null = GpgME::Key::null;
     if (mKeys.empty()) {
         return null;
     } else {
         return mKeys.front();
     }
 }
 
 void Kleo::KeyRequester::setKeys(const std::vector<GpgME::Key> &keys)
 {
     mKeys.clear();
     for (std::vector<GpgME::Key>::const_iterator it = keys.begin(); it != keys.end(); ++it)
         if (!it->isNull()) {
             mKeys.push_back(*it);
         }
     updateKeys();
 }
 
 void Kleo::KeyRequester::setKey(const GpgME::Key &key)
 {
     mKeys.clear();
     if (!key.isNull()) {
         mKeys.push_back(key);
     }
     updateKeys();
 }
 
 QString Kleo::KeyRequester::fingerprint() const
 {
     if (mKeys.empty()) {
         return QString();
     } else {
         return QLatin1String(mKeys.front().primaryFingerprint());
     }
 }
 
 QStringList Kleo::KeyRequester::fingerprints() const
 {
     QStringList result;
     for (std::vector<GpgME::Key>::const_iterator it = mKeys.begin(); it != mKeys.end(); ++it)
         if (!it->isNull())
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
     return result;
 }
 
 void Kleo::KeyRequester::setFingerprint(const QString &fingerprint)
 {
     startKeyListJob(QStringList(fingerprint));
 }
 
 void Kleo::KeyRequester::setFingerprints(const QStringList &fingerprints)
 {
     startKeyListJob(fingerprints);
 }
 
 void Kleo::KeyRequester::updateKeys()
 {
     if (mKeys.empty()) {
         mLabel->clear();
         return;
     }
     if (mKeys.size() > 1) {
         setMultipleKeysEnabled(true);
     }
 
     QStringList labelTexts;
     QString toolTipText;
     for (std::vector<GpgME::Key>::const_iterator it = mKeys.begin(); it != mKeys.end(); ++it) {
         if (it->isNull()) {
             continue;
         }
         const QString fpr = QLatin1String(it->primaryFingerprint());
         labelTexts.push_back(fpr.right(8));
         toolTipText += fpr.right(8) + QLatin1String(": ");
         if (const char *uid = it->userID(0).id())
             if (it->protocol() == GpgME::OpenPGP) {
                 toolTipText += QString::fromUtf8(uid);
             } else {
                 toolTipText += Kleo::DN(uid).prettyDN();
             }
         else {
             toolTipText += xi18n("<placeholder>unknown</placeholder>");
         }
         toolTipText += QLatin1Char('\n');
     }
 
-    mLabel->setText(labelTexts.join(QStringLiteral(", ")));
+    mLabel->setText(labelTexts.join(QLatin1String(", ")));
     mLabel->setToolTip(toolTipText);
 }
 
 #ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 #define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 static void showKeyListError(QWidget *parent, const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n("<qt><p>An error occurred while fetching "
                              "the keys from the backend:</p>"
                              "<p><b>%1</b></p></qt>",
                              QString::fromLocal8Bit(err.asString()));
 
     KMessageBox::error(parent, msg, i18n("Key Listing Failed"));
 }
 #endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 
 void Kleo::KeyRequester::startKeyListJob(const QStringList &fingerprints)
 {
     if (!mSMIMEBackend && !mOpenPGPBackend) {
         return;
     }
 
     mTmpKeys.clear();
     mJobs = 0;
 
     unsigned int count = 0;
     for (QStringList::const_iterator it = fingerprints.begin(); it != fingerprints.end(); ++it)
         if (!(*it).trimmed().isEmpty()) {
             ++count;
         }
 
     if (!count) {
         // don't fall into the trap that an empty pattern means
         // "return all keys" :)
         setKey(GpgME::Key::null);
         return;
     }
 
     if (mOpenPGPBackend) {
         KeyListJob *job = mOpenPGPBackend->keyListJob(false);    // local, no sigs
         if (!job) {
             KMessageBox::error(this,
                                i18n("The OpenPGP backend does not support listing keys. "
                                     "Check your installation."),
                                i18n("Key Listing Failed"));
         } else {
             connect(job, &KeyListJob::result, this, &SigningKeyRequester::slotKeyListResult);
             connect(job, &KeyListJob::nextKey, this, &SigningKeyRequester::slotNextKey);
 
             const GpgME::Error err = job->start(fingerprints,
                                                 mKeyUsage & Kleo::KeySelectionDialog::SecretKeys &&
                                                 !(mKeyUsage & Kleo::KeySelectionDialog::PublicKeys));
 
             if (err) {
                 showKeyListError(this, err);
             } else {
                 ++mJobs;
             }
         }
     }
 
     if (mSMIMEBackend) {
         KeyListJob *job = mSMIMEBackend->keyListJob(false);    // local, no sigs
         if (!job) {
             KMessageBox::error(this,
                                i18n("The S/MIME backend does not support listing keys. "
                                     "Check your installation."),
                                i18n("Key Listing Failed"));
         } else {
             connect(job, &KeyListJob::result, this, &SigningKeyRequester::slotKeyListResult);
             connect(job, &KeyListJob::nextKey, this, &SigningKeyRequester::slotNextKey);
 
             const GpgME::Error err = job->start(fingerprints,
                                                 mKeyUsage & Kleo::KeySelectionDialog::SecretKeys &&
                                                 !(mKeyUsage & Kleo::KeySelectionDialog::PublicKeys));
 
             if (err) {
                 showKeyListError(this, err);
             } else {
                 ++mJobs;
             }
         }
     }
 
     if (mJobs > 0) {
         mEraseButton->setEnabled(false);
         mDialogButton->setEnabled(false);
     }
 }
 
 void Kleo::KeyRequester::slotNextKey(const GpgME::Key &key)
 {
     if (!key.isNull()) {
         mTmpKeys.push_back(key);
     }
 }
 
 void Kleo::KeyRequester::slotKeyListResult(const GpgME::KeyListResult &res)
 {
     if (res.error()) {
         showKeyListError(this, res.error());
     }
 
     if (--mJobs <= 0) {
         mEraseButton->setEnabled(true);
         mDialogButton->setEnabled(true);
 
         setKeys(mTmpKeys);
         mTmpKeys.clear();
     }
 }
 
 void Kleo::KeyRequester::slotDialogButtonClicked()
 {
     KeySelectionDialog *dlg = mKeys.empty()
                               ? new KeySelectionDialog(mDialogCaption, mDialogMessage, mInitialQuery, mKeyUsage, mMulti, false, this)
                               : new KeySelectionDialog(mDialogCaption, mDialogCaption, mKeys, mKeyUsage, mMulti, false, this);
 
     if (dlg->exec() == QDialog::Accepted) {
         if (mMulti) {
             setKeys(dlg->selectedKeys());
         } else {
             setKey(dlg->selectedKey());
         }
         Q_EMIT changed();
     }
 
     delete dlg;
 }
 
 void Kleo::KeyRequester::slotEraseButtonClicked()
 {
     if (!mKeys.empty()) {
         Q_EMIT changed();
     }
     mKeys.clear();
     updateKeys();
 }
 
 void Kleo::KeyRequester::setDialogCaption(const QString &caption)
 {
     mDialogCaption = caption;
 }
 
 void Kleo::KeyRequester::setDialogMessage(const QString &msg)
 {
     mDialogMessage = msg;
 }
 
 bool Kleo::KeyRequester::isMultipleKeysEnabled() const
 {
     return mMulti;
 }
 
 void Kleo::KeyRequester::setMultipleKeysEnabled(bool multi)
 {
     if (multi == mMulti) {
         return;
     }
 
     if (!multi && !mKeys.empty()) {
         mKeys.erase(mKeys.begin() + 1, mKeys.end());
     }
 
     mMulti = multi;
     updateKeys();
 }
 
 unsigned int Kleo::KeyRequester::allowedKeys() const
 {
     return mKeyUsage;
 }
 
 void Kleo::KeyRequester::setAllowedKeys(unsigned int keyUsage)
 {
     mKeyUsage = keyUsage;
     mOpenPGPBackend = nullptr;
     mSMIMEBackend = nullptr;
 
     if (mKeyUsage & KeySelectionDialog::OpenPGPKeys) {
         mOpenPGPBackend = openpgp();
     }
     if (mKeyUsage & KeySelectionDialog::SMIMEKeys) {
         mSMIMEBackend = smime();
     }
 
     if (mOpenPGPBackend && !mSMIMEBackend) {
         mDialogCaption = i18n("OpenPGP Key Selection");
         mDialogMessage = i18n("Please select an OpenPGP key to use.");
     } else if (!mOpenPGPBackend && mSMIMEBackend) {
         mDialogCaption = i18n("S/MIME Key Selection");
         mDialogMessage = i18n("Please select an S/MIME key to use.");
     } else {
         mDialogCaption = i18n("Key Selection");
         mDialogMessage = i18n("Please select an (OpenPGP or S/MIME) key to use.");
     }
 }
 
 QPushButton *Kleo::KeyRequester::dialogButton()
 {
     return mDialogButton;
 }
 
 QPushButton *Kleo::KeyRequester::eraseButton()
 {
     return mEraseButton;
 }
 
 static inline unsigned int foo(bool openpgp, bool smime, bool trusted, bool valid)
 {
     unsigned int result = 0;
     if (openpgp) {
         result |= Kleo::KeySelectionDialog::OpenPGPKeys;
     }
     if (smime) {
         result |= Kleo::KeySelectionDialog::SMIMEKeys;
     }
     if (trusted) {
         result |= Kleo::KeySelectionDialog::TrustedKeys;
     }
     if (valid) {
         result |= Kleo::KeySelectionDialog::ValidKeys;
     }
     return result;
 }
 
 static inline unsigned int encryptionKeyUsage(bool openpgp, bool smime, bool trusted, bool valid)
 {
     return foo(openpgp, smime, trusted, valid) | Kleo::KeySelectionDialog::EncryptionKeys | Kleo::KeySelectionDialog::PublicKeys;
 }
 
 static inline unsigned int signingKeyUsage(bool openpgp, bool smime, bool trusted, bool valid)
 {
     return foo(openpgp, smime, trusted, valid) | Kleo::KeySelectionDialog::SigningKeys | Kleo::KeySelectionDialog::SecretKeys;
 }
 
 Kleo::EncryptionKeyRequester::EncryptionKeyRequester(bool multi, unsigned int proto,
         QWidget *parent,
         bool onlyTrusted, bool onlyValid)
     : KeyRequester(encryptionKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid), multi,
                    parent), d(nullptr)
 {
 }
 
 Kleo::EncryptionKeyRequester::EncryptionKeyRequester(QWidget *parent)
     : KeyRequester(0, false, parent), d(nullptr)
 {
 }
 
 Kleo::EncryptionKeyRequester::~EncryptionKeyRequester() {}
 
 void Kleo::EncryptionKeyRequester::setAllowedKeys(unsigned int proto, bool onlyTrusted, bool onlyValid)
 {
     KeyRequester::setAllowedKeys(encryptionKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid));
 }
 
 Kleo::SigningKeyRequester::SigningKeyRequester(bool multi, unsigned int proto,
         QWidget *parent,
         bool onlyTrusted, bool onlyValid)
     : KeyRequester(signingKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid), multi,
                    parent), d(nullptr)
 {
 }
 
 Kleo::SigningKeyRequester::SigningKeyRequester(QWidget *parent)
     : KeyRequester(0, false, parent), d(nullptr)
 {
 }
 
 Kleo::SigningKeyRequester::~SigningKeyRequester() {}
 
 void Kleo::SigningKeyRequester::setAllowedKeys(unsigned int proto, bool onlyTrusted, bool onlyValid)
 {
     KeyRequester::setAllowedKeys(signingKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid));
 }
 
 void Kleo::KeyRequester::virtual_hook(int, void *) {}
 void Kleo::EncryptionKeyRequester::virtual_hook(int id, void *data)
 {
     KeyRequester::virtual_hook(id, data);
 }
 void Kleo::SigningKeyRequester::virtual_hook(int id, void *data)
 {
     KeyRequester::virtual_hook(id, data);
 }
 
diff --git a/src/ui/keyselectiondialog.cpp b/src/ui/keyselectiondialog.cpp
index 73ee6feee..d9d740881 100644
--- a/src/ui/keyselectiondialog.cpp
+++ b/src/ui/keyselectiondialog.cpp
@@ -1,989 +1,989 @@
 /*  -*- c++ -*-
     keyselectiondialog.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klar�vdalens 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 <KLocalizedString>
 #include <kwindowsystem.h>
 #include <kconfig.h>
 #include <kmessagebox.h>
 #include <QPushButton>
 #include <kconfiggroup.h>
 #include <QMenu>
 #include <QLineEdit>
 
 // Qt
 #include <QCheckBox>
 #include <QLabel>
 #include <QTimer>
 #include <QDateTime>
 #include <QProcess>
 
 #include <QRegExp>
 #include <QPushButton>
 #include <QFrame>
 #include <QApplication>
 #include <QHBoxLayout>
 #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());
         KWindowSystem::setIcons(winId(), qApp->windowIcon().pixmap(32, 32),
                                 qApp->windowIcon().pixmap(16, 16));
 
         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(QStringLiteral("0X")))
+        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 b7638fae5..2634fad93 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(QStringLiteral(", "));
+    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
 
   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);
             }
         }
     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/filesystemwatcher.cpp b/src/utils/filesystemwatcher.cpp
index 628d5625c..22b80b85a 100644
--- a/src/utils/filesystemwatcher.cpp
+++ b/src/utils/filesystemwatcher.cpp
@@ -1,334 +1,334 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     filesystemwatcher.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2008 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 "filesystemwatcher.h"
 #include "kleo/stl_util.h"
 
 #include <libkleo_debug.h>
 
 #include <QFileSystemWatcher>
 #include <QString>
 #include <QStringList>
 #include <QTimer>
 #include <QDir>
 
 #include <set>
 
 using namespace Kleo;
 
 class FileSystemWatcher::Private
 {
     FileSystemWatcher *const q;
 public:
     explicit Private(FileSystemWatcher *qq, const QStringList &paths = QStringList());
     ~Private()
     {
         delete m_watcher;
     }
 
     void onFileChanged(const QString &path);
     void onDirectoryChanged(const QString &path);
     void handleTimer();
     void onTimeout();
 
     void connectWatcher();
 
     QFileSystemWatcher *m_watcher = nullptr;
     QTimer m_timer;
     std::set<QString> m_seenPaths;
     std::set<QString> m_cachedDirectories;
     std::set<QString> m_cachedFiles;
     QStringList m_paths, m_blacklist, m_whitelist;
 };
 
 FileSystemWatcher::Private::Private(FileSystemWatcher *qq, const QStringList &paths)
     : q(qq),
       m_watcher(nullptr),
       m_paths(paths)
 {
     m_timer.setSingleShot(true);
     connect(&m_timer, &QTimer::timeout, q, [this]() { onTimeout(); });
 }
 
 static bool is_matching(const QString &file, const QStringList &list)
 {
     for (const QString &entry : list)
         if (QRegExp(entry, Qt::CaseInsensitive, QRegExp::Wildcard).exactMatch(file)) {
             return true;
         }
     return false;
 }
 
 static bool is_blacklisted(const QString &file, const QStringList &blacklist)
 {
     return is_matching(file, blacklist);
 }
 
 static bool is_whitelisted(const QString &file, const QStringList &whitelist)
 {
     if (whitelist.empty()) {
         return true;    // special case
     }
     return is_matching(file, whitelist);
 }
 
 void FileSystemWatcher::Private::onFileChanged(const QString &path)
 {
     const QFileInfo fi(path);
     if (is_blacklisted(fi.fileName(), m_blacklist)) {
         return;
     }
     if (!is_whitelisted(fi.fileName(), m_whitelist)) {
         return;
     }
     qCDebug(LIBKLEO_LOG) << path;
     m_seenPaths.insert(path);
     m_cachedFiles.insert(path);
     handleTimer();
 }
 
 static QStringList list_dir_absolute(const QString &path, const QStringList &blacklist, const QStringList &whitelist)
 {
     QDir dir(path);
     QStringList entries = dir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot);
     QStringList::iterator end =
         std::remove_if(entries.begin(), entries.end(),
                        [&blacklist](const QString &entry) {
                            return is_blacklisted(entry, blacklist);
                        });
     if (!whitelist.empty())
         end = std::remove_if(entries.begin(), end,
                              [&whitelist](const QString &entry) {
                                  return !is_whitelisted(entry, whitelist);
                              });
     entries.erase(end, entries.end());
     std::sort(entries.begin(), entries.end());
 
     std::transform(entries.begin(), entries.end(), entries.begin(),
                    [&dir](const QString &entry) {
                        return dir.absoluteFilePath(entry);
                    });
 
     return entries;
 }
 
 static QStringList find_new_files(const QStringList &current, const std::set<QString> &seen)
 {
     QStringList result;
     std::set_difference(current.begin(), current.end(),
                         seen.begin(), seen.end(),
                         std::back_inserter(result));
     return result;
 }
 
 void FileSystemWatcher::Private::onDirectoryChanged(const QString &path)
 {
     const QStringList newFiles = find_new_files(list_dir_absolute(path, m_blacklist, m_whitelist), m_seenPaths);
 
     if (newFiles.empty()) {
         return;
     }
 
     qCDebug(LIBKLEO_LOG) << "newFiles" << newFiles;
 
     m_cachedFiles.insert(newFiles.begin(), newFiles.end());
     q->addPaths(newFiles);
 
     m_cachedDirectories.insert(path);
     handleTimer();
 }
 
 void FileSystemWatcher::Private::onTimeout()
 {
     std::set<QString> dirs, files;
 
     dirs.swap(m_cachedDirectories);
     files.swap(m_cachedFiles);
 
     if (dirs.empty() && files.empty()) {
         return;
     }
 
     Q_EMIT q->triggered();
 
     for (const QString &i : qAsConst(dirs)) {
         Q_EMIT q->directoryChanged(i);
     }
     for (const QString &i : qAsConst(files)) {
         Q_EMIT q->fileChanged(i);
     }
 }
 
 void FileSystemWatcher::Private::handleTimer()
 {
     if (m_timer.interval() == 0) {
         onTimeout();
         return;
     }
     m_timer.start();
 }
 
 void FileSystemWatcher::Private::connectWatcher()
 {
     if (!m_watcher) {
         return;
     }
     connect(m_watcher, &QFileSystemWatcher::directoryChanged, q, [this](const QString &str) { onDirectoryChanged(str); });
     connect(m_watcher, &QFileSystemWatcher::fileChanged, q, [this](const QString &str) { onFileChanged(str); });
 }
 
 FileSystemWatcher::FileSystemWatcher(QObject *p)
     : QObject(p), d(new Private(this))
 {
     setEnabled(true);
 }
 
 FileSystemWatcher::FileSystemWatcher(const QStringList &paths, QObject *p)
     : QObject(p), d(new Private(this, paths))
 {
     setEnabled(true);
 }
 
 void FileSystemWatcher::setEnabled(bool enable)
 {
     if (isEnabled() == enable) {
         return;
     }
     if (enable) {
         Q_ASSERT(!d->m_watcher);
         d->m_watcher = new QFileSystemWatcher;
         if (!d->m_paths.empty()) {
             d->m_watcher->addPaths(d->m_paths);
         }
         d->connectWatcher();
     } else {
         Q_ASSERT(d->m_watcher);
         delete d->m_watcher;
         d->m_watcher = nullptr;
     }
 }
 
 bool FileSystemWatcher::isEnabled() const
 {
     return d->m_watcher != nullptr;
 }
 
 FileSystemWatcher::~FileSystemWatcher()
 {
 }
 
 void FileSystemWatcher::setDelay(int ms)
 {
     Q_ASSERT(ms >= 0);
     d->m_timer.setInterval(ms);
 }
 
 int FileSystemWatcher::delay() const
 {
     return d->m_timer.interval();
 }
 
 void FileSystemWatcher::blacklistFiles(const QStringList &paths)
 {
     d->m_blacklist += paths;
     QStringList blacklisted;
     d->m_paths.erase(kdtools::separate_if(d->m_paths.begin(), d->m_paths.end(),
                                           std::back_inserter(blacklisted), d->m_paths.begin(),
                                           [this](const QString &path) {
                                               return is_blacklisted(path, d->m_blacklist);
                                           }).second, d->m_paths.end());
     if (d->m_watcher && !blacklisted.empty()) {
         d->m_watcher->removePaths(blacklisted);
     }
 }
 
 void FileSystemWatcher::whitelistFiles(const QStringList &patterns)
 {
     d->m_whitelist += patterns;
     // ### would be nice to add newly-matching paths here right away,
     // ### but it's not as simple as blacklisting above, esp. since we
     // ### don't want to subject addPath()'ed paths to whitelisting.
 }
 
 static QStringList resolve(const QStringList &paths, const QStringList &blacklist, const QStringList &whitelist)
 {
     if (paths.empty()) {
         return QStringList();
     }
     QStringList result;
     for (const QString &path : paths)
         if (QDir(path).exists()) {
             result += list_dir_absolute(path, blacklist, whitelist);
         }
     return result + resolve(result, blacklist, whitelist);
 }
 
 void FileSystemWatcher::addPaths(const QStringList &paths)
 {
     if (paths.empty()) {
         return;
     }
     const QStringList newPaths = paths + resolve(paths, d->m_blacklist, d->m_whitelist);
     if (!newPaths.empty()) {
-        qCDebug(LIBKLEO_LOG) << "adding\n " << newPaths.join(QStringLiteral("\n ")) << "\n/end";
+        qCDebug(LIBKLEO_LOG) << "adding\n " << newPaths.join(QLatin1String("\n ")) << "\n/end";
     }
     d->m_paths += newPaths;
     d->m_seenPaths.insert(newPaths.begin(), newPaths.end());
     if (d->m_watcher && !newPaths.empty()) {
         d->m_watcher->addPaths(newPaths);
     }
 }
 
 void FileSystemWatcher::addPath(const QString &path)
 {
     addPaths(QStringList(path));
 }
 
 void FileSystemWatcher::removePaths(const QStringList &paths)
 {
     if (paths.empty()) {
         return;
     }
     for (const QString &i : paths) {
         d->m_paths.removeAll(i);
     }
     if (d->m_watcher) {
         d->m_watcher->removePaths(paths);
     }
 }
 
 void FileSystemWatcher::removePath(const QString &path)
 {
     removePaths(QStringList(path));
 }
 
 #include "moc_filesystemwatcher.cpp"
diff --git a/src/utils/formatting.cpp b/src/utils/formatting.cpp
index 265980e1a..32d419f36 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(QStringLiteral(", "));
+    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(QStringLiteral(", "));
+    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 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(QStringLiteral(", "));
+    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() == QStringLiteral("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() == QStringLiteral("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() == QStringLiteral("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");
     }
 }