diff --git a/src/dialogs/deletecertificatesdialog.cpp b/src/dialogs/deletecertificatesdialog.cpp
index 6e891816e..b1752e1de 100644
--- a/src/dialogs/deletecertificatesdialog.cpp
+++ b/src/dialogs/deletecertificatesdialog.cpp
@@ -1,229 +1,232 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/deletecertificatesdialog.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 "deletecertificatesdialog.h"
 
 #include <view/keytreeview.h>
 
 #include <Libkleo/KeyListModel>
 #include <Libkleo/Stl_Util>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include "kleopatra_debug.h"
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include <QLabel>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <QWhatsThis>
 #include <QCursor>
 #include <QPushButton>
 #include <QTreeView>
 
 #include <gpgme++/key.h>
 
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 class DeleteCertificatesDialog::Private
 {
     friend class ::Kleo::Dialogs::DeleteCertificatesDialog;
     DeleteCertificatesDialog *const q;
 public:
     explicit Private(DeleteCertificatesDialog *qq)
         : q(qq),
           ui(q)
     {
 
     }
 
     void slotWhatsThisRequested()
     {
         qCDebug(KLEOPATRA_LOG);
         if (QWidget *const widget = qobject_cast<QWidget *>(q->sender()))
             if (!widget->whatsThis().isEmpty()) {
                 QWhatsThis::showText(QCursor::pos(), widget->whatsThis());
             }
     }
 
     void readConfig()
     {
         KConfigGroup dialog(KSharedConfig::openConfig(), "DeleteCertificatesDialog");
+        ui.selectedKTV.restoreLayout(dialog);
+        ui.unselectedKTV.restoreLayout(dialog);
         const QSize size = dialog.readEntry("Size", QSize(600, 400));
         if (size.isValid()) {
             q->resize(size);
         }
     }
 
     void writeConfig()
     {
         KConfigGroup dialog(KSharedConfig::openConfig(), "DeleteCertificatesDialog");
+        ui.selectedKTV.saveLayout(dialog);
         dialog.writeEntry("Size", q->size());
         dialog.sync();
     }
 
 private:
     struct UI {
         QLabel selectedLB;
         KeyTreeView selectedKTV;
         QLabel unselectedLB;
         KeyTreeView unselectedKTV;
         QDialogButtonBox buttonBox;
         QVBoxLayout vlay;
 
         explicit UI(DeleteCertificatesDialog *qq)
             : selectedLB(i18n("These are the certificates you have selected for deletion:"), qq),
               selectedKTV(qq),
               unselectedLB(i18n("These certificates will be deleted even though you did <b>not</b> "
                                  "explicitly select them (<a href=\"whatsthis://\">Why?</a>):"), qq),
               unselectedKTV(qq),
               buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel),
               vlay(qq)
         {
             KDAB_SET_OBJECT_NAME(selectedLB);
             KDAB_SET_OBJECT_NAME(selectedKTV);
             KDAB_SET_OBJECT_NAME(unselectedLB);
             KDAB_SET_OBJECT_NAME(unselectedKTV);
             KDAB_SET_OBJECT_NAME(buttonBox);
             KDAB_SET_OBJECT_NAME(vlay);
 
             vlay.addWidget(&selectedLB);
             vlay.addWidget(&selectedKTV, 1);
             vlay.addWidget(&unselectedLB);
             vlay.addWidget(&unselectedKTV, 1);
             vlay.addWidget(&buttonBox);
 
             const QString unselectedWhatsThis
                 = xi18nc("@info:whatsthis",
                          "<title>Why do you want to delete more certificates than I selected?</title>"
                          "<para>When you delete CA certificates (both root CAs and intermediate CAs), "
                          "the certificates issued by them will also be deleted.</para>"
                          "<para>This can be nicely seen in <application>Kleopatra</application>'s "
                          "hierarchical view mode: In this mode, if you delete a certificate that has "
                          "children, those children will also be deleted. Think of CA certificates as "
                          "folders containing other certificates: When you delete the folder, you "
                          "delete its contents, too.</para>");
             unselectedLB.setContextMenuPolicy(Qt::NoContextMenu);
             unselectedLB.setWhatsThis(unselectedWhatsThis);
             unselectedKTV.setWhatsThis(unselectedWhatsThis);
 
             buttonBox.button(QDialogButtonBox::Ok)->setText(i18nc("@action:button", "Delete"));
 
             connect(&unselectedLB, SIGNAL(linkActivated(QString)), qq, SLOT(slotWhatsThisRequested()));
 
             selectedKTV.setFlatModel(AbstractKeyListModel::createFlatKeyListModel(&selectedKTV));
             unselectedKTV.setFlatModel(AbstractKeyListModel::createFlatKeyListModel(&unselectedKTV));
 
             selectedKTV.setHierarchicalView(false);
             selectedKTV.view()->setSelectionMode(QAbstractItemView::NoSelection);
             unselectedKTV.setHierarchicalView(false);
             unselectedKTV.view()->setSelectionMode(QAbstractItemView::NoSelection);
 
             connect(&buttonBox, SIGNAL(accepted()), qq, SLOT(accept()));
             connect(&buttonBox, &QDialogButtonBox::rejected, qq, &QDialog::reject);
         }
     } ui;
 };
 
 DeleteCertificatesDialog::DeleteCertificatesDialog(QWidget *p)
     : QDialog(p), d(new Private(this))
 {
     d->readConfig();
 }
 
 DeleteCertificatesDialog::~DeleteCertificatesDialog()
 {
     d->writeConfig();
 }
 
 void DeleteCertificatesDialog::setSelectedKeys(const std::vector<Key> &keys)
 {
     d->ui.selectedKTV.setKeys(keys);
 }
 
 void DeleteCertificatesDialog::setUnselectedKeys(const std::vector<Key> &keys)
 {
     d->ui.unselectedLB .setVisible(!keys.empty());
     d->ui.unselectedKTV.setVisible(!keys.empty());
     d->ui.unselectedKTV.setKeys(keys);
 }
 
 std::vector<Key> DeleteCertificatesDialog::keys() const
 {
     const std::vector<Key> sel = d->ui.selectedKTV.keys();
     const std::vector<Key> uns = d->ui.unselectedKTV.keys();
     std::vector<Key> result;
     result.reserve(sel.size() + uns.size());
     result.insert(result.end(), sel.begin(), sel.end());
     result.insert(result.end(), uns.begin(), uns.end());
     return result;
 }
 
 void DeleteCertificatesDialog::accept()
 {
 
     const std::vector<Key> sel = d->ui.selectedKTV.keys();
     const std::vector<Key> uns = d->ui.unselectedKTV.keys();
 
     const uint secret = std::count_if(sel.cbegin(), sel.cend(), std::mem_fn(&Key::hasSecret))
                         + std::count_if(uns.cbegin(), uns.cend(), std::mem_fn(&Key::hasSecret));
     const uint total  = sel.size() + uns.size();
 
     int ret = KMessageBox::Continue;
     if (secret)
         ret = KMessageBox::warningContinueCancel(this,
                 secret == total
                 ? i18np("The certificate to be deleted is your own. "
                         "It contains private key material, "
                         "which is needed to decrypt past communication "
                         "encrypted to the certificate, and should therefore "
                         "not be deleted.",
 
                         "All of the certificates to be deleted "
                         "are your own. "
                         "They contain private key material, "
                         "which is needed to decrypt past communication "
                         "encrypted to the certificate, and should therefore "
                         "not be deleted.",
 
                         secret)
                 : i18np("One of the certificates to be deleted "
                         "is your own. "
                         "It contains private key material, "
                         "which is needed to decrypt past communication "
                         "encrypted to the certificate, and should therefore "
                         "not be deleted.",
 
                         "Some of the certificates to be deleted "
                         "are your own. "
                         "They contain private key material, "
                         "which is needed to decrypt past communication "
                         "encrypted to the certificate, and should therefore "
                         "not be deleted.",
 
                         secret),
                 i18n("Secret Key Deletion"),
                 KStandardGuiItem::guiItem(KStandardGuiItem::Delete),
                 KStandardGuiItem::cancel(), QString(), KMessageBox::Notify | KMessageBox::Dangerous);
 
     if (ret == KMessageBox::Continue) {
         QDialog::accept();
     } else {
         QDialog::reject();
     }
 }
 
 #include "moc_deletecertificatesdialog.cpp"
