atspi/atspi-event-listener.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2002 Ximian Inc.
   6  * Copyright 2002 Sun Microsystems, Inc.
   7  * Copyright 2010, 2011 Novell, Inc.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 #include "atspi-private.h"
  26 #include "atspi-accessible-private.h"
  27 #include <string.h>
  28 #include <strings.h>
  29 #include <ctype.h>
  30
  31 typedef struct
  32 {
  33   AtspiEventListenerCB callback;
  34   void *user_data;
  35   GDestroyNotify callback_destroyed;
  36   char *event_type;
  37   char *category;
  38   char *name;
  39   char *detail;
  40   GArray *properties;
  41 } EventListenerEntry;
  42
  43 G_DEFINE_TYPE (AtspiEventListener, atspi_event_listener, G_TYPE_OBJECT)
  44
  45 void
  46 atspi_event_listener_init (AtspiEventListener *listener)
  47 {
  48 }
  49
  50 void
  51 atspi_event_listener_class_init (AtspiEventListenerClass *klass)
  52 {
  53 }
  54
  55 static void
  56 remove_datum (AtspiEvent *event, void *user_data)
  57 {
  58   AtspiEventListenerSimpleCB cb = user_data;
  59   cb (event);
  60 }
  61
  62 typedef struct
  63 {
  64   gpointer callback;
  65   GDestroyNotify callback_destroyed;
  66   gint ref_count;
  67 } CallbackInfo;
  68 static GHashTable *callbacks;
  69
  70 void
  71 callback_ref (void *callback, GDestroyNotify callback_destroyed)
  72 {
  73   CallbackInfo *info;
  74
  75   if (!callbacks)
  76   {
  77     callbacks = g_hash_table_new (g_direct_hash, g_direct_equal);
  78     if (!callbacks)
  79       return;
  80   }
  81
  82   info = g_hash_table_lookup (callbacks, callback);
  83   if (!info)
  84   {
  85     info = g_new (CallbackInfo, 1);
  86     info->callback = callback;
  87     info->callback_destroyed = callback_destroyed;
  88     info->ref_count = 1;
  89     g_hash_table_insert (callbacks, callback, info);
  90   }
  91   else
  92     info->ref_count++;
  93 }
  94
  95 void
  96 callback_unref (gpointer callback)
  97 {
  98   CallbackInfo *info;
  99
 100   if (!callbacks)
 101     return;
 102   info = g_hash_table_lookup (callbacks, callback);
 103   if (!info)
 104   {
 105     g_warning ("AT-SPI: Dereferencing invalid callback %p\n", callback);
 106     return;
 107   }
 108   info->ref_count--;
 109   if (info->ref_count == 0)
 110   {
 111 #if 0
 112     /* TODO: Figure out why this seg faults from Python */
 113     if (info->callback_destroyed)
 114       (*info->callback_destroyed) (info->callback);
 115 #endif
 116     g_free (info);
 117     g_hash_table_remove (callbacks, callback);
 118   }
 119 }
 120
 121 /**
 122  * atspi_event_listener_new:
 123  * @callback: (scope notified): An #AtspiEventListenerCB to be called
 124  * when an event is fired.
 125  * @user_data: (closure): data to pass to the callback.
 126  * @callback_destroyed: A #GDestroyNotify called when the listener is freed
 127  * and data associated with the callback should be freed.  Can be NULL.
 128  *
 129  * Creates a new #AtspiEventListener associated with a specified @callback.
 130  *
 131  * Returns: (transfer full): A new #AtspiEventListener.
 132  */
 133 AtspiEventListener *
 134 atspi_event_listener_new (AtspiEventListenerCB callback,
 135                                  gpointer user_data,
 136                                  GDestroyNotify callback_destroyed)
 137 {
 138   AtspiEventListener *listener = g_object_new (ATSPI_TYPE_EVENT_LISTENER, NULL);
 139   listener->callback = callback;
 140   callback_ref (callback, callback_destroyed);
 141   listener->user_data = user_data;
 142   listener->cb_destroyed = callback_destroyed;
 143   return listener;
 144 }
 145
 146 /**
 147  * atspi_event_listener_new_simple: (skip)
 148  * @callback: (scope notified): An #AtspiEventListenerSimpleCB to be called
 149  * when an event is fired.
 150  * @callback_destroyed: A #GDestroyNotify called when the listener is freed
 151  * and data associated with the callback should be freed.  Can be NULL.
 152  *
 153  * Creates a new #AtspiEventListener associated with a specified @callback.
 154  * Returns: (transfer full): A new #AtspiEventListener.
 155  **/
 156 AtspiEventListener *
 157 atspi_event_listener_new_simple (AtspiEventListenerSimpleCB callback,
 158                                  GDestroyNotify callback_destroyed)
 159 {
 160   AtspiEventListener *listener = g_object_new (ATSPI_TYPE_EVENT_LISTENER, NULL);
 161   listener->callback = remove_datum;
 162   callback_ref (remove_datum, callback_destroyed);
 163   listener->user_data = callback;
 164   listener->cb_destroyed = callback_destroyed;
 165   return listener;
 166 }
 167
 168 static GList *event_listeners = NULL;
 169
 170 static gchar *
 171 convert_name_from_dbus (const char *name, gboolean path_hack)
 172 {
 173   gchar *ret;
 174   const char *p = name;
 175   gchar *q;
 176
 177   if (!name)
 178     return g_strdup ("");
 179
 180  ret = g_malloc (g_utf8_strlen (name, -1) * 2 + 1);
 181   q = ret;
 182
 183   while (*p)
 184   {
 185     if (isupper (*p))
 186     {
 187       if (q > ret)
 188         *q++ = '-';
 189       *q++ = tolower (*p++);
 190     }
 191     else if (path_hack && *p == '/')
 192     {
 193       *q++ = ':';
 194       p++;
 195     }
 196     else
 197       *q++ = *p++;
 198   }
 199   *q = '\0';
 200   return ret;
 201 }
 202
 203 static void
 204 cache_process_children_changed (AtspiEvent *event)
 205 {
 206   AtspiAccessible *child;
 207
 208   if (!G_VALUE_HOLDS (&event->any_data, ATSPI_TYPE_ACCESSIBLE) ||
 209       !(event->source->cached_properties & ATSPI_CACHE_CHILDREN) ||
 210       atspi_state_set_contains (event->source->states, ATSPI_STATE_MANAGES_DESCENDANTS))
 211     return;
 212
 213   child = g_value_get_object (&event->any_data);
 214   if (child == NULL)
 215     return;
 216
 217   if (!strncmp (event->type, "object:children-changed:add", 27))
 218   {
 219     g_ptr_array_remove (event->source->children, child); /* just to be safe */
 220     if (event->detail1 < 0 || event->detail1 > event->source->children->len)
 221     {
 222       event->source->cached_properties &= ~ATSPI_CACHE_CHILDREN;
 223       return;
 224     }
 225     /* Unfortunately, there's no g_ptr_array_insert or similar */
 226     g_ptr_array_add (event->source->children, NULL);
 227     memmove (event->source->children->pdata + event->detail1 + 1,
 228              event->source->children->pdata + event->detail1,
 229              (event->source->children->len - event->detail1 - 1) * sizeof (gpointer));
 230     g_ptr_array_index (event->source->children, event->detail1) = g_object_ref (child);
 231   }
 232   else
 233   {
 234     g_ptr_array_remove (event->source->children, child);
 235     if (child == child->parent.app->root)
 236       g_object_run_dispose (G_OBJECT (child->parent.app));
 237   }
 238 }
 239
 240 static void
 241 cache_process_property_change (AtspiEvent *event)
 242 {
 243   if (!strcmp (event->type, "object:property-change:accessible-parent"))
 244   {
 245     if (event->source->accessible_parent)
 246       g_object_unref (event->source->accessible_parent);
 247     if (G_VALUE_HOLDS (&event->any_data, ATSPI_TYPE_ACCESSIBLE))
 248     {
 249       event->source->accessible_parent = g_value_dup_object (&event->any_data);
 250       _atspi_accessible_add_cache (event->source, ATSPI_CACHE_PARENT);
 251     }
 252     else
 253     {
 254       event->source->accessible_parent = NULL;
 255       event->source->cached_properties &= ~ATSPI_CACHE_PARENT;
 256     }
 257   }
 258   else if (!strcmp (event->type, "object:property-change:accessible-name"))
 259   {
 260     if (event->source->name)
 261       g_free (event->source->name);
 262     if (G_VALUE_HOLDS_STRING (&event->any_data))
 263     {
 264       event->source->name = g_value_dup_string (&event->any_data);
 265       _atspi_accessible_add_cache (event->source, ATSPI_CACHE_NAME);
 266     }
 267     else
 268     {
 269       event->source->name = NULL;
 270       event->source->cached_properties &= ~ATSPI_CACHE_NAME;
 271     }
 272   }
 273   else if (!strcmp (event->type, "object:property-change:accessible-description"))
 274   {
 275     if (event->source->description)
 276       g_free (event->source->description);
 277     if (G_VALUE_HOLDS_STRING (&event->any_data))
 278     {
 279       event->source->description = g_value_dup_string (&event->any_data);
 280       _atspi_accessible_add_cache (event->source, ATSPI_CACHE_DESCRIPTION);
 281     }
 282     else
 283     {
 284       event->source->description = NULL;
 285       event->source->cached_properties &= ~ATSPI_CACHE_DESCRIPTION;
 286     }
 287   }
 288   else if (!strcmp (event->type, "object:property-change:accessible-role"))
 289   {
 290     if (G_VALUE_HOLDS_INT (&event->any_data))
 291     {
 292       event->source->role = g_value_get_int (&event->any_data);
 293       _atspi_accessible_add_cache (event->source, ATSPI_CACHE_ROLE);
 294     }
 295     else
 296     {
 297       event->source->cached_properties &= ~ATSPI_CACHE_ROLE;
 298     }
 299   }
 300 }
 301
 302 static void
 303 cache_process_state_changed (AtspiEvent *event)
 304 {
 305   if (event->source->states)
 306     atspi_state_set_set_by_name (event->source->states, event->type + 21,
 307                                  event->detail1);
 308 }
 309
 310 static dbus_bool_t
 311 demarshal_rect (DBusMessageIter *iter, AtspiRect *rect)
 312 {
 313   dbus_int32_t x, y, width, height;
 314   DBusMessageIter iter_struct;
 315
 316   dbus_message_iter_recurse (iter, &iter_struct);
 317   if (dbus_message_iter_get_arg_type (&iter_struct) != DBUS_TYPE_INT32) return FALSE;
 318   dbus_message_iter_get_basic (&iter_struct, &x);
 319   dbus_message_iter_next (&iter_struct);
 320   if (dbus_message_iter_get_arg_type (&iter_struct) != DBUS_TYPE_INT32) return FALSE;
 321   dbus_message_iter_get_basic (&iter_struct, &y);
 322   dbus_message_iter_next (&iter_struct);
 323   if (dbus_message_iter_get_arg_type (&iter_struct) != DBUS_TYPE_INT32) return FALSE;
 324   dbus_message_iter_get_basic (&iter_struct, &width);
 325   dbus_message_iter_next (&iter_struct);
 326   if (dbus_message_iter_get_arg_type (&iter_struct) != DBUS_TYPE_INT32) return FALSE;
 327   dbus_message_iter_get_basic (&iter_struct, &height);
 328   rect->x = x;
 329   rect->y = y;
 330   rect->width = width;
 331   rect->height = height;
 332   return TRUE;
 333 }
 334
 335 static gchar *
 336 strdup_and_adjust_for_dbus (const char *s)
 337 {
 338   gchar *d = g_strdup (s);
 339   gchar *p;
 340   int parts = 0;
 341
 342   if (!d)
 343     return NULL;
 344
 345   for (p = d; *p; p++)
 346   {
 347     if (*p == '-')
 348     {
 349       memmove (p, p + 1, g_utf8_strlen (p, -1));
 350       *p = toupper (*p);
 351     }
 352     else if (*p == ':')
 353     {
 354       parts++;
 355       if (parts == 2)
 356         break;
 357       p [1] = toupper (p [1]);
 358     }
 359   }
 360
 361   d [0] = toupper (d [0]);
 362   return d;
 363 }
 364
 365 static gboolean
 366 convert_event_type_to_dbus (const char *eventType, char **categoryp, char **namep, char **detailp, GPtrArray **matchrule_array)
 367 {
 368   gchar *tmp = strdup_and_adjust_for_dbus (eventType);
 369   char *category = NULL, *name = NULL, *detail = NULL;
 370   char *saveptr = NULL;
 371
 372   if (tmp == NULL) return FALSE;
 373   category = strtok_r (tmp, ":", &saveptr);
 374   if (category) category = g_strdup (category);
 375   name = strtok_r (NULL, ":", &saveptr);
 376   if (name)
 377   {
 378     name = g_strdup (name);
 379     detail = strtok_r (NULL, ":", &saveptr);
 380     if (detail) detail = g_strdup (detail);
 381   }
 382   if (matchrule_array)
 383   {
 384     gchar *matchrule;
 385     (*matchrule_array) = g_ptr_array_new ();
 386     matchrule = g_strdup_printf ("type='signal',interface='org.a11y.atspi.Event.%s'", category);
 387     if (name && name [0])
 388     {
 389              gchar *new_str = g_strconcat (matchrule, ",member='", name, "'", NULL);
 390              g_free (matchrule);
 391              matchrule = new_str;
 392     }
 393     if (detail && detail [0])
 394     {
 395       gchar *new_str = g_strconcat (matchrule, ",arg0='", detail, "'", NULL);
 396       g_ptr_array_add (*matchrule_array, new_str);
 397       new_str = g_strconcat (matchrule, ",arg0path='", detail, "/'", NULL);
 398       g_ptr_array_add (*matchrule_array, new_str);
 399       g_free (matchrule);
 400     }
 401     else
 402       g_ptr_array_add (*matchrule_array, matchrule);
 403   }
 404   if (categoryp) *categoryp = category;
 405   else g_free (category);
 406   if (namep) *namep = name;
 407   else if (name) g_free (name);
 408   if (detailp) *detailp = detail;
 409   else if (detail) g_free (detail);
 410   g_free (tmp);
 411   return TRUE;
 412 }
 413
 414 static void
 415 listener_entry_free (EventListenerEntry *e)
 416 {
 417   gpointer callback = (e->callback == remove_datum ? (gpointer)e->user_data : (gpointer)e->callback);
 418   g_free (e->event_type);
 419   g_free (e->category);
 420   g_free (e->name);
 421   if (e->detail) g_free (e->detail);
 422   callback_unref (callback);
 423   g_free (e);
 424 }
 425
 426 /**
 427  * atspi_event_listener_register:
 428  * @listener: The #AtspiEventListener to register against an event type.
 429  * @event_type: a character string indicating the type of events for which
 430  *            notification is requested.  Format is
 431  *            EventClass:major_type:minor_type:detail
 432  *            where all subfields other than EventClass are optional.
 433  *            EventClasses include "object", "window", "mouse",
 434  *            and toolkit events (e.g. "Gtk", "AWT").
 435  *            Examples: "focus:", "Gtk:GtkWidget:button_press_event".
 436  *
 437  * Adds an in-process callback function to an existing #AtspiEventListener.
 438  *
 439  * Legal object event types:
 440  *
 441  *    (property change events)
 442  *
 443  *            object:property-change
 444  *            object:property-change:accessible-name
 445  *            object:property-change:accessible-description
 446  *            object:property-change:accessible-parent
 447  *            object:property-change:accessible-value
 448  *            object:property-change:accessible-role
 449  *            object:property-change:accessible-table-caption
 450  *            object:property-change:accessible-table-column-description
 451  *            object:property-change:accessible-table-column-header
 452  *            object:property-change:accessible-table-row-description
 453  *            object:property-change:accessible-table-row-header
 454  *            object:property-change:accessible-table-summary
 455  *
 456  *    (other object events)
 457  *
 458  *            object:state-changed
 459  *            object:children-changed
 460  *            object:visible-data-changed
 461  *            object:selection-changed
 462  *            object:text-selection-changed
 463  *            object:text-changed
 464  *            object:text-caret-moved
 465  *            object:row-inserted
 466  *            object:row-reordered
 467  *            object:row-deleted
 468  *            object:column-inserted
 469  *            object:column-reordered
 470  *            object:column-deleted
 471  *            object:model-changed
 472  *            object:active-descendant-changed
 473  *
 474  *  (screen reader events)
 475 *             screen-reader:region-changed
 476  *
 477  *  (window events)
 478  *
 479  *            window:minimize
 480  *            window:maximize
 481  *            window:restore
 482  *            window:close
 483  *            window:create
 484  *            window:reparent
 485  *            window:desktop-create
 486  *            window:desktop-destroy
 487  *            window:activate
 488  *            window:deactivate
 489  *            window:raise
 490  *            window:lower
 491  *            window:move
 492  *            window:resize
 493  *            window:shade
 494  *            window:unshade
 495  *            window:restyle
 496  *
 497  *  (other events)
 498  *
 499  *            focus:
 500  *            mouse:abs
 501  *            mouse:rel
 502  *            mouse:b1p
 503  *            mouse:b1r
 504  *            mouse:b2p
 505  *            mouse:b2r
 506  *            mouse:b3p
 507  *            mouse:b3r
 508  *
 509  * NOTE: this character string may be UTF-8, but should not contain byte
 510  * value 56
 511  *            (ascii ':'), except as a delimiter, since non-UTF-8 string
 512  *            delimiting functions are used internally.
 513  *            In general, listening to
 514  *            toolkit-specific events is not recommended.
 515  *
 516  * Currently, object:text-reading-position needs to be specified explicitly
 517  * (it is not implied by object:text), since it is generated by the screen
 518  * reader and is thus a special case internally.
 519  *
 520  * Returns: #TRUE if successful, otherwise #FALSE.
 521  **/
 522 gboolean
 523 atspi_event_listener_register (AtspiEventListener *listener,
 524                                              const gchar              *event_type,
 525                                              GError **error)
 526 {
 527   /* TODO: Keep track of which events have been registered, so that we
 528  * deregister all of them when the event listener is destroyed */
 529
 530   return atspi_event_listener_register_from_callback (listener->callback,
 531                                                       listener->user_data,
 532                                                       listener->cb_destroyed,
 533                                                       event_type, error);
 534 }
 535
 536 /**
 537  * atspi_event_listener_register_full:
 538  * @listener: The #AtspiEventListener to register against an event type.
 539  * @event_type: a character string indicating the type of events for which
 540  *            notification is requested.  See #atspi_event_listener_register
 541  * for a description of the format and legal event types.
 542 * @properties: (element-type gchar*) (transfer none) (allow-none): a list of
 543  *             properties that should be sent along with the event. The
 544  *             properties are valued for the duration of the event callback.k
 545  *             TODO: Document.
 546  *
 547  * Adds an in-process callback function to an existing #AtspiEventListener.
 548  *
 549  * Returns: #TRUE if successful, otherwise #FALSE.
 550  **/
 551 gboolean
 552 atspi_event_listener_register_full (AtspiEventListener *listener,
 553                                              const gchar              *event_type,
 554                                              GArray *properties,
 555                                              GError **error)
 556 {
 557   /* TODO: Keep track of which events have been registered, so that we
 558  * deregister all of them when the event listener is destroyed */
 559
 560   return atspi_event_listener_register_from_callback_full (listener->callback,
 561                                                            listener->user_data,
 562                                                            listener->cb_destroyed,
 563                                                            event_type,
 564                                                            properties,
 565                                                            error);
 566 }
 567
 568 static gboolean
 569 notify_event_registered (EventListenerEntry *e)
 570 {
 571
 572   if (e->properties)
 573     dbind_method_call_reentrant (_atspi_bus (), atspi_bus_registry,
 574                                  atspi_path_registry,
 575                                  atspi_interface_registry,
 576                                  "RegisterEvent",
 577                                  NULL, "sas", e->event_type,
 578                                  e->properties);
 579   else
 580     dbind_method_call_reentrant (_atspi_bus (), atspi_bus_registry,
 581                                  atspi_path_registry,
 582                                  atspi_interface_registry,
 583                                  "RegisterEvent",
 584                                  NULL, "s", e->event_type);
 585
 586   return TRUE;
 587 }
 588
 589 /**
 590  * atspi_event_listener_register_from_callback:
 591  * @callback: (scope notified): the #AtspiEventListenerCB to be registered
 592  * against an event type.
 593  * @user_data: (closure): User data to be passed to the callback.
 594  * @callback_destroyed: A #GDestroyNotify called when the callback is destroyed.
 595  * @event_type: a character string indicating the type of events for which
 596  *            notification is requested.  See #atspi_event_listener_register
 597  * for a description of the format.
 598  *
 599  * Registers an #AtspiEventListenerCB against an @event_type.
 600  *
 601  * Returns: #TRUE if successfull, otherwise #FALSE.
 602  *
 603  **/
 604 gboolean
 605 atspi_event_listener_register_from_callback (AtspiEventListenerCB callback,
 606                                              void *user_data,
 607                                              GDestroyNotify callback_destroyed,
 608                                              const gchar              *event_type,
 609                                              GError **error)
 610 {
 611   return atspi_event_listener_register_from_callback_full (callback,
 612                                                            user_data,
 613                                                            callback_destroyed,
 614                                                            event_type, NULL,
 615                                                            error);
 616 }
 617
 618 static GArray *
 619 copy_event_properties (GArray *src)
 620 {
 621   gint i;
 622
 623   GArray *dst = g_array_new (FALSE, FALSE, sizeof (char *));
 624
 625   if (!src)
 626     return dst;
 627   for (i = 0; i < src->len; i++)
 628     {
 629       gchar *dup = g_strdup (g_array_index (src, char *, i));
 630     g_array_append_val (dst, dup);
 631     }
 632   return dst;
 633 }
 634
 635 /**
 636  * atspi_event_listener_register_from_callback_full:
 637  * @callback: (scope async): an #AtspiEventListenerCB function pointer.
 638  * @user_data: (closure callback)
 639  * @callback_destroyed: (destroy callback)
 640  * @event_type:
 641  * @properties: (element-type utf8)
 642  * @error:
 643  *
 644  * Returns: #TRUE if successful, otherwise #FALSE.
 645  *
 646  **/
 647 gboolean
 648 atspi_event_listener_register_from_callback_full (AtspiEventListenerCB callback,
 649                                                   void *user_data,
 650                                                   GDestroyNotify callback_destroyed,
 651                                                   const gchar              *event_type,
 652                                                   GArray *properties,
 653                                                   GError **error)
 654 {
 655   EventListenerEntry *e;
 656   DBusError d_error;
 657   GPtrArray *matchrule_array;
 658   gint i;
 659
 660   if (!callback)
 661     {
 662       return FALSE;
 663     }
 664
 665   if (!event_type)
 666   {
 667     g_warning ("called atspi_event_listener_register_from_callback with a NULL event_type");
 668     return FALSE;
 669   }
 670
 671   e = g_new (EventListenerEntry, 1);
 672   e->event_type = g_strdup (event_type);
 673   e->callback = callback;
 674   e->user_data = user_data;
 675   e->callback_destroyed = callback_destroyed;
 676   callback_ref (callback == remove_datum ? (gpointer)user_data : (gpointer)callback,
 677                 callback_destroyed);
 678   if (!convert_event_type_to_dbus (event_type, &e->category, &e->name, &e->detail, &matchrule_array))
 679   {
 680     g_free (e);
 681     return FALSE;
 682   }
 683   e->properties = copy_event_properties (properties);
 684   event_listeners = g_list_prepend (event_listeners, e);
 685   for (i = 0; i < matchrule_array->len; i++)
 686   {
 687     char *matchrule = g_ptr_array_index (matchrule_array, i);
 688     dbus_error_init (&d_error);
 689     dbus_bus_add_match (_atspi_bus(), matchrule, &d_error);
 690     if (dbus_error_is_set (&d_error))
 691       {
 692         g_warning ("AT-SPI: Adding match: %s", d_error.message);
 693         dbus_error_free (&d_error);
 694         /* TODO: Set error */
 695       }
 696
 697     g_free (matchrule);
 698   }
 699   g_ptr_array_free (matchrule_array, TRUE);
 700
 701   notify_event_registered (e);
 702   return TRUE;
 703 }
 704
 705 void
 706 _atspi_reregister_event_listeners ()
 707 {
 708   GList *l;
 709   EventListenerEntry *e;
 710
 711   for (l = event_listeners; l; l = l->next)
 712     {
 713       e = l->data;
 714       notify_event_registered (e);
 715     }
 716 }
 717
 718 /**
 719  * atspi_event_listener_register_no_data: (skip)
 720  * @callback: (scope notified): the #AtspiEventListenerSimpleCB to be
 721  *            registered against an event type.
 722  * @callback_destroyed: A #GDestroyNotify called when the callback is destroyed.
 723  * @event_type: a character string indicating the type of events for which
 724  *            notification is requested.  Format is
 725  *            EventClass:major_type:minor_type:detail
 726  *            where all subfields other than EventClass are optional.
 727  *            EventClasses include "object", "window", "mouse",
 728  *            and toolkit events (e.g. "Gtk", "AWT").
 729  *            Examples: "focus:", "Gtk:GtkWidget:button_press_event".
 730  *
 731  * Registers an #AtspiEventListenetSimpleCB. The method is similar to
 732  * #atspi_event_listener_register, but @callback takes no user_data.
 733  *
 734  * Returns: #TRUE if successfull, otherwise #FALSE.
 735  **/
 736 gboolean
 737 atspi_event_listener_register_no_data (AtspiEventListenerSimpleCB callback,
 738                                  GDestroyNotify callback_destroyed,
 739                                  const gchar              *event_type,
 740                                  GError **error)
 741 {
 742   return atspi_event_listener_register_from_callback (remove_datum, callback,
 743                                                       callback_destroyed,
 744                                                       event_type, error);
 745 }
 746
 747 static gboolean
 748 is_superset (const gchar *super, const gchar *sub)
 749 {
 750   if (!super || !super [0])
 751     return TRUE;
 752   return (strcmp (super, sub) == 0);
 753 }
 754
 755 /**
 756  * atspi_event_listener_deregister:
 757  * @listener: The #AtspiEventListener to deregister.
 758  * @event_type: a string specifying the event type for which this
 759  *             listener is to be deregistered.
 760  *
 761  * Deregisters an #AtspiEventListener from the registry, for a specific
 762  *             event type.
 763  *
 764  * Returns: #TRUE if successful, otherwise #FALSE.
 765  **/
 766 gboolean
 767 atspi_event_listener_deregister (AtspiEventListener *listener,
 768                                                const gchar              *event_type,
 769                                                GError **error)
 770 {
 771   return atspi_event_listener_deregister_from_callback (listener->callback,
 772                                                         listener->user_data,
 773                                                         event_type, error);
 774 }
 775
 776 /**
 777  * atspi_event_listener_deregister_from_callback:
 778  * @callback: (scope call): the #AtspiEventListenerCB registered against an
 779  *            event type.
 780  * @user_data: (closure): User data that was passed in for this callback.
 781  * @event_type: a string specifying the event type for which this
 782  *             listener is to be deregistered.
 783  *
 784  * Deregisters an #AtspiEventListenerCB from the registry, for a specific
 785  *             event type.
 786  *
 787  * Returns: #TRUE if successful, otherwise #FALSE.
 788  **/
 789 gboolean
 790 atspi_event_listener_deregister_from_callback (AtspiEventListenerCB callback,
 791                                                void *user_data,
 792                                                const gchar              *event_type,
 793                                                GError **error)
 794 {
 795   char *category, *name, *detail;
 796   GPtrArray *matchrule_array;
 797   gint i;
 798   GList *l;
 799   gboolean result = TRUE;
 800
 801   if (!callback)
 802   {
 803     return FALSE;
 804   }
 805   if (!convert_event_type_to_dbus (event_type, &category, &name, &detail, &matchrule_array))
 806   {
 807     return FALSE;
 808   }
 809
 810   for (l = event_listeners; l;)
 811   {
 812     EventListenerEntry *e = l->data;
 813     if (e->callback == callback &&
 814         e->user_data == user_data &&
 815         is_superset (category, e->category) &&
 816         is_superset (name, e->name) &&
 817         is_superset (detail, e->detail))
 818     {
 819       gboolean need_replace;
 820       DBusMessage *message, *reply;
 821       need_replace = (l == event_listeners);
 822       l = g_list_remove (l, e);
 823       if (need_replace)
 824         event_listeners = l;
 825       for (i = 0; i < matchrule_array->len; i++)
 826       {
 827         char *matchrule = g_ptr_array_index (matchrule_array, i);
 828         dbus_bus_remove_match (_atspi_bus(), matchrule, NULL);
 829       }
 830       message = dbus_message_new_method_call (atspi_bus_registry,
 831             atspi_path_registry,
 832             atspi_interface_registry,
 833             "DeregisterEvent");
 834       if (!message) {
 835         result = FALSE;
 836         break;
 837       }
 838       dbus_message_append_args (message, DBUS_TYPE_STRING, &event_type, DBUS_TYPE_INVALID);
 839       reply = _atspi_dbus_send_with_reply_and_block (message, error);
 840       if (reply)
 841         dbus_message_unref (reply);
 842
 843       listener_entry_free (e);
 844     }
 845     else l = g_list_next (l);
 846   }
 847   g_free (category);
 848   g_free (name);
 849   if (detail) g_free (detail);
 850   for (i = 0; i < matchrule_array->len; i++)
 851     g_free (g_ptr_array_index (matchrule_array, i));
 852   g_ptr_array_free (matchrule_array, TRUE);
 853   return result;
 854 }
 855
 856 /**
 857  * atspi_event_listener_deregister_no_data: (skip)
 858  * @callback: (scope call): the #AtspiEventListenerSimpleCB registered against
 859  *            an event type.
 860  * @event_type: a string specifying the event type for which this
 861  *             listener is to be deregistered.
 862  *
 863  * deregisters an #AtspiEventListenerSimpleCB from the registry, for a specific
 864  *             event type.
 865  *
 866  * Returns: #TRUE if successful, otherwise #FALSE.
 867  **/
 868 gboolean
 869 atspi_event_listener_deregister_no_data (AtspiEventListenerSimpleCB callback,
 870                                    const gchar              *event_type,
 871                                    GError **error)
 872 {
 873   return atspi_event_listener_deregister_from_callback (remove_datum, callback,
 874                                                         event_type,
 875                                                         error);
 876 }
 877
 878 static AtspiEvent *
 879 atspi_event_copy (AtspiEvent *src)
 880 {
 881   AtspiEvent *dst = g_new0 (AtspiEvent, 1);
 882   dst->type = g_strdup (src->type);
 883   dst->source = g_object_ref (src->source);
 884   dst->detail1 = src->detail1;
 885   dst->detail2 = src->detail2;
 886   g_value_init (&dst->any_data, G_VALUE_TYPE (&src->any_data));
 887   g_value_copy (&src->any_data, &dst->any_data);
 888   dst->sender = g_object_ref (src->sender);
 889   return dst;
 890 }
 891
 892 static void
 893 atspi_event_free (AtspiEvent *event)
 894 {
 895   g_object_unref (event->source);
 896   g_free (event->type);
 897   g_value_unset (&event->any_data);
 898   g_object_unref (event->sender);
 899   g_free (event);
 900 }
 901
 902 static gboolean
 903 detail_matches_listener (const char *event_detail, const char *listener_detail)
 904 {
 905   if (!listener_detail)
 906     return TRUE;
 907
 908   if (!event_detail)
 909     return FALSE;
 910
 911   return !(listener_detail [strcspn (listener_detail, ":")] == '\0'
 912                ? strncmp (listener_detail, event_detail,
 913                           strcspn (event_detail, ":"))
 914                : strcmp (listener_detail, event_detail));
 915 }
 916
 917 void
 918 _atspi_send_event (AtspiEvent *e)
 919 {
 920   char *category, *name, *detail;
 921   GList *l;
 922   GList *called_listeners = NULL;
 923
 924   /* Ensure that the value is set to avoid a Python exception */
 925   /* TODO: Figure out how to do this without using a private field */
 926   if (e->any_data.g_type == 0)
 927   {
 928     g_value_init (&e->any_data, G_TYPE_INT);
 929     g_value_set_int (&e->any_data, 0);
 930   }
 931
 932   if (!convert_event_type_to_dbus (e->type, &category, &name, &detail, NULL))
 933   {
 934     g_warning ("AT-SPI: Couldn't parse event: %s\n", e->type);
 935     return;
 936   }
 937   for (l = event_listeners; l; l = g_list_next (l))
 938   {
 939     EventListenerEntry *entry = l->data;
 940     if (!strcmp (category, entry->category) &&
 941         (entry->name == NULL || !strcmp (name, entry->name)) &&
 942         detail_matches_listener (detail, entry->detail))
 943     {
 944       GList *l2;
 945       for (l2 = called_listeners; l2; l2 = l2->next)
 946       {
 947         EventListenerEntry *e2 = l2->data;
 948         if (entry->callback == e2->callback && entry->user_data == e2->user_data)
 949           break;
 950       }
 951       if (!l2)
 952       {
 953         entry->callback (atspi_event_copy (e), entry->user_data);
 954         called_listeners = g_list_prepend (called_listeners, entry);
 955       }
 956     }
 957   }
 958   if (detail) g_free (detail);
 959   g_free (name);
 960   g_free (category);
 961   g_list_free (called_listeners);
 962 }
 963
 964 DBusHandlerResult
 965 _atspi_dbus_handle_event (DBusConnection *bus, DBusMessage *message, void *data)
 966 {
 967   char *detail = NULL;
 968   const char *category = dbus_message_get_interface (message);
 969   const char *sender = dbus_message_get_sender (message);
 970   const char *member = dbus_message_get_member (message);
 971   const char *signature = dbus_message_get_signature (message);
 972   gchar *name;
 973   gchar *converted_type;
 974   DBusMessageIter iter, iter_variant;
 975   dbus_message_iter_init (message, &iter);
 976   AtspiEvent e;
 977   dbus_int32_t detail1, detail2;
 978   char *p;
 979   GHashTable *cache = NULL;
 980
 981   if (strcmp (signature, "siiv(so)") != 0 &&
 982       strcmp (signature, "siiva{sv}") != 0)
 983   {
 984    g_warning ("Got invalid signature %s for signal %s from interface %s\n", signature, member, category);
 985     return DBUS_HANDLER_RESULT_HANDLED;
 986   }
 987
 988   memset (&e, 0, sizeof (e));
 989
 990   if (!category)
 991   {
 992     // TODO: Error
 993     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 994   }
 995
 996   category = g_utf8_strrchr (category, -1, '.');
 997   if (category == NULL)
 998   {
 999     // TODO: Error
1000     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1001   }
1002   category++;
1003
1004   dbus_message_iter_get_basic (&iter, &detail);
1005   dbus_message_iter_next (&iter);
1006   dbus_message_iter_get_basic (&iter, &detail1);
1007   e.detail1 = detail1;
1008   dbus_message_iter_next (&iter);
1009   dbus_message_iter_get_basic (&iter, &detail2);
1010   e.detail2 = detail2;
1011   dbus_message_iter_next (&iter);
1012
1013   converted_type = convert_name_from_dbus (category, FALSE);
1014   name = convert_name_from_dbus (member, FALSE);
1015   detail = convert_name_from_dbus (detail, TRUE);
1016
1017   if (strcasecmp  (category, name) != 0)
1018   {
1019     p = g_strconcat (converted_type, ":", name, NULL);
1020     g_free (converted_type);
1021     converted_type = p;
1022   }
1023   else if (detail [0] == '\0')
1024   {
1025     p = g_strconcat (converted_type, ":",  NULL);
1026     g_free (converted_type);
1027     converted_type = p;
1028   }
1029
1030   if (detail[0] != '\0')
1031   {
1032     p = g_strconcat (converted_type, ":", detail, NULL);
1033     g_free (converted_type);
1034     converted_type = p;
1035   }
1036   e.type = converted_type;
1037   if (strcmp (category, "ScreenReader") != 0)
1038   {
1039     e.source = _atspi_ref_accessible (sender, dbus_message_get_path (message));
1040     if (e.source == NULL)
1041     {
1042       g_warning ("Got no valid source accessible for signal %s from interface %s\n", member, category);
1043       g_free (converted_type);
1044       g_free (name);
1045       g_free (detail);
1046       return DBUS_HANDLER_RESULT_HANDLED;
1047     }
1048   }
1049
1050   dbus_message_iter_recurse (&iter, &iter_variant);
1051   switch (dbus_message_iter_get_arg_type (&iter_variant))
1052   {
1053     case DBUS_TYPE_STRUCT:
1054     {
1055       AtspiRect rect;
1056       if (demarshal_rect (&iter_variant, &rect))
1057       {
1058         g_value_init (&e.any_data, ATSPI_TYPE_RECT);
1059         g_value_set_boxed (&e.any_data, &rect);
1060       }
1061       else
1062       {
1063         AtspiAccessible *accessible;
1064         accessible = _atspi_dbus_return_accessible_from_iter (&iter_variant);
1065         if (!strcmp (category, "ScreenReader"))
1066         {
1067           e.source = accessible;
1068         }
1069         else
1070         {
1071           g_value_init (&e.any_data, ATSPI_TYPE_ACCESSIBLE);
1072           g_value_set_instance (&e.any_data, accessible);
1073           if (accessible)
1074             g_object_unref (accessible);        /* value now owns it */
1075         }
1076       }
1077       break;
1078     }
1079     case DBUS_TYPE_STRING:
1080     {
1081       dbus_message_iter_get_basic (&iter_variant, &p);
1082       g_value_init (&e.any_data, G_TYPE_STRING);
1083       g_value_set_string (&e.any_data, p);
1084       break;
1085     }
1086   default:
1087     break;
1088   }
1089
1090   dbus_message_iter_next (&iter);
1091   if (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_ARRAY)
1092   {
1093     /* new form -- parse properties sent with event */
1094     cache = _atspi_dbus_update_cache_from_dict (e.source, &iter);
1095   }
1096
1097   e.sender = _atspi_ref_accessible (sender, ATSPI_DBUS_PATH_ROOT);
1098
1099   if (!strncmp (e.type, "object:children-changed", 23))
1100   {
1101     cache_process_children_changed (&e);
1102   }
1103   else if (!strncmp (e.type, "object:property-change", 22))
1104   {
1105     cache_process_property_change (&e);
1106   }
1107   else if (!strncmp (e.type, "object:state-changed", 20))
1108   {
1109     cache_process_state_changed (&e);
1110   }
1111   else if (!strncmp (e.type, "focus", 5))
1112   {
1113     /* BGO#663992 - TODO: figure out the real problem */
1114     e.source->cached_properties &= ~(ATSPI_CACHE_STATES);
1115   }
1116
1117   _atspi_send_event (&e);
1118
1119   if (cache)
1120     _atspi_accessible_unref_cache (e.source);
1121
1122   g_free (converted_type);
1123   g_free (name);
1124   g_free (detail);
1125   g_object_unref (e.source);
1126   g_value_unset (&e.any_data);
1127   return DBUS_HANDLER_RESULT_HANDLED;
1128 }
1129
1130 G_DEFINE_BOXED_TYPE (AtspiEvent, atspi_event, atspi_event_copy, atspi_event_free)