diff --git a/CMakeLists.txt b/CMakeLists.txt
index eda643b39..401ed5afa 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,177 +1,174 @@
 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)
+cmake_minimum_required(VERSION 3.16 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.07.40")
 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.80.0")
 set(KMIME_VERSION "5.17.40")
 set(LIBKLEO_VERSION "5.17.42")
-set(QT_REQUIRED_VERSION "5.14.0")
+set(QT_REQUIRED_VERSION "5.15.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=0x055100)
+add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x055200)
 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)
 
 kde_enable_exceptions()
-option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" FALSE)
+option(USE_UNITY_CMAKE_SUPPORT "Use UNITY cmake support (speedup compile time)" OFF)
 
-set(COMPILE_WITH_UNITY_CMAKE_SUPPORT false)
+set(COMPILE_WITH_UNITY_CMAKE_SUPPORT OFF)
 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()
+    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}
         )
 
 if(KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
diff --git a/autotests/CMakeLists.txt b/autotests/CMakeLists.txt
index 889738fe0..f3fc7b04b 100644
--- a/autotests/CMakeLists.txt
+++ b/autotests/CMakeLists.txt
@@ -1,10 +1,10 @@
 set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_SOURCE_DIR}/src)
 
 set(kuniqueservicetest_src kuniqueservicetest.cpp ${CMAKE_SOURCE_DIR}/src/utils/kuniqueservice.cpp)
 
 ecm_qt_declare_logging_category(kuniqueservicetest_src HEADER kleopatra_debug.h IDENTIFIER KLEOPATRA_LOG CATEGORY_NAME org.kde.pim.kleopatra)
 add_executable(kuniqueservicetest ${kuniqueservicetest_src})
 add_test(NAME kuniqueservicetest COMMAND kuniqueservicetest)
 ecm_mark_as_test(kuniqueservicetest)
-target_link_libraries(kuniqueservicetest Qt5::Test ${_kleopatra_dbusaddons_libs})
+target_link_libraries(kuniqueservicetest Qt::Test ${_kleopatra_dbusaddons_libs})
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index bb251bded..d30850c3f 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,385 +1,385 @@
 add_subdirectory(icons)
 
 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
       utils/gnupg-registry.c
       selftest/registrycheck.cpp
       utils/windowsprocessdevice.cpp
       utils/userinfo_win.cpp
   )
 else()
   set(_kleopatra_extra_uiserver_SRCS uiserver/uiserver_unix.cpp)
   set(_kleopatra_extra_SRCS)
 endif()
 
 set(_kleopatra_uiserver_SRCS
     uiserver/sessiondata.cpp
     uiserver/uiserver.cpp
     ${_kleopatra_extra_uiserver_SRCS}
     uiserver/assuanserverconnection.cpp
     uiserver/echocommand.cpp
     uiserver/decryptverifycommandemailbase.cpp
     uiserver/decryptverifycommandfilesbase.cpp
     uiserver/signcommand.cpp
     uiserver/signencryptfilescommand.cpp
     uiserver/prepencryptcommand.cpp
     uiserver/prepsigncommand.cpp
     uiserver/encryptcommand.cpp
     uiserver/selectcertificatecommand.cpp
     uiserver/importfilescommand.cpp
     uiserver/createchecksumscommand.cpp
     uiserver/verifychecksumscommand.cpp
 
     selftest/uiservercheck.cpp
   )
 
 if(ASSUAN2_FOUND)
   include_directories(${ASSUAN2_INCLUDES})
   set(_kleopatra_uiserver_extra_libs ${ASSUAN2_LIBRARIES})
 else()
   include_directories(${ASSUAN_INCLUDES})
   if(WIN32)
     set(_kleopatra_uiserver_extra_libs ${ASSUAN_VANILLA_LIBRARIES})
   else()
     set(_kleopatra_uiserver_extra_libs ${ASSUAN_PTHREAD_LIBRARIES})
   endif()
 endif()
 
 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()
 
 ki18n_wrap_ui(_kleopatra_uiserver_SRCS crypto/gui/signingcertificateselectionwidget.ui)
 
 if("${Gpgmepp_VERSION}" VERSION_GREATER_EQUAL "1.14.1")
     set(_kleopatra_deviceinfowatcher_files
         smartcard/deviceinfowatcher.cpp
     )
 else()
     set(_kleopatra_deviceinfowatcher_files)
 endif()
 
 set(_kleopatra_SRCS
   utils/gui-helper.cpp
   utils/filedialog.cpp
   utils/kdpipeiodevice.cpp
   utils/headerview.cpp
   utils/scrollarea.cpp
   utils/dragqueen.cpp
   utils/multivalidator.cpp
   utils/systemtrayicon.cpp
 
   utils/hex.cpp
   utils/path-helper.cpp
   utils/input.cpp
   utils/output.cpp
   utils/validation.cpp
   utils/wsastarter.cpp
   utils/iodevicelogger.cpp
   utils/log.cpp
   utils/action_data.cpp
   utils/types.cpp
   utils/archivedefinition.cpp
   utils/auditlog.cpp
   utils/clipboardmenu.cpp
   utils/kuniqueservice.cpp
   utils/tags.cpp
   utils/writecertassuantransaction.cpp
   utils/keyparameters.cpp
   utils/userinfo.cpp
 
   selftest/selftest.cpp
   selftest/enginecheck.cpp
   selftest/gpgconfcheck.cpp
   selftest/gpgagentcheck.cpp
   selftest/libkleopatrarccheck.cpp
 
   ${_kleopatra_extra_SRCS}
 
   view/keylistcontroller.cpp
   view/keytreeview.cpp
   view/searchbar.cpp
   view/smartcardwidget.cpp
   view/padwidget.cpp
   view/pgpcardwidget.cpp
   view/pivcardwidget.cpp
   view/netkeywidget.cpp
   view/nullpinwidget.cpp
   view/tabwidget.cpp
   view/keycacheoverlay.cpp
   view/waitwidget.cpp
   view/welcomewidget.cpp
 
   dialogs/certificateselectiondialog.cpp
   dialogs/certifywidget.cpp
   dialogs/expirydialog.cpp
   dialogs/lookupcertificatesdialog.cpp
   dialogs/ownertrustdialog.cpp
   dialogs/selftestdialog.cpp
   dialogs/certifycertificatedialog.cpp
   dialogs/revokecertificationwidget.cpp
   dialogs/revokecertificationdialog.cpp
   dialogs/adduseriddialog.cpp
   dialogs/addemaildialog.cpp
   dialogs/deletecertificatesdialog.cpp
   dialogs/setinitialpindialog.cpp
   dialogs/certificatedetailswidget.cpp
   dialogs/trustchainwidget.cpp
   dialogs/weboftrustwidget.cpp
   dialogs/weboftrustdialog.cpp
   dialogs/exportdialog.cpp
   dialogs/subkeyswidget.cpp
   dialogs/gencardkeydialog.cpp
   dialogs/updatenotification.cpp
   dialogs/pivcardapplicationadministrationkeyinputdialog.cpp
   dialogs/certificatedetailsinputwidget.cpp
   dialogs/createcsrforcardkeydialog.cpp
   dialogs/groupdetailsdialog.cpp
   dialogs/editgroupdialog.cpp
 
   crypto/controller.cpp
   crypto/certificateresolver.cpp
   crypto/sender.cpp
   crypto/recipient.cpp
   crypto/task.cpp
   crypto/taskcollection.cpp
   crypto/decryptverifytask.cpp
   crypto/decryptverifyemailcontroller.cpp
   crypto/decryptverifyfilescontroller.cpp
   crypto/autodecryptverifyfilescontroller.cpp
   crypto/encryptemailtask.cpp
   crypto/encryptemailcontroller.cpp
   crypto/newsignencryptemailcontroller.cpp
   crypto/signencrypttask.cpp
   crypto/signencryptfilescontroller.cpp
   crypto/signemailtask.cpp
   crypto/signemailcontroller.cpp
   crypto/createchecksumscontroller.cpp
   crypto/verifychecksumscontroller.cpp
 
   crypto/gui/wizard.cpp
   crypto/gui/wizardpage.cpp
 
   crypto/gui/certificateselectionline.cpp
   crypto/gui/certificatelineedit.cpp
   crypto/gui/signingcertificateselectionwidget.cpp
   crypto/gui/signingcertificateselectiondialog.cpp
 
   crypto/gui/resultitemwidget.cpp
   crypto/gui/resultlistwidget.cpp
   crypto/gui/resultpage.cpp
 
   crypto/gui/newresultpage.cpp
   crypto/gui/signencryptfileswizard.cpp
 
   crypto/gui/signencryptemailconflictdialog.cpp
 
   crypto/gui/decryptverifyoperationwidget.cpp
   crypto/gui/decryptverifyfileswizard.cpp
   crypto/gui/decryptverifyfilesdialog.cpp
 
   crypto/gui/objectspage.cpp
   crypto/gui/resolverecipientspage.cpp
   crypto/gui/signerresolvepage.cpp
   crypto/gui/encryptemailwizard.cpp
   crypto/gui/signemailwizard.cpp
   crypto/gui/signencryptwidget.cpp
   crypto/gui/signencryptwizard.cpp
   crypto/gui/unknownrecipientwidget.cpp
 
   crypto/gui/verifychecksumsdialog.cpp
 
   commands/command.cpp
   commands/gnupgprocesscommand.cpp
   commands/detailscommand.cpp
   commands/exportcertificatecommand.cpp
   commands/importcertificatescommand.cpp
   commands/importcertificatefromfilecommand.cpp
   commands/importcertificatefromclipboardcommand.cpp
   commands/importcertificatefromdatacommand.cpp
   commands/lookupcertificatescommand.cpp
   commands/reloadkeyscommand.cpp
   commands/refreshx509certscommand.cpp
   commands/refreshopenpgpcertscommand.cpp
   commands/deletecertificatescommand.cpp
   commands/decryptverifyfilescommand.cpp
   commands/signencryptfilescommand.cpp
   commands/signencryptfoldercommand.cpp
   commands/encryptclipboardcommand.cpp
   commands/signclipboardcommand.cpp
   commands/decryptverifyclipboardcommand.cpp
   commands/clearcrlcachecommand.cpp
   commands/dumpcrlcachecommand.cpp
   commands/dumpcertificatecommand.cpp
   commands/importcrlcommand.cpp
   commands/changeexpirycommand.cpp
   commands/changeownertrustcommand.cpp
   commands/changeroottrustcommand.cpp
   commands/changepassphrasecommand.cpp
   commands/certifycertificatecommand.cpp
   commands/revokecertificationcommand.cpp
   commands/selftestcommand.cpp
   commands/exportsecretkeycommand.cpp
   commands/exportopenpgpcertstoservercommand.cpp
   commands/adduseridcommand.cpp
   commands/newcertificatecommand.cpp
   commands/setinitialpincommand.cpp
   commands/learncardkeyscommand.cpp
   commands/checksumcreatefilescommand.cpp
   commands/checksumverifyfilescommand.cpp
   commands/exportpaperkeycommand.cpp
   commands/importpaperkeycommand.cpp
   commands/genrevokecommand.cpp
   commands/keytocardcommand.cpp
   commands/cardcommand.cpp
   commands/pivgeneratecardkeycommand.cpp
   commands/changepincommand.cpp
   commands/authenticatepivcardapplicationcommand.cpp
   commands/setpivcardapplicationadministrationkeycommand.cpp
   commands/certificatetopivcardcommand.cpp
   commands/importcertificatefrompivcardcommand.cpp
   commands/createopenpgpkeyfromcardkeyscommand.cpp
   commands/createcsrforcardkeycommand.cpp
 
   ${_kleopatra_uiserver_files}
 
   conf/configuredialog.cpp
   conf/groupsconfigdialog.cpp
   conf/groupsconfigpage.cpp
   conf/groupsconfigwidget.cpp
 
   newcertificatewizard/listwidget.cpp
   newcertificatewizard/newcertificatewizard.cpp
 
   smartcard/readerstatus.cpp
   smartcard/card.cpp
   smartcard/openpgpcard.cpp
   smartcard/netkeycard.cpp
   smartcard/pivcard.cpp
   smartcard/keypairinfo.cpp
   smartcard/utils.cpp
 
   ${_kleopatra_deviceinfowatcher_files}
 
   aboutdata.cpp
   systrayicon.cpp
   kleopatraapplication.cpp
   mainwindow.cpp
   main.cpp
   kleopatra.qrc
 )
 
 if(WIN32)
   configure_file (versioninfo.rc.in versioninfo.rc)
   set(_kleopatra_SRCS ${CMAKE_CURRENT_BINARY_DIR}/versioninfo.rc ${_kleopatra_SRCS})
 endif()
 
 if(HAVE_KCMUTILS)
   set (_kleopatra_extra_libs KF5::KCMUtils)
 else()
   set (_kleopatra_SRCS conf/kleopageconfigdialog.cpp ${_kleopatra_SRCS})
 endif()
 
 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/expirydialog.ui
   dialogs/lookupcertificatesdialog.ui
   dialogs/ownertrustdialog.ui
   dialogs/selectchecklevelwidget.ui
   dialogs/selftestdialog.ui
   dialogs/adduseriddialog.ui
   dialogs/setinitialpindialog.ui
   dialogs/certificatedetailswidget.ui
   dialogs/trustchainwidget.ui
   dialogs/subkeyswidget.ui
   newcertificatewizard/listwidget.ui
   newcertificatewizard/chooseprotocolpage.ui
   newcertificatewizard/enterdetailspage.ui
   newcertificatewizard/keycreationpage.ui
   newcertificatewizard/resultpage.ui
   newcertificatewizard/advancedsettingsdialog.ui
 )
 
 kconfig_add_kcfg_files(_kleopatra_SRCS
   kcfg/tooltippreferences.kcfgc
   kcfg/emailoperationspreferences.kcfgc
   kcfg/fileoperationspreferences.kcfgc
   kcfg/smimevalidationpreferences.kcfgc
   kcfg/tagspreferences.kcfgc
   kcfg/settings.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})
 #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
   QGpgme
   ${_kleopatra_extra_libs}
   KF5::Libkleo
   KF5::Mime
   KF5::I18n
   KF5::XmlGui
   KF5::IconThemes
   KF5::WindowSystem
   KF5::CoreAddons
   KF5::ItemModels
   KF5::Crash
-  Qt5::Network
-  Qt5::PrintSupport # Printing secret keys
+  Qt::Network
+  Qt::PrintSupport # Printing secret keys
   ${_kleopatra_uiserver_extra_libs}
   ${_kleopatra_dbusaddons_libs}
   kleopatraclientcore
   ${_kleopatra_platform_libs}
 )
 
 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_signencryptfiles.desktop
         data/kleopatra_signencryptfolders.desktop
         data/kleopatra_decryptverifyfiles.desktop
         data/kleopatra_decryptverifyfolders.desktop
   DESTINATION ${KDE_INSTALL_KSERVICES5DIR}
 )
diff --git a/src/crypto/gui/signerresolvepage.cpp b/src/crypto/gui/signerresolvepage.cpp
index d3f1e9c28..a2d2a7f1e 100644
--- a/src/crypto/gui/signerresolvepage.cpp
+++ b/src/crypto/gui/signerresolvepage.cpp
@@ -1,670 +1,666 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signerresolvepage.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 "signerresolvepage.h"
 #include "signerresolvepage_p.h"
 
 #include "signingcertificateselectiondialog.h"
 
 #include <crypto/certificateresolver.h>
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <utils/kleo_assert.h>
 
 
 #include <gpgme++/key.h>
 
 #include <QDialog>
 #include <KLocalizedString>
 
 #include <QButtonGroup>
 #include <QCheckBox>
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
 #include <QPointer>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QVBoxLayout>
 #include <QVector>
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 namespace
 {
 static SignerResolvePage::Operation operationFromFlags(bool sign, bool encrypt)
 {
     if (!encrypt && sign) {
         return SignerResolvePage::SignOnly;
     }
     if (!sign && encrypt) {
         return SignerResolvePage::EncryptOnly;
     }
     return SignerResolvePage::SignAndEncrypt;
 }
 
 static QString formatLabel(Protocol p, const Key &key)
 {
     return i18nc("%1=protocol (S/Mime, OpenPGP), %2=certificate", "Sign using %1: %2", Formatting::displayName(p),
                  !key.isNull() ? Formatting::formatForComboBox(key) : i18n("No certificate selected"));
 }
 
 static std::vector<Protocol> supportedProtocols()
 {
     std::vector<Protocol> protocols;
     protocols.push_back(OpenPGP);
     protocols.push_back(CMS);
     return protocols;
 }
 }
 
 AbstractSigningProtocolSelectionWidget::AbstractSigningProtocolSelectionWidget(QWidget *p, Qt::WindowFlags f) : QWidget(p, f)
 {
 }
 
 ReadOnlyProtocolSelectionWidget::ReadOnlyProtocolSelectionWidget(QWidget *p, Qt::WindowFlags f) : AbstractSigningProtocolSelectionWidget(p, f)
 {
     QVBoxLayout *const layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     const auto supportedProtocolsLst = supportedProtocols();
     for (const Protocol i: supportedProtocolsLst) {
         QLabel *const l = new QLabel;
         l->setText(formatLabel(i, Key()));
         layout->addWidget(l);
         m_labels[i] =  l;
     }
 }
 
 void ReadOnlyProtocolSelectionWidget::setProtocolChecked(Protocol protocol, bool checked)
 {
     QLabel *const l = label(protocol);
     Q_ASSERT(l);
     l->setVisible(checked);
 }
 
 bool ReadOnlyProtocolSelectionWidget::isProtocolChecked(Protocol protocol) const
 {
     QLabel *const l = label(protocol);
     Q_ASSERT(l);
     return l->isVisible();
 }
 
 std::set<Protocol> ReadOnlyProtocolSelectionWidget::checkedProtocols() const
 {
     std::set<Protocol> res;
     Q_FOREACH (const Protocol i, supportedProtocols())  //krazy:exclude=foreach
         if (isProtocolChecked(i)) {
             res.insert(i);
         }
     return res;
 
 }
 
 SigningProtocolSelectionWidget::SigningProtocolSelectionWidget(QWidget *parent, Qt::WindowFlags f)
     : AbstractSigningProtocolSelectionWidget(parent, f)
 {
 
     m_buttonGroup = new QButtonGroup(this);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
-    connect(m_buttonGroup, static_cast<void (QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), this, &SigningProtocolSelectionWidget::userSelectionChanged);
-#else
     connect(m_buttonGroup, &QButtonGroup::idClicked, this, &SigningProtocolSelectionWidget::userSelectionChanged);
-#endif
 
     QVBoxLayout *const layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     Q_FOREACH (const Protocol i, supportedProtocols()) {   //krazy:exclude=foreach
         QCheckBox *const b = new QCheckBox;
         b->setText(formatLabel(i, Key()));
         m_buttons[i] = b;
         layout->addWidget(b);
         m_buttonGroup->addButton(b);
     }
     setExclusive(true);
 }
 
 void SigningProtocolSelectionWidget::setProtocolChecked(Protocol p, bool checked)
 {
     Q_ASSERT(p != UnknownProtocol);
     QCheckBox *const b = button(p);
     Q_ASSERT(b);
     b->setChecked(checked);
 }
 
 bool SigningProtocolSelectionWidget::isProtocolChecked(Protocol p) const
 {
     Q_ASSERT(p != UnknownProtocol);
     const QAbstractButton *const b = button(p);
     Q_ASSERT(b);
     return b->isChecked();
 }
 
 std::set<Protocol> SigningProtocolSelectionWidget::checkedProtocols() const
 {
     std::set<Protocol> res;
     for (std::map<Protocol, QCheckBox *>::const_iterator it = m_buttons.begin(), end = m_buttons.end();
             it != end;
             ++it)
         if (it->second->isChecked()) {
             res.insert(it->first);
         }
     return res;
 }
 
 void SigningProtocolSelectionWidget::setExclusive(bool exclusive)
 {
     if (exclusive == isExclusive()) {
         return;
     }
     m_buttonGroup->setExclusive(exclusive);
     Q_EMIT userSelectionChanged();
 }
 
 QCheckBox *SigningProtocolSelectionWidget::button(Protocol p) const
 {
     const std::map<Protocol, QCheckBox *>::const_iterator it = m_buttons.find(p);
     return it == m_buttons.end() ? nullptr : it->second;
 }
 
 QLabel *ReadOnlyProtocolSelectionWidget::label(Protocol p) const
 {
     const std::map<Protocol, QLabel *>::const_iterator it = m_labels.find(p);
     return it == m_labels.end() ? nullptr : it->second;
 }
 
 bool SigningProtocolSelectionWidget::isExclusive() const
 {
     return m_buttonGroup->exclusive();
 }
 
 void SigningProtocolSelectionWidget::setCertificate(Protocol prot, const Key &key)
 {
     QAbstractButton *const b = button(prot);
     Q_ASSERT(b);
     b->setText(formatLabel(prot, key));
 }
 
 void ReadOnlyProtocolSelectionWidget::setCertificate(Protocol prot, const Key &key)
 {
     QLabel *const l = label(prot);
     l->setText(formatLabel(prot, key));
 }
 
 namespace
 {
 
 class ValidatorImpl : public SignerResolvePage::Validator
 {
 public:
     QString explanation() const override
     {
         return QString();
     }
     bool isComplete() const override
     {
         return true;
     }
     QString customWindowTitle() const override
     {
         return QString();
     }
 };
 }
 
 class SignerResolvePage::Private
 {
     friend class ::Kleo::Crypto::Gui::SignerResolvePage;
     SignerResolvePage *const q;
 public:
     explicit Private(SignerResolvePage *qq);
     ~Private();
 
     void setOperation(Operation operation);
     void operationButtonClicked(int operation);
     void selectCertificates();
     void setCertificates(const QMap<GpgME::Protocol, GpgME::Key> &certs);
     void updateModeSelectionWidgets();
     void updateUi();
     bool protocolSelected(Protocol p) const;
     bool protocolSelectionActuallyUserMutable() const;
 
 private:
     QButtonGroup *signEncryptGroup;
     QRadioButton *signAndEncryptRB;
     QRadioButton *encryptOnlyRB;
     QRadioButton *signOnlyRB;
     QGroupBox *signingCertificateBox;
     QLabel *signerLabelLabel;
     QLabel *signerLabel;
     QGroupBox *encryptBox;
     QCheckBox *textArmorCO;
     QPushButton *selectCertificatesButton;
     SigningProtocolSelectionWidget *signingProtocolSelectionWidget;
     ReadOnlyProtocolSelectionWidget *readOnlyProtocolSelectionWidget;
     std::vector<Protocol> presetProtocols;
     bool signingMutable;
     bool encryptionMutable;
     bool signingSelected;
     bool encryptionSelected;
     bool multipleProtocolsAllowed;
     bool protocolSelectionUserMutable;
     QMap<GpgME::Protocol, GpgME::Key> certificates;
     std::shared_ptr<SignerResolvePage::Validator> validator;
     std::shared_ptr<SigningPreferences> signingPreferences;
 };
 
 bool SignerResolvePage::Private::protocolSelectionActuallyUserMutable() const
 {
     return (q->protocolSelectionUserMutable() || presetProtocols.empty()) && q->operation() == SignOnly;
 }
 
 SignerResolvePage::Private::Private(SignerResolvePage *qq)
     : q(qq)
     , presetProtocols()
     , signingMutable(true)
     , encryptionMutable(true)
     , signingSelected(false)
     , encryptionSelected(false)
     , multipleProtocolsAllowed(false)
     , protocolSelectionUserMutable(true)
     , validator(new ValidatorImpl)
 
 {
     QVBoxLayout *layout = new QVBoxLayout(q);
 
     signEncryptGroup = new QButtonGroup(q);
     q->connect(signEncryptGroup, SIGNAL(buttonClicked(int)), q, SLOT(operationButtonClicked(int)));
 
     signAndEncryptRB = new QRadioButton;
     signAndEncryptRB->setText(i18n("Sign and encrypt (OpenPGP only)"));
     signAndEncryptRB->setChecked(true);
     signEncryptGroup->addButton(signAndEncryptRB, SignAndEncrypt);
     layout->addWidget(signAndEncryptRB);
 
     encryptOnlyRB = new QRadioButton;
     encryptOnlyRB->setText(i18n("Encrypt only"));
     signEncryptGroup->addButton(encryptOnlyRB, EncryptOnly);
     layout->addWidget(encryptOnlyRB);
 
     signOnlyRB = new QRadioButton;
     signOnlyRB->setText(i18n("Sign only"));
     signEncryptGroup->addButton(signOnlyRB, SignOnly);
     layout->addWidget(signOnlyRB);
 
     encryptBox = new QGroupBox;
     encryptBox->setTitle(i18n("Encryption Options"));
     QBoxLayout *const encryptLayout = new QVBoxLayout(encryptBox);
     textArmorCO = new QCheckBox;
     textArmorCO->setText(i18n("Text output (ASCII armor)"));
     encryptLayout->addWidget(textArmorCO);
     layout->addWidget(encryptBox);
 
     signingCertificateBox = new QGroupBox;
     signingCertificateBox->setTitle(i18n("Signing Options"));
     QGridLayout *signerLayout = new QGridLayout(signingCertificateBox);
     signerLayout->setColumnStretch(1, 1);
 
     signerLabelLabel = new QLabel;
     signerLabelLabel->setText(i18n("Signer:"));
     signerLayout->addWidget(signerLabelLabel, 1, 0);
     signerLabel = new QLabel;
     signerLayout->addWidget(signerLabel, 1, 1);
     signerLabelLabel->setVisible(false);
     signerLabel->setVisible(false);
 
     signingProtocolSelectionWidget = new SigningProtocolSelectionWidget;
     connect(signingProtocolSelectionWidget, SIGNAL(userSelectionChanged()), q, SLOT(updateUi()));
     signerLayout->addWidget(signingProtocolSelectionWidget, 2, 0, 1, -1);
 
     readOnlyProtocolSelectionWidget = new ReadOnlyProtocolSelectionWidget;
     signerLayout->addWidget(readOnlyProtocolSelectionWidget, 3, 0, 1, -1);
 
     selectCertificatesButton = new QPushButton;
     selectCertificatesButton->setText(i18n("Change Signing Certificates..."));
     selectCertificatesButton->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
     signerLayout->addWidget(selectCertificatesButton, 4, 0, 1, -1, Qt::AlignLeft);
     q->connect(selectCertificatesButton, SIGNAL(clicked()), q, SLOT(selectCertificates()));
     layout->addWidget(signingCertificateBox);
     layout->addStretch();
 }
 
 void SignerResolvePage::setValidator(const std::shared_ptr<SignerResolvePage::Validator> &validator)
 {
     Q_ASSERT(validator);
     d->validator = validator;
     d->updateUi();
 }
 
 std::shared_ptr<SignerResolvePage::Validator> SignerResolvePage::validator() const
 {
     return d->validator;
 }
 
 SignerResolvePage::Private::~Private() {}
 
 bool SignerResolvePage::Private::protocolSelected(Protocol p) const
 {
     Q_ASSERT(p != UnknownProtocol);
     return signingProtocolSelectionWidget->isProtocolChecked(p);
 }
 
 void SignerResolvePage::Private::setCertificates(const QMap<GpgME::Protocol, GpgME::Key> &certs)
 {
     certificates = certs;
     Q_FOREACH (const Protocol i, certs.keys()) {   //krazy:exclude=foreach
         const Key key = certs.value(i);
         readOnlyProtocolSelectionWidget->setCertificate(i, key);
         signingProtocolSelectionWidget->setCertificate(i, key);
     }
     updateUi();
 }
 
 void SignerResolvePage::Private::updateUi()
 {
     const bool ismutable = protocolSelectionActuallyUserMutable();
     readOnlyProtocolSelectionWidget->setVisible(!ismutable);
     signingProtocolSelectionWidget->setVisible(ismutable);
 
     q->setExplanation(validator->explanation());
     Q_EMIT q->completeChanged();
 
     const QString customTitle = validator->customWindowTitle();
     if (!customTitle.isEmpty()) {
         Q_EMIT q->windowTitleChanged(customTitle);
     }
     selectCertificatesButton->setEnabled(signingProtocolSelectionWidget->checkedProtocols().size() > 0);
 }
 
 void SignerResolvePage::setProtocolSelectionUserMutable(bool ismutable)
 {
     if (d->protocolSelectionUserMutable == ismutable) {
         return;
     }
     d->protocolSelectionUserMutable = ismutable;
     d->updateModeSelectionWidgets();
 }
 
 bool SignerResolvePage::protocolSelectionUserMutable() const
 {
     return d->protocolSelectionUserMutable;
 }
 
 void SignerResolvePage::setMultipleProtocolsAllowed(bool allowed)
 {
     if (d->multipleProtocolsAllowed == allowed) {
         return;
     }
     d->multipleProtocolsAllowed = allowed;
     d->updateModeSelectionWidgets();
 }
 
 bool SignerResolvePage::multipleProtocolsAllowed() const
 {
     return d->multipleProtocolsAllowed;
 }
 
 void SignerResolvePage::Private::updateModeSelectionWidgets()
 {
     const bool bothMutable = signingMutable && encryptionMutable;
     const bool noSigningPossible = !signingSelected && !signingMutable;
     const bool noEncryptionPossible = !encryptionSelected && !encryptionMutable;
     signAndEncryptRB->setChecked(signingSelected && encryptionSelected);
     signOnlyRB->setChecked(signingSelected && !encryptionSelected);
     encryptOnlyRB->setChecked(encryptionSelected && !signingSelected);
     const bool canSignAndEncrypt = !noSigningPossible && !noEncryptionPossible && bothMutable && presetProtocols != std::vector<Protocol>(1, CMS);
     const bool canSignOnly = !encryptionSelected || encryptionMutable;
     const bool canEncryptOnly = !signingSelected || signingMutable;
 
     signAndEncryptRB->setEnabled(canSignAndEncrypt);
     signOnlyRB->setEnabled(canSignOnly);
     encryptOnlyRB->setEnabled(canEncryptOnly);
     const bool buttonsVisible = signingMutable || encryptionMutable;
     signOnlyRB->setVisible(buttonsVisible);
     encryptOnlyRB->setVisible(buttonsVisible);
     signAndEncryptRB->setVisible(buttonsVisible);
     signingProtocolSelectionWidget->setExclusive(!multipleProtocolsAllowed);
     signingCertificateBox->setVisible(!noSigningPossible);
     encryptBox->setVisible(!noEncryptionPossible);
     updateUi();
 }
 
 void SignerResolvePage::Private::selectCertificates()
 {
     QPointer<SigningCertificateSelectionDialog> dlg = new SigningCertificateSelectionDialog(q);
     dlg->setAllowedProtocols(signingProtocolSelectionWidget->checkedProtocols());
     if (dlg->exec() == QDialog::Accepted && dlg) {
         const QMap<Protocol, Key> certs = dlg->selectedCertificates();
         setCertificates(certs);
         if (signingPreferences && dlg->rememberAsDefault()) {
             signingPreferences->setPreferredCertificate(OpenPGP, certs.value(OpenPGP));
             signingPreferences->setPreferredCertificate(CMS, certs.value(CMS));
         }
     }
 
     delete dlg;
     updateUi();
 }
 
 void SignerResolvePage::Private::operationButtonClicked(int mode_)
 {
     const Operation op = static_cast<SignerResolvePage::Operation>(mode_);
     signingCertificateBox->setEnabled(op != EncryptOnly);
     encryptBox->setEnabled(op != SignOnly);
     if (op == SignAndEncrypt) {
         signingProtocolSelectionWidget->setProtocolChecked(CMS, false);
         readOnlyProtocolSelectionWidget->setProtocolChecked(CMS, false);
         signingProtocolSelectionWidget->setProtocolChecked(OpenPGP, true);
         readOnlyProtocolSelectionWidget->setProtocolChecked(OpenPGP, true);
     }
     updateUi();
 }
 
 void SignerResolvePage::Private::setOperation(Operation op)
 {
     switch (op) {
     case SignOnly:
         signOnlyRB->click();
         break;
     case EncryptOnly:
         encryptOnlyRB->click();
         break;
     case SignAndEncrypt:
         signAndEncryptRB->click();
         break;
     }
 }
 
 SignerResolvePage::Operation SignerResolvePage::operation() const
 {
     return operationFromFlags(signingSelected(), encryptionSelected());
 }
 
 SignerResolvePage::SignerResolvePage(QWidget *parent, Qt::WindowFlags f)
     : WizardPage(parent, f), d(new Private(this))
 {
     setTitle(i18n("<b>Choose Operation to be Performed</b>"));
 //    setSubTitle( i18n( "TODO" ) );
     setPresetProtocol(UnknownProtocol);
     d->setCertificates(QMap<GpgME::Protocol, GpgME::Key>());
     d->updateModeSelectionWidgets();
     d->operationButtonClicked(EncryptOnly);
 }
 
 SignerResolvePage::~SignerResolvePage() {}
 
 void SignerResolvePage::setSignersAndCandidates(const std::vector<KMime::Types::Mailbox> &signers,
         const std::vector< std::vector<GpgME::Key> > &keys)
 {
     kleo_assert(signers.empty() || signers.size() == keys.size());
 
     switch (signers.size()) {
     case 0:
         d->signerLabelLabel->setVisible(false);
         d->signerLabel->setVisible(false);    // TODO: use default identity?
         break;
     case 1:
         d->signerLabelLabel->setVisible(true);
         d->signerLabel->setVisible(true);   // TODO: use default identity?
         d->signerLabel->setText(signers.front().prettyAddress());
         break;
     default: // > 1
         kleo_assert(!"Resolving multiple signers not implemented");
     }
     d->updateUi();
 }
 
 void SignerResolvePage::setPresetProtocol(Protocol protocol)
 {
     std::vector<Protocol> protocols;
     if (protocol != CMS) {
         protocols.push_back(OpenPGP);
     }
     if (protocol != OpenPGP) {
         protocols.push_back(CMS);
     }
     setPresetProtocols(protocols);
     d->updateUi();
 }
 
 void SignerResolvePage::setPresetProtocols(const std::vector<Protocol> &protocols)
 {
     d->presetProtocols = protocols;
     Q_FOREACH (const Protocol i, supportedProtocols()) {   //krazy:exclude=foreach
         const bool checked = std::find(protocols.begin(), protocols.end(), i) != protocols.end();
         d->signingProtocolSelectionWidget->setProtocolChecked(i, checked);
         d->readOnlyProtocolSelectionWidget->setProtocolChecked(i, checked);
     }
     d->updateModeSelectionWidgets();
 }
 
 std::set<Protocol> SignerResolvePage::selectedProtocols() const
 {
     return d->signingProtocolSelectionWidget->checkedProtocols();
 }
 
 std::vector<Key> SignerResolvePage::signingCertificates(Protocol protocol) const
 {
     std::vector<Key> result;
     if (protocol != CMS && d->signingProtocolSelectionWidget->isProtocolChecked(OpenPGP) && !d->certificates[OpenPGP].isNull()) {
         result.push_back(d->certificates[OpenPGP]);
     }
     if (protocol != OpenPGP && d->signingProtocolSelectionWidget->isProtocolChecked(CMS) && !d->certificates[CMS].isNull()) {
         result.push_back(d->certificates[CMS]);
     }
     return result;
 }
 
 std::vector<Key> SignerResolvePage::resolvedSigners() const
 {
     std::vector<Key> result = signingCertificates(CMS);
     const std::vector<Key> pgp = signingCertificates(OpenPGP);
     result.insert(result.end(), pgp.begin(), pgp.end());
     return result;
 }
 
 bool SignerResolvePage::isComplete() const
 {
     Q_ASSERT(d->validator);
     return d->validator->isComplete();
 }
 
 bool SignerResolvePage::encryptionSelected() const
 {
     return !d->signOnlyRB->isChecked();
 }
 
 void SignerResolvePage::setEncryptionSelected(bool selected)
 {
     d->encryptionSelected = selected;
     d->updateModeSelectionWidgets();
     d->setOperation(operationFromFlags(d->signingSelected, d->encryptionSelected));
 }
 
 bool SignerResolvePage::signingSelected() const
 {
     return !d->encryptOnlyRB->isChecked();
 }
 
 void SignerResolvePage::setSigningSelected(bool selected)
 {
     d->signingSelected = selected;
     d->updateModeSelectionWidgets();
     d->setOperation(operationFromFlags(d->signingSelected, d->encryptionSelected));
 }
 
 bool SignerResolvePage::isEncryptionUserMutable() const
 {
     return d->encryptionMutable;
 }
 
 bool SignerResolvePage::isSigningUserMutable() const
 {
     return d->signingMutable;
 }
 
 void SignerResolvePage::setEncryptionUserMutable(bool ismutable)
 {
     d->encryptionMutable = ismutable;
     d->updateModeSelectionWidgets();
 }
 
 void SignerResolvePage::setSigningUserMutable(bool ismutable)
 {
     d->signingMutable = ismutable;
     d->updateModeSelectionWidgets();
 }
 
 std::set<Protocol> SignerResolvePage::selectedProtocolsWithoutSigningCertificate() const
 {
     std::set<Protocol> res;
     Q_FOREACH (const Protocol i, selectedProtocols())   //krazy:exclude=foreach
         if (signingCertificates(i).empty()) {
             res.insert(i);
         }
     return res;
 }
 
 bool SignerResolvePage::isAsciiArmorEnabled() const
 {
     return d->textArmorCO->isChecked();
 }
 
 void SignerResolvePage::setAsciiArmorEnabled(bool enabled)
 {
     d->textArmorCO->setChecked(enabled);
 }
 
 void SignerResolvePage::setSigningPreferences(const std::shared_ptr<SigningPreferences> &prefs)
 {
     d->signingPreferences = prefs;
     QMap<Protocol, Key> map;
     map[OpenPGP] = prefs ? prefs->preferredCertificate(OpenPGP) : Key();
     map[CMS] = prefs ? prefs->preferredCertificate(CMS) : Key();
     d->setCertificates(map);
 }
 
 std::shared_ptr<SigningPreferences> SignerResolvePage::signingPreferences() const
 {
     return d->signingPreferences;
 }
 
 void SignerResolvePage::onNext()
 {
 }
 
 #include "moc_signerresolvepage.cpp"
 #include "moc_signerresolvepage_p.cpp"
 
diff --git a/src/libkleopatraclient/core/CMakeLists.txt b/src/libkleopatraclient/core/CMakeLists.txt
index fb6aa7f26..b1829adf1 100644
--- a/src/libkleopatraclient/core/CMakeLists.txt
+++ b/src/libkleopatraclient/core/CMakeLists.txt
@@ -1,69 +1,69 @@
 add_definitions(
   -D_ASSUAN_ONLY_GPG_ERRORS
 )
 
 if(WIN32)
   set(_kleopatraclientcore_extra_SRCS ../../utils/gnupg-registry.c)
 else()
   set(_kleopatraclientcore_extra_SRCS)
 endif()
 
 ecm_qt_declare_logging_category(_kleopatraclientcore_common_SRCS HEADER libkleopatraclientcore_debug.h IDENTIFIER LIBKLEOPATRACLIENTCORE_LOG CATEGORY_NAME org.kde.pim.libkleopatraclientcore
         DESCRIPTION "kleopatra (kleopatra)"
         OLD_CATEGORY_NAMES log_libkleopatraclientcore
         EXPORT KLEOPATRA
     )
 
 
 add_library(kleopatraclientcore
   ${_kleopatraclientcore_extra_SRCS}
   initialization.cpp
   command.cpp
   selectcertificatecommand.cpp
   signencryptfilescommand.cpp
   decryptverifyfilescommand.cpp
   libkleopatraclientcore_debug.cpp
   ${_kleopatraclientcore_common_SRCS}
 )
 generate_export_header(kleopatraclientcore BASE_NAME kleopatraclientcore)
 
 set_target_properties(kleopatraclientcore PROPERTIES
   VERSION ${libkleopatraclient_version}
   SOVERSION ${libkleopatraclient_soversion}
 )
 if (COMPILE_WITH_UNITY_CMAKE_SUPPORT)
     set_target_properties(kleopatraclientcore PROPERTIES UNITY_BUILD ON)
 endif()
 
 
 if(WIN32)
   if(ASSUAN2_FOUND)
     target_link_libraries(kleopatraclientcore
       
       ${ASSUAN2_LIBRARIES}
       ws2_32
     )
   else()
     target_link_libraries(kleopatraclientcore
       
       ${ASSUAN_VANILLA_LIBRARIES}
       ws2_32
     )
   endif()
 else()
   if(ASSUAN2_FOUND)
     target_link_libraries(kleopatraclientcore
       
       ${ASSUAN2_LIBRARIES}
     )
   else()
     target_link_libraries(kleopatraclientcore
       
       ${ASSUAN_PTHREAD_LIBRARIES}
     )
   endif()
 endif()
 