diff --git a/src/view/keytreeview.cpp b/src/view/keytreeview.cpp
index 80655aa2e..032833963 100644
--- a/src/view/keytreeview.cpp
+++ b/src/view/keytreeview.cpp
@@ -1,704 +1,712 @@
 /* -*- 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 <Libkleo/KeyList>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/KeyRearrangeColumnsProxyModel>
 #include <Libkleo/Predicates>
 
 #include "utils/headerview.h"
 #include "utils/tags.h"
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KeyFilter>
 #include <Libkleo/KeyCache>
 
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 #include <QTimer>
 #include <QTreeView>
 #include <QHeaderView>
 #include <QItemSelectionModel>
 #include <QItemSelection>
 #include <QLayout>
 #include <QList>
 #include <QMenu>
 #include <QAction>
 #include <QEvent>
 #include <QContextMenuEvent>
 
 #include <KSharedConfig>
 #include <KLocalizedString>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 #define TAGS_COLUMN 13
 
 using namespace Kleo;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 namespace
 {
 
 class TreeView : public QTreeView
 {
 public:
     explicit TreeView(QWidget *parent = nullptr) : QTreeView(parent)
     {
         header()->installEventFilter(this);
     }
 
     QSize minimumSizeHint() const override
     {
         const QSize min = QTreeView::minimumSizeHint();
         return QSize(min.width(), min.height() + 5 * fontMetrics().height());
     }
 
 protected:
     bool eventFilter(QObject *watched, QEvent *event) override
     {
         Q_UNUSED(watched)
         if (event->type() == QEvent::ContextMenu) {
             QContextMenuEvent *e = static_cast<QContextMenuEvent *>(event);
 
             if (!mHeaderPopup) {
                 mHeaderPopup = new QMenu(this);
                 mHeaderPopup->setTitle(i18n("View Columns"));
                 for (int i = 0; i < model()->columnCount(); ++i) {
                     QAction *tmp
                         = mHeaderPopup->addAction(model()->headerData(i, Qt::Horizontal).toString());
                     tmp->setData(QVariant(i));
                     tmp->setCheckable(true);
                     mColumnActions << tmp;
                 }
 
                 connect(mHeaderPopup, &QMenu::triggered, this, [this] (QAction *action) {
                     const int col = action->data().toInt();
                     if ((col == TAGS_COLUMN) && action->isChecked()) {
                         Tags::enableTags();
                     }
                     if (action->isChecked()) {
                         showColumn(col);
                     } else {
                         hideColumn(col);
                     }
 
                     KeyTreeView *tv = qobject_cast<KeyTreeView *> (parent());
                     if (tv) {
                         tv->resizeColumns();
                     }
                 });
             }
 
             for (QAction *action : qAsConst(mColumnActions)) {
                 const int column = action->data().toInt();
                 action->setChecked(!isColumnHidden(column));
             }
 
             mHeaderPopup->popup(mapToGlobal(e->pos()));
             return true;
         }
 
         return false;
     }
 
 private:
     QMenu *mHeaderPopup = nullptr;
 
     QList<QAction *> mColumnActions;
 };
 
 } // anon namespace
 
 KeyTreeView::KeyTreeView(QWidget *parent)
     : QWidget(parent),
       m_proxy(new KeyListSortFilterProxyModel(this)),
       m_additionalProxy(nullptr),
       m_view(new TreeView(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 TreeView(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 TreeView(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 (HeaderView *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 (HeaderView *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()) {
-        m_group = KSharedConfig::openConfig()->group("KeyTreeView_default");
-    } else {
+    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);
 
     HeaderView *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->setAlternatingRowColors( true );
     m_view->setAllColumnsShowFocus(true);
     m_view->setSortingEnabled(true);
 
     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->setFilterFixedString(m_stringFilter);
     m_proxy->setKeyFilter(m_keyFilter);
     m_proxy->setSortCaseSensitivity(Qt::CaseInsensitive);
 
     KeyRearrangeColumnsProxyModel *rearangingModel = new KeyRearrangeColumnsProxyModel(this);
     rearangingModel->setSourceModel(m_proxy);
     rearangingModel->setSourceColumns(QVector<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
 #ifdef GPGME_HAS_REMARKS
     // If a column is added before this TAGS_COLUMN define has to be updated accordingly
                                                      << KeyList::Remarks
 #endif
     );
     m_view->setModel(rearangingModel);
 
     /* Handle expansion state */
-    m_expandedKeys = m_group.readEntry("Expanded", QStringList());
+    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;
-        m_group.writeEntry("Expanded", m_expandedKeys);
+        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()));
-        m_group.writeEntry("Expanded", m_expandedKeys);
+        if (m_group.isValid()) {
+            m_group.writeEntry("Expanded", m_expandedKeys);
+        }
     });
 
     connect(KeyCache::instance().get(), &KeyCache::keysMayHaveChanged, this, [this] () {
         /* We use a single shot timer here to ensure that the keysMayHaveChanged
          * handlers are all handled before we restore the expand state so that
          * the model is already populated. */
         QTimer::singleShot(0, [this] () {
             restoreExpandState();
             setUpTagKeys();
             if (!m_onceResized) {
                 m_onceResized = true;
                 resizeColumns();
             }
         });
     });
     resizeColumns();
-    restoreLayout();
+    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: qAsConst(m_expandedKeys)) {
         const KeyListModelInterface *km = dynamic_cast<const KeyListModelInterface*> (m_view->model());
         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()
 {
 #ifdef GPGME_HAS_REMARKS
     const auto tagKeys = Tags::tagKeys();
     if (m_hierarchicalModel) {
         m_hierarchicalModel->setRemarkKeys(tagKeys);
     }
     if (m_flatModel) {
         m_flatModel->setRemarkKeys(tagKeys);
     }
 #endif
 }
 
-void KeyTreeView::saveLayout()
+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));
     }
 
-    m_group.writeEntry("ColumnVisibility", columnVisibility);
-    m_group.writeEntry("ColumnOrder", columnOrder);
-    m_group.writeEntry("ColumnWidths", columnWidths);
+    group.writeEntry("ColumnVisibility", columnVisibility);
+    group.writeEntry("ColumnOrder", columnOrder);
+    group.writeEntry("ColumnWidths", columnWidths);
 
-    m_group.writeEntry("SortAscending", (int)header->sortIndicatorOrder());
+    group.writeEntry("SortAscending", (int)header->sortIndicatorOrder());
     if (header->isSortIndicatorShown()) {
-        m_group.writeEntry("SortColumn", header->sortIndicatorSection());
+        group.writeEntry("SortColumn", header->sortIndicatorSection());
     } else {
-        m_group.writeEntry("SortColumn", -1);
+        group.writeEntry("SortColumn", -1);
     }
 }
 
-void KeyTreeView::restoreLayout()
+void KeyTreeView::restoreLayout(const KConfigGroup &group)
 {
     QHeaderView *header = m_view->header();
 
-    QVariantList columnVisibility = m_group.readEntry("ColumnVisibility", QVariantList());
-    QVariantList columnOrder = m_group.readEntry("ColumnOrder", QVariantList());
-    QVariantList columnWidths = m_group.readEntry("ColumnWidths", QVariantList());
+    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) {
                 Tags::enableTags();
             }
             if (!visible) {
                 m_view->hideColumn(i);
             }
         }
         m_onceResized = true;
     }
 
