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, 2003 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002, 2003 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 "config.h"
  25
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <stdarg.h>
  31 #include <libbonobo.h>
  32 #include <orbit/orbit.h>
  33 #include <atk/atk.h>
  34 #include <atk/atkobject.h>
  35 #include <atk/atknoopobject.h>
  36 #include <libspi/Accessibility.h>
  37 #include <libspi/spi-private.h>
  38 #include "remoteobject.h"
  39 #include "accessible.h"
  40 #include "application.h"
  41 #include <bonobo-activation/bonobo-activation-register.h>
  42
  43 #undef SPI_BRIDGE_DEBUG
  44
  45 #define DBG(a,b) if(_dbg>=(a))b
  46
  47 int _dbg = 0;
  48 static CORBA_Environment ev;
  49 static Accessibility_Registry registry = CORBA_OBJECT_NIL;
  50 static Accessibility_DeviceEventController device_event_controller = CORBA_OBJECT_NIL;
  51 static SpiApplication *this_app = NULL;
  52 static gboolean registry_died = FALSE;
  53 static gboolean atk_listeners_registered = FALSE;
  54 static gint toplevels = 0;
  55 static gboolean exiting = FALSE;
  56
  57 static guint atk_signal_text_changed;
  58 static guint atk_signal_children_changed;
  59 static guint atk_signal_active_descendant_changed;
  60 static guint atk_signal_text_selection_changed;
  61
  62 /* NOT YET USED
  63    static guint atk_signal_row_reordered;
  64    static guint atk_signal_row_inserted;
  65    static guint atk_signal_row_deleted;
  66    static guint atk_signal_column_reordered;
  67    static guint atk_signal_column_inserted;
  68    static guint atk_signal_column_deleted;
  69 */
  70
  71 static guint atk_signal_link_selected;
  72 static guint atk_signal_bounds_changed;
  73
  74 static Accessibility_Registry spi_atk_bridge_get_registry (void);
  75 static void     spi_atk_bridge_do_registration         (void);
  76 static void     spi_atk_bridge_toplevel_added          (AtkObject             *object,
  77                                                         guint                 index,
  78                                                         AtkObject             *child);
  79 static void     spi_atk_bridge_toplevel_removed        (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
  92 static void     spi_atk_bridge_init_nil                (CORBA_any *any,
  93                                                         AtkObject *obj);
  94 static void     spi_atk_bridge_init_object             (CORBA_any *any,
  95                                                         AtkObject *obj,
  96                                                         CORBA_Object *c_obj);
  97 static void     spi_atk_bridge_init_string             (CORBA_any *any,
  98                                                         AtkObject *obj,
  99                                                         gchar **string);
 100 static void     spi_atk_bridge_init_rect               (CORBA_any *any,
 101                                                         AtkObject *obj,
 102                                                         AtkRectangle *rect);
 103
 104 static gboolean
 105 spi_atk_bridge_window_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_state_event_listener (GSignalInvocationHint *signal_hint,
 111                                      guint n_param_values,
 112                                      const GValue *param_values,
 113                                      gpointer data);
 114 static gboolean spi_atk_bridge_signal_listener         (GSignalInvocationHint *signal_hint,
 115                                                         guint                  n_param_values,
 116                                                         const GValue          *param_values,
 117                                                         gpointer               data);
 118 static gint     spi_atk_bridge_key_listener            (AtkKeyEventStruct     *event,
 119                                                         gpointer               data);
 120 static void     spi_atk_tidy_windows                   (void);
 121 static void     deregister_application                 (BonoboObject          *app);
 122 static void     reinit_register_vars                   (void);
 123
 124 /* For automatic libgnome init */
 125 extern void gnome_accessibility_module_init     (void);
 126 extern void gnome_accessibility_module_shutdown (void);
 127
 128 static int     atk_bridge_initialized = FALSE;
 129 static pid_t   atk_bridge_pid = 0;
 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 spi_atk_bridge_init_event_type_consts ()
 143 {
 144   static gboolean done = FALSE;
 145
 146   if (done)
 147     return;
 148
 149   atk_signal_children_changed = g_signal_lookup ("children_changed",
 150                                               ATK_TYPE_OBJECT);
 151   atk_signal_text_changed = g_signal_lookup ("text_changed",
 152                                              ATK_TYPE_TEXT);
 153   atk_signal_bounds_changed = g_signal_lookup ("bounds_changed",
 154                                               ATK_TYPE_COMPONENT);
 155   atk_signal_active_descendant_changed =
 156          g_signal_lookup ("active_descendant_changed",
 157                           ATK_TYPE_OBJECT);
 158   atk_signal_link_selected = g_signal_lookup ("link_selected",
 159                                               ATK_TYPE_HYPERTEXT);
 160   atk_signal_text_selection_changed = g_signal_lookup ("text_selection_changed",
 161                                               ATK_TYPE_TEXT);
 162   done = TRUE;
 163 }
 164
 165 static int
 166 atk_bridge_init (gint *argc, gchar **argv[])
 167 {
 168   const char *debug_env_string = g_getenv ("AT_SPI_DEBUG");
 169   gchar *fname;
 170
 171   if (atk_bridge_initialized)
 172     {
 173       return 0;
 174     }
 175   atk_bridge_initialized = TRUE;
 176   atk_bridge_pid = getpid ();
 177
 178   if (g_getenv ("ATK_BRIDGE_REDIRECT_LOG"))
 179   {
 180       fname = g_strconcat ("/tmp/", g_get_prgname (), ".at-spi-log", NULL);
 181       /* make sure we're not being redirected - security issue */
 182       if (!g_file_test (fname, G_FILE_TEST_IS_SYMLINK))
 183           freopen (fname, "w", stderr);
 184       g_free (fname);
 185   }
 186
 187   if (debug_env_string)
 188       _dbg = (int) g_ascii_strtod (debug_env_string, NULL);
 189
 190   if (!bonobo_init (argc, argv ? *argv : NULL))
 191     {
 192       g_error ("Could not initialize Bonobo");
 193     }
 194
 195   /* Create the accessible application server object */
 196   this_app = spi_application_new (atk_get_root ());
 197   /*
 198    * We only want to enable the bridge for top level
 199    * applications, we detect bonobo components by seeing
 200    * if they were activated with the intention of extracting
 201    * an impl. by IID - very solid.
 202    */
 203   if (bonobo_activation_iid_get ())
 204     {
 205       DBG (1, g_message ("Found Bonobo component\n"));
 206       g_signal_connect (atk_get_root (),
 207                         "children-changed::add",
 208                         (GCallback) spi_atk_bridge_toplevel_added,
 209                         NULL);
 210       g_signal_connect (atk_get_root (),
 211                         "children-changed::remove",
 212                         (GCallback) spi_atk_bridge_toplevel_removed,
 213                         NULL);
 214     }
 215   else
 216     {
 217       spi_atk_bridge_do_registration ();
 218     }
 219   spi_atk_register_event_listeners ();
 220   spi_atk_bridge_init_event_type_consts ();
 221
 222   return 0;
 223 }
 224
 225
 226 static void
 227 spi_atk_bridge_do_registration (void)
 228 {
 229   CORBA_Environment ev;
 230
 231   CORBA_exception_init(&ev);
 232
 233   if (spi_atk_bridge_get_registry () == CORBA_OBJECT_NIL)
 234     {
 235       g_error ("Could not locate registry");
 236     }
 237
 238   bonobo_activate ();
 239
 240   /* Create the accessible application server object */
 241   if (this_app == NULL)
 242     this_app = spi_application_new (atk_get_root ());
 243
 244   DBG (1, g_message ("About to register application\n"));
 245
 246   spi_atk_bridge_register_application (spi_atk_bridge_get_registry ());
 247
 248   g_atexit (spi_atk_bridge_exit_func);
 249
 250   DBG (1, g_message ("Application registered & listening\n"));
 251
 252 }
 253
 254 static void
 255 spi_atk_bridge_toplevel_added (AtkObject *object,
 256                                guint     index,
 257                                AtkObject *child)
 258 {
 259   if (toplevels == 0)
 260     {
 261       spi_atk_bridge_do_registration ();
 262     }
 263   toplevels++;
 264 }
 265
 266 static void
 267 spi_atk_bridge_toplevel_removed (AtkObject *object,
 268                                  guint     index,
 269                                  AtkObject *child)
 270 {
 271   BonoboObject *app = (BonoboObject *) this_app;
 272
 273   toplevels--;
 274   if (toplevels == 0)
 275     {
 276       deregister_application (app);
 277       reinit_register_vars ();
 278     }
 279   if (toplevels < 0)
 280     {
 281       g_warning ("More toplevels removed than added\n");
 282       toplevels = 0;
 283     }
 284 }
 285
 286 static void
 287 spi_atk_bridge_register_application (Accessibility_Registry registry)
 288 {
 289   Accessibility_Registry_registerApplication (spi_atk_bridge_get_registry (),
 290                                               BONOBO_OBJREF (this_app),
 291                                               &ev);
 292 }
 293
 294 /*
 295  * Returns a 'canonicalized' value for DISPLAY,
 296  * with the screen number stripped off if present.
 297  */
 298 static const gchar*
 299 spi_display_name (void)
 300 {
 301     static const char *canonical_display_name = NULL;
 302     if (!canonical_display_name)
 303     {
 304         const gchar *display_env = g_getenv ("AT_SPI_DISPLAY");
 305         if (!display_env)
 306         {
 307             display_env = g_getenv ("DISPLAY");
 308             if (!display_env || !display_env[0])
 309                 canonical_display_name = ":0";
 310             else
 311             {
 312                 gchar *display_p, *screen_p;
 313                 canonical_display_name = g_strdup (display_env);
 314                 display_p = strrchr (canonical_display_name, ':');
 315                 screen_p = strrchr (canonical_display_name, '.');
 316                 if (screen_p && display_p && (screen_p > display_p))
 317                 {
 318                     *screen_p = '\0';
 319                 }
 320             }
 321         }
 322         else
 323         {
 324             canonical_display_name = display_env;
 325         }
 326     }
 327     return canonical_display_name;
 328 }
 329
 330 static Accessibility_Registry
 331 spi_atk_bridge_get_registry (void)
 332 {
 333   CORBA_Environment ev;
 334
 335   if (registry_died || (registry == CORBA_OBJECT_NIL)) {
 336           CORBA_exception_init (&ev);
 337           if (registry_died)
 338             {
 339               if (exiting)
 340                 return CORBA_OBJECT_NIL;
 341               else
 342                 DBG (1, g_warning ("registry died! restarting..."));
 343             }
 344           bonobo_activation_set_activation_env_value ("AT_SPI_DISPLAY", spi_display_name ());
 345
 346           registry = bonobo_activation_activate_from_id (
 347                   "OAFIID:Accessibility_Registry:1.0", 0, NULL, &ev);
 348
 349           if (ev._major != CORBA_NO_EXCEPTION)
 350           {
 351                   g_error ("Accessibility app error: exception during "
 352                            "registry activation from id: %s\n",
 353                            CORBA_exception_id (&ev));
 354                   CORBA_exception_free (&ev);
 355           }
 356
 357           if (registry_died && registry) {
 358                   registry_died = FALSE;
 359                   spi_atk_bridge_register_application (registry);
 360           }
 361   }
 362   return registry;
 363 }
 364
 365 static Accessibility_DeviceEventController
 366 spi_atk_bridget_get_dec (void)
 367 {
 368   CORBA_Environment ev;
 369
 370   if (device_event_controller != CORBA_OBJECT_NIL)
 371     {
 372       if (ORBit_small_get_connection_status (device_event_controller)
 373           == ORBIT_CONNECTION_CONNECTED)
 374         return device_event_controller;
 375     }
 376
 377   CORBA_exception_init (&ev);
 378
 379   device_event_controller =
 380     Accessibility_Registry_getDeviceEventController (
 381             spi_atk_bridge_get_registry (), &ev);
 382
 383   if (BONOBO_EX (&ev))
 384     {
 385       g_warning (_("failure: no device event controller found.\n"));
 386       registry_died = TRUE;
 387       device_event_controller = CORBA_OBJECT_NIL;
 388     }
 389
 390   return device_event_controller;
 391 }
 392
 393 int
 394 gtk_module_init (gint *argc, gchar **argv[])
 395 {
 396         return atk_bridge_init (argc, argv);
 397 }
 398
 399 static void
 400 add_signal_listener (const char *signal_name)
 401 {
 402   guint id;
 403
 404   id = atk_add_global_event_listener (
 405     spi_atk_bridge_signal_listener, signal_name);
 406
 407   g_array_append_val (listener_ids, id);
 408 }
 409
 410 static void
 411 spi_atk_register_event_listeners (void)
 412 {
 413   /*
 414    * kludge to make sure the Atk interface types are registered, otherwise
 415    * the AtkText signal handlers below won't get registered
 416    */
 417   guint      id;
 418   GObject   *ao = g_object_new (ATK_TYPE_OBJECT, NULL);
 419   AtkObject *bo = atk_no_op_object_new (ao);
 420
 421
 422   if (atk_listeners_registered) return;
 423
 424   atk_listeners_registered = TRUE;
 425
 426   /* Register for focus event notifications, and register app with central registry  */
 427
 428   listener_ids = g_array_sized_new (FALSE, TRUE, sizeof (guint), 16);
 429
 430   atk_bridge_focus_tracker_id = atk_add_focus_tracker (spi_atk_bridge_focus_tracker);
 431
 432   id = atk_add_global_event_listener (spi_atk_bridge_property_event_listener,
 433                                       "Gtk:AtkObject:property-change");
 434   g_array_append_val (listener_ids, id);
 435   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 436                                       "window:create");
 437   g_array_append_val (listener_ids, id);
 438   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 439                                       "window:destroy");
 440   g_array_append_val (listener_ids, id);
 441   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 442                                       "window:minimize");
 443   g_array_append_val (listener_ids, id);
 444   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 445                                       "window:maximize");
 446   g_array_append_val (listener_ids, id);
 447   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 448                                       "window:restore");
 449   g_array_append_val (listener_ids, id);
 450   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 451                                       "window:activate");
 452   g_array_append_val (listener_ids, id);
 453   id = atk_add_global_event_listener (spi_atk_bridge_window_event_listener,
 454                                       "window:deactivate");
 455   g_array_append_val (listener_ids, id);
 456   id = atk_add_global_event_listener (spi_atk_bridge_state_event_listener,
 457                                       "Gtk:AtkObject:state-change");
 458   g_array_append_val (listener_ids, id);
 459
 460   add_signal_listener ("Gtk:AtkObject:children-changed");
 461   add_signal_listener ("Gtk:AtkObject:visible-data-changed");
 462   add_signal_listener ("Gtk:AtkObject:active-descendant-changed");
 463   add_signal_listener ("Gtk:AtkComponent:bounds-changed");
 464   add_signal_listener ("Gtk:AtkSelection:selection-changed");
 465   add_signal_listener ("Gtk:AtkText:text-selection-changed");
 466   add_signal_listener ("Gtk:AtkText:text-changed");
 467   add_signal_listener ("Gtk:AtkText:text-caret-moved");
 468   add_signal_listener ("Gtk:AtkTable:row-inserted");
 469   add_signal_listener ("Gtk:AtkTable:row-reordered");
 470   add_signal_listener ("Gtk:AtkTable:row-deleted");
 471   add_signal_listener ("Gtk:AtkTable:column-inserted");
 472   add_signal_listener ("Gtk:AtkTable:column-reordered");
 473   add_signal_listener ("Gtk:AtkTable:column-deleted");
 474   add_signal_listener ("Gtk:AtkTable:model-changed");
 475   add_signal_listener ("Gtk:AtkHypertext:link-selected");
 476 /*
 477  * May add the following listeners to implement preemptive key listening for GTK+
 478  *
 479  * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-press-event");
 480  * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-release-event");
 481  */
 482   atk_bridge_key_event_listener_id = atk_add_key_event_listener (
 483     spi_atk_bridge_key_listener, NULL);
 484
 485   g_object_unref (G_OBJECT (bo));
 486   g_object_unref (ao);
 487 }
 488
 489 static void
 490 deregister_application (BonoboObject *app)
 491 {
 492   Accessibility_Registry registry = spi_atk_bridge_get_registry ();
 493   Accessibility_Registry_deregisterApplication (registry, BONOBO_OBJREF (app), &ev);
 494
 495   device_event_controller = bonobo_object_release_unref (device_event_controller, &ev);
 496   registry = bonobo_object_release_unref (registry, &ev);
 497
 498   app = bonobo_object_unref (app);
 499 }
 500
 501 static void
 502 spi_atk_bridge_exit_func (void)
 503 {
 504   BonoboObject *app = (BonoboObject *) this_app;
 505
 506   DBG (1, g_message ("exiting bridge\n"));
 507
 508   if (!app)
 509     {
 510       return;
 511     }
 512   this_app = NULL;
 513   if (atk_bridge_pid != getpid ())
 514     {
 515       _exit (0);
 516     }
 517
 518   exiting = TRUE;
 519   /*
 520    * Check whether we still have windows which have not been deleted.
 521    */
 522   spi_atk_tidy_windows ();
 523   /*
 524    *  FIXME: this may be incorrect for apps that do their own bonobo
 525    *  shutdown, until we can explicitly shutdown to get the ordering
 526    *  right.
 527    */
 528   if (!bonobo_is_initialized ())
 529     {
 530       DBG (1, g_warning ("Re-initializing bonobo\n"));
 531       g_assert (bonobo_init (0, NULL));
 532       g_assert (bonobo_activate ());
 533     }
 534
 535   if (!registry_died)
 536     deregister_application (app);
 537
 538   DBG (1, g_message ("bridge exit func complete.\n"));
 539
 540   if (g_getenv ("AT_BRIDGE_SHUTDOWN"))
 541     {
 542       g_assert (!bonobo_debug_shutdown ());
 543     }
 544 }
 545
 546 void
 547 gnome_accessibility_module_init (void)
 548 {
 549   atk_bridge_init (NULL, NULL);
 550
 551   if (g_getenv ("AT_BRIDGE_SHUTDOWN"))
 552     {
 553         g_print("Atk Accessibility bridge initialized\n");
 554     }
 555 }
 556
 557 void
 558 gnome_accessibility_module_shutdown (void)
 559 {
 560   BonoboObject *app = (BonoboObject *) this_app;
 561   int     i;
 562   GArray *ids = listener_ids;
 563
 564   if (!atk_bridge_initialized)
 565     {
 566       return;
 567     }
 568   atk_bridge_initialized = FALSE;
 569   this_app = NULL;
 570
 571   if (g_getenv ("AT_BRIDGE_SHUTDOWN"))
 572     {
 573         g_print("Atk Accessibility bridge shutdown\n");
 574     }
 575
 576   listener_ids = NULL;
 577   atk_remove_focus_tracker (atk_bridge_focus_tracker_id);
 578
 579   for (i = 0; ids && i < ids->len; i++)
 580   {
 581           atk_remove_global_event_listener (g_array_index (ids, guint, i));
 582   }
 583
 584   atk_remove_key_event_listener (atk_bridge_key_event_listener_id);
 585
 586   deregister_application (app);
 587 }
 588
 589 static void
 590 spi_atk_bridge_focus_tracker (AtkObject *object)
 591 {
 592   SpiAccessible *source;
 593   Accessibility_Event e;
 594   const gchar *name = atk_object_get_name (object);
 595
 596   source = spi_accessible_new (object);
 597
 598   CORBA_exception_init (&ev);
 599
 600   e.type = "focus:";
 601   e.source = BONOBO_OBJREF (source);
 602   e.detail1 = 0;
 603   e.detail2 = 0;
 604   spi_atk_bridge_init_nil (&e.any_data, object);
 605   if (BONOBO_EX (&ev))
 606       registry_died = TRUE;
 607   else
 608       Accessibility_Registry_notifyEvent (spi_atk_bridge_get_registry (),
 609                                           &e, &ev);
 610   if (BONOBO_EX (&ev))
 611     registry_died = TRUE;
 612
 613   bonobo_object_unref (source);
 614
 615   CORBA_exception_free (&ev);
 616 }
 617
 618 static void
 619 spi_atk_emit_eventv (const GObject         *gobject,
 620                      long                   detail1,
 621                      long                   detail2,
 622                      CORBA_any             *any,
 623                      const char            *format, ...)
 624 {
 625   va_list             args;
 626   Accessibility_Event e;
 627   AtkObject          *aobject;
 628   SpiAccessible      *source = NULL;
 629   Accessibility_Registry registry;
 630   const gchar *name;
 631 #ifdef SPI_BRIDGE_DEBUG
 632   CORBA_string s = NULL;
 633 #endif
 634
 635   va_start (args, format);
 636
 637   if (ATK_IS_IMPLEMENTOR (gobject))
 638     {
 639       aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 640       source  = spi_accessible_new (aobject);
 641       g_object_unref (G_OBJECT (aobject));
 642     }
 643   else if (ATK_IS_OBJECT (gobject))
 644     {
 645       aobject = ATK_OBJECT (gobject);
 646       if (SPI_IS_REMOTE_OBJECT (aobject))
 647          e.source = spi_remote_object_get_accessible (SPI_REMOTE_OBJECT (aobject));
 648       else
 649          source  = spi_accessible_new (aobject);
 650     }
 651   else
 652     {
 653       aobject = NULL;
 654       DBG (0, g_warning ("received property-change event from non-AtkImplementor"));
 655       va_end (args);
 656       return;
 657     }
 658   name = atk_object_get_name (aobject);
 659   e.type = g_strdup_vprintf (format, args);
 660   if (source) e.source = BONOBO_OBJREF (source);
 661   e.detail1 = detail1;
 662   e.detail2 = detail2;
 663   if (any) e.any_data = *any;
 664   else spi_atk_bridge_init_nil (&e.any_data, aobject);
 665
 666 #ifdef SPI_BRIDGE_DEBUG
 667   if (e.source != CORBA_OBJECT_NIL)
 668       s = Accessibility_Accessible__get_name (e.source, &ev);
 669   g_message ("Emitting event '%s' (%lu, %lu) on %s",
 670              e.type, e.detail1, e.detail2, s);
 671   CORBA_free (s);
 672 #endif
 673   CORBA_exception_init (&ev);
 674   registry = spi_atk_bridge_get_registry ();
 675   if (registry_died) {
 676       g_free (e.type);
 677       return;
 678   }
 679   Accessibility_Registry_notifyEvent (registry,
 680                                       &e, &ev);
 681 #ifdef SPI_BRIDGE_DEBUG
 682   if (ev._major != CORBA_NO_EXCEPTION)
 683       g_message ("error emitting event %s, (%d) %s",
 684                  e.type,
 685                  ev._major,
 686                  CORBA_exception_id(&ev));
 687 #endif
 688   if (BONOBO_EX (&ev)) registry_died = TRUE;
 689
 690   if (source)
 691       bonobo_object_unref (BONOBO_OBJECT (source));
 692   else
 693       Bonobo_Unknown_unref (e.source, &ev);
 694
 695   CORBA_exception_free (&ev);
 696
 697   g_free (e.type);
 698
 699   if (!any && e.any_data._release) CORBA_free (e.any_data._value);
 700
 701   va_end (args);
 702
 703 }
 704
 705 static gboolean
 706 spi_atk_bridge_property_event_listener (GSignalInvocationHint *signal_hint,
 707                                         guint n_param_values,
 708                                         const GValue *param_values,
 709                                         gpointer data)
 710 {
 711   AtkPropertyValues *values;
 712   GObject *gobject;
 713   const gchar *prop_name;
 714   CORBA_any any;
 715   const gchar *sp = NULL;
 716   AtkObject *ao;
 717   SpiAccessible *s_ao = NULL;
 718   CORBA_Object c_obj;
 719   gint i;
 720   const gchar *name = NULL;
 721
 722 #ifdef SPI_BRIDGE_DEBUG
 723   GSignalQuery signal_query;
 724   const gchar *signame;
 725   const gchar *s, *s2;
 726
 727   g_signal_query (signal_hint->signal_id, &signal_query);
 728   signame = signal_query.signal_name;
 729
 730   s2 = g_type_name (G_OBJECT_TYPE (g_value_get_object (param_values + 0)));
 731   s = atk_object_get_name (ATK_OBJECT (g_value_get_object (param_values + 0)));
 732   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 733   DBG (2, g_message ("Received (property) signal %s:%s:%s from object %s (gail %s)\n",
 734            g_type_name (signal_query.itype), signame, values->property_name, s, s2));
 735
 736 #endif
 737
 738   gobject = g_value_get_object (param_values + 0);
 739   name = atk_object_get_name (ATK_OBJECT (gobject));
 740   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 741
 742   prop_name = values->property_name;
 743   if (strcmp (prop_name, "accessible-name") == 0)
 744     {
 745       spi_atk_bridge_init_string (&any,
 746                                   ATK_OBJECT (gobject),
 747                                   (gchar **)&name);
 748     }
 749   else if (strcmp (prop_name, "accessible-description") == 0)
 750     {
 751       sp = atk_object_get_description (ATK_OBJECT (gobject));
 752       spi_atk_bridge_init_string (&any,
 753                                   ATK_OBJECT (gobject),
 754                                   (gchar **)&sp);
 755     }
 756   else if (strcmp (prop_name, "accessible-parent") == 0)
 757     {
 758       ao = atk_object_get_parent (ATK_OBJECT (gobject));
 759       if (ao)
 760         {
 761           s_ao = spi_accessible_new (ao);
 762           c_obj = BONOBO_OBJREF (s_ao);
 763           spi_atk_bridge_init_object (&any,
 764                                       ATK_OBJECT (gobject),
 765                                       &c_obj);
 766         }
 767       else
 768         {
 769           spi_atk_bridge_init_nil (&any,
 770                                    ATK_OBJECT (gobject));
 771         }
 772     }
 773   else if (strcmp (prop_name, "accessible-table-summary") == 0)
 774     {
 775       ao = atk_table_get_summary (ATK_TABLE (gobject));
 776       if (ao)
 777         {
 778           s_ao = spi_accessible_new (ao);
 779           c_obj = BONOBO_OBJREF (s_ao);
 780           spi_atk_bridge_init_object (&any,
 781                                       ATK_OBJECT (gobject),
 782                                       &c_obj);
 783         }
 784       else
 785         {
 786           spi_atk_bridge_init_nil (&any,
 787                                    ATK_OBJECT (gobject));
 788         }
 789     }
 790   else if (strcmp (prop_name, "accessible-table-column-header") == 0)
 791     {
 792       i = g_value_get_int (&(values->new_value));
 793       ao = atk_table_get_column_header (ATK_TABLE (gobject), i);
 794       if (ao)
 795         {
 796           s_ao = spi_accessible_new (ao);
 797           c_obj = BONOBO_OBJREF (s_ao);
 798           spi_atk_bridge_init_object (&any,
 799                                       ATK_OBJECT (gobject),
 800                                       &c_obj);
 801         }
 802       else
 803         {
 804           spi_atk_bridge_init_nil (&any, ATK_OBJECT (gobject));
 805         }
 806     }
 807   else if (strcmp (prop_name, "accessible-table-row-header") == 0)
 808     {
 809       i = g_value_get_int (&(values->new_value));
 810       ao = atk_table_get_row_header (ATK_TABLE (gobject), i);
 811       if (ao)
 812         {
 813           s_ao = spi_accessible_new (ao);
 814           c_obj = BONOBO_OBJREF (s_ao);
 815           spi_atk_bridge_init_object (&any, ATK_OBJECT (gobject), &c_obj);
 816         }
 817       else
 818         {
 819           spi_atk_bridge_init_nil (&any, ATK_OBJECT (gobject));
 820         }
 821     }
 822   else if (strcmp (prop_name, "accessible-table-row-description") == 0)
 823     {
 824       i = g_value_get_int (&(values->new_value));
 825       sp = atk_table_get_row_description (ATK_TABLE (gobject), i);
 826       spi_atk_bridge_init_string (&any, ATK_OBJECT (gobject),
 827                                   (gchar **)&sp);
 828     }
 829   else if (strcmp (prop_name, "accessible-table-column-description") == 0)
 830     {
 831       i = g_value_get_int (&(values->new_value));
 832       sp = atk_table_get_column_description (ATK_TABLE (gobject), i);
 833       spi_atk_bridge_init_string (&any, ATK_OBJECT (gobject),
 834                                   (gchar **)&sp);
 835     }
 836   else if (strcmp (prop_name, "accessible-table-caption-object") == 0)
 837     {
 838       ao = atk_table_get_caption (ATK_TABLE (gobject));
 839       sp = atk_object_get_name (ao);
 840       spi_atk_bridge_init_string (&any, ATK_OBJECT (gobject),
 841                                   (gchar **)&sp);
 842     }
 843   else
 844     {
 845       spi_atk_bridge_init_nil (&any, ATK_OBJECT (gobject));
 846     }
 847
 848   spi_atk_emit_eventv (gobject, 0, 0, &any,
 849                        "object:property-change:%s", prop_name);
 850
 851
 852   return TRUE;
 853 }
 854
 855 static gboolean
 856 spi_atk_bridge_state_event_listener (GSignalInvocationHint *signal_hint,
 857                                      guint n_param_values,
 858                                      const GValue *param_values,
 859                                      gpointer data)
 860 {
 861   GObject *gobject;
 862   gchar *property_name;
 863   gchar *type;
 864   unsigned long detail1;
 865 #ifdef SPI_BRIDGE_DEBUG
 866   GSignalQuery signal_query;
 867   const gchar *name;
 868
 869   g_signal_query (signal_hint->signal_id, &signal_query);
 870   name = signal_query.signal_name;
 871   fprintf (stderr, "Received (state) signal %s:%s\n",
 872            g_type_name (signal_query.itype), name);
 873 #endif
 874
 875   gobject = g_value_get_object (param_values + 0);
 876   property_name = g_strdup (g_value_get_string (param_values + 1));
 877   detail1 = (g_value_get_boolean (param_values + 2))
 878     ? 1 : 0;
 879   type = g_strdup_printf ("object:state-changed:%s", property_name);
 880   spi_atk_emit_eventv (gobject,
 881                        detail1,
 882                        0,
 883                        NULL,
 884                        type);
 885   g_free (property_name);
 886   g_free (type);
 887   return TRUE;
 888 }
 889
 890 static void
 891 spi_init_keystroke_from_atk_key_event (Accessibility_DeviceEvent  *keystroke,
 892                                        AtkKeyEventStruct          *event)
 893 {
 894 #ifdef SPI_DEBUG
 895   if (event)
 896     {
 897       g_print ("event %c (%d)\n", (int) event->keyval, (int) event->keycode);
 898     }
 899   else
 900 #endif
 901   if (!event)
 902     { /* this doesn't really need translating */
 903       g_print (_("WARNING: NULL key event reported."));
 904     }
 905
 906   keystroke->id        = (CORBA_long) event->keyval;
 907   keystroke->hw_code   = (CORBA_short) event->keycode;
 908   keystroke->timestamp = (CORBA_unsigned_long) event->timestamp;
 909   keystroke->modifiers = (CORBA_unsigned_short) (event->state & 0xFFFF);
 910   if (event->string)
 911     {
 912       gunichar c;
 913
 914       keystroke->event_string = CORBA_string_dup (event->string);
 915       c = g_utf8_get_char_validated (event->string, -1);
 916       if (c > 0 && g_unichar_isprint (c))
 917         keystroke->is_text = CORBA_TRUE;
 918       else
 919         keystroke->is_text = CORBA_FALSE;
 920     }
 921   else
 922     {
 923       keystroke->event_string = CORBA_string_dup ("");
 924       keystroke->is_text = CORBA_FALSE;
 925     }
 926   switch (event->type)
 927     {
 928     case (ATK_KEY_EVENT_PRESS):
 929       keystroke->type = Accessibility_KEY_PRESSED_EVENT;
 930       break;
 931     case (ATK_KEY_EVENT_RELEASE):
 932       keystroke->type = Accessibility_KEY_RELEASED_EVENT;
 933       break;
 934     default:
 935       keystroke->type = 0;
 936       break;
 937     }
 938 #if 0
 939   g_print ("key_event type %d; val=%d code=%d modifiers=%x name=%s is_text=%d, time=%lx\n",
 940            (int) keystroke->type, (int) keystroke->id, (int) keystroke->hw_code,
 941            (int) keystroke->modifiers,
 942            keystroke->event_string, (int) keystroke->is_text, (unsigned long) keystroke->timestamp);
 943 #endif
 944 }
 945
 946 static gint
 947 spi_atk_bridge_key_listener (AtkKeyEventStruct *event, gpointer data)
 948 {
 949   CORBA_boolean             result;
 950   Accessibility_DeviceEvent key_event;
 951
 952   CORBA_exception_init (&ev);
 953
 954   spi_init_keystroke_from_atk_key_event (&key_event, event);
 955
 956   result = Accessibility_DeviceEventController_notifyListenersSync (
 957           spi_atk_bridget_get_dec (), &key_event, &ev);
 958
 959   if (key_event.event_string) CORBA_free (key_event.event_string);
 960
 961   if (BONOBO_EX(&ev)) {
 962       result = FALSE;
 963       CORBA_exception_free (&ev);
 964   }
 965
 966   return result;
 967 }
 968
 969 static gboolean
 970 spi_atk_bridge_signal_listener (GSignalInvocationHint *signal_hint,
 971                                 guint n_param_values,
 972                                 const GValue *param_values,
 973                                 gpointer data)
 974 {
 975   GObject *gobject;
 976   GSignalQuery signal_query;
 977   const gchar *name;
 978   const gchar *detail;
 979   CORBA_any any;
 980   CORBA_Object c_obj;
 981   char *sp = NULL;
 982   AtkObject *ao;
 983   gint detail1 = 0, detail2 = 0;
 984   SpiAccessible *s_ao = NULL;
 985 #ifdef SPI_BRIDGE_DEBUG
 986   const gchar *s, *s2;
 987 #endif
 988
 989   g_signal_query (signal_hint->signal_id, &signal_query);
 990
 991   name = signal_query.signal_name;
 992   if (signal_hint->detail)
 993     detail = g_quark_to_string (signal_hint->detail);
 994   else
 995     detail = NULL;
 996
 997 #ifdef SPI_BRIDGE_DEBUG
 998   s2 = g_type_name (G_OBJECT_TYPE (g_value_get_object (param_values + 0)));
 999   s = atk_object_get_name (ATK_OBJECT (g_value_get_object (param_values + 0)));
1000   fprintf (stderr, "Received signal %s:%s detail: %s from object %s (gail %s)\n",
1001            g_type_name (signal_query.itype), name,
1002            detail ? detail : "<NULL>", s ? s : "<NULL>" , s2);
1003 #endif
1004
1005   gobject = g_value_get_object (param_values + 0);
1006
1007   if (signal_query.signal_id == atk_signal_active_descendant_changed)
1008     {
1009       gpointer child = g_value_get_pointer (param_values + 1);
1010
1011       g_return_val_if_fail (ATK_IS_OBJECT (child), TRUE);
1012
1013       ao = ATK_OBJECT (child);
1014
1015       detail1 = atk_object_get_index_in_parent (ao);
1016       s_ao = spi_accessible_new (ao);
1017       c_obj = BONOBO_OBJREF (s_ao);
1018       spi_atk_bridge_init_object (&any, ATK_OBJECT (gobject), &c_obj);
1019     }
1020   else if (signal_query.signal_id == atk_signal_link_selected)
1021     {
1022       if (G_VALUE_TYPE (param_values + 1) == G_TYPE_INT)
1023         detail1 = g_value_get_int (param_values + 1);
1024       spi_atk_bridge_init_nil (&any, ATK_OBJECT (gobject));
1025     }
1026   else if (signal_query.signal_id == atk_signal_bounds_changed)
1027     {
1028       AtkRectangle *atk_rect = NULL;
1029
1030       if (G_VALUE_HOLDS_BOXED (param_values + 1))
1031           atk_rect = g_value_get_boxed (param_values + 1);
1032       spi_atk_bridge_init_rect (&any, ATK_OBJECT (gobject), atk_rect);
1033     }
1034   else if ((signal_query.signal_id == atk_signal_children_changed) && gobject)
1035     {
1036       ao = atk_object_ref_accessible_child (ATK_OBJECT (gobject),
1037                                             detail1);
1038       if (ao)
1039         {
1040           s_ao = spi_accessible_new (ao);
1041           c_obj = BONOBO_OBJREF (s_ao);
1042           spi_atk_bridge_init_object (&any, ATK_OBJECT (gobject), &c_obj);
1043           g_object_unref (ao);
1044         }
1045       else
1046         {
1047           spi_atk_bridge_init_nil (&any, ATK_OBJECT (gobject));
1048         }
1049     }
1050   else
1051     {
1052       if (n_param_values >= 2)
1053         {
1054           if (G_VALUE_TYPE (param_values + 1) == G_TYPE_INT)
1055             detail1 = g_value_get_int (param_values + 1);
1056           if (n_param_values >= 3)
1057             {
1058               if (G_VALUE_TYPE (param_values + 2) == G_TYPE_INT)
1059                 detail2 = g_value_get_int (param_values + 2);
1060             }
1061         }
1062
1063       if (signal_query.signal_id == atk_signal_text_changed)
1064         {
1065           sp = atk_text_get_text (ATK_TEXT (gobject),
1066                                   detail1,
1067                                   detail1+detail2);
1068           spi_atk_bridge_init_string (&any, ATK_OBJECT (gobject),
1069                                       (gchar **) &sp);
1070         }
1071       else if (signal_query.signal_id == atk_signal_text_selection_changed)
1072         {
1073           /* Return NULL as the selected string */
1074           spi_atk_bridge_init_nil (&any, ATK_OBJECT (gobject));
1075         }
1076       else
1077         {
1078           spi_atk_bridge_init_nil (&any, ATK_OBJECT (gobject));
1079         }
1080     }
1081
1082   if (detail)
1083     spi_atk_emit_eventv (gobject, detail1, detail2, &any,
1084                          "object:%s:%s", name, detail);
1085   else
1086     spi_atk_emit_eventv (gobject, detail1, detail2, &any,
1087                          "object:%s", name);
1088
1089   if (sp)
1090     g_free (sp);
1091
1092   return TRUE;
1093 }
1094
1095 static gboolean
1096 spi_atk_bridge_window_event_listener (GSignalInvocationHint *signal_hint,
1097                                       guint n_param_values,
1098                                       const GValue *param_values,
1099                                       gpointer data)
1100 {
1101   GObject *gobject;
1102   GSignalQuery signal_query;
1103   CORBA_any any;
1104   const gchar *name, *s;
1105 #ifdef SPI_BRIDGE_DEBUG
1106   const gchar *s2;
1107 #endif
1108
1109   g_signal_query (signal_hint->signal_id, &signal_query);
1110
1111   name = signal_query.signal_name;
1112
1113 #ifdef SPI_BRIDGE_DEBUG
1114   s2 = g_type_name (G_OBJECT_TYPE (g_value_get_object (param_values + 0)));
1115   s = atk_object_get_name (ATK_OBJECT (g_value_get_object (param_values + 0)));
1116   fprintf (stderr, "Received signal %s:%s from object %s (gail %s)\n",
1117            g_type_name (signal_query.itype), name, s ? s : "<NULL>" , s2);
1118 #endif
1119
1120   gobject = g_value_get_object (param_values + 0);
1121
1122   s = atk_object_get_name (ATK_OBJECT (gobject));
1123   spi_atk_bridge_init_string (&any, ATK_OBJECT (gobject), (gchar **) &s);
1124
1125   spi_atk_emit_eventv (gobject, 0, 0, &any,
1126                        "window:%s", name);
1127   return TRUE;
1128 }
1129
1130 static void
1131 spi_atk_tidy_windows (void)
1132 {
1133   AtkObject *root;
1134   gint n_children;
1135   gint i;
1136
1137   root = atk_get_root ();
1138   n_children = atk_object_get_n_accessible_children (root);
1139   for (i = 0; i < n_children; i++)
1140     {
1141       AtkObject *child;
1142       AtkStateSet *stateset;
1143       CORBA_any any;
1144       const gchar *name;
1145
1146       child = atk_object_ref_accessible_child (root, i);
1147       stateset = atk_object_ref_state_set (child);
1148
1149       name = atk_object_get_name (child);
1150       spi_atk_bridge_init_string (&any, child, (gchar**) &name);
1151       if (atk_state_set_contains_state (stateset, ATK_STATE_ACTIVE))
1152         {
1153           spi_atk_emit_eventv (G_OBJECT (child), 0, 0, &any, "window:deactivate");
1154           if (registry_died)
1155             return;
1156         }
1157       g_object_unref (stateset);
1158
1159       spi_atk_emit_eventv (G_OBJECT (child), 0, 0, &any, "window:destroy");
1160       g_object_unref (child);
1161     }
1162 }
1163
1164 static void
1165 reinit_register_vars (void)
1166 {
1167   registry = CORBA_OBJECT_NIL;
1168   device_event_controller = CORBA_OBJECT_NIL;
1169   this_app = NULL;
1170 }
1171
1172 static void
1173 spi_atk_bridge_init_base (CORBA_any *any, AtkObject *obj,
1174                           Accessibility_Application *app, Accessibility_Role *role,
1175                           CORBA_string *name)
1176 {
1177     const gchar *s = atk_object_get_name (obj);
1178     *app = spi_accessible_new_return (atk_get_root (), FALSE, NULL);
1179     *role = spi_role_from_atk_role (atk_object_get_role (obj));
1180     *name = s ? s : ""; /* string gets dup-ed in util.c spi_init_any_* */
1181 }
1182
1183 static void
1184 spi_atk_bridge_init_nil  (CORBA_any *any, AtkObject *obj)
1185 {
1186     Accessibility_Application app = CORBA_OBJECT_NIL;
1187     Accessibility_Role role = Accessibility_ROLE_UNKNOWN;
1188     CORBA_string name;
1189     spi_atk_bridge_init_base (any, obj, &app, &role, &name);
1190     spi_init_any_nil (any, app, role, name);
1191 }
1192
1193 static void
1194 spi_atk_bridge_init_object (CORBA_any *any, AtkObject *obj, CORBA_Object *c_obj)
1195 {
1196     Accessibility_Application app = CORBA_OBJECT_NIL;
1197     Accessibility_Role role = Accessibility_ROLE_UNKNOWN;
1198     CORBA_string name;
1199     spi_atk_bridge_init_base (any, obj, &app, &role, &name);
1200     spi_init_any_object (any, app, role, name, c_obj);
1201 }
1202
1203 static void
1204 spi_atk_bridge_init_string (CORBA_any *any, AtkObject *obj, gchar **string)
1205 {
1206     Accessibility_Application app = CORBA_OBJECT_NIL;
1207     Accessibility_Role role = Accessibility_ROLE_UNKNOWN;
1208     CORBA_string name;
1209     spi_atk_bridge_init_base (any, obj, &app, &role, &name);
1210     spi_init_any_string (any, app, role, name, string);
1211 }
1212
1213 static void
1214 spi_atk_bridge_init_rect (CORBA_any *any, AtkObject *obj, AtkRectangle *rect)
1215 {
1216     Accessibility_Application app = CORBA_OBJECT_NIL;
1217     Accessibility_Role role = Accessibility_ROLE_UNKNOWN;
1218     CORBA_string name;
1219     spi_atk_bridge_init_base (any, obj, &app, &role, &name);
1220     spi_init_any_rect (any, app, role, name, rect);
1221 }
1222