atk-bridge/bridge.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <stdarg.h>
  27 #include <libbonobo.h>
  28 #include <orbit/orbit.h>
  29 #include <atk/atk.h>
  30 #include <atk/atkobject.h>
  31 #include <atk/atknoopobject.h>
  32 #include <libspi/Accessibility.h>
  33 #include <libspi/spi-private.h>
  34 #include "accessible.h"
  35 #include "application.h"
  36
  37 #include <bonobo-activation/bonobo-activation-register.h>
  38
  39 #undef SPI_BRIDGE_DEBUG
  40
  41 #define DBG(a,b) if(_dbg>=(a))b
  42
  43 static int _dbg = 0;
  44 static CORBA_Environment ev;
  45 static Accessibility_Registry registry = CORBA_OBJECT_NIL;
  46 static Accessibility_DeviceEventController device_event_controller = CORBA_OBJECT_NIL;
  47 static SpiApplication *this_app = NULL;
  48 static gboolean registry_died = FALSE;
  49 static gboolean atk_listeners_registered = FALSE;
  50 static guint toplevel_handler;
  51
  52 /* NOT YET USED
  53    static GQuark atk_quark_property_changed_name;
  54    static GQuark atk_quark_property_changed_description;
  55    static GQuark atk_quark_property_changed_parent;
  56    static GQuark atk_quark_property_changed_role;
  57    static GQuark atk_quark_property_changed_table_caption;
  58    static GQuark atk_quark_property_changed_table_column_description;
  59    static GQuark atk_quark_property_changed_table_row_description;
  60    static guint atk_signal_property_changed;
  61 */
  62
  63 static guint atk_signal_text_changed;
  64 static guint atk_signal_child_changed;
  65 static guint atk_signal_active_descendant_changed;
  66
  67 /* NOT YET USED
  68    static guint atk_signal_text_selection_changed;
  69    static guint atk_signal_row_reordered;
  70    static guint atk_signal_row_inserted;
  71    static guint atk_signal_row_deleted;
  72    static guint atk_signal_column_reordered;
  73    static guint atk_signal_column_inserted;
  74    static guint atk_signal_column_deleted;
  75 */
  76
  77 static Accessibility_Registry spi_atk_bridge_get_registry (void);
  78 static void     spi_atk_bridge_do_registration         (void);
  79 static void     spi_atk_bridge_toplevel_added          (AtkObject             *object,
  80                                                         guint                 index,
  81                                                         AtkObject             *child);
  82
  83 static void     spi_atk_bridge_exit_func               (void);
  84 static void     spi_atk_register_event_listeners       (void);
  85 static void     spi_atk_bridge_focus_tracker           (AtkObject             *object);
  86 static void     spi_atk_bridge_register_application    (Accessibility_Registry registry);
  87 static gboolean spi_atk_bridge_property_event_listener (GSignalInvocationHint *signal_hint,
  88                                                         guint                  n_param_values,
  89                                                         const GValue          *param_values,
  90                                                         gpointer               data);
  91 static gboolean
  92 spi_atk_bridge_window_event_listener (GSignalInvocationHint *signal_hint,
  93                                 guint n_param_values,
  94                                 const GValue *param_values,
  95                                 gpointer data);
  96 static gboolean
  97 spi_atk_bridge_state_event_listener (GSignalInvocationHint *signal_hint,
  98                                      guint n_param_values,
  99                                      const GValue *param_values,
 100                                      gpointer data);
 101 static gboolean spi_atk_bridge_signal_listener         (GSignalInvocationHint *signal_hint,
 102                                                         guint                  n_param_values,
 103                                                         const GValue          *param_values,
 104                                                         gpointer               data);
 105 static gint     spi_atk_bridge_key_listener            (AtkKeyEventStruct     *event,
 106                                                         gpointer               data);
 107
 108 /* For automatic libgnome init */
 109 extern void gnome_accessibility_module_init     (void);
 110 extern void gnome_accessibility_module_shutdown (void);
 111
 112 static int     atk_bridge_initialized = FALSE;
 113 static guint   atk_bridge_focus_tracker_id = 0;
 114 static guint   atk_bridge_key_event_listener_id = 0;
 115 static GArray *listener_ids = NULL;
 116
 117 /*
 118  *   These exported symbols are hooked by gnome-program
 119  * to provide automatic module initialization and shutdown.
 120  */
 121 extern void gnome_accessibility_module_init     (void);
 122 extern void gnome_accessibility_module_shutdown (void);
 123
 124 static void
 125 spi_atk_bridge_init_event_type_consts ()
 126 {
 127   atk_signal_child_changed = g_signal_lookup ("child_changed",
 128                                               ATK_TYPE_OBJECT);
 129   atk_signal_text_changed = g_signal_lookup ("text_changed",
 130                                              ATK_TYPE_TEXT);
 131   atk_signal_active_descendant_changed =
 132          g_signal_lookup ("active_descendant_changed",
 133                           ATK_TYPE_OBJECT);
 134 }
 135
 136 static int
 137 atk_bridge_init (gint *argc, gchar **argv[])
 138 {
 139   const char *debug_env_string = g_getenv ("AT_SPI_DEBUG");
 140
 141   if (atk_bridge_initialized)
 142     {
 143       return 0;
 144     }
 145   atk_bridge_initialized = TRUE;
 146
 147   if (debug_env_string)
 148     _dbg = (int) g_ascii_strtod (debug_env_string, NULL);
 149
 150   if (!bonobo_init (argc, argv ? *argv : NULL))
 151     {
 152       g_error ("Could not initialize Bonobo");
 153     }
 154
 155   /*
 156    * We only want to enable the bridge for top level
 157    * applications, we detect bonobo components by seeing
 158    * if they were activated with the intention of extracting
 159    * an impl. by IID - very solid.
 160    */
 161   if (bonobo_activation_iid_get ())
 162     {
 163       DBG (1, g_message ("Found Bonobo component\n"));
 164       toplevel_handler = g_signal_connect (atk_get_root (),
 165                                            "children-changed::add",
 166                                            (GCallback) spi_atk_bridge_toplevel_added,
 167                                            NULL);
 168     }
 169   else
 170     {
 171       spi_atk_bridge_do_registration ();
 172     }
 173
 174   spi_atk_bridge_init_event_type_consts ();
 175
 176   return 0;
 177 }
 178
 179
 180 static void
 181 spi_atk_bridge_do_registration (void)
 182 {
 183   CORBA_Environment ev;
 184
 185   CORBA_exception_init(&ev);
 186
 187   if (spi_atk_bridge_get_registry () == CORBA_OBJECT_NIL)
 188     {
 189       g_error ("Could not locate registry");
 190     }
 191
 192   bonobo_activate ();
 193
 194   /* Create the accessible application server object */
 195
 196   this_app = spi_application_new (atk_get_root ());
 197
 198   DBG (1, g_message ("About to register application\n"));
 199
 200   spi_atk_bridge_register_application (spi_atk_bridge_get_registry ());
 201
 202   g_atexit (spi_atk_bridge_exit_func);
 203
 204   DBG (1, g_message ("Application registered & listening\n"));
 205
 206 }
 207
 208 static void
 209 spi_atk_bridge_toplevel_added (AtkObject *object,
 210                                guint     index,
 211                                AtkObject *child)
 212 {
 213   g_signal_handler_disconnect (object, toplevel_handler);
 214   spi_atk_bridge_do_registration ();
 215 }
 216
 217 static void
 218 spi_atk_bridge_register_application (Accessibility_Registry registry)
 219 {
 220   Accessibility_Registry_registerApplication (spi_atk_bridge_get_registry (),
 221                                               BONOBO_OBJREF (this_app),
 222                                               &ev);
 223   spi_atk_register_event_listeners ();
 224 }
 225
 226 static Accessibility_Registry
 227 spi_atk_bridge_get_registry (void)
 228 {
 229   CORBA_Environment ev;
 230
 231   if (registry_died || (registry == NULL)) {
 232           CORBA_exception_init (&ev);
 233           if (registry_died)
 234             DBG (1, g_warning ("registry died! restarting..."));
 235           registry = bonobo_activation_activate_from_id (
 236                   "OAFIID:Accessibility_Registry:1.0", 0, NULL, &ev);
 237
 238           if (ev._major != CORBA_NO_EXCEPTION)
 239           {
 240                   g_error ("Accessibility app error: exception during "
 241                            "registry activation from id: %s\n",
 242                            CORBA_exception_id (&ev));
 243                   CORBA_exception_free (&ev);
 244           }
 245
 246           if (registry_died && registry) {
 247                   registry_died = FALSE;
 248                   spi_atk_bridge_register_application (registry);
 249           }
 250   }
 251   return registry;
 252 }
 253
 254 static Accessibility_DeviceEventController
 255 spi_atk_bridget_get_dec (void)
 256 {
 257   CORBA_Environment ev;
 258
 259   if (device_event_controller != CORBA_OBJECT_NIL)
 260     {
 261       if (ORBit_small_get_connection_status (device_event_controller)
 262           == ORBIT_CONNECTION_CONNECTED)
 263         return device_event_controller;
 264     }
 265
 266   CORBA_exception_init (&ev);
 267
 268   device_event_controller =
 269     Accessibility_Registry_getDeviceEventController (
 270             spi_atk_bridge_get_registry (), &ev);
 271
 272   if (BONOBO_EX (&ev))
 273     {
 274       g_warning ("failure: no deviceeventcontroller found\n");
 275       registry_died = TRUE;
 276       device_event_controller = CORBA_OBJECT_NIL;
 277     }
 278
 279   return device_event_controller;
 280 }
 281
 282 int
 283 gtk_module_init (gint *argc, gchar **argv[])
 284 {
 285         return atk_bridge_init (argc, argv);
 286 }
 287
 288 static void
 289 add_signal_listener (const char *signal_name)
 290 {
 291   guint id;
 292
 293   id = atk_add_global_event_listener (
 294     spi_atk_bridge_signal_listener, signal_name);
 295
 296   g_array_append_val (listener_ids, id);
 297 }
 298
 299 static void
 300 spi_atk_register_event_listeners (void)
 301 {
 302   /*
 303    * kludge to make sure the Atk interface types are registered, otherwise
 304    * the AtkText signal handlers below won't get registered
 305    */
 306   guint      id;
 307   GObject   *ao = g_object_new (ATK_TYPE_OBJECT, NULL);
 308   AtkObject *bo = atk_no_op_object_new (ao);
 309
 310
 311   if (atk_listeners_registered) return;
 312
 313   atk_listeners_registered = TRUE;
 314
 315   /* Register for focus event notifications, and register app with central registry  */
 316
 317   listener_ids = g_array_sized_new (FALSE, TRUE, sizeof (guint), 16);
 318
 319   atk_bridge_focus_tracker_id = atk_add_focus_tracker (spi_atk_bridge_focus_tracker);
 320
 321   id = atk_add_global_event_listener (spi_atk_bridge_property_event_listener,
 322                                       "Gtk:AtkObject:property-change");
 323   g_array_append_val (listener_ids, id);
 324   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 325                                       "window:create");
 326   g_array_append_val (listener_ids, id);
 327   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 328                                       "window:destroy");
 329   g_array_append_val (listener_ids, id);
 330   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 331                                       "window:minimize");
 332   g_array_append_val (listener_ids, id);
 333   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 334                                       "window:maximize");
 335   g_array_append_val (listener_ids, id);
 336   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 337                                       "window:restore");
 338   g_array_append_val (listener_ids, id);
 339   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 340                                       "window:activate");
 341   g_array_append_val (listener_ids, id);
 342   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 343                                       "window:deactivate");
 344   g_array_append_val (listener_ids, id);
 345   id = atk_add_global_event_listener (spi_atk_bridge_state_event_listener,
 346                                       "Gtk:AtkObject:state-change");
 347   g_array_append_val (listener_ids, id);
 348
 349   add_signal_listener ("Gtk:AtkObject:children-changed");
 350   add_signal_listener ("Gtk:AtkObject:visible-data-changed");
 351   add_signal_listener ("Gtk:AtkObject:active-descendant-changed");
 352   add_signal_listener ("Gtk:AtkSelection:selection-changed");
 353   add_signal_listener ("Gtk:AtkText:text-selection-changed");
 354   add_signal_listener ("Gtk:AtkText:text-changed");
 355   add_signal_listener ("Gtk:AtkText:text-caret-moved");
 356   add_signal_listener ("Gtk:AtkTable:row-inserted");
 357   add_signal_listener ("Gtk:AtkTable:row-reordered");
 358   add_signal_listener ("Gtk:AtkTable:row-deleted");
 359   add_signal_listener ("Gtk:AtkTable:column-inserted");
 360   add_signal_listener ("Gtk:AtkTable:column-reordered");
 361   add_signal_listener ("Gtk:AtkTable:column-deleted");
 362   add_signal_listener ("Gtk:AtkTable:model-changed");
 363 /*
 364  * May add the following listeners to implement preemptive key listening for GTK+
 365  *
 366  * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-press-event");
 367  * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-release-event");
 368  */
 369   atk_bridge_key_event_listener_id = atk_add_key_event_listener (
 370     spi_atk_bridge_key_listener, NULL);
 371
 372   g_object_unref (G_OBJECT (bo));
 373   g_object_unref (ao);
 374 }
 375
 376 static void
 377 deregister_application (BonoboObject *app)
 378 {
 379   Accessibility_Registry registry = spi_atk_bridge_get_registry ();
 380   Accessibility_Registry_deregisterApplication (registry, BONOBO_OBJREF (app), &ev);
 381
 382   device_event_controller = bonobo_object_release_unref (device_event_controller, &ev);
 383   registry = bonobo_object_release_unref (registry, &ev);
 384
 385   app = bonobo_object_unref (app);
 386 }
 387
 388 static void
 389 spi_atk_bridge_exit_func (void)
 390 {
 391   BonoboObject *app = (BonoboObject *) this_app;
 392
 393   DBG (1, g_message ("exiting bridge\n"));
 394
 395   if (!app)
 396     {
 397       return;
 398     }
 399   this_app = NULL;
 400
 401   /*
 402    *  FIXME: this may be incorrect for apps that do their own bonobo
 403    *  shutdown, until we can explicitly shutdown to get the ordering
 404    *  right.
 405    */
 406   if (!bonobo_is_initialized ())
 407     {
 408       DBG (1, g_warning ("Re-initializing bonobo\n"));
 409       g_assert (bonobo_init (0, NULL));
 410       g_assert (bonobo_activate ());
 411     }
 412
 413   deregister_application (app);
 414
 415   DBG (1, g_message ("bridge exit func complete.\n"));
 416
 417   if (g_getenv ("AT_BRIDGE_SHUTDOWN"))
 418     {
 419       g_assert (!bonobo_debug_shutdown ());
 420     }
 421 }
 422
 423 void
 424 gnome_accessibility_module_init (void)
 425 {
 426   atk_bridge_init (NULL, NULL);
 427
 428   g_print("Atk Accessibilty bridge initialized\n");
 429 }
 430
 431 void
 432 gnome_accessibility_module_shutdown (void)
 433 {
 434   BonoboObject *app = (BonoboObject *) this_app;
 435   int     i;
 436   GArray *ids = listener_ids;
 437
 438   if (!atk_bridge_initialized)
 439     {
 440       return;
 441     }
 442   atk_bridge_initialized = FALSE;
 443   this_app = NULL;
 444
 445   g_print("Atk Accessibilty bridge shutdown\n");
 446
 447   listener_ids = NULL;
 448   atk_remove_focus_tracker (atk_bridge_focus_tracker_id);
 449
 450   for (i = 0; ids && i < ids->len; i++)
 451   {
 452           atk_remove_global_event_listener (g_array_index (ids, guint, i));
 453   }
 454
 455   atk_remove_key_event_listener (atk_bridge_key_event_listener_id);
 456
 457   deregister_application (app);
 458 }
 459
 460 static void
 461 spi_atk_bridge_focus_tracker (AtkObject *object)
 462 {
 463   SpiAccessible *source;
 464   Accessibility_Event e;
 465
 466   source = spi_accessible_new (object);
 467
 468   e.type = "focus:";
 469   e.source = BONOBO_OBJREF (source);
 470   e.detail1 = 0;
 471   e.detail2 = 0;
 472   spi_init_any_nil (&e.any_data);
 473
 474   CORBA_exception_init (&ev);
 475   Accessibility_Registry_notifyEvent (spi_atk_bridge_get_registry (), &e, &ev);
 476   if (BONOBO_EX (&ev))
 477     registry_died = TRUE;
 478
 479   bonobo_object_unref (source);
 480
 481   CORBA_exception_free (&ev);
 482 }
 483
 484 static void
 485 spi_atk_emit_eventv (const GObject         *gobject,
 486                      long                   detail1,
 487                      long                   detail2,
 488                      CORBA_any             *any,
 489                      const char            *format, ...)
 490 {
 491   va_list             args;
 492   Accessibility_Event e;
 493   SpiAccessible      *source;
 494   AtkObject          *aobject;
 495 #ifdef SPI_BRIDGE_DEBUG
 496   CORBA_string s;
 497 #endif
 498
 499   va_start (args, format);
 500
 501   if (ATK_IS_IMPLEMENTOR (gobject))
 502     {
 503       aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 504       source  = spi_accessible_new (aobject);
 505       g_object_unref (G_OBJECT (aobject));
 506     }
 507   else if (ATK_IS_OBJECT (gobject))
 508     {
 509       aobject = ATK_OBJECT (gobject);
 510       source  = spi_accessible_new (aobject);
 511     }
 512   else
 513     {
 514       aobject = NULL;
 515       source  = NULL;
 516       DBG (0, g_warning ("received property-change event from non-AtkImplementor"));
 517     }
 518
 519   if (source)
 520     {
 521       e.type = g_strdup_vprintf (format, args);
 522       e.source = BONOBO_OBJREF (source);
 523       e.detail1 = detail1;
 524       e.detail2 = detail2;
 525       if (any) e.any_data = *any;
 526       else spi_init_any_nil (&e.any_data);
 527
 528 #ifdef SPI_BRIDGE_DEBUG
 529       s = Accessibility_Accessible__get_name (BONOBO_OBJREF (source), &ev);
 530       g_warning ("Emitting event '%s' (%lu, %lu) on %s",
 531                  e.type, e.detail1, e.detail2, s);
 532       CORBA_free (s);
 533 #endif
 534       CORBA_exception_init (&ev);
 535       Accessibility_Registry_notifyEvent (spi_atk_bridge_get_registry (),
 536                                           &e, &ev);
 537 #ifdef SPI_BRIDGE_DEBUG
 538       if (ev._major != CORBA_NO_EXCEPTION)
 539         g_warning ("error emitting event %s, (%d) %s",
 540                    e.type,
 541                    ev._major,
 542                    CORBA_exception_id(&ev));
 543 #endif
 544       if (BONOBO_EX (&ev)) registry_died = TRUE;
 545       Accessibility_Accessible_unref (e.source, &ev);
 546
 547       CORBA_exception_free (&ev);
 548
 549       g_free (e.type);
 550     }
 551
 552   va_end (args);
 553
 554 }
 555
 556 static gboolean
 557 spi_atk_bridge_property_event_listener (GSignalInvocationHint *signal_hint,
 558                                         guint n_param_values,
 559                                         const GValue *param_values,
 560                                         gpointer data)
 561 {
 562   AtkPropertyValues *values;
 563   GObject *gobject;
 564
 565 #ifdef SPI_BRIDGE_DEBUG
 566   GSignalQuery signal_query;
 567   const gchar *name;
 568   const gchar *s, *s2;
 569
 570   g_signal_query (signal_hint->signal_id, &signal_query);
 571   name = signal_query.signal_name;
 572
 573   s2 = g_type_name (G_OBJECT_TYPE (g_value_get_object (param_values + 0)));
 574   s = atk_object_get_name (ATK_OBJECT (g_value_get_object (param_values + 0)));
 575   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 576   DBG (2, g_message ("Received (property) signal %s:%s:%s from object %s (gail %s)\n",
 577            g_type_name (signal_query.itype), name, values->property_name, s, s2));
 578
 579 #endif
 580
 581   gobject = g_value_get_object (param_values + 0);
 582   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 583
 584   spi_atk_emit_eventv (gobject, 0, 0, NULL,
 585                        "object:property-change:%s", values->property_name);
 586
 587   return TRUE;
 588 }
 589
 590 static gboolean
 591 spi_atk_bridge_state_event_listener (GSignalInvocationHint *signal_hint,
 592                                      guint n_param_values,
 593                                      const GValue *param_values,
 594                                      gpointer data)
 595 {
 596   GObject *gobject;
 597   gchar *property_name;
 598   gchar *type;
 599   unsigned long detail1;
 600 #ifdef SPI_BRIDGE_DEBUG
 601   GSignalQuery signal_query;
 602   const gchar *name;
 603
 604   g_signal_query (signal_hint->signal_id, &signal_query);
 605   name = signal_query.signal_name;
 606   fprintf (stderr, "Received (state) signal %s:%s\n",
 607            g_type_name (signal_query.itype), name);
 608 #endif
 609
 610   gobject = g_value_get_object (param_values + 0);
 611   property_name = g_strdup (g_value_get_string (param_values + 1));
 612   detail1 = (g_value_get_boolean (param_values + 2))
 613     ? 1 : 0;
 614   type = g_strdup_printf ("object:state-changed:%s", property_name);
 615   spi_atk_emit_eventv (gobject,
 616                        detail1,
 617                        0,
 618                        NULL,
 619                        type);
 620   g_free (property_name);
 621   g_free (type);
 622   return TRUE;
 623 }
 624
 625 static void
 626 spi_init_keystroke_from_atk_key_event (Accessibility_DeviceEvent  *keystroke,
 627                                        AtkKeyEventStruct          *event)
 628 {
 629 #ifdef SPI_DEBUG
 630   if (event)
 631     {
 632       g_print ("event %c (%d)\n", (int) event->keyval, (int) event->keycode);
 633     }
 634   else
 635 #endif
 636   if (!event)
 637     {
 638       g_print ("WARNING: NULL key event!");
 639     }
 640
 641   keystroke->id        = (CORBA_long) event->keyval;
 642   keystroke->hw_code   = (CORBA_short) event->keycode;
 643   keystroke->timestamp = (CORBA_unsigned_long) event->timestamp;
 644   keystroke->modifiers = (CORBA_unsigned_short) (event->state & 0xFFFF);
 645   if (event->string)
 646     {
 647       keystroke->event_string = CORBA_string_dup (event->string);
 648       keystroke->is_text = CORBA_TRUE;
 649     }
 650   else
 651     {
 652       keystroke->event_string = CORBA_string_dup ("");
 653       keystroke->is_text = CORBA_FALSE;
 654     }
 655   switch (event->type)
 656     {
 657     case (ATK_KEY_EVENT_PRESS):
 658       keystroke->type = Accessibility_KEY_PRESSED_EVENT;
 659       break;
 660     case (ATK_KEY_EVENT_RELEASE):
 661       keystroke->type = Accessibility_KEY_RELEASED_EVENT;
 662       break;
 663     default:
 664       keystroke->type = 0;
 665       break;
 666     }
 667 #if 0
 668   g_print ("key_event type %d; val=%d code=%d modifiers=%x name=%s is_text=%d, time=%lx\n",
 669            (int) keystroke->type, (int) keystroke->id, (int) keystroke->hw_code,
 670            (int) keystroke->modifiers,
 671            keystroke->event_string, (int) keystroke->is_text, (unsigned long) keystroke->timestamp);
 672 #endif
 673 }
 674
 675 static gint
 676 spi_atk_bridge_key_listener (AtkKeyEventStruct *event, gpointer data)
 677 {
 678   CORBA_boolean             result;
 679   Accessibility_DeviceEvent key_event;
 680
 681   CORBA_exception_init (&ev);
 682
 683   spi_init_keystroke_from_atk_key_event (&key_event, event);
 684
 685   result = Accessibility_DeviceEventController_notifyListenersSync (
 686           spi_atk_bridget_get_dec (), &key_event, &ev);
 687
 688   CORBA_exception_free (&ev);
 689
 690   return result;
 691 }
 692
 693 static gboolean
 694 spi_atk_bridge_signal_listener (GSignalInvocationHint *signal_hint,
 695                                 guint n_param_values,
 696                                 const GValue *param_values,
 697                                 gpointer data)
 698 {
 699   GObject *gobject;
 700   GSignalQuery signal_query;
 701   const gchar *name;
 702   const gchar *detail;
 703   CORBA_any any;
 704   CORBA_Object c_obj;
 705   char *sp = NULL;
 706   AtkObject *ao;
 707   gint detail1 = 0, detail2 = 0;
 708   SpiAccessible *s_ao = NULL;
 709 #ifdef SPI_BRIDGE_DEBUG
 710   const gchar *s, *s2;
 711 #endif
 712
 713   g_signal_query (signal_hint->signal_id, &signal_query);
 714
 715   name = signal_query.signal_name;
 716   if (signal_hint->detail)
 717     detail = g_quark_to_string (signal_hint->detail);
 718   else
 719     detail = NULL;
 720
 721 #ifdef SPI_BRIDGE_DEBUG
 722   s2 = g_type_name (G_OBJECT_TYPE (g_value_get_object (param_values + 0)));
 723   s = atk_object_get_name (ATK_OBJECT (g_value_get_object (param_values + 0)));
 724   fprintf (stderr, "Received signal %s:%s detail: %s from object %s (gail %s)\n",
 725            g_type_name (signal_query.itype), name,
 726            detail ? detail : "<NULL>", s ? s : "<NULL>" , s2);
 727 #endif
 728
 729   gobject = g_value_get_object (param_values + 0);
 730
 731   if (signal_query.signal_id == atk_signal_active_descendant_changed)
 732     {
 733       gpointer child = g_value_get_pointer (param_values + 1);
 734
 735       g_return_val_if_fail (ATK_IS_OBJECT (child), TRUE);
 736
 737       ao = ATK_OBJECT (child);
 738
 739       detail1 = atk_object_get_index_in_parent (ao);
 740       s_ao = spi_accessible_new (ao);
 741       c_obj = BONOBO_OBJREF (s_ao);
 742       spi_init_any_object (&any, &c_obj);
 743     }
 744   else
 745     {
 746       if (G_VALUE_TYPE (param_values + 1) == G_TYPE_INT)
 747         detail1 = g_value_get_int (param_values + 1);
 748       if (G_VALUE_TYPE (param_values + 2) == G_TYPE_INT)
 749         detail2 = g_value_get_int (param_values + 2);
 750
 751       if (signal_query.signal_id == atk_signal_text_changed)
 752         {
 753           sp = atk_text_get_text (ATK_TEXT (gobject),
 754                                   detail1,
 755                                   detail1+detail2);
 756           spi_init_any_string (&any, &sp);
 757         }
 758       else if ((signal_query.signal_id == atk_signal_child_changed) && gobject)
 759         {
 760           ao = atk_object_ref_accessible_child (ATK_OBJECT (gobject),
 761                                                 detail1);
 762           if (ao)
 763             {
 764               s_ao = spi_accessible_new (ao);
 765               c_obj = BONOBO_OBJREF (s_ao);
 766               spi_init_any_object (&any, &c_obj);
 767               g_object_unref (ao);
 768             }
 769           else
 770             {
 771               spi_init_any_nil (&any);
 772             }
 773         }
 774       else
 775         {
 776           spi_init_any_nil (&any);
 777         }
 778     }
 779
 780   if (detail)
 781     spi_atk_emit_eventv (gobject, detail1, detail2, &any,
 782                          "object:%s:%s", name, detail);
 783   else
 784     spi_atk_emit_eventv (gobject, detail1, detail2, &any,
 785                          "object:%s", name);
 786
 787   if (sp)
 788     g_free (sp);
 789
 790   return TRUE;
 791 }
 792
 793 static gboolean
 794 spi_atk_bridge_window_event_listener (GSignalInvocationHint *signal_hint,
 795                                       guint n_param_values,
 796                                       const GValue *param_values,
 797                                       gpointer data)
 798 {
 799   GObject *gobject;
 800   GSignalQuery signal_query;
 801   CORBA_any any;
 802   const gchar *name, *s;
 803 #ifdef SPI_BRIDGE_DEBUG
 804   const gchar *s2;
 805 #endif
 806
 807   g_signal_query (signal_hint->signal_id, &signal_query);
 808
 809   name = signal_query.signal_name;
 810
 811 #ifdef SPI_BRIDGE_DEBUG
 812   s2 = g_type_name (G_OBJECT_TYPE (g_value_get_object (param_values + 0)));
 813   s = atk_object_get_name (ATK_OBJECT (g_value_get_object (param_values + 0)));
 814   fprintf (stderr, "Received signal %s:%s from object %s (gail %s)\n",
 815            g_type_name (signal_query.itype), name, s ? s : "<NULL>" , s2);
 816 #endif
 817
 818   gobject = g_value_get_object (param_values + 0);
 819
 820   s = atk_object_get_name (ATK_OBJECT (gobject));
 821   spi_init_any_string (&any, (char **) &s);
 822
 823   spi_atk_emit_eventv (gobject, 0, 0, &any,
 824                        "window:%s", name);
 825   return TRUE;
 826 }