No OneTemporary
Actions

Size

29 KB

Subscribers

None

View Options

	diff --git a/src/commands/decryptverifyclipboardcommand.cpp b/src/commands/decryptverifyclipboardcommand.cpp
	index b787eaf35..4440daf9e 100644
	--- a/src/commands/decryptverifyclipboardcommand.cpp
	+++ b/src/commands/decryptverifyclipboardcommand.cpp
	@@ -1,171 +1,196 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/decryptverifyclipboardcommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "decryptverifyclipboardcommand.h"

	#ifndef QT_NO_CLIPBOARD

	#include "command_p.h"

	#include <crypto/decryptverifyemailcontroller.h>

	#include <utils/input.h>
	#include <utils/output.h>

	#include <Libkleo/Classify>
	#include <Libkleo/Stl_Util>

	#include "kleopatra_debug.h"
	#include <KLocalizedString>
	+#include <KMessageDialog>
	+#include <QApplication>
	+#include <QClipboard>

	#include <exception>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::Crypto;

	+using namespace Qt::Literals::StringLiterals;
	+
	class DecryptVerifyClipboardCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::DecryptVerifyClipboardCommand;
	DecryptVerifyClipboardCommand *q_func() const
	{
	return static_cast<DecryptVerifyClipboardCommand *>(q);
	}

	public:
	explicit Private(DecryptVerifyClipboardCommand qq, KeyListController c);
	~Private() override;

	void init();

	private:
	void slotControllerDone()
	{
	finished();
	}
	void slotControllerError(int, const QString &)
	{
	finished();
	}

	private:
	std::shared_ptr<const ExecutionContext> shared_qq;
	std::shared_ptr<Input> input;
	DecryptVerifyEMailController controller;
	};

	DecryptVerifyClipboardCommand::Private *DecryptVerifyClipboardCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const DecryptVerifyClipboardCommand::Private *DecryptVerifyClipboardCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	DecryptVerifyClipboardCommand::Private::Private(DecryptVerifyClipboardCommand qq, KeyListController c)
	: Command::Private(qq, c)
	, shared_qq(qq, [](DecryptVerifyClipboardCommand *) {})
	, input()
	, controller({}, Task::DataSource::Clipboard)
	{
	}

	DecryptVerifyClipboardCommand::Private::~Private()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	DecryptVerifyClipboardCommand::DecryptVerifyClipboardCommand(KeyListController *c)
	: Command(new Private(this, c))
	{
	d->init();
	}

	DecryptVerifyClipboardCommand::DecryptVerifyClipboardCommand(QAbstractItemView v, KeyListController c)
	: Command(v, new Private(this, c))
	{
	d->init();
	}

	void DecryptVerifyClipboardCommand::Private::init()
	{
	controller.setExecutionContext(shared_qq);
	connect(&controller, &Controller::done, q, [this]() {
	slotControllerDone();
	});
	connect(&controller, &Controller::error, q, [this](int err, const QString &details) {
	slotControllerError(err, details);
	});
	}

	DecryptVerifyClipboardCommand::~DecryptVerifyClipboardCommand()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	// static
	bool DecryptVerifyClipboardCommand::canDecryptVerifyCurrentClipboard()
	{
	try {
	return Input::createFromClipboard()->classification() & (Class::CipherText \| Class::ClearsignedMessage \| Class::OpaqueSignature);
	} catch (...) {
	}
	return false;
	}

	void DecryptVerifyClipboardCommand::doStart()
	{
	- try {
	- const std::shared_ptr<Input> input = Input::createFromClipboard();
	-
	- const unsigned int classification = input->classification();
	-
	- if (classification & (Class::ClearsignedMessage \| Class::OpaqueSignature)) {
	- d->controller.setOperation(Verify);
	- d->controller.setVerificationMode(Opaque);
	- } else if (classification & Class::CipherText) {
	- d->controller.setOperation(DecryptVerify);
	- } else {
	- d->information(i18n("The clipboard does not appear to "
	- "contain a signature or encrypted text."),
	- i18n("Decrypt/Verify Clipboard Error"));
	+ auto dialog = new KMessageDialog(KMessageDialog::Information, i18nc("@info", "Decrypting/Verifying clipboard…"), nullptr);
	+ dialog->setAttribute(Qt::WA_DeleteOnClose);
	+
	+ auto onClipboardAvailable = [dialog, this]() {
	+ dialog->close();
	+ try {
	+ const std::shared_ptr<Input> input = Input::createFromClipboard();
	+
	+ const unsigned int classification = input->classification();
	+
	+ if (classification & (Class::ClearsignedMessage \| Class::OpaqueSignature)) {
	+ d->controller.setOperation(Verify);
	+ d->controller.setVerificationMode(Opaque);
	+ } else if (classification & Class::CipherText) {
	+ d->controller.setOperation(DecryptVerify);
	+ } else {
	+ d->information(i18n("The clipboard does not appear to "
	+ "contain a signature or encrypted text."),
	+ i18n("Decrypt/Verify Clipboard Error"));
	+ d->finished();
	+ return;
	+ }
	+
	+ d->controller.setProtocol(findProtocol(classification));
	+ d->controller.setInput(input);
	+ d->controller.setOutput(Output::createFromClipboard());
	+
	+ d->controller.start();
	+
	+ } catch (const std::exception &e) {
	+ d->information(i18n("An error occurred: %1", QString::fromLocal8Bit(e.what())), i18n("Decrypt/Verify Clipboard Error"));
	d->finished();
	- return;
	}
	-
	- d->controller.setProtocol(findProtocol(classification));
	- d->controller.setInput(input);
	- d->controller.setOutput(Output::createFromClipboard());
	-
	- d->controller.start();
	-
	- } catch (const std::exception &e) {
	- d->information(i18n("An error occurred: %1", QString::fromLocal8Bit(e.what())), i18n("Decrypt/Verify Clipboard Error"));
	- d->finished();
	+ };
	+
	+ if (qApp->platformName() != "wayland"_L1) {
	+ onClipboardAvailable();
	+ } else {
	+ dialog->show();
	+ connect(
	+ qApp->clipboard(),
	+ &QClipboard::dataChanged,
	+ this,
	+ [onClipboardAvailable]() {
	+ onClipboardAvailable();
	+ },
	+ Qt::SingleShotConnection);
	}
	}

	void DecryptVerifyClipboardCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG);
	d->controller.cancel();
	}

	#undef d
	#undef q

	#include "moc_decryptverifyclipboardcommand.cpp"

	#endif // QT_NO_CLIPBOARD
	diff --git a/src/commands/encryptclipboardcommand.cpp b/src/commands/encryptclipboardcommand.cpp
	index fe01dd4b9..c5c2a1230 100644
	--- a/src/commands/encryptclipboardcommand.cpp
	+++ b/src/commands/encryptclipboardcommand.cpp
	@@ -1,178 +1,206 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/encryptclipboardcommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "encryptclipboardcommand.h"

	#ifndef QT_NO_CLIPBOARD

	#include "command_p.h"

	#include <settings.h>

	#include <crypto/encryptemailcontroller.h>

	#include <utils/input.h>
	#include <utils/output.h>

	#include <Libkleo/Stl_Util>

	#include "kleopatra_debug.h"
	#include <KLocalizedString>
	+#include <KMessageDialog>

	#include <QApplication>
	#include <QClipboard>
	#include <QMimeData>

	#include <exception>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::Crypto;

	+using namespace Qt::Literals::StringLiterals;
	+
	class EncryptClipboardCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::EncryptClipboardCommand;
	EncryptClipboardCommand *q_func() const
	{
	return static_cast<EncryptClipboardCommand *>(q);
	}

	public:
	explicit Private(EncryptClipboardCommand qq, KeyListController c);
	~Private() override;

	void init();

	private:
	void slotRecipientsResolved();
	void slotControllerDone()
	{
	finished();
	}
	void slotControllerError(int, const QString &)
	{
	finished();
	}

	private:
	std::shared_ptr<const ExecutionContext> shared_qq;
	std::shared_ptr<Input> input;
	EncryptEMailController controller;
	};

	EncryptClipboardCommand::Private *EncryptClipboardCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const EncryptClipboardCommand::Private *EncryptClipboardCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	EncryptClipboardCommand::Private::Private(EncryptClipboardCommand qq, KeyListController c)
	: Command::Private(qq, c)
	, shared_qq(qq, [](EncryptClipboardCommand *) {})
	, input()
	, controller(EncryptEMailController::ClipboardMode)
	{
	if (!Settings{}.cmsEnabled()) {
	controller.setProtocol(GpgME::OpenPGP);
	}
	}

	EncryptClipboardCommand::Private::~Private()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	EncryptClipboardCommand::EncryptClipboardCommand(KeyListController *c)
	: Command(new Private(this, c))
	{
	d->init();
	}

	EncryptClipboardCommand::EncryptClipboardCommand(QAbstractItemView v, KeyListController c)
	: Command(v, new Private(this, c))
	{
	d->init();
	}

	void EncryptClipboardCommand::Private::init()
	{
	controller.setExecutionContext(shared_qq);
	connect(&controller, &Controller::done, q, [this]() {
	slotControllerDone();
	});
	connect(&controller, &Controller::error, q, [this](int err, const QString &details) {
	slotControllerError(err, details);
	});
	}

	EncryptClipboardCommand::~EncryptClipboardCommand()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	// static
	bool EncryptClipboardCommand::canEncryptCurrentClipboard()
	{
	if (const QClipboard *clip = QApplication::clipboard())
	if (const QMimeData *mime = clip->mimeData()) {
	return mime->hasText();
	}
	return false;
	}

	void EncryptClipboardCommand::doStart()
	{
	- try {
	- // snapshot clipboard content here, in case it's being changed...
	- d->input = Input::createFromClipboard();
	-
	- connect(&d->controller, &EncryptEMailController::recipientsResolved, this, [this]() {
	- d->slotRecipientsResolved();
	- });
	-
	- d->controller.startResolveRecipients();
	-
	- } catch (const std::exception &e) {
	- d->information(i18n("An error occurred: %1", QString::fromLocal8Bit(e.what())), i18n("Encrypt Clipboard Error"));
	- d->finished();
	+ auto dialog = new KMessageDialog(KMessageDialog::Information, i18nc("@info", "Encrypting clipboard…"), nullptr);
	+ dialog->setAttribute(Qt::WA_DeleteOnClose);
	+
	+ auto onClipboardAvailable = [dialog, this]() {
	+ dialog->close();
	+ try {
	+ // snapshot clipboard content here, in case it's being changed...
	+ d->input = Input::createFromClipboard();
	+ if (d->input->size() == 0) {
	+ d->information(i18nc("@info", "The clipboard is empty"), i18nc("@title:dialog", "Encrypt Clipboard Error"));
	+ d->finished();
	+ return;
	+ }
	+
	+ connect(&d->controller, &EncryptEMailController::recipientsResolved, this, [this]() {
	+ d->slotRecipientsResolved();
	+ });
	+
	+ d->controller.startResolveRecipients();
	+
	+ } catch (const std::exception &e) {
	+ d->information(i18n("An error occurred: %1", QString::fromLocal8Bit(e.what())), i18n("Encrypt Clipboard Error"));
	+ d->finished();
	+ }
	+ };
	+
	+ if (qApp->platformName() != "wayland"_L1) {
	+ onClipboardAvailable();
	+ } else {
	+ dialog->show();
	+ connect(
	+ qApp->clipboard(),
	+ &QClipboard::dataChanged,
	+ this,
	+ [onClipboardAvailable]() {
	+ onClipboardAvailable();
	+ },
	+ Qt::SingleShotConnection);
	}
	}

	void EncryptClipboardCommand::Private::slotRecipientsResolved()
	{
	try {
	controller.setInputAndOutput(input, Output::createFromClipboard());
	input.reset(); // no longer needed, so don't keep a reference
	controller.start();
	} catch (const std::exception &e) {
	information(i18n("An error occurred: %1", QString::fromLocal8Bit(e.what())), i18n("Encrypt Clipboard Error"));
	finished();
	}
	}

	void EncryptClipboardCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG);
	d->controller.cancel();
	}

	#undef d
	#undef q

	#include "moc_encryptclipboardcommand.cpp"

	#endif // QT_NO_CLIPBOARD
	diff --git a/src/commands/importcertificatefromclipboardcommand.cpp b/src/commands/importcertificatefromclipboardcommand.cpp
	index 059100041..82c6ba1bb 100644
	--- a/src/commands/importcertificatefromclipboardcommand.cpp
	+++ b/src/commands/importcertificatefromclipboardcommand.cpp
	@@ -1,130 +1,140 @@
	/* -- mode: c++; c-basic-offset:4 --
	importcertificatefromclipboardcommand.cpp

	This clipboard is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "importcertificatefromclipboardcommand.h"

	#ifndef QT_NO_CLIPBOARD

	#include "importcertificatescommand_p.h"

	#include <Libkleo/Classify>

	#include <gpgme++/global.h>

	#include <KLocalizedString>
	+#include <KMessageDialog>

	#include <QApplication>
	#include <QByteArray>
	#include <QClipboard>
	#include <QMimeData>

	using namespace GpgME;
	using namespace Kleo;

	+using namespace Qt::Literals::StringLiterals;
	+
	class ImportCertificateFromClipboardCommand::Private : public ImportCertificatesCommand::Private
	{
	friend class ::ImportCertificateFromClipboardCommand;
	ImportCertificateFromClipboardCommand *q_func() const
	{
	return static_cast<ImportCertificateFromClipboardCommand *>(q);
	}

	public:
	explicit Private(ImportCertificateFromClipboardCommand qq, KeyListController c);
	~Private() override;

	- bool ensureHaveClipboard();
	-
	private:
	QByteArray input;
	};

	ImportCertificateFromClipboardCommand::Private *ImportCertificateFromClipboardCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const ImportCertificateFromClipboardCommand::Private *ImportCertificateFromClipboardCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	ImportCertificateFromClipboardCommand::Private::Private(ImportCertificateFromClipboardCommand qq, KeyListController c)
	: ImportCertificatesCommand::Private(qq, c)
	{
	}

	ImportCertificateFromClipboardCommand::Private::~Private()
	{
	}

	// static
	bool ImportCertificateFromClipboardCommand::canImportCurrentClipboard()
	{
	if (const QClipboard *clip = QApplication::clipboard())
	if (const QMimeData *mime = clip->mimeData())
	return mime->hasText() && mayBeAnyCertStoreType(classifyContent(mime->text().toUtf8()));
	return false;
	}

	#define d d_func()
	#define q q_func()

	ImportCertificateFromClipboardCommand::ImportCertificateFromClipboardCommand(KeyListController *p)
	: ImportCertificatesCommand(new Private(this, p))
	{
	}

	ImportCertificateFromClipboardCommand::ImportCertificateFromClipboardCommand(QAbstractItemView v, KeyListController p)
	: ImportCertificatesCommand(v, new Private(this, p))
	{
	}

	ImportCertificateFromClipboardCommand::~ImportCertificateFromClipboardCommand()
	{
	}

	void ImportCertificateFromClipboardCommand::doStart()
	{
	- if (!d->ensureHaveClipboard()) {
	- d->canceled();
	- return;
	- }
	-
	- d->setWaitForMoreJobs(true);
	- const unsigned int classification = classifyContent(d->input);
	- if (!mayBeAnyCertStoreType(classification)) {
	- d->error(i18n("Clipboard contents do not look like a certificate."), i18n("Certificate Import Failed"));
	- } else {
	- const GpgME::Protocol protocol = findProtocol(classification);
	- if (protocol == GpgME::UnknownProtocol) {
	- d->error(i18n("Could not determine certificate type of clipboard contents."), i18n("Certificate Import Failed"));
	+ // Don't remove this dialog, it's required to query the clipboard on wayland
	+ auto dialog = new KMessageDialog(KMessageDialog::Information, i18nc("@info", "Importing certificate from clipboard…"), nullptr);
	+ dialog->setAttribute(Qt::WA_DeleteOnClose);
	+ auto onClipboardAvailable = [this, dialog]() {
	+ dialog->close();
	+ d->input = qApp->clipboard()->text().toUtf8();
	+ d->setWaitForMoreJobs(true);
	+ const unsigned int classification = classifyContent(d->input);
	+ if (d->input.isEmpty()) {
	+ d->error(i18nc("@info", "The clipboard is empty."), i18nc("@title:dialog", "Certificate Import Failed"));
	+ } else if (!mayBeAnyCertStoreType(classification)) {
	+ d->error(i18nc("@info", "Clipboard contents do not look like a certificate."), i18nc("@title:dialog", "Certificate Import Failed"));
	} else {
	- d->startImport(protocol, d->input, i18n("Clipboard"));
	+ const GpgME::Protocol protocol = findProtocol(classification);
	+ if (protocol == GpgME::UnknownProtocol) {
	+ d->error(i18nc("@info", "Could not determine certificate type of clipboard contents."), i18nc("@title:dialog", "Certificate Import Failed"));
	+ } else {
	+ d->startImport(protocol, d->input, i18n("Clipboard"));
	+ }
	}
	- }
	- d->setWaitForMoreJobs(false);
	-}
	+ d->setWaitForMoreJobs(false);
	+ };

	-bool ImportCertificateFromClipboardCommand::Private::ensureHaveClipboard()
	-{
	- if (input.isEmpty())
	- if (const QClipboard *cb = qApp->clipboard()) {
	- input = cb->text().toUtf8();
	- }
	- return !input.isEmpty();
	+ if (qApp->platformName() != "wayland"_L1) {
	+ onClipboardAvailable();
	+ } else {
	+ dialog->show();
	+ connect(
	+ qApp->clipboard(),
	+ &QClipboard::dataChanged,
	+ this,
	+ [onClipboardAvailable]() {
	+ onClipboardAvailable();
	+ },
	+ Qt::SingleShotConnection);
	+ }
	}

	#undef d
	#undef q

	#endif // QT_NO_CLIPBOARD

	#include "moc_importcertificatefromclipboardcommand.cpp"
	diff --git a/src/commands/signclipboardcommand.cpp b/src/commands/signclipboardcommand.cpp
	index b94e2ca11..d7654d1f8 100644
	--- a/src/commands/signclipboardcommand.cpp
	+++ b/src/commands/signclipboardcommand.cpp
	@@ -1,178 +1,207 @@
	/* -- mode: c++; c-basic-offset:4 --
	commands/signclipboardcommand.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB

	SPDX-License-Identifier: GPL-2.0-or-later
	*/

	#include <config-kleopatra.h>

	#include "signclipboardcommand.h"

	#ifndef QT_NO_CLIPBOARD

	#include "command_p.h"

	#include <crypto/signemailcontroller.h>

	#include <utils/input.h>
	#include <utils/output.h>

	#include <Libkleo/Stl_Util>

	#include "kleopatra_debug.h"
	#include <KLocalizedString>
	+#include <KMessageDialog>

	#include <QApplication>
	#include <QClipboard>
	#include <QMimeData>

	#include <exception>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::Crypto;

	+using namespace Qt::Literals::StringLiterals;
	+
	class SignClipboardCommand::Private : public Command::Private
	{
	friend class ::Kleo::Commands::SignClipboardCommand;
	SignClipboardCommand *q_func() const
	{
	return static_cast<SignClipboardCommand *>(q);
	}

	public:
	explicit Private(SignClipboardCommand qq, KeyListController c);
	~Private() override;

	void init();

	private:
	void slotSignersResolved();
	void slotControllerDone()
	{
	finished();
	}
	void slotControllerError(int, const QString &)
	{
	finished();
	}

	private:
	std::shared_ptr<const ExecutionContext> shared_qq;
	std::shared_ptr<Input> input;
	SignEMailController controller;
	};

	SignClipboardCommand::Private *SignClipboardCommand::d_func()
	{
	return static_cast<Private *>(d.get());
	}
	const SignClipboardCommand::Private *SignClipboardCommand::d_func() const
	{
	return static_cast<const Private *>(d.get());
	}

	#define d d_func()
	#define q q_func()

	SignClipboardCommand::Private::Private(SignClipboardCommand qq, KeyListController c)
	: Command::Private(qq, c)
	, shared_qq(qq, [](SignClipboardCommand *) {})
	, input()
	, controller(SignEMailController::ClipboardMode)
	{
	}

	SignClipboardCommand::Private::~Private()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	SignClipboardCommand::SignClipboardCommand(GpgME::Protocol protocol, KeyListController *c)
	: Command(new Private(this, c))
	{
	d->init();
	d->controller.setProtocol(protocol);
	}

	SignClipboardCommand::SignClipboardCommand(GpgME::Protocol protocol, QAbstractItemView v, KeyListController c)
	: Command(v, new Private(this, c))
	{
	d->init();
	d->controller.setProtocol(protocol);
	}

	void SignClipboardCommand::Private::init()
	{
	controller.setExecutionContext(shared_qq);
	controller.setDetachedSignature(false);
	connect(&controller, &Controller::done, q, [this]() {
	slotControllerDone();
	});
	connect(&controller, &Controller::error, q, [this](int err, const QString &details) {
	slotControllerError(err, details);
	});
	}

	SignClipboardCommand::~SignClipboardCommand()
	{
	qCDebug(KLEOPATRA_LOG);
	}

	// static
	bool SignClipboardCommand::canSignCurrentClipboard()
	{
	bool canSign = false;
	if (const QClipboard *const clip = QApplication::clipboard()) {
	if (const QMimeData *const mime = clip->mimeData()) {
	canSign = mime->hasText();
	}
	}
	return canSign;
	}

	void SignClipboardCommand::doStart()
	{
	- try {
	- // snapshot clipboard content here, in case it's being changed...
	- d->input = Input::createFromClipboard();
	-
	- connect(&d->controller, &SignEMailController::signersResolved, this, [this]() {
	- d->slotSignersResolved();
	- });
	-
	- d->controller.startResolveSigners();
	-
	- } catch (const std::exception &e) {
	- d->information(i18n("An error occurred: %1", QString::fromLocal8Bit(e.what())), i18n("Sign Clipboard Error"));
	- d->finished();
	+ auto dialog = new KMessageDialog(KMessageDialog::Information, i18nc("@info", "Signing clipboard…"), nullptr);
	+ dialog->setAttribute(Qt::WA_DeleteOnClose);
	+
	+ auto onClipboardAvailable = [dialog, this]() {
	+ dialog->close();
	+ try {
	+ // snapshot clipboard content here, in case it's being changed...
	+ d->input = Input::createFromClipboard();
	+
	+ if (d->input->size() == 0) {
	+ d->information(i18nc("@info", "The clipboard is empty"), i18nc("@title:dialog", "Sign Clipboard Error"));
	+ d->finished();
	+ return;
	+ }
	+
	+ connect(&d->controller, &SignEMailController::signersResolved, this, [this]() {
	+ d->slotSignersResolved();
	+ });
	+
	+ d->controller.startResolveSigners();
	+
	+ } catch (const std::exception &e) {
	+ d->information(i18n("An error occurred: %1", QString::fromLocal8Bit(e.what())), i18n("Sign Clipboard Error"));
	+ d->finished();
	+ }
	+ };
	+
	+ if (qApp->platformName() != "wayland"_L1) {
	+ onClipboardAvailable();
	+ } else {
	+ dialog->show();
	+ connect(
	+ qApp->clipboard(),
	+ &QClipboard::dataChanged,
	+ this,
	+ [onClipboardAvailable]() {
	+ onClipboardAvailable();
	+ },
	+ Qt::SingleShotConnection);
	}
	}

	void SignClipboardCommand::Private::slotSignersResolved()
	{
	try {
	controller.setInputAndOutput(input, Output::createFromClipboard());
	input.reset(); // no longer needed, so don't keep a reference
	controller.start();
	} catch (const std::exception &e) {
	information(i18n("An error occurred: %1", QString::fromLocal8Bit(e.what())), i18n("Sign Clipboard Error"));
	finished();
	}
	}

	void SignClipboardCommand::doCancel()
	{
	qCDebug(KLEOPATRA_LOG);
	d->controller.cancel();
	}

	#undef d
	#undef q

	#include "moc_signclipboardcommand.cpp"

	#endif // QT_NO_CLIPBOARD
	diff --git a/src/utils/clipboardmenu.cpp b/src/utils/clipboardmenu.cpp
	index f4a04ad4a..371ce0db9 100644
	--- a/src/utils/clipboardmenu.cpp
	+++ b/src/utils/clipboardmenu.cpp
	@@ -1,149 +1,146 @@
	/*
	SPDX-FileCopyrightText: 2014-2021 Laurent Montel <montel@kde.org>

	SPDX-License-Identifier: GPL-2.0-only
	*/

	#include <config-kleopatra.h>

	#include "clipboardmenu.h"

	#include "kdtoolsglobal.h"
	#include "mainwindow.h"

	#include <settings.h>

	#include <commands/decryptverifyclipboardcommand.h>
	#include <commands/encryptclipboardcommand.h>
	#include <commands/importcertificatefromclipboardcommand.h>
	#include <commands/signclipboardcommand.h>

	#include <Libkleo/Algorithm>
	#include <Libkleo/Compat>
	#include <Libkleo/KeyCache>

	#include <KActionMenu>
	#include <KLocalizedString>

	#include <QAction>
	#include <QApplication>
	#include <QClipboard>
	#include <QSignalBlocker>

	#include <gpgme++/key.h>

	using namespace Kleo;

	using namespace Kleo::Commands;

	ClipboardMenu::ClipboardMenu(QObject *parent)
	: QObject{parent}
	{
	mClipboardMenu = new KActionMenu(i18n("Clipboard"), this);
	mImportClipboardAction = new QAction(i18nc("@action", "Certificate Import"), this);
	mEncryptClipboardAction = new QAction(i18nc("@action", "Encrypt..."), this);
	const Kleo::Settings settings{};
	if (settings.cmsEnabled() && settings.cmsSigningAllowed()) {
	mSmimeSignClipboardAction = new QAction(i18nc("@action", "S/MIME-Sign..."), this);
	Q_SET_OBJECT_NAME(mSmimeSignClipboardAction);
	}
	mOpenPGPSignClipboardAction = new QAction(i18nc("@action", "OpenPGP-Sign..."), this);
	mDecryptVerifyClipboardAction = new QAction(i18nc("@action", "Decrypt/Verify..."), this);

	Q_SET_OBJECT_NAME(mClipboardMenu);
	Q_SET_OBJECT_NAME(mImportClipboardAction);
	Q_SET_OBJECT_NAME(mEncryptClipboardAction);
	Q_SET_OBJECT_NAME(mOpenPGPSignClipboardAction);
	Q_SET_OBJECT_NAME(mDecryptVerifyClipboardAction);

	connect(mImportClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotImportClipboard);
	connect(mEncryptClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotEncryptClipboard);
	if (mSmimeSignClipboardAction) {
	connect(mSmimeSignClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotSMIMESignClipboard);
	}
	connect(mOpenPGPSignClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotOpenPGPSignClipboard);
	connect(mDecryptVerifyClipboardAction, &QAction::triggered, this, &ClipboardMenu::slotDecryptVerifyClipboard);
	mClipboardMenu->addAction(mImportClipboardAction);
	mClipboardMenu->addAction(mEncryptClipboardAction);
	if (mSmimeSignClipboardAction) {
	mClipboardMenu->addAction(mSmimeSignClipboardAction);
	}
	mClipboardMenu->addAction(mOpenPGPSignClipboardAction);
	mClipboardMenu->addAction(mDecryptVerifyClipboardAction);
	connect(QApplication::clipboard(), &QClipboard::changed, this, &ClipboardMenu::slotEnableDisableActions);
	connect(KeyCache::instance().get(), &KeyCache::keyListingDone, this, &ClipboardMenu::slotEnableDisableActions);
	slotEnableDisableActions();
	}

	ClipboardMenu::~ClipboardMenu() = default;

	void ClipboardMenu::setMainWindow(MainWindow *window)
	{
	mWindow = window;
	}

	KActionMenu *ClipboardMenu::clipboardMenu() const
	{
	return mClipboardMenu;
	}

	void ClipboardMenu::startCommand(Command *cmd)
	{
	Q_ASSERT(cmd);
	cmd->setParent(mWindow);
	cmd->start();
	}

	void ClipboardMenu::slotImportClipboard()
	{
	startCommand(new ImportCertificateFromClipboardCommand(nullptr));
	}

	void ClipboardMenu::slotEncryptClipboard()
	{
	startCommand(new EncryptClipboardCommand(nullptr));
	}

	void ClipboardMenu::slotOpenPGPSignClipboard()
	{
	startCommand(new SignClipboardCommand(GpgME::OpenPGP, nullptr));
	}

	void ClipboardMenu::slotSMIMESignClipboard()
	{
	startCommand(new SignClipboardCommand(GpgME::CMS, nullptr));
	}

	void ClipboardMenu::slotDecryptVerifyClipboard()
	{
	startCommand(new DecryptVerifyClipboardCommand(nullptr));
	}

	namespace
	{

	bool hasSigningKeys(GpgME::Protocol protocol)
	{
	if (!KeyCache::instance()->initialized()) {
	return false;
	}
	return std::ranges::any_of(KeyCache::instance()->keys(), [protocol](const auto &k) {
	return k.hasSecret() && Kleo::keyHasSign(k) && (k.protocol() == protocol);
	});
	}

	}

	void ClipboardMenu::slotEnableDisableActions()
	{
	- const QSignalBlocker blocker(QApplication::clipboard());
	- mImportClipboardAction->setEnabled(ImportCertificateFromClipboardCommand::canImportCurrentClipboard());
	- mEncryptClipboardAction->setEnabled(EncryptClipboardCommand::canEncryptCurrentClipboard());
	- mOpenPGPSignClipboardAction->setEnabled(SignClipboardCommand::canSignCurrentClipboard() && hasSigningKeys(GpgME::OpenPGP));
	+ mOpenPGPSignClipboardAction->setEnabled(hasSigningKeys(GpgME::OpenPGP));
	if (mSmimeSignClipboardAction) {
	- mSmimeSignClipboardAction->setEnabled(SignClipboardCommand::canSignCurrentClipboard() && hasSigningKeys(GpgME::CMS));
	+ Settings settings;
	+ mSmimeSignClipboardAction->setEnabled(settings.cmsEnabled() && settings.cmsSigningAllowed() && hasSigningKeys(GpgME::CMS));
	}
	- mDecryptVerifyClipboardAction->setEnabled(DecryptVerifyClipboardCommand::canDecryptVerifyCurrentClipboard());
	}

	#include "moc_clipboardmenu.cpp"

File Metadata

Mime Type: text/x-diff
Expires: Fri, Dec 5, 9:35 AM (20 h, 14 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: d1/fa/a70a50c261ce72a150d9becd40fb

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions