diff --git a/src/crypto/gui/signencryptfileswizard.cpp b/src/crypto/gui/signencryptfileswizard.cpp
index 9df8eb514..9816f9ce6 100644
--- a/src/crypto/gui/signencryptfileswizard.cpp
+++ b/src/crypto/gui/signencryptfileswizard.cpp
@@ -1,683 +1,697 @@
 /*  crypto/gui/signencryptfileswizard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencryptfileswizard.h"
 #include "signencryptwidget.h"
 
 #include "newresultpage.h"
 
 #include <fileoperationspreferences.h>
 #include <settings.h>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KColorScheme>
 #include <KConfigGroup>
 #include <KWindowConfig>
 #include <KMessageBox>
 #include <KMessageWidget>
 
 #include "kleopatra_debug.h"
 #include <Libkleo/Compliance>
 #include <Libkleo/GnuPG>
 #include <Libkleo/Formatting>
 #include <Libkleo/SystemInfo>
 
 #include <Libkleo/FileNameRequester>
 #include <QWindow>
 #include <QVBoxLayout>
 #include <QWizardPage>
 #include <QGroupBox>
 #include <QLabel>
 #include <QIcon>
 #include <QCheckBox>
 #include <QPushButton>
 #include <QStyle>
 
 #include <gpgme++/key.h>
 
 #include <array>
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto::Gui;
 
 enum Page {
     SigEncPageId,
     ResultPageId,
 
     NumPages
 };
 
 class FileNameRequesterWithIcon : public QWidget
 {
     Q_OBJECT
 
 public:
     explicit FileNameRequesterWithIcon(QDir::Filters filter, QWidget *parent = nullptr)
         : QWidget(parent)
     {
         auto layout = new QHBoxLayout{this};
         layout->setContentsMargins(0, 0, 0, 0);
         mIconLabel = new QLabel{this};
         mRequester = new FileNameRequester{filter, this};
         mRequester->setExistingOnly(false);
         layout->addWidget(mIconLabel);
         layout->addWidget(mRequester);
 
         setFocusPolicy(mRequester->focusPolicy());
         setFocusProxy(mRequester);
 
         connect(mRequester, &FileNameRequester::fileNameChanged,
                 this, &FileNameRequesterWithIcon::fileNameChanged);
     }
 
     void setIcon(const QIcon &icon)
     {
         mIconLabel->setPixmap(icon.pixmap(32, 32));
     }
 
     void setFileName(const QString &name)
     {
         mRequester->setFileName(name);
     }
 
     QString fileName() const
     {
         return mRequester->fileName();
     }
 
     void setNameFilter(const QString &nameFilter)
     {
         mRequester->setNameFilter(nameFilter);
     }
 
     QString nameFilter() const
     {
         return mRequester->nameFilter();
     }
 
     FileNameRequester *requester()
     {
         return mRequester;
     }
 
 Q_SIGNALS:
     void fileNameChanged(const QString &filename);
 
 protected:
     bool event(QEvent *e) override
     {
         if (e->type() == QEvent::ToolTipChange) {
             mRequester->setToolTip(toolTip());
         }
         return QWidget::event(e);
     }
 
 private:
     QLabel *mIconLabel;
     FileNameRequester *mRequester;
 };
 
 class SigEncPage: public QWizardPage
 {
     Q_OBJECT
 
 public:
     explicit SigEncPage(QWidget *parent = nullptr)
         : QWizardPage(parent),
           mParent((SignEncryptFilesWizard *) parent),
           mWidget(new SignEncryptWidget),
           mOutLayout(new QVBoxLayout),
           mOutputLabel{nullptr},
           mArchive(false),
           mUseOutputDir(false),
           mSingleFile{true}
     {
         setTitle(i18nc("@title", "Sign / Encrypt Files"));
         auto vLay = new QVBoxLayout(this);
         vLay->setContentsMargins(0, 0, 0, 0);
         if (!Settings{}.cmsEnabled()) {
             mWidget->setProtocol(GpgME::OpenPGP);
         }
         mWidget->setSignAsText(i18nc("@option:check on SignEncryptPage",
                                      "&Sign as:"));
         mWidget->setEncryptForMeText(i18nc("@option:check on SignEncryptPage",
                                            "Encrypt for &me:"));
         mWidget->setEncryptForOthersText(i18nc("@option:check on SignEncryptPage",
                                                "Encrypt for &others:"));
         mWidget->setEncryptWithPasswordText(i18nc("@option:check on SignEncryptPage",
                                                   "Encrypt with &password. Anyone you share the password with can read the data."));
         vLay->addWidget(mWidget);
         connect(mWidget, &SignEncryptWidget::operationChanged, this,
                 &SigEncPage::updateCommitButton);
         connect(mWidget, &SignEncryptWidget::keysChanged, this,
                 &SigEncPage::updateFileWidgets);
 
         auto outputGrp = new QGroupBox(i18nc("@title:group", "Output"));
         outputGrp->setLayout(mOutLayout);
 
         mPlaceholderWidget = new QLabel(i18n("Please select an action."));
         mOutLayout->addWidget(mPlaceholderWidget);
 
         mOutputLabel = new QLabel(i18nc("@label on SignEncryptPage", "Output &files/folder:"));
         mOutLayout->addWidget(mOutputLabel);
 
         createRequesters(mOutLayout);
 
         mUseOutputDirChk = new QCheckBox(i18nc("@option:check on SignEncryptPage",
                                                "Encrypt / Sign &each file separately."));
         mUseOutputDirChk->setToolTip(i18nc("@info:tooltip",
                                            "Keep each file separate instead of creating an archive for all."));
         mOutLayout->addWidget(mUseOutputDirChk);
         connect (mUseOutputDirChk, &QCheckBox::toggled, this, [this] (bool state) {
                     mUseOutputDir = state;
                     mArchive = !mUseOutputDir && !mSingleFile;
                     updateFileWidgets();
                 });
 
         vLay->addWidget(outputGrp);
 
         auto messageWidget = new KMessageWidget;
         messageWidget->setMessageType(KMessageWidget::Error);
         messageWidget->setIcon(style()->standardIcon(QStyle::SP_MessageBoxCritical, nullptr, this));
         messageWidget->setText(i18n("Signing and encrypting files is not possible."));
         messageWidget->setToolTip(xi18nc("@info %1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                                          "<para>You cannot use <application>Kleopatra</application> for signing or encrypting files "
                                          "because the <application>GnuPG</application> system used by <application>Kleopatra</application> is not %1.</para>",
                                          DeVSCompliance::name(true)));
         messageWidget->setCloseButtonVisible(false);
         messageWidget->setVisible(DeVSCompliance::isActive() && !DeVSCompliance::isCompliant());
         vLay->addWidget(messageWidget);
 
         setMinimumHeight(300);
     }
 
     void setEncryptionPreset(bool value)
     {
         mWidget->setEncryptionChecked(value);
     }
 
     void setSigningPreset(bool value)
     {
         mWidget->setSigningChecked(value);
     }
 
     bool isComplete() const override
     {
         if (DeVSCompliance::isActive() && !DeVSCompliance::isCompliant()) {
             return false;
         }
         return mWidget->isComplete();
     }
 
     int nextId() const override
     {
         return ResultPageId;
     }
 
     void initializePage() override
     {
         setCommitPage(true);
         updateCommitButton(mWidget->currentOp());
     }
 
     void setArchiveForced(bool archive)
     {
         mArchive = archive;
         setArchiveMutable(!archive);
     }
 
     void setArchiveMutable(bool archive)
     {
         mUseOutputDirChk->setVisible(archive);
         if (archive) {
             const KConfigGroup archCfg(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
             mUseOutputDirChk->setChecked(archCfg.readEntry("LastUseOutputDir", false));
         } else {
             mUseOutputDirChk->setChecked(false);
         }
     }
 
     void setSingleFile(bool singleFile)
     {
         mSingleFile = singleFile;
         mArchive = !mUseOutputDir && !mSingleFile;
     }
 
     bool validatePage() override
     {
         if (DeVSCompliance::isActive() && !DeVSCompliance::isCompliant()) {
             KMessageBox::error(topLevelWidget(),
                                xi18nc("@info %1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                                       "<para>Sorry! You cannot use <application>Kleopatra</application> for signing or encrypting files "
                                       "because the <application>GnuPG</application> system used by <application>Kleopatra</application> is not %1.</para>",
                                       DeVSCompliance::name(true)));
             return false;
         }
         bool sign = !mWidget->signKey().isNull();
         bool encrypt = !mWidget->selfKey().isNull() || !mWidget->recipients().empty();
         if (!mWidget->validate()) {
             return false;
         }
         mWidget->saveOwnKeys();
         if (mUseOutputDirChk->isVisible()) {
             KConfigGroup archCfg(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
             archCfg.writeEntry("LastUseOutputDir", mUseOutputDir);
         }
 
         if (sign && !encrypt && mArchive) {
             return KMessageBox::warningContinueCancel(this,
             xi18nc("@info",
             "<para>Archiving in combination with sign-only currently requires what are known as opaque signatures - "
             "unlike detached ones, these embed the content in the signature.</para>"
             "<para>This format is rather unusual. You might want to archive the files separately, "
             "and then sign the archive as one file with Kleopatra.</para>"
             "<para>Future versions of Kleopatra are expected to also support detached signatures in this case.</para>"),
             i18nc("@title:window", "Unusual Signature Warning"),
             KStandardGuiItem::cont(), KStandardGuiItem::cancel(),
             QStringLiteral("signencryptfileswizard-archive+sign-only-warning"))
             == KMessageBox::Continue;
         } else if (sign && !encrypt) {
             return true;
         }
 
         if (!mWidget->selfKey().isNull() || mWidget->encryptSymmetric()) {
             return true;
         }
         const auto recipientKeys = recipients();
         const bool hasSecret = std::any_of(std::begin(recipientKeys), std::end(recipientKeys),
                                            [](const auto &k) { return k.hasSecret(); });
         if (!hasSecret) {
             if (KMessageBox::warningContinueCancel(this,
             xi18nc("@info",
             "<para>None of the recipients you are encrypting to seems to be your own.</para>"
             "<para>This means that you will not be able to decrypt the data anymore, once encrypted.</para>"
             "<para>Do you want to continue, or cancel to change the recipient selection?</para>"),
             i18nc("@title:window", "Encrypt-To-Self Warning"),
             KStandardGuiItem::cont(),
             KStandardGuiItem::cancel(),
             QStringLiteral("warn-encrypt-to-non-self"), KMessageBox::Notify | KMessageBox::Dangerous)
             == KMessageBox::Cancel) {
                 return false;
             }
         }
         return true;
     }
 
     std::vector<Key> recipients() const
     {
         return mWidget->recipients();
     }
 
     /* In the future we might find a usecase for multiple
      * signers */
     std::vector<Key> signers() const
     {
         const Key k = mWidget->signKey();
         if (!k.isNull()) {
             return {k};
         }
         return {};
     }
 
 private:
     struct RequesterInfo {
         SignEncryptFilesWizard::KindNames id;
         QString icon;
         QString toolTip;
         QString accessibleName;
         QString nameFilterBinary;
         QString nameFilterAscii;
     };
     void createRequesters(QBoxLayout *lay) {
         static const std::array<RequesterInfo, 6> requestersInfo = {{
             {
                 SignEncryptFilesWizard::SignatureCMS,
                 QStringLiteral("document-sign"),
                 i18nc("@info:tooltip", "This is the filename of the S/MIME signature."),
                 i18nc("Lineedit accessible name", "S/MIME signature file"),
                 i18nc("Name filter binary", "S/MIME Signatures (*.p7s)"),
                 i18nc("Name filter ASCII", "S/MIME Signatures (*.p7s *.pem)"),
             },
             {
                 SignEncryptFilesWizard::SignaturePGP,
                 QStringLiteral("document-sign"),
                 i18nc("@info:tooltip", "This is the filename of the detached OpenPGP signature."),
                 i18nc("Lineedit accessible name", "OpenPGP signature file"),
                 i18nc("Name filter binary", "OpenPGP Signatures (*.sig *.pgp)"),
                 i18nc("Name filter ASCII", "OpenPGP Signatures (*.asc *.sig)"),
             },
             {
                 SignEncryptFilesWizard::CombinedPGP,
                 QStringLiteral("document-edit-sign-encrypt"),
                 i18nc("@info:tooltip", "This is the filename of the OpenPGP-signed and encrypted file."),
                 i18nc("Lineedit accessible name", "OpenPGP signed and encrypted file"),
                 i18nc("Name filter binary", "OpenPGP Files (*.gpg *.pgp)"),
                 i18nc("Name filter ASCII", "OpenPGP Files (*.asc)"),
             },
             {
                 SignEncryptFilesWizard::EncryptedPGP,
                 QStringLiteral("document-encrypt"),
                 i18nc("@info:tooltip", "This is the filename of the OpenPGP encrypted file."),
                 i18nc("Lineedit accessible name", "OpenPGP encrypted file"),
                 i18nc("Name filter binary", "OpenPGP Files (*.gpg *.pgp)"),
                 i18nc("Name filter ASCII", "OpenPGP Files (*.asc)"),
             },
             {
                 SignEncryptFilesWizard::EncryptedCMS,
                 QStringLiteral("document-encrypt"),
                 i18nc("@info:tooltip", "This is the filename of the S/MIME encrypted file."),
                 i18nc("Lineedit accessible name", "S/MIME encrypted file"),
                 i18nc("Name filter binary", "S/MIME Files (*.p7m)"),
                 i18nc("Name filter ASCII", "S/MIME Files (*.p7m *.pem)"),
             },
             {
                 SignEncryptFilesWizard::Directory,
                 QStringLiteral("folder"),
                 i18nc("@info:tooltip", "The resulting files are written to this directory."),
                 i18nc("Lineedit accessible name", "Output directory"),
                 {},
                 {},
             },
         }};
 
         if (!mRequesters.empty()) {
             return;
         }
         const bool isAscii = FileOperationsPreferences().addASCIIArmor();
         for (const auto &requester : requestersInfo) {
             const auto id = requester.id;
             auto requesterWithIcon = new FileNameRequesterWithIcon{id == SignEncryptFilesWizard::Directory ? QDir::Dirs : QDir::Files, this};
             requesterWithIcon->setIcon(QIcon::fromTheme(requester.icon));
             requesterWithIcon->setToolTip(requester.toolTip);
             requesterWithIcon->requester()->setAccessibleNameOfLineEdit(requester.accessibleName);
             requesterWithIcon->setNameFilter(isAscii ? requester.nameFilterAscii : requester.nameFilterBinary);
             lay->addWidget(requesterWithIcon);
 
             connect(requesterWithIcon, &FileNameRequesterWithIcon::fileNameChanged, this, [this, id](const QString &newName) {
                 mOutNames[id] = newName;
             });
 
             mRequesters.insert(id, requesterWithIcon);
         }
     }
 
 public:
     void setOutputNames(const QMap<int, QString> &names) {
         Q_ASSERT(mOutNames.isEmpty());
         for (auto it = std::begin(names); it != std::end(names); ++it) {
             mRequesters.value(it.key())->setFileName(it.value());
         }
         mOutNames = names;
         updateFileWidgets();
     }
 
     QMap <int, QString> outputNames() const {
         if (!mUseOutputDir) {
             auto ret = mOutNames;
             ret.remove(SignEncryptFilesWizard::Directory);
             return ret;
         }
         return mOutNames;
     }
 
     bool encryptSymmetric() const
     {
         return mWidget->encryptSymmetric();
     }
 
 private Q_SLOTS:
