diff --git a/src/commands/changeexpirycommand.cpp b/src/commands/changeexpirycommand.cpp
index ea9e2651d..0b65708f8 100644
--- a/src/commands/changeexpirycommand.cpp
+++ b/src/commands/changeexpirycommand.cpp
@@ -1,272 +1,249 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/changeexpirycommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "changeexpirycommand.h"
-
 #include "command_p.h"
 
-#include <dialogs/expirydialog.h>
+#include "dialogs/expirydialog.h"
 
 #include <Libkleo/Formatting>
 
+#include <KLocalizedString>
+
 #include <QGpgME/Protocol>
 #include <QGpgME/ChangeExpiryJob>
 
+#include <QDateTime>
+
 #include <gpgme++/key.h>
 
-#include <KLocalizedString>
 #include "kleopatra_debug.h"
 
-#include <QDateTime>
-
-#include <QDebug>
-
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E01 // 1.14.1
 # define CHANGEEXPIRYJOB_SUPPORTS_SUBKEYS
 #endif
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 using namespace QGpgME;
 
 class ChangeExpiryCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::ChangeExpiryCommand;
     ChangeExpiryCommand *q_func() const
     {
         return static_cast<ChangeExpiryCommand *>(q);
     }
 public:
     explicit Private(ChangeExpiryCommand *qq, KeyListController *c);
-    ~Private();
-
-    void init();
+    ~Private() override;
 
 private:
     void slotDialogAccepted();
     void slotDialogRejected();
     void slotResult(const Error &err);
 
 private:
     void ensureDialogCreated();
     void createJob();
     void showErrorDialog(const Error &error);
     void showSuccessDialog();
 
 private:
     GpgME::Key key;
     GpgME::Subkey subkey;
     QPointer<ExpiryDialog> dialog;
     QPointer<ChangeExpiryJob> job;
 };
 
 ChangeExpiryCommand::Private *ChangeExpiryCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const ChangeExpiryCommand::Private *ChangeExpiryCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 ChangeExpiryCommand::Private::Private(ChangeExpiryCommand *qq, KeyListController *c)
-    : Command::Private(qq, c),
-      key(),
-      dialog(),
-      job()
-{
-
-}
-
-ChangeExpiryCommand::Private::~Private()
-{
-    qCDebug(KLEOPATRA_LOG);
-}
-
-ChangeExpiryCommand::ChangeExpiryCommand(KeyListController *c)
-    : Command(new Private(this, c))
+    : Command::Private{qq, c}
 {
-    d->init();
 }
 
-ChangeExpiryCommand::ChangeExpiryCommand(QAbstractItemView *v, KeyListController *c)
-    : Command(v, new Private(this, c))
-{
-    d->init();
-}
-
-ChangeExpiryCommand::ChangeExpiryCommand(const GpgME::Key &key)
-    : Command(key, new Private(this, nullptr))
-{
-    d->init();
-}
-
-void ChangeExpiryCommand::Private::init()
-{
-
-}
-
-ChangeExpiryCommand::~ChangeExpiryCommand()
-{
-    qCDebug(KLEOPATRA_LOG);
-}
-
-void ChangeExpiryCommand::setSubkey(const GpgME::Subkey &subkey)
-{
-    d->subkey = subkey;
-}
-
-void ChangeExpiryCommand::doStart()
-{
-    const std::vector<Key> keys = d->keys();
-    if (keys.size() != 1 ||
-            keys.front().protocol() != GpgME::OpenPGP ||
-            !keys.front().hasSecret() ||
-            keys.front().subkey(0).isNull()) {
-        d->finished();
-        return;
-    }
-
-    d->key = keys.front();
-
-    if (!d->subkey.isNull() &&
-            d->subkey.parent().primaryFingerprint() != d->key.primaryFingerprint()) {
-        qDebug() << "Invalid subkey" << d->subkey.fingerprint()
-                 << ": Not a subkey of key" << d->key.primaryFingerprint();
-        d->finished();
-        return;
-    }
-
-    const Subkey subkey = !d->subkey.isNull() ? d->subkey : d->key.subkey(0);
-
-    d->ensureDialogCreated();
-    Q_ASSERT(d->dialog);
-    d->dialog->setDateOfExpiry(subkey.neverExpires() ? QDate() :
-                               QDateTime::fromSecsSinceEpoch(subkey.expirationTime()).date());
-    d->dialog->show();
-
-}
+ChangeExpiryCommand::Private::~Private() = default;
 
 void ChangeExpiryCommand::Private::slotDialogAccepted()
 {
     Q_ASSERT(dialog);
 
-    static const QTime END_OF_DAY(23, 59, 59);
+    static const QTime END_OF_DAY{23, 59, 59};
 
-    const QDateTime expiry(dialog->dateOfExpiry(), END_OF_DAY);
+    const QDateTime expiry{dialog->dateOfExpiry(), END_OF_DAY};
 
     qCDebug(KLEOPATRA_LOG) << "expiry" << expiry;
 
     createJob();
     Q_ASSERT(job);
 
+#ifdef CHANGEEXPIRYJOB_SUPPORTS_SUBKEYS
     std::vector<Subkey> subkeys;
     if (!subkey.isNull()) {
         subkeys.push_back(subkey);
     }
 
-#ifdef CHANGEEXPIRYJOB_SUPPORTS_SUBKEYS
     if (const Error err = job->start(key, expiry, subkeys)) {
 #else
     if (const Error err = job->start(key, expiry)) {
 #endif
         showErrorDialog(err);
         finished();
     }
 }
 
 void ChangeExpiryCommand::Private::slotDialogRejected()
 {
     Q_EMIT q->canceled();
     finished();
 }
 
 void ChangeExpiryCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled())
         ;
     else if (err) {
         showErrorDialog(err);
     } else {
         showSuccessDialog();
     }
     finished();
 }
 
