diff --git a/src/kleo/kconfigbasedkeyfilter.cpp b/src/kleo/kconfigbasedkeyfilter.cpp
index b5e110a..90deaf7 100644
--- a/src/kleo/kconfigbasedkeyfilter.cpp
+++ b/src/kleo/kconfigbasedkeyfilter.cpp
@@ -1,254 +1,254 @@
 /*
     kconfigbasedkeyfilter.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     Copyright (c) 2004 Klarälvdalens Datakonsult AB
 
     Libkleopatra is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License as
     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.
 
     Libkleopatra is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
     In addition, as a special exception, the copyright holders give
     permission to link the code of this program with any edition of
     the Qt library by Trolltech AS, Norway (or with modified versions
     of Qt that use the same license as Qt), and distribute linked
     combinations including the two.  You must obey the GNU General
     Public License in all respects for all of the code used other than
     Qt.  If you modify this file, you may extend this exception to
     your version of the file, but you are not obligated to do so.  If
     you do not wish to do so, delete this exception statement from
     your version.
 */
 
 #include "kconfigbasedkeyfilter.h"
 
 #include <kconfigbase.h>
 #include <kconfiggroup.h>
 
 #include <algorithm>
 #include <QDebug>
 
 using namespace Kleo;
 using namespace GpgME;
 
 //
 //
 // FontDescription - intuitive font property resolving
 //                   (QFont::resolve doesn't work for us)
 //
 //
 struct KeyFilter::FontDescription::Private {
     bool bold, italic, strikeOut, fullFont;
     QFont font;
 };
 
 KeyFilter::FontDescription::FontDescription()
     : d(new Private)
 {
     d->bold = d->italic = d->strikeOut = d->fullFont = false;
 }
 
 KeyFilter::FontDescription::FontDescription(const FontDescription &other)
     : d(new Private(*other.d))
 {
 
 }
 
 KeyFilter::FontDescription::~FontDescription()
 {
     delete d;
 }
 
 KeyFilter::FontDescription KeyFilter::FontDescription::create(bool b, bool i, bool s)
 {
     FontDescription fd;
     fd.d->bold = b;
     fd.d->italic = i;
     fd.d->strikeOut = s;
     return fd;
 }
 
 KeyFilter::FontDescription KeyFilter::FontDescription::create(const QFont &f, bool b, bool i, bool s)
 {
     FontDescription fd;
     fd.d->fullFont = true;
     fd.d->font = f;
     fd.d->bold = b;
     fd.d->italic = i;
     fd.d->strikeOut = s;
     return fd;
 }
 
 QFont KeyFilter::FontDescription::font(const QFont &base) const
 {
     QFont font;
     if (d->fullFont) {
         font = d->font;
         font.setPointSize(base.pointSize());
     } else {
         font = base;
     }
     if (d->bold) {
         font.setBold(true);
     }
     if (d->italic) {
         font.setItalic(true);
     }
     if (d->strikeOut) {
         font.setStrikeOut(true);
     }
     return font;
 }
 
 KeyFilter::FontDescription KeyFilter::FontDescription::resolve(const FontDescription &other) const
 {
     FontDescription fd;
     fd.d->fullFont = this->d->fullFont || other.d->fullFont;
     if (fd.d->fullFont) {
         fd.d->font = this->d->fullFont ? this->d->font : other.d->font;
     }
     fd.d->bold = this->d->bold || other.d->bold;
     fd.d->italic = this->d->italic || other.d->italic;
     fd.d->strikeOut = this->d->strikeOut || other.d->strikeOut;
     return fd;
 }
 
 static const struct {
     const char *name;
     Key::OwnerTrust trust;
     UserID::Validity validity;
 } ownerTrustAndValidityMap[] = {
     { "unknown",   Key::Unknown,   UserID::Unknown   },
     { "undefined", Key::Undefined, UserID::Undefined },
     { "never",     Key::Never,     UserID::Never     },
     { "marginal",  Key::Marginal,  UserID::Marginal  },
     { "full",      Key::Full,      UserID::Full      },
     { "ultimate",  Key::Ultimate,  UserID::Ultimate  },
 };
 
 static Key::OwnerTrust map2OwnerTrust(const QString &s)
 {
     for (unsigned int i = 0; i < sizeof ownerTrustAndValidityMap / sizeof * ownerTrustAndValidityMap; ++i)
         if (s.toLower() == QLatin1String(ownerTrustAndValidityMap[i].name)) {
             return ownerTrustAndValidityMap[i].trust;
         }
     return ownerTrustAndValidityMap[0].trust;
 }
 
 static UserID::Validity map2Validity(const QString &s)
 {
     for (unsigned int i = 0; i < sizeof ownerTrustAndValidityMap / sizeof * ownerTrustAndValidityMap; ++i)
         if (s.toLower() == QLatin1String(ownerTrustAndValidityMap[i].name)) {
             return ownerTrustAndValidityMap[i].validity;
         }
     return ownerTrustAndValidityMap[0].validity;
 }
 
 KConfigBasedKeyFilter::KConfigBasedKeyFilter(const KConfigGroup &config)
     : DefaultKeyFilter()
 {
     setFgColor(config.readEntry<QColor>("foreground-color", QColor()));
     setBgColor(config.readEntry<QColor>("background-color", QColor()));
     setName(config.readEntry("Name", config.name()));
     setIcon(config.readEntry("icon"));
     setId(config.readEntry("id", config.name()));
     if (config.hasKey("font")) {
         setUseFullFont(true);
         setFont(config.readEntry("font"));
     } else {
         setUseFullFont(false);
         setItalic(config.readEntry("font-italic", false));
         setBold(config.readEntry("font-bold", false));
     }
     setStrikeOut(config.readEntry("font-strikeout", false));
 #ifdef SET
 #undef SET
 #endif
 #define SET(member,key) \
     if ( config.hasKey( key ) ) { \
         set##member(config.readEntry( key, false ) ? Set : NotSet); \
         setSpecificity(specificity() + 1); \
     }
     SET(Revoked, "is-revoked");
     SET(Expired, "is-expired");
     SET(Disabled, "is-disabled");
     SET(Root, "is-root-certificate");
     SET(CanEncrypt, "can-encrypt");
     SET(CanSign, "can-sign");
     SET(CanCertify, "can-certify");
     SET(CanAuthenticate, "can-authenticate");
     SET(Qualified, "is-qualified");
     SET(CardKey, "is-cardkey");
     SET(HasSecret, "has-secret-key");
     SET(IsOpenPGP, "is-openpgp-key");
     SET(WasValidated, "was-validated");
 #undef SET
     static const struct {
         const char *prefix;
         LevelState state;
     } prefixMap[] = {
         { "is-", Is },
         { "is-not-", IsNot },
         { "is-at-least-", IsAtLeast },
         { "is-at-most-", IsAtMost },
     };
     for (unsigned int i = 0; i < sizeof prefixMap / sizeof * prefixMap; ++i) {
         const QString key = QLatin1String(prefixMap[i].prefix) + QLatin1String("ownertrust");
         if (config.hasKey(key)) {
             setOwnerTrust(prefixMap[i].state);
             setOwnerTrustReferenceLevel(map2OwnerTrust(config.readEntry(key, QString())));
             setSpecificity(specificity() + 1);
             break;
         }
     }
     for (unsigned int i = 0; i < sizeof prefixMap / sizeof * prefixMap; ++i) {
         const QString key = QLatin1String(prefixMap[i].prefix) + QLatin1String("validity");
         if (config.hasKey(key)) {
             setValidity(prefixMap[i].state);
             setValidityReferenceLevel(map2Validity(config.readEntry(key, QString())));
             setSpecificity(specificity() + 1);
             break;
         }
     }
     static const struct {
         const char *key;
         MatchContext context;
     } matchMap[] = {
         { "any", AnyMatchContext },
         { "appearance", Appearance },
         { "filtering", Filtering },
     };
     const QStringList contexts = config.readEntry("match-contexts", "any").toLower().split(QRegExp(QLatin1String("[^a-zA-Z0-9_-!]+")), QString::SkipEmptyParts);
     setMatchContexts(NoMatchContext);
     for (const QString & ctx : contexts) {
         bool found = false;
         for (unsigned int i = 0; i < sizeof matchMap / sizeof * matchMap; ++i)
             if (ctx == QLatin1String(matchMap[i].key)) {
                 setMatchContexts(availableMatchContexts() |= matchMap[i].context);
                 found = true;
                 break;
             } else if (ctx.startsWith(QLatin1Char('!')) && ctx.mid(1) == QLatin1String(matchMap[i].key)) {
                 setMatchContexts(availableMatchContexts() &= matchMap[i].context);
                 found = true;
                 break;
             }
         if (!found) {
-            qWarning() << QStringLiteral("KConfigBasedKeyFilter: found unknown match context '%1' in group '%2'").arg(ctx).arg(config.name());
+            qWarning() << QStringLiteral("KConfigBasedKeyFilter: found unknown match context '%1' in group '%2'").arg(ctx, config.name());
         }
     }
     if (availableMatchContexts() == NoMatchContext) {
         qWarning() << QStringLiteral("KConfigBasedKeyFilter: match context in group '%1' evaluates to NoMatchContext, "
                                      "replaced by AnyMatchContext").arg(config.name());
         setMatchContexts(AnyMatchContext);
     }
 }
