diff --git a/src/conf/appearanceconfigpage.cpp b/src/conf/appearanceconfigpage.cpp
index 5284c246c..b44ce1735 100644
--- a/src/conf/appearanceconfigpage.cpp
+++ b/src/conf/appearanceconfigpage.cpp
@@ -1,83 +1,83 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/appearanceconfigpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2004,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 "appearanceconfigpage.h"
 
 #include "appearanceconfigwidget.h"
 
-#include <kmessagebox.h>
+#include <KMessageBox>
 
 #include <QVBoxLayout>
 
 using namespace Kleo;
 using namespace Kleo::Config;
 
 AppearanceConfigurationPage::AppearanceConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
     QVBoxLayout *lay = new QVBoxLayout(this);
     mWidget = new AppearanceConfigWidget(this);
     lay->addWidget(mWidget);
 
     connect(mWidget, &AppearanceConfigWidget::changed, this, &Kleo::Config::AppearanceConfigurationPage::markAsChanged);
 
     load();
 }
 
 void AppearanceConfigurationPage::load()
 {
     mWidget->load();
 }
 
 void AppearanceConfigurationPage::save()
 {
     mWidget->save();
 
 }
 
 void AppearanceConfigurationPage::defaults()
 {
     mWidget->defaults();
 }
 
 extern "C"
 {
     Q_DECL_EXPORT KCModule *create_kleopatra_config_appear(QWidget *parent = nullptr, const QVariantList &args = QVariantList())
     {
         AppearanceConfigurationPage *page =
             new AppearanceConfigurationPage(parent, args);
         page->setObjectName(QStringLiteral("kleopatra_config_appear"));
         return page;
     }
 }
 
diff --git a/src/conf/appearanceconfigpage.h b/src/conf/appearanceconfigpage.h
index f72d2e811..a4eec31de 100644
--- a/src/conf/appearanceconfigpage.h
+++ b/src/conf/appearanceconfigpage.h
@@ -1,64 +1,64 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/appearanceconfigpage.h
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2004,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_CONFIG_APPEARANCECONFIGPAGE_H
 #define KLEOPATRA_CONFIG_APPEARANCECONFIGPAGE_H
 
-#include <kcmodule.h>
+#include <KCModule>
 namespace Kleo
 {
 namespace Config
 {
 
 class AppearanceConfigWidget;
 
 /**
  * "Appearance" configuration page for kleopatra's configuration dialog
  */
 class AppearanceConfigurationPage : public KCModule
 {
     Q_OBJECT
 public:
     explicit AppearanceConfigurationPage(QWidget *parent = nullptr, const QVariantList &args = QVariantList());
 
     void load() override;
     void save() override;
     void defaults() override;
 
 private:
     AppearanceConfigWidget *mWidget;
 };
 
 }
 }
 
 #endif // KLEOPATRA_CONFIG_APPEARANCECONFIGPAGE_H