-void ChangeExpiryCommand::doCancel()
-{
-    qCDebug(KLEOPATRA_LOG);
-    if (d->job) {
-        d->job->slotCancel();
-    }
-}
-
 void ChangeExpiryCommand::Private::ensureDialogCreated()
 {
     if (dialog) {
         return;
     }
 
     dialog = new ExpiryDialog;
     applyWindowID(dialog);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
 
     connect(dialog, SIGNAL(accepted()), q, SLOT(slotDialogAccepted()));
     connect(dialog, SIGNAL(rejected()), q, SLOT(slotDialogRejected()));
 }
 
 void ChangeExpiryCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     const auto backend = (key.protocol() == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     if (!backend) {
         return;
     }
 
     ChangeExpiryJob *const j = backend->changeExpiryJob();
     if (!j) {
         return;
     }
 
     connect(j, &Job::progress,
             q, &Command::progress);
-    connect(j, SIGNAL(result(GpgME::Error)),
-            q, SLOT(slotResult(GpgME::Error)));
+    connect(j, &ChangeExpiryJob::result,
+            q, [this] (const auto &err) { slotResult(err); });
 
     job = j;
 }
 
 void ChangeExpiryCommand::Private::showErrorDialog(const Error &err)
 {
     error(i18n("<p>An error occurred while trying to change "
                "the expiry date for <b>%1</b>:</p><p>%2</p>",
                Formatting::formatForComboBox(key),
                QString::fromLocal8Bit(err.asString())),
           i18n("Expiry Date Change Error"));
 }
 
 void ChangeExpiryCommand::Private::showSuccessDialog()
 {
     information(i18n("Expiry date changed successfully."),
                 i18n("Expiry Date Change Succeeded"));
 }
 
+ChangeExpiryCommand::ChangeExpiryCommand(KeyListController *c)
+    : Command{new Private{this, c}}
+{
+}
+
+ChangeExpiryCommand::ChangeExpiryCommand(QAbstractItemView *v, KeyListController *c)
+    : Command{v, new Private{this, c}}
+{
+}
+
+ChangeExpiryCommand::ChangeExpiryCommand(const GpgME::Key &key)
+    : Command{key, new Private{this, nullptr}}
+{
+}
+
+ChangeExpiryCommand::~ChangeExpiryCommand() = default;
+
+void ChangeExpiryCommand::setSubkey(const GpgME::Subkey &subkey)
+{
+    d->subkey = subkey;
+}
+
+void ChangeExpiryCommand::doStart()
+{
+    const std::vector<Key> keys = d->keys();
+    if (keys.size() != 1 ||
+            keys.front().protocol() != GpgME::OpenPGP ||
+            !keys.front().hasSecret() ||
+            keys.front().subkey(0).isNull()) {
+        d->finished();
+        return;
+    }
+
+    d->key = keys.front();
+
+    if (!d->subkey.isNull() &&
+            d->subkey.parent().primaryFingerprint() != d->key.primaryFingerprint()) {
+        qDebug() << "Invalid subkey" << d->subkey.fingerprint()
+                 << ": Not a subkey of key" << d->key.primaryFingerprint();
+        d->finished();
+        return;
+    }
+
+    const Subkey subkey = !d->subkey.isNull() ? d->subkey : d->key.subkey(0);
+
+    d->ensureDialogCreated();
+    Q_ASSERT(d->dialog);
+    d->dialog->setDateOfExpiry(subkey.neverExpires() ? QDate() :
+                               QDateTime::fromSecsSinceEpoch(subkey.expirationTime()).date());
+    d->dialog->show();
+
+}
+
+void ChangeExpiryCommand::doCancel()
+{
+    if (d->job) {
+        d->job->slotCancel();
+    }
+}
+
 #undef d
 #undef q
 
 #include "moc_changeexpirycommand.cpp"
