summaryrefslogtreecommitdiffstats
path: root/accessible/atk/AccessibleWrap.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /accessible/atk/AccessibleWrap.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'accessible/atk/AccessibleWrap.cpp')
-rw-r--r--accessible/atk/AccessibleWrap.cpp1305
1 files changed, 1305 insertions, 0 deletions
diff --git a/accessible/atk/AccessibleWrap.cpp b/accessible/atk/AccessibleWrap.cpp
new file mode 100644
index 0000000000..98f303ee4a
--- /dev/null
+++ b/accessible/atk/AccessibleWrap.cpp
@@ -0,0 +1,1305 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "AccessibleWrap.h"
+
+#include "LocalAccessible-inl.h"
+#include "AccAttributes.h"
+#include "ApplicationAccessibleWrap.h"
+#include "InterfaceInitFuncs.h"
+#include "nsAccUtils.h"
+#include "mozilla/a11y/PDocAccessible.h"
+#include "OuterDocAccessible.h"
+#include "RemoteAccessible.h"
+#include "DocAccessibleParent.h"
+#include "RootAccessible.h"
+#include "mozilla/a11y/TableAccessible.h"
+#include "mozilla/a11y/TableCellAccessible.h"
+#include "nsMai.h"
+#include "nsMaiHyperlink.h"
+#include "nsString.h"
+#include "nsStateMap.h"
+#include "mozilla/a11y/Platform.h"
+#include "Relation.h"
+#include "RootAccessible.h"
+#include "States.h"
+#include "nsISimpleEnumerator.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Sprintf.h"
+#include "nsAccessibilityService.h"
+#include "nsComponentManagerUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+MaiAtkObject::EAvailableAtkSignals MaiAtkObject::gAvailableAtkSignals =
+ eUnknown;
+
+// defined in ApplicationAccessibleWrap.cpp
+extern "C" GType g_atk_hyperlink_impl_type;
+
+/* MaiAtkObject */
+
+enum {
+ ACTIVATE,
+ CREATE,
+ DEACTIVATE,
+ DESTROY,
+ MAXIMIZE,
+ MINIMIZE,
+ RESIZE,
+ RESTORE,
+ LAST_SIGNAL
+};
+
+enum MaiInterfaceType {
+ MAI_INTERFACE_COMPONENT, /* 0 */
+ MAI_INTERFACE_ACTION,
+ MAI_INTERFACE_VALUE,
+ MAI_INTERFACE_EDITABLE_TEXT,
+ MAI_INTERFACE_HYPERTEXT,
+ MAI_INTERFACE_HYPERLINK_IMPL,
+ MAI_INTERFACE_SELECTION,
+ MAI_INTERFACE_TABLE,
+ MAI_INTERFACE_TEXT,
+ MAI_INTERFACE_DOCUMENT,
+ MAI_INTERFACE_IMAGE, /* 10 */
+ MAI_INTERFACE_TABLE_CELL
+};
+
+static GType GetAtkTypeForMai(MaiInterfaceType type) {
+ switch (type) {
+ case MAI_INTERFACE_COMPONENT:
+ return ATK_TYPE_COMPONENT;
+ case MAI_INTERFACE_ACTION:
+ return ATK_TYPE_ACTION;
+ case MAI_INTERFACE_VALUE:
+ return ATK_TYPE_VALUE;
+ case MAI_INTERFACE_EDITABLE_TEXT:
+ return ATK_TYPE_EDITABLE_TEXT;
+ case MAI_INTERFACE_HYPERTEXT:
+ return ATK_TYPE_HYPERTEXT;
+ case MAI_INTERFACE_HYPERLINK_IMPL:
+ return g_atk_hyperlink_impl_type;
+ case MAI_INTERFACE_SELECTION:
+ return ATK_TYPE_SELECTION;
+ case MAI_INTERFACE_TABLE:
+ return ATK_TYPE_TABLE;
+ case MAI_INTERFACE_TEXT:
+ return ATK_TYPE_TEXT;
+ case MAI_INTERFACE_DOCUMENT:
+ return ATK_TYPE_DOCUMENT;
+ case MAI_INTERFACE_IMAGE:
+ return ATK_TYPE_IMAGE;
+ case MAI_INTERFACE_TABLE_CELL:
+ MOZ_ASSERT(false);
+ }
+ return G_TYPE_INVALID;
+}
+
+#define NON_USER_EVENT ":system"
+
+// The atk interfaces we can expose without checking what version of ATK we are
+// dealing with. At the moment AtkTableCell is the only interface we can't
+// always expose.
+static const GInterfaceInfo atk_if_infos[] = {
+ {(GInterfaceInitFunc)componentInterfaceInitCB,
+ (GInterfaceFinalizeFunc) nullptr, nullptr},
+ {(GInterfaceInitFunc)actionInterfaceInitCB,
+ (GInterfaceFinalizeFunc) nullptr, nullptr},
+ {(GInterfaceInitFunc)valueInterfaceInitCB, (GInterfaceFinalizeFunc) nullptr,
+ nullptr},
+ {(GInterfaceInitFunc)editableTextInterfaceInitCB,
+ (GInterfaceFinalizeFunc) nullptr, nullptr},
+ {(GInterfaceInitFunc)hypertextInterfaceInitCB,
+ (GInterfaceFinalizeFunc) nullptr, nullptr},
+ {(GInterfaceInitFunc)hyperlinkImplInterfaceInitCB,
+ (GInterfaceFinalizeFunc) nullptr, nullptr},
+ {(GInterfaceInitFunc)selectionInterfaceInitCB,
+ (GInterfaceFinalizeFunc) nullptr, nullptr},
+ {(GInterfaceInitFunc)tableInterfaceInitCB, (GInterfaceFinalizeFunc) nullptr,
+ nullptr},
+ {(GInterfaceInitFunc)textInterfaceInitCB, (GInterfaceFinalizeFunc) nullptr,
+ nullptr},
+ {(GInterfaceInitFunc)documentInterfaceInitCB,
+ (GInterfaceFinalizeFunc) nullptr, nullptr},
+ {(GInterfaceInitFunc)imageInterfaceInitCB, (GInterfaceFinalizeFunc) nullptr,
+ nullptr}};
+
+static GQuark quark_mai_hyperlink = 0;
+
+AtkHyperlink* MaiAtkObject::GetAtkHyperlink() {
+ NS_ASSERTION(quark_mai_hyperlink, "quark_mai_hyperlink not initialized");
+ MaiHyperlink* maiHyperlink =
+ (MaiHyperlink*)g_object_get_qdata(G_OBJECT(this), quark_mai_hyperlink);
+ if (!maiHyperlink) {
+ maiHyperlink = new MaiHyperlink(acc);
+ g_object_set_qdata(G_OBJECT(this), quark_mai_hyperlink, maiHyperlink);
+ }
+
+ return maiHyperlink->GetAtkHyperlink();
+}
+
+void MaiAtkObject::Shutdown() {
+ acc = nullptr;
+ MaiHyperlink* maiHyperlink =
+ (MaiHyperlink*)g_object_get_qdata(G_OBJECT(this), quark_mai_hyperlink);
+ if (maiHyperlink) {
+ delete maiHyperlink;
+ g_object_set_qdata(G_OBJECT(this), quark_mai_hyperlink, nullptr);
+ }
+}
+
+struct MaiAtkObjectClass {
+ AtkObjectClass parent_class;
+};
+
+static guint mai_atk_object_signals[LAST_SIGNAL] = {
+ 0,
+};
+
+static void MaybeFireNameChange(AtkObject* aAtkObj, const nsString& aNewName);
+
+G_BEGIN_DECLS
+/* callbacks for MaiAtkObject */
+static void classInitCB(AtkObjectClass* aClass);
+static void initializeCB(AtkObject* aAtkObj, gpointer aData);
+static void finalizeCB(GObject* aObj);
+
+/* callbacks for AtkObject virtual functions */
+static const gchar* getNameCB(AtkObject* aAtkObj);
+/* getDescriptionCB is also used by image interface */
+const gchar* getDescriptionCB(AtkObject* aAtkObj);
+static AtkRole getRoleCB(AtkObject* aAtkObj);
+static AtkAttributeSet* getAttributesCB(AtkObject* aAtkObj);
+static const gchar* GetLocaleCB(AtkObject*);
+static AtkObject* getParentCB(AtkObject* aAtkObj);
+static gint getChildCountCB(AtkObject* aAtkObj);
+static AtkObject* refChildCB(AtkObject* aAtkObj, gint aChildIndex);
+static gint getIndexInParentCB(AtkObject* aAtkObj);
+static AtkStateSet* refStateSetCB(AtkObject* aAtkObj);
+static AtkRelationSet* refRelationSetCB(AtkObject* aAtkObj);
+
+/* the missing atkobject virtual functions */
+/*
+ static AtkLayer getLayerCB(AtkObject *aAtkObj);
+ static gint getMdiZorderCB(AtkObject *aAtkObj);
+ static void SetNameCB(AtkObject *aAtkObj,
+ const gchar *name);
+ static void SetDescriptionCB(AtkObject *aAtkObj,
+ const gchar *description);
+ static void SetParentCB(AtkObject *aAtkObj,
+ AtkObject *parent);
+ static void SetRoleCB(AtkObject *aAtkObj,
+ AtkRole role);
+ static guint ConnectPropertyChangeHandlerCB(
+ AtkObject *aObj,
+ AtkPropertyChangeHandler *handler);
+ static void RemovePropertyChangeHandlerCB(
+ AtkObject *aAtkObj,
+ guint handler_id);
+ static void InitializeCB(AtkObject *aAtkObj,
+ gpointer data);
+ static void ChildrenChangedCB(AtkObject *aAtkObj,
+ guint change_index,
+ gpointer changed_child);
+ static void FocusEventCB(AtkObject *aAtkObj,
+ gboolean focus_in);
+ static void PropertyChangeCB(AtkObject *aAtkObj,
+ AtkPropertyValues *values);
+ static void StateChangeCB(AtkObject *aAtkObj,
+ const gchar *name,
+ gboolean state_set);
+ static void VisibleDataChangedCB(AtkObject *aAtkObj);
+*/
+G_END_DECLS
+
+static GType GetMaiAtkType(uint16_t interfacesBits);
+static const char* GetUniqueMaiAtkTypeName(uint16_t interfacesBits);
+
+static gpointer parent_class = nullptr;
+
+GType mai_atk_object_get_type(void) {
+ static GType type = 0;
+
+ if (!type) {
+ static const GTypeInfo tinfo = {
+ sizeof(MaiAtkObjectClass),
+ (GBaseInitFunc) nullptr,
+ (GBaseFinalizeFunc) nullptr,
+ (GClassInitFunc)classInitCB,
+ (GClassFinalizeFunc) nullptr,
+ nullptr, /* class data */
+ sizeof(MaiAtkObject), /* instance size */
+ 0, /* nb preallocs */
+ (GInstanceInitFunc) nullptr,
+ nullptr /* value table */
+ };
+
+ type = g_type_register_static(ATK_TYPE_OBJECT, "MaiAtkObject", &tinfo,
+ GTypeFlags(0));
+ quark_mai_hyperlink = g_quark_from_static_string("MaiHyperlink");
+ }
+ return type;
+}
+
+AccessibleWrap::AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc)
+ : LocalAccessible(aContent, aDoc), mAtkObject(nullptr) {}
+
+AccessibleWrap::~AccessibleWrap() {
+ NS_ASSERTION(!mAtkObject, "ShutdownAtkObject() is not called");
+}
+
+void AccessibleWrap::ShutdownAtkObject() {
+ if (!mAtkObject) return;
+
+ NS_ASSERTION(IS_MAI_OBJECT(mAtkObject), "wrong type of atk object");
+ if (IS_MAI_OBJECT(mAtkObject)) MAI_ATK_OBJECT(mAtkObject)->Shutdown();
+
+ g_object_unref(mAtkObject);
+ mAtkObject = nullptr;
+}
+
+void AccessibleWrap::Shutdown() {
+ ShutdownAtkObject();
+ LocalAccessible::Shutdown();
+}
+
+void AccessibleWrap::GetNativeInterface(void** aOutAccessible) {
+ *aOutAccessible = nullptr;
+
+ if (!mAtkObject) {
+ if (IsDefunct() || IsText()) {
+ // We don't create ATK objects for node which has been shutdown or
+ // plain text leaves
+ return;
+ }
+
+ GType type = GetMaiAtkType(CreateMaiInterfaces());
+ if (!type) return;
+
+ mAtkObject = reinterpret_cast<AtkObject*>(g_object_new(type, nullptr));
+ if (!mAtkObject) return;
+
+ atk_object_initialize(mAtkObject, static_cast<Accessible*>(this));
+ mAtkObject->role = ATK_ROLE_INVALID;
+ mAtkObject->layer = ATK_LAYER_INVALID;
+ }
+
+ *aOutAccessible = mAtkObject;
+}
+
+AtkObject* AccessibleWrap::GetAtkObject(void) {
+ void* atkObj = nullptr;
+ GetNativeInterface(&atkObj);
+ return static_cast<AtkObject*>(atkObj);
+}
+
+// Get AtkObject from LocalAccessible interface
+/* static */
+AtkObject* AccessibleWrap::GetAtkObject(LocalAccessible* acc) {
+ void* atkObjPtr = nullptr;
+ acc->GetNativeInterface(&atkObjPtr);
+ return atkObjPtr ? ATK_OBJECT(atkObjPtr) : nullptr;
+}
+
+/* private */
+uint16_t AccessibleWrap::CreateMaiInterfaces(void) {
+ uint16_t interfacesBits = 0;
+
+ // The Component interface is supported by all accessibles.
+ interfacesBits |= 1 << MAI_INTERFACE_COMPONENT;
+
+ // Add Action interface if the action count is more than zero.
+ if (ActionCount() > 0) interfacesBits |= 1 << MAI_INTERFACE_ACTION;
+
+ // Text, Editabletext, and Hypertext interface.
+ HyperTextAccessible* hyperText = AsHyperText();
+ if (hyperText && hyperText->IsTextRole()) {
+ interfacesBits |= 1 << MAI_INTERFACE_TEXT;
+ interfacesBits |= 1 << MAI_INTERFACE_EDITABLE_TEXT;
+ if (!nsAccUtils::MustPrune(this)) {
+ interfacesBits |= 1 << MAI_INTERFACE_HYPERTEXT;
+ }
+ }
+
+ // Value interface.
+ if (HasNumericValue()) interfacesBits |= 1 << MAI_INTERFACE_VALUE;
+
+ // Document interface.
+ if (IsDoc()) interfacesBits |= 1 << MAI_INTERFACE_DOCUMENT;
+
+ if (IsImage()) interfacesBits |= 1 << MAI_INTERFACE_IMAGE;
+
+ // HyperLink interface.
+ if (IsLink()) interfacesBits |= 1 << MAI_INTERFACE_HYPERLINK_IMPL;
+
+ if (!nsAccUtils::MustPrune(this)) { // These interfaces require children
+ // Table interface.
+ if (AsTable()) interfacesBits |= 1 << MAI_INTERFACE_TABLE;
+
+ if (AsTableCell()) interfacesBits |= 1 << MAI_INTERFACE_TABLE_CELL;
+
+ // Selection interface.
+ if (IsSelect()) {
+ interfacesBits |= 1 << MAI_INTERFACE_SELECTION;
+ }
+ }
+
+ return interfacesBits;
+}
+
+static GType GetMaiAtkType(uint16_t interfacesBits) {
+ GType type;
+ static const GTypeInfo tinfo = {
+ sizeof(MaiAtkObjectClass),
+ (GBaseInitFunc) nullptr,
+ (GBaseFinalizeFunc) nullptr,
+ (GClassInitFunc) nullptr,
+ (GClassFinalizeFunc) nullptr,
+ nullptr, /* class data */
+ sizeof(MaiAtkObject), /* instance size */
+ 0, /* nb preallocs */
+ (GInstanceInitFunc) nullptr,
+ nullptr /* value table */
+ };
+
+ /*
+ * The members we use to register GTypes are GetAtkTypeForMai
+ * and atk_if_infos, which are constant values to each MaiInterface
+ * So we can reuse the registered GType when having
+ * the same MaiInterface types.
+ */
+ const char* atkTypeName = GetUniqueMaiAtkTypeName(interfacesBits);
+ type = g_type_from_name(atkTypeName);
+ if (type) {
+ return type;
+ }
+
+ /*
+ * gobject limits the number of types that can directly derive from any
+ * given object type to 4095.
+ */
+ static uint16_t typeRegCount = 0;
+ if (typeRegCount++ >= 4095) {
+ return G_TYPE_INVALID;
+ }
+ type = g_type_register_static(MAI_TYPE_ATK_OBJECT, atkTypeName, &tinfo,
+ GTypeFlags(0));
+
+ for (uint32_t index = 0; index < ArrayLength(atk_if_infos); index++) {
+ if (interfacesBits & (1 << index)) {
+ g_type_add_interface_static(type,
+ GetAtkTypeForMai((MaiInterfaceType)index),
+ &atk_if_infos[index]);
+ }
+ }
+
+ // Special case AtkTableCell so we can check what version of Atk we are
+ // dealing with.
+ if (IsAtkVersionAtLeast(2, 12) &&
+ (interfacesBits & (1 << MAI_INTERFACE_TABLE_CELL))) {
+ const GInterfaceInfo cellInfo = {
+ (GInterfaceInitFunc)tableCellInterfaceInitCB,
+ (GInterfaceFinalizeFunc) nullptr, nullptr};
+ g_type_add_interface_static(type, gAtkTableCellGetTypeFunc(), &cellInfo);
+ }
+
+ return type;
+}
+
+static const char* GetUniqueMaiAtkTypeName(uint16_t interfacesBits) {
+#define MAI_ATK_TYPE_NAME_LEN (30) /* 10+sizeof(uint16_t)*8/4+1 < 30 */
+
+ static gchar namePrefix[] = "MaiAtkType"; /* size = 10 */
+ static gchar name[MAI_ATK_TYPE_NAME_LEN + 1];
+
+ SprintfLiteral(name, "%s%x", namePrefix, interfacesBits);
+ name[MAI_ATK_TYPE_NAME_LEN] = '\0';
+
+ return name;
+}
+
+bool AccessibleWrap::IsValidObject() {
+ // to ensure we are not shut down
+ return !IsDefunct();
+}
+
+/* static functions for ATK callbacks */
+void classInitCB(AtkObjectClass* aClass) {
+ GObjectClass* gobject_class = G_OBJECT_CLASS(aClass);
+
+ parent_class = g_type_class_peek_parent(aClass);
+
+ aClass->get_name = getNameCB;
+ aClass->get_description = getDescriptionCB;
+ aClass->get_parent = getParentCB;
+ aClass->get_n_children = getChildCountCB;
+ aClass->ref_child = refChildCB;
+ aClass->get_index_in_parent = getIndexInParentCB;
+ aClass->get_role = getRoleCB;
+ aClass->get_attributes = getAttributesCB;
+ aClass->get_object_locale = GetLocaleCB;
+ aClass->ref_state_set = refStateSetCB;
+ aClass->ref_relation_set = refRelationSetCB;
+
+ aClass->initialize = initializeCB;
+
+ gobject_class->finalize = finalizeCB;
+
+ mai_atk_object_signals[ACTIVATE] = g_signal_new(
+ "activate", MAI_TYPE_ATK_OBJECT, G_SIGNAL_RUN_LAST,
+ 0, /* default signal handler */
+ nullptr, nullptr, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ mai_atk_object_signals[CREATE] = g_signal_new(
+ "create", MAI_TYPE_ATK_OBJECT, G_SIGNAL_RUN_LAST,
+ 0, /* default signal handler */
+ nullptr, nullptr, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ mai_atk_object_signals[DEACTIVATE] = g_signal_new(
+ "deactivate", MAI_TYPE_ATK_OBJECT, G_SIGNAL_RUN_LAST,
+ 0, /* default signal handler */
+ nullptr, nullptr, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ mai_atk_object_signals[DESTROY] = g_signal_new(
+ "destroy", MAI_TYPE_ATK_OBJECT, G_SIGNAL_RUN_LAST,
+ 0, /* default signal handler */
+ nullptr, nullptr, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ mai_atk_object_signals[MAXIMIZE] = g_signal_new(
+ "maximize", MAI_TYPE_ATK_OBJECT, G_SIGNAL_RUN_LAST,
+ 0, /* default signal handler */
+ nullptr, nullptr, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ mai_atk_object_signals[MINIMIZE] = g_signal_new(
+ "minimize", MAI_TYPE_ATK_OBJECT, G_SIGNAL_RUN_LAST,
+ 0, /* default signal handler */
+ nullptr, nullptr, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ mai_atk_object_signals[RESIZE] = g_signal_new(
+ "resize", MAI_TYPE_ATK_OBJECT, G_SIGNAL_RUN_LAST,
+ 0, /* default signal handler */
+ nullptr, nullptr, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+ mai_atk_object_signals[RESTORE] = g_signal_new(
+ "restore", MAI_TYPE_ATK_OBJECT, G_SIGNAL_RUN_LAST,
+ 0, /* default signal handler */
+ nullptr, nullptr, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
+}
+
+void initializeCB(AtkObject* aAtkObj, gpointer aData) {
+ NS_ASSERTION((IS_MAI_OBJECT(aAtkObj)), "Invalid AtkObject");
+ NS_ASSERTION(aData, "Invalid Data to init AtkObject");
+ if (!aAtkObj || !aData) return;
+
+ /* call parent init function */
+ /* AtkObjectClass has not a "initialize" function now,
+ * maybe it has later
+ */
+
+ if (ATK_OBJECT_CLASS(parent_class)->initialize) {
+ ATK_OBJECT_CLASS(parent_class)->initialize(aAtkObj, aData);
+ }
+
+ /* initialize object */
+ MAI_ATK_OBJECT(aAtkObj)->acc = static_cast<Accessible*>(aData);
+}
+
+void finalizeCB(GObject* aObj) {
+ if (!IS_MAI_OBJECT(aObj)) return;
+ NS_ASSERTION(!MAI_ATK_OBJECT(aObj)->acc, "acc NOT null");
+
+ // call parent finalize function
+ // finalize of GObjectClass will unref the accessible parent if has
+ if (G_OBJECT_CLASS(parent_class)->finalize) {
+ G_OBJECT_CLASS(parent_class)->finalize(aObj);
+ }
+}
+
+const gchar* getNameCB(AtkObject* aAtkObj) {
+ nsAutoString name;
+ if (Accessible* acc = GetInternalObj(aAtkObj)) {
+ acc->Name(name);
+ } else {
+ return nullptr;
+ }
+
+ // XXX Firing an event from here does not seem right
+ MaybeFireNameChange(aAtkObj, name);
+
+ return aAtkObj->name;
+}
+
+static void MaybeFireNameChange(AtkObject* aAtkObj, const nsString& aNewName) {
+ NS_ConvertUTF16toUTF8 newNameUTF8(aNewName);
+ if (aAtkObj->name && !strcmp(aAtkObj->name, newNameUTF8.get())) return;
+
+ // Below we duplicate the functionality of atk_object_set_name(),
+ // but without calling atk_object_get_name(). Instead of
+ // atk_object_get_name() we directly access aAtkObj->name. This is because
+ // atk_object_get_name() would call getNameCB() which would call
+ // MaybeFireNameChange() (or atk_object_set_name() before this problem was
+ // fixed) and we would get an infinite recursion.
+ // See http://bugzilla.mozilla.org/733712
+
+ // Do not notify for initial name setting.
+ // See bug http://bugzilla.gnome.org/665870
+ bool notify = !!aAtkObj->name;
+
+ free(aAtkObj->name);
+ aAtkObj->name = strdup(newNameUTF8.get());
+
+ if (notify) g_object_notify(G_OBJECT(aAtkObj), "accessible-name");
+}
+
+const gchar* getDescriptionCB(AtkObject* aAtkObj) {
+ nsAutoString uniDesc;
+ if (Accessible* acc = GetInternalObj(aAtkObj)) {
+ acc->Description(uniDesc);
+ } else {
+ return nullptr;
+ }
+
+ NS_ConvertUTF8toUTF16 objDesc(aAtkObj->description);
+ if (!uniDesc.Equals(objDesc)) {
+ atk_object_set_description(aAtkObj, NS_ConvertUTF16toUTF8(uniDesc).get());
+ }
+
+ return aAtkObj->description;
+}
+
+AtkRole getRoleCB(AtkObject* aAtkObj) {
+ if (aAtkObj->role != ATK_ROLE_INVALID) return aAtkObj->role;
+
+ Accessible* acc = GetInternalObj(aAtkObj);
+ if (!acc) {
+ return ATK_ROLE_INVALID;
+ }
+
+#ifdef DEBUG
+ if (AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj)) {
+ NS_ASSERTION(nsAccUtils::IsTextInterfaceSupportCorrect(accWrap),
+ "Does not support Text interface when it should");
+ }
+#endif
+
+#define ROLE(geckoRole, stringRole, ariaRole, atkRole, macRole, macSubrole, \
+ msaaRole, ia2Role, androidClass, nameRule) \
+ case roles::geckoRole: \
+ aAtkObj->role = atkRole; \
+ break;
+
+ switch (acc->Role()) {
+#include "RoleMap.h"
+ default:
+ MOZ_CRASH("Unknown role.");
+ }
+
+#undef ROLE
+
+ if (aAtkObj->role == ATK_ROLE_LIST_BOX && !IsAtkVersionAtLeast(2, 1)) {
+ aAtkObj->role = ATK_ROLE_LIST;
+ } else if (aAtkObj->role == ATK_ROLE_TABLE_ROW &&
+ !IsAtkVersionAtLeast(2, 1)) {
+ aAtkObj->role = ATK_ROLE_LIST_ITEM;
+ } else if (aAtkObj->role == ATK_ROLE_MATH && !IsAtkVersionAtLeast(2, 12)) {
+ aAtkObj->role = ATK_ROLE_SECTION;
+ } else if (aAtkObj->role == ATK_ROLE_COMMENT && !IsAtkVersionAtLeast(2, 12)) {
+ aAtkObj->role = ATK_ROLE_SECTION;
+ } else if (aAtkObj->role == ATK_ROLE_LANDMARK &&
+ !IsAtkVersionAtLeast(2, 12)) {
+ aAtkObj->role = ATK_ROLE_SECTION;
+ } else if (aAtkObj->role == ATK_ROLE_FOOTNOTE &&
+ !IsAtkVersionAtLeast(2, 25, 2)) {
+ aAtkObj->role = ATK_ROLE_SECTION;
+ } else if (aAtkObj->role == ATK_ROLE_STATIC && !IsAtkVersionAtLeast(2, 16)) {
+ aAtkObj->role = ATK_ROLE_TEXT;
+ } else if ((aAtkObj->role == ATK_ROLE_MATH_FRACTION ||
+ aAtkObj->role == ATK_ROLE_MATH_ROOT) &&
+ !IsAtkVersionAtLeast(2, 16)) {
+ aAtkObj->role = ATK_ROLE_SECTION;
+ } else if (aAtkObj->role == ATK_ROLE_MARK && !IsAtkVersionAtLeast(2, 36)) {
+ aAtkObj->role = ATK_ROLE_TEXT;
+ } else if (aAtkObj->role == ATK_ROLE_SUGGESTION &&
+ !IsAtkVersionAtLeast(2, 36)) {
+ aAtkObj->role = ATK_ROLE_SECTION;
+ } else if (aAtkObj->role == ATK_ROLE_COMMENT && !IsAtkVersionAtLeast(2, 36)) {
+ aAtkObj->role = ATK_ROLE_SECTION;
+ } else if ((aAtkObj->role == ATK_ROLE_CONTENT_DELETION ||
+ aAtkObj->role == ATK_ROLE_CONTENT_INSERTION) &&
+ !IsAtkVersionAtLeast(2, 34)) {
+ aAtkObj->role = ATK_ROLE_SECTION;
+ }
+
+ return aAtkObj->role;
+}
+
+static AtkAttributeSet* ConvertToAtkAttributeSet(AccAttributes* aAttributes) {
+ if (!aAttributes) {
+ return nullptr;
+ }
+
+ AtkAttributeSet* objAttributeSet = nullptr;
+
+ for (auto iter : *aAttributes) {
+ nsAutoString name;
+ iter.NameAsString(name);
+ if (name.Equals(u"placeholder")) {
+ name.AssignLiteral(u"placeholder-text");
+ }
+
+ nsAutoString value;
+ iter.ValueAsString(value);
+
+ AtkAttribute* objAttr = (AtkAttribute*)g_malloc(sizeof(AtkAttribute));
+ objAttr->name = g_strdup(NS_ConvertUTF16toUTF8(name).get());
+ objAttr->value = g_strdup(NS_ConvertUTF16toUTF8(value).get());
+ objAttributeSet = g_slist_prepend(objAttributeSet, objAttr);
+ }
+
+ // libspi will free it
+ return objAttributeSet;
+}
+
+AtkAttributeSet* getAttributesCB(AtkObject* aAtkObj) {
+ Accessible* acc = GetInternalObj(aAtkObj);
+ if (!acc) {
+ return nullptr;
+ }
+ RefPtr<AccAttributes> attributes = acc->Attributes();
+ return ConvertToAtkAttributeSet(attributes);
+}
+
+const gchar* GetLocaleCB(AtkObject* aAtkObj) {
+ Accessible* acc = GetInternalObj(aAtkObj);
+ if (!acc) {
+ return nullptr;
+ }
+
+ nsAutoString locale;
+ acc->Language(locale);
+ return AccessibleWrap::ReturnString(locale);
+}
+
+AtkObject* getParentCB(AtkObject* aAtkObj) {
+ if (aAtkObj->accessible_parent) return aAtkObj->accessible_parent;
+
+ Accessible* acc = GetInternalObj(aAtkObj);
+ if (!acc) {
+ return nullptr;
+ }
+
+ Accessible* parent = acc->Parent();
+ AtkObject* atkParent = parent ? GetWrapperFor(parent) : nullptr;
+ if (atkParent) atk_object_set_parent(aAtkObj, atkParent);
+
+ return aAtkObj->accessible_parent;
+}
+
+gint getChildCountCB(AtkObject* aAtkObj) {
+ Accessible* acc = GetInternalObj(aAtkObj);
+ if (!acc || nsAccUtils::MustPrune(acc)) {
+ return 0;
+ }
+ return static_cast<gint>(acc->EmbeddedChildCount());
+}
+
+AtkObject* refChildCB(AtkObject* aAtkObj, gint aChildIndex) {
+ // aChildIndex should not be less than zero
+ if (aChildIndex < 0) {
+ return nullptr;
+ }
+
+ Accessible* acc = GetInternalObj(aAtkObj);
+ if (!acc || nsAccUtils::MustPrune(acc)) {
+ return nullptr;
+ }
+ Accessible* accChild = acc->EmbeddedChildAt(aChildIndex);
+ if (!accChild) {
+ return nullptr;
+ }
+
+ AtkObject* childAtkObj = GetWrapperFor(accChild);
+ NS_ASSERTION(childAtkObj, "Fail to get AtkObj");
+ if (!childAtkObj) {
+ return nullptr;
+ }
+
+ g_object_ref(childAtkObj);
+
+ if (aAtkObj != childAtkObj->accessible_parent) {
+ atk_object_set_parent(childAtkObj, aAtkObj);
+ }
+
+ return childAtkObj;
+}
+
+gint getIndexInParentCB(AtkObject* aAtkObj) {
+ // We don't use LocalAccessible::IndexInParent() because we don't include text
+ // leaf nodes as children in ATK.
+ Accessible* acc = GetInternalObj(aAtkObj);
+ if (!acc) {
+ return -1;
+ }
+ if (acc->IsDoc()) {
+ return 0;
+ }
+ Accessible* parent = acc->Parent();
+ if (!parent) {
+ return -1;
+ }
+ return parent->IndexOfEmbeddedChild(acc);
+}
+
+static void TranslateStates(uint64_t aState, roles::Role aRole,
+ AtkStateSet* aStateSet) {
+ // atk doesn't have a read only state so read only things shouldn't be
+ // editable. However, we don't do this for list items because Gecko always
+ // exposes those as read only.
+ if ((aState & states::READONLY) && aRole != roles::LISTITEM) {
+ aState &= ~states::EDITABLE;
+ }
+
+ // Convert every state to an entry in AtkStateMap
+ uint64_t bitMask = 1;
+ for (auto stateIndex = 0U; stateIndex < gAtkStateMapLen; stateIndex++) {
+ if (gAtkStateMap[stateIndex]
+ .atkState) { // There's potentially an ATK state for this
+ bool isStateOn = (aState & bitMask) != 0;
+ if (gAtkStateMap[stateIndex].stateMapEntryType == kMapOpposite) {
+ isStateOn = !isStateOn;
+ }
+ if (isStateOn) {
+ atk_state_set_add_state(aStateSet, gAtkStateMap[stateIndex].atkState);
+ }
+ }
+ bitMask <<= 1;
+ }
+}
+
+AtkStateSet* refStateSetCB(AtkObject* aAtkObj) {
+ AtkStateSet* state_set = nullptr;
+ state_set = ATK_OBJECT_CLASS(parent_class)->ref_state_set(aAtkObj);
+
+ if (Accessible* acc = GetInternalObj(aAtkObj)) {
+ TranslateStates(acc->State(), acc->Role(), state_set);
+ } else {
+ TranslateStates(states::DEFUNCT, roles::NOTHING, state_set);
+ }
+
+ return state_set;
+}
+
+static void UpdateAtkRelation(RelationType aType, Accessible* aAcc,
+ AtkRelationType aAtkType,
+ AtkRelationSet* aAtkSet) {
+ if (aAtkType == ATK_RELATION_NULL) return;
+
+ AtkRelation* atkRelation =
+ atk_relation_set_get_relation_by_type(aAtkSet, aAtkType);
+ if (atkRelation) atk_relation_set_remove(aAtkSet, atkRelation);
+
+ Relation rel(aAcc->RelationByType(aType));
+ nsTArray<AtkObject*> targets;
+ Accessible* tempAcc = nullptr;
+ while ((tempAcc = rel.Next())) {
+ targets.AppendElement(GetWrapperFor(tempAcc));
+ }
+
+ if (targets.Length()) {
+ atkRelation =
+ atk_relation_new(targets.Elements(), targets.Length(), aAtkType);
+ atk_relation_set_add(aAtkSet, atkRelation);
+ g_object_unref(atkRelation);
+ }
+}
+
+AtkRelationSet* refRelationSetCB(AtkObject* aAtkObj) {
+ AtkRelationSet* relation_set =
+ ATK_OBJECT_CLASS(parent_class)->ref_relation_set(aAtkObj);
+
+ Accessible* acc = GetInternalObj(aAtkObj);
+ if (!acc) {
+ return relation_set;
+ }
+
+#define RELATIONTYPE(geckoType, geckoTypeName, atkType, msaaType, ia2Type) \
+ UpdateAtkRelation(RelationType::geckoType, acc, atkType, relation_set);
+
+#include "RelationTypeMap.h"
+
+#undef RELATIONTYPE
+
+ return relation_set;
+}
+
+// Check if aAtkObj is a valid MaiAtkObject, and return the AccessibleWrap
+// for it.
+AccessibleWrap* GetAccessibleWrap(AtkObject* aAtkObj) {
+ NS_ENSURE_TRUE(IS_MAI_OBJECT(aAtkObj), nullptr);
+
+ // If we're working with an ATK object, we need to convert the Accessible
+ // back to an AccessibleWrap:
+ Accessible* storedAcc = MAI_ATK_OBJECT(aAtkObj)->acc;
+ if (!storedAcc) {
+ return nullptr;
+ }
+ auto* accWrap = static_cast<AccessibleWrap*>(storedAcc->AsLocal());
+
+ // Check if the accessible was deconstructed.
+ if (!accWrap) return nullptr;
+
+ NS_ENSURE_TRUE(accWrap->GetAtkObject() == aAtkObj, nullptr);
+
+ AccessibleWrap* appAccWrap = ApplicationAcc();
+ if (appAccWrap != accWrap && !accWrap->IsValidObject()) {
+ return nullptr;
+ }
+
+ return accWrap;
+}
+
+RemoteAccessible* GetProxy(AtkObject* aObj) {
+ Accessible* acc = GetInternalObj(aObj);
+ if (!acc) {
+ return nullptr;
+ }
+
+ return acc->AsRemote();
+}
+
+Accessible* GetInternalObj(AtkObject* aObj) {
+ if (!aObj || !IS_MAI_OBJECT(aObj)) return nullptr;
+
+ return MAI_ATK_OBJECT(aObj)->acc;
+}
+
+AtkObject* GetWrapperFor(Accessible* aAcc) {
+ if (!aAcc) {
+ return nullptr;
+ }
+
+ if (aAcc->IsRemote()) {
+ return reinterpret_cast<AtkObject*>(aAcc->AsRemote()->GetWrapper());
+ }
+
+ return AccessibleWrap::GetAtkObject(aAcc->AsLocal());
+}
+
+static uint16_t GetInterfacesForProxy(RemoteAccessible* aProxy) {
+ uint16_t interfaces = 1 << MAI_INTERFACE_COMPONENT;
+ if (aProxy->IsHyperText()) {
+ interfaces |= (1 << MAI_INTERFACE_HYPERTEXT) | (1 << MAI_INTERFACE_TEXT) |
+ (1 << MAI_INTERFACE_EDITABLE_TEXT);
+ }
+
+ if (aProxy->IsLink()) {
+ interfaces |= 1 << MAI_INTERFACE_HYPERLINK_IMPL;
+ }
+
+ if (aProxy->HasNumericValue()) {
+ interfaces |= 1 << MAI_INTERFACE_VALUE;
+ }
+
+ if (aProxy->IsTable()) {
+ interfaces |= 1 << MAI_INTERFACE_TABLE;
+ }
+
+ if (aProxy->IsTableCell()) {
+ interfaces |= 1 << MAI_INTERFACE_TABLE_CELL;
+ }
+
+ if (aProxy->IsImage()) {
+ interfaces |= 1 << MAI_INTERFACE_IMAGE;
+ }
+
+ if (aProxy->IsDoc()) {
+ interfaces |= 1 << MAI_INTERFACE_DOCUMENT;
+ }
+
+ if (aProxy->IsSelect()) {
+ interfaces |= 1 << MAI_INTERFACE_SELECTION;
+ }
+
+ if (aProxy->IsActionable()) {
+ interfaces |= 1 << MAI_INTERFACE_ACTION;
+ }
+
+ return interfaces;
+}
+
+void a11y::ProxyCreated(RemoteAccessible* aProxy) {
+ MOZ_ASSERT(aProxy->RemoteParent() || aProxy->IsDoc(),
+ "Need parent to check for HyperLink interface");
+ GType type = GetMaiAtkType(GetInterfacesForProxy(aProxy));
+ NS_ASSERTION(type, "why don't we have a type!");
+
+ AtkObject* obj = reinterpret_cast<AtkObject*>(g_object_new(type, nullptr));
+ if (!obj) return;
+
+ atk_object_initialize(obj, static_cast<Accessible*>(aProxy));
+ obj->role = ATK_ROLE_INVALID;
+ obj->layer = ATK_LAYER_INVALID;
+ aProxy->SetWrapper(reinterpret_cast<uintptr_t>(obj));
+}
+
+void a11y::ProxyDestroyed(RemoteAccessible* aProxy) {
+ auto obj = reinterpret_cast<MaiAtkObject*>(aProxy->GetWrapper());
+ if (!obj) {
+ return;
+ }
+
+ obj->Shutdown();
+ g_object_unref(obj);
+ aProxy->SetWrapper(0);
+}
+
+void a11y::PlatformEvent(Accessible* aTarget, uint32_t aEventType) {
+ AtkObject* wrapper = GetWrapperFor(aTarget);
+
+ switch (aEventType) {
+ case nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE:
+ if (aTarget->IsDoc()) {
+ g_signal_emit_by_name(wrapper, "load_complete");
+ }
+ // XXX - Handle native dialog accessibles.
+ if (!aTarget->IsRoot() && aTarget->HasARIARole() &&
+ aTarget->Role() == roles::DIALOG) {
+ guint id = g_signal_lookup("activate", MAI_TYPE_ATK_OBJECT);
+ g_signal_emit(wrapper, id, 0);
+ }
+ break;
+ case nsIAccessibleEvent::EVENT_DOCUMENT_RELOAD:
+ if (aTarget->IsDoc()) {
+ g_signal_emit_by_name(wrapper, "reload");
+ }
+ break;
+ case nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_STOPPED:
+ if (aTarget->IsDoc()) {
+ g_signal_emit_by_name(wrapper, "load_stopped");
+ }
+ break;
+ case nsIAccessibleEvent::EVENT_MENUPOPUP_START:
+ atk_focus_tracker_notify(wrapper); // fire extra focus event
+ atk_object_notify_state_change(wrapper, ATK_STATE_VISIBLE, true);
+ atk_object_notify_state_change(wrapper, ATK_STATE_SHOWING, true);
+ break;
+ case nsIAccessibleEvent::EVENT_MENUPOPUP_END:
+ atk_object_notify_state_change(wrapper, ATK_STATE_VISIBLE, false);
+ atk_object_notify_state_change(wrapper, ATK_STATE_SHOWING, false);
+ break;
+ case nsIAccessibleEvent::EVENT_ALERT:
+ // A hack using state change showing events as alert events.
+ atk_object_notify_state_change(wrapper, ATK_STATE_SHOWING, true);
+ break;
+ case nsIAccessibleEvent::EVENT_VALUE_CHANGE:
+ case nsIAccessibleEvent::EVENT_TEXT_VALUE_CHANGE:
+ if (aTarget->HasNumericValue()) {
+ // Make sure this is a numeric value. Don't fire for string value
+ // changes (e.g. text editing) ATK values are always numeric.
+ g_object_notify((GObject*)wrapper, "accessible-value");
+ }
+ break;
+ case nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED:
+ g_signal_emit_by_name(wrapper, "text_selection_changed");
+ break;
+ case nsIAccessibleEvent::EVENT_SELECTION_WITHIN:
+ g_signal_emit_by_name(wrapper, "selection_changed");
+ break;
+ case nsIAccessibleEvent::EVENT_TEXT_ATTRIBUTE_CHANGED:
+ g_signal_emit_by_name(wrapper, "text-attributes-changed");
+ break;
+ case nsIAccessibleEvent::EVENT_NAME_CHANGE: {
+ nsAutoString newName;
+ aTarget->Name(newName);
+ MaybeFireNameChange(wrapper, newName);
+ break;
+ }
+ case nsIAccessibleEvent::EVENT_WINDOW_ACTIVATE: {
+ guint id = g_signal_lookup("activate", MAI_TYPE_ATK_OBJECT);
+ g_signal_emit(wrapper, id, 0);
+ // Always fire a current focus event after activation.
+ FocusMgr()->ForceFocusEvent();
+ break;
+ }
+ case nsIAccessibleEvent::EVENT_WINDOW_DEACTIVATE: {
+ guint id = g_signal_lookup("deactivate", MAI_TYPE_ATK_OBJECT);
+ g_signal_emit(wrapper, id, 0);
+ break;
+ }
+ case nsIAccessibleEvent::EVENT_WINDOW_MAXIMIZE: {
+ guint id = g_signal_lookup("maximize", MAI_TYPE_ATK_OBJECT);
+ g_signal_emit(wrapper, id, 0);
+ break;
+ }
+ case nsIAccessibleEvent::EVENT_WINDOW_MINIMIZE: {
+ guint id = g_signal_lookup("minimize", MAI_TYPE_ATK_OBJECT);
+ g_signal_emit(wrapper, id, 0);
+ break;
+ }
+ case nsIAccessibleEvent::EVENT_WINDOW_RESTORE: {
+ guint id = g_signal_lookup("restore", MAI_TYPE_ATK_OBJECT);
+ g_signal_emit(wrapper, id, 0);
+ break;
+ }
+ }
+}
+
+void a11y::PlatformStateChangeEvent(Accessible* aTarget, uint64_t aState,
+ bool aEnabled) {
+ MaiAtkObject* atkObj = MAI_ATK_OBJECT(GetWrapperFor(aTarget));
+ atkObj->FireStateChangeEvent(aState, aEnabled);
+}
+
+void a11y::PlatformFocusEvent(Accessible* aTarget,
+ const LayoutDeviceIntRect& aCaretRect) {
+ AtkObject* wrapper = GetWrapperFor(aTarget);
+
+ // XXX Do we really need this check? If so, do we need a similar check for
+ // RemoteAccessible?
+ if (LocalAccessible* localTarget = aTarget->AsLocal()) {
+ a11y::RootAccessible* rootAcc = localTarget->RootAccessible();
+ if (!rootAcc || !rootAcc->IsActivated()) {
+ return;
+ }
+ }
+
+ atk_focus_tracker_notify(wrapper);
+ atk_object_notify_state_change(wrapper, ATK_STATE_FOCUSED, true);
+}
+
+void a11y::PlatformCaretMoveEvent(Accessible* aTarget, int32_t aOffset,
+ bool aIsSelectionCollapsed,
+ int32_t aGranularity,
+ const LayoutDeviceIntRect& aCaretRect,
+ bool aFromUser) {
+ AtkObject* wrapper = GetWrapperFor(aTarget);
+ g_signal_emit_by_name(wrapper, "text_caret_moved", aOffset);
+}
+
+void MaiAtkObject::FireStateChangeEvent(uint64_t aState, bool aEnabled) {
+ auto state = aState;
+ int32_t stateIndex = -1;
+ while (state > 0) {
+ ++stateIndex;
+ state >>= 1;
+ }
+
+ MOZ_ASSERT(
+ stateIndex >= 0 && stateIndex < static_cast<int32_t>(gAtkStateMapLen),
+ "No ATK state for internal state was found");
+ if (stateIndex < 0 || stateIndex >= static_cast<int32_t>(gAtkStateMapLen)) {
+ return;
+ }
+
+ if (gAtkStateMap[stateIndex].atkState != kNone) {
+ MOZ_ASSERT(gAtkStateMap[stateIndex].stateMapEntryType != kNoStateChange,
+ "State changes should not fired for this state");
+
+ if (gAtkStateMap[stateIndex].stateMapEntryType == kMapOpposite) {
+ aEnabled = !aEnabled;
+ }
+
+ // Fire state change for first state if there is one to map
+ atk_object_notify_state_change(&parent, gAtkStateMap[stateIndex].atkState,
+ aEnabled);
+ }
+}
+
+void a11y::PlatformTextChangeEvent(Accessible* aTarget, const nsAString& aStr,
+ int32_t aStart, uint32_t aLen,
+ bool aIsInsert, bool aFromUser) {
+ MaiAtkObject* atkObj = MAI_ATK_OBJECT(GetWrapperFor(aTarget));
+ atkObj->FireTextChangeEvent(aStr, aStart, aLen, aIsInsert, aFromUser);
+}
+
+#define OLD_TEXT_INSERTED "text_changed::insert"
+#define OLD_TEXT_REMOVED "text_changed::delete"
+static const char* oldTextChangeStrings[2][2] = {
+ {OLD_TEXT_REMOVED NON_USER_EVENT, OLD_TEXT_INSERTED NON_USER_EVENT},
+ {OLD_TEXT_REMOVED, OLD_TEXT_INSERTED}};
+
+#define TEXT_INSERTED "text-insert"
+#define TEXT_REMOVED "text-remove"
+#define NON_USER_DETAIL "::system"
+static const char* textChangedStrings[2][2] = {
+ {TEXT_REMOVED NON_USER_DETAIL, TEXT_INSERTED NON_USER_DETAIL},
+ {TEXT_REMOVED, TEXT_INSERTED}};
+
+void MaiAtkObject::FireTextChangeEvent(const nsAString& aStr, int32_t aStart,
+ uint32_t aLen, bool aIsInsert,
+ bool aFromUser) {
+ if (gAvailableAtkSignals == eUnknown) {
+ gAvailableAtkSignals = g_signal_lookup("text-insert", G_OBJECT_TYPE(this))
+ ? eHaveNewAtkTextSignals
+ : eNoNewAtkSignals;
+ }
+
+ if (gAvailableAtkSignals == eNoNewAtkSignals) {
+ // XXX remove this code and the gHaveNewTextSignals check when we can
+ // stop supporting old atk since it doesn't really work anyway
+ // see bug 619002
+ const char* signal_name = oldTextChangeStrings[aFromUser][aIsInsert];
+ g_signal_emit_by_name(this, signal_name, aStart, aLen);
+ } else {
+ const char* signal_name = textChangedStrings[aFromUser][aIsInsert];
+ g_signal_emit_by_name(this, signal_name, aStart, aLen,
+ NS_ConvertUTF16toUTF8(aStr).get());
+ }
+}
+
+void a11y::PlatformShowHideEvent(Accessible* aTarget, Accessible* aParent,
+ bool aInsert, bool aFromUser) {
+ AtkObject* atkObj = GetWrapperFor(aTarget);
+ if (!aInsert) {
+ // XXX - Handle native dialog accessibles.
+ if (!aTarget->IsRoot() && aTarget->HasARIARole() &&
+ aTarget->Role() == roles::DIALOG) {
+ guint id = g_signal_lookup("deactivate", MAI_TYPE_ATK_OBJECT);
+ g_signal_emit(atkObj, id, 0);
+ }
+ }
+
+ MaiAtkObject* obj = MAI_ATK_OBJECT(atkObj);
+ obj->FireAtkShowHideEvent(GetWrapperFor(aParent), aInsert, aFromUser);
+}
+
+#define ADD_EVENT "children_changed::add"
+#define HIDE_EVENT "children_changed::remove"
+
+static const char* kMutationStrings[2][2] = {
+ {HIDE_EVENT NON_USER_EVENT, ADD_EVENT NON_USER_EVENT},
+ {HIDE_EVENT, ADD_EVENT},
+};
+
+void MaiAtkObject::FireAtkShowHideEvent(AtkObject* aParent, bool aIsAdded,
+ bool aFromUser) {
+ if (!aParent) {
+ // XXX ATK needs a parent for these events. However, we might have already
+ // unbound from the parent by the time we fire a hide event. Ideally, we
+ // need to find a way to keep the parent around, but ATK clients don't seem
+ // to care about these missing events.
+ MOZ_ASSERT(!aIsAdded);
+ return;
+ }
+ int32_t indexInParent = getIndexInParentCB(&this->parent);
+ const char* signal_name = kMutationStrings[aFromUser][aIsAdded];
+ g_signal_emit_by_name(aParent, signal_name, indexInParent, this, nullptr);
+}
+
+void a11y::PlatformSelectionEvent(Accessible*, Accessible* aWidget, uint32_t) {
+ MaiAtkObject* obj = MAI_ATK_OBJECT(GetWrapperFor(aWidget));
+ g_signal_emit_by_name(obj, "selection_changed");
+}
+
+// static
+void AccessibleWrap::GetKeyBinding(Accessible* aAccessible,
+ nsAString& aResult) {
+ // Return all key bindings including access key and keyboard shortcut.
+
+ // Get access key.
+ nsAutoString keyBindingsStr;
+ KeyBinding keyBinding = aAccessible->AccessKey();
+ if (!keyBinding.IsEmpty()) {
+ keyBinding.AppendToString(keyBindingsStr, KeyBinding::eAtkFormat);
+
+ Accessible* parent = aAccessible->Parent();
+ roles::Role role = parent ? parent->Role() : roles::NOTHING;
+ if (role == roles::PARENT_MENUITEM || role == roles::MENUITEM ||
+ role == roles::RADIO_MENU_ITEM || role == roles::CHECK_MENU_ITEM) {
+ // It is submenu, expose keyboard shortcuts from menu hierarchy like
+ // "s;<Alt>f:s"
+ nsAutoString keysInHierarchyStr = keyBindingsStr;
+ do {
+ KeyBinding parentKeyBinding = parent->AccessKey();
+ if (!parentKeyBinding.IsEmpty()) {
+ nsAutoString str;
+ parentKeyBinding.ToString(str, KeyBinding::eAtkFormat);
+ str.Append(':');
+
+ keysInHierarchyStr.Insert(str, 0);
+ }
+ } while ((parent = parent->Parent()) && parent->Role() != roles::MENUBAR);
+
+ keyBindingsStr.Append(';');
+ keyBindingsStr.Append(keysInHierarchyStr);
+ }
+ } else {
+ // No access key, add ';' to point this.
+ keyBindingsStr.Append(';');
+ }
+
+ // Get keyboard shortcut.
+ keyBindingsStr.Append(';');
+ if (LocalAccessible* localAcc = aAccessible->AsLocal()) {
+ keyBinding = localAcc->KeyboardShortcut();
+ if (!keyBinding.IsEmpty()) {
+ keyBinding.AppendToString(keyBindingsStr, KeyBinding::eAtkFormat);
+ }
+ }
+ aResult = keyBindingsStr;
+}
+
+// static
+Accessible* AccessibleWrap::GetColumnHeader(TableAccessible* aAccessible,
+ int32_t aColIdx) {
+ if (!aAccessible) {
+ return nullptr;
+ }
+
+ Accessible* cell = aAccessible->CellAt(0, aColIdx);
+ if (!cell) {
+ return nullptr;
+ }
+
+ // If the cell at the first row is column header then assume it is column
+ // header for all rows,
+ if (cell->Role() == roles::COLUMNHEADER) {
+ return cell;
+ }
+
+ // otherwise get column header for the data cell at the first row.
+ TableCellAccessible* tableCell = cell->AsTableCell();
+ if (!tableCell) {
+ return nullptr;
+ }
+
+ AutoTArray<Accessible*, 10> headerCells;
+ tableCell->ColHeaderCells(&headerCells);
+ if (headerCells.IsEmpty()) {
+ return nullptr;
+ }
+
+ return headerCells[0];
+}
+
+// static
+Accessible* AccessibleWrap::GetRowHeader(TableAccessible* aAccessible,
+ int32_t aRowIdx) {
+ if (!aAccessible) {
+ return nullptr;
+ }
+
+ Accessible* cell = aAccessible->CellAt(aRowIdx, 0);
+ if (!cell) {
+ return nullptr;
+ }
+
+ // If the cell at the first column is row header then assume it is row
+ // header for all columns,
+ if (cell->Role() == roles::ROWHEADER) {
+ return cell;
+ }
+
+ // otherwise get row header for the data cell at the first column.
+ TableCellAccessible* tableCell = cell->AsTableCell();
+ if (!tableCell) {
+ return nullptr;
+ }
+
+ AutoTArray<Accessible*, 10> headerCells;
+ tableCell->RowHeaderCells(&headerCells);
+ if (headerCells.IsEmpty()) {
+ return nullptr;
+ }
+
+ return headerCells[0];
+}