libspi/application.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 /* application.c: implements SpiApplication.idl */
  24
  25 #include <string.h>
  26 #include <config.h>
  27 #include <atk/atkutil.h>
  28 #include <libspi/application.h>
  29
  30 /*
  31  * Our parent Gtk object type
  32  */
  33 #define PARENT_TYPE SPI_ACCESSIBLE_TYPE
  34
  35 /*
  36  * A pointer to our parent object class
  37  */
  38 static SpiAccessibleClass *spi_application_parent_class;
  39
  40 static SpiApplication *the_app;
  41
  42 /* static methods */
  43
  44 static void notify_listeners (GList *listeners,
  45                               Accessibility_Event *e,
  46                               CORBA_Environment *ev);
  47
  48 static char *reverse_lookup_name_for_toolkit_event (char *toolkit_name);
  49
  50 static const char *
  51 lookup_toolkit_event_for_name (const char *generic_name)
  52 {
  53     char *toolkit_specific_name;
  54     SpiApplicationClass *klass = g_type_class_peek (SPI_APPLICATION_TYPE);
  55 #ifdef SPI_DEBUG
  56     fprintf (stderr, "looking for %s in hash table.\n", generic_name);
  57 #endif
  58     toolkit_specific_name =
  59             (char *) g_hash_table_lookup (klass->toolkit_event_names, generic_name);
  60 #ifdef SPI_DEBUG
  61     fprintf (stderr, "generic event %s converted to %s\n", generic_name, toolkit_specific_name);
  62 #endif
  63     return toolkit_specific_name;
  64 }
  65
  66 /*
  67  * Implemented GObject::finalize
  68  */
  69 static void
  70 spi_accessible_application_finalize (GObject *object)
  71 {
  72   /* TODO: any necessary cleanup */
  73   g_print ("application finalize called\n");
  74   (G_OBJECT_CLASS (spi_application_parent_class))->finalize (object);
  75 }
  76
  77 static CORBA_string
  78 impl_accessibility_application_get_toolkit_name (PortableServer_Servant servant,
  79                                                  CORBA_Environment *ev)
  80 {
  81         return CORBA_string_dup (atk_get_toolkit_name ());
  82 }
  83
  84 static CORBA_string
  85 impl_accessibility_application_get_version (PortableServer_Servant servant,
  86                                             CORBA_Environment *ev)
  87 {
  88         return CORBA_string_dup (atk_get_toolkit_version ());
  89 }
  90
  91 static CORBA_long
  92 impl_accessibility_application_get_id (PortableServer_Servant servant,
  93                                        CORBA_Environment *ev)
  94 {
  95         SpiApplication *application = SPI_APPLICATION (
  96                 bonobo_object_from_servant (servant));
  97         return application->id;
  98 }
  99
 100 static void
 101 impl_accessibility_application_set_id (PortableServer_Servant servant,
 102                                        const CORBA_long id,
 103                                        CORBA_Environment *ev)
 104 {
 105         SpiApplication *application = SPI_APPLICATION (
 106                 bonobo_object_from_servant (servant));
 107         application->id = id;
 108 }
 109
 110 #define APP_STATIC_BUFF_SZ 64
 111
 112 static gboolean
 113 spi_application_object_event_listener (GSignalInvocationHint *signal_hint,
 114                                    guint n_param_values,
 115                                    const GValue *param_values,
 116                                    gpointer data)
 117 {
 118   Accessibility_Event *e = Accessibility_Event__alloc();
 119   AtkObject *aobject;
 120   GObject *gobject;
 121   SpiAccessible *source;
 122   CORBA_Environment ev;
 123   GSignalQuery signal_query;
 124   const gchar *name;
 125   char sbuf[APP_STATIC_BUFF_SZ];
 126   char *generic_name;
 127
 128   g_signal_query (signal_hint->signal_id, &signal_query);
 129   name = signal_query.signal_name;
 130   fprintf (stderr, "Received (object) signal %s:%s\n",
 131            g_type_name (signal_query.itype), name);
 132
 133   /* TODO: move GTK dependency out of app.c into bridge */
 134   snprintf(sbuf, APP_STATIC_BUFF_SZ, "Gtk:%s:%s", g_type_name (signal_query.itype), name);
 135
 136   generic_name = reverse_lookup_name_for_toolkit_event (sbuf);
 137   gobject = g_value_get_object (param_values + 0);
 138
 139   /* notify the actual listeners */
 140   if (ATK_IS_IMPLEMENTOR (gobject))
 141   {
 142     aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 143   }
 144   else if (ATK_IS_OBJECT (gobject))
 145   {
 146     aobject = ATK_OBJECT (gobject);
 147     g_object_ref (G_OBJECT (aobject));
 148   }
 149   else
 150   {
 151     aobject = NULL;
 152     g_error("received event from non-AtkImplementor");
 153   }
 154
 155   g_return_val_if_fail (generic_name, FALSE);
 156   if (generic_name)
 157     {
 158         source = spi_accessible_new (aobject);
 159         e->type = CORBA_string_dup (generic_name);
 160         e->source = BONOBO_OBJREF (source);
 161         /*
 162          * no need to dup this ref, since it's inprocess
 163          * and will be dup'ed by (inprocess) notify_listeners() call below
 164          */
 165         e->detail1 = 0;
 166         e->detail2 = 0;
 167         if (the_app) notify_listeners (the_app->toolkit_listeners, e, &ev);
 168         /* unref because the in-process notify has called b_o_dup_ref (e->source) */
 169         bonobo_object_release_unref (e->source, &ev);
 170     }
 171   /* and, decrement the refcount on atkobject, incremented moments ago:
 172    *  the call to spi_accessible_new() above should have added an extra ref */
 173   g_object_unref (G_OBJECT (aobject));
 174
 175   return TRUE;
 176 }
 177
 178
 179 static gboolean
 180 spi_application_toolkit_event_listener (GSignalInvocationHint *signal_hint,
 181                                     guint n_param_values,
 182                                     const GValue *param_values,
 183                                     gpointer data)
 184 {
 185   Accessibility_Event *e = Accessibility_Event__alloc();
 186   AtkObject *aobject;
 187   GObject *gobject;
 188   SpiAccessible *source;
 189   CORBA_Environment ev;
 190   GSignalQuery signal_query;
 191   const char *name;
 192   char sbuf[APP_STATIC_BUFF_SZ];
 193
 194   g_signal_query (signal_hint->signal_id, &signal_query);
 195   name = signal_query.signal_name;
 196   fprintf (stderr, "Received signal %s:%s\n", g_type_name (signal_query.itype), name);
 197
 198   /* TODO: move GTK dependency out of app.c into bridge */
 199   snprintf(sbuf, APP_STATIC_BUFF_SZ, "Gtk:%s:%s", g_type_name (signal_query.itype), name);
 200
 201   gobject = g_value_get_object (param_values + 0);
 202   /* notify the actual listeners */
 203   if (ATK_IS_IMPLEMENTOR (gobject))
 204     {
 205       aobject = atk_implementor_ref_accessible (ATK_IMPLEMENTOR (gobject));
 206       source = spi_accessible_new (aobject);
 207       e->type = CORBA_string_dup (sbuf);
 208       e->source = BONOBO_OBJREF (source);
 209       e->detail1 = 0;
 210       e->detail2 = 0;
 211       if (the_app) notify_listeners (the_app->toolkit_listeners, e, &ev);
 212       bonobo_object_unref (BONOBO_OBJECT (source));
 213       g_object_unref (G_OBJECT (aobject));
 214     }
 215   return TRUE;
 216 }
 217
 218 static void
 219 impl_accessibility_application_register_toolkit_event_listener (PortableServer_Servant servant,
 220                                                                 Accessibility_EventListener listener,
 221                                                                 const CORBA_char *event_name,
 222                                                                 CORBA_Environment *ev)
 223 {
 224   guint spi_listener_id;
 225   spi_listener_id =
 226      atk_add_global_event_listener (spi_application_toolkit_event_listener, (char *) event_name);
 227   the_app->toolkit_listeners = g_list_append (the_app->toolkit_listeners,
 228                                               CORBA_Object_duplicate (listener, ev));
 229 #ifdef SPI_DEBUG
 230   fprintf (stderr, "registered %d for toolkit events named: %s\n",
 231            spi_listener_id,
 232            event_name);
 233 #endif
 234 }
 235
 236 static void
 237 impl_accessibility_application_register_object_event_listener (PortableServer_Servant servant,
 238                                                                Accessibility_EventListener listener,
 239                                                                const CORBA_char *event_name,
 240                                                                CORBA_Environment *ev)
 241 {
 242   guint spi_listener_id = 0;
 243   const char *toolkit_specific_event_name =
 244           lookup_toolkit_event_for_name (event_name);
 245   if (toolkit_specific_event_name)
 246   {
 247     spi_listener_id =
 248        atk_add_global_event_listener (spi_application_object_event_listener,
 249                                       CORBA_string_dup (toolkit_specific_event_name));
 250     the_app->toolkit_listeners = g_list_append (the_app->toolkit_listeners,
 251                                               CORBA_Object_duplicate (listener, ev));
 252   }
 253 #ifdef SPI_DEBUG
 254   fprintf (stderr, "registered %d for object events named: %s\n",
 255            spi_listener_id,
 256            event_name);
 257 #endif
 258 }
 259
 260 static void
 261 notify_listeners (GList *listeners, Accessibility_Event *e, CORBA_Environment *ev)
 262 {
 263     int n_listeners=0;
 264     int i;
 265     if (listeners) n_listeners = g_list_length (listeners);
 266
 267     for (i=0; i<n_listeners; ++i) {
 268         Accessibility_EventListener listener;
 269         e->source = bonobo_object_dup_ref (e->source, ev);
 270         listener = (Accessibility_EventListener) g_list_nth_data (listeners, i);
 271         Accessibility_EventListener_notifyEvent (listener, e, ev);
 272         /*
 273          * when this (oneway) call completes, the CORBA refcount and
 274          * Bonobo_Unknown refcount will be decremented by the recipient
 275          */
 276     }
 277 }
 278
 279 static char *
 280 reverse_lookup_name_for_toolkit_event (char *toolkit_specific_name)
 281 {
 282     char *generic_name;
 283     SpiApplicationClass *klass = g_type_class_peek (SPI_APPLICATION_TYPE);
 284 #ifdef SPI_DEBUG
 285     fprintf (stderr, "(reverse lookup) looking for %s in hash table.\n", toolkit_specific_name);
 286 #endif
 287     generic_name =
 288             (char *) g_hash_table_lookup (klass->generic_event_names, toolkit_specific_name);
 289 #ifdef SPI_DEBUG
 290     fprintf (stderr, "toolkit event %s converted to %s\n", toolkit_specific_name, generic_name);
 291 #endif
 292     return generic_name;
 293 }
 294
 295 static void
 296 init_toolkit_names (GHashTable **generic_event_names, GHashTable **toolkit_event_names)
 297 {
 298         *toolkit_event_names = g_hash_table_new (g_str_hash, g_str_equal);
 299         *generic_event_names = g_hash_table_new (g_str_hash, g_str_equal);
 300         g_hash_table_insert (*toolkit_event_names,
 301                              "object:property-change",
 302                              "Gtk:AtkObject:property-change");
 303         g_hash_table_insert (*generic_event_names,
 304                              "Gtk:AtkObject:property-change",
 305                              "object:property-change");
 306 #ifdef SPI_DEBUG
 307         fprintf (stderr, "inserted spi_selection_changed hash\n");
 308 #endif
 309 }
 310
 311 static void
 312 spi_application_class_init (SpiApplicationClass *klass)
 313 {
 314   GObjectClass * object_class = (GObjectClass *) klass;
 315   POA_Accessibility_Application__epv *epv = &klass->epv;
 316
 317   spi_application_parent_class = g_type_class_ref (SPI_ACCESSIBLE_TYPE);
 318
 319   object_class->finalize = spi_accessible_application_finalize;
 320
 321   epv->_get_toolkitName = impl_accessibility_application_get_toolkit_name;
 322   epv->_get_version = impl_accessibility_application_get_version;
 323   epv->_get_id = impl_accessibility_application_get_id;
 324   epv->_set_id = impl_accessibility_application_set_id;
 325   epv->registerToolkitEventListener = impl_accessibility_application_register_toolkit_event_listener;
 326   init_toolkit_names (&klass->generic_event_names, &klass->toolkit_event_names);
 327 }
 328
 329 static void
 330 spi_application_init (SpiApplication  *application)
 331 {
 332   application->parent.atko = g_object_new (ATK_TYPE_OBJECT, NULL);
 333   application->toolkit_listeners = NULL;
 334   the_app = application;
 335 }
 336
 337 BONOBO_TYPE_FUNC_FULL (SpiApplication,
 338                        Accessibility_Application,
 339                        PARENT_TYPE, spi_application);
 340
 341 SpiApplication *
 342 spi_application_new (AtkObject *app_root)
 343 {
 344     SpiApplication *retval = g_object_new (SPI_APPLICATION_TYPE, NULL);
 345     g_object_unref (retval->parent.atko);
 346     retval->parent.atko = app_root;
 347     g_object_ref (G_OBJECT (app_root));
 348     return retval;
 349 }