No OneTemporary
Actions

Size

53 KB

Subscribers

None

View Options

	diff --git a/src/crypto/gui/signencryptfileswizard.cpp b/src/crypto/gui/signencryptfileswizard.cpp
	index 22601e7be..2f9b01675 100644
	--- a/src/crypto/gui/signencryptfileswizard.cpp
	+++ b/src/crypto/gui/signencryptfileswizard.cpp
	@@ -1,697 +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("Invalid compliance settings for signing and encrypting files."));
	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 SignEncryptWidget::Operation op)
	+ void updateCommitButton(const SignEncryptWidget::Operations 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 fdbf53c3f..1ea8ce8c7 100644
	--- a/src/crypto/gui/signencryptwidget.cpp
	+++ b/src/crypto/gui/signencryptwidget.cpp
	@@ -1,690 +1,689 @@
	/* 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/Compliance>
	#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);
	setValidIfSMIME(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);
	setValidIfSMIME(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);
	setValidIfSMIME(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() && !DeVSCompliance::keyIsCompliant(signKey())) {
	return false;
	}

	if (!selfKey().isNull() && !DeVSCompliance::keyIsCompliant(selfKey())) {
	return false;
	}

	for (const auto &key: recipients()) {
	if (!DeVSCompliance::keyIsCompliant(key)) {
	return false;
	}
	}

	return true;
	}

	void SignEncryptWidget::updateOp()
	{
	const Key sigKey = signKey();
	const std::vector<Key> recp = recipients();

	- if (!sigKey.isNull() && (!recp.empty() \|\| encryptSymmetric())) {
	- mOp = SignAndEncrypt;
	- } else if (!recp.empty() \|\| encryptSymmetric()) {
	- mOp = Encrypt;
	- } else if (!sigKey.isNull()) {
	- mOp = Sign;
	- } else {
	- mOp = NoOperation;
	+ Operations op = NoOperation;
	+ if (!sigKey.isNull()) {
	+ op \|= Sign;
	+ }
	+ if (!recp.empty() \|\| encryptSymmetric()) {
	+ op \|= Encrypt;
	}
	+ mOp = op;
	Q_EMIT operationChanged(mOp);
	Q_EMIT keysChanged();
	}

	-SignEncryptWidget::Operation SignEncryptWidget::currentOp() const
	+SignEncryptWidget::Operations 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() != 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 c9411ec34..9db551844 100644
	--- a/src/crypto/gui/signencryptwidget.h
	+++ b/src/crypto/gui/signencryptwidget.h
	@@ -1,154 +1,158 @@
	/* 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
	+ NoOperation = 0x00,
	+ Sign = 0x01,
	+ Encrypt = 0x02,
	+ SignAndEncrypt = Sign \| Encrypt
	};
	+ Q_DECLARE_FLAGS(Operations, Operation)

	/** 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. */
	- Operation currentOp() const;
	+ Operations 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(Operation op);
	+ void operationChanged(Operations 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;
	- Operation mOp;
	+ Operations mOp;
	AbstractKeyListModel *mModel = nullptr;
	QCheckBox *mSymmetric = nullptr;
	QCheckBox *mSigChk = nullptr;
	QCheckBox *mEncOtherChk = nullptr;
	QCheckBox *mEncSelfChk = nullptr;
	GpgME::Protocol mCurrentProto = GpgME::UnknownProtocol;
	const bool mIsExclusive;
	};
	+
	+Q_DECLARE_OPERATORS_FOR_FLAGS(SignEncryptWidget::Operations)
	+
	} // namespace Kleo

File Metadata

Mime Type: text/x-diff
Expires: Thu, Feb 26, 6:27 PM (11 h, 44 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 4a/4b/d1302ecf1c14ddb90d56134a9e41

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions