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