diff --git a/src/ui/keylistview.cpp b/src/ui/keylistview.cpp
index 96e26db2e..74c3c47ff 100644
--- a/src/ui/keylistview.cpp
+++ b/src/ui/keylistview.cpp
@@ -1,560 +1,564 @@
 /*
     keylistview.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-libkleo.h>
 
 #include "keylistview.h"
 
 #include <kleo_ui_debug.h>
 
 #include <QColor>
 #include <QFont>
 #include <QFontMetrics>
 #include <QKeyEvent>
 #include <QPoint>
 #include <QTimer>
 #include <QToolTip>
 
 #include <gpgme++/key.h>
 
 #include <map>
 #include <vector>
 
 using namespace Kleo;
 
 static const int updateDelayMilliSecs = 500;
 
 class Q_DECL_HIDDEN KeyListView::KeyListViewPrivate
 {
 public:
     KeyListViewPrivate()
         : updateTimer(nullptr)
     {
     }
 
     std::vector<GpgME::Key> keyBuffer;
     QTimer *updateTimer = nullptr;
     std::map<QByteArray, KeyListViewItem *> itemMap;
 };
 
 // a list of signals where we want to replace QListViewItem with
 // Kleo:KeyListViewItem:
 static const struct {
     const char *source;
     const char *target;
 } signalReplacements[] = {
     {
         SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)),
         SLOT(slotEmitDoubleClicked(QTreeWidgetItem *, int)),
     },
     {
         SIGNAL(itemSelectionChanged()),
         SLOT(slotEmitSelectionChanged()),
     },
     {
         SIGNAL(customContextMenuRequested(QPoint)),
         SLOT(slotEmitContextMenu(QPoint)),
     },
 };
 static const int numSignalReplacements = sizeof signalReplacements / sizeof *signalReplacements;
 
 KeyListView::KeyListView(const ColumnStrategy *columnStrategy, const DisplayStrategy *displayStrategy, QWidget *parent, Qt::WindowFlags f)
     : NavigatableTreeWidget(parent)
     , mColumnStrategy(columnStrategy)
     , mDisplayStrategy(displayStrategy)
     , mHierarchical(false)
     , d(new KeyListViewPrivate())
 {
     setWindowFlags(f);
     setContextMenuPolicy(Qt::CustomContextMenu);
 
     d->updateTimer = new QTimer(this);
     d->updateTimer->setSingleShot(true);
     connect(d->updateTimer, &QTimer::timeout, this, &KeyListView::slotUpdateTimeout);
     if (!columnStrategy) {
         qCWarning(KLEO_UI_LOG) << "Kleo::KeyListView: need a column strategy to work with!";
         return;
     }
 
     const QFontMetrics fm = fontMetrics();
 
     for (int col = 0; !columnStrategy->title(col).isEmpty(); ++col) {
         headerItem()->setText(col, columnStrategy->title(col));
         header()->resizeSection(col, columnStrategy->width(col, fm));
         header()->setSectionResizeMode(col, columnStrategy->resizeMode(col));
     }
 
     setAllColumnsShowFocus(false);
 
     for (int i = 0; i < numSignalReplacements; ++i) {
         connect(this, signalReplacements[i].source, signalReplacements[i].target);
     }
 
     this->setToolTip(QString());
     viewport()->setToolTip(QString()); // make double sure :)
 }
 
 KeyListView::~KeyListView()
 {
     d->updateTimer->stop();
     // need to clear here, since in ~QListView, our children won't have
     // a valid listView() pointing to us anymore, and their dtors try to
     // unregister from us.
     clear();
     Q_ASSERT(d->itemMap.size() == 0);
     // need to delete the tooltip ourselves, as ~QToolTip isn't virtual :o
     delete mColumnStrategy;
     mColumnStrategy = nullptr;
     delete mDisplayStrategy;
     mDisplayStrategy = nullptr;
 }
 
 void KeyListView::takeItem(QTreeWidgetItem *qlvi)
 {
     // qCDebug(KLEO_UI_LOG) <<"Kleo::KeyListView::takeItem(" << qlvi <<" )";
     if (auto *item = lvi_cast<KeyListViewItem>(qlvi)) {
         deregisterItem(item);
     }
     takeTopLevelItem(indexOfTopLevelItem(qlvi));
 }
 
 void KeyListView::setHierarchical(bool hier)
 {
     if (hier == mHierarchical) {
         return;
     }
     mHierarchical = hier;
     if (hier) {
         gatherScattered();
     } else {
         scatterGathered(firstChild());
     }
 }
 
 void KeyListView::slotAddKey(const GpgME::Key &key)
 {
     if (key.isNull()) {
         return;
     }
 
     d->keyBuffer.push_back(key);
     if (!d->updateTimer->isActive()) {
         d->updateTimer->start(updateDelayMilliSecs);
     }
 }
 
 void KeyListView::slotUpdateTimeout()
 {
     if (d->keyBuffer.empty()) {
         return;
     }
 
     const bool wasUpdatesEnabled = viewport()->updatesEnabled();
     if (wasUpdatesEnabled) {
         viewport()->setUpdatesEnabled(false);
     }
     qCDebug(KLEO_UI_LOG) << "Kleo::KeyListView::slotUpdateTimeout(): processing" << d->keyBuffer.size() << "items en block";
     if (hierarchical()) {
         for (std::vector<GpgME::Key>::const_iterator it = d->keyBuffer.begin(); it != d->keyBuffer.end(); ++it) {
             doHierarchicalInsert(*it);
         }
         gatherScattered();
     } else {
         for (std::vector<GpgME::Key>::const_iterator it = d->keyBuffer.begin(); it != d->keyBuffer.end(); ++it) {
             (void)new KeyListViewItem(this, *it);
         }
     }
     if (wasUpdatesEnabled) {
         viewport()->setUpdatesEnabled(true);
     }
     d->keyBuffer.clear();
 }
 
 void KeyListView::clear()
 {
     d->updateTimer->stop();
     d->keyBuffer.clear();
     while (QTreeWidgetItem *item = topLevelItem(0)) {
         delete item;
     }
     QTreeWidget::clear();
 }
 
 void KeyListView::registerItem(KeyListViewItem *item)
 {
     // qCDebug(KLEO_UI_LOG) <<"registerItem(" << item <<" )";
     if (!item) {
         return;
     }
     const QByteArray fpr = item->key().primaryFingerprint();
     if (!fpr.isEmpty()) {
         d->itemMap.insert(std::make_pair(fpr, item));
     }
 }
 
 void KeyListView::deregisterItem(const KeyListViewItem *item)
 {
     // qCDebug(KLEO_UI_LOG) <<"deregisterItem( KeyLVI:" << item <<" )";
     if (!item) {
         return;
     }
     auto it = d->itemMap.find(item->key().primaryFingerprint());
     if (it == d->itemMap.end()) {
         return;
     }
     // This Q_ASSERT triggers, though it shouldn't. Print some more
     // information when it happens.
     // Q_ASSERT( it->second == item );
     if (it->second != item) {
         qCWarning(KLEO_UI_LOG) << "deregisterItem:"
                                << "item      " << item->key().primaryFingerprint() //
                                << "it->second" << (it->second ? it->second->key().primaryFingerprint() : "is null");
         return;
     }
     d->itemMap.erase(it);
 }
 
 void KeyListView::doHierarchicalInsert(const GpgME::Key &key)
 {
     const QByteArray fpr = key.primaryFingerprint();
     if (fpr.isEmpty()) {
         return;
     }
     KeyListViewItem *item = nullptr;
     if (!key.isRoot()) {
         if (KeyListViewItem *parent = itemByFingerprint(key.chainID())) {
             item = new KeyListViewItem(parent, key);
             parent->setExpanded(true);
         }
     }
     if (!item) {
         item = new KeyListViewItem(this, key); // top-level (for now)
     }
 
     d->itemMap.insert(std::make_pair(fpr, item));
 }
 
 void KeyListView::gatherScattered()
 {
     KeyListViewItem *item = firstChild();
     while (item) {
         KeyListViewItem *cur = item;
         item = item->nextSibling();
         if (cur->key().isRoot()) {
             continue;
         }
         if (KeyListViewItem *parent = itemByFingerprint(cur->key().chainID())) {
             // found a new parent...
             // ### todo: optimize by suppressing removing/adding the item to the itemMap...
             takeTopLevelItem(indexOfTopLevelItem(cur));
             parent->addChild(cur);
             parent->setExpanded(true);
         }
     }
 }
 
 void KeyListView::scatterGathered(KeyListViewItem *start)
 {
     KeyListViewItem *item = start;
     while (item) {
         KeyListViewItem *cur = item;
         item = item->nextSibling();
 
         scatterGathered(lvi_cast<KeyListViewItem>(cur->child(0)));
         Q_ASSERT(cur->childCount() == 0);
 
         // ### todo: optimize by suppressing removing/adding the item to the itemMap...
         if (cur->parent()) {
             static_cast<KeyListViewItem *>(cur->parent())->takeItem(cur);
         } else {
             takeItem(cur);
         }
         addTopLevelItem(cur);
     }
 }
 
 KeyListViewItem *KeyListView::itemByFingerprint(const QByteArray &s) const
 {
     if (s.isEmpty()) {
         return nullptr;
     }
     const std::map<QByteArray, KeyListViewItem *>::const_iterator it = d->itemMap.find(s);
     if (it == d->itemMap.end()) {
         return nullptr;
     }
     return it->second;
 }
 
 void KeyListView::slotRefreshKey(const GpgME::Key &key)
 {
     const char *fpr = key.primaryFingerprint();
     if (!fpr) {
         return;
     }
     if (KeyListViewItem *item = itemByFingerprint(fpr)) {
         item->setKey(key);
     } else {
         // none found -> add it
         slotAddKey(key);
     }
 }
 
 // slots for the emission of covariant Q_SIGNALS:
 
 void KeyListView::slotEmitDoubleClicked(QTreeWidgetItem *item, int col)
 {
     if (!item || lvi_cast<KeyListViewItem>(item)) {
         Q_EMIT doubleClicked(static_cast<KeyListViewItem *>(item), col);
     }
 }
 
 void KeyListView::slotEmitReturnPressed(QTreeWidgetItem *item)
 {
     if (!item || lvi_cast<KeyListViewItem>(item)) {
         Q_EMIT returnPressed(static_cast<KeyListViewItem *>(item));
     }
 }
 
 void KeyListView::slotEmitSelectionChanged()
 {
     Q_EMIT selectionChanged(selectedItem());
 }
 
 void KeyListView::slotEmitContextMenu(const QPoint &pos)
 {
     QTreeWidgetItem *item = itemAt(pos);
     if (!item || lvi_cast<KeyListViewItem>(item)) {
         Q_EMIT contextMenu(static_cast<KeyListViewItem *>(item), viewport()->mapToGlobal(pos));
     }
 }
 
 //
 //
 // KeyListViewItem
 //
 //
 
 KeyListViewItem::KeyListViewItem(KeyListView *parent, const GpgME::Key &key)
     : QTreeWidgetItem(parent, RTTI)
 {
     Q_ASSERT(parent);
     setKey(key);
 }
 
 KeyListViewItem::KeyListViewItem(KeyListView *parent, KeyListViewItem *after, const GpgME::Key &key)
     : QTreeWidgetItem(parent, after, RTTI)
 {
     Q_ASSERT(parent);
     setKey(key);
 }
 
 KeyListViewItem::KeyListViewItem(KeyListViewItem *parent, const GpgME::Key &key)
     : QTreeWidgetItem(parent, RTTI)
 {
     Q_ASSERT(parent && parent->listView());
     setKey(key);
 }
 
 KeyListViewItem::KeyListViewItem(KeyListViewItem *parent, KeyListViewItem *after, const GpgME::Key &key)
     : QTreeWidgetItem(parent, after, RTTI)
 {
     Q_ASSERT(parent && parent->listView());
     setKey(key);
 }
 
 KeyListViewItem::~KeyListViewItem()
 {
     // delete the children first... When children are deleted in the
     // QLVI dtor, they don't have listView() anymore, thus they don't
     // call deregister( this ), leading to stale entries in the
     // itemMap...
     while (QTreeWidgetItem *item = child(0)) {
         delete item;
     }
     // better do this here, too, since deletion is top-down and thus
     // we're deleted when our parent item is no longer a
     // KeyListViewItem, but a mere QListViewItem, so our takeItem()
     // overload is gone by that time...
     if (KeyListView *lv = listView()) {
         lv->deregisterItem(this);
     }
 }
 
 void KeyListViewItem::setKey(const GpgME::Key &key)
 {
     KeyListView *lv = listView();
     if (lv) {
         lv->deregisterItem(this);
     }
     mKey = key;
     if (lv) {
         lv->registerItem(this);
     }
 
     // the ColumnStrategy operations might be very slow, so cache their
     // result here, where we're non-const :)
     const KeyListView::ColumnStrategy *cs = lv ? lv->columnStrategy() : nullptr;
     if (!cs) {
         return;
     }
     const KeyListView::DisplayStrategy *ds = lv->displayStrategy();
     const int numCols = lv ? lv->columnCount() : 0;
     for (int i = 0; i < numCols; ++i) {
         setText(i, cs->text(key, i));
+        const auto accessibleText = cs->accessibleText(key, i);
+        if (!accessibleText.isEmpty()) {
+            setData(i, Qt::AccessibleTextRole, accessibleText);
+        }
         setToolTip(i, cs->toolTip(key, i));
         const QIcon icon = cs->icon(key, i);
         if (!icon.isNull()) {
             setIcon(i, icon);
         }
         if (ds) {
             setForeground(i, QBrush(ds->keyForeground(key, foreground(i).color())));
             setBackground(i, QBrush(ds->keyBackground(key, background(i).color())));
             setFont(i, ds->keyFont(key, font(i)));
         }
     }
 }
 
 QString KeyListViewItem::toolTip(int col) const
 {
     return listView() && listView()->columnStrategy() ? listView()->columnStrategy()->toolTip(key(), col) : QString();
 }
 
 bool KeyListViewItem::operator<(const QTreeWidgetItem &other) const
 {
     if (other.type() != RTTI || !listView() || !listView()->columnStrategy()) {
         return QTreeWidgetItem::operator<(other);
     }
     const auto that = static_cast<const KeyListViewItem *>(&other);
     return listView()->columnStrategy()->compare(this->key(), that->key(), treeWidget()->sortColumn()) < 0;
 }
 
 void KeyListViewItem::takeItem(QTreeWidgetItem *qlvi)
 {
     // qCDebug(KLEO_UI_LOG) <<"Kleo::KeyListViewItem::takeItem(" << qlvi <<" )";
     if (auto *item = lvi_cast<KeyListViewItem>(qlvi)) {
         listView()->deregisterItem(item);
     }
     takeChild(indexOfChild(qlvi));
 }
 
 //
 //
 // ColumnStrategy
 //
 //
 
 KeyListView::ColumnStrategy::~ColumnStrategy()
 {
 }
 
 int KeyListView::ColumnStrategy::compare(const GpgME::Key &key1, const GpgME::Key &key2, const int col) const
 {
     return QString::localeAwareCompare(text(key1, col), text(key2, col));
 }
 
 int KeyListView::ColumnStrategy::width(int col, const QFontMetrics &fm) const
 {
     return fm.horizontalAdvance(title(col)) * 2;
 }
 
 QString KeyListView::ColumnStrategy::toolTip(const GpgME::Key &key, int col) const
 {
     return text(key, col);
 }
 
 //
 //
 // DisplayStrategy
 //
 //
 
 KeyListView::DisplayStrategy::~DisplayStrategy()
 {
 }
 
 // font
 QFont KeyListView::DisplayStrategy::keyFont(const GpgME::Key &, const QFont &font) const
 {
     return font;
 }
 
 // foreground
 QColor KeyListView::DisplayStrategy::keyForeground(const GpgME::Key &, const QColor &fg) const
 {
     return fg;
 }
 
 // background
 QColor KeyListView::DisplayStrategy::keyBackground(const GpgME::Key &, const QColor &bg) const
 {
     return bg;
 }
 
 //
 //
 // Collection of covariant return reimplementations of QListView(Item)
 // members:
 //
 //
 
 KeyListView *KeyListViewItem::listView() const
 {
     return static_cast<KeyListView *>(QTreeWidgetItem::treeWidget());
 }
 
 KeyListViewItem *KeyListViewItem::nextSibling() const
 {
     if (parent()) {
         const int myIndex = parent()->indexOfChild(const_cast<KeyListViewItem *>(this));
         return static_cast<KeyListViewItem *>(parent()->child(myIndex + 1));
     }
     const int myIndex = treeWidget()->indexOfTopLevelItem(const_cast<KeyListViewItem *>(this));
     return static_cast<KeyListViewItem *>(treeWidget()->topLevelItem(myIndex + 1));
 }
 
 KeyListViewItem *KeyListView::firstChild() const
 {
     return static_cast<KeyListViewItem *>(topLevelItem(0));
 }
 
 KeyListViewItem *KeyListView::selectedItem() const
 {
     QList<KeyListViewItem *> selection = selectedItems();
     if (selection.isEmpty()) {
         return nullptr;
     }
     return selection.first();
 }
 
 QList<KeyListViewItem *> KeyListView::selectedItems() const
 {
     QList<KeyListViewItem *> result;
     const auto selectedItems = QTreeWidget::selectedItems();
     for (QTreeWidgetItem *selectedItem : selectedItems) {
         if (auto *i = lvi_cast<KeyListViewItem>(selectedItem)) {
             result.append(i);
         }
     }
     return result;
 }
 
 bool KeyListView::isMultiSelection() const
 {
     return selectionMode() == ExtendedSelection || selectionMode() == MultiSelection;
 }
 
 void KeyListView::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) {
         if (selectedItem()) {
             slotEmitReturnPressed(selectedItem());
         }
     }
     QTreeView::keyPressEvent(event);
 }
diff --git a/src/ui/keylistview.h b/src/ui/keylistview.h
index 7ee82c733..5469672a7 100644
--- a/src/ui/keylistview.h
+++ b/src/ui/keylistview.h
@@ -1,198 +1,199 @@
 /*
     keylistview.h
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include "kleo_export.h"
 
 #include "navigatabletreewidget.h"
 
 #include <QByteArray>
 #include <QHeaderView>
 #include <QIcon>
 
 #include <gpgme++/key.h>
 
 class QFont;
 class QColor;
 
 namespace Kleo
 {
 
 // work around moc parser bug...
 #define TEMPLATE_TYPENAME(T) template<typename T>
 TEMPLATE_TYPENAME(T)
 inline T *lvi_cast(QTreeWidgetItem *item)
 {
     return item && (item->type() == T::RTTI) ? static_cast<T *>(item) : nullptr;
 }
 
 TEMPLATE_TYPENAME(T)
 inline const T *lvi_cast(const QTreeWidgetItem *item)
 {
     return item && (item->type() == T::RTTI) ? static_cast<const T *>(item) : nullptr;
 }
 #undef TEMPLATE_TYPENAME
 
 class KeyListView;
 
 class KeyListViewItem : public QTreeWidgetItem
 {
 public:
     KeyListViewItem(KeyListView *parent, const GpgME::Key &key);
     KeyListViewItem(KeyListView *parent, KeyListViewItem *after, const GpgME::Key &key);
     KeyListViewItem(KeyListViewItem *parent, const GpgME::Key &key);
     KeyListViewItem(KeyListViewItem *parent, KeyListViewItem *after, const GpgME::Key &key);
     ~KeyListViewItem() override;
 
     void setKey(const GpgME::Key &key);
     const GpgME::Key &key() const
     {
         return mKey;
     }
 
     enum { RTTI = QTreeWidgetItem::UserType + 1 };
 
     //
     // only boring stuff below:
     //
     virtual QString toolTip(int column) const;
 
     /*! \reimp for covariant return */
     KeyListView *listView() const;
     /*! \reimp for covariant return */
     KeyListViewItem *nextSibling() const;
     /*! \reimp */
     bool operator<(const QTreeWidgetItem &other) const override;
     /*! \reimp */
     void takeItem(QTreeWidgetItem *item);
 
 private:
     GpgME::Key mKey;
 };
 
 class KLEO_EXPORT KeyListView : public NavigatableTreeWidget
 {
     Q_OBJECT
     friend class KeyListViewItem;
 
 public:
     class KLEO_EXPORT ColumnStrategy
     {
     public:
         virtual ~ColumnStrategy();
         virtual QString title(int column) const = 0;
         virtual int width(int column, const QFontMetrics &fm) const;
         virtual QHeaderView::ResizeMode resizeMode(int) const
         {
             return QHeaderView::Interactive;
         }
 
         virtual QString text(const GpgME::Key &key, int column) const = 0;
+        virtual QString accessibleText(const GpgME::Key &key, int column) const = 0;
         virtual QString toolTip(const GpgME::Key &key, int column) const;
         virtual QIcon icon(const GpgME::Key &, int) const
         {
             return QIcon();
         }
         virtual int compare(const GpgME::Key &key1, const GpgME::Key &key2, const int column) const;
     };
 
     class KLEO_EXPORT DisplayStrategy
     {
     public:
         virtual ~DisplayStrategy();
         // font
         virtual QFont keyFont(const GpgME::Key &, const QFont &) const;
         // foreground
         virtual QColor keyForeground(const GpgME::Key &, const QColor &) const;
         // background
         virtual QColor keyBackground(const GpgME::Key &, const QColor &) const;
     };
 
     explicit KeyListView(const ColumnStrategy *strategy, const DisplayStrategy *display = nullptr, QWidget *parent = nullptr, Qt::WindowFlags f = {});
 
     ~KeyListView() override;
 
     const ColumnStrategy *columnStrategy() const
     {
         return mColumnStrategy;
     }
     const DisplayStrategy *displayStrategy() const
     {
         return mDisplayStrategy;
     }
 
     bool hierarchical() const
     {
         return mHierarchical;
     }
     virtual void setHierarchical(bool hier);
 
     void flushKeys()
     {
         slotUpdateTimeout();
     }
 
     bool isMultiSelection() const;
 
     KeyListViewItem *itemByFingerprint(const QByteArray &) const;
 
 public:
     using QTreeWidget::selectionChanged; // for below, but moc doesn't like it to be in the Q_SIGNALS: section
 Q_SIGNALS:
     void doubleClicked(Kleo::KeyListViewItem *, int);
     void returnPressed(Kleo::KeyListViewItem *);
     void selectionChanged(Kleo::KeyListViewItem *);
     void contextMenu(Kleo::KeyListViewItem *, const QPoint &);
 
 protected:
     void keyPressEvent(QKeyEvent *event) override;
 
 public Q_SLOTS:
     virtual void slotAddKey(const GpgME::Key &key);
     virtual void slotRefreshKey(const GpgME::Key &key);
 
     //
     // Only boring stuff below:
     //
 private Q_SLOTS:
     void slotEmitDoubleClicked(QTreeWidgetItem *, int);
     void slotEmitReturnPressed(QTreeWidgetItem *);
     void slotEmitSelectionChanged();
     void slotEmitContextMenu(const QPoint &pos);
     void slotUpdateTimeout();
 
 public:
     /*! \reimp for covariant return */
     KeyListViewItem *selectedItem() const;
     /*! \reimp */
     QList<KeyListViewItem *> selectedItems() const;
     /*! \reimp for covariant return */
     KeyListViewItem *firstChild() const;
     /*! \reimp */
     void clear();
     /*! \reimp */
     void takeItem(QTreeWidgetItem *);
 
 private:
     void doHierarchicalInsert(const GpgME::Key &);
     void gatherScattered();
     void scatterGathered(KeyListViewItem *);
     void registerItem(KeyListViewItem *);
     void deregisterItem(const KeyListViewItem *);
 
 private:
     const ColumnStrategy *mColumnStrategy = nullptr;
     const DisplayStrategy *mDisplayStrategy = nullptr;
     bool mHierarchical = false;
 
     class KeyListViewPrivate;
     std::unique_ptr<KeyListViewPrivate> const d;
 };
 }
diff --git a/src/ui/keyselectiondialog.cpp b/src/ui/keyselectiondialog.cpp
index 69f9ffc08..b94ce4b78 100644
--- a/src/ui/keyselectiondialog.cpp
+++ b/src/ui/keyselectiondialog.cpp
@@ -1,1001 +1,1016 @@
 /*  -*- c++ -*-
     keyselectiondialog.cpp
 
     This file is part of libkleopatra, the KDE keymanagement library
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     Based on kpgpui.cpp
     SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
     See file libkdenetwork/AUTHORS.kpgp for details
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-libkleo.h>
 
 #include "keyselectiondialog.h"
 
 #include "keylistview.h"
 #include "progressdialog.h"
 
 #include <libkleo/dn.h>
+#include <libkleo/formatting.h>
 
 #include <kleo_ui_debug.h>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 
 #include <QGpgME/KeyListJob>
 
 #include <QApplication>
 #include <QCheckBox>
 #include <QDateTime>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QProcess>
 #include <QPushButton>
 #include <QRegExp>
 #include <QScrollBar>
 #include <QStringBuilder>
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <algorithm>
 #include <iterator>
 #include <string.h>
 
 using namespace Kleo;
 
 static bool checkKeyUsage(const GpgME::Key &key, unsigned int keyUsage, QString *statusString = nullptr)
 {
     auto setStatusString = [statusString](const QString &status) {
         if (statusString) {
             *statusString = status;
         }
     };
 
     if (keyUsage & KeySelectionDialog::ValidKeys) {
         if (key.isInvalid()) {
             if (key.keyListMode() & GpgME::Validate) {
                 qCDebug(KLEO_UI_LOG) << "key is invalid";
                 setStatusString(i18n("The key is not valid."));
                 return false;
             } else {
                 qCDebug(KLEO_UI_LOG) << "key is invalid - ignoring";
             }
         }
         if (key.isExpired()) {
             qCDebug(KLEO_UI_LOG) << "key is expired";
             setStatusString(i18n("The key is expired."));
             return false;
         } else if (key.isRevoked()) {
             qCDebug(KLEO_UI_LOG) << "key is revoked";
             setStatusString(i18n("The key is revoked."));
             return false;
         } else if (key.isDisabled()) {
             qCDebug(KLEO_UI_LOG) << "key is disabled";
             setStatusString(i18n("The key is disabled."));
             return false;
         }
     }
 
     if (keyUsage & KeySelectionDialog::EncryptionKeys && !key.canEncrypt()) {
         qCDebug(KLEO_UI_LOG) << "key can't encrypt";
         setStatusString(i18n("The key is not designated for encryption."));
         return false;
     }
     if (keyUsage & KeySelectionDialog::SigningKeys && !key.canSign()) {
         qCDebug(KLEO_UI_LOG) << "key can't sign";
         setStatusString(i18n("The key is not designated for signing."));
         return false;
     }
     if (keyUsage & KeySelectionDialog::CertificationKeys && !key.canCertify()) {
         qCDebug(KLEO_UI_LOG) << "key can't certify";
         setStatusString(i18n("The key is not designated for certifying."));
         return false;
     }
     if (keyUsage & KeySelectionDialog::AuthenticationKeys && !key.canAuthenticate()) {
         qCDebug(KLEO_UI_LOG) << "key can't authenticate";
         setStatusString(i18n("The key is not designated for authentication."));
         return false;
     }
 
     if (keyUsage & KeySelectionDialog::SecretKeys && !(keyUsage & KeySelectionDialog::PublicKeys) && !key.hasSecret()) {
         qCDebug(KLEO_UI_LOG) << "key isn't secret";
         setStatusString(i18n("The key is not secret."));
         return false;
     }
 
     if (keyUsage & KeySelectionDialog::TrustedKeys && key.protocol() == GpgME::OpenPGP &&
         // only check this for secret keys for now.
         // Seems validity isn't checked for secret keylistings...
         !key.hasSecret()) {
         std::vector<GpgME::UserID> uids = key.userIDs();
         for (std::vector<GpgME::UserID>::const_iterator it = uids.begin(); it != uids.end(); ++it) {
             if (!it->isRevoked() && it->validity() >= GpgME::UserID::Marginal) {
                 return true;
             }
         }
         qCDebug(KLEO_UI_LOG) << "key has no UIDs with validity >= Marginal";
         setStatusString(i18n("The key is not trusted enough."));
         return false;
     }
     // X.509 keys are always trusted, else they won't be the keybox.
     // PENDING(marc) check that this ^ is correct
 
     setStatusString(i18n("The key can be used."));
     return true;
 }
 
 static bool checkKeyUsage(const std::vector<GpgME::Key> &keys, unsigned int keyUsage)
 {
     for (auto it = keys.begin(); it != keys.end(); ++it) {
         if (!checkKeyUsage(*it, keyUsage)) {
             return false;
         }
     }
     return true;
 }
 
 static inline QString time_t2string(time_t t)
 {
     return QDateTime::fromSecsSinceEpoch(t).toString();
 }
 
 namespace
 {
 
 class ColumnStrategy : public KeyListView::ColumnStrategy
 {
 public:
     ColumnStrategy(unsigned int keyUsage);
 
     QString title(int col) const override;
     int width(int col, const QFontMetrics &fm) const override;
 
     QString text(const GpgME::Key &key, int col) const override;
+    QString accessibleText(const GpgME::Key &key, int column) const override;
     QString toolTip(const GpgME::Key &key, int col) const override;
     QIcon icon(const GpgME::Key &key, int col) const override;
 
 private:
     const QIcon mKeyGoodPix, mKeyBadPix, mKeyUnknownPix, mKeyValidPix;
     const unsigned int mKeyUsage;
 };
 
 static QString iconPath(const QString &name)
 {
     return QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("libkleopatra/pics/") + name + QStringLiteral(".png"));
 }
 
 ColumnStrategy::ColumnStrategy(unsigned int keyUsage)
     : KeyListView::ColumnStrategy()
     , mKeyGoodPix(iconPath(QStringLiteral("key_ok")))
     , mKeyBadPix(iconPath(QStringLiteral("key_bad")))
     , mKeyUnknownPix(iconPath(QStringLiteral("key_unknown")))
     , mKeyValidPix(iconPath(QStringLiteral("key")))
     , mKeyUsage(keyUsage)
 {
     if (keyUsage == 0) {
         qCWarning(KLEO_UI_LOG) << "KeySelectionDialog: keyUsage == 0. You want to use AllKeys instead.";
     }
 }
 
 QString ColumnStrategy::title(int col) const
 {
     switch (col) {
     case 0:
         return i18n("Key ID");
     case 1:
         return i18n("User ID");
     default:
         return QString();
     }
 }
 
 int ColumnStrategy::width(int col, const QFontMetrics &fm) const
 {
     if (col == 0) {
         static const char hexchars[] = "0123456789ABCDEF";
         int maxWidth = 0;
         for (unsigned int i = 0; i < 16; ++i) {
             maxWidth = qMax(fm.boundingRect(QLatin1Char(hexchars[i])).width(), maxWidth);
         }
         return 8 * maxWidth + 2 * 16 /* KIconLoader::SizeSmall */;
     }
     return KeyListView::ColumnStrategy::width(col, fm);
 }
 
 QString ColumnStrategy::text(const GpgME::Key &key, int col) const
 {
     switch (col) {
     case 0: {
         if (key.shortKeyID()) {
-            return QString::fromUtf8(key.shortKeyID());
+            return Formatting::prettyID(key.shortKeyID());
         } else {
             return xi18n("<placeholder>unknown</placeholder>");
         }
     }
     case 1: {
         const char *uid = key.userID(0).id();
         if (key.protocol() == GpgME::OpenPGP) {
             return uid && *uid ? QString::fromUtf8(uid) : QString();
         } else { // CMS
             return DN(uid).prettyDN();
         }
     }
     default:
         return QString();
     }
 }
 
