atk-adaptor/accessible-cache.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2009, 2010 Codethink Ltd.
   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 <atk/atk.h>
  24 #include <string.h>
  25
  26 #include "accessible-cache.h"
  27 #include "accessible-register.h"
  28 #include "bridge.h"
  29
  30 SpiCache *spi_global_cache = NULL;
  31
  32 static gboolean
  33 child_added_listener (GSignalInvocationHint * signal_hint,
  34                       guint n_param_values,
  35                       const GValue * param_values, gpointer data);
  36
  37 static void
  38 toplevel_added_listener (AtkObject * accessible,
  39                          guint index, AtkObject * child);
  40
  41 static void
  42 remove_object (GObject * source, GObject * gobj, gpointer data);
  43
  44 static void
  45 add_object (SpiCache * cache, GObject * gobj);
  46
  47 static void
  48 add_subtree (SpiCache *cache, AtkObject * accessible);
  49
  50 static gboolean
  51 add_pending_items (gpointer data);
  52
  53 /*---------------------------------------------------------------------------*/
  54
  55 static void
  56 spi_cache_finalize (GObject * object);
  57
  58 static void
  59 spi_cache_dispose (GObject * object);
  60
  61 /*---------------------------------------------------------------------------*/
  62
  63 enum
  64 {
  65   OBJECT_ADDED,
  66   OBJECT_REMOVED,
  67   LAST_SIGNAL
  68 };
  69 static guint cache_signals[LAST_SIGNAL] = { 0 };
  70
  71 /*---------------------------------------------------------------------------*/
  72
  73 G_DEFINE_TYPE (SpiCache, spi_cache, G_TYPE_OBJECT)
  74
  75 static void spi_cache_class_init (SpiCacheClass * klass)
  76 {
  77   GObjectClass *object_class = (GObjectClass *) klass;
  78
  79   spi_cache_parent_class = g_type_class_ref (G_TYPE_OBJECT);
  80
  81   object_class->finalize = spi_cache_finalize;
  82   object_class->dispose = spi_cache_dispose;
  83
  84   cache_signals [OBJECT_ADDED] = \
  85       g_signal_new ("object-added",
  86                     SPI_CACHE_TYPE,
  87                     G_SIGNAL_ACTION,
  88                     0,
  89                     NULL,
  90                     NULL,
  91                     g_cclosure_marshal_VOID__OBJECT,
  92                     G_TYPE_NONE,
  93                     1,
  94                     G_TYPE_OBJECT);
  95
  96   cache_signals [OBJECT_REMOVED] = \
  97       g_signal_new ("object-removed",
  98                     SPI_CACHE_TYPE,
  99                     G_SIGNAL_ACTION,
 100                     0,
 101                     NULL,
 102                     NULL,
 103                     g_cclosure_marshal_VOID__OBJECT,
 104                     G_TYPE_NONE,
 105                     1,
 106                     G_TYPE_OBJECT);
 107 }
 108
 109 static void
 110 spi_cache_init (SpiCache * cache)
 111 {
 112   cache->objects = g_hash_table_new (g_direct_hash, g_direct_equal);
 113   cache->add_traversal = g_queue_new ();
 114
 115 #ifdef SPI_ATK_DEBUG
 116   if (g_thread_supported ())
 117     g_message ("AT-SPI: Threads enabled");
 118
 119   g_debug ("AT-SPI: Initial Atk tree regisration");
 120 #endif
 121
 122   g_signal_connect (spi_global_register,
 123                     "object-deregistered",
 124                     (GCallback) remove_object, cache);
 125
 126   add_subtree (cache, spi_global_app_data->root);
 127
 128   cache->child_added_listener = atk_add_global_event_listener (child_added_listener,
 129                                                                "Gtk:AtkObject:children-changed");
 130
 131   g_signal_connect (G_OBJECT (spi_global_app_data->root),
 132                     "children-changed::add",
 133                     (GCallback) toplevel_added_listener, NULL);
 134 }
 135
 136 static void
 137 spi_cache_finalize (GObject * object)
 138 {
 139   SpiCache *cache = SPI_CACHE (object);
 140
 141   while (!g_queue_is_empty (cache->add_traversal))
 142     g_object_unref (G_OBJECT (g_queue_pop_head (cache->add_traversal)));
 143   g_queue_free (cache->add_traversal);
 144   g_hash_table_unref (cache->objects);
 145
 146   g_signal_handlers_disconnect_by_func (spi_global_register,
 147                                         (GCallback) remove_object, cache);
 148
 149   g_signal_handlers_disconnect_by_func (G_OBJECT (spi_global_app_data->root),
 150                                         (GCallback) toplevel_added_listener, NULL);
 151
 152   atk_remove_global_event_listener (cache->child_added_listener);
 153
 154   G_OBJECT_CLASS (spi_cache_parent_class)->finalize (object);
 155 }
 156
 157 static void
 158 spi_cache_dispose (GObject * object)
 159 {
 160   SpiCache *cache = SPI_CACHE (object);
 161
 162   G_OBJECT_CLASS (spi_cache_parent_class)->dispose (object);
 163 }
 164
 165 /*---------------------------------------------------------------------------*/
 166
 167 static void
 168 remove_object (GObject * source, GObject * gobj, gpointer data)
 169 {
 170   SpiCache *cache = SPI_CACHE (data);
 171
 172   if (spi_cache_in (cache, gobj))
 173     {
 174 #ifdef SPI_ATK_DEBUG
 175   g_debug ("CACHE REM - %s - %d - %s\n", atk_object_get_name (ATK_OBJECT (gobj)),
 176             atk_object_get_role (ATK_OBJECT (gobj)),
 177             spi_register_object_to_path (spi_global_register, gobj));
 178 #endif
 179       g_signal_emit (cache, cache_signals [OBJECT_REMOVED], 0, gobj);
 180       g_hash_table_remove (cache->objects, gobj);
 181     }
 182   else
 183     {
 184       g_queue_remove (cache->add_traversal, gobj);
 185       g_object_unref (gobj);
 186     }
 187 }
 188
 189 static void
 190 add_object (SpiCache * cache, GObject * gobj)
 191 {
 192   g_return_if_fail (G_IS_OBJECT (gobj));
 193
 194   g_hash_table_insert (cache->objects, gobj, NULL);
 195
 196 #ifdef SPI_ATK_DEBUG
 197   g_debug ("CACHE ADD - %s - %d - %s\n", atk_object_get_name (ATK_OBJECT (gobj)),
 198             atk_object_get_role (ATK_OBJECT (gobj)),
 199             spi_register_object_to_path (spi_global_register, gobj));
 200 #endif
 201
 202   g_signal_emit (cache, cache_signals [OBJECT_ADDED], 0, gobj);
 203 }
 204
 205 /*---------------------------------------------------------------------------*/
 206
 207 static GStaticRecMutex cache_mutex        = G_STATIC_REC_MUTEX_INIT;
 208 static GStaticMutex recursion_check_guard = G_STATIC_MUTEX_INIT;
 209
 210 static gboolean recursion_check = FALSE;
 211
 212 static gboolean
 213 recursion_check_and_set ()
 214 {
 215   gboolean ret;
 216   g_static_mutex_lock (&recursion_check_guard);
 217   ret = recursion_check;
 218   recursion_check = TRUE;
 219   g_static_mutex_unlock (&recursion_check_guard);
 220   return ret;
 221 }
 222
 223 static void
 224 recursion_check_unset ()
 225 {
 226   g_static_mutex_lock (&recursion_check_guard);
 227   recursion_check = FALSE;
 228   g_static_mutex_unlock (&recursion_check_guard);
 229 }
 230
 231 /*---------------------------------------------------------------------------*/
 232
 233 static void
 234 append_children (AtkObject * accessible, GQueue * traversal)
 235 {
 236   AtkObject *current;
 237   guint i;
 238   gint count = atk_object_get_n_accessible_children (accessible);
 239
 240   if (count < 0)
 241     count = 0;
 242   for (i = 0; i < count; i++)
 243     {
 244       current = atk_object_ref_accessible_child (accessible, i);
 245       if (current)
 246         {
 247           g_queue_push_tail (traversal, current);
 248         }
 249     }
 250 }
 251
 252 /*
 253  * Adds a subtree of accessible objects
 254  * to the cache at the accessible object provided.
 255  *
 256  * The leaf nodes do not have their children
 257  * registered. A node is considered a leaf
 258  * if it has the state "manages-descendants"
 259  * or if it has already been registered.
 260  */
 261 static void
 262 add_subtree (SpiCache *cache, AtkObject * accessible)
 263 {
 264   g_return_if_fail (ATK_IS_OBJECT (accessible));
 265
 266   g_object_ref (accessible);
 267   g_queue_push_tail (cache->add_traversal, accessible);
 268   add_pending_items (cache);
 269 }
 270
 271 static gboolean
 272 add_pending_items (gpointer data)
 273 {
 274   SpiCache *cache = SPI_CACHE (data);
 275   AtkObject *current;
 276   GQueue *to_add;
 277
 278   to_add = g_queue_new ();
 279
 280   while (!g_queue_is_empty (cache->add_traversal))
 281     {
 282       AtkStateSet *set;
 283
 284       /* cache->add_traversal holds a ref to current */
 285       current = g_queue_pop_head (cache->add_traversal);
 286       set = atk_object_ref_state_set (current);
 287
 288       if (set && !atk_state_set_contains_state (set, ATK_STATE_TRANSIENT))
 289         {
 290           /* transfer the ref into to_add */
 291           g_queue_push_tail (to_add, current);
 292           if (!spi_cache_in (cache, G_OBJECT (current)) &&
 293               !atk_state_set_contains_state  (set, ATK_STATE_MANAGES_DESCENDANTS) &&
 294               !atk_state_set_contains_state  (set, ATK_STATE_DEFUNCT))
 295             {
 296               append_children (current, cache->add_traversal);
 297             }
 298         }
 299       else
 300         {
 301           /* drop the ref for the removed object */
 302           g_object_unref (current);
 303         }
 304
 305       if (set)
 306         g_object_unref (set);
 307     }
 308
 309   while (!g_queue_is_empty (to_add))
 310     {
 311       current = g_queue_pop_head (to_add);
 312
 313       /* Make sure object is registerd so we are notified if it goes away */
 314       g_free (spi_register_object_to_path (spi_global_register,
 315               G_OBJECT (current)));
 316
 317       add_object (cache, G_OBJECT(current));
 318       g_object_unref (G_OBJECT (current));
 319     }
 320
 321   g_queue_free (to_add);
 322   cache->add_pending_idle = 0;
 323   return FALSE;
 324 }
 325
 326 /*---------------------------------------------------------------------------*/
 327
 328 static gboolean
 329 child_added_listener (GSignalInvocationHint * signal_hint,
 330                       guint n_param_values,
 331                       const GValue * param_values, gpointer data)
 332 {
 333   SpiCache *cache = spi_global_cache;
 334   AtkObject *accessible;
 335
 336   const gchar *detail = NULL;
 337
 338   g_static_rec_mutex_lock (&cache_mutex);
 339
 340   /*
 341    * Ensure that only accessibles already in the cache
 342    * have their signals processed.
 343    */
 344   accessible = ATK_OBJECT (g_value_get_object (&param_values[0]));
 345   g_return_val_if_fail (ATK_IS_OBJECT (accessible), TRUE);
 346
 347   if (spi_cache_in (cache, G_OBJECT(accessible)))
 348     {
 349 #ifdef SPI_ATK_DEBUG
 350       if (recursion_check_and_set ())
 351         g_warning ("AT-SPI: Recursive use of cache module");
 352
 353       g_debug ("AT-SPI: Tree update listener");
 354 #endif
 355       if (signal_hint->detail)
 356         detail = g_quark_to_string (signal_hint->detail);
 357
 358       if (detail && !strncmp (detail, "add", 3))
 359         {
 360           gpointer child;
 361           int index = g_value_get_uint (param_values + 1);
 362           child = g_value_get_pointer (param_values + 2);
 363           if (!child)
 364             {
 365               g_static_rec_mutex_unlock (&cache_mutex);
 366               return;
 367             }
 368
 369           g_object_ref (child);
 370           g_queue_push_tail (cache->add_traversal, child);
 371
 372           if (cache->add_pending_idle == 0)
 373             cache->add_pending_idle = g_idle_add (add_pending_items, cache);
 374         }
 375 #ifdef SPI_ATK_DEBUG
 376       recursion_check_unset ();
 377 #endif
 378     }
 379
 380   g_static_rec_mutex_unlock (&cache_mutex);
 381
 382   return TRUE;
 383 }
 384
 385 /*---------------------------------------------------------------------------*/
 386
 387 static void
 388 toplevel_added_listener (AtkObject * accessible,
 389                          guint index, AtkObject * child)
 390 {
 391   SpiCache *cache = spi_global_cache;
 392
 393   g_static_rec_mutex_lock (&cache_mutex);
 394
 395   g_return_if_fail (ATK_IS_OBJECT (accessible));
 396
 397   if (spi_cache_in (cache, G_OBJECT(accessible)))
 398     {
 399 #ifdef SPI_ATK_DEBUG
 400       if (recursion_check_and_set ())
 401         g_warning ("AT-SPI: Recursive use of registration module");
 402
 403       g_debug ("AT-SPI: Toplevel added listener");
 404 #endif
 405       if (!ATK_IS_OBJECT (child))
 406         {
 407           child = atk_object_ref_accessible_child (accessible, index);
 408         }
 409       else
 410         g_object_ref (child);
 411
 412       g_queue_push_tail (cache->add_traversal, child);
 413
 414       if (cache->add_pending_idle == 0)
 415         cache->add_pending_idle = g_idle_add (add_pending_items, cache);
 416 #ifdef SPI_ATK_DEBUG
 417       recursion_check_unset ();
 418 #endif
 419     }
 420
 421   g_static_rec_mutex_unlock (&cache_mutex);
 422 }
 423
 424 /*---------------------------------------------------------------------------*/
 425
 426 void
 427 spi_cache_foreach (SpiCache * cache, GHFunc func, gpointer data)
 428 {
 429   g_hash_table_foreach (cache->objects, func, data);
 430 }
 431
 432 gboolean
 433 spi_cache_in (SpiCache * cache, GObject * object)
 434 {
 435   if (!cache)
 436     return FALSE;
 437
 438   if (g_hash_table_lookup_extended (cache->objects,
 439                                     object,
 440                                     NULL,
 441                                     NULL))
 442     return TRUE;
 443   else
 444     return FALSE;
 445 }
 446
 447 #ifdef SPI_ATK_DEBUG
 448 void
 449 spi_cache_print_info (GObject * obj)
 450 {
 451   char * path = spi_register_object_to_path (spi_global_register, obj);
 452
 453   if (spi_cache_in (spi_global_cache, obj))
 454       g_printf ("%s IC\n", path);
 455   else
 456       g_printf ("%s NC\n", path);
 457
 458   if (path)
 459       g_free (path);
 460 }
 461 #endif
 462
 463 /*END------------------------------------------------------------------------*/