diff --git a/CMakeLists.txt b/CMakeLists.txt
index e7b59a195..28b064d55 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,234 +1,235 @@
 # SPDX-FileCopyrightText: none
 # SPDX-License-Identifier: BSD-3-Clause
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 set(RELEASE_SERVICE_VERSION_MAJOR "22")
 set(RELEASE_SERVICE_VERSION_MINOR "07")
 set(RELEASE_SERVICE_VERSION_MICRO "70")
 
 # The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
 if (NOT RELEASE_SERVICE_VERSION)
     set(RELEASE_SERVICE_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}.${RELEASE_SERVICE_VERSION_MINOR}.${RELEASE_SERVICE_VERSION_MICRO}")
 endif()
 if(RELEASE_SERVICE_VERSION_MICRO LESS 10)
     set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}0${RELEASE_SERVICE_VERSION_MICRO}")
 else()
     set(KDE_APPLICATIONS_COMPACT_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}${RELEASE_SERVICE_VERSION_MINOR}${RELEASE_SERVICE_VERSION_MICRO}")
 endif()
 
 set(KLEOPATRA_VERSION_MAJOR "3")
 set(KLEOPATRA_VERSION_MINOR "1")
 set(KLEOPATRA_VERSION_MICRO "22")
 
 set(kleopatra_version "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}.${KDE_APPLICATIONS_COMPACT_VERSION}")
 # The following is for Windows
 set(kleopatra_version_win "${KLEOPATRA_VERSION_MAJOR}.${KLEOPATRA_VERSION_MINOR}.${KLEOPATRA_VERSION_MICRO}")
 set(kleopatra_fileversion_win "${KLEOPATRA_VERSION_MAJOR},${KLEOPATRA_VERSION_MINOR},${KLEOPATRA_VERSION_MICRO},0")
 
 project(kleopatra VERSION ${kleopatra_version})
 
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF5_MIN_VERSION "5.95.0")
 set(KIDENTITYMANAGEMENT_VERSION "5.20.40")
 set(KMAILTRANSPORT_VERSION "5.20.40")
 set(KMIME_VERSION "5.20.40")
 set(LIBKLEO_VERSION "5.20.46")
 set(QT_REQUIRED_VERSION "5.15.2")
 set(GPGME_REQUIRED_VERSION "1.16.0")
 
 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 ()
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 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(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 include(ECMDeprecationSettings)
 include(KDEClangFormat)
 
 # Find KF5 packages
 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"
     PURPOSE "Required to generate Kleopatra documentation."
     TYPE OPTIONAL)
 
 # 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 ${Qt${QT_MAJOR_VERSION}DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 if (QT_MAJOR_VERSION STREQUAL "6")
     find_package(QGpgmeQt6 ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 else()
     find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 endif()
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.17.0")
     set(QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY 1)
     set(QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE 1)
     set(QGPGME_SUPPORTS_WKDLOOKUP 1)
     set(QGPGME_SUPPORTS_IMPORT_WITH_FILTER 1)
     set(QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN 1)
     set(QGPGME_SUPPORTS_SECRET_KEY_EXPORT 1)
     set(QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT 1)
     set(QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID 1)
 endif()
 if (QGpgme_VERSION VERSION_GREATER_EQUAL "1.17.2")
     set(QGPGME_SUPPORTS_KEY_REVOCATION 1)
     set(QGPGME_SUPPORTS_KEY_REFRESH 1)
+    set(QGPGME_SUPPORTS_SET_FILENAME 1)
 endif()
 
 # Kdepimlibs packages
 find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KF5Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)
 find_package(KF5IdentityManagement ${KIDENTITYMANAGEMENT_VERSION} CONFIG)
 find_package(KF5MailTransport ${KMAILTRANSPORT_VERSION} CONFIG)
 find_package(KF5MailTransportAkonadi ${KMAILTRANSPORT_VERSION} CONFIG)
 
 find_package(Qt${QT_MAJOR_VERSION} ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)
 
 find_package(Assuan2 REQUIRED)
 
 
 set(kleopatra_release FALSE)
 
 if(NOT kleopatra_release)
     find_package(Git)
     if(GIT_FOUND)
         execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse
                         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                         RESULT_VARIABLE rc
                         ERROR_QUIET)
         if(rc EQUAL 0)
             execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
                 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                 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 ${CMAKE_CURRENT_SOURCE_DIR}
                 OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
             string(REGEX REPLACE "^([0-9]+)-([0-9]+)-([0-9]+)T([0-9]+):([0-9]+):([0-9]+).*$" "\\1\\2\\3T\\4\\5\\6"
                    Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")
 
             set(kleopatra_version "${kleopatra_version}+git${Kleopatra_WC_LAST_CHANGED_DATE}~${Kleopatra_WC_REVISION}")
         endif()
     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}
     ${ASSUAN2_INCLUDES}
     )
 
 add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
 if (WIN32)
 # On Windows, we need to use stuff deprecated since Qt 5.11, e.g. from QDesktopWidget
 ecm_set_disabled_deprecation_versions(QT 5.10.0 KF 5.96.0)
 else ()
 ecm_set_disabled_deprecation_versions(QT 5.14.0 KF 5.96.0)
 endif ()
 
 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)
 remove_definitions(-DQT_NO_FOREACH)
 
 # Disable the use of QStringBuilder for operator+ to prevent crashes when
 # returning the result of concatenating string temporaries in lambdas. We do
 # this for example in some std::transform expressions.
 # This is a known issue: https://bugreports.qt.io/browse/QTBUG-47066
 # Alternatively, one would always have to remember to force the lambdas to
 # return a QString instead of QStringBuilder, but that's just too easy to
 # forget and, unfortunately, the compiler doesn't issue a warning if one forgets
 # this. So, it's just too dangerous.
 # One can still use QStringBuilder explicitly with the operator% if necessary.
 remove_definitions(-DQT_USE_FAST_OPERATOR_PLUS)
 remove_definitions(-DQT_USE_QSTRINGBUILDER)
 
 kde_enable_exceptions()
 option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" OFF)
 
 set(COMPILE_WITH_UNITY_CMAKE_SUPPORT OFF)
 if (USE_UNITY_CMAKE_SUPPORT)
     set(COMPILE_WITH_UNITY_CMAKE_SUPPORT ON)
 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}
         )
 
 ki18n_install(po)
 if(KF5DocTools_FOUND)
     kdoctools_install(po)
     add_subdirectory(doc)
 endif()
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 # add clang-format target for all our real source files
 file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h *.c)
 kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES})
