diff --git a/src/crypto/gui/encryptemailwizard.cpp b/src/crypto/gui/encryptemailwizard.cpp
index cb784169c..a19a277f3 100644
--- a/src/crypto/gui/encryptemailwizard.cpp
+++ b/src/crypto/gui/encryptemailwizard.cpp
@@ -1,58 +1,58 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/encryptemailwizard.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 "encryptemailwizard.h"
 #include <crypto/gui/resolverecipientspage.h>
 
 #include <KLocalizedString>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 class EncryptEMailWizard::Private
 {
 public:
     bool m_quickMode = false;
 };
 
 EncryptEMailWizard::EncryptEMailWizard(QWidget *parent, Qt::WindowFlags flags) : SignEncryptWizard(parent, flags), d(new Private)
 {
     setWindowTitle(i18nc("@title:window", "Encrypt Mail Message"));
     std::vector<int> pageOrder;
-    pageOrder.push_back(ResolveRecipientsPage);
-    pageOrder.push_back(ResultPage);
+    pageOrder.push_back(Page::ResolveRecipients);
+    pageOrder.push_back(Page::Result);
     setPageOrder(pageOrder);
-    setCommitPage(SignEncryptWizard::ResolveRecipientsPage);
+    setCommitPage(Page::ResolveRecipients);
 }
 
 EncryptEMailWizard::~EncryptEMailWizard()
 {
 
 }
 
 bool EncryptEMailWizard::quickMode() const
 {
     return d->m_quickMode;
 }
 
 void EncryptEMailWizard::setQuickMode(bool quick)
 {
     if (quick == d->m_quickMode) {
         return;
     }
     d->m_quickMode = quick;
     signerResolvePage()->setAutoAdvance(quick);
     resolveRecipientsPage()->setAutoAdvance(quick);
     setKeepResultPageOpenWhenDone(!quick);
 }
 
 #include "encryptemailwizard.h"
diff --git a/src/crypto/gui/signemailwizard.cpp b/src/crypto/gui/signemailwizard.cpp
index 19d8572e4..bb1f2e47a 100644
--- a/src/crypto/gui/signemailwizard.cpp
+++ b/src/crypto/gui/signemailwizard.cpp
@@ -1,149 +1,149 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signemailwizard.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 "signemailwizard.h"
 
 #include "signerresolvepage.h"
 
 #include <Libkleo/Formatting>
 
 #include <KLocalizedString>
 
 #include <gpgme++/key.h>
 
 
 using namespace Kleo;
 using namespace Kleo::Crypto::Gui;
 using namespace GpgME;
 
 namespace
 {
 
 class SignerResolveValidator : public SignerResolvePage::Validator
 {
 public:
     explicit SignerResolveValidator(SignerResolvePage *page);
     bool isComplete() const override;
     QString explanation() const override;
     void update() const;
     QString customWindowTitle() const override
     {
         return QString();
     }
 
 private:
     SignerResolvePage *m_page;
     mutable QString expl;
     mutable bool complete;
 };
 }
 
 SignerResolveValidator::SignerResolveValidator(SignerResolvePage *page)
     : SignerResolvePage::Validator(), m_page(page), complete(true)
 {
     Q_ASSERT(m_page);
 }
 
 void SignerResolveValidator::update() const
 {
     const bool haveSelected = !m_page->selectedProtocols().empty();
     const std::set<Protocol> missing = m_page->selectedProtocolsWithoutSigningCertificate();
 
     complete = haveSelected && missing.empty();
     expl.clear();
     if (complete) {
         return;
     }
     if (!haveSelected) {
         expl = i18n("You need to select a signing certificate to proceed.");
         return;
     }
 
     Q_ASSERT(missing.size() <= 2);
     if (missing.size() == 1) {
         if (missing.find(OpenPGP) != missing.end()) {
             expl = i18n("You need to select an OpenPGP signing certificate to proceed.");
         } else {
             expl = i18n("You need to select an S/MIME signing certificate to proceed.");
         }
     } else {
         expl = i18n("You need to select an OpenPGP signing certificate and an S/MIME signing certificate to proceed.");
     }
 }
 
 QString SignerResolveValidator::explanation() const
 {
     update();
     return expl;
 }
 
 bool SignerResolveValidator::isComplete() const
 {
     update();
     return complete;
 }
 
 class SignEMailWizard::Private
 {
     friend class ::Kleo::Crypto::Gui::SignEMailWizard;
     SignEMailWizard *const q;
 public:
     explicit Private(SignEMailWizard *qq);
     ~Private();
 
     void operationSelected();
 
     bool m_quickMode;
 };
 
 SignEMailWizard::Private::Private(SignEMailWizard *qq)
     : q(qq), m_quickMode(false)
 {
     q->setWindowTitle(i18nc("@title:window", "Sign Mail Message"));
 
     std::vector<int> pageOrder;
     q->setSignerResolvePageValidator(std::shared_ptr<SignerResolveValidator>(new SignerResolveValidator(q->signerResolvePage())));
-    pageOrder.push_back(SignEncryptWizard::ResolveSignerPage);
-    pageOrder.push_back(SignEncryptWizard::ResultPage);
+    pageOrder.push_back(Page::ResolveSigner);
+    pageOrder.push_back(Page::Result);
     q->setPageOrder(pageOrder);
-    q->setCommitPage(SignEncryptWizard::ResolveSignerPage);
+    q->setCommitPage(Page::ResolveSigner);
     q->setEncryptionSelected(false);
     q->setEncryptionUserMutable(false);
     q->setSigningSelected(true);
     q->setSigningUserMutable(false);
     q->signerResolvePage()->setProtocolSelectionUserMutable(false);
     q->setMultipleProtocolsAllowed(false);
 }
 
 SignEMailWizard::Private::~Private() {}
 
 SignEMailWizard::SignEMailWizard(QWidget *parent, Qt::WindowFlags f)
     : SignEncryptWizard(parent, f), d(new Private(this))
 {
 }
 
 bool SignEMailWizard::quickMode() const
 {
     return d->m_quickMode;
 }
 
 void SignEMailWizard::setQuickMode(bool quick)
 {
     if (quick == d->m_quickMode) {
         return;
     }
     d->m_quickMode = quick;
     signerResolvePage()->setAutoAdvance(quick);
     setKeepResultPageOpenWhenDone(!quick);
 }
 
 SignEMailWizard::~SignEMailWizard() {}
 
diff --git a/src/crypto/gui/signencryptwizard.cpp b/src/crypto/gui/signencryptwizard.cpp
index 708bfa97d..470415f4f 100644
--- a/src/crypto/gui/signencryptwizard.cpp
+++ b/src/crypto/gui/signencryptwizard.cpp
@@ -1,283 +1,283 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signencryptwizard.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 "signencryptwizard.h"
 
 #include "objectspage.h"
 #include "resolverecipientspage.h"
 #include "signerresolvepage.h"
 #include "resultpage.h"
 
 #include <crypto/task.h>
 #include <crypto/taskcollection.h>
 #include <crypto/certificateresolver.h>
 
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
 
 #include <gpgme++/key.h>
 
 #include <KConfig>
 
 #include <QFileInfo>
 #include <QTimer>
 
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace GpgME;
 using namespace KMime::Types;
 
 class SignEncryptWizard::Private
 {
     friend class ::Kleo::Crypto::Gui::SignEncryptWizard;
     SignEncryptWizard *const q;
 public:
     explicit Private(SignEncryptWizard *qq);
     ~Private();
 
-    void setCommitPage(Page page);
+    void setCommitPage(Page::Id page);
 
-    Gui::ResolveRecipientsPage *const recipientResolvePage;  // clashes with enum of same name
+    ResolveRecipientsPage *const recipientResolvePage;
     SignerResolvePage *const signerResolvePage;
-    Gui::ObjectsPage *const objectsPage;  // clashes with enum of same name
-    Gui::ResultPage *const resultPage;   // clashes with enum of same name
+    ObjectsPage *const objectsPage;
+    ResultPage *const resultPage;
 };
 
 SignEncryptWizard::Private::Private(SignEncryptWizard *qq)
     : q(qq),
-      recipientResolvePage(new Gui::ResolveRecipientsPage),
+      recipientResolvePage(new ResolveRecipientsPage),
       signerResolvePage(new SignerResolvePage),
