No OneTemporary
Actions

Size

87 KB

Subscribers

None

View Options

	diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
	index 2ff100f03..cbb80f8fb 100644
	--- a/src/CMakeLists.txt
	+++ b/src/CMakeLists.txt
	@@ -1,617 +1,619 @@
	# SPDX-FileCopyrightText: none
	# SPDX-License-Identifier: BSD-3-Clause
	add_subdirectory(icons)
	add_subdirectory(mimetypes)

	include_directories(${CMAKE_CURRENT_BINARY_DIR})
	include_directories(${CMAKE_CURRENT_SOURCE_DIR})

	if (NOT DISABLE_KWATCHGNUPG)
	add_subdirectory(kwatchgnupg)
	endif()
	add_subdirectory(libkleopatraclient)
	add_subdirectory(conf)
	add_subdirectory(kconf_update)

	if(WIN32)
	set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_win.cpp)
	set(_kleopatra_extra_SRCS
	selftest/registrycheck.cpp selftest/registrycheck.h
	utils/gnupg-registry.c
	utils/userinfo_win.cpp
	utils/windowsprocessdevice.cpp utils/windowsprocessdevice.h
	versioninfo.rc kleopatra.w32-manifest
	)
	else()
	set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_unix.cpp)
	set(_kleopatra_extra_SRCS)
	endif()

	set(_kleopatra_uiserver_SRCS
	${_kleopatra_extra_uiserver_SRCS}

	selftest/uiservercheck.cpp selftest/uiservercheck.h
	uiserver/assuanserverconnection.cpp uiserver/assuanserverconnection.h
	uiserver/createchecksumscommand.cpp uiserver/createchecksumscommand.h
	uiserver/decryptverifycommandemailbase.cpp uiserver/decryptverifycommandemailbase.h
	uiserver/decryptverifycommandfilesbase.cpp uiserver/decryptverifycommandfilesbase.h
	uiserver/echocommand.cpp uiserver/echocommand.h
	uiserver/encryptcommand.cpp uiserver/encryptcommand.h
	uiserver/importfilescommand.cpp uiserver/importfilescommand.h
	uiserver/prepencryptcommand.cpp uiserver/prepencryptcommand.h
	uiserver/prepsigncommand.cpp uiserver/prepsigncommand.h
	uiserver/selectcertificatecommand.cpp
	uiserver/sessiondata.cpp uiserver/sessiondata.h
	uiserver/signcommand.cpp uiserver/signcommand.h
	uiserver/signencryptfilescommand.cpp
	uiserver/uiserver.cpp
	uiserver/verifychecksumscommand.cpp uiserver/verifychecksumscommand.h
	)

	set(_kleopatra_uiserver_extra_libs LibAssuan::LibAssuan LibGpgError::LibGpgError)

	if(HAVE_GPG_ERR_SOURCE_KLEO)
	add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_KLEO)
	add_definitions(-DGPGMEPP_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_KLEO)
	else()
	add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_USER_1)
	add_definitions(-DGPGMEPP_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_USER_1)
	endif()

	if(KPim6IdentityManagementCore_FOUND AND KPim6MailTransport_FOUND AND KPim6AkonadiMime_FOUND)
	set(_kleopatra_mail_libs
	KPim6::IdentityManagementCore # Export OpenPGP keys using WKS
	KPim6::MailTransport
	KPim6::AkonadiMime
	)
	add_definitions(-DMAILAKONADI_ENABLED)
	endif()

	ki18n_wrap_ui(_kleopatra_uiserver_SRCS crypto/gui/signingcertificateselectionwidget.ui)

	set(_kleopatra_SRCS
	${_kleopatra_extra_SRCS}

	accessibility/accessiblelink.cpp
	accessibility/accessiblelink_p.h
	accessibility/accessiblerichtextlabel.cpp
	accessibility/accessiblerichtextlabel_p.h
	accessibility/accessiblevaluelabel.cpp
	accessibility/accessiblevaluelabel_p.h
	accessibility/accessiblewidgetfactory.cpp
	accessibility/accessiblewidgetfactory.h
	commands/adduseridcommand.cpp
	commands/adduseridcommand.h
	commands/authenticatepivcardapplicationcommand.cpp
	commands/authenticatepivcardapplicationcommand.h
	commands/cardcommand.cpp
	commands/cardcommand.h
	commands/certificatetopivcardcommand.cpp
	commands/certificatetopivcardcommand.h
	commands/certifycertificatecommand.cpp
	commands/certifycertificatecommand.h
	commands/certifygroupcommand.cpp
	commands/certifygroupcommand.h
	commands/changeexpirycommand.cpp
	commands/changeexpirycommand.h
	commands/changeownertrustcommand.cpp
	commands/changeownertrustcommand.h
	commands/changepassphrasecommand.cpp
	commands/changepassphrasecommand.h
	commands/changepincommand.cpp
	commands/changepincommand.h
	commands/changeroottrustcommand.cpp
	commands/changeroottrustcommand.h
	commands/checksumcreatefilescommand.cpp
	commands/checksumcreatefilescommand.h
	commands/checksumverifyfilescommand.cpp
	commands/checksumverifyfilescommand.h
	commands/clearcrlcachecommand.cpp
	commands/clearcrlcachecommand.h
	commands/command.cpp
	commands/command.h
	commands/createcsrforcardkeycommand.cpp
	commands/createcsrforcardkeycommand.h
	commands/createopenpgpkeyfromcardkeyscommand.cpp
	commands/createopenpgpkeyfromcardkeyscommand.h
	commands/decryptverifyclipboardcommand.cpp
	commands/decryptverifyclipboardcommand.h
	commands/decryptverifyfilescommand.cpp
	commands/decryptverifyfilescommand.h
	commands/deletecertificatescommand.cpp
	commands/deletecertificatescommand.h
	commands/detailscommand.cpp
	commands/detailscommand.h
	commands/dumpcertificatecommand.cpp
	commands/dumpcertificatecommand.h
	commands/dumpcrlcachecommand.cpp
	commands/dumpcrlcachecommand.h
	commands/encryptclipboardcommand.cpp
	commands/encryptclipboardcommand.h
	commands/exportcertificatecommand.cpp
	commands/exportcertificatecommand.h
	commands/exportgroupscommand.cpp
	commands/exportgroupscommand.h
	commands/exportopenpgpcertstoservercommand.cpp
	commands/exportopenpgpcertstoservercommand.h
	commands/exportopenpgpcerttoprovidercommand.cpp
	commands/exportopenpgpcerttoprovidercommand.h
	commands/exportpaperkeycommand.cpp
	commands/exportpaperkeycommand.h
	commands/exportsecretkeycommand.cpp
	commands/exportsecretkeycommand.h
	commands/exportsecretsubkeycommand.cpp
	commands/exportsecretsubkeycommand.h
	commands/genrevokecommand.cpp
	commands/genrevokecommand.h
	commands/gnupgprocesscommand.cpp
	commands/gnupgprocesscommand.h
	commands/importcertificatefromclipboardcommand.cpp
	commands/importcertificatefromclipboardcommand.h
	commands/importcertificatefromdatacommand.cpp
	commands/importcertificatefromdatacommand.h
	commands/importcertificatefromfilecommand.cpp
	commands/importcertificatefromfilecommand.h
	commands/importcertificatefromkeyservercommand.cpp
	commands/importcertificatefromkeyservercommand.h
	commands/importcertificatefrompivcardcommand.cpp
	commands/importcertificatefrompivcardcommand.h
	commands/importcertificatescommand.cpp
	commands/importcertificatescommand.h
	commands/importcrlcommand.cpp
	commands/importcrlcommand.h
	commands/importpaperkeycommand.cpp
	commands/importpaperkeycommand.h
	commands/keytocardcommand.cpp
	commands/keytocardcommand.h
	commands/learncardkeyscommand.cpp
	commands/learncardkeyscommand.h
	commands/lookupcertificatescommand.cpp
	commands/lookupcertificatescommand.h
	commands/newcertificatesigningrequestcommand.cpp
	commands/newcertificatesigningrequestcommand.h
	commands/newopenpgpcertificatecommand.cpp
	commands/newopenpgpcertificatecommand.h
	commands/openpgpgeneratecardkeycommand.cpp
	commands/openpgpgeneratecardkeycommand.h
	commands/pivgeneratecardkeycommand.cpp
	commands/pivgeneratecardkeycommand.h
	commands/refreshcertificatecommand.cpp
	commands/refreshcertificatecommand.h
	commands/refreshopenpgpcertscommand.cpp
	commands/refreshopenpgpcertscommand.h
	commands/refreshx509certscommand.cpp
	commands/refreshx509certscommand.h
	commands/reloadkeyscommand.cpp
	commands/reloadkeyscommand.h
	commands/revokecertificationcommand.cpp
	commands/revokecertificationcommand.h
	commands/revokekeycommand.cpp
	commands/revokekeycommand.h
	commands/revokeuseridcommand.cpp
	commands/revokeuseridcommand.h
	commands/selftestcommand.cpp
	commands/selftestcommand.h
	commands/setinitialpincommand.cpp
	commands/setinitialpincommand.h
	commands/setpivcardapplicationadministrationkeycommand.cpp
	commands/setpivcardapplicationadministrationkeycommand.h
	commands/setprimaryuseridcommand.cpp
	commands/setprimaryuseridcommand.h
	commands/signclipboardcommand.cpp
	commands/signclipboardcommand.h
	commands/signencryptfilescommand.cpp
	commands/signencryptfilescommand.h
	commands/signencryptfoldercommand.cpp
	commands/signencryptfoldercommand.h
	commands/viewemailfilescommand.cpp
	commands/viewemailfilescommand.h
	conf/configuredialog.cpp
	conf/configuredialog.h
	conf/groupsconfigdialog.cpp
	conf/groupsconfigdialog.h
	conf/groupsconfigwidget.cpp
	conf/groupsconfigwidget.h
	crypto/autodecryptverifyfilescontroller.cpp
	crypto/autodecryptverifyfilescontroller.h
	crypto/certificateresolver.cpp
	crypto/certificateresolver.h
	crypto/checksumsutils_p.cpp
	crypto/checksumsutils_p.h
	crypto/controller.cpp
	crypto/controller.h
	crypto/createchecksumscontroller.cpp
	crypto/createchecksumscontroller.h
	crypto/decryptverifyemailcontroller.cpp
	crypto/decryptverifyemailcontroller.h
	crypto/decryptverifyfilescontroller.cpp
	crypto/decryptverifyfilescontroller.h
	crypto/decryptverifytask.cpp
	crypto/decryptverifytask.h
	crypto/encryptemailcontroller.cpp
	crypto/encryptemailcontroller.h
	crypto/encryptemailtask.cpp
	crypto/encryptemailtask.h
	crypto/gui/certificatelineedit.cpp
	crypto/gui/certificatelineedit.h
	crypto/gui/certificateselectionline.cpp
	crypto/gui/certificateselectionline.h
	crypto/gui/decryptverifyfilesdialog.cpp
	crypto/gui/decryptverifyfilesdialog.h
	crypto/gui/decryptverifyfileswizard.cpp
	crypto/gui/decryptverifyfileswizard.h
	crypto/gui/decryptverifyoperationwidget.cpp
	crypto/gui/decryptverifyoperationwidget.h
	crypto/gui/encryptemailwizard.cpp
	crypto/gui/encryptemailwizard.h
	crypto/gui/newresultpage.cpp
	crypto/gui/newresultpage.h
	crypto/gui/objectspage.cpp
	crypto/gui/objectspage.h
	crypto/gui/resolverecipientspage.cpp
	crypto/gui/resolverecipientspage.h
	crypto/gui/resultitemwidget.cpp
	crypto/gui/resultitemwidget.h
	crypto/gui/resultlistwidget.cpp
	crypto/gui/resultlistwidget.h
	crypto/gui/resultpage.cpp
	crypto/gui/resultpage.h
	crypto/gui/signemailwizard.cpp
	crypto/gui/signemailwizard.h
	crypto/gui/signencryptemailconflictdialog.cpp
	crypto/gui/signencryptemailconflictdialog.h
	crypto/gui/signencryptfileswizard.cpp
	crypto/gui/signencryptfileswizard.h
	crypto/gui/signencryptwidget.cpp
	crypto/gui/signencryptwidget.h
	crypto/gui/signencryptwizard.cpp
	crypto/gui/signencryptwizard.h
	crypto/gui/signerresolvepage.cpp
	crypto/gui/signerresolvepage.h
	crypto/gui/signingcertificateselectiondialog.cpp
	crypto/gui/signingcertificateselectiondialog.h
	crypto/gui/signingcertificateselectionwidget.cpp
	crypto/gui/signingcertificateselectionwidget.h
	crypto/gui/unknownrecipientwidget.cpp
	crypto/gui/unknownrecipientwidget.h
	crypto/gui/verifychecksumsdialog.cpp
	crypto/gui/verifychecksumsdialog.h
	crypto/gui/wizard.cpp
	crypto/gui/wizard.h
	crypto/gui/wizardpage.cpp
	crypto/gui/wizardpage.h
	crypto/newsignencryptemailcontroller.cpp
	crypto/newsignencryptemailcontroller.h
	crypto/recipient.cpp
	crypto/recipient.h
	crypto/sender.cpp
	crypto/sender.h
	crypto/signemailcontroller.cpp
	crypto/signemailcontroller.h
	crypto/signemailtask.cpp
	crypto/signemailtask.h
	crypto/signencryptfilescontroller.cpp
	crypto/signencryptfilescontroller.h
	crypto/signencrypttask.cpp
	crypto/signencrypttask.h
	crypto/task.cpp
	crypto/task.h
	crypto/taskcollection.cpp
	crypto/taskcollection.h
	crypto/verifychecksumscontroller.cpp
	crypto/verifychecksumscontroller.h
	dialogs/adduseriddialog.cpp
	dialogs/adduseriddialog.h
	dialogs/certificatedetailsdialog.cpp
	dialogs/certificatedetailsdialog.h
	dialogs/certificatedetailsinputwidget.cpp
	dialogs/certificatedetailsinputwidget.h
	dialogs/certificatedetailswidget.cpp
	dialogs/certificatedetailswidget.h
	dialogs/certificateselectiondialog.cpp
	dialogs/certificateselectiondialog.h
	dialogs/certifycertificatedialog.cpp
	dialogs/certifycertificatedialog.h
	dialogs/certifywidget.cpp
	dialogs/certifywidget.h
	dialogs/createcsrforcardkeydialog.cpp
	dialogs/createcsrforcardkeydialog.h
	dialogs/deletecertificatesdialog.cpp
	dialogs/deletecertificatesdialog.h
	dialogs/editgroupdialog.cpp
	dialogs/editgroupdialog.h
	dialogs/expirydialog.cpp
	dialogs/expirydialog.h
	dialogs/exportdialog.cpp
	dialogs/exportdialog.h
	dialogs/gencardkeydialog.cpp
	dialogs/gencardkeydialog.h
	dialogs/groupdetailsdialog.cpp
	dialogs/groupdetailsdialog.h
	dialogs/lookupcertificatesdialog.cpp
	dialogs/lookupcertificatesdialog.h
	dialogs/nameandemailwidget.cpp
	dialogs/nameandemailwidget.h
	dialogs/newopenpgpcertificatedetailsdialog.cpp
	dialogs/newopenpgpcertificatedetailsdialog.h
	dialogs/pivcardapplicationadministrationkeyinputdialog.cpp
	dialogs/pivcardapplicationadministrationkeyinputdialog.h
	dialogs/revokekeydialog.cpp
	dialogs/revokekeydialog.h
	dialogs/selftestdialog.cpp
	dialogs/selftestdialog.h
	dialogs/setinitialpindialog.cpp
	dialogs/setinitialpindialog.h
	dialogs/subkeyswidget.cpp
	dialogs/subkeyswidget.h
	dialogs/trustchainwidget.cpp
	dialogs/trustchainwidget.h
	dialogs/updatenotification.cpp
	dialogs/updatenotification.h
	dialogs/weboftrustdialog.cpp
	dialogs/weboftrustdialog.h
	dialogs/weboftrustwidget.cpp
	dialogs/weboftrustwidget.h
	interfaces/anchorprovider.h
	interfaces/focusfirstchild.h
	newcertificatewizard/advancedsettingsdialog.cpp
	newcertificatewizard/advancedsettingsdialog_p.h
	newcertificatewizard/enterdetailspage.cpp
	newcertificatewizard/enterdetailspage_p.h
	newcertificatewizard/keyalgo.cpp
	newcertificatewizard/keyalgo_p.h
	newcertificatewizard/keycreationpage.cpp
	newcertificatewizard/keycreationpage_p.h
	newcertificatewizard/listwidget.cpp
	newcertificatewizard/listwidget.h
	newcertificatewizard/newcertificatewizard.cpp
	newcertificatewizard/newcertificatewizard.h
	newcertificatewizard/resultpage.cpp
	newcertificatewizard/resultpage_p.h
	newcertificatewizard/wizardpage.cpp
	newcertificatewizard/wizardpage_p.h
	selftest/compliancecheck.cpp
	selftest/compliancecheck.h
	selftest/enginecheck.cpp
	selftest/enginecheck.h
	selftest/gpgagentcheck.cpp
	selftest/gpgagentcheck.h
	selftest/gpgconfcheck.cpp
	selftest/gpgconfcheck.h
	selftest/libkleopatrarccheck.cpp
	selftest/libkleopatrarccheck.h
	selftest/selftest.cpp
	selftest/selftest.h
	smartcard/algorithminfo.h
	smartcard/card.cpp
	smartcard/card.h
	smartcard/deviceinfowatcher.cpp
	smartcard/deviceinfowatcher.h
	smartcard/keypairinfo.cpp
	smartcard/keypairinfo.h
	smartcard/netkeycard.cpp
	smartcard/netkeycard.h
	smartcard/openpgpcard.cpp
	smartcard/openpgpcard.h
	smartcard/p15card.cpp
	smartcard/p15card.h
	smartcard/pivcard.cpp
	smartcard/pivcard.h
	smartcard/readerstatus.cpp
	smartcard/readerstatus.h
	smartcard/utils.cpp
	smartcard/utils.h
	utils/accessibility.cpp
	utils/accessibility.h
	utils/action_data.cpp
	utils/action_data.h
	utils/applicationstate.cpp
	utils/applicationstate.h
	utils/archivedefinition.cpp
	utils/archivedefinition.h
	utils/certificatepair.h
	utils/clipboardmenu.cpp
	utils/clipboardmenu.h
	utils/debug-helpers.cpp
	utils/debug-helpers.h
	utils/dragqueen.cpp
	utils/dragqueen.h
	utils/email.cpp
	utils/email.h
	utils/emptypassphraseprovider.cpp
	utils/emptypassphraseprovider.h
	utils/expiration.cpp
	utils/expiration.h
	utils/filedialog.cpp
	utils/filedialog.h
	utils/gui-helper.cpp
	utils/gui-helper.h
	utils/headerview.cpp
	utils/headerview.h
	utils/input.cpp
	utils/input.h
	utils/iodevicelogger.cpp
	utils/iodevicelogger.h
	utils/kdpipeiodevice.cpp
	utils/kdpipeiodevice.h
	+ utils/keyexportdraghandler.cpp
	+ utils/keyexportdraghandler.h
	utils/keyparameters.cpp
	utils/keyparameters.h
	utils/kuniqueservice.cpp
	utils/kuniqueservice.h
	utils/log.cpp
	utils/log.h
	utils/memory-helpers.h
	utils/multivalidator.cpp
	utils/multivalidator.h
	utils/output.cpp
	utils/output.h
	utils/overwritedialog.cpp
	utils/overwritedialog.h
	utils/path-helper.cpp
	utils/path-helper.h
	utils/scrollarea.cpp
	utils/scrollarea.h
	utils/systemtrayicon.cpp
	utils/systemtrayicon.h
	utils/tags.cpp
	utils/tags.h
	utils/types.cpp
	utils/types.h
	utils/userinfo.cpp
	utils/userinfo.h
	utils/validation.cpp
	utils/validation.h
	utils/writecertassuantransaction.cpp
	utils/writecertassuantransaction.h
	utils/wsastarter.cpp
	utils/wsastarter.h
	view/anchorcache.cpp
	view/anchorcache_p.h
	view/errorlabel.cpp
	view/errorlabel.h
	view/formtextinput.cpp
	view/formtextinput.h
	view/htmllabel.cpp
	view/htmllabel.h
	view/infofield.cpp
	view/infofield.h
	view/keycacheoverlay.cpp
	view/keycacheoverlay.h
	view/keylistcontroller.cpp
	view/keylistcontroller.h
	view/keytreeview.cpp
	view/keytreeview.h
	view/netkeywidget.cpp
	view/netkeywidget.h
	view/nullpinwidget.cpp
	view/nullpinwidget.h
	view/openpgpkeycardwidget.cpp
	view/openpgpkeycardwidget.h
	view/p15cardwidget.cpp
	view/p15cardwidget.h
	view/padwidget.cpp
	view/padwidget.h
	view/pgpcardwidget.cpp
	view/pgpcardwidget.h
	view/pivcardwidget.cpp
	view/pivcardwidget.h
	view/searchbar.cpp
	view/searchbar.h
	view/smartcardwidget.cpp
	view/smartcardwidget.h
	view/tabwidget.cpp
	view/tabwidget.h
	view/urllabel.cpp
	view/urllabel.h
	view/waitwidget.cpp
	view/waitwidget.h
	view/welcomewidget.cpp
	view/welcomewidget.h

	aboutdata.cpp
	aboutdata.h
	kleopatra.qrc
	kleopatraapplication.cpp
	kleopatraapplication.h
	main.cpp
	mainwindow.cpp
	mainwindow.h
	systrayicon.cpp
	systrayicon.h
	)

	if(WIN32)
	configure_file (versioninfo.rc.in versioninfo.rc)
	set(_kleopatra_SRCS ${CMAKE_CURRENT_BINARY_DIR}/versioninfo.rc ${_kleopatra_SRCS})
	configure_file (kleopatra.w32-manifest.in kleopatra.w32-manifest)
	set(_kleopatra_SRCS ${CMAKE_CURRENT_BINARY_DIR}/kleopatra.w32-manifest ${_kleopatra_SRCS})
	endif()

	set (_kleopatra_SRCS conf/kleopageconfigdialog.cpp conf/kleopageconfigdialog.h ${_kleopatra_SRCS})

	ecm_qt_declare_logging_category(_kleopatra_SRCS HEADER kleopatra_debug.h IDENTIFIER KLEOPATRA_LOG CATEGORY_NAME org.kde.pim.kleopatra
	DESCRIPTION "kleopatra (kleopatra)"
	OLD_CATEGORY_NAMES log_kleopatra
	EXPORT KLEOPATRA
	)


	if(KLEO_MODEL_TEST)
	add_definitions(-DKLEO_MODEL_TEST)
	set(_kleopatra_SRCS ${_kleopatra_SRCS} models/modeltest.cpp)
	endif()

	ki18n_wrap_ui(_kleopatra_SRCS
	dialogs/setinitialpindialog.ui
	dialogs/trustchainwidget.ui
	newcertificatewizard/listwidget.ui
	)

	kconfig_add_kcfg_files(_kleopatra_SRCS
	kcfg/emailoperationspreferences.kcfgc
	kcfg/fileoperationspreferences.kcfgc
	kcfg/settings.kcfgc
	kcfg/smimevalidationpreferences.kcfgc
	kcfg/tagspreferences.kcfgc
	kcfg/tooltippreferences.kcfgc
	)

	file(GLOB ICONS_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/icons/*-apps-kleopatra.png")
	ecm_add_app_icon(_kleopatra_SRCS ICONS ${ICONS_SRCS})

	add_executable(kleopatra_bin ${_kleopatra_SRCS} ${_kleopatra_uiserver_SRCS})

	# For the ConfigureDialog & KCMs
	target_link_libraries(kleopatra_bin kcm_kleopatra_static)

	#if (COMPILE_WITH_UNITY_CMAKE_SUPPORT)
	# set_target_properties(kleopatra_bin PROPERTIES UNITY_BUILD ON)
	#endif()
	set_target_properties(kleopatra_bin PROPERTIES OUTPUT_NAME kleopatra)

	if (WIN32)
	set(_kleopatra_platform_libs "secur32")
	endif ()

	target_link_libraries(kleopatra_bin
	Gpgmepp
	KPim6::Libkleo
	KPim6::Mime
	KPim6::MimeTreeParserWidgets
	KF6::Codecs
	KF6::CoreAddons
	KF6::Crash
	KF6::I18n
	KF6::IconThemes
	KF6::ItemModels
	KF6::KIOCore
	KF6::KIOWidgets
	KF6::WindowSystem
	KF6::XmlGui
	Qt::Network
	Qt::PrintSupport # Printing secret keys
	kleopatraclientcore
	${_kleopatra_extra_libs}
	${_kleopatra_mail_libs}
	${_kleopatra_uiserver_extra_libs}
	${_kleopatra_dbusaddons_libs}
	${_kleopatra_platform_libs}
	)

	target_link_libraries(kleopatra_bin QGpgmeQt6)

	install(TARGETS kleopatra_bin ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})

	install(
	PROGRAMS data/org.kde.kleopatra.desktop data/kleopatra_import.desktop
	DESTINATION ${KDE_INSTALL_APPDIR}
	)
	install(FILES data/org.kde.kleopatra.appdata.xml DESTINATION ${KDE_INSTALL_METAINFODIR})
	install(FILES data/kleopatra-mime.xml DESTINATION ${KDE_INSTALL_MIMEDIR})
	install(
	PROGRAMS data/kleopatra_signencryptfiles.desktop
	data/kleopatra_signencryptfolders.desktop
	data/kleopatra_decryptverifyfiles.desktop
	data/kleopatra_decryptverifyfolders.desktop
	DESTINATION ${KDE_INSTALL_DATADIR}/kio/servicemenus
	)
	diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
	index 1d8222e97..f9a3079ef 100644
	--- a/src/mainwindow.cpp
	+++ b/src/mainwindow.cpp
	@@ -1,878 +1,885 @@
	/* -- 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 "aboutdata.h"
	#include "kleopatraapplication.h"
	#include "mainwindow.h"
	#include "settings.h"

	#include <interfaces/focusfirstchild.h>

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

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

	#include "utils/action_data.h"
	#include "utils/clipboardmenu.h"
	#include "utils/detail_p.h"
	#include "utils/filedialog.h"
	#include "utils/gui-helper.h"
	+#include "utils/keyexportdraghandler.h"

	#include <Libkleo/GnuPG>

	#include "dialogs/updatenotification.h"

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

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

	#include <Libkleo/Classify>
	#include <Libkleo/Compliance>
	#include <Libkleo/DocAction>
	#include <Libkleo/Formatting>
	#include <Libkleo/GnuPG>
	#include <Libkleo/KeyCache>
	#include <Libkleo/KeyListModel>
	#include <Libkleo/KeyListSortFilterProxyModel>
	#include <Libkleo/Stl_Util>
	#include <Libkleo/SystemInfo>

	#include <KSharedConfig>
	#include <chrono>
	#include <vector>
	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 CertificateView : public QWidget, public FocusFirstChild
	{
	Q_OBJECT
	public:
	CertificateView(QWidget *parent = nullptr)
	: QWidget{parent}
	, ui{this}
	{
	}

	SearchBar *searchBar() const
	{
	return ui.searchBar;
	}

	TabWidget *tabWidget() const
	{
	return ui.tabWidget;
	}

	void focusFirstChild(Qt::FocusReason reason) override
	{
	ui.searchBar->lineEdit()->setFocus(reason);
	}

	private:
	struct UI {
	TabWidget *tabWidget = nullptr;
	SearchBar *searchBar = nullptr;
	explicit UI(CertificateView *q)
	{
	auto vbox = new QVBoxLayout{q};
	vbox->setSpacing(0);

	searchBar = new SearchBar{q};
	vbox->addWidget(searchBar);
	tabWidget = new TabWidget{q};
	vbox->addWidget(tabWidget);

	tabWidget->connectSearchBar(searchBar);
	}
	} ui;
	};

	}

	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::questionTwoActionsCancel(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::ButtonCode::SecondaryAction) {
	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.searchTab->searchBar()->updateClickMessage(shortcutStr);
	}

	void updateStatusBar()
	{
	auto statusBar = std::make_unique<QStatusBar>();
	auto settings = KleopatraApplication::instance()->distributionSettings();
	bool showStatusbar = false;
	if (settings) {
	const QString statusline = settings->value(QStringLiteral("statusline"), {}).toString();
	if (!statusline.isEmpty()) {
	auto customStatusLbl = new QLabel(statusline);
	statusBar->insertWidget(0, customStatusLbl);
	showStatusbar = true;
	}
	}
	if (DeVSCompliance::isActive()) {
	auto statusLbl = std::make_unique<QLabel>(DeVSCompliance::name());
	if (!SystemInfo::isHighContrastModeActive()) {
	const auto color = KColorScheme(QPalette::Active, KColorScheme::View)
	.foreground(DeVSCompliance::isCompliant() ? KColorScheme::NormalText : KColorScheme::NegativeText)
	.color();
	const auto background = KColorScheme(QPalette::Active, KColorScheme::View)
	.background(DeVSCompliance::isCompliant() ? 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());
	showStatusbar = true;
	}

	if (showStatusbar) {
	q->setStatusBar(statusBar.release()); // QMainWindow takes ownership
	} else {
	q->setStatusBar(nullptr);
	}
	}

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

	void configureGroups()
	{
	// open groups config dialog as independent top-level window
	KleopatraApplication::instance()->openOrRaiseGroupsConfigDialog(nullptr);
	}

	void showHandbook();

	void gnupgLogViewer()
	{
	// Warning: Don't assume that the program needs to be in PATH. On Windows, it will also be found next to the calling process.
	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 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.searchTab->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);
	if (auto ffci = dynamic_cast<Kleo::FocusFirstChild *>(widget)) {
	ffci->focusFirstChild(Qt::TabFocusReason);
	}
	}

	void showCertificateView()
	{
	if (KeyCache::instance()->keys().empty()) {
	showView(QStringLiteral("view_certificate_overview"), ui.welcomeWidget);
	} else {
	showView(QStringLiteral("view_certificate_overview"), 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.searchTab->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 {
	CertificateView *searchTab = nullptr;
	PadWidget *padWidget = nullptr;
	SmartCardWidget *scWidget = nullptr;
	WelcomeWidget *welcomeWidget = nullptr;
	QStackedWidget *stackWidget = nullptr;
	explicit UI(MainWindow *q);
	} ui;
	QAction *focusToClickSearchAction = nullptr;
	ClipboardMenu *clipboadMenu = nullptr;
	};

	MainWindow::Private::UI::UI(MainWindow *q)
	: padWidget(nullptr)
	{
	auto mainWidget = new QWidget{q};
	auto mainLayout = new QVBoxLayout(mainWidget);
	mainLayout->setContentsMargins({});
	stackWidget = new QStackedWidget{q};

	searchTab = new CertificateView{q};
	stackWidget->addWidget(searchTab);

	new KeyCacheOverlay(mainWidget, q);

	scWidget = new SmartCardWidget{q};
	stackWidget->addWidget(scWidget);

	welcomeWidget = new WelcomeWidget{q};
	stackWidget->addWidget(welcomeWidget);

	mainLayout->addWidget(stackWidget);

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

	+ auto flatKeyExportDragHandler = new KeyExportDragHandler(flatModel);
	+ flatModel->setDragHandler(flatKeyExportDragHandler);
	+
	+ auto hierarchicalKeyExportDragHandler = new KeyExportDragHandler(hierarchicalModel);
	+ hierarchicalModel->setDragHandler(hierarchicalKeyExportDragHandler);
	+
	controller.setFlatModel(flatModel);
	controller.setHierarchicalModel(hierarchicalModel);
	controller.setTabWidget(ui.searchTab->tabWidget());

	ui.searchTab->tabWidget()->setFlatModel(flatModel);
	ui.searchTab->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"));

	// make toolbar buttons accessible by keyboard
	auto toolbar = q->findChild<KToolBar *>();
	if (toolbar) {
	auto toolbarButtons = toolbar->findChildren<QToolButton *>();
	for (auto b : toolbarButtons) {
	b->setFocusPolicy(Qt::TabFocus);
	}
	// move toolbar and its child widgets before the central widget in the tab order;
	// this is necessary to make Shift+Tab work as expected
	forceSetTabOrder(q, toolbar);
	auto toolbarChildren = toolbar->findChildren<QWidget *>();
	std::for_each(std::rbegin(toolbarChildren), std::rend(toolbarChildren), [toolbar](auto w) {
	forceSetTabOrder(toolbar, w);
	});
	}

	if (auto action = q->actionCollection()->action(QStringLiteral("help_whats_this"))) {
	delete action;
	}

	q->setAcceptDrops(true);

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

	updateSearchBarClickMessage();
	updateStatusBar();

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

	// delay setting the models to use the key cache so that the UI (including
	// the "Loading certificate cache..." overlay) is shown before the
	// blocking key cache initialization happens
	QMetaObject::invokeMethod(
	q,
	[flatModel, hierarchicalModel]() {
	flatModel->useKeyCache(true, KeyList::AllKeys);
	hierarchicalModel->useKeyCache(true, KeyList::AllKeys);
	},
	Qt::QueuedConnection);
	}

	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,
	[this](bool) {
	gnupgLogViewer();
	},
	QString(),
	},
	#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,
	[this](bool) {
	restartDaemons();
	},
	{},
	},
	// Help menu
	#ifdef Q_OS_WIN
	{
	"help_check_updates",
	i18n("Check for updates"),
	QString(),
	"gpg4win-compact",
	q,
	[this](bool) {
	forceUpdateCheck();
	},
	QString(),
	},
	#endif
	// View menu
	{
	"view_certificate_overview",
	i18nc("@action show certificate overview", "Certificates"),
	i18n("Show certificate overview"),
	"view-certificate",
	q,
	[this](bool) {
	showCertificateView();
	},
	QString(),
	},
	{
	"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,
	[this](bool) {
	showPadView();
	},
	QString(),
	},
	{
	"manage_smartcard",
	i18nc("@action show smartcard management view", "Smartcards"),
	i18n("Show smartcard management"),
	"auth-sim-locked",
	q,
	[this](bool) {
	showSmartcardView();
	},
	QString(),
	},
	// Settings menu
	{
	"settings_self_test",
	i18n("Perform Self-Test"),
	QString(),
	nullptr,
	q,
	[this](bool) {
	selfTest();
	},
	QString(),
	},
	{
	"configure_groups",
	i18n("Configure Groups..."),
	QString(),
	"group",
	q,
	[this](bool) {
	configureGroups();
	},
	QString(),
	}};

	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);
	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 quickguide =
	new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")),
	i18n("&Quickguide"),
	i18nc("Only available in German and English. Leave to English for other languages.", "encrypt_and_sign_gnupgvsd_en.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"),
	coll);
	coll->addAction(QStringLiteral("help_doc_quickguide"), quickguide);

	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.", "symmetric_encryption_gnupgvsd_en.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"),
	coll);
	coll->addAction(QStringLiteral("help_doc_symenc"), symguide);

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

	#ifdef Q_OS_WIN
	const auto gpgol =
	new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")),
	i18n("&Mail encryption in Outlook"),
	i18nc("Only available in German and English. Leave to English for other languages. Only shown on Windows.", "gpgol_outlook_addin_en.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"),
	coll);
	coll->addAction(QStringLiteral("help_doc_gpgol"), gpgol);
	#endif

	/* The submenu with advanced topics */
	const auto certmngmnt =
	new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")),
	i18n("&Certification Management"),
	i18nc("Only available in German and English. Leave to English for other languages.", "certification_management_gnupgvsd_en.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"),
	coll);
	coll->addAction(QStringLiteral("help_doc_cert_management"), certmngmnt);

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

	const auto man_gnupg = new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")),
	i18n("GnuPG Command&line"),
	QStringLiteral("gnupg_manual_en.pdf"),
	QStringLiteral("../share/doc/gnupg-vsd"),
	coll);
	coll->addAction(QStringLiteral("help_doc_gnupg"), man_gnupg);

	/* The secops */
	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);
	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);
	coll->addAction(QStringLiteral("help_doc_vsa10584"), vsa10584);

	q->setStandardToolBarMenuEnabled(true);

	controller.createActions(coll);

	ui.searchTab->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.searchTab->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.searchTab->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());

	KleopatraApplication::instance()->handleFiles(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 "mainwindow.moc"
	#include "moc_mainwindow.cpp"
	diff --git a/src/utils/keyexportdraghandler.cpp b/src/utils/keyexportdraghandler.cpp
	new file mode 100644
	index 000000000..9bf575b34
	--- /dev/null
	+++ b/src/utils/keyexportdraghandler.cpp
	@@ -0,0 +1,138 @@
	+// SPDX-FileCopyrightText: 2024 g10 Code GmbH
	+// SPDX-License-Identifier: GPL-2.0-or-later
	+
	+#include "keyexportdraghandler.h"
	+
	+#include "kleopatra_debug.h"
	+
	+#include <Libkleo/Formatting>
	+#include <Libkleo/KeyList>
	+
	+#include <QGpgME/ExportJob>
	+#include <QGpgME/Protocol>
	+
	+#include <gpgme++/key.h>
	+
	+#include <QEventLoop>
	+#include <QRegularExpression>
	+#include <QTemporaryFile>
	+#include <QUrl>
	+
	+using namespace GpgME;
	+using namespace Kleo;
	+
	+static QStringList supportedMimeTypes = {
	+ QStringLiteral("text/uri-list"),
	+ QStringLiteral("application/pgp-keys"),
	+ QStringLiteral("text/plain"),
	+};
	+
	+class KeyExportMimeData : public QMimeData
	+{
	+public:
	+ QVariant retrieveData(const QString &mimeType, QMetaType type) const override
	+ {
	+ Q_UNUSED(type);
	+ QByteArray pgpData;
	+ QByteArray smimeData;
	+
	+ if (!pgpFprs.isEmpty()) {
	+ auto job = QGpgME::openpgp()->publicKeyExportJob(true);
	+ job->exec(pgpFprs, pgpData);
	+ }
	+ if (!smimeFprs.isEmpty()) {
	+ auto job = QGpgME::smime()->publicKeyExportJob(true);
	+ job->exec(smimeFprs, smimeData);
	+ }
	+
	+ if (mimeType == QStringLiteral("text/uri-list")) {
	+ auto file = new QTemporaryFile();
	+
	+ file->setFileTemplate(name);
	+ file->open();
	+ file->write(pgpData + smimeData);
	+ const auto newName = file->fileName().remove(QRegularExpression(QStringLiteral("\\.[^.]+$")));
	+ file->rename(newName);
	+ file->close();
	+ return QUrl(QStringLiteral("file://%1").arg(newName));
	+ } else if (mimeType == QStringLiteral("application/pgp-keys")) {
	+ return pgpData;
	+ } else if (mimeType == QStringLiteral("text/plain")) {
	+ QByteArray data = pgpData + smimeData;
	+ return data;
	+ }
	+
	+ return {};
	+ }
	+ bool hasFormat(const QString &mimeType) const override
	+ {
	+ return supportedMimeTypes.contains(mimeType);
	+ ;
	+ }
	+ QStringList formats() const override
	+ {
	+ return supportedMimeTypes;
	+ }
	+ QStringList pgpFprs;
	+ QStringList smimeFprs;
	+ QString name;
	+};
	+
	+KeyExportDragHandler::KeyExportDragHandler(QAbstractItemModel *model)
	+ : QObject(model)
	+ , m_model(model)
	+{
	+}
	+
	+QStringList KeyExportDragHandler::mimeTypes() const
	+{
	+ return supportedMimeTypes;
	+}
	+
	+Qt::ItemFlags KeyExportDragHandler::flags(const QModelIndex &index) const
	+{
	+ Qt::ItemFlags defaultFlags = m_model->QAbstractItemModel::flags(index);
	+ return Qt::ItemIsDragEnabled \| defaultFlags;
	+}
	+
	+QMimeData *KeyExportDragHandler::mimeData(const QModelIndexList &indexes) const
	+{
	+ auto mimeData = new KeyExportMimeData();
	+
	+ QStringList pgpFprs;
	+ QStringList smimeFprs;
	+
	+ // apparently we're getting an index for each column even though we're selecting whole rows
	+ // so figure out whether we're actually selecting more than one row
	+ bool singleRow = true;
	+ int row = indexes[0].row();
	+ auto parent = indexes[0].parent();
	+
	+ for (const auto &index : indexes) {
	+ auto key = index.data(KeyList::KeyRole).value<Key>();
	+
	+ if (key.protocol() == GpgME::OpenPGP) {
	+ pgpFprs += m_model->index(index.row(), KeyList::Columns::Fingerprint, index.parent()).data(0).toString();
	+ } else {
	+ smimeFprs += m_model->index(index.row(), KeyList::Columns::Fingerprint, index.parent()).data(0).toString();
	+ }
	+
	+ if (index.row() != row \|\| index.parent() != parent) {
	+ singleRow = false;
	+ }
	+ }
	+
	+ if (singleRow) {
	+ auto name = m_model->index(indexes[0].row(), KeyList::Columns::PrettyName, indexes[0].parent()).data(0).toString();
	+ if (name.isEmpty()) {
	+ name = m_model->index(indexes[0].row(), KeyList::Columns::PrettyEMail, indexes[0].parent()).data(0).toString();
	+ }
	+ mimeData->name = QStringLiteral("%1_%2_public.asc")
	+ .arg(name)
	+ .arg(Formatting::prettyKeyID(
	+ m_model->index(indexes[0].row(), KeyList::Columns::ShortKeyID, indexes[0].parent()).data(0).toString().toLatin1().data()));
	+ }
	+ mimeData->pgpFprs = pgpFprs;
	+ mimeData->smimeFprs = smimeFprs;
	+ return mimeData;
	+}
	diff --git a/src/utils/keyexportdraghandler.h b/src/utils/keyexportdraghandler.h
	new file mode 100644
	index 000000000..7362ed1bf
	--- /dev/null
	+++ b/src/utils/keyexportdraghandler.h
	@@ -0,0 +1,23 @@
	+// SPDX-FileCopyrightText: 2024 g10 Code GmbH
	+// SPDX-License-Identifier: GPL-2.0-or-later
	+
	+#pragma once
	+
	+#include <Libkleo/KeyListModel>
	+
	+#include <QAbstractItemModel>
	+#include <QMimeData>
	+#include <QObject>
	+#include <QStringList>
	+
	+class KeyExportDragHandler : public Kleo::DragHandler, QObject
	+{
	+public:
	+ explicit KeyExportDragHandler(QAbstractItemModel *model);
	+ QMimeData *mimeData(const QModelIndexList &indexes) const override;
	+ Qt::ItemFlags flags(const QModelIndex &index) const override;
	+ QStringList mimeTypes() const override;
	+
	+private:
	+ QAbstractItemModel *m_model = nullptr;
	+};
	diff --git a/src/view/tabwidget.cpp b/src/view/tabwidget.cpp
	index 6ae4e044e..bd2cea205 100644
	--- a/src/view/tabwidget.cpp
	+++ b/src/view/tabwidget.cpp
	@@ -1,1108 +1,1110 @@
	/* -- 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 "tabwidget.h"

	#include "keytreeview.h"
	#include "kleopatra_debug.h"
	#include "searchbar.h"

	#include <settings.h>

	#include <utils/action_data.h>

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

	#include <gpgme++/key.h>

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

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

	#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()
	{
	+ view()->setDragDropMode(QAbstractItemView::DragOnly);
	+ view()->setDragEnabled(true);
	}

	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,
	[this](bool) {
	d->slotNewTab();
	},
	QStringLiteral("CTRL+SHIFT+N"),
	};

	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,
	[this](bool) {
	d->slotRenameCurrentTab();
	},
	QStringLiteral("CTRL+SHIFT+R"),
	RegularQAction,
	Disabled,
	},
	{
	Actions::Duplicate,
	i18n("Duplicate Tab"),
	i18n("Duplicate this tab"),
	"tab-duplicate",
	this,
	[this](bool) {
	d->slotDuplicateCurrentTab();
	},
	QStringLiteral("CTRL+SHIFT+D"),
	},
	{
	Actions::Close,
	i18n("Close Tab"),
	i18n("Close this tab"),
	"tab-close",
	this,
	[this](bool) {
	d->slotCloseCurrentTab();
	},
	QStringLiteral("CTRL+SHIFT+W"),
	RegularQAction,
	Disabled,
	}, // ### CTRL-W when available
	{
	Actions::MoveLeft,
	i18n("Move Tab Left"),
	i18n("Move this tab left"),
	nullptr,
	this,
	[this](bool) {
	d->slotMoveCurrentTabLeft();
	},
	QStringLiteral("CTRL+SHIFT+LEFT"),
	RegularQAction,
	Disabled,
	},
	{
	Actions::MoveRight,
	i18n("Move Tab Right"),
	i18n("Move this tab right"),
	nullptr,
	this,
	[this](bool) {
	d->slotMoveCurrentTabRight();
	},
	QStringLiteral("CTRL+SHIFT+RIGHT"),
	RegularQAction,
	Disabled,
	},
	{
	Actions::Hierarchical,
	i18n("Hierarchical Certificate List"),
	QString(),
	nullptr,
	this,
	[this](bool on) {
	d->slotToggleHierarchicalView(on);
	},
	QString(),
	KFToggleAction,
	Disabled,
	},
	{
	Actions::ExpandAll,
	i18n("Expand All"),
	QString(),
	nullptr,
	this,
	[this](bool) {
	d->slotExpandAll();
	},
	QStringLiteral("CTRL+."),
	RegularQAction,
	Disabled,
	},
	{
	Actions::CollapseAll,
	i18n("Collapse All"),
	QString(),
	nullptr,
	this,
	[this](bool) {
	d->slotCollapseAll();
	},
	QStringLiteral("CTRL+,"),
	RegularQAction,
	Disabled,
	},
	};

	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.actionState == 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(QStringLiteral("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"

File Metadata

Mime Type: text/x-diff
Expires: Thu, Feb 26, 6:26 PM (48 m, 57 s)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 61/d1/5ff505addd987708a901288cee02

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions