No OneTemporary
Actions

Size

32 KB

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index c95ed536e..e2f0f6665 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,250 +1,250 @@
	# SPDX-FileCopyrightText: none
	# SPDX-License-Identifier: BSD-3-Clause
	cmake_minimum_required(VERSION 3.16 FATAL_ERROR)

	set(RELEASE_SERVICE_VERSION_MAJOR "24")
	set(RELEASE_SERVICE_VERSION_MINOR "11")
	set(RELEASE_SERVICE_VERSION_MICRO "70")

	# The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
	if (NOT RELEASE_SERVICE_VERSION)
	set(RELEASE_SERVICE_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}.${RELEASE_SERVICE_VERSION_MINOR}.${RELEASE_SERVICE_VERSION_MICRO}")
	endif()
	if(RELEASE_SERVICE_VERSION_MICRO LESS 10)
	set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}0${RELEASE_SERVICE_VERSION_MICRO}")
	else()
	set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}${RELEASE_SERVICE_VERSION_MICRO}")
	endif()

	set(KLEOPATRA_VERSION_MAJOR "3")
	set(KLEOPATRA_VERSION_MINOR "2")
	set(KLEOPATRA_VERSION_MICRO "0")

	set(kleopatra_version "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}.${KDE_APPLICATIONS_COMPACT_VERSION}")
	# The following is for Windows
	set(kleopatra_version_win "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}")
	set(kleopatra_fileversion_win "${KLEOPATRA_VERSION_MAJOR},${KLEOPATRA_VERSION_MINOR},${KLEOPATRA_VERSION_MICRO},0")
	if (NOT KLEOPATRA_DISTRIBUTION_TEXT)
	# This is only used on Windows for the file attributes of Kleopatra
	set(KLEOPATRA_DISTRIBUTION_TEXT "KDE")
	endif()

	project(kleopatra VERSION ${kleopatra_version})

	option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)

	# Standalone build. Find / include everything necessary.
	set(KF_MIN_VERSION "6.4.0")
	set(KIDENTITYMANAGEMENT_VERSION "6.2.40")
	set(KMAILTRANSPORT_VERSION "6.2.40")
	set(AKONADI_MIME_VERSION "6.2.40")
	set(KMIME_VERSION "6.2.40")
	-set(LIBKLEO_VERSION "6.2.41")
	+set(LIBKLEO_VERSION "6.2.42")
	set(QT_REQUIRED_VERSION "6.7.0")
	set(MIMETREEPARSER_VERSION "6.2.40")
	set(GPGME_REQUIRED_VERSION "1.21.0")
	set(LIBASSUAN_REQUIRED_VERSION "2.4.2")
	set(GPG_ERROR_REQUIRED_VERSION "1.36")

	if (WIN32)
	set(KF6_WANT_VERSION ${KF_MIN_VERSION})
	set(KMIME_WANT_VERSION ${KMIME_VERSION})
	else ()
	set(KF6_WANT_VERSION ${KF_MIN_VERSION})
	set(KMIME_WANT_VERSION ${KMIME_VERSION})
	endif ()

	set(CMAKE_CXX_STANDARD 20)
	set(CMAKE_CXX_STANDARD_REQUIRED ON)

	find_package(ECM ${KF6_WANT_VERSION} CONFIG REQUIRED)
	set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
	set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})

	include(ECMInstallIcons)
	include(ECMSetupVersion)
	include(ECMAddTests)
	include(GenerateExportHeader)
	include(ECMGenerateHeaders)
	include(FeatureSummary)
	include(CheckFunctionExists)
	include(KDEInstallDirs)
	include(KDECMakeSettings)
	include(KDECompilerSettings NO_POLICY_SCOPE)
	include(ECMAddAppIcon)
	include(ECMQtDeclareLoggingCategory)
	include(ECMDeprecationSettings)
	include(ECMFeatureSummary)
	include(KDEClangFormat)
	include(KDEGitCommitHooks)

	# Find KF6 packages
	find_package(KF6 ${KF6_WANT_VERSION}
	REQUIRED COMPONENTS
	Codecs
	ColorScheme
	Config
	CoreAddons
	Crash
	I18n
	IconThemes
	ItemModels
	KIO
	WidgetsAddons
	WindowSystem
	XmlGui
	StatusNotifierItem

	OPTIONAL_COMPONENTS
	DocTools
	)

	set_package_properties(KF6DocTools PROPERTIES
	DESCRIPTION "Documentation tools"
	PURPOSE "Required to generate Kleopatra documentation."
	TYPE OPTIONAL)

	# Optional packages
	if (WIN32)
	# Only a replacement available for Windows so this
	# is required on other platforms.
	find_package(KF6DBusAddons ${KF6_WANT_VERSION} CONFIG)
	set_package_properties(KF6DBusAddons PROPERTIES DESCRIPTION "Support library to work with DBus"
	PURPOSE "DBus session integration"
	URL "https://inqlude.org/libraries/kdbusaddons.html"
	TYPE OPTIONAL)
	else()
	find_package(KF6DBusAddons ${KF6_WANT_VERSION} CONFIG REQUIRED)
	set(_kleopatra_dbusaddons_libs KF6::DBusAddons)
	endif()

	set(HAVE_QDBUS ${Qt6DBus_FOUND})

	find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	set(QGPGME_NAME "QGpgmeQt6")
	find_package(${QGPGME_NAME} ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.22.0")
	set(QGPGME_HAS_TOLOGSTRING 1)
	set(QGPGME_SUPPORTS_IS_MIME 1)
	endif()
	if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.23.0")
	set(QGPGME_SUPPORTS_WKD_REFRESH_JOB 1)
	endif()
	if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.23.3")
	set(QGPGME_FILE_JOBS_SUPPORT_DIRECT_FILE_IO 1)
	set(QGPGME_IMPORT_JOB_SUPPORTS_IMPORT_OPTIONS 1)
	endif()

	find_package(KPim6Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
	find_package(KPim6Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)
	find_package(KPim6IdentityManagementCore ${KIDENTITYMANAGEMENT_VERSION} CONFIG)
	find_package(KPim6MailTransport ${KMAILTRANSPORT_VERSION} CONFIG)
	find_package(KPim6AkonadiMime ${AKONADI_MIME_VERSION} CONFIG)
	find_package(KPim6MimeTreeParserWidgets ${MIMETREEPARSER_VERSION} CONFIG REQUIRED)

	set(CMAKE_MODULE_PATH ${LIBKLEO_MODULE_PATH} ${CMAKE_MODULE_PATH})

	find_package(Qt6 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)

	find_package(LibAssuan ${LIBASSUAN_REQUIRED_VERSION} REQUIRED)
	set_package_properties(LibAssuan PROPERTIES
	TYPE REQUIRED
	PURPOSE "Needed for Kleopatra to act as the GnuPG UI Server"
	)
	find_package(LibGpgError ${GPG_ERROR_REQUIRED_VERSION} REQUIRED)

	set(kleopatra_release FALSE)

	if(NOT kleopatra_release)
	find_package(Git)
	if(GIT_FOUND)
	execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	RESULT_VARIABLE rc
	ERROR_QUIET)
	if(rc EQUAL 0)
	execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	OUTPUT_VARIABLE Kleopatra_WC_REVISION)
	string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")

	execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%cI ${CMAKE_CURRENT_SOURCE_DIR}
	WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
	OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
	string(REGEX REPLACE "^([0-9]+)-([0-9]+)-([0-9]+)T([0-9]+):([0-9]+):([0-9]+).*$" "\\1\\2\\3T\\4\\5\\6"
	Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")

	set(kleopatra_version "${kleopatra_version}+git${Kleopatra_WC_LAST_CHANGED_DATE}~${Kleopatra_WC_REVISION}")
	endif()
	endif()
	endif()

	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.in ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.in ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)

	include_directories(
	${CMAKE_CURRENT_BINARY_DIR}
	${CMAKE_CURRENT_SOURCE_DIR}
	)

	add_definitions(-DQT_NO_CONTEXTLESS_CONNECT)
	ecm_set_disabled_deprecation_versions(QT 6.7.2 KF 6.4.0)

	if(CMAKE_COMPILER_IS_GNUCXX)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
	endif()
	if(MINGW)
	# we do not care about different signedness of passed pointer arguments
	add_compile_options($<$<COMPILE_LANGUAGE:C>:-Wno-pointer-sign>)
	endif()

	add_definitions(-DQT_NO_EMIT)
	remove_definitions(-DQT_NO_FOREACH)

	# Disable the use of QStringBuilder for operator+ to prevent crashes when
	# returning the result of concatenating string temporaries in lambdas. We do
	# this for example in some std::transform expressions.
	# This is a known issue: https://bugreports.qt.io/browse/QTBUG-47066
	# Alternatively, one would always have to remember to force the lambdas to
	# return a QString instead of QStringBuilder, but that's just too easy to
	# forget and, unfortunately, the compiler doesn't issue a warning if one forgets
	# this. So, it's just too dangerous.
	# One can still use QStringBuilder explicitly with the operator% if necessary.
	remove_definitions(-DQT_USE_FAST_OPERATOR_PLUS)
	remove_definitions(-DQT_USE_QSTRINGBUILDER)

	kde_enable_exceptions()
	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(pics)
	add_subdirectory(src)

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

	ecm_qt_install_logging_categories(
	EXPORT KLEOPATRA
	FILE kleopatra.categories
	DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
	)

	ki18n_install(po)
	if(KF6DocTools_FOUND)
	kdoctools_install(po)
	add_subdirectory(doc)
	endif()
	ecm_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/dialogs/editgroupdialog.cpp b/src/dialogs/editgroupdialog.cpp
	index 8c477a254..8f14e3f3d 100644
	--- a/src/dialogs/editgroupdialog.cpp
	+++ b/src/dialogs/editgroupdialog.cpp
	@@ -1,487 +1,547 @@
	/*
	dialogs/editgroupdialog.cpp

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

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

	#include "editgroupdialog.h"

	#include "commands/detailscommand.h"
	#include "utils/gui-helper.h"
	#include "view/keytreeview.h"
	#include <settings.h>

	#include <Libkleo/Algorithm>
	#include <Libkleo/Compat>
	#include <Libkleo/DefaultKeyFilter>
	#include <Libkleo/KeyCache>
	+#include <Libkleo/KeyFilter>
	+#include <Libkleo/KeyFilterManager>
	+#include <Libkleo/KeyHelpers>
	#include <Libkleo/KeyListModel>
	#include <Libkleo/KeyListSortFilterProxyModel>

	#include <KColorScheme>
	#include <KConfigGroup>
	#include <KGuiItem>
	#include <KLocalizedString>
	#include <KSeparator>
	#include <KSharedConfig>
	#include <KStandardGuiItem>

	#include <QApplication>
	+#include <QComboBox>
	#include <QDialogButtonBox>
	#include <QGroupBox>
	#include <QHBoxLayout>
	#include <QItemSelectionModel>
	#include <QLabel>
	#include <QLineEdit>
	#include <QPalette>
	#include <QPushButton>
	#include <QTreeView>
	#include <QVBoxLayout>

	#include "kleopatra_debug.h"

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::Dialogs;
	using namespace GpgME;

	Q_DECLARE_METATYPE(GpgME::Key)

	namespace
	{
	auto createOpenPGPOnlyKeyFilter()
	{
	auto filter = std::make_shared<DefaultKeyFilter>();
	filter->setIsOpenPGP(DefaultKeyFilter::Set);
	return filter;
	}
	}

	-class WarnNonEncryptionKeysProxyModel : public Kleo::AbstractKeyListSortFilterProxyModel
	+namespace
	+{
	+
	+class FiltersProxyModel : public QSortFilterProxyModel
	{
	Q_OBJECT
	+
	public:
	- using Kleo::AbstractKeyListSortFilterProxyModel::AbstractKeyListSortFilterProxyModel;
	- ~WarnNonEncryptionKeysProxyModel() override;
	- WarnNonEncryptionKeysProxyModel *clone() const override
	- {
	- return new WarnNonEncryptionKeysProxyModel(this->parent());
	- }
	+ using QSortFilterProxyModel::QSortFilterProxyModel;

	- QVariant data(const QModelIndex &index, int role) const override
	+protected:
	+ bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override
	{
	- const auto sourceIndex = sourceModel()->index(index.row(), index.column());
	- if (!Kleo::keyHasEncrypt(sourceIndex.data(KeyList::KeyRole).value<Key>())) {
	- if (role == Qt::DecorationRole && index.column() == 0) {
	- return QIcon::fromTheme(QStringLiteral("data-warning"));
	- }
	- if (role == Qt::ToolTipRole) {
	- return i18nc("@info:tooltip", "This certificate cannot be used for encryption.");
	- }
	- }
	- return sourceIndex.data(role);
	+ const QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
	+ const auto matchContexts = qvariant_cast<KeyFilter::MatchContexts>(sourceModel()->data(index, KeyFilterManager::FilterMatchContextsRole));
	+ return matchContexts & KeyFilter::Filtering;
	}
	};

	-WarnNonEncryptionKeysProxyModel::~WarnNonEncryptionKeysProxyModel() = default;
	+}

	-class DisableNonEncryptionKeysProxyModel : public Kleo::AbstractKeyListSortFilterProxyModel
	+class WarnNonEncryptionKeysProxyModel : public Kleo::AbstractKeyListSortFilterProxyModel
	{
	Q_OBJECT
	public:
	- using Kleo::AbstractKeyListSortFilterProxyModel::AbstractKeyListSortFilterProxyModel;
	- ~DisableNonEncryptionKeysProxyModel() override;
	- DisableNonEncryptionKeysProxyModel *clone() const override
	+ enum Mode {
	+ Warn,
	+ Disable,
	+ };
	+
	+ WarnNonEncryptionKeysProxyModel(Mode mode, QObject *parent = nullptr)
	+ : AbstractKeyListSortFilterProxyModel(parent)
	+ , m_mode(mode)
	{
	- return new DisableNonEncryptionKeysProxyModel(this->parent());
	+ }
	+
	+ WarnNonEncryptionKeysProxyModel *clone() const override
	+ {
	+ return new WarnNonEncryptionKeysProxyModel(m_mode, parent());
	}

	QVariant data(const QModelIndex &index, int role) const override
	{
	+ if (!index.isValid()) {
	+ return {};
	+ }
	const auto sourceIndex = sourceModel()->index(index.row(), index.column());
	- if (!Kleo::keyHasEncrypt(sourceIndex.data(KeyList::KeyRole).value<Key>())) {
	- if (role == Qt::ForegroundRole) {
	- return qApp->palette().color(QPalette::Disabled, QPalette::Text);
	+ const auto &key = sourceIndex.data(KeyList::KeyRole).value<Key>();
	+ if (!Kleo::canBeUsedForEncryption(key)) {
	+ if (role == Qt::DecorationRole && index.column() == KeyList::Columns::Validity) {
	+ return QIcon::fromTheme(QStringLiteral("data-error"));
	}
	- if (role == Qt::BackgroundRole) {
	- return KColorScheme(QPalette::Disabled, KColorScheme::View).background(KColorScheme::NeutralBackground).color();
	+ if (role == Qt::DisplayRole && index.column() == KeyList::Columns::Validity) {
	+ return i18nc("@info as in 'this certificate is unusable'", "unusable");
	}
	if (role == Qt::ToolTipRole) {
	- return i18nc("@info:tooltip", "This certificate cannot be added to the group as it cannot be used for encryption.");
	+ return i18nc("@info:tooltip", "This certificate cannot be used for encryption.");
	+ }
	+ if (role == Qt::BackgroundRole \|\| role == Qt::ForegroundRole) {
	+ return {};
	}
	}
	return sourceIndex.data(role);
	}
	Qt::ItemFlags flags(const QModelIndex &index) const override
	{
	auto originalFlags = index.model()->QAbstractItemModel::flags(index);
	- if (Kleo::keyHasEncrypt(index.data(KeyList::KeyRole).value<Key>())) {
	+ const auto key = index.data(KeyList::KeyRole).value<Key>();
	+ if (m_mode == Warn \|\| Kleo::canBeUsedForEncryption(key)) {
	return originalFlags;
	} else {
	return (originalFlags & ~Qt::ItemIsEnabled);
	}
	return {};
	}
	-};

	-DisableNonEncryptionKeysProxyModel::~DisableNonEncryptionKeysProxyModel() = default;
	+private:
	+ Mode m_mode;
	+};

	class EditGroupDialog::Private
	{
	friend class ::Kleo::Dialogs::EditGroupDialog;
	EditGroupDialog *const q;

	struct {
	QLineEdit *groupNameEdit = nullptr;
	QLineEdit *availableKeysFilter = nullptr;
	KeyTreeView *availableKeysList = nullptr;
	QLineEdit *groupKeysFilter = nullptr;
	KeyTreeView *groupKeysList = nullptr;
	QDialogButtonBox *buttonBox = nullptr;
	+ QComboBox *combo = nullptr;
	} ui;
	AbstractKeyListModel *availableKeysModel = nullptr;
	AbstractKeyListModel *groupKeysModel = nullptr;
	KeyGroup keyGroup;
	std::vector<GpgME::Key> oldKeys;
	+ FiltersProxyModel *filtersProxyModel = nullptr;

	public:
	Private(EditGroupDialog *qq)
	: q(qq)
	{
	auto mainLayout = new QVBoxLayout(q);

	{
	auto groupNameLayout = new QHBoxLayout();
	auto label = new QLabel(i18nc("Name of a group of keys", "Name:"), q);
	groupNameLayout->addWidget(label);
	ui.groupNameEdit = new QLineEdit(q);
	label->setBuddy(ui.groupNameEdit);
	groupNameLayout->addWidget(ui.groupNameEdit);
	mainLayout->addLayout(groupNameLayout);
	}

	mainLayout->addWidget(new KSeparator(Qt::Horizontal, q));

	auto centerLayout = new QVBoxLayout;

	auto availableKeysGroupBox = new QGroupBox{i18nc("@title", "Available Keys"), q};
	availableKeysGroupBox->setFlat(true);
	auto availableKeysLayout = new QVBoxLayout{availableKeysGroupBox};

	{
	auto hbox = new QHBoxLayout;
	auto label = new QLabel{i18nc("@label", "Search:")};
	label->setAccessibleName(i18nc("@label", "Search available keys"));
	label->setToolTip(i18nc("@info:tooltip", "Search the list of available keys for keys matching the search term."));
	hbox->addWidget(label);

	ui.availableKeysFilter = new QLineEdit(q);
	ui.availableKeysFilter->setClearButtonEnabled(true);
	ui.availableKeysFilter->setAccessibleName(i18nc("@label", "Search available keys"));
	ui.availableKeysFilter->setToolTip(i18nc("@info:tooltip", "Search the list of available keys for keys matching the search term."));
	ui.availableKeysFilter->setPlaceholderText(i18nc("@info::placeholder", "Enter search term"));
	ui.availableKeysFilter->setCursorPosition(0); // prevent emission of accessible text cursor event before accessible focus event
	label->setBuddy(ui.availableKeysFilter);
	hbox->addWidget(ui.availableKeysFilter, 1);

	+ ui.combo = new QComboBox;
	+ ui.combo->setAccessibleName(i18n("Filter certificates by category"));
	+ ui.combo->setToolTip(i18nc("@info:tooltip", "Show only certificates that belong to the selected category."));
	+
	+ hbox->addWidget(ui.combo);
	+
	+ filtersProxyModel = new FiltersProxyModel{q};
	+ auto keyFilterModel = new KeyFilterModel{q};
	+
	+ std::shared_ptr<DefaultKeyFilter> filter;
	+ filter = std::make_shared<DefaultKeyFilter>();
	+ filter->setCanEncrypt(DefaultKeyFilter::Set);
	+ filter->setIsBad(DefaultKeyFilter::NotSet);
	+ filter->setName(i18n("Usable for Encryption"));
	+ filter->setDescription(i18n("Certificates that can be used for encryption"));
	+ filter->setId(QStringLiteral("CanEncryptFilter"));
	+ filter->setMatchContexts(KeyFilter::Filtering);
	+ keyFilterModel->prependCustomFilter(filter);
	+
	+ filtersProxyModel->setSourceModel(keyFilterModel);
	+ filtersProxyModel->sort(0, Qt::AscendingOrder);
	+ ui.combo->setModel(filtersProxyModel);
	+
	+ connect(ui.combo, &QComboBox::currentIndexChanged, q, [this](int index) {
	+ const auto filter =
	+ filtersProxyModel->data(filtersProxyModel->index(index, 0), KeyFilterManager::FilterRole).value<std::shared_ptr<KeyFilter>>();
	+ ui.availableKeysList->setKeyFilter(filter);
	+ });
	+
	availableKeysLayout->addLayout(hbox);
	}

	availableKeysModel = AbstractKeyListModel::createFlatKeyListModel(q);
	availableKeysModel->setKeys(KeyCache::instance()->keys());
	- auto proxyModel = new DisableNonEncryptionKeysProxyModel(q);
	+ auto proxyModel = new WarnNonEncryptionKeysProxyModel(WarnNonEncryptionKeysProxyModel::Disable, q);
	proxyModel->setSourceModel(availableKeysModel);
	ui.availableKeysList = new KeyTreeView({}, nullptr, proxyModel, q, {});
	ui.availableKeysList->view()->setAccessibleName(i18n("available keys"));
	ui.availableKeysList->view()->setRootIsDecorated(false);
	ui.availableKeysList->setFlatModel(availableKeysModel);
	ui.availableKeysList->setHierarchicalView(false);
	if (!Settings{}.cmsEnabled()) {
	ui.availableKeysList->setKeyFilter(createOpenPGPOnlyKeyFilter());
	}
	availableKeysLayout->addWidget(ui.availableKeysList, /stretch=/1);

	centerLayout->addWidget(availableKeysGroupBox, /stretch=/1);

	auto buttonsLayout = new QHBoxLayout;
	buttonsLayout->addStretch(1);

	auto addButton = new QPushButton(q);
	addButton->setIcon(QIcon::fromTheme(QStringLiteral("arrow-down")));
	addButton->setAccessibleName(i18nc("@action:button", "Add Selected Keys"));
	addButton->setToolTip(i18nc("@info:tooltip", "Add the selected keys to the group"));
	addButton->setEnabled(false);
	buttonsLayout->addWidget(addButton);

	auto removeButton = new QPushButton(q);
	removeButton->setIcon(QIcon::fromTheme(QStringLiteral("arrow-up")));
	removeButton->setAccessibleName(i18nc("@action:button", "Remove Selected Keys"));
	removeButton->setToolTip(i18nc("@info:tooltip", "Remove the selected keys from the group"));
	removeButton->setEnabled(false);
	buttonsLayout->addWidget(removeButton);

	buttonsLayout->addStretch(1);

	centerLayout->addLayout(buttonsLayout);

	auto groupKeysGroupBox = new QGroupBox{i18nc("@title", "Group Keys"), q};
	groupKeysGroupBox->setFlat(true);
	auto groupKeysLayout = new QVBoxLayout{groupKeysGroupBox};

	{
	auto hbox = new QHBoxLayout;
	auto label = new QLabel{i18nc("@label", "Search:")};
	label->setAccessibleName(i18nc("@label", "Search group keys"));
	label->setToolTip(i18nc("@info:tooltip", "Search the list of group keys for keys matching the search term."));
	hbox->addWidget(label);

	ui.groupKeysFilter = new QLineEdit(q);
	ui.groupKeysFilter->setClearButtonEnabled(true);
	ui.groupKeysFilter->setAccessibleName(i18nc("@label", "Search group keys"));
	ui.groupKeysFilter->setToolTip(i18nc("@info:tooltip", "Search the list of group keys for keys matching the search term."));
	ui.groupKeysFilter->setPlaceholderText(i18nc("@info::placeholder", "Enter search term"));
	ui.groupKeysFilter->setCursorPosition(0); // prevent emission of accessible text cursor event before accessible focus event
	label->setBuddy(ui.groupKeysFilter);
	hbox->addWidget(ui.groupKeysFilter, 1);

	groupKeysLayout->addLayout(hbox);
	}

	groupKeysModel = AbstractKeyListModel::createFlatKeyListModel(q);

	- auto warnNonEncryptionProxyModel = new WarnNonEncryptionKeysProxyModel(q);
	+ auto warnNonEncryptionProxyModel = new WarnNonEncryptionKeysProxyModel(WarnNonEncryptionKeysProxyModel::Warn, q);
	ui.groupKeysList = new KeyTreeView({}, nullptr, warnNonEncryptionProxyModel, q, {});
	ui.groupKeysList->view()->setAccessibleName(i18n("group keys"));
	ui.groupKeysList->view()->setRootIsDecorated(false);
	ui.groupKeysList->setFlatModel(groupKeysModel);
	ui.groupKeysList->setHierarchicalView(false);
	groupKeysLayout->addWidget(ui.groupKeysList, /stretch=/1);

	centerLayout->addWidget(groupKeysGroupBox, /stretch=/1);

	mainLayout->addLayout(centerLayout);

	mainLayout->addWidget(new KSeparator(Qt::Horizontal, q));

	ui.buttonBox = new QDialogButtonBox(QDialogButtonBox::Save \| QDialogButtonBox::Cancel, q);
	QPushButton *saveButton = ui.buttonBox->button(QDialogButtonBox::Save);
	KGuiItem::assign(saveButton, KStandardGuiItem::save());
	KGuiItem::assign(ui.buttonBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
	saveButton->setEnabled(false);
	mainLayout->addWidget(ui.buttonBox);

	// prevent accidental closing of dialog when pressing Enter while a search field has focus
	Kleo::unsetAutoDefaultButtons(q);

	connect(ui.groupNameEdit, &QLineEdit::textChanged, q, [saveButton](const QString &text) {
	saveButton->setEnabled(!text.trimmed().isEmpty());
	});
	connect(ui.availableKeysFilter, &QLineEdit::textChanged, ui.availableKeysList, &KeyTreeView::setStringFilter);
	connect(ui.availableKeysList->view()->selectionModel(),
	&QItemSelectionModel::selectionChanged,
	q,
	- [addButton](const QItemSelection &selected, const QItemSelection &) {
	- addButton->setEnabled(!selected.isEmpty());
	+ [addButton, this](const QItemSelection &, const QItemSelection &) {
	+ addButton->setEnabled(ui.availableKeysList->selectedKeys().size() > 0);
	});
	connect(ui.availableKeysList->view(), &QAbstractItemView::doubleClicked, q, [this](const QModelIndex &index) {
	showKeyDetails(index);
	});
	connect(ui.groupKeysFilter, &QLineEdit::textChanged, ui.groupKeysList, &KeyTreeView::setStringFilter);
	connect(ui.groupKeysList->view()->selectionModel(),
	&QItemSelectionModel::selectionChanged,
	q,
	[removeButton](const QItemSelection &selected, const QItemSelection &) {
	removeButton->setEnabled(!selected.isEmpty());
	});
	connect(ui.groupKeysList->view(), &QAbstractItemView::doubleClicked, q, [this](const QModelIndex &index) {
	showKeyDetails(index);
	});
	connect(addButton, &QPushButton::clicked, q, [this]() {
	addKeysToGroup();
	});
	connect(removeButton, &QPushButton::clicked, q, [this]() {
	removeKeysFromGroup();
	});
	connect(ui.buttonBox, &QDialogButtonBox::accepted, q, &EditGroupDialog::accept);
	connect(ui.buttonBox, &QDialogButtonBox::rejected, q, &EditGroupDialog::reject);

	connect(KeyCache::instance().get(), &KeyCache::keysMayHaveChanged, q, [this] {
	updateFromKeyCache();
	});

	// calculate default size with enough space for the key list
	const auto fm = q->fontMetrics();
	const QSize sizeHint = q->sizeHint();
	const QSize defaultSize = QSize(qMax(sizeHint.width(), 150 * fm.horizontalAdvance(QLatin1Char('x'))), sizeHint.height());
	restoreLayout(defaultSize);
	+
	+ for (auto i = 0; i < filtersProxyModel->rowCount(); ++i) {
	+ if (filtersProxyModel->index(i, 0).data(KeyFilterManager::FilterIdRole).toString() == QStringLiteral("CanEncryptFilter")) {
	+ ui.combo->setCurrentIndex(i);
	+ break;
	+ };
	+ }
	}

	~Private()
	{
	saveLayout();
	}

	private:
	void saveLayout()
	{
	KConfigGroup configGroup(KSharedConfig::openConfig(), QStringLiteral("EditGroupDialog"));
	configGroup.writeEntry("Size", q->size());

	configGroup.sync();
	}

	void restoreLayout(const QSize &defaultSize)
	{
	const KConfigGroup configGroup(KSharedConfig::openConfig(), QStringLiteral("EditGroupDialog"));

	const KConfigGroup availableKeysConfig = configGroup.group(QStringLiteral("AvailableKeysView"));
	ui.availableKeysList->restoreLayout(availableKeysConfig);

	const KConfigGroup groupKeysConfig = configGroup.group(QStringLiteral("GroupKeysView"));
	ui.groupKeysList->restoreLayout(groupKeysConfig);

	const QSize size = configGroup.readEntry("Size", defaultSize);
	if (size.isValid()) {
	q->resize(size);
	}
	}

	void showKeyDetails(const QModelIndex &index)
	{
	if (!index.isValid()) {
	return;
	}
	const auto key = index.model()->data(index, KeyList::KeyRole).value<GpgME::Key>();
	if (!key.isNull()) {
	auto cmd = new DetailsCommand(key);
	cmd->setParentWidget(q);
	cmd->start();
	}
	}

	void addKeysToGroup();
	void removeKeysFromGroup();
	void updateFromKeyCache();
	};

	void EditGroupDialog::Private::addKeysToGroup()
	{
	const std::vector<Key> selectedGroupKeys = ui.groupKeysList->selectedKeys();

	- const std::vector<Key> selectedKeys = ui.availableKeysList->selectedKeys();
	+ std::vector<Key> selectedKeys = ui.availableKeysList->selectedKeys();
	+
	+ // NOTE: This seems to be only necessary on Qt5. I've added it here for ease
	+ // of backporting. We can remove it after backporting.
	+ Kleo::erase_if(selectedKeys, [](const auto &key) {
	+ return !Kleo::canBeUsedForEncryption(key);
	+ });
	+
	groupKeysModel->addKeys(selectedKeys);
	for (const Key &key : selectedKeys) {
	availableKeysModel->removeKey(key);
	}

	ui.groupKeysList->selectKeys(selectedGroupKeys);
	}

	void EditGroupDialog::Private::removeKeysFromGroup()
	{
	const auto selectedOtherKeys = ui.availableKeysList->selectedKeys();

	const std::vector<Key> selectedKeys = ui.groupKeysList->selectedKeys();
	for (const Key &key : selectedKeys) {
	groupKeysModel->removeKey(key);
	}
	availableKeysModel->addKeys(selectedKeys);

	ui.availableKeysList->selectKeys(selectedOtherKeys);
	}

	void EditGroupDialog::Private::updateFromKeyCache()
	{
	const auto selectedGroupKeys = ui.groupKeysList->selectedKeys();
	const auto selectedOtherKeys = ui.availableKeysList->selectedKeys();

	const auto wasGroupKey = [this](const Key &key) {
	return std::ranges::any_of(oldKeys, [key](const auto &k) {
	return _detail::ByFingerprint<std::equal_to>()(k, key);
	});
	};
	const auto allKeys = KeyCache::instance()->keys();
	std::vector<Key> groupKeys;
	groupKeys.reserve(allKeys.size());
	std::vector<Key> otherKeys;
	otherKeys.reserve(otherKeys.size());
	std::partition_copy(allKeys.begin(), allKeys.end(), std::back_inserter(groupKeys), std::back_inserter(otherKeys), wasGroupKey);
	groupKeysModel->setKeys(groupKeys);
	availableKeysModel->setKeys(otherKeys);

	ui.groupKeysList->selectKeys(selectedGroupKeys);
	ui.availableKeysList->selectKeys(selectedOtherKeys);
	}

	EditGroupDialog::EditGroupDialog(QWidget *parent)
	: QDialog(parent)
	, d(new Private(this))
	{
	setWindowTitle(i18nc("@title:window", "Edit Group"));
	}

	EditGroupDialog::~EditGroupDialog() = default;

	void EditGroupDialog::setInitialFocus(FocusWidget widget)
	{
	switch (widget) {
	case GroupName:
	d->ui.groupNameEdit->setFocus();
	break;
	case KeysFilter:
	d->ui.availableKeysFilter->setFocus();
	break;
	default:
	qCDebug(KLEOPATRA_LOG) << "EditGroupDialog::setInitialFocus - invalid focus widget:" << widget;
	}
	}

	void EditGroupDialog::showEvent(QShowEvent *event)
	{
	QDialog::showEvent(event);

	// prevent accidental closing of dialog when pressing Enter while a search field has focus
	Kleo::unsetDefaultButtons(d->ui.buttonBox);
	}

	KeyGroup EditGroupDialog::keyGroup() const
	{
	std::vector<Key> keys;
	keys.reserve(d->groupKeysModel->rowCount());
	for (int row = 0; row < d->groupKeysModel->rowCount(); ++row) {
	const QModelIndex index = d->groupKeysModel->index(row, 0);
	keys.push_back(d->groupKeysModel->key(index));
	}
	d->keyGroup.setKeys(keys);

	d->keyGroup.setName(d->ui.groupNameEdit->text().trimmed());
	return d->keyGroup;
	}

	void EditGroupDialog::setKeyGroup(const KeyGroup &keyGroup)
	{
	d->keyGroup = keyGroup;

	const auto &keys = keyGroup.keys();
	d->oldKeys = std::vector<GpgME::Key>(keys.begin(), keys.end());
	d->groupKeysModel->setKeys(d->oldKeys);

	// update the keys in the "available keys" list
	const auto isGroupKey = [keys](const Key &key) {
	return std::ranges::any_of(keys, [key](const auto &k) {
	return _detail::ByFingerprint<std::equal_to>()(k, key);
	});
	};
	auto otherKeys = KeyCache::instance()->keys();
	Kleo::erase_if(otherKeys, isGroupKey);
	d->availableKeysModel->setKeys(otherKeys);

	d->ui.groupNameEdit->setText(keyGroup.name());
	}

	#include "editgroupdialog.moc"
	#include "moc_editgroupdialog.cpp"

File Metadata

Mime Type: text/x-diff
Expires: Fri, Dec 5, 5:29 AM (1 d, 7 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: e3/23/47c50ad40e88267f5d15841e65f9

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions