No OneTemporary
Actions

Size

95 KB

Subscribers

None

View Options

	diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
	index 6d077ca90..eec3baf7f 100644
	--- a/src/mainwindow.cpp
	+++ b/src/mainwindow.cpp
	@@ -1,719 +1,719 @@
	/* -- 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 "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/GnuPG>
	#include <Libkleo/KeyListModel>
	#include <Libkleo/KeyListSortFilterProxyModel>
	#include <Libkleo/Stl_Util>
	#include <Libkleo/Classify>
	#include <Libkleo/KeyCache>
	#include <Libkleo/DocAction>

	#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().displayName();
	KGuiItem item = KStandardGuiItem::quit();
	item.setText(xi18nc("@action:button", "&Quit <application>%1</application>", app));
	return item;
	}

	static KGuiItem KStandardGuiItem_close()
	{
	KGuiItem item = KStandardGuiItem::close();
	item.setText(i18nc("@action:button", "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().displayName();
	const int rc = KMessageBox::questionYesNoCancel(q,
	xi18n("<application>%1</application> may be used by other applications as a service.<nl/>"
	"You may instead want to close this window without exiting <application>%1</application>.", app),
	i18nc("@title:window", "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::NormalText: 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()
	{
	const QString exec =
	QStandardPaths::findExecutable(QStringLiteral("kwatchgnupg"));
	if (exec.isEmpty()) {
	KMessageBox::error(
	q,
	i18n("Could not start the GnuPG Log Viewer (kwatchgnupg). "
	"Please check your installation."),
	i18n("Error Starting KWatchGnuPG"));
	} else {
	QProcess::startDetached(QStringLiteral("kwatchgnupg"), QStringList());
	}
	}

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

	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 restartDaemons()
	{
	Kleo::killDaemons();
	}

	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();

	if (KeyCache::instance()->initialized()) {
	keyListingDone();
	}
	}

	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 std::vector<action_data> action_data = {
	// see keylistcontroller.cpp for more actions
	// Tools menu
	#ifndef Q_OS_WIN
	{
	"tools_start_kwatchgnupg", i18n("GnuPG Log Viewer"), QString(),
	- "kwatchgnupg", q, SLOT(gnupgLogViewer()), QString(), false, true
	+ "kwatchgnupg", q, [this](bool) { gnupgLogViewer(); }, QString(), false, true
	},
	#endif
	{
	"tools_restart_backend", i18nc("@action:inmenu", "Restart Background Processes"),
	i18nc("@info:tooltip", "Restart the background processes, e.g. after making changes to the configuration."),
	- "view-refresh", q, SLOT(restartDaemons()), {}, false, true
	+ "view-refresh", q, [this](bool) { restartDaemons(); }, {}, false, true
	},
	// Help menu
	#ifdef Q_OS_WIN
	{
	"help_check_updates", i18n("Check for updates"), QString(),
	- "gpg4win-compact", q, SLOT(forceUpdateCheck()), QString(), false, true
	+ "gpg4win-compact", q, [this](bool) { forceUpdateCheck(); }, QString(), false, true
	},
	#endif
	// View menu
	{
	"view_certificate_overview", i18nc("@action show certificate overview", "Certificates"),
	- i18n("Show certificate overview"), "view-certificate", q, SLOT(showCertificateView()), QString(), false, true
	+ i18n("Show certificate overview"), "view-certificate", q, [this](bool) { 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
	+ i18n("Show pad for encrypting/decrypting and signing/verifying text"), "note", q, [this](bool) { showPadView(); }, 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
	+ i18n("Show smartcard management"), "auth-sim-locked", q, [this](bool) { showSmartcardView(); }, QString(), false, true
	},
	// Settings menu
	{
	"settings_self_test", i18n("Perform Self-Test"), QString(),
	- nullptr, q, SLOT(selfTest()), QString(), false, true
	+ nullptr, q, [this](bool) { selfTest(); }, QString(), false, true
	},
	{
	"configure_groups", i18n("Configure Groups..."), QString(),
	- "group", q, SLOT(configureGroups()), QString(), false, true
	+ "group", q, [this](bool) { configureGroups(); }, QString(), false, true
	}
	};

	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);
	}
	}

	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());

	/* Add additional help actions for documentation */
	const auto compendium = new DocAction(QIcon::fromTheme(QStringLiteral("gpg4win-compact")), i18n("Gpg4win Compendium"),
	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"),
	QStringLiteral("../share/gpg4win"));
	coll->addAction(QStringLiteral("help_doc_compendium"), compendium);

	/* Documentation centered around the german approved VS-NfD mode for official
	* RESTRICTED communication. This is only available in some distributions with
	* the focus on official communications. */
	const auto symguide = new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")), i18n("Password-based encryption"),
	i18nc("Only available in German and English. Leave to English for other languages.",
	"handout_symmetric_encryption_gnupg_en.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"));
	coll->addAction(QStringLiteral("help_doc_symenc"), symguide);

	const auto quickguide = new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")), i18n("Quickguide"),
	i18nc("Only available in German and English. Leave to English for other languages.",
	"handout_sign_encrypt_gnupg_en.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"));
	coll->addAction(QStringLiteral("help_doc_quickguide"), quickguide);

	const auto vsa10573 = new DocAction(QIcon::fromTheme(QStringLiteral("dvipdf")), i18n("SecOps VSA-10573"),
	i18nc("Only available in German and English. Leave to English for other languages.",
	"BSI-VSA-10573-ENG_secops-20220207.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"));
	coll->addAction(QStringLiteral("help_doc_vsa10573"), vsa10573);

	const auto vsa10584 = new DocAction(QIcon::fromTheme(QStringLiteral("dvipdf")), i18n("SecOps VSA-10584"),
	i18nc("Only available in German and English. Leave to English for other languages.",
	"BSI-VSA-10584-ENG_secops-20220207.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"));
	coll->addAction(QStringLiteral("help_doc_vsa10584"), vsa10584);

	const auto man_gpg = new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")), i18n("GnuPG Manual"),
	QStringLiteral("gnupg.pdf"), QStringLiteral("../share/doc/gnupg"));
	coll->addAction(QStringLiteral("help_doc_gnupg"), man_gpg);

	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/mainwindow.h b/src/mainwindow.h
	index f166bb2e9..7128bdbfc 100644
	--- a/src/mainwindow.h
	+++ b/src/mainwindow.h
	@@ -1,57 +1,50 @@
	/* -- mode: c++; c-basic-offset:4 --
	mainwindow.h

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

	SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
	SPDX-FileContributor: Intevation GmbH

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

	#pragma once

	#include <KXmlGuiWindow>

	#include <utils/pimpl_ptr.h>

	class MainWindow : public KXmlGuiWindow
	{
	Q_OBJECT
	public:
	explicit MainWindow(QWidget *parent = nullptr, Qt::WindowFlags f = {});
	~MainWindow() override;

	public Q_SLOTS:
	void importCertificatesFromFile(const QStringList &files);

	protected:
	QByteArray savedGeometry;

	void closeEvent(QCloseEvent *e) override;
	void showEvent(QShowEvent *e) override;
	void hideEvent(QHideEvent *e) override;
	void dragEnterEvent(QDragEnterEvent *) override;
	void dropEvent(QDropEvent *) override;
	void readProperties(const KConfigGroup &cg) override;
	void saveProperties(KConfigGroup &cg) override;

	private:
	class Private;
	kdtools::pimpl_ptr<Private> d;
	Q_PRIVATE_SLOT(d, void closeAndQuit())
	- Q_PRIVATE_SLOT(d, void selfTest())
	Q_PRIVATE_SLOT(d, void configureToolbars())
	- Q_PRIVATE_SLOT(d, void configureGroups())
	Q_PRIVATE_SLOT(d, void editKeybindings())
	- Q_PRIVATE_SLOT(d, void gnupgLogViewer())
	Q_PRIVATE_SLOT(d, void slotConfigCommitted())
	Q_PRIVATE_SLOT(d, void slotContextMenuRequested(QAbstractItemView *, QPoint))
	Q_PRIVATE_SLOT(d, void slotFocusQuickSearch())
	- Q_PRIVATE_SLOT(d, void showCertificateView())
	Q_PRIVATE_SLOT(d, void showPadView())
	- Q_PRIVATE_SLOT(d, void showSmartcardView())
	- Q_PRIVATE_SLOT(d, void forceUpdateCheck())
	- Q_PRIVATE_SLOT(d, void restartDaemons())
	};
	diff --git a/src/utils/action_data.cpp b/src/utils/action_data.cpp
	index d26066ce6..e7b5e6ed8 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.receiver && ad.func) {
	if (ad.toggle) {
	- QObject::connect(a, SIGNAL(toggled(bool)), ad.receiver, ad.slot);
	+ QObject::connect(a, &KToggleAction::toggled, ad.receiver, ad.func);
	} else {
	- QObject::connect(a, SIGNAL(triggered()), ad.receiver, ad.slot);
	+ QObject::connect(a, &QAction::triggered, ad.receiver, ad.func);
	}
	}
	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 std::vector<action_data> &data, KActionCollection *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 eff238434..519616f86 100644
	--- a/src/utils/action_data.h
	+++ b/src/utils/action_data.h
	@@ -1,39 +1,41 @@
	/* -- 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>
	+
	+#include <functional>
	#include <vector>

	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;
	+ std::function<void(bool)> func;
	QString shortcut;
	bool toggle;
	bool enabled;
	};

	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 c7c4ebe7f..d1cf5d88d 100644
	--- a/src/view/keylistcontroller.cpp
	+++ b/src/view/keylistcontroller.cpp
	@@ -1,862 +1,862 @@
	/* -- 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-FileCopyrightText: 2022 Felix Tiede

	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 <settings.h>
	#include "tooltippreferences.h"
	#include "kleopatra_debug.h"
	#include "commands/exportcertificatecommand.h"
	#include "commands/exportopenpgpcertstoservercommand.h"
	#ifdef MAILAKONADI_ENABLED
	#include "commands/exportopenpgpcerttoprovidercommand.h"
	#endif // MAILAKONADI_ENABLED
	#ifdef QGPGME_SUPPORTS_SECRET_KEY_EXPORT
	# include "commands/exportsecretkeycommand.h"
	#else
	# include "commands/exportsecretkeycommand_old.h"
	#endif
	#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 "commands/revokekeycommand.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>
	#include <iterator>

	// needed for GPGME_VERSION_NUMBER
	#include <gpgme.h>

	using namespace Kleo;
	using namespace Kleo::Commands;
	using namespace Kleo::SmartCard;
	using namespace GpgME;
	#ifndef QGPGME_SUPPORTS_SECRET_KEY_EXPORT
	using Kleo::Commands::Compat::ExportSecretKeyCommand;
	#endif

	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::instance().get(), &KeyCache::added, q, [this](const GpgME::Key &key) { slotAddKey(key); });
	connect(KeyCache::instance().get(), &KeyCache::aboutToRemove, q, [this](const GpgME::Key &key) { slotAboutToRemoveKey(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 std::vector<action_data> common_and_openpgp_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
	},
	#ifdef MAILAKONADI_ENABLED
	{
	"file_export_certificate_to_provider", i18n("Publish at Mail Provider..."), i18n("Publish the selected certificate (public key) at mail provider's Web Key Directory if offered"),
	"view-certificate-export", nullptr, nullptr, QString(), false, true
	},
	#endif // MAILAKONADI_ENABLED
	{
	"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
	+ "process-stop", this, [this](bool) { cancelCommands(); }, QStringLiteral("Escape"), false, false
	},
	{
	"view_certificate_details", i18n("Details"), QString(),
	"dialog-information", nullptr, nullptr, QString(), false, true
	},
	// Certificate menu
	#ifdef QGPGME_SUPPORTS_KEY_REVOCATION
	{
	"certificates_revoke", i18n("Revoke Certificate..."), i18n("Revoke the selected OpenPGP certificate"),
	"view-certificate-revoke", nullptr, nullptr, {}, false, true
	},
	#endif
	{
	"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_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
	},
	// Tools menu
	{
	"tools_refresh_openpgp_certificates", i18n("Refresh OpenPGP Certificates"), QString(),
	"view-refresh", nullptr, nullptr, QString(), false, true
	},
	// Window menu
	// (come from TabWidget)
	// Help menu
	// (come from MainWindow)
	};

	static const std::vector<action_data> cms_action_data = {
	// Certificate menu
	{
	"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_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
	},
	{
	"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
	},
	};

	std::vector<action_data> action_data = common_and_openpgp_action_data;

	if (Settings{}.cmsEnabled()) {
	action_data.reserve(action_data.size() + cms_action_data.size());
	std::copy(std::begin(cms_action_data), std::end(cms_action_data),
	std::back_inserter(action_data));
	}

	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")));
	#ifdef MAILAKONADI_ENABLED
	registerActionForCommand<ExportOpenPGPCertToProviderCommand>(coll->action(QStringLiteral("file_export_certificate_to_provider")));
	#endif // MAILAKONADI_ENABLED
	//---
	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")));
	//---
	#ifdef QGPGME_SUPPORTS_KEY_REVOCATION
	registerActionForCommand<RevokeKeyCommand>(coll->action(QStringLiteral("certificates_revoke")));
	#endif
	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, &QObject::destroyed, q, [this](QObject *obj) { slotDestroyed(obj); });
	connect(view, &QAbstractItemView::doubleClicked, q, [this](const QModelIndex &index) { slotDoubleClicked(index); });
	connect(view, &QAbstractItemView::activated, q, [this](const QModelIndex &index) { slotActivated(index); });
	connect(view->selectionModel(), &QItemSelectionModel::selectionChanged,
	q, [this](const QItemSelection &oldSel, const QItemSelection &newSel) {
	slotSelectionChanged(oldSel, newSel);
	});

	view->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(view, &QWidget::customContextMenuRequested, q, [this](const QPoint &pos) { slotContextMenu(pos); });
	}

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

	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 GPGME_VERSION_NUMBER >= 0x011102 // 1.17.2
	// we need to check the primary subkey because Key::hasSecret() is also true if just the secret key stub of an offline key is available
	const auto primaryKeyCanBeUsedForSecretKeyOperations = [](const auto &k) { return k.subkey(0).isSecret(); };
	#else
	// older versions of GpgME did not always set the secret flag for card keys
	const auto primaryKeyCanBeUsedForSecretKeyOperations = [](const auto &k) { return k.subkey(0).isSecret() \|\| k.subkey(0).isCardKey(); };
	#endif
	if (std::all_of(keys.cbegin(), keys.cend(), primaryKeyCanBeUsedForSecretKeyOperations)) {
	result \|= Command::NeedSecretKey;
	}

	if (std::all_of(std::begin(keys), std::end(keys), [](const auto &k) { return k.subkey(0).isSecret() && !k.subkey(0).isCardKey(); })) {
	result \|= Command::NeedSecretKeyData;
	}

	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"
	diff --git a/src/view/tabwidget.cpp b/src/view/tabwidget.cpp
	index b71bb7d8b..dd5fae510 100644
	--- a/src/view/tabwidget.cpp
	+++ b/src/view/tabwidget.cpp
	@@ -1,1004 +1,1004 @@
	/* -- mode: c++; c-basic-offset:4 --
	view/tabwidget.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 "searchbar.h"
	#include "tabwidget.h"
	#include "keytreeview.h"
	#include "kleopatra_debug.h"

	#include <settings.h>

	#include <utils/action_data.h>

	#include <Libkleo/Stl_Util>
	#include <Libkleo/KeyFilter>
	#include <Libkleo/KeyFilterManager>
	#include <Libkleo/KeyListModel>
	#include <Libkleo/KeyListSortFilterProxyModel>

	#include <gpgme++/key.h>

	#include <KLocalizedString>
	#include <QTabWidget>
	#include <KConfigGroup>
	#include <KSharedConfig>
	#include <KConfig>
	#include <QAction>
	#include <KActionCollection>
	#include <QInputDialog>

	#include <QTreeView>
	#include <QToolButton>
	#include <QMenu>
	#include <QVBoxLayout>
	#include <QRegularExpression>
	#include <QAbstractProxyModel>

	#include <map>

	using namespace Kleo;
	using namespace GpgME;

	namespace
	{

	class Page : public Kleo::KeyTreeView
	{
	Q_OBJECT
	Page(const Page &other);
	public:
	Page(const QString &title, const QString &id, const QString &text, AbstractKeyListSortFilterProxyModel proxy = nullptr, const QString &toolTip = QString(), QWidget parent = nullptr, const KConfigGroup &group = KConfigGroup());
	Page(const KConfigGroup &group, QWidget *parent = nullptr);
	~Page() override;

	void setTemporary(bool temporary);
	bool isTemporary() const
	{
	return m_isTemporary;
	}

	void setHierarchicalView(bool hierarchical) override;
	void setStringFilter(const QString &filter) override;
	void setKeyFilter(const std::shared_ptr<KeyFilter> &filter) override;

	QString title() const
	{
	return m_title.isEmpty() && keyFilter() ? keyFilter()->name() : m_title;
	}
	void setTitle(const QString &title);

	QString toolTip() const
	{
	return m_toolTip.isEmpty() ? title() : m_toolTip;
	}
	// not used void setToolTip(const QString &tip);

	bool canBeClosed() const
	{
	return m_canBeClosed;
	}
	bool canBeRenamed() const
	{
	return m_canBeRenamed;
	}
	bool canChangeStringFilter() const
	{
	return m_canChangeStringFilter;
	}
	bool canChangeKeyFilter() const
	{
	return m_canChangeKeyFilter && !m_isTemporary;
	}
	bool canChangeHierarchical() const
	{
	return m_canChangeHierarchical;
	}

	void saveTo(KConfigGroup &group) const;

	Page *clone() const override
	{
	return new Page(*this);
	}

	void liftAllRestrictions()
	{
	m_canBeClosed = m_canBeRenamed = m_canChangeStringFilter = m_canChangeKeyFilter = m_canChangeHierarchical = true;
	}

	Q_SIGNALS:
	void titleChanged(const QString &title);

	private:
	void init();

	private:
	QString m_title;
	QString m_toolTip;
	bool m_isTemporary : 1;
	bool m_canBeClosed : 1;
	bool m_canBeRenamed : 1;
	bool m_canChangeStringFilter : 1;
	bool m_canChangeKeyFilter : 1;
	bool m_canChangeHierarchical : 1;
	};
	} // anon namespace

	Page::Page(const Page &other)
	: KeyTreeView(other),
	m_title(other.m_title),
	m_toolTip(other.m_toolTip),
	m_isTemporary(other.m_isTemporary),
	m_canBeClosed(other.m_canBeClosed),
	m_canBeRenamed(other.m_canBeRenamed),
	m_canChangeStringFilter(other.m_canChangeStringFilter),
	m_canChangeKeyFilter(other.m_canChangeKeyFilter),
	m_canChangeHierarchical(other.m_canChangeHierarchical)
	{
	init();
	}

	Page::Page(const QString &title, const QString &id, const QString &text, AbstractKeyListSortFilterProxyModel proxy, const QString &toolTip, QWidget parent,
	const KConfigGroup &group)
	: KeyTreeView(text, KeyFilterManager::instance()->keyFilterByID(id), proxy, parent, group),
	m_title(title),
	m_toolTip(toolTip),
	m_isTemporary(false),
	m_canBeClosed(true),
	m_canBeRenamed(true),
	m_canChangeStringFilter(true),
	m_canChangeKeyFilter(true),
	m_canChangeHierarchical(true)
	{
	init();
	}

	static const char TITLE_ENTRY[] = "title";
	static const char STRING_FILTER_ENTRY[] = "string-filter";
	static const char KEY_FILTER_ENTRY[] = "key-filter";
	static const char HIERARCHICAL_VIEW_ENTRY[] = "hierarchical-view";
	static const char COLUMN_SIZES[] = "column-sizes";
	static const char SORT_COLUMN[] = "sort-column";
	static const char SORT_DESCENDING[] = "sort-descending";

	Page::Page(const KConfigGroup &group, QWidget *parent)
	: KeyTreeView(group.readEntry(STRING_FILTER_ENTRY),
	KeyFilterManager::instance()->keyFilterByID(group.readEntry(KEY_FILTER_ENTRY)),
	nullptr, parent, group),
	m_title(group.readEntry(TITLE_ENTRY)),
	m_toolTip(),
	m_isTemporary(false),
	m_canBeClosed(!group.isImmutable()),
	m_canBeRenamed(!group.isEntryImmutable(TITLE_ENTRY)),
	m_canChangeStringFilter(!group.isEntryImmutable(STRING_FILTER_ENTRY)),
	m_canChangeKeyFilter(!group.isEntryImmutable(KEY_FILTER_ENTRY)),
	m_canChangeHierarchical(!group.isEntryImmutable(HIERARCHICAL_VIEW_ENTRY))
	{
	init();
	setHierarchicalView(group.readEntry(HIERARCHICAL_VIEW_ENTRY, true));
	const QList<int> settings = group.readEntry(COLUMN_SIZES, QList<int>());
	std::vector<int> sizes;
	sizes.reserve(settings.size());
	std::copy(settings.cbegin(), settings.cend(), std::back_inserter(sizes));
	setColumnSizes(sizes);
	setSortColumn(group.readEntry(SORT_COLUMN, 0),
	group.readEntry(SORT_DESCENDING, true) ? Qt::DescendingOrder : Qt::AscendingOrder);
	}

	void Page::init()
	{

	}

	Page::~Page() {}

	void Page::saveTo(KConfigGroup &group) const
	{

	group.writeEntry(TITLE_ENTRY, m_title);
	group.writeEntry(STRING_FILTER_ENTRY, stringFilter());
	group.writeEntry(KEY_FILTER_ENTRY, keyFilter() ? keyFilter()->id() : QString());
	group.writeEntry(HIERARCHICAL_VIEW_ENTRY, isHierarchicalView());
	QList<int> settings;
	const auto sizes = columnSizes();
	settings.reserve(sizes.size());
	std::copy(sizes.cbegin(), sizes.cend(), std::back_inserter(settings));
	group.writeEntry(COLUMN_SIZES, settings);
	group.writeEntry(SORT_COLUMN, sortColumn());
	group.writeEntry(SORT_DESCENDING, sortOrder() == Qt::DescendingOrder);
	}

	void Page::setStringFilter(const QString &filter)
	{
	if (!m_canChangeStringFilter) {
	return;
	}
	KeyTreeView::setStringFilter(filter);
	}

	void Page::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
	{
	if (!canChangeKeyFilter()) {
	return;
	}
	const QString oldTitle = title();
	KeyTreeView::setKeyFilter(filter);
	const QString newTitle = title();
	if (oldTitle != newTitle) {
	Q_EMIT titleChanged(newTitle);
	}
	}

	void Page::setTitle(const QString &t)
	{
	if (t == m_title) {
	return;
	}
	if (!m_canBeRenamed) {
	return;
	}
	const QString oldTitle = title();
	m_title = t;
	const QString newTitle = title();
	if (oldTitle != newTitle) {
	Q_EMIT titleChanged(newTitle);
	}
	}

	#if 0 // not used
	void Page::setToolTip(const QString &tip)
	{
	if (tip == m_toolTip) {
	return;
	}
	if (!m_canBeRenamed) {
	return;
	}
	const QString oldTip = toolTip();
	m_toolTip = tip;
	const QString newTip = toolTip();
	if (oldTip != newTip) {
	Q_EMIT titleChanged(title());
	}
	}
	#endif

	void Page::setHierarchicalView(bool on)
	{
	if (!m_canChangeHierarchical) {
	return;
	}
	KeyTreeView::setHierarchicalView(on);
	}

	void Page::setTemporary(bool on)
	{
	if (on == m_isTemporary) {
	return;
	}
	m_isTemporary = on;
	if (on) {
	setKeyFilter(std::shared_ptr<KeyFilter>());
	}
	}

	namespace
	{
	class Actions
	{
	public:
	constexpr static const char *Rename = "window_rename_tab";
	constexpr static const char *Duplicate = "window_duplicate_tab";
	constexpr static const char *Close = "window_close_tab";
	constexpr static const char *MoveLeft = "window_move_tab_left";
	constexpr static const char *MoveRight = "window_move_tab_right";
	constexpr static const char *Hierarchical = "window_view_hierarchical";
	constexpr static const char *ExpandAll = "window_expand_all";
	constexpr static const char *CollapseAll = "window_collapse_all";

	explicit Actions() {}

	void insert(const std::string &name, QAction *action)
	{
	actions.insert({name, action});
	}

	auto get(const std::string &name) const
	{
	const auto it = actions.find(name);
	return (it != actions.end()) ? it->second : nullptr;
	}

	void setChecked(const std::string &name, bool checked) const
	{
	if (auto action = get(name)) {
	action->setChecked(checked);
	}
	}

	void setEnabled(const std::string &name, bool enabled) const
	{
	if (auto action = get(name)) {
	action->setEnabled(enabled);
	}
	}

	void setVisible(const std::string &name, bool visible) const
	{
	if (auto action = get(name)) {
	action->setVisible(visible);
	}
	}

	private:
	std::map<std::string, QAction *> actions;
	};
	}

	//
	//
	// TabWidget
	//
	//

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

	private:
	void slotContextMenu(const QPoint &p);
	void currentIndexChanged(int index);
	void slotPageTitleChanged(const QString &title);
	void slotPageKeyFilterChanged(const std::shared_ptr<KeyFilter> &filter);
	void slotPageStringFilterChanged(const QString &filter);
	void slotPageHierarchyChanged(bool on);

	#ifndef QT_NO_INPUTDIALOG
	void slotRenameCurrentTab()
	{
	renamePage(currentPage());
	}
	#endif // QT_NO_INPUTDIALOG
	void slotNewTab();
	void slotDuplicateCurrentTab()
	{
	duplicatePage(currentPage());
	}
	void slotCloseCurrentTab()
	{
	closePage(currentPage());
	}
	void slotMoveCurrentTabLeft()
	{
	movePageLeft(currentPage());
	}
	void slotMoveCurrentTabRight()
	{
	movePageRight(currentPage());
	}
	void slotToggleHierarchicalView(bool on)
	{
	toggleHierarchicalView(currentPage(), on);
	}
	void slotExpandAll()
	{
	expandAll(currentPage());
	}
	void slotCollapseAll()
	{
	collapseAll(currentPage());
	}

	#ifndef QT_NO_INPUTDIALOG
	void renamePage(Page *page);
	#endif
	void duplicatePage(Page *page);
	void closePage(Page *page);
	void movePageLeft(Page *page);
	void movePageRight(Page *page);
	void toggleHierarchicalView(Page *page, bool on);
	void expandAll(Page *page);
	void collapseAll(Page *page);

	void enableDisableCurrentPageActions();
	void enableDisablePageActions(const Actions &actions, const Page *page);

	Page *currentPage() const
	{
	Q_ASSERT(!tabWidget->currentWidget() \|\| qobject_cast<Page *>(tabWidget->currentWidget()));
	return static_cast<Page *>(tabWidget->currentWidget());
	}
	Page *page(unsigned int idx) const
	{
	Q_ASSERT(!tabWidget->widget(idx) \|\| qobject_cast<Page *>(tabWidget->widget(idx)));
	return static_cast<Page *>(tabWidget->widget(idx));
	}

	Page *senderPage() const
	{
	QObject *const sender = q->sender();
	Q_ASSERT(!sender \|\| qobject_cast<Page *>(sender));
	return static_cast<Page *>(sender);
	}

	bool isSenderCurrentPage() const
	{
	Page *const sp = senderPage();
	return sp && sp == currentPage();
	}

	QTreeView addView(Page page, Page *columnReference);

	private:
	AbstractKeyListModel *flatModel = nullptr;
	AbstractKeyListModel *hierarchicalModel = nullptr;
	QToolButton *newTabButton = nullptr;
	QToolButton *closeTabButton = nullptr;
	QTabWidget *tabWidget = nullptr;
	QAction *newAction = nullptr;
	Actions currentPageActions;
	Actions otherPageActions;
	bool actionsCreated = false;
	};

	TabWidget::Private::Private(TabWidget *qq)
	: q{qq}
	{
	auto layout = new QVBoxLayout{q};
	layout->setContentsMargins(0, 0, 0, 0);

	// create "New Tab" button before tab widget to ensure correct tab order
	newTabButton = new QToolButton{q};

	tabWidget = new QTabWidget{q};
	KDAB_SET_OBJECT_NAME(tabWidget);

	layout->addWidget(tabWidget);

	tabWidget->setMovable(true);

	tabWidget->tabBar()->setContextMenuPolicy(Qt::CustomContextMenu);

	// create "Close Tab" button after tab widget to ensure correct tab order
	closeTabButton = new QToolButton{q};

	connect(tabWidget, &QTabWidget::currentChanged, q, [this](int index) { currentIndexChanged(index); });
	connect(tabWidget->tabBar(), &QWidget::customContextMenuRequested, q, [this](const QPoint & p) {
	slotContextMenu(p);
	});
	}

	void TabWidget::Private::slotContextMenu(const QPoint &p)
	{
	const int tabUnderPos = tabWidget->tabBar()->tabAt(p);
	Page const contextMenuPage = static_cast<Page >(tabWidget->widget(tabUnderPos));
	const Page *const current = currentPage();

	const auto actions = contextMenuPage == current ? currentPageActions : otherPageActions;

	enableDisablePageActions(actions, contextMenuPage);

	QMenu menu;
	if (auto action = actions.get(Actions::Rename)) {
	menu.addAction(action);
	}
	menu.addSeparator();
	menu.addAction(newAction);
	if (auto action = actions.get(Actions::Duplicate)) {
	menu.addAction(action);
	}
	menu.addSeparator();
	if (auto action = actions.get(Actions::MoveLeft)) {
	menu.addAction(action);
	}
	if (auto action = actions.get(Actions::MoveRight)) {
	menu.addAction(action);
	}
	menu.addSeparator();
	if (auto action = actions.get(Actions::Close)) {
	menu.addAction(action);
	}

	const QAction *const action = menu.exec(tabWidget->tabBar()->mapToGlobal(p));
	if (!action) {
	return;
	}

	if (contextMenuPage == current \|\| action == newAction) {
	return; // performed through signal/slot connections...
	}

	#ifndef QT_NO_INPUTDIALOG
	if (action == otherPageActions.get(Actions::Rename)) {
	renamePage(contextMenuPage);
	}
	#endif // QT_NO_INPUTDIALOG
	else if (action == otherPageActions.get(Actions::Duplicate)) {
	duplicatePage(contextMenuPage);
	} else if (action == otherPageActions.get(Actions::Close)) {
	closePage(contextMenuPage);
	} else if (action == otherPageActions.get(Actions::MoveLeft)) {
	movePageLeft(contextMenuPage);
	} else if (action == otherPageActions.get(Actions::MoveRight)) {
	movePageRight(contextMenuPage);
	}
	}

	void TabWidget::Private::currentIndexChanged(int index)
	{
	const Page *const page = this->page(index);
	Q_EMIT q->currentViewChanged(page ? page->view() : nullptr);
	Q_EMIT q->keyFilterChanged(page ? page->keyFilter() : std::shared_ptr<KeyFilter>());
	Q_EMIT q->stringFilterChanged(page ? page->stringFilter() : QString());
	enableDisableCurrentPageActions();
	}

	void TabWidget::Private::enableDisableCurrentPageActions()
	{
	const Page *const page = currentPage();

	Q_EMIT q->enableChangeStringFilter(page && page->canChangeStringFilter());
	Q_EMIT q->enableChangeKeyFilter(page && page->canChangeKeyFilter());

	enableDisablePageActions(currentPageActions, page);
	}

	void TabWidget::Private::enableDisablePageActions(const Actions &actions, const Page *p)
	{
	actions.setEnabled(Actions::Rename, p && p->canBeRenamed());
	actions.setEnabled(Actions::Duplicate, p);
	actions.setEnabled(Actions::Close, p && p->canBeClosed() && tabWidget->count() > 1);
	actions.setEnabled(Actions::MoveLeft, p && tabWidget->indexOf(const_cast<Page *>(p)) != 0);
	actions.setEnabled(Actions::MoveRight, p && tabWidget->indexOf(const_cast<Page *>(p)) != tabWidget->count() - 1);
	actions.setEnabled(Actions::Hierarchical, p && p->canChangeHierarchical());
	actions.setChecked(Actions::Hierarchical, p && p->isHierarchicalView());
	actions.setVisible(Actions::Hierarchical, Kleo::Settings{}.cmsEnabled());
	actions.setEnabled(Actions::ExpandAll, p && p->isHierarchicalView());
	actions.setEnabled(Actions::CollapseAll, p && p->isHierarchicalView());
	}

	void TabWidget::Private::slotPageTitleChanged(const QString &)
	{
	if (Page *const page = senderPage()) {
	const int idx = tabWidget->indexOf(page);
	tabWidget->setTabText(idx, page->title());
	tabWidget->setTabToolTip(idx, page->toolTip());
	}
	}

	void TabWidget::Private::slotPageKeyFilterChanged(const std::shared_ptr<KeyFilter> &kf)
	{
	if (isSenderCurrentPage()) {
	Q_EMIT q->keyFilterChanged(kf);
	}
	}

	void TabWidget::Private::slotPageStringFilterChanged(const QString &filter)
	{
	if (isSenderCurrentPage()) {
	Q_EMIT q->stringFilterChanged(filter);
	}
	}

	void TabWidget::Private::slotPageHierarchyChanged(bool)
	{
	enableDisableCurrentPageActions();
	}

	void TabWidget::Private::slotNewTab()
	{
	const KConfigGroup group = KSharedConfig::openConfig()->group(QString::asprintf("View #%u", tabWidget->count()));
	Page *page = new Page(QString(), QStringLiteral("all-certificates"), QString(), nullptr, QString(), nullptr, group);
	addView(page, currentPage());
	tabWidget->setCurrentIndex(tabWidget->count() - 1);
	}

	void TabWidget::Private::renamePage(Page *page)
	{
	if (!page) {
	return;
	}
	bool ok;
	const QString text = QInputDialog::getText(q, i18n("Rename Tab"), i18n("New tab title:"), QLineEdit::Normal, page->title(), &ok);
	if (!ok) {
	return;
	}
	page->setTitle(text);
	}

	void TabWidget::Private::duplicatePage(Page *page)
	{
	if (!page) {
	return;
	}
	Page *const clone = page->clone();
	Q_ASSERT(clone);
	clone->liftAllRestrictions();
	addView(clone, page);
	}

	void TabWidget::Private::closePage(Page *page)
	{
	if (!page \|\| !page->canBeClosed() \|\| tabWidget->count() <= 1) {
	return;
	}
	Q_EMIT q->viewAboutToBeRemoved(page->view());
	tabWidget->removeTab(tabWidget->indexOf(page));
	enableDisableCurrentPageActions();
	}

	void TabWidget::Private::movePageLeft(Page *page)
	{
	if (!page) {
	return;
	}
	const int idx = tabWidget->indexOf(page);
	if (idx <= 0) {
	return;
	}
	tabWidget->tabBar()->moveTab(idx, idx - 1);
	enableDisableCurrentPageActions();
	}

	void TabWidget::Private::movePageRight(Page *page)
	{
	if (!page) {
	return;
	}
	const int idx = tabWidget->indexOf(page);
	if (idx < 0 \|\| idx >= tabWidget->count() - 1) {
	return;
	}
	tabWidget->tabBar()->moveTab(idx, idx + 1);
	enableDisableCurrentPageActions();
	}

	void TabWidget::Private::toggleHierarchicalView(Page *page, bool on)
	{
	if (!page) {
	return;
	}
	page->setHierarchicalView(on);
	}

	void TabWidget::Private::expandAll(Page *page)
	{
	if (!page \|\| !page->view()) {
	return;
	}
	page->view()->expandAll();
	}

	void TabWidget::Private::collapseAll(Page *page)
	{
	if (!page \|\| !page->view()) {
	return;
	}
	page->view()->collapseAll();
	}

	TabWidget::TabWidget(QWidget *p, Qt::WindowFlags f)
	: QWidget(p, f), d(new Private(this))
	{
	}

	TabWidget::~TabWidget() {
	saveViews(KSharedConfig::openConfig().data());
	}

	void TabWidget::setFlatModel(AbstractKeyListModel *model)
	{
	if (model == d->flatModel) {
	return;
	}
	d->flatModel = model;
	for (unsigned int i = 0, end = count(); i != end; ++i)
	if (Page *const page = d->page(i)) {
	page->setFlatModel(model);
	}
	}

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

	void TabWidget::setHierarchicalModel(AbstractKeyListModel *model)
	{
	if (model == d->hierarchicalModel) {
	return;
	}
	d->hierarchicalModel = model;
	for (unsigned int i = 0, end = count(); i != end; ++i)
	if (Page *const page = d->page(i)) {
	page->setHierarchicalModel(model);
	}
	}

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

	QString TabWidget::stringFilter() const
	{
	return d->currentPage() ? d->currentPage()->stringFilter() : QString{};
	}

	void TabWidget::setStringFilter(const QString &filter)
	{
	if (Page *const page = d->currentPage()) {
	page->setStringFilter(filter);
	}
	}

	void TabWidget::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
	{
	if (!filter) {
	qCDebug(KLEOPATRA_LOG) << "TabWidget::setKeyFilter() trial to set filter=NULL";
	return;
	}

	if (Page *const page = d->currentPage()) {
	page->setKeyFilter(filter);
	}
	}

	std::vector<QAbstractItemView *> TabWidget::views() const
	{
	std::vector<QAbstractItemView *> result;
	const unsigned int N = count();
	result.reserve(N);
	for (unsigned int i = 0; i != N; ++i)
	if (const Page *const p = d->page(i)) {
	result.push_back(p->view());
	}
	return result;
	}

	QAbstractItemView *TabWidget::currentView() const
	{
	if (Page *const page = d->currentPage()) {
	return page->view();
	} else {
	return nullptr;
	}
	}

	KeyListModelInterface *TabWidget::currentModel() const
	{
	const QAbstractItemView *const view = currentView();
	if (!view) {
	return nullptr;
	}
	auto const proxy = qobject_cast<QAbstractProxyModel *>(view->model());
	if (!proxy) {
	return nullptr;
	}
	return dynamic_cast<KeyListModelInterface *>(proxy);
	}

	unsigned int TabWidget::count() const
	{
	return d->tabWidget->count();
	}

	void TabWidget::setMultiSelection(bool on)
	{
	for (unsigned int i = 0, end = count(); i != end; ++i)
	if (const Page *const p = d->page(i))
	if (QTreeView *const view = p->view()) {
	view->setSelectionMode(on ? QAbstractItemView::ExtendedSelection : QAbstractItemView::SingleSelection);
	}
	}

	void TabWidget::createActions(KActionCollection *coll)
	{
	if (!coll) {
	return;
	}
	const action_data actionDataNew = {
	"window_new_tab", i18n("New Tab"), i18n("Open a new tab"),
	- "tab-new-background", this, SLOT(slotNewTab()), QStringLiteral("CTRL+SHIFT+N"), false, true
	+ "tab-new-background", this, [this](bool) { d->slotNewTab(); }, QStringLiteral("CTRL+SHIFT+N"), false, true
	};

	d->newAction = make_action_from_data(actionDataNew, coll);

	const std::vector<action_data> actionData = {
	{
	Actions::Rename, i18n("Rename Tab..."), i18n("Rename this tab"),
	- "edit-rename", this, SLOT(slotRenameCurrentTab()), QStringLiteral("CTRL+SHIFT+R"), false, false
	+ "edit-rename", this, [this](bool) { d->slotRenameCurrentTab(); }, QStringLiteral("CTRL+SHIFT+R"), false, false
	},
	{
	Actions::Duplicate, i18n("Duplicate Tab"), i18n("Duplicate this tab"),
	- "tab-duplicate", this, SLOT(slotDuplicateCurrentTab()), QStringLiteral("CTRL+SHIFT+D"), false, true
	+ "tab-duplicate", this, [this](bool) { d->slotDuplicateCurrentTab(); }, QStringLiteral("CTRL+SHIFT+D"), false, true
	},
	{
	Actions::Close, i18n("Close Tab"), i18n("Close this tab"),
	- "tab-close", this, SLOT(slotCloseCurrentTab()), QStringLiteral("CTRL+SHIFT+W"), false, false
	+ "tab-close", this, [this](bool) { d->slotCloseCurrentTab(); }, QStringLiteral("CTRL+SHIFT+W"), false, false
	}, // ### CTRL-W when available
	{
	Actions::MoveLeft, i18n("Move Tab Left"), i18n("Move this tab left"),
	- nullptr, this, SLOT(slotMoveCurrentTabLeft()), QStringLiteral("CTRL+SHIFT+LEFT"), false, false
	+ nullptr, this, [this](bool) { d->slotMoveCurrentTabLeft(); }, QStringLiteral("CTRL+SHIFT+LEFT"), false, false
	},
	{
	Actions::MoveRight, i18n("Move Tab Right"), i18n("Move this tab right"),
	- nullptr, this, SLOT(slotMoveCurrentTabRight()), QStringLiteral("CTRL+SHIFT+RIGHT"), false, false
	+ nullptr, this, [this](bool) { d->slotMoveCurrentTabRight(); }, QStringLiteral("CTRL+SHIFT+RIGHT"), false, false
	},
	{
	Actions::Hierarchical, i18n("Hierarchical Certificate List"), QString(),
	- nullptr, this, SLOT(slotToggleHierarchicalView(bool)), QString(), true, false
	+ nullptr, this, [this](bool on) { d->slotToggleHierarchicalView(on); }, QString(), true, false
	},
	{
	Actions::ExpandAll, i18n("Expand All"), QString(),
	- nullptr, this, SLOT(slotExpandAll()), QStringLiteral("CTRL+."), false, false
	+ nullptr, this, [this](bool) { d->slotExpandAll(); }, QStringLiteral("CTRL+."), false, false
	},
	{
	Actions::CollapseAll, i18n("Collapse All"), QString(),
	- nullptr, this, SLOT(slotCollapseAll()), QStringLiteral("CTRL+,"), false, false
	+ nullptr, this, [this](bool) { d->slotCollapseAll(); }, QStringLiteral("CTRL+,"), false, false
	},
	};

	for (const auto &ad : actionData) {
	d->currentPageActions.insert(ad.name, make_action_from_data(ad, coll));
	}

	for (const auto &ad : actionData) {
	// create actions for the context menu of the currently not active tabs,
	// but do not add those actions to the action collection
	auto action = new QAction(ad.text, coll);
	if (ad.icon) {
	action->setIcon(QIcon::fromTheme(QLatin1String(ad.icon)));
	}
	action->setEnabled(ad.enabled);
	d->otherPageActions.insert(ad.name, action);
	}

	d->newTabButton->setDefaultAction(d->newAction);
	d->tabWidget->setCornerWidget(d->newTabButton, Qt::TopLeftCorner);
	if (auto action = d->currentPageActions.get(Actions::Close)) {
	d->closeTabButton->setDefaultAction(action);
	d->tabWidget->setCornerWidget(d->closeTabButton, Qt::TopRightCorner);
	} else {
	d->closeTabButton->setVisible(false);
	}
	d->actionsCreated = true;
	}

	QAbstractItemView *TabWidget::addView(const QString &title, const QString &id, const QString &text)
	{
	const KConfigGroup group = KSharedConfig::openConfig()->group(QString::asprintf("View #%u", d->tabWidget->count()));
	Page *page = new Page(title, id, text, nullptr, QString(), nullptr, group);
	return d->addView(page, d->currentPage());
	}

	QAbstractItemView *TabWidget::addView(const KConfigGroup &group)
	{
	return d->addView(new Page(group), nullptr);
	}

	QAbstractItemView TabWidget::addTemporaryView(const QString &title, AbstractKeyListSortFilterProxyModel proxy, const QString &tabToolTip)
	{
	const KConfigGroup group = KSharedConfig::openConfig()->group("KeyTreeView_default");
	Page *const page = new Page(title, QString(), QString(), proxy, tabToolTip, nullptr, group);
	page->setTemporary(true);
	QAbstractItemView *v = d->addView(page, d->currentPage());
	d->tabWidget->setCurrentIndex(d->tabWidget->count() - 1);
	return v;
	}

	QTreeView TabWidget::Private::addView(Page page, Page *columnReference)
	{
	if (!page) {
	return nullptr;
	}

	if (!actionsCreated) {
	auto coll = new KActionCollection(q);
	q->createActions(coll);
	}

	page->setFlatModel(flatModel);
	page->setHierarchicalModel(hierarchicalModel);

	connect(page, &Page::titleChanged, q, [this](const QString &text) { slotPageTitleChanged(text); });
	connect(page, &Page::keyFilterChanged, q, [this](const std::shared_ptr<Kleo::KeyFilter> &filter) { slotPageKeyFilterChanged(filter); });
	connect(page, &Page::stringFilterChanged, q, [this](const QString &text) { slotPageStringFilterChanged(text); });
	connect(page, &Page::hierarchicalChanged, q, [this](bool on) { slotPageHierarchyChanged(on); });

	if (columnReference) {
	page->setColumnSizes(columnReference->columnSizes());
	page->setSortColumn(columnReference->sortColumn(), columnReference->sortOrder());
	}

	QAbstractItemView *const previous = q->currentView();
	const int tabIndex = tabWidget->addTab(page, page->title());
	setTabOrder(closeTabButton, page->view());
	tabWidget->setTabToolTip(tabIndex, page->toolTip());
	// work around a bug in QTabWidget (tested with 4.3.2) not emitting currentChanged() when the first widget is inserted
	QAbstractItemView *const current = q->currentView();
	if (previous != current) {
	currentIndexChanged(tabWidget->currentIndex());
	}
	enableDisableCurrentPageActions();
	QTreeView *view = page->view();
	Q_EMIT q->viewAdded(view);
	return view;
	}

	static QStringList extractViewGroups(const KConfig *config)
	{
	return config ? config->groupList().filter(QRegularExpression(QStringLiteral("^View #\\d+$"))) : QStringList();
	}

	// work around deleteGroup() not deleting groups out of groupList():
	static const bool KCONFIG_DELETEGROUP_BROKEN = true;

	void TabWidget::loadViews(const KConfig *config)
	{
	if (config) {
	QStringList groupList = extractViewGroups(config);
	groupList.sort();
	for (const QString &group : std::as_const(groupList)) {
	const KConfigGroup kcg(config, group);
	if (!KCONFIG_DELETEGROUP_BROKEN \|\| kcg.readEntry("magic", 0U) == 0xFA1AFE1U) {
	addView(kcg);
	}
	}
	}
	if (!count()) {
	// add default view:
	addView(i18n("All Certificates"), QStringLiteral("all-certificates"));
	}
	}

	void TabWidget::saveViews(KConfig *config) const
	{
	if (!config) {
	return;
	}
	const auto extraView{extractViewGroups(config)};
	for (const QString &group : extraView) {
	config->deleteGroup(group);
	}
	unsigned int vg = 0;
	for (unsigned int i = 0, end = count(); i != end; ++i) {
	if (const Page *const p = d->page(i)) {
	if (p->isTemporary()) {
	continue;
	}
	KConfigGroup group(config, QString::asprintf("View #%u", vg++));
	p->saveTo(group);
	if (KCONFIG_DELETEGROUP_BROKEN) {
	group.writeEntry("magic", 0xFA1AFE1U);
	}
	}
	}
	}

	void TabWidget::connectSearchBar(SearchBar *sb)
	{
	connect(sb, &SearchBar::stringFilterChanged, this, &TabWidget::setStringFilter);
	connect(this, &TabWidget::stringFilterChanged, sb, &SearchBar::setStringFilter);

	connect(sb, &SearchBar::keyFilterChanged, this, &TabWidget::setKeyFilter);
	connect(this, &TabWidget::keyFilterChanged, sb, &SearchBar::setKeyFilter);

	connect(this, &TabWidget::enableChangeStringFilter, sb, &SearchBar::setChangeStringFilterEnabled);
	connect(this, &TabWidget::enableChangeKeyFilter, sb, &SearchBar::setChangeKeyFilterEnabled);
	}

	#include "moc_tabwidget.cpp"
	#include "tabwidget.moc"
	diff --git a/src/view/tabwidget.h b/src/view/tabwidget.h
	index d135f991d..f6e294da8 100644
	--- a/src/view/tabwidget.h
	+++ b/src/view/tabwidget.h
	@@ -1,98 +1,88 @@
	/* -- mode: c++; c-basic-offset:4 --
	view/tabwidget.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 <QWidget>

	#include <memory>
	#include <vector>

	#include <utils/pimpl_ptr.h>


	class QAbstractItemView;

	class KConfigGroup;
	class KActionCollection;
	class KConfig;

	namespace Kleo
	{

	class AbstractKeyListModel;
	class AbstractKeyListSortFilterProxyModel;
	class KeyFilter;
	class KeyListModelInterface;
	class SearchBar;

	class TabWidget : public QWidget
	{
	Q_OBJECT
	public:
	explicit TabWidget(QWidget *parent = nullptr, Qt::WindowFlags f = {});
	~TabWidget() override;

	void setFlatModel(AbstractKeyListModel *model);
	AbstractKeyListModel *flatModel() const;
	void setHierarchicalModel(AbstractKeyListModel *model);
	AbstractKeyListModel *hierarchicalModel() const;

	QAbstractItemView *addView(const QString &title = QString(), const QString &keyFilterID = QString(), const QString &searchString = QString());
	QAbstractItemView *addView(const KConfigGroup &group);
	QAbstractItemView addTemporaryView(const QString &title = QString(), AbstractKeyListSortFilterProxyModel proxy = nullptr, const QString &tabToolTip = QString());

	void loadViews(const KConfig *cfg);
	void saveViews(KConfig *cfg) const;

	std::vector<QAbstractItemView *> views() const;
	QAbstractItemView *currentView() const;
	KeyListModelInterface *currentModel() const;

	unsigned int count() const;

	void createActions(KActionCollection *collection);
	void connectSearchBar(SearchBar *sb);

	void setMultiSelection(bool on);

	QString stringFilter() const;

	public Q_SLOTS:
	void setKeyFilter(const std::shared_ptr<Kleo::KeyFilter> &filter);
	void setStringFilter(const QString &filter);

	Q_SIGNALS:
	void viewAdded(QAbstractItemView *view);
	void viewAboutToBeRemoved(QAbstractItemView *view);

	void currentViewChanged(QAbstractItemView *view);
	void stringFilterChanged(const QString &filter);
	void keyFilterChanged(const std::shared_ptr<Kleo::KeyFilter> &filter);

	void enableChangeStringFilter(bool enable);
	void enableChangeKeyFilter(bool enable);

	private:
	class Private;
	kdtools::pimpl_ptr<Private> d;
	-
	- Q_PRIVATE_SLOT(d, void slotRenameCurrentTab())
	- Q_PRIVATE_SLOT(d, void slotNewTab())
	- Q_PRIVATE_SLOT(d, void slotDuplicateCurrentTab())
	- Q_PRIVATE_SLOT(d, void slotCloseCurrentTab())
	- Q_PRIVATE_SLOT(d, void slotMoveCurrentTabLeft())
	- Q_PRIVATE_SLOT(d, void slotMoveCurrentTabRight())
	- Q_PRIVATE_SLOT(d, void slotToggleHierarchicalView(bool))
	- Q_PRIVATE_SLOT(d, void slotExpandAll())
	- Q_PRIVATE_SLOT(d, void slotCollapseAll())
	};

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 17, 12:27 AM (12 h, 59 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: c3/68/ef8601fc6c5e71200b608dac2090

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions