diff --git a/src/conf/gnupgsystemconfigurationpage.cpp b/src/conf/gnupgsystemconfigurationpage.cpp
index fad1f45d7..d38997d34 100644
--- a/src/conf/gnupgsystemconfigurationpage.cpp
+++ b/src/conf/gnupgsystemconfigurationpage.cpp
@@ -1,99 +1,99 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/gnupgsystemconfigurationpage.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 <config-kleopatra.h>
 #include "gnupgsystemconfigurationpage.h"
 
-#include <libkleo/cryptoconfigmodule.h>
+#include <Libkleo/CryptoConfigModule>
 #include <QGpgME/Protocol>
 #include <QGpgME/CryptoConfig>
 
 #include <QVBoxLayout>
 
 using namespace Kleo::Config;
 
 GnuPGSystemConfigurationPage::GnuPGSystemConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
     QVBoxLayout *lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
 
     QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
 
     mWidget = new CryptoConfigModule(config,
                                      CryptoConfigModule::TabbedLayout,
                                      this);
     lay->addWidget(mWidget);
 
 
     connect(mWidget, &CryptoConfigModule::changed, this, &Kleo::Config::GnuPGSystemConfigurationPage::markAsChanged);
 
     load();
 }
 
 GnuPGSystemConfigurationPage::~GnuPGSystemConfigurationPage()
 {
     // ### correct here?
     if (QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig()) {
         config->clear();
     }
 }
 
 void GnuPGSystemConfigurationPage::load()
 {
     mWidget->reset();
 }
 
 void GnuPGSystemConfigurationPage::save()
 {
     mWidget->save();
 #if 0
     // Tell other apps (e.g. kmail) that the gpgconf data might have changed
     QDBusMessage message =
         QDBusMessage::createSignal(QString(), "org.kde.kleo.CryptoConfig", "changed");
     QDBusConnection::sessionBus().send(message);
 #endif
 }
 
 void GnuPGSystemConfigurationPage::defaults()
 {
     mWidget->defaults();
 }
 
 extern "C" Q_DECL_EXPORT KCModule *create_kleopatra_config_gnupgsystem(QWidget *parent, const QVariantList &args)
 {
     GnuPGSystemConfigurationPage *page =
         new GnuPGSystemConfigurationPage(parent, args);
     page->setObjectName(QStringLiteral("kleopatra_config_gnupgsystem"));
     return page;
 }
 
diff --git a/src/crypto/gui/resultitemwidget.cpp b/src/crypto/gui/resultitemwidget.cpp
index c03713640..7bf6b7fa3 100644
--- a/src/crypto/gui/resultitemwidget.cpp
+++ b/src/crypto/gui/resultitemwidget.cpp
@@ -1,385 +1,385 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resultitemwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2008 Klarälvdalens Datakonsult AB
     2016 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     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 <config-kleopatra.h>
 
 #include "resultitemwidget.h"
 
 #include "utils/auditlog.h"
 #include "commands/command.h"
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/lookupcertificatescommand.h"
 #include "crypto/decryptverifytask.h"
 
-#include <libkleo/messagebox.h>
+#include <Libkleo/MessageBox>
 #include <Libkleo/Classify>
 
 #include <gpgme++/key.h>
 #include <gpgme++/gpgmepp_version.h>
 #include <gpgme++/decryptionresult.h>
 
 #include <KLocalizedString>
 #include <QPushButton>
 #include <KStandardGuiItem>
 #include "kleopatra_debug.h"
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QUrl>
 #include <QVBoxLayout>
 #include <KGuiItem>
 #include <KColorScheme>
 
 #if GPGMEPP_VERSION > 0x10B01 // > 1.11.1
 # define GPGME_HAS_LEGACY_NOMDC
 #endif
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 namespace
 {
 // TODO move out of here
 static QColor colorForVisualCode(Task::Result::VisualCode code)
 {
     switch (code) {
     case Task::Result::AllGood:
         return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color();
     case Task::Result::NeutralError:
     case Task::Result::Warning:
         return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NormalBackground).color();
     case Task::Result::Danger:
         return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color();
     case Task::Result::NeutralSuccess:
     default:
         return QColor(0x00, 0x80, 0xFF); // light blue
     }
 }
 static QColor txtColorForVisualCode(Task::Result::VisualCode code)
 {
     switch (code) {
     case Task::Result::AllGood:
         return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::PositiveText).color();
     case Task::Result::NeutralError:
     case Task::Result::Warning:
         return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::NormalText).color();
     case Task::Result::Danger:
         return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::NegativeText).color();
     case Task::Result::NeutralSuccess:
     default:
         return QColor(0xFF, 0xFF, 0xFF); // white
     }
 }
 }
 
 class ResultItemWidget::Private
 {
     ResultItemWidget *const q;
 public:
     explicit Private(const std::shared_ptr<const Task::Result> &result, ResultItemWidget *qq) : q(qq), m_result(result), m_detailsLabel(nullptr), m_actionsLabel(nullptr), m_closeButton(nullptr), m_importCanceled(false)
     {
         Q_ASSERT(m_result);
     }
 
     void slotLinkActivated(const QString &);
     void updateShowDetailsLabel();
 
     void addKeyImportButton(QBoxLayout *lay, bool search);
     void addIgnoreMDCButton(QBoxLayout *lay);
 
     void oneImportFinished();
 
     const std::shared_ptr<const Task::Result> m_result;
     QLabel *m_detailsLabel;
     QLabel *m_actionsLabel;
     QPushButton *m_closeButton;
     bool m_importCanceled;
 };
 
 void ResultItemWidget::Private::oneImportFinished()
 {
     if (m_importCanceled) {
         return;
     }
     if (m_result->parentTask()) {
         m_result->parentTask()->start();
     }
     q->setVisible(false);
 }
 
 void ResultItemWidget::Private::addIgnoreMDCButton(QBoxLayout *lay)
 {
     if (!m_result || !lay) {
         return;
     }
 
     const auto dvResult = dynamic_cast<const DecryptVerifyResult *>(m_result.get());
     if (!dvResult) {
         return;
     }
     const auto decResult = dvResult->decryptionResult();
 
 #ifdef GPGME_HAS_LEGACY_NOMDC
     if (decResult.isNull() || !decResult.error() || !decResult.isLegacyCipherNoMDC())
 #endif
     {
         return;
     }
 
     auto btn = new QPushButton(i18n("Force decryption"));
     btn->setFixedSize(btn->sizeHint());
 
     connect (btn, &QPushButton::clicked, q, [this] () {
         if (m_result->parentTask()) {
             const auto dvTask = dynamic_cast<DecryptVerifyTask*>(m_result->parentTask().data());
             dvTask->setIgnoreMDCError(true);
             dvTask->start();
             q->setVisible(false);
         } else {
             qCWarning(KLEOPATRA_LOG) << "Failed to get parent task";
         }
     });
     lay->addWidget(btn);
 }
 
 void ResultItemWidget::Private::addKeyImportButton(QBoxLayout *lay, bool search)
 {
     if (!m_result || !lay) {
         return;
     }
 
     const auto dvResult = dynamic_cast<const DecryptVerifyResult *>(m_result.get());
     if (!dvResult) {
         return;
     }
     const auto verifyResult = dvResult->verificationResult();
 
     if (verifyResult.isNull()) {
         return;
     }
 
     for (const auto &sig: verifyResult.signatures()) {
         if (!(sig.summary() & GpgME::Signature::KeyMissing)) {
             continue;
         }
 
         auto btn = new QPushButton;
         QString suffix;
         const auto keyid = QLatin1String(sig.fingerprint());
         if (verifyResult.numSignatures() > 1) {
             suffix = QLatin1Char(' ') + keyid;
         }
         btn = new QPushButton(search ? i18nc("1 is optional keyid. No space is intended as it can be empty.",
                                        "Search%1", suffix)
                                      : i18nc("1 is optional keyid. No space is intended as it can be empty.",
                                        "Import%1", suffix));
 
         if (search) {
             btn->setIcon(QIcon::fromTheme(QStringLiteral("edit-find")));
             connect (btn, &QPushButton::clicked, q, [this, btn, keyid] () {
                 btn->setEnabled(false);
                 m_importCanceled = false;
                 auto cmd = new Kleo::Commands::LookupCertificatesCommand(keyid, nullptr);
                 connect(cmd, &Kleo::Commands::LookupCertificatesCommand::canceled,
                         q, [this]() { m_importCanceled = true; });
                 connect(cmd, &Kleo::Commands::LookupCertificatesCommand::finished,
                         q, [this, btn]() {
                     btn->setEnabled(true);
                     oneImportFinished();
                 });
                 cmd->setParentWidget(q);
                 cmd->start();
             });
         } else {
             btn->setIcon(QIcon::fromTheme(QStringLiteral("view-certificate-import")));
             connect (btn, &QPushButton::clicked, q, [this, btn] () {
                 btn->setEnabled(false);
                 m_importCanceled = false;
                 auto cmd = new Kleo::ImportCertificateFromFileCommand();
                 connect(cmd, &Kleo::ImportCertificateFromFileCommand::canceled,
                         q, [this]() { m_importCanceled = true; });
                 connect(cmd, &Kleo::ImportCertificateFromFileCommand::finished,
                         q, [this, btn]() {
                     btn->setEnabled(true);
                     oneImportFinished();
                 });
                 cmd->setParentWidget(q);
                 cmd->start();
             });
         }
         btn->setFixedSize(btn->sizeHint());
         lay->addWidget(btn);
     }
 }
 
 static QUrl auditlog_url_template()
 {
     QUrl url(QStringLiteral("kleoresultitem://showauditlog"));
     return url;
 }
 
 void ResultItemWidget::Private::updateShowDetailsLabel()
 {
     if (!m_actionsLabel || !m_detailsLabel) {
         return;
     }
 
     const auto parentTask = m_result->parentTask();
     QString auditLogLink;
     if (m_result->hasError()) {
         auditLogLink = m_result->auditLog().formatLink(auditlog_url_template(), i18n("Diagnostics"));
     } else {
         auditLogLink = m_result->auditLog().formatLink(auditlog_url_template());
     }
     m_actionsLabel->setText(auditLogLink);
 }
 
 ResultItemWidget::ResultItemWidget(const std::shared_ptr<const Task::Result> &result, QWidget *parent, Qt::WindowFlags flags) : QWidget(parent, flags), d(new Private(result, this))
 {
     const QColor color = colorForVisualCode(d->m_result->code());
     const QColor txtColor = txtColorForVisualCode(d->m_result->code());
     const QString styleSheet = QStringLiteral("QFrame,QLabel { background-color: %1; margin: 0px; }"
                                               "QFrame#resultFrame{ border-color: %2; border-style: solid; border-radius: 3px; border-width: 1px }"
                                               "QLabel { color: %3; padding: 5px; border-radius: 3px }").arg(color.name()).arg(color.darker(150).name()).arg(txtColor.name());
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     QFrame *frame = new QFrame;
     frame->setObjectName(QStringLiteral("resultFrame"));
     frame->setStyleSheet(styleSheet);
     topLayout->addWidget(frame);
     QHBoxLayout *layout = new QHBoxLayout(frame);
     QVBoxLayout *vlay = new QVBoxLayout();
     QLabel *overview = new QLabel;
     overview->setWordWrap(true);
     overview->setTextFormat(Qt::RichText);
     overview->setText(d->m_result->overview());
     overview->setFocusPolicy(Qt::StrongFocus);
     overview->setStyleSheet(styleSheet);
     connect(overview, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));
 
     vlay->addWidget(overview);
     layout->addLayout(vlay);
 
     const QString details = d->m_result->details();
 
     QVBoxLayout *actionLayout = new QVBoxLayout;
     layout->addLayout(actionLayout);
 
     d->addKeyImportButton(actionLayout, false);
     // TODO: Only show if auto-key-retrieve is not set.
     d->addKeyImportButton(actionLayout, true);
 
     d->addIgnoreMDCButton(actionLayout);
 
     d->m_actionsLabel = new QLabel;
     connect(d->m_actionsLabel, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));
     actionLayout->addWidget(d->m_actionsLabel);
     d->m_actionsLabel->setFocusPolicy(Qt::StrongFocus);
     d->m_actionsLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     d->m_actionsLabel->setStyleSheet(styleSheet);
 
     d->m_detailsLabel = new QLabel;
     d->m_detailsLabel->setWordWrap(true);
     d->m_detailsLabel->setTextFormat(Qt::RichText);
     d->m_detailsLabel->setText(details);
     d->m_detailsLabel->setFocusPolicy(Qt::StrongFocus);
     d->m_detailsLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     d->m_detailsLabel->setStyleSheet(styleSheet);
 
     connect(d->m_detailsLabel, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));
     vlay->addWidget(d->m_detailsLabel);
 
     d->m_closeButton = new QPushButton;
     KGuiItem::assign(d->m_closeButton, KStandardGuiItem::close());
     d->m_closeButton->setFixedSize(d->m_closeButton->sizeHint());
     connect(d->m_closeButton, &QAbstractButton::clicked, this, &ResultItemWidget::closeButtonClicked);
     actionLayout->addWidget(d->m_closeButton);
     d->m_closeButton->setVisible(false);
 
     layout->setStretch(0, 1);
     actionLayout->addStretch(-1);
     vlay->addStretch(-1);
 
     d->updateShowDetailsLabel();
     setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Maximum);
 }
 
 ResultItemWidget::~ResultItemWidget()
 {
 }
 
 void ResultItemWidget::showCloseButton(bool show)
 {
     d->m_closeButton->setVisible(show);
 }
 
 bool ResultItemWidget::hasErrorResult() const
 {
     return d->m_result->hasError();
 }
 
 void ResultItemWidget::Private::slotLinkActivated(const QString &link)
 {
     Q_ASSERT(m_result);
     qCDebug(KLEOPATRA_LOG) << "Link activated: " << link;
     if (link.startsWith(QLatin1String("key:"))) {
         auto split = link.split(QLatin1Char(':'));
         auto fpr = split.value(1);
         if (split.size() == 2 && isFingerprint(fpr)) {
             /* There might be a security consideration here if somehow
              * a short keyid is used in a link and it collides with another.
              * So we additionally check that it really is a fingerprint. */
             auto cmd = Command::commandForQuery(fpr);
             cmd->setParentWId(q->effectiveWinId());
             cmd->start();
         } else {
             qCWarning(KLEOPATRA_LOG) << "key link invalid " << link;
         }
         return;
     }
 
     const QUrl url(link);
 
     if (url.host() == QLatin1String("showauditlog")) {
         q->showAuditLog();
         return;
     }
     qCWarning(KLEOPATRA_LOG) << "Unexpected link scheme: " << link;
 }
 
 void ResultItemWidget::showAuditLog()
 {
     MessageBox::auditLog(parentWidget(), d->m_result->auditLog().text());
 }
 
 #include "moc_resultitemwidget.cpp"
