diff --git a/qt/pinentrydialog.cpp b/qt/pinentrydialog.cpp
index 73caca6..b43ede0 100644
--- a/qt/pinentrydialog.cpp
+++ b/qt/pinentrydialog.cpp
@@ -1,721 +1,749 @@
 /* pinentrydialog.cpp - A (not yet) secure Qt 4 dialog for PIN entry.
  * Copyright (C) 2002, 2008 Klarälvdalens Datakonsult AB (KDAB)
  * Copyright 2007 Ingo Klöcker
  * Copyright 2016 Intevation GmbH
- * Copyright (C) 2021 g10 Code GmbH
+ * Copyright (C) 2021, 2022 g10 Code GmbH
  *
  * Written by Steffen Hansen <steffen@klaralvdalens-datakonsult.se>.
  * Modified by Andre Heinecke <aheinecke@intevation.de>
  * Software engineering by Ingo Klöcker <dev@ingo-kloecker.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: GPL-2.0+
  */
 
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
 
 #include "pinentrydialog.h"
 
 #include "accessibility.h"
 #include "capslock.h"
 #include "pinlineedit.h"
 #include "util.h"
 
 #include <QGridLayout>
 #include <QProgressBar>
 #include <QApplication>
 #include <QFontMetrics>
 #include <QStyle>
 #include <QPainter>
 #include <QPushButton>
 #include <QDialogButtonBox>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QPalette>
 #include <QLineEdit>
 #include <QAction>
 #include <QCheckBox>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QMessageBox>
 #include <QRegularExpression>
 #include <QAccessible>
 
 #include <QDebug>
 
 #ifdef Q_OS_WIN
 #include <windows.h>
 #if QT_VERSION >= 0x050700
 #include <QtPlatformHeaders/QWindowsWindowFunctions>
 #endif
 #endif
 
 void raiseWindow(QWidget *w)
 {
 #ifdef Q_OS_WIN
 #if QT_VERSION >= 0x050700
     QWindowsWindowFunctions::setWindowActivationBehavior(
             QWindowsWindowFunctions::AlwaysActivateWindow);
 #endif
 #endif
     w->setWindowState((w->windowState() & ~Qt::WindowMinimized) | Qt::WindowActive);
     w->activateWindow();
     w->raise();
 }
 
 QPixmap icon(QStyle::StandardPixmap which)
 {
     QPixmap pm = qApp->windowIcon().pixmap(48, 48);
 
     if (which != QStyle::SP_CustomBase) {
         const QIcon ic = qApp->style()->standardIcon(which);
         QPainter painter(&pm);
         const int emblemSize = 22;
         painter.drawPixmap(pm.width() - emblemSize, 0,
                            ic.pixmap(emblemSize, emblemSize));
     }
 
     return pm;
 }
 
 void PinEntryDialog::slotTimeout()
 {
     _timed_out = true;
     reject();
 }
 
 PinEntryDialog::PinEntryDialog(QWidget *parent, const char *name,
                                int timeout, bool modal, bool enable_quality_bar,
                                const QString &repeatString,
                                const QString &visibilityTT,
                                const QString &hideTT)
     : QDialog(parent),
       mRepeat(NULL),
       mRepeatError{nullptr},
       _grabbed(false),
       _have_quality_bar{enable_quality_bar},
       _disable_echo_allowed(true),
       mEnforceConstraints(false),
       mFormatPassphrase{false},
       mVisibilityTT(visibilityTT),
       mHideTT(hideTT),
       mVisiActionEdit(NULL),
       mGenerateButton{nullptr},
       mVisiCB(NULL),
       mFormattedPassphraseHint(NULL),
       mFormattedPassphraseHintSpacer(NULL),
       mCapsLockHint(NULL),
       mConstraintsHint(NULL)
 {
     _timed_out = false;
 
     if (modal) {
         setWindowModality(Qt::ApplicationModal);
     }
 
     QPalette redTextPalette;
     redTextPalette.setColor(QPalette::WindowText, Qt::red);
 
     auto *const mainLayout = new QVBoxLayout{this};
 
     auto *const hbox = new QHBoxLayout;
 
     _icon = new QLabel(this);
     _icon->setPixmap(icon());
     hbox->addWidget(_icon, 0, Qt::AlignVCenter | Qt::AlignLeft);
 
     auto *const grid = new QGridLayout;
     int row = 1;
 
     _error = new QLabel(this);
     _error->setPalette(redTextPalette);
     _error->hide();
     grid->addWidget(_error, row, 1, 1, 2);
 
     row++;
     _desc = new QLabel(this);
     _desc->hide();
     grid->addWidget(_desc,  row, 1, 1, 2);
 
     row++;
     mCapsLockHint = new QLabel(this);
     mCapsLockHint->setPalette(redTextPalette);
     mCapsLockHint->setAlignment(Qt::AlignCenter);
     mCapsLockHint->setVisible(false);
     grid->addWidget(mCapsLockHint, row, 1, 1, 2);
 
     row++;
     {
         _prompt = new QLabel(this);
         _prompt->hide();
         grid->addWidget(_prompt, row, 1);
 
         const auto l = new QHBoxLayout;
         _edit = new PinLineEdit(this);
         _edit->setMaxLength(256);
         _edit->setMinimumWidth(_edit->fontMetrics().averageCharWidth()*20 + 48);
         _edit->setEchoMode(QLineEdit::Password);
         _prompt->setBuddy(_edit);
         l->addWidget(_edit, 1);
 
         if (!repeatString.isNull()) {
             mGenerateButton = new QPushButton{this};
             mGenerateButton->setIcon(QIcon(QLatin1String(":/icons/password-generate")));
             mGenerateButton->setVisible(false);
             l->addWidget(mGenerateButton);
         }
         grid->addLayout(l, row, 2);
     }
 
     /* Set up the show password action */
     const QIcon visibilityIcon = QIcon(QLatin1String(":/icons/visibility.svg"));
     const QIcon hideIcon = QIcon(QLatin1String(":/icons/hint.svg"));
 #if QT_VERSION >= 0x050200
     if (!visibilityIcon.isNull() && !hideIcon.isNull()) {
         mVisiActionEdit = _edit->addAction(visibilityIcon, QLineEdit::TrailingPosition);
         mVisiActionEdit->setVisible(false);
         mVisiActionEdit->setToolTip(mVisibilityTT);
     } else
 #endif
     {
         if (!mVisibilityTT.isNull()) {
             row++;
             mVisiCB = new QCheckBox{mVisibilityTT, this};
             grid->addWidget(mVisiCB, row, 1, 1, 2, Qt::AlignLeft);
         }
     }
 
     row++;
     mConstraintsHint = new QLabel{this};
     mConstraintsHint->setVisible(false);
     grid->addWidget(mConstraintsHint, row, 2);
 
     row++;
     mFormattedPassphraseHintSpacer = new QLabel{this};
     mFormattedPassphraseHintSpacer->setVisible(false);
     mFormattedPassphraseHint = new QLabel{this};
     mFormattedPassphraseHint->setVisible(false);
     grid->addWidget(mFormattedPassphraseHintSpacer, row, 1);
     grid->addWidget(mFormattedPassphraseHint, row, 2);
 
     if (!repeatString.isNull()) {
         row++;
         auto repeatLabel = new QLabel{this};
         repeatLabel->setText(repeatString);
         grid->addWidget(repeatLabel, row, 1);
 
         mRepeat = new PinLineEdit(this);
         mRepeat->setMaxLength(256);
         mRepeat->setEchoMode(QLineEdit::Password);
         repeatLabel->setBuddy(mRepeat);
         grid->addWidget(mRepeat, row, 2);
 
         row++;
         mRepeatError = new QLabel{this};
         mRepeatError->setPalette(redTextPalette);
         mRepeatError->hide();
         grid->addWidget(mRepeatError, row, 2);
     }
 
     if (enable_quality_bar) {
         row++;
         _quality_bar_label = new QLabel(this);
         _quality_bar_label->setAlignment(Qt::AlignVCenter);
         grid->addWidget(_quality_bar_label, row, 1);
 
         _quality_bar = new QProgressBar(this);
         _quality_bar->setAlignment(Qt::AlignCenter);
         _quality_bar_label->setBuddy(_quality_bar);
         grid->addWidget(_quality_bar, row, 2);
     }
 
     hbox->addLayout(grid, 1);
     mainLayout->addLayout(hbox);
 
     QDialogButtonBox *const buttons = new QDialogButtonBox(this);
     buttons->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     _ok = buttons->button(QDialogButtonBox::Ok);
     _cancel = buttons->button(QDialogButtonBox::Cancel);
 
     if (style()->styleHint(QStyle::SH_DialogButtonBox_ButtonsHaveIcons)) {
         _ok->setIcon(style()->standardIcon(QStyle::SP_DialogOkButton));
         _cancel->setIcon(style()->standardIcon(QStyle::SP_DialogCancelButton));
     }
 
     mainLayout->addStretch(1);
     mainLayout->addWidget(buttons);
     mainLayout->setSizeConstraint(QLayout::SetFixedSize);
 
     if (timeout > 0) {
         _timer = new QTimer(this);
         connect(_timer, SIGNAL(timeout()), this, SLOT(slotTimeout()));
         _timer->start(timeout * 1000);
     } else {
         _timer = NULL;
     }
 
     connect(buttons, SIGNAL(accepted()), this, SLOT(onAccept()));
     connect(buttons, SIGNAL(rejected()), this, SLOT(reject()));
     connect(_edit, SIGNAL(textChanged(QString)),
             this, SLOT(updateQuality(QString)));
     connect(_edit, SIGNAL(textChanged(QString)),
             this, SLOT(textChanged(QString)));
     connect(_edit, SIGNAL(backspacePressed()),
             this, SLOT(onBackspace()));
     if (mGenerateButton) {
         connect(mGenerateButton, &QPushButton::clicked,
                 this, &PinEntryDialog::generatePin);
     }
     if (mVisiActionEdit) {
         connect(mVisiActionEdit, SIGNAL(triggered()),
                 this, SLOT(toggleVisibility()));
     }
     if (mVisiCB) {
         connect(mVisiCB, SIGNAL(toggled(bool)),
                 this, SLOT(toggleVisibility()));
     }
     if (mRepeat) {
         connect(mRepeat, SIGNAL(textChanged(QString)),
                 this, SLOT(textChanged(QString)));
         connect(_edit, &QLineEdit::returnPressed,
                 this, [this] { mRepeat->setFocus(); });
     }
 
     auto capsLockWatcher = new CapsLockWatcher{this};
     connect(capsLockWatcher, &CapsLockWatcher::stateChanged,
             this, [this] (bool locked) {
                 mCapsLockHint->setVisible(locked);
             });
 
     connect(qApp, SIGNAL(focusChanged(QWidget *, QWidget *)),
             this, SLOT(focusChanged(QWidget *, QWidget *)));
     connect(qApp, SIGNAL(applicationStateChanged(Qt::ApplicationState)),
             this, SLOT(checkCapsLock()));
 
     checkCapsLock();
 
+#ifndef QT_NO_ACCESSIBILITY
+    QAccessible::installActivationObserver(this);
+    accessibilityActiveChanged(QAccessible::isActive());
+#endif
+
 #if QT_VERSION >= 0x050000
     /* This is mostly an issue on Windows where this results
        in the pinentry popping up nicely with an animation and
        comes to front. It is not ifdefed for Windows only since
        window managers on Linux like KWin can also have this
        result in an animation when the pinentry is shown and
        not just popping it up.
     */
     if (qApp->platformName() != QLatin1String("wayland")) {
         setWindowState(Qt::WindowMinimized);
         QTimer::singleShot(0, this, [this] () {
             raiseWindow(this);
         });
     }
 #else
     activateWindow();
     raise();
 #endif
 }
 
+PinEntryDialog::~PinEntryDialog()
+{
+#ifndef QT_NO_ACCESSIBILITY
+    QAccessible::removeActivationObserver(this);
+#endif
+}
+
 void PinEntryDialog::keyReleaseEvent(QKeyEvent *event)
 {
     QDialog::keyReleaseEvent(event);
     checkCapsLock();
 }
 
 void PinEntryDialog::showEvent(QShowEvent *event)
 {
     QDialog::showEvent(event);
     _edit->setFocus();
 }
 
 void PinEntryDialog::setDescription(const QString &txt)
 {
     _desc->setVisible(!txt.isEmpty());
     _desc->setText(txt);
     Accessibility::setDescription(_desc, txt);
     _icon->setPixmap(icon());
     setError(QString());
 }
 
 QString PinEntryDialog::description() const
 {
     return _desc->text();
 }
 
 void PinEntryDialog::setError(const QString &txt)
 {
     if (!txt.isNull()) {
         _icon->setPixmap(icon(QStyle::SP_MessageBoxCritical));
     }
     _error->setText(txt);
     Accessibility::setDescription(_error, txt);
     _error->setVisible(!txt.isEmpty());
 }
 
 QString PinEntryDialog::error() const
 {
     return _error->text();
 }
 
 void PinEntryDialog::setPin(const QString &txt)
 {
     _edit->setPin(txt);
 }
 
 QString PinEntryDialog::pin() const
 {
     return _edit->pin();
 }
 
 void PinEntryDialog::setPrompt(const QString &txt)
 {
     _prompt->setText(txt);
     _prompt->setVisible(!txt.isEmpty());
     if (txt.contains("PIN"))
       _disable_echo_allowed = false;
 }
 
 QString PinEntryDialog::prompt() const
 {
     return _prompt->text();
 }
 
 void PinEntryDialog::setOkText(const QString &txt)
 {
     _ok->setText(txt);
     Accessibility::setDescription(_ok, txt);
     _ok->setVisible(!txt.isEmpty());
 }
 
 void PinEntryDialog::setCancelText(const QString &txt)
 {
     _cancel->setText(txt);
     Accessibility::setDescription(_cancel, txt);
     _cancel->setVisible(!txt.isEmpty());
 }
 
 void PinEntryDialog::setQualityBar(const QString &txt)
 {
     if (_have_quality_bar) {
         _quality_bar_label->setText(txt);
         Accessibility::setDescription(_quality_bar_label, txt);
     }
 }
 
 void PinEntryDialog::setQualityBarTT(const QString &txt)
 {
     if (_have_quality_bar) {
         _quality_bar->setToolTip(txt);
     }
 }
 
 void PinEntryDialog::setGenpinLabel(const QString &txt)
 {
     if (!mGenerateButton) {
         return;
     }
     mGenerateButton->setVisible(!txt.isEmpty());
     if (!txt.isEmpty()) {
         Accessibility::setName(mGenerateButton, txt);
     }
 }
 
 void PinEntryDialog::setGenpinTT(const QString &txt)
 {
     if (mGenerateButton) {
         mGenerateButton->setToolTip(txt);
     }
 }
 
 void PinEntryDialog::setCapsLockHint(const QString &txt)
 {
     mCapsLockHint->setText(txt);
 }
 
 void PinEntryDialog::setFormattedPassphrase(const PinEntryDialog::FormattedPassphraseOptions &options)
 {
     mFormatPassphrase = options.formatPassphrase;
     mFormattedPassphraseHint->setText(QLatin1String("<html>") + options.hint.toHtmlEscaped() + QLatin1String("</html>"));
     Accessibility::setName(mFormattedPassphraseHint, options.hint);
     toggleFormattedPassphrase();
 }
 
 void PinEntryDialog::setConstraintsOptions(const ConstraintsOptions &options)
 {
     mEnforceConstraints = options.enforce;
     mConstraintsHint->setText(options.shortHint);
     mConstraintsHint->setToolTip(QLatin1String("<html>") +
                                  options.longHint.toHtmlEscaped().replace(QLatin1String("\n\n"), QLatin1String("<br>")) +
                                  QLatin1String("</html>"));
     Accessibility::setDescription(mConstraintsHint, options.longHint);
     mConstraintsErrorTitle = options.errorTitle;
 
     mConstraintsHint->setVisible(mEnforceConstraints && !options.shortHint.isEmpty());
 }
 
 void PinEntryDialog::toggleFormattedPassphrase()
 {
     const bool enableFormatting = mFormatPassphrase && _edit->echoMode() == QLineEdit::Normal;
     _edit->setFormattedPassphrase(enableFormatting);
     if (mRepeat) {
         mRepeat->setFormattedPassphrase(enableFormatting);
         const bool hintAboutToBeHidden = mFormattedPassphraseHint->isVisible() && !enableFormatting;
         if (hintAboutToBeHidden) {
             // set hint spacer to current height of hint label before hiding the hint
             mFormattedPassphraseHintSpacer->setMinimumHeight(mFormattedPassphraseHint->height());
             mFormattedPassphraseHintSpacer->setVisible(true);
         } else if (enableFormatting) {
             mFormattedPassphraseHintSpacer->setVisible(false);
         }
         mFormattedPassphraseHint->setVisible(enableFormatting);
     }
 }
 
 void PinEntryDialog::onBackspace()
 {
     cancelTimeout();
 
     if (_disable_echo_allowed) {
         _edit->setEchoMode(QLineEdit::NoEcho);
         if (mRepeat) {
             mRepeat->setEchoMode(QLineEdit::NoEcho);
         }
     }
 }
 
 void PinEntryDialog::updateQuality(const QString &txt)
 {
     int length;
     int percent;
     QPalette pal;
 
     _disable_echo_allowed = false;
 
     if (!_have_quality_bar || !_pinentry_info) {
         return;
     }
     const QByteArray utf8_pin = txt.toUtf8();
     const char *pin = utf8_pin.constData();
     length = strlen(pin);
     percent = length ? pinentry_inq_quality(_pinentry_info, pin, length) : 0;
     if (!length) {
         _quality_bar->reset();
     } else {
         pal = _quality_bar->palette();
         if (percent < 0) {
             pal.setColor(QPalette::Highlight, QColor("red"));
             percent = -percent;
         } else {
             pal.setColor(QPalette::Highlight, QColor("green"));
         }
         _quality_bar->setPalette(pal);
         _quality_bar->setValue(percent);
     }
 }
 
 void PinEntryDialog::setPinentryInfo(pinentry_t peinfo)
 {
     _pinentry_info = peinfo;
 }
 
 void PinEntryDialog::focusChanged(QWidget *old, QWidget *now)
 {
     // Grab keyboard. It might be a little weird to do it here, but it works!
     // Previously this code was in showEvent, but that did not work in Qt4.
     if (!_pinentry_info || _pinentry_info->grab) {
         if (_grabbed && old && (old == _edit || old == mRepeat)) {
             old->releaseKeyboard();
             _grabbed = false;
         }
         if (!_grabbed && now && (now == _edit || now == mRepeat)) {
             now->grabKeyboard();
             _grabbed = true;
         }
     }
     // make Ok the default button unless we have a repeat input field and
     // the first input field has focus now; this allows us to move the focus
     // to the repeat input field when the user presses Return in the first
     // input field; otherwise, the dialog would "press" Ok when it receives
     // the Return key press
     _ok->setDefault(!mRepeat || now != _edit);
 }
 
 void PinEntryDialog::textChanged(const QString &text)
 {
     Q_UNUSED(text);
 
     cancelTimeout();
 
     if (mVisiActionEdit && sender() == _edit) {
         mVisiActionEdit->setVisible(!_edit->pin().isEmpty());
     }
     if (mGenerateButton) {
         mGenerateButton->setVisible(
             _edit->pin().isEmpty()
 #ifndef QT_NO_ACCESSIBILITY
             && !mGenerateButton->accessibleName().isEmpty()
 #endif
         );
     }
 }
 
 void PinEntryDialog::generatePin()
 {
     unique_malloced_ptr<char> pin{pinentry_inq_genpin(_pinentry_info)};
     if (pin) {
         if (_edit->echoMode() == QLineEdit::Password) {
             if (mVisiActionEdit) {
                 mVisiActionEdit->trigger();
             }
             if (mVisiCB) {
                 mVisiCB->setChecked(true);
             }
         }
         const auto pinStr = QString::fromUtf8(pin.get());
         _edit->setPin(pinStr);
         mRepeat->setPin(pinStr);
         // explicitly focus the first input field and select the generated password
         _edit->setFocus();
         _edit->selectAll();
     }
 }
 
 void PinEntryDialog::toggleVisibility()
 {
     if (sender() != mVisiCB) {
         if (_edit->echoMode() == QLineEdit::Password) {
             if (mVisiActionEdit) {
                 mVisiActionEdit->setIcon(QIcon(QLatin1String(":/icons/hint.svg")));
                 mVisiActionEdit->setToolTip(mHideTT);
             }
             _edit->setEchoMode(QLineEdit::Normal);
             if (mRepeat) {
                 mRepeat->setEchoMode(QLineEdit::Normal);
             }
         } else {
             if (mVisiActionEdit) {
                 mVisiActionEdit->setIcon(QIcon(QLatin1String(":/icons/visibility.svg")));
                 mVisiActionEdit->setToolTip(mVisibilityTT);
             }
             _edit->setEchoMode(QLineEdit::Password);
             if (mRepeat) {
                 mRepeat->setEchoMode(QLineEdit::Password);
             }
         }
     } else {
         if (mVisiCB->isChecked()) {
             if (mRepeat) {
                 mRepeat->setEchoMode(QLineEdit::Normal);
             }
             _edit->setEchoMode(QLineEdit::Normal);
         } else {
             if (mRepeat) {
                 mRepeat->setEchoMode(QLineEdit::Password);
             }
             _edit->setEchoMode(QLineEdit::Password);
         }
     }
     toggleFormattedPassphrase();
 }
 
 QString PinEntryDialog::repeatedPin() const
 {
     if (mRepeat) {
         return mRepeat->pin();
     }
     return QString();
 }
 
 bool PinEntryDialog::timedOut() const
 {
     return _timed_out;
 }
 
 void PinEntryDialog::setRepeatErrorText(const QString &err)
 {
     if (mRepeatError) {
         mRepeatError->setText(err);
     }
 }
 
 void PinEntryDialog::cancelTimeout()
 {
     if (_timer) {
         _timer->stop();
     }
 }
 
 void PinEntryDialog::checkCapsLock()
 {
     const auto state = capsLockState();
     if (state != LockState::Unknown) {
         mCapsLockHint->setVisible(state == LockState::On);
     }
 }
 
 void PinEntryDialog::onAccept()
 {
     cancelTimeout();
 
     if (mRepeat && mRepeat->pin() != _edit->pin()) {
 #ifndef QT_NO_ACCESSIBILITY
         if (QAccessible::isActive()) {
             QMessageBox::information(this, mRepeatError->text(), mRepeatError->text());
         } else
 #endif
         {
             mRepeatError->setVisible(true);
         }
         return;
     }
 
     const auto result = checkConstraints();
     if (result != PassphraseNotOk) {
         accept();
     }
 }
 