-target_link_libraries(kleopatraclientcore Qt5::Widgets KF5::I18n Gpgmepp)
+target_link_libraries(kleopatraclientcore Qt::Widgets KF5::I18n Gpgmepp)
 
 install(TARGETS kleopatraclientcore ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/src/libkleopatraclient/tests/CMakeLists.txt b/src/libkleopatraclient/tests/CMakeLists.txt
index d2a6b9cb9..1ea09f56e 100644
--- a/src/libkleopatraclient/tests/CMakeLists.txt
+++ b/src/libkleopatraclient/tests/CMakeLists.txt
@@ -1,17 +1,17 @@
 set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
 
 set(kleoclient_TESTS
   test_signencryptfilescommand
   test_decryptverifyfilescommand
 )
 
 foreach(_kleoclient_test ${kleoclient_TESTS})
   add_executable( ${_kleoclient_test} ${_kleoclient_test}.cpp )
   ecm_mark_as_test(${_kleoclient_test})
 
   target_link_libraries("${_kleoclient_test}"
     kleopatraclientcore
-    Qt5::Gui
-    Qt5::Core
+    Qt::Gui
+    Qt::Core
 )
 endforeach()
diff --git a/src/utils/dragqueen.cpp b/src/utils/dragqueen.cpp
index 55ad7a801..5da2d7294 100644
--- a/src/utils/dragqueen.cpp
+++ b/src/utils/dragqueen.cpp
@@ -1,210 +1,203 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/dragqueen.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 "dragqueen.h"
 
 #include <QDrag>
 #include <QMouseEvent>
 #include <QStringList>
 #include <QVariant>
 #include <QApplication>
 #include <QUrl>
 #include <QStyle>
 
 #include <algorithm>
 
 using namespace Kleo;
 
 namespace
 {
 class MimeDataProxy : public QMimeData
 {
     Q_OBJECT
 public:
     explicit MimeDataProxy(QMimeData *source)
         : QMimeData(), m_source(source)
     {
 
     }
 
     QStringList formats() const override
     {
         if (m_source) {
             return m_source->formats();
         } else {
             return QStringList();
         }
     }
 
     bool hasFormat(const QString &format) const override
     {
         return m_source && m_source->hasFormat(format);
     }
 
 protected:
     QVariant retrieveData(const QString &format, QVariant::Type type) const override
     {
         if (!m_source) {
             return QVariant();
         }
         // Doesn't work, is protected:
         // return m_source->retrieveData( format, type );
 
         switch (type) {
         case QVariant::String:
             if (format == QLatin1String("text/plain")) {
                 return m_source->text();
             }
             if (format == QLatin1String("text/html")) {
                 return m_source->html();
             }
             break;
         case QVariant::Color:
             if (format == QLatin1String("application/x-color")) {
                 return m_source->colorData();
             }
             break;
         case QVariant::Image:
             if (format == QLatin1String("application/x-qt-image")) {
                 return m_source->imageData();
             }
             break;
         case QVariant::List:
         case QVariant::Url:
             if (format == QLatin1String("text/uri-list")) {
                 const QList<QUrl> urls = m_source->urls();
                 if (urls.size() == 1) {
                     return urls.front();
                 }
                 QList<QVariant> result;
                 std::copy(urls.begin(), urls.end(),
                           std::back_inserter(result));
                 return result;
             }
             break;
         default:
             break;
         }
 
         QVariant v = m_source->data(format);
         v.convert(type);
         return v;
     }
 private:
     QPointer<QMimeData> m_source;
 };
 }
 
 DragQueen::DragQueen(QWidget *p, Qt::WindowFlags f)
     : QLabel(p, f),
       m_data(),
       m_dragStartPosition()
 {
 
 }
 
 DragQueen::DragQueen(const QString &t, QWidget *p, Qt::WindowFlags f)
     : QLabel(t, p, f),
       m_data(),
       m_dragStartPosition()
 {
 
 }
 
 DragQueen::~DragQueen()
 {
     delete m_data;
 }
 
 void DragQueen::setUrl(const QString &url)
 {
     QMimeData *data = new QMimeData;
     QList<QUrl> urls;
     urls.push_back(QUrl(url));
     data->setUrls(urls);
     setMimeData(data);
 }
 
 QString DragQueen::url() const
 {
     if (!m_data || !m_data->hasUrls()) {
         return QString();
     }
     const QList<QUrl> urls = m_data->urls();
     if (urls.empty()) {
         return QString();
     }
     return urls.front().toString();
 }
 
 void DragQueen::setMimeData(QMimeData *data)
 {
     if (data == m_data) {
         return;
     }
     delete m_data;
     m_data = data;
 }
 
 QMimeData *DragQueen::mimeData() const
 {
     return m_data;
 }
 
 void DragQueen::mousePressEvent(QMouseEvent *e)
 {
 #ifndef QT_NO_DRAGANDDROP
     if (m_data && e->button() == Qt::LeftButton) {
         m_dragStartPosition = e->pos();
     }
 #endif
     QLabel::mousePressEvent(e);
 }
 
 static QPoint calculate_hot_spot(const QPoint &mouse, const QSize &pix, const QLabel *label)
 {
     const Qt::Alignment align = label->alignment();
     const int margin = label->margin();
     const QRect cr = label->contentsRect().adjusted(margin, margin, -margin, -margin);
     const QRect rect = QStyle::alignedRect(QApplication::layoutDirection(), align, pix, cr);
     return mouse - rect.topLeft();
 }
 
 void DragQueen::mouseMoveEvent(QMouseEvent *e)
 {
 #ifndef QT_NO_DRAGANDDROP
     if (m_data &&
             (e->buttons() & Qt::LeftButton) &&
             (m_dragStartPosition - e->pos()).manhattanLength() > QApplication::startDragDistance()) {
         QDrag *drag = new QDrag(this);
-#if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
-        if (const QPixmap *const pix = pixmap()) {
-            drag->setPixmap(*pix);
-            drag->setHotSpot(calculate_hot_spot(e->pos(), pix->size(), this));
-        }
-#else
         const QPixmap pix = pixmap(Qt::ReturnByValue);
         if (!pix.isNull()) {
             drag->setPixmap(pix);
             drag->setHotSpot(calculate_hot_spot(e->pos(), pix.size(), this));
         }
-#endif
         drag->setMimeData(new MimeDataProxy(m_data));
         drag->exec();
     } else {
 #endif
         QLabel::mouseMoveEvent(e);
 #ifndef QT_NO_DRAGANDDROP
     }
 #endif
 }
 
 #include "dragqueen.moc"
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 8f3b65e8f..cfdb9e3ea 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,78 +1,78 @@
 add_subdirectory(gnupg_home)
 
 set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
 include_directories(
   ${CMAKE_SOURCE_DIR}/src/
   ${CMAKE_BINARY_DIR}/src/
   ${Boost_INCLUDE_DIR}
   ${GPGME_INCLUDES}
 )
 
 ########### next target ###############
 
 set(test_verify_SRCS test_verify.cpp)
 
 add_definitions(-DKLEO_TEST_GNUPGHOME="${CMAKE_CURRENT_BINARY_DIR}/gnupg_home")
 add_definitions(-DKLEO_TEST_DATADIR="${CMAKE_CURRENT_SOURCE_DIR}")
 
 
 add_executable(test_verify  ${test_verify_SRCS})
 add_test(NAME test_verify COMMAND test_verify)
 ecm_mark_as_test(test_verify)
 
 target_link_libraries(test_verify
   KF5::Libkleo
-  Qt5::Test
+  Qt::Test
   QGpgme
   KF5::CoreAddons
   KF5::I18n
-  Qt5::Widgets
+  Qt::Widgets
 )
 
 ########### next target ###############
 
 if(USABLE_ASSUAN_FOUND)
 
   # this doesn't yet work on Windows
 
   add_definitions(-DGPG_ERR_SOURCE_DEFAULT=GPG_ERR_SOURCE_USER_2)
 
   set(test_uiserver_SRCS test_uiserver.cpp ${CMAKE_SOURCE_DIR}/src/utils/wsastarter.cpp
                                            ${CMAKE_SOURCE_DIR}/src/utils/hex.cpp)
 
 #FIXME: omitting TEST makes test_uiserver print output again on a Win32 console;
 # find a better fix for this issue
   if(WIN32)
     add_executable(test_uiserver ${test_uiserver_SRCS})
   else()
     add_executable(test_uiserver ${test_uiserver_SRCS})
   endif()
   target_link_libraries(test_uiserver KF5::I18n)
 
   if(ASSUAN2_FOUND)
     target_link_libraries(test_uiserver
       KF5::Libkleo
       ${ASSUAN2_LIBRARIES}
     )
   else()
     target_link_libraries(test_uiserver
       KF5::Libkleo
       ${ASSUAN_LIBRARIES}
     )
   endif()
 
   if(WIN32)
     target_link_libraries(test_uiserver
       ${ASSUAN_VANILLA_LIBRARIES}
       QGpgme
       ws2_32
     )
   else()
     target_link_libraries(test_uiserver
       ${ASSUAN_PTHREAD_LIBRARIES}
       QGpgme
   )
   endif()
 
 endif()