diff --git a/src/dialogs/certificatedetailswidget.cpp b/src/dialogs/certificatedetailswidget.cpp
index 27b73c653..916848f43 100644
--- a/src/dialogs/certificatedetailswidget.cpp
+++ b/src/dialogs/certificatedetailswidget.cpp
@@ -1,657 +1,657 @@
 /*  Copyright (c) 2016 Klarälvdalens Datakonsult AB
                   2017 Intevation GmbH
 
     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
 */
 
 #include "certificatedetailswidget.h"
 #include "ui_certificatedetailswidget.h"
 #include "kleopatra_debug.h"
 #include "exportdialog.h"
 #include "trustchainwidget.h"
 #include "subkeyswidget.h"
 #include "weboftrustdialog.h"
 
 #include "commands/changepassphrasecommand.h"
 #include "commands/changeexpirycommand.h"
 #include "commands/certifycertificatecommand.h"
 #include "commands/adduseridcommand.h"
 #include "commands/genrevokecommand.h"
 #include "commands/detailscommand.h"
 #include "commands/dumpcertificatecommand.h"
 #include "utils/remarks.h"
 
-#include <libkleo/formatting.h>
-#include <libkleo/dn.h>
-#include <libkleo/keycache.h>
+#include <Libkleo/Formatting>
+#include <Libkleo/Dn>
+#include <Libkleo/KeyCache>
 
 #include <gpgme++/context.h>
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <gpgme++/tofuinfo.h>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/KeyListJob>
 
 #include <QDateTime>
 #include <QDialogButtonBox>
 #include <QMenu>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <QLocale>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 #define HIDE_ROW(row) \
     ui.row->setVisible(false); \
     ui.row##Lbl->setVisible(false);
 
 Q_DECLARE_METATYPE(GpgME::UserID)
 
 using namespace Kleo;
 
 class CertificateDetailsWidget::Private
 {
 public:
     Private(CertificateDetailsWidget *parent)
         : q(parent)
     {}
 
     void setupCommonProperties();
     void setupPGPProperties();
     void setupSMIMEProperties();
 
     void revokeUID(const GpgME::UserID &uid);
     void genRevokeCert();
     void certifyClicked();
     void webOfTrustClicked();
     void exportClicked();
     void addUserID();
     void changePassphrase();
     void changeExpiration();
     void keysMayHaveChanged();
     void showTrustChainDialog();
     void showMoreDetails();
     void publishCertificate();
     void userIDTableContextMenuRequested(const QPoint &p);
 
     QString tofuTooltipString(const GpgME::UserID &uid) const;
 
     void smimeLinkActivated(const QString &link);
 
     void setUpdatedKey(const GpgME::Key &key);
     void keyListDone(const GpgME::KeyListResult &,
                      const std::vector<GpgME::Key> &, const QString &,
                      const GpgME::Error &);
 
     Ui::CertificateDetailsWidget ui;
     GpgME::Key key;
     bool updateInProgress;
 private:
     CertificateDetailsWidget *q;
 };
 
 void CertificateDetailsWidget::Private::setupCommonProperties()
 {
     // TODO: Enable once implemented
     HIDE_ROW(publishing)
 
     const bool hasSecret = key.hasSecret();
     const bool isOpenPGP = key.protocol() == GpgME::OpenPGP;
     // TODO: Enable once implemented
     const bool canRevokeUID = false; // isOpenPGP && hasSecret
 
     ui.changePassphraseBtn->setVisible(hasSecret);
     ui.genRevokeBtn->setVisible(isOpenPGP && hasSecret);
     ui.certifyBtn->setVisible(isOpenPGP && !hasSecret);
     ui.changeExpirationBtn->setVisible(isOpenPGP && hasSecret);
     ui.addUserIDBtn->setVisible(hasSecret && isOpenPGP);
     ui.webOfTrustBtn->setVisible(isOpenPGP);
 
     ui.hboxLayout_1->addStretch(1);
 
     ui.validFrom->setText(Kleo::Formatting::creationDateString(key));
     const QString expiry = Kleo::Formatting::expirationDateString(key);
     ui.expires->setText(expiry.isEmpty() ? i18nc("Expires", "never") : expiry);
     ui.type->setText(Kleo::Formatting::type(key));
     ui.fingerprint->setText(Formatting::prettyID(key.primaryFingerprint()));
 
     if (Kleo::Formatting::complianceMode().isEmpty()) {
         HIDE_ROW(compliance)
     } else {
         ui.complianceLbl->setText(Kleo::Formatting::complianceStringForKey(key));
     }
 
     ui.userIDTable->clear();
 
     QStringList headers = { i18n("Email"), i18n("Name"), i18n("Trust Level"), i18n("Tags") };
     if (canRevokeUID) {
         headers << QString();
     }
     ui.userIDTable->setColumnCount(headers.count());
     ui.userIDTable->setColumnWidth(0, 200);
     ui.userIDTable->setColumnWidth(1, 200);
     ui.userIDTable->setHeaderLabels(headers);
 
     const auto uids = key.userIDs();
     for (unsigned int i = 0; i < uids.size(); ++i) {
         const auto &uid = uids[i];
         auto item = new QTreeWidgetItem;
         const QString toolTip = tofuTooltipString(uid);
         item->setData(0, Qt::UserRole, QVariant::fromValue(uid));
 
         auto pMail = Kleo::Formatting::prettyEMail(uid);
         auto pName = Kleo::Formatting::prettyName(uid);
         if (!isOpenPGP && pMail.isEmpty() && !pName.isEmpty()) {
             // S/MIME UserIDs are sometimes split, with one userID
             // containing the name another the Mail, we merge these
             // UID's into a single item.
 
             if (i + 1 < uids.size()) {
                 pMail = Kleo::Formatting::prettyEMail(uids[i + 1]);
                 // skip next uid
                 ++i;
             }
         }
 
         if (!isOpenPGP && pMail.isEmpty() && pName.isEmpty()) {
             // S/MIME certificates sometimes contain urls where both
             // name and mail is empty. In that case we print whatever
             // the uid is as name.
             //
             // Can be ugly like (3:uri24:http://ca.intevation.org), but
             // this is better then showing an empty entry.
             pName = QString::fromLatin1(uid.id());
         }
 
         item->setData(0, Qt::DisplayRole, pMail);
         item->setData(0, Qt::ToolTipRole, toolTip);
         item->setData(1, Qt::DisplayRole, pName);
         item->setData(1, Qt::ToolTipRole, toolTip);
 
         QIcon trustIcon;
         if (updateInProgress) {
            trustIcon = QIcon::fromTheme(QStringLiteral("emblem-question"));
            item->setData(2, Qt::DisplayRole, i18n("Updating..."));
         } else {
             switch (uid.validity()) {
             case GpgME::UserID::Unknown:
             case GpgME::UserID::Undefined:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-question"));
                 break;
             case GpgME::UserID::Never:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-error"));
                 break;
             case GpgME::UserID::Marginal:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-warning"));
                 break;
             case GpgME::UserID::Full:
             case GpgME::UserID::Ultimate:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-success"));
                 break;
             }
             item->setData(2, Qt::DisplayRole, Kleo::Formatting::validityShort(uid));
         }
         item->setData(2, Qt::DecorationRole, trustIcon);
         item->setData(2, Qt::ToolTipRole, toolTip);
 
         GpgME::Error err;
         QStringList remarkList;
 #ifdef GPGME_HAS_REMARKS
         for (const auto &rem: uid.remarks(Remarks::remarkKeys(), err)) {
             remarkList << QString::fromStdString(rem);
         }
 #endif
         const auto remark = remarkList.join(QStringLiteral("; "));
         item->setData(3, Qt::DisplayRole, remark);
         item->setData(3, Qt::ToolTipRole, toolTip);
 
         ui.userIDTable->addTopLevelItem(item);
 
         if (canRevokeUID) {
             auto button = new QPushButton;
             button->setIcon(QIcon::fromTheme(QStringLiteral("entry-delete")));
             button->setToolTip(i18n("Revoke this User ID"));
             button->setMaximumWidth(32);
             QObject::connect(button, &QPushButton::clicked,
                             q, [this, uid]() { revokeUID(uid); });
             ui.userIDTable->setItemWidget(item, 4, button);
         }
     }
     if (!Remarks::remarksEnabled()) {
         ui.userIDTable->hideColumn(3);
     }
 }
 
 void CertificateDetailsWidget::Private::revokeUID(const GpgME::UserID &uid)
 {
     Q_UNUSED(uid);
     qCWarning(KLEOPATRA_LOG) << "Revoking UserID is not implemented. How did you even get here?!?!";
 }
 
 void CertificateDetailsWidget::Private::changeExpiration()
 {
     auto cmd = new Kleo::Commands::ChangeExpiryCommand(key);
     QObject::connect(cmd, &Kleo::Commands::ChangeExpiryCommand::finished,
                      q, [this]() {
                          ui.changeExpirationBtn->setEnabled(true);
                      });
     ui.changeExpirationBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::changePassphrase()
 {
     auto cmd = new Kleo::Commands::ChangePassphraseCommand(key);
     QObject::connect(cmd, &Kleo::Commands::ChangePassphraseCommand::finished,
                      q, [this]() {
                          ui.changePassphraseBtn->setEnabled(true);
                      });
     ui.changePassphraseBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::genRevokeCert()
 {
     auto cmd = new Kleo::Commands::GenRevokeCommand(key);
     QObject::connect(cmd, &Kleo::Commands::GenRevokeCommand::finished,
                      q, [this]() {
                          ui.genRevokeBtn->setEnabled(true);
                      });
     ui.genRevokeBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::certifyClicked()
 {
     auto cmd = new Kleo::Commands::CertifyCertificateCommand(key);
     QObject::connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
                      q, [this]() {
                          ui.certifyBtn->setEnabled(true);
                      });
     ui.certifyBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::webOfTrustClicked()
 {
     QScopedPointer<WebOfTrustDialog> dlg(new WebOfTrustDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::exportClicked()
 {
     QScopedPointer<ExportDialog> dlg(new ExportDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::addUserID()
 {
     auto cmd = new Kleo::Commands::AddUserIDCommand(key);
     QObject::connect(cmd, &Kleo::Commands::AddUserIDCommand::finished,
                      q, [this]() {
                          ui.addUserIDBtn->setEnabled(true);
                          key.update();
                          q->setKey(key);
                      });
     ui.addUserIDBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::keysMayHaveChanged()
 {
     auto newKey = Kleo::KeyCache::instance()->findByFingerprint(key.primaryFingerprint());
     if (!newKey.isNull()) {
         setUpdatedKey(newKey);
     }
 }
 
 void CertificateDetailsWidget::Private::showTrustChainDialog()
 {
     QScopedPointer<TrustChainDialog> dlg(new TrustChainDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::publishCertificate()
 {
     qCWarning(KLEOPATRA_LOG) << "publishCertificateis not implemented.";
     //TODO
 }
 
 void CertificateDetailsWidget::Private::userIDTableContextMenuRequested(const QPoint &p)
 {
     auto item = ui.userIDTable->itemAt(p);
     if (!item) {
         return;
     }
 
     const auto userID = item->data(0, Qt::UserRole).value<GpgME::UserID>();
 
     QMenu *menu = new QMenu(q);
     menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-sign")),
                     i18n("Certify ..."),
                     q, [this, userID]() {
         auto cmd = new Kleo::Commands::CertifyCertificateCommand(userID);
         ui.userIDTable->setEnabled(false);
         connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
                 q, [this]() {
             ui.userIDTable->setEnabled(true);
             // Trigger an update when done
             q->setKey(key);
         });
         cmd->start();
     });
     connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
     menu->popup(ui.userIDTable->viewport()->mapToGlobal(p));
 }
 
 void CertificateDetailsWidget::Private::showMoreDetails()
 {
     ui.moreDetailsBtn->setEnabled(false);
     if (key.protocol() == GpgME::CMS) {
         auto cmd = new Kleo::Commands::DumpCertificateCommand(key);
         connect(cmd, &Kleo::Commands::DumpCertificateCommand::finished,
                 q, [this]() {
                     ui.moreDetailsBtn->setEnabled(true);
                 });
         cmd->setUseDialog(true);
         cmd->start();
     } else {
         QScopedPointer<SubKeysDialog> dlg(new SubKeysDialog(q));
         dlg->setKey(key);
         dlg->exec();
         ui.moreDetailsBtn->setEnabled(true);
     }
 }
 
 QString CertificateDetailsWidget::Private::tofuTooltipString(const GpgME::UserID &uid) const
 {
     const auto tofu = uid.tofuInfo();
     if (tofu.isNull()) {
         return QString();
     }
 
     QString html = QStringLiteral("<table border=\"0\" cell-padding=\"5\">");
     const auto appendRow = [&html](const QString &lbl, const QString &val) {
         html += QStringLiteral("<tr>"
                                "<th style=\"text-align: right; padding-right: 5px; white-space: nowrap;\">%1:</th>"
                                "<td style=\"white-space: nowrap;\">%2</td>"
                                "</tr>")
                     .arg(lbl, val);
     };
     const auto appendHeader = [this, &html](const QString &hdr) {
         html += QStringLiteral("<tr><th colspan=\"2\" style=\"background-color: %1; color: %2\">%3</th></tr>")
                     .arg(q->palette().highlight().color().name(),
                          q->palette().highlightedText().color().name(),
                          hdr);
     };
     const auto dateTime = [](long ts) {
         QLocale l;
         return ts == 0 ? i18n("never") : l.toString(QDateTime::fromSecsSinceEpoch(ts), QLocale::ShortFormat);
     };
     appendHeader(i18n("Signing"));
     appendRow(i18n("First message"), dateTime(tofu.signFirst()));
     appendRow(i18n("Last message"), dateTime(tofu.signLast()));
     appendRow(i18n("Message count"), QString::number(tofu.signCount()));
     appendHeader(i18n("Encryption"));
     appendRow(i18n("First message"), dateTime(tofu.encrFirst()));
     appendRow(i18n("Last message"), dateTime(tofu.encrLast()));
     appendRow(i18n("Message count"), QString::number(tofu.encrCount()));
 
     html += QStringLiteral("</table>");
     // Make sure the tooltip string is different for each UserID, even if the
     // data are the same, otherwise the tooltip is not updated and moved when
     // user moves mouse from one row to another.
     html += QStringLiteral("<!-- %1 //-->").arg(QString::fromUtf8(uid.id()));
     return html;
 }
 
 
 void CertificateDetailsWidget::Private::setupPGPProperties()
 {
     HIDE_ROW(smimeOwner)
     HIDE_ROW(smimeIssuer)
     ui.smimeRelatedAddresses->setVisible(false);
     ui.trustChainDetailsBtn->setVisible(false);
 
     ui.userIDTable->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(ui.userIDTable, &QAbstractItemView::customContextMenuRequested,
             q, [this](const QPoint &p) { userIDTableContextMenuRequested(p); });
 }
 
 static QString formatDNToolTip(const Kleo::DN &dn)
 {
     QString html = QStringLiteral("<table border=\"0\" cell-spacing=15>");
 
     const auto appendRow = [&html, dn](const QString &lbl, const QString &attr) {
                                 const QString val = dn[attr];
                                 if (!val.isEmpty()) {
                                     html += QStringLiteral(
                                             "<tr><th style=\"text-align: left; white-space: nowrap\">%1:</th>"
                                                 "<td style=\"white-space: nowrap\">%2</td>"
                                             "</tr>").arg(lbl, val);
                                 }
                             };
     appendRow(i18n("Common Name"), QStringLiteral("CN"));
     appendRow(i18n("Organization"), QStringLiteral("O"));
     appendRow(i18n("Street"), QStringLiteral("STREET"));
     appendRow(i18n("City"),  QStringLiteral("L"));
     appendRow(i18n("State"), QStringLiteral("ST"));
     appendRow(i18n("Country"), QStringLiteral("C"));
     html += QStringLiteral("</table>");
 
     return html;
 }
 
 void CertificateDetailsWidget::Private::setupSMIMEProperties()
 {
     HIDE_ROW(publishing)
 
     const auto ownerId = key.userID(0);
     const Kleo::DN dn(ownerId.id());
     const QString cn = dn[QStringLiteral("CN")];
     const QString o = dn[QStringLiteral("O")];
     const QString dnEmail = dn[QStringLiteral("EMAIL")];
     const QString name = cn.isEmpty() ? dnEmail : cn;
 
     QString owner;
     if (name.isEmpty()) {
         owner = dn.dn();
     } else if (o.isEmpty()) {
         owner = name;
     } else {
         owner = i18nc("<name> of <company>", "%1 of %2", name, o);
     }
     ui.smimeOwner->setText(owner);
     ui.smimeOwner->setTextInteractionFlags(Qt::TextBrowserInteraction);
 
     const Kleo::DN issuerDN(key.issuerName());
     const QString issuerCN = issuerDN[QStringLiteral("CN")];
     const QString issuer = issuerCN.isEmpty() ? QString::fromUtf8(key.issuerName()) : issuerCN;
     ui.smimeIssuer->setText(QStringLiteral("<a href=\"#issuerDetails\">%1</a>").arg(issuer));
 
     ui.smimeIssuer->setToolTip(formatDNToolTip(issuerDN));
 
     ui.smimeOwner->setToolTip(formatDNToolTip(dn));
 
 }
 
 void CertificateDetailsWidget::Private::smimeLinkActivated(const QString &link)
 {
     if (link == QLatin1String("#issuerDetails")) {
         const auto parentKey = KeyCache::instance()->findIssuers(key, KeyCache::NoOption);
 
         if (!parentKey.size()) {
             return;
         }
         auto cmd = new Kleo::Commands::DetailsCommand(parentKey[0], nullptr);
         cmd->setParentWidget(q);
         cmd->start();
         return;
     }
     qCWarning(KLEOPATRA_LOG) << "Unknown link activated:" << link;
 }
 
 CertificateDetailsWidget::CertificateDetailsWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
     d->ui.setupUi(this);
 
     connect(d->ui.addUserIDBtn, &QPushButton::clicked,
             this, [this]() { d->addUserID(); });
     connect(d->ui.changePassphraseBtn, &QPushButton::clicked,
             this, [this]() { d->changePassphrase(); });
     connect(d->ui.genRevokeBtn, &QPushButton::clicked,
             this, [this]() { d->genRevokeCert(); });
     connect(d->ui.changeExpirationBtn, &QPushButton::clicked,
             this, [this]() { d->changeExpiration(); });
     connect(d->ui.smimeOwner, &QLabel::linkActivated,
             this, [this](const QString &link) { d->smimeLinkActivated(link); });
     connect(d->ui.smimeIssuer, &QLabel::linkActivated,
             this, [this](const QString &link) { d->smimeLinkActivated(link); });
     connect(d->ui.trustChainDetailsBtn, &QPushButton::pressed,
             this, [this]() { d->showTrustChainDialog(); });
     connect(d->ui.moreDetailsBtn, &QPushButton::pressed,
             this, [this]() { d->showMoreDetails(); });
     connect(d->ui.publishing, &QPushButton::pressed,
             this, [this]() { d->publishCertificate(); });
     connect(d->ui.certifyBtn, &QPushButton::clicked,
             this, [this]() { d->certifyClicked(); });
     connect(d->ui.webOfTrustBtn, &QPushButton::clicked,
             this, [this]() { d->webOfTrustClicked(); });
     connect(d->ui.exportBtn, &QPushButton::clicked,
             this, [this]() { d->exportClicked(); });
 
     connect(Kleo::KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, [this]() { d->keysMayHaveChanged(); });
 }
 
 CertificateDetailsWidget::~CertificateDetailsWidget()
 {
 }
 
 void CertificateDetailsWidget::Private::keyListDone(const GpgME::KeyListResult &,
                                                     const std::vector<GpgME::Key> &keys,
                                                     const QString &,
                                                     const GpgME::Error &) {
         updateInProgress = false;
         if (keys.size() != 1) {
             qCWarning(KLEOPATRA_LOG) << "Invalid keylist result in update.";
             return;
         }
         // As we listen for keysmayhavechanged we get the update
         // after updating the keycache.
         KeyCache::mutableInstance()->insert(keys);
 }
 
 void CertificateDetailsWidget::Private::setUpdatedKey(const GpgME::Key &k)
 {
     key = k;
 
     setupCommonProperties();
     if (key.protocol() == GpgME::OpenPGP) {
         setupPGPProperties();
     } else {
         setupSMIMEProperties();
     }
 }
 
 void CertificateDetailsWidget::setKey(const GpgME::Key &key)
 {
     if (key.protocol() == GpgME::CMS) {
         // For everything but S/MIME this should be quick
         // and we don't need to show another status.
         d->updateInProgress = true;
     }
     d->setUpdatedKey(key);
 
     // Run a keylistjob with full details (TOFU / Validate)
     QGpgME::KeyListJob *job = key.protocol() == GpgME::OpenPGP ? QGpgME::openpgp()->keyListJob(false, true, true) :
                                                                  QGpgME::smime()->keyListJob(false, true, true);
 
     auto ctx = QGpgME::Job::context(job);
     ctx->addKeyListMode(GpgME::WithTofu);
     ctx->addKeyListMode(GpgME::Signatures);
     ctx->addKeyListMode(GpgME::SignatureNotations);
 
     // Windows QGpgME new style connect problem makes this necessary.
     connect(job, SIGNAL(result(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)),
             this, SLOT(keyListDone(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)));
 
     job->start(QStringList() << QLatin1String(key.primaryFingerprint()), key.hasSecret());
 }
 
 GpgME::Key CertificateDetailsWidget::key() const
 {
     return d->key;
 }
 
 CertificateDetailsDialog::CertificateDetailsDialog(QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window", "Certificate Details"));
     auto l = new QVBoxLayout(this);
     l->addWidget(new CertificateDetailsWidget(this));
 
     auto bbox = new QDialogButtonBox(this);
     auto btn = bbox->addButton(QDialogButtonBox::Close);
     connect(btn, &QPushButton::pressed, this, &QDialog::accept);
     l->addWidget(bbox);
     readConfig();
 }
 
 CertificateDetailsDialog::~CertificateDetailsDialog()
 {
     writeConfig();
 }
 
 void CertificateDetailsDialog::readConfig()
 {
     KConfigGroup dialog(KSharedConfig::openConfig(), "CertificateDetailsDialog");
     const QSize size = dialog.readEntry("Size", QSize(730, 280));
     if (size.isValid()) {
         resize(size);
     }
 }
 
 void CertificateDetailsDialog::writeConfig()
 {
     KConfigGroup dialog(KSharedConfig::openConfig(), "CertificateDetailsDialog");
     dialog.writeEntry("Size", size());
     dialog.sync();
 }
 
 void CertificateDetailsDialog::setKey(const GpgME::Key &key)
 {
     auto w = findChild<CertificateDetailsWidget*>();
     Q_ASSERT(w);
     w->setKey(key);
 }
 
 GpgME::Key CertificateDetailsDialog::key() const
 {
     auto w = findChild<CertificateDetailsWidget*>();
     Q_ASSERT(w);
     return w->key();
 }
 
 #include "moc_certificatedetailswidget.cpp"
diff --git a/src/dialogs/subkeyswidget.cpp b/src/dialogs/subkeyswidget.cpp
index ba6dd9a8a..abc74933e 100644
--- a/src/dialogs/subkeyswidget.cpp
+++ b/src/dialogs/subkeyswidget.cpp
@@ -1,217 +1,217 @@
 /*  Copyright (c) 2016 Klarälvdalens Datakonsult AB
     2017 by Bundesamt für Sicherheit in der Informationstechnik
     Software engineering by Intevation GmbH
 
     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
 */
 
 #include "subkeyswidget.h"
 #include "ui_subkeyswidget.h"
 
 #include "smartcard/readerstatus.h"
 
 #include "commands/keytocardcommand.h"
 #include "commands/importpaperkeycommand.h"
 
 #include <gpgme++/key.h>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QTreeWidgetItem>
 #include <QMenu>
 
-#include <libkleo/formatting.h>
+#include <Libkleo/Formatting>
 
 Q_DECLARE_METATYPE(GpgME::Subkey)
 
 using namespace Kleo;
 
 class SubKeysWidget::Private
 {
 public:
     Private(SubKeysWidget *q)
         : q(q)
     {
         ui.setupUi(q);
         ui.subkeysTree->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(ui.subkeysTree, &QAbstractItemView::customContextMenuRequested,
                 q, [this](const QPoint &p) { tableContextMenuRequested(p); });
     }
 
     GpgME::Key key;
     Ui::SubKeysWidget ui;
     void tableContextMenuRequested(const QPoint &p);
 private:
     SubKeysWidget *q;
 };
 
 void SubKeysWidget::Private::tableContextMenuRequested(const QPoint &p)
 {
     auto item = ui.subkeysTree->itemAt(p);
     if (!item) {
         return;
     }
     const auto subkey = item->data(0, Qt::UserRole).value<GpgME::Subkey>();
 
     QMenu *menu = new QMenu(q);
     connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
 
     bool hasActions = false;
 
     if (!subkey.isSecret()) {
         hasActions = true;
         menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-import")),
                         i18n("Restore printed backup"),
                         q, [this, subkey] () {
             auto cmd = new Kleo::Commands::ImportPaperKeyCommand(subkey.parent());
             ui.subkeysTree->setEnabled(false);
             connect(cmd, &Kleo::Commands::ImportPaperKeyCommand::finished,
                     q, [this]() { ui.subkeysTree->setEnabled(true); });
             cmd->setParentWidget(q);
             cmd->start();
         });
     }
 
     if (subkey.isSecret() && Kleo::Commands::KeyToCardCommand::supported()) {
         const auto cards = SmartCard::ReaderStatus::instance()->getCards();
         if (cards.size() && cards[0]->appType() == SmartCard::Card::OpenPGPApplication) {
             const auto card = cards[0];
 
             if (!subkey.cardSerialNumber() || card->serialNumber() != subkey.cardSerialNumber()) {
                 hasActions = true;
                 menu->addAction(QIcon::fromTheme(QStringLiteral("send-to-symbolic")),
                                 i18n("Transfer to smartcard"),
                                 q, [this, subkey, card]() {
                     auto cmd = new Kleo::Commands::KeyToCardCommand(subkey, card->serialNumber());
                     ui.subkeysTree->setEnabled(false);
                     connect(cmd, &Kleo::Commands::KeyToCardCommand::finished,
                             q, [this]() { ui.subkeysTree->setEnabled(true); });
                     cmd->setParentWidget(q);
                     cmd->start();
                 });
             }
         }
     }
 
     if (hasActions) {
         menu->popup(ui.subkeysTree->viewport()->mapToGlobal(p));
     } else {
         delete menu;
     }
 }
 
 SubKeysWidget::SubKeysWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
 }
 
 SubKeysWidget::~SubKeysWidget()
 {
 }
 
 void SubKeysWidget::setKey(const GpgME::Key &key)
 {
     d->key = key;
 
     for (const auto &subkey : key.subkeys()) {
         auto item = new QTreeWidgetItem();
         item->setData(0, Qt::DisplayRole, Formatting::prettyID(subkey.keyID()));
         item->setData(0, Qt::UserRole, QVariant::fromValue(subkey));
         item->setData(1, Qt::DisplayRole, Kleo::Formatting::type(subkey));
         item->setData(2, Qt::DisplayRole, Kleo::Formatting::creationDateString(subkey));
         item->setData(3, Qt::DisplayRole, Kleo::Formatting::expirationDateString(subkey));
         item->setData(4, Qt::DisplayRole, Kleo::Formatting::validityShort(subkey));
         switch (subkey.publicKeyAlgorithm()) {
             case GpgME::Subkey::AlgoECDSA:
             case GpgME::Subkey::AlgoEDDSA:
             case GpgME::Subkey::AlgoECDH:
                 item->setData(5, Qt::DisplayRole, QString::fromStdString(subkey.algoName()));
                 break;
             default:
                 item->setData(5, Qt::DisplayRole, QString::number(subkey.length()));
         }
         item->setData(6, Qt::DisplayRole, Kleo::Formatting::usageString(subkey));
         item->setData(7, Qt::DisplayRole, subkey.keyID() == key.keyID() ? QStringLiteral("✓") : QString());
         d->ui.subkeysTree->addTopLevelItem(item);
     }
 
     const auto subkey = key.subkey(0);
     if (const char *card = subkey.cardSerialNumber()) {
         d->ui.stored->setText(i18nc("stored...", "on SmartCard with serial no. %1", QString::fromUtf8(card)));
     } else {
         d->ui.stored->setText(i18nc("stored...", "on this computer"));
     }
     d->ui.subkeysTree->resizeColumnToContents(0);
 }
 
 
 GpgME::Key SubKeysWidget::key() const
 {
     return d->key;
 }
 
 
 
 SubKeysDialog::SubKeysDialog(QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window", "Subkeys Details"));
     auto l = new QVBoxLayout(this);
     l->addWidget(new SubKeysWidget(this));
 
     auto bbox = new QDialogButtonBox(this);
     auto btn = bbox->addButton(QDialogButtonBox::Close);
     connect(btn, &QPushButton::clicked, this, &QDialog::accept);
     l->addWidget(bbox);
     readConfig();
 }
 
 SubKeysDialog::~SubKeysDialog()
 {
     writeConfig();
 }
 
 void SubKeysDialog::readConfig()
 {
     KConfigGroup dialog(KSharedConfig::openConfig(), "SubKeysDialog");
     const QSize size = dialog.readEntry("Size", QSize(820, 280));
     if (size.isValid()) {
         resize(size);
     }
 }
 
 void SubKeysDialog::writeConfig()
 {
     KConfigGroup dialog(KSharedConfig::openConfig(), "SubKeysDialog");
     dialog.writeEntry("Size", size());
     dialog.sync();
 }
 
 void SubKeysDialog::setKey(const GpgME::Key &key)
 {
     auto w = findChild<SubKeysWidget*>();
     Q_ASSERT(w);
     w->setKey(key);
 }
 
 GpgME::Key SubKeysDialog::key() const
 {
     auto w = findChild<SubKeysWidget*>();
     Q_ASSERT(w);
     return w->key();
 }
diff --git a/src/dialogs/trustchainwidget.cpp b/src/dialogs/trustchainwidget.cpp
index 60d480ff3..287c0cc23 100644
--- a/src/dialogs/trustchainwidget.cpp
+++ b/src/dialogs/trustchainwidget.cpp
@@ -1,126 +1,126 @@
 /*  Copyright (c) 2016 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
 */
 
 #include "trustchainwidget.h"
 #include "ui_trustchainwidget.h"
 
 #include "kleopatra_debug.h"
 
 #include <QTreeWidgetItem>
 #include <QTreeWidget>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 #include <gpgme++/key.h>
 
-#include <libkleo/dn.h>
-#include <libkleo/keycache.h>
+#include <Libkleo/Dn>
+#include <Libkleo/KeyCache>
 
 class TrustChainWidget::Private
 {
 public:
     Private(TrustChainWidget *qq)
         : q(qq)
     {}
 
     GpgME::Key key;
     Ui::TrustChainWidget ui;
 
 private:
     TrustChainWidget *q;
 };
 
 TrustChainWidget::TrustChainWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
     d->ui.setupUi(this);
 }
 
 TrustChainWidget::~TrustChainWidget()
 {
 }
 
 void TrustChainWidget::setKey(const GpgME::Key &key)
 {
     if (key.protocol() != GpgME::CMS) {
         qCDebug(KLEOPATRA_LOG) << "Trust chain is only supported for CMS keys";
         return;
     }
 
     d->key = key;
     d->ui.treeWidget->clear();
     const auto chain = Kleo::KeyCache::instance()->findIssuers(key,
                             Kleo::KeyCache::RecursiveSearch | Kleo::KeyCache::IncludeSubject);
     if (chain.empty()) {
         return;
     }
     QTreeWidgetItem *last = nullptr;
     if (!chain.back().isRoot()) {
         last = new QTreeWidgetItem(d->ui.treeWidget);
         last->setText(0, i18n("Issuer Certificate Not Found (%1)",
                               Kleo::DN(chain.back().issuerName()).prettyDN()));
         const QBrush &fg = d->ui.treeWidget->palette().brush(QPalette::Disabled, QPalette::WindowText);
         last->setForeground(0, fg);
     }
     for (auto it = chain.rbegin(), end = chain.rend(); it != end; ++it) {
         last = last ? new QTreeWidgetItem(last) : new QTreeWidgetItem(d->ui.treeWidget);
         last->setText(0, Kleo::DN(it->userID(0).id()).prettyDN());
     }
     d->ui.treeWidget->expandAll();
 }
 
 GpgME::Key TrustChainWidget::key() const
 {
     return d->key;
 }
 
 
 
 TrustChainDialog::TrustChainDialog(QWidget *parent)
     : QDialog(parent)
 {
     resize(650, 330);
     setWindowTitle(i18nc("@title:window", "Trust Chain"));
 
     auto l = new QVBoxLayout(this);
     l->addWidget(new TrustChainWidget(this));
 
     auto bbox = new QDialogButtonBox(this);
     auto btn = bbox->addButton(QDialogButtonBox::Close);
     connect(btn, &QPushButton::pressed, this, &QDialog::accept);
     l->addWidget(bbox);
 }
 
 TrustChainDialog::~TrustChainDialog()
 {
 }
 
 void TrustChainDialog::setKey(const GpgME::Key &key)
 {
     auto w = findChild<TrustChainWidget*>();
     Q_ASSERT(w);
     w->setKey(key);
 }
 
 GpgME::Key TrustChainDialog::key() const
 {
     auto w = findChild<TrustChainWidget*>();
     Q_ASSERT(w);
     return w->key();
 }
 
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index a54a241e1..ad15589f5 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1,707 +1,707 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     mainwindow.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 <config-kleopatra.h>
 
 #include "mainwindow.h"
 #include "aboutdata.h"
 
 #include "view/padwidget.h"
 #include "view/searchbar.h"
 #include "view/tabwidget.h"
 #include "view/keylistcontroller.h"
 #include "view/keycacheoverlay.h"
 #include "view/smartcardwidget.h"
 #include "view/welcomewidget.h"
 
 #include "commands/selftestcommand.h"
 #include "commands/importcrlcommand.h"
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/signencryptfilescommand.h"
 
 #include "utils/detail_p.h"
 #include "utils/gnupg-helper.h"
 #include "utils/action_data.h"
 #include "utils/filedialog.h"
 #include "utils/clipboardmenu.h"
 
 #include "dialogs/updatenotification.h"
 
 #include <KXMLGUIFactory>
 #include <QApplication>
 #include <QLineEdit>
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KStandardAction>
 #include <QAction>
 #include <KAboutData>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include <KShortcutsDialog>
 #include <KEditToolBar>
 #include "kleopatra_debug.h"
 #include <KConfigGroup>
 
 #include <QAbstractItemView>
 #include <QCloseEvent>
 #include <QMenu>
 #include <QTimer>
 #include <QProcess>
 #include <QVBoxLayout>
 #include <QMimeData>
 #include <QDesktopServices>
 #include <QDir>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QLabel>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
-#include <libkleo/cryptoconfigdialog.h>
+#include <Libkleo/CryptoConfigDialog>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/Classify>
 #include <Libkleo/KeyCache>
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 
 #include <vector>
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 static KGuiItem KStandardGuiItem_quit()
 {
     static const QString app = KAboutData::applicationData().componentName();
     KGuiItem item = KStandardGuiItem::quit();
     item.setText(i18nc("Quit [ApplicationName]", "&Quit %1", app));
     return item;
 }
 
 static KGuiItem KStandardGuiItem_close()
 {
     KGuiItem item = KStandardGuiItem::close();
     item.setText(i18n("Only &Close Window"));
     return item;
 }
 
 static bool isQuitting = false;
 
 class MainWindow::Private
 {
     friend class ::MainWindow;
     MainWindow *const q;
 
 public:
     explicit Private(MainWindow *qq);
     ~Private();
 
     template <typename T>
     void createAndStart()
     {
         (new T(this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(QAbstractItemView *view)
     {
         (new T(view, &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a)
     {
         (new T(a, this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a, QAbstractItemView *view)
     {
         (new T(a, view, &this->controller))->start();
     }
 
     void closeAndQuit()
     {
         const QString app = KAboutData::applicationData().componentName();
         const int rc = KMessageBox::questionYesNoCancel(q,
                        i18n("%1 may be used by other applications as a service.\n"
                             "You may instead want to close this window without exiting %1.", app),
                        i18n("Really Quit?"), KStandardGuiItem_close(), KStandardGuiItem_quit(), KStandardGuiItem::cancel(),
                        QLatin1String("really-quit-") + app.toLower());
         if (rc == KMessageBox::Cancel) {
             return;
         }
         isQuitting = true;
         if (!q->close()) {
             return;
         }
         // WARNING: 'this' might be deleted at this point!
         if (rc == KMessageBox::No) {
             qApp->quit();
         }
     }
     void configureToolbars()
     {
         KEditToolBar dlg(q->factory());
         dlg.exec();
     }
     void editKeybindings()
     {
         KShortcutsDialog::configure(q->actionCollection(), KShortcutsEditor::LetterShortcutsAllowed);
         updateSearchBarClickMessage();
     }
 
     void updateSearchBarClickMessage()
     {
         const QString shortcutStr = focusToClickSearchAction->shortcut().toString();
         ui.searchBar->updateClickMessage(shortcutStr);
     }
 
     void updateStatusBar()
     {
         const auto complianceMode = Formatting::complianceMode();
         if (!complianceMode.isEmpty()) {
             auto statusBar = new QStatusBar;
             q->setStatusBar(statusBar);
             auto statusLbl = new QLabel(i18nc("Compliance means that GnuPG is running in a more restricted mode e.g. to handle restricted documents.",
                                         // The germans want some extra sausage
                                         "Compliance: %1", complianceMode == QLatin1String("de-vs") ? QStringLiteral ("VS-NfD") : complianceMode));
             statusBar->insertPermanentWidget(0, statusLbl);
 
         } else {
             q->setStatusBar(nullptr);
         }
     }
 
     void selfTest()
     {
         createAndStart<SelfTestCommand>();
     }
     void configureBackend();
 
     void showHandbook();
 
     void gnupgLogViewer()
     {
         if (!QProcess::startDetached(QStringLiteral("kwatchgnupg"), QStringList()))
             KMessageBox::error(q, i18n("Could not start the GnuPG Log Viewer (kwatchgnupg). "
                                        "Please check your installation."),
                                i18n("Error Starting KWatchGnuPG"));
     }
 
     void forceUpdateCheck()
     {
         UpdateNotification::forceUpdateCheck(q);
     }
 
     void openCompendium()
     {
         QDir datadir(QCoreApplication::applicationDirPath() + QStringLiteral("/../share/gpg4win"));
         const auto path = datadir.filePath(i18nc("The Gpg4win compendium is only available"
                                                  "at this point (24.7.2017) in german and english."
                                                  "Please check with Gpg4win before translating this filename.",
                                                  "gpg4win-compendium-en.pdf"));
         qCDebug(KLEOPATRA_LOG) << "Opening Compendium at:" << path;
         // The compendium is always installed. So this should work. Otherwise
         // we have debug output.
         QDesktopServices::openUrl(QUrl::fromLocalFile(path));
     }
 
     void slotConfigCommitted();
     void slotContextMenuRequested(QAbstractItemView *, const QPoint &p)
     {
         if (QMenu *const menu = qobject_cast<QMenu *>(q->factory()->container(QStringLiteral("listview_popup"), q))) {
             menu->exec(p);
         } else {
             qCDebug(KLEOPATRA_LOG) << "no \"listview_popup\" <Menu> in kleopatra's ui.rc file";
         }
     }
 
     void slotFocusQuickSearch()
     {
         ui.searchBar->lineEdit()->setFocus();
     }
 
     void toggleSmartcardView()
     {
         const auto coll = q->actionCollection();
         if (coll) {
             auto act = coll->action(QStringLiteral("pad_view"));
             if (act) {
                 act->setChecked(false);
             }
         }
         if (ui.stackWidget->currentWidget() == ui.scWidget) {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
             checkWelcomePage();
             return;
         }
         ui.stackWidget->setCurrentWidget(ui.scWidget);
     }
 
     void togglePadView()
     {
         const auto coll = q->actionCollection();
         if (coll) {
             auto act = coll->action(QStringLiteral("manage_smartcard"));
             if (act) {
                 act->setChecked(false);
             }
         }
         if (ui.stackWidget->currentWidget() == ui.padWidget) {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
             checkWelcomePage();
             return;
         }
         if (!ui.padWidget) {
             ui.padWidget = new PadWidget;
             ui.stackWidget->addWidget(ui.padWidget);
         }
         ui.stackWidget->setCurrentWidget(ui.padWidget);
         ui.stackWidget->resize(ui.padWidget->sizeHint());
     }
 
 private:
     void setupActions();
 
     QAbstractItemView *currentView() const
     {
         return ui.tabWidget.currentView();
     }
 
     void checkWelcomePage()
     {
         const auto curWidget = ui.stackWidget->currentWidget();
         if (curWidget == ui.scWidget || curWidget == ui.padWidget) {
            return;
         }
         if (KeyCache::instance()->keys().empty()) {
             ui.stackWidget->setCurrentWidget(ui.welcomeWidget);
         } else {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
         }
     }
 
 private:
     Kleo::KeyListController controller;
     bool firstShow : 1;
     struct UI {
         QWidget *searchTab;
         TabWidget tabWidget;
         SearchBar *searchBar;
         PadWidget *padWidget;
         SmartCardWidget *scWidget;
         WelcomeWidget *welcomeWidget;
         QStackedWidget *stackWidget;
         explicit UI(MainWindow *q);
     } ui;
     QAction *focusToClickSearchAction;
     ClipboardMenu *clipboadMenu;
 };
 
 MainWindow::Private::UI::UI(MainWindow *q)
     : tabWidget(q), padWidget(nullptr)
 {
     KDAB_SET_OBJECT_NAME(tabWidget);
 
     searchTab = new QWidget;
     QVBoxLayout *vbox = new QVBoxLayout(searchTab);
     vbox->setSpacing(0);
     searchBar = new SearchBar;
     vbox->addWidget(searchBar);
     tabWidget.connectSearchBar(searchBar);
     vbox->addWidget(&tabWidget);
 
     QWidget *mainWidget = new QWidget;
     auto mainLayout = new QVBoxLayout(mainWidget);
     stackWidget = new QStackedWidget;
 
     mainLayout->addWidget(stackWidget);
 
     stackWidget->addWidget(searchTab);
 
     new KeyCacheOverlay(mainWidget, q);
 
     scWidget = new SmartCardWidget();
     stackWidget->addWidget(scWidget);
 
     welcomeWidget = new WelcomeWidget();
     stackWidget->addWidget(welcomeWidget);
 
     q->setCentralWidget(mainWidget);
 }
 
 MainWindow::Private::Private(MainWindow *qq)
     : q(qq),
       controller(q),
       firstShow(true),
       ui(q)
 {
     KDAB_SET_OBJECT_NAME(controller);
 
     AbstractKeyListModel *flatModel = AbstractKeyListModel::createFlatKeyListModel(q);
     AbstractKeyListModel *hierarchicalModel = AbstractKeyListModel::createHierarchicalKeyListModel(q);
 
     KDAB_SET_OBJECT_NAME(flatModel);
     KDAB_SET_OBJECT_NAME(hierarchicalModel);
 
     controller.setFlatModel(flatModel);
     controller.setHierarchicalModel(hierarchicalModel);
     controller.setTabWidget(&ui.tabWidget);
 
     ui.tabWidget.setFlatModel(flatModel);
     ui.tabWidget.setHierarchicalModel(hierarchicalModel);
 
     ui.stackWidget->setCurrentWidget(ui.searchTab);
 
     setupActions();
 
     connect(&controller, SIGNAL(contextMenuRequested(QAbstractItemView*,QPoint)), q, SLOT(slotContextMenuRequested(QAbstractItemView*,QPoint)));
     connect(ui.scWidget, &SmartCardWidget::backRequested, q, [this]() {
             auto action = q->actionCollection()->action(QStringLiteral("manage_smartcard"));
             Q_ASSERT(action);
             action->setChecked(false);
         });
     connect(KeyCache::instance().get(), &KeyCache::keyListingDone, q, [this] () {checkWelcomePage();});
 
     q->createGUI(QStringLiteral("kleopatra.rc"));
 
     q->setAcceptDrops(true);
 
     q->setAutoSaveSettings();
     updateSearchBarClickMessage();
     updateStatusBar();
 }
 
 MainWindow::Private::~Private() {}
 
 MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags)
     : KXmlGuiWindow(parent, flags), d(new Private(this))
 {
     resize(1024, 500);
 }
 
 MainWindow::~MainWindow() {}
 
 void MainWindow::Private::setupActions()
 {
 
     KActionCollection *const coll = q->actionCollection();
 
     const action_data action_data[] = {
         // most have been MOVED TO keylistcontroller.cpp
         // Tools menu
 #ifndef Q_OS_WIN
         {
             "tools_start_kwatchgnupg", i18n("GnuPG Log Viewer"), QString(),
             "kwatchgnupg", q, SLOT(gnupgLogViewer()), QString(), false, true
         },
 #endif
 #ifdef Q_OS_WIN
         {
             "help_check_updates", i18n("Check for updates"), QString(),
             "gpg4win-compact", q, SLOT(forceUpdateCheck()), QString(), false, true
         },
         {
             "help_show_compendium", i18n("Gpg4win Compendium"), QString(),
             "gpg4win-compact", q, SLOT(openCompendium()), QString(), false, true
         },
 #endif
         {
             "pad_view", i18nc("Title for a generic data input / output area supporting text actions.", "Notepad"),
             i18n("Switch to Pad view."), "edittext", q, SLOT(togglePadView()), QString(), true, true
         },
         // most have been MOVED TO keylistcontroller.cpp
 #if 0
         {
             "configure_backend", i18n("Configure GnuPG Backend..."), QString(),
             0, q, SLOT(configureBackend()), QString(), false, true
         },
 #endif
         // Settings menu
         {
             "settings_self_test", i18n("Perform Self-Test"), QString(),
             nullptr, q, SLOT(selfTest()), QString(), false, true
         },
         {
             "manage_smartcard", i18n("Manage Smartcards"),
             i18n("Edit or initialize a crypto hardware token."), "secure-card", q, SLOT(toggleSmartcardView()), QString(), true, true
         }
 
         // most have been MOVED TO keylistcontroller.cpp
     };
 
     make_actions_from_data(action_data, /*sizeof action_data / sizeof *action_data,*/ coll);
 
     if (QAction *action = coll->action(QStringLiteral("configure_backend"))) {
         action->setMenuRole(QAction::NoRole);    //prevent Qt OS X heuristics for config* actions
     }
 
     KStandardAction::close(q, SLOT(close()), coll);
     KStandardAction::quit(q, SLOT(closeAndQuit()), coll);
     KStandardAction::configureToolbars(q, SLOT(configureToolbars()), coll);
     KStandardAction::keyBindings(q, SLOT(editKeybindings()), coll);
     KStandardAction::preferences(qApp, SLOT(openOrRaiseConfigDialog()), coll);
 
     focusToClickSearchAction = new QAction(i18n("Set Focus to Quick Search"), q);
     coll->addAction(QStringLiteral("focus_to_quickseach"), focusToClickSearchAction);
     coll->setDefaultShortcut(focusToClickSearchAction, QKeySequence(Qt::ALT + Qt::Key_Q));
     connect(focusToClickSearchAction, SIGNAL(triggered(bool)), q, SLOT(slotFocusQuickSearch()));
     clipboadMenu = new ClipboardMenu(q);
     clipboadMenu->setMainWindow(q);
     clipboadMenu->clipboardMenu()->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste")));
     clipboadMenu->clipboardMenu()->setDelayed(false);
     coll->addAction(QStringLiteral("clipboard_menu"), clipboadMenu->clipboardMenu());
 
     q->setStandardToolBarMenuEnabled(true);
 
     controller.createActions(coll);
 
     ui.tabWidget.createActions(coll);
 }
 
 void MainWindow::Private::configureBackend()
 {
     QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
     if (!config) {
         KMessageBox::error(q, i18n("Could not configure the cryptography backend (gpgconf tool not found)"), i18n("Configuration Error"));
         return;
     }
 
     Kleo::CryptoConfigDialog dlg(config);
 
     const int result = dlg.exec();
 
     // Forget all data parsed from gpgconf, so that we show updated information
     // when reopening the configuration dialog.
     config->clear();
 
     if (result == QDialog::Accepted) {
 #if 0
         // Tell other apps (e.g. kmail) that the gpgconf data might have changed
         QDBusMessage message =
             QDBusMessage::createSignal(QString(), "org.kde.kleo.CryptoConfig", "changed");
         QDBusConnection::sessionBus().send(message);
 #endif
     }
 }
 
 void MainWindow::Private::slotConfigCommitted()
 {
     controller.updateConfig();
     updateStatusBar();
 }
 
 void MainWindow::closeEvent(QCloseEvent *e)
 {
     // KMainWindow::closeEvent() insists on quitting the application,
     // so do not let it touch the event...
     qCDebug(KLEOPATRA_LOG);
     if (d->controller.hasRunningCommands()) {
         if (d->controller.shutdownWarningRequired()) {
             const int ret = KMessageBox::warningContinueCancel(this, i18n("There are still some background operations ongoing. "
                             "These will be terminated when closing the window. "
                             "Proceed?"),
                             i18n("Ongoing Background Tasks"));
             if (ret != KMessageBox::Continue) {
                 e->ignore();
                 return;
             }
         }
         d->controller.cancelCommands();
         if (d->controller.hasRunningCommands()) {
             // wait for them to be finished:
             setEnabled(false);
             QEventLoop ev;
             QTimer::singleShot(100, &ev, &QEventLoop::quit);
             connect(&d->controller, &KeyListController::commandsExecuting, &ev, &QEventLoop::quit);
             ev.exec();
             if (d->controller.hasRunningCommands())
                 qCWarning(KLEOPATRA_LOG)
                         << "controller still has commands running, this may crash now...";
             setEnabled(true);
         }
     }
     if (isQuitting || qApp->isSavingSession()) {
         d->ui.tabWidget.saveViews(KSharedConfig::openConfig().data());
         KConfigGroup grp(KConfigGroup(KSharedConfig::openConfig(), autoSaveGroup()));
         saveMainWindowSettings(grp);
         e->accept();
     } else {
         e->ignore();
         hide();
     }
 }
 
 void MainWindow::showEvent(QShowEvent *e)
 {
     KXmlGuiWindow::showEvent(e);
     if (d->firstShow) {
         d->ui.tabWidget.loadViews(KSharedConfig::openConfig().data());
         d->firstShow = false;
     }
 
     if (!savedGeometry.isEmpty()) {
         restoreGeometry(savedGeometry);
     }
 
 }
 
 void MainWindow::hideEvent(QHideEvent *e)
 {
     savedGeometry = saveGeometry();
     KXmlGuiWindow::hideEvent(e);
 }
 
 void MainWindow::importCertificatesFromFile(const QStringList &files)
 {
     if (!files.empty()) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     }
 }
 
 static QStringList extract_local_files(const QMimeData *data)
 {
     const QList<QUrl> urls = data->urls();
     // begin workaround KDE/Qt misinterpretation of text/uri-list
     QList<QUrl>::const_iterator end = urls.end();
     if (urls.size() > 1 && !urls.back().isValid()) {
         --end;
     }
     // end workaround
     QStringList result;
     std::transform(urls.begin(), end,
                    std::back_inserter(result),
                    std::mem_fn(&QUrl::toLocalFile));
     result.erase(std::remove_if(result.begin(), result.end(),
                                 std::mem_fn(&QString::isEmpty)), result.end());
     return result;
 }
 
 static bool can_decode_local_files(const QMimeData *data)
 {
     if (!data) {
         return false;
     }
     return !extract_local_files(data).empty();
 }
 
 void MainWindow::dragEnterEvent(QDragEnterEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (can_decode_local_files(e->mimeData())) {
         e->acceptProposedAction();
     }
 }
 
 void MainWindow::dropEvent(QDropEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (!can_decode_local_files(e->mimeData())) {
         return;
     }
 
     e->setDropAction(Qt::CopyAction);
 
     const QStringList files = extract_local_files(e->mimeData());
 
     const unsigned int classification = classify(files);
 
     QMenu menu;
 
     QAction *const signEncrypt = menu.addAction(i18n("Sign/Encrypt..."));
     QAction *const decryptVerify = mayBeAnyMessageType(classification) ? menu.addAction(i18n("Decrypt/Verify...")) : nullptr;
     if (signEncrypt || decryptVerify) {
         menu.addSeparator();
     }
 
     QAction *const importCerts = mayBeAnyCertStoreType(classification) ? menu.addAction(i18n("Import Certificates")) : nullptr;
     QAction *const importCRLs  = mayBeCertificateRevocationList(classification) ? menu.addAction(i18n("Import CRLs")) : nullptr;
     if (importCerts || importCRLs) {
         menu.addSeparator();
     }
 
     if (!signEncrypt && !decryptVerify && !importCerts && !importCRLs) {
         return;
     }
 
     menu.addAction(i18n("Cancel"));
 
     const QAction *const chosen = menu.exec(mapToGlobal(e->pos()));
 
     if (!chosen) {
         return;
     }
 
     if (chosen == signEncrypt) {
         d->createAndStart<SignEncryptFilesCommand>(files);
     } else if (chosen == decryptVerify) {
         d->createAndStart<DecryptVerifyFilesCommand>(files);
     } else if (chosen == importCerts) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     } else if (chosen == importCRLs) {
         d->createAndStart<ImportCrlCommand>(files);
     }
 
     e->accept();
 }
 
 void MainWindow::readProperties(const KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::readProperties(cg);
     savedGeometry = cg.readEntry("savedGeometry", QByteArray());
     if (!savedGeometry.isEmpty()) {
         restoreGeometry(savedGeometry);
     }
 
     if (! cg.readEntry<bool>("hidden", false)) {
         show();
     }
 }
 
 void MainWindow::saveProperties(KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::saveProperties(cg);
     cg.writeEntry("hidden", isHidden());
     if (isHidden()) {
         cg.writeEntry("savedGeometry", savedGeometry);
     } else {
         cg.writeEntry("savedGeometry", saveGeometry());
     }
 }
 
 #include "moc_mainwindow.cpp"
diff --git a/src/utils/kleo_assert.h b/src/utils/kleo_assert.h
index ea436c5ea..35c12bd04 100644
--- a/src/utils/kleo_assert.h
+++ b/src/utils/kleo_assert.h
@@ -1,97 +1,97 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/kleo_assert.h
 
     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.
 */
 
 #ifndef __KLEOPATRA_UTILS_KLEO_ASSERT_H__
 #define __KLEOPATRA_UTILS_KLEO_ASSERT_H__
 
-#include <libkleo/exception.h>
+#include <Libkleo/Exception>
 
 #include <assert.h>
 
 #define S(x) #x
 #define S_(x) S(x)
 #define S_LINE S_(__LINE__)
 
 #define kleo_assert_fail_impl( cond, file, line )                       \
     throw Kleo::Exception( gpg_error( GPG_ERR_INTERNAL ),               \
                            "assertion \"" #cond "\" failed at " file ":" line )
 #define kleo_assert_fail_impl_func( cond, file, line, func )            \
     throw Kleo::Exception( gpg_error( GPG_ERR_INTERNAL ),               \
                            std::string( "assertion \"" #cond "\" failed in " ) + func + " (" file ":" line ")" )
 
 #define kleo_assert_impl( cond, file, line )                  \
     if ( cond ) {}                                            \
     else kleo_assert_fail_impl( cond, file, line )
 #define kleo_assert_impl_func( cond, file, line, func )       \
     if ( cond ) {}                                            \
     else kleo_assert_fail_impl_func( cond, file, line, func )
 
 // from glibc's assert.h:
 /* Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__'
    which contains the name of the function currently being defined.
    This is broken in G++ before version 2.6.
    C9x has a similar variable called __func__, but prefer the GCC one since
    it demangles C++ function names.  */
 
 #if defined (__GNUC_PREREQ)
 # define KLEO_GNUC_PREREQ __GNUC_PREREQ
 #elif defined (__MINGW_GNUC_PREREQ)
 # define KLEO_GNUC_PREREQ __MINGW_GNUC_PREREQ
 #else
 # define KLEO_GNUC_PREREQ(maj, min) 0
 #endif
 
 #if KLEO_GNUC_PREREQ(2, 6)
 # define kleo_assert( cond ) kleo_assert_impl_func( cond, __FILE__, S_LINE, __PRETTY_FUNCTION__ )
 # define kleo_assert_fail( cond ) kleo_assert_fail_impl_func( cond, __FILE__, S_LINE, __PRETTY_FUNCTION__ )
 # define notImplemented() throw Exception( gpg_error( GPG_ERR_NOT_IMPLEMENTED ), __PRETTY_FUNCTION__ )
 #elif defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
 # define kleo_assert( cond ) kleo_assert_impl_func( cond, __FILE__, S_LINE, __func__ )
 # define kleo_assert_fail( cond ) kleo_assert_fail_impl_func( cond, __FILE__, S_LINE, __func__ )
 # define notImplemented() throw Exception( gpg_error( GPG_ERR_NOT_IMPLEMENTED ), __func__ )
 #endif
 
 #undef KLEO_GNUC_PREREQ
 
 #ifndef kleo_assert
 # define kleo_assert( cond ) kleo_assert_impl( cond, __FILE__, S_LINE )
 #endif
 
 #ifndef kleo_assert_fail
 # define kleo_assert_fail( cond ) kleo_assert_fail_impl( cond, __FILE__, S_LINE )
 #endif
 
 #ifndef notImplemented
 # define notImplemented() kleo_assert( !"Sorry, not yet implemented" )
 #endif
 
 #endif /* __KLEOPATRA_UTILS_KLEO_ASSERT_H__ */