diff --git a/src/dialogs/expirydialog.cpp b/src/dialogs/expirydialog.cpp
index c8c5d837c..96eee2419 100644
--- a/src/dialogs/expirydialog.cpp
+++ b/src/dialogs/expirydialog.cpp
@@ -1,206 +1,206 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/expirydialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "expirydialog.h"
 
 #include "ui_expirydialog.h"
 
 #include <QDate>
-
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 
 enum Period {
     Days,
     Weeks,
     Months,
     Years,
 
     NumPeriods
 };
 
 static QDate date_by_amount_and_unit(int inAmount, int inUnit)
 {
     const QDate current = QDate::currentDate();
     switch (inUnit) {
     case Days:   return current.addDays(inAmount);
     case Weeks:  return current.addDays(7 * inAmount);
     case Months: return current.addMonths(inAmount);
     case Years:  return current.addYears(inAmount);
     default:
         Q_ASSERT(!"Should not reach here");
     }
     return QDate();
 }
 
 // these calculations should be precise enough for the forseeable future...
 static const double DAYS_IN_GREGORIAN_YEAR = 365.2425;
 
 static int monthsBetween(const QDate &d1, const QDate &d2)
 {
     const int days = d1.daysTo(d2);
     return qRound(days / DAYS_IN_GREGORIAN_YEAR * 12);
 }
 
 static int yearsBetween(const QDate &d1, const QDate &d2)
 {
     const int days = d1.daysTo(d2);
     return qRound(days / DAYS_IN_GREGORIAN_YEAR);
 }
 
 class ExpiryDialog::Private
 {
     friend class ::Kleo::Dialogs::ExpiryDialog;
     ExpiryDialog *const q;
 public:
     explicit Private(ExpiryDialog *qq)
-        : q(qq),
-          inUnit(Days),
-          ui(q)
+        : q{qq}
+        , inUnit{Days}
+        , ui{q}
     {
-        connect(ui.inSB, SIGNAL(valueChanged(int)),
-                q, SLOT(slotInAmountChanged()));
-        connect(ui.inCB, SIGNAL(currentIndexChanged(int)),
-                q, SLOT(slotInUnitChanged()));
-        connect(ui.onCW, SIGNAL(selectionChanged()),
-                q, SLOT(slotOnDateChanged()));
+        connect(ui.inSB, &QSpinBox::valueChanged,
+                q, [this] () { slotInAmountChanged(); });
+        connect(ui.inCB, QOverload<int>::of(&QComboBox::currentIndexChanged),
+                q, [this] () { slotInUnitChanged(); });
+        connect(ui.onCW, &QCalendarWidget::selectionChanged,
+                q, [this] () { slotOnDateChanged(); });
         connect(ui.onCW, &QCalendarWidget::currentPageChanged,
                 q, [this] (int year, int month) {
-                    // We select the ame day in the month when
+                    // We select the same day in the month when
                     // a page is switched.
                     auto date = ui.onCW->selectedDate();
                     if (!date.setDate(year, month, date.day())) {
                         date.setDate(year, month, 1);
                     }
                     ui.onCW->setSelectedDate(date);
                 });
 
         Q_ASSERT(ui.inCB->currentIndex() == inUnit);
     }
 
 private:
     void slotInAmountChanged();
     void slotInUnitChanged();
     void slotOnDateChanged();
 
 private:
     QDate inDate() const;
     int inAmountByDate(const QDate &date) const;
 
 private:
     int inUnit;
 
     struct UI : public Ui::ExpiryDialog {
         explicit UI(Dialogs::ExpiryDialog *qq)
-            : Ui::ExpiryDialog()
+            : Ui::ExpiryDialog{}
         {
             auto mainWidget = new QWidget(qq);
 
             setupUi(mainWidget);
             auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, qq);
             auto mainLayout = new QVBoxLayout;
             qq->setLayout(mainLayout);
             mainLayout->addWidget(mainWidget);
             QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
             okButton->setDefault(true);
             okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
             qq->connect(buttonBox, &QDialogButtonBox::accepted, qq, &QDialog::accept);
             qq->connect(buttonBox, &QDialogButtonBox::rejected, qq, &QDialog::reject);
             mainLayout->addWidget(buttonBox);
 
             Q_ASSERT(inCB->count() == NumPeriods);
 
             onCW->setMinimumDate(QDate::currentDate().addDays(1));
         }
     } ui;
 };
 
 ExpiryDialog::ExpiryDialog(QWidget *p)
-    : QDialog(p), d(new Private(this))
+    : QDialog{p}
+    , d{new Private{this}}
 {
     setWindowTitle(i18nc("@title:window", "Change Expiry"));
 }
 
-ExpiryDialog::~ExpiryDialog() {}
+ExpiryDialog::~ExpiryDialog() = default;
 
 void ExpiryDialog::setDateOfExpiry(const QDate &date)
 {
     const QDate current = QDate::currentDate();
     if (date.isValid()) {
         d->ui.onRB->setChecked(true);
         d->ui.onCW->setSelectedDate(qMax(date, current));
     } else {
         d->ui.neverRB->setChecked(true);
         d->ui.onCW->setSelectedDate(current);
         d->ui.inSB->setValue(0);
     }
 }
 
 QDate ExpiryDialog::dateOfExpiry() const
 {
     return
         d->ui.inRB->isChecked() ? d->inDate() :
         d->ui.onRB->isChecked() ? d->ui.onCW->selectedDate() :
-        QDate();
+        QDate{};
 }
 
 void ExpiryDialog::Private::slotInUnitChanged()
 {
     const int oldInAmount = ui.inSB->value();
     const QDate targetDate = date_by_amount_and_unit(oldInAmount, inUnit);
     inUnit = ui.inCB->currentIndex();
     if (targetDate.isValid()) {
         ui.inSB->setValue(inAmountByDate(targetDate));
     } else {
         slotInAmountChanged();
     }
 }
 
 void ExpiryDialog::Private::slotInAmountChanged()
 {
     // Only modify onCW when onCW is slave:
     if (ui.inRB->isChecked()) {
         ui.onCW->setSelectedDate(inDate());
     }
 }
 
 void ExpiryDialog::Private::slotOnDateChanged()
 {
     // Only modify inSB/inCB when onCW is master:
     if (ui.onRB->isChecked()) {
         ui.inSB->setValue(inAmountByDate(ui.onCW->selectedDate()));
     }
 }
 
 QDate ExpiryDialog::Private::inDate() const
 {
     return date_by_amount_and_unit(ui.inSB->value(), ui.inCB->currentIndex());
 }
 
 int ExpiryDialog::Private::inAmountByDate(const QDate &selected) const
 {
     const QDate current  = QDate::currentDate();
 
     switch (ui.inCB->currentIndex()) {
     case Days:   return current.daysTo(selected);
     case Weeks:  return qRound(current.daysTo(selected) / 7.0);
     case Months: return monthsBetween(current, selected);
     case Years:  return yearsBetween(current, selected);
     };
     Q_ASSERT(!"Should not reach here");
     return -1;
 }
 
 #include "moc_expirydialog.cpp"
diff --git a/src/dialogs/expirydialog.h b/src/dialogs/expirydialog.h
index b09736760..245eb70d6 100644
--- a/src/dialogs/expirydialog.h
+++ b/src/dialogs/expirydialog.h
@@ -1,44 +1,41 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/expirydialog.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QDialog>
 
-#include <utils/pimpl_ptr.h>
+#include <memory.h>
 
 class QDate;
 
 namespace Kleo
 {
 namespace Dialogs
 {
 
 class ExpiryDialog : public QDialog
 {
     Q_OBJECT
     Q_PROPERTY(QDate dateOfExpiry READ dateOfExpiry WRITE setDateOfExpiry)
 public:
     explicit ExpiryDialog(QWidget *parent = nullptr);
-    ~ExpiryDialog();
+    ~ExpiryDialog() override;
 
     void setDateOfExpiry(const QDate &date);
     QDate dateOfExpiry() const;
 
 private:
     class Private;
-    kdtools::pimpl_ptr<Private> d;
-    Q_PRIVATE_SLOT(d, void slotInAmountChanged())
-    Q_PRIVATE_SLOT(d, void slotInUnitChanged())
-    Q_PRIVATE_SLOT(d, void slotOnDateChanged())
+    std::unique_ptr<Private> d;
 };
 
 }
 }