+#ifndef QT_NO_ACCESSIBILITY
+void PinEntryDialog::accessibilityActiveChanged(bool active)
+{
+    // Allow text labels to get focus if accessibility is active
+    const auto focusPolicy = active ? Qt::TabFocus : Qt::NoFocus;
+    _error->setFocusPolicy(focusPolicy);
+    _desc->setFocusPolicy(focusPolicy);
+    mCapsLockHint->setFocusPolicy(focusPolicy);
+    mConstraintsHint->setFocusPolicy(focusPolicy);
+    mFormattedPassphraseHint->setFocusPolicy(focusPolicy);
+    if (mRepeatError) {
+        mRepeatError->setFocusPolicy(focusPolicy);
+    }
+}
+#endif
+
 PinEntryDialog::PassphraseCheckResult PinEntryDialog::checkConstraints()
 {
     if (!mEnforceConstraints) {
         return PassphraseNotChecked;
     }
 
     const auto passphrase = _edit->pin().toUtf8();
     unique_malloced_ptr<char> error{pinentry_inq_checkpin(
         _pinentry_info, passphrase.constData(), passphrase.size())};
 
     if (!error) {
         return PassphraseOk;
     }
 
     const auto messageLines = QString::fromUtf8(QByteArray::fromPercentEncoding(error.get())).split(QChar{'\n'});
     if (messageLines.isEmpty()) {
         // shouldn't happen because pinentry_inq_checkpin() either returns NULL or a non-empty string
         return PassphraseOk;
     }
     const auto firstLine = messageLines.first();
     const auto indexOfFirstNonEmptyAdditionalLine = messageLines.indexOf(QRegularExpression{QStringLiteral(".*\\S.*")}, 1);
     const auto additionalLines = indexOfFirstNonEmptyAdditionalLine > 0 ? messageLines.mid(indexOfFirstNonEmptyAdditionalLine).join(QChar{'\n'}) : QString{};
     QMessageBox messageBox{this};
     messageBox.setIcon(QMessageBox::Information);
     messageBox.setWindowTitle(mConstraintsErrorTitle);
     messageBox.setText(firstLine);
     messageBox.setInformativeText(additionalLines);
     messageBox.setStandardButtons(QMessageBox::Ok);
     messageBox.exec();
     return PassphraseNotOk;
 }
 
 #include "pinentrydialog.moc"
