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