No OneTemporary
Actions

Size

26 KB

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 4087ebaba..bd1412df1 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,176 +1,176 @@
	set(kleopatra_version 3.1.15)
	# The following is for Windows. Keep in line with kleopatra_version.
	set(kleopatra_fileversion 3,1,15,0)
	cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
	project(kleopatra VERSION ${kleopatra_version})

	# The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
	if (NOT RELEASE_SERVICE_VERSION)
	set (RELEASE_SERVICE_VERSION "21.03.80")
	endif()

	option(FORCE_DISABLE_KCMUTILS "Force building Kleopatra without KCMUtils. Doing this will disable configuration KCM Plugins. [default=OFF]" OFF)
	option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)

	# Standalone build. Find / include everything necessary.
	set(KF5_MIN_VERSION "5.78.0")
	set(KMIME_VERSION "5.16.40")
	-set(LIBKLEO_VERSION "5.16.46")
	+set(LIBKLEO_VERSION "5.16.47")
	set(QT_REQUIRED_VERSION "5.14.0")
	set(GPGME_REQUIRED_VERSION "1.13.1")

	if (WIN32)
	set(KF5_WANT_VERSION "5.70.0")
	set(KMIME_WANT_VERSION "5.12.0")
	else ()
	set(KF5_WANT_VERSION ${KF5_MIN_VERSION})
	set(KMIME_WANT_VERSION ${KMIME_VERSION})
	endif ()

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


	include(ECMInstallIcons)
	include(ECMSetupVersion)
	include(ECMAddTests)

	include(GenerateExportHeader)
	include(ECMGenerateHeaders)

	include(FeatureSummary)
	include(CheckFunctionExists)
	include(ECMGeneratePriFile)

	include(KDEInstallDirs)
	include(KDECMakeSettings)
	include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
	include(ECMAddAppIcon)
	include(ECMQtDeclareLoggingCategory)

	# Find KF5 packages
	if (NOT FORCE_DISABLE_KCMUTILS)
	find_package(KF5KCMUtils ${KF5_WANT_VERSION} CONFIG REQUIRED)
	endif()
	find_package(KF5WidgetsAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5ConfigWidgets ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5CoreAddons ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5Codecs ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5Config ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5I18n ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5IconThemes ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5ItemModels ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5XmlGui ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5WindowSystem ${KF5_WANT_VERSION} CONFIG REQUIRED)
	find_package(KF5DocTools ${KF5_WANT_VERSION} CONFIG)
	find_package(KF5Crash ${KF5_WANT_VERSION} REQUIRED)

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

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

	set(HAVE_QDBUS ${Qt5DBus_FOUND})

	find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
	find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)

	# Kdepimlibs packages
	find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
	find_package(KF5Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)

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

	find_package(Assuan2 REQUIRED)

	set(HAVE_KCMUTILS ${KF5KCMUtils_FOUND})
	set(CMAKE_CXX_STANDARD 14)
	set(CMAKE_CXX_STANDARD_REQUIRED ON)


	find_package(Boost 1.34.0 REQUIRED)

	find_path(Boost_TOPOLOGICAL_SORT_DIR NAMES boost/graph/topological_sort.hpp PATHS ${Boost_INCLUDE_DIRS})
	if(NOT Boost_TOPOLOGICAL_SORT_DIR)
	message(FATAL_ERROR "The Boost Topological_sort header was NOT found. Should be part of Boost graph module.")
	endif()

	set(kleopatra_release FALSE)

	if(NOT kleopatra_release)
	if(GIT_FOUND)
	execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
	WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
	OUTPUT_VARIABLE Kleopatra_WC_REVISION)
	string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")

	execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%ci ${CMAKE_CURRENT_SOURCE_DIR}
	WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
	OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
	string(REGEX REPLACE " [-0-9:+ ]*\n" "" Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")

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

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

	include (ConfigureChecks.cmake)

	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
	include_directories(
	${CMAKE_CURRENT_BINARY_DIR}
	${CMAKE_CURRENT_SOURCE_DIR}
	${Boost_INCLUDE_DIR}
	${ASSUAN2_INCLUDES}
	)

	add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
	#add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050f00)
	add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x054F00)
	if(CMAKE_COMPILER_IS_GNUCXX)
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
	endif()
	add_definitions(-DQT_NO_EMIT)

	kde_enable_exceptions()
	option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" FALSE)

	set(COMPILE_WITH_UNITY_CMAKE_SUPPORT false)
	if (USE_UNITY_CMAKE_SUPPORT)
	if(${CMAKE_VERSION} VERSION_LESS "3.16.0")
	message(STATUS "CMAKE version is less than 3.16.0 . We can't use cmake unify build support")
	else()
	set(COMPILE_WITH_UNITY_CMAKE_SUPPORT true)
	endif()
	endif()

	add_subdirectory(pics)
	add_subdirectory(src)

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

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

	if(KF5DocTools_FOUND)
	add_subdirectory(doc)
	endif()
	diff --git a/src/kleopatraapplication.cpp b/src/kleopatraapplication.cpp
	index 2525bf917..74ec81541 100644
	--- a/src/kleopatraapplication.cpp
	+++ b/src/kleopatraapplication.cpp
	@@ -1,647 +1,648 @@
	/*
	kleopatraapplication.cpp

	This file is part of Kleopatra, the KDE keymanager
	SPDX-FileCopyrightText: 2008 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
	*/

	#include <config-kleopatra.h>

	#include "kleopatraapplication.h"

	#include "mainwindow.h"
	#include "kleopatra_options.h"
	#include "systrayicon.h"
	#include <smartcard/readerstatus.h>
	#include <conf/configuredialog.h>

	#include <Libkleo/GnuPG>
	#include <utils/kdpipeiodevice.h>
	#include <utils/log.h>

	#include <gpgme++/key.h>

	#include <Libkleo/FileSystemWatcher>
	#include <Libkleo/KeyCache>
	#include <Libkleo/Classify>

	#ifdef HAVE_USABLE_ASSUAN
	# include <uiserver/uiserver.h>
	#endif

	#include "commands/signencryptfilescommand.h"
	#include "commands/decryptverifyfilescommand.h"
	#include "commands/lookupcertificatescommand.h"
	#include "commands/checksumcreatefilescommand.h"
	#include "commands/checksumverifyfilescommand.h"
	#include "commands/detailscommand.h"
	#include "commands/newcertificatecommand.h"

	#include "dialogs/updatenotification.h"

	#include <KIconLoader>
	#include <KLocalizedString>
	#include "kleopatra_debug.h"
	#include <KMessageBox>
	#include <KWindowSystem>

	#include <QFile>
	#include <QDir>
	#include <QPointer>

	#include <memory>
	#include <KSharedConfig>

	using namespace Kleo;
	using namespace Kleo::Commands;

	static void add_resources()
	{
	KIconLoader::global()->addAppDir(QStringLiteral("libkleopatra"));
	KIconLoader::global()->addAppDir(QStringLiteral("kwatchgnupg"));
	}

	static QList<QByteArray> default_logging_options()
	{
	QList<QByteArray> result;
	result.push_back("io");
	return result;
	}

	class KleopatraApplication::Private
	{
	friend class ::KleopatraApplication;
	KleopatraApplication *const q;
	public:
	explicit Private(KleopatraApplication *qq)
	: q(qq),
	ignoreNewInstance(true),
	firstNewInstance(true),
	sysTray(nullptr)
	{
	}
	~Private() {
	#ifndef QT_NO_SYSTEMTRAYICON
	delete sysTray;
	#endif
	}
	void init()
	{
	KDAB_SET_OBJECT_NAME(readerStatus);
	#ifndef QT_NO_SYSTEMTRAYICON
	sysTray = new SysTrayIcon();
	sysTray->setFirstCardWithNullPin(readerStatus.firstCardWithNullPin());
	sysTray->setAnyCardCanLearnKeys(readerStatus.anyCardCanLearnKeys());

	connect(&readerStatus, &SmartCard::ReaderStatus::firstCardWithNullPinChanged,
	sysTray, &SysTrayIcon::setFirstCardWithNullPin);
	connect(&readerStatus, &SmartCard::ReaderStatus::anyCardCanLearnKeysChanged,
	sysTray, &SysTrayIcon::setAnyCardCanLearnKeys);
	#endif
	}

	private:
	void connectConfigureDialog()
	{
	if (configureDialog && q->mainWindow()) {
	connect(configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()));
	}
	}
	void disconnectConfigureDialog()
	{
	if (configureDialog && q->mainWindow()) {
	disconnect(configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()));
	}
	}

	public:
	bool ignoreNewInstance;
	bool firstNewInstance;
	QPointer<ConfigureDialog> configureDialog;
	QPointer<MainWindow> mainWindow;
	SmartCard::ReaderStatus readerStatus;
	#ifndef QT_NO_SYSTEMTRAYICON
	SysTrayIcon *sysTray;
	#endif
	std::shared_ptr<KeyCache> keyCache;
	std::shared_ptr<Log> log;
	std::shared_ptr<FileSystemWatcher> watcher;

	public:
	void setupKeyCache()
	{
	keyCache = KeyCache::mutableInstance();
	watcher.reset(new FileSystemWatcher);

	watcher->whitelistFiles(gnupgFileWhitelist());
	watcher->addPath(gnupgHomeDirectory());
	watcher->setDelay(1000);
	keyCache->addFileSystemWatcher(watcher);
	+ keyCache->setGroupsConfig(QStringLiteral("kleopatragroupsrc"));
	}

	void setupLogging()
	{
	log = Log::mutableInstance();

	const QByteArray envOptions = qgetenv("KLEOPATRA_LOGOPTIONS");
	const bool logAll = envOptions.trimmed() == "all";
	const QList<QByteArray> options = envOptions.isEmpty() ? default_logging_options() : envOptions.split(',');

	const QByteArray dirNative = qgetenv("KLEOPATRA_LOGDIR");
	if (dirNative.isEmpty()) {
	return;
	}
	const QString dir = QFile::decodeName(dirNative);
	const QString logFileName = QDir(dir).absoluteFilePath(QStringLiteral("kleopatra.log.%1").arg(QCoreApplication::applicationPid()));
	std::unique_ptr<QFile> logFile(new QFile(logFileName));
	if (!logFile->open(QIODevice::WriteOnly \| QIODevice::Append)) {
	qCDebug(KLEOPATRA_LOG) << "Could not open file for logging: " << logFileName << "\nLogging disabled";
	return;
	}

	log->setOutputDirectory(dir);
	if (logAll \|\| options.contains("io")) {
	log->setIOLoggingEnabled(true);
	}
	qInstallMessageHandler(Log::messageHandler);

	#ifdef HAVE_USABLE_ASSUAN
	if (logAll \|\| options.contains("pipeio")) {
	KDPipeIODevice::setDebugLevel(KDPipeIODevice::Debug);
	}
	UiServer::setLogStream(log->logFile());
	#endif

	}
	};

	KleopatraApplication::KleopatraApplication(int &argc, char *argv[])
	: QApplication(argc, argv), d(new Private(this))
	{
	}

	void KleopatraApplication::init()
	{
	d->init();
	add_resources();
	d->setupKeyCache();
	d->setupLogging();
	#ifndef QT_NO_SYSTEMTRAYICON
	d->sysTray->show();
	#endif
	setQuitOnLastWindowClosed(false);
	KWindowSystem::allowExternalProcessWindowActivation();
	}

	KleopatraApplication::~KleopatraApplication()
	{
	// main window doesn't receive "close" signal and cannot
	// save settings before app exit
	delete d->mainWindow;

	// work around kdelibs bug https://bugs.kde.org/show_bug.cgi?id=162514
	KSharedConfig::openConfig()->sync();
	}

	namespace
	{
	typedef void (KleopatraApplication::*Func)(const QStringList &, GpgME::Protocol);
	}

	void KleopatraApplication::slotActivateRequested(const QStringList &arguments,
	const QString &workingDirectory)
	{
	QCommandLineParser parser;

	kleopatra_options(&parser);
	QString err;
	if (!arguments.isEmpty() && !parser.parse(arguments)) {
	err = parser.errorText();
	} else if (arguments.isEmpty()) {
	// KDBusServices omits the application name if no other
	// arguments are provided. In that case the parser prints
	// a warning.
	parser.parse(QStringList() << QCoreApplication::applicationFilePath());
	}

	if (err.isEmpty()) {
	err = newInstance(parser, workingDirectory);
	}

	if (!err.isEmpty()) {
	KMessageBox::sorry(nullptr, err.toHtmlEscaped(), i18n("Failed to execute command"));
	Q_EMIT setExitValue(1);
	return;
	}
	Q_EMIT setExitValue(0);
	}

	QString KleopatraApplication::newInstance(const QCommandLineParser &parser,
	const QString &workingDirectory)
	{
	if (d->ignoreNewInstance) {
	qCDebug(KLEOPATRA_LOG) << "New instance ignored because of ignoreNewInstance";
	return QString();
	}

	QStringList files;
	const QDir cwd = QDir(workingDirectory);
	bool queryMode = parser.isSet(QStringLiteral("query")) \|\| parser.isSet(QStringLiteral("search"));

	// Query and Search treat positional arguments differently, see below.
	if (!queryMode) {
	const auto positionalArguments = parser.positionalArguments();
	for (const QString &file : positionalArguments) {
	// We do not check that file exists here. Better handle
	// these errors in the UI.
	if (QFileInfo(file).isAbsolute()) {
	files << file;
	} else {
	files << cwd.absoluteFilePath(file);
	}
	}
	}

	GpgME::Protocol protocol = GpgME::UnknownProtocol;

	if (parser.isSet(QStringLiteral("openpgp"))) {
	qCDebug(KLEOPATRA_LOG) << "found OpenPGP";
	protocol = GpgME::OpenPGP;
	}

	if (parser.isSet(QStringLiteral("cms"))) {
	qCDebug(KLEOPATRA_LOG) << "found CMS";
	if (protocol == GpgME::OpenPGP) {
	return i18n("Ambiguous protocol: --openpgp and --cms");
	}
	protocol = GpgME::CMS;
	}

	// Check for Parent Window id
	WId parentId = 0;
	if (parser.isSet(QStringLiteral("parent-windowid"))) {
	#ifdef Q_OS_WIN
	// WId is not a portable type as it is a pointer type on Windows.
	// casting it from an integer is ok though as the values are guaranteed to
	// be compatible in the documentation.
	parentId = reinterpret_cast<WId>(parser.value(QStringLiteral("parent-windowid")).toUInt());
	#else
	parentId = parser.value(QStringLiteral("parent-windowid")).toUInt();
	#endif
	}

	// Handle openpgp4fpr URI scheme
	QString needle;
	if (queryMode) {
	needle = parser.positionalArguments().join(QLatin1Char(' '));
	}
	if (needle.startsWith(QLatin1String("openpgp4fpr:"))) {
	needle.remove(0, 12);
	}

	// Check for --search command.
	if (parser.isSet(QStringLiteral("search"))) {
	// This is an extra command instead of a combination with the
	// similar query to avoid changing the older query commands behavior
	// and query's "show details if a certificate exist or search on a
	// keyserver" logic is hard to explain and use consistently.
	if (needle.isEmpty()) {
	return i18n("No search string specified for --search");
	}
	LookupCertificatesCommand *const cmd = new LookupCertificatesCommand(needle, nullptr);
	cmd->setParentWId(parentId);
	cmd->start();
	return QString();
	}

	// Check for --query command
	if (parser.isSet(QStringLiteral("query"))) {
	if (needle.isEmpty()) {
	return i18n("No fingerprint argument specified for --query");
	}
	auto cmd = Command::commandForQuery(needle);
	cmd->setParentWId(parentId);
	cmd->start();
	return QString();
	}

	// Check for --gen-key command
	if (parser.isSet(QStringLiteral("gen-key"))) {
	auto cmd = new NewCertificateCommand(nullptr);
	cmd->setParentWId(parentId);
	cmd->setProtocol(protocol);
	cmd->start();
	return QString();
	}

	// Check for --config command
	if (parser.isSet(QStringLiteral("config"))) {
	openConfigDialogWithForeignParent(parentId);
	return QString();
	}

	static const QMap<QString, Func> funcMap {
	{ QStringLiteral("import-certificate"), &KleopatraApplication::importCertificatesFromFile },
	{ QStringLiteral("encrypt"), &KleopatraApplication::encryptFiles },
	{ QStringLiteral("sign"), &KleopatraApplication::signFiles },
	{ QStringLiteral("encrypt-sign"), &KleopatraApplication::signEncryptFiles },
	{ QStringLiteral("sign-encrypt"), &KleopatraApplication::signEncryptFiles },
	{ QStringLiteral("decrypt"), &KleopatraApplication::decryptFiles },
	{ QStringLiteral("verify"), &KleopatraApplication::verifyFiles },
	{ QStringLiteral("decrypt-verify"), &KleopatraApplication::decryptVerifyFiles },
	{ QStringLiteral("checksum"), &KleopatraApplication::checksumFiles },
	};

	QString found;
	Q_FOREACH (const QString &opt, funcMap.keys()) {
	if (parser.isSet(opt) && found.isEmpty()) {
	found = opt;
	} else if (parser.isSet(opt)) {
	return i18n("Ambiguous commands \"%1\" and \"%2\"", found, opt);
	}
	}

	QStringList errors;
	if (!found.isEmpty()) {
	if (files.empty()) {
	return i18n("No files specified for \"%1\" command", found);
	}
	qCDebug(KLEOPATRA_LOG) << "found" << found;
	(this->*funcMap.value(found))(files, protocol);
	} else {
	if (files.empty()) {
	if (!(d->firstNewInstance && isSessionRestored())) {
	qCDebug(KLEOPATRA_LOG) << "openOrRaiseMainWindow";
	openOrRaiseMainWindow();
	}
	} else {
	for (const QString& fileName : qAsConst(files)) {
	QFileInfo fi(fileName);
	if (!fi.isReadable()) {
	errors << i18n("Cannot read \"%1\"", fileName);
	}
	}
	Q_FOREACH (Command *cmd, Command::commandsForFiles(files)) {
	if (parentId) {
	cmd->setParentWId(parentId);
	} else {
	MainWindow *mw = mainWindow();
	if (!mw) {
	mw = new MainWindow;
	mw->setAttribute(Qt::WA_DeleteOnClose);
	setMainWindow(mw);
	d->connectConfigureDialog();
	}
	cmd->setParentWidget(mw);
	}
	cmd->start();
	}
	}
	}
	d->firstNewInstance = false;

	#ifdef Q_OS_WIN
	// On Windows we might be started from the
	// explorer in any working directory. E.g.
	// a double click on a file. To avoid preventing
	// the folder from deletion we set the
	// working directory to the users homedir.
	QDir::setCurrent(QDir::homePath());
	#endif

	return errors.join(QLatin1Char('\n'));
	}

	#ifndef QT_NO_SYSTEMTRAYICON
	const SysTrayIcon *KleopatraApplication::sysTrayIcon() const
	{
	return d->sysTray;
	}

	SysTrayIcon *KleopatraApplication::sysTrayIcon()
	{
	return d->sysTray;
	}
	#endif

	const MainWindow *KleopatraApplication::mainWindow() const
	{
	return d->mainWindow;
	}

	MainWindow *KleopatraApplication::mainWindow()
	{
	return d->mainWindow;
	}

	void KleopatraApplication::setMainWindow(MainWindow *mainWindow)
	{
	if (mainWindow == d->mainWindow) {
	return;
	}

	d->disconnectConfigureDialog();

	d->mainWindow = mainWindow;
	#ifndef QT_NO_SYSTEMTRAYICON
	d->sysTray->setMainWindow(mainWindow);
	#endif

	d->connectConfigureDialog();
	}

	static void open_or_raise(QWidget *w)
	{
	if (w->isMinimized()) {
	KWindowSystem::unminimizeWindow(w->winId());
	w->raise();
	} else if (w->isVisible()) {
	w->raise();
	} else {
	w->show();
	}
	}

	void KleopatraApplication::toggleMainWindowVisibility()
	{
	if (mainWindow()) {
	mainWindow()->setVisible(!mainWindow()->isVisible());
	} else {
	openOrRaiseMainWindow();
	}
	}

	void KleopatraApplication::restoreMainWindow()
	{
	qCDebug(KLEOPATRA_LOG) << "restoring main window";

	// Sanity checks
	if (!isSessionRestored()) {
	qCDebug(KLEOPATRA_LOG) << "Not in session restore";
	return;
	}

	if (mainWindow()) {
	qCDebug(KLEOPATRA_LOG) << "Already have main window";
	return;
	}

	MainWindow *mw = new MainWindow;
	if (KMainWindow::canBeRestored(1)) {
	// restore to hidden state, Mainwindow::readProperties() will
	// restore saved visibility.
	mw->restore(1, false);
	}

	mw->setAttribute(Qt::WA_DeleteOnClose);
	setMainWindow(mw);
	d->connectConfigureDialog();

	}

	void KleopatraApplication::openOrRaiseMainWindow()
	{
	MainWindow *mw = mainWindow();
	if (!mw) {
	mw = new MainWindow;
	mw->setAttribute(Qt::WA_DeleteOnClose);
	setMainWindow(mw);
	d->connectConfigureDialog();
	}
	open_or_raise(mw);
	UpdateNotification::checkUpdate(mw);
	}

	void KleopatraApplication::openConfigDialogWithForeignParent(WId parentWId)
	{
	if (!d->configureDialog) {
	d->configureDialog = new ConfigureDialog;
	d->configureDialog->setAttribute(Qt::WA_DeleteOnClose);
	d->connectConfigureDialog();
	}

	// This is similar to what the commands do.
	if (parentWId) {
	if (QWidget *pw = QWidget::find(parentWId)) {
	d->configureDialog->setParent(pw, d->configureDialog->windowFlags());
	} else {
	d->configureDialog->setAttribute(Qt::WA_NativeWindow, true);
	KWindowSystem::setMainWindow(d->configureDialog->windowHandle(), parentWId);
	}
	}

	open_or_raise(d->configureDialog);

	// If we have a parent we want to raise over it.
	if (parentWId) {
	d->configureDialog->raise();
	}
	}

	void KleopatraApplication::openOrRaiseConfigDialog()
	{
	openConfigDialogWithForeignParent(0);
	}

	#ifndef QT_NO_SYSTEMTRAYICON
	void KleopatraApplication::startMonitoringSmartCard()
	{
	d->readerStatus.startMonitoring();
	}
	#endif // QT_NO_SYSTEMTRAYICON

	void KleopatraApplication::importCertificatesFromFile(const QStringList &files, GpgME::Protocol /proto/)
	{
	openOrRaiseMainWindow();
	if (!files.empty()) {
	mainWindow()->importCertificatesFromFile(files);
	}
	}

	void KleopatraApplication::encryptFiles(const QStringList &files, GpgME::Protocol proto)
	{
	SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
	cmd->setEncryptionPolicy(Force);
	cmd->setSigningPolicy(Allow);
	if (proto != GpgME::UnknownProtocol) {
	cmd->setProtocol(proto);
	}
	cmd->start();
	}

	void KleopatraApplication::signFiles(const QStringList &files, GpgME::Protocol proto)
	{
	SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
	cmd->setSigningPolicy(Force);
	cmd->setEncryptionPolicy(Deny);
	if (proto != GpgME::UnknownProtocol) {
	cmd->setProtocol(proto);
	}
	cmd->start();
	}

	void KleopatraApplication::signEncryptFiles(const QStringList &files, GpgME::Protocol proto)
	{
	SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
	if (proto != GpgME::UnknownProtocol) {
	cmd->setProtocol(proto);
	}
	cmd->start();
	}

	void KleopatraApplication::decryptFiles(const QStringList &files, GpgME::Protocol /proto/)
	{
	DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
	cmd->setOperation(Decrypt);
	cmd->start();
	}

	void KleopatraApplication::verifyFiles(const QStringList &files, GpgME::Protocol /proto/)
	{
	DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
	cmd->setOperation(Verify);
	cmd->start();
	}

	void KleopatraApplication::decryptVerifyFiles(const QStringList &files, GpgME::Protocol /proto/)
	{
	DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
	cmd->start();
	}

	void KleopatraApplication::checksumFiles(const QStringList &files, GpgME::Protocol /proto/)
	{
	QStringList verifyFiles, createFiles;

	for (const QString &file : files) {
	if (isChecksumFile(file)) {
	verifyFiles << file;
	} else {
	createFiles << file;
	}
	}

	if (!verifyFiles.isEmpty()) {
	auto *const cmd = new ChecksumVerifyFilesCommand(verifyFiles, nullptr);
	cmd->start();
	}
	if (!createFiles.isEmpty()) {
	auto *const cmd = new ChecksumCreateFilesCommand(createFiles, nullptr);
	cmd->start();
	}
	}

	void KleopatraApplication::setIgnoreNewInstance(bool ignore)
	{
	d->ignoreNewInstance = ignore;
	}

	bool KleopatraApplication::ignoreNewInstance() const
	{
	return d->ignoreNewInstance;
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jan 14, 12:51 AM (10 h, 43 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 7f/50/e6cf4e7d2e5b8ff46616d5b971f5

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions