blob: 96e34c4f8ce11efbf729926279cf29a56b42b14d [file] [log] [blame]
/*
* Copyright (C) 2021 Igalia S.L.
* Copyright (C) 2022 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "AccessibilityAtspi.h"
#if USE(ATSPI)
#include "AXObjectCache.h"
#include "AccessibilityAtspiEnums.h"
#include "AccessibilityAtspiInterfaces.h"
#include "AccessibilityObjectAtspi.h"
#include "AccessibilityRootAtspi.h"
#include <gio/gio.h>
#include <glib/gi18n-lib.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/SortedArrayMap.h>
#include <wtf/UUID.h>
#include <wtf/glib/RunLoopSourcePriority.h>
namespace WebCore {
AccessibilityAtspi& AccessibilityAtspi::singleton()
{
static NeverDestroyed<AccessibilityAtspi> atspi;
return atspi;
}
AccessibilityAtspi::AccessibilityAtspi()
: m_cacheUpdateTimer(RunLoop::main(), this, &AccessibilityAtspi::cacheUpdateTimerFired)
, m_cacheClearTimer(RunLoop::main(), this, &AccessibilityAtspi::cacheClearTimerFired)
{
m_cacheUpdateTimer.setPriority(RunLoopSourcePriority::RunLoopDispatcher);
m_cacheClearTimer.setPriority(RunLoopSourcePriority::ReleaseUnusedResourcesTimer);
}
void AccessibilityAtspi::connect(const String& busAddress)
{
if (busAddress.isEmpty())
return;
m_isConnecting = true;
g_dbus_connection_new_for_address(busAddress.utf8().data(),
static_cast<GDBusConnectionFlags>(G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION), nullptr, nullptr,
[](GObject*, GAsyncResult* result, gpointer userData) {
auto& atspi = *static_cast<AccessibilityAtspi*>(userData);
GUniqueOutPtr<GError> error;
atspi.didConnect(adoptGRef(g_dbus_connection_new_for_address_finish(result, &error.outPtr())));
if (error)
g_warning("Can't connect to a11y bus: %s", error->message);
}, this);
}
void AccessibilityAtspi::didConnect(GRefPtr<GDBusConnection>&& connection)
{
m_isConnecting = false;
m_connection = WTFMove(connection);
if (!m_connection)
return;
for (auto& pendingRegistration : m_pendingRootRegistrations)
registerRoot(pendingRegistration.root, WTFMove(pendingRegistration.interfaces), WTFMove(pendingRegistration.completionHandler));
m_pendingRootRegistrations.clear();
initializeRegistry();
}
void AccessibilityAtspi::initializeRegistry()
{
RELEASE_ASSERT(m_connection);
g_dbus_proxy_new(m_connection.get(), G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, nullptr,
"org.a11y.atspi.Registry", "/org/a11y/atspi/registry", "org.a11y.atspi.Registry", nullptr, [](GObject*, GAsyncResult* result, gpointer userData) {
auto& atspi = *static_cast<AccessibilityAtspi*>(userData);
GUniqueOutPtr<GError> error;
atspi.m_registry = adoptGRef(g_dbus_proxy_new_finish(result, &error.outPtr()));
if (!atspi.m_registry) {
g_warning("Failed to connect to atspi registry: %s\n", error->message);
return;
}
g_signal_connect(atspi.m_registry.get(), "g-signal", G_CALLBACK(+[](GDBusProxy*, char*, char* signal, GVariant* parameters, AccessibilityAtspi* atspi) {
const char* dbusName;
const char* eventName;
if (!g_strcmp0(signal, "EventListenerRegistered")) {
g_variant_get(parameters, "(&s&s@as)", &dbusName, &eventName, nullptr);
atspi->addEventListener(dbusName, eventName);
} else if (!g_strcmp0(signal, "EventListenerDeregistered")) {
g_variant_get(parameters, "(&s&s)", &dbusName, &eventName);
atspi->removeEventListener(dbusName, eventName);
}
}), &atspi);
g_dbus_proxy_call(atspi.m_registry.get(), "GetRegisteredEvents", nullptr, G_DBUS_CALL_FLAGS_NONE, -1, nullptr, [](GObject* proxy, GAsyncResult* result, gpointer userData) {
auto& atspi = *static_cast<AccessibilityAtspi*>(userData);
GUniqueOutPtr<GError> error;
GRefPtr<GVariant> resultVariant = adoptGRef(g_dbus_proxy_call_finish(G_DBUS_PROXY(proxy), result, &error.outPtr()));
if (!resultVariant) {
g_warning("Failed to get atspi registered event listeners: %s\n", error->message);
return;
}
GRefPtr<GVariant> events;
g_variant_get(resultVariant.get(), "(@a(ss))", &events.outPtr());
GVariantIter iter;
g_variant_iter_init(&iter, events.get());
const char* dbusName;
const char* eventName;
while (g_variant_iter_loop(&iter, "(&s&s)", &dbusName, &eventName))
atspi.addEventListener(dbusName, eventName);
}, &atspi);
}, this);
}
static GUniquePtr<char*> eventConvertingDetailToNonCamelCase(const char* eventName)
{
GUniquePtr<char*> event(g_strsplit(eventName, ":", 3));
if (!event.get()[0] || !event.get()[1] || !event.get()[2] || !*event.get()[2])
return event;
char* converted = static_cast<char*>(g_malloc(strlen(event.get()[2]) * 2 + 1));
char* convertedPtr = converted;
char* detailPtr = event.get()[2];
while (*detailPtr) {
if (isASCIIUpper(*detailPtr)) {
if (convertedPtr > converted)
*convertedPtr++ = '-';
*convertedPtr++ = toASCIILower(*detailPtr++);
} else
*convertedPtr++ = *detailPtr++;
}
*convertedPtr = '\0';
g_free(event.get()[2]);
event.get()[2] = converted;
return event;
}
void AccessibilityAtspi::addEventListener(const char* dbusName, const char* eventName)
{
auto& listeners = m_eventListeners.ensure(dbusName, [] {
return Vector<GUniquePtr<char*>> { };
}).iterator->value;
listeners.append(eventConvertingDetailToNonCamelCase(eventName));
addClient(dbusName);
}
static bool eventIsSubtype(char** needle, char** haystack)
{
while (*haystack && **haystack) {
if (g_strcmp0(*needle, *haystack))
return false;
needle++;
haystack++;
}
return true;
}
void AccessibilityAtspi::removeEventListener(const char* dbusName, const char* eventName)
{
if (!eventName || !*eventName) {
m_eventListeners.remove(dbusName);
return;
}
auto it = m_eventListeners.find(dbusName);
if (it == m_eventListeners.end())
return;
auto needle = eventConvertingDetailToNonCamelCase(eventName);
it->value.removeAllMatching([&](const GUniquePtr<char*>& event) {
return eventIsSubtype(needle.get(), event.get());
});
if (it->value.isEmpty())
m_eventListeners.remove(it);
}
void AccessibilityAtspi::addClient(const char* dbusName)
{
if (m_clients.isEmpty())
AXObjectCache::enableAccessibility();
auto addResult = m_clients.add(dbusName, 0);
if (!addResult.isNewEntry)
return;
m_cacheClearTimer.stop();
addResult.iterator->value = g_dbus_connection_signal_subscribe(m_connection.get(), nullptr, "org.freedesktop.DBus", "NameOwnerChanged", nullptr, dbusName,
G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE, [](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar*, GVariant* parameters, gpointer userData) {
auto& atspi = *static_cast<AccessibilityAtspi*>(userData);
const char* interface;
const char* oldName;
const char* newName;
g_variant_get(parameters, "(&s&s&s)", &interface, &oldName, &newName);
if (*oldName != '\0' && *newName == '\0')
atspi.removeClient(oldName);
}, this, nullptr);
}
void AccessibilityAtspi::removeClient(const char* dbusName)
{
auto id = m_clients.take(dbusName);
if (!id)
return;
g_dbus_connection_signal_unsubscribe(m_connection.get(), id);
if (!m_clients.isEmpty())
return;
m_cacheUpdateList.clear();
m_cacheUpdateTimer.stop();
m_cacheClearTimer.startOneShot(10_s);
}
bool AccessibilityAtspi::shouldEmitSignal(const char* interface, const char* name, const char* detail)
{
// Always emit signals if we couldn't connect to the registry.
if (!m_registry)
return true;
if (m_eventListeners.isEmpty())
return false;
const char* needle[4] = { interface, name, detail, nullptr };
for (const auto& listeners : m_eventListeners.values()) {
auto result = listeners.findIf([&](const GUniquePtr<char*>& event) {
return eventIsSubtype(const_cast<char**>(needle), event.get());
});
if (result != notFound)
return true;
}
return false;
}
const char* AccessibilityAtspi::uniqueName() const
{
return m_connection ? g_dbus_connection_get_unique_name(m_connection.get()) : nullptr;
}
GVariant* AccessibilityAtspi::nullReference() const
{
return g_variant_new("(so)", uniqueName(), "/org/a11y/atspi/null");
}
GVariant* AccessibilityAtspi::applicationReference() const
{
// The application is the same for all root objects, so just use the first root object that is already embedded.
for (auto* rootObject : m_rootObjects.keys()) {
if (!rootObject->path().isNull())
return rootObject->applicationReference();
}
return nullReference();
}
void AccessibilityAtspi::registerRoot(AccessibilityRootAtspi& rootObject, Vector<std::pair<GDBusInterfaceInfo*, GDBusInterfaceVTable*>>&& interfaces, CompletionHandler<void(const String&)>&& completionHandler)
{
if (m_isConnecting) {
m_pendingRootRegistrations.append({ rootObject, WTFMove(interfaces), WTFMove(completionHandler) });
return;
}
if (!m_connection) {
completionHandler({ });
return;
}
ensureCache();
String path = makeString("/org/a11y/webkit/accessible/", makeStringByReplacingAll(createVersion4UUIDString(), '-', '_'));
Vector<unsigned, 3> registeredObjects;
registeredObjects.reserveInitialCapacity(interfaces.size());
for (const auto& interface : interfaces) {
auto id = g_dbus_connection_register_object(m_connection.get(), path.utf8().data(), interface.first, interface.second, &rootObject, nullptr, nullptr);
registeredObjects.uncheckedAppend(id);
}
m_rootObjects.add(&rootObject, WTFMove(registeredObjects));
String reference = makeString(uniqueName(), ':', path);
rootObject.setPath(WTFMove(path));
completionHandler(reference);
}
void AccessibilityAtspi::unregisterRoot(AccessibilityRootAtspi& rootObject)
{
for (unsigned i = 0; i < m_pendingRootRegistrations.size(); ++i) {
auto& pendingRootRegistration = m_pendingRootRegistrations[i];
if (pendingRootRegistration.root.ptr() == &rootObject) {
pendingRootRegistration.completionHandler({ });
m_pendingRootRegistrations.remove(i);
return;
}
}
if (!m_connection)
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, rootObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "StateChanged",
g_variant_new("(siiva{sv})", "defunct", TRUE, 0, g_variant_new_string("0"), nullptr), nullptr);
auto registeredObjects = m_rootObjects.take(&rootObject);
g_dbus_connection_emit_signal(m_connection.get(), nullptr, "/org/a11y/atspi/cache", "org.a11y.atspi.Cache", "RemoveAccessible",
g_variant_new("((so))", uniqueName(), rootObject.path().utf8().data()), nullptr);
for (auto id : registeredObjects)
g_dbus_connection_unregister_object(m_connection.get(), id);
}
String AccessibilityAtspi::registerObject(AccessibilityObjectAtspi& atspiObject, Vector<std::pair<GDBusInterfaceInfo*, GDBusInterfaceVTable*>>&& interfaces)
{
RELEASE_ASSERT(!m_isConnecting);
if (!m_connection)
return { };
ensureCache();
String path = makeString("/org/a11y/atspi/accessible/", makeStringByReplacingAll(createVersion4UUIDString(), '-', '_'));
Vector<unsigned, 7> registeredObjects;
registeredObjects.reserveInitialCapacity(interfaces.size());
for (const auto& interface : interfaces) {
auto id = g_dbus_connection_register_object(m_connection.get(), path.utf8().data(), interface.first, interface.second, &atspiObject, nullptr, nullptr);
registeredObjects.uncheckedAppend(id);
}
m_atspiObjects.add(&atspiObject, WTFMove(registeredObjects));
m_cacheUpdateList.add(&atspiObject);
if (!m_cacheUpdateTimer.isActive())
m_cacheUpdateTimer.startOneShot(0_s);
return path;
}
void AccessibilityAtspi::unregisterObject(AccessibilityObjectAtspi& atspiObject)
{
RELEASE_ASSERT(!m_isConnecting);
if (!m_connection)
return;
if (m_atspiHyperlinks.contains(&atspiObject)) {
auto registeredObjects = m_atspiHyperlinks.take(&atspiObject);
for (auto id : registeredObjects)
g_dbus_connection_unregister_object(m_connection.get(), id);
}
const auto& path = atspiObject.path();
g_dbus_connection_emit_signal(m_connection.get(), nullptr, path.utf8().data(), "org.a11y.atspi.Event.Object", "StateChanged",
g_variant_new("(siiva{sv})", "defunct", TRUE, 0, g_variant_new_string("0"), nullptr), nullptr);
if (!m_cacheUpdateList.remove(&atspiObject) && m_cache.remove(path)) {
g_dbus_connection_emit_signal(m_connection.get(), nullptr, "/org/a11y/atspi/cache", "org.a11y.atspi.Cache", "RemoveAccessible",
g_variant_new("((so))", uniqueName(), path.utf8().data()), nullptr);
}
if (m_cacheUpdateList.isEmpty())
m_cacheUpdateTimer.stop();
auto registeredObjects = m_atspiObjects.take(&atspiObject);
for (auto id : registeredObjects)
g_dbus_connection_unregister_object(m_connection.get(), id);
}
String AccessibilityAtspi::registerHyperlink(AccessibilityObjectAtspi& atspiObject, Vector<std::pair<GDBusInterfaceInfo*, GDBusInterfaceVTable*>>&& interfaces)
{
if (!m_connection)
return { };
String path = makeString("/org/a11y/atspi/accessible/", makeStringByReplacingAll(createVersion4UUIDString(), '-', '_'));
Vector<unsigned, 1> registeredObjects;
registeredObjects.reserveInitialCapacity(interfaces.size());
for (const auto& interface : interfaces) {
auto id = g_dbus_connection_register_object(m_connection.get(), path.utf8().data(), interface.first, interface.second, &atspiObject, nullptr, nullptr);
registeredObjects.uncheckedAppend(id);
}
m_atspiHyperlinks.add(&atspiObject, WTFMove(registeredObjects));
return path;
}
void AccessibilityAtspi::parentChanged(AccessibilityObjectAtspi& atspiObject)
{
if (!m_connection)
return;
// Always emit parentChanged when there are clients because the atspi cache always consumes it.
if (!m_clients.isEmpty())
return;
// Do not emit parent-changed for pending objects, since AddAccessible will update the cache.
if (m_cacheUpdateList.contains(&atspiObject))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "PropertyChange",
g_variant_new("(siiva{sv})", "accessible-parent", 0, 0, atspiObject.parentReference(), nullptr), nullptr);
}
void AccessibilityAtspi::parentChanged(AccessibilityRootAtspi& rootObject)
{
if (!m_connection)
return;
// Always emit parentChanged when there are clients because the atspi cache always consumes it.
if (m_clients.isEmpty())
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, rootObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "PropertyChange",
g_variant_new("(siiva{sv})", "accessible-parent", 0, 0, rootObject.parentReference(), nullptr), nullptr);
}
void AccessibilityAtspi::childrenChanged(AccessibilityObjectAtspi& atspiObject, AccessibilityObjectAtspi& child, ChildrenChanged change)
{
if (!m_connection)
return;
// Always emit ChildrenChanged when there are clients because the atspi cache always consumes it.
if (m_clients.isEmpty())
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "ChildrenChanged",
g_variant_new("(siiv(so))", change == ChildrenChanged::Added ? "add" : "remove", child.indexInParentForChildrenChanged(change),
0, g_variant_new("(so)", uniqueName(), child.path().utf8().data()), uniqueName(), atspiObject.path().utf8().data()), nullptr);
}
void AccessibilityAtspi::childrenChanged(AccessibilityRootAtspi& rootObject, AccessibilityObjectAtspi& child, ChildrenChanged change)
{
if (!m_connection)
return;
// Always emit ChildrenChanged when there are clients because the atspi cache always consumes it.
if (m_clients.isEmpty())
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, rootObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "ChildrenChanged",
g_variant_new("(siiv(so))", change == ChildrenChanged::Added ? "add" : "remove", 0,
0, g_variant_new("(so)", uniqueName(), child.path().utf8().data()), uniqueName(), rootObject.path().utf8().data()), nullptr);
}
void AccessibilityAtspi::stateChanged(AccessibilityObjectAtspi& atspiObject, const char* name, bool value)
{
#if ENABLE(DEVELOPER_MODE)
notifyStateChanged(atspiObject, name, value);
#endif
if (!m_connection)
return;
if (!shouldEmitSignal("Object", "StateChanged", name))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "StateChanged",
g_variant_new("(siiva{sv})", name, value, 0, g_variant_new_string("0"), nullptr), nullptr);
}
void AccessibilityAtspi::textChanged(AccessibilityObjectAtspi& atspiObject, const char* changeType, CString&& text, unsigned offset, unsigned length)
{
#if ENABLE(DEVELOPER_MODE)
notifyTextChanged(atspiObject);
#endif
if (!m_connection)
return;
if (!shouldEmitSignal("Object", "TextChanged", changeType))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "TextChanged",
g_variant_new("(siiva{sv})", changeType, offset, length, g_variant_new_string(text.data()), nullptr), nullptr);
}
void AccessibilityAtspi::textAttributesChanged(AccessibilityObjectAtspi& atspiObject)
{
if (!m_connection)
return;
if (!shouldEmitSignal("Object", "TextAttributesChanged"))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "TextAttributesChanged",
g_variant_new("(siiva{sv})", "", 0, 0, g_variant_new_string(""), nullptr), nullptr);
}
void AccessibilityAtspi::textCaretMoved(AccessibilityObjectAtspi& atspiObject, unsigned caretOffset)
{
#if ENABLE(DEVELOPER_MODE)
notifyTextCaretMoved(atspiObject, caretOffset);
#endif
if (!m_connection)
return;
if (!shouldEmitSignal("Object", "TextCaretMoved"))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "TextCaretMoved",
g_variant_new("(siiva{sv})", "", caretOffset, 0, g_variant_new_string(""), nullptr), nullptr);
}
void AccessibilityAtspi::textSelectionChanged(AccessibilityObjectAtspi& atspiObject)
{
if (!m_connection)
return;
if (!shouldEmitSignal("Object", "TextSelectionChanged"))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "TextSelectionChanged",
g_variant_new("(siiva{sv})", "", 0, 0, g_variant_new_string(""), nullptr), nullptr);
}
void AccessibilityAtspi::valueChanged(AccessibilityObjectAtspi& atspiObject, double value)
{
#if ENABLE(DEVELOPER_MODE)
notifyValueChanged(atspiObject);
#endif
if (!m_connection)
return;
if (!shouldEmitSignal("Object", "PropertyChange", "accessible-value"))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "PropertyChange",
g_variant_new("(siiva{sv})", "accessible-value", 0, 0, g_variant_new_double(value), nullptr), nullptr);
}
void AccessibilityAtspi::selectionChanged(AccessibilityObjectAtspi& atspiObject)
{
#if ENABLE(DEVELOPER_MODE)
if (atspiObject.role() == Atspi::Role::Menu)
notifyMenuSelectionChanged(atspiObject);
else
notifySelectionChanged(atspiObject);
#endif
if (!m_connection)
return;
if (!shouldEmitSignal("Object", "SelectionChanged"))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Object", "SelectionChanged",
g_variant_new("(siiva{sv})", "", 0, 0, g_variant_new_string(""), nullptr), nullptr);
}
void AccessibilityAtspi::loadEvent(AccessibilityObjectAtspi& atspiObject, CString&& event)
{
#if ENABLE(DEVELOPER_MODE)
notifyLoadEvent(atspiObject, event);
#endif
if (!m_connection)
return;
if (!shouldEmitSignal("Document", event.data()))
return;
g_dbus_connection_emit_signal(m_connection.get(), nullptr, atspiObject.path().utf8().data(), "org.a11y.atspi.Event.Document", event.data(),
g_variant_new("(siiva{sv})", "", 0, 0, g_variant_new_string(""), nullptr), nullptr);
}
struct RoleNameEntry {
const char* name;
const char* localizedName;
};
static constexpr std::pair<AccessibilityRole, RoleNameEntry> roleNames[] = {
{ AccessibilityRole::Application, { "application", N_("application") } },
{ AccessibilityRole::ApplicationAlert, { "notification", N_("notification") } },
{ AccessibilityRole::ApplicationAlertDialog, { "alert", N_("alert") } },
{ AccessibilityRole::ApplicationDialog, { "dialog", N_("dialog") } },
{ AccessibilityRole::ApplicationGroup, { "grouping", N_("grouping") } },
{ AccessibilityRole::ApplicationLog, { "log", N_("log") } },
{ AccessibilityRole::ApplicationMarquee, { "marquee", N_("marquee") } },
{ AccessibilityRole::ApplicationStatus, { "statusbar", N_("statusbar") } },
{ AccessibilityRole::ApplicationTextGroup, { "section", N_("section") } },
{ AccessibilityRole::ApplicationTimer, { "timer", N_("timer") } },
{ AccessibilityRole::Audio, { "audio", N_("audio") } },
{ AccessibilityRole::Blockquote, { "block quote", N_("block quote") } },
{ AccessibilityRole::BusyIndicator, { "progress bar", N_("progress bar") } },
{ AccessibilityRole::Button, { "push button", N_("push button") } },
{ AccessibilityRole::Canvas, { "canvas", N_("canvas") } },
{ AccessibilityRole::Caption, { "caption", N_("caption") } },
{ AccessibilityRole::Cell, { "table cell", N_("table cell") } },
{ AccessibilityRole::CheckBox, { "check box", N_("check box") } },
{ AccessibilityRole::ColorWell, { "push button", N_("push button") } },
{ AccessibilityRole::ColumnHeader, { "column header", N_("column header") } },
{ AccessibilityRole::ComboBox, { "combo box", N_("combo box") } },
{ AccessibilityRole::Definition, { "definition", N_("definition") } },
{ AccessibilityRole::Deletion, { "content deletion", N_("content deletion") } },
{ AccessibilityRole::DescriptionList, { "description list", N_("description list") } },
{ AccessibilityRole::DescriptionListDetail, { "description value", N_("description value") } },
{ AccessibilityRole::DescriptionListTerm, { "description term", N_("description term") } },
{ AccessibilityRole::Directory, { "directory pane", N_("directory pane") } },
{ AccessibilityRole::Div, { "section", N_("section") } },
{ AccessibilityRole::Document, { "document frame", N_("document frame") } },
{ AccessibilityRole::DocumentArticle, { "article", N_("article") } },
{ AccessibilityRole::DocumentMath, { "math", N_("math") } },
{ AccessibilityRole::DocumentNote, { "comment", N_("comment") } },
{ AccessibilityRole::Feed, { "panel", N_("panel") } },
{ AccessibilityRole::Figure, { "panel", N_("panel") } },
{ AccessibilityRole::Footer, { "footer", N_("footer") } },
{ AccessibilityRole::Footnote, { "footnote", N_("footnote") } },
{ AccessibilityRole::Form, { "form", N_("form") } },
{ AccessibilityRole::GraphicsDocument, { "document frame", N_("document frame") } },
{ AccessibilityRole::GraphicsObject, { "panel", N_("panel") } },
{ AccessibilityRole::GraphicsSymbol, { "image", N_("image") } },
{ AccessibilityRole::Grid, { "table", N_("table") } },
{ AccessibilityRole::GridCell, { "table cell", N_("table cell") } },
{ AccessibilityRole::Group, { "panel", N_("panel") } },
{ AccessibilityRole::Heading, { "heading", N_("heading") } },
{ AccessibilityRole::HorizontalRule, { "separator", N_("separator") } },
{ AccessibilityRole::Inline, { "text", N_("text") } },
{ AccessibilityRole::Image, { "image", N_("image") } },
{ AccessibilityRole::ImageMap, { "image map", N_("image map") } },
{ AccessibilityRole::ImageMapLink, { "link", N_("link") } },
{ AccessibilityRole::Insertion, { "content insertion", N_("content insertion") } },
{ AccessibilityRole::Label, { "label", N_("label") } },
{ AccessibilityRole::LandmarkBanner, { "landmark", N_("landmark") } },
{ AccessibilityRole::LandmarkComplementary, { "landmark", N_("landmark") } },
{ AccessibilityRole::LandmarkContentInfo, { "landmark", N_("landmark") } },
{ AccessibilityRole::LandmarkDocRegion, { "landmark", N_("landmark") } },
{ AccessibilityRole::LandmarkMain, { "landmark", N_("landmark") } },
{ AccessibilityRole::LandmarkNavigation, { "landmark", N_("landmark") } },
{ AccessibilityRole::LandmarkRegion, { "landmark", N_("landmark") } },
{ AccessibilityRole::LandmarkSearch, { "landmark", N_("landmark") } },
{ AccessibilityRole::Legend, { "label", N_("label") } },
{ AccessibilityRole::Link, { "link", N_("link") } },
{ AccessibilityRole::List, { "list", N_("list") } },
{ AccessibilityRole::ListBox, { "heading", N_("list box") } },
{ AccessibilityRole::ListBoxOption, { "list item", N_("list item") } },
{ AccessibilityRole::ListItem, { "list item", N_("list item") } },
{ AccessibilityRole::ListMarker, { "text", N_("text") } },
{ AccessibilityRole::Mark, { "mar", N_("mark") } },
{ AccessibilityRole::MathElement, { "math", N_("math") } },
{ AccessibilityRole::Menu, { "menu", N_("menu") } },
{ AccessibilityRole::MenuBar, { "menu bar", N_("menu bar") } },
{ AccessibilityRole::MenuButton, { "menu item", N_("menu item") } },
{ AccessibilityRole::MenuItem, { "menu item", N_("menu item") } },
{ AccessibilityRole::MenuItemCheckbox, { "check menu item", N_("check menu item") } },
{ AccessibilityRole::MenuItemRadio, { "radio menu item", N_("radio menu item") } },
{ AccessibilityRole::MenuListPopup, { "menu", N_("menu") } },
{ AccessibilityRole::MenuListOption, { "menu item", N_("menu item") } },
{ AccessibilityRole::Meter, { "level bar", N_("level bar") } },
{ AccessibilityRole::Outline, { "tree", N_("tree") } },
{ AccessibilityRole::Paragraph, { "paragraph", N_("paragraph") } },
{ AccessibilityRole::PopUpButton, { "combo box", N_("combo box") } },
{ AccessibilityRole::Pre, { "section", N_("section") } },
{ AccessibilityRole::ProgressIndicator, { "progress bar", N_("progress bar") } },
{ AccessibilityRole::RadioButton, { "radio button", N_("radio button") } },
{ AccessibilityRole::RadioGroup, { "panel", N_("panel") } },
{ AccessibilityRole::RowHeader, { "row header", N_("row header") } },
{ AccessibilityRole::Row, { "table row", N_("table row") } },
{ AccessibilityRole::ScrollArea, { "scroll pane", N_("scroll pane") } },
{ AccessibilityRole::ScrollBar, { "scroll bar", N_("scroll bar") } },
{ AccessibilityRole::SearchField, { "entry", N_("entry") } },
{ AccessibilityRole::Slider, { "slider", N_("slider") } },
{ AccessibilityRole::SpinButton, { "spin button", N_("spin button") } },
{ AccessibilityRole::SplitGroup, { "split pane", N_("split pane") } },
{ AccessibilityRole::Splitter, { "separator", N_("separator") } },
{ AccessibilityRole::StaticText, { "text", N_("text") } },
{ AccessibilityRole::Subscript, { "subscript", N_("subscript") } },
{ AccessibilityRole::Superscript, { "superscript", N_("superscript") } },
{ AccessibilityRole::Switch, { "toggle button", N_("toggle button") } },
{ AccessibilityRole::SVGRoot, { "panel", N_("panel") } },
{ AccessibilityRole::SVGText, { "section", N_("section") } },
{ AccessibilityRole::SVGTSpan, { "text", N_("text") } },
{ AccessibilityRole::SVGTextPath, { "text", N_("text") } },
{ AccessibilityRole::TabGroup, { "page tab list", N_("page tab list") } },
{ AccessibilityRole::TabList, { "page tab list", N_("page tab list") } },
{ AccessibilityRole::TabPanel, { "scroll pane", N_("scroll pane") } },
{ AccessibilityRole::Tab, { "page tab", N_("page tab") } },
{ AccessibilityRole::Table, { "table", N_("table") } },
{ AccessibilityRole::Term, { "description term", N_("description term") } },
{ AccessibilityRole::TextArea, { "entry", N_("entry") } },
{ AccessibilityRole::TextField, { "entry", N_("entry") } },
{ AccessibilityRole::TextGroup, { "section", N_("section") } },
{ AccessibilityRole::Time, { "text", N_("text") } },
{ AccessibilityRole::Tree, { "tree", N_("tree") } },
{ AccessibilityRole::TreeGrid, { "tree table", N_("tree table") } },
{ AccessibilityRole::TreeItem, { "tree item", N_("tree item") } },
{ AccessibilityRole::ToggleButton, { "toggle button", N_("toggle button") } },
{ AccessibilityRole::Toolbar, { "tool bar", N_("tool bar") } },
{ AccessibilityRole::Unknown, { "unknown", N_("unknown") } },
{ AccessibilityRole::UserInterfaceTooltip, { "tool tip", N_("tool tip") } },
{ AccessibilityRole::Video, { "video", N_("video") } },
{ AccessibilityRole::WebArea, { "document web", N_("document web") } },
{ AccessibilityRole::WebCoreLink, { "link", N_("link") } },
{ AccessibilityRole::Window, { "window", N_("window") } }
};
const char* AccessibilityAtspi::localizedRoleName(AccessibilityRole role)
{
static constexpr SortedArrayMap roleNamesMap { roleNames };
if (auto entry = roleNamesMap.tryGet(role))
return entry->localizedName;
return _("unknown");
}
#define ITEM_SIGNATURE "(so)(so)(so)iiassusau"
#define GET_ITEMS_SIGNATURE "a(" ITEM_SIGNATURE ")"
GDBusInterfaceVTable AccessibilityAtspi::s_cacheFunctions = {
// method_call
[](GDBusConnection*, const gchar* sender, const gchar*, const gchar*, const gchar* methodName, GVariant*, GDBusMethodInvocation* invocation, gpointer userData) {
if (!g_strcmp0(methodName, "GetItems")) {
auto& atspi = *static_cast<AccessibilityAtspi*>(userData);
atspi.addClient(sender);
GVariantBuilder builder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("(" GET_ITEMS_SIGNATURE ")"));
g_variant_builder_open(&builder, G_VARIANT_TYPE(GET_ITEMS_SIGNATURE));
for (auto* rootObject : atspi.m_rootObjects.keys()) {
g_variant_builder_open(&builder, G_VARIANT_TYPE("(" ITEM_SIGNATURE ")"));
rootObject->serialize(&builder);
g_variant_builder_close(&builder);
}
// We need to call updateBackingStore() on every object before calling serialize()
// and updating the backing store can detach the object and remove it from the cache.
auto paths = copyToVector(atspi.m_cache.keys());
for (const auto& path : paths) {
auto wrapper = atspi.m_cache.get(path);
wrapper->updateBackingStore();
if (!atspi.m_cache.contains(path) || wrapper->isDefunct())
continue;
g_variant_builder_open(&builder, G_VARIANT_TYPE("(" ITEM_SIGNATURE ")"));
wrapper->serialize(&builder);
g_variant_builder_close(&builder);
}
g_variant_builder_close(&builder);
g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
},
// get_property
[](GDBusConnection*, const gchar*, const gchar*, const gchar*, const gchar* propertyName, GError** error, gpointer) -> GVariant* {
g_set_error(error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "Unknown property '%s'", propertyName);
return nullptr;
},
// set_property,
nullptr,
// padding
{ nullptr }
};
void AccessibilityAtspi::ensureCache()
{
if (m_cacheID || !m_connection)
return;
m_cacheID = g_dbus_connection_register_object(m_connection.get(), "/org/a11y/atspi/cache", const_cast<GDBusInterfaceInfo*>(&webkit_cache_interface), &s_cacheFunctions, this, nullptr, nullptr);
}
void AccessibilityAtspi::addToCacheIfNeeded(AccessibilityObjectAtspi& atspiObject)
{
atspiObject.updateBackingStore();
if (atspiObject.isDefunct())
return;
auto addResult = m_cache.add(atspiObject.path(), &atspiObject);
if (!addResult.isNewEntry)
return;
GVariantBuilder builder = G_VARIANT_BUILDER_INIT(G_VARIANT_TYPE("(" ITEM_SIGNATURE ")"));
atspiObject.serialize(&builder);
g_dbus_connection_emit_signal(m_connection.get(), nullptr, "/org/a11y/atspi/cache", "org.a11y.atspi.Cache", "AddAccessible",
g_variant_new("(@(" ITEM_SIGNATURE "))", g_variant_builder_end(&builder)), nullptr);
}
void AccessibilityAtspi::cacheUpdateTimerFired()
{
auto cacheUpdateList = std::exchange(m_cacheUpdateList, { });
for (auto& atspiObject : cacheUpdateList)
addToCacheIfNeeded(*atspiObject);
}
void AccessibilityAtspi::cacheClearTimerFired()
{
for (const auto& registeredObjects : m_atspiHyperlinks.values()) {
for (auto id : registeredObjects)
g_dbus_connection_unregister_object(m_connection.get(), id);
}
m_atspiHyperlinks.clear();
for (const auto& it : m_atspiObjects) {
for (auto id : it.value)
g_dbus_connection_unregister_object(m_connection.get(), id);
it.key->didUnregisterObject();
}
m_atspiObjects.clear();
m_cache.clear();
RELEASE_ASSERT(m_cacheUpdateList.isEmpty());
m_cacheUpdateTimer.stop();
m_cacheClearTimer.stop();
}
namespace Accessibility {
PlatformRoleMap createPlatformRoleMap()
{
PlatformRoleMap roleMap;
for (const auto& entry : roleNames)
roleMap.add(static_cast<unsigned>(entry.first), String::fromUTF8(entry.second.name));
return roleMap;
}
} // namespace Accessibility
#if ENABLE(DEVELOPER_MODE)
void AccessibilityAtspi::addNotificationObserver(void* context, NotificationObserver&& observer)
{
AXObjectCache::enableAccessibility();
m_notificationObservers.add(context, WTFMove(observer));
}
void AccessibilityAtspi::removeNotificationObserver(void* context)
{
m_notificationObservers.remove(context);
}
void AccessibilityAtspi::notifyStateChanged(AccessibilityObjectAtspi& atspiObject, const char* name, bool value) const
{
if (m_notificationObservers.isEmpty())
return;
auto notificationName = [&](const char* name) -> const char* {
if (!g_strcmp0(name, "checked"))
return "CheckedStateChanged";
if (!g_strcmp0(name, "invalid-entry"))
return "AXInvalidStatusChanged";
if (!g_strcmp0(name, "active"))
return "ActiveStateChanged";
if (!g_strcmp0(name, "busy"))
return "AXElementBusyChanged";
if (!g_strcmp0(name, "enabled"))
return "AXDisabledStateChanged";
if (!g_strcmp0(name, "expanded"))
return "AXExpandedChanged";
if (!g_strcmp0(name, "pressed"))
return "AXPressedStateChanged";
if (!g_strcmp0(name, "read-only"))
return "AXReadOnlyStatusChanged";
if (!g_strcmp0(name, "required"))
return "AXRequiredStatusChanged";
if (!g_strcmp0(name, "sensitive"))
return "AXSensitiveStateChanged";
if (!g_strcmp0(name, "focused") && value)
return "AXFocusedUIElementChanged";
return nullptr;
};
const char* notification = notificationName(name);
if (!notification)
return;
for (const auto& observer : m_notificationObservers.values())
observer(atspiObject, notification, value);
}
void AccessibilityAtspi::notifySelectionChanged(AccessibilityObjectAtspi& atspiObject) const
{
for (const auto& observer : m_notificationObservers.values())
observer(atspiObject, "AXSelectedChildrenChanged", nullptr);
}
void AccessibilityAtspi::notifyMenuSelectionChanged(AccessibilityObjectAtspi& atspiObject) const
{
for (const auto& observer : m_notificationObservers.values())
observer(atspiObject, "AXMenuItemSelected", nullptr);
}
void AccessibilityAtspi::notifyTextChanged(AccessibilityObjectAtspi& atspiObject) const
{
for (const auto& observer : m_notificationObservers.values())
observer(atspiObject, "AXTextChanged", nullptr);
}
void AccessibilityAtspi::notifyTextCaretMoved(AccessibilityObjectAtspi& atspiObject, unsigned caretOffset) const
{
for (const auto& observer : m_notificationObservers.values())
observer(atspiObject, "AXTextCaretMoved", caretOffset);
}
void AccessibilityAtspi::notifyValueChanged(AccessibilityObjectAtspi& atspiObject) const
{
for (const auto& observer : m_notificationObservers.values())
observer(atspiObject, "AXValueChanged", nullptr);
}
void AccessibilityAtspi::notifyLoadEvent(AccessibilityObjectAtspi& atspiObject, const CString& event) const
{
if (event != "LoadComplete")
return;
for (const auto& observer : m_notificationObservers.values())
observer(atspiObject, "AXLoadComplete", nullptr);
}
#endif
} // namespace WebCore
#endif // USE(ATSPI)