libspi/accessible.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 /* accessible.c: the core of the accessibility implementation */
  25
  26 #include <config.h>
  27 #include <stdio.h>
  28 #include <bonobo/bonobo-exception.h>
  29 #include <atk/atk.h>
  30 #include <libspi/libspi.h>
  31 #include "spi-private.h"
  32
  33 /* Our parent Gtk object type  */
  34 #define PARENT_TYPE SPI_TYPE_BASE
  35
  36 static gboolean spi_init_role_lookup_table (Accessibility_Role *role_table);
  37 Accessibility_Role spi_accessible_role_from_atk_role (AtkRole role);
  38
  39 static gboolean
  40 spi_init_role_lookup_table (Accessibility_Role *role_table)
  41 {
  42   int i;
  43   /* if it's not in the list below, dunno what it is */
  44   for (i = 0; i < ATK_ROLE_LAST_DEFINED; ++i)
  45     {
  46       role_table [i] = Accessibility_ROLE_UNKNOWN;
  47     }
  48
  49   role_table [ATK_ROLE_INVALID] =             Accessibility_ROLE_INVALID;
  50   role_table [ATK_ROLE_ACCEL_LABEL] =         Accessibility_ROLE_ACCELERATOR_LABEL;
  51   role_table [ATK_ROLE_ALERT] =               Accessibility_ROLE_ALERT;
  52   role_table [ATK_ROLE_ANIMATION] =           Accessibility_ROLE_ANIMATION;
  53   role_table [ATK_ROLE_ARROW] =               Accessibility_ROLE_ARROW;
  54   role_table [ATK_ROLE_CALENDAR] =            Accessibility_ROLE_CALENDAR;
  55   role_table [ATK_ROLE_CANVAS] =              Accessibility_ROLE_CANVAS;
  56   role_table [ATK_ROLE_CHECK_BOX] =           Accessibility_ROLE_CHECK_BOX;
  57   role_table [ATK_ROLE_CHECK_MENU_ITEM] =     Accessibility_ROLE_CHECK_MENU_ITEM;
  58   role_table [ATK_ROLE_COLOR_CHOOSER] =       Accessibility_ROLE_COLOR_CHOOSER;
  59   role_table [ATK_ROLE_COLUMN_HEADER] =       Accessibility_ROLE_COLUMN_HEADER;
  60   role_table [ATK_ROLE_COMBO_BOX] =           Accessibility_ROLE_COMBO_BOX;
  61   role_table [ATK_ROLE_DATE_EDITOR] =         Accessibility_ROLE_DATE_EDITOR;
  62   role_table [ATK_ROLE_DESKTOP_ICON] =        Accessibility_ROLE_DESKTOP_ICON;
  63   role_table [ATK_ROLE_DESKTOP_FRAME] =       Accessibility_ROLE_DESKTOP_FRAME;
  64   role_table [ATK_ROLE_DIAL] =                Accessibility_ROLE_DIAL;
  65   role_table [ATK_ROLE_DIALOG] =              Accessibility_ROLE_DIALOG;
  66   role_table [ATK_ROLE_DIRECTORY_PANE] =      Accessibility_ROLE_DIRECTORY_PANE;
  67   role_table [ATK_ROLE_DRAWING_AREA] =        Accessibility_ROLE_DRAWING_AREA;
  68   role_table [ATK_ROLE_FILE_CHOOSER] =        Accessibility_ROLE_FILE_CHOOSER;
  69   role_table [ATK_ROLE_FILLER] =              Accessibility_ROLE_FILLER;
  70   role_table [ATK_ROLE_FONT_CHOOSER] =        Accessibility_ROLE_FONT_CHOOSER;
  71   role_table [ATK_ROLE_FRAME] =               Accessibility_ROLE_FRAME;
  72   role_table [ATK_ROLE_GLASS_PANE] =          Accessibility_ROLE_GLASS_PANE;
  73   role_table [ATK_ROLE_HTML_CONTAINER] =      Accessibility_ROLE_HTML_CONTAINER;
  74   role_table [ATK_ROLE_ICON] =                Accessibility_ROLE_ICON;
  75   role_table [ATK_ROLE_IMAGE] =               Accessibility_ROLE_IMAGE;
  76   role_table [ATK_ROLE_INTERNAL_FRAME] =      Accessibility_ROLE_INTERNAL_FRAME;
  77   role_table [ATK_ROLE_LABEL] =               Accessibility_ROLE_LABEL;
  78   role_table [ATK_ROLE_LAYERED_PANE] =        Accessibility_ROLE_LAYERED_PANE;
  79   role_table [ATK_ROLE_LIST] =                Accessibility_ROLE_LIST;
  80   role_table [ATK_ROLE_LIST_ITEM] =           Accessibility_ROLE_LIST_ITEM;
  81   role_table [ATK_ROLE_MENU] =                Accessibility_ROLE_MENU;
  82   role_table [ATK_ROLE_MENU_BAR] =            Accessibility_ROLE_MENU_BAR;
  83   role_table [ATK_ROLE_MENU_ITEM] =           Accessibility_ROLE_MENU_ITEM;
  84   role_table [ATK_ROLE_OPTION_PANE] =         Accessibility_ROLE_OPTION_PANE;
  85   role_table [ATK_ROLE_PAGE_TAB] =            Accessibility_ROLE_PAGE_TAB;
  86   role_table [ATK_ROLE_PAGE_TAB_LIST] =       Accessibility_ROLE_PAGE_TAB_LIST;
  87   role_table [ATK_ROLE_PANEL] =               Accessibility_ROLE_PANEL;
  88   role_table [ATK_ROLE_PASSWORD_TEXT] =       Accessibility_ROLE_PASSWORD_TEXT;
  89   role_table [ATK_ROLE_POPUP_MENU] =          Accessibility_ROLE_POPUP_MENU;
  90   role_table [ATK_ROLE_PROGRESS_BAR] =        Accessibility_ROLE_PROGRESS_BAR;
  91   role_table [ATK_ROLE_PUSH_BUTTON] =         Accessibility_ROLE_PUSH_BUTTON;
  92   role_table [ATK_ROLE_RADIO_BUTTON] =        Accessibility_ROLE_RADIO_BUTTON;
  93   role_table [ATK_ROLE_RADIO_MENU_ITEM] =     Accessibility_ROLE_RADIO_MENU_ITEM;
  94   role_table [ATK_ROLE_ROOT_PANE] =           Accessibility_ROLE_ROOT_PANE;
  95   role_table [ATK_ROLE_ROW_HEADER] =          Accessibility_ROLE_ROW_HEADER;
  96   role_table [ATK_ROLE_SCROLL_BAR] =          Accessibility_ROLE_SCROLL_BAR;
  97   role_table [ATK_ROLE_SCROLL_PANE] =         Accessibility_ROLE_SCROLL_PANE;
  98   role_table [ATK_ROLE_SEPARATOR] =           Accessibility_ROLE_SEPARATOR;
  99   role_table [ATK_ROLE_SLIDER] =              Accessibility_ROLE_SLIDER;
 100   role_table [ATK_ROLE_SPIN_BUTTON] =         Accessibility_ROLE_SPIN_BUTTON;
 101   role_table [ATK_ROLE_SPLIT_PANE] =          Accessibility_ROLE_SPLIT_PANE;
 102   role_table [ATK_ROLE_STATUSBAR] =           Accessibility_ROLE_STATUS_BAR;
 103   role_table [ATK_ROLE_TABLE] =               Accessibility_ROLE_TABLE;
 104   role_table [ATK_ROLE_TABLE_CELL] =          Accessibility_ROLE_TABLE_CELL;
 105   role_table [ATK_ROLE_TABLE_COLUMN_HEADER] = Accessibility_ROLE_TABLE_COLUMN_HEADER;
 106   role_table [ATK_ROLE_TABLE_ROW_HEADER] =    Accessibility_ROLE_TABLE_ROW_HEADER;
 107   role_table [ATK_ROLE_TEAR_OFF_MENU_ITEM] =  Accessibility_ROLE_TEAROFF_MENU_ITEM;
 108   role_table [ATK_ROLE_TERMINAL] =            Accessibility_ROLE_TERMINAL;
 109   role_table [ATK_ROLE_TEXT] =                Accessibility_ROLE_TEXT;
 110   role_table [ATK_ROLE_TOGGLE_BUTTON] =       Accessibility_ROLE_TOGGLE_BUTTON;
 111   role_table [ATK_ROLE_TOOL_BAR] =            Accessibility_ROLE_TOOL_BAR;
 112   role_table [ATK_ROLE_TOOL_TIP] =            Accessibility_ROLE_TOOL_TIP;
 113   role_table [ATK_ROLE_TREE] =                Accessibility_ROLE_TREE;
 114   role_table [ATK_ROLE_TREE_TABLE] =          Accessibility_ROLE_TREE_TABLE;
 115   role_table [ATK_ROLE_UNKNOWN] =             Accessibility_ROLE_UNKNOWN;
 116   role_table [ATK_ROLE_VIEWPORT] =            Accessibility_ROLE_VIEWPORT;
 117   role_table [ATK_ROLE_WINDOW] =              Accessibility_ROLE_WINDOW;
 118   role_table [ATK_ROLE_HEADER] =              Accessibility_ROLE_HEADER;
 119   role_table [ATK_ROLE_FOOTER] =              Accessibility_ROLE_FOOTER;
 120   role_table [ATK_ROLE_PARAGRAPH] =           Accessibility_ROLE_PARAGRAPH;
 121   role_table [ATK_ROLE_RULER] =               Accessibility_ROLE_RULER;
 122   role_table [ATK_ROLE_APPLICATION] =         Accessibility_ROLE_APPLICATION;
 123   role_table [ATK_ROLE_AUTOCOMPLETE] =        Accessibility_ROLE_AUTOCOMPLETE;
 124   role_table [ATK_ROLE_EDITBAR] =             Accessibility_ROLE_EDITBAR;
 125   role_table [ATK_ROLE_EMBEDDED] =            Accessibility_ROLE_EMBEDDED;
 126   role_table [ATK_ROLE_ENTRY] =               Accessibility_ROLE_ENTRY;
 127   role_table [ATK_ROLE_CHART] =               Accessibility_ROLE_CHART;
 128   role_table [ATK_ROLE_CAPTION] =             Accessibility_ROLE_CAPTION;
 129   role_table [ATK_ROLE_DOCUMENT_FRAME] =      Accessibility_ROLE_DOCUMENT_FRAME;
 130   role_table [ATK_ROLE_HEADING] =             Accessibility_ROLE_HEADING;
 131   role_table [ATK_ROLE_PAGE] =                Accessibility_ROLE_PAGE;
 132   role_table [ATK_ROLE_SECTION] =             Accessibility_ROLE_SECTION;
 133   role_table [ATK_ROLE_FORM] =                Accessibility_ROLE_FORM;
 134   return TRUE;
 135 }
 136
 137 Accessibility_Role
 138 spi_accessible_role_from_atk_role (AtkRole role)
 139 {
 140   static gboolean is_initialized = FALSE;
 141   static Accessibility_Role spi_role_table [ATK_ROLE_LAST_DEFINED];
 142   Accessibility_Role spi_role;
 143
 144   if (!is_initialized)
 145    {
 146      is_initialized = spi_init_role_lookup_table (spi_role_table);
 147    }
 148
 149   if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)
 150     {
 151       spi_role = spi_role_table [role];
 152     }
 153   else
 154     {
 155       spi_role = Accessibility_ROLE_EXTENDED;
 156     }
 157   return spi_role;
 158 }
 159
 160 static AtkObject *
 161 get_atkobject_from_servant (PortableServer_Servant servant)
 162 {
 163   SpiBase *object = SPI_BASE (bonobo_object_from_servant (servant));
 164
 165   g_return_val_if_fail (object, NULL);
 166   g_return_val_if_fail (ATK_IS_OBJECT(object->gobj), NULL);
 167   return ATK_OBJECT(object->gobj);
 168 }
 169
 170 /*
 171  * CORBA Accessibility::Accessible::get_name method implementation
 172  */
 173 static CORBA_char *
 174 impl_accessibility_accessible_get_name (PortableServer_Servant servant,
 175                                         CORBA_Environment     *ev)
 176 {
 177   const gchar *name;
 178   CORBA_char  *retval;
 179   AtkObject   *object = get_atkobject_from_servant (servant);
 180
 181   g_return_val_if_fail (object != NULL, CORBA_string_dup (""));
 182
 183   name = atk_object_get_name (object);
 184
 185   if (name)
 186     {
 187       retval = CORBA_string_dup (name);
 188     }
 189   else
 190     {
 191       retval = CORBA_string_dup ("");
 192     }
 193
 194   return retval;
 195 }
 196
 197 /*
 198  * CORBA Accessibility::Accessible::set_name method implementation
 199  */
 200 static void
 201 impl_accessibility_accessible_set_name (PortableServer_Servant servant,
 202                                         const CORBA_char      *name,
 203                                         CORBA_Environment     *ev)
 204 {
 205   AtkObject *object = get_atkobject_from_servant (servant);
 206
 207   g_return_if_fail (object != NULL);
 208
 209   atk_object_set_name (object, name);
 210 }
 211
 212 /*
 213  * CORBA Accessibility::Accessible::get_description method implementation
 214  */
 215 static CORBA_char *
 216 impl_accessibility_accessible_get_description (PortableServer_Servant servant,
 217                                                CORBA_Environment     *ev)
 218 {
 219   const gchar *descr;
 220   CORBA_char  *retval;
 221   AtkObject   *object = get_atkobject_from_servant (servant);
 222
 223   g_return_val_if_fail (object != NULL, CORBA_string_dup (""));
 224
 225   descr = atk_object_get_description (object);
 226
 227   if (descr)
 228     {
 229       retval = CORBA_string_dup (descr);
 230     }
 231   else
 232     {
 233       retval = CORBA_string_dup ("");
 234     }
 235
 236   return retval;
 237 }
 238
 239 /*
 240  * CORBA Accessibility::Accessible::set_description method implementation
 241  */
 242 static void
 243 impl_accessibility_accessible_set_description (PortableServer_Servant servant,
 244                                                const CORBA_char      *descr,
 245                                                CORBA_Environment     *ev)
 246 {
 247   AtkObject *object = get_atkobject_from_servant (servant);
 248
 249   g_return_if_fail (object != NULL);
 250
 251   atk_object_set_description (object, descr);
 252 }
 253
 254 /*
 255  * CORBA Accessibility::Accessible::get_parent method implementation
 256  */
 257 static Accessibility_Accessible
 258 impl_accessibility_accessible_get_parent (PortableServer_Servant servant,
 259                                           CORBA_Environment     *ev)
 260 {
 261   AtkObject *parent;
 262   AtkObject *object = get_atkobject_from_servant (servant);
 263
 264   g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL);
 265
 266   parent = atk_object_get_parent (object);
 267
 268   return spi_accessible_new_return (parent, FALSE, ev);
 269 }
 270
 271 /*
 272  * CORBA Accessibility::Accessible::get_IndexInParent method implementation
 273  */
 274 static CORBA_long
 275 impl_accessibility_accessible_get_index_in_parent (PortableServer_Servant servant,
 276                                                    CORBA_Environment     *ev)
 277 {
 278   AtkObject *object = get_atkobject_from_servant (servant);
 279
 280   g_return_val_if_fail (object != NULL, -1);
 281
 282   return atk_object_get_index_in_parent (object);
 283 }
 284
 285 /*
 286  * CORBA Accessibility::Accessible::get_childCount method implementation
 287  */
 288 static CORBA_long
 289 impl_accessibility_accessible_get_child_count (PortableServer_Servant servant,
 290                                                CORBA_Environment     *ev)
 291 {
 292   AtkObject *object = get_atkobject_from_servant (servant);
 293
 294   g_return_val_if_fail (object != NULL, 0);
 295
 296   return atk_object_get_n_accessible_children (object);
 297 }
 298
 299 /*
 300  * CORBA Accessibility::Accessible::getChildAtIndex method implementation
 301  */
 302 static Accessibility_Accessible
 303 impl_accessibility_accessible_get_child_at_index (PortableServer_Servant servant,
 304                                                   const CORBA_long      index,
 305                                                   CORBA_Environment     *ev)
 306 {
 307   AtkObject *child;
 308   AtkObject *object = get_atkobject_from_servant (servant);
 309
 310   g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL);
 311
 312   child = atk_object_ref_accessible_child (object, index);
 313
 314   return spi_accessible_new_return (child, TRUE, ev);
 315 }
 316
 317 /*
 318  * CORBA Accessibility::Accessible::getState method implementation
 319  */
 320 static Accessibility_StateSet
 321 impl_accessibility_accessible_get_state (PortableServer_Servant servant,
 322                                          CORBA_Environment     *ev)
 323 {
 324   AtkObject *object = get_atkobject_from_servant (servant);
 325   AtkStateSet *atk_set;
 326   SpiStateSet *set;
 327   Accessibility_StateSet retval;
 328
 329   bonobo_return_val_if_fail (object != NULL, NULL, ev);
 330
 331   atk_set = atk_object_ref_state_set (object);
 332
 333   set = spi_state_set_new (atk_set);
 334   retval = bonobo_object_dup_ref (
 335                                   BONOBO_OBJREF(set),
 336                                   ev);
 337
 338   return retval;
 339 }
 340
 341 /*
 342  * CORBA Accessibility::Accessible::getRelationSet method implementation
 343  */
 344 static Accessibility_RelationSet *
 345 impl_accessibility_accessible_get_relation_set (PortableServer_Servant servant,
 346                                                 CORBA_Environment     *ev)
 347 {
 348   Accessibility_RelationSet *retval;
 349   gint n_relations;
 350   gint i;
 351   AtkRelationSet *relation_set;
 352   AtkObject      *object = get_atkobject_from_servant (servant);
 353
 354   bonobo_return_val_if_fail (object != NULL, NULL, ev);
 355
 356   relation_set = atk_object_ref_relation_set (object);
 357
 358   n_relations = atk_relation_set_get_n_relations (relation_set);
 359
 360   retval = CORBA_sequence_Accessibility_Relation__alloc ();
 361   retval->_length = retval->_maximum = n_relations;
 362   retval->_buffer = CORBA_sequence_Accessibility_Relation_allocbuf (n_relations);
 363   CORBA_sequence_set_release (retval, CORBA_TRUE);
 364
 365   for (i = 0; i < n_relations; ++i)
 366     {
 367       retval->_buffer[i] =
 368         bonobo_object_dup_ref (
 369           BONOBO_OBJREF (
 370             spi_relation_new (atk_relation_set_get_relation (relation_set, i))),
 371           ev);
 372     }
 373
 374   return retval;
 375 }
 376
 377 /*
 378  * CORBA Accessibility::Accessible::getRole method implementation
 379  */
 380 static Accessibility_Role
 381 impl_accessibility_accessible_get_role (PortableServer_Servant servant,
 382                                         CORBA_Environment     *ev)
 383 {
 384   AtkRole            role;
 385   Accessibility_Role retval;
 386   AtkObject         *object = get_atkobject_from_servant (servant);
 387
 388   g_return_val_if_fail (object != NULL, 0);
 389
 390   role = atk_object_get_role (object);
 391   retval = spi_role_from_atk_role (role);
 392
 393   return retval;
 394 }
 395
 396 /*
 397  * CORBA Accessibility::Accessible::getRole method implementation
 398  */
 399 static CORBA_char *
 400 impl_accessibility_accessible_get_role_name (PortableServer_Servant servant,
 401                                              CORBA_Environment     *ev)
 402 {
 403   const gchar     *role_name;
 404   AtkRole    role;
 405   AtkObject *object = get_atkobject_from_servant (servant);
 406
 407   g_return_val_if_fail (object != NULL, NULL);
 408
 409   role = atk_object_get_role (object);
 410
 411   role_name = atk_role_get_name (role);
 412   if (role_name)
 413     return CORBA_string_dup (role_name);
 414   else
 415     return CORBA_string_dup ("");
 416 }
 417
 418 /*
 419  * CORBA Accessibility::Accessible::getLocalizedRole method implementation
 420  */
 421 static CORBA_char *
 422 impl_accessibility_accessible_get_local_role_name (PortableServer_Servant servant,
 423                                                    CORBA_Environment     *ev)
 424 {
 425   const gchar     *role_name;
 426   AtkRole    role;
 427   AtkObject *object = get_atkobject_from_servant (servant);
 428
 429   g_return_val_if_fail (object != NULL, NULL);
 430
 431   role = atk_object_get_role (object);
 432
 433   role_name = atk_role_get_localized_name (role);
 434   if (role_name)
 435     return CORBA_string_dup (role_name);
 436   else
 437     return CORBA_string_dup ("");
 438 }
 439
 440 static Accessibility_Accessible
 441 impl_accessibility_accessible_get_application (PortableServer_Servant servant,
 442                                                CORBA_Environment     *ev)
 443 {
 444     return spi_accessible_new_return (atk_get_root (), FALSE, ev);
 445 }
 446
 447 static Accessibility_AttributeSet*
 448 impl_accessibility_accessible_get_attributes (PortableServer_Servant servant,
 449                                                CORBA_Environment     *ev)
 450 {
 451     Accessibility_AttributeSet *retval;
 452     GSList *attributes;
 453     gint n_attributes = 0;
 454     gint i;
 455
 456     AtkObject *object = get_atkobject_from_servant (servant);
 457
 458     g_return_val_if_fail (object != NULL, NULL);
 459     attributes = atk_object_get_attributes (object);
 460
 461     bonobo_return_val_if_fail (attributes != NULL, NULL, ev);
 462     n_attributes = g_slist_length (attributes);
 463
 464     retval = CORBA_sequence_CORBA_string__alloc ();
 465     retval->_length = retval->_maximum = n_attributes;
 466     retval->_buffer = CORBA_sequence_CORBA_string_allocbuf (n_attributes);
 467     CORBA_sequence_set_release (retval, CORBA_TRUE);
 468
 469     for (i = 0; i < n_attributes; ++i)
 470     {
 471         retval->_buffer[i] = CORBA_string_dup (g_slist_nth_data (attributes, i));
 472     }
 473
 474   return retval;
 475 }
 476
 477 static void
 478 spi_accessible_class_init (SpiAccessibleClass *klass)
 479 {
 480         POA_Accessibility_Accessible__epv *epv = &klass->epv;
 481
 482         epv->_get_name = impl_accessibility_accessible_get_name;
 483         epv->_set_name = impl_accessibility_accessible_set_name;
 484         epv->_get_description = impl_accessibility_accessible_get_description;
 485         epv->_set_description = impl_accessibility_accessible_set_description;
 486
 487         epv->_get_parent = impl_accessibility_accessible_get_parent;
 488         epv->_get_childCount = impl_accessibility_accessible_get_child_count;
 489         epv->getChildAtIndex = impl_accessibility_accessible_get_child_at_index;
 490         epv->getIndexInParent = impl_accessibility_accessible_get_index_in_parent;
 491
 492         epv->getRelationSet = impl_accessibility_accessible_get_relation_set;
 493         epv->getState = impl_accessibility_accessible_get_state;
 494         epv->getRole = impl_accessibility_accessible_get_role;
 495         epv->getRoleName = impl_accessibility_accessible_get_role_name;
 496         epv->getLocalizedRoleName = impl_accessibility_accessible_get_local_role_name;
 497         epv->getApplication = impl_accessibility_accessible_get_application;
 498         epv->getAttributes = impl_accessibility_accessible_get_attributes;
 499 }
 500
 501 static void
 502 spi_accessible_init (SpiAccessible *accessible)
 503 {
 504 }
 505
 506 BONOBO_TYPE_FUNC_FULL (SpiAccessible,
 507                        Accessibility_Accessible,
 508                        PARENT_TYPE,
 509                        spi_accessible)
 510
 511 static GHashTable *public_corba_refs = NULL;
 512
 513 static GHashTable *
 514 get_public_refs (void)
 515 {
 516   if (!public_corba_refs)
 517     {
 518       public_corba_refs = g_hash_table_new (NULL, NULL);
 519     }
 520   return public_corba_refs;
 521 }
 522
 523 static void
 524 de_register_public_ref (SpiBase *object)
 525 {
 526   g_hash_table_remove (get_public_refs (), object->gobj);
 527 }
 528
 529 SpiAccessible *
 530 spi_accessible_new (AtkObject *o)
 531 {
 532   return spi_accessible_construct (SPI_ACCESSIBLE_TYPE, o);
 533 }
 534
 535 SpiAccessible *
 536 spi_accessible_construct (GType type, AtkObject *o)
 537 {
 538     SpiAccessible *retval;
 539     CORBA_Environment ev;
 540
 541     CORBA_exception_init (&ev);
 542
 543     g_assert (o);
 544     g_assert (g_type_is_a (type, SPI_ACCESSIBLE_TYPE));
 545
 546     if ((retval = g_hash_table_lookup (get_public_refs (), o)))
 547       {
 548         bonobo_object_ref (BONOBO_OBJECT (retval));
 549         return retval;
 550       }
 551     else
 552       {
 553         retval = g_object_new (type, NULL);
 554         spi_base_construct (SPI_BASE (retval), G_OBJECT(o));
 555       }
 556
 557     g_hash_table_insert (get_public_refs (), o, retval);
 558     g_signal_connect (G_OBJECT (retval), "destroy",
 559                       G_CALLBACK (de_register_public_ref),
 560                       NULL);
 561
 562     /* aggregate appropriate SPI interfaces based on ATK interfaces */
 563
 564     if (ATK_IS_ACTION (o))
 565       {
 566         bonobo_object_add_interface (bonobo_object (retval),
 567                 BONOBO_OBJECT (spi_action_interface_new (o)));
 568       }
 569
 570     if (ATK_IS_COMPONENT (o))
 571       {
 572         bonobo_object_add_interface (bonobo_object (retval),
 573                                      BONOBO_OBJECT (spi_component_interface_new (o)));
 574       }
 575
 576     if (ATK_IS_EDITABLE_TEXT (o))
 577       {
 578          bonobo_object_add_interface (bonobo_object (retval),
 579                                       BONOBO_OBJECT(spi_editable_text_interface_new (o)));
 580       }
 581
 582     else if (ATK_IS_TEXT (o))
 583        {
 584          bonobo_object_add_interface (bonobo_object (retval),
 585                                       BONOBO_OBJECT (spi_text_interface_new (o)));
 586        }
 587
 588     if (ATK_IS_HYPERTEXT (o))
 589       {
 590         bonobo_object_add_interface (bonobo_object (retval),
 591                                      BONOBO_OBJECT (spi_hypertext_interface_new (o)));
 592       }
 593
 594     if (ATK_IS_IMAGE (o))
 595       {
 596         bonobo_object_add_interface (bonobo_object (retval),
 597                                      BONOBO_OBJECT (spi_image_interface_new (o)));
 598       }
 599
 600     if (ATK_IS_SELECTION (o))
 601       {
 602         bonobo_object_add_interface (bonobo_object (retval),
 603                                      BONOBO_OBJECT (spi_selection_interface_new (o)));
 604       }
 605
 606     if (ATK_IS_TABLE (o))
 607       {
 608         bonobo_object_add_interface (bonobo_object (retval),
 609                                      BONOBO_OBJECT (spi_table_interface_new (o)));
 610       }
 611
 612     if (ATK_IS_VALUE (o))
 613       {
 614         bonobo_object_add_interface (bonobo_object (retval),
 615                                      BONOBO_OBJECT (spi_value_interface_new (o)));
 616       }
 617
 618     return retval;
 619 }
 620
 621 /**
 622  * spi_accessible_new_return:
 623  * @o: an AtkObject or NULL
 624  * @release_ref: whether to unref this AtkObject before return
 625  * @ev: a CORBA environment
 626  *
 627  * A helper function to instantiate a CORBA accessiblility
 628  * proxy from an AtkObject.
 629  *
 630  * Return value: the proxy or CORBA_OBJECT_NIL
 631  **/
 632 Accessibility_Accessible
 633 spi_accessible_new_return (AtkObject         *o,
 634                            gboolean           release_ref,
 635                            CORBA_Environment *ev)
 636 {
 637   SpiAccessible *accessible;
 638   Accessibility_Accessible retval;
 639
 640   if (!o)
 641     {
 642       return CORBA_OBJECT_NIL;
 643     }
 644   else if (SPI_IS_REMOTE_OBJECT (o))
 645     {
 646       retval = spi_remote_object_get_accessible (SPI_REMOTE_OBJECT (o));
 647     }
 648   else
 649     {
 650       accessible = spi_accessible_construct (SPI_ACCESSIBLE_TYPE, o);
 651       retval = CORBA_Object_duplicate (BONOBO_OBJREF (accessible), ev);
 652     }
 653
 654   if (release_ref)
 655     {
 656       g_object_unref (G_OBJECT (o));
 657     }
 658
 659   return retval;
 660 }