diff --git a/config-kleopatra.h.cmake b/config-kleopatra.h.cmake
index 93bed2da0..e4feb87c5 100644
--- a/config-kleopatra.h.cmake
+++ b/config-kleopatra.h.cmake
@@ -1,55 +1,58 @@
 /* Define to 1 if you have a recent enough libassuan */
 #cmakedefine HAVE_USABLE_ASSUAN 1
 
 /* Define to 1 if you have libassuan v2 */
 #cmakedefine HAVE_ASSUAN2 1
 
 #ifndef HAVE_ASSUAN2
 /* Define to 1 if your libassuan has the assuan_fd_t type  */
 #cmakedefine HAVE_ASSUAN_FD_T 1
 
 /* Define to 1 if your libassuan has the assuan_inquire_ext function */
 #cmakedefine HAVE_ASSUAN_INQUIRE_EXT 1
 
 /* Define to 1 if your assuan_inquire_ext puts the buffer arguments into the callback signature */
 #cmakedefine HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT 1
 
 /* Define to 1 if your libassuan has the assuan_sock_get_nonce function */
 #cmakedefine HAVE_ASSUAN_SOCK_GET_NONCE 1
 
 #endif
 /* Define to 1 if you build libkleopatraclient */
 #cmakedefine HAVE_KLEOPATRACLIENT_LIBRARY 1
 
 /* DBus available */
 #cmakedefine01 HAVE_QDBUS
 
 /* Defined if QGpgME supports changing the expiration date of the primary key and the subkeys simultaneously */
 #cmakedefine QGPGME_SUPPORTS_CHANGING_EXPIRATION_OF_COMPLETE_KEY 1
 
 /* Defined if QGpgME supports retrieving the default value of a config entry */
 #cmakedefine QGPGME_CRYPTOCONFIGENTRY_HAS_DEFAULT_VALUE 1
 
 /* Defined if QGpgME supports WKD lookup */
 #cmakedefine QGPGME_SUPPORTS_WKDLOOKUP 1
 
 /* Defined if QGpgME supports specifying an import filter when importing keys */
 #cmakedefine QGPGME_SUPPORTS_IMPORT_WITH_FILTER 1
 
 /* Defined if QGpgME supports setting key origin when importing keys */
 #cmakedefine QGPGME_SUPPORTS_IMPORT_WITH_KEY_ORIGIN 1
 
 /* Defined if QGpgME supports the export of secret keys */
 #cmakedefine QGPGME_SUPPORTS_SECRET_KEY_EXPORT 1
 
 /* Defined if QGpgME supports the export of secret subkeys */
 #cmakedefine QGPGME_SUPPORTS_SECRET_SUBKEY_EXPORT 1
 
 /* Defined if QGpgME supports receiving keys by their key ids */
 #cmakedefine QGPGME_SUPPORTS_RECEIVING_KEYS_BY_KEY_ID 1
 
 /* Defined if QGpgME supports revoking own OpenPGP keys */
 #cmakedefine QGPGME_SUPPORTS_KEY_REVOCATION 1
 
 /* Defined if QGpgME supports refreshing keys */
 #cmakedefine QGPGME_SUPPORTS_KEY_REFRESH 1