-      objectsPage(new Gui::ObjectsPage),
-      resultPage(new Gui::ResultPage)
+      objectsPage(new ObjectsPage),
+      resultPage(new ResultPage)
 {
-    q->setPage(SignEncryptWizard::ResolveSignerPage, signerResolvePage);
-    q->setPage(SignEncryptWizard::ObjectsPage, objectsPage);
-    q->setPage(SignEncryptWizard::ResolveRecipientsPage, recipientResolvePage);
-    q->setPage(SignEncryptWizard::ResultPage, resultPage);
+    q->setPage(Page::ResolveSigner, signerResolvePage);
+    q->setPage(Page::Objects, objectsPage);
+    q->setPage(Page::ResolveRecipients, recipientResolvePage);
+    q->setPage(Page::Result, resultPage);
     //TODO: move the RecipientPreferences creation out of here, don't create a new instance for each wizard
     recipientResolvePage->setRecipientPreferences(std::shared_ptr<RecipientPreferences>(new KConfigBasedRecipientPreferences(KSharedConfig::openConfig())));
     signerResolvePage->setSigningPreferences(std::shared_ptr<SigningPreferences>(new KConfigBasedSigningPreferences(KSharedConfig::openConfig())));
     q->resize(QSize(640, 480).expandedTo(q->sizeHint()));
 }
 
 void SignEncryptWizard::onNext(int currentId)
 {
-    if (currentId == ResolveRecipientsPage) {
+    if (currentId == Page::ResolveRecipients) {
         QTimer::singleShot(0, this, &SignEncryptWizard::recipientsResolved);
     }
-    if (currentId == ResolveSignerPage) {
+    if (currentId == Page::ResolveSigner) {
         //FIXME: Sign&Encrypt is only supported by OpenPGP. Remove this when we support this for CMS, too
         if (encryptionSelected() && signingSelected()) {
             setPresetProtocol(OpenPGP);
         }
         QTimer::singleShot(0, this, &SignEncryptWizard::signersResolved);
     }
-    if (currentId == ObjectsPage) {
+    if (currentId == Page::Objects) {
         QTimer::singleShot(0, this, &SignEncryptWizard::objectsResolved);
     }
 }
 
 SignEncryptWizard::Private::~Private() {}
 
 SignEncryptWizard::SignEncryptWizard(QWidget *p, Qt::WindowFlags f)
     : Wizard(p, f), d(new Private(this))
 {
 }
 
 SignEncryptWizard::~SignEncryptWizard() {}
 
-void SignEncryptWizard::setCommitPage(Page page)
+void SignEncryptWizard::setCommitPage(Page::Id page)
 {
     d->setCommitPage(page);
 }
 
-void SignEncryptWizard::Private::setCommitPage(Page page)
+void SignEncryptWizard::Private::setCommitPage(Page::Id page)
 {
-    q->page(ResolveSignerPage)->setCommitPage(false);
-    q->page(ResolveRecipientsPage)->setCommitPage(false);
-    q->page(ObjectsPage)->setCommitPage(false);
-    q->page(ResultPage)->setCommitPage(false);
+    q->page(Page::ResolveSigner)->setCommitPage(false);
+    q->page(Page::ResolveRecipients)->setCommitPage(false);
+    q->page(Page::Objects)->setCommitPage(false);
+    q->page(Page::Result)->setCommitPage(false);
     q->page(page)->setCommitPage(true);
 }
 
 void SignEncryptWizard::setPresetProtocol(Protocol proto)
 {
     d->signerResolvePage->setPresetProtocol(proto);
     d->signerResolvePage->setProtocolSelectionUserMutable(proto == UnknownProtocol);
     d->recipientResolvePage->setPresetProtocol(proto);
 }
 
 GpgME::Protocol SignEncryptWizard::selectedProtocol() const
 {
     return d->recipientResolvePage->selectedProtocol();
 }
 
 GpgME::Protocol SignEncryptWizard::presetProtocol() const
 {
     return d->recipientResolvePage->presetProtocol();
 }
 
 void SignEncryptWizard::setEncryptionSelected(bool selected)
 {
     d->signerResolvePage->setEncryptionSelected(selected);
 }
 
 void SignEncryptWizard::setSigningSelected(bool selected)
 {
     d->signerResolvePage->setSigningSelected(selected);
 }
 
 bool SignEncryptWizard::isSigningUserMutable() const
 {
     return d->signerResolvePage->isSigningUserMutable();
 }
 
 void SignEncryptWizard::setSigningUserMutable(bool isMutable)
 {
     d->signerResolvePage->setSigningUserMutable(isMutable);
 }
 
 bool SignEncryptWizard::isEncryptionUserMutable() const
 {
     return d->signerResolvePage->isEncryptionUserMutable();
 }
 
 bool SignEncryptWizard::isMultipleProtocolsAllowed() const
 {
     return d->recipientResolvePage->multipleProtocolsAllowed();
 }
 
 void SignEncryptWizard::setMultipleProtocolsAllowed(bool allowed)
 {
     d->signerResolvePage->setMultipleProtocolsAllowed(allowed);
     d->recipientResolvePage->setMultipleProtocolsAllowed(allowed);
 }
 
 void SignEncryptWizard::setEncryptionUserMutable(bool isMutable)
 {
     d->signerResolvePage->setEncryptionUserMutable(isMutable);
 }
 
 void SignEncryptWizard::setFiles(const QStringList &files)
 {
     d->objectsPage->setFiles(files);
 }
 
 QFileInfoList SignEncryptWizard::resolvedFiles() const
 {
     const QStringList files = d->objectsPage->files();
     QFileInfoList fileInfos;
     for (const QString &i : files) {
         fileInfos.push_back(QFileInfo(i));
     }
     return fileInfos;
 }
 
 bool SignEncryptWizard::signingSelected() const
 {
     return d->signerResolvePage->signingSelected();
 }
 
 bool SignEncryptWizard::encryptionSelected() const
 {
     return d->signerResolvePage->encryptionSelected();
 }
 
 void SignEncryptWizard::setRecipients(const std::vector<Mailbox> &recipients, const std::vector<Mailbox> &encryptToSelfRecipients)
 {
     d->recipientResolvePage->setRecipients(recipients, encryptToSelfRecipients);
 }
 
 void SignEncryptWizard::setSignersAndCandidates(const std::vector<Mailbox> &signers, const std::vector< std::vector<Key> > &keys)
 {
     d->signerResolvePage->setSignersAndCandidates(signers, keys);
 }
 
 void SignEncryptWizard::setTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     kleo_assert(coll);
     d->resultPage->setTaskCollection(coll);
 }
 
 std::vector<Key> SignEncryptWizard::resolvedCertificates() const
 {
     return d->recipientResolvePage->resolvedCertificates();
 }
 
 std::vector<Key> SignEncryptWizard::resolvedSigners() const
 {
     return d->signerResolvePage->resolvedSigners();
 }
 
 bool SignEncryptWizard::isAsciiArmorEnabled() const
 {
     return d->signerResolvePage->isAsciiArmorEnabled();
 }
 
 void SignEncryptWizard::setAsciiArmorEnabled(bool enabled)
 {
     d->signerResolvePage->setAsciiArmorEnabled(enabled);
 }
 
 bool SignEncryptWizard::recipientsUserMutable() const
 {
     return d->recipientResolvePage->recipientsUserMutable();
 }
 
 void SignEncryptWizard::setRecipientsUserMutable(bool isMutable)
 {
     d->recipientResolvePage->setRecipientsUserMutable(isMutable);
 }
 
 void SignEncryptWizard::setSignerResolvePageValidator(const std::shared_ptr<SignerResolvePage::Validator> &validator)
 {
     d->signerResolvePage->setValidator(validator);
 }
 
 Gui::SignerResolvePage *SignEncryptWizard::signerResolvePage()
 {
     return d->signerResolvePage;
 }
 
 const Gui::SignerResolvePage *SignEncryptWizard::signerResolvePage() const
 {
     return d->signerResolvePage;
 }
 
 Gui::ResolveRecipientsPage *SignEncryptWizard::resolveRecipientsPage()
 {
     return d->recipientResolvePage;
 }
 
 Gui::ObjectsPage *SignEncryptWizard::objectsPage()
 {
     return d->objectsPage;
 }
 
 Gui::ResultPage *SignEncryptWizard::resultPage()
 {
     return d->resultPage;
 }
 
 bool SignEncryptWizard::keepResultPageOpenWhenDone() const
 {
     return d->resultPage->keepOpenWhenDone();
 }
 
 void SignEncryptWizard::setKeepResultPageOpenWhenDone(bool keep)
 {
     d->resultPage->setKeepOpenWhenDone(keep);
 }
 
diff --git a/src/crypto/gui/signencryptwizard.h b/src/crypto/gui/signencryptwizard.h
index ef5bc3b04..397fe3f28 100644
--- a/src/crypto/gui/signencryptwizard.h
+++ b/src/crypto/gui/signencryptwizard.h
@@ -1,138 +1,140 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signencryptwizard.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <crypto/gui/wizard.h>
 
 #include <crypto/gui/signerresolvepage.h>
 
 #include <utils/pimpl_ptr.h>
 
 #include <KMime/HeaderParsing>
 #include <gpgme++/global.h>
 
 #include <memory>
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 }
 
 class QFileInfo;
 template <typename T> class QList;
 using QFileInfoList = QList<QFileInfo>;
 
 namespace Kleo
 {
 namespace Crypto
 {
 
 class Task;
 class TaskCollection;
 
 namespace Gui
 {
 
 class ObjectsPage;
 class ResolveRecipientsPage;
 class ResultPage;
 class SignerResolvePage;
 
 class SignEncryptWizard : public Wizard
 {
     Q_OBJECT
 public:
     explicit SignEncryptWizard(QWidget *parent = nullptr, Qt::WindowFlags f = {});
     ~SignEncryptWizard() override;
 
-    enum Page {
-        ResolveSignerPage = 0,
-        ObjectsPage,
-        ResolveRecipientsPage,
-        ResultPage
+    struct Page {
+        enum Id {
+            ResolveSigner = 0,
+            Objects,
+            ResolveRecipients,
+            Result,
+        };
     };
 
-    void setCommitPage(Page);
+    void setCommitPage(Page::Id);
 
     GpgME::Protocol presetProtocol() const;
     void setPresetProtocol(GpgME::Protocol proto);
 
     GpgME::Protocol selectedProtocol() const;
 
     /// SignOrEncryptFiles mode subinterface
     //@{
 
     QFileInfoList resolvedFiles() const;
     void setFiles(const QStringList &files);
 
     bool signingSelected() const;
     void setSigningSelected(bool selected);
 
     bool encryptionSelected() const;
     void setEncryptionSelected(bool selected);
 
     bool isSigningUserMutable() const;
     void setSigningUserMutable(bool isMutable);
 
     bool isEncryptionUserMutable() const;
     void setEncryptionUserMutable(bool isMutable);
 
     bool isMultipleProtocolsAllowed() const;
     void setMultipleProtocolsAllowed(bool allowed);
 
     //@}
 
     void setRecipients(const std::vector<KMime::Types::Mailbox> &recipients, const std::vector<KMime::Types::Mailbox> &encryptoToSelfRecipients);
 
     /** if true, the user is allowed to remove/add recipients via the UI.
      * Defaults to @p false.
      */
     bool recipientsUserMutable() const;
     void setRecipientsUserMutable(bool isMutable);
 
     void setSignersAndCandidates(const std::vector<KMime::Types::Mailbox> &signers, const std::vector< std::vector<GpgME::Key> > &keys);
 
     void setTaskCollection(const std::shared_ptr<TaskCollection> &tasks);
 
     std::vector<GpgME::Key> resolvedCertificates() const;
     std::vector<GpgME::Key> resolvedSigners() const;
 
     bool isAsciiArmorEnabled() const;
     void setAsciiArmorEnabled(bool enabled);
 
     bool keepResultPageOpenWhenDone() const;
     void setKeepResultPageOpenWhenDone(bool keep);
 
     void onNext(int currentId) override;
 
 Q_SIGNALS:
     void signersResolved();
     void objectsResolved();
     void recipientsResolved();
 
 protected:
-    Gui::SignerResolvePage *signerResolvePage();
-    const Gui::SignerResolvePage *signerResolvePage() const;
-    Gui::ObjectsPage *objectsPage();
-    Gui::ResultPage *resultPage();
-    Gui::ResolveRecipientsPage *resolveRecipientsPage();
+    SignerResolvePage *signerResolvePage();
+    const SignerResolvePage *signerResolvePage() const;
+    ObjectsPage *objectsPage();
+    ResultPage *resultPage();
+    ResolveRecipientsPage *resolveRecipientsPage();
 
     void setSignerResolvePageValidator(const std::shared_ptr<SignerResolvePage::Validator> &validator);
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
 };
 
 }
 }
 }