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   g_idle_add (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     exit(-1);
 107   }
 108
 109   if (CORBA_Object_is_nil (oclient, &ev))
 110     {
 111       g_error ("Could not locate registry");
 112     }
 113
 114   registry = (Accessibility_Registry) oclient;
 115
 116   fprintf(stderr, "About to register application\n");
 117
 118   bonobo_activate ();
 119
 120   Accessibility_Registry_registerApplication (registry,
 121                                               CORBA_Object_duplicate (BONOBO_OBJREF (this_app), &ev),
 122                                               &ev);
 123
 124   register_atk_event_listeners ();
 125
 126   return FALSE;
 127 }
 128
 129 static void
 130 register_atk_event_listeners ()
 131 {
 132   GType t;
 133
 134   /*
 135    * kludge to make sure the Atk interface types are registered, otherwise
 136    * the AtkText signal handlers below won't get registered
 137    */
 138
 139   AtkObject *o = atk_no_op_object_new (g_object_new (ATK_TYPE_OBJECT, NULL));
 140
 141   /* Register for focus event notifications, and register app with central registry  */
 142
 143   atk_add_focus_tracker (bridge_focus_tracker);
 144   atk_add_global_event_listener (bridge_property_event_listener, "Gtk:AtkObject:property-change");
 145   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkObject:children-changed");
 146   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkObject:visible-data-changed");
 147   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkSelection:selection-changed");
 148   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkText:text-selection-changed");
 149   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkText:text-changed");
 150   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkText:text-caret-moved");
 151   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:row-inserted");
 152   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:row-reordered");
 153   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:row-deleted");
 154   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:column-inserted");
 155   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:column-reordered");
 156   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:column-deleted");
 157   atk_add_global_event_listener (bridge_signal_listener, "Gtk:AtkTable:model-changed");
 158   atk_add_key_event_listener    (bridge_key_listener, NULL);
 159 }
 160
 161 static void bridge_exit_func()
 162 {
 163   fprintf (stderr, "exiting bridge\n");
 164   Accessibility_Registry_deregisterApplication (registry,
 165                                                 CORBA_Object_duplicate (BONOBO_OBJREF (this_app), &ev),
 166                                                 &ev);
 167   fprintf (stderr, "bridge exit func complete.\n");
 168 }
 169
 170 static void bridge_focus_tracker (AtkObject *object)
 171 {
 172   Accessibility_Event *e = Accessibility_Event__alloc();
 173   e->type = CORBA_string_dup ("focus:");
 174   e->source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (object)), &ev);
 175   e->detail1 = 0;
 176   e->detail2 = 0;
 177   Accessibility_Registry_notifyEvent (registry, e, &ev);
 178 }
 179
 180 static gboolean
 181 bridge_property_event_listener (GSignalInvocationHint *signal_hint,
 182                                 guint n_param_values,
 183                                 const GValue *param_values,
 184                                 gpointer data)
 185 {
 186   Accessibility_Event *e = Accessibility_Event__alloc();
 187   Bonobo_Unknown source = NULL;
 188   AtkObject *aobject;
 189   AtkPropertyValues *values;
 190   GObject *gobject;
 191   GSignalQuery signal_query;
 192   gchar *name;
 193   char sbuf[APP_STATIC_BUFF_SZ];
 194
 195   g_signal_query (signal_hint->signal_id, &signal_query);
 196   name = signal_query.signal_name;
 197 #ifdef SPI_BRIDGE_DEBUG
 198   fprintf (stderr, "Received (property) signal %s:%s\n",
 199            g_type_name (signal_query.itype), name);
 200 #endif
 201   gobject = g_value_get_object (param_values + 0);
 202   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 203
 204   /* notify the actual listeners */
 205   if (ATK_IS_IMPLEMENTOR (gobject))
 206   {
 207     aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 208     source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 209     g_object_unref (G_OBJECT(aobject));
 210   }
 211   else if (ATK_IS_OBJECT (gobject))
 212   {
 213     aobject = ATK_OBJECT (gobject);
 214     source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 215   }
 216   else
 217   {
 218     g_error("received property-change event from non-AtkImplementor");
 219   }
 220
 221   snprintf(sbuf, APP_STATIC_BUFF_SZ, "object:property-change:%s", values->property_name);
 222   e->type = CORBA_string_dup (sbuf);
 223   e->source = source;
 224   e->detail1 = 0;
 225   e->detail2 = 0;
 226   if (source)
 227     Accessibility_Registry_notifyEvent (registry, e, &ev);
 228   return TRUE;
 229 }
 230
 231 static gboolean
 232 bridge_state_event_listener (GSignalInvocationHint *signal_hint,
 233                              guint n_param_values,
 234                              const GValue *param_values,
 235                              gpointer data)
 236 {
 237   Accessibility_Event *e = Accessibility_Event__alloc();
 238   Bonobo_Unknown source = NULL;
 239   AtkObject *aobject;
 240   AtkPropertyValues *values;
 241   GObject *gobject;
 242   GSignalQuery signal_query;
 243   gchar *name;
 244   char sbuf[APP_STATIC_BUFF_SZ];
 245
 246   g_signal_query (signal_hint->signal_id, &signal_query);
 247   name = signal_query.signal_name;
 248 #ifdef SPI_BRIDGE_DEBUG
 249   fprintf (stderr, "Received (state) signal %s:%s\n",
 250            g_type_name (signal_query.itype), name);
 251 #endif
 252   gobject = g_value_get_object (param_values + 0);
 253   values = (AtkPropertyValues*) g_value_get_pointer (param_values + 1);
 254
 255   /* notify the actual listeners */
 256   if (ATK_IS_IMPLEMENTOR (gobject))
 257   {
 258     aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 259     source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 260     g_object_unref (G_OBJECT(aobject));
 261   }
 262   else if (ATK_IS_OBJECT (gobject))
 263   {
 264     aobject = ATK_OBJECT (gobject);
 265     source = CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 266   }
 267   else
 268   {
 269     g_error("received property-change event from non-AtkImplementor");
 270   }
 271
 272   snprintf(sbuf, APP_STATIC_BUFF_SZ, "object:%s:%s", values->property_name, "?");
 273   e->type = CORBA_string_dup (sbuf);
 274   e->source = source;
 275   e->detail1 = (unsigned long) values->old_value.data[0].v_ulong;
 276   e->detail2 = (unsigned long) values->new_value.data[0].v_ulong;
 277   if (source)
 278     Accessibility_Registry_notifyEvent (registry, e, &ev);
 279   return TRUE;
 280 }
 281
 282 #define SPI_DEBUG
 283
 284 static Accessibility_KeyStroke *
 285 accessibility_keystroke_from_atk_key_event (AtkKeyEventStruct *event)
 286 {
 287   Accessibility_KeyStroke *keystroke;
 288   keystroke = Accessibility_KeyStroke__alloc ();
 289
 290 #ifdef SPI_DEBUG
 291   if (event) g_print ("event %c (%d)\n", (int) event->keyval, (int) event->keycode);
 292   else
 293 #endif
 294   if (!event) g_print ("WARNING: NULL key event!");
 295
 296   keystroke->keyID = (CORBA_long) event->keyval;
 297   keystroke->keycode = (CORBA_short) event->keycode;
 298   keystroke->timestamp = (CORBA_unsigned_long) event->timestamp;
 299   keystroke->modifiers = (CORBA_unsigned_short) (event->state & 0xFFFF);
 300
 301   switch (event->type)
 302     {
 303     case (ATK_KEY_EVENT_PRESS):
 304             keystroke->type = Accessibility_KEY_PRESSED;
 305             break;
 306     case (ATK_KEY_EVENT_RELEASE):
 307             keystroke->type = Accessibility_KEY_RELEASED;
 308             break;
 309     default:
 310     }
 311
 312   return keystroke;
 313 }
 314
 315 static gint
 316 bridge_key_listener (AtkKeyEventStruct *event, gpointer data)
 317 {
 318   Accessibility_KeyStroke *key_event = accessibility_keystroke_from_atk_key_event (event);
 319   CORBA_boolean result;
 320   Accessibility_DeviceEventController controller =
 321           Accessibility_Registry_getDeviceEventController (registry, &ev);
 322   result = Accessibility_DeviceEventController_notifyListenersSync (controller,
 323                                                                     (Accessibility_DeviceEvent *) key_event,
 324                                                                     &ev);
 325 }
 326
 327 static gboolean
 328 bridge_signal_listener (GSignalInvocationHint *signal_hint,
 329                         guint n_param_values,
 330                         const GValue *param_values,
 331                         gpointer data)
 332 {
 333   Accessibility_Event *e = g_new0(Accessibility_Event, 1);
 334   AtkObject *aobject;
 335   Bonobo_Unknown source;
 336   AtkPropertyValues *values;
 337   GObject *gobject;
 338   GSignalQuery signal_query;
 339   gchar *name;
 340   char sbuf[APP_STATIC_BUFF_SZ];
 341
 342   g_signal_query (signal_hint->signal_id, &signal_query);
 343   name = signal_query.signal_name;
 344 #ifdef SPI_BRIDGE_DEBUG
 345   fprintf (stderr, "Received signal %s:%s\n",
 346            g_type_name (signal_query.itype), name);
 347 #endif
 348   gobject = g_value_get_object (param_values + 0);
 349
 350   /* notify the actual listeners */
 351   if (ATK_IS_IMPLEMENTOR (gobject))
 352   {
 353     aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 354   }
 355   else if (ATK_IS_OBJECT (gobject))
 356   {
 357     aobject = ATK_OBJECT (gobject);
 358     g_object_ref (aobject);
 359   }
 360   else
 361   {
 362     g_error("received property-change event from non-AtkImplementor");
 363   }
 364
 365   snprintf(sbuf, APP_STATIC_BUFF_SZ, "%s:%s", name, g_type_name (signal_query.itype));
 366   source =  CORBA_Object_duplicate (BONOBO_OBJREF (spi_accessible_new (aobject)), &ev);
 367   e->type = CORBA_string_dup (sbuf);
 368   e->source = source;
 369   e->detail1 = 0;
 370   e->detail2 = 0;
 371   Accessibility_Registry_notifyEvent (registry, e, &ev);
 372   g_object_unref (aobject);
 373   return TRUE;
 374 }
 375
 376 static Accessibility_Registry bridge_get_registry ()
 377 {
 378   return registry;
 379 }