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