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