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