No OneTemporary
Actions

Size

53 KB

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 39804314..302f465d 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,149 +1,150 @@
	# SPDX-License-Identifier: CC0-1.0
	# SPDX-FileCopyrightText: none
	cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
	set(PIM_VERSION "5.20.46")

	project(libkleo VERSION ${PIM_VERSION})

	set(KF5_MIN_VERSION "5.95.0")

	if (WIN32)
	set(KF5_WANT_VERSION "5.70.0")
	else ()
	set(KF5_WANT_VERSION ${KF5_MIN_VERSION})
	endif ()

	find_package(ECM ${KF5_WANT_VERSION} CONFIG REQUIRED)
	set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})

	include(KDEInstallDirs)
	include(KDECMakeSettings)
	include(KDECompilerSettings NO_POLICY_SCOPE)

	include(GenerateExportHeader)
	include(ECMSetupVersion)
	include(ECMGenerateHeaders)
	include(ECMGeneratePriFile)

	include(FeatureSummary)
	include(ECMQtDeclareLoggingCategory)
	include(ECMDeprecationSettings)
	include(ECMAddQch)
	include(KDEClangFormat)
	include(KDEGitCommitHooks)

	option(BUILD_QCH "Build API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)" OFF)
	add_feature_info(QCH ${BUILD_QCH} "API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)")

	set(LIBKLEO_LIB_VERSION ${PIM_VERSION})
	set(QT_REQUIRED_VERSION "5.15.2")
	set(KDEPIMTEXTEDIT_VERSION "5.20.40")
	set(GPGME_REQUIRED_VERSION "1.15.0")

	find_package(Qt${QT_MAJOR_VERSION} ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets)
	if (QT_MAJOR_VERSION STREQUAL "6")
	find_package(Qt6Core5Compat)
	endif()
	find_package(KF5I18n ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5Config ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5WidgetsAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
	+find_package(KF5ConfigWidgets ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5Completion ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5CoreAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5Codecs ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5ItemModels ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5PimTextEdit ${KDEPIMTEXTEDIT_VERSION} CONFIG)

	find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	set_package_properties(Gpgmepp PROPERTIES DESCRIPTION "GpgME++ Library" URL "https://www.gnupg.org" TYPE REQUIRED PURPOSE "GpgME++ is required for OpenPGP support")
	if (QT_MAJOR_VERSION STREQUAL "6")
	find_package(QGpgmeQt6 ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	else()
	find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	endif()
	message(STATUS "GpgME++ Version ${Gpgmepp_VERSION}")
	if (Gpgmepp_VERSION VERSION_GREATER_EQUAL "1.16.0")
	set(GPGMEPP_SUPPORTS_TRUST_SIGNATURES 1)
	endif()

	find_package(Boost 1.34.0)
	set_package_properties(Boost PROPERTIES DESCRIPTION "Boost C++ Libraries" URL "https://www.boost.org" TYPE REQUIRED PURPOSE "Boost is required for building most KDEPIM applications")


	set_package_properties(KF5PimTextEdit PROPERTIES DESCRIPTION
	"A textedit with PIM-specific features."
	URL "https://commits.kde.org/kpimtextedit"
	TYPE OPTIONAL PURPOSE "Improved audit log viewer.")

	ecm_setup_version(PROJECT VARIABLE_PREFIX LIBKLEO
	VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/libkleo_version.h"
	PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5LibkleoConfigVersion.cmake"
	SOVERSION 5
	)

	########### Targets ###########
	ecm_set_disabled_deprecation_versions(QT 5.15.2 KF 5.96.0)

	remove_definitions(-DQT_NO_FOREACH)
	add_definitions(-DQT_NO_EMIT)
	########### CMake Config Files ###########
	set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5Libkleo")

	configure_package_config_file(
	"${CMAKE_CURRENT_SOURCE_DIR}/KF5LibkleoConfig.cmake.in"
	"${CMAKE_CURRENT_BINARY_DIR}/KF5LibkleoConfig.cmake"
	INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR}
	)

	install(FILES
	"${CMAKE_CURRENT_BINARY_DIR}/KF5LibkleoConfig.cmake"
	"${CMAKE_CURRENT_BINARY_DIR}/KF5LibkleoConfigVersion.cmake"
	DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
	COMPONENT Devel
	)

	install(EXPORT KF5LibkleoTargets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE KF5LibkleoTargets.cmake NAMESPACE KF5::)

	install(FILES
	${CMAKE_CURRENT_BINARY_DIR}/libkleo_version.h
	DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF}/Libkleo COMPONENT Devel
	)

	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-libkleo.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-libkleo.h)
	include_directories(${CMAKE_CURRENT_BINARY_DIR})

	option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" OFF)

	set(COMPILE_WITH_UNITY_CMAKE_SUPPORT OFF)
	if (USE_UNITY_CMAKE_SUPPORT)
	set(COMPILE_WITH_UNITY_CMAKE_SUPPORT ON)
	endif()


	add_subdirectory(src)
	if (BUILD_TESTING)
	add_subdirectory(autotests)
	add_subdirectory(tests)
	endif()

	ecm_qt_install_logging_categories(
	EXPORT LIBKLEO
	FILE libkleo.categories
	DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
	)

	ki18n_install(po)
	if (BUILD_QCH)
	ecm_install_qch_export(
	TARGETS KF5Libkleo_QCH
	FILE KF5LibkleoQchTargets.cmake
	DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
	COMPONENT Devel
	)
	set(PACKAGE_INCLUDE_QCHTARGETS "include(\"\${CMAKE_CURRENT_LIST_DIR}/KF5LibkleoQchTargets.cmake\")")
	endif()
	feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)

	# add clang-format target for all our real source files
	file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES .cpp .h *.c)
	kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES})
	kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)
	diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
	index 095fcf0a..50cbd472 100644
	--- a/src/CMakeLists.txt
	+++ b/src/CMakeLists.txt
	@@ -1,358 +1,359 @@
	# SPDX-License-Identifier: CC0-1.0
	# SPDX-FileCopyrightText: none
	# target_include_directories does not handle empty include paths
	include_directories(
	${Boost_INCLUDE_DIRS}
	${GPGME_INCLUDES}
	)
	add_definitions(-DTRANSLATION_DOMAIN=\"libkleopatra\")

	#add_definitions( -DQT_NO_CAST_FROM_ASCII )
	#add_definitions( -DQT_NO_CAST_TO_ASCII )

	kde_enable_exceptions()

	add_definitions( -DGPGMEPP_ERR_SOURCE_DEFAULT=13 ) # 13 is GPG_ERR_SOURCE_KLEO, even if gpg-error's too old to know about

	add_subdirectory( pics )
	add_library(KF5Libkleo)
	add_library(KF5::Libkleo ALIAS KF5Libkleo)

	########### next target ###############
	target_sources(KF5Libkleo PRIVATE
	kleo/checksumdefinition.cpp
	kleo/checksumdefinition.h
	kleo/debug.cpp
	kleo/debug.h
	kleo/defaultkeyfilter.cpp
	kleo/defaultkeyfilter.h
	kleo/defaultkeygenerationjob.cpp
	kleo/defaultkeygenerationjob.h
	kleo/docaction.cpp
	kleo/dn.cpp
	kleo/dn.h
	kleo/enum.cpp
	kleo/enum.h
	kleo/kconfigbasedkeyfilter.cpp
	kleo/kconfigbasedkeyfilter.h
	kleo/keyfilter.h
	kleo/keyfiltermanager.cpp
	kleo/keyfiltermanager.h
	kleo/keygroup.cpp
	kleo/keygroup.h
	kleo/keygroupconfig.cpp
	kleo/keygroupconfig.h
	kleo/keygroupimportexport.cpp
	kleo/keygroupimportexport.h
	kleo/keyresolver.cpp
	kleo/keyresolver.h
	kleo/keyresolvercore.cpp
	kleo/keyresolvercore.h
	kleo/keyserverconfig.cpp
	kleo/keyserverconfig.h
	kleo/kleoexception.cpp
	kleo/kleoexception.h
	kleo/oidmap.cpp
	kleo/oidmap.h
	kleo/predicates.h
	kleo/stl_util.h
	models/keycache.cpp
	models/keycache.h
	models/keycache_p.h
	models/keylist.h
	models/keylistmodel.cpp
	models/keylistmodel.h
	models/keylistmodelinterface.cpp
	models/keylistmodelinterface.h
	models/keylistsortfilterproxymodel.cpp
	models/keylistsortfilterproxymodel.h
	models/keyrearrangecolumnsproxymodel.cpp
	models/keyrearrangecolumnsproxymodel.h
	models/subkeylistmodel.cpp
	models/subkeylistmodel.h
	models/useridlistmodel.cpp
	models/useridlistmodel.h
	utils/algorithm.h
	utils/assuan.cpp
	utils/assuan.h
	utils/classify.cpp
	utils/classify.h
	utils/compat.cpp
	utils/compat.h
	utils/cryptoconfig.cpp
	utils/cryptoconfig.h
	utils/cryptoconfig_p.h
	utils/filesystemwatcher.cpp
	utils/filesystemwatcher.h
	utils/formatting.cpp
	utils/formatting.h
	utils/gnupg-registry.c
	utils/gnupg-registry.h
	utils/gnupg.cpp
	utils/gnupg.h
	utils/hex.cpp
	utils/hex.h
	utils/keyhelpers.cpp
	utils/keyhelpers.h
	utils/qtstlhelpers.cpp
	utils/qtstlhelpers.h
	utils/scdaemon.cpp
	utils/scdaemon.h
	utils/stringutils.cpp
	utils/stringutils.h
	utils/systeminfo.cpp
	utils/systeminfo.h
	utils/test.cpp
	utils/test.h
	utils/uniquelock.cpp
	utils/uniquelock.h
	)
	ecm_qt_declare_logging_category(KF5Libkleo HEADER libkleo_debug.h IDENTIFIER LIBKLEO_LOG CATEGORY_NAME org.kde.pim.libkleo
	DESCRIPTION "libkleo (kleo_core)"
	EXPORT LIBKLEO
	)


	target_sources(KF5Libkleo PRIVATE
	ui/auditlogviewer.cpp
	ui/auditlogviewer.h
	ui/cryptoconfigentryreaderport.cpp
	ui/cryptoconfigentryreaderport_p.h
	ui/cryptoconfigmodule.cpp
	ui/cryptoconfigmodule.h
	ui/cryptoconfigmodule_p.h
	ui/directoryserviceswidget.cpp
	ui/directoryserviceswidget.h
	ui/dnattributeorderconfigwidget.cpp
	ui/dnattributeorderconfigwidget.h
	ui/editdirectoryservicedialog.cpp
	ui/editdirectoryservicedialog.h
	ui/filenamerequester.cpp
	ui/filenamerequester.h
	ui/messagebox.cpp
	ui/messagebox.h
	ui/progressbar.cpp
	ui/progressbar.h
	ui/progressdialog.cpp
	ui/progressdialog.h
	ui/readerportselection.cpp
	ui/readerportselection.h
	)

	ecm_qt_declare_logging_category(KF5Libkleo HEADER kleo_ui_debug.h IDENTIFIER KLEO_UI_LOG CATEGORY_NAME org.kde.pim.kleo_ui
	DESCRIPTION "libkleo (kleo_ui)"
	OLD_CATEGORY_NAMES log_kleo_ui
	EXPORT LIBKLEO
	)


	target_sources(KF5Libkleo PRIVATE # make this a separate lib.
	ui/keyapprovaldialog.cpp
	ui/keyapprovaldialog.h
	ui/keylistview.cpp
	ui/keylistview.h
	ui/keyrequester.cpp
	ui/keyrequester.h
	ui/keyselectioncombo.cpp
	ui/keyselectioncombo.h
	ui/keyselectiondialog.cpp
	ui/keyselectiondialog.h
	ui/newkeyapprovaldialog.cpp
	ui/newkeyapprovaldialog.h
	)


	target_link_libraries(KF5Libkleo PUBLIC Gpgmepp PRIVATE Qt${QT_MAJOR_VERSION}::Widgets
	KF5::I18n
	KF5::Completion
	KF5::ConfigCore
	+ KF5::ConfigWidgets
	KF5::CoreAddons
	KF5::WidgetsAddons
	KF5::ItemModels
	KF5::Codecs)

	if (QT_MAJOR_VERSION STREQUAL "6")
	target_link_libraries(KF5Libkleo PRIVATE Qt6::Core5Compat PUBLIC QGpgmeQt6)
	else()
	target_link_libraries(KF5Libkleo PUBLIC QGpgme)
	endif()
	# Boost::headers may not be available for old versions of Boost
	if (TARGET Boost::headers)
	target_link_libraries(KF5Libkleo PRIVATE Boost::headers)
	endif()

	if (KF5PimTextEdit_FOUND)
	add_definitions(-DHAVE_PIMTEXTEDIT)
	target_link_libraries(KF5Libkleo PRIVATE KF5::PimTextEdit)
	endif()

	if (COMPILE_WITH_UNITY_CMAKE_SUPPORT)
	set_target_properties(KF5Libkleo PROPERTIES UNITY_BUILD ON)
	endif()
	generate_export_header(KF5Libkleo BASE_NAME kleo)
	if(WIN32)
	target_link_libraries(KF5Libkleo ${GPGME_VANILLA_LIBRARIES} )
	endif()

	set_target_properties(KF5Libkleo PROPERTIES
	VERSION ${LIBKLEO_VERSION}
	SOVERSION ${LIBKLEO_SOVERSION}
	EXPORT_NAME Libkleo
	)

	install(TARGETS
	KF5Libkleo
	EXPORT KF5LibkleoTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS}
	)

	target_include_directories(KF5Libkleo INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF}/Libkleo>")
	target_include_directories(KF5Libkleo PUBLIC "$<BUILD_INTERFACE:${libkleo_SOURCE_DIR}/src;${libkleo_BINARY_DIR}/src>")

	ecm_generate_headers(libkleo_CamelCase_HEADERS
	HEADER_NAMES
	ChecksumDefinition
	Debug
	DefaultKeyFilter
	DefaultKeyGenerationJob
	DocAction
	Dn
	Enum
	KConfigBasedKeyFilter
	KeyFilter
	KeyFilterManager
	KeyGroup
	KeyGroupConfig
	KeyGroupImportExport
	KeyResolver
	KeyResolverCore
	KeyserverConfig
	KleoException
	OidMap
	Predicates
	Stl_Util
	REQUIRED_HEADERS libkleo_HEADERS
	PREFIX Libkleo
	RELATIVE kleo
	)

	ecm_generate_headers(libkleo_CamelCase_models_HEADERS
	HEADER_NAMES
	KeyCache
	KeyList
	KeyListModel
	KeyListModelInterface
	KeyListSortFilterProxyModel
	KeyRearrangeColumnsProxyModel
	SubkeyListModel
	UserIDListModel
	REQUIRED_HEADERS libkleo_models_HEADERS
	PREFIX Libkleo
	RELATIVE models
	)

	ecm_generate_headers(libkleo_CamelCase_utils_HEADERS
	HEADER_NAMES
	Algorithm
	Assuan
	Classify
	Compat
	CryptoConfig
	FileSystemWatcher
	Formatting
	GnuPG
	Hex
	KeyHelpers
	QtStlHelpers
	SCDaemon
	StringUtils
	SystemInfo
	Test
	UniqueLock
	REQUIRED_HEADERS libkleo_utils_HEADERS
	PREFIX Libkleo
	RELATIVE utils
	)

	ecm_generate_headers(libkleo_CamelCase_ui_HEADERS
	HEADER_NAMES
	CryptoConfigModule
	DNAttributeOrderConfigWidget
	DirectoryServicesWidget
	EditDirectoryServiceDialog
	FileNameRequester
	KeyApprovalDialog
	KeyListView
	KeyRequester
	KeySelectionCombo
	KeySelectionDialog
	MessageBox
	NewKeyApprovalDialog
	ProgressDialog
	ReaderPortSelection
	REQUIRED_HEADERS libkleo_ui_HEADERS
	PREFIX Libkleo
	RELATIVE ui
	)

	ecm_generate_pri_file(BASE_NAME Libkleo
	LIB_NAME KF5Libkleo
	DEPS "QGpgme" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF}/Libkleo
	)


	install(FILES
	${libkleo_CamelCase_HEADERS}
	${libkleo_CamelCase_models_HEADERS}
	${libkleo_CamelCase_ui_HEADERS}
	${libkleo_CamelCase_utils_HEADERS}
	DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF}/Libkleo/Libkleo
	COMPONENT Devel
	)

	install(FILES
	${CMAKE_CURRENT_BINARY_DIR}/kleo_export.h
	${libkleo_HEADERS}
	${libkleo_models_HEADERS}
	${libkleo_ui_HEADERS}
	${libkleo_utils_HEADERS}
	DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF}/Libkleo/libkleo
	COMPONENT Devel
	)
	install(FILES
	${PRI_FILENAME}
	DESTINATION ${ECM_MKSPECS_INSTALL_DIR})


	if ( WIN32 )
	install ( FILES libkleopatrarc-win32.desktop DESTINATION ${KDE_INSTALL_CONFDIR} RENAME libkleopatrarc )
	else ()
	install ( FILES libkleopatrarc.desktop DESTINATION ${KDE_INSTALL_CONFDIR} RENAME libkleopatrarc )
	endif ()

	if (BUILD_QCH)
	ecm_add_qch(
	KF5Libkleo_QCH
	NAME KF5Libkleo
	BASE_NAME KF5Libkleo
	VERSION ${PIM_VERSION}
	ORG_DOMAIN org.kde
	SOURCES # using only public headers, to cover only public API
	${libkleo_HEADERS}
	${libkleo_models_HEADERS}
	${libkleo_ui_HEADERS}
	${libkleo_utils_HEADERS}
	#MD_MAINPAGE "${CMAKE_SOURCE_DIR}/README.md"
	#IMAGE_DIRS "${CMAKE_SOURCE_DIR}/docs/pics"
	LINK_QCHS
	Qt5Core_QCH
	Qt5Gui_QCH
	Qt5Widgets_QCH
	INCLUDE_DIRS
	${CMAKE_CURRENT_BINARY_DIR}
	BLANK_MACROS
	KLEO_EXPORT
	TAGFILE_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR}
	QCH_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR}
	COMPONENT Devel
	)
	endif()
	diff --git a/src/ui/newkeyapprovaldialog.cpp b/src/ui/newkeyapprovaldialog.cpp
	index f587a6d6..8a8af267 100644
	--- a/src/ui/newkeyapprovaldialog.cpp
	+++ b/src/ui/newkeyapprovaldialog.cpp
	@@ -1,936 +1,933 @@
	/* -- c++ --
	newkeyapprovaldialog.cpp

	This file is part of libkleopatra, the KDE keymanagement library
	SPDX-FileCopyrightText: 2018 Intevation GmbH
	SPDX-FileCopyrightText: 2021 g10 Code GmbH
	SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>

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

	#include <config-libkleo.h>

	#include "newkeyapprovaldialog.h"

	#include "keyselectioncombo.h"
	#include "progressdialog.h"

	#include <libkleo/debug.h>
	#include <libkleo/defaultkeyfilter.h>
	#include <libkleo/formatting.h>
	#include <libkleo/gnupg.h>
	#include <libkleo/systeminfo.h>

	#include <libkleo_debug.h>

	+#include <KColorScheme>
	#include <KLocalizedString>
	#include <KMessageBox>

	#include <QGpgME/DefaultKeyGenerationJob>
	#include <QGpgME/Job>

	#include <QButtonGroup>
	#include <QCheckBox>
	#include <QDialogButtonBox>
	#include <QGroupBox>
	#include <QHBoxLayout>
	#include <QLabel>
	#include <QMap>
	#include <QPushButton>
	#include <QRadioButton>
	#include <QScreen>
	#include <QScrollArea>
	#include <QToolTip>
	#include <QVBoxLayout>
	#include <QWindow>

	#include <gpgme++/key.h>
	#include <gpgme++/keygenerationresult.h>

	using namespace Kleo;
	using namespace GpgME;

	namespace
	{
	class EncryptFilter : public DefaultKeyFilter
	{
	public:
	EncryptFilter()
	: DefaultKeyFilter()
	{
	setCanEncrypt(DefaultKeyFilter::Set);
	}
	};
	static std::shared_ptr<KeyFilter> s_encryptFilter = std::shared_ptr<KeyFilter>(new EncryptFilter);

	class OpenPGPFilter : public DefaultKeyFilter
	{
	public:
	OpenPGPFilter()
	: DefaultKeyFilter()
	{
	setIsOpenPGP(DefaultKeyFilter::Set);
	setCanEncrypt(DefaultKeyFilter::Set);
	}
	};
	static std::shared_ptr<KeyFilter> s_pgpEncryptFilter = std::shared_ptr<KeyFilter>(new OpenPGPFilter);

	class OpenPGPSignFilter : public DefaultKeyFilter
	{
	public:
	OpenPGPSignFilter()
	: DefaultKeyFilter()
	{
	/* Also list unusable keys to make it transparent why they are unusable */
	setDisabled(DefaultKeyFilter::NotSet);
	setRevoked(DefaultKeyFilter::NotSet);
	setExpired(DefaultKeyFilter::NotSet);
	setCanSign(DefaultKeyFilter::Set);
	setHasSecret(DefaultKeyFilter::Set);
	setIsOpenPGP(DefaultKeyFilter::Set);
	}
	};
	static std::shared_ptr<KeyFilter> s_pgpSignFilter = std::shared_ptr<KeyFilter>(new OpenPGPSignFilter);

	class SMIMEFilter : public DefaultKeyFilter
	{
	public:
	SMIMEFilter()
	: DefaultKeyFilter()
	{
	setIsOpenPGP(DefaultKeyFilter::NotSet);
	setCanEncrypt(DefaultKeyFilter::Set);
	}
	};
	static std::shared_ptr<KeyFilter> s_smimeEncryptFilter = std::shared_ptr<KeyFilter>(new SMIMEFilter);

	class SMIMESignFilter : public DefaultKeyFilter
	{
	public:
	SMIMESignFilter()
	: DefaultKeyFilter()
	{
	setDisabled(DefaultKeyFilter::NotSet);
	setRevoked(DefaultKeyFilter::NotSet);
	setExpired(DefaultKeyFilter::NotSet);
	setCanSign(DefaultKeyFilter::Set);
	setIsOpenPGP(DefaultKeyFilter::NotSet);
	setHasSecret(DefaultKeyFilter::Set);
	}
	};
	static std::shared_ptr<KeyFilter> s_smimeSignFilter = std::shared_ptr<KeyFilter>(new SMIMESignFilter);

	/* Some decoration and a button to remove the filter for a keyselectioncombo */
	class ComboWidget : public QWidget
	{
	Q_OBJECT
	public:
	explicit ComboWidget(KeySelectionCombo *combo)
	: mCombo(combo)
	, mFilterBtn(new QPushButton)
	{
	auto hLay = new QHBoxLayout(this);
	auto infoBtn = new QPushButton;
	infoBtn->setIcon(QIcon::fromTheme(QStringLiteral("help-contextual")));
	infoBtn->setIconSize(QSize(22, 22));
	infoBtn->setFlat(true);
	hLay->addWidget(infoBtn);
	hLay->addWidget(combo, 1);
	hLay->addWidget(mFilterBtn, 0);

	connect(infoBtn, &QPushButton::clicked, this, [this, infoBtn]() {
	QToolTip::showText(infoBtn->mapToGlobal(QPoint()) + QPoint(infoBtn->width(), 0),
	mCombo->currentData(Qt::ToolTipRole).toString(),
	infoBtn,
	QRect(),
	30000);
	});

	// FIXME: This is ugly to enforce but otherwise the
	// icon is broken.
	combo->setMinimumHeight(22);
	mFilterBtn->setMinimumHeight(23);

	updateFilterButton();

	connect(mFilterBtn, &QPushButton::clicked, this, [this]() {
	const QString curFilter = mCombo->idFilter();
	if (curFilter.isEmpty()) {
	setIdFilter(mLastIdFilter);
	mLastIdFilter = QString();
	} else {
	setIdFilter(QString());
	mLastIdFilter = curFilter;
	}
	});
	}

	void setIdFilter(const QString &id)
	{
	mCombo->setIdFilter(id);
	updateFilterButton();
	}

	void updateFilterButton()
	{
	if (mCombo->idFilter().isEmpty()) {
	mFilterBtn->setIcon(QIcon::fromTheme(QStringLiteral("kt-add-filters")));
	mFilterBtn->setToolTip(i18n("Show keys matching the email address"));
	} else {
	mFilterBtn->setIcon(QIcon::fromTheme(QStringLiteral("kt-remove-filters")));
	mFilterBtn->setToolTip(i18n("Show all keys"));
	}
	}

	KeySelectionCombo *combo()
	{
	return mCombo;
	}

	GpgME::Protocol fixedProtocol() const
	{
	return mFixedProtocol;
	}

	void setFixedProtocol(GpgME::Protocol proto)
	{
	mFixedProtocol = proto;
	}

	private:
	KeySelectionCombo *mCombo;
	QPushButton *mFilterBtn;
	QString mLastIdFilter;
	GpgME::Protocol mFixedProtocol = GpgME::UnknownProtocol;
	};

	static enum GpgME::UserID::Validity keyValidity(const GpgME::Key &key)
	{
	enum GpgME::UserID::Validity validity = GpgME::UserID::Validity::Unknown;

	for (const auto &uid : key.userIDs()) {
	if (validity == GpgME::UserID::Validity::Unknown \|\| validity > uid.validity()) {
	validity = uid.validity();
	}
	}

	return validity;
	}

	static bool key_has_addr(const GpgME::Key &key, const QString &addr)
	{
	for (const auto &uid : key.userIDs()) {
	if (QString::fromStdString(uid.addrSpec()).toLower() == addr.toLower()) {
	return true;
	}
	}
	return false;
	}

	bool anyKeyHasProtocol(const std::vector<Key> &keys, GpgME::Protocol protocol)
	{
	return std::any_of(std::begin(keys), std::end(keys), [protocol](const auto &key) {
	return key.protocol() == protocol;
	});
	}

	Key findfirstKeyOfType(const std::vector<Key> &keys, GpgME::Protocol protocol)
	{
	const auto it = std::find_if(std::begin(keys), std::end(keys), [protocol](const auto &key) {
	return key.protocol() == protocol;
	});
	return it != std::end(keys) ? *it : Key();
	}

	} // namespace

	class NewKeyApprovalDialog::Private
	{
	private:
	enum Action {
	Unset,
	GenerateKey,
	IgnoreKey,
	};

	public:
	enum {
	OpenPGPButtonId = 1,
	SMIMEButtonId = 2,
	};

	Private(NewKeyApprovalDialog *qq,
	bool encrypt,
	bool sign,
	GpgME::Protocol forcedProtocol,
	GpgME::Protocol presetProtocol,
	const QString &sender,
	bool allowMixed)
	: mForcedProtocol{forcedProtocol}
	, mSender{sender}
	, mSign{sign}
	, mEncrypt{encrypt}
	, mAllowMixed{allowMixed}
	, q{qq}
	{
	Q_ASSERT(forcedProtocol == GpgME::UnknownProtocol \|\| presetProtocol == GpgME::UnknownProtocol \|\| presetProtocol == forcedProtocol);
	Q_ASSERT(!allowMixed \|\| (allowMixed && forcedProtocol == GpgME::UnknownProtocol));
	Q_ASSERT(!(!allowMixed && presetProtocol == GpgME::UnknownProtocol));

	// We do the translation here to avoid having the same string multiple times.
	mGenerateTooltip = i18nc(
	"@info:tooltip for a 'Generate new key pair' action "
	"in a combobox when a user does not yet have an OpenPGP or S/MIME key.",
	"Generate a new key using your E-Mail address.<br/><br/>"
	"The key is necessary to decrypt and sign E-Mails. "
	"You will be asked for a passphrase to protect this key and the protected key "
	"will be stored in your home directory.");
	mMainLay = new QVBoxLayout;

	QDialogButtonBox *btnBox = new QDialogButtonBox(QDialogButtonBox::Ok \| QDialogButtonBox::Cancel);
	mOkButton = btnBox->button(QDialogButtonBox::Ok);
	#ifndef NDEBUG
	mOkButton->setObjectName(QStringLiteral("ok button"));
	#endif
	QObject::connect(btnBox, &QDialogButtonBox::accepted, q, [this]() {
	accepted();
	});
	QObject::connect(btnBox, &QDialogButtonBox::rejected, q, &QDialog::reject);

	mScrollArea = new QScrollArea;
	mScrollArea->setWidget(new QWidget);
	mScrollLayout = new QVBoxLayout;
	mScrollArea->widget()->setLayout(mScrollLayout);
	mScrollArea->setWidgetResizable(true);
	mScrollArea->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow);
	mScrollArea->setFrameStyle(QFrame::NoFrame);
	mScrollLayout->setContentsMargins(0, 0, 0, 0);

	q->setWindowTitle(i18nc("@title:window", "Security approval"));

	auto fmtLayout = new QHBoxLayout;
	mFormatBtns = new QButtonGroup(qq);
	QAbstractButton *pgpBtn;
	QAbstractButton *smimeBtn;
	if (mAllowMixed) {
	pgpBtn = new QCheckBox(i18n("OpenPGP"));
	smimeBtn = new QCheckBox(i18n("S/MIME"));
	} else {
	pgpBtn = new QRadioButton(i18n("OpenPGP"));
	smimeBtn = new QRadioButton(i18n("S/MIME"));
	}
	#ifndef NDEBUG
	pgpBtn->setObjectName(QStringLiteral("openpgp button"));
	smimeBtn->setObjectName(QStringLiteral("smime button"));
	#endif
	mFormatBtns->addButton(pgpBtn, OpenPGPButtonId);
	mFormatBtns->addButton(smimeBtn, SMIMEButtonId);
	mFormatBtns->setExclusive(!mAllowMixed);

	fmtLayout->addStretch(-1);
	fmtLayout->addWidget(pgpBtn);
	fmtLayout->addWidget(smimeBtn);
	mMainLay->addLayout(fmtLayout);

	if (mForcedProtocol != GpgME::UnknownProtocol) {
	pgpBtn->setChecked(mForcedProtocol == GpgME::OpenPGP);
	smimeBtn->setChecked(mForcedProtocol == GpgME::CMS);
	pgpBtn->setVisible(false);
	smimeBtn->setVisible(false);
	} else {
	pgpBtn->setChecked(presetProtocol == GpgME::OpenPGP \|\| presetProtocol == GpgME::UnknownProtocol);
	smimeBtn->setChecked(presetProtocol == GpgME::CMS \|\| presetProtocol == GpgME::UnknownProtocol);
	}

	QObject::connect(mFormatBtns, &QButtonGroup::idClicked, q, [this](int buttonId) {
	// ensure that at least one protocol button is checked
	if (mAllowMixed && !mFormatBtns->button(OpenPGPButtonId)->isChecked() && !mFormatBtns->button(SMIMEButtonId)->isChecked()) {
	mFormatBtns->button(buttonId == OpenPGPButtonId ? SMIMEButtonId : OpenPGPButtonId)->setChecked(true);
	}
	updateWidgets();
	});

	mMainLay->addWidget(mScrollArea);

	mComplianceLbl = new QLabel;
	mComplianceLbl->setVisible(false);
	#ifndef NDEBUG
	mComplianceLbl->setObjectName(QStringLiteral("compliance label"));
	#endif

	auto btnLayout = new QHBoxLayout;
	btnLayout->addWidget(mComplianceLbl);
	btnLayout->addWidget(btnBox);
	mMainLay->addLayout(btnLayout);

	q->setLayout(mMainLay);
	}

	~Private() = default;

	GpgME::Protocol currentProtocol()
	{
	const bool openPGPButtonChecked = mFormatBtns->button(OpenPGPButtonId)->isChecked();
	const bool smimeButtonChecked = mFormatBtns->button(SMIMEButtonId)->isChecked();
	if (mAllowMixed) {
	if (openPGPButtonChecked && !smimeButtonChecked) {
	return GpgME::OpenPGP;
	}
	if (!openPGPButtonChecked && smimeButtonChecked) {
	return GpgME::CMS;
	}
	} else if (openPGPButtonChecked) {
	return GpgME::OpenPGP;
	} else if (smimeButtonChecked) {
	return GpgME::CMS;
	}
	return GpgME::UnknownProtocol;
	}

	auto findVisibleKeySelectionComboWithGenerateKey()
	{
	const auto it = std::find_if(std::begin(mAllCombos), std::end(mAllCombos), [](auto combo) {
	return combo->isVisible() && combo->currentData(Qt::UserRole).toInt() == GenerateKey;
	});
	return it != std::end(mAllCombos) ? *it : nullptr;
	}

	void generateKey(KeySelectionCombo *combo)
	{
	const auto &addr = combo->property("address").toString();
	auto job = new QGpgME::DefaultKeyGenerationJob(q);
	auto progress =
	new Kleo::ProgressDialog(job, i18n("Generating key for '%1'...", addr) + QStringLiteral("\n\n") + i18n("This can take several minutes."), q);
	progress->setWindowFlags(progress->windowFlags() & ~Qt::WindowContextHelpButtonHint);
	progress->setWindowTitle(i18nc("@title:window", "Key generation"));
	progress->setModal(true);
	progress->setAutoClose(true);
	progress->setMinimumDuration(0);
	progress->setValue(0);

	mRunningJobs << job;
	connect(job, &QGpgME::DefaultKeyGenerationJob::result, q, [this, job, combo](const GpgME::KeyGenerationResult &result) {
	handleKeyGenResult(result, job, combo);
	});
	job->start(addr, QString());
	return;
	}

	void handleKeyGenResult(const GpgME::KeyGenerationResult &result, QGpgME::Job job, KeySelectionCombo combo)
	{
	mLastError = result.error();
	if (!mLastError \|\| mLastError.isCanceled()) {
	combo->setDefaultKey(QString::fromLatin1(result.fingerprint()), GpgME::OpenPGP);
	connect(combo, &KeySelectionCombo::keyListingFinished, q, [this, job]() {
	mRunningJobs.removeAll(job);
	});
	combo->refreshKeys();
	} else {
	mRunningJobs.removeAll(job);
	}
	}

	void checkAccepted()
	{
	if (mLastError \|\| mLastError.isCanceled()) {
	KMessageBox::error(q, QString::fromLocal8Bit(mLastError.asString()), i18n("Operation Failed"));
	mRunningJobs.clear();
	return;
	}

	if (!mRunningJobs.empty()) {
	return;
	}

	/* Save the keys */
	mAcceptedResult.protocol = currentProtocol();
	for (const auto combo : std::as_const(mEncCombos)) {
	const auto addr = combo->property("address").toString();
	const auto key = combo->currentKey();
	if (!combo->isVisible() \|\| key.isNull()) {
	continue;
	}
	mAcceptedResult.encryptionKeys[addr].push_back(key);
	}
	for (const auto combo : std::as_const(mSigningCombos)) {
	const auto key = combo->currentKey();
	if (!combo->isVisible() \|\| key.isNull()) {
	continue;
	}
	mAcceptedResult.signingKeys.push_back(key);
	}

	q->accept();
	}

	void accepted()
	{
	// We can assume everything was validly resolved, otherwise
	// the OK button would have been disabled.
	// Handle custom items now.
	if (auto combo = findVisibleKeySelectionComboWithGenerateKey()) {
	generateKey(combo);
	return;
	}
	checkAccepted();
	}

	auto encryptionKeyFilter(GpgME::Protocol protocol)
	{
	switch (protocol) {
	case OpenPGP:
	return s_pgpEncryptFilter;
	case CMS:
	return s_smimeEncryptFilter;
	default:
	return s_encryptFilter;
	}
	}

	void updateWidgets()
	{
	const GpgME::Protocol protocol = currentProtocol();
	const auto encryptionFilter = encryptionKeyFilter(protocol);

	for (auto combo : std::as_const(mSigningCombos)) {
	auto widget = qobject_cast<ComboWidget *>(combo->parentWidget());
	if (!widget) {
	qCDebug(LIBKLEO_LOG) << "Failed to find signature combo widget";
	continue;
	}
	widget->setVisible(protocol == GpgME::UnknownProtocol \|\| widget->fixedProtocol() == GpgME::UnknownProtocol \|\| widget->fixedProtocol() == protocol);
	}
	for (auto combo : std::as_const(mEncCombos)) {
	auto widget = qobject_cast<ComboWidget *>(combo->parentWidget());
	if (!widget) {
	qCDebug(LIBKLEO_LOG) << "Failed to find combo widget";
	continue;
	}
	widget->setVisible(protocol == GpgME::UnknownProtocol \|\| widget->fixedProtocol() == GpgME::UnknownProtocol \|\| widget->fixedProtocol() == protocol);
	if (widget->isVisible() && combo->property("address") != mSender) {
	combo->setKeyFilter(encryptionFilter);
	}
	}
	// hide the labels indicating the protocol of the sender's keys if only a single protocol is active
	const auto protocolLabels = q->findChildren<QLabel *>(QStringLiteral("protocol label"));
	for (auto label : protocolLabels) {
	label->setVisible(protocol == GpgME::UnknownProtocol);
	}
	}

	auto createProtocolLabel(GpgME::Protocol protocol)
	{
	auto label = new QLabel(Formatting::displayName(protocol));
	label->setObjectName(QStringLiteral("protocol label"));
	return label;
	}

	ComboWidget *createSigningCombo(const QString &addr, const GpgME::Key &key, GpgME::Protocol protocol = GpgME::UnknownProtocol)
	{
	Q_ASSERT(!key.isNull() \|\| protocol != UnknownProtocol);
	protocol = !key.isNull() ? key.protocol() : protocol;

	auto combo = new KeySelectionCombo();
	auto comboWidget = new ComboWidget(combo);
	#ifndef NDEBUG
	combo->setObjectName(QStringLiteral("signing key"));
	#endif
	if (protocol == GpgME::OpenPGP) {
	combo->setKeyFilter(s_pgpSignFilter);
	} else if (protocol == GpgME::CMS) {
	combo->setKeyFilter(s_smimeSignFilter);
	}
	if (key.isNull() \|\| key_has_addr(key, mSender)) {
	comboWidget->setIdFilter(mSender);
	}
	comboWidget->setFixedProtocol(protocol);
	if (!key.isNull()) {
	combo->setDefaultKey(QString::fromLatin1(key.primaryFingerprint()), protocol);
	}
	if (key.isNull() && protocol == OpenPGP) {
	combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Generate a new key pair"), GenerateKey, mGenerateTooltip);
	}
	combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("emblem-unavailable")),
	i18n("Don't confirm identity and integrity"),
	IgnoreKey,
	i18nc("@info:tooltip for not selecting a key for signing.", "The E-Mail will not be cryptographically signed."));

	mSigningCombos << combo;
	mAllCombos << combo;
	combo->setProperty("address", addr);

	connect(combo, &KeySelectionCombo::currentKeyChanged, q, [this]() {
	updateOkButton();
	});
	connect(combo, qOverload<int>(&QComboBox::currentIndexChanged), q, [this]() {
	updateOkButton();
	});

	return comboWidget;
	}

	void setSigningKeys(const std::vector<GpgME::Key> &preferredKeys, const std::vector<GpgME::Key> &alternativeKeys)
	{
	auto group = new QGroupBox(i18nc("Caption for signing key selection", "Confirm identity '%1' as:", mSender));
	group->setAlignment(Qt::AlignLeft);
	auto sigLayout = new QVBoxLayout(group);

	const bool mayNeedOpenPGP = mForcedProtocol != CMS;
	const bool mayNeedCMS = mForcedProtocol != OpenPGP;
	if (mayNeedOpenPGP) {
	if (mAllowMixed) {
	sigLayout->addWidget(createProtocolLabel(OpenPGP));
	}
	const Key preferredKey = findfirstKeyOfType(preferredKeys, OpenPGP);
	const Key alternativeKey = findfirstKeyOfType(alternativeKeys, OpenPGP);
	if (!preferredKey.isNull()) {
	qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << preferredKey;
	auto comboWidget = createSigningCombo(mSender, preferredKey);
	sigLayout->addWidget(comboWidget);
	} else if (!alternativeKey.isNull()) {
	qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << alternativeKey;
	auto comboWidget = createSigningCombo(mSender, alternativeKey);
	sigLayout->addWidget(comboWidget);
	} else {
	qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for OpenPGP key";
	auto comboWidget = createSigningCombo(mSender, Key(), OpenPGP);
	sigLayout->addWidget(comboWidget);
	}
	}
	if (mayNeedCMS) {
	if (mAllowMixed) {
	sigLayout->addWidget(createProtocolLabel(CMS));
	}
	const Key preferredKey = findfirstKeyOfType(preferredKeys, CMS);
	const Key alternativeKey = findfirstKeyOfType(alternativeKeys, CMS);
	if (!preferredKey.isNull()) {
	qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << preferredKey;
	auto comboWidget = createSigningCombo(mSender, preferredKey);
	sigLayout->addWidget(comboWidget);
	} else if (!alternativeKey.isNull()) {
	qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for" << alternativeKey;
	auto comboWidget = createSigningCombo(mSender, alternativeKey);
	sigLayout->addWidget(comboWidget);
	} else {
	qCDebug(LIBKLEO_LOG) << "setSigningKeys - creating signing combo for S/MIME key";
	auto comboWidget = createSigningCombo(mSender, Key(), CMS);
	sigLayout->addWidget(comboWidget);
	}
	}

	mScrollLayout->addWidget(group);
	}

	ComboWidget *createEncryptionCombo(const QString &addr, const GpgME::Key &key, GpgME::Protocol fixedProtocol)
	{
	auto combo = new KeySelectionCombo(false);
	auto comboWidget = new ComboWidget(combo);
	#ifndef NDEBUG
	combo->setObjectName(QStringLiteral("encryption key"));
	#endif
	if (fixedProtocol == GpgME::OpenPGP) {
	combo->setKeyFilter(s_pgpEncryptFilter);
	} else if (fixedProtocol == GpgME::CMS) {
	combo->setKeyFilter(s_smimeEncryptFilter);
	} else {
	combo->setKeyFilter(s_encryptFilter);
	}
	if (key.isNull() \|\| key_has_addr(key, addr)) {
	comboWidget->setIdFilter(addr);
	}
	comboWidget->setFixedProtocol(fixedProtocol);
	if (!key.isNull()) {
	combo->setDefaultKey(QString::fromLatin1(key.primaryFingerprint()), fixedProtocol);
	}

	if (addr == mSender && key.isNull() && fixedProtocol == OpenPGP) {
	combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Generate a new key pair"), GenerateKey, mGenerateTooltip);
	}

	combo->appendCustomItem(QIcon::fromTheme(QStringLiteral("emblem-unavailable")),
	i18n("No key. Recipient will be unable to decrypt."),
	IgnoreKey,
	i18nc("@info:tooltip for No Key selected for a specific recipient.",
	"Do not select a key for this recipient.<br/><br/>"
	"The recipient will receive the encrypted E-Mail, but it can only "
	"be decrypted with the other keys selected in this dialog."));

	connect(combo, &KeySelectionCombo::currentKeyChanged, q, [this]() {
	updateOkButton();
	});
	connect(combo, qOverload<int>(&QComboBox::currentIndexChanged), q, [this]() {
	updateOkButton();
	});

	mEncCombos << combo;
	mAllCombos << combo;
	combo->setProperty("address", addr);
	return comboWidget;
	}

	void addEncryptionAddr(const QString &addr,
	GpgME::Protocol preferredKeysProtocol,
	const std::vector<GpgME::Key> &preferredKeys,
	GpgME::Protocol alternativeKeysProtocol,
	const std::vector<GpgME::Key> &alternativeKeys,
	QGridLayout *encGrid)
	{
	if (addr == mSender) {
	const bool mayNeedOpenPGP = mForcedProtocol != CMS;
	const bool mayNeedCMS = mForcedProtocol != OpenPGP;
	if (mayNeedOpenPGP) {
	if (mAllowMixed) {
	encGrid->addWidget(createProtocolLabel(OpenPGP), encGrid->rowCount(), 0);
	}
	for (const auto &key : preferredKeys) {
	if (key.protocol() == OpenPGP) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
	auto comboWidget = createEncryptionCombo(addr, key, OpenPGP);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	}
	for (const auto &key : alternativeKeys) {
	if (key.protocol() == OpenPGP) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
	auto comboWidget = createEncryptionCombo(addr, key, OpenPGP);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	}
	if (!anyKeyHasProtocol(preferredKeys, OpenPGP) && !anyKeyHasProtocol(alternativeKeys, OpenPGP)) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for OpenPGP key";
	auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), OpenPGP);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	}
	if (mayNeedCMS) {
	if (mAllowMixed) {
	encGrid->addWidget(createProtocolLabel(CMS), encGrid->rowCount(), 0);
	}
	for (const auto &key : preferredKeys) {
	if (key.protocol() == CMS) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
	auto comboWidget = createEncryptionCombo(addr, key, CMS);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	}
	for (const auto &key : alternativeKeys) {
	if (key.protocol() == CMS) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
	auto comboWidget = createEncryptionCombo(addr, key, CMS);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	}
	if (!anyKeyHasProtocol(preferredKeys, CMS) && !anyKeyHasProtocol(alternativeKeys, CMS)) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for S/MIME key";
	auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), CMS);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	}
	} else {
	encGrid->addWidget(new QLabel(addr), encGrid->rowCount(), 0);

	for (const auto &key : preferredKeys) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
	auto comboWidget = createEncryptionCombo(addr, key, preferredKeysProtocol);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	for (const auto &key : alternativeKeys) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << key;
	auto comboWidget = createEncryptionCombo(addr, key, alternativeKeysProtocol);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	if (!mAllowMixed) {
	if (preferredKeys.empty()) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for" << Formatting::displayName(preferredKeysProtocol)
	<< "key";
	auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), preferredKeysProtocol);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	if (alternativeKeys.empty() && alternativeKeysProtocol != UnknownProtocol) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for"
	<< Formatting::displayName(alternativeKeysProtocol) << "key";
	auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), alternativeKeysProtocol);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	} else {
	if (preferredKeys.empty() && alternativeKeys.empty()) {
	qCDebug(LIBKLEO_LOG) << "setEncryptionKeys -" << addr << "- creating encryption combo for any key";
	auto comboWidget = createEncryptionCombo(addr, GpgME::Key(), UnknownProtocol);
	encGrid->addWidget(comboWidget, encGrid->rowCount(), 0, 1, 2);
	}
	}
	}
	}

	void setEncryptionKeys(GpgME::Protocol preferredKeysProtocol,
	const QMap<QString, std::vector<GpgME::Key>> &preferredKeys,
	GpgME::Protocol alternativeKeysProtocol,
	const QMap<QString, std::vector<GpgME::Key>> &alternativeKeys)
	{
	{
	auto group = new QGroupBox(i18nc("Encrypt to self (email address):", "Encrypt to self (%1):", mSender));
	#ifndef NDEBUG
	group->setObjectName(QStringLiteral("encrypt-to-self box"));
	#endif
	group->setAlignment(Qt::AlignLeft);
	auto encGrid = new QGridLayout(group);

	addEncryptionAddr(mSender, preferredKeysProtocol, preferredKeys.value(mSender), alternativeKeysProtocol, alternativeKeys.value(mSender), encGrid);

	encGrid->setColumnStretch(1, -1);
	mScrollLayout->addWidget(group);
	}

	const bool hasOtherRecipients = std::any_of(preferredKeys.keyBegin(), preferredKeys.keyEnd(), [this](const auto &recipient) {
	return recipient != mSender;
	});
	if (hasOtherRecipients) {
	auto group = new QGroupBox(i18n("Encrypt to others:"));
	#ifndef NDEBUG
	group->setObjectName(QStringLiteral("encrypt-to-others box"));
	#endif
	group->setAlignment(Qt::AlignLeft);
	auto encGrid = new QGridLayout{group};

	for (auto it = std::begin(preferredKeys); it != std::end(preferredKeys); ++it) {
	const auto &address = it.key();
	const auto &keys = it.value();
	if (address != mSender) {
	addEncryptionAddr(address, preferredKeysProtocol, keys, alternativeKeysProtocol, alternativeKeys.value(address), encGrid);
	}
	}

	encGrid->setColumnStretch(1, -1);
	mScrollLayout->addWidget(group);
	}

	mScrollLayout->addStretch(-1);
	}

	void updateOkButton()
	{
	static QString origOkText = mOkButton->text();
	const bool isGenerate = bool(findVisibleKeySelectionComboWithGenerateKey());
	const bool allVisibleEncryptionKeysAreIgnored = std::all_of(std::begin(mEncCombos), std::end(mEncCombos), [](auto combo) {
	return !combo->isVisible() \|\| combo->currentData(Qt::UserRole).toInt() == IgnoreKey;
	});

	// If we don't encrypt the ok button is always enabled. But otherwise
	// we only enable it if we encrypt to at least one recipient.
	mOkButton->setEnabled(!mEncrypt \|\| !allVisibleEncryptionKeysAreIgnored);

	mOkButton->setText(isGenerate ? i18n("Generate") : origOkText);

	if (!Kleo::gnupgUsesDeVsCompliance()) {
	return;
	}

	// Handle compliance
	bool de_vs = Kleo::gnupgIsDeVsCompliant();

	if (de_vs) {
	const GpgME::Protocol protocol = currentProtocol();

	for (const auto combo : std::as_const(mAllCombos)) {
	if (!combo->isVisible()) {
	continue;
	}
	const auto key = combo->currentKey();
	if (key.isNull()) {
	continue;
	}
	if (protocol != GpgME::UnknownProtocol && key.protocol() != protocol) {
	continue;
	}
	if (!Formatting::isKeyDeVs(key) \|\| keyValidity(key) < GpgME::UserID::Validity::Full) {
	de_vs = false;
	break;
	}
	}
	}

	if (de_vs) {
	mOkButton->setIcon(QIcon::fromTheme(QStringLiteral("security-high")));
	if (!SystemInfo::isHighContrastModeActive()) {
	- mOkButton->setStyleSheet(
	- QStringLiteral("background-color: ")
	- + QStringLiteral(
	- "#D5FAE2")); // KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name());
	+ mOkButton->setStyleSheet(QStringLiteral("background-color: ")
	+ + KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name());
	}
	mComplianceLbl->setText(i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
	"%1 communication possible.",
	Formatting::deVsString()));
	} else {
	mOkButton->setIcon(QIcon::fromTheme(QStringLiteral("security-medium")));
	if (!SystemInfo::isHighContrastModeActive()) {
	- mOkButton->setStyleSheet(
	- QStringLiteral("background-color: ")
	- + QStringLiteral(
	- "#FAE9EB")); // KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name()));
	+ mOkButton->setStyleSheet(QStringLiteral("background-color: ")
	+ + KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name());
	}
	mComplianceLbl->setText(i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
	"%1 communication not possible.",
	Formatting::deVsString()));
	}
	mComplianceLbl->setVisible(true);
	}

	GpgME::Protocol mForcedProtocol;
	QList<KeySelectionCombo *> mSigningCombos;
	QList<KeySelectionCombo *> mEncCombos;
	QList<KeySelectionCombo *> mAllCombos;
	QScrollArea *mScrollArea;
	QVBoxLayout *mScrollLayout;
	QPushButton *mOkButton;
	QVBoxLayout *mMainLay;
	QButtonGroup *mFormatBtns;
	QString mSender;
	bool mSign;
	bool mEncrypt;
	bool mAllowMixed;
	NewKeyApprovalDialog *q;
	QList<QGpgME::Job *> mRunningJobs;
	GpgME::Error mLastError;
	QLabel *mComplianceLbl;
	KeyResolver::Solution mAcceptedResult;
	QString mGenerateTooltip;
	};

	NewKeyApprovalDialog::NewKeyApprovalDialog(bool encrypt,
	bool sign,
	const QString &sender,
	KeyResolver::Solution preferredSolution,
	KeyResolver::Solution alternativeSolution,
	bool allowMixed,
	GpgME::Protocol forcedProtocol,
	QWidget *parent,
	Qt::WindowFlags f)
	: QDialog(parent, f)
	, d{std::make_unique<Private>(this, encrypt, sign, forcedProtocol, preferredSolution.protocol, sender, allowMixed)}
	{
	if (sign) {
	d->setSigningKeys(std::move(preferredSolution.signingKeys), std::move(alternativeSolution.signingKeys));
	}
	if (encrypt) {
	d->setEncryptionKeys(allowMixed ? UnknownProtocol : preferredSolution.protocol,
	std::move(preferredSolution.encryptionKeys),
	allowMixed ? UnknownProtocol : alternativeSolution.protocol,
	std::move(alternativeSolution.encryptionKeys));
	}
	d->updateWidgets();
	d->updateOkButton();

	const auto size = sizeHint();
	const auto desk = screen()->size();
	resize(QSize(desk.width() / 3, qMin(size.height(), desk.height() / 2)));
	}

	Kleo::NewKeyApprovalDialog::~NewKeyApprovalDialog() = default;

	KeyResolver::Solution NewKeyApprovalDialog::result()
	{
	return d->mAcceptedResult;
	}

	#include "newkeyapprovaldialog.moc"

File Metadata

Mime Type: text/x-diff
Expires: Sat, Feb 7, 7:37 AM (1 d, 21 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: d3/1c/84a22904d30b7d6dbaae2f7383be

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions