/* -*- 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] && (key->state & GDK_CONTROL_MASK || 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; }