No OneTemporary
Actions

Size

54 KB

Subscribers

None

View Options

	diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
	index c607c59b6..9482e5a7e 100644
	--- a/src/mainwindow.cpp
	+++ b/src/mainwindow.cpp
	@@ -1,686 +1,686 @@
	/* -- mode: c++; c-basic-offset:4 --
	mainwindow.cpp

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

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

	#include <config-kleopatra.h>
	#include "mainwindow.h"
	#include "aboutdata.h"
	#include "settings.h"

	#include "view/padwidget.h"
	#include "view/searchbar.h"
	#include "view/tabwidget.h"
	#include "view/keylistcontroller.h"
	#include "view/keycacheoverlay.h"
	#include "view/smartcardwidget.h"
	#include "view/welcomewidget.h"

	#include "commands/selftestcommand.h"
	#include "commands/importcrlcommand.h"
	#include "commands/importcertificatefromfilecommand.h"
	#include "commands/decryptverifyfilescommand.h"
	#include "commands/signencryptfilescommand.h"
	#include "commands/listreaderscommand.h"

	#include "conf/groupsconfigdialog.h"

	#include "utils/detail_p.h"
	#include <Libkleo/GnuPG>
	#include "utils/action_data.h"
	#include "utils/filedialog.h"
	#include "utils/clipboardmenu.h"

	#include "dialogs/updatenotification.h"

	#include <KXMLGUIFactory>
	#include <QApplication>
	#include <QSize>
	#include <QLineEdit>
	#include <KActionMenu>
	#include <KActionCollection>
	#include <KLocalizedString>
	#include <KStandardAction>
	#include <QAction>
	#include <KAboutData>
	#include <KMessageBox>
	#include <KStandardGuiItem>
	#include <KShortcutsDialog>
	#include <KEditToolBar>
	#include "kleopatra_debug.h"
	#include <KConfigGroup>
	#include <KConfigDialog>
	#include <KColorScheme>

	#include <QAbstractItemView>
	#include <QCloseEvent>
	#include <QMenu>
	#include <QTimer>
	#include <QProcess>
	#include <QVBoxLayout>
	#include <QMimeData>
	#include <QDesktopServices>
	#include <QDir>
	#include <QStackedWidget>
	#include <QStatusBar>
	#include <QLabel>

	#include <Libkleo/Formatting>
	#include <Libkleo/KeyListModel>
	#include <Libkleo/KeyListSortFilterProxyModel>
	#include <Libkleo/Stl_Util>
	#include <Libkleo/Classify>
	#include <Libkleo/KeyCache>

	#include <vector>
	#include <KSharedConfig>
	#include <chrono>
	using namespace std::chrono_literals;

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

	static KGuiItem KStandardGuiItem_quit()
	{
	static const QString app = KAboutData::applicationData().componentName();
	KGuiItem item = KStandardGuiItem::quit();
	item.setText(i18nc("Quit [ApplicationName]", "&Quit %1", app));
	return item;
	}

	static KGuiItem KStandardGuiItem_close()
	{
	KGuiItem item = KStandardGuiItem::close();
	item.setText(i18n("Only &Close Window"));
	return item;
	}

	static bool isQuitting = false;

	namespace
	{
	static const std::vector<QString> mainViewActionNames = {
	QStringLiteral("view_certificate_overview"),
	QStringLiteral("manage_smartcard"),
	QStringLiteral("pad_view")
	};
	}

	class MainWindow::Private
	{
	friend class ::MainWindow;
	MainWindow *const q;

	public:
	explicit Private(MainWindow *qq);
	~Private();

	template <typename T>
	void createAndStart()
	{
	(new T(this->currentView(), &this->controller))->start();
	}
	template <typename T>
	void createAndStart(QAbstractItemView *view)
	{
	(new T(view, &this->controller))->start();
	}
	template <typename T>
	void createAndStart(const QStringList &a)
	{
	(new T(a, this->currentView(), &this->controller))->start();
	}
	template <typename T>
	void createAndStart(const QStringList &a, QAbstractItemView *view)
	{
	(new T(a, view, &this->controller))->start();
	}

	void closeAndQuit()
	{
	const QString app = KAboutData::applicationData().componentName();
	const int rc = KMessageBox::questionYesNoCancel(q,
	i18n("%1 may be used by other applications as a service.\n"
	"You may instead want to close this window without exiting %1.", app),
	i18n("Really Quit?"), KStandardGuiItem_close(), KStandardGuiItem_quit(), KStandardGuiItem::cancel(),
	QLatin1String("really-quit-") + app.toLower());
	if (rc == KMessageBox::Cancel) {
	return;
	}
	isQuitting = true;
	if (!q->close()) {
	return;
	}
	// WARNING: 'this' might be deleted at this point!
	if (rc == KMessageBox::No) {
	qApp->quit();
	}
	}
	void configureToolbars()
	{
	KEditToolBar dlg(q->factory());
	dlg.exec();
	}
	void editKeybindings()
	{
	KShortcutsDialog::showDialog(q->actionCollection(), KShortcutsEditor::LetterShortcutsAllowed, q);
	updateSearchBarClickMessage();
	}

	void updateSearchBarClickMessage()
	{
	const QString shortcutStr = focusToClickSearchAction->shortcut().toString();
	ui.searchBar->updateClickMessage(shortcutStr);
	}

	void updateStatusBar()
	{
	if (Kleo::gnupgUsesDeVsCompliance()) {
	auto statusBar = std::make_unique<QStatusBar>();
	auto statusLbl = std::make_unique<QLabel>(Formatting::deVsString(Kleo::gnupgIsDeVsCompliant()));
	const auto color = KColorScheme(QPalette::Active, KColorScheme::View).foreground(
	Kleo::gnupgIsDeVsCompliant() ? KColorScheme::PositiveText : KColorScheme::NegativeText
	).color();
	const auto background = KColorScheme(QPalette::Active, KColorScheme::View).background(
	Kleo::gnupgIsDeVsCompliant() ? KColorScheme::PositiveBackground : KColorScheme::NegativeBackground
	).color();
	statusLbl->setStyleSheet(QStringLiteral("QLabel { color: %1; background-color: %2; }").
	arg(color.name()).arg(background.name()));
	statusBar->insertPermanentWidget(0, statusLbl.release());
	q->setStatusBar(statusBar.release()); // QMainWindow takes ownership
	} else {
	q->setStatusBar(nullptr);
	}
	}

	void selfTest()
	{
	createAndStart<SelfTestCommand>();
	}

	void configureGroups()
	{
	if (KConfigDialog::showDialog(GroupsConfigDialog::dialogName())) {
	return;
	}
	KConfigDialog *dialog = new GroupsConfigDialog(q);
	dialog->show();
	}

	void showHandbook();

	void gnupgLogViewer()
	{
	if (!QProcess::startDetached(QStringLiteral("kwatchgnupg"), QStringList()))
	KMessageBox::error(q, i18n("Could not start the GnuPG Log Viewer (kwatchgnupg). "
	"Please check your installation."),
	i18n("Error Starting KWatchGnuPG"));
	}

	void forceUpdateCheck()
	{
	UpdateNotification::forceUpdateCheck(q);
	}

	void openCompendium()
	{
	QDir datadir(QCoreApplication::applicationDirPath() + QStringLiteral("/../share/gpg4win"));
	const auto path = datadir.filePath(i18nc("The Gpg4win compendium is only available"
	"at this point (24.7.2017) in german and english."
	"Please check with Gpg4win before translating this filename.",
	"gpg4win-compendium-en.pdf"));
	qCDebug(KLEOPATRA_LOG) << "Opening Compendium at:" << path;
	// The compendium is always installed. So this should work. Otherwise
	// we have debug output.
	QDesktopServices::openUrl(QUrl::fromLocalFile(path));
	}

	void slotConfigCommitted();
	void slotContextMenuRequested(QAbstractItemView *, const QPoint &p)
	{
	if (auto const menu = qobject_cast<QMenu *>(q->factory()->container(QStringLiteral("listview_popup"), q))) {
	menu->exec(p);
	} else {
	qCDebug(KLEOPATRA_LOG) << "no \"listview_popup\" <Menu> in kleopatra's ui.rc file";
	}
	}

	void slotFocusQuickSearch()
	{
	ui.searchBar->lineEdit()->setFocus();
	}

	void showView(const QString &actionName, QWidget *widget)
	{
	const auto coll = q->actionCollection();
	if (coll) {
	for ( const QString &name : mainViewActionNames ) {
	if (auto action = coll->action(name)) {
	action->setChecked(name == actionName);
	}
	}
	}
	ui.stackWidget->setCurrentWidget(widget);
	}

	void showCertificateView()
	{
	showView(QStringLiteral("view_certificate_overview"),
	KeyCache::instance()->keys().empty() ? ui.welcomeWidget : ui.searchTab);
	}

	void showSmartcardView()
	{
	showView(QStringLiteral("manage_smartcard"), ui.scWidget);
	}

	void showPadView()
	{
	if (!ui.padWidget) {
	ui.padWidget = new PadWidget;
	ui.stackWidget->addWidget(ui.padWidget);
	}
	showView(QStringLiteral("pad_view"), ui.padWidget);
	ui.stackWidget->resize(ui.padWidget->sizeHint());
	}

	void listSmartcardReaders()
	{
	auto command = new ListReadersCommand(q);
	command->start();
	}

	private:
	void setupActions();

	QAbstractItemView *currentView() const
	{
	return ui.tabWidget.currentView();
	}

	void keyListingDone()
	{
	const auto curWidget = ui.stackWidget->currentWidget();
	if (curWidget == ui.scWidget \|\| curWidget == ui.padWidget) {
	return;
	}
	showCertificateView();
	}

	private:
	Kleo::KeyListController controller;
	bool firstShow : 1;
	struct UI {
	QWidget *searchTab;
	TabWidget tabWidget;
	SearchBar *searchBar;
	PadWidget *padWidget;
	SmartCardWidget *scWidget;
	WelcomeWidget *welcomeWidget;
	QStackedWidget *stackWidget;
	explicit UI(MainWindow *q);
	} ui;
	QAction *focusToClickSearchAction;
	ClipboardMenu *clipboadMenu;
	};

	MainWindow::Private::UI::UI(MainWindow *q)
	: tabWidget(q), padWidget(nullptr)
	{
	KDAB_SET_OBJECT_NAME(tabWidget);

	searchTab = new QWidget;
	auto vbox = new QVBoxLayout(searchTab);
	vbox->setSpacing(0);
	searchBar = new SearchBar;
	vbox->addWidget(searchBar);
	tabWidget.connectSearchBar(searchBar);
	vbox->addWidget(&tabWidget);

	auto mainWidget = new QWidget;
	auto mainLayout = new QVBoxLayout(mainWidget);
	stackWidget = new QStackedWidget;

	mainLayout->addWidget(stackWidget);

	stackWidget->addWidget(searchTab);

	new KeyCacheOverlay(mainWidget, q);

	scWidget = new SmartCardWidget();
	stackWidget->addWidget(scWidget);

	welcomeWidget = new WelcomeWidget();
	stackWidget->addWidget(welcomeWidget);

	q->setCentralWidget(mainWidget);
	}

	MainWindow::Private::Private(MainWindow *qq)
	: q(qq),
	controller(q),
	firstShow(true),
	ui(q)
	{
	KDAB_SET_OBJECT_NAME(controller);

	AbstractKeyListModel *flatModel = AbstractKeyListModel::createFlatKeyListModel(q);
	AbstractKeyListModel *hierarchicalModel = AbstractKeyListModel::createHierarchicalKeyListModel(q);

	KDAB_SET_OBJECT_NAME(flatModel);
	KDAB_SET_OBJECT_NAME(hierarchicalModel);

	controller.setFlatModel(flatModel);
	controller.setHierarchicalModel(hierarchicalModel);
	controller.setTabWidget(&ui.tabWidget);

	ui.tabWidget.setFlatModel(flatModel);
	ui.tabWidget.setHierarchicalModel(hierarchicalModel);

	setupActions();

	ui.stackWidget->setCurrentWidget(ui.searchTab);
	if (auto action = q->actionCollection()->action(QStringLiteral("view_certificate_overview"))) {
	action->setChecked(true);
	}

	connect(&controller, SIGNAL(contextMenuRequested(QAbstractItemView,QPoint)), q, SLOT(slotContextMenuRequested(QAbstractItemView,QPoint)));
	connect(KeyCache::instance().get(), &KeyCache::keyListingDone, q, [this] () {keyListingDone();});

	q->createGUI(QStringLiteral("kleopatra.rc"));

	q->setAcceptDrops(true);

	// set default window size
	q->resize(QSize(1024, 500));
	q->setAutoSaveSettings();

	updateSearchBarClickMessage();
	updateStatusBar();
	}

	MainWindow::Private::~Private() {}

	MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags)
	: KXmlGuiWindow(parent, flags), d(new Private(this))
	{}

	MainWindow::~MainWindow() {}

	void MainWindow::Private::setupActions()
	{

	KActionCollection *const coll = q->actionCollection();

	- const action_data action_data[] = {
	+ const std::vector<action_data> action_data = {
	// most have been MOVED TO keylistcontroller.cpp
	// Tools menu
	#ifndef Q_OS_WIN
	{
	"tools_start_kwatchgnupg", i18n("GnuPG Log Viewer"), QString(),
	"kwatchgnupg", q, SLOT(gnupgLogViewer()), QString(), false, true
	},
	#endif
	#ifdef Q_OS_WIN
	{
	"help_check_updates", i18n("Check for updates"), QString(),
	"gpg4win-compact", q, SLOT(forceUpdateCheck()), QString(), false, true
	},
	{
	"help_show_compendium", i18n("Gpg4win Compendium"), QString(),
	"gpg4win-compact", q, SLOT(openCompendium()), QString(), false, true
	},
	#endif
	{
	"view_certificate_overview", i18nc("@action show certificate overview", "Certificates"),
	i18n("Show certificate overview"), "view-certificate", q, SLOT(showCertificateView()), QString(), false, true
	},
	{
	"pad_view", i18nc("@action show input / output area for encrypting/signing resp. decrypting/verifying text", "Notepad"),
	i18n("Show pad for encrypting/decrypting and signing/verifying text"), "note", q, SLOT(showPadView()), QString(), false, true
	},
	// most have been MOVED TO keylistcontroller.cpp
	// Settings menu
	{
	"settings_self_test", i18n("Perform Self-Test"), QString(),
	nullptr, q, SLOT(selfTest()), QString(), false, true
	},
	{
	"settings_list_readers", i18n("List Smartcard Readers"), QString(),
	nullptr, q, SLOT(listSmartcardReaders()), QString(), false, true
	},
	{
	"configure_groups", i18n("Configure Groups..."), QString(),
	"group", q, SLOT(configureGroups()), QString(), false, true
	},
	{
	"manage_smartcard", i18nc("@action show smartcard management view", "Smartcards"),
	i18n("Show smartcard management"), "auth-sim-locked", q, SLOT(showSmartcardView()), QString(), false, true
	}

	// most have been MOVED TO keylistcontroller.cpp
	};

	- make_actions_from_data(action_data, /sizeof action_data / sizeof action_data,*/ coll);
	+ make_actions_from_data(action_data, coll);

	if (!Settings().groupsEnabled()) {
	if (auto action = coll->action(QStringLiteral("configure_groups"))) {
	delete action;
	}
	}

	for ( const QString &name : mainViewActionNames ) {
	if (auto action = coll->action(name)) {
	action->setCheckable(true);
	}
	}

	if (QAction *action = coll->action(QStringLiteral("configure_backend"))) {
	action->setMenuRole(QAction::NoRole); //prevent Qt OS X heuristics for config* actions
	}

	KStandardAction::close(q, SLOT(close()), coll);
	KStandardAction::quit(q, SLOT(closeAndQuit()), coll);
	KStandardAction::configureToolbars(q, SLOT(configureToolbars()), coll);
	KStandardAction::keyBindings(q, SLOT(editKeybindings()), coll);
	KStandardAction::preferences(qApp, SLOT(openOrRaiseConfigDialog()), coll);

	focusToClickSearchAction = new QAction(i18n("Set Focus to Quick Search"), q);
	coll->addAction(QStringLiteral("focus_to_quickseach"), focusToClickSearchAction);
	coll->setDefaultShortcut(focusToClickSearchAction, QKeySequence(Qt::ALT \| Qt::Key_Q));
	connect(focusToClickSearchAction, SIGNAL(triggered(bool)), q, SLOT(slotFocusQuickSearch()));
	clipboadMenu = new ClipboardMenu(q);
	clipboadMenu->setMainWindow(q);
	clipboadMenu->clipboardMenu()->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste")));
	clipboadMenu->clipboardMenu()->setPopupMode(QToolButton::InstantPopup);
	coll->addAction(QStringLiteral("clipboard_menu"), clipboadMenu->clipboardMenu());

	q->setStandardToolBarMenuEnabled(true);

	controller.createActions(coll);

	ui.tabWidget.createActions(coll);
	}

	void MainWindow::Private::slotConfigCommitted()
	{
	controller.updateConfig();
	updateStatusBar();
	}

	void MainWindow::closeEvent(QCloseEvent *e)
	{
	// KMainWindow::closeEvent() insists on quitting the application,
	// so do not let it touch the event...
	qCDebug(KLEOPATRA_LOG);
	if (d->controller.hasRunningCommands()) {
	if (d->controller.shutdownWarningRequired()) {
	const int ret = KMessageBox::warningContinueCancel(this, i18n("There are still some background operations ongoing. "
	"These will be terminated when closing the window. "
	"Proceed?"),
	i18n("Ongoing Background Tasks"));
	if (ret != KMessageBox::Continue) {
	e->ignore();
	return;
	}
	}
	d->controller.cancelCommands();
	if (d->controller.hasRunningCommands()) {
	// wait for them to be finished:
	setEnabled(false);
	QEventLoop ev;
	QTimer::singleShot(100ms, &ev, &QEventLoop::quit);
	connect(&d->controller, &KeyListController::commandsExecuting, &ev, &QEventLoop::quit);
	ev.exec();
	if (d->controller.hasRunningCommands())
	qCWarning(KLEOPATRA_LOG)
	<< "controller still has commands running, this may crash now...";
	setEnabled(true);
	}
	}
	if (isQuitting \|\| qApp->isSavingSession()) {
	d->ui.tabWidget.saveViews(KSharedConfig::openConfig().data());
	KConfigGroup grp(KConfigGroup(KSharedConfig::openConfig(), autoSaveGroup()));
	saveMainWindowSettings(grp);
	e->accept();
	} else {
	e->ignore();
	hide();
	}
	}

	void MainWindow::showEvent(QShowEvent *e)
	{
	KXmlGuiWindow::showEvent(e);
	if (d->firstShow) {
	d->ui.tabWidget.loadViews(KSharedConfig::openConfig().data());
	d->firstShow = false;
	}

	if (!savedGeometry.isEmpty()) {
	restoreGeometry(savedGeometry);
	}

	}

	void MainWindow::hideEvent(QHideEvent *e)
	{
	savedGeometry = saveGeometry();
	KXmlGuiWindow::hideEvent(e);
	}

	void MainWindow::importCertificatesFromFile(const QStringList &files)
	{
	if (!files.empty()) {
	d->createAndStart<ImportCertificateFromFileCommand>(files);
	}
	}

	static QStringList extract_local_files(const QMimeData *data)
	{
	const QList<QUrl> urls = data->urls();
	// begin workaround KDE/Qt misinterpretation of text/uri-list
	QList<QUrl>::const_iterator end = urls.end();
	if (urls.size() > 1 && !urls.back().isValid()) {
	--end;
	}
	// end workaround
	QStringList result;
	std::transform(urls.begin(), end,
	std::back_inserter(result),
	std::mem_fn(&QUrl::toLocalFile));
	result.erase(std::remove_if(result.begin(), result.end(),
	std::mem_fn(&QString::isEmpty)), result.end());
	return result;
	}

	static bool can_decode_local_files(const QMimeData *data)
	{
	if (!data) {
	return false;
	}
	return !extract_local_files(data).empty();
	}

	void MainWindow::dragEnterEvent(QDragEnterEvent *e)
	{
	qCDebug(KLEOPATRA_LOG);

	if (can_decode_local_files(e->mimeData())) {
	e->acceptProposedAction();
	}
	}

	void MainWindow::dropEvent(QDropEvent *e)
	{
	qCDebug(KLEOPATRA_LOG);

	if (!can_decode_local_files(e->mimeData())) {
	return;
	}

	e->setDropAction(Qt::CopyAction);

	const QStringList files = extract_local_files(e->mimeData());

	const unsigned int classification = classify(files);

	QMenu menu;

	QAction *const signEncrypt = menu.addAction(i18n("Sign/Encrypt..."));
	QAction *const decryptVerify = mayBeAnyMessageType(classification) ? menu.addAction(i18n("Decrypt/Verify...")) : nullptr;
	if (signEncrypt \|\| decryptVerify) {
	menu.addSeparator();
	}

	QAction *const importCerts = mayBeAnyCertStoreType(classification) ? menu.addAction(i18n("Import Certificates")) : nullptr;
	QAction *const importCRLs = mayBeCertificateRevocationList(classification) ? menu.addAction(i18n("Import CRLs")) : nullptr;
	if (importCerts \|\| importCRLs) {
	menu.addSeparator();
	}

	if (!signEncrypt && !decryptVerify && !importCerts && !importCRLs) {
	return;
	}

	menu.addAction(i18n("Cancel"));

	const QAction *const chosen = menu.exec(mapToGlobal(e->pos()));

	if (!chosen) {
	return;
	}

	if (chosen == signEncrypt) {
	d->createAndStart<SignEncryptFilesCommand>(files);
	} else if (chosen == decryptVerify) {
	d->createAndStart<DecryptVerifyFilesCommand>(files);
	} else if (chosen == importCerts) {
	d->createAndStart<ImportCertificateFromFileCommand>(files);
	} else if (chosen == importCRLs) {
	d->createAndStart<ImportCrlCommand>(files);
	}

	e->accept();
	}

	void MainWindow::readProperties(const KConfigGroup &cg)
	{
	qCDebug(KLEOPATRA_LOG);
	KXmlGuiWindow::readProperties(cg);
	setHidden(cg.readEntry("hidden", false));
	}

	void MainWindow::saveProperties(KConfigGroup &cg)
	{
	qCDebug(KLEOPATRA_LOG);
	KXmlGuiWindow::saveProperties(cg);
	cg.writeEntry("hidden", isHidden());
	}

	#include "moc_mainwindow.cpp"
	diff --git a/src/utils/action_data.cpp b/src/utils/action_data.cpp
	index bdb286ccc..d26066ce6 100644
	--- a/src/utils/action_data.cpp
	+++ b/src/utils/action_data.cpp
	@@ -1,59 +1,59 @@
	/* -- mode: c++; c-basic-offset:4 --
	utils/action_data.cpp

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

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

	#include <config-kleopatra.h>

	#include "action_data.h"

	#include <KToggleAction>
	#include <KActionCollection>
	#include <QAction>
	#include <QIcon>
	#include <QKeySequence>

	QAction Kleo::createAction(const action_data &ad, KActionCollection coll)
	{

	QAction *const a = ad.toggle ? new KToggleAction(coll) : new QAction(coll);
	a->setObjectName(QLatin1String(ad.name));
	a->setText(ad.text);
	if (!ad.tooltip.isEmpty()) {
	a->setToolTip(ad.tooltip);
	}
	if (ad.icon) {
	a->setIcon(QIcon::fromTheme(QLatin1String(ad.icon)));
	}
	if (ad.receiver && ad.slot) {
	if (ad.toggle) {
	QObject::connect(a, SIGNAL(toggled(bool)), ad.receiver, ad.slot);
	} else {
	QObject::connect(a, SIGNAL(triggered()), ad.receiver, ad.slot);
	}
	}
	a->setEnabled(ad.enabled);
	coll->addAction(QLatin1String(ad.name), a);
	return a;
	}

	QAction Kleo::make_action_from_data(const action_data &ad, KActionCollection coll)
	{

	QAction *const a = createAction(ad, coll);
	if (!ad.shortcut.isEmpty()) {
	coll->setDefaultShortcut(a, QKeySequence(ad.shortcut));
	}
	return a;
	}

	-void Kleo::make_actions_from_data(const action_data ads, unsigned int size, KActionCollection coll)
	+void Kleo::make_actions_from_data(const std::vector<action_data> &data, KActionCollection *coll)
	{
	- for (unsigned int i = 0; i < size; ++i) {
	- coll->addAction(QLatin1String(ads[i].name), make_action_from_data(ads[i], coll));
	+ for (const auto &actionData : data) {
	+ coll->addAction(QLatin1String(actionData.name), make_action_from_data(actionData, coll));
	}
	}
	diff --git a/src/utils/action_data.h b/src/utils/action_data.h
	index 9a5c0e787..bd501886b 100644
	--- a/src/utils/action_data.h
	+++ b/src/utils/action_data.h
	@@ -1,44 +1,38 @@
	/* -- mode: c++; c-basic-offset:4 --
	utils/action_data.h

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

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

	#pragma once

	#include <QString>

	class QObject;
	class QAction;
	class KActionCollection;

	namespace Kleo
	{

	struct action_data {
	const char *name;
	QString text;
	QString tooltip;
	const char *icon;
	const QObject *receiver;
	const char *slot;
	QString shortcut;
	bool toggle;
	bool enabled;
	};

	-void make_actions_from_data(const action_data data, unsigned int numData, KActionCollection collection);
	-
	-template <unsigned int N>
	-inline void make_actions_from_data(const action_data(&data)[N], KActionCollection *collection)
	-{
	- make_actions_from_data(data, N, collection);
	-}
	+void make_actions_from_data(const std::vector<action_data> &data, KActionCollection *collection);

	QAction make_action_from_data(const action_data &ad, KActionCollection coll);
	QAction createAction(const action_data &ad, KActionCollection coll);
	}

	diff --git a/src/view/keylistcontroller.cpp b/src/view/keylistcontroller.cpp
	index ba1d80042..28d0c1c6d 100644
	--- a/src/view/keylistcontroller.cpp
	+++ b/src/view/keylistcontroller.cpp
	@@ -1,810 +1,810 @@
	/* -- mode: c++; c-basic-offset:4 --
	controllers/keylistcontroller.cpp

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

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

	#include <config-kleopatra.h>

	#include "keylistcontroller.h"
	#include "tabwidget.h"

	#include <smartcard/readerstatus.h>

	#include <utils/action_data.h>

	#include "tooltippreferences.h"
	#include "kleopatra_debug.h"
	#include "commands/exportcertificatecommand.h"
	#include "commands/exportopenpgpcertstoservercommand.h"
	#include "commands/exportsecretkeycommand.h"
	#include "commands/importcertificatefromfilecommand.h"
	#include "commands/changepassphrasecommand.h"
	#include "commands/lookupcertificatescommand.h"
	#include "commands/reloadkeyscommand.h"
	#include "commands/refreshx509certscommand.h"
	#include "commands/refreshopenpgpcertscommand.h"
	#include "commands/detailscommand.h"
	#include "commands/deletecertificatescommand.h"
	#include "commands/decryptverifyfilescommand.h"
	#include "commands/signencryptfilescommand.h"
	#include "commands/signencryptfoldercommand.h"
	#include "commands/clearcrlcachecommand.h"
	#include "commands/dumpcrlcachecommand.h"
	#include "commands/dumpcertificatecommand.h"
	#include "commands/importcrlcommand.h"
	#include "commands/changeexpirycommand.h"
	#include "commands/changeownertrustcommand.h"
	#include "commands/changeroottrustcommand.h"
	#include "commands/certifycertificatecommand.h"
	#include "commands/revokecertificationcommand.h"
	#include "commands/adduseridcommand.h"
	#include "commands/newcertificatecommand.h"
	#include "commands/checksumverifyfilescommand.h"
	#include "commands/checksumcreatefilescommand.h"
	#include "commands/exportpaperkeycommand.h"

	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyListModel>
	#include <Libkleo/Formatting>

	#include <gpgme++/key.h>

	#include <KActionCollection>
	#include <KLocalizedString>

	#include <QAbstractItemView>
	#include <QPointer>
	#include <QItemSelectionModel>
	#include <QAction>

	#include <algorithm>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::SmartCard;
	using namespace GpgME;

	class KeyListController::Private
	{
	friend class ::Kleo::KeyListController;
	KeyListController *const q;
	public:
	explicit Private(KeyListController *qq);
	~Private();

	void connectView(QAbstractItemView *view);
	void connectCommand(Command *cmd);

	void connectTabWidget();
	void disconnectTabWidget();

	void addCommand(Command *cmd)
	{
	connectCommand(cmd);
	commands.insert(std::lower_bound(commands.begin(), commands.end(), cmd), cmd);
	}
	void addView(QAbstractItemView *view)
	{
	connectView(view);
	views.insert(std::lower_bound(views.begin(), views.end(), view), view);
	}
	void removeView(QAbstractItemView *view)
	{
	view->disconnect(q);
	view->selectionModel()->disconnect(q);
	views.erase(std::remove(views.begin(), views.end(), view), views.end());
	}

	public:
	void slotDestroyed(QObject *o)
	{
	qCDebug(KLEOPATRA_LOG) << (void *)o;
	views.erase(std::remove(views.begin(), views.end(), o), views.end());
	commands.erase(std::remove(commands.begin(), commands.end(), o), commands.end());
	}
	void slotDoubleClicked(const QModelIndex &idx);
	void slotActivated(const QModelIndex &idx);
	void slotSelectionChanged(const QItemSelection &old, const QItemSelection &new_);
	void slotContextMenu(const QPoint &pos);
	void slotCommandFinished();
	void slotAddKey(const Key &key);
	void slotAboutToRemoveKey(const Key &key);
	void slotProgress(const QString &what, int current, int total)
	{
	Q_EMIT q->progress(current, total);
	if (!what.isEmpty()) {
	Q_EMIT q->message(what);
	}
	}
	void slotActionTriggered();
	void slotCurrentViewChanged(QAbstractItemView *view)
	{
	if (view && !std::binary_search(views.cbegin(), views.cend(), view)) {
	qCDebug(KLEOPATRA_LOG) << "you need to register view" << view << "before trying to set it as the current view!";
	addView(view);
	}
	currentView = view;
	q->enableDisableActions(view ? view->selectionModel() : nullptr);
	}

	private:
	int toolTipOptions() const;

	private:
	static Command::Restrictions calculateRestrictionsMask(const QItemSelectionModel *sm);

	private:
	struct action_item {
	QPointer<QAction> action;
	Command::Restrictions restrictions;
	Command (createCommand)(QAbstractItemView , KeyListController );
	};
	std::vector<action_item> actions;
	std::vector<QAbstractItemView *> views;
	std::vector<Command *> commands;
	QPointer<QWidget> parentWidget;
	QPointer<TabWidget> tabWidget;
	QPointer<QAbstractItemView> currentView;
	QPointer<AbstractKeyListModel> flatModel, hierarchicalModel;
	};

	KeyListController::Private::Private(KeyListController *qq)
	: q(qq),
	actions(),
	views(),
	commands(),
	parentWidget(),
	tabWidget(),
	flatModel(),
	hierarchicalModel()
	{
	connect(KeyCache::mutableInstance().get(), SIGNAL(added(GpgME::Key)),
	q, SLOT(slotAddKey(GpgME::Key)));
	connect(KeyCache::mutableInstance().get(), SIGNAL(aboutToRemove(GpgME::Key)),
	q, SLOT(slotAboutToRemoveKey(GpgME::Key)));
	}

	KeyListController::Private::~Private() {}

	KeyListController::KeyListController(QObject *p)
	: QObject(p), d(new Private(this))
	{

	}

	KeyListController::~KeyListController() {}

	void KeyListController::Private::slotAddKey(const Key &key)
	{
	// ### make model act on keycache directly...
	if (flatModel) {
	flatModel->addKey(key);
	}
	if (hierarchicalModel) {
	hierarchicalModel->addKey(key);
	}
	}

	void KeyListController::Private::slotAboutToRemoveKey(const Key &key)
	{
	// ### make model act on keycache directly...
	if (flatModel) {
	flatModel->removeKey(key);
	}
	if (hierarchicalModel) {
	hierarchicalModel->removeKey(key);
	}
	}

	void KeyListController::addView(QAbstractItemView *view)
	{
	if (!view \|\| std::binary_search(d->views.cbegin(), d->views.cend(), view)) {
	return;
	}
	d->addView(view);
	}

	void KeyListController::removeView(QAbstractItemView *view)
	{
	if (!view \|\| !std::binary_search(d->views.cbegin(), d->views.cend(), view)) {
	return;
	}
	d->removeView(view);
	}

	void KeyListController::setCurrentView(QAbstractItemView *view)
	{
	d->slotCurrentViewChanged(view);
	}

	std::vector<QAbstractItemView *> KeyListController::views() const
	{
	return d->views;
	}

	void KeyListController::setFlatModel(AbstractKeyListModel *model)
	{
	if (model == d->flatModel) {
	return;
	}

	d->flatModel = model;

	if (model) {
	model->clear();
	if (KeyCache::instance()->initialized()) {
	model->addKeys(KeyCache::instance()->keys());
	}
	model->setToolTipOptions(d->toolTipOptions());
	}
	}

	void KeyListController::setHierarchicalModel(AbstractKeyListModel *model)
	{
	if (model == d->hierarchicalModel) {
	return;
	}

	d->hierarchicalModel = model;

	if (model) {
	model->clear();
	if (KeyCache::instance()->initialized()) {
	model->addKeys(KeyCache::instance()->keys());
	}
	model->setToolTipOptions(d->toolTipOptions());
	}
	}

	void KeyListController::setTabWidget(TabWidget *tabWidget)
	{
	if (tabWidget == d->tabWidget) {
	return;
	}

	d->disconnectTabWidget();

	d->tabWidget = tabWidget;

	d->connectTabWidget();

	d->slotCurrentViewChanged(tabWidget ? tabWidget->currentView() : nullptr);
	}

	void KeyListController::setParentWidget(QWidget *parent)
	{
	d->parentWidget = parent;
	}

	QWidget *KeyListController::parentWidget() const
	{
	return d->parentWidget;
	}

	static const struct {
	const char *signal;
	const char *slot;
	} tabs2controller[] = {
	{ SIGNAL(viewAdded(QAbstractItemView)), SLOT(addView(QAbstractItemView)) },
	{ SIGNAL(viewAboutToBeRemoved(QAbstractItemView)), SLOT(removeView(QAbstractItemView)) },
	{ SIGNAL(currentViewChanged(QAbstractItemView)), SLOT(slotCurrentViewChanged(QAbstractItemView)) },
	};
	static const unsigned int numTabs2Controller = sizeof tabs2controller / sizeof * tabs2controller;

	void KeyListController::Private::connectTabWidget()
	{
	if (!tabWidget) {
	return;
	}
	const auto views = tabWidget->views();
	std::for_each(views.cbegin(), views.cend(),
	[this](QAbstractItemView *view) { addView(view); });
	for (unsigned int i = 0; i < numTabs2Controller; ++i) {
	connect(tabWidget, tabs2controller[i].signal, q, tabs2controller[i].slot);
	}
	}

	void KeyListController::Private::disconnectTabWidget()
	{
	if (!tabWidget) {
	return;
	}
	for (unsigned int i = 0; i < numTabs2Controller; ++i) {
	disconnect(tabWidget, tabs2controller[i].signal, q, tabs2controller[i].slot);
	}
	const auto views = tabWidget->views();
	std::for_each(views.cbegin(), views.cend(),
	[this](QAbstractItemView *view) { removeView(view); });
	}

	AbstractKeyListModel *KeyListController::flatModel() const
	{
	return d->flatModel;
	}

	AbstractKeyListModel *KeyListController::hierarchicalModel() const
	{
	return d->hierarchicalModel;
	}

	QAbstractItemView *KeyListController::currentView() const
	{
	return d->currentView;
	}

	TabWidget *KeyListController::tabWidget() const
	{
	return d->tabWidget;
	}

	void KeyListController::createActions(KActionCollection *coll)
	{

	- const action_data action_data[] = {
	+ const std::vector<action_data> action_data = {
	// File menu
	{
	"file_new_certificate", i18n("New Key Pair..."), QString(),
	"view-certificate-add", nullptr, nullptr, QStringLiteral("Ctrl+N"), false, true
	},
	{
	"file_export_certificates", i18n("Export..."), i18n("Export the selected certificate (public key) to a file"),
	"view-certificate-export", nullptr, nullptr, QStringLiteral("Ctrl+E"), false, true
	},
	{
	"file_export_certificates_to_server", i18n("Publish on Server..."), i18n("Publish the selected certificate (public key) on a public keyserver"),
	"view-certificate-export-server", nullptr, nullptr, QStringLiteral("Ctrl+Shift+E"), false, true
	},
	{
	"file_export_secret_keys", i18n("Backup Secret Keys..."), QString(),
	"view-certificate-export-secret", nullptr, nullptr, QString(), false, true
	},
	{
	"file_export_paper_key", i18n("Print Secret Key..."), QString(),
	"document-print", nullptr, nullptr, QString(), false, true
	},
	{
	"file_lookup_certificates", i18n("Lookup on Server..."), i18n("Search for certificates online using a public keyserver"),
	"edit-find", nullptr, nullptr, QStringLiteral("Shift+Ctrl+I"), false, true
	},
	{
	"file_import_certificates", i18n("Import..."), i18n("Import a certificate from a file"),
	"view-certificate-import", nullptr, nullptr, QStringLiteral("Ctrl+I"), false, true
	},
	{
	"file_decrypt_verify_files", i18n("Decrypt/Verify..."), i18n("Decrypt and/or verify files"),
	"document-edit-decrypt-verify", nullptr, nullptr, QString(), false, true
	},
	{
	"file_sign_encrypt_files", i18n("Sign/Encrypt..."), i18n("Encrypt and/or sign files"),
	"document-edit-sign-encrypt", nullptr, nullptr, QString(), false, true
	},
	{
	"file_sign_encrypt_folder", i18n("Sign/Encrypt Folder..."), i18n("Encrypt and/or sign folders"),
	nullptr/"folder-edit-sign-encrypt"/, nullptr, nullptr, QString(), false, true
	},
	{
	"file_checksum_create_files", i18n("Create Checksum Files..."), QString(),
	nullptr/"document-checksum-create"/, nullptr, nullptr, QString(), false, true
	},
	{
	"file_checksum_verify_files", i18n("Verify Checksum Files..."), QString(),
	nullptr/"document-checksum-verify"/, nullptr, nullptr, QString(), false, true
	},
	// View menu
	{
	"view_redisplay", i18n("Redisplay"), QString(),
	"view-refresh", nullptr, nullptr, QStringLiteral("F5"), false, true
	},
	{
	"view_stop_operations", i18n("Stop Operation"), QString(),
	"process-stop", this, SLOT(cancelCommands()), QStringLiteral("Escape"), false, false
	},
	{
	"view_certificate_details", i18n("Details"), QString(),
	"dialog-information", nullptr, nullptr, QString(), false, true
	},
	// Certificate menu
	{
	"certificates_delete", i18n("Delete"), i18n("Delete selected certificates"),
	"edit-delete", nullptr, nullptr, QStringLiteral("Delete"), false, true
	},
	{
	"certificates_certify_certificate", i18n("Certify..."), i18n("Certify the validity of the selected certificate"),
	"view-certificate-sign", nullptr, nullptr, QString(), false, true
	},
	{
	"certificates_revoke_certification", i18n("Revoke Certification..."), i18n("Revoke the certification of the selected certificate"),
	"view-certificate-revoke", nullptr, nullptr, QString(), false, true
	},
	{
	"certificates_change_expiry", i18n("Change Expiry Date..."), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	{
	"certificates_change_owner_trust", i18n("Change Certification Trust..."), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	{
	"certificates_trust_root", i18n("Trust Root Certificate"), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	{
	"certificates_distrust_root", i18n("Distrust Root Certificate"), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	{
	"certificates_change_passphrase", i18n("Change Passphrase..."), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	{
	"certificates_add_userid", i18n("Add User-ID..."), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	{
	"certificates_dump_certificate", i18n("Technical Details"), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	// Tools menu
	{
	"tools_refresh_x509_certificates", i18n("Refresh S/MIME Certificates"), QString(),
	"view-refresh", nullptr, nullptr, QString(), false, true
	},
	{
	"tools_refresh_openpgp_certificates", i18n("Refresh OpenPGP Certificates"), QString(),
	"view-refresh", nullptr, nullptr, QString(), false, true
	},
	{
	"crl_clear_crl_cache", i18n("Clear CRL Cache"), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	{
	"crl_dump_crl_cache", i18n("Dump CRL Cache"), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	{
	"crl_import_crl", i18n("Import CRL From File..."), QString(),
	nullptr, nullptr, nullptr, QString(), false, true
	},
	// Window menu
	// (come from TabWidget)
	// Help menu
	// (come from MainWindow)
	};

	make_actions_from_data(action_data, coll);

	if (QAction *action = coll->action(QStringLiteral("view_stop_operations"))) {
	connect(this, &KeyListController::commandsExecuting, action, &QAction::setEnabled);
	}

	// ### somehow make this better...
	registerActionForCommand<NewCertificateCommand>(coll->action(QStringLiteral("file_new_certificate")));
	//---
	registerActionForCommand<LookupCertificatesCommand>(coll->action(QStringLiteral("file_lookup_certificates")));
	registerActionForCommand<ImportCertificateFromFileCommand>(coll->action(QStringLiteral("file_import_certificates")));
	//---
	registerActionForCommand<ExportCertificateCommand>(coll->action(QStringLiteral("file_export_certificates")));
	registerActionForCommand<ExportSecretKeyCommand>(coll->action(QStringLiteral("file_export_secret_keys")));
	registerActionForCommand<ExportPaperKeyCommand>(coll->action(QStringLiteral("file_export_paper_key")));
	registerActionForCommand<ExportOpenPGPCertsToServerCommand>(coll->action(QStringLiteral("file_export_certificates_to_server")));
	//---
	registerActionForCommand<DecryptVerifyFilesCommand>(coll->action(QStringLiteral("file_decrypt_verify_files")));
	registerActionForCommand<SignEncryptFilesCommand>(coll->action(QStringLiteral("file_sign_encrypt_files")));
	registerActionForCommand<SignEncryptFolderCommand>(coll->action(QStringLiteral("file_sign_encrypt_folder")));
	//---
	registerActionForCommand<ChecksumCreateFilesCommand>(coll->action(QStringLiteral("file_checksum_create_files")));
	registerActionForCommand<ChecksumVerifyFilesCommand>(coll->action(QStringLiteral("file_checksum_verify_files")));

	registerActionForCommand<ReloadKeysCommand>(coll->action(QStringLiteral("view_redisplay")));
	//coll->action( "view_stop_operations" ) <-- already dealt with in make_actions_from_data()
	registerActionForCommand<DetailsCommand>(coll->action(QStringLiteral("view_certificate_details")));

	registerActionForCommand<ChangeOwnerTrustCommand>(coll->action(QStringLiteral("certificates_change_owner_trust")));
	registerActionForCommand<TrustRootCommand>(coll->action(QStringLiteral("certificates_trust_root")));
	registerActionForCommand<DistrustRootCommand>(coll->action(QStringLiteral("certificates_distrust_root")));
	//---
	registerActionForCommand<CertifyCertificateCommand>(coll->action(QStringLiteral("certificates_certify_certificate")));
	if (RevokeCertificationCommand::isSupported()) {
	registerActionForCommand<RevokeCertificationCommand>(coll->action(QStringLiteral("certificates_revoke_certification")));
	}
	//---
	registerActionForCommand<ChangeExpiryCommand>(coll->action(QStringLiteral("certificates_change_expiry")));
	registerActionForCommand<ChangePassphraseCommand>(coll->action(QStringLiteral("certificates_change_passphrase")));
	registerActionForCommand<AddUserIDCommand>(coll->action(QStringLiteral("certificates_add_userid")));
	//---
	registerActionForCommand<DeleteCertificatesCommand>(coll->action(QStringLiteral("certificates_delete")));
	//---
	registerActionForCommand<DumpCertificateCommand>(coll->action(QStringLiteral("certificates_dump_certificate")));

	registerActionForCommand<RefreshX509CertsCommand>(coll->action(QStringLiteral("tools_refresh_x509_certificates")));
	registerActionForCommand<RefreshOpenPGPCertsCommand>(coll->action(QStringLiteral("tools_refresh_openpgp_certificates")));
	//---
	registerActionForCommand<ImportCrlCommand>(coll->action(QStringLiteral("crl_import_crl")));
	//---
	registerActionForCommand<ClearCrlCacheCommand>(coll->action(QStringLiteral("crl_clear_crl_cache")));
	registerActionForCommand<DumpCrlCacheCommand>(coll->action(QStringLiteral("crl_dump_crl_cache")));

	enableDisableActions(nullptr);
	}

	void KeyListController::registerAction(QAction action, Command::Restrictions restrictions, Command (create)(QAbstractItemView , KeyListController *))
	{
	if (!action) {
	return;
	}
	Q_ASSERT(!action->isCheckable()); // can be added later, for now, disallow

	const Private::action_item ai = {
	action, restrictions, create
	};
	connect(action, SIGNAL(triggered()), this, SLOT(slotActionTriggered()));
	d->actions.push_back(ai);
	}

	void KeyListController::registerCommand(Command *cmd)
	{
	if (!cmd \|\| std::binary_search(d->commands.cbegin(), d->commands.cend(), cmd)) {
	return;
	}
	d->addCommand(cmd);
	qCDebug(KLEOPATRA_LOG) << (void *)cmd;
	if (d->commands.size() == 1) {
	Q_EMIT commandsExecuting(true);
	}
	}

	bool KeyListController::hasRunningCommands() const
	{
	return !d->commands.empty();
	}

	bool KeyListController::shutdownWarningRequired() const
	{
	return std::any_of(d->commands.cbegin(), d->commands.cend(), std::mem_fn(&Command::warnWhenRunningAtShutdown));
	}

	// slot
	void KeyListController::cancelCommands()
	{
	std::for_each(d->commands.begin(), d->commands.end(), std::mem_fn(&Command::cancel));
	}

	void KeyListController::Private::connectView(QAbstractItemView *view)
	{

	connect(view, SIGNAL(destroyed(QObject*)),
	q, SLOT(slotDestroyed(QObject*)));
	connect(view, SIGNAL(doubleClicked(QModelIndex)),
	q, SLOT(slotDoubleClicked(QModelIndex)));
	connect(view, SIGNAL(activated(QModelIndex)),
	q, SLOT(slotActivated(QModelIndex)));
	connect(view->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
	q, SLOT(slotSelectionChanged(QItemSelection,QItemSelection)));

	view->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(view, SIGNAL(customContextMenuRequested(QPoint)),
	q, SLOT(slotContextMenu(QPoint)));
	}

	void KeyListController::Private::connectCommand(Command *cmd)
	{
	if (!cmd) {
	return;
	}
	connect(cmd, SIGNAL(destroyed(QObject)), q, SLOT(slotDestroyed(QObject)));
	connect(cmd, SIGNAL(finished()), q, SLOT(slotCommandFinished()));
	//connect( cmd, SIGNAL(canceled()), q, SLOT(slotCommandCanceled()) );
	connect(cmd, &Command::info, q, &KeyListController::message);
	connect(cmd, SIGNAL(progress(QString,int,int)), q, SLOT(slotProgress(QString,int,int)));
	}

	void KeyListController::Private::slotDoubleClicked(const QModelIndex &idx)
	{
	QAbstractItemView const view = qobject_cast<QAbstractItemView >(q->sender());
	if (!view \|\| !std::binary_search(views.cbegin(), views.cend(), view)) {
	return;
	}

	DetailsCommand *const c = new DetailsCommand(view, q);
	if (parentWidget) {
	c->setParentWidget(parentWidget);
	}

	c->setIndex(idx);
	c->start();
	}

	void KeyListController::Private::slotActivated(const QModelIndex &idx)
	{
	Q_UNUSED(idx)
	QAbstractItemView const view = qobject_cast<QAbstractItemView >(q->sender());
	if (!view \|\| !std::binary_search(views.cbegin(), views.cend(), view)) {
	return;
	}

	}

	void KeyListController::Private::slotSelectionChanged(const QItemSelection &old, const QItemSelection &new_)
	{
	Q_UNUSED(old)
	Q_UNUSED(new_)

	const QItemSelectionModel const sm = qobject_cast<QItemSelectionModel >(q->sender());
	if (!sm) {
	return;
	}
	q->enableDisableActions(sm);
	}

	void KeyListController::Private::slotContextMenu(const QPoint &p)
	{
	QAbstractItemView const view = qobject_cast<QAbstractItemView >(q->sender());
	if (view && std::binary_search(views.cbegin(), views.cend(), view)) {
	Q_EMIT q->contextMenuRequested(view, view->viewport()->mapToGlobal(p));
	} else {
	qCDebug(KLEOPATRA_LOG) << "sender is not a QAbstractItemView*!";
	}
	}

	void KeyListController::Private::slotCommandFinished()
	{
	Command const cmd = qobject_cast<Command >(q->sender());
	if (!cmd \|\| !std::binary_search(commands.cbegin(), commands.cend(), cmd)) {
	return;
	}
	qCDebug(KLEOPATRA_LOG) << (void *)cmd;
	if (commands.size() == 1) {
	Q_EMIT q->commandsExecuting(false);
	}
	}

	void KeyListController::enableDisableActions(const QItemSelectionModel *sm) const
	{
	const Command::Restrictions restrictionsMask = d->calculateRestrictionsMask(sm);
	for (const Private::action_item &ai : std::as_const(d->actions))
	if (ai.action) {
	ai.action->setEnabled(ai.restrictions == (ai.restrictions & restrictionsMask));
	}
	}

	static bool all_secret_are_not_owner_trust_ultimate(const std::vector<Key> &keys)
	{
	for (const Key &key : keys)
	if (key.hasSecret() && key.ownerTrust() == Key::Ultimate) {
	return false;
	}
	return true;
	}

	Command::Restrictions find_root_restrictions(const std::vector<Key> &keys)
	{
	bool trusted = false, untrusted = false;
	for (const Key &key : keys)
	if (key.isRoot())
	if (key.userID(0).validity() == UserID::Ultimate) {
	trusted = true;
	} else {
	untrusted = true;
	}
	else {
	return Command::NoRestriction;
	}
	if (trusted)
	if (untrusted) {
	return Command::NoRestriction;
	} else {
	return Command::MustBeTrustedRoot;
	}
	else if (untrusted) {
	return Command::MustBeUntrustedRoot;
	} else {
	return Command::NoRestriction;
	}
	}

	Command::Restrictions KeyListController::Private::calculateRestrictionsMask(const QItemSelectionModel *sm)
	{
	if (!sm) {
	return Command::NoRestriction;
	}

	const KeyListModelInterface const m = dynamic_cast<const KeyListModelInterface >(sm->model());
	if (!m) {
	return Command::NoRestriction;
	}

	const std::vector<Key> keys = m->keys(sm->selectedRows());
	if (keys.empty()) {
	return Command::NoRestriction;
	}

	Command::Restrictions result = Command::NeedSelection;

	if (keys.size() == 1) {
	result \|= Command::OnlyOneKey;
	}

	if (std::all_of(keys.cbegin(), keys.cend(), std::mem_fn(&Key::hasSecret))) {
	result \|= Command::NeedSecretKey;
	} else if (!std::any_of(keys.cbegin(), keys.cend(), std::mem_fn(&Key::hasSecret))) {
	result \|= Command::MustNotBeSecretKey;
	}

	if (std::all_of(keys.cbegin(), keys.cend(), [](const Key &key) { return key.protocol() == OpenPGP; })) {
	result \|= Command::MustBeOpenPGP;
	} else if (std::all_of(keys.cbegin(), keys.cend(), [](const Key &key) { return key.protocol() == CMS; })) {
	result \|= Command::MustBeCMS;
	}

	if (all_secret_are_not_owner_trust_ultimate(keys)) {
	result \|= Command::MayOnlyBeSecretKeyIfOwnerTrustIsNotYetUltimate;
	}

	result \|= find_root_restrictions(keys);

	if (const ReaderStatus *rs = ReaderStatus::instance()) {
	if (!rs->firstCardWithNullPin().empty()) {
	result \|= Command::AnyCardHasNullPin;
	}
	if (rs->anyCardCanLearnKeys()) {
	result \|= Command::AnyCardCanLearnKeys;
	}
	}

	return result;
	}

	void KeyListController::Private::slotActionTriggered()
	{
	if (const QObject *const s = q->sender()) {
	const auto it = std::find_if(actions.cbegin(), actions.cend(),
	[this](const action_item &item) { return item.action == q->sender(); });
	if (it != actions.end())
	if (Command *const c = it->createCommand(this->currentView, q)) {
	if (parentWidget) {
	c->setParentWidget(parentWidget);
	}
	c->start();
	} else
	qCDebug(KLEOPATRA_LOG) << "createCommand() == NULL for action(?) \""
	<< qPrintable(s->objectName()) << "\"";
	else {
	qCDebug(KLEOPATRA_LOG) << "I don't know anything about action(?) \"%s\"", qPrintable(s->objectName());
	}
	} else {
	qCDebug(KLEOPATRA_LOG) << "not called through a signal/slot connection (sender() == NULL)";
	}
	}

	int KeyListController::Private::toolTipOptions() const
	{
	using namespace Kleo::Formatting;
	static const int validityFlags = Validity \| Issuer \| ExpiryDates \| CertificateUsage;
	static const int ownerFlags = Subject \| UserIDs \| OwnerTrust;
	static const int detailsFlags = StorageLocation \| CertificateType \| SerialNumber \| Fingerprint;

	const TooltipPreferences prefs;

	int flags = KeyID;
	flags \|= prefs.showValidity() ? validityFlags : 0;
	flags \|= prefs.showOwnerInformation() ? ownerFlags : 0;
	flags \|= prefs.showCertificateDetails() ? detailsFlags : 0;
	return flags;
	}

	void KeyListController::updateConfig()
	{
	const int opts = d->toolTipOptions();
	if (d->flatModel) {
	d->flatModel->setToolTipOptions(opts);
	}
	if (d->hierarchicalModel) {
	d->hierarchicalModel->setToolTipOptions(opts);
	}
	}

	#include "moc_keylistcontroller.cpp"

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 3:33 PM (1 d, 42 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: f1/b8/8183d8389b7814a3992f1461dd12

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions