atk-adaptor/event.c

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