+QString ColumnStrategy::accessibleText(const GpgME::Key &key, int col) const
+{
+    switch (col) {
+    case 0: {
+        if (key.shortKeyID()) {
+            return Formatting::accessibleHexID(key.shortKeyID());
+        }
+    }
+    default:
+        return {};
+    }
+}
+
 QString ColumnStrategy::toolTip(const GpgME::Key &key, int) const
 {
     const char *uid = key.userID(0).id();
     const char *fpr = key.primaryFingerprint();
     const char *issuer = key.issuerName();
     const GpgME::Subkey subkey = key.subkey(0);
     const QString expiry = subkey.neverExpires() ? i18n("never") : time_t2string(subkey.expirationTime());
     const QString creation = time_t2string(subkey.creationTime());
     QString keyStatusString;
     if (!checkKeyUsage(key, mKeyUsage, &keyStatusString)) {
         // Show the status in bold if there is a problem
         keyStatusString = QLatin1String("<b>") % keyStatusString % QLatin1String("</b>");
     }
 
     QString html = QStringLiteral("<qt><p style=\"style='white-space:pre'\">");
     if (key.protocol() == GpgME::OpenPGP) {
         html += i18n("OpenPGP key for <b>%1</b>", uid ? QString::fromUtf8(uid) : i18n("unknown"));
     } else {
         html += i18n("S/MIME key for <b>%1</b>", uid ? DN(uid).prettyDN() : i18n("unknown"));
     }
     html += QStringLiteral("</p><table>");
 
     const auto addRow = [&html](const QString &name, const QString &value) {
         html += QStringLiteral("<tr><td align=\"right\"><b>%1: </b></td><td>%2</td></tr>").arg(name, value);
     };
     addRow(i18nc("Key creation date", "Created"), creation);
     addRow(i18nc("Key Expiration date", "Expiry"), expiry);
     addRow(i18nc("Key fingerprint", "Fingerprint"), fpr ? QString::fromLatin1(fpr) : i18n("unknown"));
     if (key.protocol() != GpgME::OpenPGP) {
         addRow(i18nc("Key issuer", "Issuer"), issuer ? DN(issuer).prettyDN() : i18n("unknown"));
     }
     addRow(i18nc("Key status", "Status"), keyStatusString);
     html += QStringLiteral("</table></qt>");
 
     return html;
 }
 
 QIcon ColumnStrategy::icon(const GpgME::Key &key, int col) const
 {
     if (col != 0) {
         return QIcon();
     }
     // this key did not undergo a validating keylisting yet:
     if (!(key.keyListMode() & GpgME::Validate)) {
         return mKeyUnknownPix;
     }
 
     if (!checkKeyUsage(key, mKeyUsage)) {
         return mKeyBadPix;
     }
 
     if (key.protocol() == GpgME::CMS) {
         return mKeyGoodPix;
     }
 
     switch (key.userID(0).validity()) {
     default:
     case GpgME::UserID::Unknown:
     case GpgME::UserID::Undefined:
         return mKeyUnknownPix;
     case GpgME::UserID::Never:
         return mKeyValidPix;
     case GpgME::UserID::Marginal:
     case GpgME::UserID::Full:
     case GpgME::UserID::Ultimate:
         return mKeyGoodPix;
     }
 }
 
 }
 
 static const int sCheckSelectionDelay = 250;
 
 KeySelectionDialog::KeySelectionDialog(QWidget *parent, Options options)
     : QDialog(parent)
     , mOpenPGPBackend(QGpgME::openpgp())
     , mSMIMEBackend(QGpgME::smime())
     , mKeyUsage(AllKeys)
 {
     qCDebug(KLEO_UI_LOG) << "mTruncated:" << mTruncated << "mSavedOffsetY:" << mSavedOffsetY;
     setUpUI(options, QString());
 }
 
 KeySelectionDialog::KeySelectionDialog(const QString &title,
                                        const QString &text,
                                        const std::vector<GpgME::Key> &selectedKeys,
                                        unsigned int keyUsage,
                                        bool extendedSelection,
                                        bool rememberChoice,
                                        QWidget *parent,
                                        bool modal)
     : QDialog(parent)
     , mSelectedKeys(selectedKeys)
     , mKeyUsage(keyUsage)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, QString());
 }
 
 KeySelectionDialog::KeySelectionDialog(const QString &title,
                                        const QString &text,
                                        const QString &initialQuery,
                                        const std::vector<GpgME::Key> &selectedKeys,
                                        unsigned int keyUsage,
                                        bool extendedSelection,
                                        bool rememberChoice,
                                        QWidget *parent,
                                        bool modal)
     : QDialog(parent)
     , mSelectedKeys(selectedKeys)
     , mKeyUsage(keyUsage)
     , mSearchText(initialQuery)
     , mInitialQuery(initialQuery)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 KeySelectionDialog::KeySelectionDialog(const QString &title,
                                        const QString &text,
                                        const QString &initialQuery,
                                        unsigned int keyUsage,
                                        bool extendedSelection,
                                        bool rememberChoice,
                                        QWidget *parent,
                                        bool modal)
     : QDialog(parent)
     , mKeyUsage(keyUsage)
     , mSearchText(initialQuery)
     , mInitialQuery(initialQuery)
 {
     setWindowTitle(title);
     setModal(modal);
     init(rememberChoice, extendedSelection, text, initialQuery);
 }
 
 void KeySelectionDialog::setUpUI(Options options, const QString &initialQuery)
 {
     auto mainLayout = new QVBoxLayout(this);
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     mOkButton = buttonBox->button(QDialogButtonBox::Ok);
     mOkButton->setDefault(true);
     mOkButton->setShortcut(Qt::CTRL | Qt::Key_Return);
 
     mCheckSelectionTimer = new QTimer(this);
     mStartSearchTimer = new QTimer(this);
 
     QFrame *page = new QFrame(this);
     mainLayout->addWidget(page);
     mainLayout->addWidget(buttonBox);
 
     mTopLayout = new QVBoxLayout(page);
     mTopLayout->setContentsMargins(0, 0, 0, 0);
 
     mTextLabel = new QLabel(page);
     mTextLabel->setWordWrap(true);
 
     // Setting the size policy is necessary as a workaround for https://issues.kolab.org/issue4429
     // and http://bugreports.qt.nokia.com/browse/QTBUG-8740
     mTextLabel->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
     connect(mTextLabel, &QLabel::linkActivated, this, &KeySelectionDialog::slotStartCertificateManager);
     mTopLayout->addWidget(mTextLabel);
     mTextLabel->hide();
 
     QPushButton *const searchExternalPB = new QPushButton(i18n("Search for &External Certificates"), page);
     mTopLayout->addWidget(searchExternalPB, 0, Qt::AlignLeft);
     connect(searchExternalPB, &QAbstractButton::clicked, this, &KeySelectionDialog::slotStartSearchForExternalCertificates);
     if (initialQuery.isEmpty()) {
         searchExternalPB->hide();
     }
 
     auto hlay = new QHBoxLayout();
     mTopLayout->addLayout(hlay);
 
     auto le = new QLineEdit(page);
     le->setClearButtonEnabled(true);
     le->setText(initialQuery);
 
     QLabel *lbSearchFor = new QLabel(i18n("&Search for:"), page);
     lbSearchFor->setBuddy(le);
 
     hlay->addWidget(lbSearchFor);
     hlay->addWidget(le, 1);
     le->setFocus();
 
     connect(le, &QLineEdit::textChanged, this, [this](const QString &s) {
         slotSearch(s);
     });
     connect(mStartSearchTimer, &QTimer::timeout, this, &KeySelectionDialog::slotFilter);
 
     mKeyListView = new KeyListView(new ColumnStrategy(mKeyUsage), nullptr, page);
     mKeyListView->setObjectName(QStringLiteral("mKeyListView"));
     mKeyListView->header()->stretchLastSection();
     mKeyListView->setRootIsDecorated(true);
     mKeyListView->setSortingEnabled(true);
     mKeyListView->header()->setSortIndicatorShown(true);
     mKeyListView->header()->setSortIndicator(1, Qt::AscendingOrder); // sort by User ID
     if (options & ExtendedSelection) {
         mKeyListView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     }
     mTopLayout->addWidget(mKeyListView, 10);
 
     if (options & RememberChoice) {
         mRememberCB = new QCheckBox(i18n("&Remember choice"), page);
         mTopLayout->addWidget(mRememberCB);
         mRememberCB->setWhatsThis(
             i18n("<qt><p>If you check this box your choice will "
                  "be stored and you will not be asked again."
                  "</p></qt>"));
     }
 
     connect(mCheckSelectionTimer, &QTimer::timeout, this, [this]() {
         slotCheckSelection();
     });
     connectSignals();
 
     connect(mKeyListView, &KeyListView::doubleClicked, this, &KeySelectionDialog::slotTryOk);
     connect(mKeyListView, &KeyListView::contextMenu, this, &KeySelectionDialog::slotRMB);
 
     if (options & RereadKeys) {
         QPushButton *button = new QPushButton(i18n("&Reread Keys"));
         buttonBox->addButton(button, QDialogButtonBox::ActionRole);
         connect(button, &QPushButton::clicked, this, &KeySelectionDialog::slotRereadKeys);
     }
     if (options & ExternalCertificateManager) {
         QPushButton *button = new QPushButton(i18n("&Start Certificate Manager"));
         buttonBox->addButton(button, QDialogButtonBox::ActionRole);
         connect(button, &QPushButton::clicked, this, [this]() {
             slotStartCertificateManager();
         });
     }
     connect(mOkButton, &QPushButton::clicked, this, &KeySelectionDialog::slotOk);
     connect(buttonBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &KeySelectionDialog::slotCancel);
 
     mTopLayout->activate();
 
     if (qApp) {
         QSize dialogSize(sizeHint());
         KConfigGroup dialogConfig(KSharedConfig::openStateConfig(), "Key Selection Dialog");
         dialogSize = dialogConfig.readEntry("Dialog size", dialogSize);
         const QByteArray headerState = dialogConfig.readEntry("header", QByteArray());
         if (!headerState.isEmpty()) {
             mKeyListView->header()->restoreState(headerState);
         }
         resize(dialogSize);
     }
 }
 
 void KeySelectionDialog::init(bool rememberChoice, bool extendedSelection, const QString &text, const QString &initialQuery)
 {
     Options options = {RereadKeys, ExternalCertificateManager};
     options.setFlag(ExtendedSelection, extendedSelection);
     options.setFlag(RememberChoice, rememberChoice);
 
     setUpUI(options, initialQuery);
     setText(text);
 
     if (mKeyUsage & OpenPGPKeys) {
         mOpenPGPBackend = QGpgME::openpgp();
     }
     if (mKeyUsage & SMIMEKeys) {
         mSMIMEBackend = QGpgME::smime();
     }
 
     slotRereadKeys();
 }
 
 KeySelectionDialog::~KeySelectionDialog()
 {
     disconnectSignals();
     KConfigGroup dialogConfig(KSharedConfig::openStateConfig(), "Key Selection Dialog");
     dialogConfig.writeEntry("Dialog size", size());
     dialogConfig.writeEntry("header", mKeyListView->header()->saveState());
     dialogConfig.sync();
 }
 
 void KeySelectionDialog::setText(const QString &text)
 {
     mTextLabel->setText(text);
     mTextLabel->setVisible(!text.isEmpty());
 }
 
 void KeySelectionDialog::setKeys(const std::vector<GpgME::Key> &keys)
 {
     for (const GpgME::Key &key : keys) {
         mKeyListView->slotAddKey(key);
     }
 }
 
 void KeySelectionDialog::connectSignals()
 {
     if (mKeyListView->isMultiSelection()) {
         connect(mKeyListView, &QTreeWidget::itemSelectionChanged, this, &KeySelectionDialog::slotSelectionChanged);
     } else {
         connect(mKeyListView,
                 qOverload<KeyListViewItem *>(&KeyListView::selectionChanged),
                 this,
                 qOverload<KeyListViewItem *>(&KeySelectionDialog::slotCheckSelection));
     }
 }
 
 void KeySelectionDialog::disconnectSignals()
 {
     if (mKeyListView->isMultiSelection()) {
         disconnect(mKeyListView, &QTreeWidget::itemSelectionChanged, this, &KeySelectionDialog::slotSelectionChanged);
     } else {
         disconnect(mKeyListView,
                    qOverload<KeyListViewItem *>(&KeyListView::selectionChanged),
                    this,
                    qOverload<KeyListViewItem *>(&KeySelectionDialog::slotCheckSelection));
     }
 }
 
 const GpgME::Key &KeySelectionDialog::selectedKey() const
 {
     static const GpgME::Key null = GpgME::Key::null;
     if (mKeyListView->isMultiSelection() || !mKeyListView->selectedItem()) {
         return null;
     }
     return mKeyListView->selectedItem()->key();
 }
 
 QString KeySelectionDialog::fingerprint() const
 {
     return QLatin1String(selectedKey().primaryFingerprint());
 }
 
 QStringList KeySelectionDialog::fingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (const char *fpr = it->primaryFingerprint()) {
             result.push_back(QLatin1String(fpr));
         }
     }
     return result;
 }
 
 QStringList KeySelectionDialog::pgpKeyFingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (it->protocol() == GpgME::OpenPGP) {
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
         }
     }
     return result;
 }
 
 QStringList KeySelectionDialog::smimeFingerprints() const
 {
     QStringList result;
     for (auto it = mSelectedKeys.begin(); it != mSelectedKeys.end(); ++it) {
         if (it->protocol() == GpgME::CMS) {
             if (const char *fpr = it->primaryFingerprint()) {
                 result.push_back(QLatin1String(fpr));
             }
         }
     }
     return result;
 }
 
 void KeySelectionDialog::slotRereadKeys()
 {
     mKeyListView->clear();
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     // FIXME: save current selection
     if (mOpenPGPBackend) {
         startKeyListJobForBackend(mOpenPGPBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
     if (mSMIMEBackend) {
         startKeyListJobForBackend(mSMIMEBackend, std::vector<GpgME::Key>(), false /*non-validating*/);
     }
 
     if (mListJobCount == 0) {
         mKeyListView->setEnabled(true);
         KMessageBox::information(this,
                                  i18n("No backends found for listing keys. "
                                       "Check your installation."),
                                  i18n("Key Listing Failed"));
         connectSignals();
     }
 }
 
 void KeySelectionDialog::slotStartCertificateManager(const QString &query)
 {
     QStringList args;
 
     if (!query.isEmpty()) {
         args << QStringLiteral("--search") << query;
     }
     const QString exec = QStandardPaths::findExecutable(QStringLiteral("kleopatra"));
     if (exec.isEmpty()) {
         qCWarning(KLEO_UI_LOG) << "Could not find kleopatra executable in PATH";
         KMessageBox::error(this,
                            i18n("Could not start certificate manager; "
                                 "please check your installation."),
                            i18n("Certificate Manager Error"));
     } else {
         QProcess::startDetached(QStringLiteral("kleopatra"), args);
         qCDebug(KLEO_UI_LOG) << "\nslotStartCertManager(): certificate manager started.";
     }
 }
 
 #ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 #define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 static void showKeyListError(QWidget *parent, const GpgME::Error &err)
 {
     Q_ASSERT(err);
     const QString msg = i18n(
         "<qt><p>An error occurred while fetching "
         "the keys from the backend:</p>"
         "<p><b>%1</b></p></qt>",
         QString::fromLocal8Bit(err.asString()));
 
     KMessageBox::error(parent, msg, i18n("Key Listing Failed"));
 }
 #endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
 
 namespace
 {
 struct ExtractFingerprint {
     QString operator()(const GpgME::Key &key)
     {
         return QLatin1String(key.primaryFingerprint());
     }
 };
 }
 
 void KeySelectionDialog::startKeyListJobForBackend(const QGpgME::Protocol *backend, const std::vector<GpgME::Key> &keys, bool validate)
 {
     Q_ASSERT(backend);
     QGpgME::KeyListJob *job = backend->keyListJob(false, false, validate); // local, w/o sigs, validation as given
     if (!job) {
         return;
     }
 
     connect(job, &QGpgME::KeyListJob::result, this, &KeySelectionDialog::slotKeyListResult);
     if (validate) {
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotRefreshKey);
     } else {
         connect(job, &QGpgME::KeyListJob::nextKey, mKeyListView, &KeyListView::slotAddKey);
     }
 
     QStringList fprs;
     std::transform(keys.begin(), keys.end(), std::back_inserter(fprs), ExtractFingerprint());
     const GpgME::Error err = job->start(fprs, mKeyUsage & SecretKeys && !(mKeyUsage & PublicKeys));
 
     if (err) {
         return showKeyListError(this, err);
     }
 
 #ifndef LIBKLEO_NO_PROGRESSDIALOG
     // FIXME: create a MultiProgressDialog:
     (void)new ProgressDialog(job, validate ? i18n("Checking selected keys...") : i18n("Fetching keys..."), this);
 #endif
     ++mListJobCount;
 }
 
 static void selectKeys(KeyListView *klv, const std::vector<GpgME::Key> &selectedKeys)
 {
     klv->clearSelection();
     if (selectedKeys.empty()) {
         return;
     }
     for (auto it = selectedKeys.begin(); it != selectedKeys.end(); ++it) {
         if (KeyListViewItem *item = klv->itemByFingerprint(it->primaryFingerprint())) {
             item->setSelected(true);
         }
     }
 }
 
 void KeySelectionDialog::slotKeyListResult(const GpgME::KeyListResult &res)
 {
     if (res.error()) {
         showKeyListError(this, res.error());
     } else if (res.isTruncated()) {
         ++mTruncated;
     }
 
     if (--mListJobCount > 0) {
         return; // not yet finished...
     }
 
     if (mTruncated > 0) {
         KMessageBox::information(this,
                                  i18np("<qt>One backend returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        "<qt>%1 backends returned truncated output.<p>"
                                        "Not all available keys are shown</p></qt>",
                                        mTruncated),
                                  i18n("Key List Result"));
     }
 
     mKeyListView->flushKeys();
 
     mKeyListView->setEnabled(true);
     mListJobCount = mTruncated = 0;
     mKeysToCheck.clear();
 
     selectKeys(mKeyListView, mSelectedKeys);
 
     slotFilter();
 
     connectSignals();
 
     slotSelectionChanged();
 
     // restore the saved position of the contents
     mKeyListView->verticalScrollBar()->setValue(mSavedOffsetY);
     mSavedOffsetY = 0;
 }
 
 void KeySelectionDialog::slotSelectionChanged()
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotSelectionChanged()";
 
     // (re)start the check selection timer. Checking the selection is delayed
     // because else drag-selection doesn't work very good (checking key trust
     // is slow).
     mCheckSelectionTimer->start(sCheckSelectionDelay);
 }
 
 namespace
 {
 struct AlreadyChecked {
     bool operator()(const GpgME::Key &key) const
     {
         return key.keyListMode() & GpgME::Validate;
     }
 };
 }
 
 void KeySelectionDialog::slotCheckSelection(KeyListViewItem *item)
 {
     qCDebug(KLEO_UI_LOG) << "KeySelectionDialog::slotCheckSelection()";
 
     mCheckSelectionTimer->stop();
 
     mSelectedKeys.clear();
 
     if (!mKeyListView->isMultiSelection()) {
         if (item) {
             mSelectedKeys.push_back(item->key());
         }
     }
 
     for (KeyListViewItem *it = mKeyListView->firstChild(); it; it = it->nextSibling()) {
         if (it->isSelected()) {
             mSelectedKeys.push_back(it->key());
         }
     }
 
     mKeysToCheck.clear();
     std::remove_copy_if(mSelectedKeys.begin(), mSelectedKeys.end(), std::back_inserter(mKeysToCheck), AlreadyChecked());
     if (mKeysToCheck.empty()) {
         mOkButton->setEnabled(!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage));
         return;
     }
 
     // performed all fast checks - now for validating key listing:
     startValidatingKeyListing();
 }
 
 void KeySelectionDialog::startValidatingKeyListing()
 {
     if (mKeysToCheck.empty()) {
         return;
     }
 
     mListJobCount = 0;
     mTruncated = 0;
     mSavedOffsetY = mKeyListView->verticalScrollBar()->value();
 
     disconnectSignals();
     mKeyListView->setEnabled(false);
 
     std::vector<GpgME::Key> smime;
     std::vector<GpgME::Key> openpgp;
     for (std::vector<GpgME::Key>::const_iterator it = mKeysToCheck.begin(); it != mKeysToCheck.end(); ++it) {
         if (it->protocol() == GpgME::OpenPGP) {
             openpgp.push_back(*it);
         } else {
             smime.push_back(*it);
         }
     }
 
     if (!openpgp.empty()) {
         Q_ASSERT(mOpenPGPBackend);
         startKeyListJobForBackend(mOpenPGPBackend, openpgp, true /*validate*/);
     }
     if (!smime.empty()) {
         Q_ASSERT(mSMIMEBackend);
         startKeyListJobForBackend(mSMIMEBackend, smime, true /*validate*/);
     }
 
     Q_ASSERT(mListJobCount > 0);
 }
 
 bool KeySelectionDialog::rememberSelection() const
 {
     return mRememberCB && mRememberCB->isChecked();
 }
 
 void KeySelectionDialog::slotRMB(KeyListViewItem *item, const QPoint &p)
 {
     if (!item) {
         return;
     }
 
     mCurrentContextMenuItem = item;
 
     QMenu menu;
     menu.addAction(i18n("Recheck Key"), this, &KeySelectionDialog::slotRecheckKey);
     menu.exec(p);
 }
 
 void KeySelectionDialog::slotRecheckKey()
 {
     if (!mCurrentContextMenuItem || mCurrentContextMenuItem->key().isNull()) {
         return;
     }
 
     mKeysToCheck.clear();
     mKeysToCheck.push_back(mCurrentContextMenuItem->key());
 }
 
 void KeySelectionDialog::slotTryOk()
 {
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         slotOk();
     }
 }
 
 void KeySelectionDialog::slotOk()
 {
     if (mCheckSelectionTimer->isActive()) {
         slotCheckSelection();
     }
 #if 0 // Laurent I don't understand why we returns here.
     // button could be disabled again after checking the selected key1
     if (!mSelectedKeys.empty() && checkKeyUsage(mSelectedKeys, mKeyUsage)) {
         return;
     }
 #endif
     mStartSearchTimer->stop();
     accept();
 }
 
 void KeySelectionDialog::slotCancel()
 {
     mCheckSelectionTimer->stop();
     mStartSearchTimer->stop();
     reject();
 }
 
 void KeySelectionDialog::slotSearch(const QString &text)
 {
     mSearchText = text.trimmed().toUpper();
     slotSearch();
 }
 
 void KeySelectionDialog::slotSearch()
 {
     mStartSearchTimer->setSingleShot(true);
     mStartSearchTimer->start(sCheckSelectionDelay);
 }
 
 void KeySelectionDialog::slotFilter()
 {
     if (mSearchText.isEmpty()) {
         showAllItems();
         return;
     }
 
     // OK, so we need to filter:
     QRegExp keyIdRegExp(QLatin1String("(?:0x)?[A-F0-9]{1,8}"), Qt::CaseInsensitive);
     if (keyIdRegExp.exactMatch(mSearchText)) {
         if (mSearchText.startsWith(QLatin1String("0X")))
         // search for keyID only:
         {
             filterByKeyID(mSearchText.mid(2));
         } else
         // search for UID and keyID:
         {
             filterByKeyIDOrUID(mSearchText);
         }
     } else {
         // search in UID:
         filterByUID(mSearchText);
     }
 }
 
 void KeySelectionDialog::filterByKeyID(const QString &keyID)
 {
     Q_ASSERT(keyID.length() <= 8);
     Q_ASSERT(!keyID.isEmpty()); // regexp in slotFilter should prevent these
     if (keyID.isEmpty()) {
         showAllItems();
     } else {
         for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
             item->setHidden(!item->text(0).toUpper().startsWith(keyID));
         }
     }
 }
 
 static bool anyUIDMatches(const KeyListViewItem *item, QRegExp &rx)
 {
     if (!item) {
         return false;
     }
 
     const std::vector<GpgME::UserID> uids = item->key().userIDs();
     for (auto it = uids.begin(); it != uids.end(); ++it) {
         if (it->id() && rx.indexIn(QString::fromUtf8(it->id())) >= 0) {
             return true;
         }
     }
     return false;
 }
 
 void KeySelectionDialog::filterByKeyIDOrUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!item->text(0).toUpper().startsWith(str) && !anyUIDMatches(item, rx));
     }
 }
 
 void KeySelectionDialog::filterByUID(const QString &str)
 {
     Q_ASSERT(!str.isEmpty());
 
     // match beginnings of words:
     QRegExp rx(QLatin1String("\\b") + QRegExp::escape(str), Qt::CaseInsensitive);
 
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(!anyUIDMatches(item, rx));
     }
 }
 
 void KeySelectionDialog::showAllItems()
 {
     for (KeyListViewItem *item = mKeyListView->firstChild(); item; item = item->nextSibling()) {
         item->setHidden(false);
     }
 }