-    int sortOrder = m_group.readEntry("SortAscending", (int)Qt::AscendingOrder);
-    int sortColumn = m_group.readEntry("SortColumn", 0);
+    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()
 {
-    saveLayout();
+    if (m_group.isValid()) {
+        saveLayout(m_group);
+    }
 }
 
 static QAbstractProxyModel *find_last_proxy(QAbstractProxyModel *pm)
 {
     Q_ASSERT(pm);
     while (QAbstractProxyModel *const sm = qobject_cast<QAbstractProxyModel *>(pm->sourceModel())) {
         pm = sm;
     }
     return pm;
 }
 
 void KeyTreeView::setFlatModel(AbstractKeyListModel *model)
 {
     if (model == m_flatModel) {
         return;
     }
     m_flatModel = model;
     if (!m_isHierarchical)
         // TODO: this fails when called after setHierarchicalView( false )...
     {
         find_last_proxy(m_proxy)->setSourceModel(model);
     }
 }
 
 void KeyTreeView::setHierarchicalModel(AbstractKeyListModel *model)
 {
     if (model == m_hierarchicalModel) {
         return;
     }
     m_hierarchicalModel = model;
     if (m_isHierarchical) {
         find_last_proxy(m_proxy)->setSourceModel(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->setFilterFixedString(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);
 }
 
 static QItemSelection itemSelectionFromKeys(const std::vector<Key> &keys, const KeyListSortFilterProxyModel &proxy)
 {
     QItemSelection result;
     for (const Key &key : keys) {
         const QModelIndex mi = proxy.index(key);
         if (mi.isValid()) {
             result.merge(QItemSelection(mi, mi), QItemSelectionModel::Select);
         }
     }
     return result;
 }
 
 void KeyTreeView::selectKeys(const std::vector<Key> &keys)
 {
     m_view->selectionModel()->select(itemSelectionFromKeys(keys, *m_proxy), QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
 }
 
 std::vector<Key> KeyTreeView::selectedKeys() const
 {
     return m_proxy->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 = m_proxy->keys(m_view->selectionModel()->selectedRows());
     const Key currentKey = m_proxy->key(m_view->currentIndex());
 
     m_isHierarchical = on;
     find_last_proxy(m_proxy)->setSourceModel(model());
     if (on) {
         m_view->expandAll();
     }
     selectKeys(selectedKeys);
     if (!currentKey.isNull()) {
         const QModelIndex currentIndex = m_proxy->index(currentKey);
         if (currentIndex.isValid()) {
             m_view->selectionModel()->setCurrentIndex(m_proxy->index(currentKey), QItemSelectionModel::NoUpdate);
             m_view->scrollTo(currentIndex);
         }
     }
     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); });
     }
 
 }
 
 static const struct {
     const char *signal;
     const char *slot;
 } connections[] = {
     {
         SIGNAL(stringFilterChanged(QString)),
         SLOT(setStringFilter(QString))
     },
     {
         SIGNAL(keyFilterChanged(std::shared_ptr<Kleo::KeyFilter>)),
         SLOT(setKeyFilter(std::shared_ptr<Kleo::KeyFilter>))
     },
 };
 static const unsigned int numConnections = sizeof connections / sizeof * connections;
 
 void KeyTreeView::disconnectSearchBar(const QObject *bar)
 {
     for (unsigned int i = 0; i < numConnections; ++i) {
         disconnect(this, connections[i].signal, bar,  connections[i].slot);
         disconnect(bar,  connections[i].signal, this, connections[i].slot);
     }
 }
 
 bool KeyTreeView::connectSearchBar(const QObject *bar)
 {
     for (unsigned int i = 0; i < numConnections; ++i)
         if (!connect(this, connections[i].signal, bar,  connections[i].slot) ||
                 !connect(bar,  connections[i].signal, this, connections[i].slot)) {
             return false;
         }
     return true;
 }
 
 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);
     }
 }
diff --git a/src/view/keytreeview.h b/src/view/keytreeview.h
index 3a9bca4cb..549d80ee7 100644
--- a/src/view/keytreeview.h
+++ b/src/view/keytreeview.h
@@ -1,159 +1,160 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     view/keytreeview.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef __KLEOPATRA_VIEW_KEYTREEVIEW_H__
 #define __KLEOPATRA_VIEW_KEYTREEVIEW_H__
 
 #include <QWidget>
 
 #include <QString>
 #include <QStringList>
 
 #include <gpgme++/key.h>
 
 #include <memory>
 #include <vector>
 
 #include <KConfigGroup>
 
 class QTreeView;
 
 namespace Kleo
 {
 
 class KeyFilter;
 class AbstractKeyListModel;
 class AbstractKeyListSortFilterProxyModel;
 class KeyListSortFilterProxyModel;
 
 class KeyTreeView : public QWidget
 {
     Q_OBJECT
 public:
     explicit KeyTreeView(QWidget *parent = nullptr);
     KeyTreeView(const QString &stringFilter, const std::shared_ptr<KeyFilter> &keyFilter,
                 AbstractKeyListSortFilterProxyModel *additionalProxy, QWidget *parent,
-                const KConfigGroup &group = KConfigGroup());
+                const KConfigGroup &group);
     ~KeyTreeView();
 
     QTreeView *view() const
     {
         return m_view;
     }
 
     AbstractKeyListModel *model() const
     {
         return m_isHierarchical ? hierarchicalModel() : flatModel();
     }
 
     AbstractKeyListModel *flatModel() const
     {
         return m_flatModel;
     }
     AbstractKeyListModel *hierarchicalModel() const
     {
         return m_hierarchicalModel;
     }
 
     void setFlatModel(AbstractKeyListModel *model);
     void setHierarchicalModel(AbstractKeyListModel *model);
 
     void setKeys(const std::vector<GpgME::Key> &keys);
     const std::vector<GpgME::Key> &keys() const
     {
         return m_keys;
     }
 
     void selectKeys(const std::vector<GpgME::Key> &keys);
     std::vector<GpgME::Key> selectedKeys() const;
 
     void addKeysUnselected(const std::vector<GpgME::Key> &keys);
     void addKeysSelected(const std::vector<GpgME::Key> &keys);
     void removeKeys(const std::vector<GpgME::Key> &keys);
 
 #if 0
     void setToolTipOptions(int options);
     int toolTipOptions() const;
 #endif
 
     QString stringFilter() const
     {
         return m_stringFilter;
     }
     const std::shared_ptr<KeyFilter> &keyFilter() const
     {
         return m_keyFilter;
     }
     bool isHierarchicalView() const
     {
         return m_isHierarchical;
     }
 
     void setColumnSizes(const std::vector<int> &sizes);
     std::vector<int> columnSizes() const;
 
     void setSortColumn(int sortColumn, Qt::SortOrder sortOrder);
     int sortColumn() const;
     Qt::SortOrder sortOrder() const;
 
     virtual KeyTreeView *clone() const
     {
         return new KeyTreeView(*this);
     }
 
     void disconnectSearchBar(const QObject *bar);
     bool connectSearchBar(const QObject *bar);
     void resizeColumns();
 
+    void saveLayout(KConfigGroup &group);
+    void restoreLayout(const KConfigGroup &group);
+
 public Q_SLOTS:
     virtual void setStringFilter(const QString &text);
     virtual void setKeyFilter(const std::shared_ptr<Kleo::KeyFilter> &filter);
     virtual void setHierarchicalView(bool on);
 
 Q_SIGNALS:
     void stringFilterChanged(const QString &filter);
     void keyFilterChanged(const std::shared_ptr<Kleo::KeyFilter> &filter);
     void hierarchicalChanged(bool on);
 
 protected:
     KeyTreeView(const KeyTreeView &);
 
 private:
     void init();
     void addKeysImpl(const std::vector<GpgME::Key> &, bool);
     void restoreExpandState();
-    void saveLayout();
-    void restoreLayout();
     void setUpTagKeys();
 
 private:
     std::vector<GpgME::Key> m_keys;
 
     KeyListSortFilterProxyModel *m_proxy;
     AbstractKeyListSortFilterProxyModel *m_additionalProxy;
 
     QTreeView *m_view;
 
     AbstractKeyListModel *m_flatModel;
     AbstractKeyListModel *m_hierarchicalModel;
 
     QString m_stringFilter;
     std::shared_ptr<KeyFilter> m_keyFilter;
 
     QStringList m_expandedKeys;
 
     KConfigGroup m_group;
 
     bool m_isHierarchical : 1;
     bool m_onceResized : 1;
 };
 
 }
 
 #endif // __KLEOPATRA_VIEW_KEYTREEVIEW_H__
