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