cspi/spi_main.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 /*
  24  *
  25  * Basic SPI initialization and event loop function prototypes
  26  *
  27  */
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <cspi/spi-private.h>
  31
  32 #undef DEBUG_OBJECTS
  33
  34 static CORBA_Environment ev = { 0 };
  35 static Accessibility_Registry registry = CORBA_OBJECT_NIL;
  36 static GHashTable *live_refs = NULL;
  37
  38 static guint
  39 cspi_object_hash (gconstpointer key)
  40 {
  41   CORBA_Object object = (CORBA_Object) key;
  42   guint        retval;
  43
  44   retval = CORBA_Object_hash (object, 0, &ev);
  45
  46   return retval;
  47 }
  48
  49 static gboolean
  50 cspi_object_equal (gconstpointer a, gconstpointer b)
  51 {
  52   CORBA_Object objecta = (CORBA_Object) a;
  53   CORBA_Object objectb = (CORBA_Object) b;
  54   gboolean     retval;
  55
  56   retval = CORBA_Object_is_equivalent (objecta, objectb, &ev);
  57
  58   return retval;
  59 }
  60
  61 static void
  62 cspi_object_release (gpointer  value)
  63 {
  64   Accessible *a = (Accessible *) value;
  65
  66 #ifdef DEBUG_OBJECTS
  67   g_print ("releasing %p => %p\n", a, a->objref);
  68 #endif
  69
  70   cspi_release_unref (a->objref);
  71
  72   memset (a, 0xaa, sizeof (Accessible));
  73   a->ref_count = -1;
  74
  75 #ifndef DEBUG_OBJECTS
  76   free (a);
  77 #endif
  78 }
  79
  80 SPIBoolean
  81 cspi_accessible_is_a (Accessible *obj,
  82                       const char *interface_name)
  83 {
  84   SPIBoolean        retval;
  85   Bonobo_Unknown unknown;
  86
  87   if (obj == NULL)
  88     {
  89       return FALSE;
  90     }
  91
  92   unknown = Bonobo_Unknown_queryInterface (CSPI_OBJREF (obj),
  93                                            interface_name, cspi_ev ());
  94
  95   if (ev._major != CORBA_NO_EXCEPTION)
  96     {
  97       g_error ("Exception '%s' checking if is '%s'",
  98                cspi_exception_get_text (),
  99                interface_name);
 100     }
 101
 102   if (unknown != CORBA_OBJECT_NIL)
 103     {
 104       retval = TRUE;
 105       cspi_release_unref (unknown);
 106     }
 107   else
 108     {
 109       retval = FALSE;
 110     }
 111
 112   return retval;
 113 }
 114
 115 static GHashTable *
 116 cspi_get_live_refs (void)
 117 {
 118   if (!live_refs)
 119     {
 120       live_refs = g_hash_table_new_full (cspi_object_hash,
 121                                          cspi_object_equal,
 122                                          NULL,
 123                                          cspi_object_release);
 124     }
 125   return live_refs;
 126 }
 127
 128 CORBA_Environment *
 129 cspi_ev (void)
 130 {
 131   /* This method is an ugly hack */
 132   return &ev;
 133 }
 134
 135 Accessibility_Registry
 136 cspi_registry (void)
 137 {
 138   return registry;
 139 }
 140
 141 SPIBoolean
 142 cspi_exception (void)
 143 {
 144   SPIBoolean retval;
 145
 146   if (ev._major != CORBA_NO_EXCEPTION)
 147     {
 148       CORBA_exception_free (&ev);
 149       retval = TRUE;
 150     }
 151   else
 152     {
 153       retval = FALSE;
 154     }
 155
 156   return retval;
 157 }
 158
 159 Accessible *
 160 cspi_object_add (CORBA_Object corba_object)
 161 {
 162         return cspi_object_add_ref (corba_object, FALSE);
 163 }
 164
 165 Accessible *
 166 cspi_object_add_ref (CORBA_Object corba_object, gboolean do_ref)
 167 {
 168   Accessible *ref;
 169
 170   if (corba_object == CORBA_OBJECT_NIL)
 171     {
 172       ref = NULL;
 173     }
 174   else if (!cspi_check_ev ("pre method check: add"))
 175     {
 176       ref = NULL;
 177     }
 178   else
 179     {
 180       if ((ref = g_hash_table_lookup (cspi_get_live_refs (), corba_object)))
 181         {
 182           g_assert (ref->ref_count > 0);
 183           ref->ref_count++;
 184           if (!do_ref)
 185                 cspi_release_unref (corba_object);
 186 #ifdef DEBUG_OBJECTS
 187           g_print ("returning cached %p => %p\n", ref, ref->objref);
 188 #endif
 189         }
 190       else
 191         {
 192           ref = malloc (sizeof (Accessible));
 193
 194 #ifdef DEBUG_OBJECTS
 195           g_print ("allocating %p => %p\n", ref, corba_object);
 196 #endif
 197           if (do_ref) {
 198 #ifdef JAVA_BRIDGE_BUG_IS_FIXED
 199                   g_assert (CORBA_Object_is_a (corba_object,
 200                                                 "IDL:Bonobo/Unknown:1.0", cspi_ev ()));
 201 #endif
 202                   ref->objref = bonobo_object_dup_ref (corba_object, cspi_ev ());
 203           } else
 204                   ref->objref = corba_object;
 205           ref->ref_count = 1;
 206
 207           g_hash_table_insert (cspi_get_live_refs (), ref->objref, ref);
 208         }
 209     }
 210
 211   return ref;
 212 }
 213
 214 void
 215 cspi_object_ref (Accessible *accessible)
 216 {
 217   g_return_if_fail (accessible != NULL);
 218
 219   accessible->ref_count++;
 220 }
 221
 222 void
 223 cspi_object_unref (Accessible *accessible)
 224 {
 225   if (accessible == NULL)
 226     {
 227       return;
 228     }
 229
 230   if (--accessible->ref_count == 0)
 231     {
 232       g_hash_table_remove (cspi_get_live_refs (), accessible->objref);
 233     }
 234 }
 235
 236 static void
 237 cspi_cleanup (void)
 238 {
 239   GHashTable *refs;
 240
 241   refs = live_refs;
 242   live_refs = NULL;
 243   if (refs)
 244     {
 245       g_hash_table_destroy (refs);
 246     }
 247
 248   if (registry != CORBA_OBJECT_NIL)
 249     {
 250       cspi_release_unref (registry);
 251       registry = CORBA_OBJECT_NIL;
 252     }
 253 }
 254
 255 static gboolean SPI_inited = FALSE;
 256
 257 /**
 258  * SPI_init:
 259  *
 260  * Connects to the accessibility registry and initializes the SPI.
 261  *
 262  * Returns: 0 on success, otherwise an integer error code.
 263  **/
 264 int
 265 SPI_init (void)
 266 {
 267   if (SPI_inited)
 268     {
 269       return 1;
 270     }
 271
 272   SPI_inited = TRUE;
 273
 274   CORBA_exception_init (&ev);
 275
 276   registry = cspi_init ();
 277
 278   g_atexit (cspi_cleanup);
 279
 280   return 0;
 281 }
 282
 283 /**
 284  * SPI_event_main:
 285  *
 286  * Starts/enters the main event loop for the SPI services.
 287  *
 288  * (NOTE: This method does not return control, it is exited via a call to
 289  *  SPI_event_quit () from within an event handler).
 290  *
 291  **/
 292 void
 293 SPI_event_main (void)
 294 {
 295   cspi_main ();
 296 }
 297
 298 /**
 299  * SPI_event_quit:
 300  *
 301  * Quits the last main event loop for the SPI services,
 302  * see SPI_event_main
 303  **/
 304 void
 305 SPI_event_quit (void)
 306 {
 307   cspi_main_quit ();
 308 }
 309
 310 /**
 311  * SPI_eventIsReady:
 312  *
 313  * Checks to see if an SPI event is waiting in the event queue.
 314  * Used by clients that don't wish to use SPI_event_main().
 315  *
 316  * Not Yet Implemented.
 317  *
 318  * Returns: #TRUE if an event is waiting, otherwise #FALSE.
 319  *
 320  **/
 321 SPIBoolean
 322 SPI_eventIsReady ()
 323 {
 324   return FALSE;
 325 }
 326
 327 /**
 328  * SPI_nextEvent:
 329  * @waitForEvent: a #SPIBoolean indicating whether to block or not.
 330  *
 331  * Gets the next event in the SPI event queue; blocks if no event
 332  * is pending and @waitForEvent is #TRUE.
 333  * Used by clients that don't wish to use SPI_event_main().
 334  *
 335  * Not Yet Implemented.
 336  *
 337  * Returns: the next #AccessibleEvent in the SPI event queue.
 338  **/
 339 AccessibleEvent *
 340 SPI_nextEvent (SPIBoolean waitForEvent)
 341 {
 342   return NULL;
 343 }
 344
 345 /**
 346  * SPI_exit:
 347  *
 348  * Disconnects from the Accessibility Registry and releases
 349  * any floating resources. Call only once at exit.
 350  *
 351  * Returns: 0 if there were no leaks, otherwise non zero.
 352  **/
 353 int
 354 SPI_exit (void)
 355 {
 356   int leaked;
 357
 358   if (!SPI_inited)
 359     {
 360       return 0;
 361     }
 362
 363   SPI_inited = FALSE;
 364
 365   if (live_refs)
 366     {
 367       leaked = g_hash_table_size (live_refs);
 368     }
 369   else
 370     {
 371       leaked = 0;
 372     }
 373
 374 #ifdef DEBUG_OBJECTS
 375   if (leaked)
 376     {
 377       fprintf (stderr, "Leaked %d SPI handles\n", leaked);
 378     }
 379 #endif
 380
 381   cspi_cleanup ();
 382
 383   fprintf (stderr, "bye-bye!\n");
 384
 385   return leaked;
 386 }
 387
 388 /**
 389  * SPI_freeString:
 390  * @s: a character string returned from another at-spi call.
 391  *
 392  * Free a character string returned from an at-spi call.  Clients of
 393  * at-spi should use this function instead of free () or g_free().
 394  * This API should not be used to free strings
 395  * from other libraries or allocated by the client.
 396  **/
 397 void
 398 SPI_freeString (char *s)
 399 {
 400   CORBA_free (s);
 401 }