diff --git a/CMakeLists.txt b/CMakeLists.txt
index 86b10d819..e4deb357e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,236 +1,236 @@
 # 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 "11")
 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.97.0")
 set(KIDENTITYMANAGEMENT_VERSION "5.21.40")
 set(KMAILTRANSPORT_VERSION "5.21.40")
 set(KMIME_VERSION "5.21.40")
-set(LIBKLEO_VERSION "5.21.47")
+set(LIBKLEO_VERSION "5.21.48")
 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)
     set(QGPGME_SUPPORTS_SET_PRIMARY_UID 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.97.0)
 else ()
 ecm_set_disabled_deprecation_versions(QT 5.14.0 KF 5.97.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/src/aboutdata.cpp b/src/aboutdata.cpp
index cbc2f1fb3..a70b1ab2a 100644
--- a/src/aboutdata.cpp
+++ b/src/aboutdata.cpp
@@ -1,109 +1,111 @@
 /*
     aboutdata.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2001, 2002, 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 #include <version-kleopatra.h>
 
 #include "aboutdata.h"
 
 #include <Libkleo/GnuPG>
 
 #include <KLocalizedString>
 #include <KLazyLocalizedString>
 static const char kleopatra_version[] = KLEOPATRA_VERSION_STRING;
 
 struct about_data {
     const KLazyLocalizedString name;
     const KLazyLocalizedString desc;
     const char *email;
     const char *web;
 };
 
 static const about_data authors[] = {
     {kli18n("Andre Heinecke"), kli18n("Current Maintainer"),
      "aheinecke@gnupg.org", nullptr},
     {kli18n("Marc Mutz"), kli18n("Former Maintainer"), "mutz@kde.org", nullptr},
     {kli18n("Steffen Hansen"), kli18n("Former Maintainer"), "hansen@kde.org",
      nullptr},
     {kli18n("Matthias Kalle Dalheimer"), kli18n("Original Author"),
      "kalle@kde.org", nullptr},
 };
 
 static const about_data credits[] = {
     {kli18n("David Faure"),
      kli18n("Backend configuration framework, KIO integration"),
      "faure@kde.org", nullptr},
     {kli18n("Michel Boyer de la Giroday"),
      kli18n("Key-state dependent colors and fonts in the certificates list"),
      "michel@klaralvdalens-datakonsult.se", nullptr},
     {kli18n("Thomas Moenicke"), kli18n("Artwork"), "tm@php-qt.org", nullptr},
     {kli18n("Frank Osterfeld"),
      kli18n("Resident gpgme/win wrangler, UI Server commands and dialogs"),
      "osterfeld@kde.org", nullptr},
     {kli18n("Karl-Heinz Zimmer"),
      kli18n("DN display ordering support, infrastructure"), "khz@kde.org",
      nullptr},
     {kli18n("Laurent Montel"), kli18n("Qt5 port, general code maintenance"),
      "montel@kde.org", nullptr},
 };
 
 AboutData::AboutData()
-    : KAboutData(QStringLiteral("kleopatra"), i18n("Kleopatra"),
+    : KAboutData(QStringLiteral("kleopatra"),
+      (Kleo::brandingWindowTitle().isEmpty() ?
+       i18n("Kleopatra") : Kleo::brandingWindowTitle()),
 #ifdef Q_OS_WIN
                  Kleo::gpg4winVersion(),
                  Kleo::gpg4winDescription(),
 #else
                  QLatin1String(kleopatra_version),
                  i18n("Certificate Manager and Unified Crypto GUI"),
 #endif
                  KAboutLicense::GPL,
                  i18n("(c) 2002 Steffen\u00A0Hansen, Matthias\u00A0Kalle\u00A0" "Dalheimer, Klar\u00E4lvdalens\u00A0" "Datakonsult\u00A0" "AB\n"
                       "(c) 2004, 2007, 2008, 2009 Marc\u00A0Mutz, Klar\u00E4lvdalens\u00A0" "Datakonsult\u00A0" "AB") +
                  QLatin1Char('\n') +
                  i18n("(c) 2016-2018 Intevation GmbH") +
                  QLatin1Char('\n') +
                  i18n("(c) 2010-%1 The Kleopatra developers, g10 Code GmbH", QStringLiteral("2022"))
 #ifdef Q_OS_WIN
                  , Kleo::gpg4winLongDescription()
 #endif
                  )
 {
     using ::authors;
     using ::credits;
     for (unsigned int i = 0; i < sizeof authors / sizeof * authors; ++i) {
         addAuthor(KLocalizedString(authors[i].name).toString(), KLocalizedString(authors[i].desc).toString(),
                   QLatin1String(authors[i].email), QLatin1String(authors[i].web));
     }
     for (unsigned int i = 0; i < sizeof credits / sizeof * credits; ++i) {
         addCredit(KLocalizedString(credits[i].name).toString(), KLocalizedString(credits[i].desc).toString(),
                   QLatin1String(credits[i].email), QLatin1String(credits[i].web));
     }
 
     /* For Linux it is possible that kleo is shipped as part
      * of a Gpg4win based Appimage with according about data. */
     if (Kleo::gpg4winSignedversion()) {
         setVersion(Kleo::gpg4winVersion().toUtf8());
         setShortDescription(Kleo::gpg4winDescription());
         setOtherText(Kleo::gpg4winLongDescription());
         setBugAddress("https://dev.gnupg.org/u/rgpg4win");
     }
 
     const auto backendVersions = Kleo::backendVersionInfo();
     if (!backendVersions.empty()) {
         setOtherText(i18nc("Preceeds a list of applications/libraries used by Kleopatra",
                            "Uses:") +
                      QLatin1String{"<ul><li>"} +
                      backendVersions.join(QLatin1String{"</li><li>"}) +
                      QLatin1String{"</li></ul>"} +
                      otherText());
     }
 #ifdef Q_OS_WIN
     setBugAddress("https://dev.gnupg.org/u/rgpg4win");
 #endif
 }
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index b33567a27..2fcef18b6 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1,783 +1,807 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     mainwindow.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 #include "mainwindow.h"
 #include "aboutdata.h"
 #include "settings.h"
 
 #include <interfaces/focusfirstchild.h>
 
 #include "view/padwidget.h"
 #include "view/searchbar.h"
 #include "view/tabwidget.h"
 #include "view/keylistcontroller.h"
 #include "view/keycacheoverlay.h"
 #include "view/smartcardwidget.h"
 #include "view/welcomewidget.h"
 
 #include "commands/selftestcommand.h"
 #include "commands/importcrlcommand.h"
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/signencryptfilescommand.h"
 
 #include "conf/groupsconfigdialog.h"
 
 #include "utils/detail_p.h"
 #include <Libkleo/GnuPG>
 #include "utils/action_data.h"
 #include "utils/filedialog.h"
 #include "utils/clipboardmenu.h"
 #include "utils/gui-helper.h"
 #include "utils/qt-cxx20-compat.h"
 
 #include "dialogs/updatenotification.h"
 
 #include <KXMLGUIFactory>
 #include <QApplication>
 #include <QSize>
 #include <QLineEdit>
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KStandardAction>
 #include <QAction>
 #include <KAboutData>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include <KShortcutsDialog>
 #include <KToolBar>
 #include <KEditToolBar>
 #include "kleopatra_debug.h"
 #include <KConfigGroup>
 #include <KConfigDialog>
 #include <KColorScheme>
 
 #include <QAbstractItemView>
 #include <QCloseEvent>
 #include <QMenu>
 #include <QTimer>
 #include <QProcess>
 #include <QVBoxLayout>
 #include <QMimeData>
 #include <QDesktopServices>
 #include <QDir>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QLabel>
+#include <QPixmap>
 
 #include <Libkleo/Compliance>
 #include <Libkleo/Formatting>
 #include <Libkleo/GnuPG>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/Classify>
 #include <Libkleo/KeyCache>
 #include <Libkleo/DocAction>
 #include <Libkleo/SystemInfo>
 
 #include <vector>
 #include <KSharedConfig>
 #include <chrono>
 using namespace std::chrono_literals;
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 static KGuiItem KStandardGuiItem_quit()
 {
     static const QString app = KAboutData::applicationData().displayName();
     KGuiItem item = KStandardGuiItem::quit();
     item.setText(xi18nc("@action:button", "&Quit <application>%1</application>", app));
     return item;
 }
 
 static KGuiItem KStandardGuiItem_close()
 {
     KGuiItem item = KStandardGuiItem::close();
     item.setText(i18nc("@action:button", "Only &Close Window"));
     return item;
 }
 
 static bool isQuitting = false;
 
 namespace
 {
 static const std::vector<QString> mainViewActionNames = {
     QStringLiteral("view_certificate_overview"),
     QStringLiteral("manage_smartcard"),
     QStringLiteral("pad_view")
 };
 
 class CertificateView : public QWidget, public FocusFirstChild
 {
     Q_OBJECT
 public:
     CertificateView(QWidget* parent = nullptr)
         : QWidget{parent}
         , ui{this}
     {
     }
 
     SearchBar *searchBar() const
     {
         return ui.searchBar;
     }
 
     TabWidget *tabWidget() const
     {
         return ui.tabWidget;
     }
 
     void focusFirstChild(Qt::FocusReason reason) override
     {
         ui.searchBar->lineEdit()->setFocus(reason);
     }
 
 private:
     struct UI {
         TabWidget *tabWidget = nullptr;
         SearchBar *searchBar = nullptr;
         explicit UI(CertificateView *q)
         {
             auto vbox = new QVBoxLayout{q};
             vbox->setSpacing(0);
 
             searchBar = new SearchBar{q};
             vbox->addWidget(searchBar);
             tabWidget = new TabWidget{q};
             vbox->addWidget(tabWidget);
 
             tabWidget->connectSearchBar(searchBar);
         }
     } ui;
 };
 
 }
 
 class MainWindow::Private
 {
     friend class ::MainWindow;
     MainWindow *const q;
 
 public:
     explicit Private(MainWindow *qq);
     ~Private();
 
     template <typename T>
     void createAndStart()
     {
         (new T(this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(QAbstractItemView *view)
     {
         (new T(view, &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a)
     {
         (new T(a, this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a, QAbstractItemView *view)
     {
         (new T(a, view, &this->controller))->start();
     }
 
     void closeAndQuit()
     {
         const QString app = KAboutData::applicationData().displayName();
         const int rc = KMessageBox::questionYesNoCancel(q,
                        xi18n("<application>%1</application> may be used by other applications as a service.<nl/>"
                              "You may instead want to close this window without exiting <application>%1</application>.", app),
                        i18nc("@title:window", "Really Quit?"),
                        KStandardGuiItem_close(),
                        KStandardGuiItem_quit(),
                        KStandardGuiItem::cancel(),
                        QLatin1String("really-quit-") + app.toLower());
         if (rc == KMessageBox::Cancel) {
             return;
         }
         isQuitting = true;
         if (!q->close()) {
             return;
         }
         // WARNING: 'this' might be deleted at this point!
         if (rc == KMessageBox::No) {
             qApp->quit();
         }
     }
     void configureToolbars()
     {
         KEditToolBar dlg(q->factory());
         dlg.exec();
     }
     void editKeybindings()
     {
         KShortcutsDialog::showDialog(q->actionCollection(), KShortcutsEditor::LetterShortcutsAllowed, q);
         updateSearchBarClickMessage();
     }
 
     void updateSearchBarClickMessage()
     {
         const QString shortcutStr = focusToClickSearchAction->shortcut().toString();
         ui.searchTab->searchBar()->updateClickMessage(shortcutStr);
     }
 
     void updateStatusBar()
     {
         if (DeVSCompliance::isActive()) {
             auto statusBar = std::make_unique<QStatusBar>();
             auto statusLbl = std::make_unique<QLabel>(DeVSCompliance::name());
             if (!SystemInfo::isHighContrastModeActive()) {
                 const auto color = KColorScheme(QPalette::Active, KColorScheme::View).foreground(
                     DeVSCompliance::isCompliant() ? KColorScheme::NormalText: KColorScheme::NegativeText
                 ).color();
                 const auto background = KColorScheme(QPalette::Active, KColorScheme::View).background(
                     DeVSCompliance::isCompliant() ? KColorScheme::PositiveBackground : KColorScheme::NegativeBackground
                 ).color();
                 statusLbl->setStyleSheet(QStringLiteral("QLabel { color: %1; background-color: %2; }").
                                         arg(color.name()).arg(background.name()));
             }
             statusBar->insertPermanentWidget(0, statusLbl.release());
             q->setStatusBar(statusBar.release());  // QMainWindow takes ownership
         } else {
             q->setStatusBar(nullptr);
         }
     }
 
     void selfTest()
     {
         createAndStart<SelfTestCommand>();
     }
 
     void configureGroups()
     {
         if (KConfigDialog::showDialog(GroupsConfigDialog::dialogName())) {
             return;
         }
         KConfigDialog *dialog = new GroupsConfigDialog(q);
         dialog->show();
     }
 
     void showHandbook();
 
     void gnupgLogViewer()
     {
       const QString exec =
           QStandardPaths::findExecutable(QStringLiteral("kwatchgnupg"));
       if (exec.isEmpty()) {
         KMessageBox::error(
             q,
             i18n("Could not start the GnuPG Log Viewer (kwatchgnupg). "
                  "Please check your installation."),
             i18n("Error Starting KWatchGnuPG"));
       } else {
         QProcess::startDetached(QStringLiteral("kwatchgnupg"), QStringList());
       }
     }
 
     void forceUpdateCheck()
     {
         UpdateNotification::forceUpdateCheck(q);
     }
 
     void slotConfigCommitted();
     void slotContextMenuRequested(QAbstractItemView *, const QPoint &p)
     {
         if (auto const menu = qobject_cast<QMenu *>(q->factory()->container(QStringLiteral("listview_popup"), q))) {
             menu->exec(p);
         } else {
             qCDebug(KLEOPATRA_LOG) << "no \"listview_popup\" <Menu> in kleopatra's ui.rc file";
         }
     }
 
     void slotFocusQuickSearch()
     {
         ui.searchTab->searchBar()->lineEdit()->setFocus();
     }
 
     void showView(const QString &actionName, QWidget *widget)
     {
         const auto coll = q->actionCollection();
         if (coll) {
             for ( const QString &name : mainViewActionNames ) {
                 if (auto action = coll->action(name)) {
                     action->setChecked(name == actionName);
                 }
             }
         }
         ui.stackWidget->setCurrentWidget(widget);
         if (auto ffci = dynamic_cast<Kleo::FocusFirstChild *>(widget)) {
             ffci->focusFirstChild(Qt::TabFocusReason);
         }
     }
 
     void showCertificateView()
     {
         if (KeyCache::instance()->keys().empty()) {
             showView(QStringLiteral("view_certificate_overview"), ui.welcomeWidget);
         } else {
             showView(QStringLiteral("view_certificate_overview"), ui.searchTab);
         }
     }
 
     void showSmartcardView()
     {
         showView(QStringLiteral("manage_smartcard"), ui.scWidget);
     }
 
     void showPadView()
     {
         if (!ui.padWidget) {
             ui.padWidget = new PadWidget;
             ui.stackWidget->addWidget(ui.padWidget);
         }
         showView(QStringLiteral("pad_view"), ui.padWidget);
         ui.stackWidget->resize(ui.padWidget->sizeHint());
     }
 
     void restartDaemons()
     {
         Kleo::killDaemons();
     }
 
 private:
     void setupActions();
 
     QAbstractItemView *currentView() const
     {
         return ui.searchTab->tabWidget()->currentView();
     }
 
     void keyListingDone()
     {
         const auto curWidget = ui.stackWidget->currentWidget();
         if (curWidget == ui.scWidget || curWidget == ui.padWidget) {
            return;
         }
         showCertificateView();
     }
 
 private:
     Kleo::KeyListController controller;
     bool firstShow : 1;
     struct UI {
         CertificateView *searchTab = nullptr;
         PadWidget *padWidget = nullptr;
         SmartCardWidget *scWidget = nullptr;
         WelcomeWidget *welcomeWidget = nullptr;
         QStackedWidget *stackWidget = nullptr;
         explicit UI(MainWindow *q);
     } ui;
     QAction *focusToClickSearchAction = nullptr;
     ClipboardMenu *clipboadMenu = nullptr;
 };
 
 MainWindow::Private::UI::UI(MainWindow *q)
     : padWidget(nullptr)
 {
     auto mainWidget = new QWidget{q};
     auto mainLayout = new QVBoxLayout(mainWidget);
     stackWidget = new QStackedWidget{q};
 
     searchTab = new CertificateView{q};
     stackWidget->addWidget(searchTab);
 
     new KeyCacheOverlay(mainWidget, q);
 
     scWidget = new SmartCardWidget{q};
     stackWidget->addWidget(scWidget);
 
     welcomeWidget = new WelcomeWidget{q};
     stackWidget->addWidget(welcomeWidget);
 
     mainLayout->addWidget(stackWidget);
 
     q->setCentralWidget(mainWidget);
 }
 
 MainWindow::Private::Private(MainWindow *qq)
     : q(qq),
       controller(q),
       firstShow(true),
       ui(q)
 {
     KDAB_SET_OBJECT_NAME(controller);
 
     AbstractKeyListModel *flatModel = AbstractKeyListModel::createFlatKeyListModel(q);
     AbstractKeyListModel *hierarchicalModel = AbstractKeyListModel::createHierarchicalKeyListModel(q);
 
     KDAB_SET_OBJECT_NAME(flatModel);
     KDAB_SET_OBJECT_NAME(hierarchicalModel);
 
     controller.setFlatModel(flatModel);
     controller.setHierarchicalModel(hierarchicalModel);
     controller.setTabWidget(ui.searchTab->tabWidget());
 
     ui.searchTab->tabWidget()->setFlatModel(flatModel);
     ui.searchTab->tabWidget()->setHierarchicalModel(hierarchicalModel);
 
     setupActions();
 
     ui.stackWidget->setCurrentWidget(ui.searchTab);
     if (auto action = q->actionCollection()->action(QStringLiteral("view_certificate_overview"))) {
         action->setChecked(true);
     }
 
     connect(&controller, SIGNAL(contextMenuRequested(QAbstractItemView*,QPoint)), q, SLOT(slotContextMenuRequested(QAbstractItemView*,QPoint)));
     connect(KeyCache::instance().get(), &KeyCache::keyListingDone, q, [this] () {keyListingDone();});
 
     q->createGUI(QStringLiteral("kleopatra.rc"));
 
     // make toolbar buttons accessible by keyboard
-    if (auto toolbar = q->findChild<KToolBar*>()) {
+    auto toolbar = q->findChild<KToolBar*>();
+    if (toolbar) {
         auto toolbarButtons = toolbar->findChildren<QToolButton*>();
         for (auto b : toolbarButtons) {
             b->setFocusPolicy(Qt::TabFocus);
         }
         // move toolbar and its child widgets before the central widget in the tab order;
         // this is necessary to make Shift+Tab work as expected
         forceSetTabOrder(q, toolbar);
         auto toolbarChildren = toolbar->findChildren<QWidget*>();
         std::for_each(std::rbegin(toolbarChildren), std::rend(toolbarChildren), [toolbar](auto w) {
             forceSetTabOrder(toolbar, w);
         });
     }
 
+    const auto title = Kleo::brandingWindowTitle();
+    if (!title.isEmpty()) {
+        QApplication::setApplicationDisplayName(title);
+    }
+
+    const auto icon = Kleo::brandingIcon();
+    if (!icon.isEmpty()) {
+        const auto dir = QDir(Kleo::gpg4winInstallPath() + QStringLiteral("/../share/kleopatra/pics"));
+        qCDebug(KLEOPATRA_LOG) << "Loading branding icon:" << dir.absoluteFilePath(icon);
+        QPixmap brandingIcon(dir.absoluteFilePath(icon));
+        if (!brandingIcon.isNull()) {
+            auto *w = new QWidget;
+            auto *hl = new QHBoxLayout;
+            auto *lbl = new QLabel;
+            w->setLayout(hl);
+            hl->addWidget(lbl);
+            lbl->setPixmap(brandingIcon);
+            toolbar->addSeparator();
+            toolbar->addWidget(w);
+        }
+    }
+
     q->setAcceptDrops(true);
 
     // set default window size
     q->resize(QSize(1024, 500));
     q->setAutoSaveSettings();
 
     updateSearchBarClickMessage();
     updateStatusBar();
 
     if (KeyCache::instance()->initialized()) {
         keyListingDone();
     }
 }
 
 MainWindow::Private::~Private() {}
 
 MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags)
     : KXmlGuiWindow(parent, flags), d(new Private(this))
 {}
 
 MainWindow::~MainWindow() {}
 
 void MainWindow::Private::setupActions()
 {
 
     KActionCollection *const coll = q->actionCollection();
 
     const std::vector<action_data> action_data = {
         // see keylistcontroller.cpp for more actions
         // Tools menu
 #ifndef Q_OS_WIN
         {
             "tools_start_kwatchgnupg", i18n("GnuPG Log Viewer"), QString(),
             "kwatchgnupg", q, [this](bool) { gnupgLogViewer(); }, QString()
         },
 #endif
         {
             "tools_restart_backend", i18nc("@action:inmenu", "Restart Background Processes"),
             i18nc("@info:tooltip", "Restart the background processes, e.g. after making changes to the configuration."),
             "view-refresh", q, [this](bool) { restartDaemons(); }, {}
         },
         // Help menu
 #ifdef Q_OS_WIN
         {
             "help_check_updates", i18n("Check for updates"), QString(),
             "gpg4win-compact", q, [this](bool) { forceUpdateCheck(); }, QString()
         },
 #endif
         // View menu
         {
             "view_certificate_overview", i18nc("@action show certificate overview", "Certificates"),
             i18n("Show certificate overview"), "view-certificate", q, [this](bool) { showCertificateView(); }, QString()
         },
         {
             "pad_view", i18nc("@action show input / output area for encrypting/signing resp. decrypting/verifying text", "Notepad"),
             i18n("Show pad for encrypting/decrypting and signing/verifying text"), "note", q, [this](bool) { showPadView(); }, QString()
         },
         {
             "manage_smartcard", i18nc("@action show smartcard management view", "Smartcards"),
             i18n("Show smartcard management"), "auth-sim-locked", q, [this](bool) { showSmartcardView(); }, QString()
         },
         // Settings menu
         {
             "settings_self_test", i18n("Perform Self-Test"), QString(),
             nullptr, q, [this](bool) { selfTest(); }, QString()
         },
         {
             "configure_groups", i18n("Configure Groups..."), QString(),
             "group", q, [this](bool) { configureGroups(); }, QString()
         }
     };
 
     make_actions_from_data(action_data, coll);
 
     if (!Settings().groupsEnabled()) {
         if (auto action = coll->action(QStringLiteral("configure_groups"))) {
             delete action;
         }
     }
 
     for ( const QString &name : mainViewActionNames ) {
         if (auto action = coll->action(name)) {
             action->setCheckable(true);
         }
     }
 
     KStandardAction::close(q, SLOT(close()), coll);
     KStandardAction::quit(q, SLOT(closeAndQuit()), coll);
     KStandardAction::configureToolbars(q, SLOT(configureToolbars()), coll);
     KStandardAction::keyBindings(q, SLOT(editKeybindings()), coll);
     KStandardAction::preferences(qApp, SLOT(openOrRaiseConfigDialog()), coll);
 
     focusToClickSearchAction = new QAction(i18n("Set Focus to Quick Search"), q);
     coll->addAction(QStringLiteral("focus_to_quickseach"), focusToClickSearchAction);
     coll->setDefaultShortcut(focusToClickSearchAction, QKeySequence(Qt::ALT | Qt::Key_Q));
     connect(focusToClickSearchAction, SIGNAL(triggered(bool)), q, SLOT(slotFocusQuickSearch()));
     clipboadMenu = new ClipboardMenu(q);
     clipboadMenu->setMainWindow(q);
     clipboadMenu->clipboardMenu()->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste")));
     clipboadMenu->clipboardMenu()->setPopupMode(QToolButton::InstantPopup);
     coll->addAction(QStringLiteral("clipboard_menu"), clipboadMenu->clipboardMenu());
 
     /* Add additional help actions for documentation */
     const auto compendium = new DocAction(QIcon::fromTheme(QStringLiteral("gpg4win-compact")), i18n("Gpg4win Compendium"),
             i18nc("The Gpg4win compendium is only available"
                   "at this point (24.7.2017) in german and english."
                   "Please check with Gpg4win before translating this filename.",
                   "gpg4win-compendium-en.pdf"),
             QStringLiteral("../share/gpg4win"));
     coll->addAction(QStringLiteral("help_doc_compendium"), compendium);
 
     /* Documentation centered around the german approved VS-NfD mode for official
      * RESTRICTED communication. This is only available in some distributions with
      * the focus on official communications. */
     const auto symguide = new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")), i18n("Password-based encryption"),
             i18nc("Only available in German and English. Leave to English for other languages.",
                 "handout_symmetric_encryption_gnupg_en.pdf"),
             QStringLiteral("../share/doc/gnupg-vsd"));
     coll->addAction(QStringLiteral("help_doc_symenc"), symguide);
 
     const auto quickguide = new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")), i18n("Quickguide"),
             i18nc("Only available in German and English. Leave to English for other languages.",
                 "handout_sign_encrypt_gnupg_en.pdf"),
             QStringLiteral("../share/doc/gnupg-vsd"));
     coll->addAction(QStringLiteral("help_doc_quickguide"), quickguide);
 
     const auto vsa10573 = new DocAction(QIcon::fromTheme(QStringLiteral("dvipdf")), i18n("SecOps VSA-10573"),
             i18nc("Only available in German and English. Leave to English for other languages.",
                 "BSI-VSA-10573-ENG_secops-20220207.pdf"),
             QStringLiteral("../share/doc/gnupg-vsd"));
     coll->addAction(QStringLiteral("help_doc_vsa10573"), vsa10573);
 
     const auto vsa10584 = new DocAction(QIcon::fromTheme(QStringLiteral("dvipdf")), i18n("SecOps VSA-10584"),
             i18nc("Only available in German and English. Leave to English for other languages.",
                 "BSI-VSA-10584-ENG_secops-20220207.pdf"),
             QStringLiteral("../share/doc/gnupg-vsd"));
     coll->addAction(QStringLiteral("help_doc_vsa10584"), vsa10584);
 
     const auto man_gpg = new DocAction(QIcon::fromTheme(QStringLiteral("help-contextual")), i18n("GnuPG Manual"),
             QStringLiteral("gnupg.pdf"), QStringLiteral("../share/doc/gnupg"));
     coll->addAction(QStringLiteral("help_doc_gnupg"), man_gpg);
 
     q->setStandardToolBarMenuEnabled(true);
 
     controller.createActions(coll);
 
     ui.searchTab->tabWidget()->createActions(coll);
 }
 
 void MainWindow::Private::slotConfigCommitted()
 {
     controller.updateConfig();
     updateStatusBar();
 }
 
 void MainWindow::closeEvent(QCloseEvent *e)
 {
     // KMainWindow::closeEvent() insists on quitting the application,
     // so do not let it touch the event...
     qCDebug(KLEOPATRA_LOG);
     if (d->controller.hasRunningCommands()) {
         if (d->controller.shutdownWarningRequired()) {
             const int ret = KMessageBox::warningContinueCancel(this, i18n("There are still some background operations ongoing. "
                             "These will be terminated when closing the window. "
                             "Proceed?"),
                             i18n("Ongoing Background Tasks"));
             if (ret != KMessageBox::Continue) {
                 e->ignore();
                 return;
             }
         }
         d->controller.cancelCommands();
         if (d->controller.hasRunningCommands()) {
             // wait for them to be finished:
             setEnabled(false);
             QEventLoop ev;
             QTimer::singleShot(100ms, &ev, &QEventLoop::quit);
             connect(&d->controller, &KeyListController::commandsExecuting, &ev, &QEventLoop::quit);
             ev.exec();
             if (d->controller.hasRunningCommands())
                 qCWarning(KLEOPATRA_LOG)
                         << "controller still has commands running, this may crash now...";
             setEnabled(true);
         }
     }
     if (isQuitting || qApp->isSavingSession()) {
         d->ui.searchTab->tabWidget()->saveViews(KSharedConfig::openConfig().data());
         KConfigGroup grp(KConfigGroup(KSharedConfig::openConfig(), autoSaveGroup()));
         saveMainWindowSettings(grp);
         e->accept();
     } else {
         e->ignore();
         hide();
     }
 }
 
 void MainWindow::showEvent(QShowEvent *e)
 {
     KXmlGuiWindow::showEvent(e);
     if (d->firstShow) {
         d->ui.searchTab->tabWidget()->loadViews(KSharedConfig::openConfig().data());
         d->firstShow = false;
     }
 
     if (!savedGeometry.isEmpty()) {
         restoreGeometry(savedGeometry);
     }
 }
 
 void MainWindow::hideEvent(QHideEvent *e)
 {
     savedGeometry = saveGeometry();
     KXmlGuiWindow::hideEvent(e);
 }
 
 void MainWindow::importCertificatesFromFile(const QStringList &files)
 {
     if (!files.empty()) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     }
 }
 
 static QStringList extract_local_files(const QMimeData *data)
 {
     const QList<QUrl> urls = data->urls();
     // begin workaround KDE/Qt misinterpretation of text/uri-list
     QList<QUrl>::const_iterator end = urls.end();
     if (urls.size() > 1 && !urls.back().isValid()) {
         --end;
     }
     // end workaround
     QStringList result;
     std::transform(urls.begin(), end,
                    std::back_inserter(result),
                    std::mem_fn(&QUrl::toLocalFile));
     result.erase(std::remove_if(result.begin(), result.end(),
                                 std::mem_fn(&QString::isEmpty)), result.end());
     return result;
 }
 
 static bool can_decode_local_files(const QMimeData *data)
 {
     if (!data) {
         return false;
     }
     return !extract_local_files(data).empty();
 }
 
 void MainWindow::dragEnterEvent(QDragEnterEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (can_decode_local_files(e->mimeData())) {
         e->acceptProposedAction();
     }
 }
 
 void MainWindow::dropEvent(QDropEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (!can_decode_local_files(e->mimeData())) {
         return;
     }
 
     e->setDropAction(Qt::CopyAction);
 
     const QStringList files = extract_local_files(e->mimeData());
 
     const unsigned int classification = classify(files);
 
     QMenu menu;
 
     QAction *const signEncrypt = menu.addAction(i18n("Sign/Encrypt..."));
     QAction *const decryptVerify = mayBeAnyMessageType(classification) ? menu.addAction(i18n("Decrypt/Verify...")) : nullptr;
     if (signEncrypt || decryptVerify) {
         menu.addSeparator();
     }
 
     QAction *const importCerts = mayBeAnyCertStoreType(classification) ? menu.addAction(i18n("Import Certificates")) : nullptr;
     QAction *const importCRLs  = mayBeCertificateRevocationList(classification) ? menu.addAction(i18n("Import CRLs")) : nullptr;
     if (importCerts || importCRLs) {
         menu.addSeparator();
     }
 
     if (!signEncrypt && !decryptVerify && !importCerts && !importCRLs) {
         return;
     }
 
     menu.addAction(i18n("Cancel"));
 
     const QAction *const chosen = menu.exec(mapToGlobal(e->pos()));
 
     if (!chosen) {
         return;
     }
 
     if (chosen == signEncrypt) {
         d->createAndStart<SignEncryptFilesCommand>(files);
     } else if (chosen == decryptVerify) {
         d->createAndStart<DecryptVerifyFilesCommand>(files);
     } else if (chosen == importCerts) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     } else if (chosen == importCRLs) {
         d->createAndStart<ImportCrlCommand>(files);
     }
 
     e->accept();
 }
 
 void MainWindow::readProperties(const KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::readProperties(cg);
     setHidden(cg.readEntry("hidden", false));
 }
 
 void MainWindow::saveProperties(KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::saveProperties(cg);
     cg.writeEntry("hidden", isHidden());
 }
 
 #include "mainwindow.moc"
 #include "moc_mainwindow.cpp"