diff --git a/src/conf/appearanceconfigwidget.cpp b/src/conf/appearanceconfigwidget.cpp
index a2c5303f8..6440076a9 100644
--- a/src/conf/appearanceconfigwidget.cpp
+++ b/src/conf/appearanceconfigwidget.cpp
@@ -1,640 +1,640 @@
 /*
     appearanceconfigwidget.cpp
 
     This file is part of kleopatra, the KDE key manager
     Copyright (c) 2002,2004,2008 Klarälvdalens Datakonsult AB
     Copyright (c) 2002,2003 Marc Mutz <mutz@kde.org>
 
     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 <config-kleopatra.h>
 
 #include "appearanceconfigwidget.h"
 #include "ui_appearanceconfigwidget.h"
 
 #include "tooltippreferences.h"
 
 #include <QGpgME/Protocol>
 #include "Libkleo/KeyFilterManager"
 #include "Libkleo/Dn"
 #include "Libkleo/DNAttributeOrderConfigWidget"
 
-#include <kicondialog.h>
+#include <KIconDialog>
 #include <QIcon>
 
-#include <kconfig.h>
+#include <KConfig>
 #include <KLocalizedString>
-#include <kconfiggroup.h>
+#include <KConfigGroup>
 
 #include <QColor>
 #include <QFont>
 #include <QString>
 #include <QRegularExpression>
 #include <QApplication>
 #include <QColorDialog>
 #include <QFontDialog>
 
 #include <algorithm>
 
 using namespace Kleo;
 using namespace Kleo::Config;
 
 enum {
     HasNameRole = Qt::UserRole + 0x1234, /*!< Records that the user has assigned a name (to avoid comparing with i18n-strings) */
     HasFontRole,                         /*!< Records that the user has chosen  completely different font (as opposed to italic/bold/strikeout) */
     IconNameRole,                        /*!< Records the name of the icon (since QIcon won't give it out again, once set) */
     MayChangeNameRole,
     MayChangeForegroundRole,
     MayChangeBackgroundRole,
     MayChangeFontRole,
     MayChangeItalicRole,
     MayChangeBoldRole,
     MayChangeStrikeOutRole,
     MayChangeIconRole,
 
     EndDummy
 };
 
 static QFont tryToFindFontFor(const QListWidgetItem *item)
 {
     if (item)
         if (const QListWidget *const lw = item->listWidget()) {
             return lw->font();
         }
     return QApplication::font("QListWidget");
 }
 
 static bool is(const QListWidgetItem *item, bool (QFont::*func)() const)
 {
     if (!item) {
         return false;
     }
     const QVariant v = item->data(Qt::FontRole);
     if (!v.isValid() || v.type() != QVariant::Font) {
         return false;
     }
     return (v.value<QFont>().*func)();
 }
 
 static bool is_italic(const QListWidgetItem *item)
 {
     return is(item, &QFont::italic);
 }
 static bool is_bold(const QListWidgetItem *item)
 {
     return is(item, &QFont::bold);
 }
 static bool is_strikeout(const QListWidgetItem *item)
 {
     return is(item, &QFont::strikeOut);
 }
 
 static void set(QListWidgetItem *item, bool on, void (QFont::*func)(bool))
 {
     if (!item) {
         return;
     }
     const QVariant v = item->data(Qt::FontRole);
     QFont font = v.isValid() && v.type() == QVariant::Font ? v.value<QFont>() : tryToFindFontFor(item);
     (font.*func)(on);
     item->setData(Qt::FontRole, font);
 }
 
 static void set_italic(QListWidgetItem *item, bool on)
 {
     set(item, on, &QFont::setItalic);
 }
 static void set_bold(QListWidgetItem *item, bool on)
 {
     set(item, on, &QFont::setBold);
 }
 static void set_strikeout(QListWidgetItem *item, bool on)
 {
     set(item, on, &QFont::setStrikeOut);
 }
 
 static void apply_config(const KConfigGroup &group, QListWidgetItem *item)
 {
     if (!item) {
         return;
     }
 
     const QString name = group.readEntry("Name");
     item->setText(name.isEmpty() ? i18nc("Key filter without user-assigned name", "<unnamed>") : name);
     item->setData(HasNameRole, !name.isEmpty());
     item->setData(MayChangeNameRole, !group.isEntryImmutable("Name"));
 
     const QColor fg = group.readEntry("foreground-color", QColor());
     item->setData(Qt::ForegroundRole, fg.isValid() ? QBrush(fg) : QVariant());
     item->setData(MayChangeForegroundRole, !group.isEntryImmutable("foreground-color"));
 
     const QColor bg = group.readEntry("background-color", QColor());
     item->setData(Qt::BackgroundRole, bg.isValid() ? QBrush(bg) : QVariant());
     item->setData(MayChangeBackgroundRole, !group.isEntryImmutable("background-color"));
 
     const QFont defaultFont = tryToFindFontFor(item);
     if (group.hasKey("font")) {
         const QFont font = group.readEntry("font", defaultFont);
         item->setData(Qt::FontRole, font != defaultFont ? font : QVariant());
         item->setData(HasFontRole,  font != defaultFont);
     } else {
         QFont font = defaultFont;
         font.setStrikeOut(group.readEntry("font-strikeout", false));
         font.setItalic(group.readEntry("font-italic", false));
         font.setBold(group.readEntry("font-bold", false));
         item->setData(Qt::FontRole, font);
         item->setData(HasFontRole, false);
     }
     item->setData(MayChangeFontRole, !group.isEntryImmutable("font"));
     item->setData(MayChangeItalicRole, !group.isEntryImmutable("font-italic"));
     item->setData(MayChangeBoldRole, !group.isEntryImmutable("font-bold"));
     item->setData(MayChangeStrikeOutRole, !group.isEntryImmutable("font-strikeout"));
 
     const QString iconName = group.readEntry("icon");
     item->setData(Qt::DecorationRole, iconName.isEmpty() ? QVariant() : QIcon::fromTheme(iconName));
     item->setData(IconNameRole, iconName.isEmpty() ? QVariant() : iconName);
     item->setData(MayChangeIconRole, !group.isEntryImmutable("icon"));
 }
 
 static void erase_if_allowed(QListWidgetItem *item, int role, int allowRole)
 {
     if (item && item->data(allowRole).toBool()) {
         item->setData(role, QVariant());
     }
 }
 
 #if 0
 static void erase_if_allowed(QListWidgetItem *item, const int role[], size_t numRoles, int allowRole)
 {
     if (item && item->data(allowRole).toBool())
         for (unsigned int i = 0; i < numRoles; ++i) {
             item->setData(role[i], QVariant());
         }
 }
 
 static void erase_if_allowed(QListWidgetItem *item, int role, const int allowRole[], size_t numAllowRoles)
 {
     if (!item) {
         return;
     }
     for (unsigned int i = 0; i < numAllowRoles; ++i)
         if (!item->data(allowRole[i]).toBool()) {
             return;
         }
     item->setData(role, QVariant());
 }
 #endif
 
 static void erase_if_allowed(QListWidgetItem *item, const int role[], size_t numRoles, const int allowRole[], size_t numAllowRoles)
 {
     if (!item) {
         return;
     }
     for (unsigned int i = 0; i < numAllowRoles; ++i)
         if (!item->data(allowRole[i]).toBool()) {
             return;
         }
     for (unsigned int i = 0; i < numRoles; ++i) {
         item->setData(role[i], QVariant());
     }
 }
 
 static void set_default_appearance(QListWidgetItem *item)
 {
     if (!item) {
         return;
     }
     erase_if_allowed(item, Qt::ForegroundRole, MayChangeForegroundRole);
     erase_if_allowed(item, Qt::BackgroundRole, MayChangeBackgroundRole);
     erase_if_allowed(item, Qt::DecorationRole, MayChangeIconRole);
     static const int fontRoles[] = { Qt::FontRole, HasFontRole };
     static const int fontAllowRoles[] = {
         MayChangeFontRole,
         MayChangeItalicRole,
         MayChangeBoldRole,
         MayChangeStrikeOutRole,
     };
     erase_if_allowed(item, fontRoles, sizeof(fontRoles) / sizeof(int), fontAllowRoles, sizeof(fontAllowRoles) / sizeof(int));
 }
 
 static void writeOrDelete(KConfigGroup &group, const char *key, const QVariant &value)
 {
     if (value.isValid()) {
         group.writeEntry(key, value);
     } else {
         group.deleteEntry(key);
     }
 }
 
 static QVariant brush2color(const QVariant &v)
 {
     if (v.isValid()) {
         if (v.type() == QVariant::Color) {
             return v;
         } else if (v.type() == QVariant::Brush) {
             return v.value<QBrush>().color();
         }
     }
     return QVariant();
 }
 
 static void save_to_config(const QListWidgetItem *item, KConfigGroup &group)
 {
     if (!item) {
         return;
     }
     writeOrDelete(group, "Name", item->data(HasNameRole).toBool() ? item->text() : QVariant());
     writeOrDelete(group, "foreground-color", brush2color(item->data(Qt::ForegroundRole)));
     writeOrDelete(group, "background-color", brush2color(item->data(Qt::BackgroundRole)));
     writeOrDelete(group, "icon", item->data(IconNameRole));
 
     group.deleteEntry("font");
     group.deleteEntry("font-strikeout");
     group.deleteEntry("font-italic");
     group.deleteEntry("font-bold");
 
     if (item->data(HasFontRole).toBool()) {
         writeOrDelete(group, "font", item->data(Qt::FontRole));
         return;
     }
 
     if (is_strikeout(item)) {
         group.writeEntry("font-strikeout", true);
     }
     if (is_italic(item)) {
         group.writeEntry("font-italic", true);
     }
     if (is_bold(item)) {
         group.writeEntry("font-bold", true);
     }
 }
 
 static void kiosk_enable(QWidget *w, const QListWidgetItem *item, int allowRole)
 {
     if (!w) {
         return;
     }
     if (item && !item->data(allowRole).toBool()) {
         w->setEnabled(false);
         w->setToolTip(i18n("This parameter has been locked down by the system administrator."));
     } else {
         w->setEnabled(item);
         w->setToolTip(QString());
     }
 }
 
 class AppearanceConfigWidget::Private : public Ui_AppearanceConfigWidget
 {
     friend class ::Kleo::Config::AppearanceConfigWidget;
     AppearanceConfigWidget *const q;
 public:
     explicit Private(AppearanceConfigWidget *qq)
         : Ui_AppearanceConfigWidget(),
           q(qq),
           dnOrderWidget(nullptr)
     {
         setupUi(q);
 
         if (QLayout *const l = q->layout()) {
             l->setContentsMargins(0, 0, 0, 0);
         }
 
         QWidget *w = new QWidget;
         dnOrderWidget = Kleo::DNAttributeMapper::instance()->configWidget(w);
         dnOrderWidget->setObjectName(QStringLiteral("dnOrderWidget"));
         (new QVBoxLayout(w))->addWidget(dnOrderWidget);
 
         tabWidget->addTab(w, i18n("DN-Attribute Order"));
 
         connect(dnOrderWidget, &DNAttributeOrderConfigWidget::changed, q, &AppearanceConfigWidget::changed);
 
         connect(iconButton, SIGNAL(clicked()), q, SLOT(slotIconClicked()));
 #ifndef QT_NO_COLORDIALOG
         connect(foregroundButton, SIGNAL(clicked()), q, SLOT(slotForegroundClicked()));
         connect(backgroundButton, SIGNAL(clicked()), q, SLOT(slotBackgroundClicked()));
 #else
         foregroundButton->hide();
         backgroundButton->hide();
 #endif
 #ifndef QT_NO_FONTDIALOG
         connect(fontButton, SIGNAL(clicked()), q, SLOT(slotFontClicked()));
 #else
         fontButton->hide();
 #endif
         connect(categoriesLV, SIGNAL(itemSelectionChanged()), q, SLOT(slotSelectionChanged()));
         connect(defaultLookPB, SIGNAL(clicked()), q, SLOT(slotDefaultClicked()));
         connect(italicCB, SIGNAL(toggled(bool)), q, SLOT(slotItalicToggled(bool)));
         connect(boldCB, SIGNAL(toggled(bool)), q, SLOT(slotBoldToggled(bool)));
         connect(strikeoutCB, SIGNAL(toggled(bool)), q, SLOT(slotStrikeOutToggled(bool)));
         connect(tooltipValidityCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipValidityChanged(bool)));
         connect(tooltipOwnerCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipOwnerChanged(bool)));
         connect(tooltipDetailsCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipDetailsChanged(bool)));
     }
 
 private:
     void enableDisableActions(QListWidgetItem *item);
     QListWidgetItem *selectedItem() const;
 
 private:
     void slotIconClicked();
 #ifndef QT_NO_COLORDIALOG
     void slotForegroundClicked();
     void slotBackgroundClicked();
 #endif
 #ifndef QT_NO_FONTDIALOG
     void slotFontClicked();
 #endif
     void slotSelectionChanged();
     void slotDefaultClicked();
     void slotItalicToggled(bool);
     void slotBoldToggled(bool);
     void slotStrikeOutToggled(bool);
     void slotTooltipValidityChanged(bool);
     void slotTooltipOwnerChanged(bool);
     void slotTooltipDetailsChanged(bool);
 
 private:
     Kleo::DNAttributeOrderConfigWidget *dnOrderWidget;
 };
 
 AppearanceConfigWidget::AppearanceConfigWidget(QWidget *p, Qt::WindowFlags f)
     : QWidget(p, f), d(new Private(this))
 {
 //    load();
 }
 
 AppearanceConfigWidget::~AppearanceConfigWidget() {}
 
 void AppearanceConfigWidget::Private::slotSelectionChanged()
 {
     enableDisableActions(selectedItem());
 }
 
 QListWidgetItem *AppearanceConfigWidget::Private::selectedItem() const
 {
     const QList<QListWidgetItem *> items = categoriesLV->selectedItems();
     return items.empty() ? nullptr : items.front();
 }
 
 void AppearanceConfigWidget::Private::enableDisableActions(QListWidgetItem *item)
 {
     kiosk_enable(iconButton, item, MayChangeIconRole);
 #ifndef QT_NO_COLORDIALOG
     kiosk_enable(foregroundButton, item, MayChangeForegroundRole);
     kiosk_enable(backgroundButton, item, MayChangeBackgroundRole);
 #endif
 #ifndef QT_NO_FONTDIALOG
     kiosk_enable(fontButton, item, MayChangeFontRole);
 #endif
     kiosk_enable(italicCB, item, MayChangeItalicRole);
     kiosk_enable(boldCB, item, MayChangeBoldRole);
     kiosk_enable(strikeoutCB, item, MayChangeStrikeOutRole);
 
     defaultLookPB->setEnabled(item);
 
     italicCB->setChecked(is_italic(item));
     boldCB->setChecked(is_bold(item));
     strikeoutCB->setChecked(is_strikeout(item));
 }
 
 void AppearanceConfigWidget::Private::slotDefaultClicked()
 {
 
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     set_default_appearance(item);
     enableDisableActions(item);
 
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::defaults()
 {
 
     // This simply means "default look for every category"
     for (int i = 0, end = d->categoriesLV->count(); i != end; ++i) {
         set_default_appearance(d->categoriesLV->item(i));
     }
     d->tooltipValidityCheckBox->setChecked(true);
     d->tooltipOwnerCheckBox->setChecked(false);
     d->tooltipDetailsCheckBox->setChecked(false);
 
     d->dnOrderWidget->defaults();
 
     Q_EMIT changed();
 }
 
 void AppearanceConfigWidget::load()
 {
 
     d->dnOrderWidget->load();
 
     d->categoriesLV->clear();
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("libkleopatrarc"));
     if (!config) {
         return;
     }
     const QStringList groups = config->groupList().filter(QRegularExpression(QStringLiteral("^Key Filter #\\d+$")));
     for (const QString &group : groups) {
         //QListWidgetItem * item = new QListWidgetItem( d->categoriesLV );
         apply_config(KConfigGroup(config, group), new QListWidgetItem(d->categoriesLV));
     }
 
     const TooltipPreferences prefs;
     d->tooltipValidityCheckBox->setChecked(prefs.showValidity());
     d->tooltipOwnerCheckBox->setChecked(prefs.showOwnerInformation());
     d->tooltipDetailsCheckBox->setChecked(prefs.showCertificateDetails());
 }
 
 void AppearanceConfigWidget::save()
 {
 
     d->dnOrderWidget->save();
 
     TooltipPreferences prefs;
     prefs.setShowValidity(d->tooltipValidityCheckBox->isChecked());
     prefs.setShowOwnerInformation(d->tooltipOwnerCheckBox->isChecked());
     prefs.setShowCertificateDetails(d->tooltipDetailsCheckBox->isChecked());
     prefs.save();
 
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("libkleopatrarc"));
     if (!config) {
         return;
     }
     // We know (assume) that the groups in the config object haven't changed,
     // so we just iterate over them and over the listviewitems, and map one-to-one.
     const QStringList groups = config->groupList().filter(QRegularExpression(QStringLiteral("^Key Filter #\\d+$")));
 #if 0
     if (groups.isEmpty()) {
         // If we created the default categories ourselves just now, then we need to make up their list
         Q3ListViewItemIterator lvit(categoriesLV);
         for (; lvit.current(); ++lvit) {
             groups << lvit.current()->text(0);
         }
     }
 #endif
     for (int i = 0, end = std::min(groups.size(), d->categoriesLV->count()); i != end; ++i) {
         const QListWidgetItem *const item = d->categoriesLV->item(i);
         Q_ASSERT(item);
         KConfigGroup group(config, groups[i]);
         save_to_config(item, group);
     }
 
     config->sync();
     KeyFilterManager::instance()->reload();
 }
 
 void AppearanceConfigWidget::Private::slotIconClicked()
 {
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     const QString iconName = KIconDialog::getIcon( /* repeating default arguments begin */
                                  KIconLoader::Desktop, KIconLoader::Application, false, 0, false,
                                  /* repeating default arguments end */
                                  q);
     if (iconName.isEmpty()) {
         return;
     }
 
     item->setIcon(QIcon::fromTheme(iconName));
     item->setData(IconNameRole, iconName);
     Q_EMIT q->changed();
 }
 
 #ifndef QT_NO_COLORDIALOG
 void AppearanceConfigWidget::Private::slotForegroundClicked()
 {
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     const QVariant v = brush2color(item->data(Qt::ForegroundRole));
 
     const QColor initial = v.isValid() ? v.value<QColor>() : categoriesLV->palette().color(QPalette::Normal, QPalette::Text);
     const QColor c = QColorDialog::getColor(initial, q);
 
     if (c.isValid()) {
         item->setData(Qt::ForegroundRole, QBrush(c));
         Q_EMIT q->changed();
     }
 }
 
 void AppearanceConfigWidget::Private::slotBackgroundClicked()
 {
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     const QVariant v = brush2color(item->data(Qt::BackgroundRole));
 
     const QColor initial = v.isValid() ? v.value<QColor>() : categoriesLV->palette().color(QPalette::Normal, QPalette::Base);
     const QColor c = QColorDialog::getColor(initial, q);
 
     if (c.isValid()) {
         item->setData(Qt::BackgroundRole, QBrush(c));
         Q_EMIT q->changed();
     }
 }
 #endif // QT_NO_COLORDIALOG
 
 #ifndef QT_NO_FONTDIALOG
 void AppearanceConfigWidget::Private::slotFontClicked()
 {
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     const QVariant v = item->data(Qt::FontRole);
 
     bool ok = false;
     const QFont defaultFont = tryToFindFontFor(item);
     const QFont initial = v.isValid() && v.type() == QVariant::Font ? v.value<QFont>() : defaultFont;
     QFont f = QFontDialog::getFont(&ok, initial, q);
     if (!ok) {
         return;
     }
 
     // disallow circumventing KIOSK:
     if (!item->data(MayChangeItalicRole).toBool()) {
         f.setItalic(initial.italic());
     }
     if (!item->data(MayChangeBoldRole).toBool()) {
         f.setBold(initial.bold());
     }
     if (!item->data(MayChangeStrikeOutRole).toBool()) {
         f.setStrikeOut(initial.strikeOut());
     }
 
     item->setData(Qt::FontRole, f != defaultFont ? f : QVariant());
     item->setData(HasFontRole, true);
     Q_EMIT q->changed();
 }
 #endif // QT_NO_FONTDIALOG
 
 void AppearanceConfigWidget::Private::slotItalicToggled(bool on)
 {
     set_italic(selectedItem(), on);
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotBoldToggled(bool on)
 {
     set_bold(selectedItem(), on);
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotStrikeOutToggled(bool on)
 {
     set_strikeout(selectedItem(), on);
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotTooltipValidityChanged(bool)
 {
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotTooltipOwnerChanged(bool)
 {
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotTooltipDetailsChanged(bool)
 {
     Q_EMIT q->changed();
 }
 
 #include "moc_appearanceconfigwidget.cpp"
diff --git a/src/conf/cryptooperationsconfigpage.h b/src/conf/cryptooperationsconfigpage.h
index 937d5c34f..c3686e7ca 100644
--- a/src/conf/cryptooperationsconfigpage.h
+++ b/src/conf/cryptooperationsconfigpage.h
@@ -1,64 +1,64 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/cryptooperationsconfigpage.h
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2010 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_CONFIG_CRYPTOOPERATIONSCONFIGPAGE_H
 #define KLEOPATRA_CONFIG_CRYPTOOPERATIONSCONFIGPAGE_H
 
-#include <kcmodule.h>
+#include <KCModule>
 namespace Kleo
 {
 namespace Config
 {
 
 class CryptoOperationsConfigWidget;
 
 /**
  * "Crypto Operations" configuration page for kleopatra's configuration dialog
  */
 class CryptoOperationsConfigurationPage : public KCModule
 {
     Q_OBJECT
 public:
     explicit CryptoOperationsConfigurationPage(QWidget *parent = nullptr, const QVariantList &args = QVariantList());
 
     void load() override;
     void save() override;
     void defaults() override;
 
 private:
     CryptoOperationsConfigWidget *mWidget;
 };
 
 }
 }
 
 #endif // KLEOPATRA_CONFIG_CRYPTOOPERATIONSCONFIGPAGE_H
diff --git a/src/conf/dirservconfigpage.cpp b/src/conf/dirservconfigpage.cpp
index 51cad75c6..1873cdbff 100644
--- a/src/conf/dirservconfigpage.cpp
+++ b/src/conf/dirservconfigpage.cpp
@@ -1,392 +1,392 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/dirservconfigpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2004,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 "dirservconfigpage.h"
 #include <Libkleo/DirectoryServicesWidget>
 #include <Libkleo/CryptoConfigModule>
 
 #include <QGpgME/Protocol>
 
-#include <kmessagebox.h>
+#include <KMessageBox>
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
-#include <kconfig.h>
+#include <KConfig>
 #include <QSpinBox>
 
 #include <QLabel>
 #include <QDateTimeEdit>
 #include <QCheckBox>
 #include <QLayout>
 
 using namespace Kleo;
 
 #if 0 // disabled, since it is apparently confusing
 // For sync'ing kabldaprc
 class KABSynchronizer
 {
 public:
     KABSynchronizer()
         : mConfig("kabldaprc")
     {
         mConfig.setGroup("LDAP");
     }
 
     KUrl::List readCurrentList() const
     {
 
         KUrl::List lst;
         // stolen from kabc/ldapclient.cpp
         const uint numHosts = mConfig.readEntry("NumSelectedHosts");
         for (uint j = 0; j < numHosts; j++) {
             const QString num = QString::number(j);
 
             KUrl url;
             url.setProtocol("ldap");
             url.setPath("/");   // workaround KUrl parsing bug
             const QString host = mConfig.readEntry(QString("SelectedHost") + num).trimmed();
             url.setHost(host);
 
             const int port = mConfig.readEntry(QString("SelectedPort") + num);
             if (port != 0) {
                 url.setPort(port);
             }
 
             const QString base = mConfig.readEntry(QString("SelectedBase") + num).trimmed();
             url.setQuery(base);
 
             const QString bindDN = mConfig.readEntry(QString("SelectedBind") + num).trimmed();
             url.setUser(bindDN);
 
             const QString pwdBindDN = mConfig.readEntry(QString("SelectedPwdBind") + num).trimmed();
             url.setPass(pwdBindDN);
             lst.append(url);
         }
         return lst;
     }
 
     void writeList(const KUrl::List &lst)
     {
 
         mConfig.writeEntry("NumSelectedHosts", lst.count());
 
         KUrl::List::const_iterator it = lst.begin();
         KUrl::List::const_iterator end = lst.end();
         unsigned j = 0;
         for (; it != end; ++it, ++j) {
             const QString num = QString::number(j);
             KUrl url = *it;
 
             Q_ASSERT(url.scheme() == "ldap");
             mConfig.writeEntry(QString("SelectedHost") + num, url.host());
             mConfig.writeEntry(QString("SelectedPort") + num, url.port());
 
             // KUrl automatically encoded the query (e.g. for spaces inside it),
             // so decode it before writing it out
             const QString base = KUrl::decode_string(url.query().mid(1));
             mConfig.writeEntry(QString("SelectedBase") + num, base);
             mConfig.writeEntry(QString("SelectedBind") + num, url.user());
             mConfig.writeEntry(QString("SelectedPwdBind") + num, url.pass());
         }
         mConfig.sync();
     }
 
 private:
     KConfig mConfig;
 };
 
 #endif
 
 static const char s_x509services_componentName[] = "dirmngr";
 static const char s_x509services_groupName[] = "LDAP";
 static const char s_x509services_entryName[] = "LDAP Server";
 
 static const char s_x509services_new_componentName[] = "gpgsm";
 static const char s_x509services_new_groupName[] = "Configuration";
 static const char s_x509services_new_entryName[] = "keyserver";
 
 static const char s_pgpservice_componentName[] = "gpg";
 static const char s_pgpservice_groupName[] = "Keyserver";
 static const char s_pgpservice_entryName[] = "keyserver";
 
 static const char s_timeout_componentName[] = "dirmngr";
 static const char s_timeout_groupName[] = "LDAP";
 static const char s_timeout_entryName[] = "ldaptimeout";
 
 static const char s_maxitems_componentName[] = "dirmngr";
 static const char s_maxitems_groupName[] = "LDAP";
 static const char s_maxitems_entryName[] = "max-replies";
 
 #ifdef NOT_USEFUL_CURRENTLY
 static const char s_addnewservers_componentName[] = "dirmngr";
 static const char s_addnewservers_groupName[] = "LDAP";
 static const char s_addnewservers_entryName[] = "add-servers";
 #endif
 
 DirectoryServicesConfigurationPage::DirectoryServicesConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
     mConfig = QGpgME::cryptoConfig();
     QGridLayout *glay = new QGridLayout(this);
     glay->setContentsMargins(0, 0, 0, 0);
 
     int row = 0;
     mWidget = new Kleo::DirectoryServicesWidget(this);
     if (QLayout *l = mWidget->layout()) {
         l->setContentsMargins(0, 0, 0, 0);
     }
     glay->addWidget(mWidget, row, 0, 1, 3);
     connect(mWidget, SIGNAL(changed()), this, SLOT(changed()));
 
     // LDAP timeout
     ++row;
     QLabel *label = new QLabel(i18n("LDAP &timeout (minutes:seconds):"), this);
     mTimeout = new QTimeEdit(this);
     mTimeout->setDisplayFormat(QStringLiteral("mm:ss"));
     connect(mTimeout, SIGNAL(timeChanged(QTime)), this, SLOT(changed()));
     label->setBuddy(mTimeout);
     glay->addWidget(label, row, 0);
     glay->addWidget(mTimeout, row, 1);
 
     // Max number of items returned by queries
     ++row;
     mMaxItemsLabel = new QLabel(i18n("&Maximum number of items returned by query:"), this);
     mMaxItems = new QSpinBox(this);
     mMaxItems->setMinimum(0);
     mMaxItemsLabel->setBuddy(mMaxItems);
     connect(mMaxItems, SIGNAL(valueChanged(int)), this, SLOT(changed()));
     glay->addWidget(mMaxItemsLabel, row, 0);
     glay->addWidget(mMaxItems, row, 1);
 
 #ifdef NOT_USEFUL_CURRENTLY
     ++row
     mAddNewServersCB = new QCheckBox(i18n("Automatically add &new servers discovered in CRL distribution points"), this);
     connect(mAddNewServersCB, SIGNAL(clicked()), this, SLOT(changed()));
     glay->addWidget(mAddNewServersCB, row, 0, 1, 3);
 #endif
 
     glay->setRowStretch(++row, 1);
     glay->setColumnStretch(2, 1);
 
     load();
 }
 
 static QList<QUrl> string2urls(const QString &str)
 {
     QList<QUrl> ret;
     if (str.isEmpty()) {
         return ret;
     }
     ret << QUrl::fromEncoded(str.toLocal8Bit());
     return ret;
 }
 
 void DirectoryServicesConfigurationPage::load()
 {
 
     mWidget->clear();
 
     // gpgsm/Configuration/keyserver is not provided by older gpgconf versions;
     if ((mX509ServicesEntry = configEntry(s_x509services_new_componentName, s_x509services_new_groupName, s_x509services_new_entryName,
                                           QGpgME::CryptoConfigEntry::ArgType_LDAPURL, /*isList=*/true, /*showError=*/false))) {
         mWidget->addX509Services(mX509ServicesEntry->urlValueList());
     } else if ((mX509ServicesEntry = configEntry(s_x509services_componentName, s_x509services_groupName, s_x509services_entryName,
                                      QGpgME::CryptoConfigEntry::ArgType_LDAPURL, true))) {
         mWidget->addX509Services(mX509ServicesEntry->urlValueList());
     }
 
     mWidget->setX509ReadOnly(mX509ServicesEntry && mX509ServicesEntry->isReadOnly());
 
     mOpenPGPServiceEntry = configEntry(s_pgpservice_componentName, s_pgpservice_groupName, s_pgpservice_entryName,
                                        QGpgME::CryptoConfigEntry::ArgType_String, false);
     if (mOpenPGPServiceEntry) {
         mWidget->addOpenPGPServices(string2urls(parseKeyserver(mOpenPGPServiceEntry->stringValue()).url));
     }
 
     mWidget->setOpenPGPReadOnly(mOpenPGPServiceEntry && mOpenPGPServiceEntry->isReadOnly());
 
     if (mX509ServicesEntry)
         if (mOpenPGPServiceEntry) {
             mWidget->setAllowedProtocols(DirectoryServicesWidget::AllProtocols);
         } else {
             mWidget->setAllowedProtocols(DirectoryServicesWidget::X509Protocol);
         }
     else if (mOpenPGPServiceEntry) {
         mWidget->setAllowedProtocols(DirectoryServicesWidget::OpenPGPProtocol);
     } else {
         mWidget->setDisabled(true);
     }
 
     DirectoryServicesWidget::Protocols readOnlyProtocols;
     if (mX509ServicesEntry && mX509ServicesEntry->isReadOnly()) {
         readOnlyProtocols = DirectoryServicesWidget::X509Protocol;
     }
 
     mTimeoutConfigEntry = configEntry(s_timeout_componentName, s_timeout_groupName, s_timeout_entryName, QGpgME::CryptoConfigEntry::ArgType_UInt, false);
     if (mTimeoutConfigEntry) {
         QTime time = QTime(0, 0, 0, 0).addSecs(mTimeoutConfigEntry->uintValue());
         //qCDebug(KLEOPATRA_LOG) <<"timeout:" << mTimeoutConfigEntry->uintValue() <<"  ->" << time;
         mTimeout->setTime(time);
     }
 
     mMaxItemsConfigEntry = configEntry(s_maxitems_componentName, s_maxitems_groupName, s_maxitems_entryName, QGpgME::CryptoConfigEntry::ArgType_UInt, false);
     if (mMaxItemsConfigEntry) {
         mMaxItems->blockSignals(true);   // KNumInput emits valueChanged from setValue!
         mMaxItems->setValue(mMaxItemsConfigEntry->uintValue());
         mMaxItems->blockSignals(false);
     }
     const bool maxItemsEnabled = mMaxItemsConfigEntry && !mMaxItemsConfigEntry->isReadOnly();
     mMaxItems->setEnabled(maxItemsEnabled);
     mMaxItemsLabel->setEnabled(maxItemsEnabled);
 
 #ifdef NOT_USEFUL_CURRENTLY
     mAddNewServersConfigEntry = configEntry(s_addnewservers_componentName, s_addnewservers_groupName, s_addnewservers_entryName, QGpgME::CryptoConfigEntry::ArgType_None, false);
     if (mAddNewServersConfigEntry) {
         mAddNewServersCB->setChecked(mAddNewServersConfigEntry->boolValue());
     }
 #endif
 }
 
 void DirectoryServicesConfigurationPage::save()
 {
     if (mX509ServicesEntry) {
         mX509ServicesEntry->setURLValueList(mWidget->x509Services());
     }
 
     if (mOpenPGPServiceEntry) {
         const QList<QUrl> serv = mWidget->openPGPServices();
         if (serv.empty()) {
             mOpenPGPServiceEntry->setStringValue(QString());
         } else {
             ParsedKeyserver pks = parseKeyserver(mOpenPGPServiceEntry->stringValue());
             pks.url = serv.front().url();
             mOpenPGPServiceEntry->setStringValue(assembleKeyserver(pks));
         }
     }
 
     QTime time(mTimeout->time());
     unsigned int timeout = time.minute() * 60 + time.second();
     if (mTimeoutConfigEntry && mTimeoutConfigEntry->uintValue() != timeout) {
         mTimeoutConfigEntry->setUIntValue(timeout);
     }
     if (mMaxItemsConfigEntry && mMaxItemsConfigEntry->uintValue() != (uint)mMaxItems->value()) {
         mMaxItemsConfigEntry->setUIntValue(mMaxItems->value());
     }
 #ifdef NOT_USEFUL_CURRENTLY
     if (mAddNewServersConfigEntry && mAddNewServersConfigEntry->boolValue() != mAddNewServersCB->isChecked()) {
         mAddNewServersConfigEntry->setBoolValue(mAddNewServersCB->isChecked());
     }
 #endif
 
     mConfig->sync(true);
 
 #if 0
     // Also write the LDAP URLs to kabldaprc so that they are used by kaddressbook
     KABSynchronizer sync;
     const KUrl::List toAdd = mWidget->urlList();
     KUrl::List currentList = sync.readCurrentList();
 
     KUrl::List::const_iterator it = toAdd.begin();
     KUrl::List::const_iterator end = toAdd.end();
     for (; it != end; ++it) {
         // check if the URL is already in currentList
         if (currentList.find(*it) == currentList.end())
             // if not, add it
         {
             currentList.append(*it);
         }
     }
     sync.writeList(currentList);
 #endif
 }
 
 void DirectoryServicesConfigurationPage::defaults()
 {
     // these guys don't have a default, to clear them:
     if (mX509ServicesEntry) {
         mX509ServicesEntry->setURLValueList(QList<QUrl>());
     }
     if (mOpenPGPServiceEntry) {
         mOpenPGPServiceEntry->setStringValue(QString());
     }
     // these presumably have a default, use that one:
     if (mTimeoutConfigEntry) {
         mTimeoutConfigEntry->resetToDefault();
     }
     if (mMaxItemsConfigEntry) {
         mMaxItemsConfigEntry->resetToDefault();
     }
 #ifdef NOT_USEFUL_CURRENTLY
     if (mAddNewServersConfigEntry) {
         mAddNewServersConfigEntry->resetToDefault();
     }
 #endif
     load();
 }
 
 extern "C"
 {
     Q_DECL_EXPORT KCModule *create_kleopatra_config_dirserv(QWidget *parent = nullptr, const QVariantList &args = QVariantList())
     {
         DirectoryServicesConfigurationPage *page =
             new DirectoryServicesConfigurationPage(parent, args);
         page->setObjectName(QStringLiteral("kleopatra_config_dirserv"));
         return page;
     }
 }
 
 // Find config entry for ldap servers. Implements runtime checks on the configuration option.
 QGpgME::CryptoConfigEntry *DirectoryServicesConfigurationPage::configEntry(const char *componentName,
         const char *groupName,
         const char *entryName,
         QGpgME::CryptoConfigEntry::ArgType argType,
         bool isList,
         bool showError)
 {
     QGpgME::CryptoConfigEntry *entry = mConfig->entry(QLatin1String(componentName), QLatin1String(groupName), QLatin1String(entryName));
 
     if (!entry) {
         if (showError) {
             KMessageBox::error(this, i18n("Backend error: gpgconf does not seem to know the entry for %1/%2/%3", QLatin1String(componentName), QLatin1String(groupName), QLatin1String(entryName)));
         }
         return nullptr;
     }
     if (entry->argType() != argType || entry->isList() != isList) {
         if (showError) {
             KMessageBox::error(this, i18n("Backend error: gpgconf has wrong type for %1/%2/%3: %4 %5", QLatin1String(componentName), QLatin1String(groupName), QLatin1String(entryName), entry->argType(), entry->isList()));
         }
         return nullptr;
     }
     return entry;
 }
 
diff --git a/src/conf/gnupgsystemconfigurationpage.h b/src/conf/gnupgsystemconfigurationpage.h
index 501d9f441..97b6b76b8 100644
--- a/src/conf/gnupgsystemconfigurationpage.h
+++ b/src/conf/gnupgsystemconfigurationpage.h
@@ -1,64 +1,64 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/gnupgsystemconfigurationpage.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_GNUPGSYSTEMCONFIGURATIONPAGE_H
 #define KLEOPATRA_GNUPGSYSTEMCONFIGURATIONPAGE_H
 
-#include <kcmodule.h>
+#include <KCModule>
 namespace Kleo
 {
 class CryptoConfigModule;
 }
 
 namespace Kleo
 {
 namespace Config
 {
 
 class GnuPGSystemConfigurationPage : public KCModule
 {
     Q_OBJECT
 public:
     explicit GnuPGSystemConfigurationPage(QWidget *parent = nullptr, const QVariantList &args = QVariantList());
     ~GnuPGSystemConfigurationPage() override;
 
     void load() override;
     void save() override;
     void defaults() override;
 
 private:
     Kleo::CryptoConfigModule *mWidget;
 };
 
 }
 }
 
 #endif // KLEOPATRA_GNUPGSYSTEMCONFIGURATIONPAGE_H
diff --git a/src/conf/smimevalidationconfigurationpage.cpp b/src/conf/smimevalidationconfigurationpage.cpp
index 5476b1b32..8794956ae 100644
--- a/src/conf/smimevalidationconfigurationpage.cpp
+++ b/src/conf/smimevalidationconfigurationpage.cpp
@@ -1,78 +1,78 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/smimevalidationconfigurationpage.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 "smimevalidationconfigurationpage.h"
 #include "smimevalidationconfigurationwidget.h"
 
 #include <QVBoxLayout>
-#include <kmessagebox.h>
+#include <KMessageBox>
 
 using namespace Kleo::Config;
 
 SMimeValidationConfigurationPage::SMimeValidationConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
     QVBoxLayout *lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
 
     mWidget = new SMimeValidationConfigurationWidget(this);
     lay->addWidget(mWidget);
 
     connect(mWidget, &SMimeValidationConfigurationWidget::changed, this, &Kleo::Config::SMimeValidationConfigurationPage::markAsChanged);
     load();
 }
 
 void SMimeValidationConfigurationPage::load()
 {
     mWidget->load();
 }
 
 void SMimeValidationConfigurationPage::save()
 {
     mWidget->save();
 
 }
 
 void SMimeValidationConfigurationPage::defaults()
 {
     mWidget->defaults();
 }
 
 extern "C" Q_DECL_EXPORT KCModule *create_kleopatra_config_smimevalidation(QWidget *parent, const QVariantList &args)
 {
     SMimeValidationConfigurationPage *page =
         new SMimeValidationConfigurationPage(parent, args);
     page->setObjectName(QStringLiteral("kleopatra_config_smimevalidation"));
     return page;
 }
 
diff --git a/src/conf/smimevalidationconfigurationpage.h b/src/conf/smimevalidationconfigurationpage.h
index 8d094969c..cfbee2d52 100644
--- a/src/conf/smimevalidationconfigurationpage.h
+++ b/src/conf/smimevalidationconfigurationpage.h
@@ -1,60 +1,60 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/smimevalidationconfigurationpage.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_SMIMEVALIDATIONCONFIGURATIONPAGE_H
 #define KLEOPATRA_SMIMEVALIDATIONCONFIGURATIONPAGE_H
 
-#include <kcmodule.h>
+#include <KCModule>
 namespace Kleo
 {
 namespace Config
 {
 
 class SMimeValidationConfigurationWidget;
 
 class SMimeValidationConfigurationPage : public KCModule
 {
     Q_OBJECT
 public:
     explicit SMimeValidationConfigurationPage(QWidget *parent = nullptr, const QVariantList &args = QVariantList());
 
     void load() override;
     void save() override;
     void defaults() override;
 
 private:
     SMimeValidationConfigurationWidget *mWidget;
 };
 
 }
 }
 
 #endif // KLEOPATRA_SMIMEVALIDATIONCONFIGURATIONPAGE_H
diff --git a/src/crlview.cpp b/src/crlview.cpp
index 6fce78d1a..1e063f489 100644
--- a/src/crlview.cpp
+++ b/src/crlview.cpp
@@ -1,148 +1,148 @@
 /*
     crlview.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2001,2002,2004 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 "crlview.h"
 
 #include <KLocalizedString>
-#include <kprocess.h>
-#include <kmessagebox.h>
+#include <KProcess>
+#include <KMessageBox>
 #include <QPushButton>
 #include <KStandardGuiItem>
 
 #include <QLabel>
 #include <QTextEdit>
 #include <QTimer>
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QCloseEvent>
 #include <QFontDatabase>
 #include <KGuiItem>
 
 CRLView::CRLView(QWidget *parent)
     : QDialog(parent), _process(0)
 {
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     topLayout->setSpacing(4);
     topLayout->setContentsMargins(10, 10, 10, 10);
 
     topLayout->addWidget(new QLabel(i18n("CRL cache dump:"), this));
 
     _textView = new QTextEdit(this);
     _textView->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
     _textView->setReadOnly(true);
     topLayout->addWidget(_textView);
 
     QHBoxLayout *hbLayout = new QHBoxLayout();
     topLayout->addItem(hbLayout);
 
     _updateButton = new QPushButton(i18n("&Update"), this);
     _closeButton = new QPushButton(this);
     KGuiItem::assign(_closeButton, KStandardGuiItem::close());
 
     hbLayout->addWidget(_updateButton);
     hbLayout->addStretch();
     hbLayout->addWidget(_closeButton);
 
     // connections:
     connect(_updateButton, &QPushButton::clicked, this, &CRLView::slotUpdateView);
     connect(_closeButton, &QPushButton::clicked, this, &CRLView::close);
 
     resize(_textView->fontMetrics().width('M') * 80,
            _textView->fontMetrics().lineSpacing() * 25);
 
     _timer = new QTimer(this);
     connect(_timer, &QTimer::timeout, this, &CRLView::slotAppendBuffer);
 }
 
 CRLView::~CRLView()
 {
     delete _process; _process = nullptr;
 }
 
 void CRLView::closeEvent(QCloseEvent *e)
 {
     QDialog::closeEvent(e);
     delete _process; _process = nullptr;
 }
 
 void CRLView::slotUpdateView()
 {
     _updateButton->setEnabled(false);
     _textView->clear();
     _buffer.clear();
     if (!_process) {
         _process = new KProcess();
         *_process << "gpgsm" << "--call-dirmngr" << "listcrls";
         connect(_process, &KProcess::readyReadStandardOutput, this, &CRLView::slotReadStdout);
         connect(_process, &KProcess::finished, this, &CRLView::slotProcessExited);
     }
     if (_process->state() == QProcess::Running) {
         _process->kill();
     }
     _process->setOutputChannelMode(KProcess::OnlyStdoutChannel);
     _process->start();
     if (!_process->waitForStarted()) {
         KMessageBox::error(this, i18n("Unable to start gpgsm process. Please check your installation."), i18n("Certificate Manager Error"));
         processExited();
     }
     _timer->start(1000);
 }
 
 void CRLView::slotReadStdout()
 {
     _buffer.append(_process->readAllStandardOutput());
 }
 
 void CRLView::slotAppendBuffer()
 {
     _textView->append(_buffer);
     _buffer.clear();
 }
 
 void CRLView::processExited()
 {
     _timer->stop();
     slotAppendBuffer();
     _updateButton->setEnabled(true);
 }
 
 void CRLView::slotProcessExited(int, QProcess::ExitStatus _status)
 {
     processExited();
     if (_status != QProcess::NormalExit) {
         KMessageBox::error(this, i18n("The GpgSM process ended prematurely because of an unexpected error."), i18n("Certificate Manager Error"));
     }
 }
 
diff --git a/src/kwatchgnupg/kwatchgnupgconfig.cpp b/src/kwatchgnupg/kwatchgnupgconfig.cpp
index 298d7365f..1222f4d4c 100644
--- a/src/kwatchgnupg/kwatchgnupgconfig.cpp
+++ b/src/kwatchgnupg/kwatchgnupgconfig.cpp
@@ -1,218 +1,218 @@
 /*
     kwatchgnupgconfig.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2001,2002,2004 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 "kwatchgnupgconfig.h"
 #include "kwatchgnupg.h"
 
 #include "Libkleo/FileNameRequester"
 
 #include <KLocalizedString>
-#include <kconfig.h>
+#include <KConfig>
 #include <KPluralHandlingSpinBox>
 
 #include <QVBoxLayout>
 #include <QLabel>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QPushButton>
 #include <QGroupBox>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <QDialogButtonBox>
 
 static const char *log_levels[] = { "none", "basic", "advanced", "expert", "guru" };
 
 static int log_level_to_int(const QString &loglevel)
 {
     if (loglevel == QLatin1String("none")) {
         return 0;
     } else if (loglevel == QLatin1String("basic")) {
         return 1;
     } else if (loglevel == QLatin1String("advanced")) {
         return 2;
     } else if (loglevel == QLatin1String("expert")) {
         return 3;
     } else if (loglevel == QLatin1String("guru")) {
         return 4;
     } else {
         // default
         return 1;
     }
 }
 
 KWatchGnuPGConfig::KWatchGnuPGConfig(QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window", "Configure KWatchGnuPG"));
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
 
     mButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     QPushButton *okButton = mButtonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(mButtonBox, &QDialogButtonBox::rejected, this, &KWatchGnuPGConfig::reject);
 
     QWidget *top = new QWidget;
     mainLayout->addWidget(top);
     mainLayout->addWidget(mButtonBox);
 
     QVBoxLayout *vlay = new QVBoxLayout(top);
     vlay->setContentsMargins(0, 0, 0, 0);
 
     QGroupBox *group = new QGroupBox(i18n("WatchGnuPG"), top);
     vlay->addWidget(group);
 
     QGridLayout *glay = new QGridLayout(group);
     glay->setColumnStretch(1, 1);
 
     int row = -1;
 
     ++row;
     mExeED = new Kleo::FileNameRequester(group);
     QLabel *label = new QLabel(i18n("&Executable:"), group);
     label->setBuddy(mExeED);
     glay->addWidget(label, row, 0);
     glay->addWidget(mExeED, row, 1);
 
     connect(mExeED, &Kleo::FileNameRequester::fileNameChanged, this, &KWatchGnuPGConfig::slotChanged);
 
     ++row;
     mSocketED = new Kleo::FileNameRequester(group);
     label = new QLabel(i18n("&Socket:"), group);
     label->setBuddy(mSocketED);
     glay->addWidget(label, row, 0);
     glay->addWidget(mSocketED, row, 1);
 
     connect(mSocketED, &Kleo::FileNameRequester::fileNameChanged, this, &KWatchGnuPGConfig::slotChanged);
 
     ++row;
     mLogLevelCB = new QComboBox(group);
     mLogLevelCB->addItem(i18n("None"));
     mLogLevelCB->addItem(i18n("Basic"));
     mLogLevelCB->addItem(i18n("Advanced"));
     mLogLevelCB->addItem(i18n("Expert"));
     mLogLevelCB->addItem(i18n("Guru"));
     label = new QLabel(i18n("Default &log level:"), group);
     label->setBuddy(mLogLevelCB);
     glay->addWidget(label, row, 0);
     glay->addWidget(mLogLevelCB, row, 1);
 
     connect(mLogLevelCB, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this, &KWatchGnuPGConfig::slotChanged);
 
     /******************* Log Window group *******************/
     group = new QGroupBox(i18n("Log Window"), top);
     vlay->addWidget(group);
 
     glay = new QGridLayout(group);
     glay->setColumnStretch(1, 1);
 
     row = -1;
 
     ++row;
     mLoglenSB = new KPluralHandlingSpinBox(group);
     mLoglenSB->setRange(0, 1000000);
     mLoglenSB->setSingleStep(100);
     mLoglenSB->setSuffix(ki18ncp("history size spinbox suffix", " line", " lines"));
     mLoglenSB->setSpecialValueText(i18n("unlimited"));
     label = new QLabel(i18n("&History size:"), group);
     label->setBuddy(mLoglenSB);
     glay->addWidget(label, row, 0);
     glay->addWidget(mLoglenSB, row, 1);
     QPushButton *button = new QPushButton(i18n("Set &Unlimited"), group);
     glay->addWidget(button, row, 2);
 
     connect(mLoglenSB, static_cast<void (KPluralHandlingSpinBox::*)(int)>(&KPluralHandlingSpinBox::valueChanged), this, &KWatchGnuPGConfig::slotChanged);
     connect(button, &QPushButton::clicked, this, &KWatchGnuPGConfig::slotSetHistorySizeUnlimited);
 
     ++row;
     mWordWrapCB = new QCheckBox(i18n("Enable &word wrapping"), group);
     mWordWrapCB->hide(); // QTextEdit doesn't support word wrapping in LogText mode
     glay->addWidget(mWordWrapCB, row, 0, 1, 3);
 
     connect(mWordWrapCB, &QCheckBox::clicked, this, &KWatchGnuPGConfig::slotChanged);
 
     vlay->addStretch(1);
 
     connect(okButton, &QPushButton::clicked, this, &KWatchGnuPGConfig::slotSave);
 }
 
 KWatchGnuPGConfig::~KWatchGnuPGConfig() {}
 
 void KWatchGnuPGConfig::slotSetHistorySizeUnlimited()
 {
     mLoglenSB->setValue(0);
 }
 
 void KWatchGnuPGConfig::loadConfig()
 {
     const KConfigGroup watchGnuPG(KSharedConfig::openConfig(), "WatchGnuPG");
     mExeED->setFileName(watchGnuPG.readEntry("Executable", WATCHGNUPGBINARY));
     mSocketED->setFileName(watchGnuPG.readEntry("Socket", WATCHGNUPGSOCKET));
     mLogLevelCB->setCurrentIndex(log_level_to_int(watchGnuPG.readEntry("LogLevel", "basic")));
 
     const KConfigGroup logWindow(KSharedConfig::openConfig(), "LogWindow");
     mLoglenSB->setValue(logWindow.readEntry("MaxLogLen", 10000));
     mWordWrapCB->setChecked(logWindow.readEntry("WordWrap", false));
 
     mButtonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 }
 
 void KWatchGnuPGConfig::saveConfig()
 {
     KConfigGroup watchGnuPG(KSharedConfig::openConfig(), "WatchGnuPG");
     watchGnuPG.writeEntry("Executable", mExeED->fileName());
     watchGnuPG.writeEntry("Socket", mSocketED->fileName());
     watchGnuPG.writeEntry("LogLevel", log_levels[mLogLevelCB->currentIndex()]);
 
     KConfigGroup logWindow(KSharedConfig::openConfig(), "LogWindow");
     logWindow.writeEntry("MaxLogLen", mLoglenSB->value());
     logWindow.writeEntry("WordWrap", mWordWrapCB->isChecked());
 
     KSharedConfig::openConfig()->sync();
 
     mButtonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 }
 
 void KWatchGnuPGConfig::slotChanged()
 {
     mButtonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
 }
 
 void KWatchGnuPGConfig::slotSave()
 {
     saveConfig();
     Q_EMIT reconfigure();
     accept();
 }
 
diff --git a/src/kwatchgnupg/kwatchgnupgmainwin.cpp b/src/kwatchgnupg/kwatchgnupgmainwin.cpp
index acb281c03..b483aac79 100644
--- a/src/kwatchgnupg/kwatchgnupgmainwin.cpp
+++ b/src/kwatchgnupg/kwatchgnupgmainwin.cpp
@@ -1,284 +1,284 @@
 /*
     kwatchgnupgmainwin.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2001,2002,2004 Klar�vdalens 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 "kwatchgnupgmainwin.h"
 #include "kwatchgnupgconfig.h"
 #include "kwatchgnupg.h"
 #include "tray.h"
 
 #include <QGpgME/Protocol>
 #include <QGpgME/CryptoConfig>
 
 #include "kdlogtextwidget.h"
 
-#include <kmessagebox.h>
+#include <KMessageBox>
 #include <KLocalizedString>
 #include <QApplication>
 #include <QAction>
-#include <kactioncollection.h>
-#include <kstandardaction.h>
-#include <kprocess.h>
-#include <kconfig.h>
-#include <kedittoolbar.h>
-#include <kshortcutsdialog.h>
+#include <KActionCollection>
+#include <KStandardAction>
+#include <KProcess>
+#include <KConfig>
+#include <KEditToolBar>
+#include <KShortcutsDialog>
 #include <QIcon>
 #include <KConfigGroup>
 
 #include <QEventLoop>
 #include <QTextStream>
 #include <QDateTime>
 #include <QFileDialog>
 #include <KSharedConfig>
 
 KWatchGnuPGMainWindow::KWatchGnuPGMainWindow(QWidget *parent)
     : KXmlGuiWindow(parent, Qt::Window), mConfig(nullptr)
 {
     createActions();
     createGUI();
 
     mCentralWidget = new KDLogTextWidget(this);
     KDAB_SET_OBJECT_NAME(mCentralWidget);
 
     setCentralWidget(mCentralWidget);
 
     mWatcher = new KProcess;
     connect(mWatcher, SIGNAL(finished(int,QProcess::ExitStatus)),
             this, SLOT(slotWatcherExited(int,QProcess::ExitStatus)));
 
     connect(mWatcher, &QProcess::readyReadStandardOutput,
             this, &KWatchGnuPGMainWindow::slotReadStdout);
 
     slotReadConfig();
     mSysTray = new KWatchGnuPGTray(this);
     QAction *act = mSysTray->action(QStringLiteral("quit"));
     if (act) {
         connect(act, &QAction::triggered, this, &KWatchGnuPGMainWindow::slotQuit);
     }
 
     setAutoSaveSettings();
 }
 
 KWatchGnuPGMainWindow::~KWatchGnuPGMainWindow()
 {
     delete mWatcher;
 }
 
 void KWatchGnuPGMainWindow::slotClear()
 {
     mCentralWidget->clear();
     mCentralWidget->message(i18n("[%1] Log cleared", QDateTime::currentDateTime().toString(Qt::ISODate)));
 }
 
 void KWatchGnuPGMainWindow::createActions()
 {
     QAction *action = actionCollection()->addAction(QStringLiteral("clear_log"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear-history")));
     action->setText(i18n("C&lear History"));
     connect(action, &QAction::triggered, this, &KWatchGnuPGMainWindow::slotClear);
     actionCollection()->setDefaultShortcut(action, QKeySequence(Qt::CTRL + Qt::Key_L));
     (void)KStandardAction::saveAs(this, SLOT(slotSaveAs()), actionCollection());
     (void)KStandardAction::close(this, SLOT(close()), actionCollection());
     (void)KStandardAction::quit(this, SLOT(slotQuit()), actionCollection());
     (void)KStandardAction::preferences(this, SLOT(slotConfigure()), actionCollection());
     (void)KStandardAction::keyBindings(this, SLOT(configureShortcuts()), actionCollection());
     (void)KStandardAction::configureToolbars(this, SLOT(slotConfigureToolbars()), actionCollection());
 }
 
 void KWatchGnuPGMainWindow::configureShortcuts()
 {
     KShortcutsDialog::configure(actionCollection(), KShortcutsEditor::LetterShortcutsAllowed, this);
 }
 
 void KWatchGnuPGMainWindow::slotConfigureToolbars()
 {
     KEditToolBar dlg(factory());
     dlg.exec();
 }
 
 void KWatchGnuPGMainWindow::startWatcher()
 {
     disconnect(mWatcher, SIGNAL(finished(int,QProcess::ExitStatus)),
                this, SLOT(slotWatcherExited(int,QProcess::ExitStatus)));
     if (mWatcher->state() == QProcess::Running) {
         mWatcher->kill();
         while (mWatcher->state() == QProcess::Running) {
             qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
         }
         mCentralWidget->message(i18n("[%1] Log stopped", QDateTime::currentDateTime().toString(Qt::ISODate)));
     }
     mWatcher->clearProgram();
 
     {
         const KConfigGroup config(KSharedConfig::openConfig(), "WatchGnuPG");
         *mWatcher << config.readEntry("Executable", WATCHGNUPGBINARY);
         *mWatcher << QStringLiteral("--force");
         *mWatcher << config.readEntry("Socket", WATCHGNUPGSOCKET);
     }
 
     mWatcher->setOutputChannelMode(KProcess::OnlyStdoutChannel);
     mWatcher->start();
     const bool ok = mWatcher->waitForStarted();
     if (!ok) {
         KMessageBox::sorry(this, i18n("The watchgnupg logging process could not be started.\nPlease install watchgnupg somewhere in your $PATH.\nThis log window is unable to display any useful information."));
     } else {
         mCentralWidget->message(i18n("[%1] Log started", QDateTime::currentDateTime().toString(Qt::ISODate)));
     }
     connect(mWatcher, SIGNAL(finished(int,QProcess::ExitStatus)),
             this, SLOT(slotWatcherExited(int,QProcess::ExitStatus)));
 }
 
 void KWatchGnuPGMainWindow::setGnuPGConfig()
 {
     QStringList logclients;
     // Get config object
     QGpgME::CryptoConfig *cconfig = QGpgME::cryptoConfig();
     if (!cconfig) {
         return;
     }
     //Q_ASSERT( cconfig );
     KConfigGroup config(KSharedConfig::openConfig(), "WatchGnuPG");
     const QStringList comps = cconfig->componentList();
     for (QStringList::const_iterator it = comps.constBegin(); it != comps.constEnd(); ++it) {
         QGpgME::CryptoConfigComponent *comp = cconfig->component(*it);
         Q_ASSERT(comp);
         // Look for log-file entry in Debug group
         QGpgME::CryptoConfigGroup *group = comp->group(QStringLiteral("Debug"));
         if (group) {
             QGpgME::CryptoConfigEntry *entry = group->entry(QStringLiteral("log-file"));
             if (entry) {
                 entry->setStringValue(QLatin1String("socket://") + config.readEntry("Socket", WATCHGNUPGSOCKET));
                 logclients << QStringLiteral("%1 (%2)").arg(*it, comp->description());
             }
             entry = group->entry(QStringLiteral("debug-level"));
             if (entry) {
                 entry->setStringValue(config.readEntry("LogLevel", "basic"));
             }
         }
     }
     cconfig->sync(true);
     if (logclients.isEmpty()) {
         KMessageBox::sorry(nullptr, i18n("There are no components available that support logging."));
     }
 }
 
 void KWatchGnuPGMainWindow::slotWatcherExited(int, QProcess::ExitStatus)
 {
     if (KMessageBox::questionYesNo(this, i18n("The watchgnupg logging process died.\nDo you want to try to restart it?"), QString(), KGuiItem(i18n("Try Restart")), KGuiItem(i18n("Do Not Try"))) == KMessageBox::Yes) {
         mCentralWidget->message(i18n("====== Restarting logging process ====="));
         startWatcher();
     } else {
         KMessageBox::sorry(this, i18n("The watchgnupg logging process is not running.\nThis log window is unable to display any useful information."));
     }
 }
 
 void KWatchGnuPGMainWindow::slotReadStdout()
 {
     if (!mWatcher) {
         return;
     }
     while (mWatcher->canReadLine()) {
         QString str = QString::fromUtf8(mWatcher->readLine());
         if (str.endsWith(QLatin1Char('\n'))) {
             str.chop(1);
         }
         if (str.endsWith(QLatin1Char('\r'))) {
             str.chop(1);
         }
         mCentralWidget->message(str);
         if (!isVisible()) {
             // Change tray icon to show something happened
             // PENDING(steffen)
             mSysTray->setAttention(true);
         }
     }
 }
 
 void KWatchGnuPGMainWindow::show()
 {
     mSysTray->setAttention(false);
     KMainWindow::show();
 }
 
 void KWatchGnuPGMainWindow::slotSaveAs()
 {
     const QString filename = QFileDialog::getSaveFileName(this, i18n("Save Log to File"));
     if (filename.isEmpty()) {
         return;
     }
     QFile file(filename);
     if (file.open(QIODevice::WriteOnly)) {
         QTextStream(&file) << mCentralWidget->text();
     } else
         KMessageBox::information(this, i18n("Could not save file %1: %2",
                                             filename, file.errorString()));
 }
 
 void KWatchGnuPGMainWindow::slotQuit()
 {
     disconnect(mWatcher, SIGNAL(finished(int,QProcess::ExitStatus)),
                this, SLOT(slotWatcherExited(int,QProcess::ExitStatus)));
     mWatcher->kill();
     qApp->quit();
 }
 
 void KWatchGnuPGMainWindow::slotConfigure()
 {
     if (!mConfig) {
         mConfig = new KWatchGnuPGConfig(this);
         mConfig->setObjectName(QStringLiteral("config dialog"));
         connect(mConfig, &KWatchGnuPGConfig::reconfigure,
                 this, &KWatchGnuPGMainWindow::slotReadConfig);
     }
     mConfig->loadConfig();
     mConfig->exec();
 }
 
 void KWatchGnuPGMainWindow::slotReadConfig()
 {
     const KConfigGroup config(KSharedConfig::openConfig(), "LogWindow");
     const int maxLogLen = config.readEntry("MaxLogLen", 10000);
     mCentralWidget->setHistorySize(maxLogLen < 1 ? -1 : maxLogLen);
     setGnuPGConfig();
     startWatcher();
 }
 
 bool KWatchGnuPGMainWindow::queryClose()
 {
     if (!qApp->isSavingSession()) {
         hide();
         return false;
     }
     return KMainWindow::queryClose();
 }
 
diff --git a/src/kwatchgnupg/main.cpp b/src/kwatchgnupg/main.cpp
index 010116267..acb2881aa 100644
--- a/src/kwatchgnupg/main.cpp
+++ b/src/kwatchgnupg/main.cpp
@@ -1,72 +1,72 @@
 /*
     main.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2001,2002,2004 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 "aboutdata.h"
 #include "kwatchgnupgmainwin.h"
-#include <kdelibs4configmigrator.h>
+#include <Kdelibs4ConfigMigrator>
 #include "utils/kuniqueservice.h"
 
-#include <kmessagebox.h>
+#include <KMessageBox>
 #include <KLocalizedString>
 #include <KCrash>
 #include "kwatchgnupg_debug.h"
 #include <QCommandLineParser>
 #include <QApplication>
 
 int main(int argc, char **argv)
 {
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
     QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling, true);
     QApplication app(argc, argv);
     KCrash::initialize();
     Kdelibs4ConfigMigrator migrate(QStringLiteral("kwatchgnupg"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("kwatchgnupgrc"));
     migrate.setUiFiles(QStringList() << QStringLiteral("kwatchgnupgui.rc"));
     migrate.migrate();
 
     KLocalizedString::setApplicationDomain("kwatchgnupg");
     AboutData aboutData;
 
     KAboutData::setApplicationData(aboutData);
     QCommandLineParser parser;
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     KUniqueService service;
 
     KWatchGnuPGMainWindow *mMainWin = new KWatchGnuPGMainWindow();
     mMainWin->show();
     return app.exec();
 }
diff --git a/src/kwatchgnupg/tray.cpp b/src/kwatchgnupg/tray.cpp
index 7b98b99ef..a2bd1034c 100644
--- a/src/kwatchgnupg/tray.cpp
+++ b/src/kwatchgnupg/tray.cpp
@@ -1,67 +1,67 @@
 /*
     main.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2001,2002,2004 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 "tray.h"
 #include "kwatchgnupgmainwin.h"
 
 #include "kwatchgnupg_debug.h"
 #include <KLocalizedString>
-#include <kiconloader.h>
+#include <KIconLoader>
 
 KWatchGnuPGTray::KWatchGnuPGTray(KWatchGnuPGMainWindow *mainwin)
     : KStatusNotifierItem(mainwin)
 {
     qCDebug(KWATCHGNUPG_LOG) << "KWatchGnuPGTray::KWatchGnuPGTray";
 
     setObjectName(QStringLiteral("KWatchGnuPG Tray Window"));
     KIconLoader::global()->addAppDir(QStringLiteral("kwatchgnupg"));
 
     mNormalPix.addPixmap(KIconLoader::global()->loadIcon(QStringLiteral("kwatchgnupg"), KIconLoader::Panel));
     mAttentionPix.addPixmap(KIconLoader::global()->loadIcon(QStringLiteral("kwatchgnupg2"), KIconLoader::Panel));
     setToolTipTitle(i18n("KWatchGnuPG Log Viewer"));
 }
 
 KWatchGnuPGTray::~KWatchGnuPGTray()
 {
 }
 
 void KWatchGnuPGTray::setAttention(bool att)
 {
     if (att) {
         setIconByPixmap(mAttentionPix);
     } else {
         setIconByPixmap(mNormalPix);
     }
 }
 
diff --git a/src/kwatchgnupg/tray.h b/src/kwatchgnupg/tray.h
index 5e0ef1cb2..2288aeed5 100644
--- a/src/kwatchgnupg/tray.h
+++ b/src/kwatchgnupg/tray.h
@@ -1,56 +1,56 @@
 /*
     main.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2001,2002,2004 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 TRAY_H
 #define TRAY_H
 
 #include <QIcon>
-#include <kstatusnotifieritem.h>
+#include <KStatusNotifierItem>
 
 class KWatchGnuPGMainWindow;
 
 class KWatchGnuPGTray : public KStatusNotifierItem
 {
     Q_OBJECT
 public:
     explicit KWatchGnuPGTray(KWatchGnuPGMainWindow *mainwin);
     virtual ~KWatchGnuPGTray();
 
 public Q_SLOTS:
     void setAttention(bool att);
 private:
     QIcon mNormalPix;
     QIcon mAttentionPix;
 };
 
 #endif /* TRAY_H */
 
diff --git a/src/main.cpp b/src/main.cpp
index 64ee20d53..d330fbdbf 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,264 +1,264 @@
 /*
     main.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     Copyright (c) 2001,2002,2004,2008 Klarävdalens 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 "aboutdata.h"
 #include "kleopatraapplication.h"
 #include "mainwindow.h"
 
-#include <kdelibs4configmigrator.h>
+#include <Kdelibs4ConfigMigrator>
 
 #include <commands/reloadkeyscommand.h>
 #include <commands/selftestcommand.h>
 
 #include <utils/gnupg-helper.h>
 #include <utils/archivedefinition.h>
 #include "utils/kuniqueservice.h"
 
 #include <uiserver/uiserver.h>
 #include <uiserver/assuancommand.h>
 #include <uiserver/echocommand.h>
 #include <uiserver/decryptcommand.h>
 #include <uiserver/verifycommand.h>
 #include <uiserver/decryptverifyfilescommand.h>
 #include <uiserver/decryptfilescommand.h>
 #include <uiserver/verifyfilescommand.h>
 #include <uiserver/prepencryptcommand.h>
 #include <uiserver/prepsigncommand.h>
 #include <uiserver/encryptcommand.h>
 #include <uiserver/signcommand.h>
 #include <uiserver/signencryptfilescommand.h>
 #include <uiserver/selectcertificatecommand.h>
 #include <uiserver/importfilescommand.h>
 #include <uiserver/createchecksumscommand.h>
 #include <uiserver/verifychecksumscommand.h>
 
 #include <Libkleo/ChecksumDefinition>
 
 #include "kleopatra_debug.h"
 #include "kleopatra_options.h"
 
 #include <KLocalizedString>
-#include <kiconloader.h>
-#include <kmessagebox.h>
+#include <KIconLoader>
+#include <KMessageBox>
 #include <KCrash>
 
 #include <QTextDocument> // for Qt::escape
 #include <QMessageBox>
 #include <QTimer>
 #include <QTime>
 #include <QEventLoop>
 #include <QThreadPool>
 
 #include <gpgme++/global.h>
 #include <gpgme++/error.h>
 
 #include <memory>
 #include <iostream>
 #include <QCommandLineParser>
 
 static bool selfCheck()
 {
     Kleo::Commands::SelfTestCommand cmd(nullptr);
     cmd.setAutoDelete(false);
     cmd.setAutomaticMode(true);
     QEventLoop loop;
     QObject::connect(&cmd, &Kleo::Commands::SelfTestCommand::finished, &loop, &QEventLoop::quit);
     QTimer::singleShot(0, &cmd, &Kleo::Command::start);   // start() may Q_EMIT finished()...
     loop.exec();
     if (cmd.isCanceled()) {
         return false;
     } else {
         return true;
     }
 }
 
 static void fillKeyCache(Kleo::UiServer *server)
 {
     Kleo::ReloadKeysCommand *cmd = new Kleo::ReloadKeysCommand(nullptr);
     QObject::connect(cmd, SIGNAL(finished()), server, SLOT(enableCryptoCommands()));
     cmd->start();
 }
 
 int main(int argc, char **argv)
 {
     QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling, true);
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
     KleopatraApplication app(argc, argv);
     KCrash::initialize();
 
 
     QTime timer;
     timer.start();
 
     KLocalizedString::setApplicationDomain("kleopatra");
 
     KUniqueService service;
     QObject::connect(&service, &KUniqueService::activateRequested,
                      &app, &KleopatraApplication::slotActivateRequested);
     QObject::connect(&app, &KleopatraApplication::setExitValue,
     &service, [&service](int i) {
         service.setExitValue(i);
     });
     // Delay init after KUniqueservice call as this might already
     // have terminated us and so we can avoid overhead (e.g. keycache
     // setup / systray icon).
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: Service created";
     app.init();
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: Application initialized";
 
     AboutData aboutData;
 
     KAboutData::setApplicationData(aboutData);
 
     QCommandLineParser parser;
     aboutData.setupCommandLine(&parser);
     kleopatra_options(&parser);
 
     parser.process(QApplication::arguments());
     aboutData.processCommandLine(&parser);
 
     Kdelibs4ConfigMigrator migrate(QStringLiteral("kleopatra"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("kleopatrarc")
                                          << QStringLiteral("libkleopatrarc"));
     migrate.setUiFiles(QStringList() << QStringLiteral("kleopatra.rc"));
     migrate.migrate();
 
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: Application created";
 
     // Initialize GpgME
     const GpgME::Error gpgmeInitError = GpgME::initializeLibrary(0);
 
     {
         const unsigned int threads = QThreadPool::globalInstance()->maxThreadCount();
         QThreadPool::globalInstance()->setMaxThreadCount(qMax(2U, threads));
     }
     if (gpgmeInitError) {
         KMessageBox::sorry(nullptr, xi18nc("@info",
                                      "<para>The version of the <application>GpgME</application> library you are running against "
                                      "is older than the one that the <application>GpgME++</application> library was built against.</para>"
                                      "<para><application>Kleopatra</application> will not function in this setting.</para>"
                                      "<para>Please ask your administrator for help in resolving this issue.</para>"),
                            i18nc("@title", "GpgME Too Old"));
         return EXIT_FAILURE;
     }
 
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: GPGME Initialized";
 
     Kleo::ChecksumDefinition::setInstallPath(Kleo::gpg4winInstallPath());
     Kleo::ArchiveDefinition::setInstallPath(Kleo::gnupgInstallPath());
 
     int rc;
     Kleo::UiServer server(parser.value(QStringLiteral("uiserver-socket")));
     try {
         qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: UiServer created";
 
         QObject::connect(&server, &Kleo::UiServer::startKeyManagerRequested, &app, &KleopatraApplication::openOrRaiseMainWindow);
 
         QObject::connect(&server, &Kleo::UiServer::startConfigDialogRequested, &app, &KleopatraApplication::openOrRaiseConfigDialog);
 
 #define REGISTER( Command ) server.registerCommandFactory( std::shared_ptr<Kleo::AssuanCommandFactory>( new Kleo::GenericAssuanCommandFactory<Kleo::Command> ) )
         REGISTER(CreateChecksumsCommand);
         REGISTER(DecryptCommand);
         REGISTER(DecryptFilesCommand);
         REGISTER(DecryptVerifyFilesCommand);
         REGISTER(EchoCommand);
         REGISTER(EncryptCommand);
         REGISTER(EncryptFilesCommand);
         REGISTER(EncryptSignFilesCommand);
         REGISTER(ImportFilesCommand);
         REGISTER(PrepEncryptCommand);
         REGISTER(PrepSignCommand);
         REGISTER(SelectCertificateCommand);
         REGISTER(SignCommand);
         REGISTER(SignEncryptFilesCommand);
         REGISTER(SignFilesCommand);
         REGISTER(VerifyChecksumsCommand);
         REGISTER(VerifyCommand);
         REGISTER(VerifyFilesCommand);
 #undef REGISTER
 
         server.start();
         qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: UiServer started";
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Failed to start UI Server: " << e.what();
 #ifdef Q_OS_WIN
         // Once there actually is a plugin for other systems then Windows this
         // error should probably be shown, too. But currently only Windows users need
         // to care.
         QMessageBox::information(nullptr, i18n("GPG UI Server Error"),
                                  i18n("<qt>The Kleopatra GPG UI Server Module could not be initialized.<br/>"
                                       "The error given was: <b>%1</b><br/>"
                                       "You can use Kleopatra as a certificate manager, but cryptographic plugins that "
                                       "rely on a GPG UI Server being present might not work correctly, or at all.</qt>",
                                       QString::fromUtf8(e.what()).toHtmlEscaped()));
 #endif
     }
     const bool daemon = parser.isSet(QStringLiteral("daemon"));
     if (!daemon && app.isSessionRestored()) {
         app.restoreMainWindow();
     }
 
     if (!selfCheck()) {
         return EXIT_FAILURE;
     }
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: SelfCheck completed";
 
     fillKeyCache(&server);
 #ifndef QT_NO_SYSTEMTRAYICON
     app.startMonitoringSmartCard();
 #endif
     app.setIgnoreNewInstance(false);
 
     if (!daemon) {
         const QString err = app.newInstance(parser);
         if (!err.isEmpty()) {
             std::cerr << i18n("Invalid arguments: %1", err).toLocal8Bit().constData() << "\n";
             return EXIT_FAILURE;
         }
         qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: new instance created";
     }
 
     rc = app.exec();
 
     app.setIgnoreNewInstance(true);
     QObject::disconnect(&server, &Kleo::UiServer::startKeyManagerRequested, &app, &KleopatraApplication::openOrRaiseMainWindow);
     QObject::disconnect(&server, &Kleo::UiServer::startConfigDialogRequested, &app, &KleopatraApplication::openOrRaiseConfigDialog);
 
     server.stop();
     server.waitForStopped();
 
     return rc;
 }