diff --git a/src/models/modeltest.cpp b/src/models/modeltest.cpp
index 4018048..28ac1cf 100644
--- a/src/models/modeltest.cpp
+++ b/src/models/modeltest.cpp
@@ -1,530 +1,529 @@
 /****************************************************************************
 **
 ** Copyright (C) 2007 Trolltech ASA. All rights reserved.
 **
 ** This file is part of the Qt Concurrent project on Trolltech Labs.
 **
 ** This file may be used under the terms of the GNU General Public
 ** License version 2.0 as published by the Free Software Foundation
 ** and appearing in the file LICENSE.GPL included in the packaging of
 ** this file.  Please review the following information to ensure GNU
 ** General Public Licensing requirements will be met:
 ** http://www.trolltech.com/products/qt/opensource.html
 **
 ** If you are unsure which license is appropriate for your use, please
 ** review the following information:
 ** http://www.trolltech.com/products/qt/licensing.html or contact the
 ** sales department at sales@trolltech.com.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ****************************************************************************/
 
 #include "modeltest.h"
 
 #include <QSize>
 
 Q_DECLARE_METATYPE(QModelIndex)
 
 /*!
     Connect to all of the models signals.  Whenever anything happens recheck everything.
 */
 ModelTest::ModelTest(QAbstractItemModel *_model, QObject *parent) : QObject(parent), model(_model), fetchingMore(false)
 {
     Q_ASSERT(model);
 
     connect(model, &QAbstractItemModel::columnsAboutToBeInserted, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::columnsAboutToBeRemoved, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::columnsInserted, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::columnsRemoved, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::dataChanged, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::headerDataChanged, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::layoutAboutToBeChanged, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::layoutChanged, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::modelReset, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::rowsAboutToBeInserted, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::rowsAboutToBeRemoved, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::rowsInserted, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::rowsRemoved, this, &ModelTest::runAllTests);
 
     // Special checks for inserting/removing
     connect(model, &QAbstractItemModel::layoutAboutToBeChanged, this, &ModelTest::layoutAboutToBeChanged);
     connect(model, &QAbstractItemModel::layoutChanged, this, &ModelTest::layoutChanged);
 
     connect(model, &QAbstractItemModel::rowsAboutToBeInserted, this, &ModelTest::rowsAboutToBeInserted);
     connect(model, &QAbstractItemModel::rowsAboutToBeRemoved, this, &ModelTest::rowsAboutToBeRemoved);
     connect(model, &QAbstractItemModel::rowsInserted, this, &ModelTest::rowsInserted);
     connect(model, &QAbstractItemModel::rowsRemoved, this, &ModelTest::rowsRemoved);
 
     runAllTests();
 }
 
 void ModelTest::runAllTests()
 {
     if (fetchingMore) {
         return;
     }
     nonDestructiveBasicTest();
     rowCount();
     columnCount();
     hasIndex();
     index();
     parent();
     data();
 }
 
 /*!
     nonDestructiveBasicTest tries to call a number of the basic functions (not all)
     to make sure the model doesn't outright segfault, testing the functions that makes sense.
 */
 void ModelTest::nonDestructiveBasicTest()
 {
     Q_ASSERT(model->buddy(QModelIndex()) == QModelIndex());
     model->canFetchMore(QModelIndex());
     Q_ASSERT(model->columnCount(QModelIndex()) >= 0);
     Q_ASSERT(model->data(QModelIndex()) == QVariant());
     fetchingMore = true;
     model->fetchMore(QModelIndex());
     fetchingMore = false;
     Qt::ItemFlags flags = model->flags(QModelIndex());
     Q_ASSERT(flags == Qt::ItemIsDropEnabled || flags == 0);
     model->hasChildren(QModelIndex());
     model->hasIndex(0, 0);
     model->headerData(0, Qt::Horizontal);
     model->index(0, 0);
     model->itemData(QModelIndex());
     QVariant cache;
     model->match(QModelIndex(), -1, cache);
     model->mimeTypes();
     Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
     Q_ASSERT(model->rowCount() >= 0);
     QVariant variant;
     model->setData(QModelIndex(), variant, -1);
     model->setHeaderData(-1, Qt::Horizontal, QVariant());
     model->setHeaderData(0, Qt::Horizontal, QVariant());
     model->setHeaderData(999999, Qt::Horizontal, QVariant());
-    QMap<int, QVariant> roles;
     model->sibling(0, 0, QModelIndex());
     model->span(QModelIndex());
     model->supportedDropActions();
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::rowCount() and hasChildren()
 
     Models that are dynamically populated are not as fully tested here.
  */
 void ModelTest::rowCount()
 {
     // check top row
     QModelIndex topIndex = model->index(0, 0, QModelIndex());
     int rows = model->rowCount(topIndex);
     Q_ASSERT(rows >= 0);
     if (rows > 0) {
         Q_ASSERT(model->hasChildren(topIndex) == true);
     }
 
     QModelIndex secondLevelIndex = model->index(0, 0, topIndex);
     if (secondLevelIndex.isValid()) { // not the top level
         // check a row count where parent is valid
         rows = model->rowCount(secondLevelIndex);
         Q_ASSERT(rows >= 0);
         if (rows > 0) {
             Q_ASSERT(model->hasChildren(secondLevelIndex) == true);
         }
     }
 
     // The models rowCount() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::columnCount() and hasChildren()
  */
 void ModelTest::columnCount()
 {
     // check top row
     QModelIndex topIndex = model->index(0, 0, QModelIndex());
     Q_ASSERT(model->columnCount(topIndex) >= 0);
 
     // check a column count where parent is valid
     QModelIndex childIndex = model->index(0, 0, topIndex);
     if (childIndex.isValid()) {
         Q_ASSERT(model->columnCount(childIndex) >= 0);
     }
 
     // columnCount() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::hasIndex()
  */
 void ModelTest::hasIndex()
 {
     // Make sure that invalid values returns an invalid index
     Q_ASSERT(model->hasIndex(-2, -2) == false);
     Q_ASSERT(model->hasIndex(-2, 0) == false);
     Q_ASSERT(model->hasIndex(0, -2) == false);
 
     int rows = model->rowCount();
     int columns = model->columnCount();
 
     // check out of bounds
     Q_ASSERT(model->hasIndex(rows, columns) == false);
     Q_ASSERT(model->hasIndex(rows + 1, columns + 1) == false);
 
     if (rows > 0) {
         Q_ASSERT(model->hasIndex(0, 0) == true);
     }
 
     // hasIndex() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::index()
  */
 void ModelTest::index()
 {
     // Make sure that invalid values returns an invalid index
     Q_ASSERT(model->index(-2, -2) == QModelIndex());
     Q_ASSERT(model->index(-2, 0) == QModelIndex());
     Q_ASSERT(model->index(0, -2) == QModelIndex());
 
     int rows = model->rowCount();
     int columns = model->columnCount();
 
     if (rows == 0) {
         return;
     }
 
     // Catch off by one errors
     Q_ASSERT(model->index(rows, columns) == QModelIndex());
     Q_ASSERT(model->index(0, 0).isValid() == true);
 
     // Make sure that the same index is *always* returned
     QModelIndex a = model->index(0, 0);
     QModelIndex b = model->index(0, 0);
     Q_ASSERT(a == b);
 
     // index() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::parent()
  */
 void ModelTest::parent()
 {
     // Make sure the model wont crash and will return an invalid QModelIndex
     // when asked for the parent of an invalid index.
     Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
 
     if (model->rowCount() == 0) {
         return;
     }
 
     // Column 0                | Column 1    |
     // QModelIndex()           |             |
     //    \- topIndex          | topIndex1   |
     //         \- childIndex   | childIndex1 |
 
     // Common error test #1, make sure that a top level index has a parent
     // that is a invalid QModelIndex.
     QModelIndex topIndex = model->index(0, 0, QModelIndex());
     Q_ASSERT(model->parent(topIndex) == QModelIndex());
 
     // Common error test #2, make sure that a second level index has a parent
     // that is the first level index.
     if (model->rowCount(topIndex) > 0) {
         QModelIndex childIndex = model->index(0, 0, topIndex);
         Q_ASSERT(model->parent(childIndex) == topIndex);
     }
 
     // Common error test #3, the second column should NOT have the same children
     // as the first column in a row.
     // Usually the second column shouldn't have children.
     QModelIndex topIndex1 = model->index(0, 1, QModelIndex());
     if (model->rowCount(topIndex1) > 0) {
         QModelIndex childIndex = model->index(0, 0, topIndex);
         QModelIndex childIndex1 = model->index(0, 0, topIndex1);
         Q_ASSERT(childIndex != childIndex1);
     }
 
     // Full test, walk n levels deep through the model making sure that all
     // parent's children correctly specify their parent.
     checkChildren(QModelIndex());
 }
 
 /*!
     Called from the parent() test.
 
     A model that returns an index of parent X should also return X when asking
     for the parent of the index.
 
     This recursive function does pretty extensive testing on the whole model in an
     effort to catch edge cases.
 
     This function assumes that rowCount(), columnCount() and index() already work.
     If they have a bug it will point it out, but the above tests should have already
     found the basic bugs because it is easier to figure out the problem in
     those tests then this one.
  */
 void ModelTest::checkChildren(const QModelIndex &parent, int currentDepth)
 {
     // First just try walking back up the tree.
     QModelIndex p = parent;
     while (p.isValid()) {
         p = p.parent();
     }
 
     // For models that are dynamically populated
     if (model->canFetchMore(parent)) {
         fetchingMore = true;
         model->fetchMore(parent);
         fetchingMore = false;
     }
 
     int rows = model->rowCount(parent);
     int columns = model->columnCount(parent);
 
     if (rows > 0) {
         Q_ASSERT(model->hasChildren(parent));
     }
 
     // Some further testing against rows(), columns(), and hasChildren()
     Q_ASSERT(rows >= 0);
     Q_ASSERT(columns >= 0);
     if (rows > 0) {
         Q_ASSERT(model->hasChildren(parent) == true);
     }
 
     //qCDebug(KLEOPATRA_LOG) << "parent:" << model->data(parent).toString() << "rows:" << rows
     //         << "columns:" << columns << "parent column:" << parent.column();
 
     Q_ASSERT(model->hasIndex(rows + 1, 0, parent) == false);
     for (int r = 0; r < rows; ++r) {
         if (model->canFetchMore(parent)) {
             fetchingMore = true;
             model->fetchMore(parent);
             fetchingMore = false;
         }
         Q_ASSERT(model->hasIndex(r, columns + 1, parent) == false);
         for (int c = 0; c < columns; ++c) {
             Q_ASSERT(model->hasIndex(r, c, parent) == true);
             QModelIndex index = model->index(r, c, parent);
             // rowCount() and columnCount() said that it existed...
             Q_ASSERT(index.isValid() == true);
 
             // index() should always return the same index when called twice in a row
             QModelIndex modifiedIndex = model->index(r, c, parent);
             Q_ASSERT(index == modifiedIndex);
 
             // Make sure we get the same index if we request it twice in a row
             QModelIndex a = model->index(r, c, parent);
             QModelIndex b = model->index(r, c, parent);
             Q_ASSERT(a == b);
 
             // Some basic checking on the index that is returned
             Q_ASSERT(index.model() == model);
             Q_ASSERT(index.row() == r);
             Q_ASSERT(index.column() == c);
             // While you can technically return a QVariant usually this is a sign
             // of an bug in data()  Disable if this really is ok in your model.
             Q_ASSERT(model->data(index, Qt::DisplayRole).isValid() == true);
 
             // If the next test fails here is some somewhat useful debug you play with.
             /*
             if (model->parent(index) != parent) {
                 qCDebug(KLEOPATRA_LOG) << r << c << currentDepth << model->data(index).toString()
                          << model->data(parent).toString();
                 qCDebug(KLEOPATRA_LOG) << index << parent << model->parent(index);
                 // And a view that you can even use to show the model.
                 //QTreeView view;
                 //view.setModel(model);
                 //view.show();
             }*/
 
             // Check that we can get back our real parent.
             Q_ASSERT(model->parent(index) == parent);
 
             // recursively go down the children
             if (model->hasChildren(index) && currentDepth < 10) {
                 //qCDebug(KLEOPATRA_LOG) << r << c << "has children" << model->rowCount(index);
                 checkChildren(index, ++currentDepth);
             }/* else { if (currentDepth >= 10) qCDebug(KLEOPATRA_LOG) << "checked 10 deep"; };*/
 
             // make sure that after testing the children that the index doesn't change.
             QModelIndex newerIndex = model->index(r, c, parent);
             Q_ASSERT(index == newerIndex);
         }
     }
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::data()
  */
 void ModelTest::data()
 {
     // Invalid index should return an invalid qvariant
     Q_ASSERT(!model->data(QModelIndex()).isValid());
 
     if (model->rowCount() == 0) {
         return;
     }
 
     // A valid index should have a valid QVariant data
     Q_ASSERT(model->index(0, 0).isValid());
 
     // shouldn't be able to set data on an invalid index
     Q_ASSERT(model->setData(QModelIndex(), QLatin1String("foo"), Qt::DisplayRole) == false);
 
     // General Purpose roles that should return a QString
     QVariant variant = model->data(model->index(0, 0), Qt::ToolTipRole);
     if (variant.isValid()) {
         Q_ASSERT(variant.canConvert<QString>());
     }
     variant = model->data(model->index(0, 0), Qt::StatusTipRole);
     if (variant.isValid()) {
         Q_ASSERT(variant.canConvert<QString>());
     }
     variant = model->data(model->index(0, 0), Qt::WhatsThisRole);
     if (variant.isValid()) {
         Q_ASSERT(variant.canConvert<QString>());
     }
 
     // General Purpose roles that should return a QSize
     variant = model->data(model->index(0, 0), Qt::SizeHintRole);
     if (variant.isValid()) {
         Q_ASSERT(variant.canConvert<QSize>());
     }
 
     // General Purpose roles that should return a QFont
     QVariant fontVariant = model->data(model->index(0, 0), Qt::FontRole);
     if (fontVariant.isValid()) {
         Q_ASSERT(fontVariant.canConvert<QFont>());
     }
 
     // Check that the alignment is one we know about
     QVariant textAlignmentVariant = model->data(model->index(0, 0), Qt::TextAlignmentRole);
     if (textAlignmentVariant.isValid()) {
         int alignment = textAlignmentVariant.toInt();
         Q_ASSERT(alignment == Qt::AlignLeft ||
                  alignment == Qt::AlignRight ||
                  alignment == Qt::AlignHCenter ||
                  alignment == Qt::AlignJustify ||
                  alignment == Qt::AlignTop ||
                  alignment == Qt::AlignBottom ||
                  alignment == Qt::AlignVCenter ||
                  alignment == Qt::AlignCenter ||
                  alignment == Qt::AlignAbsolute ||
                  alignment == Qt::AlignLeading ||
                  alignment == Qt::AlignTrailing);
     }
 
     // General Purpose roles that should return a QColor
     QVariant colorVariant = model->data(model->index(0, 0), Qt::BackgroundColorRole);
     if (colorVariant.isValid()) {
         Q_ASSERT(colorVariant.canConvert<QColor>());
     }
 
     colorVariant = model->data(model->index(0, 0), Qt::TextColorRole);
     if (colorVariant.isValid()) {
         Q_ASSERT(colorVariant.canConvert<QColor>());
     }
 
     // Check that the "check state" is one we know about.
     QVariant checkStateVariant = model->data(model->index(0, 0), Qt::CheckStateRole);
     if (checkStateVariant.isValid()) {
         int state = checkStateVariant.toInt();
         Q_ASSERT(state == Qt::Unchecked ||
                  state == Qt::PartiallyChecked ||
                  state == Qt::Checked);
     }
 }
 
 /*!
     Store what is about to be inserted to make sure it actually happens
 
     \sa rowsInserted()
  */
 void ModelTest::rowsAboutToBeInserted(const QModelIndex &parent, int start, int end)
 {
     Q_UNUSED(end);
     Changing c;
     c.parent = parent;
     c.oldSize = model->rowCount(parent);
     c.last = model->data(model->index(start - 1, 0, parent));
     c.next = model->data(model->index(start, 0, parent));
     insert.push(c);
 }
 
 /*!
     Confirm that what was said was going to happen actually did
 
     \sa rowsAboutToBeInserted()
  */
 void ModelTest::rowsInserted(const QModelIndex &parent, int start, int end)
 {
     Changing c = insert.pop();
     Q_ASSERT(c.parent == parent);
     Q_ASSERT(c.oldSize + (end - start + 1) == model->rowCount(parent));
     Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
     /*
     if (c.next != model->data(model->index(end + 1, 0, c.parent))) {
         qCDebug(KLEOPATRA_LOG) << start << end;
         for (int i=0; i < model->rowCount(); ++i)
             qCDebug(KLEOPATRA_LOG) << model->index(i, 0).data().toString();
         qCDebug(KLEOPATRA_LOG) << c.next << model->data(model->index(end + 1, 0, c.parent));
     }
     */
     Q_ASSERT(c.next == model->data(model->index(end + 1, 0, c.parent)));
 }
 
 void ModelTest::layoutAboutToBeChanged()
 {
     for (int i = 0; i < qBound(0, model->rowCount(), 100); ++i) {
         changing.append(QPersistentModelIndex(model->index(i, 0)));
     }
 }
 
 void ModelTest::layoutChanged()
 {
     for (int i = 0; i < changing.count(); ++i) {
         QPersistentModelIndex p = changing[i];
         Q_ASSERT(p == model->index(p.row(), p.column(), p.parent()));
     }
     changing.clear();
 }
 
 /*!
     Store what is about to be inserted to make sure it actually happens
 
     \sa rowsRemoved()
  */
 void ModelTest::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
 {
     Changing c;
     c.parent = parent;
     c.oldSize = model->rowCount(parent);
     c.last = model->data(model->index(start - 1, 0, parent));
     c.next = model->data(model->index(end + 1, 0, parent));
     remove.push(c);
 }
 
 /*!
     Confirm that what was said was going to happen actually did
 
     \sa rowsAboutToBeRemoved()
  */
 void ModelTest::rowsRemoved(const QModelIndex &parent, int start, int end)
 {
     Changing c = remove.pop();
     Q_ASSERT(c.parent == parent);
     Q_ASSERT(c.oldSize - (end - start + 1) == model->rowCount(parent));
     Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
     Q_ASSERT(c.next == model->data(model->index(start, 0, c.parent)));
 }
 
diff --git a/src/utils/classify.cpp b/src/utils/classify.cpp
index ec8f467..462b9b9 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    | Binary  | CipherText },
     { "p7s", CMS    | Binary  | 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)
+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 availabe classification */
     const unsigned int extClass = classifyExtension(fi);
     if (!GpgME::hasFeature(0, GpgME::BinaryAndFineGrainedIdentify) &&
         !(extClass & ExamineContentHint)) {
         /* GpgME's identfiy 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.";
         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(", "));
 }
 
 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();
     Q_FOREACH (const QRegExp &pattern, patterns) {
         if (pattern.exactMatch(fileName)) {
             return true;
         }
     }
     return false;
 }
diff --git a/src/utils/formatting.cpp b/src/utils/formatting.cpp
index a4dace5..3e95d1f 100644
--- a/src/utils/formatting.cpp
+++ b/src/utils/formatting.cpp
@@ -1,895 +1,895 @@
 /* -*- 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 <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION > 0x10900
 # define GPGME_HAS_KEY_IS_DEVS
 #endif
 
 
 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(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(arg.toHtmlEscaped());
+    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_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(", "));
 }
 
 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"));
         }
     }
     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::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()) {
             if (sig.certClass() > 0) {
                 return i18n("class %1", sig.certClass());
             } else {
                 return i18nc("good/valid signature", "good");
             }
         }
         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:  return QString();
     }
     return QString();
 }
 
 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(", "));
 }
 
 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)
 {
     for (const auto &uid: key.userIDs()) {
         if (uid.validity() < UserID::Validity::Full) {
             return false;
         }
     }
     return true;
 }
 
 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)
 {
 #ifdef GPGME_HAS_KEY_IS_DEVS
     for (const auto &sub: key.subkeys()) {
         if (sub.isExpired() || sub.isRevoked()) {
             // Ignore old subkeys
             continue;
         }
         if (!sub.isDeVs()) {
             return false;
         }
     }
     return true;
 #else
     return false;
 #endif
 }
 
 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");
     }
 
     return i18nc("As in not all user IDs are valid.", "not certified");
 }