-    void updateCommitButton(const QString &label)
+    void updateCommitButton(const SignEncryptWidget::Operation op)
     {
         if (mParent->currentPage() != this) {
             return;
         }
+        QString label;
+        switch (op) {
+        case SignEncryptWidget::Sign:
+            label = i18nc("@action:button", "Sign");
+            break;
+        case SignEncryptWidget::Encrypt:
+            label = i18nc("@action:button", "Encrypt");
+            break;
+        case SignEncryptWidget::SignAndEncrypt:
+            label = i18nc("@action:button", "Sign / Encrypt");
+            break;
+        default:
+            ;
+        };
         auto btn = qobject_cast<QPushButton*>(mParent->button(QWizard::CommitButton));
         if (!label.isEmpty()) {
             mParent->setButtonText(QWizard::CommitButton, label);
             if (DeVSCompliance::isActive()) {
                 const bool de_vs = DeVSCompliance::isCompliant() && mWidget->isDeVsAndValid();
                 DeVSCompliance::decorate(btn, de_vs);
                 mParent->setLabelText(DeVSCompliance::name(de_vs));
             }
         } else {
             mParent->setButtonText(QWizard::CommitButton, i18n("Next"));
             btn->setIcon(QIcon());
             btn->setStyleSheet(QString());
         }
         Q_EMIT completeChanged();
     }
 
     void updateFileWidgets()
     {
         if (mRequesters.isEmpty()) {
             return;
         }
         const std::vector<Key> recipients = mWidget->recipients();
         const Key sigKey = mWidget->signKey();
         const bool pgp = mWidget->encryptSymmetric() ||
                          std::any_of(std::cbegin(recipients), std::cend(recipients),
                                      [](const auto &k) { return k.protocol() == Protocol::OpenPGP; });
         const bool cms = std::any_of(std::cbegin(recipients), std::cend(recipients),
                                      [](const auto &k) { return k.protocol() == Protocol::CMS; });
 
         mOutLayout->setEnabled(false);
         if (cms || pgp || !sigKey.isNull()) {
             mPlaceholderWidget->setVisible(false);
             mOutputLabel->setVisible(true);
             mRequesters[SignEncryptFilesWizard::SignatureCMS]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::CMS);
             mRequesters[SignEncryptFilesWizard::EncryptedCMS]->setVisible(!mUseOutputDir && cms);
             mRequesters[SignEncryptFilesWizard::CombinedPGP]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::OpenPGP && pgp);
             mRequesters[SignEncryptFilesWizard::EncryptedPGP]->setVisible(!mUseOutputDir && sigKey.protocol() != Protocol::OpenPGP && pgp);
             mRequesters[SignEncryptFilesWizard::SignaturePGP]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::OpenPGP && !pgp);
             mRequesters[SignEncryptFilesWizard::Directory]->setVisible(mUseOutputDir);
             auto firstNotHidden = std::find_if(std::cbegin(mRequesters), std::cend(mRequesters),
                                                [](auto w) { return !w->isHidden(); });
             mOutputLabel->setBuddy(*firstNotHidden);
         } else {
             mPlaceholderWidget->setVisible(true);
             mOutputLabel->setVisible(false);
             std::for_each(std::cbegin(mRequesters), std::cend(mRequesters),
                           [](auto w) { w->setVisible(false); });
             mOutputLabel->setBuddy(nullptr);
         }
         mOutLayout->setEnabled(true);
     }
 
 private:
     SignEncryptFilesWizard *mParent;
     SignEncryptWidget *mWidget;
     QMap <int, QString> mOutNames;
     QMap <int, FileNameRequesterWithIcon *> mRequesters;
     QVBoxLayout *mOutLayout;
     QWidget *mPlaceholderWidget;
     QCheckBox *mUseOutputDirChk;
     QLabel *mOutputLabel;
     bool mArchive;
     bool mUseOutputDir;
     bool mSingleFile;
 };
 
 class ResultPage : public NewResultPage
 {
     Q_OBJECT
 
 public:
     explicit ResultPage(QWidget *parent = nullptr)
         : NewResultPage(parent),
           mParent((SignEncryptFilesWizard *) parent)
     {
         setTitle(i18nc("@title", "Results"));
         setSubTitle(i18nc("@title",
                           "Status and progress of the crypto operations is shown here."));
     }
 
     void initializePage() override
     {
         mParent->setLabelText(QString());
     }
 
 private:
     SignEncryptFilesWizard *mParent;
 };
 
 SignEncryptFilesWizard::SignEncryptFilesWizard(QWidget *parent, Qt::WindowFlags f)
     : QWizard(parent, f)
 {
     readConfig();
 
     const bool de_vs = DeVSCompliance::isActive();
 #ifdef Q_OS_WIN
     // Enforce modern style to avoid vista style ugliness.
     setWizardStyle(QWizard::ModernStyle);
 #endif
     mSigEncPage = new SigEncPage(this);
     mResultPage = new ResultPage(this);
 
     connect(this, &QWizard::currentIdChanged, this,
             &SignEncryptFilesWizard::slotCurrentIdChanged);
     setPage(SigEncPageId, mSigEncPage);
     setPage(ResultPageId, mResultPage);
     setOptions(QWizard::IndependentPages |
                (de_vs ? QWizard::HaveCustomButton1 : QWizard::WizardOption(0)) |
                QWizard::NoBackButtonOnLastPage |
                QWizard::NoBackButtonOnStartPage);
 
     if (de_vs) {
         /* We use a custom button to display a label next to the
            buttons.  */
         auto btn = button(QWizard::CustomButton1);
         /* We style the button so that it looks and acts like a
            label.  */
         btn->setStyleSheet(QStringLiteral("border: none"));
         btn->setFocusPolicy(Qt::NoFocus);
     }
 }
 
 void SignEncryptFilesWizard::setLabelText(const QString &label)
 {
     button(QWizard::CommitButton)->setToolTip(label);
     setButtonText(QWizard::CustomButton1, label);
 }
 
 void SignEncryptFilesWizard::slotCurrentIdChanged(int id)
 {
     if (id == ResultPageId) {
         Q_EMIT operationPrepared();
     }
 }
 
 SignEncryptFilesWizard::~SignEncryptFilesWizard()
 {
     qCDebug(KLEOPATRA_LOG);
     writeConfig();
 }
 
 void SignEncryptFilesWizard::setSigningPreset(bool preset)
 {
     mSigEncPage->setSigningPreset(preset);
 }
 
 void SignEncryptFilesWizard::setSigningUserMutable(bool mut)
 {
     if (mut == mSigningUserMutable) {
         return;
     }
     mSigningUserMutable = mut;
 }
 
 void SignEncryptFilesWizard::setEncryptionPreset(bool preset)
 {
     mSigEncPage->setEncryptionPreset(preset);
 }
 
 void SignEncryptFilesWizard::setEncryptionUserMutable(bool mut)
 {
     if (mut == mEncryptionUserMutable) {
         return;
     }
     mEncryptionUserMutable = mut;
 }
 
 void SignEncryptFilesWizard::setArchiveForced(bool archive)
 {
     mSigEncPage->setArchiveForced(archive);
 }
 
 void SignEncryptFilesWizard::setArchiveMutable(bool archive)
 {
     mSigEncPage->setArchiveMutable(archive);
 }
 
 void SignEncryptFilesWizard::setSingleFile(bool singleFile)
 {
     mSigEncPage->setSingleFile(singleFile);
 }
 
 std::vector<Key> SignEncryptFilesWizard::resolvedRecipients() const
 {
     return mSigEncPage->recipients();
 }
 
 std::vector<Key> SignEncryptFilesWizard::resolvedSigners() const
 {
     return mSigEncPage->signers();
 }
 
 void SignEncryptFilesWizard::setTaskCollection(const std::shared_ptr<Kleo::Crypto::TaskCollection> &coll)
 {
     mResultPage->setTaskCollection(coll);
 }
 
 void SignEncryptFilesWizard::setOutputNames(const QMap<int, QString> &map) const
 {
     mSigEncPage->setOutputNames(map);
 }
 
 QMap<int, QString> SignEncryptFilesWizard::outputNames() const
 {
     return mSigEncPage->outputNames();
 }
 
 bool SignEncryptFilesWizard::encryptSymmetric() const
 {
     return mSigEncPage->encryptSymmetric();
 }
 
 void SignEncryptFilesWizard::readConfig()
 {
     winId(); // ensure there's a window created
 
     // set default window size
     windowHandle()->resize(640, 480);
 
     // restore size from config file
     KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
     KWindowConfig::restoreWindowSize(windowHandle(), cfgGroup);
 
     // NOTICE: QWindow::setGeometry() does NOT impact the backing QWidget geometry even if the platform
     // window was created -> QTBUG-40584. We therefore copy the size here.
     // TODO: remove once this was resolved in QWidget QPA
     resize(windowHandle()->size());
 }
 
 void SignEncryptFilesWizard::writeConfig()
 {
     KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
     KWindowConfig::saveWindowSize(windowHandle(), cfgGroup);
     cfgGroup.sync();
 }
 
 
 #include "signencryptfileswizard.moc"
diff --git a/src/crypto/gui/signencryptwidget.cpp b/src/crypto/gui/signencryptwidget.cpp
index bd1e59a8f..6860cacbe 100644
--- a/src/crypto/gui/signencryptwidget.cpp
+++ b/src/crypto/gui/signencryptwidget.cpp
@@ -1,690 +1,688 @@
 /*  crypto/gui/signencryptwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "signencryptwidget.h"
 
 #include "kleopatra_debug.h"
 
 #include "certificatelineedit.h"
 #include "fileoperationspreferences.h"
 #include "kleopatraapplication.h"
 #include "settings.h"
 #include "unknownrecipientwidget.h"
 
 #include "dialogs/certificateselectiondialog.h"
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QScrollArea>
 #include <QScrollBar>
 
 #include <Libkleo/DefaultKeyFilter>
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeySelectionCombo>
 #include <Libkleo/KeyListSortFilterProxyModel>
 
 #include <Libkleo/GnuPG>
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KMessageBox>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 namespace {
 class SignCertificateFilter: public DefaultKeyFilter
 {
 public:
     SignCertificateFilter(GpgME::Protocol proto) : DefaultKeyFilter()
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setHasSecret(DefaultKeyFilter::Set);
         setCanSign(DefaultKeyFilter::Set);
 
         if (proto == GpgME::OpenPGP) {
             setIsOpenPGP(DefaultKeyFilter::Set);
         } else if (proto == GpgME::CMS) {
             setIsOpenPGP(DefaultKeyFilter::NotSet);
         }
     }
 };
 class EncryptCertificateFilter: public DefaultKeyFilter
 {
 public:
     EncryptCertificateFilter(GpgME::Protocol proto): DefaultKeyFilter()
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanEncrypt(DefaultKeyFilter::Set);
 
         if (proto == GpgME::OpenPGP) {
             setIsOpenPGP(DefaultKeyFilter::Set);
         } else if (proto == GpgME::CMS) {
             setIsOpenPGP(DefaultKeyFilter::NotSet);
         }
     }
 };
 class EncryptSelfCertificateFilter: public EncryptCertificateFilter
 {
 public:
     EncryptSelfCertificateFilter(GpgME::Protocol proto): EncryptCertificateFilter(proto)
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanEncrypt(DefaultKeyFilter::Set);
         setHasSecret(DefaultKeyFilter::Set);
     }
 };
 }
 
 SignEncryptWidget::SignEncryptWidget(QWidget *parent, bool sigEncExclusive)
     : QWidget(parent),
       mModel(AbstractKeyListModel::createFlatKeyListModel(this)),
       mIsExclusive(sigEncExclusive)
 {
     auto lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
 
     mModel->useKeyCache(true, KeyList::IncludeGroups);
 
     const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
     const bool havePublicKeys = !KeyCache::instance()->keys().empty();
     const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
 
     /* The signature selection */
     auto sigLay = new QHBoxLayout;
     auto sigGrp = new QGroupBox(i18nc("@title:group", "Prove authenticity (sign)"));
     mSigChk = new QCheckBox(i18n("Sign as:"));
     mSigChk->setEnabled(haveSecretKeys);
     mSigChk->setChecked(haveSecretKeys);
 
     mSigSelect = new KeySelectionCombo();
     mSigSelect->setEnabled(mSigChk->isChecked());
 
     sigLay->addWidget(mSigChk);
     sigLay->addWidget(mSigSelect, 1);
     sigGrp->setLayout(sigLay);
     lay->addWidget(sigGrp);
 
     connect(mSigChk, &QCheckBox::toggled, mSigSelect, &QWidget::setEnabled);
     connect(mSigChk, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSigSelect, &KeySelectionCombo::currentKeyChanged,
             this, &SignEncryptWidget::updateOp);
 
     // Recipient selection
     auto encBoxLay = new QVBoxLayout;
     auto encBox = new QGroupBox(i18nc("@title:group", "Encrypt"));
     encBox->setLayout(encBoxLay);
     auto recipientGrid = new QGridLayout;
 
     // Own key
     mEncSelfChk = new QCheckBox(i18n("Encrypt for me:"));
     mEncSelfChk->setEnabled(haveSecretKeys && !symmetricOnly);
     mEncSelfChk->setChecked(haveSecretKeys && !symmetricOnly);
     mSelfSelect = new KeySelectionCombo();
     mSelfSelect->setEnabled(mEncSelfChk->isChecked());
     recipientGrid->addWidget(mEncSelfChk, 0, 0);
     recipientGrid->addWidget(mSelfSelect, 0, 1);
 
     // Checkbox for other keys
     mEncOtherChk = new QCheckBox(i18n("Encrypt for others:"));
     mEncOtherChk->setEnabled(havePublicKeys && !symmetricOnly);
     mEncOtherChk->setChecked(havePublicKeys && !symmetricOnly);
     recipientGrid->addWidget(mEncOtherChk, 1, 0, Qt::AlignTop);
     connect(mEncOtherChk, &QCheckBox::toggled, this,
         [this](bool toggled) {
             for (CertificateLineEdit *edit : std::as_const(mRecpWidgets)) {
                 edit->setEnabled(toggled);
             }
             updateOp();
         });
     mRecpLayout = new QVBoxLayout;
     recipientGrid->addLayout(mRecpLayout, 1, 1);
     recipientGrid->setRowStretch(2, 1);
 
     // Scroll area for other keys
     auto recipientWidget = new QWidget;
     auto recipientScroll = new QScrollArea;
     recipientWidget->setLayout(recipientGrid);
     recipientScroll->setWidget(recipientWidget);
     recipientScroll->setWidgetResizable(true);
     recipientScroll->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow);
     recipientScroll->setFrameStyle(QFrame::NoFrame);
     recipientScroll->setFocusPolicy(Qt::NoFocus);
     recipientGrid->setContentsMargins(0, 0, 0, 0);
     encBoxLay->addWidget(recipientScroll, 1);
 
     auto bar = recipientScroll->verticalScrollBar();
     connect (bar, &QScrollBar::rangeChanged, this, [bar] (int, int max) {
             bar->setValue(max);
         });
 
     addRecipientWidget();
 
     // Checkbox for password
     mSymmetric = new QCheckBox(i18n("Encrypt with password. Anyone you share the password with can read the data."));
     mSymmetric->setToolTip(i18nc("Tooltip information for symmetric encryption",
                                  "Additionally to the keys of the recipients you can encrypt your data with a password. "
                                  "Anyone who has the password can read the data without any secret key. "
                                  "Using a password is <b>less secure</b> then public key cryptography. Even if you pick a very strong password."));
     mSymmetric->setChecked(symmetricOnly || !havePublicKeys);
     encBoxLay->addWidget(mSymmetric);
 
     // Connect it
     connect(mEncSelfChk, &QCheckBox::toggled, mSelfSelect, &QWidget::setEnabled);
     connect(mEncSelfChk, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSymmetric, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSelfSelect, &KeySelectionCombo::currentKeyChanged,
             this, &SignEncryptWidget::updateOp);
 
     if (mIsExclusive) {
         connect(mEncOtherChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mSigChk->setChecked(false);
             }
         });
         connect(mEncSelfChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mSigChk->setChecked(false);
             }
         });
         connect(mSigChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mEncSelfChk->setChecked(false);
                 mEncOtherChk->setChecked(false);
             }
         });
     }
 
     // Ensure that the mSigChk is aligned togehter with the encryption check boxes.
     mSigChk->setMinimumWidth(qMax(mEncOtherChk->width(), mEncSelfChk->width()));
 
     lay->addWidget(encBox);
 
     connect(KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, &SignEncryptWidget::updateCheckBoxes);
     connect(KleopatraApplication::instance(), &KleopatraApplication::configurationChanged,
             this, &SignEncryptWidget::updateCheckBoxes);
 
     loadKeys();
     onProtocolChanged();
     updateOp();
 }
 
 void SignEncryptWidget::setSignAsText(const QString &text)
 {
     mSigChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptForMeText(const QString &text)
 {
     mEncSelfChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptForOthersText(const QString &text)
 {
     mEncOtherChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptWithPasswordText(const QString& text)
 {
     mSymmetric->setText(text);
 }
 
 CertificateLineEdit *SignEncryptWidget::addRecipientWidget()
 {
     return insertRecipientWidget(nullptr);
 }
 
 CertificateLineEdit *SignEncryptWidget::insertRecipientWidget(CertificateLineEdit *after)
 {
     Q_ASSERT(!after || mRecpLayout->indexOf(after) != -1);
 
     const auto index = after ? mRecpLayout->indexOf(after) + 1 : mRecpLayout->count();
 
     auto certSel = new CertificateLineEdit(mModel,
                                            new EncryptCertificateFilter(mCurrentProto),
                                            this);
     certSel->setAccessibleNameOfLineEdit(i18nc("text for screen readers", "recipient key"));
     certSel->setEnabled(mEncOtherChk->isChecked());
     mRecpWidgets.insert(index, certSel);
 
     if (mRecpLayout->count() > 0) {
         auto prevWidget = after ? after : mRecpLayout->itemAt(mRecpLayout->count() - 1)->widget();
         setTabOrder(prevWidget, certSel);
     }
     mRecpLayout->insertWidget(index, certSel);
 
     connect(certSel, &CertificateLineEdit::keyChanged,
             this, &SignEncryptWidget::recipientsChanged);
     connect(certSel, &CertificateLineEdit::editingStarted,
             this, &SignEncryptWidget::recipientsChanged);
     connect(certSel, &CertificateLineEdit::certificateSelectionRequested,
             this, [this, certSel]() { certificateSelectionRequested(certSel); });
 
     return certSel;
 }
 
 void SignEncryptWidget::addRecipient(const Key &key)
 {
     CertificateLineEdit *certSel = addRecipientWidget();
     if (!key.isNull()) {
         certSel->setKey(key);
         mAddedKeys << key;
     }
 }
 
 void SignEncryptWidget::addRecipient(const KeyGroup &group)
 {
     CertificateLineEdit *certSel = addRecipientWidget();
     if (!group.isNull()) {
         certSel->setGroup(group);
         mAddedGroups << group;
     }
 }
 
 void SignEncryptWidget::certificateSelectionRequested(CertificateLineEdit *certificateLineEdit)
 {
     CertificateSelectionDialog dlg{this};
 
     dlg.setOptions(CertificateSelectionDialog::Options(
         CertificateSelectionDialog::MultiSelection |
         CertificateSelectionDialog::EncryptOnly |
         CertificateSelectionDialog::optionsFromProtocol(mCurrentProto) |
         CertificateSelectionDialog::IncludeGroups));
 
     if (!certificateLineEdit->key().isNull()) {
         const auto key = certificateLineEdit->key();
         const auto name = QString::fromUtf8(key.userID(0).name());
         const auto email = QString::fromUtf8(key.userID(0).email());
         dlg.setStringFilter(!name.isEmpty() ? name : email);
     } else if (!certificateLineEdit->group().isNull()) {
         dlg.setStringFilter(certificateLineEdit->group().name());
     } else {
         dlg.setStringFilter(certificateLineEdit->text());
     }
 
     if (dlg.exec()) {
         const std::vector<Key> keys = dlg.selectedCertificates();
         const std::vector<KeyGroup> groups = dlg.selectedGroups();
         if (keys.size() == 0 && groups.size() == 0) {
             return;
         }
         CertificateLineEdit *certWidget = nullptr;
         for (const Key &key : keys) {
             if (!certWidget) {
                 certWidget = certificateLineEdit;
             } else {
                 certWidget = insertRecipientWidget(certWidget);
             }
             certWidget->setKey(key);
         }
         for (const KeyGroup &group : groups) {
             if (!certWidget) {
                 certWidget = certificateLineEdit;
             } else {
                 certWidget = insertRecipientWidget(certWidget);
             }
             certWidget->setGroup(group);
         }
     }
 
     recipientsChanged();
 }
 
 void SignEncryptWidget::clearAddedRecipients()
 {
     for (auto w: std::as_const(mUnknownWidgets)) {
         mRecpLayout->removeWidget(w);
         delete w;
     }
 
     for (auto &key: std::as_const(mAddedKeys)) {
         removeRecipient(key);
     }
 
     for (auto &group: std::as_const(mAddedGroups)) {
         removeRecipient(group);
     }
 }
 
 void SignEncryptWidget::addUnknownRecipient(const char *keyID)
 {
     auto unknownWidget = new UnknownRecipientWidget(keyID);
     mUnknownWidgets << unknownWidget;
 
     if (mRecpLayout->count() > 0) {
         auto lastWidget = mRecpLayout->itemAt(mRecpLayout->count() - 1)->widget();
         setTabOrder(lastWidget, unknownWidget);
     }
     mRecpLayout->addWidget(unknownWidget);
 
     connect(KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, [this] () {
         // Check if any unknown recipient can now be found.
         for (auto w: mUnknownWidgets) {
             auto key = KeyCache::instance()->findByKeyIDOrFingerprint(w->keyID().toLatin1().constData());
             if (key.isNull()) {
                 std::vector<std::string> subids;
                 subids.push_back(std::string(w->keyID().toLatin1().constData()));
                 for (const auto &subkey: KeyCache::instance()->findSubkeysByKeyID(subids)) {
                     key = subkey.parent();
                 }
             }
             if (key.isNull()) {
                 continue;
             }
             // Key is now available replace by line edit.
             qCDebug(KLEOPATRA_LOG) << "Removing widget for keyid: " << w->keyID();
             mRecpLayout->removeWidget(w);
             mUnknownWidgets.removeAll(w);
             delete w;
             addRecipient(key);
         }
     });
 }
 
 void SignEncryptWidget::recipientsChanged()
 {
     const bool hasEmptyRecpWidget =
         std::any_of(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                     [](auto w) { return w->isEmpty(); });
     if (!hasEmptyRecpWidget) {
         addRecipientWidget();
     }
     updateOp();
 }
 
 Key SignEncryptWidget::signKey() const
 {
     if (mSigSelect->isEnabled()) {
         return mSigSelect->currentKey();
     }
     return Key();
 }
 
 Key SignEncryptWidget::selfKey() const
 {
     if (mSelfSelect->isEnabled()) {
         return mSelfSelect->currentKey();
     }
     return Key();
 }
 
 std::vector<Key> SignEncryptWidget::recipients() const
 {
     std::vector<Key> ret;
     for (const CertificateLineEdit *w : std::as_const(mRecpWidgets)) {
         if (!w->isEnabled()) {
             // If one is disabled, all are disabled.
             break;
         }
         const Key k = w->key();
         const KeyGroup g = w->group();
         if (!k.isNull()) {
             ret.push_back(k);
         } else if (!g.isNull()) {
             const auto keys = g.keys();
             std::copy(keys.begin(), keys.end(), std::back_inserter(ret));
         }
     }
     const Key k = selfKey();
     if (!k.isNull()) {
         ret.push_back(k);
     }
     return ret;
 }
 
 bool SignEncryptWidget::isDeVsAndValid() const
 {
     if (!signKey().isNull()
         && (!signKey().isDeVs() || keyValidity(signKey()) < GpgME::UserID::Validity::Full)) {
         return false;
     }
 
     if (!selfKey().isNull()
         && (!selfKey().isDeVs() || keyValidity(selfKey()) < GpgME::UserID::Validity::Full)) {
         return false;
     }
 
     for (const auto &key: recipients()) {
         if (!key.isDeVs() || keyValidity(key) < GpgME::UserID::Validity::Full) {
             return false;
         }
     }
 
     return true;
 }
 
 void SignEncryptWidget::updateOp()
 {
     const Key sigKey = signKey();
     const std::vector<Key> recp = recipients();
 
-    QString newOp;
     if (!sigKey.isNull() && (!recp.empty() || encryptSymmetric())) {
-        newOp = i18nc("@action", "Sign / Encrypt");
+        mOp = SignAndEncrypt;
     } else if (!recp.empty() || encryptSymmetric()) {
-        newOp = i18nc("@action", "Encrypt");
+        mOp = Encrypt;
     } else if (!sigKey.isNull()) {
-        newOp = i18nc("@action", "Sign");
+        mOp = Sign;
     } else {
-        newOp = QString();
+        mOp = NoOperation;
     }
-    mOp = newOp;
     Q_EMIT operationChanged(mOp);
     Q_EMIT keysChanged();
 }
 
-QString SignEncryptWidget::currentOp() const
+SignEncryptWidget::Operation SignEncryptWidget::currentOp() const
 {
     return mOp;
 }
 
 namespace
 {
 bool recipientWidgetHasFocus(CertificateLineEdit *w)
 {
     // check if w (or its focus proxy) or a child widget of w has focus
     return w->hasFocus() || w->isAncestorOf(qApp->focusWidget());
 }
 }
 
 void SignEncryptWidget::recpRemovalRequested(CertificateLineEdit *w)
 {
     if (!w) {
         return;
     }
     const int emptyEdits =
         std::count_if(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                       [](auto w) { return w->isEmpty(); });
     if (emptyEdits > 1) {
         if (recipientWidgetHasFocus(w)) {
             const int index = mRecpLayout->indexOf(w);
             const auto focusWidget = (index < mRecpLayout->count() - 1) ?
                 mRecpLayout->itemAt(index + 1)->widget() :
                 mRecpLayout->itemAt(mRecpLayout->count() - 2)->widget();
             focusWidget->setFocus();
         }
         mRecpLayout->removeWidget(w);
         mRecpWidgets.removeAll(w);
         w->deleteLater();
     }
 }
 
 void SignEncryptWidget::removeRecipient(const GpgME::Key &key)
 {
     for (CertificateLineEdit *edit: std::as_const(mRecpWidgets)) {
         const auto editKey = edit->key();
         if (key.isNull() && editKey.isNull()) {
             recpRemovalRequested(edit);
             return;
         }
         if (editKey.primaryFingerprint() &&
             key.primaryFingerprint() &&
             !strcmp(editKey.primaryFingerprint(), key.primaryFingerprint())) {
             recpRemovalRequested(edit);
             return;
         }
     }
 }
 
 void SignEncryptWidget::removeRecipient(const KeyGroup &group)
 {
     for (CertificateLineEdit *edit: std::as_const(mRecpWidgets)) {
         const auto editGroup = edit->group();
         if (group.isNull() && editGroup.isNull()) {
             recpRemovalRequested(edit);
             return;
         }
         if (editGroup.name() == group.name()) {
             recpRemovalRequested(edit);
             return;
         }
     }
 }
 
 bool SignEncryptWidget::encryptSymmetric() const
 {
     return mSymmetric->isChecked();
 }
 
 void SignEncryptWidget::loadKeys()
 {
     KConfigGroup keys(KSharedConfig::openConfig(), "SignEncryptKeys");
     auto cache = KeyCache::instance();
     mSigSelect->setDefaultKey(keys.readEntry("SigningKey", QString()));
     mSelfSelect->setDefaultKey(keys.readEntry("EncryptKey", QString()));
 }
 
 void SignEncryptWidget::saveOwnKeys() const
 {
     KConfigGroup keys(KSharedConfig::openConfig(), "SignEncryptKeys");
     auto sigKey = mSigSelect->currentKey();
     auto encKey = mSelfSelect->currentKey();
     if (!sigKey.isNull()) {
         keys.writeEntry("SigningKey", sigKey.primaryFingerprint());
     }
     if (!encKey.isNull()) {
         keys.writeEntry("EncryptKey", encKey.primaryFingerprint());
     }
 }
 
 void SignEncryptWidget::setSigningChecked(bool value)
 {
     mSigChk->setChecked(value && !KeyCache::instance()->secretKeys().empty());
 }
 
 void SignEncryptWidget::setEncryptionChecked(bool checked)
 {
     if (checked) {
         const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
         const bool havePublicKeys = !KeyCache::instance()->keys().empty();
         const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
         mEncSelfChk->setChecked(haveSecretKeys && !symmetricOnly);
         mEncOtherChk->setChecked(havePublicKeys && !symmetricOnly);
         mSymmetric->setChecked(symmetricOnly || !havePublicKeys);
     } else {
         mEncSelfChk->setChecked(false);
         mEncOtherChk->setChecked(false);
         mSymmetric->setChecked(false);
     }
 }
 
 void SignEncryptWidget::setProtocol(GpgME::Protocol proto)
 {
     if (mCurrentProto == proto) {
         return;
     }
     mCurrentProto = proto;
     onProtocolChanged();
 }
 
 void Kleo::SignEncryptWidget::onProtocolChanged()
 {
     mSigSelect->setKeyFilter(std::shared_ptr<KeyFilter>(new SignCertificateFilter(mCurrentProto)));
     mSelfSelect->setKeyFilter(std::shared_ptr<KeyFilter>(new EncryptSelfCertificateFilter(mCurrentProto)));
     const auto encFilter = std::shared_ptr<KeyFilter>(new EncryptCertificateFilter(mCurrentProto));
     for (CertificateLineEdit *edit : std::as_const(mRecpWidgets)) {
         edit->setKeyFilter(encFilter);
     }
 
     if (mIsExclusive) {
         mSymmetric->setDisabled(mCurrentProto == GpgME::CMS);
         if (mSymmetric->isChecked() && mCurrentProto == GpgME::CMS) {
             mSymmetric->setChecked(false);
         }
         if (mSigChk->isChecked() && mCurrentProto == GpgME::CMS &&
                 (mEncSelfChk->isChecked() || mEncOtherChk->isChecked())) {
             mSigChk->setChecked(false);
         }
     }
 }
 
 bool SignEncryptWidget::isComplete() const
 {
-    return !currentOp().isEmpty()
+    return currentOp() != NoOperation
         && std::all_of(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                         [](auto w) { return !w->isEnabled() || w->hasAcceptableInput(); });
 }
 
 bool SignEncryptWidget::validate()
 {
     CertificateLineEdit *firstUnresolvedRecipient = nullptr;
     QStringList unresolvedRecipients;
     for (const auto edit: std::as_const(mRecpWidgets)) {
         if (edit->isEnabled() && !edit->hasAcceptableInput()) {
             if (!firstUnresolvedRecipient) {
                 firstUnresolvedRecipient = edit;
             }
             unresolvedRecipients.push_back(edit->text().toHtmlEscaped());
         }
     }
     if (!unresolvedRecipients.isEmpty()) {
         KMessageBox::errorList(this,
                                i18n("Could not find a key for the following recipients:"),
                                unresolvedRecipients,
                                i18n("Failed to find some keys"));
     }
     if (firstUnresolvedRecipient) {
         firstUnresolvedRecipient->setFocus();
     }
     return unresolvedRecipients.isEmpty();
 }
 
 void SignEncryptWidget::updateCheckBoxes()
 {
     const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
     const bool havePublicKeys = !KeyCache::instance()->keys().empty();
     const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
     mSigChk->setEnabled(haveSecretKeys);
     mEncSelfChk->setEnabled(haveSecretKeys && !symmetricOnly);
     mEncOtherChk->setEnabled(havePublicKeys && !symmetricOnly);
     if (symmetricOnly) {
         mEncSelfChk->setChecked(false);
         mEncOtherChk->setChecked(false);
         mSymmetric->setChecked(true);
     }
 }
diff --git a/src/crypto/gui/signencryptwidget.h b/src/crypto/gui/signencryptwidget.h
index 5652e08ea..c9411ec34 100644
--- a/src/crypto/gui/signencryptwidget.h
+++ b/src/crypto/gui/signencryptwidget.h
@@ -1,148 +1,154 @@
 /*  crypto/gui/signencryptwidget.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #pragma once
 
 #include <QWidget>
 #include <QVector>
 
 #include <Libkleo/KeyGroup>
 
 #include <gpgme++/key.h>
 
 class QCheckBox;
 class QVBoxLayout;
 
 namespace Kleo
 {
 class CertificateLineEdit;
 class KeySelectionCombo;
 class AbstractKeyListModel;
 class UnknownRecipientWidget;
 
 class SignEncryptWidget: public QWidget
 {
     Q_OBJECT
 public:
+    enum Operation {
+        NoOperation,
+        Sign,
+        Encrypt,
+        SignAndEncrypt
+    };
+
     /** If cmsSigEncExclusive is true CMS operations can be
      * done only either as sign or as encrypt */
     explicit SignEncryptWidget(QWidget *parent = nullptr, bool cmsSigEncExclusive = false);
 
     /** Overwrite default text with custom text, e.g. with a character marked
      *  as shortcut key. */
     void setSignAsText(const QString &text);
     void setEncryptForMeText(const QString &text);
     void setEncryptForOthersText(const QString &text);
     void setEncryptWithPasswordText(const QString &text);
 
     /** Returns the list of recipients selected in the dialog
      * or an empty list if encryption is disabled */
     std::vector<GpgME::Key> recipients() const;
 
     /** Returns the selected signing key or a null key if signing
      * is disabled. */
     GpgME::Key signKey() const;
 
     /** Returns the selected encrypt to self key or a null key if
      * encrypt to self is disabled. */
     GpgME::Key selfKey() const;
 
-    /** Returns the operation based on the current selection or
-     * a null string if nothing would happen. */
-    QString currentOp() const;
+    /** Returns the operation based on the current selection. */
+    Operation currentOp() const;
 
     /** Whether or not symmetric encryption should also be used. */
     bool encryptSymmetric() const;
 
     /** Save the currently selected signing and encrypt to self keys. */
     void saveOwnKeys() const;
 
     /** Return whether or not all keys involved in the operation are
         compliant with CO_DE_VS, and all keys are valid (i.e. all
         userIDs have Validity >= Full).  */
     bool isDeVsAndValid() const;
 
     /** Set whether or not signing group should be checked */
     void setSigningChecked(bool value);
 
     /** Set whether or not encryption group should be checked */
     void setEncryptionChecked(bool value);
 
     /** Filter for a specific protocol. Use UnknownProtocol for both
      * S/MIME and OpenPGP */
     void setProtocol(GpgME::Protocol protocol);
 
     /** Add a recipient with the key key */
     void addRecipient(const GpgME::Key &key);
 
     /** Add a group of recipients */
     void addRecipient(const Kleo::KeyGroup &group);
 
     /** Add a placehoder for an unknown key */
     void addUnknownRecipient(const char *keyId);
 
     /** Remove all Recipients added by keyId or by key. */
     void clearAddedRecipients();
 
     /** Remove a Recipient key */
     void removeRecipient(const GpgME::Key &key);
 
     /** Remove a recipient group */
     void removeRecipient(const Kleo::KeyGroup &group);
 
     /** Returns true if all required information has been entered. */
     bool isComplete() const;
 
     /** Returns true if all recipients have been resolved. Otherwise, shows
         an error message and returns false. */
     bool validate();
 
 protected Q_SLOTS:
     void updateOp();
     void recipientsChanged();
     void recpRemovalRequested(CertificateLineEdit *w);
     void certificateSelectionRequested(CertificateLineEdit *w);
 
 protected:
     void loadKeys();
 
 Q_SIGNALS:
     /* Emitted when the certificate selection changed the operation
      * with that selection. e.g. "Sign" or "Sign/Encrypt".
      * If no crypto operation is selected this returns a null string. */
-    void operationChanged(const QString &op);
+    void operationChanged(Operation op);
 
     /* Emitted when the certificate selection might be changed. */
     void keysChanged();
 
 private:
     CertificateLineEdit* addRecipientWidget();
     /** Inserts a new recipient widget after widget @p after or at the end
      *  if @p after is null. */
     CertificateLineEdit* insertRecipientWidget(CertificateLineEdit *after);
     void onProtocolChanged();
     void updateCheckBoxes();
 
 private:
     KeySelectionCombo *mSigSelect = nullptr;
     KeySelectionCombo *mSelfSelect = nullptr;
     QVector<CertificateLineEdit *> mRecpWidgets;
     QVector<UnknownRecipientWidget *> mUnknownWidgets;
     QVector<GpgME::Key> mAddedKeys;
     QVector<KeyGroup> mAddedGroups;
     QVBoxLayout *mRecpLayout = nullptr;
-    QString mOp;
+    Operation mOp;
     AbstractKeyListModel *mModel = nullptr;
     QCheckBox *mSymmetric = nullptr;
     QCheckBox *mSigChk = nullptr;
     QCheckBox *mEncOtherChk = nullptr;
     QCheckBox *mEncSelfChk = nullptr;
     GpgME::Protocol mCurrentProto = GpgME::UnknownProtocol;
     const bool mIsExclusive;
 };
 } // namespace Kleo
diff --git a/src/view/padwidget.cpp b/src/view/padwidget.cpp
index 07fed93b2..f54b7cc8e 100644
--- a/src/view/padwidget.cpp
+++ b/src/view/padwidget.cpp
@@ -1,532 +1,547 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     padwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2018 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "padwidget.h"
 
 #include "kleopatra_debug.h"
 
 #include <settings.h>
 
 #include <Libkleo/KleoException>
 #include <Libkleo/Classify>
 #include <Libkleo/Compliance>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 #include <Libkleo/SystemInfo>
 
 #include "crypto/gui/signencryptwidget.h"
 #include "crypto/gui/resultitemwidget.h"
 
 #include "crypto/signencrypttask.h"
 #include "crypto/decryptverifytask.h"
 #include <Libkleo/GnuPG>
 #include "utils/input.h"
 #include "utils/output.h"
 
 #include "commands/importcertificatefromdatacommand.h"
 
 #include <gpgme++/data.h>
 #include <gpgme++/decryptionresult.h>
 
 #include <QGpgME/DataProvider>
 
 #include <QButtonGroup>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QLabel>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QTabWidget>
 #include <QTextEdit>
 #include <QVBoxLayout>
 #include <QStyle>
 
 #include <KLocalizedString>
 #include <KColorScheme>
 #include <KMessageBox>
 #include <KMessageWidget>
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 static GpgME::Protocol getProtocol(const std::shared_ptr<const Kleo::Crypto::Task::Result> &result)
 {
     const auto dvResult = dynamic_cast<const Kleo::Crypto::DecryptVerifyResult*>(result.get());
     if (dvResult) {
         for (const auto &key: KeyCache::instance()->findRecipients(dvResult->decryptionResult())) {
             return key.protocol();
         }
         for (const auto &key: KeyCache::instance()->findSigners(dvResult->verificationResult())) {
             return key.protocol();
         }
     }
     return GpgME::UnknownProtocol;
 }
 
 class PadWidget::Private
 {
     friend class ::Kleo::PadWidget;
 
 public:
     Private(PadWidget *qq):
         q(qq),
         mEdit(new QTextEdit),
         mCryptBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("document-edit-sign-encrypt")), i18n("Sign / Encrypt Notepad"))),
         mDecryptBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("document-edit-decrypt-verify")), i18n("Decrypt / Verify Notepad"))),
         mImportBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("view-certificate-import")), i18n("Import Notepad"))),
         mRevertBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("edit-undo")), i18n("Revert"))),
         mMessageWidget{new KMessageWidget},
         mAdditionalInfoLabel(new QLabel),
         mSigEncWidget(new SignEncryptWidget(nullptr, true)),
         mProgressBar(new QProgressBar),
         mProgressLabel(new QLabel),
         mLastResultWidget(nullptr),
         mPGPRB(nullptr),
         mCMSRB(nullptr),
         mImportProto(GpgME::UnknownProtocol)
     {
         auto vLay = new QVBoxLayout(q);
 
         auto btnLay = new QHBoxLayout;
         vLay->addLayout(btnLay);
         btnLay->addWidget(mCryptBtn);
         btnLay->addWidget(mDecryptBtn);
         btnLay->addWidget(mImportBtn);
         btnLay->addWidget(mRevertBtn);
 
         mRevertBtn->setVisible(false);
 
         btnLay->addWidget(mAdditionalInfoLabel);
 
         btnLay->addStretch(-1);
 
         mMessageWidget->setMessageType(KMessageWidget::Warning);
         mMessageWidget->setIcon(q->style()->standardIcon(QStyle::SP_MessageBoxWarning, nullptr, q));
         mMessageWidget->setText(i18n("Signing and encryption is not possible."));
         mMessageWidget->setToolTip(xi18nc("@info %1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                                          "<para>You cannot use <application>Kleopatra</application> for signing or encryption "
                                          "because the <application>GnuPG</application> system used by <application>Kleopatra</application> is not %1.</para>",
                                          DeVSCompliance::name(true)));
         mMessageWidget->setCloseButtonVisible(false);
         mMessageWidget->setVisible(false);
         vLay->addWidget(mMessageWidget);
 
         mProgressBar->setRange(0, 0);
         mProgressBar->setVisible(false);
         mProgressLabel->setVisible(false);
         auto progLay = new QHBoxLayout;
 
         progLay->addWidget(mProgressLabel);
         progLay->addWidget(mProgressBar);
 
         mStatusLay = new QVBoxLayout;
         mStatusLay->addLayout(progLay);
         vLay->addLayout(mStatusLay, 0);
 
         auto tabWidget = new QTabWidget;
         vLay->addWidget(tabWidget, 1);
 
         tabWidget->addTab(mEdit, QIcon::fromTheme(QStringLiteral("edittext")), i18n("Notepad"));
 
         // The recipients area
         auto recipientsWidget = new QWidget;
         auto recipientsVLay = new QVBoxLayout(recipientsWidget);
         auto protocolSelectionLay = new QHBoxLayout;
 
         bool pgpOnly = KeyCache::instance()->pgpOnly();
         if (!pgpOnly) {
             recipientsVLay->addLayout(protocolSelectionLay);
         }
 
         protocolSelectionLay->addWidget(new QLabel(i18n("<h3>Protocol:</h3>")));
         protocolSelectionLay->addStretch(-1);
         // Once S/MIME is supported add radio for S/MIME here.
 
         recipientsVLay->addWidget(mSigEncWidget);
         tabWidget->addTab(recipientsWidget, QIcon::fromTheme(QStringLiteral("contact-new-symbolic")),
                           i18n("Recipients"));
 
         mEdit->setPlaceholderText(i18n("Enter a message to encrypt or decrypt..."));
 
         auto fixedFont = QFont(QStringLiteral("Monospace"));
         fixedFont.setStyleHint(QFont::TypeWriter);
         // This does not work well
         // QFontDatabase::systemFont(QFontDatabase::FixedFont);
 
         mEdit->setFont(fixedFont);
         mEdit->setAcceptRichText(false);
         mEdit->setMinimumWidth(QFontMetrics(fixedFont).averageCharWidth() * 70);
 
         if (KeyCache::instance()->pgpOnly() || !Settings{}.cmsEnabled()) {
             mSigEncWidget->setProtocol(GpgME::OpenPGP);
         } else {
             auto grp = new QButtonGroup(q);
             auto mPGPRB = new QRadioButton(i18n("OpenPGP"));
             auto mCMSRB = new QRadioButton(i18n("S/MIME"));
             grp->addButton(mPGPRB);
             grp->addButton(mCMSRB);
 
             KConfigGroup config(KSharedConfig::openConfig(), "Notepad");
             if (config.readEntry("wasCMS", false)) {
                 mCMSRB->setChecked(true);
                 mSigEncWidget->setProtocol(GpgME::CMS);
             } else {
                 mPGPRB->setChecked(true);
                 mSigEncWidget->setProtocol(GpgME::OpenPGP);
             }
 
             protocolSelectionLay->addWidget(mPGPRB);
             protocolSelectionLay->addWidget(mCMSRB);
             connect(mPGPRB, &QRadioButton::toggled, q, [this] (bool value) {
                     if (value) {
                         mSigEncWidget->setProtocol(GpgME::OpenPGP);
                     }
                 });
             connect(mCMSRB, &QRadioButton::toggled, q, [this] (bool value) {
                     if (value) {
                         mSigEncWidget->setProtocol(GpgME::CMS);
                     }
                 });
         }
 
         updateButtons();
 
         connect(mEdit, &QTextEdit::textChanged, q, [this] () {
                 updateButtons();
             });
 
         connect(mCryptBtn, &QPushButton::clicked, q, [this] () {
                 doEncryptSign();
             });
 
-        connect(mSigEncWidget, &SignEncryptWidget::operationChanged, q, [this] (const QString &) {
+        connect(mSigEncWidget, &SignEncryptWidget::operationChanged, q, [this]() {
                 updateButtons();
             });
 
         connect(mDecryptBtn, &QPushButton::clicked, q, [this] () {
                 doDecryptVerify();
             });
 
         connect(mImportBtn, &QPushButton::clicked, q, [this]() {
             doImport();
         });
 
         connect(mRevertBtn, &QPushButton::clicked, q, [this] () {
                 revert();
             });
     }
 
     void revert()
     {
         mEdit->setPlainText(QString::fromUtf8(mInputData));
         mRevertBtn->setVisible(false);
     }
 
     void updateRecipientsFromResult(const Kleo::Crypto::DecryptVerifyResult &result)
     {
         const auto decResult = result.decryptionResult();
 
         for (const auto &recipient: decResult.recipients()) {
             if (!recipient.keyID()) {
                 continue;
             }
 
             GpgME::Key key;
             if (strlen(recipient.keyID()) < 16) {
                 key = KeyCache::instance()->findByShortKeyID(recipient.keyID());
             } else {
                 key = KeyCache::instance()->findByKeyIDOrFingerprint(recipient.keyID());
             }
 
             if (key.isNull()) {
                 std::vector<std::string> subids;
                 subids.push_back(std::string(recipient.keyID()));
                 for (const auto &subkey: KeyCache::instance()->findSubkeysByKeyID(subids)) {
                     key = subkey.parent();
                     break;
                 }
             }
 
             if (key.isNull()) {
                 qCDebug(KLEOPATRA_LOG) << "Unknown key" << recipient.keyID();
                 mSigEncWidget->addUnknownRecipient(recipient.keyID());
                 continue;
             }
 
             bool keyFound = false;
             for (const auto &existingKey: mSigEncWidget->recipients()) {
                 if (existingKey.primaryFingerprint() && key.primaryFingerprint() &&
                     !strcmp (existingKey.primaryFingerprint(), key.primaryFingerprint())) {
                     keyFound = true;
                     break;
                 }
             }
             if (!keyFound) {
                 mSigEncWidget->addRecipient(key);
             }
         }
     }
 
     void cryptDone(const std::shared_ptr<const Kleo::Crypto::Task::Result> &result)
     {
         updateButtons();
         mProgressBar->setVisible(false);
         mProgressLabel->setVisible(false);
 
         mLastResultWidget = new ResultItemWidget(result);
         mLastResultWidget->showCloseButton(true);
         mStatusLay->addWidget(mLastResultWidget);
 
         connect(mLastResultWidget, &ResultItemWidget::closeButtonClicked, q, [this] () {
             removeLastResultItem();
         });
 
         // Check result protocol
         if (mPGPRB) {
             auto proto = getProtocol(result);
             if (proto == GpgME::UnknownProtocol) {
                 proto = mPGPRB->isChecked() ? GpgME::OpenPGP : GpgME::CMS;
             } else if (proto == GpgME::OpenPGP) {
                 mPGPRB->setChecked(true);
             } else if (proto == GpgME::CMS) {
                 mCMSRB->setChecked(true);
             }
 
             KConfigGroup config(KSharedConfig::openConfig(), "Notepad");
             config.writeEntry("wasCMS", proto == GpgME::CMS);
         }
 
         if (result->errorCode()) {
             if (!result->errorString().isEmpty()) {
                 KMessageBox::error(q,
                         result->errorString(),
                         i18nc("@title", "Error in crypto action"));
             }
             return;
         }
         mEdit->setPlainText(QString::fromUtf8(mOutputData));
         mOutputData.clear();
         mRevertBtn->setVisible(true);
 
         const auto decryptVerifyResult = dynamic_cast<const Kleo::Crypto::DecryptVerifyResult*>(result.get());
         if (decryptVerifyResult) {
             updateRecipientsFromResult(*decryptVerifyResult);
         }
     }
 
     void doDecryptVerify()
     {
         doCryptoCommon();
         mSigEncWidget->clearAddedRecipients();
         mProgressLabel->setText(i18n("Decrypt / Verify") + QStringLiteral("..."));
         auto input = Input::createFromByteArray(&mInputData,  i18n("Notepad"));
         auto output = Output::createFromByteArray(&mOutputData, i18n("Notepad"));
 
         AbstractDecryptVerifyTask *task;
         auto classification = input->classification();
         if (classification & Class::OpaqueSignature ||
             classification & Class::ClearsignedMessage) {
             auto verifyTask = new VerifyOpaqueTask();
             verifyTask->setInput(input);
             verifyTask->setOutput(output);
             task = verifyTask;
         } else {
             auto decTask = new DecryptVerifyTask();
             decTask->setInput(input);
             decTask->setOutput(output);
             task = decTask;
         }
         try {
             task->autodetectProtocolFromInput();
         } catch (const Kleo::Exception &e) {
             KMessageBox::error(q,
                     e.message(),
                     i18nc("@title", "Error in crypto action"));
             updateButtons();
             mProgressBar->setVisible(false);
             mProgressLabel->setVisible(false);
             return;
         }
 
         connect (task, &Task::result, q, [this, task] (const std::shared_ptr<const Kleo::Crypto::Task::Result> &result) {
                 qCDebug(KLEOPATRA_LOG) << "Decrypt / Verify done. Err:" << result->errorCode();
                 task->deleteLater();
                 cryptDone(result);
             });
         task->start();
     }
 
     void removeLastResultItem()
     {
         if (mLastResultWidget) {
             mStatusLay->removeWidget(mLastResultWidget);
             delete mLastResultWidget;
             mLastResultWidget = nullptr;
         }
     }
 
     void doCryptoCommon()
     {
         mCryptBtn->setEnabled(false);
         mDecryptBtn->setEnabled(false);
         mImportBtn->setEnabled(false);
         mProgressBar->setVisible(true);
         mProgressLabel->setVisible(true);
         mInputData = mEdit->toPlainText().toUtf8();
         removeLastResultItem();
     }
 
     void doEncryptSign()
     {
         if (DeVSCompliance::isActive() && !DeVSCompliance::isCompliant()) {
             KMessageBox::error(q->topLevelWidget(),
                                xi18nc("@info %1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                                       "<para>Sorry! You cannot use <application>Kleopatra</application> for signing or encryption "
                                       "because the <application>GnuPG</application> system used by <application>Kleopatra</application> is not %1.</para>",
                                       DeVSCompliance::name(true)));
             return;
         }
 
         doCryptoCommon();
-        mProgressLabel->setText(mSigEncWidget->currentOp() + QStringLiteral("..."));
+        switch (mSigEncWidget->currentOp()) {
+        case SignEncryptWidget::Sign:
+            mProgressLabel->setText(i18nc("@info:progress", "Signing notepad..."));
+            break;
+        case SignEncryptWidget::Encrypt:
+            mProgressLabel->setText(i18nc("@info:progress", "Encrypting notepad..."));
+            break;
+        case SignEncryptWidget::SignAndEncrypt:
+            mProgressLabel->setText(i18nc("@info:progress", "Signing and encrypting notepad..."));
+            break;
+        default:
+            ;
+        };
         auto input = Input::createFromByteArray(&mInputData,  i18n("Notepad"));
         auto output = Output::createFromByteArray(&mOutputData, i18n("Notepad"));
 
         auto task = new SignEncryptTask();
         task->setInput(input);
         task->setOutput(output);
 
         const auto sigKey = mSigEncWidget->signKey();
 
         const std::vector<GpgME::Key> recipients = mSigEncWidget->recipients();
         const bool encrypt = mSigEncWidget->encryptSymmetric() || !recipients.empty();
         const bool sign = !sigKey.isNull();
 
         if (sign) {
             task->setSign(true);
             std::vector<GpgME::Key> signVector;
             signVector.push_back(sigKey);
             task->setSigners(signVector);
         } else {
             task->setSign(false);
         }
         task->setEncrypt(encrypt);
         task->setRecipients(recipients);
         task->setEncryptSymmetric(mSigEncWidget->encryptSymmetric());
         task->setAsciiArmor(true);
 
         if (sign && !encrypt && sigKey.protocol() == GpgME::OpenPGP) {
             task->setClearsign(true);
         }
 
         connect (task, &Task::result, q, [this, task] (const std::shared_ptr<const Kleo::Crypto::Task::Result> &result) {
                 qCDebug(KLEOPATRA_LOG) << "Encrypt / Sign done. Err:" << result->errorCode();
                 task->deleteLater();
                 cryptDone(result);
             });
         task->start();
     }
 
     void doImport()
     {
         doCryptoCommon();
         mProgressLabel->setText(i18n("Importing..."));
         auto cmd = new Kleo::ImportCertificateFromDataCommand(mInputData, mImportProto);
         connect(cmd, &Kleo::ImportCertificatesCommand::finished, q, [this] () {
                 updateButtons();
                 mProgressBar->setVisible(false);
                 mProgressLabel->setVisible(false);
 
                 mRevertBtn->setVisible(true);
                 mEdit->setPlainText(QString());
             });
         cmd->start();
     }
 
     void checkImportProtocol()
     {
         QGpgME::QByteArrayDataProvider dp(mEdit->toPlainText().toUtf8());
         GpgME::Data data(&dp);
         auto type = data.type();
         if (type == GpgME::Data::PGPKey) {
             mImportProto = GpgME::OpenPGP;
         } else if (type == GpgME::Data::X509Cert ||
                    type == GpgME::Data::PKCS12) {
             mImportProto = GpgME::CMS;
         } else {
             mImportProto = GpgME::UnknownProtocol;
         }
     }
 
     void updateButtons()
     {
         mAdditionalInfoLabel->setVisible(false);
 
         mDecryptBtn->setEnabled(mEdit->document() && !mEdit->document()->isEmpty());
 
         checkImportProtocol();
         mImportBtn->setEnabled(mImportProto != GpgME::UnknownProtocol);
 
-        if (!mSigEncWidget->currentOp().isEmpty()) {
-            mCryptBtn->setEnabled(true);
-            mCryptBtn->setText(i18nc("1 is an operation to apply to the notepad. "
-                                     "Like Sign/Encrypt or just Encrypt.", "%1 Notepad",
-                                     mSigEncWidget->currentOp()));
-        } else {
-            mCryptBtn->setText(i18n("Sign / Encrypt Notepad"));
-            mCryptBtn->setEnabled(false);
-        }
+        mCryptBtn->setEnabled(mSigEncWidget->currentOp() != SignEncryptWidget::NoOperation);
+        switch (mSigEncWidget->currentOp()) {
+        case SignEncryptWidget::Sign:
+            mCryptBtn->setText(i18nc("@action:button", "Sign Notepad"));
+            break;
+        case SignEncryptWidget::Encrypt:
+            mCryptBtn->setText(i18nc("@action:button", "Encrypt Notepad"));
+            break;
+        case SignEncryptWidget::SignAndEncrypt:
+        default:
+            mCryptBtn->setText(i18nc("@action:button", "Sign / Encrypt Notepad"));
+        };
 
         if (DeVSCompliance::isActive()) {
             const bool de_vs = DeVSCompliance::isCompliant() && mSigEncWidget->isDeVsAndValid();
             DeVSCompliance::decorate(mCryptBtn, de_vs);
             mAdditionalInfoLabel->setText(DeVSCompliance::name(de_vs));
             mAdditionalInfoLabel->setVisible(true);
             if (!DeVSCompliance::isCompliant()) {
                 mCryptBtn->setEnabled(false);
             }
             mMessageWidget->setVisible(!DeVSCompliance::isCompliant());
         }
     }
 
 private:
     PadWidget *const q;
     QTextEdit *mEdit;
     QPushButton *mCryptBtn;
     QPushButton *mDecryptBtn;
     QPushButton *mImportBtn;
     QPushButton *mRevertBtn;
     KMessageWidget *mMessageWidget;
     QLabel *mAdditionalInfoLabel;
     QByteArray mInputData;
     QByteArray mOutputData;
     SignEncryptWidget *mSigEncWidget;
     QProgressBar *mProgressBar;
     QLabel *mProgressLabel;
     QVBoxLayout *mStatusLay;
     ResultItemWidget *mLastResultWidget;
     QList<GpgME::Key> mAutoAddedKeys;
     QRadioButton *mPGPRB;
     QRadioButton *mCMSRB;
     GpgME::Protocol mImportProto;
 };
 
 PadWidget::PadWidget(QWidget *parent):
     QWidget(parent),
     d(new Private(this))
 {
 }
 
 void PadWidget::focusFirstChild(Qt::FocusReason reason)
 {
     d->mEdit->setFocus(reason);
 }