diff --git a/qt/pinentrydialog.h b/qt/pinentrydialog.h
index 549bafc..ef34ecd 100644
--- a/qt/pinentrydialog.h
+++ b/qt/pinentrydialog.h
@@ -1,170 +1,179 @@
 /* pinentrydialog.h - A (not yet) secure Qt 4 dialog for PIN entry.
  * Copyright (C) 2002, 2008 Klarälvdalens Datakonsult AB (KDAB)
  * Copyright 2007 Ingo Klöcker
  * Copyright 2016 Intevation GmbH
- * Copyright (C) 2021 g10 Code GmbH
+ * Copyright (C) 2021, 2022 g10 Code GmbH
  *
  * Written by Steffen Hansen <steffen@klaralvdalens-datakonsult.se>.
  * Modified by Andre Heinecke <aheinecke@intevation.de>
  * Software engineering by Ingo Klöcker <dev@ingo-kloecker.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: GPL-2.0+
  */
 
 #ifndef __PINENTRYDIALOG_H__
 #define __PINENTRYDIALOG_H__
 
+#include <QAccessible>
 #include <QDialog>
 #include <QStyle>
 #include <QTimer>
 
 #include "pinentry.h"
 
 class QLabel;
 class QPushButton;
 class QLineEdit;
 class PinLineEdit;
 class QString;
 class QProgressBar;
 class QCheckBox;
 class QAction;
 
 QPixmap icon(QStyle::StandardPixmap which = QStyle::SP_CustomBase);
 
 void raiseWindow(QWidget *w);
 
 class PinEntryDialog : public QDialog
+#ifndef QT_NO_ACCESSIBILITY
+    , public QAccessible::ActivationObserver
+#endif
 {
     Q_OBJECT
 
     Q_PROPERTY(QString description READ description WRITE setDescription)
     Q_PROPERTY(QString error READ error WRITE setError)
     Q_PROPERTY(QString pin READ pin WRITE setPin)
     Q_PROPERTY(QString prompt READ prompt WRITE setPrompt)
 public:
     struct FormattedPassphraseOptions
     {
         bool formatPassphrase;
         QString hint;
     };
     struct ConstraintsOptions
     {
         bool enforce;
         QString shortHint;
         QString longHint;
         QString errorTitle;
     };
 
     explicit PinEntryDialog(QWidget *parent = 0, const char *name = 0,
                             int timeout = 0, bool modal = false,
                             bool enable_quality_bar = false,
                             const QString &repeatString = QString(),
                             const QString &visibiltyTT = QString(),
                             const QString &hideTT = QString());
+    ~PinEntryDialog() override;
 
     void setDescription(const QString &);
     QString description() const;
 
     void setError(const QString &);
     QString error() const;
 
     void setPin(const QString &);
     QString pin() const;
 
     QString repeatedPin() const;
     void setRepeatErrorText(const QString &);
 
     void setPrompt(const QString &);
     QString prompt() const;
 
     void setOkText(const QString &);
     void setCancelText(const QString &);
 
     void setQualityBar(const QString &);
     void setQualityBarTT(const QString &);
 
     void setGenpinLabel(const QString &);
     void setGenpinTT(const QString &);
 
     void setCapsLockHint(const QString &);
 
     void setFormattedPassphrase(const FormattedPassphraseOptions &options);
 
     void setConstraintsOptions(const ConstraintsOptions &options);
 
     void setPinentryInfo(pinentry_t);
 
     bool timedOut() const;
 
 protected Q_SLOTS:
     void updateQuality(const QString &);
     void slotTimeout();
     void textChanged(const QString &);
     void focusChanged(QWidget *old, QWidget *now);
     void toggleVisibility();
     void onBackspace();
     void generatePin();
     void toggleFormattedPassphrase();
 
 protected:
     void keyReleaseEvent(QKeyEvent *event) override;
     /* reimp */ void showEvent(QShowEvent *event);
 
 private Q_SLOTS:
     void cancelTimeout();
     void checkCapsLock();
     void onAccept();
 
 private:
+#ifndef QT_NO_ACCESSIBILITY
+    void accessibilityActiveChanged(bool active) override;
+#endif
+
     enum PassphraseCheckResult {
         PassphraseNotChecked = -1,
         PassphraseNotOk = 0,
         PassphraseOk
     };
     PassphraseCheckResult checkConstraints();
 
 private:
     QLabel    *_icon;
     QLabel    *_desc;
     QLabel    *_error;
     QLabel    *_prompt;
     QLabel    *_quality_bar_label;
     QProgressBar *_quality_bar;
     PinLineEdit *_edit;
     PinLineEdit *mRepeat;
     QLabel      *mRepeatError;
     QPushButton *_ok;
     QPushButton *_cancel;
     bool       _grabbed;
     bool       _have_quality_bar;
     bool       _timed_out;
     bool       _disable_echo_allowed;
     bool       mEnforceConstraints;
     bool       mFormatPassphrase;
     pinentry_t _pinentry_info;
     QTimer    *_timer;
     QString    mVisibilityTT,
                mHideTT;
     QAction   *mVisiActionEdit;
     QPushButton *mGenerateButton;
     QCheckBox *mVisiCB;
     QLabel    *mFormattedPassphraseHint;
     QLabel    *mFormattedPassphraseHintSpacer;
     QLabel    *mCapsLockHint;
     QLabel    *mConstraintsHint;
     QString   mConstraintsErrorTitle;
 };
 
 #endif // __PINENTRYDIALOG_H__