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 <libbonobo.h>
  26 #include <orbit/orbit.h>
  27 #include <atk/atk.h>
  28 #include <atk/atkobject.h>
  29 #include <atk/atknoopobject.h>
  30 #include <libspi/Accessibility.h>
  31 #include "accessible.h"
  32 #include "application.h"
  33
  34 /* #define SPI_BRIDGE_DEBUG 1 */
  35
  36 #define APP_STATIC_BUFF_SZ 64
  37
  38 typedef struct _ArgStruct ArgStruct;
  39
  40 struct _ArgStruct {
  41   gint c;
  42   char **v;
  43 };
  44
  45 static CORBA_Environment ev;
  46 static Accessibility_Registry registry;
  47 static SpiApplication *this_app;
  48
  49 static gboolean bridge_register_app (gpointer p);
  50 static void bridge_focus_tracker (AtkObject *object);
  51 static void bridge_exit_func(void);
  52 static gboolean bridge_register_event_listener ();
  53 static void register_atk_event_listeners();
  54 static gboolean bridge_property_event_listener (GSignalInvocationHint *signal_hint,
  55                                                 guint n_param_values,
  56                                                 const GValue *param_values,
  57                                                 gpointer data);
  58 static gboolean bridge_state_event_listener (GSignalInvocationHint *signal_hint,
  59                                              guint n_param_values,
  60                                              const GValue *param_values,
  61                                              gpointer data);
  62 static gboolean bridge_signal_listener (GSignalInvocationHint *signal_hint,
  63                                         guint n_param_values,
  64                                         const GValue *param_values,
  65                                         gpointer data);
  66
  67 static gint bridge_key_listener (AtkKeyEventStruct *event,
  68                                  gpointer data);
  69
  70 int
  71 gtk_module_init(gint *argc, gchar **argv[])
  72 {
  73   ArgStruct *args = (ArgStruct *) g_new0(ArgStruct, 1);
  74   args->c = *argc;
  75   args->v = *argv;
  76   bridge_register_app (args);
  77   g_atexit (bridge_exit_func);
  78 }
  79
  80 static gboolean
  81 bridge_register_app (gpointer gp)
  82 {
  83   CORBA_Object oclient;
  84   AtkObject *atko;
  85   char *obj_id;
  86   ArgStruct *args = (ArgStruct *)gp;
  87
  88   CORBA_exception_init(&ev);
  89
  90   if (!bonobo_init (&(args->c), args->v))
  91     {
  92       g_error ("Could not initialize Bonobo");
  93     }
  94
  95   /* Create the accesssible application server object */
  96   this_app = spi_application_new(atk_get_root ());
  97
  98   obj_id = "OAFIID:Accessibility_Registry:proto0.1";
  99
 100   oclient = bonobo_activation_activate_from_id (obj_id, 0, NULL, &ev);
 101   if (ev._major != CORBA_NO_EXCEPTION) {
 102     fprintf(stderr,
 103             ("Accessibility app error: exception during registry activation from id: %s\n"),
 104             CORBA_exception_id(&ev));
 105     CORBA_exception_free(&ev);
 106   }
 107
 108   if (CORBA_Object_is_nil (oclient, &ev))
 109     {
 110       g_error ("Could not locate registry");
 111     }
 112
 113   registry = (Accessibility_Registry) oclient;
 114
 115   fprintf(stderr, "About to register application\n");
 116
 117   Accessibility_Registry_ref (registry, &ev);
 118
 119   bonobo_activate ();
 120
 121   Accessibility_Registry_registerApplication (registry,
 122                                               CORBA_Object_duplicate (BONOBO_OBJREF (this_app), &ev),
 123                                               &ev);
 124
 125   register_atk_event_listeners ();
 126
 127   return FALSE;
 128 }
 129
 130 static void
 131 register_atk_event_listeners ()
 132 {
 133   GType t;
 134
 135   /*
 136    * kludge to make sure the Atk interface types are registered, otherwise
 137    * the AtkText signal handlers below won't get registered
 138    */
 139
 140   AtkObject *o = atk_no_op_object_new (g_object_new (ATK_TYPE_OBJECT, NULL));
 141
 142   /* Register for focus event notifications, and register app with central registry  */
 143
 144   atk_add_focus_tracker (bridge_focus_tracker);
 145   atk_add_global_event_listener (bridge_property_event_listener, "Gtk:AtkObject:property-change");
 146   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkObject:children-changed");
 147   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkObject:visible-data-changed");
 148   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkSelection:selection-changed");
 149   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkText:text-selection-changed");
 150   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkText:text-changed");
 151   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkText:text-caret-moved");
 152   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:row-inserted");
 153   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:row-reordered");
 154   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:row-deleted");
 155   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:column-inserted");
 156   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:column-reordered");
 157   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:column-deleted");
 158   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:model-changed");
 159   atk_add_key_event_listener    (bridge_key_listener, NULL);
 160 }
 161
 162 static void bridge_exit_func()
 163 {
 164   fprintf (stderr, "exiting bridge\n");
 165   Accessibility_Registry_deregisterApplication (registry,
 166                                                 CORBA_Object_duplicate (BONOBO_OBJREF (this_app), &ev),
 167                                                 &ev);
 168   Accessibility_Registry_unref (registry, &ev);
 169
 170   fprintf (stderr, "bridge exit func complete.\n");
 171 }
 172
 173 static void bridge_focus_tracker (AtkObject *object)
 174 {
 175   Accessibility_Event *e = Accessibility_Event__alloc();
 176   e->type = CORBA_string_dup ("focus:");
 177   e->source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (object)), &ev);
 178   e->detail1 = 0;
 179   e->detail2 = 0;
 180   Accessibility_Registry_notifyEvent (registry, e, &ev);
 181 }
 182
 183 static gboolean
 184 bridge_property_event_listener (GSignalInvocationHint *signal_hint,
 185                                 guint n_param_values,
 186                                 const GValue *param_values,
 187                                 gpointer data)
 188 {
 189   Accessibility_Event *e = Accessibility_Event__alloc();
 190   Bonobo_Unknown source = NULL;
 191   AtkObject *aobject;
 192   AtkPropertyValues *values;
 193   GObject *gobject;
 194   GSignalQuery signal_query;
 195   gchar *name;
 196   char sbuf[APP_STATIC_BUFF_SZ];
 197
 198   g_signal_query (signal_hint->signal_id, &signal_query);
 199   name = signal_query.signal_name;
 200 #ifdef SPI_BRIDGE_DEBUG
 201   fprintf (stderr, "Received (property) signal %s:%s\n",
 202            g_type_name (signal_query.itype), name);
 203 #endif
 204   gobject = g_value_get_object (param_values + 0);
 205   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 206
 207   /* notify the actual listeners */
 208   if (ATK_IS_IMPLEMENTOR (gobject))
 209   {
 210     aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 211     source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 212     g_object_unref (G_OBJECT(aobject));
 213   }
 214   else if (ATK_IS_OBJECT (gobject))
 215   {
 216     aobject = ATK_OBJECT (gobject);
 217     source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 218   }
 219   else
 220   {
 221     g_error("received property-change event from non-AtkImplementor");
 222   }
 223
 224   snprintf(sbuf, APP_STATIC_BUFF_SZ, "object:property-change:%s", values->property_name);
 225   e->type = CORBA_string_dup (sbuf);
 226   e->source = source;
 227   e->detail1 = 0;
 228   e->detail2 = 0;
 229   if (source)
 230     Accessibility_Registry_notifyEvent (registry, e, &ev);
 231   return TRUE;
 232 }
 233
 234 static gboolean
 235 bridge_state_event_listener (GSignalInvocationHint *signal_hint,
 236                              guint n_param_values,
 237                              const GValue *param_values,
 238                              gpointer data)
 239 {
 240   Accessibility_Event *e = Accessibility_Event__alloc();
 241   Bonobo_Unknown source = NULL;
 242   AtkObject *aobject;
 243   AtkPropertyValues *values;
 244   GObject *gobject;
 245   GSignalQuery signal_query;
 246   gchar *name;
 247   char sbuf[APP_STATIC_BUFF_SZ];
 248
 249   g_signal_query (signal_hint->signal_id, &signal_query);
 250   name = signal_query.signal_name;
 251 #ifdef SPI_BRIDGE_DEBUG
 252   fprintf (stderr, "Received (state) signal %s:%s\n",
 253            g_type_name (signal_query.itype), name);
 254 #endif
 255   gobject = g_value_get_object (param_values + 0);
 256   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 257
 258   /* notify the actual listeners */
 259   if (ATK_IS_IMPLEMENTOR (gobject))
 260   {
 261     aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 262     source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 263     g_object_unref (G_OBJECT(aobject));
 264   }
 265   else if (ATK_IS_OBJECT (gobject))
 266   {
 267     aobject = ATK_OBJECT (gobject);
 268     source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 269   }
 270   else
 271   {
 272     g_error("received property-change event from non-AtkImplementor");
 273   }
 274
 275   snprintf(sbuf, APP_STATIC_BUFF_SZ, "object:%s:%s", values->property_name, "?");
 276   e->type = CORBA_string_dup (sbuf);
 277   e->source = source;
 278   e->detail1 = (unsigned long) values->old_value.data[0].v_ulong;
 279   e->detail2 = (unsigned long) values->new_value.data[0].v_ulong;
 280   if (source)
 281     Accessibility_Registry_notifyEvent (registry, e, &ev);
 282   return TRUE;
 283 }
 284
 285 static Accessibility_KeyStroke *
 286 accessibility_keystroke_from_atk_key_event (AtkKeyEventStruct *event)
 287 {
 288   Accessibility_KeyStroke *keystroke;
 289   keystroke = Accessibility_KeyStroke__alloc ();
 290
 291 #ifdef SPI_DEBUG
 292   if (event) g_print ("event %c (%d)\n", (int) event->keyval, (int) event->keycode);
 293   else
 294 #endif
 295   if (!event) g_print ("WARNING: NULL key event!");
 296
 297   keystroke->keyID = (CORBA_long) event->keyval;
 298   keystroke->keycode = (CORBA_short) event->keycode;
 299   keystroke->timestamp = (CORBA_unsigned_long) event->timestamp;
 300   keystroke->modifiers = (CORBA_unsigned_short) (event->state & 0xFFFF);
 301
 302   switch (event->type)
 303     {
 304     case (ATK_KEY_EVENT_PRESS):
 305             keystroke->type = Accessibility_KEY_PRESSED;
 306             break;
 307     case (ATK_KEY_EVENT_RELEASE):
 308             keystroke->type = Accessibility_KEY_RELEASED;
 309             break;
 310     default:
 311     }
 312
 313   return keystroke;
 314 }
 315
 316 static gint
 317 bridge_key_listener (AtkKeyEventStruct *event, gpointer data)
 318 {
 319   Accessibility_KeyStroke *key_event = accessibility_keystroke_from_atk_key_event (event);
 320   CORBA_boolean result;
 321   Accessibility_DeviceEventController controller =
 322           Accessibility_Registry_getDeviceEventController (registry, &ev);
 323   result = Accessibility_DeviceEventController_notifyListenersSync (controller,
 324                                                                     (Accessibility_DeviceEvent *) key_event,
 325                                                                     &ev);
 326 }
 327
 328 static gboolean
 329 bridge_signal_listener (GSignalInvocationHint *signal_hint,
 330                         guint n_param_values,
 331                         const GValue *param_values,
 332                         gpointer data)
 333 {
 334   Accessibility_Event *e = g_new0(Accessibility_Event, 1);
 335   AtkObject *aobject;
 336   Bonobo_Unknown source;
 337   AtkPropertyValues *values;
 338   GObject *gobject;
 339   GSignalQuery signal_query;
 340   gchar *name;
 341   char sbuf[APP_STATIC_BUFF_SZ];
 342
 343   g_signal_query (signal_hint->signal_id, &signal_query);
 344   name = signal_query.signal_name;
 345 #ifdef SPI_BRIDGE_DEBUG
 346   fprintf (stderr, "Received signal %s:%s\n",
 347            g_type_name (signal_query.itype), name);
 348 #endif
 349   gobject = g_value_get_object (param_values + 0);
 350
 351   /* notify the actual listeners */
 352   if (ATK_IS_IMPLEMENTOR (gobject))
 353   {
 354     aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 355   }
 356   else if (ATK_IS_OBJECT (gobject))
 357   {
 358     aobject = ATK_OBJECT (gobject);
 359     g_object_ref (aobject);
 360   }
 361   else
 362   {
 363     g_error("received property-change event from non-AtkImplementor");
 364   }
 365
 366   snprintf(sbuf, APP_STATIC_BUFF_SZ, "%s:%s", name, g_type_name (signal_query.itype));
 367   source =  CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 368   e->type = CORBA_string_dup (sbuf);
 369   e->source = source;
 370   e->detail1 = 0;
 371   e->detail2 = 0;
 372   Accessibility_Registry_notifyEvent (registry, e, &ev);
 373   g_object_unref (aobject);
 374   return TRUE;
 375 }
 376
 377 static Accessibility_Registry bridge_get_registry ()
 378 {
 379   return registry;
 380 }