diff --git a/src/view/netkeywidget.cpp b/src/view/netkeywidget.cpp
index 1536ea61c..1d1368873 100644
--- a/src/view/netkeywidget.cpp
+++ b/src/view/netkeywidget.cpp
@@ -1,321 +1,329 @@
 /*  view/netkeywidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "netkeywidget.h"
 #include "nullpinwidget.h"
 #include "keytreeview.h"
 #include "kleopatraapplication.h"
 #include "systrayicon.h"
 
 #include "kleopatra_debug.h"
 
 #include "smartcard/netkeycard.h"
 #include "smartcard/readerstatus.h"
 
 #include "commands/changepincommand.h"
 #include "commands/createopenpgpkeyfromcardkeyscommand.h"
 #include "commands/createcsrforcardkeycommand.h"
 #include "commands/learncardkeyscommand.h"
 #include "commands/detailscommand.h"
 
 #include <Libkleo/KeyListModel>
 
+#include <KConfigGroup>
+#include <KSharedConfig>
+
 #include <QInputDialog>
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QScrollArea>
 #include <QPushButton>
 #include <QTreeView>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <gpgme++/context.h>
 #include <gpgme++/engineinfo.h>
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 using namespace Kleo::Commands;
 
 NetKeyWidget::NetKeyWidget(QWidget *parent) :
     QWidget(parent),
     mSerialNumberLabel(new QLabel(this)),
     mVersionLabel(new QLabel(this)),
     mLearnKeysLabel(new QLabel(this)),
     mErrorLabel(new QLabel(this)),
     mNullPinWidget(new NullPinWidget(this)),
     mLearnKeysBtn(new QPushButton(this)),
     mChangeNKSPINBtn(new QPushButton(this)),
     mChangeSigGPINBtn(new QPushButton(this)),
     mTreeView(new KeyTreeView(this)),
     mArea(new QScrollArea)
 {
     auto vLay = new QVBoxLayout;
 
     // Set up the scroll are
     mArea->setFrameShape(QFrame::NoFrame);
     mArea->setWidgetResizable(true);
     auto mAreaWidget = new QWidget;
     mAreaWidget->setLayout(vLay);
     mArea->setWidget(mAreaWidget);
     auto scrollLay = new QVBoxLayout(this);
     scrollLay->setContentsMargins(0, 0, 0, 0);
     scrollLay->addWidget(mArea);
 
     // Add general widgets
     mVersionLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     vLay->addWidget(mVersionLabel, 0, Qt::AlignLeft);
 
     mSerialNumberLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
 
     auto hLay1 = new QHBoxLayout;
     hLay1->addWidget(new QLabel(i18n("Serial number:")));
     hLay1->addWidget(mSerialNumberLabel);
     hLay1->addStretch(1);
     vLay->addLayout(hLay1);
 
     vLay->addWidget(mNullPinWidget);
 
 
     auto line1 = new QFrame();
     line1->setFrameShape(QFrame::HLine);
     vLay->addWidget(line1);
     vLay->addWidget(new QLabel(QStringLiteral("<b>%1</b>").arg(i18n("Certificates:"))), 0, Qt::AlignLeft);
 
     mLearnKeysLabel = new QLabel(i18n("There are unknown certificates on this card."));
     mLearnKeysBtn->setText(i18nc("@action", "Load Certificates"));
     connect(mLearnKeysBtn, &QPushButton::clicked, this, [this] () {
         mLearnKeysBtn->setEnabled(false);
         auto cmd = new LearnCardKeysCommand(GpgME::CMS);
         cmd->setParentWidget(this);
         cmd->start();
 
         auto icon = KleopatraApplication::instance()->sysTrayIcon();
         if (icon) {
             icon->setLearningInProgress(true);
         }
 
         connect(cmd, &Command::finished, this, [icon] () {
             ReaderStatus::mutableInstance()->updateStatus();
             icon->setLearningInProgress(false);
         });
     });
 
     auto hLay2 = new QHBoxLayout;
     hLay2->addWidget(mLearnKeysLabel);
     hLay2->addWidget(mLearnKeysBtn);
     hLay2->addStretch(1);
     vLay->addLayout(hLay2);
 
     mErrorLabel->setVisible(false);
     vLay->addWidget(mErrorLabel);
 
     // The certificate view
     mTreeView->setHierarchicalModel(AbstractKeyListModel::createHierarchicalKeyListModel(mTreeView));
     mTreeView->setHierarchicalView(true);
 
     connect(mTreeView->view(), &QAbstractItemView::doubleClicked, this, [this] (const QModelIndex &idx) {
         const auto klm = dynamic_cast<KeyListModelInterface *> (mTreeView->view()->model());
         if (!klm) {
             qCDebug(KLEOPATRA_LOG) << "Unhandled Model: " << mTreeView->view()->model()->metaObject()->className();
             return;
         }
         auto cmd = new DetailsCommand(klm->key(idx), nullptr);
         cmd->setParentWidget(this);
         cmd->start();
     });
     vLay->addWidget(mTreeView);
 
 
     // The action area
     auto line2 = new QFrame();
     line2->setFrameShape(QFrame::HLine);
     vLay->addWidget(line2);
     vLay->addWidget(new QLabel(QStringLiteral("<b>%1</b>").arg(i18n("Actions:"))), 0, Qt::AlignLeft);
 
     auto actionLayout = new QHBoxLayout();
 
     if (CreateOpenPGPKeyFromCardKeysCommand::isSupported()) {
         mKeyForCardKeysButton = new QPushButton(this);
         mKeyForCardKeysButton->setText(i18nc("@action:button", "Create OpenPGP Key"));
         mKeyForCardKeysButton->setToolTip(i18nc("@info:tooltip", "Create an OpenPGP key for the keys stored on the card."));
         actionLayout->addWidget(mKeyForCardKeysButton);
         connect(mKeyForCardKeysButton, &QPushButton::clicked, this, &NetKeyWidget::createKeyFromCardKeys);
     }
 
     if (!(engineInfo(GpgME::GpgSMEngine).engineVersion() < "2.2.26")) { // see https://dev.gnupg.org/T5184
         mCreateCSRButton = new QPushButton(this);
         mCreateCSRButton->setText(i18nc("@action:button", "Create CSR"));
         mCreateCSRButton->setToolTip(i18nc("@info:tooltip", "Create a certificate signing request for a key stored on the card."));
         mCreateCSRButton->setEnabled(false);
         actionLayout->addWidget(mCreateCSRButton);
         connect(mCreateCSRButton, &QPushButton::clicked, this, [this] () { createCSR(); });
     }
 
     mChangeNKSPINBtn->setText(i18nc("NKS is an identifier for a type of keys on a NetKey card", "Change NKS PIN"));
     mChangeSigGPINBtn->setText(i18nc("SigG is an identifier for a type of keys on a NetKey card", "Change SigG PIN"));
 
     connect(mChangeNKSPINBtn, &QPushButton::clicked, this, [this] () { doChangePin(NetKeyCard::nksPinKeyRef()); });
     connect(mChangeSigGPINBtn, &QPushButton::clicked, this, [this] () { doChangePin(NetKeyCard::sigGPinKeyRef()); });
 
     actionLayout->addWidget(mChangeNKSPINBtn);
     actionLayout->addWidget(mChangeSigGPINBtn);
     actionLayout->addStretch(1);
 
     vLay->addLayout(actionLayout);
     vLay->addStretch(1);
+
+    const KConfigGroup configGroup(KSharedConfig::openConfig(), "NetKeyCardView");
+    mTreeView->restoreLayout(configGroup);
 }
 
 NetKeyWidget::~NetKeyWidget()
 {
+    KConfigGroup configGroup(KSharedConfig::openConfig(), "NetKeyCardView");
+    mTreeView->saveLayout(configGroup);
 }
 
 namespace
 {
 std::vector<KeyPairInfo> getKeysSuitableForCSRCreation(const NetKeyCard *netKeyCard)
 {
     std::vector<KeyPairInfo> keys;
 
     for (const auto &key : netKeyCard->keyInfos()) {
         if (key.keyRef.substr(0, 9) == "NKS-SIGG.") {
             // SigG certificates for qualified signatures are issued with the physical cards;
             // it's not possible to request a certificate for them
             continue;
         }
         if (key.canSign() && (key.keyRef.substr(0, 9) == "NKS-NKS3.") && !netKeyCard->hasNKSNullPin()) {
             keys.push_back(key);
         }
     }
 
     return keys;
 }
 }
 
 void NetKeyWidget::setCard(const NetKeyCard* card)
 {
     mSerialNumber = card->serialNumber();
     mVersionLabel->setText(i18nc("1 is a Version number", "NetKey v%1 Card", card->appVersion()));
     mSerialNumberLabel->setText(card->displaySerialNumber());
 
     mNullPinWidget->setSerialNumber(mSerialNumber);
     /* According to users of NetKey Cards it is fairly uncommon
      * to use SigG Certificates at all. So it should be optional to set the pins. */
     mNullPinWidget->setVisible(card->hasNKSNullPin() /*|| card->hasSigGNullPin()*/);
 
     mNullPinWidget->setSigGVisible(false/*card->hasSigGNullPin()*/);
     mNullPinWidget->setNKSVisible(card->hasNKSNullPin());
     mChangeNKSPINBtn->setEnabled(!card->hasNKSNullPin());
 
     if (card->hasSigGNullPin()) {
         mChangeSigGPINBtn->setText(i18nc("SigG is an identifier for a type of keys on a NetKey card",
                                    "Set SigG PIN"));
     } else {
         mChangeSigGPINBtn->setText(i18nc("SigG is an identifier for a type of keys on a NetKey card",
                                   "Change SigG PIN"));
     }
 
     mLearnKeysBtn->setEnabled(true);
     mLearnKeysBtn->setVisible(card->canLearnKeys());
     mTreeView->setVisible(!card->canLearnKeys());
     mLearnKeysLabel->setVisible(card->canLearnKeys());
 
     const auto errMsg = card->errorMsg();
     if (!errMsg.isEmpty()) {
         mErrorLabel->setText(QStringLiteral("<b>%1:</b> %2").arg(i18n("Error"), errMsg));
         mErrorLabel->setVisible(true);
     } else {
         mErrorLabel->setVisible(false);
     }
 
     const auto keys = card->keys();
     mTreeView->setKeys(keys);
 
     if (mKeyForCardKeysButton) {
         mKeyForCardKeysButton->setEnabled(!card->hasNKSNullPin() && card->hasSigningKey() && card->hasEncryptionKey());
     }
     if (mCreateCSRButton) {
         mCreateCSRButton->setEnabled(!getKeysSuitableForCSRCreation(card).empty());
     }
 }
 
 void NetKeyWidget::doChangePin(const std::string &keyRef)
 {
     const auto netKeyCard = ReaderStatus::instance()->getCard<NetKeyCard>(mSerialNumber);
     if (!netKeyCard) {
         KMessageBox::error(this,
                            i18n("Failed to find the smartcard with the serial number: %1", QString::fromStdString(mSerialNumber)));
         return;
     }
 
     auto cmd = new ChangePinCommand(mSerialNumber, NetKeyCard::AppName, this);
     this->setEnabled(false);
     connect(cmd, &ChangePinCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->setKeyRef(keyRef);
     if ((keyRef == NetKeyCard::nksPinKeyRef() && netKeyCard->hasNKSNullPin())
         || (keyRef == NetKeyCard::sigGPinKeyRef() && netKeyCard->hasSigGNullPin())) {
         cmd->setMode(ChangePinCommand::NullPinMode);
     }
     cmd->start();
 }
 
 void NetKeyWidget::createKeyFromCardKeys()
 {
     auto cmd = new CreateOpenPGPKeyFromCardKeysCommand(mSerialNumber, NetKeyCard::AppName, this);
     this->setEnabled(false);
     connect(cmd, &CreateOpenPGPKeyFromCardKeysCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->start();
 }
 
 namespace
 {
 std::string getKeyRef(const std::vector<KeyPairInfo> &keys, QWidget *parent)
 {
     QStringList options;
     for (const auto &key : keys) {
         options << QStringLiteral("%1 - %2").arg(QString::fromStdString(key.keyRef), QString::fromStdString(key.grip));
     }
 
     bool ok;
     const QString choice = QInputDialog::getItem(parent, i18n("Select Key"),
         i18n("Please select the key you want to create a certificate signing request for:"), options, /* current= */ 0, /* editable= */ false, &ok);
     return ok ? keys[options.indexOf(choice)].keyRef : std::string();
 }
 }
 
 void NetKeyWidget::createCSR()
 {
     const auto netKeyCard = ReaderStatus::instance()->getCard<NetKeyCard>(mSerialNumber);
     if (!netKeyCard) {
         KMessageBox::error(this,
                            i18n("Failed to find the smartcard with the serial number: %1", QString::fromStdString(mSerialNumber)));
         return;
     }
     const auto suitableKeys = getKeysSuitableForCSRCreation(netKeyCard.get());
     if (suitableKeys.empty()) {
         KMessageBox::error(this,
                            i18n("Sorry! No keys suitable for creating a certificate signing request found on the smartcard."));
         return;
     }
     const auto keyRef = getKeyRef(suitableKeys, this);
     if (keyRef.empty()) {
         return;
     }
     auto cmd = new CreateCSRForCardKeyCommand(keyRef, mSerialNumber, NetKeyCard::AppName, this);
     this->setEnabled(false);
     connect(cmd, &CreateCSRForCardKeyCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->start();
 }
diff --git a/src/view/tabwidget.cpp b/src/view/tabwidget.cpp
index 93dccb89a..f3b54aa27 100644
--- a/src/view/tabwidget.cpp
+++ b/src/view/tabwidget.cpp
@@ -1,954 +1,955 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     view/tabwidget.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 "tabwidget.h"
 #include "keytreeview.h"
 #include "kleopatra_debug.h"
 
 #include <utils/action_data.h>
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KeyFilter>
 #include <Libkleo/KeyFilterManager>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 #include <QTabWidget>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KConfig>
 #include <QAction>
 #include <KActionCollection>
 #include <QInputDialog>
 
 #include <QTreeView>
 #include <QToolButton>
 #include <QMenu>
 #include <QVBoxLayout>
 #include <QRegularExpression>
 #include <QAbstractProxyModel>
 
 #include <map>
 
 using namespace Kleo;
 using namespace GpgME;
 
 namespace
 {
 
 class Page : public Kleo::KeyTreeView
 {
     Q_OBJECT
     Page(const Page &other);
 public:
     Page(const QString &title, const QString &id, const QString &text, AbstractKeyListSortFilterProxyModel *proxy = nullptr, const QString &toolTip = QString(), QWidget *parent = nullptr, const KConfigGroup &group = KConfigGroup());
     Page(const KConfigGroup &group, QWidget *parent = nullptr);
     ~Page();
 
     void setTemporary(bool temporary);
     bool isTemporary() const
     {
         return m_isTemporary;
     }
 
     void setHierarchicalView(bool hierarchical) override;
     void setStringFilter(const QString &filter) override;
     void setKeyFilter(const std::shared_ptr<KeyFilter> &filter) override;
 
     QString title() const
     {
         return m_title.isEmpty() && keyFilter() ? keyFilter()->name() : m_title;
     }
     void setTitle(const QString &title);
 
     QString toolTip() const
     {
         return m_toolTip.isEmpty() ? title() : m_toolTip;
     }
     // not used void setToolTip(const QString &tip);
 
     bool canBeClosed() const
     {
         return m_canBeClosed;
     }
     bool canBeRenamed() const
     {
         return m_canBeRenamed;
     }
     bool canChangeStringFilter() const
     {
         return m_canChangeStringFilter;
     }
     bool canChangeKeyFilter() const
     {
         return m_canChangeKeyFilter && !m_isTemporary;
     }
     bool canChangeHierarchical() const
     {
         return m_canChangeHierarchical;
     }
 
     void saveTo(KConfigGroup &group) const;
 
     Page *clone() const override
     {
         return new Page(*this);
     }
 
     void liftAllRestrictions()
     {
         m_canBeClosed = m_canBeRenamed = m_canChangeStringFilter = m_canChangeKeyFilter = m_canChangeHierarchical = true;
     }
 
 Q_SIGNALS:
     void titleChanged(const QString &title);
 
 private:
     void init();
 
 private:
     QString m_title;
     QString m_toolTip;
     bool m_isTemporary : 1;
     bool m_canBeClosed : 1;
     bool m_canBeRenamed : 1;
     bool m_canChangeStringFilter : 1;
     bool m_canChangeKeyFilter : 1;
     bool m_canChangeHierarchical : 1;
 };
 } // anon namespace
 
 Page::Page(const Page &other)
     : KeyTreeView(other),
       m_title(other.m_title),
       m_toolTip(other.m_toolTip),
       m_isTemporary(other.m_isTemporary),
       m_canBeClosed(other.m_canBeClosed),
       m_canBeRenamed(other.m_canBeRenamed),
       m_canChangeStringFilter(other.m_canChangeStringFilter),
       m_canChangeKeyFilter(other.m_canChangeKeyFilter),
       m_canChangeHierarchical(other.m_canChangeHierarchical)
 {
     init();
 }
 
 Page::Page(const QString &title, const QString &id, const QString &text, AbstractKeyListSortFilterProxyModel *proxy, const QString &toolTip, QWidget *parent,
            const KConfigGroup &group)
     : KeyTreeView(text, KeyFilterManager::instance()->keyFilterByID(id), proxy, parent, group),
       m_title(title),
       m_toolTip(toolTip),
       m_isTemporary(false),
       m_canBeClosed(true),
       m_canBeRenamed(true),
       m_canChangeStringFilter(true),
       m_canChangeKeyFilter(true),
       m_canChangeHierarchical(true)
 {
     init();
 }
 
 static const char TITLE_ENTRY[] = "title";
 static const char STRING_FILTER_ENTRY[] = "string-filter";
 static const char KEY_FILTER_ENTRY[] = "key-filter";
 static const char HIERARCHICAL_VIEW_ENTRY[] = "hierarchical-view";
 static const char COLUMN_SIZES[] = "column-sizes";
 static const char SORT_COLUMN[] = "sort-column";
 static const char SORT_DESCENDING[] = "sort-descending";
 
 Page::Page(const KConfigGroup &group, QWidget *parent)
     : KeyTreeView(group.readEntry(STRING_FILTER_ENTRY),
                   KeyFilterManager::instance()->keyFilterByID(group.readEntry(KEY_FILTER_ENTRY)),
                   nullptr, parent, group),
       m_title(group.readEntry(TITLE_ENTRY)),
       m_toolTip(),
       m_isTemporary(false),
       m_canBeClosed(!group.isImmutable()),
       m_canBeRenamed(!group.isEntryImmutable(TITLE_ENTRY)),
       m_canChangeStringFilter(!group.isEntryImmutable(STRING_FILTER_ENTRY)),
       m_canChangeKeyFilter(!group.isEntryImmutable(KEY_FILTER_ENTRY)),
       m_canChangeHierarchical(!group.isEntryImmutable(HIERARCHICAL_VIEW_ENTRY))
 {
     init();
     setHierarchicalView(group.readEntry(HIERARCHICAL_VIEW_ENTRY, true));
     const QList<int> settings = group.readEntry(COLUMN_SIZES, QList<int>());
     std::vector<int> sizes;
     sizes.reserve(settings.size());
     std::copy(settings.cbegin(), settings.cend(), std::back_inserter(sizes));
     setColumnSizes(sizes);
     setSortColumn(group.readEntry(SORT_COLUMN, 0),
                   group.readEntry(SORT_DESCENDING, true) ? Qt::DescendingOrder : Qt::AscendingOrder);
 }
 
 void Page::init()
 {
 
 }
 
 Page::~Page() {}
 
 void Page::saveTo(KConfigGroup &group) const
 {
 
     group.writeEntry(TITLE_ENTRY,         m_title);
     group.writeEntry(STRING_FILTER_ENTRY, stringFilter());
     group.writeEntry(KEY_FILTER_ENTRY,    keyFilter() ? keyFilter()->id() : QString());
     group.writeEntry(HIERARCHICAL_VIEW_ENTRY, isHierarchicalView());
     QList<int> settings;
     const auto sizes = columnSizes();
     settings.reserve(sizes.size());
     std::copy(sizes.cbegin(), sizes.cend(), std::back_inserter(settings));
     group.writeEntry(COLUMN_SIZES,        settings);
     group.writeEntry(SORT_COLUMN,         sortColumn());
     group.writeEntry(SORT_DESCENDING,     sortOrder() == Qt::DescendingOrder);
 }
 
 void Page::setStringFilter(const QString &filter)
 {
     if (!m_canChangeStringFilter) {
         return;
     }
     KeyTreeView::setStringFilter(filter);
 }
 
 void Page::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     if (!canChangeKeyFilter()) {
         return;
     }
     const QString oldTitle = title();
     KeyTreeView::setKeyFilter(filter);
     const QString newTitle = title();
     if (oldTitle != newTitle) {
         Q_EMIT titleChanged(newTitle);
     }
 }
 
 void Page::setTitle(const QString &t)
 {
     if (t == m_title) {
         return;
     }
     if (!m_canBeRenamed) {
         return;
     }
     const QString oldTitle = title();
     m_title = t;
     const QString newTitle = title();
     if (oldTitle != newTitle) {
         Q_EMIT titleChanged(newTitle);
     }
 }
 
 #if 0 // not used
 void Page::setToolTip(const QString &tip)
 {
     if (tip == m_toolTip) {
         return;
     }
     if (!m_canBeRenamed) {
         return;
     }
     const QString oldTip = toolTip();
     m_toolTip = tip;
     const QString newTip = toolTip();
     if (oldTip != newTip) {
         Q_EMIT titleChanged(title());
     }
 }
 #endif
 
 void Page::setHierarchicalView(bool on)
 {
     if (!m_canChangeHierarchical) {
         return;
     }
     KeyTreeView::setHierarchicalView(on);
 }
 
 void Page::setTemporary(bool on)
 {
     if (on == m_isTemporary) {
         return;
     }
     m_isTemporary = on;
     if (on) {
         setKeyFilter(std::shared_ptr<KeyFilter>());
     }
 }
 
 //
 //
 // TabWidget
 //
 //
 
 class TabWidget::Private
 {
     friend class ::Kleo::TabWidget;
     TabWidget *const q;
 public:
     explicit Private(TabWidget *qq);
     ~Private() {}
 
 private:
     void slotContextMenu(const QPoint &p);
     void currentIndexChanged(int index);
     void slotPageTitleChanged(const QString &title);
     void slotPageKeyFilterChanged(const std::shared_ptr<KeyFilter> &filter);
     void slotPageStringFilterChanged(const QString &filter);
     void slotPageHierarchyChanged(bool on);
 
 #ifndef QT_NO_INPUTDIALOG
     void slotRenameCurrentTab()
     {
         renamePage(currentPage());
     }
 #endif // QT_NO_INPUTDIALOG
     void slotNewTab();
     void slotDuplicateCurrentTab()
     {
         duplicatePage(currentPage());
     }
     void slotCloseCurrentTab()
     {
         closePage(currentPage());
     }
     void slotMoveCurrentTabLeft()
     {
         movePageLeft(currentPage());
     }
     void slotMoveCurrentTabRight()
     {
         movePageRight(currentPage());
     }
     void slotToggleHierarchicalView(bool on)
     {
         toggleHierarchicalView(currentPage(), on);
     }
     void slotExpandAll()
     {
         expandAll(currentPage());
     }
     void slotCollapseAll()
     {
         collapseAll(currentPage());
     }
 
 #ifndef QT_NO_INPUTDIALOG
     void renamePage(Page *page);
 #endif
     void duplicatePage(Page *page);
     void closePage(Page *page);
     void movePageLeft(Page *page);
     void movePageRight(Page *page);
     void toggleHierarchicalView(Page *page, bool on);
     void expandAll(Page *page);
     void collapseAll(Page *page);
 
     void enableDisableCurrentPageActions();
     void enableDisablePageActions(QAction *actions[], const Page *page);
 
     Page *currentPage() const
     {
         Q_ASSERT(!tabWidget.currentWidget() || qobject_cast<Page *>(tabWidget.currentWidget()));
         return static_cast<Page *>(tabWidget.currentWidget());
     }
     Page *page(unsigned int idx) const
     {
         Q_ASSERT(!tabWidget.widget(idx) || qobject_cast<Page *>(tabWidget.widget(idx)));
         return static_cast<Page *>(tabWidget.widget(idx));
     }
 
     Page *senderPage() const
     {
         QObject *const sender = q->sender();
         Q_ASSERT(!sender || qobject_cast<Page *>(sender));
         return static_cast<Page *>(sender);
     }
 
     bool isSenderCurrentPage() const
     {
         Page *const sp = senderPage();
         return sp && sp == currentPage();
     }
 
     QTreeView *addView(Page *page, Page *columnReference);
     void setCornerAction(QAction *action, Qt::Corner corner);
 
 private:
     AbstractKeyListModel *flatModel;
     AbstractKeyListModel *hierarchicalModel;
     QTabWidget tabWidget;
     QVBoxLayout layout;
     enum {
         Rename,
         Duplicate,
         Close,
         MoveLeft,
         MoveRight,
         Hierarchical,
         ExpandAll,
         CollapseAll,
 
         NumPageActions
     };
     QAction *newAction;
     QAction *currentPageActions[NumPageActions];
     QAction *otherPageActions[NumPageActions];
     bool actionsCreated;
 };
 
 TabWidget::Private::Private(TabWidget *qq)
     : q(qq),
       flatModel(nullptr),
       hierarchicalModel(nullptr),
       tabWidget(q),
       layout(q),
       actionsCreated(false)
 {
     KDAB_SET_OBJECT_NAME(tabWidget);
     KDAB_SET_OBJECT_NAME(layout);
 
     layout.setContentsMargins(0, 0, 0, 0);
     layout.addWidget(&tabWidget);
 
     tabWidget.tabBar()->hide();
     tabWidget.setMovable(true);
 
     tabWidget.tabBar()->setContextMenuPolicy(Qt::CustomContextMenu);
 
     connect(&tabWidget, SIGNAL(currentChanged(int)), q, SLOT(currentIndexChanged(int)));
     connect(tabWidget.tabBar(), &QWidget::customContextMenuRequested, q, [this](const QPoint & p) {
         slotContextMenu(p);
     });
 
 }
 
 void TabWidget::Private::slotContextMenu(const QPoint &p)
 {
     const int tabUnderPos = tabWidget.tabBar()->tabAt(p);
     Page *const contextMenuPage = static_cast<Page *>(tabWidget.widget(tabUnderPos));
     const Page *const current = currentPage();
 
     QAction **const actions = contextMenuPage == current ? currentPageActions : otherPageActions;
 
     enableDisablePageActions(actions, contextMenuPage);
 
     QMenu menu;
     menu.addAction(actions[Rename]);
     menu.addSeparator();
     menu.addAction(newAction);
     menu.addAction(actions[Duplicate]);
     menu.addSeparator();
     menu.addAction(actions[MoveLeft]);
     menu.addAction(actions[MoveRight]);
     menu.addSeparator();
     menu.addAction(actions[Close]);
 
     const QAction *const action = menu.exec(tabWidget.tabBar()->mapToGlobal(p));
 
     if (contextMenuPage == current || action == newAction) {
         return;    // performed through signal/slot connections...
     }
 
 #ifndef QT_NO_INPUTDIALOG
     if (action == otherPageActions[Rename]) {
         renamePage(contextMenuPage);
     }
 #endif // QT_NO_INPUTDIALOG
     else if (action == otherPageActions[Duplicate]) {
         duplicatePage(contextMenuPage);
     } else if (action == otherPageActions[Close]) {
         closePage(contextMenuPage);
     } else if (action == otherPageActions[MoveLeft]) {
         movePageLeft(contextMenuPage);
     } else if (action == otherPageActions[MoveRight]) {
         movePageRight(contextMenuPage);
     }
 
 }
 
 void TabWidget::Private::currentIndexChanged(int index)
 {
     const Page *const page = this->page(index);
     Q_EMIT q->currentViewChanged(page ? page->view() : nullptr);
     Q_EMIT q->keyFilterChanged(page ? page->keyFilter() : std::shared_ptr<KeyFilter>());
     Q_EMIT q->stringFilterChanged(page ? page->stringFilter() : QString());
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::enableDisableCurrentPageActions()
 {
     const Page *const page = currentPage();
 
     Q_EMIT q->enableChangeStringFilter(page && page->canChangeStringFilter());
     Q_EMIT q->enableChangeKeyFilter(page && page->canChangeKeyFilter());
 
     enableDisablePageActions(currentPageActions, page);
 }
 
 void TabWidget::Private::enableDisablePageActions(QAction *actions[], const Page *p)
 {
     actions[Rename]      ->setEnabled(p && p->canBeRenamed());
     actions[Duplicate]   ->setEnabled(p);
     actions[Close]       ->setEnabled(p && p->canBeClosed() && tabWidget.count() > 1);
     actions[MoveLeft]    ->setEnabled(p && tabWidget.indexOf(const_cast<Page *>(p)) != 0);
     actions[MoveRight]   ->setEnabled(p && tabWidget.indexOf(const_cast<Page *>(p)) != tabWidget.count() - 1);
     actions[Hierarchical]->setEnabled(p && p->canChangeHierarchical());
     actions[Hierarchical]->setChecked(p && p->isHierarchicalView());
     actions[ExpandAll]   ->setEnabled(p && p->isHierarchicalView());
     actions[CollapseAll] ->setEnabled(p && p->isHierarchicalView());
 
     if (tabWidget.count() < 2) {
         tabWidget.tabBar()->hide();
     } else {
         tabWidget.tabBar()->show();
     }
 }
 
 void TabWidget::Private::slotPageTitleChanged(const QString &)
 {
     if (Page *const page = senderPage()) {
         const int idx = tabWidget.indexOf(page);
         tabWidget.setTabText(idx, page->title());
         tabWidget.setTabToolTip(idx, page->toolTip());
     }
 }
 
 void TabWidget::Private::slotPageKeyFilterChanged(const std::shared_ptr<KeyFilter> &kf)
 {
     if (isSenderCurrentPage()) {
         Q_EMIT q->keyFilterChanged(kf);
     }
 }
 
 void TabWidget::Private::slotPageStringFilterChanged(const QString &filter)
 {
     if (isSenderCurrentPage()) {
         Q_EMIT q->stringFilterChanged(filter);
     }
 }
 
 void TabWidget::Private::slotPageHierarchyChanged(bool)
 {
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::slotNewTab()
 {
     const KConfigGroup group = KSharedConfig::openConfig()->group(QString::asprintf("View #%u", tabWidget.count()));
     Page *page = new Page(QString(), QStringLiteral("all-certificates"), QString(), nullptr, QString(), nullptr, group);
     addView(page, currentPage());
     tabWidget.setCurrentIndex(tabWidget.count() - 1);
 }
 
 void TabWidget::Private::renamePage(Page *page)
 {
     if (!page) {
         return;
     }
     bool ok;
     const QString text = QInputDialog::getText(q, i18n("Rename Tab"), i18n("New tab title:"), QLineEdit::Normal, page->title(), &ok);
     if (!ok) {
         return;
     }
     page->setTitle(text);
 }
 
 void TabWidget::Private::duplicatePage(Page *page)
 {
     if (!page) {
         return;
     }
     Page *const clone = page->clone();
     Q_ASSERT(clone);
     clone->liftAllRestrictions();
     addView(clone, page);
 }
 
 void TabWidget::Private::closePage(Page *page)
 {
     if (!page || !page->canBeClosed() || tabWidget.count() <= 1) {
         return;
     }
     Q_EMIT q->viewAboutToBeRemoved(page->view());
     tabWidget.removeTab(tabWidget.indexOf(page));
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::movePageLeft(Page *page)
 {
     if (!page) {
         return;
     }
     const int idx = tabWidget.indexOf(page);
     if (idx <= 0) {
         return;
     }
     tabWidget.tabBar()->moveTab(idx, idx - 1);
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::movePageRight(Page *page)
 {
     if (!page) {
         return;
     }
     const int idx = tabWidget.indexOf(page);
     if (idx < 0 || idx >= tabWidget.count() - 1) {
         return;
     }
     tabWidget.tabBar()->moveTab(idx, idx + 1);
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::toggleHierarchicalView(Page *page, bool on)
 {
     if (!page) {
         return;
     }
     page->setHierarchicalView(on);
 }
 
 void TabWidget::Private::expandAll(Page *page)
 {
     if (!page || !page->view()) {
         return;
     }
     page->view()->expandAll();
 }
 
 void TabWidget::Private::collapseAll(Page *page)
 {
     if (!page || !page->view()) {
         return;
     }
     page->view()->collapseAll();
 }
 
 TabWidget::TabWidget(QWidget *p, Qt::WindowFlags f)
     : QWidget(p, f), d(new Private(this))
 {
 
 }
 
 TabWidget::~TabWidget() {
     saveViews(KSharedConfig::openConfig().data());
 }
 
 void TabWidget::setFlatModel(AbstractKeyListModel *model)
 {
     if (model == d->flatModel) {
         return;
     }
     d->flatModel = model;
     for (unsigned int i = 0, end = count(); i != end; ++i)
         if (Page *const page = d->page(i)) {
             page->setFlatModel(model);
         }
 }
 
 AbstractKeyListModel *TabWidget::flatModel() const
 {
     return d->flatModel;
 }
 
 void TabWidget::setHierarchicalModel(AbstractKeyListModel *model)
 {
     if (model == d->hierarchicalModel) {
         return;
     }
     d->hierarchicalModel = model;
     for (unsigned int i = 0, end = count(); i != end; ++i)
         if (Page *const page = d->page(i)) {
             page->setHierarchicalModel(model);
         }
 }
 
 AbstractKeyListModel *TabWidget::hierarchicalModel() const
 {
     return d->hierarchicalModel;
 }
 
 void TabWidget::Private::setCornerAction(QAction *action, Qt::Corner corner)
 {
     if (!action) {
         return;
     }
     QToolButton *b = new QToolButton;
     b->setDefaultAction(action);
     tabWidget.setCornerWidget(b, corner);
 }
 
 void TabWidget::setStringFilter(const QString &filter)
 {
     if (Page *const page = d->currentPage()) {
         page->setStringFilter(filter);
     }
 }
 
 void TabWidget::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     if (!filter) {
         qCDebug(KLEOPATRA_LOG) << "TabWidget::setKeyFilter() trial to set filter=NULL";
         return;
     }
 
     if (Page *const page = d->currentPage()) {
         page->setKeyFilter(filter);
     }
 }
 
 std::vector<QAbstractItemView *> TabWidget::views() const
 {
     std::vector<QAbstractItemView *> result;
     const unsigned int N = count();
     result.reserve(N);
     for (unsigned int i = 0; i != N; ++i)
         if (const Page *const p = d->page(i)) {
             result.push_back(p->view());
         }
     return result;
 }
 
 QAbstractItemView *TabWidget::currentView() const
 {
     if (Page *const page = d->currentPage()) {
         return page->view();
     } else {
         return nullptr;
     }
 }
 
 KeyListModelInterface *TabWidget::currentModel() const
 {
     const QAbstractItemView *const view = currentView();
     if (!view) {
         return nullptr;
     }
     QAbstractProxyModel *const proxy = qobject_cast<QAbstractProxyModel *>(view->model());
     if (!proxy) {
         return nullptr;
     }
     return dynamic_cast<KeyListModelInterface *>(proxy);
 }
 
 unsigned int TabWidget::count() const
 {
     return d->tabWidget.count();
 }
 
 void TabWidget::setMultiSelection(bool on)
 {
     for (unsigned int i = 0, end = count(); i != end; ++i)
         if (const Page *const p = d->page(i))
             if (QTreeView *const view = p->view()) {
                 view->setSelectionMode(on ? QAbstractItemView::ExtendedSelection : QAbstractItemView::SingleSelection);
             }
 }
 
 void TabWidget::createActions(KActionCollection *coll)
 {
     if (!coll) {
         return;
     }
     const action_data actionDataNew = {
         "window_new_tab", i18n("New Tab"), i18n("Open a new tab"),
         "tab-new-background", this, SLOT(slotNewTab()), QStringLiteral("CTRL+SHIFT+N"), false, true
     };
 
     d->newAction = make_action_from_data(actionDataNew, coll);
 
     struct action_data actionData[] = {
         {
             "window_rename_tab", i18n("Rename Tab..."), i18n("Rename this tab"),
             "edit-rename", this, SLOT(slotRenameCurrentTab()), QStringLiteral("CTRL+SHIFT+R"), false, false
         },
         {
             "window_duplicate_tab", i18n("Duplicate Tab"), i18n("Duplicate this tab"),
             "tab-duplicate", this, SLOT(slotDuplicateCurrentTab()), QStringLiteral("CTRL+SHIFT+D"), false, true
         },
         {
             "window_close_tab", i18n("Close Tab"), i18n("Close this tab"),
             "tab-close", this, SLOT(slotCloseCurrentTab()), QStringLiteral("CTRL+SHIFT+W"), false, false
         }, // ### CTRL-W when available
         {
             "window_move_tab_left", i18n("Move Tab Left"), i18n("Move this tab left"),
             nullptr, this, SLOT(slotMoveCurrentTabLeft()), QStringLiteral("CTRL+SHIFT+LEFT"), false, false
         },
         {
             "window_move_tab_right", i18n("Move Tab Right"), i18n("Move this tab right"),
             nullptr, this, SLOT(slotMoveCurrentTabRight()), QStringLiteral("CTRL+SHIFT+RIGHT"), false, false
         },
         {
             "window_view_hierarchical", i18n("Hierarchical Certificate List"), QString(),
             nullptr, this, SLOT(slotToggleHierarchicalView(bool)), QString(), true, false
         },
         {
             "window_expand_all", i18n("Expand All"), QString(),
             nullptr, this, SLOT(slotExpandAll()), QStringLiteral("CTRL+."), false, false
         },
         {
             "window_collapse_all", i18n("Collapse All"), QString(),
             nullptr, this, SLOT(slotCollapseAll()), QStringLiteral("CTRL+,"), false, false
         },
     };
 
     for (int i = 0; i < d->NumPageActions; ++i) {
         d->currentPageActions[i] = make_action_from_data(actionData[i], coll);
     }
 
     for (int i = 0; i < d->NumPageActions; ++i) {
         action_data ad = actionData[i];
         Q_ASSERT(QString::fromLatin1(ad.name).startsWith(QLatin1String("window_")));
         ad.name = ad.name + strlen("window_");
         ad.tooltip.clear();
         ad.receiver = nullptr;
         ad.shortcut.clear();
         d->otherPageActions[i] = make_action_from_data(ad, coll);
     }
 
     d->setCornerAction(d->newAction,                 Qt::TopLeftCorner);
     d->setCornerAction(d->currentPageActions[d->Close], Qt::TopRightCorner);
     d->actionsCreated = true;
 }
 
 QAbstractItemView *TabWidget::addView(const QString &title, const QString &id, const QString &text)
 {
     const KConfigGroup group = KSharedConfig::openConfig()->group(QString::asprintf("View #%u", d->tabWidget.count()));
     Page *page = new Page(title, id, text, nullptr, QString(), nullptr, group);
     return d->addView(page, d->currentPage());
 }
 
 QAbstractItemView *TabWidget::addView(const KConfigGroup &group)
 {
     return d->addView(new Page(group), nullptr);
 }
 
 QAbstractItemView *TabWidget::addTemporaryView(const QString &title, AbstractKeyListSortFilterProxyModel *proxy, const QString &tabToolTip)
 {
-    Page *const page = new Page(title, QString(), QString(), proxy, tabToolTip);
+    const KConfigGroup group = KSharedConfig::openConfig()->group("KeyTreeView_default");
+    Page *const page = new Page(title, QString(), QString(), proxy, tabToolTip, nullptr, group);
     page->setTemporary(true);
     QAbstractItemView *v = d->addView(page, d->currentPage());
     d->tabWidget.setCurrentIndex(d->tabWidget.count() - 1);
     return v;
 }
 
 QTreeView *TabWidget::Private::addView(Page *page, Page *columnReference)
 {
     if (!page) {
         return nullptr;
     }
 
     if (!actionsCreated) {
         KActionCollection *coll = new KActionCollection(q);
         q->createActions(coll);
     }
 
     page->setFlatModel(flatModel);
     page->setHierarchicalModel(hierarchicalModel);
 
     connect(page, SIGNAL(titleChanged(QString)), q, SLOT(slotPageTitleChanged(QString)));
     connect(page, SIGNAL(keyFilterChanged(std::shared_ptr<Kleo::KeyFilter>)), q, SLOT(slotPageKeyFilterChanged(std::shared_ptr<Kleo::KeyFilter>)));
     connect(page, SIGNAL(stringFilterChanged(QString)), q, SLOT(slotPageStringFilterChanged(QString)));
     connect(page, SIGNAL(hierarchicalChanged(bool)), q, SLOT(slotPageHierarchyChanged(bool)));
 
     if (columnReference) {
         page->setColumnSizes(columnReference->columnSizes());
         page->setSortColumn(columnReference->sortColumn(), columnReference->sortOrder());
     }
 
     QAbstractItemView *const previous = q->currentView();
     const int tabIndex = tabWidget.addTab(page, page->title());
     tabWidget.setTabToolTip(tabIndex, page->toolTip());
     // work around a bug in QTabWidget (tested with 4.3.2) not emitting currentChanged() when the first widget is inserted
     QAbstractItemView *const current = q->currentView();
     if (previous != current) {
         currentIndexChanged(tabWidget.currentIndex());
     }
     enableDisableCurrentPageActions();
     QTreeView *view = page->view();
     Q_EMIT q->viewAdded(view);
     return view;
 }
 
 static QStringList extractViewGroups(const KConfig *config)
 {
     return config ? config->groupList().filter(QRegularExpression(QStringLiteral("^View #\\d+$"))) : QStringList();
 }
 
 // work around deleteGroup() not deleting groups out of groupList():
 static const bool KCONFIG_DELETEGROUP_BROKEN = true;
 
 void TabWidget::loadViews(const KConfig *config)
 {
     if (config) {
         QStringList groupList = extractViewGroups(config);
         groupList.sort();
         for (const QString &group : qAsConst(groupList)) {
             const KConfigGroup kcg(config, group);
             if (!KCONFIG_DELETEGROUP_BROKEN || kcg.readEntry("magic", 0U) == 0xFA1AFE1U) {
                 addView(kcg);
             }
         }
     }
     if (!count()) {
         // add default view:
         addView(QString(), QStringLiteral("all-certificates"));
     }
 }
 
 void TabWidget::saveViews(KConfig *config) const
 {
     if (!config) {
         return;
     }
     Q_FOREACH (const QString &group, extractViewGroups(config)) {
         config->deleteGroup(group);
     }
     unsigned int vg = 0;
     for (unsigned int i = 0, end = count(); i != end; ++i) {
         if (const Page *const p = d->page(i)) {
             if (p->isTemporary()) {
                 continue;
             }
             KConfigGroup group(config, QString::asprintf("View #%u", vg++));
             p->saveTo(group);
             if (KCONFIG_DELETEGROUP_BROKEN) {
                 group.writeEntry("magic", 0xFA1AFE1U);
             }
         }
     }
 }
 
 static void xconnect(const QObject *o1, const char *signal, const QObject *o2, const char *slot)
 {
     QObject::connect(o1, signal, o2, slot);
     QObject::connect(o2, signal, o1, slot);
 }
 
 void TabWidget::connectSearchBar(QObject *sb)
 {
     xconnect(sb, SIGNAL(stringFilterChanged(QString)),
              this, SLOT(setStringFilter(QString)));
     xconnect(sb, SIGNAL(keyFilterChanged(std::shared_ptr<Kleo::KeyFilter>)),
              this, SLOT(setKeyFilter(std::shared_ptr<Kleo::KeyFilter>)));
     connect(this, SIGNAL(enableChangeStringFilter(bool)),
             sb, SLOT(setChangeStringFilterEnabled(bool)));
     connect(this, SIGNAL(enableChangeKeyFilter(bool)),
             sb, SLOT(setChangeKeyFilterEnabled(bool)));
 }
 
 #include "moc_tabwidget.cpp"
 #include "tabwidget.moc"