diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f40fdb05b..291b46857 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,387 +1,388 @@
 add_subdirectory(icons)
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 
 if (NOT DISABLE_KWATCHGNUPG)
     add_subdirectory(kwatchgnupg)
 endif()
 add_subdirectory(libkleopatraclient)
 add_subdirectory(conf)
 add_subdirectory(kconf_update)
 
 if(WIN32)
   set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_win.cpp)
   set(_kleopatra_extra_SRCS
       utils/gnupg-registry.c
       selftest/registrycheck.cpp
       utils/windowsprocessdevice.cpp
       utils/userinfo_win.cpp
   )
 else()
   set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_unix.cpp)
   set(_kleopatra_extra_SRCS)
 endif()
 
 set(_kleopatra_uiserver_SRCS
     uiserver/sessiondata.cpp
     uiserver/uiserver.cpp
     ${_kleopatra_extra_uiserver_SRCS}
     uiserver/assuanserverconnection.cpp
     uiserver/echocommand.cpp
     uiserver/decryptverifycommandemailbase.cpp
     uiserver/decryptverifycommandfilesbase.cpp
     uiserver/signcommand.cpp
     uiserver/signencryptfilescommand.cpp
     uiserver/prepencryptcommand.cpp
     uiserver/prepsigncommand.cpp
     uiserver/encryptcommand.cpp
     uiserver/selectcertificatecommand.cpp
     uiserver/importfilescommand.cpp
     uiserver/createchecksumscommand.cpp
     uiserver/verifychecksumscommand.cpp
 
     selftest/uiservercheck.cpp
   )
 
 if(ASSUAN2_FOUND)
   include_directories(${ASSUAN2_INCLUDES})
   set(_kleopatra_uiserver_extra_libs ${ASSUAN2_LIBRARIES})
 else()
   include_directories(${ASSUAN_INCLUDES})
   if(WIN32)
     set(_kleopatra_uiserver_extra_libs ${ASSUAN_VANILLA_LIBRARIES})
   else()
     set(_kleopatra_uiserver_extra_libs ${ASSUAN_PTHREAD_LIBRARIES})
   endif()
 endif()
 
 if(HAVE_GPG_ERR_SOURCE_KLEO)
   add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_KLEO)
   add_definitions(-DGPGMEPP_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_KLEO)
 else()
   add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_USER_1)
   add_definitions(-DGPGMEPP_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_USER_1)
 endif()
 
 ki18n_wrap_ui(_kleopatra_uiserver_SRCS crypto/gui/signingcertificateselectionwidget.ui)
 
 if("${Gpgmepp_VERSION}" VERSION_GREATER_EQUAL "1.14.1")
     set(_kleopatra_deviceinfowatcher_files
         smartcard/deviceinfowatcher.cpp
     )
 else()
     set(_kleopatra_deviceinfowatcher_files)
 endif()
 
 set(_kleopatra_SRCS
   utils/gui-helper.cpp
   utils/filedialog.cpp
   utils/kdpipeiodevice.cpp
   utils/headerview.cpp
   utils/scrollarea.cpp
   utils/dragqueen.cpp
   utils/multivalidator.cpp
   utils/systemtrayicon.cpp
 
   utils/hex.cpp
   utils/path-helper.cpp
   utils/input.cpp
   utils/output.cpp
   utils/validation.cpp
   utils/wsastarter.cpp
   utils/iodevicelogger.cpp
   utils/log.cpp
   utils/action_data.cpp
   utils/types.cpp
   utils/archivedefinition.cpp
   utils/auditlog.cpp
   utils/clipboardmenu.cpp
   utils/kuniqueservice.cpp
   utils/tags.cpp
   utils/writecertassuantransaction.cpp
   utils/keyparameters.cpp
   utils/userinfo.cpp
 
   selftest/selftest.cpp
   selftest/enginecheck.cpp
   selftest/gpgconfcheck.cpp
   selftest/gpgagentcheck.cpp
   selftest/libkleopatrarccheck.cpp
 
   ${_kleopatra_extra_SRCS}
 
   view/keylistcontroller.cpp
   view/keytreeview.cpp
   view/searchbar.cpp
   view/smartcardwidget.cpp
   view/padwidget.cpp
   view/pgpcardwidget.cpp
   view/pivcardwidget.cpp
   view/p15cardwidget.cpp
   view/netkeywidget.cpp
   view/nullpinwidget.cpp
   view/tabwidget.cpp
   view/keycacheoverlay.cpp
   view/waitwidget.cpp
   view/welcomewidget.cpp
 
   dialogs/certificateselectiondialog.cpp
   dialogs/certifywidget.cpp
   dialogs/expirydialog.cpp
   dialogs/lookupcertificatesdialog.cpp
   dialogs/ownertrustdialog.cpp
   dialogs/selftestdialog.cpp
   dialogs/certifycertificatedialog.cpp
   dialogs/revokecertificationwidget.cpp
   dialogs/revokecertificationdialog.cpp
   dialogs/adduseriddialog.cpp
   dialogs/addemaildialog.cpp
   dialogs/deletecertificatesdialog.cpp
   dialogs/setinitialpindialog.cpp
+  dialogs/certificatedetailsdialog.cpp
   dialogs/certificatedetailswidget.cpp
   dialogs/trustchainwidget.cpp
   dialogs/weboftrustwidget.cpp
   dialogs/weboftrustdialog.cpp
   dialogs/exportdialog.cpp
   dialogs/subkeyswidget.cpp
   dialogs/gencardkeydialog.cpp
   dialogs/updatenotification.cpp
   dialogs/pivcardapplicationadministrationkeyinputdialog.cpp
   dialogs/certificatedetailsinputwidget.cpp
   dialogs/createcsrforcardkeydialog.cpp
   dialogs/groupdetailsdialog.cpp
   dialogs/editgroupdialog.cpp
 
   crypto/controller.cpp
   crypto/certificateresolver.cpp
   crypto/sender.cpp
   crypto/recipient.cpp
   crypto/task.cpp
   crypto/taskcollection.cpp
   crypto/decryptverifytask.cpp
   crypto/decryptverifyemailcontroller.cpp
   crypto/decryptverifyfilescontroller.cpp
   crypto/autodecryptverifyfilescontroller.cpp
   crypto/encryptemailtask.cpp
   crypto/encryptemailcontroller.cpp
   crypto/newsignencryptemailcontroller.cpp
   crypto/signencrypttask.cpp
   crypto/signencryptfilescontroller.cpp
   crypto/signemailtask.cpp
   crypto/signemailcontroller.cpp
   crypto/createchecksumscontroller.cpp
   crypto/verifychecksumscontroller.cpp
 
   crypto/gui/wizard.cpp
   crypto/gui/wizardpage.cpp
 
   crypto/gui/certificateselectionline.cpp
   crypto/gui/certificatelineedit.cpp
   crypto/gui/signingcertificateselectionwidget.cpp
   crypto/gui/signingcertificateselectiondialog.cpp
 
   crypto/gui/resultitemwidget.cpp
   crypto/gui/resultlistwidget.cpp
   crypto/gui/resultpage.cpp
 
   crypto/gui/newresultpage.cpp
   crypto/gui/signencryptfileswizard.cpp
 
   crypto/gui/signencryptemailconflictdialog.cpp
 
   crypto/gui/decryptverifyoperationwidget.cpp
   crypto/gui/decryptverifyfileswizard.cpp
   crypto/gui/decryptverifyfilesdialog.cpp
 
   crypto/gui/objectspage.cpp
   crypto/gui/resolverecipientspage.cpp
   crypto/gui/signerresolvepage.cpp
   crypto/gui/encryptemailwizard.cpp
   crypto/gui/signemailwizard.cpp
   crypto/gui/signencryptwidget.cpp
   crypto/gui/signencryptwizard.cpp
   crypto/gui/unknownrecipientwidget.cpp
 
   crypto/gui/verifychecksumsdialog.cpp
 
   commands/command.cpp
   commands/gnupgprocesscommand.cpp
   commands/detailscommand.cpp
   commands/exportcertificatecommand.cpp
   commands/importcertificatescommand.cpp
   commands/importcertificatefromfilecommand.cpp
   commands/importcertificatefromclipboardcommand.cpp
   commands/importcertificatefromdatacommand.cpp
   commands/lookupcertificatescommand.cpp
   commands/reloadkeyscommand.cpp
   commands/refreshx509certscommand.cpp
   commands/refreshopenpgpcertscommand.cpp
   commands/deletecertificatescommand.cpp
   commands/decryptverifyfilescommand.cpp
   commands/signencryptfilescommand.cpp
   commands/signencryptfoldercommand.cpp
   commands/encryptclipboardcommand.cpp
   commands/signclipboardcommand.cpp
   commands/decryptverifyclipboardcommand.cpp
   commands/clearcrlcachecommand.cpp
   commands/dumpcrlcachecommand.cpp
   commands/dumpcertificatecommand.cpp
   commands/importcrlcommand.cpp
   commands/changeexpirycommand.cpp
   commands/changeownertrustcommand.cpp
   commands/changeroottrustcommand.cpp
   commands/changepassphrasecommand.cpp
   commands/certifycertificatecommand.cpp
   commands/revokecertificationcommand.cpp
   commands/selftestcommand.cpp
   commands/exportsecretkeycommand.cpp
   commands/exportopenpgpcertstoservercommand.cpp
   commands/adduseridcommand.cpp
   commands/newcertificatecommand.cpp
   commands/setinitialpincommand.cpp
   commands/learncardkeyscommand.cpp
   commands/checksumcreatefilescommand.cpp
   commands/checksumverifyfilescommand.cpp
   commands/exportpaperkeycommand.cpp
   commands/importpaperkeycommand.cpp
   commands/genrevokecommand.cpp
   commands/keytocardcommand.cpp
   commands/cardcommand.cpp
   commands/pivgeneratecardkeycommand.cpp
   commands/changepincommand.cpp
   commands/authenticatepivcardapplicationcommand.cpp
   commands/setpivcardapplicationadministrationkeycommand.cpp
   commands/certificatetopivcardcommand.cpp
   commands/importcertificatefrompivcardcommand.cpp
   commands/createopenpgpkeyfromcardkeyscommand.cpp
   commands/createcsrforcardkeycommand.cpp
 
   ${_kleopatra_uiserver_files}
 
   conf/configuredialog.cpp
   conf/groupsconfigdialog.cpp
   conf/groupsconfigpage.cpp
   conf/groupsconfigwidget.cpp
 
   newcertificatewizard/listwidget.cpp
   newcertificatewizard/newcertificatewizard.cpp
 
   smartcard/readerstatus.cpp
   smartcard/card.cpp
   smartcard/openpgpcard.cpp
   smartcard/netkeycard.cpp
   smartcard/pivcard.cpp
   smartcard/p15card.cpp
   smartcard/keypairinfo.cpp
   smartcard/utils.cpp
 
   ${_kleopatra_deviceinfowatcher_files}
 
   aboutdata.cpp
   systrayicon.cpp
   kleopatraapplication.cpp
   mainwindow.cpp
   main.cpp
   kleopatra.qrc
 )
 
 if(WIN32)
   configure_file (versioninfo.rc.in versioninfo.rc)
   set(_kleopatra_SRCS ${CMAKE_CURRENT_BINARY_DIR}/versioninfo.rc ${_kleopatra_SRCS})
 endif()
 
 if(HAVE_KCMUTILS)
   set (_kleopatra_extra_libs KF5::KCMUtils)
 else()
   set (_kleopatra_SRCS conf/kleopageconfigdialog.cpp ${_kleopatra_SRCS})
 endif()
 
 ecm_qt_declare_logging_category(_kleopatra_SRCS HEADER kleopatra_debug.h IDENTIFIER KLEOPATRA_LOG CATEGORY_NAME org.kde.pim.kleopatra
         DESCRIPTION "kleopatra (kleopatra)"
         OLD_CATEGORY_NAMES log_kleopatra
         EXPORT KLEOPATRA
     )
 
 
 if(KLEO_MODEL_TEST)
   add_definitions(-DKLEO_MODEL_TEST)
   set(_kleopatra_SRCS ${_kleopatra_SRCS} models/modeltest.cpp)
 endif()
 
 ki18n_wrap_ui(_kleopatra_SRCS
   dialogs/expirydialog.ui
   dialogs/lookupcertificatesdialog.ui
   dialogs/ownertrustdialog.ui
   dialogs/selectchecklevelwidget.ui
   dialogs/selftestdialog.ui
   dialogs/adduseriddialog.ui
   dialogs/setinitialpindialog.ui
   dialogs/certificatedetailswidget.ui
   dialogs/trustchainwidget.ui
   dialogs/subkeyswidget.ui
   newcertificatewizard/listwidget.ui
   newcertificatewizard/chooseprotocolpage.ui
   newcertificatewizard/enterdetailspage.ui
   newcertificatewizard/keycreationpage.ui
   newcertificatewizard/resultpage.ui
   newcertificatewizard/advancedsettingsdialog.ui
 )
 
 kconfig_add_kcfg_files(_kleopatra_SRCS
   kcfg/tooltippreferences.kcfgc
   kcfg/emailoperationspreferences.kcfgc
   kcfg/fileoperationspreferences.kcfgc
   kcfg/smimevalidationpreferences.kcfgc
   kcfg/tagspreferences.kcfgc
   kcfg/settings.kcfgc
 )
 
 file(GLOB ICONS_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/icons/*-apps-kleopatra.png")
 ecm_add_app_icon(_kleopatra_SRCS ICONS ${ICONS_SRCS})
 
 add_executable(kleopatra_bin ${_kleopatra_SRCS} ${_kleopatra_uiserver_SRCS})
 #if (COMPILE_WITH_UNITY_CMAKE_SUPPORT)
 #    set_target_properties(kleopatra_bin PROPERTIES UNITY_BUILD ON)
 #endif()
 set_target_properties(kleopatra_bin PROPERTIES OUTPUT_NAME kleopatra)
 
 if (WIN32)
   set(_kleopatra_platform_libs "secur32")
 endif ()
 
 target_link_libraries(kleopatra_bin
   Gpgmepp
   QGpgme
   ${_kleopatra_extra_libs}
   KF5::Libkleo
   KF5::Mime
   KF5::I18n
   KF5::XmlGui
   KF5::IconThemes
   KF5::WindowSystem
   KF5::CoreAddons
   KF5::ItemModels
   KF5::Crash
   Qt::Network
   Qt::PrintSupport # Printing secret keys
   ${_kleopatra_uiserver_extra_libs}
   ${_kleopatra_dbusaddons_libs}
   kleopatraclientcore
   ${_kleopatra_platform_libs}
 )
 
 install(TARGETS kleopatra_bin ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
 
 install(
   PROGRAMS data/org.kde.kleopatra.desktop data/kleopatra_import.desktop
   DESTINATION ${KDE_INSTALL_APPDIR}
 )
 install(FILES data/org.kde.kleopatra.appdata.xml DESTINATION ${KDE_INSTALL_METAINFODIR})
 install(
   FILES data/kleopatra_signencryptfiles.desktop
         data/kleopatra_signencryptfolders.desktop
         data/kleopatra_decryptverifyfiles.desktop
         data/kleopatra_decryptverifyfolders.desktop
   DESTINATION ${KDE_INSTALL_KSERVICES5DIR}
 )
diff --git a/src/commands/detailscommand.cpp b/src/commands/detailscommand.cpp
index b03d357fd..fcb2de32c 100644
--- a/src/commands/detailscommand.cpp
+++ b/src/commands/detailscommand.cpp
@@ -1,162 +1,162 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/detailscommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "detailscommand.h"
 #include "command_p.h"
 
-#include <dialogs/certificatedetailswidget.h>
+#include <dialogs/certificatedetailsdialog.h>
 
 #include "kleopatra_debug.h"
 
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 class DetailsCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::DetailsCommand;
     DetailsCommand *q_func() const
     {
         return static_cast<DetailsCommand *>(q);
     }
 public:
     explicit Private(DetailsCommand *qq, KeyListController *c);
     ~Private();
 
 private:
     void ensureDialogCreated()
     {
         if (dialog) {
             return;
         }
 
         auto dlg = new CertificateDetailsDialog;
         applyWindowID(dlg);
         dlg->setAttribute(Qt::WA_DeleteOnClose);
         connect(dlg, &QDialog::finished, q_func(), [this] (int) {
                 slotDialogClosed();
             });
 
         dialog = dlg;
     }
 
     void ensureDialogVisible()
     {
         ensureDialogCreated();
         if (dialog->isVisible()) {
             dialog->raise();
         } else {
             dialog->show();
         }
     }
 
     void init()
     {
         q->setWarnWhenRunningAtShutdown(false);
     }
 
 private:
     void slotDialogClosed();
 
 private:
     QPointer<CertificateDetailsDialog> dialog;
 };
 
 DetailsCommand::Private *DetailsCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const DetailsCommand::Private *DetailsCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define q q_func()
 #define d d_func()
 
 DetailsCommand::Private::Private(DetailsCommand *qq, KeyListController *c)
     : Command::Private(qq, c),
       dialog()
 {
 
 }
 
 DetailsCommand::Private::~Private() {}
 
 DetailsCommand::DetailsCommand(KeyListController *p)
     : Command(new Private(this, p))
 {
     d->init();
 }
 
 DetailsCommand::DetailsCommand(QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
     d->init();
 }
 
 DetailsCommand::DetailsCommand(const Key &key, KeyListController *p)
     : Command(new Private(this, p))
 {
     Q_ASSERT(!key.isNull());
     d->init();
     setKey(key);
 }
 
 DetailsCommand::DetailsCommand(const Key &key, QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
     Q_ASSERT(!key.isNull());
     d->init();
     setKey(key);
 }
 
 DetailsCommand::~DetailsCommand() {}
 
 void DetailsCommand::doStart()
 {
     const std::vector<Key> keys = d->keys();
     Key key;
     if (keys.size() == 1) {
         key = keys.front();
     } else {
         qCWarning(KLEOPATRA_LOG) << "can only work with one certificate at a time";
     }
 
     if (key.isNull()) {
         d->finished();
         return;
     }
 
     d->ensureDialogCreated();
 
     d->dialog->setKey(key);
 
     d->ensureDialogVisible();
 }
 
 void DetailsCommand::doCancel()
 {
     if (d->dialog) {
         d->dialog->close();
     }
 }
 
 void DetailsCommand::Private::slotDialogClosed()
 {
     finished();
 }
 
 #undef q_func
 #undef d_func
 
 #include "moc_detailscommand.cpp"
diff --git a/src/dialogs/certificatedetailsdialog.cpp b/src/dialogs/certificatedetailsdialog.cpp
new file mode 100644
index 000000000..94adf7b1d
--- /dev/null
+++ b/src/dialogs/certificatedetailsdialog.cpp
@@ -0,0 +1,68 @@
+/*  SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
+    SPDX-FileCopyrightText: 2017 Intevation GmbH
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include "certificatedetailsdialog.h"
+
+#include "certificatedetailswidget.h"
+
+#include <KConfigGroup>
+#include <KLocalizedString>
+#include <KSharedConfig>
+
+#include <QDialogButtonBox>
+#include <QPushButton>
+#include <QVBoxLayout>
+
+#include <gpgme++/key.h>
+
+CertificateDetailsDialog::CertificateDetailsDialog(QWidget *parent)
+    : QDialog(parent)
+{
+    setWindowTitle(i18nc("@title:window", "Certificate Details"));
+    auto l = new QVBoxLayout(this);
+    l->addWidget(new CertificateDetailsWidget(this));
+
+    auto bbox = new QDialogButtonBox(this);
+    auto btn = bbox->addButton(QDialogButtonBox::Close);
+    connect(btn, &QPushButton::pressed, this, &QDialog::accept);
+    l->addWidget(bbox);
+    readConfig();
+}
+
+CertificateDetailsDialog::~CertificateDetailsDialog()
+{
+    writeConfig();
+}
+
+void CertificateDetailsDialog::readConfig()
+{
+    KConfigGroup dialog(KSharedConfig::openStateConfig(), "CertificateDetailsDialog");
+    const QSize size = dialog.readEntry("Size", QSize(730, 280));
+    if (size.isValid()) {
+        resize(size);
+    }
+}
+
+void CertificateDetailsDialog::writeConfig()
+{
+    KConfigGroup dialog(KSharedConfig::openStateConfig(), "CertificateDetailsDialog");
+    dialog.writeEntry("Size", size());
+    dialog.sync();
+}
+
+void CertificateDetailsDialog::setKey(const GpgME::Key &key)
+{
+    auto w = findChild<CertificateDetailsWidget*>();
+    Q_ASSERT(w);
+    w->setKey(key);
+}
+
+GpgME::Key CertificateDetailsDialog::key() const
+{
+    auto w = findChild<CertificateDetailsWidget*>();
+    Q_ASSERT(w);
+    return w->key();
+}
diff --git a/src/dialogs/certificatedetailsdialog.h b/src/dialogs/certificatedetailsdialog.h
new file mode 100644
index 000000000..6e9fdfcb3
--- /dev/null
+++ b/src/dialogs/certificatedetailsdialog.h
@@ -0,0 +1,27 @@
+/*  SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#pragma once
+
+#include <QDialog>
+
+namespace GpgME {
+class Key;
+}
+
+class CertificateDetailsDialog : public QDialog
+{
+    Q_OBJECT
+public:
+    explicit CertificateDetailsDialog(QWidget *parent = nullptr);
+    ~CertificateDetailsDialog() override;
+
+    void setKey(const GpgME::Key &key);
+    GpgME::Key key() const;
+
+private:
+    void readConfig();
+    void writeConfig();
+};
diff --git a/src/dialogs/certificatedetailswidget.cpp b/src/dialogs/certificatedetailswidget.cpp
index 453641c54..4c278f424 100644
--- a/src/dialogs/certificatedetailswidget.cpp
+++ b/src/dialogs/certificatedetailswidget.cpp
@@ -1,678 +1,626 @@
 /*  SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2017 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "certificatedetailswidget.h"
 #include "ui_certificatedetailswidget.h"
 #include "kleopatra_debug.h"
 #include "exportdialog.h"
 #include "trustchainwidget.h"
 #include "subkeyswidget.h"
 #include "weboftrustdialog.h"
 
 #include "commands/changepassphrasecommand.h"
 #include "commands/changeexpirycommand.h"
 #include "commands/certifycertificatecommand.h"
 #include "commands/revokecertificationcommand.h"
 #include "commands/adduseridcommand.h"
 #include "commands/genrevokecommand.h"
 #include "commands/detailscommand.h"
 #include "commands/dumpcertificatecommand.h"
 
 #include "utils/tags.h"
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Dn>
 #include <Libkleo/KeyCache>
 
 #include <gpgme++/context.h>
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <gpgme++/tofuinfo.h>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/KeyListJob>
 
 #include <QDateTime>
-#include <QDialogButtonBox>
 #include <QMenu>
-#include <KConfigGroup>
-#include <KSharedConfig>
 #include <QLocale>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 #if GPGMEPP_VERSION >= 0x10F00 // 1.15.0
 # define GPGME_HAS_WITH_SECRET
 # include <QGpgME/Debug>
 #endif
 
 #define HIDE_ROW(row) \
     ui.row->setVisible(false); \
     ui.row##Lbl->setVisible(false);
 
 Q_DECLARE_METATYPE(GpgME::UserID)
 
 using namespace Kleo;
 
 class CertificateDetailsWidget::Private
 {
 public:
     Private(CertificateDetailsWidget *parent)
         : updateInProgress (false), q(parent)
     {}
 
     void setupCommonProperties();
     void setupPGPProperties();
     void setupSMIMEProperties();
 
     void revokeUID(const GpgME::UserID &uid);
     void genRevokeCert();
     void certifyClicked();
     void webOfTrustClicked();
     void exportClicked();
     void addUserID();
     void changePassphrase();
     void changeExpiration();
     void keysMayHaveChanged();
     void showTrustChainDialog();
     void showMoreDetails();
     void publishCertificate();
     void userIDTableContextMenuRequested(const QPoint &p);
 
     QString tofuTooltipString(const GpgME::UserID &uid) const;
 
     void smimeLinkActivated(const QString &link);
 
     void setUpdatedKey(const GpgME::Key &key);
     void keyListDone(const GpgME::KeyListResult &,
                      const std::vector<GpgME::Key> &, const QString &,
                      const GpgME::Error &);
 
     Ui::CertificateDetailsWidget ui;
     GpgME::Key key;
     bool updateInProgress;
 private:
     CertificateDetailsWidget *const q;
 };
 
 void CertificateDetailsWidget::Private::setupCommonProperties()
 {
     // TODO: Enable once implemented
     HIDE_ROW(publishing)
 
     const bool hasSecret = key.hasSecret();
     const bool isOpenPGP = key.protocol() == GpgME::OpenPGP;
     // TODO: Enable once implemented
     const bool canRevokeUID = false; // isOpenPGP && hasSecret
 
     ui.changePassphraseBtn->setVisible(hasSecret);
     ui.genRevokeBtn->setVisible(isOpenPGP && hasSecret);
     ui.certifyBtn->setVisible(isOpenPGP && !hasSecret);
     ui.changeExpirationBtn->setVisible(isOpenPGP && hasSecret);
     ui.addUserIDBtn->setVisible(hasSecret && isOpenPGP);
     ui.webOfTrustBtn->setVisible(isOpenPGP);
 
     ui.hboxLayout_1->addStretch(1);
 
     ui.validFrom->setText(Kleo::Formatting::creationDateString(key));
     const QString expiry = Kleo::Formatting::expirationDateString(key);
     ui.expires->setText(expiry.isEmpty() ? i18nc("Expires", "never") : expiry);
     ui.type->setText(Kleo::Formatting::type(key));
     ui.fingerprint->setText(Formatting::prettyID(key.primaryFingerprint()));
 
     if (Kleo::Formatting::complianceMode().isEmpty()) {
         HIDE_ROW(compliance)
     } else {
         ui.complianceLbl->setText(Kleo::Formatting::complianceStringForKey(key));
     }
 
     ui.userIDTable->clear();
 
     QStringList headers = { i18n("Email"), i18n("Name"), i18n("Trust Level"), i18n("Tags") };
     if (canRevokeUID) {
         headers << QString();
     }
     ui.userIDTable->setColumnCount(headers.count());
     ui.userIDTable->setColumnWidth(0, 200);
     ui.userIDTable->setColumnWidth(1, 200);
     ui.userIDTable->setHeaderLabels(headers);
 
     const auto uids = key.userIDs();
     for (unsigned int i = 0; i < uids.size(); ++i) {
         const auto &uid = uids[i];
         auto item = new QTreeWidgetItem;
         const QString toolTip = tofuTooltipString(uid);
         item->setData(0, Qt::UserRole, QVariant::fromValue(uid));
 
         auto pMail = Kleo::Formatting::prettyEMail(uid);
         auto pName = Kleo::Formatting::prettyName(uid);
         if (!isOpenPGP && pMail.isEmpty() && !pName.isEmpty()) {
             // S/MIME UserIDs are sometimes split, with one userID
             // containing the name another the Mail, we merge these
             // UID's into a single item.
 
             if (i + 1 < uids.size()) {
                 pMail = Kleo::Formatting::prettyEMail(uids[i + 1]);
                 // skip next uid
                 ++i;
             }
         }
 
         if (!isOpenPGP && pMail.isEmpty() && pName.isEmpty()) {
             // S/MIME certificates sometimes contain urls where both
             // name and mail is empty. In that case we print whatever
             // the uid is as name.
             //
             // Can be ugly like (3:uri24:http://ca.intevation.org), but
             // this is better then showing an empty entry.
             pName = QString::fromLatin1(uid.id());
         }
 
         item->setData(0, Qt::DisplayRole, pMail);
         item->setData(0, Qt::ToolTipRole, toolTip);
         item->setData(1, Qt::DisplayRole, pName);
         item->setData(1, Qt::ToolTipRole, toolTip);
 
         QIcon trustIcon;
         if (updateInProgress) {
            trustIcon = QIcon::fromTheme(QStringLiteral("emblem-question"));
            item->setData(2, Qt::DisplayRole, i18n("Updating..."));
         } else {
             switch (uid.validity()) {
             case GpgME::UserID::Unknown:
             case GpgME::UserID::Undefined:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-question"));
                 break;
             case GpgME::UserID::Never:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-error"));
                 break;
             case GpgME::UserID::Marginal:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-warning"));
                 break;
             case GpgME::UserID::Full:
             case GpgME::UserID::Ultimate:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-success"));
                 break;
             }
             item->setData(2, Qt::DisplayRole, Kleo::Formatting::validityShort(uid));
         }
         item->setData(2, Qt::DecorationRole, trustIcon);
         item->setData(2, Qt::ToolTipRole, toolTip);
 
         GpgME::Error err;
         QStringList tagList;
 #ifdef GPGME_HAS_REMARKS
         for (const auto &tag: uid.remarks(Tags::tagKeys(), err)) {
             if (err) {
                 qCWarning(KLEOPATRA_LOG) << "Getting remarks for user id" << uid.id() << "failed:" << err;
             }
             tagList << QString::fromStdString(tag);
         }
         qCDebug(KLEOPATRA_LOG) << "tagList:" << tagList;
 #endif
         const auto tags = tagList.join(QStringLiteral("; "));
         item->setData(3, Qt::DisplayRole, tags);
         item->setData(3, Qt::ToolTipRole, toolTip);
 
         ui.userIDTable->addTopLevelItem(item);
 
         if (canRevokeUID) {
             auto button = new QPushButton;
             button->setIcon(QIcon::fromTheme(QStringLiteral("entry-delete")));
             button->setToolTip(i18n("Revoke this User ID"));
             button->setMaximumWidth(32);
             QObject::connect(button, &QPushButton::clicked,
                             q, [this, uid]() { revokeUID(uid); });
             ui.userIDTable->setItemWidget(item, 4, button);
         }
     }
     if (!Tags::tagsEnabled()) {
         ui.userIDTable->hideColumn(3);
     }
 }
 
 void CertificateDetailsWidget::Private::revokeUID(const GpgME::UserID &uid)
 {
     Q_UNUSED(uid)
     qCWarning(KLEOPATRA_LOG) << "Revoking UserID is not implemented. How did you even get here?!?!";
 }
 
 void CertificateDetailsWidget::Private::changeExpiration()
 {
     auto cmd = new Kleo::Commands::ChangeExpiryCommand(key);
     QObject::connect(cmd, &Kleo::Commands::ChangeExpiryCommand::finished,
                      q, [this]() {
                          ui.changeExpirationBtn->setEnabled(true);
                      });
     ui.changeExpirationBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::changePassphrase()
 {
     auto cmd = new Kleo::Commands::ChangePassphraseCommand(key);
     QObject::connect(cmd, &Kleo::Commands::ChangePassphraseCommand::finished,
                      q, [this]() {
                          ui.changePassphraseBtn->setEnabled(true);
                      });
     ui.changePassphraseBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::genRevokeCert()
 {
     auto cmd = new Kleo::Commands::GenRevokeCommand(key);
     QObject::connect(cmd, &Kleo::Commands::GenRevokeCommand::finished,
                      q, [this]() {
                          ui.genRevokeBtn->setEnabled(true);
                      });
     ui.genRevokeBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::certifyClicked()
 {
     auto cmd = new Kleo::Commands::CertifyCertificateCommand(key);
     QObject::connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
                      q, [this]() {
                          ui.certifyBtn->setEnabled(true);
                      });
     ui.certifyBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::webOfTrustClicked()
 {
     QScopedPointer<WebOfTrustDialog> dlg(new WebOfTrustDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::exportClicked()
 {
     QScopedPointer<ExportDialog> dlg(new ExportDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::addUserID()
 {
     auto cmd = new Kleo::Commands::AddUserIDCommand(key);
     QObject::connect(cmd, &Kleo::Commands::AddUserIDCommand::finished,
                      q, [this]() {
                          ui.addUserIDBtn->setEnabled(true);
                          key.update();
                          q->setKey(key);
                      });
     ui.addUserIDBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::keysMayHaveChanged()
 {
     auto newKey = Kleo::KeyCache::instance()->findByFingerprint(key.primaryFingerprint());
     if (!newKey.isNull()) {
         setUpdatedKey(newKey);
     }
 }
 
 void CertificateDetailsWidget::Private::showTrustChainDialog()
 {
     QScopedPointer<TrustChainDialog> dlg(new TrustChainDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::publishCertificate()
 {
     qCWarning(KLEOPATRA_LOG) << "publishCertificateis not implemented.";
     //TODO
 }
 
 void CertificateDetailsWidget::Private::userIDTableContextMenuRequested(const QPoint &p)
 {
     auto item = ui.userIDTable->itemAt(p);
     if (!item) {
         return;
     }
 
     const auto userID = item->data(0, Qt::UserRole).value<GpgME::UserID>();
 
     auto menu = new QMenu(q);
     menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-sign")),
                     i18n("Certify..."),
                     q, [this, userID]() {
         auto cmd = new Kleo::Commands::CertifyCertificateCommand(userID);
         ui.userIDTable->setEnabled(false);
         connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
                 q, [this]() {
             ui.userIDTable->setEnabled(true);
             // Trigger an update when done
             q->setKey(key);
         });
         cmd->start();
     });
     if (Kleo::Commands::RevokeCertificationCommand::isSupported()) {
         menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-revoke")),
                         i18n("Revoke Certification..."),
                         q, [this, userID]() {
             auto cmd = new Kleo::Commands::RevokeCertificationCommand(userID);
             ui.userIDTable->setEnabled(false);
             connect(cmd, &Kleo::Commands::RevokeCertificationCommand::finished,
                     q, [this]() {
                 ui.userIDTable->setEnabled(true);
                 // Trigger an update when done
                 q->setKey(key);
             });
             cmd->start();
         });
     }
     connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
     menu->popup(ui.userIDTable->viewport()->mapToGlobal(p));
 }
 
 void CertificateDetailsWidget::Private::showMoreDetails()
 {
     ui.moreDetailsBtn->setEnabled(false);
     if (key.protocol() == GpgME::CMS) {
         auto cmd = new Kleo::Commands::DumpCertificateCommand(key);
         connect(cmd, &Kleo::Commands::DumpCertificateCommand::finished,
                 q, [this]() {
                     ui.moreDetailsBtn->setEnabled(true);
                 });
         cmd->setUseDialog(true);
         cmd->start();
     } else {
         QScopedPointer<SubKeysDialog> dlg(new SubKeysDialog(q));
         dlg->setKey(key);
         dlg->exec();
         ui.moreDetailsBtn->setEnabled(true);
     }
 }
 
 QString CertificateDetailsWidget::Private::tofuTooltipString(const GpgME::UserID &uid) const
 {
     const auto tofu = uid.tofuInfo();
     if (tofu.isNull()) {
         return QString();
     }
 
     QString html = QStringLiteral("<table border=\"0\" cell-padding=\"5\">");
     const auto appendRow = [&html](const QString &lbl, const QString &val) {
         html += QStringLiteral("<tr>"
                                "<th style=\"text-align: right; padding-right: 5px; white-space: nowrap;\">%1:</th>"
                                "<td style=\"white-space: nowrap;\">%2</td>"
                                "</tr>")
                     .arg(lbl, val);
     };
     const auto appendHeader = [this, &html](const QString &hdr) {
         html += QStringLiteral("<tr><th colspan=\"2\" style=\"background-color: %1; color: %2\">%3</th></tr>")
                     .arg(q->palette().highlight().color().name(),
                          q->palette().highlightedText().color().name(),
                          hdr);
     };
     const auto dateTime = [](long ts) {
         QLocale l;
         return ts == 0 ? i18n("never") : l.toString(QDateTime::fromSecsSinceEpoch(ts), QLocale::ShortFormat);
     };
     appendHeader(i18n("Signing"));
     appendRow(i18n("First message"), dateTime(tofu.signFirst()));
     appendRow(i18n("Last message"), dateTime(tofu.signLast()));
     appendRow(i18n("Message count"), QString::number(tofu.signCount()));
     appendHeader(i18n("Encryption"));
     appendRow(i18n("First message"), dateTime(tofu.encrFirst()));
     appendRow(i18n("Last message"), dateTime(tofu.encrLast()));
     appendRow(i18n("Message count"), QString::number(tofu.encrCount()));
 
     html += QStringLiteral("</table>");
     // Make sure the tooltip string is different for each UserID, even if the
     // data are the same, otherwise the tooltip is not updated and moved when
     // user moves mouse from one row to another.
     html += QStringLiteral("<!-- %1 //-->").arg(QString::fromUtf8(uid.id()));
     return html;
 }
 
 
 void CertificateDetailsWidget::Private::setupPGPProperties()
 {
     HIDE_ROW(smimeOwner)
     HIDE_ROW(smimeIssuer)
     ui.smimeRelatedAddresses->setVisible(false);
     ui.trustChainDetailsBtn->setVisible(false);
 
     ui.userIDTable->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(ui.userIDTable, &QAbstractItemView::customContextMenuRequested,
             q, [this](const QPoint &p) { userIDTableContextMenuRequested(p); });
 }
 
 static QString formatDNToolTip(const Kleo::DN &dn)
 {
     QString html = QStringLiteral("<table border=\"0\" cell-spacing=15>");
 
     const auto appendRow = [&html, dn](const QString &lbl, const QString &attr) {
                                 const QString val = dn[attr];
                                 if (!val.isEmpty()) {
                                     html += QStringLiteral(
                                             "<tr><th style=\"text-align: left; white-space: nowrap\">%1:</th>"
                                                 "<td style=\"white-space: nowrap\">%2</td>"
                                             "</tr>").arg(lbl, val);
                                 }
                             };
     appendRow(i18n("Common Name"), QStringLiteral("CN"));
     appendRow(i18n("Organization"), QStringLiteral("O"));
     appendRow(i18n("Street"), QStringLiteral("STREET"));
     appendRow(i18n("City"),  QStringLiteral("L"));
     appendRow(i18n("State"), QStringLiteral("ST"));
     appendRow(i18n("Country"), QStringLiteral("C"));
     html += QStringLiteral("</table>");
 
     return html;
 }
 
 void CertificateDetailsWidget::Private::setupSMIMEProperties()
 {
     HIDE_ROW(publishing)
 
     const auto ownerId = key.userID(0);
     const Kleo::DN dn(ownerId.id());
     const QString cn = dn[QStringLiteral("CN")];
     const QString o = dn[QStringLiteral("O")];
     const QString dnEmail = dn[QStringLiteral("EMAIL")];
     const QString name = cn.isEmpty() ? dnEmail : cn;
 
     QString owner;
     if (name.isEmpty()) {
         owner = dn.dn();
     } else if (o.isEmpty()) {
         owner = name;
     } else {
         owner = i18nc("<name> of <company>", "%1 of %2", name, o);
     }
     ui.smimeOwner->setText(owner);
     ui.smimeOwner->setTextInteractionFlags(Qt::TextBrowserInteraction);
 
     const Kleo::DN issuerDN(key.issuerName());
     const QString issuerCN = issuerDN[QStringLiteral("CN")];
     const QString issuer = issuerCN.isEmpty() ? QString::fromUtf8(key.issuerName()) : issuerCN;
     ui.smimeIssuer->setText(QStringLiteral("<a href=\"#issuerDetails\">%1</a>").arg(issuer));
 
     ui.smimeIssuer->setToolTip(formatDNToolTip(issuerDN));
 
     ui.smimeOwner->setToolTip(formatDNToolTip(dn));
 
 }
 
 void CertificateDetailsWidget::Private::smimeLinkActivated(const QString &link)
 {
     if (link == QLatin1String("#issuerDetails")) {
         const auto parentKey = KeyCache::instance()->findIssuers(key, KeyCache::NoOption);
 
         if (!parentKey.size()) {
             return;
         }
         auto cmd = new Kleo::Commands::DetailsCommand(parentKey[0], nullptr);
         cmd->setParentWidget(q);
         cmd->start();
         return;
     }
     qCWarning(KLEOPATRA_LOG) << "Unknown link activated:" << link;
 }
 
 CertificateDetailsWidget::CertificateDetailsWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
     d->ui.setupUi(this);
 
     connect(d->ui.addUserIDBtn, &QPushButton::clicked,
             this, [this]() { d->addUserID(); });
     connect(d->ui.changePassphraseBtn, &QPushButton::clicked,
             this, [this]() { d->changePassphrase(); });
     connect(d->ui.genRevokeBtn, &QPushButton::clicked,
             this, [this]() { d->genRevokeCert(); });
     connect(d->ui.changeExpirationBtn, &QPushButton::clicked,
             this, [this]() { d->changeExpiration(); });
     connect(d->ui.smimeOwner, &QLabel::linkActivated,
             this, [this](const QString &link) { d->smimeLinkActivated(link); });
     connect(d->ui.smimeIssuer, &QLabel::linkActivated,
             this, [this](const QString &link) { d->smimeLinkActivated(link); });
     connect(d->ui.trustChainDetailsBtn, &QPushButton::pressed,
             this, [this]() { d->showTrustChainDialog(); });
     connect(d->ui.moreDetailsBtn, &QPushButton::pressed,
             this, [this]() { d->showMoreDetails(); });
     connect(d->ui.publishing, &QPushButton::pressed,
             this, [this]() { d->publishCertificate(); });
     connect(d->ui.certifyBtn, &QPushButton::clicked,
             this, [this]() { d->certifyClicked(); });
     connect(d->ui.webOfTrustBtn, &QPushButton::clicked,
             this, [this]() { d->webOfTrustClicked(); });
     connect(d->ui.exportBtn, &QPushButton::clicked,
             this, [this]() { d->exportClicked(); });
 
     connect(Kleo::KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, [this]() { d->keysMayHaveChanged(); });
 }
 
 CertificateDetailsWidget::~CertificateDetailsWidget()
 {
 }
 
 void CertificateDetailsWidget::Private::keyListDone(const GpgME::KeyListResult &,
                                                     const std::vector<GpgME::Key> &keys,
                                                     const QString &,
                                                     const GpgME::Error &) {
         updateInProgress = false;
         if (keys.size() != 1) {
             qCWarning(KLEOPATRA_LOG) << "Invalid keylist result in update.";
             return;
         }
         // As we listen for keysmayhavechanged we get the update
         // after updating the keycache.
         KeyCache::mutableInstance()->insert(keys);
 }
 
 void CertificateDetailsWidget::Private::setUpdatedKey(const GpgME::Key &k)
 {
     key = k;
 
     setupCommonProperties();
     if (key.protocol() == GpgME::OpenPGP) {
         setupPGPProperties();
     } else {
         setupSMIMEProperties();
     }
 }
 
 void CertificateDetailsWidget::setKey(const GpgME::Key &key)
 {
     if (key.protocol() == GpgME::CMS) {
         // For everything but S/MIME this should be quick
         // and we don't need to show another status.
         d->updateInProgress = true;
     }
     d->setUpdatedKey(key);
 
     // Run a keylistjob with full details (TOFU / Validate)
     QGpgME::KeyListJob *job = key.protocol() == GpgME::OpenPGP ? QGpgME::openpgp()->keyListJob(false, true, true) :
                                                                  QGpgME::smime()->keyListJob(false, true, true);
 
     auto ctx = QGpgME::Job::context(job);
     ctx->addKeyListMode(GpgME::WithTofu);
     ctx->addKeyListMode(GpgME::SignatureNotations);
 #ifdef GPGME_HAS_WITH_SECRET
     if (key.hasSecret()) {
         ctx->addKeyListMode(GpgME::WithSecret);
     }
 #endif
 
     // Windows QGpgME new style connect problem makes this necessary.
     connect(job, SIGNAL(result(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)),
             this, SLOT(keyListDone(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)));
 
 #ifdef GPGME_HAS_WITH_SECRET
     job->start(QStringList() << QLatin1String(key.primaryFingerprint()));
 #else
     job->start(QStringList() << QLatin1String(key.primaryFingerprint()), key.hasSecret());
 #endif
 }
 
 GpgME::Key CertificateDetailsWidget::key() const
 {
     return d->key;
 }
 
-CertificateDetailsDialog::CertificateDetailsDialog(QWidget *parent)
-    : QDialog(parent)
-{
-    setWindowTitle(i18nc("@title:window", "Certificate Details"));
-    auto l = new QVBoxLayout(this);
-    l->addWidget(new CertificateDetailsWidget(this));
-
-    auto bbox = new QDialogButtonBox(this);
-    auto btn = bbox->addButton(QDialogButtonBox::Close);
-    connect(btn, &QPushButton::pressed, this, &QDialog::accept);
-    l->addWidget(bbox);
-    readConfig();
-}
-
-CertificateDetailsDialog::~CertificateDetailsDialog()
-{
-    writeConfig();
-}
-
-void CertificateDetailsDialog::readConfig()
-{
-    KConfigGroup dialog(KSharedConfig::openStateConfig(), "CertificateDetailsDialog");
-    const QSize size = dialog.readEntry("Size", QSize(730, 280));
-    if (size.isValid()) {
-        resize(size);
-    }
-}
-
-void CertificateDetailsDialog::writeConfig()
-{
-    KConfigGroup dialog(KSharedConfig::openStateConfig(), "CertificateDetailsDialog");
-    dialog.writeEntry("Size", size());
-    dialog.sync();
-}
-
-void CertificateDetailsDialog::setKey(const GpgME::Key &key)
-{
-    auto w = findChild<CertificateDetailsWidget*>();
-    Q_ASSERT(w);
-    w->setKey(key);
-}
-
-GpgME::Key CertificateDetailsDialog::key() const
-{
-    auto w = findChild<CertificateDetailsWidget*>();
-    Q_ASSERT(w);
-    return w->key();
-}
-
 #include "moc_certificatedetailswidget.cpp"
diff --git a/src/dialogs/certificatedetailswidget.h b/src/dialogs/certificatedetailswidget.h
index 276e9768f..889c63058 100644
--- a/src/dialogs/certificatedetailswidget.h
+++ b/src/dialogs/certificatedetailswidget.h
@@ -1,55 +1,37 @@
 /*  SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QWidget>
-#include <QDialog>
 
 #include <vector>
 
 namespace GpgME {
-class Key;
 class Error;
+class Key;
 class KeyListResult;
 }
 
 class CertificateDetailsWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     explicit CertificateDetailsWidget(QWidget *parent = nullptr);
-    ~CertificateDetailsWidget();
+    ~CertificateDetailsWidget() override;
 
     void setKey(const GpgME::Key &key);
     GpgME::Key key() const;
 
 private:
     class Private;
     const QScopedPointer<Private> d;
 
     // Windows QGpgME new style connect problem makes this necessary.
     Q_PRIVATE_SLOT(d, void keyListDone(const GpgME::KeyListResult &,
                    const std::vector<GpgME::Key> &, const QString &,
                    const GpgME::Error &))
 };
-
-
-class CertificateDetailsDialog : public QDialog
-{
-    Q_OBJECT
-public:
-    explicit CertificateDetailsDialog(QWidget *parent = nullptr);
-    ~CertificateDetailsDialog();
-
-    void setKey(const GpgME::Key &key);
-    GpgME::Key key() const;
-
-private:
-    void readConfig();
-    void writeConfig();
-};
-