Revision control
Copy as Markdown
// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qspimatchrulematcher_p.h"
#if QT_CONFIG(accessibility)
#include "atspiadaptor_p.h"
#include "qspi_constant_mappings_p.h"
QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals;
Q_STATIC_LOGGING_CATEGORY(lcAccessibilityAtspi, "qt.accessibility.atspi")
QSpiMatchRuleMatcher::QSpiMatchRuleMatcher(const QSpiMatchRule &matchRule)
: m_states(spiStatesFromSpiStateSet(matchRule.states)),
m_stateMatchType(matchRule.stateMatchType),
m_attributes(matchRule.attributes),
m_attributeMatchType(matchRule.attributeMatchType),
m_roleMatchType(matchRule.roleMatchType),
m_interfaceMatchType(matchRule.interfaceMatchType)
{
// extract roles encoded in bitset stored in multiple 32 bit integers
for (qsizetype i = 0; i < matchRule.roles.size(); ++i) {
const auto role = matchRule.roles.at(i);
for (int j = 0; j < 32; j++) {
if (role & (1 << j)) {
const auto atspiRole = i * 32 + j;
if (atspiRole < ATSPI_ROLE_LAST_DEFINED)
m_roles.insert(AtspiRole(atspiRole));
else
qCWarning(lcAccessibilityAtspi)
<< "Ignoring invalid AT-SPI role value" << atspiRole;
}
}
}
// use qualified interface names to match what AtSpiAdaptor::accessibleInterfaces returns
m_interfaces.reserve(matchRule.interfaces.size());
for (const QString &ifaceName : matchRule.interfaces)
m_interfaces.push_back("org.a11y.atspi."_L1 + ifaceName);
}
bool QSpiMatchRuleMatcher::matchAttributes(QAccessibleInterface &iface) const
{
switch (m_attributeMatchType) {
case ATSPI_Collection_MATCH_EMPTY:
if (m_attributes.empty())
return AtSpiAdaptor::getAttributes(&iface).isEmpty();
[[fallthrough]];
case ATSPI_Collection_MATCH_ALL: {
if (m_attributes.empty())
return true;
const QSpiAttributeSet attributes = AtSpiAdaptor::getAttributes(&iface);
for (const auto &[key, value] : m_attributes.asKeyValueRange()) {
if (!attributes.contains(key) || attributes[key] != value)
return false;
}
return true;
}
case ATSPI_Collection_MATCH_ANY: {
const QSpiAttributeSet attributes = AtSpiAdaptor::getAttributes(&iface);
for (const auto &[key, value] : m_attributes.asKeyValueRange()) {
if (attributes.contains(key) && attributes[key] == value)
return true;
}
return false;
}
case ATSPI_Collection_MATCH_NONE: {
const QSpiAttributeSet attributes = AtSpiAdaptor::getAttributes(&iface);
for (const auto &[key, value] : m_attributes.asKeyValueRange()) {
if (attributes.contains(key) && attributes[key] == value)
return false;
}
return true;
}
default:
qCWarning(lcAccessibilityAtspi)
<< "QSpiMatchRuleMatcher::matchAttributes called with invalid match type "
<< m_attributeMatchType;
return false;
}
}
bool QSpiMatchRuleMatcher::matchInterfaces(QAccessibleInterface &iface) const
{
switch (m_interfaceMatchType) {
case ATSPI_Collection_MATCH_EMPTY:
if (m_interfaces.empty())
return AtSpiAdaptor::accessibleInterfaces(&iface).isEmpty();
[[fallthrough]];
case ATSPI_Collection_MATCH_ALL: {
if (m_interfaces.empty())
return true;
const QStringList interfaces = AtSpiAdaptor::accessibleInterfaces(&iface);
for (const QString &atSpiInterface : m_interfaces) {
if (!interfaces.contains(atSpiInterface))
return false;
}
return true;
}
case ATSPI_Collection_MATCH_ANY: {
const QStringList interfaces = AtSpiAdaptor::accessibleInterfaces(&iface);
for (const QString &atSpiInterface : m_interfaces) {
if (interfaces.contains(atSpiInterface))
return true;
}
return false;
}
case ATSPI_Collection_MATCH_NONE: {
const QStringList interfaces = AtSpiAdaptor::accessibleInterfaces(&iface);
for (const QString &atSpiInterface : m_interfaces) {
if (interfaces.contains(atSpiInterface))
return false;
}
return true;
}
default:
qCWarning(lcAccessibilityAtspi)
<< "QSpiMatchRuleMatcher::matchInterfaces called with invalid match type "
<< m_interfaceMatchType;
return false;
}
}
bool QSpiMatchRuleMatcher::matchRoles(QAccessibleInterface &iface) const
{
switch (m_roleMatchType) {
case ATSPI_Collection_MATCH_EMPTY:
if (m_roles.empty())
// accessible always has exactly one role, i.e. can't have no roles
return false;
[[fallthrough]];
case ATSPI_Collection_MATCH_ALL:
if (m_roles.empty())
return true;
if (m_roles.size() > 1)
// accessible only has a single role
return false;
[[fallthrough]];
case ATSPI_Collection_MATCH_ANY:
return m_roles.find(AtSpiAdaptor::getRole(&iface)) != m_roles.end();
case ATSPI_Collection_MATCH_NONE:
return m_roles.find(AtSpiAdaptor::getRole(&iface)) == m_roles.end();
default:
qCWarning(lcAccessibilityAtspi)
<< "QSpiMatchRuleMatcher::matchRoles called with invalid match type "
<< m_roleMatchType;
return false;
}
}
bool QSpiMatchRuleMatcher::matchStates(QAccessibleInterface &iface) const
{
switch (m_stateMatchType) {
case ATSPI_Collection_MATCH_EMPTY:
if (m_states == 0)
return spiStatesFromQState(iface.state()) == 0;
[[fallthrough]];
case ATSPI_Collection_MATCH_ALL:
return (spiStatesFromQState(iface.state()) & m_states) == m_states;
case ATSPI_Collection_MATCH_ANY:
return (spiStatesFromQState(iface.state()) & m_states) != 0;
case ATSPI_Collection_MATCH_NONE:
return (spiStatesFromQState(iface.state()) & m_states) == 0;
default:
qCWarning(lcAccessibilityAtspi)
<< "QSpiMatchRuleMatcher::matchStates called with invalid match type "
<< m_stateMatchType;
return false;
}
}
bool QSpiMatchRuleMatcher::match(QAccessibleInterface &iface) const
{
return matchRoles(iface) && matchStates(iface) && matchInterfaces(iface)
&& matchAttributes(iface);
}
QT_END_NAMESPACE
#endif // QT_CONFIG(accessibility)