No OneTemporary
Actions

Size

40 KB

Subscribers

None

View Options

	diff --git a/src/conf/CMakeLists.txt b/src/conf/CMakeLists.txt
	index 48effb57c..1e969c484 100644
	--- a/src/conf/CMakeLists.txt
	+++ b/src/conf/CMakeLists.txt
	@@ -1,76 +1,75 @@
	include_directories(${kleopatra_SOURCE_DIR}/src)


	set(_kcm_kleopatra_libkleopatraclient_extra_SRCS
	smimevalidationconfigurationwidget.cpp
	smimevalidationconfigurationpage.cpp
	cryptooperationsconfigwidget.cpp
	cryptooperationsconfigpage.cpp
	smimevalidationconfigurationwidget.h
	smimevalidationconfigurationpage.h
	cryptooperationsconfigwidget.h
	cryptooperationsconfigpage.h
	smartcardconfigpage.cpp
	smartcardconfigpage.h
	)

	ki18n_wrap_ui(_kcm_kleopatra_libkleopatraclient_extra_SRCS
	smimevalidationconfigurationwidget.ui
	)

	kconfig_add_kcfg_files(_kcm_kleopatra_libkleopatraclient_extra_SRCS
	${kleopatra_SOURCE_DIR}/src/kcfg/smimevalidationpreferences.kcfgc
	)

	set(_kcm_kleopatra_libkleopatraclient_extra_LIBS kleopatraclientgui)


	set(kcm_kleopatra_PART_SRCS
	dirservconfigpage.cpp
	appearanceconfigpage.cpp
	appearanceconfigwidget.cpp
	gnupgsystemconfigurationpage.cpp
	dirservconfigpage.h
	appearanceconfigpage.h
	appearanceconfigwidget.h
	gnupgsystemconfigurationpage.h
	labelledwidget.cpp labelledwidget.h
	labelledwidget.cpp labelledwidget.h
	${kleopatra_BINARY_DIR}/src/kleopatra_debug.cpp
	${_kcm_kleopatra_libkleopatraclient_extra_SRCS}
	)


	ki18n_wrap_ui(kcm_kleopatra_PART_SRCS
	- appearanceconfigwidget.ui
	smimevalidationconfigurationwidget.ui
	)

	kconfig_add_kcfg_files(kcm_kleopatra_PART_SRCS
	${kleopatra_SOURCE_DIR}/src/kcfg/tooltippreferences.kcfgc
	${kleopatra_SOURCE_DIR}/src/kcfg/emailoperationspreferences.kcfgc
	${kleopatra_SOURCE_DIR}/src/kcfg/fileoperationspreferences.kcfgc
	${kleopatra_SOURCE_DIR}/src/kcfg/tagspreferences.kcfgc
	${kleopatra_SOURCE_DIR}/src/kcfg/settings.kcfgc
	)

	add_library(kcm_kleopatra_static STATIC ${kcm_kleopatra_PART_SRCS})
	set_property(TARGET kcm_kleopatra_static PROPERTY POSITION_INDEPENDENT_CODE ON)

	target_link_libraries(kcm_kleopatra_static
	KPim${KF_MAJOR_VERSION}::Libkleo
	KF${KF_MAJOR_VERSION}::I18n
	KF${KF_MAJOR_VERSION}::IconThemes
	KF${KF_MAJOR_VERSION}::KCMUtils
	KF${KF_MAJOR_VERSION}::WidgetsAddons
	${_kcm_kleopatra_extra_libs}
	${_kleopatra_dbusaddons_libs}
	${_kcm_kleopatra_libkleopatraclient_extra_LIBS}
	)

	if (NOT WIN32)
	add_library(kleopatra_config_gnupgsystem MODULE kcm_gnupgsystemconfigurationpage.cpp)
	target_link_libraries(kleopatra_config_gnupgsystem kcm_kleopatra_static KF${KF_MAJOR_VERSION}::CoreAddons)

	install(TARGETS kleopatra_config_gnupgsystem DESTINATION ${KDE_INSTALL_PLUGINDIR}/pim${QT_MAJOR_VERSION}/kcms/kleopatra)
	endif()
	diff --git a/src/conf/appearanceconfigwidget.cpp b/src/conf/appearanceconfigwidget.cpp
	index 9bf2ff9f6..851f4cbbc 100644
	--- a/src/conf/appearanceconfigwidget.cpp
	+++ b/src/conf/appearanceconfigwidget.cpp
	@@ -1,706 +1,886 @@
	/*
	appearanceconfigwidget.cpp

	This file is part of kleopatra, the KDE key manager
	SPDX-FileCopyrightText: 2002, 2004, 2008 Klarälvdalens Datakonsult AB
	SPDX-FileCopyrightText: 2002, 2003 Marc Mutz <mutz@kde.org>

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

	#include <config-kleopatra.h>

	#include "appearanceconfigwidget.h"
	-#include "ui_appearanceconfigwidget.h"

	#include "tagspreferences.h"
	#include "tooltippreferences.h"

	#include <settings.h>

	#include <Libkleo/KeyFilterManager>
	#include <Libkleo/Dn>
	#include <Libkleo/DNAttributeOrderConfigWidget>
	#include <Libkleo/SystemInfo>

	-#include <KIconDialog>
	-#include <QIcon>
	-
	#include <KConfig>
	-#include <KLocalizedString>
	#include <KConfigGroup>
	+#include <KIconDialog>
	+#include <KLocalizedString>
	+#include <KMessageWidget>

	-#include <QColor>
	-#include <QFont>
	-#include <QString>
	-#include <QRegularExpression>
	#include <QApplication>
	+#include <QCheckBox>
	+#include <QColor>
	#include <QColorDialog>
	+#include <QFont>
	#include <QFontDialog>
	+#include <QGridLayout>
	+#include <QIcon>
	+#include <QLabel>
	+#include <QListWidget>
	+#include <QRegularExpression>
	+#include <QString>
	+#include <QVBoxLayout>

	#include <algorithm>

	using namespace Kleo;
	using namespace Kleo::Config;

	enum {
	HasNameRole = Qt::UserRole + 0x1234, /!< Records that the user has assigned a name (to avoid comparing with i18n-strings) /
	HasFontRole, /!< Records that the user has chosen completely different font (as opposed to italic/bold/strikeout) /
	IconNameRole, /!< Records the name of the icon (since QIcon won't give it out again, once set) /
	MayChangeNameRole,
	MayChangeForegroundRole,
	MayChangeBackgroundRole,
	MayChangeFontRole,
	MayChangeItalicRole,
	MayChangeBoldRole,
	MayChangeStrikeOutRole,
	MayChangeIconRole,
	StoredForegroundRole, /!< Stores the actual configured foreground color /
	StoredBackgroundRole, /!< Stores the actual configured background color /

	EndDummy,
	};

	static QFont tryToFindFontFor(const QListWidgetItem *item)
	{
	if (item)
	if (const QListWidget *const lw = item->listWidget()) {
	return lw->font();
	}
	return QApplication::font("QListWidget");
	}

	static bool is(const QListWidgetItem item, bool (QFont::func)() const)
	{
	if (!item) {
	return false;
	}
	const QVariant v = item->data(Qt::FontRole);
	#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
	if (!v.isValid() \|\| v.type() != QVariant::Font) {
	#else
	if (!v.isValid() \|\| v.userType() != QMetaType::QFont) {
	#endif
	return false;
	}
	return (v.value<QFont>().*func)();
	}

	static bool is_italic(const QListWidgetItem *item)
	{
	return is(item, &QFont::italic);
	}
	static bool is_bold(const QListWidgetItem *item)
	{
	return is(item, &QFont::bold);
	}
	static bool is_strikeout(const QListWidgetItem *item)
	{
	return is(item, &QFont::strikeOut);
	}

	static void set(QListWidgetItem item, bool on, void (QFont::func)(bool))
	{
	if (!item) {
	return;
	}
	const QVariant v = item->data(Qt::FontRole);
	#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
	QFont font = v.isValid() && v.type() == QVariant::Font ? v.value<QFont>() : tryToFindFontFor(item);
	#else
	QFont font = v.isValid() && v.userType() == QMetaType::QFont ? v.value<QFont>() : tryToFindFontFor(item);
	#endif
	(font.*func)(on);
	item->setData(Qt::FontRole, font);
	}

	static void set_italic(QListWidgetItem *item, bool on)
	{
	set(item, on, &QFont::setItalic);
	}
	static void set_bold(QListWidgetItem *item, bool on)
	{
	set(item, on, &QFont::setBold);
	}
	static void set_strikeout(QListWidgetItem *item, bool on)
	{
	set(item, on, &QFont::setStrikeOut);
	}

	static void apply_config(const KConfigGroup &group, QListWidgetItem *item)
	{
	if (!item) {
	return;
	}

	const QString name = group.readEntry("Name");
	item->setText(name.isEmpty() ? i18nc("Key filter without user-assigned name", "<unnamed>") : name);
	item->setData(HasNameRole, !name.isEmpty());
	item->setData(MayChangeNameRole, !group.isEntryImmutable("Name"));

	const QColor fg = group.readEntry("foreground-color", QColor());
	item->setData(StoredForegroundRole, fg.isValid() ? QBrush(fg) : QVariant());
	if (!SystemInfo::isHighContrastModeActive()) {
	item->setData(Qt::ForegroundRole, fg.isValid() ? QBrush(fg) : QVariant());
	}
	item->setData(MayChangeForegroundRole, !group.isEntryImmutable("foreground-color"));

	const QColor bg = group.readEntry("background-color", QColor());
	item->setData(StoredBackgroundRole, bg.isValid() ? QBrush(bg) : QVariant());
	if (!SystemInfo::isHighContrastModeActive()) {
	item->setData(Qt::BackgroundRole, bg.isValid() ? QBrush(bg) : QVariant());
	}
	item->setData(MayChangeBackgroundRole, !group.isEntryImmutable("background-color"));

	const QFont defaultFont = tryToFindFontFor(item);
	if (group.hasKey("font")) {
	const QFont font = group.readEntry("font", defaultFont);
	item->setData(Qt::FontRole, font != defaultFont ? font : QVariant());
	item->setData(HasFontRole, font != defaultFont);
	} else {
	QFont font = defaultFont;
	font.setStrikeOut(group.readEntry("font-strikeout", false));
	font.setItalic(group.readEntry("font-italic", false));
	font.setBold(group.readEntry("font-bold", false));
	item->setData(Qt::FontRole, font);
	item->setData(HasFontRole, false);
	}
	item->setData(MayChangeFontRole, !group.isEntryImmutable("font"));
	item->setData(MayChangeItalicRole, !group.isEntryImmutable("font-italic"));
	item->setData(MayChangeBoldRole, !group.isEntryImmutable("font-bold"));
	item->setData(MayChangeStrikeOutRole, !group.isEntryImmutable("font-strikeout"));

	const QString iconName = group.readEntry("icon");
	item->setData(Qt::DecorationRole, iconName.isEmpty() ? QVariant() : QIcon::fromTheme(iconName));
	item->setData(IconNameRole, iconName.isEmpty() ? QVariant() : iconName);
	item->setData(MayChangeIconRole, !group.isEntryImmutable("icon"));
	}

	static void erase_if_allowed(QListWidgetItem *item, int role, int allowRole)
	{
	if (item && item->data(allowRole).toBool()) {
	item->setData(role, QVariant());
	}
	}

	#if 0
	static void erase_if_allowed(QListWidgetItem *item, const int role[], size_t numRoles, int allowRole)
	{
	if (item && item->data(allowRole).toBool())
	for (unsigned int i = 0; i < numRoles; ++i) {
	item->setData(role[i], QVariant());
	}
	}

	static void erase_if_allowed(QListWidgetItem *item, int role, const int allowRole[], size_t numAllowRoles)
	{
	if (!item) {
	return;
	}
	for (unsigned int i = 0; i < numAllowRoles; ++i)
	if (!item->data(allowRole[i]).toBool()) {
	return;
	}
	item->setData(role, QVariant());
	}
	#endif

	static void erase_if_allowed(QListWidgetItem *item, const int role[], size_t numRoles, const int allowRole[], size_t numAllowRoles)
	{
	if (!item) {
	return;
	}
	for (unsigned int i = 0; i < numAllowRoles; ++i)
	if (!item->data(allowRole[i]).toBool()) {
	return;
	}
	for (unsigned int i = 0; i < numRoles; ++i) {
	item->setData(role[i], QVariant());
	}
	}

	static void set_default_appearance(QListWidgetItem *item)
	{
	if (!item) {
	return;
	}
	erase_if_allowed(item, StoredForegroundRole, MayChangeForegroundRole);
	erase_if_allowed(item, Qt::ForegroundRole, MayChangeForegroundRole);
	erase_if_allowed(item, StoredBackgroundRole, MayChangeBackgroundRole);
	erase_if_allowed(item, Qt::BackgroundRole, MayChangeBackgroundRole);
	erase_if_allowed(item, Qt::DecorationRole, MayChangeIconRole);
	static const int fontRoles[] = { Qt::FontRole, HasFontRole };
	static const int fontAllowRoles[] = {
	MayChangeFontRole,
	MayChangeItalicRole,
	MayChangeBoldRole,
	MayChangeStrikeOutRole,
	};
	erase_if_allowed(item, fontRoles, sizeof(fontRoles) / sizeof(int), fontAllowRoles, sizeof(fontAllowRoles) / sizeof(int));
	}

	static void writeOrDelete(KConfigGroup &group, const char *key, const QVariant &value)
	{
	if (value.isValid()) {
	group.writeEntry(key, value);
	} else {
	group.deleteEntry(key);
	}
	}

	static QVariant brush2color(const QVariant &v)
	{
	if (v.isValid()) {
	#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
	if (v.type() == QVariant::Color) {
	#else
	if (v.userType() == QMetaType::QColor) {
	#endif
	return v;
	#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
	} else if (v.type() == QVariant::Brush) {
	#else
	} else if (v.userType() == QMetaType::QBrush) {
	#endif
	return v.value<QBrush>().color();
	}
	}
	return QVariant();
	}

	static void save_to_config(const QListWidgetItem *item, KConfigGroup &group)
	{
	if (!item) {
	return;
	}
	writeOrDelete(group, "Name", item->data(HasNameRole).toBool() ? item->text() : QVariant());
	writeOrDelete(group, "foreground-color", brush2color(item->data(StoredForegroundRole)));
	writeOrDelete(group, "background-color", brush2color(item->data(StoredBackgroundRole)));
	writeOrDelete(group, "icon", item->data(IconNameRole));

	group.deleteEntry("font");
	group.deleteEntry("font-strikeout");
	group.deleteEntry("font-italic");
	group.deleteEntry("font-bold");

	if (item->data(HasFontRole).toBool()) {
	writeOrDelete(group, "font", item->data(Qt::FontRole));
	return;
	}

	if (is_strikeout(item)) {
	group.writeEntry("font-strikeout", true);
	}
	if (is_italic(item)) {
	group.writeEntry("font-italic", true);
	}
	if (is_bold(item)) {
	group.writeEntry("font-bold", true);
	}
	}

	static void kiosk_enable(QWidget w, const QListWidgetItem item, int allowRole)
	{
	if (!w) {
	return;
	}
	if (item && !item->data(allowRole).toBool()) {
	w->setEnabled(false);
	w->setToolTip(i18n("This parameter has been locked down by the system administrator."));
	} else {
	w->setEnabled(item);
	w->setToolTip(QString());
	}
	}

	+class Ui_AppearanceConfigWidget
	+{
	+public:
	+ QVBoxLayout *verticalLayout_2;
	+ QTabWidget *tabWidget;
	+ QWidget *tab_2;
	+ QGridLayout *gridLayout;
	+ KMessageWidget *highContrastMsg;
	+ QListWidget *categoriesLV;
	+ QVBoxLayout *vboxLayout;
	+ QPushButton *iconButton;
	+ QPushButton *foregroundButton;
	+ QPushButton *backgroundButton;
	+ QPushButton *fontButton;
	+ QCheckBox *italicCB;
	+ QCheckBox *boldCB;
	+ QCheckBox *strikeoutCB;
	+ QSpacerItem *spacerItem;
	+ QPushButton *defaultLookPB;
	+ QWidget *tab;
	+ QVBoxLayout *verticalLayout;
	+ QLabel *label;
	+ QCheckBox *tooltipValidityCheckBox;
	+ QCheckBox *tooltipOwnerCheckBox;
	+ QCheckBox *tooltipDetailsCheckBox;
	+ QSpacerItem *spacerItem1;
	+ QWidget *tab_tags;
	+ QVBoxLayout *verticalLayout_tags;
	+ QCheckBox *useTagsCheckBox;
	+ QSpacerItem *spacerItem2;
	+
	+ void setupUi(QWidget *AppearanceConfigWidget)
	+ {
	+ if (AppearanceConfigWidget->objectName().isEmpty())
	+ AppearanceConfigWidget->setObjectName(QString::fromUtf8("AppearanceConfigWidget"));
	+ verticalLayout_2 = new QVBoxLayout(AppearanceConfigWidget);
	+ verticalLayout_2->setObjectName(QString::fromUtf8("verticalLayout_2"));
	+ tabWidget = new QTabWidget(AppearanceConfigWidget);
	+ tabWidget->setObjectName(QString::fromUtf8("tabWidget"));
	+ tab_2 = new QWidget();
	+ tab_2->setObjectName(QString::fromUtf8("tab_2"));
	+ gridLayout = new QGridLayout(tab_2);
	+ gridLayout->setObjectName(QString::fromUtf8("gridLayout"));
	+ highContrastMsg = new KMessageWidget(tab_2);
	+ highContrastMsg->setObjectName(QString::fromUtf8("highContrastMsg"));
	+
	+ gridLayout->addWidget(highContrastMsg, 0, 0, 1, 2);
	+
	+ categoriesLV = new QListWidget(tab_2);
	+ categoriesLV->setObjectName(QString::fromUtf8("categoriesLV"));
	+
	+ gridLayout->addWidget(categoriesLV, 1, 0, 1, 1);
	+
	+ vboxLayout = new QVBoxLayout();
	+ vboxLayout->setObjectName(QString::fromUtf8("vboxLayout"));
	+ iconButton = new QPushButton(tab_2);
	+ iconButton->setText(i18nc("@action:button", "Set Icon..."));
	+ iconButton->setObjectName(QString::fromUtf8("iconButton"));
	+ iconButton->setEnabled(false);
	+
	+ vboxLayout->addWidget(iconButton);
	+
	+ foregroundButton = new QPushButton(tab_2);
	+ foregroundButton->setText(i18nc("@action:button", "Set Text Color..."));
	+ foregroundButton->setObjectName(QString::fromUtf8("foregroundButton"));
	+ foregroundButton->setEnabled(false);
	+
	+ vboxLayout->addWidget(foregroundButton);
	+
	+ backgroundButton = new QPushButton(tab_2);
	+ backgroundButton->setText(i18nc("@action:button", "Set Background Color..."));
	+ backgroundButton->setObjectName(QString::fromUtf8("backgroundButton"));
	+ backgroundButton->setEnabled(false);
	+
	+ vboxLayout->addWidget(backgroundButton);
	+
	+ fontButton = new QPushButton(tab_2);
	+ fontButton->setText(i18nc("@action:button", "Set Font..."));
	+ fontButton->setObjectName(QString::fromUtf8("fontButton"));
	+ fontButton->setEnabled(false);
	+
	+ vboxLayout->addWidget(fontButton);
	+
	+ italicCB = new QCheckBox(tab_2);
	+ italicCB->setText(i18nc("@option:check", "Italic"));
	+ italicCB->setObjectName(QString::fromUtf8("italicCB"));
	+ italicCB->setEnabled(false);
	+
	+ vboxLayout->addWidget(italicCB);
	+
	+ boldCB = new QCheckBox(tab_2);
	+ boldCB->setText(i18nc("@option:check", "Bold"));
	+ boldCB->setObjectName(QString::fromUtf8("boldCB"));
	+ boldCB->setEnabled(false);
	+
	+ vboxLayout->addWidget(boldCB);
	+
	+ strikeoutCB = new QCheckBox(tab_2);
	+ strikeoutCB->setText(i18nc("@option:check", "Strikeout"));
	+ strikeoutCB->setObjectName(QString::fromUtf8("strikeoutCB"));
	+ strikeoutCB->setEnabled(false);
	+
	+ vboxLayout->addWidget(strikeoutCB);
	+
	+ spacerItem = new QSpacerItem(20, 100, QSizePolicy::Minimum, QSizePolicy::Expanding);
	+
	+ vboxLayout->addItem(spacerItem);
	+
	+ defaultLookPB = new QPushButton(tab_2);
	+ defaultLookPB->setText(i18nc("@action:button", "Default Appearance"));
	+ defaultLookPB->setObjectName(QString::fromUtf8("defaultLookPB"));
	+ defaultLookPB->setEnabled(false);
	+
	+ vboxLayout->addWidget(defaultLookPB);
	+
	+
	+ gridLayout->addLayout(vboxLayout, 1, 1, 1, 1);
	+
	+ tabWidget->addTab(tab_2, QString());
	+ tabWidget->setTabText(tabWidget->indexOf(tab_2), i18nc("@title:tab", "Certificate Categories"));
	+ tab = new QWidget();
	+ tab->setObjectName(QString::fromUtf8("tab"));
	+ verticalLayout = new QVBoxLayout(tab);
	+ verticalLayout->setObjectName(QString::fromUtf8("verticalLayout"));
	+ label = new QLabel(tab);
	+ label->setText(i18nc("@action:button", "Show the following information in certificate list tooltips:"));
	+ label->setObjectName(QString::fromUtf8("label"));
	+
	+ verticalLayout->addWidget(label);
	+
	+ tooltipValidityCheckBox = new QCheckBox(tab);
	+ tooltipValidityCheckBox->setText(i18nc("@option:check", "Show validity"));
	+ tooltipValidityCheckBox->setObjectName(QString::fromUtf8("tooltipValidityCheckBox"));
	+
	+ verticalLayout->addWidget(tooltipValidityCheckBox);
	+
	+ tooltipOwnerCheckBox = new QCheckBox(tab);
	+ tooltipOwnerCheckBox->setText(i18nc("@option:check", "Show owner information"));
	+ tooltipOwnerCheckBox->setObjectName(QString::fromUtf8("tooltipOwnerCheckBox"));
	+
	+ verticalLayout->addWidget(tooltipOwnerCheckBox);
	+
	+ tooltipDetailsCheckBox = new QCheckBox(tab);
	+ tooltipDetailsCheckBox->setText(i18nc("@option:check", "Show technical details"));
	+ tooltipDetailsCheckBox->setObjectName(QString::fromUtf8("tooltipDetailsCheckBox"));
	+
	+ verticalLayout->addWidget(tooltipDetailsCheckBox);
	+
	+ spacerItem1 = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding);
	+
	+ verticalLayout->addItem(spacerItem1);
	+
	+ tabWidget->addTab(tab, QString());
	+ tabWidget->setTabText(tabWidget->indexOf(tab), i18nc("@title:tab", "Tooltips"));
	+ tab_tags = new QWidget();
	+ tab_tags->setObjectName(QString::fromUtf8("tab_tags"));
	+ verticalLayout_tags = new QVBoxLayout(tab_tags);
	+ verticalLayout_tags->setObjectName(QString::fromUtf8("verticalLayout_tags"));
	+ useTagsCheckBox = new QCheckBox(tab_tags);
	+ useTagsCheckBox->setText(i18nc("@option:check", "Use tags"));
	+ useTagsCheckBox->setToolTip(i18nc("@option:check", "Enable display and usage of tags attached to keys."));
	+ useTagsCheckBox->setObjectName(QString::fromUtf8("useTagsCheckBox"));
	+
	+ verticalLayout_tags->addWidget(useTagsCheckBox);
	+
	+ spacerItem2 = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding);
	+
	+ verticalLayout_tags->addItem(spacerItem2);
	+
	+ tabWidget->addTab(tab_tags, QString());
	+ tabWidget->setTabText(tabWidget->indexOf(tab_tags), i18nc("@title:tab", "Tags"));
	+
	+ verticalLayout_2->addWidget(tabWidget);
	+ }
	+};
	+
	class AppearanceConfigWidget::Private : public Ui_AppearanceConfigWidget
	{
	friend class ::Kleo::Config::AppearanceConfigWidget;
	AppearanceConfigWidget *const q;
	public:
	explicit Private(AppearanceConfigWidget *qq)
	: Ui_AppearanceConfigWidget()
	, q(qq)
	{
	setupUi(q);

	if (QLayout *const l = q->layout()) {
	l->setContentsMargins(0, 0, 0, 0);
	}

	highContrastMsg->setVisible(SystemInfo::isHighContrastModeActive());
	highContrastMsg->setMessageType(KMessageWidget::Warning);
	highContrastMsg->setIcon(q->style()->standardIcon(QStyle::SP_MessageBoxWarning, nullptr, q));
	highContrastMsg->setText(i18n("The preview of colors is disabled because high-contrast mode is active."));
	highContrastMsg->setCloseButtonVisible(false);

	if (Kleo::Settings{}.cmsEnabled()) {
	auto w = new QWidget;
	dnOrderWidget = new DNAttributeOrderConfigWidget{w};
	dnOrderWidget->setObjectName(QStringLiteral("dnOrderWidget"));
	(new QVBoxLayout(w))->addWidget(dnOrderWidget);

	tabWidget->addTab(w, i18n("DN-Attribute Order"));

	connect(dnOrderWidget, &DNAttributeOrderConfigWidget::changed, q, &AppearanceConfigWidget::changed);
	}

	connect(iconButton, SIGNAL(clicked()), q, SLOT(slotIconClicked()));
	#ifndef QT_NO_COLORDIALOG
	connect(foregroundButton, SIGNAL(clicked()), q, SLOT(slotForegroundClicked()));
	connect(backgroundButton, SIGNAL(clicked()), q, SLOT(slotBackgroundClicked()));
	#else
	foregroundButton->hide();
	backgroundButton->hide();
	#endif
	#ifndef QT_NO_FONTDIALOG
	connect(fontButton, SIGNAL(clicked()), q, SLOT(slotFontClicked()));
	#else
	fontButton->hide();
	#endif
	connect(categoriesLV, SIGNAL(itemSelectionChanged()), q, SLOT(slotSelectionChanged()));
	connect(defaultLookPB, SIGNAL(clicked()), q, SLOT(slotDefaultClicked()));
	connect(italicCB, SIGNAL(toggled(bool)), q, SLOT(slotItalicToggled(bool)));
	connect(boldCB, SIGNAL(toggled(bool)), q, SLOT(slotBoldToggled(bool)));
	connect(strikeoutCB, SIGNAL(toggled(bool)), q, SLOT(slotStrikeOutToggled(bool)));
	connect(tooltipValidityCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipValidityChanged(bool)));
	connect(tooltipOwnerCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipOwnerChanged(bool)));
	connect(tooltipDetailsCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipDetailsChanged(bool)));
	connect(useTagsCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotUseTagsChanged(bool)));
	}

	private:
	void enableDisableActions(QListWidgetItem *item);
	QListWidgetItem *selectedItem() const;

	private:
	void slotIconClicked();
	#ifndef QT_NO_COLORDIALOG
	void slotForegroundClicked();
	void slotBackgroundClicked();
	#endif
	#ifndef QT_NO_FONTDIALOG
	void slotFontClicked();
	#endif
	void slotSelectionChanged();
	void slotDefaultClicked();
	void slotItalicToggled(bool);
	void slotBoldToggled(bool);
	void slotStrikeOutToggled(bool);
	void slotTooltipValidityChanged(bool);
	void slotTooltipOwnerChanged(bool);
	void slotTooltipDetailsChanged(bool);
	void slotUseTagsChanged(bool);

	private:
	Kleo::DNAttributeOrderConfigWidget *dnOrderWidget = nullptr;
	};

	AppearanceConfigWidget::AppearanceConfigWidget(QWidget *p, Qt::WindowFlags f)
	: QWidget(p, f), d(new Private(this))
	{
	// load();
	}

	AppearanceConfigWidget::~AppearanceConfigWidget() {}

	void AppearanceConfigWidget::Private::slotSelectionChanged()
	{
	enableDisableActions(selectedItem());
	}

	QListWidgetItem *AppearanceConfigWidget::Private::selectedItem() const
	{
	const QList<QListWidgetItem *> items = categoriesLV->selectedItems();
	return items.empty() ? nullptr : items.front();
	}

	void AppearanceConfigWidget::Private::enableDisableActions(QListWidgetItem *item)
	{
	kiosk_enable(iconButton, item, MayChangeIconRole);
	#ifndef QT_NO_COLORDIALOG
	kiosk_enable(foregroundButton, item, MayChangeForegroundRole);
	kiosk_enable(backgroundButton, item, MayChangeBackgroundRole);
	#endif
	#ifndef QT_NO_FONTDIALOG
	kiosk_enable(fontButton, item, MayChangeFontRole);
	#endif
	kiosk_enable(italicCB, item, MayChangeItalicRole);
	kiosk_enable(boldCB, item, MayChangeBoldRole);
	kiosk_enable(strikeoutCB, item, MayChangeStrikeOutRole);

	defaultLookPB->setEnabled(item);

	italicCB->setChecked(is_italic(item));
	boldCB->setChecked(is_bold(item));
	strikeoutCB->setChecked(is_strikeout(item));
	}

	void AppearanceConfigWidget::Private::slotDefaultClicked()
	{

	QListWidgetItem *const item = selectedItem();
	if (!item) {
	return;
	}

	set_default_appearance(item);
	enableDisableActions(item);

	Q_EMIT q->changed();
	}

	void AppearanceConfigWidget::defaults()
	{
	// This simply means "default look for every category"
	for (int i = 0, end = d->categoriesLV->count(); i != end; ++i) {
	set_default_appearance(d->categoriesLV->item(i));
	}

	// use a temporary TooltipPreferences instance for resetting the values to the defaults;
	// the setters respect the immutability of the individual settings, so that we don't have
	// to check this explicitly
	TooltipPreferences tooltipPrefs;
	tooltipPrefs.setShowValidity(tooltipPrefs.findItem(QStringLiteral("ShowValidity"))->getDefault().toBool());
	d->tooltipValidityCheckBox->setChecked(tooltipPrefs.showValidity());
	tooltipPrefs.setShowOwnerInformation(tooltipPrefs.findItem(QStringLiteral("ShowOwnerInformation"))->getDefault().toBool());
	d->tooltipOwnerCheckBox->setChecked(tooltipPrefs.showOwnerInformation());
	tooltipPrefs.setShowCertificateDetails(tooltipPrefs.findItem(QStringLiteral("ShowCertificateDetails"))->getDefault().toBool());
	d->tooltipDetailsCheckBox->setChecked(tooltipPrefs.showCertificateDetails());

	if (d->dnOrderWidget) {
	const Settings settings;
	if (!settings.isImmutable(QStringLiteral("AttributeOrder"))) {
	d->dnOrderWidget->setAttributeOrder(DN::defaultAttributeOrder());
	}
	}

	Q_EMIT changed();
	}

	void AppearanceConfigWidget::load()
	{
	if (d->dnOrderWidget) {
	const Settings settings;
	d->dnOrderWidget->setAttributeOrder(DN::attributeOrder());
	d->dnOrderWidget->setEnabled(!settings.isImmutable(QStringLiteral("AttributeOrder")));
	}

	d->categoriesLV->clear();
	KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("libkleopatrarc"));
	if (!config) {
	return;
	}
	const QStringList groups = config->groupList().filter(QRegularExpression(QStringLiteral("^Key Filter #\\d+$")));
	for (const QString &group : groups) {
	const KConfigGroup configGroup{config, group};
	const bool isCmsSpecificKeyFilter = !configGroup.readEntry("is-openpgp-key", true);
	auto item = new QListWidgetItem{d->categoriesLV};
	// hide CMS-specific filters if CMS is disabled; we hide those filters
	// instead of skipping them, so that they are not removed on save
	item->setHidden(isCmsSpecificKeyFilter && !Kleo::Settings{}.cmsEnabled());
	apply_config(configGroup, item);
	}

	const TooltipPreferences prefs;
	d->tooltipValidityCheckBox->setChecked(prefs.showValidity());
	d->tooltipValidityCheckBox->setEnabled(!prefs.isImmutable(QStringLiteral("ShowValidity")));
	d->tooltipOwnerCheckBox->setChecked(prefs.showOwnerInformation());
	d->tooltipOwnerCheckBox->setEnabled(!prefs.isImmutable(QStringLiteral("ShowOwnerInformation")));
	d->tooltipDetailsCheckBox->setChecked(prefs.showCertificateDetails());
	d->tooltipDetailsCheckBox->setEnabled(!prefs.isImmutable(QStringLiteral("ShowCertificateDetails")));

	const TagsPreferences tagsPrefs;
	d->useTagsCheckBox->setChecked(tagsPrefs.useTags());
	d->useTagsCheckBox->setEnabled(!tagsPrefs.isImmutable(QStringLiteral("UseTags")));
	}

	void AppearanceConfigWidget::save()
	{
	if (d->dnOrderWidget) {
	Settings settings;
	settings.setAttributeOrder(d->dnOrderWidget->attributeOrder());
	settings.save();

	DN::setAttributeOrder(settings.attributeOrder());
	}

	TooltipPreferences prefs;
	prefs.setShowValidity(d->tooltipValidityCheckBox->isChecked());
	prefs.setShowOwnerInformation(d->tooltipOwnerCheckBox->isChecked());
	prefs.setShowCertificateDetails(d->tooltipDetailsCheckBox->isChecked());
	prefs.save();

	KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("libkleopatrarc"));
	if (!config) {
	return;
	}
	// We know (assume) that the groups in the config object haven't changed,
	// so we just iterate over them and over the listviewitems, and map one-to-one.
	const QStringList groups = config->groupList().filter(QRegularExpression(QStringLiteral("^Key Filter #\\d+$")));
	#if 0
	if (groups.isEmpty()) {
	// If we created the default categories ourselves just now, then we need to make up their list
	Q3ListViewItemIterator lvit(categoriesLV);
	for (; lvit.current(); ++lvit) {
	groups << lvit.current()->text(0);
	}
	}
	#endif
	for (int i = 0, end = std::min<int>(groups.size(), d->categoriesLV->count()); i != end; ++i) {
	const QListWidgetItem *const item = d->categoriesLV->item(i);
	Q_ASSERT(item);
	KConfigGroup group(config, groups[i]);
	save_to_config(item, group);
	}

	TagsPreferences tagsPrefs;
	tagsPrefs.setUseTags(d->useTagsCheckBox->isChecked());
	tagsPrefs.save();

	config->sync();
	KeyFilterManager::instance()->reload();
	}

	void AppearanceConfigWidget::Private::slotIconClicked()
	{
	QListWidgetItem *const item = selectedItem();
	if (!item) {
	return;
	}

	const QString iconName = KIconDialog::getIcon( /* repeating default arguments begin */
	KIconLoader::Desktop, KIconLoader::Application, false, 0, false,
	/* repeating default arguments end */
	q);
	if (iconName.isEmpty()) {
	return;
	}

	item->setIcon(QIcon::fromTheme(iconName));
	item->setData(IconNameRole, iconName);
	Q_EMIT q->changed();
	}

	#ifndef QT_NO_COLORDIALOG
	void AppearanceConfigWidget::Private::slotForegroundClicked()
	{
	QListWidgetItem *const item = selectedItem();
	if (!item) {
	return;
	}

	const QVariant v = brush2color(item->data(StoredForegroundRole));

	const QColor initial = v.isValid() ? v.value<QColor>() : categoriesLV->palette().color(QPalette::Normal, QPalette::Text);
	const QColor c = QColorDialog::getColor(initial, q);

	if (c.isValid()) {
	item->setData(StoredForegroundRole, QBrush(c));
	if (!SystemInfo::isHighContrastModeActive()) {
	item->setData(Qt::ForegroundRole, QBrush(c));
	}
	Q_EMIT q->changed();
	}
	}

	void AppearanceConfigWidget::Private::slotBackgroundClicked()
	{
	QListWidgetItem *const item = selectedItem();
	if (!item) {
	return;
	}

	const QVariant v = brush2color(item->data(StoredBackgroundRole));

	const QColor initial = v.isValid() ? v.value<QColor>() : categoriesLV->palette().color(QPalette::Normal, QPalette::Base);
	const QColor c = QColorDialog::getColor(initial, q);

	if (c.isValid()) {
	item->setData(StoredBackgroundRole, QBrush(c));
	if (!SystemInfo::isHighContrastModeActive()) {
	item->setData(Qt::BackgroundRole, QBrush(c));
	}
	Q_EMIT q->changed();
	}
	}
	#endif // QT_NO_COLORDIALOG

	#ifndef QT_NO_FONTDIALOG
	void AppearanceConfigWidget::Private::slotFontClicked()
	{
	QListWidgetItem *const item = selectedItem();
	if (!item) {
	return;
	}

	const QVariant v = item->data(Qt::FontRole);

	bool ok = false;
	const QFont defaultFont = tryToFindFontFor(item);
	#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
	const QFont initial = v.isValid() && v.type() == QVariant::Font ? v.value<QFont>() : defaultFont;
	#else
	const QFont initial = v.isValid() && v.userType() == QMetaType::QFont ? v.value<QFont>() : defaultFont;
	#endif
	QFont f = QFontDialog::getFont(&ok, initial, q);
	if (!ok) {
	return;
	}

	// disallow circumventing KIOSK:
	if (!item->data(MayChangeItalicRole).toBool()) {
	f.setItalic(initial.italic());
	}
	if (!item->data(MayChangeBoldRole).toBool()) {
	f.setBold(initial.bold());
	}
	if (!item->data(MayChangeStrikeOutRole).toBool()) {
	f.setStrikeOut(initial.strikeOut());
	}

	item->setData(Qt::FontRole, f != defaultFont ? f : QVariant());
	item->setData(HasFontRole, true);
	Q_EMIT q->changed();
	}
	#endif // QT_NO_FONTDIALOG

	void AppearanceConfigWidget::Private::slotItalicToggled(bool on)
	{
	set_italic(selectedItem(), on);
	Q_EMIT q->changed();
	}

	void AppearanceConfigWidget::Private::slotBoldToggled(bool on)
	{
	set_bold(selectedItem(), on);
	Q_EMIT q->changed();
	}

	void AppearanceConfigWidget::Private::slotStrikeOutToggled(bool on)
	{
	set_strikeout(selectedItem(), on);
	Q_EMIT q->changed();
	}

	void AppearanceConfigWidget::Private::slotTooltipValidityChanged(bool)
	{
	Q_EMIT q->changed();
	}

	void AppearanceConfigWidget::Private::slotTooltipOwnerChanged(bool)
	{
	Q_EMIT q->changed();
	}

	void AppearanceConfigWidget::Private::slotTooltipDetailsChanged(bool)
	{
	Q_EMIT q->changed();
	}

	void AppearanceConfigWidget::Private::slotUseTagsChanged(bool)
	{
	Q_EMIT q->changed();
	}

	#include "moc_appearanceconfigwidget.cpp"
	diff --git a/src/conf/appearanceconfigwidget.ui b/src/conf/appearanceconfigwidget.ui
	deleted file mode 100644
	index 5c0376d8d..000000000
	--- a/src/conf/appearanceconfigwidget.ui
	+++ /dev/null
	@@ -1,215 +0,0 @@
	-<ui version="4.0" >
	- <class>AppearanceConfigWidget</class>
	- <widget class="QWidget" name="AppearanceConfigWidget" >
	- <property name="geometry" >
	- <rect>
	- <x>0</x>
	- <y>0</y>
	- <width>647</width>
	- <height>464</height>
	- </rect>
	- </property>
	- <layout class="QVBoxLayout" name="verticalLayout_2" >
	- <item>
	- <widget class="QTabWidget" name="tabWidget" >
	- <widget class="QWidget" name="tab_2" >
	- <attribute name="title" >
	- <string>Certificate Categories</string>
	- </attribute>
	- <layout class="QGridLayout" >
	- <item row="0" column="0" colspan="2" >
	- <widget class="KMessageWidget" name="highContrastMsg" />
	- </item>
	- <item row="1" column="0" >
	- <widget class="QListWidget" name="categoriesLV" />
	- </item>
	- <item row="1" column="1" >
	- <layout class="QVBoxLayout" >
	- <item>
	- <widget class="QPushButton" name="iconButton" >
	- <property name="enabled" >
	- <bool>false</bool>
	- </property>
	- <property name="text" >
	- <string>Set &Icon...</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QPushButton" name="foregroundButton" >
	- <property name="enabled" >
	- <bool>false</bool>
	- </property>
	- <property name="text" >
	- <string>Set &Text Color...</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QPushButton" name="backgroundButton" >
	- <property name="enabled" >
	- <bool>false</bool>
	- </property>
	- <property name="text" >
	- <string>Set &Background Color...</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QPushButton" name="fontButton" >
	- <property name="enabled" >
	- <bool>false</bool>
	- </property>
	- <property name="text" >
	- <string>Set F&ont...</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QCheckBox" name="italicCB" >
	- <property name="enabled" >
	- <bool>false</bool>
	- </property>
	- <property name="text" >
	- <string>Italic</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QCheckBox" name="boldCB" >
	- <property name="enabled" >
	- <bool>false</bool>
	- </property>
	- <property name="text" >
	- <string>Bold</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QCheckBox" name="strikeoutCB" >
	- <property name="enabled" >
	- <bool>false</bool>
	- </property>
	- <property name="text" >
	- <string>Strikeout</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <spacer>
	- <property name="orientation" >
	- <enum>Qt::Vertical</enum>
	- </property>
	- <property name="sizeType" >
	- <enum>QSizePolicy::Expanding</enum>
	- </property>
	- <property name="sizeHint" stdset="0" >
	- <size>
	- <width>20</width>
	- <height>100</height>
	- </size>
	- </property>
	- </spacer>
	- </item>
	- <item>
	- <widget class="QPushButton" name="defaultLookPB" >
	- <property name="enabled" >
	- <bool>false</bool>
	- </property>
	- <property name="text" >
	- <string>Default Appearance</string>
	- </property>
	- </widget>
	- </item>
	- </layout>
	- </item>
	- </layout>
	- </widget>
	- <widget class="QWidget" name="tab" >
	- <attribute name="title" >
	- <string>Tooltips</string>
	- </attribute>
	- <layout class="QVBoxLayout" name="verticalLayout" >
	- <item>
	- <widget class="QLabel" name="label" >
	- <property name="text" >
	- <string>Show the following information in certificate list tooltips:</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QCheckBox" name="tooltipValidityCheckBox" >
	- <property name="text" >
	- <string>Show validity</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QCheckBox" name="tooltipOwnerCheckBox" >
	- <property name="text" >
	- <string>Show owner information</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <widget class="QCheckBox" name="tooltipDetailsCheckBox" >
	- <property name="text" >
	- <string>Show technical details</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <spacer>
	- <property name="orientation" >
	- <enum>Qt::Vertical</enum>
	- </property>
	- <property name="sizeHint" stdset="0" >
	- <size>
	- <width>20</width>
	- <height>40</height>
	- </size>
	- </property>
	- </spacer>
	- </item>
	- </layout>
	- </widget>
	- <widget class="QWidget" name="tab_tags" >
	- <attribute name="title" >
	- <string>Tags</string>
	- </attribute>
	- <layout class="QVBoxLayout" name="verticalLayout_tags" >
	- <item>
	- <widget class="QCheckBox" name="useTagsCheckBox" >
	- <property name="text" >
	- <string>Use tags</string>
	- </property>
	- <property name="toolTip" >
	- <string>Enable display and usage of tags attached to keys.</string>
	- </property>
	- </widget>
	- </item>
	- <item>
	- <spacer>
	- <property name="orientation" >
	- <enum>Qt::Vertical</enum>
	- </property>
	- <property name="sizeHint" stdset="0" >
	- <size>
	- <width>20</width>
	- <height>40</height>
	- </size>
	- </property>
	- </spacer>
	- </item>
	- </layout>
	- </widget>
	- </widget>
	- </item>
	- </layout>
	- </widget>
	- <includes>
	- <include>KMessageWidget</include>
	- </includes>
	- <resources/>
	- <connections/>
	-</ui>

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jan 12, 10:39 PM (1 d, 7 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 73/77/a71b80e6c541365e5e174b36bb3a

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions