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