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
  27 #include <atk/atk.h>
  28 #include <droute/droute.h>
  29
  30 #include "bridge.h"
  31 #include "accessible-register.h"
  32
  33 #include "common/spi-dbus.h"
  34
  35 static GArray *listener_ids = NULL;
  36
  37 static gint atk_bridge_key_event_listener_id;
  38 static gint atk_bridge_focus_tracker_id;
  39
  40 /*---------------------------------------------------------------------------*/
  41
  42 #define ITF_EVENT_OBJECT   "org.a11y.atspi.Event.Object"
  43 #define ITF_EVENT_WINDOW   "org.a11y.atspi.Event.Window"
  44 #define ITF_EVENT_DOCUMENT "org.a11y.atspi.Event.Document"
  45 #define ITF_EVENT_FOCUS    "org.a11y.atspi.Event.Focus"
  46
  47 /*---------------------------------------------------------------------------*/
  48
  49 typedef struct _SpiReentrantCallClosure
  50 {
  51   GMainLoop   *loop;
  52   DBusMessage *reply;
  53 } SpiReentrantCallClosure;
  54
  55 static void
  56 set_reply (DBusPendingCall * pending, void *user_data)
  57 {
  58   SpiReentrantCallClosure* closure = (SpiReentrantCallClosure *) user_data;
  59
  60   closure->reply = dbus_pending_call_steal_reply (pending);
  61   g_main_loop_quit (closure->loop);
  62 }
  63
  64 static DBusMessage *
  65 send_and_allow_reentry (DBusConnection * bus, DBusMessage * message)
  66 {
  67   DBusPendingCall *pending;
  68   SpiReentrantCallClosure closure;
  69
  70   if (!dbus_connection_send_with_reply (bus, message, &pending, -1))
  71       return NULL;
  72   dbus_pending_call_set_notify (pending, set_reply, (void *) &closure, NULL);
  73   closure.loop = g_main_loop_new (NULL, FALSE);
  74
  75   if (getenv ("AT_SPI_CLIENT"))
  76     {
  77       g_main_loop_run  (closure.loop);
  78     }
  79   else
  80     {
  81       closure.reply = NULL;
  82       while (!closure.reply)
  83         {
  84           if (!dbus_connection_read_write_dispatch (spi_global_app_data->bus, 1000))
  85             return NULL;
  86         }
  87     }
  88
  89   g_main_loop_unref (closure.loop);
  90   return closure.reply;
  91 }
  92
  93 /*---------------------------------------------------------------------------*/
  94
  95 /*
  96  * Functionality related to sending device events from the application.
  97  *
  98  * This is used for forwarding key events on to the registry daemon.
  99  */
 100
 101 static gboolean
 102 Accessibility_DeviceEventController_NotifyListenersSync (const
 103                                                          Accessibility_DeviceEvent
 104                                                          * key_event)
 105 {
 106   DBusMessage *message;
 107   DBusError error;
 108   dbus_bool_t consumed = FALSE;
 109
 110   message =
 111     dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,
 112                                   SPI_DBUS_PATH_DEC,
 113                                   SPI_DBUS_INTERFACE_DEC,
 114                                   "NotifyListenersSync");
 115
 116   dbus_error_init (&error);
 117   if (spi_dbus_marshal_deviceEvent (message, key_event))
 118     {
 119       DBusMessage *reply =
 120         send_and_allow_reentry (spi_global_app_data->bus, message);
 121       if (reply)
 122         {
 123           DBusError error;
 124           dbus_error_init (&error);
 125           dbus_message_get_args (reply, &error, DBUS_TYPE_BOOLEAN, &consumed,
 126                                  DBUS_TYPE_INVALID);
 127           dbus_message_unref (reply);
 128         }
 129     }
 130   dbus_message_unref (message);
 131   return consumed;
 132 }
 133
 134 static void
 135 spi_init_keystroke_from_atk_key_event (Accessibility_DeviceEvent * keystroke,
 136                                        AtkKeyEventStruct * event)
 137 {
 138   keystroke->id = (dbus_int32_t) event->keyval;
 139   keystroke->hw_code = (dbus_int16_t) event->keycode;
 140   keystroke->timestamp = (dbus_uint32_t) event->timestamp;
 141   keystroke->modifiers = (dbus_uint16_t) (event->state & 0xFFFF);
 142   if (event->string)
 143     {
 144       gunichar c;
 145
 146       keystroke->event_string = g_strdup (event->string);
 147       c = g_utf8_get_char_validated (event->string, -1);
 148       if (c > 0 && g_unichar_isprint (c))
 149         keystroke->is_text = TRUE;
 150       else
 151         keystroke->is_text = FALSE;
 152     }
 153   else
 154     {
 155       keystroke->event_string = g_strdup ("");
 156       keystroke->is_text = FALSE;
 157     }
 158   switch (event->type)
 159     {
 160     case (ATK_KEY_EVENT_PRESS):
 161       keystroke->type = Accessibility_KEY_PRESSED_EVENT;
 162       break;
 163     case (ATK_KEY_EVENT_RELEASE):
 164       keystroke->type = Accessibility_KEY_RELEASED_EVENT;
 165       break;
 166     default:
 167       keystroke->type = 0;
 168       break;
 169     }
 170 #if 0
 171   g_print
 172     ("key_event type %d; val=%d code=%d modifiers=%x name=%s is_text=%d, time=%lx\n",
 173      (int) keystroke->type, (int) keystroke->id, (int) keystroke->hw_code,
 174      (int) keystroke->modifiers, keystroke->event_string,
 175      (int) keystroke->is_text, (unsigned long) keystroke->timestamp);
 176 #endif
 177 }
 178
 179
 180 static gint
 181 spi_atk_bridge_key_listener (AtkKeyEventStruct * event, gpointer data)
 182 {
 183   gboolean result;
 184   Accessibility_DeviceEvent key_event;
 185
 186   spi_init_keystroke_from_atk_key_event (&key_event, event);
 187
 188   result =
 189     Accessibility_DeviceEventController_NotifyListenersSync (&key_event);
 190
 191   if (key_event.event_string)
 192     g_free (key_event.event_string);
 193
 194   return result;
 195 }
 196
 197 /*---------------------------------------------------------------------------*/
 198
 199 static gchar *
 200 convert_signal_name (const gchar * s)
 201 {
 202   gchar *ret = g_strdup (s);
 203   gchar *t;
 204
 205   if (!ret)
 206     return NULL;
 207   ret[0] = toupper (ret[0]);
 208   while ((t = strchr (ret, '-')) != NULL)
 209     {
 210       memmove (t, t + 1, strlen (t));
 211       *t = toupper (*t);
 212     }
 213   return ret;
 214 }
 215
 216 static const void *
 217 replace_null (const gint type,
 218               const void *val)
 219 {
 220   switch (type)
 221     {
 222       case DBUS_TYPE_STRING:
 223       case DBUS_TYPE_OBJECT_PATH:
 224            if (!val)
 225               return "";
 226            else
 227               return val;
 228       default:
 229            return val;
 230     }
 231 }
 232
 233 static void
 234 append_basic (DBusMessageIter *iter,
 235               const char *type,
 236               const void *val)
 237 {
 238   DBusMessageIter sub;
 239
 240   dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, type, &sub);
 241
 242     val = replace_null ((int) *type, val);
 243     dbus_message_iter_append_basic(&sub, (int) *type, &val);
 244
 245   dbus_message_iter_close_container(iter, &sub);
 246 }
 247
 248 static void
 249 append_rect (DBusMessageIter *iter,
 250              const char *type,
 251              const void *val)
 252 {
 253   DBusMessageIter variant, sub;
 254   const AtkRectangle *rect = (const AtkRectangle *) val;
 255
 256   dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, type, &variant);
 257
 258     dbus_message_iter_open_container (&variant, DBUS_TYPE_STRUCT, NULL, &sub);
 259
 260       dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->x));
 261       dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->y));
 262       dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->width));
 263       dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->height));
 264
 265     dbus_message_iter_close_container (&variant, &sub);
 266
 267   dbus_message_iter_close_container(iter, &variant);
 268 }
 269
 270 static void
 271 append_object (DBusMessageIter *iter,
 272                const char *type,
 273                const void *val)
 274 {
 275   spi_object_append_v_reference (iter, ATK_OBJECT (val));
 276 }
 277
 278 static gchar *
 279 signal_name_to_dbus (const gchar *s)
 280 {
 281   gchar *ret = g_strdup (s);
 282   gchar *t;
 283
 284   if (!ret)
 285     return NULL;
 286   ret [0] = toupper (ret [0]);
 287   while ((t = strchr (ret, '-')) != NULL)
 288   {
 289     memmove (t, t + 1, strlen (t));
 290     *t = toupper (*t);
 291   }
 292   return ret;
 293 }
 294
 295 /*
 296  * Emits an AT-SPI event.
 297  * AT-SPI events names are split into three parts:
 298  * class:major:minor
 299  * This is mapped onto D-Bus events as:
 300  * D-Bus Interface:Signal Name:Detail argument
 301  *
 302  * Marshals a basic type into the 'any_data' attribute of
 303  * the AT-SPI event.
 304  */
 305 static void
 306 emit_event (AtkObject  *obj,
 307             const char *klass,
 308             const char *major,
 309             const char *minor,
 310             dbus_int32_t detail1,
 311             dbus_int32_t detail2,
 312             const char *type,
 313             const void *val,
 314             void (*append_variant) (DBusMessageIter *, const char *, const void *))
 315 {
 316   DBusConnection *bus = spi_global_app_data->bus;
 317   const char *path =  spi_register_object_to_path (spi_global_register,
 318                                                    G_OBJECT (obj));
 319
 320   gchar *cname, *t;
 321   DBusMessage *sig;
 322   DBusMessageIter iter, iter_struct;
 323
 324   if (!klass) klass = "";
 325   if (!major) major = "";
 326   if (!minor) minor = "";
 327   if (!type) type = "u";
 328
 329   /*
 330    * This is very annoying, but as '-' isn't a legal signal
 331    * name in D-Bus (Why not??!?) The names need converting
 332    * on this side, and again on the client side.
 333    */
 334   cname = signal_name_to_dbus (major);
 335   sig = dbus_message_new_signal(path, klass, cname);
 336   g_free(cname);
 337
 338   dbus_message_iter_init_append(sig, &iter);
 339
 340   dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &minor);
 341   dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &detail1);
 342   dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &detail2);
 343   append_variant (&iter, type, val);
 344   spi_object_append_reference (&iter, spi_global_app_data->root);
 345
 346   dbus_connection_send(bus, sig, NULL);
 347   dbus_message_unref(sig);
 348
 349   if (g_strcmp0 (cname, "ChildrenChanged") != 0)
 350     spi_object_lease_if_needed (G_OBJECT (obj));
 351 }
 352
 353 /*---------------------------------------------------------------------------*/
 354
 355 /*
 356  * The focus listener handles the ATK 'focus' signal and forwards it
 357  * as the AT-SPI event, 'focus:'
 358  */
 359 static void
 360 focus_tracker (AtkObject * accessible)
 361 {
 362   emit_event (accessible, ITF_EVENT_FOCUS, "focus", "", 0, 0,
 363               DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 364 }
 365
 366 /*---------------------------------------------------------------------------*/
 367
 368 #define PCHANGE "PropertyChange"
 369
 370 /*
 371  * This handler handles the following ATK signals and
 372  * converts them to AT-SPI events:
 373  *
 374  * Gtk:AtkObject:property-change -> object:property-change:(property-name)
 375  *
 376  * The property-name is part of the ATK property-change signal.
 377  */
 378 static gboolean
 379 property_event_listener (GSignalInvocationHint * signal_hint,
 380                          guint n_param_values,
 381                          const GValue * param_values, gpointer data)
 382 {
 383   AtkObject *accessible;
 384   AtkPropertyValues *values;
 385
 386   const gchar *pname = NULL;
 387
 388   AtkObject *otemp;
 389   const gchar *s1, s2;
 390   gint i;
 391
 392   accessible = g_value_get_object (&param_values[0]);
 393   values = (AtkPropertyValues *) g_value_get_pointer (&param_values[1]);
 394
 395   pname = values[0].property_name;
 396
 397   /* TODO Could improve this control statement by matching
 398    * on only the end of the signal names,
 399    */
 400   if (strcmp (pname, "accessible-name") == 0)
 401     {
 402       s1 = atk_object_get_name (accessible);
 403       if (s1 != NULL)
 404         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 405                     DBUS_TYPE_STRING_AS_STRING, s1, append_basic);
 406     }
 407   else if (strcmp (pname, "accessible-description") == 0)
 408     {
 409       s1 = atk_object_get_description (accessible);
 410       if (s1 != NULL)
 411         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 412                     DBUS_TYPE_STRING_AS_STRING, s1, append_basic);
 413     }
 414   else if (strcmp (pname, "accessible-parent") == 0)
 415     {
 416       otemp = atk_object_get_parent (accessible);
 417       if (otemp != NULL)
 418         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 419                     "(so)", otemp, append_object);
 420     }
 421   else if (strcmp (pname, "accessible-role") == 0)
 422     {
 423       i = atk_object_get_role (accessible);
 424       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 425                     DBUS_TYPE_UINT32_AS_STRING, GINT_TO_POINTER(i), append_basic);
 426     }
 427   else if (strcmp (pname, "accessible-table-summary") == 0)
 428     {
 429       otemp = atk_table_get_summary (ATK_TABLE (accessible));
 430       if (otemp != NULL)
 431         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 432                     "(so)", otemp, append_object);
 433     }
 434   else if (strcmp (pname, "accessible-table-column-header") == 0)
 435     {
 436       i = g_value_get_int (&(values->new_value));
 437       otemp = atk_table_get_column_header (ATK_TABLE (accessible), i);
 438       if (otemp != NULL)
 439         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 440                     "(so)", otemp, append_object);
 441     }
 442   else if (strcmp (pname, "accessible-table-row-header") == 0)
 443     {
 444       i = g_value_get_int (&(values->new_value));
 445       otemp = atk_table_get_row_header (ATK_TABLE (accessible), i);
 446       if (otemp != NULL)
 447         emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 448                     "(so)", otemp, append_object);
 449     }
 450   else if (strcmp (pname, "accessible-table-row-description") == 0)
 451     {
 452       i = g_value_get_int (&(values->new_value));
 453       s1 = atk_table_get_row_description (ATK_TABLE (accessible), i);
 454       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 455                   DBUS_TYPE_STRING_AS_STRING, s1, append_basic);
 456     }
 457   else if (strcmp (pname, "accessible-table-column-description") == 0)
 458     {
 459       i = g_value_get_int (&(values->new_value));
 460       s1 = atk_table_get_column_description (ATK_TABLE (accessible), i);
 461       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 462                   DBUS_TYPE_STRING_AS_STRING, s1, append_basic);
 463     }
 464   else if (strcmp (pname, "accessible-table-caption-object") == 0)
 465     {
 466       otemp = atk_table_get_caption (ATK_TABLE (accessible));
 467       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 468                   "(so)", otemp, append_object);
 469     }
 470   else
 471     {
 472       emit_event (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
 473             DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 474     }
 475   return TRUE;
 476 }
 477
 478 /*---------------------------------------------------------------------------*/
 479
 480 #define STATE_CHANGED "state-changed"
 481
 482 /*
 483  * The state event listener handles 'Gtk:AtkObject:state-change' ATK signals
 484  * and forwards them as object:state-changed:(param-name) AT-SPI events. Where
 485  * the param-name is part of the ATK state-change signal.
 486  */
 487 static gboolean
 488 state_event_listener (GSignalInvocationHint * signal_hint,
 489                       guint n_param_values,
 490                       const GValue * param_values, gpointer data)
 491 {
 492   AtkObject *accessible;
 493   gchar *pname;
 494   guint detail1;
 495
 496   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 497   pname = g_strdup (g_value_get_string (&param_values[1]));
 498
 499   /* TODO - Possibly ignore a change to the 'defunct' state.
 500    * This is because without reference counting defunct objects should be removed.
 501    */
 502   detail1 = (g_value_get_boolean (&param_values[2])) ? 1 : 0;
 503   emit_event (accessible, ITF_EVENT_OBJECT, STATE_CHANGED, pname, detail1, 0,
 504               DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 505   g_free (pname);
 506   return TRUE;
 507 }
 508
 509 /*---------------------------------------------------------------------------*/
 510
 511 /*
 512  * The window event listener handles the following ATK signals and forwards
 513  * them as AT-SPI events:
 514  *
 515  * window:create     -> window:create
 516  * window:destroy    -> window:destroy
 517  * window:minimize   -> window:minimize
 518  * window:maximize   -> window:maximize
 519  * window:activate   -> window:activate
 520  * window:deactivate -> window:deactivate
 521  */
 522 static gboolean
 523 window_event_listener (GSignalInvocationHint * signal_hint,
 524                        guint n_param_values,
 525                        const GValue * param_values, gpointer data)
 526 {
 527   AtkObject *accessible;
 528   GSignalQuery signal_query;
 529   const gchar *name, *s;
 530
 531   g_signal_query (signal_hint->signal_id, &signal_query);
 532   name = signal_query.signal_name;
 533
 534   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 535   s = atk_object_get_name (accessible);
 536   emit_event (accessible, ITF_EVENT_WINDOW, name, "", 0, 0,
 537               DBUS_TYPE_STRING_AS_STRING, s, append_basic);
 538
 539   return TRUE;
 540 }
 541
 542 /*---------------------------------------------------------------------------*/
 543
 544 /*
 545  * The document event listener handles the following ATK signals
 546  * and converts them to AT-SPI events:
 547  *
 548  * Gtk:AtkDocument:load-complete ->  document:load-complete
 549  * Gtk:AtkDocument:load-stopped  ->  document:load-stopped
 550  * Gtk:AtkDocument:reload        ->  document:reload
 551  */
 552 static gboolean
 553 document_event_listener (GSignalInvocationHint * signal_hint,
 554                          guint n_param_values,
 555                          const GValue * param_values, gpointer data)
 556 {
 557   AtkObject *accessible;
 558   GSignalQuery signal_query;
 559   const gchar *name, *s;
 560
 561   g_signal_query (signal_hint->signal_id, &signal_query);
 562   name = signal_query.signal_name;
 563
 564   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 565   s = atk_object_get_name (accessible);
 566   emit_event (accessible, ITF_EVENT_DOCUMENT, name, "", 0, 0,
 567               DBUS_TYPE_STRING_AS_STRING, s, append_basic);
 568
 569   return TRUE;
 570 }
 571
 572 /*---------------------------------------------------------------------------*/
 573
 574 /*
 575  * Signal handler for  "Gtk:AtkComponent:bounds-changed". Converts
 576  * this to an AT-SPI event - "object:bounds-changed".
 577  */
 578 static gboolean
 579 bounds_event_listener (GSignalInvocationHint * signal_hint,
 580                        guint n_param_values,
 581                        const GValue * param_values, gpointer data)
 582 {
 583   AtkObject *accessible;
 584   AtkRectangle *atk_rect;
 585   GSignalQuery signal_query;
 586   const gchar *name, *s;
 587
 588   g_signal_query (signal_hint->signal_id, &signal_query);
 589   name = signal_query.signal_name;
 590
 591   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 592
 593   if (G_VALUE_HOLDS_BOXED (param_values + 1))
 594   {
 595     atk_rect = g_value_get_boxed (param_values + 1);
 596
 597     emit_event (accessible, ITF_EVENT_OBJECT, name, "", 0, 0,
 598                 "(iiii)", atk_rect, append_rect);
 599   }
 600   return TRUE;
 601 }
 602
 603 /*---------------------------------------------------------------------------*/
 604
 605 /*
 606  * Handles the ATK signal 'Gtk:AtkObject:active-descendant-changed' and
 607  * converts it to the AT-SPI signal - 'object:active-descendant-changed'.
 608  *
 609  */
 610 static gboolean
 611 active_descendant_event_listener (GSignalInvocationHint * signal_hint,
 612                                   guint n_param_values,
 613                                   const GValue * param_values, gpointer data)
 614 {
 615   AtkObject *accessible;
 616   AtkObject *child;
 617   GSignalQuery signal_query;
 618   const gchar *name, *minor;
 619   gint detail1;
 620
 621   g_signal_query (signal_hint->signal_id, &signal_query);
 622   name = signal_query.signal_name;
 623
 624   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 625   child = ATK_OBJECT (g_value_get_pointer (&param_values[1]));
 626   g_return_val_if_fail (ATK_IS_OBJECT (child), TRUE);
 627   minor = g_quark_to_string (signal_hint->detail);
 628
 629   detail1 = atk_object_get_index_in_parent (child);
 630
 631   emit_event (accessible, ITF_EVENT_OBJECT, name, "", detail1, 0,
 632               "(so)", child, append_object);
 633   return TRUE;
 634 }
 635
 636 /*---------------------------------------------------------------------------*/
 637
 638 /*
 639  * Handles the ATK signal 'Gtk:AtkHypertext:link-selected' and
 640  * converts it to the AT-SPI signal - 'object:link-selected'
 641  *
 642  */
 643 static gboolean
 644 link_selected_event_listener (GSignalInvocationHint * signal_hint,
 645                               guint n_param_values,
 646                               const GValue * param_values, gpointer data)
 647 {
 648   AtkObject *accessible;
 649   GSignalQuery signal_query;
 650   const gchar *name, *minor;
 651   gint detail1;
 652
 653   g_signal_query (signal_hint->signal_id, &signal_query);
 654   name = signal_query.signal_name;
 655
 656   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 657   minor = g_quark_to_string (signal_hint->detail);
 658
 659   if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
 660     detail1 = g_value_get_int (&param_values[1]);
 661
 662   emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, 0,
 663               DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 664   return TRUE;
 665 }
 666
 667 /*---------------------------------------------------------------------------*/
 668
 669 /*
 670  * Handles the ATK signal 'Gtk:AtkText:text-changed' and
 671  * converts it to the AT-SPI signal - 'object:text-changed'
 672  *
 673  */
 674 static gboolean
 675 text_changed_event_listener (GSignalInvocationHint * signal_hint,
 676                              guint n_param_values,
 677                              const GValue * param_values, gpointer data)
 678 {
 679   AtkObject *accessible;
 680   GSignalQuery signal_query;
 681   const gchar *name, *minor;
 682   gchar *selected;
 683   gint detail1, detail2;
 684
 685   g_signal_query (signal_hint->signal_id, &signal_query);
 686   name = signal_query.signal_name;
 687
 688   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 689   minor = g_quark_to_string (signal_hint->detail);
 690
 691   if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
 692     detail1 = g_value_get_int (&param_values[1]);
 693
 694   if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)
 695     detail2 = g_value_get_int (&param_values[2]);
 696
 697   selected =
 698     atk_text_get_text (ATK_TEXT (accessible), detail1, detail1 + detail2);
 699
 700   emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
 701               DBUS_TYPE_STRING_AS_STRING, selected, append_basic);
 702   return TRUE;
 703 }
 704
 705 /*---------------------------------------------------------------------------*/
 706
 707 /*
 708  * Handles the ATK signal 'Gtk:AtkText:text-selection-changed' and
 709  * converts it to the AT-SPI signal - 'object:text-selection-changed'
 710  *
 711  */
 712 static gboolean
 713 text_selection_changed_event_listener (GSignalInvocationHint * signal_hint,
 714                                        guint n_param_values,
 715                                        const GValue * param_values,
 716                                        gpointer data)
 717 {
 718   AtkObject *accessible;
 719   GSignalQuery signal_query;
 720   const gchar *name, *minor;
 721   gint detail1, detail2;
 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   minor = g_quark_to_string (signal_hint->detail);
 728
 729   if (G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
 730     detail1 = g_value_get_int (&param_values[1]);
 731
 732   if (G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)
 733     detail2 = g_value_get_int (&param_values[2]);
 734
 735   emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
 736               DBUS_TYPE_STRING_AS_STRING, "", append_basic);
 737   return TRUE;
 738 }
 739
 740 /*---------------------------------------------------------------------------*/
 741
 742 /*
 743  * Children changed signal converter and forwarder.
 744  *
 745  * Klass (Interface) org.a11y.atspi.Event.Object
 746  * Major is the signal name.
 747  * Minor is 'add' or 'remove'
 748  * detail1 is the index.
 749  * detail2 is 0.
 750  * any_data is the child reference.
 751  */
 752 static gboolean
 753 children_changed_event_listener (GSignalInvocationHint * signal_hint,
 754                                  guint n_param_values,
 755                                  const GValue * param_values, gpointer data)
 756 {
 757   GSignalQuery signal_query;
 758   const gchar *name, *minor;
 759   gint detail1, detail2 = 0;
 760
 761   AtkObject *accessible, *ao=NULL;
 762   gpointer child;
 763
 764   g_signal_query (signal_hint->signal_id, &signal_query);
 765   name = signal_query.signal_name;
 766
 767   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 768   minor = g_quark_to_string (signal_hint->detail);
 769
 770   detail1 = g_value_get_uint (param_values + 1);
 771   child = g_value_get_pointer (param_values + 2);
 772
 773   if (ATK_IS_OBJECT (child))
 774     {
 775       ao = ATK_OBJECT (child);
 776       emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
 777                   "(so)", ao, append_object);
 778     }
 779   else if ((minor != NULL) && (strcmp (minor, "add") == 0))
 780     {
 781       ao = atk_object_ref_accessible_child (accessible,
 782                                             detail1);
 783       emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
 784                   "(so)", ao, append_object);
 785     }
 786   else
 787     {
 788       emit_event (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
 789                   "(so)", ao, append_object);
 790     }
 791
 792   return TRUE;
 793 }
 794
 795 /*---------------------------------------------------------------------------*/
 796
 797 static void
 798 toplevel_added_event_listener (AtkObject * accessible,
 799                                guint index, AtkObject * child)
 800 {
 801   emit_event (accessible, ITF_EVENT_OBJECT, "children-changed", "add", index, 0,
 802               "(so)", child, append_object);
 803 }
 804
 805 static void
 806 toplevel_removed_event_listener (AtkObject * accessible,
 807                                  guint index, AtkObject * child)
 808 {
 809   emit_event (accessible, ITF_EVENT_OBJECT, "children-changed", "remove", index, 0,
 810               "(so)", child, append_object);
 811 }
 812
 813 /*---------------------------------------------------------------------------*/
 814
 815 /*
 816  * Generic signal converter and forwarder.
 817  *
 818  * Klass (Interface) org.a11y.atspi.Event.Object
 819  * Major is the signal name.
 820  * Minor is NULL.
 821  * detail1 is 0.
 822  * detail2 is 0.
 823  * any_data is NULL.
 824  */
 825 static gboolean
 826 generic_event_listener (GSignalInvocationHint * signal_hint,
 827                         guint n_param_values,
 828                         const GValue * param_values, gpointer data)
 829 {
 830   AtkObject *accessible;
 831   GSignalQuery signal_query;
 832   const gchar *name;
 833   int detail1 = 0, detail2 = 0;
 834
 835   g_signal_query (signal_hint->signal_id, &signal_query);
 836   name = signal_query.signal_name;
 837
 838   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 839
 840   if (n_param_values > 1 && G_VALUE_TYPE (&param_values[1]) == G_TYPE_INT)
 841     detail1 = g_value_get_int (&param_values[1]);
 842
 843   if (n_param_values > 2 && G_VALUE_TYPE (&param_values[2]) == G_TYPE_INT)
 844     detail2 = g_value_get_int (&param_values[2]);
 845
 846   emit_event (accessible, ITF_EVENT_OBJECT, name, "", detail1, detail2,
 847               DBUS_TYPE_INT32_AS_STRING, 0, append_basic);
 848   return TRUE;
 849 }
 850
 851 /*---------------------------------------------------------------------------*/
 852
 853 /*
 854  * Registers the provided function as a handler for the given signal name
 855  * and stores the signal id returned so that the function may be
 856  * de-registered later.
 857  */
 858 static void
 859 add_signal_listener (GSignalEmissionHook listener, const char *signal_name)
 860 {
 861   guint id;
 862
 863   id = atk_add_global_event_listener (listener, signal_name);
 864   g_array_append_val (listener_ids, id);
 865 }
 866
 867 /*
 868  * Initialization for the signal handlers.
 869  *
 870  * Registers all required signal handlers.
 871  */
 872 void
 873 spi_atk_register_event_listeners (void)
 874 {
 875   /*
 876    * Kludge to make sure the Atk interface types are registered, otherwise
 877    * the AtkText signal handlers below won't get registered
 878    */
 879   GObject *ao = g_object_new (ATK_TYPE_OBJECT, NULL);
 880   AtkObject *bo = atk_no_op_object_new (ao);
 881
 882   g_object_unref (G_OBJECT (bo));
 883   g_object_unref (ao);
 884
 885   /* Register for focus event notifications, and register app with central registry  */
 886   listener_ids = g_array_sized_new (FALSE, TRUE, sizeof (guint), 16);
 887
 888   atk_bridge_focus_tracker_id = atk_add_focus_tracker (focus_tracker);
 889
 890   add_signal_listener (property_event_listener,
 891                        "Gtk:AtkObject:property-change");
 892   add_signal_listener (window_event_listener, "window:create");
 893   add_signal_listener (window_event_listener, "window:destroy");
 894   add_signal_listener (window_event_listener, "window:minimize");
 895   add_signal_listener (window_event_listener, "window:maximize");
 896   add_signal_listener (window_event_listener, "window:restore");
 897   add_signal_listener (window_event_listener, "window:activate");
 898   add_signal_listener (window_event_listener, "window:deactivate");
 899   add_signal_listener (document_event_listener,
 900                        "Gtk:AtkDocument:load-complete");
 901   add_signal_listener (document_event_listener, "Gtk:AtkDocument:reload");
 902   add_signal_listener (document_event_listener,
 903                        "Gtk:AtkDocument:load-stopped");
 904   /* TODO Fake this event on the client side */
 905   add_signal_listener (state_event_listener, "Gtk:AtkObject:state-change");
 906   /* TODO */
 907   add_signal_listener (active_descendant_event_listener,
 908                        "Gtk:AtkObject:active-descendant-changed");
 909   add_signal_listener (bounds_event_listener,
 910                        "Gtk:AtkComponent:bounds-changed");
 911   add_signal_listener (text_selection_changed_event_listener,
 912                        "Gtk:AtkText:text-selection-changed");
 913   add_signal_listener (text_changed_event_listener,
 914                        "Gtk:AtkText:text-changed");
 915   add_signal_listener (link_selected_event_listener,
 916                        "Gtk:AtkHypertext:link-selected");
 917   add_signal_listener (generic_event_listener,
 918                        "Gtk:AtkObject:visible-data-changed");
 919   add_signal_listener (generic_event_listener,
 920                        "Gtk:AtkSelection:selection-changed");
 921   add_signal_listener (generic_event_listener,
 922                        "Gtk:AtkText:text-attributes-changed");
 923   add_signal_listener (generic_event_listener,
 924                        "Gtk:AtkText:text-caret-moved");
 925   add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-inserted");
 926   add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-reordered");
 927   add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-deleted");
 928   add_signal_listener (generic_event_listener,
 929                        "Gtk:AtkTable:column-inserted");
 930   add_signal_listener (generic_event_listener,
 931                        "Gtk:AtkTable:column-reordered");
 932   add_signal_listener (generic_event_listener, "Gtk:AtkTable:column-deleted");
 933   add_signal_listener (generic_event_listener, "Gtk:AtkTable:model-changed");
 934
 935   /* Children signal listeners */
 936   atk_add_global_event_listener (children_changed_event_listener,
 937                                  "Gtk:AtkObject:children-changed");
 938
 939 #if 0
 940   g_signal_connect (G_OBJECT (spi_global_app_data->root),
 941                     "children-changed::add",
 942                     (GCallback) toplevel_added_event_listener, NULL);
 943
 944   g_signal_connect (G_OBJECT (spi_global_app_data->root),
 945                     "children-changed::remove",
 946                     (GCallback) toplevel_removed_event_listener, NULL);
 947 #endif
 948
 949   /*
 950    * May add the following listeners to implement preemptive key listening for GTK+
 951    *
 952    * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-press-event");
 953    * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-release-event");
 954    */
 955   atk_bridge_key_event_listener_id =
 956     atk_add_key_event_listener (spi_atk_bridge_key_listener, NULL);
 957 }
 958
 959 /*---------------------------------------------------------------------------*/
 960
 961 /*
 962  * De-registers all ATK signal handlers.
 963  */
 964 void
 965 spi_atk_deregister_event_listeners (void)
 966 {
 967   gint i;
 968   GArray *ids = listener_ids;
 969   listener_ids = NULL;
 970
 971   if (atk_bridge_focus_tracker_id)
 972     atk_remove_focus_tracker (atk_bridge_focus_tracker_id);
 973
 974   for (i = 0; ids && i < ids->len; i++)
 975     {
 976       atk_remove_global_event_listener (g_array_index (ids, guint, i));
 977     }
 978
 979   if (atk_bridge_key_event_listener_id)
 980     atk_remove_key_event_listener (atk_bridge_key_event_listener_id);
 981 }
 982
 983 /*---------------------------------------------------------------------------*/
 984
 985 /*
 986  * TODO This function seems out of place here.
 987  *
 988  * Emits fake deactivate signals on all top-level windows.
 989  * Used when shutting down AT-SPI, ensuring that all
 990  * windows have been removed on the client side.
 991  */
 992 void
 993 spi_atk_tidy_windows (void)
 994 {
 995   AtkObject *root;
 996   gint n_children;
 997   gint i;
 998
 999   root = atk_get_root ();
1000   n_children = atk_object_get_n_accessible_children (root);
1001   for (i = 0; i < n_children; i++)
1002     {
1003       AtkObject *child;
1004       AtkStateSet *stateset;
1005       const gchar *name;
1006
1007       child = atk_object_ref_accessible_child (root, i);
1008       stateset = atk_object_ref_state_set (child);
1009
1010       name = atk_object_get_name (child);
1011       if (atk_state_set_contains_state (stateset, ATK_STATE_ACTIVE))
1012         {
1013           emit_event (child, ITF_EVENT_WINDOW, "deactivate", NULL, 0, 0,
1014                       DBUS_TYPE_STRING_AS_STRING, name, append_basic);
1015         }
1016       g_object_unref (stateset);
1017
1018       emit_event (child, ITF_EVENT_WINDOW, "destroy", NULL, 0, 0,
1019                   DBUS_TYPE_STRING_AS_STRING, name, append_basic);
1020       g_object_unref (child);
1021     }
1022 }
1023
1024 /*END------------------------------------------------------------------------*/