X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=atspi%2Fatspi-event-listener.c;h=e7e71165b158a7667adb1075e2bec7c95b377769;hb=376e88a463ad9d1f5110808879b68d6bb0a50910;hp=36dce898ef8adb59b5315d0c968525a484133371;hpb=05d45d055808d9195c23f108cf9e635f1d63270c;p=platform%2Fupstream%2Fat-spi2-core.git diff --git a/atspi/atspi-event-listener.c b/atspi/atspi-event-listener.c index 36dce89..e7e7116 100644 --- a/atspi/atspi-event-listener.c +++ b/atspi/atspi-event-listener.c @@ -4,56 +4,181 @@ * * Copyright 2002 Ximian Inc. * Copyright 2002 Sun Microsystems, Inc. + * Copyright 2010, 2011 Novell, Inc. * * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public + * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. + * version 2.1 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. + * Lesser General Public License for more details. * - * You should have received a copy of the GNU Library General Public + * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. */ #include "atspi-private.h" +#include "atspi-accessible-private.h" #include +#include +#include typedef struct { AtspiEventListenerCB callback; void *user_data; GDestroyNotify callback_destroyed; + char *event_type; char *category; char *name; char *detail; + GArray *properties; } EventListenerEntry; -/* - * Misc. helpers. - */ +G_DEFINE_TYPE (AtspiEventListener, atspi_event_listener, G_TYPE_OBJECT) -/* - * Standard event dispatcher +void +atspi_event_listener_init (AtspiEventListener *listener) +{ +} + +void +atspi_event_listener_class_init (AtspiEventListenerClass *klass) +{ +} + +static void +remove_datum (AtspiEvent *event, void *user_data) +{ + AtspiEventListenerSimpleCB cb = user_data; + cb (event); +} + +typedef struct +{ + gpointer callback; + GDestroyNotify callback_destroyed; + gint ref_count; +} CallbackInfo; +static GHashTable *callbacks; + +void +callback_ref (void *callback, GDestroyNotify callback_destroyed) +{ + CallbackInfo *info; + + if (!callbacks) + { + callbacks = g_hash_table_new (g_direct_hash, g_direct_equal); + if (!callbacks) + return; + } + + info = g_hash_table_lookup (callbacks, callback); + if (!info) + { + info = g_new (CallbackInfo, 1); + info->callback = callback; + info->callback_destroyed = callback_destroyed; + info->ref_count = 1; + g_hash_table_insert (callbacks, callback, info); + } + else + info->ref_count++; +} + +void +callback_unref (gpointer callback) +{ + CallbackInfo *info; + + if (!callbacks) + return; + info = g_hash_table_lookup (callbacks, callback); + if (!info) + { + g_warning ("AT-SPI: Dereferencing invalid callback %p\n", callback); + return; + } + info->ref_count--; + if (info->ref_count == 0) + { +#if 0 + /* TODO: Figure out why this seg faults from Python */ + if (info->callback_destroyed) + (*info->callback_destroyed) (info->callback); +#endif + g_free (info); + g_hash_table_remove (callbacks, callback); + } +} + +/** + * atspi_event_listener_new: + * @callback: (scope notified): An #AtspiEventListenerCB to be called + * when an event is fired. + * @user_data: (closure): data to pass to the callback. + * @callback_destroyed: A #GDestroyNotify called when the listener is freed + * and data associated with the callback should be freed. Can be NULL. + * + * Creates a new #AtspiEventListener associated with a specified @callback. + * + * Returns: (transfer full): A new #AtspiEventListener. */ +AtspiEventListener * +atspi_event_listener_new (AtspiEventListenerCB callback, + gpointer user_data, + GDestroyNotify callback_destroyed) +{ + AtspiEventListener *listener = g_object_new (ATSPI_TYPE_EVENT_LISTENER, NULL); + listener->callback = callback; + callback_ref (callback, callback_destroyed); + listener->user_data = user_data; + listener->cb_destroyed = callback_destroyed; + return listener; +} + +/** + * atspi_event_listener_new_simple: (skip) + * @callback: (scope notified): An #AtspiEventListenerSimpleCB to be called + * when an event is fired. + * @callback_destroyed: A #GDestroyNotify called when the listener is freed + * and data associated with the callback should be freed. Can be NULL. + * + * Creates a new #AtspiEventListener associated with a specified @callback. + * Returns: (transfer full): A new #AtspiEventListener. + **/ +AtspiEventListener * +atspi_event_listener_new_simple (AtspiEventListenerSimpleCB callback, + GDestroyNotify callback_destroyed) +{ + AtspiEventListener *listener = g_object_new (ATSPI_TYPE_EVENT_LISTENER, NULL); + listener->callback = remove_datum; + callback_ref (remove_datum, callback_destroyed); + listener->user_data = callback; + listener->cb_destroyed = callback_destroyed; + return listener; +} -static guint listener_id = 0; static GList *event_listeners = NULL; static gchar * -convert_name_from_dbus (const char *name) +convert_name_from_dbus (const char *name, gboolean path_hack) { - gchar *ret = g_malloc (g_utf8_strlen (name, -1) * 2 + 1); + gchar *ret; const char *p = name; - gchar *q = ret; + gchar *q; - if (!ret) - return NULL; + if (!name) + return g_strdup (""); + + ret = g_malloc (g_utf8_strlen (name, -1) * 2 + 1); + q = ret; while (*p) { @@ -63,6 +188,11 @@ convert_name_from_dbus (const char *name) *q++ = '-'; *q++ = tolower (*p++); } + else if (path_hack && *p == '/') + { + *q++ = ':'; + p++; + } else *q++ = *p++; } @@ -75,22 +205,35 @@ cache_process_children_changed (AtspiEvent *event) { AtspiAccessible *child; - if (!G_VALUE_HOLDS (&event->any, ATSPI_TYPE_ACCESSIBLE) || - !event->source->children || + if (!G_VALUE_HOLDS (&event->any_data, ATSPI_TYPE_ACCESSIBLE) || + !(event->source->cached_properties & ATSPI_CACHE_CHILDREN) || atspi_state_set_contains (event->source->states, ATSPI_STATE_MANAGES_DESCENDANTS)) return; - child = g_value_get_object (&event->any); + child = g_value_get_object (&event->any_data); + if (child == NULL) + return; if (!strncmp (event->type, "object:children-changed:add", 27)) { - GList *new_list = g_list_insert (event->source->children, g_object_ref (child), event->detail1); - if (new_list) - event->source->children = new_list; + g_ptr_array_remove (event->source->children, child); /* just to be safe */ + if (event->detail1 < 0 || event->detail1 > event->source->children->len) + { + event->source->cached_properties &= ~ATSPI_CACHE_CHILDREN; + return; + } + /* Unfortunately, there's no g_ptr_array_insert or similar */ + g_ptr_array_add (event->source->children, NULL); + memmove (event->source->children->pdata + event->detail1 + 1, + event->source->children->pdata + event->detail1, + (event->source->children->len - event->detail1 - 1) * sizeof (gpointer)); + g_ptr_array_index (event->source->children, event->detail1) = g_object_ref (child); } - else if (g_list_find (event->source->children, child)) + else { - event->source->children = g_list_remove (event->source->children, child); + g_ptr_array_remove (event->source->children, child); + if (child == child->parent.app->root) + g_object_run_dispose (G_OBJECT (child->parent.app)); } } @@ -101,10 +244,10 @@ cache_process_property_change (AtspiEvent *event) { if (event->source->accessible_parent) g_object_unref (event->source->accessible_parent); - if (G_VALUE_HOLDS (&event->any, ATSPI_TYPE_ACCESSIBLE)) + if (G_VALUE_HOLDS (&event->any_data, ATSPI_TYPE_ACCESSIBLE)) { - event->source->accessible_parent = g_value_dup_object (&event->any); - event->source->cached_properties |= ATSPI_CACHE_PARENT; + event->source->accessible_parent = g_value_dup_object (&event->any_data); + _atspi_accessible_add_cache (event->source, ATSPI_CACHE_PARENT); } else { @@ -116,10 +259,10 @@ cache_process_property_change (AtspiEvent *event) { if (event->source->name) g_free (event->source->name); - if (G_VALUE_HOLDS_STRING (&event->any)) + if (G_VALUE_HOLDS_STRING (&event->any_data)) { - event->source->name = g_value_dup_string (&event->any); - event->source->cached_properties |= ATSPI_CACHE_NAME; + event->source->name = g_value_dup_string (&event->any_data); + _atspi_accessible_add_cache (event->source, ATSPI_CACHE_NAME); } else { @@ -131,10 +274,10 @@ cache_process_property_change (AtspiEvent *event) { if (event->source->description) g_free (event->source->description); - if (G_VALUE_HOLDS_STRING (&event->any)) + if (G_VALUE_HOLDS_STRING (&event->any_data)) { - event->source->description = g_value_dup_string (&event->any); - event->source->cached_properties |= ATSPI_CACHE_DESCRIPTION; + event->source->description = g_value_dup_string (&event->any_data); + _atspi_accessible_add_cache (event->source, ATSPI_CACHE_DESCRIPTION); } else { @@ -142,12 +285,26 @@ cache_process_property_change (AtspiEvent *event) event->source->cached_properties &= ~ATSPI_CACHE_DESCRIPTION; } } + else if (!strcmp (event->type, "object:property-change:accessible-role")) + { + if (G_VALUE_HOLDS_INT (&event->any_data)) + { + event->source->role = g_value_get_int (&event->any_data); + _atspi_accessible_add_cache (event->source, ATSPI_CACHE_ROLE); + } + else + { + event->source->cached_properties &= ~ATSPI_CACHE_ROLE; + } + } } static void cache_process_state_changed (AtspiEvent *event) { - atspi_state_set_set_by_name (event->source->states, event->type + 21, event->detail1); + if (event->source->states) + atspi_state_set_set_by_name (event->source->states, event->type + 21, + event->detail1); } static dbus_bool_t @@ -180,6 +337,7 @@ strdup_and_adjust_for_dbus (const char *s) { gchar *d = g_strdup (s); gchar *p; + int parts = 0; if (!d) return NULL; @@ -193,6 +351,9 @@ strdup_and_adjust_for_dbus (const char *s) } else if (*p == ':') { + parts++; + if (parts == 2) + break; p [1] = toupper (p [1]); } } @@ -202,47 +363,43 @@ strdup_and_adjust_for_dbus (const char *s) } static gboolean -convert_event_type_to_dbus (const char *eventType, char **categoryp, char **namep, char **detailp, char **matchrule) +convert_event_type_to_dbus (const char *eventType, char **categoryp, char **namep, char **detailp, GPtrArray **matchrule_array) { gchar *tmp = strdup_and_adjust_for_dbus (eventType); char *category = NULL, *name = NULL, *detail = NULL; char *saveptr = NULL; - char *p; if (tmp == NULL) return FALSE; category = strtok_r (tmp, ":", &saveptr); if (category) category = g_strdup (category); - if (!category) goto oom; name = strtok_r (NULL, ":", &saveptr); if (name) { name = g_strdup (name); - if (!name) goto oom; detail = strtok_r (NULL, ":", &saveptr); if (detail) detail = g_strdup (detail); } - if (matchrule) + if (matchrule_array) { - *matchrule = g_strdup_printf ("type='signal',interface='org.a11y.atspi.Event.%s'", category); - if (!*matchrule) goto oom; + gchar *matchrule; + (*matchrule_array) = g_ptr_array_new (); + matchrule = g_strdup_printf ("type='signal',interface='org.a11y.atspi.Event.%s'", category); if (name && name [0]) { - gchar *new_str = g_strconcat (*matchrule, ",member='", name, "'", NULL); - if (new_str) - { - g_free (*matchrule); - *matchrule = new_str; - } + gchar *new_str = g_strconcat (matchrule, ",member='", name, "'", NULL); + g_free (matchrule); + matchrule = new_str; } if (detail && detail [0]) { - gchar *new_str = g_strconcat (*matchrule, ",arg0='", detail, "'", NULL); - if (new_str) - { - g_free (*matchrule); - *matchrule = new_str; - } + gchar *new_str = g_strconcat (matchrule, ",arg0='", detail, "'", NULL); + g_ptr_array_add (*matchrule_array, new_str); + new_str = g_strconcat (matchrule, ",arg0path='", detail, "/'", NULL); + g_ptr_array_add (*matchrule_array, new_str); + g_free (matchrule); } + else + g_ptr_array_add (*matchrule_array, matchrule); } if (categoryp) *categoryp = category; else g_free (category); @@ -252,31 +409,23 @@ convert_event_type_to_dbus (const char *eventType, char **categoryp, char **name else if (detail) g_free (detail); g_free (tmp); return TRUE; -oom: - if (tmp) g_free (tmp); - if (category) g_free (category); - if (name) g_free (name); - if (detail) g_free (detail); - return FALSE; } static void listener_entry_free (EventListenerEntry *e) { + gpointer callback = (e->callback == remove_datum ? (gpointer)e->user_data : (gpointer)e->callback); + g_free (e->event_type); g_free (e->category); g_free (e->name); if (e->detail) g_free (e->detail); - if (e->callback_destroyed) - (*e->callback_destroyed) (e->callback); + callback_unref (callback); g_free (e); } /** * atspi_event_listener_register: - * @callback: (scope notified): the #AtspiEventListenerCB to be registered against - * an event type. - * @user_data: (closure): User data to be passed to the callback. - * @callback_destroyed: A #GDestroyNotify called when the callback is destroyed. + * @listener: The #AtspiEventListener to register against an event type. * @event_type: a character string indicating the type of events for which * notification is requested. Format is * EventClass:major_type:minor_type:detail @@ -285,6 +434,8 @@ listener_entry_free (EventListenerEntry *e) * and toolkit events (e.g. "Gtk", "AWT"). * Examples: "focus:", "Gtk:GtkWidget:button_press_event". * + * Adds an in-process callback function to an existing #AtspiEventListener. + * * Legal object event types: * * (property change events) @@ -320,6 +471,9 @@ listener_entry_free (EventListenerEntry *e) * object:model-changed * object:active-descendant-changed * + * (screen reader events) +* screen-reader:region-changed + * * (window events) * * window:minimize @@ -352,80 +506,217 @@ listener_entry_free (EventListenerEntry *e) * mouse:b3p * mouse:b3r * - * NOTE: this string may be UTF-8, but should not contain byte value 56 + * NOTE: this character string may be UTF-8, but should not contain byte + * value 56 * (ascii ':'), except as a delimiter, since non-UTF-8 string * delimiting functions are used internally. * In general, listening to * toolkit-specific events is not recommended. * - * Add an in-process callback function to an existing AtspiEventListener. + * Currently, object:text-reading-position needs to be specified explicitly + * (it is not implied by object:text), since it is generated by the screen + * reader and is thus a special case internally. * * Returns: #TRUE if successful, otherwise #FALSE. **/ gboolean -atspi_event_listener_register (AtspiEventListenerCB callback, - void *user_data, - GDestroyNotify callback_destroyed, - const gchar *event_type) +atspi_event_listener_register (AtspiEventListener *listener, + const gchar *event_type, + GError **error) +{ + /* TODO: Keep track of which events have been registered, so that we + * deregister all of them when the event listener is destroyed */ + + return atspi_event_listener_register_from_callback (listener->callback, + listener->user_data, + listener->cb_destroyed, + event_type, error); +} + +/** + * atspi_event_listener_register_full: + * @listener: The #AtspiEventListener to register against an event type. + * @event_type: a character string indicating the type of events for which + * notification is requested. See #atspi_event_listener_register + * for a description of the format and legal event types. +* @properties: (element-type gchar*) (transfer none) (allow-none): a list of + * properties that should be sent along with the event. The + * properties are valued for the duration of the event callback.k + * TODO: Document. + * + * Adds an in-process callback function to an existing #AtspiEventListener. + * + * Returns: #TRUE if successful, otherwise #FALSE. + **/ +gboolean +atspi_event_listener_register_full (AtspiEventListener *listener, + const gchar *event_type, + GArray *properties, + GError **error) +{ + /* TODO: Keep track of which events have been registered, so that we + * deregister all of them when the event listener is destroyed */ + + return atspi_event_listener_register_from_callback_full (listener->callback, + listener->user_data, + listener->cb_destroyed, + event_type, + properties, + error); +} + +static gboolean +notify_event_registered (EventListenerEntry *e) +{ + + if (e->properties) + dbind_method_call_reentrant (_atspi_bus (), atspi_bus_registry, + atspi_path_registry, + atspi_interface_registry, + "RegisterEvent", + NULL, "sas", e->event_type, + e->properties); + else + dbind_method_call_reentrant (_atspi_bus (), atspi_bus_registry, + atspi_path_registry, + atspi_interface_registry, + "RegisterEvent", + NULL, "s", e->event_type); + + return TRUE; +} + +/** + * atspi_event_listener_register_from_callback: + * @callback: (scope notified): the #AtspiEventListenerCB to be registered + * against an event type. + * @user_data: (closure): User data to be passed to the callback. + * @callback_destroyed: A #GDestroyNotify called when the callback is destroyed. + * @event_type: a character string indicating the type of events for which + * notification is requested. See #atspi_event_listener_register + * for a description of the format. + * + * Registers an #AtspiEventListenerCB against an @event_type. + * + * Returns: #TRUE if successfull, otherwise #FALSE. + * + **/ +gboolean +atspi_event_listener_register_from_callback (AtspiEventListenerCB callback, + void *user_data, + GDestroyNotify callback_destroyed, + const gchar *event_type, + GError **error) +{ + return atspi_event_listener_register_from_callback_full (callback, + user_data, + callback_destroyed, + event_type, NULL, + error); +} + +static GArray * +copy_event_properties (GArray *src) +{ + gint i; + + GArray *dst = g_array_new (FALSE, FALSE, sizeof (char *)); + + if (!src) + return dst; + for (i = 0; i < src->len; i++) + { + gchar *dup = g_strdup (g_array_index (src, char *, i)); + g_array_append_val (dst, dup); + } + return dst; +} + +/** + * atspi_event_listener_register_from_callback_full: + * @callback: (scope async): an #AtspiEventListenerCB function pointer. + * @user_data: (closure callback) + * @callback_destroyed: (destroy callback) + * @event_type: + * @properties: (element-type utf8) + * @error: + * + * Returns: #TRUE if successful, otherwise #FALSE. + * + **/ +gboolean +atspi_event_listener_register_from_callback_full (AtspiEventListenerCB callback, + void *user_data, + GDestroyNotify callback_destroyed, + const gchar *event_type, + GArray *properties, + GError **error) { EventListenerEntry *e; - char *matchrule; - DBusError error; - GList *new_list; - DBusMessage *message, *reply; + DBusError d_error; + GPtrArray *matchrule_array; + gint i; if (!callback) { return FALSE; } + if (!event_type) + { + g_warning ("called atspi_event_listener_register_from_callback with a NULL event_type"); + return FALSE; + } + e = g_new (EventListenerEntry, 1); - if (!e) return FALSE; + e->event_type = g_strdup (event_type); e->callback = callback; e->user_data = user_data; e->callback_destroyed = callback_destroyed; - if (!convert_event_type_to_dbus (event_type, &e->category, &e->name, &e->detail, &matchrule)) + callback_ref (callback == remove_datum ? (gpointer)user_data : (gpointer)callback, + callback_destroyed); + if (!convert_event_type_to_dbus (event_type, &e->category, &e->name, &e->detail, &matchrule_array)) { g_free (e); return FALSE; } - new_list = g_list_prepend (event_listeners, e); - if (!new_list) + e->properties = copy_event_properties (properties); + event_listeners = g_list_prepend (event_listeners, e); + for (i = 0; i < matchrule_array->len; i++) { - listener_entry_free (e); - return FALSE; - } - event_listeners = new_list; - dbus_error_init (&error); - dbus_bus_add_match (_atspi_bus(), matchrule, &error); - if (error.message) - { - g_warning ("Atspi: Adding match: %s", error.message); - } + char *matchrule = g_ptr_array_index (matchrule_array, i); + dbus_error_init (&d_error); + dbus_bus_add_match (_atspi_bus(), matchrule, &d_error); + if (dbus_error_is_set (&d_error)) + { + g_warning ("AT-SPI: Adding match: %s", d_error.message); + dbus_error_free (&d_error); + /* TODO: Set error */ + } - dbus_error_init (&error); - message = dbus_message_new_method_call (atspi_bus_registry, - atspi_path_registry, - atspi_interface_registry, - "RegisterEvent"); - if (!message) - return; - dbus_message_append_args (message, DBUS_TYPE_STRING, &event_type, DBUS_TYPE_INVALID); - reply = _atspi_dbus_send_with_reply_and_block (message); - dbus_message_unref (reply); + g_free (matchrule); + } + g_ptr_array_free (matchrule_array, TRUE); + notify_event_registered (e); return TRUE; } void -remove_datum (const AtspiEvent *event, void *user_data) +_atspi_reregister_event_listeners () { - AtspiEventListenerSimpleCB cb = user_data; - cb (event); + GList *l; + EventListenerEntry *e; + + for (l = event_listeners; l; l = l->next) + { + e = l->data; + notify_event_registered (e); + } } /** - * atspi_event_listener_register_no_data: + * atspi_event_listener_register_no_data: (skip) * @callback: (scope notified): the #AtspiEventListenerSimpleCB to be * registered against an event type. * @callback_destroyed: A #GDestroyNotify called when the callback is destroyed. @@ -437,14 +728,20 @@ remove_datum (const AtspiEvent *event, void *user_data) * and toolkit events (e.g. "Gtk", "AWT"). * Examples: "focus:", "Gtk:GtkWidget:button_press_event". * - * Like atspi_event_listener_register, but callback takes no user_data. + * Registers an #AtspiEventListenetSimpleCB. The method is similar to + * #atspi_event_listener_register, but @callback takes no user_data. + * + * Returns: #TRUE if successfull, otherwise #FALSE. **/ gboolean atspi_event_listener_register_no_data (AtspiEventListenerSimpleCB callback, GDestroyNotify callback_destroyed, - const gchar *event_type) + const gchar *event_type, + GError **error) { - return atspi_event_listener_register (remove_datum, callback, callback_destroyed, event_type); + return atspi_event_listener_register_from_callback (remove_datum, callback, + callback_destroyed, + event_type, error); } static gboolean @@ -457,33 +754,58 @@ is_superset (const gchar *super, const gchar *sub) /** * atspi_event_listener_deregister: + * @listener: The #AtspiEventListener to deregister. + * @event_type: a string specifying the event type for which this + * listener is to be deregistered. + * + * Deregisters an #AtspiEventListener from the registry, for a specific + * event type. + * + * Returns: #TRUE if successful, otherwise #FALSE. + **/ +gboolean +atspi_event_listener_deregister (AtspiEventListener *listener, + const gchar *event_type, + GError **error) +{ + return atspi_event_listener_deregister_from_callback (listener->callback, + listener->user_data, + event_type, error); +} + +/** + * atspi_event_listener_deregister_from_callback: * @callback: (scope call): the #AtspiEventListenerCB registered against an * event type. * @user_data: (closure): User data that was passed in for this callback. * @event_type: a string specifying the event type for which this * listener is to be deregistered. * - * deregisters an #AtspiEventListenerCB from the registry, for a specific + * Deregisters an #AtspiEventListenerCB from the registry, for a specific * event type. * * Returns: #TRUE if successful, otherwise #FALSE. **/ gboolean -atspi_event_listener_deregister (AtspiEventListenerCB callback, - void *user_data, - const gchar *event_type) +atspi_event_listener_deregister_from_callback (AtspiEventListenerCB callback, + void *user_data, + const gchar *event_type, + GError **error) { - char *category, *name, *detail, *matchrule; + char *category, *name, *detail; + GPtrArray *matchrule_array; + gint i; GList *l; + gboolean result = TRUE; - if (!convert_event_type_to_dbus (event_type, &category, &name, &detail, &matchrule)) + if (!callback) + { + return FALSE; + } + if (!convert_event_type_to_dbus (event_type, &category, &name, &detail, &matchrule_array)) { return FALSE; } - if (!callback) - { - return FALSE; - } for (l = event_listeners; l;) { @@ -494,21 +816,29 @@ atspi_event_listener_deregister (AtspiEventListenerCB callback, is_superset (name, e->name) && is_superset (detail, e->detail)) { - DBusError error; + gboolean need_replace; DBusMessage *message, *reply; + need_replace = (l == event_listeners); l = g_list_remove (l, e); - dbus_error_init (&error); - dbus_bus_remove_match (_atspi_bus(), matchrule, &error); - dbus_error_init (&error); + if (need_replace) + event_listeners = l; + for (i = 0; i < matchrule_array->len; i++) + { + char *matchrule = g_ptr_array_index (matchrule_array, i); + dbus_bus_remove_match (_atspi_bus(), matchrule, NULL); + } message = dbus_message_new_method_call (atspi_bus_registry, atspi_path_registry, atspi_interface_registry, - "RegisterEvent"); - if (!message) - return; + "DeregisterEvent"); + if (!message) { + result = FALSE; + break; + } dbus_message_append_args (message, DBUS_TYPE_STRING, &event_type, DBUS_TYPE_INVALID); - reply = _atspi_dbus_send_with_reply_and_block (message); - dbus_message_unref (reply); + reply = _atspi_dbus_send_with_reply_and_block (message, error); + if (reply) + dbus_message_unref (reply); listener_entry_free (e); } @@ -517,12 +847,14 @@ atspi_event_listener_deregister (AtspiEventListenerCB callback, g_free (category); g_free (name); if (detail) g_free (detail); - g_free (matchrule); - return TRUE; + for (i = 0; i < matchrule_array->len; i++) + g_free (g_ptr_array_index (matchrule_array, i)); + g_ptr_array_free (matchrule_array, TRUE); + return result; } /** - * atspi_event_listener_deregister_no_data: + * atspi_event_listener_deregister_no_data: (skip) * @callback: (scope call): the #AtspiEventListenerSimpleCB registered against * an event type. * @event_type: a string specifying the event type for which this @@ -535,9 +867,51 @@ atspi_event_listener_deregister (AtspiEventListenerCB callback, **/ gboolean atspi_event_listener_deregister_no_data (AtspiEventListenerSimpleCB callback, - const gchar *event_type) + const gchar *event_type, + GError **error) +{ + return atspi_event_listener_deregister_from_callback (remove_datum, callback, + event_type, + error); +} + +static AtspiEvent * +atspi_event_copy (AtspiEvent *src) +{ + AtspiEvent *dst = g_new0 (AtspiEvent, 1); + dst->type = g_strdup (src->type); + dst->source = g_object_ref (src->source); + dst->detail1 = src->detail1; + dst->detail2 = src->detail2; + g_value_init (&dst->any_data, G_VALUE_TYPE (&src->any_data)); + g_value_copy (&src->any_data, &dst->any_data); + dst->sender = g_object_ref (src->sender); + return dst; +} + +static void +atspi_event_free (AtspiEvent *event) { - return atspi_event_listener_deregister (remove_datum, callback, event_type); + g_object_unref (event->source); + g_free (event->type); + g_value_unset (&event->any_data); + g_object_unref (event->sender); + g_free (event); +} + +static gboolean +detail_matches_listener (const char *event_detail, const char *listener_detail) +{ + if (!listener_detail) + return TRUE; + + if (!event_detail) + return FALSE; + + return !(listener_detail [strcspn (listener_detail, ":")] == '\0' + ? strncmp (listener_detail, event_detail, + strcspn (event_detail, ":")) + : strcmp (listener_detail, event_detail)); } void @@ -545,10 +919,19 @@ _atspi_send_event (AtspiEvent *e) { char *category, *name, *detail; GList *l; + GList *called_listeners = NULL; + + /* Ensure that the value is set to avoid a Python exception */ + /* TODO: Figure out how to do this without using a private field */ + if (e->any_data.g_type == 0) + { + g_value_init (&e->any_data, G_TYPE_INT); + g_value_set_int (&e->any_data, 0); + } if (!convert_event_type_to_dbus (e->type, &category, &name, &detail, NULL)) { - g_warning ("Atspi: Couldn't parse event: %s\n", e->type); + g_warning ("AT-SPI: Couldn't parse event: %s\n", e->type); return; } for (l = event_listeners; l; l = g_list_next (l)) @@ -556,22 +939,36 @@ _atspi_send_event (AtspiEvent *e) EventListenerEntry *entry = l->data; if (!strcmp (category, entry->category) && (entry->name == NULL || !strcmp (name, entry->name)) && - (entry->detail == NULL || !strcmp (detail, entry->detail))) + detail_matches_listener (detail, entry->detail)) { - entry->callback (entry->user_data, e); + GList *l2; + for (l2 = called_listeners; l2; l2 = l2->next) + { + EventListenerEntry *e2 = l2->data; + if (entry->callback == e2->callback && entry->user_data == e2->user_data) + break; + } + if (!l2) + { + entry->callback (atspi_event_copy (e), entry->user_data); + called_listeners = g_list_prepend (called_listeners, entry); + } } } if (detail) g_free (detail); g_free (name); g_free (category); + g_list_free (called_listeners); } DBusHandlerResult -atspi_dbus_handle_event (DBusConnection *bus, DBusMessage *message, void *data) +_atspi_dbus_handle_event (DBusConnection *bus, DBusMessage *message, void *data) { char *detail = NULL; const char *category = dbus_message_get_interface (message); + const char *sender = dbus_message_get_sender (message); const char *member = dbus_message_get_member (message); + const char *signature = dbus_message_get_signature (message); gchar *name; gchar *converted_type; DBusMessageIter iter, iter_variant; @@ -579,54 +976,77 @@ atspi_dbus_handle_event (DBusConnection *bus, DBusMessage *message, void *data) AtspiEvent e; dbus_int32_t detail1, detail2; char *p; + GHashTable *cache = NULL; - if (category) + if (strcmp (signature, "siiv(so)") != 0 && + strcmp (signature, "siiva{sv}") != 0) { - category = g_utf8_strrchr (category, -1, '.'); - if (category == NULL) - { - // TODO: Error - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - } - category++; + g_warning ("Got invalid signature %s for signal %s from interface %s\n", signature, member, category); + return DBUS_HANDLER_RESULT_HANDLED; } - g_return_val_if_fail (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_STRING, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + + memset (&e, 0, sizeof (e)); + + if (!category) + { + // TODO: Error + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + category = g_utf8_strrchr (category, -1, '.'); + if (category == NULL) + { + // TODO: Error + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + category++; + dbus_message_iter_get_basic (&iter, &detail); dbus_message_iter_next (&iter); - /* TODO: Return error indicating invalid arguments in next line */ - g_return_val_if_fail (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_INT32, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); dbus_message_iter_get_basic (&iter, &detail1); e.detail1 = detail1; dbus_message_iter_next (&iter); - g_return_val_if_fail (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_INT32, DBUS_HANDLER_RESULT_NOT_YET_HANDLED); dbus_message_iter_get_basic (&iter, &detail2); e.detail2 = detail2; dbus_message_iter_next (&iter); - converted_type = convert_name_from_dbus (category); - name = convert_name_from_dbus (member); - detail = convert_name_from_dbus (detail); + converted_type = convert_name_from_dbus (category, FALSE); + name = convert_name_from_dbus (member, FALSE); + detail = convert_name_from_dbus (detail, TRUE); if (strcasecmp (category, name) != 0) { p = g_strconcat (converted_type, ":", name, NULL); - if (p) - { - g_free (converted_type); - converted_type = p; - } + g_free (converted_type); + converted_type = p; + } + else if (detail [0] == '\0') + { + p = g_strconcat (converted_type, ":", NULL); + g_free (converted_type); + converted_type = p; } + if (detail[0] != '\0') { p = g_strconcat (converted_type, ":", detail, NULL); - if (p) + g_free (converted_type); + converted_type = p; + } + e.type = converted_type; + if (strcmp (category, "ScreenReader") != 0) + { + e.source = _atspi_ref_accessible (sender, dbus_message_get_path (message)); + if (e.source == NULL) { + g_warning ("Got no valid source accessible for signal %s from interface %s\n", member, category); g_free (converted_type); - converted_type = p; + g_free (name); + g_free (detail); + return DBUS_HANDLER_RESULT_HANDLED; } } - e.type = converted_type; - e.source = _atspi_ref_accessible (dbus_message_get_sender(message), dbus_message_get_path(message)); + dbus_message_iter_recurse (&iter, &iter_variant); switch (dbus_message_iter_get_arg_type (&iter_variant)) { @@ -635,67 +1055,84 @@ atspi_dbus_handle_event (DBusConnection *bus, DBusMessage *message, void *data) AtspiRect rect; if (demarshal_rect (&iter_variant, &rect)) { - g_value_init (&e.any, ATSPI_TYPE_RECT); - g_value_set_instance (&e.any, &rect); + g_value_init (&e.any_data, ATSPI_TYPE_RECT); + g_value_set_boxed (&e.any_data, &rect); } else { AtspiAccessible *accessible; - accessible = _atspi_dbus_return_accessible_from_iter (&iter_variant); - g_value_init (&e.any, ATSPI_TYPE_ACCESSIBLE); - g_value_set_instance (&e.any, accessible); + accessible = _atspi_dbus_return_accessible_from_iter (&iter_variant); + if (!strcmp (category, "ScreenReader")) + { + e.source = accessible; + if (e.source == NULL) + { + g_warning ("Got no valid source accessible for signal %s from interface %s\n", member, category); + g_free (converted_type); + g_free (name); + g_free (detail); + return DBUS_HANDLER_RESULT_HANDLED; + } + } + else + { + g_value_init (&e.any_data, ATSPI_TYPE_ACCESSIBLE); + g_value_set_instance (&e.any_data, accessible); + if (accessible) + g_object_unref (accessible); /* value now owns it */ + } } break; } case DBUS_TYPE_STRING: { dbus_message_iter_get_basic (&iter_variant, &p); - g_value_set_string (&e.any, p); + g_value_init (&e.any_data, G_TYPE_STRING); + g_value_set_string (&e.any_data, p); break; } default: break; } - _atspi_send_event (&e); - if (!strcmp (e.type, "children-changed")) + dbus_message_iter_next (&iter); + if (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_ARRAY) + { + /* new form -- parse properties sent with event */ + cache = _atspi_dbus_update_cache_from_dict (e.source, &iter); + } + + e.sender = _atspi_ref_accessible (sender, ATSPI_DBUS_PATH_ROOT); + + if (!strncmp (e.type, "object:children-changed", 23)) { cache_process_children_changed (&e); } - else if (!strcmp (e.type, "property-change")) + else if (!strncmp (e.type, "object:property-change", 22)) { cache_process_property_change (&e); } - else if (!strcmp (e.type, "state-changed")) + else if (!strncmp (e.type, "object:state-changed", 20)) { cache_process_state_changed (&e); } + else if (!strncmp (e.type, "focus", 5)) + { + /* BGO#663992 - TODO: figure out the real problem */ + e.source->cached_properties &= ~(ATSPI_CACHE_STATES); + } + + _atspi_send_event (&e); + + if (cache) + _atspi_accessible_unref_cache (e.source); g_free (converted_type); g_free (name); g_free (detail); g_object_unref (e.source); - g_value_unset (&e.any); + g_value_unset (&e.any_data); return DBUS_HANDLER_RESULT_HANDLED; } -static AtspiEvent * -atspi_event_copy (AtspiEvent *src) -{ - AtspiEvent *dst = g_new0 (AtspiEvent, 1); - dst->type = g_strdup (src->type); - dst->detail1 = src->detail1; - dst->detail2 = src->detail2; - g_value_copy (&dst->any, &src->any); -} - -static void -atspi_event_free (AtspiEvent *event) -{ - g_object_unref (event->source); - g_free (event->type); - g_value_unset (&event->any); - g_free (event); -} - G_DEFINE_BOXED_TYPE (AtspiEvent, atspi_event, atspi_event_copy, atspi_event_free)