diff --git a/tests/test_keylister.cpp b/tests/test_keylister.cpp
index adc252950..e2d7e1a7a 100644
--- a/tests/test_keylister.cpp
+++ b/tests/test_keylister.cpp
@@ -1,154 +1,160 @@
 /*
     test_keylister.cpp
 
     This file is part of libkleopatra's test suite.
     SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-only
 */
 
 #include "test_keylister.h"
 
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/protocol.h>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <KAboutData>
 
 #include <QDebug>
 
 #include <QMessageBox>
 #include <QStringList>
 #include <QTimer>
 
 #include <KLocalizedString>
 #include <QApplication>
 #include <QCommandLineParser>
 #include <chrono>
 
 using namespace std::chrono_literals;
 
 namespace
 {
 class TestColumnStrategy : public Kleo::KeyListView::ColumnStrategy
 {
 public:
     ~TestColumnStrategy() override
     {
     }
     QString title(int col) const override;
     QString toolTip(const GpgME::Key &key, int col) const override;
     QString text(const GpgME::Key &key, int col) const override;
+    QString accessibleText(const GpgME::Key &key, int col) const override;
 };
 
 QString TestColumnStrategy::title(int col) const
 {
     switch (col) {
     case 0:
         return QStringLiteral("Subject");
     case 1:
         return QStringLiteral("EMail");
     case 2:
         return QStringLiteral("Issuer");
     case 3:
         return QStringLiteral("Serial");
     case 4:
         return QStringLiteral("Protocol");
     case 5:
         return QStringLiteral("Validity");
     default:
         return QString();
     }
 }
 
 QString TestColumnStrategy::toolTip(const GpgME::Key &key, int) const
 {
     return QStringLiteral("Fingerprint: ") + QString::fromUtf8(key.primaryFingerprint());
 }
 
 QString TestColumnStrategy::text(const GpgME::Key &key, int col) const
 {
     if (key.isNull()) {
         return QStringLiteral("<null>");
     }
     switch (col) {
     case 0:
         return QString::fromUtf8(key.userID(0).id());
     case 1:
         return QString::fromUtf8(key.userID(0).email());
     case 2:
         return QString::fromUtf8(key.issuerName());
     case 3:
         return QString::fromLatin1(key.issuerSerial());
     case 4:
         return QString::fromLatin1(key.protocolAsString());
     case 5:
         return QString(QLatin1Char(key.userID(0).validityAsString()));
     default:
         return QString();
     }
 }
+
+QString TestColumnStrategy::accessibleText(const GpgME::Key &, int) const
+{
+    return {};
+}
 }
 
 CertListView::CertListView(QWidget *parent, Qt::WindowFlags f)
     : Kleo::KeyListView(new TestColumnStrategy(), nullptr, parent, f)
 {
     setHierarchical(true);
     setRootIsDecorated(true);
 }
 
 CertListView::~CertListView()
 {
 }
 
 void CertListView::slotResult(const GpgME::KeyListResult &result)
 {
     qDebug() << "CertListView::slotResult()";
     if (result.isNull()) {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("KeyListResult is null!"));
     } else if (result.error()) {
         QMessageBox::critical(this,
                               QStringLiteral("Key Listing Result"),
                               QStringLiteral("KeyListResult Error: %1").arg(QString::fromLatin1(result.error().asString())));
     } else if (result.isTruncated()) {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("KeyListResult is truncated!"));
     } else {
         QMessageBox::information(this, QStringLiteral("Key Listing Result"), QStringLiteral("Key listing successful"));
     }
 }
 
 void CertListView::slotStart()
 {
     qDebug() << "CertListView::slotStart()";
     QGpgME::KeyListJob *job = QGpgME::smime()->keyListJob(false);
     Q_ASSERT(job);
     QObject::connect(job, &QGpgME::KeyListJob::nextKey, this, &CertListView::slotAddKey);
     QObject::connect(job, &QGpgME::KeyListJob::result, this, &CertListView::slotResult);
 #if 0
     QStringList l;
     l << "Marc";
     job->start(l, false);
 #else
     job->start(QStringList(), false);
 #endif
 }
 
 int main(int argc, char **argv)
 {
     QApplication app(argc, argv);
     KAboutData aboutData(QStringLiteral("test_keylister"), i18n("KeyLister Test"), QStringLiteral("0.1"));
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     auto clv = new CertListView;
     clv->show();
 
     QTimer::singleShot(5s, clv, &CertListView::slotStart);
 
     return app.exec();
 }