diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7ca8344cf..daf13974d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,259 +1,259 @@
 # SPDX-FileCopyrightText: none
 # SPDX-License-Identifier: BSD-3-Clause
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 set(RELEASE_SERVICE_VERSION_MAJOR "24")
 set(RELEASE_SERVICE_VERSION_MINOR "04")
 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 "2")
 set(KLEOPATRA_VERSION_MICRO "0")
 
 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")
 if (NOT KLEOPATRA_DISTRIBUTION_TEXT)
     # This is only used on Windows for the file attributes of Kleopatra
     set(KLEOPATRA_DISTRIBUTION_TEXT "KDE")
 endif()
 
 project(kleopatra VERSION ${kleopatra_version})
 
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF_MIN_VERSION "5.248.0")
 set(KIDENTITYMANAGEMENT_VERSION "6.0.40")
 set(KMAILTRANSPORT_VERSION "6.0.40")
 set(AKONADI_MIME_VERSION "6.0.40")
 set(KMIME_VERSION "6.0.40")
-set(LIBKLEO_VERSION "6.0.42")
+set(LIBKLEO_VERSION "6.0.43")
 set(QT_REQUIRED_VERSION "6.6.0")
 set(MIMETREEPARSER_VERSION "6.0.40")
 set(GPGME_REQUIRED_VERSION "1.20.0")
 set(LIBASSUAN_REQUIRED_VERSION "2.4.2")
 set(GPG_ERROR_REQUIRED_VERSION "1.36")
 
 if (WIN32)
   set(KF6_WANT_VERSION "6.0.40")
   set(KMIME_WANT_VERSION "5.248.0")
 else ()
   set(KF6_WANT_VERSION ${KF_MIN_VERSION})
   set(KMIME_WANT_VERSION ${KMIME_VERSION})
 endif ()
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 find_package(ECM ${KF6_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)
 include(KDEGitCommitHooks)
 
 # Find KF6 packages
 find_package(KF6 ${KF6_WANT_VERSION}
     REQUIRED COMPONENTS
     Codecs
     Config
     CoreAddons
     Crash
     I18n
     IconThemes
     ItemModels
     KCMUtils
     KIO
     WidgetsAddons
     WindowSystem
     XmlGui
     StatusNotifierItem
 
     OPTIONAL_COMPONENTS
     DocTools
 )
 
 set_package_properties(KF6DocTools 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(KF6DBusAddons ${KF6_WANT_VERSION} CONFIG)
   set_package_properties(KF6DBusAddons PROPERTIES DESCRIPTION "Support library to work with DBus"
                          PURPOSE "DBus session integration"
                          URL "https://inqlude.org/libraries/kdbusaddons.html"
                          TYPE OPTIONAL)
 else()
   find_package(KF6DBusAddons ${KF6_WANT_VERSION} CONFIG REQUIRED)
   set(_kleopatra_dbusaddons_libs KF6::DBusAddons)
 endif()
 
 set(HAVE_QDBUS ${Qt6DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 set(QGPGME_NAME "QGpgmeQt6")
 find_package(${QGPGME_NAME} ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.21.0")
     set(QGPGME_ARCHIVE_JOBS_SUPPORT_OUTPUT_FILENAME 1)
     set(QGPGME_ARCHIVE_JOBS_SUPPORT_INPUT_FILENAME 1)
 endif()
 if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.22.0")
     set(QGPGME_HAS_TOLOGSTRING 1)
     set(QGPGME_SUPPORTS_IS_MIME 1)
 endif()
 if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.23.0")
     set(QGPGME_SUPPORTS_WKD_REFRESH_JOB 1)
 endif()
 if (${QGPGME_NAME}_VERSION VERSION_GREATER_EQUAL "1.23.3")
     set(QGPGME_FILE_JOBS_SUPPORT_DIRECT_FILE_IO 1)
 endif()
 
 find_package(KPim6Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KPim6Mime ${KMIME_WANT_VERSION} CONFIG REQUIRED)
 find_package(KPim6IdentityManagementCore ${KIDENTITYMANAGEMENT_VERSION} CONFIG)
 find_package(KPim6MailTransport ${KMAILTRANSPORT_VERSION} CONFIG)
 find_package(KPim6AkonadiMime ${AKONADI_MIME_VERSION} CONFIG)
 find_package(KPim6MimeTreeParserWidgets ${MIMETREEPARSER_VERSION} CONFIG REQUIRED)
 
 find_package(Qt6 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)
 
 find_package(LibAssuan ${LIBASSUAN_REQUIRED_VERSION} REQUIRED)
 set_package_properties(LibAssuan PROPERTIES
   TYPE REQUIRED
   PURPOSE "Needed for Kleopatra to act as the GnuPG UI Server"
 )
 find_package(LibGpgError ${GPG_ERROR_REQUIRED_VERSION} REQUIRED)
 set_package_properties(LibGpgError PROPERTIES
   TYPE 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.in ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.in ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
 
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
 if (WIN32)
 # On Windows, we need to use stuff deprecated since Qt 5.11, e.g. from QDesktopWidget
 add_definitions(-DQT_NO_CONTEXTLESS_CONNECT)
 ecm_set_disabled_deprecation_versions(QT 5.10.0  KF 5.249.0)
 else ()
 add_definitions(-DQT_NO_CONTEXTLESS_CONNECT)
 ecm_set_disabled_deprecation_versions(QT 6.6.0 KF 5.249.0)
 endif ()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
 endif()
 if(MINGW)
     # we do not care about different signedness of passed pointer arguments
     add_compile_options($<$<COMPILE_LANGUAGE:C>:-Wno-pointer-sign>)
 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(KF6DocTools_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})
 kde_configure_git_pre_commit_hook(CHECKS CLANG_FORMAT)
 
diff --git a/src/view/keytreeview.cpp b/src/view/keytreeview.cpp
index d08ba4142..1ee85b985 100644
--- a/src/view/keytreeview.cpp
+++ b/src/view/keytreeview.cpp
@@ -1,736 +1,741 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     view/keytreeview.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "keytreeview.h"
 #include "searchbar.h"
 
 #include <Libkleo/KeyList>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/KeyRearrangeColumnsProxyModel>
 #include <Libkleo/Predicates>
 #include <Libkleo/TreeView>
 
 #include "utils/headerview.h"
 #include "utils/tags.h"
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyFilter>
 #include <Libkleo/Stl_Util>
 
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 #include <QAction>
 #include <QContextMenuEvent>
 #include <QEvent>
 #include <QHeaderView>
 #include <QItemSelection>
 #include <QItemSelectionModel>
 #include <QLayout>
 #include <QList>
 #include <QMenu>
 #include <QTimer>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 
-#define TAGS_COLUMN 13
+static int tagsColumn;
 
 using namespace Kleo;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 namespace
 {
 
 class TreeViewInternal : public Kleo::TreeView
 {
 public:
     explicit TreeViewInternal(QWidget *parent = nullptr)
         : Kleo::TreeView{parent}
     {
         connect(this, &TreeView::columnEnabled, this, [this](int column) {
-            if (column == TAGS_COLUMN) {
+            if (column == tagsColumn) {
                 Tags::enableTags();
             }
             auto tv = qobject_cast<KeyTreeView *>(this->parent());
             if (tv) {
                 tv->resizeColumns();
             }
         });
         connect(this, &TreeView::columnDisabled, this, [this]() {
             auto tv = qobject_cast<KeyTreeView *>(this->parent());
             if (tv) {
                 tv->resizeColumns();
             }
         });
     }
 
     QSize minimumSizeHint() const override
     {
         const QSize min = QTreeView::minimumSizeHint();
         return QSize(min.width(), min.height() + 5 * fontMetrics().height());
     }
 
 protected:
     void focusInEvent(QFocusEvent *event) override
     {
         QTreeView::focusInEvent(event);
         // queue the invokation, so that it happens after the widget itself got focus
         QMetaObject::invokeMethod(this, &TreeViewInternal::forceAccessibleFocusEventForCurrentItem, Qt::QueuedConnection);
     }
 
 private:
     void forceAccessibleFocusEventForCurrentItem()
     {
         // force Qt to send a focus event for the current item to accessibility
         // tools; otherwise, the user has no idea which item is selected when the
         // list gets keyboard input focus
         const auto current = currentIndex();
         setCurrentIndex({});
         setCurrentIndex(current);
     }
 
 private:
     QMenu *mHeaderPopup = nullptr;
 
     QList<QAction *> mColumnActions;
 };
 
 const KeyListModelInterface *keyListModel(const QTreeView &view)
 {
     const KeyListModelInterface *const klmi = dynamic_cast<KeyListModelInterface *>(view.model());
     Q_ASSERT(klmi);
     return klmi;
 }
 
 } // anon namespace
 
 KeyTreeView::KeyTreeView(QWidget *parent)
     : QWidget(parent)
     , m_proxy(new KeyListSortFilterProxyModel(this))
     , m_additionalProxy(nullptr)
     , m_view(new TreeViewInternal(this))
     , m_flatModel(nullptr)
     , m_hierarchicalModel(nullptr)
     , m_stringFilter()
     , m_keyFilter()
     , m_isHierarchical(true)
 {
     init();
 }
 
 KeyTreeView::KeyTreeView(const KeyTreeView &other)
     : QWidget(nullptr)
     , m_proxy(new KeyListSortFilterProxyModel(this))
     , m_additionalProxy(other.m_additionalProxy ? other.m_additionalProxy->clone() : nullptr)
     , m_view(new TreeViewInternal(this))
     , m_flatModel(other.m_flatModel)
     , m_hierarchicalModel(other.m_hierarchicalModel)
     , m_stringFilter(other.m_stringFilter)
     , m_keyFilter(other.m_keyFilter)
     , m_group(other.m_group)
     , m_isHierarchical(other.m_isHierarchical)
 {
     init();
     setColumnSizes(other.columnSizes());
     setSortColumn(other.sortColumn(), other.sortOrder());
 }
 
 KeyTreeView::KeyTreeView(const QString &text,
                          const std::shared_ptr<KeyFilter> &kf,
                          AbstractKeyListSortFilterProxyModel *proxy,
                          QWidget *parent,
                          const KConfigGroup &group)
     : QWidget(parent)
     , m_proxy(new KeyListSortFilterProxyModel(this))
     , m_additionalProxy(proxy)
     , m_view(new TreeViewInternal(this))
     , m_flatModel(nullptr)
     , m_hierarchicalModel(nullptr)
     , m_stringFilter(text)
     , m_keyFilter(kf)
     , m_group(group)
     , m_isHierarchical(true)
     , m_onceResized(false)
 {
     init();
 }
 
 void KeyTreeView::setColumnSizes(const std::vector<int> &sizes)
 {
     if (sizes.empty()) {
         return;
     }
     Q_ASSERT(m_view);
     Q_ASSERT(m_view->header());
     Q_ASSERT(qobject_cast<HeaderView *>(m_view->header()) == static_cast<HeaderView *>(m_view->header()));
     if (auto const hv = static_cast<HeaderView *>(m_view->header())) {
         hv->setSectionSizes(sizes);
     }
 }
 
 void KeyTreeView::setSortColumn(int sortColumn, Qt::SortOrder sortOrder)
 {
     Q_ASSERT(m_view);
     m_view->sortByColumn(sortColumn, sortOrder);
 }
 
 int KeyTreeView::sortColumn() const
 {
     Q_ASSERT(m_view);
     Q_ASSERT(m_view->header());
     return m_view->header()->sortIndicatorSection();
 }
 
 Qt::SortOrder KeyTreeView::sortOrder() const
 {
     Q_ASSERT(m_view);
     Q_ASSERT(m_view->header());
     return m_view->header()->sortIndicatorOrder();
 }
 
 std::vector<int> KeyTreeView::columnSizes() const
 {
     Q_ASSERT(m_view);
     Q_ASSERT(m_view->header());
     Q_ASSERT(qobject_cast<HeaderView *>(m_view->header()) == static_cast<HeaderView *>(m_view->header()));
     if (auto const hv = static_cast<HeaderView *>(m_view->header())) {
         return hv->sectionSizes();
     } else {
         return std::vector<int>();
     }
 }
 
 void KeyTreeView::init()
 {
     KDAB_SET_OBJECT_NAME(m_proxy);
     KDAB_SET_OBJECT_NAME(m_view);
 
     if (m_group.isValid()) {
         // Reopen as non const
         KConfig *conf = m_group.config();
         m_group = conf->group(m_group.name());
     }
 
     if (m_additionalProxy && m_additionalProxy->objectName().isEmpty()) {
         KDAB_SET_OBJECT_NAME(m_additionalProxy);
     }
     QLayout *layout = new QVBoxLayout(this);
     KDAB_SET_OBJECT_NAME(layout);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->addWidget(m_view);
 
     auto headerView = new HeaderView(Qt::Horizontal);
     KDAB_SET_OBJECT_NAME(headerView);
     headerView->installEventFilter(m_view);
     headerView->setSectionsMovable(true);
     m_view->setHeader(headerView);
 
     m_view->setSelectionBehavior(QAbstractItemView::SelectRows);
     m_view->setSelectionMode(QAbstractItemView::ExtendedSelection);
     m_view->setAllColumnsShowFocus(false);
     m_view->setSortingEnabled(true);
     m_view->setAccessibleName(i18n("Certificates"));
     m_view->setAccessibleDescription(m_isHierarchical ? i18n("Hierarchical list of certificates") : i18n("List of certificates"));
     // we show details on double-click
     m_view->setExpandsOnDoubleClick(false);
 
     if (model()) {
         if (m_additionalProxy) {
             m_additionalProxy->setSourceModel(model());
         } else {
             m_proxy->setSourceModel(model());
         }
     }
     if (m_additionalProxy) {
         m_proxy->setSourceModel(m_additionalProxy);
         if (!m_additionalProxy->parent()) {
             m_additionalProxy->setParent(this);
         }
     }
 
     m_proxy->setFilterRegularExpression(QRegularExpression::escape(m_stringFilter));
     m_proxy->setKeyFilter(m_keyFilter);
     m_proxy->setSortCaseSensitivity(Qt::CaseInsensitive);
 
     auto rearangingModel = new KeyRearrangeColumnsProxyModel(this);
     rearangingModel->setSourceModel(m_proxy);
-    rearangingModel->setSourceColumns(QList<int>() << KeyList::PrettyName //
-                                                     << KeyList::PrettyEMail //
-                                                     << KeyList::Validity //
-                                                     << KeyList::ValidFrom //
-                                                     << KeyList::ValidUntil //
-                                                     << KeyList::TechnicalDetails //
-                                                     << KeyList::KeyID //
-                                                     << KeyList::Fingerprint //
-                                                     << KeyList::OwnerTrust //
-                                                     << KeyList::Origin //
-                                                     << KeyList::LastUpdate //
-                                                     << KeyList::Issuer //
-                                                     << KeyList::SerialNumber //
-                                                     // If a column is added before this TAGS_COLUMN define has to be updated accordingly
-                                                     << KeyList::Remarks);
+    QList<int> columns = {
+        KeyList::PrettyName,
+        KeyList::PrettyEMail,
+        KeyList::Validity,
+        KeyList::ValidFrom,
+        KeyList::ValidUntil,
+        KeyList::TechnicalDetails,
+        KeyList::KeyID,
+        KeyList::Fingerprint,
+        KeyList::OwnerTrust,
+        KeyList::Origin,
+        KeyList::LastUpdate,
+        KeyList::Issuer,
+        KeyList::SerialNumber,
+        KeyList::Remarks,
+        KeyList::Algorithm,
+        KeyList::Keygrip,
+    };
+    tagsColumn = columns.indexOf(KeyList::Remarks);
+    rearangingModel->setSourceColumns(columns);
     m_view->setModel(rearangingModel);
 
     /* Handle expansion state */
     if (m_group.isValid()) {
         m_expandedKeys = m_group.readEntry("Expanded", QStringList());
     }
 
     connect(m_view, &QTreeView::expanded, this, [this](const QModelIndex &index) {
         if (!index.isValid()) {
             return;
         }
         const auto &key = index.data(KeyList::KeyRole).value<GpgME::Key>();
         if (key.isNull()) {
             return;
         }
         const auto fpr = QString::fromLatin1(key.primaryFingerprint());
 
         if (m_expandedKeys.contains(fpr)) {
             return;
         }
         m_expandedKeys << fpr;
         if (m_group.isValid()) {
             m_group.writeEntry("Expanded", m_expandedKeys);
         }
     });
 
     connect(m_view, &QTreeView::collapsed, this, [this](const QModelIndex &index) {
         if (!index.isValid()) {
             return;
         }
         const auto &key = index.data(KeyList::KeyRole).value<GpgME::Key>();
         if (key.isNull()) {
             return;
         }
         m_expandedKeys.removeAll(QString::fromLatin1(key.primaryFingerprint()));
         if (m_group.isValid()) {
             m_group.writeEntry("Expanded", m_expandedKeys);
         }
     });
 
     updateModelConnections(nullptr, model());
 
     resizeColumns();
     if (m_group.isValid()) {
         restoreLayout(m_group);
     }
 }
 
 void KeyTreeView::restoreExpandState()
 {
     if (!KeyCache::instance()->initialized()) {
         qCWarning(KLEOPATRA_LOG) << "Restore expand state before keycache available. Aborting.";
         return;
     }
     for (const auto &fpr : std::as_const(m_expandedKeys)) {
         const KeyListModelInterface *const km = keyListModel(*m_view);
         if (!km) {
             qCWarning(KLEOPATRA_LOG) << "invalid model";
             return;
         }
         const auto key = KeyCache::instance()->findByFingerprint(fpr.toLatin1().constData());
         if (key.isNull()) {
             qCDebug(KLEOPATRA_LOG) << "Cannot find:" << fpr << "anymore in cache";
             m_expandedKeys.removeAll(fpr);
             return;
         }
         const auto idx = km->index(key);
         if (!idx.isValid()) {
             qCDebug(KLEOPATRA_LOG) << "Cannot find:" << fpr << "anymore in model";
             m_expandedKeys.removeAll(fpr);
             return;
         }
         m_view->expand(idx);
     }
 }
 
 void KeyTreeView::setUpTagKeys()
 {
     const auto tagKeys = Tags::tagKeys();
     if (m_hierarchicalModel) {
         m_hierarchicalModel->setRemarkKeys(tagKeys);
     }
     if (m_flatModel) {
         m_flatModel->setRemarkKeys(tagKeys);
     }
 }
 
 void KeyTreeView::saveLayout(KConfigGroup &group)
 {
     QHeaderView *header = m_view->header();
 
     QVariantList columnVisibility;
     QVariantList columnOrder;
     QVariantList columnWidths;
     const int headerCount = header->count();
     columnVisibility.reserve(headerCount);
     columnWidths.reserve(headerCount);
     columnOrder.reserve(headerCount);
     for (int i = 0; i < headerCount; ++i) {
         columnVisibility << QVariant(!m_view->isColumnHidden(i));
         columnWidths << QVariant(header->sectionSize(i));
         columnOrder << QVariant(header->visualIndex(i));
     }
 
     group.writeEntry("ColumnVisibility", columnVisibility);
     group.writeEntry("ColumnOrder", columnOrder);
     group.writeEntry("ColumnWidths", columnWidths);
 
     group.writeEntry("SortAscending", (int)header->sortIndicatorOrder());
     if (header->isSortIndicatorShown()) {
         group.writeEntry("SortColumn", header->sortIndicatorSection());
     } else {
         group.writeEntry("SortColumn", -1);
     }
 }
 
 void KeyTreeView::restoreLayout(const KConfigGroup &group)
 {
     QHeaderView *header = m_view->header();
 
     QVariantList columnVisibility = group.readEntry("ColumnVisibility", QVariantList());
     QVariantList columnOrder = group.readEntry("ColumnOrder", QVariantList());
     QVariantList columnWidths = group.readEntry("ColumnWidths", QVariantList());
 
     if (columnVisibility.isEmpty()) {
         // if config is empty then use default settings
         // The numbers have to be in line with the order in
         // setsSourceColumns above
         m_view->hideColumn(5);
 
         for (int i = 7; i < m_view->model()->columnCount(); ++i) {
             m_view->hideColumn(i);
         }
         if (KeyCache::instance()->initialized()) {
             QTimer::singleShot(0, this, &KeyTreeView::resizeColumns);
         }
     } else {
         for (int i = 0; i < header->count(); ++i) {
             if (i >= columnOrder.size() || i >= columnWidths.size() || i >= columnVisibility.size()) {
                 // An additional column that was not around last time we saved.
                 // We default to hidden.
                 m_view->hideColumn(i);
                 continue;
             }
             bool visible = columnVisibility[i].toBool();
             int width = columnWidths[i].toInt();
             int order = columnOrder[i].toInt();
 
             header->resizeSection(i, width ? width : 100);
             header->moveSection(header->visualIndex(i), order);
-            if ((i == TAGS_COLUMN) && visible) {
+            if ((i == tagsColumn) && visible) {
                 Tags::enableTags();
             }
             if (!visible) {
                 m_view->hideColumn(i);
             }
         }
         m_onceResized = true;
     }
 
     int sortOrder = group.readEntry("SortAscending", (int)Qt::AscendingOrder);
     int sortColumn = group.readEntry("SortColumn", 0);
     if (sortColumn >= 0) {
         m_view->sortByColumn(sortColumn, (Qt::SortOrder)sortOrder);
     }
 }
 
 KeyTreeView::~KeyTreeView()
 {
     if (m_group.isValid()) {
         saveLayout(m_group);
     }
 }
 
 static QAbstractProxyModel *find_last_proxy(QAbstractProxyModel *pm)
 {
     Q_ASSERT(pm);
     while (auto const sm = qobject_cast<QAbstractProxyModel *>(pm->sourceModel())) {
         pm = sm;
     }
     return pm;
 }
 
 void KeyTreeView::updateModelConnections(AbstractKeyListModel *oldModel, AbstractKeyListModel *newModel)
 {
     if (oldModel == newModel) {
         return;
     }
     if (oldModel) {
         disconnect(oldModel, &QAbstractItemModel::modelAboutToBeReset, this, &KeyTreeView::saveStateBeforeModelChange);
         disconnect(oldModel, &QAbstractItemModel::modelReset, this, &KeyTreeView::restoreStateAfterModelChange);
         disconnect(oldModel, &QAbstractItemModel::rowsAboutToBeInserted, this, &KeyTreeView::saveStateBeforeModelChange);
         disconnect(oldModel, &QAbstractItemModel::rowsInserted, this, &KeyTreeView::restoreStateAfterModelChange);
         disconnect(oldModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, &KeyTreeView::saveStateBeforeModelChange);
         disconnect(oldModel, &QAbstractItemModel::rowsRemoved, this, &KeyTreeView::restoreStateAfterModelChange);
     }
     if (newModel) {
         connect(newModel, &QAbstractItemModel::modelAboutToBeReset, this, &KeyTreeView::saveStateBeforeModelChange);
         connect(newModel, &QAbstractItemModel::modelReset, this, &KeyTreeView::restoreStateAfterModelChange);
         connect(newModel, &QAbstractItemModel::rowsAboutToBeInserted, this, &KeyTreeView::saveStateBeforeModelChange);
         connect(newModel, &QAbstractItemModel::rowsInserted, this, &KeyTreeView::restoreStateAfterModelChange);
         connect(newModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, &KeyTreeView::saveStateBeforeModelChange);
         connect(newModel, &QAbstractItemModel::rowsRemoved, this, &KeyTreeView::restoreStateAfterModelChange);
     }
 }
 
 void KeyTreeView::setFlatModel(AbstractKeyListModel *model)
 {
     if (model == m_flatModel) {
         return;
     }
     auto oldModel = m_flatModel;
     m_flatModel = model;
     if (!m_isHierarchical)
     // TODO: this fails when called after setHierarchicalView( false )...
     {
         find_last_proxy(m_proxy)->setSourceModel(model);
         updateModelConnections(oldModel, model);
     }
 }
 
 void KeyTreeView::setHierarchicalModel(AbstractKeyListModel *model)
 {
     if (model == m_hierarchicalModel) {
         return;
     }
     auto oldModel = m_hierarchicalModel;
     m_hierarchicalModel = model;
     if (m_isHierarchical) {
         find_last_proxy(m_proxy)->setSourceModel(model);
         updateModelConnections(oldModel, model);
         m_view->expandAll();
         for (int column = 0; column < m_view->header()->count(); ++column) {
             m_view->header()->resizeSection(column, qMax(m_view->header()->sectionSize(column), m_view->header()->sectionSizeHint(column)));
         }
     }
 }
 
 void KeyTreeView::setStringFilter(const QString &filter)
 {
     if (filter == m_stringFilter) {
         return;
     }
     m_stringFilter = filter;
     m_proxy->setFilterRegularExpression(QRegularExpression::escape(filter));
     Q_EMIT stringFilterChanged(filter);
 }
 
 void KeyTreeView::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     if (filter == m_keyFilter || (filter && m_keyFilter && filter->id() == m_keyFilter->id())) {
         return;
     }
     m_keyFilter = filter;
     m_proxy->setKeyFilter(filter);
     Q_EMIT keyFilterChanged(filter);
 }
 
 namespace
 {
 QItemSelection itemSelectionFromKeys(const std::vector<Key> &keys, const QTreeView &view)
 {
     const QModelIndexList indexes = keyListModel(view)->indexes(keys);
     return std::accumulate(indexes.cbegin(), indexes.cend(), QItemSelection(), [](QItemSelection selection, const QModelIndex &index) {
         if (index.isValid()) {
             selection.merge(QItemSelection(index, index), QItemSelectionModel::Select);
         }
         return selection;
     });
 }
 }
 
 void KeyTreeView::selectKeys(const std::vector<Key> &keys)
 {
     m_view->selectionModel()->select(itemSelectionFromKeys(keys, *m_view), QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
 }
 
 std::vector<Key> KeyTreeView::selectedKeys() const
 {
     return keyListModel(*m_view)->keys(m_view->selectionModel()->selectedRows());
 }
 
 void KeyTreeView::setHierarchicalView(bool on)
 {
     if (on == m_isHierarchical) {
         return;
     }
     if (on && !hierarchicalModel()) {
         qCWarning(KLEOPATRA_LOG) << "hierarchical view requested, but no hierarchical model set";
         return;
     }
     if (!on && !flatModel()) {
         qCWarning(KLEOPATRA_LOG) << "flat view requested, but no flat model set";
         return;
     }
     const std::vector<Key> selectedKeys = this->selectedKeys();
     const Key currentKey = keyListModel(*m_view)->key(m_view->currentIndex());
 
     auto oldModel = model();
     m_isHierarchical = on;
     find_last_proxy(m_proxy)->setSourceModel(model());
     updateModelConnections(oldModel, model());
     if (on) {
         m_view->expandAll();
     }
     selectKeys(selectedKeys);
     if (!currentKey.isNull()) {
         const QModelIndex currentIndex = keyListModel(*m_view)->index(currentKey);
         if (currentIndex.isValid()) {
             m_view->selectionModel()->setCurrentIndex(currentIndex, QItemSelectionModel::NoUpdate);
             m_view->scrollTo(currentIndex);
         }
     }
     m_view->setAccessibleDescription(m_isHierarchical ? i18n("Hierarchical list of certificates") : i18n("List of certificates"));
     Q_EMIT hierarchicalChanged(on);
 }
 
 void KeyTreeView::setKeys(const std::vector<Key> &keys)
 {
     std::vector<Key> sorted = keys;
     _detail::sort_by_fpr(sorted);
     _detail::remove_duplicates_by_fpr(sorted);
     m_keys = sorted;
     if (m_flatModel) {
         m_flatModel->setKeys(sorted);
     }
     if (m_hierarchicalModel) {
         m_hierarchicalModel->setKeys(sorted);
     }
 }
 
 void KeyTreeView::addKeysImpl(const std::vector<Key> &keys, bool select)
 {
     if (keys.empty()) {
         return;
     }
     if (m_keys.empty()) {
         setKeys(keys);
         return;
     }
 
     std::vector<Key> sorted = keys;
     _detail::sort_by_fpr(sorted);
     _detail::remove_duplicates_by_fpr(sorted);
 
     std::vector<Key> newKeys = _detail::union_by_fpr(sorted, m_keys);
     m_keys.swap(newKeys);
 
     if (m_flatModel) {
         m_flatModel->addKeys(sorted);
     }
     if (m_hierarchicalModel) {
         m_hierarchicalModel->addKeys(sorted);
     }
 
     if (select) {
         selectKeys(sorted);
     }
 }
 
 void KeyTreeView::addKeysSelected(const std::vector<Key> &keys)
 {
     addKeysImpl(keys, true);
 }
 
 void KeyTreeView::addKeysUnselected(const std::vector<Key> &keys)
 {
     addKeysImpl(keys, false);
 }
 
 void KeyTreeView::removeKeys(const std::vector<Key> &keys)
 {
     if (keys.empty()) {
         return;
     }
     std::vector<Key> sorted = keys;
     _detail::sort_by_fpr(sorted);
     _detail::remove_duplicates_by_fpr(sorted);
     std::vector<Key> newKeys;
     newKeys.reserve(m_keys.size());
     std::set_difference(m_keys.begin(), m_keys.end(), sorted.begin(), sorted.end(), std::back_inserter(newKeys), _detail::ByFingerprint<std::less>());
     m_keys.swap(newKeys);
 
     if (m_flatModel) {
         std::for_each(sorted.cbegin(), sorted.cend(), [this](const Key &key) {
             m_flatModel->removeKey(key);
         });
     }
     if (m_hierarchicalModel) {
         std::for_each(sorted.cbegin(), sorted.cend(), [this](const Key &key) {
             m_hierarchicalModel->removeKey(key);
         });
     }
 }
 
 void KeyTreeView::disconnectSearchBar()
 {
     for (const auto &connection : m_connections) {
         disconnect(connection);
     }
     m_connections.clear();
 }
 
 bool KeyTreeView::connectSearchBar(const SearchBar *bar)
 {
     m_connections.reserve(4);
     m_connections.push_back(connect(this, &KeyTreeView::stringFilterChanged, bar, &SearchBar::setStringFilter));
     m_connections.push_back(connect(bar, &SearchBar::stringFilterChanged, this, &KeyTreeView::setStringFilter));
     m_connections.push_back(connect(this, &KeyTreeView::keyFilterChanged, bar, &SearchBar::setKeyFilter));
     m_connections.push_back(connect(bar, &SearchBar::keyFilterChanged, this, &KeyTreeView::setKeyFilter));
 
     return std::all_of(m_connections.cbegin(), m_connections.cend(), [](const QMetaObject::Connection &conn) {
         return conn;
     });
 }
 
 void KeyTreeView::resizeColumns()
 {
     m_view->setColumnWidth(KeyList::PrettyName, 260);
     m_view->setColumnWidth(KeyList::PrettyEMail, 260);
 
     for (int i = 2; i < m_view->model()->columnCount(); ++i) {
         m_view->resizeColumnToContents(i);
     }
 }
 
 void KeyTreeView::saveStateBeforeModelChange()
 {
     m_currentKey = keyListModel(*m_view)->key(m_view->currentIndex());
     m_selectedKeys = selectedKeys();
 }
 
 void KeyTreeView::restoreStateAfterModelChange()
 {
     restoreExpandState();
 
     selectKeys(m_selectedKeys);
     if (!m_currentKey.isNull()) {
         const QModelIndex currentIndex = keyListModel(*m_view)->index(m_currentKey);
         if (currentIndex.isValid()) {
             m_view->selectionModel()->setCurrentIndex(currentIndex, QItemSelectionModel::NoUpdate);
             m_view->scrollTo(currentIndex);
         }
     }
 
     setUpTagKeys();
     if (!m_onceResized) {
         m_onceResized = true;
         resizeColumns();
     }
 }
 
 #include "moc_keytreeview.cpp"