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