+
+/* Defined if QGpgME supports setting the file name of encrypted data */
+#cmakedefine QGPGME_SUPPORTS_SET_FILENAME 1
diff --git a/src/crypto/signencrypttask.cpp b/src/crypto/signencrypttask.cpp
index 866216601..ab2c144a6 100644
--- a/src/crypto/signencrypttask.cpp
+++ b/src/crypto/signencrypttask.cpp
@@ -1,682 +1,692 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signencrypttask.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 "signencrypttask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/path-helper.h>
 #include <utils/kleo_assert.h>
 #include <utils/auditlog.h>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KleoException>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignJob>
 #include <QGpgME/SignEncryptJob>
 #include <QGpgME/EncryptJob>
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/encryptionresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 QString formatInputOutputLabel(const QString &input, const QString &output, bool outputDeleted)
 {
     return i18nc("Input file --> Output file (rarr is arrow", "%1 &rarr; %2",
                  input.toHtmlEscaped(),
                  outputDeleted ? QStringLiteral("<s>%1</s>").arg(output.toHtmlEscaped()) : output.toHtmlEscaped());
 }
 
 class ErrorResult : public Task::Result
 {
 public:
     ErrorResult(bool sign, bool encrypt, const Error &err, const QString &errStr, const QString &input, const QString &output, const AuditLog &auditLog)
         : Task::Result(), m_sign(sign), m_encrypt(encrypt), m_error(err), m_errString(errStr), m_inputLabel(input), m_outputLabel(output), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     int errorCode() const override
     {
         return m_error.encodedError();
     }
     QString errorString() const override
     {
         return m_errString;
     }
     VisualCode code() const override
     {
         return NeutralError;
     }
     AuditLog auditLog() const override
     {
         return m_auditLog;
     }
 private:
     const bool m_sign;
     const bool m_encrypt;
     const Error m_error;
     const QString m_errString;
     const QString m_inputLabel;
     const QString m_outputLabel;
     const AuditLog m_auditLog;
 };
 
 class SignEncryptFilesResult : public Task::Result
 {
 public:
     SignEncryptFilesResult(const SigningResult &sr, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated, const AuditLog &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_sresult.isNull());
     }
     SignEncryptFilesResult(const EncryptionResult &er, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated, const AuditLog &auditLog)
         : Task::Result(),
           m_eresult(er),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_eresult.isNull());
     }
     SignEncryptFilesResult(const SigningResult &sr, const EncryptionResult &er, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated,  const AuditLog &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_eresult(er),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_sresult.isNull() || !m_eresult.isNull());
     }
 
     QString overview() const override;
     QString details() const override;
     int errorCode() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLog auditLog() const override;
 
 private:
     const SigningResult m_sresult;
     const EncryptionResult m_eresult;
     const QString m_inputLabel;
     const QString m_inputErrorString;
     const QString m_outputLabel;
     const QString m_outputErrorString;
     const bool m_outputCreated;
     const AuditLog m_auditLog;
 };
 
 static QString makeSigningOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Signing canceled.");
     }
 
     if (err) {
         return i18n("Signing failed.");
     }
     return i18n("Signing succeeded.");
 }
 
 static QString makeResultOverview(const SigningResult &result)
 {
     return makeSigningOverview(result.error());
 }
 
 static QString makeEncryptionOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Encryption canceled.");
     }
 
     if (err) {
         return i18n("Encryption failed.");
     }
 
     return i18n("Encryption succeeded.");
 }
 
 static QString makeResultOverview(const EncryptionResult &result)
 {
     return makeEncryptionOverview(result.error());
 }
 
 static QString makeResultOverview(const SigningResult &sr, const EncryptionResult &er)
 {
     if (er.isNull() && sr.isNull()) {
         return QString();
     }
     if (er.isNull()) {
         return makeResultOverview(sr);
     }
     if (sr.isNull()) {
         return makeResultOverview(er);
     }
     if (sr.error().isCanceled() || sr.error()) {
         return makeResultOverview(sr);
     }
     if (er.error().isCanceled() || er.error()) {
         return makeResultOverview(er);
     }
     return i18n("Signing and encryption succeeded.");
 }
 
 static QString escape(QString s)
 {
     s = s.toHtmlEscaped();
     s.replace(QLatin1Char('\n'), QStringLiteral("<br>"));
     return s;
 }
 
 static QString makeResultDetails(const SigningResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return QString();
 }
 
 static QString makeResultDetails(const EncryptionResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return i18n(" Encryption succeeded.");
 }
 
 }
 
 QString ErrorResult::overview() const
 {
     Q_ASSERT(m_error || m_error.isCanceled());
     Q_ASSERT(m_sign || m_encrypt);
     const QString label = formatInputOutputLabel(m_inputLabel, m_outputLabel, true);
     const bool canceled = m_error.isCanceled();
     if (m_sign && m_encrypt) {
         return canceled ? i18n("%1: <b>Sign/encrypt canceled.</b>", label) : i18n(" %1: Sign/encrypt failed.", label);
     }
     return i18nc("label: result. Example: foo -> foo.gpg: Encryption failed.", "%1: <b>%2</b>", label,
                  m_sign ? makeSigningOverview(m_error) : makeEncryptionOverview(m_error));
 }
 
 QString ErrorResult::details() const
 {
     return m_errString;
 }
 
 class SignEncryptTask::Private
 {
     friend class ::Kleo::Crypto::SignEncryptTask;
     SignEncryptTask *const q;
 public:
     explicit Private(SignEncryptTask *qq);
 
 private:
     std::unique_ptr<QGpgME::SignJob> createSignJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignEncryptJob> createSignEncryptJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::EncryptJob> createEncryptJob(GpgME::Protocol proto);
     std::shared_ptr<const Task::Result> makeErrorResult(const Error &err, const QString &errStr, const AuditLog &auditLog);
 
 private:
     void slotResult(const SigningResult &);
     void slotResult(const SigningResult &, const EncryptionResult &);
     void slotResult(const EncryptionResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     QStringList inputFileNames;
     QString outputFileName;
     std::vector<Key> signers;
     std::vector<Key> recipients;
 
     bool sign     : 1;
     bool encrypt  : 1;
     bool detached : 1;
     bool symmetric: 1;
     bool clearsign: 1;
 
     QPointer<QGpgME::Job> job;
     std::shared_ptr<OverwritePolicy> m_overwritePolicy;
 };
 
 SignEncryptTask::Private::Private(SignEncryptTask *qq)
     : q(qq),
       input(),
       output(),
       inputFileNames(),
       outputFileName(),
       signers(),
       recipients(),
       sign(true),
       encrypt(true),
       detached(false),
       clearsign(false),
       job(nullptr),
       m_overwritePolicy(new OverwritePolicy(nullptr))
 {
     q->setAsciiArmor(true);
 }
 
 std::shared_ptr<const Task::Result> SignEncryptTask::Private::makeErrorResult(const Error &err, const QString &errStr, const AuditLog &auditLog)
 {
     return std::shared_ptr<const ErrorResult>(new ErrorResult(sign, encrypt, err, errStr, input->label(), output->label(), auditLog));
 }
 
 SignEncryptTask::SignEncryptTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 SignEncryptTask::~SignEncryptTask() {}
 
 void SignEncryptTask::setInputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->inputFileNames = QStringList(fileName);
 }
 
 void SignEncryptTask::setInputFileNames(const QStringList &fileNames)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileNames.empty());
     d->inputFileNames = fileNames;
 }
 
 void SignEncryptTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void SignEncryptTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void SignEncryptTask::setOutputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->outputFileName = fileName;
 }
 
 void SignEncryptTask::setSigners(const std::vector<Key> &signers)
 {
     kleo_assert(!d->job);
     d->signers = signers;
 }
 
 void SignEncryptTask::setRecipients(const std::vector<Key> &recipients)
 {
     kleo_assert(!d->job);
     d->recipients = recipients;
 }
 
 void SignEncryptTask::setOverwritePolicy(const std::shared_ptr<OverwritePolicy> &policy)
 {
     kleo_assert(!d->job);
     d->m_overwritePolicy = policy;
 }
 
 void SignEncryptTask::setSign(bool sign)
 {
     kleo_assert(!d->job);
     d->sign = sign;
 }
 
 void SignEncryptTask::setEncrypt(bool encrypt)
 {
     kleo_assert(!d->job);
     d->encrypt = encrypt;
 }
 
 void SignEncryptTask::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->job);
     d->detached = detached;
 }
 
 void SignEncryptTask::setEncryptSymmetric(bool symmetric)
 {
     kleo_assert(!d->job);
     d->symmetric = symmetric;
 }
 
 void SignEncryptTask::setClearsign(bool clearsign)
 {
     kleo_assert(!d->job);
     d->clearsign = clearsign;
 }
 
 Protocol SignEncryptTask::protocol() const
 {
     if (d->sign && !d->signers.empty()) {
         return d->signers.front().protocol();
     }
     if (d->encrypt || d->symmetric) {
         if (!d->recipients.empty()) {
             return d->recipients.front().protocol();
         } else {
             return GpgME::OpenPGP;    // symmetric OpenPGP encryption
         }
     }
     throw Kleo::Exception(gpg_error(GPG_ERR_INTERNAL),
                           i18n("Cannot determine protocol for task"));
 }
 
 QString SignEncryptTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 QString SignEncryptTask::tag() const
 {
     return Formatting::displayName(protocol());
 }
 
 unsigned long long SignEncryptTask::inputSize() const
 {
     return d->input ? d->input->size() : 0U;
 }
 
 void SignEncryptTask::doStart()
 {
     kleo_assert(!d->job);
     if (d->sign) {
         kleo_assert(!d->signers.empty());
     }
 
     kleo_assert(d->input);
 
     if (!d->output) {
         d->output = Output::createFromFile(d->outputFileName, d->m_overwritePolicy);
     }
 
     if (d->encrypt || d->symmetric) {
         Context::EncryptionFlags flags = Context::AlwaysTrust;
         if (d->symmetric) {
             flags = static_cast<Context::EncryptionFlags>(flags | Context::Symmetric);
             qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
         }
         if (d->sign) {
             std::unique_ptr<QGpgME::SignEncryptJob> job = d->createSignEncryptJob(protocol());
             kleo_assert(job.get());
+#ifdef QGPGME_SUPPORTS_SET_FILENAME
+            if (d->inputFileNames.size() == 1) {
+                job->setFileName(d->inputFileNames.front());
+            }
+#endif
 
             job->start(d->signers, d->recipients,
                        d->input->ioDevice(), d->output->ioDevice(), flags);
 
             d->job = job.release();
         } else {
             std::unique_ptr<QGpgME::EncryptJob> job = d->createEncryptJob(protocol());
             kleo_assert(job.get());
+#ifdef QGPGME_SUPPORTS_SET_FILENAME
+            if (d->inputFileNames.size() == 1) {
+                job->setFileName(d->inputFileNames.front());
+            }
+#endif
 
             job->start(d->recipients, d->input->ioDevice(), d->output->ioDevice(), flags);
 
             d->job = job.release();
         }
     } else if (d->sign) {
         std::unique_ptr<QGpgME::SignJob> job = d->createSignJob(protocol());
         kleo_assert(job.get());
         kleo_assert(! (d->detached && d->clearsign));
 
         job->start(d->signers,
                    d->input->ioDevice(), d->output->ioDevice(),
                    d->detached ? GpgME::Detached : d->clearsign ?
                               GpgME::Clearsigned : GpgME::NormalSignatureMode);
 
         d->job = job.release();
     } else {
         kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
     }
 }
 
 void SignEncryptTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::SignJob> SignEncryptTask::Private::createSignJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signJob.get());
     connect(signJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(signJob.get(), SIGNAL(result(GpgME::SigningResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult)));
     return signJob;
 }
 
 std::unique_ptr<QGpgME::SignEncryptJob> SignEncryptTask::Private::createSignEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignEncryptJob> signEncryptJob(backend->signEncryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signEncryptJob.get());
     connect(signEncryptJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(signEncryptJob.get(), SIGNAL(result(GpgME::SigningResult,GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult,GpgME::EncryptionResult)));
     return signEncryptJob;
 }
 
 std::unique_ptr<QGpgME::EncryptJob> SignEncryptTask::Private::createEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(encryptJob.get());
     connect(encryptJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::EncryptionResult)));
     return encryptJob;
 }
 
 void SignEncryptTask::Private::slotResult(const SigningResult &result)
 {
     const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape( input->errorString())),
                                       auditLog));
         return;
     } else if (result.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
 
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(result, input, output, outputCreated, auditLog)));
 }
 
 void SignEncryptTask::Private::slotResult(const SigningResult &sresult, const EncryptionResult &eresult)
 {
     const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         output->cancel();
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape( input->errorString())),
                                       auditLog));
         return;
     } else if (sresult.error().code() || eresult.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!sresult.isNull() || !eresult.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
 
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(sresult, eresult, input, output, outputCreated, auditLog)));
 }
 
 void SignEncryptTask::Private::slotResult(const EncryptionResult &result)
 {
     const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         output->cancel();
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape(input->errorString())),
                                       auditLog));
         return;
     } else if (result.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(result, input, output, outputCreated, auditLog)));
 }
 
 QString SignEncryptFilesResult::overview() const
 {
     const QString files = formatInputOutputLabel(m_inputLabel, m_outputLabel, !m_outputCreated);
     return files + QLatin1String(": ") + makeOverview(makeResultOverview(m_sresult, m_eresult));
 }
 
 QString SignEncryptFilesResult::details() const
 {
     return errorString();
 }
 
 int SignEncryptFilesResult::errorCode() const
 {
     if (m_sresult.error().code()) {
         return m_sresult.error().encodedError();
     }
     if (m_eresult.error().code()) {
         return m_eresult.error().encodedError();
     }
     return 0;
 }
 
 QString SignEncryptFilesResult::errorString() const
 {
     const bool sign = !m_sresult.isNull();
     const bool encrypt = !m_eresult.isNull();
 
     kleo_assert(sign || encrypt);
 
     if (sign && encrypt) {
         return
             m_sresult.error().code() ? makeResultDetails(m_sresult, m_inputErrorString, m_outputErrorString) :
             m_eresult.error().code() ? makeResultDetails(m_eresult, m_inputErrorString, m_outputErrorString) :
             QString();
     }
 
     return
         sign   ? makeResultDetails(m_sresult, m_inputErrorString, m_outputErrorString) :
         /*else*/ makeResultDetails(m_eresult, m_inputErrorString, m_outputErrorString);
 }
 
 Task::Result::VisualCode SignEncryptFilesResult::code() const
 {
     if (m_sresult.error().isCanceled() || m_eresult.error().isCanceled()) {
         return Warning;
     }
     return (m_sresult.error().code() || m_eresult.error().code()) ? NeutralError : NeutralSuccess;
 }
 
 AuditLog SignEncryptFilesResult::auditLog() const
 {
     return m_auditLog;
 }
 
 #include "moc_signencrypttask.cpp"