atk-adaptor/event.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2011, F123 Consulting & Mais Diferenças
   6  * Copyright 2008, 2009, Codethink Ltd.
   7  * Copyright 2001, 2002, 2003 Sun Microsystems Inc.,
   8  * Copyright 2001, 2002, 2003 Ximian, Inc.
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Library General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Library General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Library General Public
  21  * License along with this library; if not, write to the
  22  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23  * Boston, MA 02111-1307, USA.
  24  */
  25
  26 #include <string.h>
  27 #include <ctype.h>
  28
  29 #include <atk/atk.h>
  30 #include <droute/droute.h>
  31 #include <atspi/atspi.h>
  32
  33 #include "bridge.h"
  34 #include "accessible-register.h"
  35
  36 #include "spi-dbus.h"
  37 #include "event.h"
  38 #include "object.h"
  39
  40 static GArray *listener_ids = NULL;
  41
  42 static gint atk_bridge_key_event_listener_id;
  43 static gint atk_bridge_focus_tracker_id;
  44
  45 /*---------------------------------------------------------------------------*/
  46
  47 #define ITF_EVENT_OBJECT   "org.a11y.atspi.Event.Object"
  48 #define ITF_EVENT_WINDOW   "org.a11y.atspi.Event.Window"
  49 #define ITF_EVENT_DOCUMENT "org.a11y.atspi.Event.Document"
  50 #define ITF_EVENT_FOCUS    "org.a11y.atspi.Event.Focus"
  51
  52 /*---------------------------------------------------------------------------*/
  53
  54 typedef struct _SpiReentrantCallClosure
  55 {
  56   DBusConnection *bus;
  57   GMainLoop   *loop;
  58   DBusMessage *reply;
  59   guint timeout;
  60 } SpiReentrantCallClosure;
  61
  62 static void
  63 switch_main_context (GMainContext *cnx)
  64 {
  65   GList *list;
  66
  67   if (spi_global_app_data->server)
  68     atspi_dbus_server_setup_with_g_main (spi_global_app_data->server, cnx);
  69   atspi_dbus_connection_setup_with_g_main (spi_global_app_data->bus, cnx);
  70   atspi_set_main_context (cnx);
  71   for (list = spi_global_app_data->direct_connections; list; list = list->next)
  72     atspi_dbus_connection_setup_with_g_main (list->data, cnx);
  73 }
  74
  75 static void
  76 set_reply (DBusPendingCall * pending, void *user_data)
  77 {
  78   SpiReentrantCallClosure* closure = (SpiReentrantCallClosure *) user_data;
  79
  80   closure->reply = dbus_pending_call_steal_reply (pending);
  81   dbus_pending_call_unref (pending);
  82   switch_main_context (NULL);
  83   g_main_loop_quit (closure->loop);
  84 }
  85
  86 static gboolean
  87 timeout_reply (void *data)
  88 {
  89   SpiReentrantCallClosure *closure = data;
  90
  91   switch_main_context (NULL);
  92   g_main_loop_quit (closure->loop);
  93   closure->timeout = -1;
  94   return FALSE;
  95 }
  96
  97 static DBusMessage *
  98 send_and_allow_reentry (DBusConnection * bus, DBusMessage * message)
  99 {
 100   DBusPendingCall *pending;
 101   SpiReentrantCallClosure closure;
 102   GSource *source;
 103
 104   closure.bus = bus;
 105   closure.loop = g_main_loop_new (spi_global_app_data->main_context, FALSE);
 106   closure.reply = NULL;
 107   switch_main_context (spi_global_app_data->main_context);
 108
 109   if (!dbus_connection_send_with_reply (bus, message, &pending, 9000) || !pending)
 110     {
 111       switch_main_context (NULL);
 112       return NULL;
 113     }
 114   dbus_pending_call_set_notify (pending, set_reply, (void *) &closure, NULL);
 115   source = g_timeout_source_new (500);
 116   g_source_set_callback (source, timeout_reply, &closure, NULL);
 117   closure.timeout = g_source_attach (source, spi_global_app_data->main_context);
 118   g_source_unref (source);
 119   g_main_loop_run  (closure.loop);
 120   if (closure.timeout != -1)
 121     g_source_destroy (source);
 122
 123   g_main_loop_unref (closure.loop);
 124   if (!closure.reply)
 125     dbus_pending_call_cancel (pending);
 126   return closure.reply;
 127 }
 128
 129 /*---------------------------------------------------------------------------*/
 130
 131 /*
 132  * Functionality related to sending device events from the application.
 133  *
 134  * This is used for forwarding key events on to the registry daemon.
 135  */
 136
 137 static gboolean
 138 Accessibility_DeviceEventController_NotifyListenersSync (const
 139                                                          AtspiDeviceEvent
 140                                                          * key_event)
 141 {
 142   DBusMessage *message;
 143   dbus_bool_t consumed = FALSE;
 144
 145   message =
 146     dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,
 147                                   ATSPI_DBUS_PATH_DEC,
 148                                   ATSPI_DBUS_INTERFACE_DEC,
 149                                   "NotifyListenersSync");
 150
 151   if (spi_dbus_marshal_deviceEvent (message, key_event))
 152     {
 153       DBusMessage *reply =
 154         send_and_allow_reentry (spi_global_app_data->bus, message);
 155       if (reply)
 156         {
 157           DBusError error;
 158           dbus_error_init (&error);
 159           if (!dbus_message_get_args (reply, &error, DBUS_TYPE_BOOLEAN,
 160               &consumed, DBUS_TYPE_INVALID))
 161             {
 162               /* TODO: print a warning */
 163               dbus_error_free (&error);
 164             }
 165           dbus_message_unref (reply);
 166         }
 167     }
 168   dbus_message_unref (message);
 169   return consumed;
 170 }
 171
 172 static void
 173 spi_init_keystroke_from_atk_key_event (AtspiDeviceEvent * keystroke,
 174                                        AtkKeyEventStruct * event)
 175 {
 176   keystroke->id = (dbus_int32_t) event->keyval;
 177   keystroke->hw_code = (dbus_int16_t) event->keycode;
 178   keystroke->timestamp = (dbus_uint32_t) event->timestamp;
 179   keystroke->modifiers = (dbus_uint16_t) (event->state & 0xFFFF);
 180   if (event->string)
 181     {
 182       gunichar c;
 183
 184       keystroke->event_string = g_strdup (event->string);
 185       c = g_utf8_get_char_validated (event->string, -1);
 186       if (c > 0 && g_unichar_isprint (c))
 187         keystroke->is_text = TRUE;
 188       else
 189         keystroke->is_text = FALSE;
 190     }
 191   else
 192     {
 193       keystroke->event_string = g_strdup ("");
 194       keystroke->is_text = FALSE;
 195     }
 196   switch (event->type)
 197     {
 198     case (ATK_KEY_EVENT_PRESS):
 199       keystroke->type = ATSPI_KEY_PRESSED;
 200       break;
 201     case (ATK_KEY_EVENT_RELEASE):
 202       keystroke->type = ATSPI_KEY_RELEASED;
 203       break;
 204     default:
 205       keystroke->type = 0;
 206       break;
 207     }
 208 #if 0
 209   g_print
 210     ("key_event type %d; val=%d code=%d modifiers=%x name=%s is_text=%d, time=%lx\n",
 211      (int) keystroke->type, (int) keystroke->id, (int) keystroke->hw_code,
 212      (int) keystroke->modifiers, keystroke->event_string,
 213      (int) keystroke->is_text, (unsigned long) keystroke->timestamp);
 214 #endif
 215 }
 216
 217
 218 static gint
 219 spi_atk_bridge_key_listener (AtkKeyEventStruct * event, gpointer data)
 220 {
 221   gboolean result;
 222   AtspiDeviceEvent key_event;
 223
 224   spi_init_keystroke_from_atk_key_event (&key_event, event);
 225
 226   result =
 227     Accessibility_DeviceEventController_NotifyListenersSync (&key_event);
 228
 229   if (key_event.event_string)
 230     g_free (key_event.event_string);
 231
 232   return result;
 233 }
 234
 235 /*---------------------------------------------------------------------------*/
 236
 237 static const void *
 238 validate_for_dbus (const gint type,
 239               const void *val)
 240 {
 241   switch (type)
 242     {
 243       case DBUS_TYPE_STRING:
 244       case DBUS_TYPE_OBJECT_PATH:
 245            if (!val)
 246               return "";
 247            else if (!g_utf8_validate (val, -1, NULL))
 248              {
 249                g_warning ("atk-bridge: Received bad UTF-8 string when emitting event");
 250                return "";
 251                }
 252            else
 253               return val;
 254       default:
 255            return val;
 256     }
 257 }
 258
 259 static void
 260 append_basic (DBusMessageIter *iter,
 261               const char *type,
 262               const void *val)
 263 {
 264   DBusMessageIter sub;
 265
 266   dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, type, &sub);
 267
 268     val = validate_for_dbus ((int) *type, val);
 269     dbus_message_iter_append_basic(&sub, (int) *type, &val);
 270
 271   dbus_message_iter_close_container(iter, &sub);
 272 }
 273
 274 static void
 275 append_rect (DBusMessageIter *iter,
 276              const char *type,
 277              const void *val)
 278 {
 279   DBusMessageIter variant, sub;
 280   const AtkRectangle *rect = (const AtkRectangle *) val;
 281
 282   dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, type, &variant);
 283
 284     dbus_message_iter_open_container (&variant, DBUS_TYPE_STRUCT, NULL, &sub);
 285
 286       dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->x));
 287       dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->y));
 288       dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->width));
 289       dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->height));
 290
 291     dbus_message_iter_close_container (&variant, &sub);
 292
 293   dbus_message_iter_close_container(iter, &variant);
 294 }
 295
 296 static void
 297 append_object (DBusMessageIter *iter,
 298                const char *type,
 299                const void *val)
 300 {
 301   spi_object_append_v_reference (iter, ATK_OBJECT (val));
 302 }
 303
 304 static gchar *
 305 signal_name_to_dbus (const gchar *s)
 306 {
 307   gchar *ret = g_strdup (s);
 308   gchar *t;
 309
 310   if (!ret)
 311     return NULL;
 312   ret [0] = toupper (ret [0]);
 313   while ((t = strchr (ret, '-')) != NULL)
 314   {
 315     memmove (t, t + 1, strlen (t));
 316     *t = toupper (*t);
 317   }
 318   return ret;
 319 }
 320
 321 /*
 322  * Converts names of the form "active-descendant-changed" to
 323  * "ActiveDescendantChanged"
 324  */
 325 static gchar *
 326 ensure_proper_format (const char *name)
 327 {
 328   gchar *ret = (gchar *) g_malloc (strlen (name) * 2 + 2);
 329   gchar *p = ret;
 330   gboolean need_upper = TRUE;
 331
 332   if (!ret)
 333     return NULL;
 334   while (*name)
 335     {
 336       if (need_upper)
 337         {
 338           *p++ = toupper (*name);
 339           need_upper = FALSE;
 340         }
 341       else if (*name == '-')
 342         need_upper = TRUE;
 343       else if (*name == ':')
 344         {
 345           need_upper = TRUE;
 346           *p++ = *name;
 347         }
 348       else
 349         *p++ = *name;
 350       name++;
 351     }
 352   *p = '\0';
 353   return ret;
 354 }
 355
 356 void
 357 append_properties (GArray *properties, event_data *evdata)
 358 {
 359   GSList *ls;
 360   gint i;
 361
 362   for (ls = evdata->properties; ls; ls = ls->next)
 363   {
 364     gboolean dup = FALSE;
 365     for (i = 0; i < properties->len; i++)
 366     {
 367       if (ls->data == g_array_index (properties, AtspiPropertyDefinition *, i))
 368       {
 369         dup = TRUE;
 370         break;
 371       }
 372     }
 373     if (!dup)
 374       g_array_append_val (properties, ls->data);
 375   }
 376 }
 377
 378 static gboolean
 379 signal_is_needed (AtkObject *obj, const gchar *klass, const gchar *major,
 380                   const gchar *minor, GArray **properties)
 381 {
 382   gchar *data [4];
 383   event_data *evdata;
 384   gboolean ret = FALSE;
 385   GList *list;
 386   GArray *props = NULL;
 387
 388   if (!spi_global_app_data->events_initialized)
 389     return TRUE;
 390
 391   data [0] = ensure_proper_format (klass[0] ? klass + 21 : klass);
 392   data [1] = ensure_proper_format (major);
 393   data [2] = ensure_proper_format (minor);
 394   data [3] = NULL;
 395
 396   /* Hack: Always pass events that update the cache.
 397    * TODO: FOr 2.2, have at-spi2-core define a special "cache listener" for
 398    * this instead, so that we don't send these if no one is listening */
 399   if (!g_strcmp0 (data [1], "ChildrenChanged") ||
 400       ((!g_strcmp0 (data [1], "PropertyChange")) &&
 401        (!g_strcmp0 (data [2], "accessible-name") ||
 402         !g_strcmp0 (data [2], "accessible-description") ||
 403         !g_strcmp0 (data [2], "accessible-parent") ||
 404         !g_strcmp0 (data [2], "accessible-role"))) ||
 405       !g_strcmp0 (data [1], "StateChanged"))
 406   {
 407     if (minor && !g_strcmp0 (minor, "defunct"))
 408       ret = TRUE;
 409     else
 410     {
 411       AtkStateSet *set = atk_object_ref_state_set (obj);
 412       AtkState state = ((!g_strcmp0 (data[1], "ChildrenChanged")) ?
 413                         ATK_STATE_MANAGES_DESCENDANTS : ATK_STATE_TRANSIENT);
 414       ret = !atk_state_set_contains_state (set, state);
 415       g_object_unref (set);
 416     }
 417   }
 418
 419   /* Hack: events such as "object::text-changed::insert:system" as
 420      generated by Gecko */
 421   data [2][strcspn (data [2], ":")] = '\0';
 422
 423   for (list = spi_global_app_data->events; list; list = list->next)
 424     {
 425       evdata = list->data;
 426       if (spi_event_is_subtype (data, evdata->data))
 427         {
 428           ret = TRUE;
 429           if (!props)
 430           props = g_array_new (TRUE, TRUE, sizeof (AtspiPropertyDefinition *));
 431           append_properties (props, evdata);
 432         }
 433     }
 434
 435   g_free (data [2]);
 436   g_free (data [1]);
 437   g_free (data [0]);
 438   *properties = props;
 439   return ret;
 440 }
 441
 442 /* Convert a : to a / so that listeners can use arg0path to match only
 443  *  * the prefix */
 444 static char *
 445 adapt_minor_for_dbus (const char *source)
 446 {
 447   gchar *ret = g_strdup (source);
 448   int i = strcspn (ret, ":");
 449   if (ret[i] == ':')
 450     ret[i] = '/';
 451   return ret;
 452 }
 453
 454 static void
 455 open_variant (DBusMessageIter *iter, const char *name, const char *type,
 456               DBusMessageIter *out)
 457 {
 458   dbus_message_iter_append_basic (iter, DBUS_TYPE_STRING, &name);
 459   dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, type, out);
 460 }
 461
 462 /*
 463  * Emits an AT-SPI event.
 464  * AT-SPI events names are split into three parts:
 465  * class:major:minor
 466  * This is mapped onto D-Bus events as:
 467  * D-Bus Interface:Signal Name:Detail argument
 468  *
 469  * Marshals a basic type into the 'any_data' attribute of
 470  * the AT-SPI event.
 471  */
 472 static void
 473 emit_event (AtkObject  *obj,
 474             const char *klass,
 475             const char *major,
 476             const char *minor,
 477             dbus_int32_t detail1,
 478             dbus_int32_t detail2,
 479             const char *type,
 480             const void *val,
 481             void (*append_variant) (DBusMessageIter *, const char *, const void *))
 482 {
 483   DBusConnection *bus = spi_global_app_data->bus;
 484   char *path;
 485   char *minor_dbus;
 486
 487   gchar *cname;
 488   DBusMessage *sig;
 489   DBusMessageIter iter, iter_dict, iter_dict_entry, iter_variant, iter_array;
 490   GArray *properties = NULL;
 491
 492   if (!klass) klass = "";
 493   if (!major) major = "";
 494   if (!minor) minor = "";
 495   if (!type) type = "u";
 496
 497   if (!signal_is_needed (obj, klass, major, minor, &properties))
 498     return;
 499
 500   path =  spi_register_object_to_path (spi_global_register, G_OBJECT (obj));
 501   g_return_if_fail (path != NULL);
 502
 503   /*
 504    * This is very annoying, but as '-' isn't a legal signal
 505    * name in D-Bus (Why not??!?) The names need converting
 506    * on this side, and again on the client side.
 507    */
 508   cname = signal_name_to_dbus (major);
 509   sig = dbus_message_new_signal(path, klass, cname);
 510
 511   dbus_message_iter_init_append(sig, &iter);
 512
 513   minor_dbus = adapt_minor_for_dbus (minor);
 514   dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &minor_dbus);
 515   g_free (minor_dbus);
 516   dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &detail1);
 517   dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &detail2);
 518   append_variant (&iter, type, val);
 519
 520   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sv}", &iter_dict);
 521   /* Add requested properties, unless the object is being marked defunct, in
 522      which case it's safest not to touch it */
 523   if (minor == NULL || strcmp (minor, "defunct") != 0 || detail1 == 0)
 524   {
 525     if (properties)
 526     {
 527       gint i;
 528       for (i = 0; i < properties->len; i++)
 529       {
 530         AtspiPropertyDefinition *prop = g_array_index (properties, AtspiPropertyDefinition *, i);
 531         dbus_message_iter_open_container (&iter_dict, DBUS_TYPE_DICT_ENTRY, NULL,
 532                                           &iter_dict_entry);
 533         dbus_message_iter_append_basic (&iter_dict_entry, DBUS_TYPE_STRING, &prop->name);
 534         prop->func (&iter_dict_entry, obj);
 535         dbus_message_iter_close_container (&iter_dict, &iter_dict_entry);
 536       }
 537       g_array_free (properties, TRUE);
 538     }
 539   }
 540     dbus_message_iter_close_container (&iter, &iter_dict);
 541
 542   dbus_connection_send(bus, sig, NULL);
 543   dbus_message_unref(sig);
 544
 545   if (g_strcmp0 (cname, "ChildrenChanged") != 0)
 546     spi_object_lease_if_needed (G_OBJECT (obj));
 547
 548   g_free(cname);
 549   g_free (path);
 550 }
 551
 552 /*---------------------------------------------------------------------------*/
 553
 554 /*
 555  * The focus listener handles the ATK 'focus' signal and forwards it
 556  * as the AT-SPI event, 'focus:'
 557  */
 558 static void
 559 focus_tracker (AtkObject * accessible)
 560 {
 561   emit_event (accessible, ITF_EVENT_FOCUS, "focus", "", 0, 0,
 562               DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 563 }
 564
 565 /*---------------------------------------------------------------------------*/
 566
 567 #define PCHANGE "PropertyChange"
 568
 569 /*
 570  * This handler handles the following ATK signals and
 571  * converts them to AT-SPI events:
 572  *
 573  * Gtk:AtkObject:property-change -> object:property-change:(property-name)
 574  *
 575  * The property-name is part of the ATK property-change signal.
 576  */
 577 static gboolean
 578 property_event_listener (GSignalInvocationHint * signal_hint,
 579                          guint n_param_values,
 580                          const GValue * param_values, gpointer data)
 581 {
 582   AtkObject *accessible;
 583   AtkPropertyValues *values;
 584
 585   const gchar *pname = NULL;
 586
 587   AtkObject *otemp;
 588   const gchar *s1;
 589   gint i;
 590
 591   accessible = g_value_get_object (&param_values[0]);
 592   values = (AtkPropertyValues *) g_value_get_pointer (&param_values[1]);
 593
 594   pname = values[0].property_name;
 595
 596   /* TODO Could improve this control statement by matching
 597    * on only the end of the signal names,
 598    */
 599   if (strcmp (pname, "accessible-name") == 0)
 600     {
 601       s1 = atk_object_get_name (accessible);
 602       if (s1 != NULL)
 603         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 604                     DBUS_TYPE_STRING_AS_STRING, s1, append_basic);
 605     }
 606   else if (strcmp (pname, "accessible-description") == 0)
 607     {
 608       s1 = atk_object_get_description (accessible);
 609       if (s1 != NULL)
 610         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 611                     DBUS_TYPE_STRING_AS_STRING, s1, append_basic);
 612     }
 613   else if (strcmp (pname, "accessible-parent") == 0)
 614     {
 615       otemp = atk_object_get_parent (accessible);
 616       if (otemp != NULL)
 617         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 618                     "(so)", otemp, append_object);
 619     }
 620   else if (strcmp (pname, "accessible-role") == 0)
 621     {
 622       i = atk_object_get_role (accessible);
 623       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 624                     DBUS_TYPE_UINT32_AS_STRING, GINT_TO_POINTER(i), append_basic);
 625     }
 626   else if (strcmp (pname, "accessible-table-summary") == 0)
 627     {
 628       otemp = atk_table_get_summary (ATK_TABLE (accessible));
 629       if (otemp != NULL)
 630         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 631                     "(so)", otemp, append_object);
 632     }
 633   else if (strcmp (pname, "accessible-table-column-header") == 0)
 634     {
 635       i = g_value_get_int (&(values->new_value));
 636       otemp = atk_table_get_column_header (ATK_TABLE (accessible), i);
 637       if (otemp != NULL)
 638         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 639                     "(so)", otemp, append_object);
 640     }
 641   else if (strcmp (pname, "accessible-table-row-header") == 0)
 642     {
 643       i = g_value_get_int (&(values->new_value));
 644       otemp = atk_table_get_row_header (ATK_TABLE (accessible), i);
 645       if (otemp != NULL)
 646         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 647                     "(so)", otemp, append_object);
 648     }
 649   else if (strcmp (pname, "accessible-table-row-description") == 0)
 650     {
 651       i = g_value_get_int (&(values->new_value));
 652       s1 = atk_table_get_row_description (ATK_TABLE (accessible), i);
 653       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 654                   DBUS_TYPE_STRING_AS_STRING, s1, append_basic);
 655     }
 656   else if (strcmp (pname, "accessible-table-column-description") == 0)
 657     {
 658       i = g_value_get_int (&(values->new_value));
 659       s1 = atk_table_get_column_description (ATK_TABLE (accessible), i);
 660       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 661                   DBUS_TYPE_STRING_AS_STRING, s1, append_basic);
 662     }
 663   else if (strcmp (pname, "accessible-table-caption-object") == 0)
 664     {
 665       otemp = atk_table_get_caption (ATK_TABLE (accessible));
 666       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 667                   "(so)", otemp, append_object);
 668     }
 669   else
 670     {
 671       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 672             DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 673     }
 674   return TRUE;
 675 }
 676
 677 /*---------------------------------------------------------------------------*/
 678
 679 #define STATE_CHANGED "state-changed"
 680
 681 static void
 682 do_debug_thing (AtkObject *accessible)
 683 {
 684   AtkObject *parent;
 685   gint x, y, width, height;
 686
 687   do
 688   {
 689     parent = atk_object_get_parent (accessible);
 690     if (!ATK_IS_COMPONENT (accessible))
 691     {
 692     return;
 693   }
 694     atk_component_get_extents (ATK_COMPONENT (accessible), &x, &y, &width, &height, ATK_XY_SCREEN);
 695     accessible = parent;
 696   } while (accessible);
 697 }
 698
 699 /*
 700  * The state event listener handles 'Gtk:AtkObject:state-change' ATK signals
 701  * and forwards them as object:state-changed:(param-name) AT-SPI events. Where
 702  * the param-name is part of the ATK state-change signal.
 703  */
 704 static gboolean
 705 state_event_listener (GSignalInvocationHint * signal_hint,
 706                       guint n_param_values,
 707                       const GValue * param_values, gpointer data)
 708 {
 709   AtkObject *accessible;
 710   const gchar *pname;
 711   guint detail1;
 712
 713   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 714   pname = g_value_get_string (&param_values[1]);
 715
 716   detail1 = (g_value_get_boolean (&param_values[2])) ? 1 : 0;
 717   emit_event (accessible, ITF_EVENT_OBJECT, STATE_CHANGED, pname, detail1, 0,
 718               DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 719
 720 if (!g_strcmp0 (pname, "focused") && detail1 && g_getenv("DODEBUG")) do_debug_thing(accessible);
 721   if (!g_strcmp0 (pname, "defunct") && detail1)
 722     spi_register_deregister_object (spi_global_register, G_OBJECT (accessible),
 723                                     TRUE);
 724   return TRUE;
 725 }
 726
 727 /*---------------------------------------------------------------------------*/
 728
 729 /*
 730  * The window event listener handles the following ATK signals and forwards
 731  * them as AT-SPI events:
 732  *
 733  * window:create     -> window:create
 734  * window:destroy    -> window:destroy
 735  * window:minimize   -> window:minimize
 736  * window:maximize   -> window:maximize
 737  * window:activate   -> window:activate
 738  * window:deactivate -> window:deactivate
 739  */
 740 static gboolean
 741 window_event_listener (GSignalInvocationHint * signal_hint,
 742                        guint n_param_values,
 743                        const GValue * param_values, gpointer data)
 744 {
 745   AtkObject *accessible;
 746   GSignalQuery signal_query;
 747   const gchar *name, *s;
 748
 749   g_signal_query (signal_hint->signal_id, &signal_query);
 750   name = signal_query.signal_name;
 751
 752   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 753   s = atk_object_get_name (accessible);
 754   emit_event (accessible, ITF_EVENT_WINDOW, name, "", 0, 0,
 755               DBUS_TYPE_STRING_AS_STRING, s, append_basic);
 756
 757   return TRUE;
 758 }
 759
 760 /*---------------------------------------------------------------------------*/
 761
 762 /*
 763  * The document event listener handles the following ATK signals
 764  * and converts them to AT-SPI events:
 765  *
 766  * Gtk:AtkDocument:load-complete ->  document:load-complete
 767  * Gtk:AtkDocument:load-stopped  ->  document:load-stopped
 768  * Gtk:AtkDocument:reload        ->  document:reload
 769  * Gtk:AtkDocument:page-changed  ->  document:page-changed
 770  */
 771 static gboolean
 772 document_event_listener (GSignalInvocationHint * signal_hint,
 773                          guint n_param_values,
 774                          const GValue * param_values, gpointer data)
 775 {
 776   AtkObject *accessible;
 777   GSignalQuery signal_query;
 778   const gchar *name, *s;
 779   gint detail1 = 0;
 780
 781   g_signal_query (signal_hint->signal_id, &signal_query);
 782   name = signal_query.signal_name;
 783
 784   if (n_param_values > 0) // on the case of page-changed
 785     if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
 786       detail1 = g_value_get_int (&param_values[1]);
 787
 788   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 789   s = atk_object_get_name (accessible);
 790   emit_event (accessible, ITF_EVENT_DOCUMENT, name, "", detail1, 0,
 791               DBUS_TYPE_STRING_AS_STRING, s, append_basic);
 792
 793   return TRUE;
 794 }
 795
 796 /*---------------------------------------------------------------------------*/
 797
 798 /*
 799  * Signal handler for  "Gtk:AtkComponent:bounds-changed". Converts
 800  * this to an AT-SPI event - "object:bounds-changed".
 801  */
 802 static gboolean
 803 bounds_event_listener (GSignalInvocationHint * signal_hint,
 804                        guint n_param_values,
 805                        const GValue * param_values, gpointer data)
 806 {
 807   AtkObject *accessible;
 808   AtkRectangle *atk_rect;
 809   GSignalQuery signal_query;
 810   const gchar *name;
 811
 812   g_signal_query (signal_hint->signal_id, &signal_query);
 813   name = signal_query.signal_name;
 814
 815   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 816
 817   if (G_VALUE_HOLDS_BOXED (param_values + 1))
 818   {
 819     atk_rect = g_value_get_boxed (param_values + 1);
 820
 821     emit_event (accessible, ITF_EVENT_OBJECT, name, "", 0, 0,
 822                 "(iiii)", atk_rect, append_rect);
 823   }
 824   return TRUE;
 825 }
 826
 827 /*---------------------------------------------------------------------------*/
 828
 829 /*
 830  * Handles the ATK signal 'Gtk:AtkObject:active-descendant-changed' and
 831  * converts it to the AT-SPI signal - 'object:active-descendant-changed'.
 832  *
 833  */
 834 static gboolean
 835 active_descendant_event_listener (GSignalInvocationHint * signal_hint,
 836                                   guint n_param_values,
 837                                   const GValue * param_values, gpointer data)
 838 {
 839   AtkObject *accessible;
 840   AtkObject *child;
 841   GSignalQuery signal_query;
 842   const gchar *name;
 843   gint detail1;
 844
 845   g_signal_query (signal_hint->signal_id, &signal_query);
 846   name = signal_query.signal_name;
 847
 848   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 849   child = ATK_OBJECT (g_value_get_pointer (&param_values[1]));
 850   g_return_val_if_fail (ATK_IS_OBJECT (child), TRUE);
 851
 852   detail1 = atk_object_get_index_in_parent (child);
 853
 854   emit_event (accessible, ITF_EVENT_OBJECT, name, "", detail1, 0,
 855               "(so)", child, append_object);
 856   return TRUE;
 857 }
 858
 859 /*---------------------------------------------------------------------------*/
 860
 861 /*
 862  * Handles the ATK signal 'Gtk:AtkHypertext:link-selected' and
 863  * converts it to the AT-SPI signal - 'object:link-selected'
 864  *
 865  */
 866 static gboolean
 867 link_selected_event_listener (GSignalInvocationHint * signal_hint,
 868                               guint n_param_values,
 869                               const GValue * param_values, gpointer data)
 870 {
 871   AtkObject *accessible;
 872   GSignalQuery signal_query;
 873   const gchar *name, *minor;
 874   gint detail1 = 0;
 875
 876   g_signal_query (signal_hint->signal_id, &signal_query);
 877   name = signal_query.signal_name;
 878
 879   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 880   minor = g_quark_to_string (signal_hint->detail);
 881
 882   if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
 883     detail1 = g_value_get_int (&param_values[1]);
 884
 885   emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, 0,
 886               DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 887   return TRUE;
 888 }
 889
 890 /*---------------------------------------------------------------------------*/
 891
 892 /*
 893  * Handles the ATK signal 'Gtk:AtkText:text-changed' and
 894  * converts it to the AT-SPI signal - 'object:text-changed'
 895  * This signal is deprecated by Gtk:AtkText:text-insert
 896  * and Gtk:AtkText:text-remove
 897  *
 898  */
 899 static gboolean
 900 text_changed_event_listener (GSignalInvocationHint * signal_hint,
 901                              guint n_param_values,
 902                              const GValue * param_values, gpointer data)
 903 {
 904   AtkObject *accessible;
 905   GSignalQuery signal_query;
 906   const gchar *name, *minor;
 907   gchar *selected;
 908   gint detail1 = 0, detail2 = 0;
 909
 910   g_signal_query (signal_hint->signal_id, &signal_query);
 911   name = signal_query.signal_name;
 912
 913   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 914   minor = g_quark_to_string (signal_hint->detail);
 915
 916   if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
 917     detail1 = g_value_get_int (&param_values[1]);
 918
 919   if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)
 920     detail2 = g_value_get_int (&param_values[2]);
 921
 922   selected =
 923     atk_text_get_text (ATK_TEXT (accessible), detail1, detail1 + detail2);
 924
 925   emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
 926               DBUS_TYPE_STRING_AS_STRING, selected, append_basic);
 927   g_free (selected);
 928
 929   return TRUE;
 930 }
 931
 932 /*
 933  * Handles the ATK signal 'Gtk:AtkText:text-insert' and
 934  * converts it to the AT-SPI signal - 'object:text-changed'
 935  *
 936  */
 937 static gboolean
 938 text_insert_event_listener (GSignalInvocationHint * signal_hint,
 939                             guint n_param_values,
 940                             const GValue * param_values, gpointer data)
 941 {
 942   AtkObject *accessible;
 943   guint text_changed_signal_id;
 944   GSignalQuery signal_query;
 945   const gchar *name;
 946   const gchar *minor_raw, *text;
 947   gchar *minor;
 948   gint detail1 = 0, detail2 = 0;
 949
 950   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 951   /* Get signal name for 'Gtk:AtkText:text-changed' so
 952    * we convert it to the AT-SPI signal - 'object:text-changed'
 953    */
 954   text_changed_signal_id = g_signal_lookup ("text-changed", G_OBJECT_TYPE (accessible));
 955   g_signal_query (text_changed_signal_id, &signal_query);
 956   name = signal_query.signal_name;
 957
 958
 959   /* Add the insert and keep any detail coming from atk */
 960   minor_raw = g_quark_to_string (signal_hint->detail);
 961   if (minor_raw)
 962     minor = g_strconcat ("insert:", minor_raw, NULL);
 963   else
 964     minor = g_strdup ("insert");
 965
 966   if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
 967     detail1 = g_value_get_int (&param_values[1]);
 968
 969   if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)
 970     detail2 = g_value_get_int (&param_values[2]);
 971
 972   if (G_VALUE_TYPE (&param_values[3]) == G_TYPE_STRING)
 973     text = g_value_get_string (&param_values[3]);
 974
 975   emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
 976               DBUS_TYPE_STRING_AS_STRING, text, append_basic);
 977   g_free (minor);
 978   return TRUE;
 979 }
 980
 981 /*
 982  * Handles the ATK signal 'Gtk:AtkText:text-remove' and
 983  * converts it to the AT-SPI signal - 'object:text-changed'
 984  *
 985  */
 986 static gboolean
 987 text_remove_event_listener (GSignalInvocationHint * signal_hint,
 988                             guint n_param_values,
 989                             const GValue * param_values, gpointer data)
 990 {
 991   AtkObject *accessible;
 992   guint text_changed_signal_id;
 993   GSignalQuery signal_query;
 994   const gchar *name;
 995   const gchar *minor_raw, *text;
 996   gchar *minor;
 997   gint detail1 = 0, detail2 = 0;
 998
 999   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
1000   /* Get signal name for 'Gtk:AtkText:text-changed' so
1001    * we convert it to the AT-SPI signal - 'object:text-changed'
1002    */
1003   text_changed_signal_id = g_signal_lookup ("text-changed", G_OBJECT_TYPE (accessible));
1004   g_signal_query (text_changed_signal_id, &signal_query);
1005   name = signal_query.signal_name;
1006
1007   minor_raw = g_quark_to_string (signal_hint->detail);
1008
1009   /* Add the delete and keep any detail coming from atk */
1010   if (minor_raw)
1011     minor = g_strconcat ("delete:", minor_raw, NULL);
1012   else
1013     minor = g_strdup ("delete");
1014
1015   if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
1016     detail1 = g_value_get_int (&param_values[1]);
1017
1018   if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)
1019     detail2 = g_value_get_int (&param_values[2]);
1020
1021   if (G_VALUE_TYPE (&param_values[3]) == G_TYPE_STRING)
1022     text = g_value_get_string (&param_values[3]);
1023
1024   emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
1025               DBUS_TYPE_STRING_AS_STRING, text, append_basic);
1026   g_free (minor);
1027   return TRUE;
1028 }
1029
1030
1031 /*---------------------------------------------------------------------------*/
1032
1033 /*
1034  * Handles the ATK signal 'Gtk:AtkText:text-selection-changed' and
1035  * converts it to the AT-SPI signal - 'object:text-selection-changed'
1036  *
1037  */
1038 static gboolean
1039 text_selection_changed_event_listener (GSignalInvocationHint * signal_hint,
1040                                        guint n_param_values,
1041                                        const GValue * param_values,
1042                                        gpointer data)
1043 {
1044   AtkObject *accessible;
1045   GSignalQuery signal_query;
1046   const gchar *name, *minor;
1047
1048   g_signal_query (signal_hint->signal_id, &signal_query);
1049   name = signal_query.signal_name;
1050
1051   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
1052   minor = g_quark_to_string (signal_hint->detail);
1053
1054   emit_event (accessible, ITF_EVENT_OBJECT, name, minor, 0, 0,
1055               DBUS_TYPE_STRING_AS_STRING, "", append_basic);
1056   return TRUE;
1057 }
1058
1059 /*---------------------------------------------------------------------------*/
1060
1061 /*
1062  * Children changed signal converter and forwarder.
1063  *
1064  * Klass (Interface) org.a11y.atspi.Event.Object
1065  * Major is the signal name.
1066  * Minor is 'add' or 'remove'
1067  * detail1 is the index.
1068  * detail2 is 0.
1069  * any_data is the child reference.
1070  */
1071 static gboolean
1072 children_changed_event_listener (GSignalInvocationHint * signal_hint,
1073                                  guint n_param_values,
1074                                  const GValue * param_values, gpointer data)
1075 {
1076   GSignalQuery signal_query;
1077   const gchar *name, *minor;
1078   gint detail1 = 0, detail2 = 0;
1079
1080   AtkObject *accessible, *ao=NULL;
1081   gpointer child;
1082   AtkStateSet *set;
1083   gboolean ret;
1084
1085   g_signal_query (signal_hint->signal_id, &signal_query);
1086   name = signal_query.signal_name;
1087
1088   /* If the accessible is on STATE_MANAGES_DESCENDANTS state,
1089      children-changed signal are not forwarded. */
1090   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
1091   set = atk_object_ref_state_set (accessible);
1092   ret = atk_state_set_contains_state (set, ATK_STATE_MANAGES_DESCENDANTS);
1093   g_object_unref (set);
1094
1095   if (ret)
1096     return TRUE;
1097
1098   minor = g_quark_to_string (signal_hint->detail);
1099
1100   detail1 = g_value_get_uint (param_values + 1);
1101   child = g_value_get_pointer (param_values + 2);
1102
1103   if (ATK_IS_OBJECT (child))
1104     {
1105       ao = ATK_OBJECT (child);
1106       emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
1107                   "(so)", ao, append_object);
1108     }
1109   else if ((minor != NULL) && (strcmp (minor, "add") == 0))
1110     {
1111       ao = atk_object_ref_accessible_child (accessible,
1112                                             detail1);
1113       emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
1114                   "(so)", ao, append_object);
1115       g_object_unref (ao);
1116     }
1117   else
1118     {
1119       emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
1120                   "(so)", ao, append_object);
1121     }
1122
1123   return TRUE;
1124 }
1125
1126 /*---------------------------------------------------------------------------*/
1127
1128 /*
1129  * Generic signal converter and forwarder.
1130  *
1131  * Klass (Interface) org.a11y.atspi.Event.Object
1132  * Major is the signal name.
1133  * Minor is NULL.
1134  * detail1 is 0.
1135  * detail2 is 0.
1136  * any_data is NULL.
1137  */
1138 static gboolean
1139 generic_event_listener (GSignalInvocationHint * signal_hint,
1140                         guint n_param_values,
1141                         const GValue * param_values, gpointer data)
1142 {
1143   AtkObject *accessible;
1144   GSignalQuery signal_query;
1145   const gchar *name;
1146   int detail1 = 0, detail2 = 0;
1147
1148   g_signal_query (signal_hint->signal_id, &signal_query);
1149   name = signal_query.signal_name;
1150
1151   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
1152
1153   if (n_param_values > 1 && G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
1154     detail1 = g_value_get_int (&param_values[1]);
1155
1156   if (n_param_values > 2 && G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)
1157     detail2 = g_value_get_int (&param_values[2]);
1158
1159   emit_event (accessible, ITF_EVENT_OBJECT, name, "", detail1, detail2,
1160               DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
1161   return TRUE;
1162 }
1163
1164 /*---------------------------------------------------------------------------*/
1165
1166 /*
1167  * Registers the provided function as a handler for the given signal name
1168  * and stores the signal id returned so that the function may be
1169  * de-registered later.
1170  */
1171 static guint
1172 add_signal_listener (GSignalEmissionHook listener, const char *signal_name)
1173 {
1174   guint id;
1175
1176   id = atk_add_global_event_listener (listener, signal_name);
1177
1178   if (id > 0) /* id == 0 is a failure */
1179     g_array_append_val (listener_ids, id);
1180
1181   return id;
1182 }
1183
1184 /*
1185  * Initialization for the signal handlers.
1186  *
1187  * Registers all required signal handlers.
1188  */
1189 void
1190 spi_atk_register_event_listeners (void)
1191 {
1192   /*
1193    * Kludge to make sure the Atk interface types are registered, otherwise
1194    * the AtkText signal handlers below won't get registered
1195    */
1196   GObject *ao = g_object_new (ATK_TYPE_OBJECT, NULL);
1197   AtkObject *bo = atk_no_op_object_new (ao);
1198   guint id = 0;
1199
1200   g_object_unref (G_OBJECT (bo));
1201   g_object_unref (ao);
1202
1203   if (listener_ids)
1204   {
1205     g_warning ("atk_bridge: spi_atk-register_event_listeners called multiple times");
1206     return;
1207   }
1208
1209   /* Register for focus event notifications, and register app with central registry  */
1210   listener_ids = g_array_sized_new (FALSE, TRUE, sizeof (guint), 16);
1211
1212   atk_bridge_focus_tracker_id = atk_add_focus_tracker (focus_tracker);
1213
1214   add_signal_listener (property_event_listener,
1215                        "Gtk:AtkObject:property-change");
1216
1217   /* window events: we tentative try to register using the old format */
1218   id = add_signal_listener (window_event_listener, "window:create");
1219
1220   if (id != 0)
1221     {
1222       /* If we are able to register using the old format, we assume
1223        * that the ATK implementor is managing window events without
1224        * AtkWindow. We can't use the opposite test because after
1225        * including AtkWindow on ATK you would be able to register to
1226        * that event, although the ATK implementor could or not use it.
1227        */
1228
1229       add_signal_listener (window_event_listener, "window:destroy");
1230       add_signal_listener (window_event_listener, "window:minimize");
1231       add_signal_listener (window_event_listener, "window:maximize");
1232       add_signal_listener (window_event_listener, "window:restore");
1233       add_signal_listener (window_event_listener, "window:activate");
1234       add_signal_listener (window_event_listener, "window:deactivate");
1235     }
1236   else
1237     {
1238       add_signal_listener (window_event_listener, "Atk:AtkWindow:create");
1239       add_signal_listener (window_event_listener, "Atk:AtkWindow:destroy");
1240       add_signal_listener (window_event_listener, "Atk:AtkWindow:minimize");
1241       add_signal_listener (window_event_listener, "Atk:AtkWindow:maximize");
1242       add_signal_listener (window_event_listener, "Atk:AtkWindow:restore");
1243       add_signal_listener (window_event_listener, "Atk:AtkWindow:activate");
1244       add_signal_listener (window_event_listener, "Atk:AtkWindow:deactivate");
1245     }
1246
1247   add_signal_listener (document_event_listener,
1248                        "Gtk:AtkDocument:load-complete");
1249   add_signal_listener (document_event_listener, "Gtk:AtkDocument:reload");
1250   add_signal_listener (document_event_listener,
1251                        "Gtk:AtkDocument:load-stopped");
1252   add_signal_listener (document_event_listener,
1253                        "Gtk:AtkDocument:page-changed");
1254   /* TODO Fake this event on the client side */
1255   add_signal_listener (state_event_listener, "Gtk:AtkObject:state-change");
1256   /* TODO */
1257   add_signal_listener (active_descendant_event_listener,
1258                        "Gtk:AtkObject:active-descendant-changed");
1259   add_signal_listener (bounds_event_listener,
1260                        "Gtk:AtkComponent:bounds-changed");
1261   add_signal_listener (text_selection_changed_event_listener,
1262                        "Gtk:AtkText:text-selection-changed");
1263   add_signal_listener (text_changed_event_listener,
1264                        "Gtk:AtkText:text-changed");
1265   add_signal_listener (text_insert_event_listener,
1266                        "Gtk:AtkText:text-insert");
1267   add_signal_listener (text_remove_event_listener,
1268                        "Gtk:AtkText:text-remove");
1269   add_signal_listener (link_selected_event_listener,
1270                        "Gtk:AtkHypertext:link-selected");
1271   add_signal_listener (generic_event_listener,
1272                        "Gtk:AtkObject:visible-data-changed");
1273   add_signal_listener (generic_event_listener,
1274                        "Gtk:AtkSelection:selection-changed");
1275   add_signal_listener (generic_event_listener,
1276                        "Gtk:AtkText:text-attributes-changed");
1277   add_signal_listener (generic_event_listener,
1278                        "Gtk:AtkText:text-caret-moved");
1279   add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-inserted");
1280   add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-reordered");
1281   add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-deleted");
1282   add_signal_listener (generic_event_listener,
1283                        "Gtk:AtkTable:column-inserted");
1284   add_signal_listener (generic_event_listener,
1285                        "Gtk:AtkTable:column-reordered");
1286   add_signal_listener (generic_event_listener, "Gtk:AtkTable:column-deleted");
1287   add_signal_listener (generic_event_listener, "Gtk:AtkTable:model-changed");
1288   add_signal_listener (children_changed_event_listener, "Gtk:AtkObject:children-changed");
1289
1290 #if 0
1291   g_signal_connect (G_OBJECT (spi_global_app_data->root),
1292                     "children-changed::add",
1293                     (GCallback) toplevel_added_event_listener, NULL);
1294
1295   g_signal_connect (G_OBJECT (spi_global_app_data->root),
1296                     "children-changed::remove",
1297                     (GCallback) toplevel_removed_event_listener, NULL);
1298 #endif
1299
1300   /*
1301    * May add the following listeners to implement preemptive key listening for GTK+
1302    *
1303    * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-press-event");
1304    * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-release-event");
1305    */
1306   atk_bridge_key_event_listener_id =
1307     atk_add_key_event_listener (spi_atk_bridge_key_listener, NULL);
1308 }
1309
1310 /*---------------------------------------------------------------------------*/
1311
1312 /*
1313  * De-registers all ATK signal handlers.
1314  */
1315 void
1316 spi_atk_deregister_event_listeners (void)
1317 {
1318   gint i;
1319   GArray *ids = listener_ids;
1320   listener_ids = NULL;
1321
1322   if (atk_bridge_focus_tracker_id)
1323   {
1324     atk_remove_focus_tracker (atk_bridge_focus_tracker_id);
1325     atk_bridge_focus_tracker_id = 0;
1326   }
1327
1328   if (ids)
1329     {
1330       for (i = 0; i < ids->len; i++)
1331         {
1332           atk_remove_global_event_listener (g_array_index (ids, guint, i));
1333         }
1334       g_array_free (ids, TRUE);
1335     }
1336
1337   if (atk_bridge_key_event_listener_id)
1338   {
1339     atk_remove_key_event_listener (atk_bridge_key_event_listener_id);
1340     atk_bridge_key_event_listener_id = 0;
1341   }
1342 }
1343
1344 /*---------------------------------------------------------------------------*/
1345
1346 /*
1347  * TODO This function seems out of place here.
1348  *
1349  * Emits fake deactivate signals on all top-level windows.
1350  * Used when shutting down AT-SPI, ensuring that all
1351  * windows have been removed on the client side.
1352  */
1353 void
1354 spi_atk_tidy_windows (void)
1355 {
1356   AtkObject *root;
1357   gint n_children;
1358   gint i;
1359
1360   root = atk_get_root ();
1361   n_children = atk_object_get_n_accessible_children (root);
1362   for (i = 0; i < n_children; i++)
1363     {
1364       AtkObject *child;
1365       AtkStateSet *stateset;
1366       const gchar *name;
1367
1368       child = atk_object_ref_accessible_child (root, i);
1369       stateset = atk_object_ref_state_set (child);
1370
1371       name = atk_object_get_name (child);
1372       if (atk_state_set_contains_state (stateset, ATK_STATE_ACTIVE))
1373         {
1374           emit_event (child, ITF_EVENT_WINDOW, "deactivate", NULL, 0, 0,
1375                       DBUS_TYPE_STRING_AS_STRING, name, append_basic);
1376         }
1377       g_object_unref (stateset);
1378
1379       emit_event (child, ITF_EVENT_WINDOW, "destroy", NULL, 0, 0,
1380                   DBUS_TYPE_STRING_AS_STRING, name, append_basic);
1381       g_object_unref (child);
1382     }
1383 }
1384
1385 gboolean
1386 spi_event_is_subtype (gchar **needle, gchar **haystack)
1387 {
1388   while (*haystack && **haystack)
1389     {
1390       if (g_strcmp0 (*needle, *haystack))
1391         return FALSE;
1392       needle++;
1393       haystack++;
1394     }
1395   return TRUE;
1396 }
1397
1398 /*END------------------------------------------------------------------------*/