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