diff options
Diffstat (limited to 'accessible/atk/UtilInterface.cpp')
| -rw-r--r-- | accessible/atk/UtilInterface.cpp | 346 |
1 files changed, 346 insertions, 0 deletions
diff --git a/accessible/atk/UtilInterface.cpp b/accessible/atk/UtilInterface.cpp new file mode 100644 index 0000000000..5cc347f91b --- /dev/null +++ b/accessible/atk/UtilInterface.cpp @@ -0,0 +1,346 @@ +/* -*- 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 "ApplicationAccessibleWrap.h" +#include "mozilla/Likely.h" +#include "nsAccessibilityService.h" +#include "nsMai.h" + +#include <atk/atk.h> +#include <gtk/gtk.h> +#include <string.h> + +using namespace mozilla; +using namespace mozilla::a11y; + +typedef AtkUtil MaiUtil; +typedef AtkUtilClass MaiUtilClass; + +#define MAI_VERSION MOZILLA_VERSION +#define MAI_NAME "Gecko" + +extern "C" { +static guint (*gail_add_global_event_listener)(GSignalEmissionHook listener, + const gchar* event_type); +static void (*gail_remove_global_event_listener)(guint remove_listener); +static void (*gail_remove_key_event_listener)(guint remove_listener); +static AtkObject* (*gail_get_root)(); +} + +struct MaiUtilListenerInfo { + gint key; + guint signal_id; + gulong hook_id; + // For window create/destory/minimize/maximize/restore/activate/deactivate + // events, we'll chain gail_util's add/remove_global_event_listener. + // So we store the listenerid returned by gail's add_global_event_listener + // in this structure to call gail's remove_global_event_listener later. + guint gail_listenerid; +}; + +static GHashTable* sListener_list = nullptr; +static gint sListener_idx = 1; + +extern "C" { +static guint add_listener(GSignalEmissionHook listener, + const gchar* object_type, const gchar* signal, + const gchar* hook_data, guint gail_listenerid = 0) { + GType type; + guint signal_id; + gint rc = 0; + + type = g_type_from_name(object_type); + if (type) { + signal_id = g_signal_lookup(signal, type); + if (signal_id > 0) { + MaiUtilListenerInfo* listener_info; + + rc = sListener_idx; + + listener_info = + (MaiUtilListenerInfo*)g_malloc(sizeof(MaiUtilListenerInfo)); + listener_info->key = sListener_idx; + listener_info->hook_id = g_signal_add_emission_hook( + signal_id, 0, listener, g_strdup(hook_data), (GDestroyNotify)g_free); + listener_info->signal_id = signal_id; + listener_info->gail_listenerid = gail_listenerid; + + g_hash_table_insert(sListener_list, &(listener_info->key), listener_info); + sListener_idx++; + } else { + g_warning("Invalid signal type %s\n", signal); + } + } else { + g_warning("Invalid object type %s\n", object_type); + } + return rc; +} + +static guint mai_util_add_global_event_listener(GSignalEmissionHook listener, + const gchar* event_type) { + guint rc = 0; + gchar** split_string; + + split_string = g_strsplit(event_type, ":", 3); + + if (split_string) { + if (!strcmp("window", split_string[0])) { + guint gail_listenerid = 0; + if (gail_add_global_event_listener) { + // call gail's function to track gtk native window events + gail_listenerid = gail_add_global_event_listener(listener, event_type); + } + + rc = add_listener(listener, "MaiAtkObject", split_string[1], event_type, + gail_listenerid); + } else { + rc = add_listener(listener, split_string[1], split_string[2], event_type); + } + g_strfreev(split_string); + } + return rc; +} + +static void mai_util_remove_global_event_listener(guint remove_listener) { + if (remove_listener > 0) { + MaiUtilListenerInfo* listener_info; + gint tmp_idx = remove_listener; + + listener_info = + (MaiUtilListenerInfo*)g_hash_table_lookup(sListener_list, &tmp_idx); + + if (listener_info != nullptr) { + if (gail_remove_global_event_listener && listener_info->gail_listenerid) { + gail_remove_global_event_listener(listener_info->gail_listenerid); + } + + /* Hook id of 0 and signal id of 0 are invalid */ + if (listener_info->hook_id != 0 && listener_info->signal_id != 0) { + /* Remove the emission hook */ + g_signal_remove_emission_hook(listener_info->signal_id, + listener_info->hook_id); + + /* Remove the element from the hash */ + g_hash_table_remove(sListener_list, &tmp_idx); + } else { + g_warning("Invalid listener hook_id %ld or signal_id %d\n", + listener_info->hook_id, listener_info->signal_id); + } + } else { + // atk-bridge is initialized with gail (e.g. yelp) + // try gail_remove_global_event_listener + if (gail_remove_global_event_listener) { + return gail_remove_global_event_listener(remove_listener); + } + + g_warning("No listener with the specified listener id %d", + remove_listener); + } + } else { + g_warning("Invalid listener_id %d", remove_listener); + } +} + +static AtkKeyEventStruct* atk_key_event_from_gdk_event_key(GdkEventKey* key) { + AtkKeyEventStruct* event = g_new0(AtkKeyEventStruct, 1); + switch (key->type) { + case GDK_KEY_PRESS: + event->type = ATK_KEY_EVENT_PRESS; + break; + case GDK_KEY_RELEASE: + event->type = ATK_KEY_EVENT_RELEASE; + break; + default: + g_assert_not_reached(); + return nullptr; + } + event->state = key->state; + event->keyval = key->keyval; + event->length = key->length; + if (key->string && key->string[0] && + g_unichar_isgraph(g_utf8_get_char(key->string))) { + event->string = key->string; + } else if (key->type == GDK_KEY_PRESS || key->type == GDK_KEY_RELEASE) { + event->string = gdk_keyval_name(key->keyval); + } + event->keycode = key->hardware_keycode; + event->timestamp = key->time; + + return event; +} + +struct MaiKeyEventInfo { + AtkKeyEventStruct* key_event; + gpointer func_data; +}; + +union AtkKeySnoopFuncPointer { + AtkKeySnoopFunc func_ptr; + gpointer data; +}; + +static gboolean notify_hf(gpointer key, gpointer value, gpointer data) { + MaiKeyEventInfo* info = (MaiKeyEventInfo*)data; + AtkKeySnoopFuncPointer atkKeySnoop; + atkKeySnoop.data = value; + return (atkKeySnoop.func_ptr)(info->key_event, info->func_data) ? TRUE + : FALSE; +} + +static void insert_hf(gpointer key, gpointer value, gpointer data) { + GHashTable* new_table = (GHashTable*)data; + g_hash_table_insert(new_table, key, value); +} + +static GHashTable* sKey_listener_list = nullptr; + +static gint mai_key_snooper(GtkWidget* the_widget, GdkEventKey* event, + gpointer func_data) { + /* notify each AtkKeySnoopFunc in turn... */ + + MaiKeyEventInfo* info = g_new0(MaiKeyEventInfo, 1); + gint consumed = 0; + if (sKey_listener_list) { + GHashTable* new_hash = g_hash_table_new(nullptr, nullptr); + g_hash_table_foreach(sKey_listener_list, insert_hf, new_hash); + info->key_event = atk_key_event_from_gdk_event_key(event); + info->func_data = func_data; + consumed = g_hash_table_foreach_steal(new_hash, notify_hf, info); + g_hash_table_destroy(new_hash); + g_free(info->key_event); + } + g_free(info); + return (consumed ? 1 : 0); +} + +static guint sKey_snooper_id = 0; + +static guint mai_util_add_key_event_listener(AtkKeySnoopFunc listener, + gpointer data) { + if (MOZ_UNLIKELY(!listener)) { + return 0; + } + + static guint key = 0; + + if (!sKey_listener_list) { + sKey_listener_list = g_hash_table_new(nullptr, nullptr); + } + + // If we have no registered event listeners then we need to (re)install the + // key event snooper. + if (g_hash_table_size(sKey_listener_list) == 0) { + sKey_snooper_id = gtk_key_snooper_install(mai_key_snooper, data); + } + + AtkKeySnoopFuncPointer atkKeySnoop; + atkKeySnoop.func_ptr = listener; + key++; + g_hash_table_insert(sKey_listener_list, GUINT_TO_POINTER(key), + atkKeySnoop.data); + return key; +} + +static void mai_util_remove_key_event_listener(guint remove_listener) { + if (!sKey_listener_list) { + // atk-bridge is initialized with gail (e.g. yelp) + // try gail_remove_key_event_listener + return gail_remove_key_event_listener(remove_listener); + } + + g_hash_table_remove(sKey_listener_list, GUINT_TO_POINTER(remove_listener)); + if (g_hash_table_size(sKey_listener_list) == 0) { + gtk_key_snooper_remove(sKey_snooper_id); + } +} + +static AtkObject* mai_util_get_root() { + ApplicationAccessible* app = ApplicationAcc(); + if (app) return app->GetAtkObject(); + + // We've shutdown, try to use gail instead + // (to avoid assert in spi_atk_tidy_windows()) + // XXX tbsaunde then why didn't we replace the gail atk_util impl? + if (gail_get_root) return gail_get_root(); + + return nullptr; +} + +static const gchar* mai_util_get_toolkit_name() { return MAI_NAME; } + +static const gchar* mai_util_get_toolkit_version() { return MAI_VERSION; } + +static void _listener_info_destroy(gpointer data) { g_free(data); } + +static void window_added(AtkObject* atk_obj, guint index, AtkObject* child) { + if (!IS_MAI_OBJECT(child)) return; + + static guint id = g_signal_lookup("create", MAI_TYPE_ATK_OBJECT); + g_signal_emit(child, id, 0); +} + +static void window_removed(AtkObject* atk_obj, guint index, AtkObject* child) { + if (!IS_MAI_OBJECT(child)) return; + + static guint id = g_signal_lookup("destroy", MAI_TYPE_ATK_OBJECT); + g_signal_emit(child, id, 0); +} + +static void UtilInterfaceInit(MaiUtilClass* klass) { + AtkUtilClass* atk_class; + gpointer data; + + data = g_type_class_peek(ATK_TYPE_UTIL); + atk_class = ATK_UTIL_CLASS(data); + + // save gail function pointer + gail_add_global_event_listener = atk_class->add_global_event_listener; + gail_remove_global_event_listener = atk_class->remove_global_event_listener; + gail_remove_key_event_listener = atk_class->remove_key_event_listener; + gail_get_root = atk_class->get_root; + + atk_class->add_global_event_listener = mai_util_add_global_event_listener; + atk_class->remove_global_event_listener = + mai_util_remove_global_event_listener; + atk_class->add_key_event_listener = mai_util_add_key_event_listener; + atk_class->remove_key_event_listener = mai_util_remove_key_event_listener; + atk_class->get_root = mai_util_get_root; + atk_class->get_toolkit_name = mai_util_get_toolkit_name; + atk_class->get_toolkit_version = mai_util_get_toolkit_version; + + sListener_list = g_hash_table_new_full(g_int_hash, g_int_equal, nullptr, + _listener_info_destroy); + // Keep track of added/removed windows. + AtkObject* root = atk_get_root(); + g_signal_connect(root, "children-changed::add", (GCallback)window_added, + nullptr); + g_signal_connect(root, "children-changed::remove", (GCallback)window_removed, + nullptr); +} +} + +GType mai_util_get_type() { + static GType type = 0; + + if (!type) { + static const GTypeInfo tinfo = { + sizeof(MaiUtilClass), + (GBaseInitFunc) nullptr, /* base init */ + (GBaseFinalizeFunc) nullptr, /* base finalize */ + (GClassInitFunc)UtilInterfaceInit, /* class init */ + (GClassFinalizeFunc) nullptr, /* class finalize */ + nullptr, /* class data */ + sizeof(MaiUtil), /* instance size */ + 0, /* nb preallocs */ + (GInstanceInitFunc) nullptr, /* instance init */ + nullptr /* value table */ + }; + + type = + g_type_register_static(ATK_TYPE_UTIL, "MaiUtil", &tinfo, GTypeFlags(0)); + } + return type; +} |