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 Sun Microsystems Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <stdarg.h>
  26 #include <libbonobo.h>
  27 #include <orbit/orbit.h>
  28 #include <atk/atk.h>
  29 #include <atk/atkobject.h>
  30 #include <atk/atknoopobject.h>
  31 #include <libspi/Accessibility.h>
  32 #include "accessible.h"
  33 #include "application.h"
  34
  35 #include <bonobo-activation/bonobo-activation-register.h>
  36
  37 #undef SPI_BRIDGE_DEBUG
  38
  39 static CORBA_Environment ev;
  40 static Accessibility_Registry registry;
  41 static SpiApplication *this_app = NULL;
  42
  43 static void     spi_atk_bridge_exit_func               (void);
  44 static void     spi_atk_register_event_listeners       (void);
  45 static gboolean spi_atk_bridge_idle_init               (gpointer               user_data);
  46 static void     spi_atk_bridge_focus_tracker           (AtkObject             *object);
  47 static gboolean spi_atk_bridge_property_event_listener (GSignalInvocationHint *signal_hint,
  48                                                         guint                  n_param_values,
  49                                                         const GValue          *param_values,
  50                                                         gpointer               data);
  51 static gboolean spi_atk_bridge_signal_listener         (GSignalInvocationHint *signal_hint,
  52                                                         guint                  n_param_values,
  53                                                         const GValue          *param_values,
  54                                                         gpointer               data);
  55 static gint     spi_atk_bridge_key_listener            (AtkKeyEventStruct     *event,
  56                                                         gpointer               data);
  57
  58 /* For automatic libgnome init */
  59 extern void gnome_accessibility_module_init     (void);
  60 extern void gnome_accessibility_module_shutdown (void);
  61
  62 static int     atk_bridge_initialized = FALSE;
  63 static guint   atk_bridge_focus_tracker_id = 0;
  64 static guint   atk_bridge_key_event_listener_id = 0;
  65 static guint   idle_init_id = 0;
  66 static GArray *listener_ids = NULL;
  67
  68 /*
  69  *   These exported symbols are hooked by gnome-program
  70  * to provide automatic module initialization and shutdown.
  71  */
  72 extern void gnome_accessibility_module_init     (void);
  73 extern void gnome_accessibility_module_shutdown (void);
  74
  75 static int
  76 atk_bridge_init (gint *argc, gchar **argv[])
  77 {
  78   CORBA_Environment ev;
  79
  80   if (atk_bridge_initialized)
  81     {
  82       return 0;
  83     }
  84   atk_bridge_initialized = TRUE;
  85
  86   if (!bonobo_init (argc, argv ? *argv : NULL))
  87     {
  88       g_error ("Could not initialize Bonobo");
  89     }
  90
  91   /*
  92    *   We only want to enable the bridge for top level
  93    * applications, we detect bonobo components by seeing
  94    * if they were activated with the intention of extracting
  95    * an impl. by IID - very solid.
  96    */
  97   if (bonobo_activation_iid_get ())
  98           return 0;
  99
 100   CORBA_exception_init(&ev);
 101
 102   registry = bonobo_activation_activate_from_id (
 103           "OAFIID:Accessibility_Registry:proto0.1", 0, NULL, &ev);
 104
 105   if (ev._major != CORBA_NO_EXCEPTION)
 106     {
 107       g_error ("Accessibility app error: exception during "
 108                "registry activation from id: %s\n",
 109                CORBA_exception_id (&ev));
 110       CORBA_exception_free (&ev);
 111     }
 112
 113   if (registry == CORBA_OBJECT_NIL)
 114     {
 115       g_error ("Could not locate registry");
 116     }
 117
 118   bonobo_activate ();
 119
 120   /* Create the accessible application server object */
 121
 122   this_app = spi_application_new (atk_get_root ());
 123
 124   fprintf (stderr, "About to register application\n");
 125
 126   Accessibility_Registry_registerApplication (registry,
 127                                               BONOBO_OBJREF (this_app),
 128                                               &ev);
 129
 130   g_atexit (spi_atk_bridge_exit_func);
 131
 132   idle_init_id = g_idle_add (spi_atk_bridge_idle_init, NULL);
 133
 134   return 0;
 135 }
 136
 137 int
 138 gtk_module_init (gint *argc, gchar **argv[])
 139 {
 140         return atk_bridge_init (argc, argv);
 141 }
 142
 143 static gboolean
 144 spi_atk_bridge_idle_init (gpointer user_data)
 145 {
 146   idle_init_id = 0;
 147
 148   spi_atk_register_event_listeners ();
 149
 150   fprintf (stderr, "Application registered & listening\n");
 151
 152   return FALSE;
 153 }
 154
 155 static void
 156 add_signal_listener (const char *signal_name)
 157 {
 158   guint id;
 159
 160   id = atk_add_global_event_listener (
 161     spi_atk_bridge_signal_listener, signal_name);
 162
 163   g_array_append_val (listener_ids, id);
 164 }
 165
 166 static void
 167 spi_atk_register_event_listeners (void)
 168 {
 169   /*
 170    * kludge to make sure the Atk interface types are registered, otherwise
 171    * the AtkText signal handlers below won't get registered
 172    */
 173   guint      id;
 174   GObject   *ao = g_object_new (ATK_TYPE_OBJECT, NULL);
 175   AtkObject *bo = atk_no_op_object_new (ao);
 176
 177   /* Register for focus event notifications, and register app with central registry  */
 178
 179   listener_ids = g_array_sized_new (FALSE, TRUE, sizeof (guint), 16);
 180
 181   atk_bridge_focus_tracker_id = atk_add_focus_tracker (spi_atk_bridge_focus_tracker);
 182
 183   id = atk_add_global_event_listener (spi_atk_bridge_property_event_listener,
 184                                       "Gtk:AtkObject:property-change");
 185   g_array_append_val (listener_ids, id);
 186
 187   add_signal_listener ("Gtk:AtkObject:children-changed");
 188   add_signal_listener ("Gtk:AtkObject:visible-data-changed");
 189   add_signal_listener ("Gtk:AtkSelection:selection-changed");
 190   add_signal_listener ("Gtk:AtkText:text-selection-changed");
 191   add_signal_listener ("Gtk:AtkText:text-changed");
 192   add_signal_listener ("Gtk:AtkText:text-caret-moved");
 193   add_signal_listener ("Gtk:AtkTable:row-inserted");
 194   add_signal_listener ("Gtk:AtkTable:row-reordered");
 195   add_signal_listener ("Gtk:AtkTable:row-deleted");
 196   add_signal_listener ("Gtk:AtkTable:column-inserted");
 197   add_signal_listener ("Gtk:AtkTable:column-reordered");
 198   add_signal_listener ("Gtk:AtkTable:column-deleted");
 199   add_signal_listener ("Gtk:AtkTable:model-changed");
 200 /*
 201  * May add the following listeners to implement preemptive key listening for GTK+
 202  *
 203  * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-press-event");
 204  * atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-release-event");
 205  */
 206   atk_bridge_key_event_listener_id = atk_add_key_event_listener (
 207     spi_atk_bridge_key_listener, NULL);
 208
 209   g_object_unref (G_OBJECT (bo));
 210   g_object_unref (ao);
 211 }
 212
 213 static void
 214 deregister_application (BonoboObject *app)
 215 {
 216   Accessibility_Registry_deregisterApplication (
 217           registry, BONOBO_OBJREF (app), &ev);
 218
 219   registry = bonobo_object_release_unref (registry, &ev);
 220
 221   app = bonobo_object_unref (app);
 222 }
 223
 224 static void
 225 spi_atk_bridge_exit_func (void)
 226 {
 227   BonoboObject *app = (BonoboObject *) this_app;
 228
 229   fprintf (stderr, "exiting bridge\n");
 230
 231   if (!app)
 232     {
 233       return;
 234     }
 235   this_app = NULL;
 236
 237   /*
 238    *  FIXME: this may be incorrect for apps that do their own bonobo
 239    *  shutdown, until we can explicitly shutdown to get the ordering
 240    *  right.
 241    */
 242   if (!bonobo_is_initialized ())
 243     {
 244       fprintf (stderr, "Re-initializing bonobo\n");
 245       g_assert (bonobo_init (0, NULL));
 246       g_assert (bonobo_activate ());
 247     }
 248
 249   deregister_application (app);
 250
 251   fprintf (stderr, "bridge exit func complete.\n");
 252
 253   if (g_getenv ("AT_BRIDGE_SHUTDOWN"))
 254     {
 255       g_assert (!bonobo_debug_shutdown ());
 256     }
 257 }
 258
 259 void
 260 gnome_accessibility_module_init (void)
 261 {
 262   atk_bridge_init (NULL, NULL);
 263
 264   g_print("Atk Accessibilty bridge initialized\n");
 265 }
 266
 267 void
 268 gnome_accessibility_module_shutdown (void)
 269 {
 270   BonoboObject *app = (BonoboObject *) this_app;
 271
 272   if (!atk_bridge_initialized)
 273     {
 274       return;
 275     }
 276   atk_bridge_initialized = FALSE;
 277   this_app = NULL;
 278
 279   g_print("Atk Accessibilty bridge shutdown\n");
 280
 281   if (idle_init_id)
 282     {
 283       g_source_remove (idle_init_id);
 284       idle_init_id = 0;
 285     }
 286   else
 287     {
 288       int     i;
 289       GArray *ids = listener_ids;
 290
 291       listener_ids = NULL;
 292       atk_remove_focus_tracker (atk_bridge_focus_tracker_id);
 293
 294       for (i = 0; ids && i < ids->len; i++)
 295         {
 296           atk_remove_global_event_listener (g_array_index (ids, guint, i));
 297         }
 298
 299       atk_remove_key_event_listener (atk_bridge_key_event_listener_id);
 300     }
 301
 302   deregister_application (app);
 303 }
 304
 305 static void
 306 spi_atk_bridge_focus_tracker (AtkObject *object)
 307 {
 308   SpiAccessible *source;
 309   Accessibility_Event e;
 310
 311   source = spi_accessible_new (object);
 312
 313   e.type = "focus:";
 314   e.source = BONOBO_OBJREF (source);
 315   e.detail1 = 0;
 316   e.detail2 = 0;
 317
 318   Accessibility_Registry_notifyEvent (registry, &e, &ev);
 319
 320   CORBA_exception_free (&ev);
 321 }
 322
 323 static void
 324 spi_atk_emit_eventv (GObject      *gobject,
 325                      unsigned long detail1,
 326                      unsigned long detail2,
 327                      const char   *format, ...)
 328 {
 329   va_list             args;
 330   Accessibility_Event e;
 331   SpiAccessible      *source;
 332   AtkObject          *aobject;
 333 #ifdef SPI_BRIDGE_DEBUG
 334   CORBA_string s;
 335 #endif
 336
 337   va_start (args, format);
 338
 339   if (ATK_IS_IMPLEMENTOR (gobject))
 340     {
 341       aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 342       source  = spi_accessible_new (aobject);
 343       g_object_unref (G_OBJECT (aobject));
 344     }
 345   else if (ATK_IS_OBJECT (gobject))
 346     {
 347       aobject = ATK_OBJECT (gobject);
 348       source  = spi_accessible_new (aobject);
 349     }
 350   else
 351     {
 352       aobject = NULL;
 353       source  = NULL;
 354       g_error ("received property-change event from non-AtkImplementor");
 355     }
 356
 357   if (source != NULL)
 358     {
 359       e.type = g_strdup_vprintf (format, args);
 360       e.source = BONOBO_OBJREF (source);
 361       e.detail1 = detail1;
 362       e.detail2 = detail2;
 363
 364 #ifdef SPI_BRIDGE_DEBUG
 365       s = Accessibility_Accessible__get_name (BONOBO_OBJREF (source), &ev);
 366       g_warning ("Emitting event '%s' (%lu, %lu) on %s",
 367                  e.type, e.detail1, e.detail2, s);
 368       CORBA_free (s);
 369 #endif
 370
 371       Accessibility_Registry_notifyEvent (registry, &e, &ev);
 372
 373       CORBA_exception_free (&ev);
 374
 375       g_free (e.type);
 376     }
 377
 378   va_end (args);
 379 }
 380
 381 static gboolean
 382 spi_atk_bridge_property_event_listener (GSignalInvocationHint *signal_hint,
 383                                         guint n_param_values,
 384                                         const GValue *param_values,
 385                                         gpointer data)
 386 {
 387   AtkPropertyValues *values;
 388   GObject *gobject;
 389
 390 #ifdef SPI_BRIDGE_DEBUG
 391   GSignalQuery signal_query;
 392   const gchar *name;
 393   gchar *s, *s2;
 394
 395   g_signal_query (signal_hint->signal_id, &signal_query);
 396   name = signal_query.signal_name;
 397
 398   s2 = g_type_name (G_OBJECT_TYPE (g_value_get_object (param_values + 0)));
 399   s = atk_object_get_name (ATK_OBJECT (g_value_get_object (param_values + 0)));
 400   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 401   fprintf (stderr, "Received (property) signal %s:%s:%s from object %s (gail %s)\n",
 402            g_type_name (signal_query.itype), name, values->property_name, s, s2);
 403
 404 #endif
 405
 406   gobject = g_value_get_object (param_values + 0);
 407   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 408
 409   spi_atk_emit_eventv (gobject, 0, 0, "object:property-change:%s", values->property_name);
 410
 411   return TRUE;
 412 }
 413
 414 #if THIS_WILL_EVER_BE_USED
 415 static gboolean
 416 spi_atk_bridge_state_event_listener (GSignalInvocationHint *signal_hint,
 417                                      guint n_param_values,
 418                                      const GValue *param_values,
 419                                      gpointer data)
 420 {
 421   GObject *gobject;
 422   AtkPropertyValues *values;
 423 #ifdef SPI_BRIDGE_DEBUG
 424   GSignalQuery signal_query;
 425   const gchar *name;
 426
 427   g_signal_query (signal_hint->signal_id, &signal_query);
 428   name = signal_query.signal_name;
 429   fprintf (stderr, "Received (state) signal %s:%s\n",
 430            g_type_name (signal_query.itype), name);
 431 #endif
 432
 433   gobject = g_value_get_object (param_values + 0);
 434   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 435
 436   spi_atk_emit_eventv (gobject,
 437                        (unsigned long) values->old_value.data[0].v_ulong,
 438                        (unsigned long) values->new_value.data[0].v_ulong,
 439                        "object:%s:?", values->property_name);
 440
 441   return TRUE;
 442 }
 443 #endif
 444
 445 static void
 446 spi_init_keystroke_from_atk_key_event (Accessibility_DeviceEvent  *keystroke,
 447                                        AtkKeyEventStruct          *event)
 448 {
 449 #ifdef SPI_DEBUG
 450   if (event)
 451     {
 452       g_print ("event %c (%d)\n", (int) event->keyval, (int) event->keycode);
 453     }
 454   else
 455 #endif
 456   if (!event)
 457     {
 458       g_print ("WARNING: NULL key event!");
 459     }
 460
 461   keystroke->id        = (CORBA_long) event->keyval;
 462   keystroke->hw_code   = (CORBA_short) event->keycode;
 463   keystroke->timestamp = (CORBA_unsigned_long) event->timestamp;
 464   keystroke->modifiers = (CORBA_unsigned_short) (event->state & 0xFFFF);
 465   if (event->string)
 466     {
 467       keystroke->event_string = CORBA_string_dup (event->string);
 468       keystroke->is_text = CORBA_TRUE;
 469     }
 470   else
 471     {
 472       keystroke->event_string = CORBA_string_dup ("");
 473       keystroke->is_text = CORBA_FALSE;
 474     }
 475   switch (event->type)
 476     {
 477     case (ATK_KEY_EVENT_PRESS):
 478       keystroke->type = Accessibility_KEY_PRESSED;
 479       break;
 480     case (ATK_KEY_EVENT_RELEASE):
 481       keystroke->type = Accessibility_KEY_RELEASED;
 482       break;
 483     default:
 484       keystroke->type = 0;
 485       break;
 486     }
 487 #if 0
 488   g_print ("key_event type %d; val=%d code=%d modifiers=%x name=%s is_text=%d, time=%lx\n",
 489            (int) keystroke->type, (int) keystroke->id, (int) keystroke->hw_code,
 490            (int) keystroke->modifiers,
 491            keystroke->event_string, (int) keystroke->is_text, (unsigned long) keystroke->timestamp);
 492 #endif
 493 }
 494
 495 static gint
 496 spi_atk_bridge_key_listener (AtkKeyEventStruct *event, gpointer data)
 497 {
 498   CORBA_boolean             result;
 499   Accessibility_DeviceEvent key_event;
 500   Accessibility_DeviceEventController controller =
 501     Accessibility_Registry_getDeviceEventController (registry, &ev);
 502
 503   if (BONOBO_EX (&ev))
 504     {
 505       g_warning ("failure: no deviceeventcontroller found\n");
 506       CORBA_exception_free (&ev);
 507       result = FALSE;
 508     }
 509   else
 510     {
 511
 512       spi_init_keystroke_from_atk_key_event (&key_event, event);
 513
 514       result = Accessibility_DeviceEventController_notifyListenersSync (
 515         controller, &key_event, &ev);
 516
 517       CORBA_exception_free (&ev);
 518     }
 519
 520   return result;
 521 }
 522
 523 static gboolean
 524 spi_atk_bridge_signal_listener (GSignalInvocationHint *signal_hint,
 525                                 guint n_param_values,
 526                                 const GValue *param_values,
 527                                 gpointer data)
 528 {
 529   GObject *gobject;
 530   GSignalQuery signal_query;
 531   const gchar *name;
 532   gint detail1 = 0, detail2 = 0;
 533 #ifdef SPI_BRIDGE_DEBUG
 534   gchar *s, *s2;
 535 #endif
 536
 537   g_signal_query (signal_hint->signal_id, &signal_query);
 538
 539   name = signal_query.signal_name;
 540
 541 #ifdef SPI_BRIDGE_DEBUG
 542   s2 = g_type_name (G_OBJECT_TYPE (g_value_get_object (param_values + 0)));
 543   s = atk_object_get_name (ATK_OBJECT (g_value_get_object (param_values + 0)));
 544   fprintf (stderr, "Received signal %s:%s from object %s (gail %s)\n",
 545            g_type_name (signal_query.itype), name, s, s2);
 546 #endif
 547
 548   gobject = g_value_get_object (param_values + 0);
 549   if (G_VALUE_TYPE (param_values + 1) == G_TYPE_INT)
 550     detail1 = g_value_get_int (param_values + 1);
 551   if (G_VALUE_TYPE (param_values + 2) == G_TYPE_INT)
 552     detail2 = g_value_get_int (param_values + 2);
 553
 554   spi_atk_emit_eventv (gobject, detail1, detail2, "object:%s", name);
 555
 556   return TRUE;
 557 }