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   role_table [ATK_ROLE_REDUNDANT_OBJECT] =    Accessibility_ROLE_REDUNDANT_OBJECT;
 135   role_table [ATK_ROLE_LINK] =                Accessibility_ROLE_LINK;
 136   role_table [ATK_ROLE_INPUT_METHOD_WINDOW] = Accessibility_ROLE_INPUT_METHOD_WINDOW;
 137   return TRUE;
 138 }
 139
 140 Accessibility_Role
 141 spi_accessible_role_from_atk_role (AtkRole role)
 142 {
 143   static gboolean is_initialized = FALSE;
 144   static Accessibility_Role spi_role_table [ATK_ROLE_LAST_DEFINED];
 145   Accessibility_Role spi_role;
 146
 147   if (!is_initialized)
 148    {
 149      is_initialized = spi_init_role_lookup_table (spi_role_table);
 150    }
 151
 152   if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)
 153     {
 154       spi_role = spi_role_table [role];
 155     }
 156   else
 157     {
 158       spi_role = Accessibility_ROLE_EXTENDED;
 159     }
 160   return spi_role;
 161 }
 162
 163 static AtkObject *
 164 get_atkobject_from_servant (PortableServer_Servant servant)
 165 {
 166   SpiBase *object = SPI_BASE (bonobo_object_from_servant (servant));
 167
 168   g_return_val_if_fail (object, NULL);
 169   g_return_val_if_fail (ATK_IS_OBJECT(object->gobj), NULL);
 170   return ATK_OBJECT(object->gobj);
 171 }
 172
 173 /*
 174  * CORBA Accessibility::Accessible::get_name method implementation
 175  */
 176 static CORBA_char *
 177 impl_accessibility_accessible_get_name (PortableServer_Servant servant,
 178                                         CORBA_Environment     *ev)
 179 {
 180   const gchar *name;
 181   CORBA_char  *retval;
 182   AtkObject   *object = get_atkobject_from_servant (servant);
 183
 184   g_return_val_if_fail (object != NULL, CORBA_string_dup (""));
 185
 186   name = atk_object_get_name (object);
 187
 188   if (name)
 189     {
 190       retval = CORBA_string_dup (name);
 191     }
 192   else
 193     {
 194       retval = CORBA_string_dup ("");
 195     }
 196
 197   return retval;
 198 }
 199
 200 /*
 201  * CORBA Accessibility::Accessible::set_name method implementation
 202  */
 203 static void
 204 impl_accessibility_accessible_set_name (PortableServer_Servant servant,
 205                                         const CORBA_char      *name,
 206                                         CORBA_Environment     *ev)
 207 {
 208   AtkObject *object = get_atkobject_from_servant (servant);
 209
 210   g_return_if_fail (object != NULL);
 211
 212   atk_object_set_name (object, name);
 213 }
 214
 215 /*
 216  * CORBA Accessibility::Accessible::get_description method implementation
 217  */
 218 static CORBA_char *
 219 impl_accessibility_accessible_get_description (PortableServer_Servant servant,
 220                                                CORBA_Environment     *ev)
 221 {
 222   const gchar *descr;
 223   CORBA_char  *retval;
 224   AtkObject   *object = get_atkobject_from_servant (servant);
 225
 226   g_return_val_if_fail (object != NULL, CORBA_string_dup (""));
 227
 228   descr = atk_object_get_description (object);
 229
 230   if (descr)
 231     {
 232       retval = CORBA_string_dup (descr);
 233     }
 234   else
 235     {
 236       retval = CORBA_string_dup ("");
 237     }
 238
 239   return retval;
 240 }
 241
 242 /*
 243  * CORBA Accessibility::Accessible::set_description method implementation
 244  */
 245 static void
 246 impl_accessibility_accessible_set_description (PortableServer_Servant servant,
 247                                                const CORBA_char      *descr,
 248                                                CORBA_Environment     *ev)
 249 {
 250   AtkObject *object = get_atkobject_from_servant (servant);
 251
 252   g_return_if_fail (object != NULL);
 253
 254   atk_object_set_description (object, descr);
 255 }
 256
 257 /*
 258  * CORBA Accessibility::Accessible::get_parent method implementation
 259  */
 260 static Accessibility_Accessible
 261 impl_accessibility_accessible_get_parent (PortableServer_Servant servant,
 262                                           CORBA_Environment     *ev)
 263 {
 264   AtkObject *parent;
 265   AtkObject *object = get_atkobject_from_servant (servant);
 266
 267   g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL);
 268
 269   parent = atk_object_get_parent (object);
 270
 271   return spi_accessible_new_return (parent, FALSE, ev);
 272 }
 273
 274 /*
 275  * CORBA Accessibility::Accessible::get_IndexInParent method implementation
 276  */
 277 static CORBA_long
 278 impl_accessibility_accessible_get_index_in_parent (PortableServer_Servant servant,
 279                                                    CORBA_Environment     *ev)
 280 {
 281   AtkObject *object = get_atkobject_from_servant (servant);
 282
 283   g_return_val_if_fail (object != NULL, -1);
 284
 285   return atk_object_get_index_in_parent (object);
 286 }
 287
 288 /*
 289  * CORBA Accessibility::Accessible::get_childCount method implementation
 290  */
 291 static CORBA_long
 292 impl_accessibility_accessible_get_child_count (PortableServer_Servant servant,
 293                                                CORBA_Environment     *ev)
 294 {
 295   AtkObject *object = get_atkobject_from_servant (servant);
 296
 297   g_return_val_if_fail (object != NULL, 0);
 298
 299   return atk_object_get_n_accessible_children (object);
 300 }
 301
 302 /*
 303  * CORBA Accessibility::Accessible::getChildAtIndex method implementation
 304  */
 305 static Accessibility_Accessible
 306 impl_accessibility_accessible_get_child_at_index (PortableServer_Servant servant,
 307                                                   const CORBA_long      index,
 308                                                   CORBA_Environment     *ev)
 309 {
 310   AtkObject *child;
 311   AtkObject *object = get_atkobject_from_servant (servant);
 312
 313   g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL);
 314
 315   child = atk_object_ref_accessible_child (object, index);
 316
 317   return spi_accessible_new_return (child, TRUE, ev);
 318 }
 319
 320 /*
 321  * CORBA Accessibility::Accessible::getState method implementation
 322  */
 323 static Accessibility_StateSet
 324 impl_accessibility_accessible_get_state (PortableServer_Servant servant,
 325                                          CORBA_Environment     *ev)
 326 {
 327   AtkObject *object = get_atkobject_from_servant (servant);
 328   AtkStateSet *atk_set;
 329   SpiStateSet *set;
 330   Accessibility_StateSet retval;
 331
 332   bonobo_return_val_if_fail (object != NULL, NULL, ev);
 333
 334   atk_set = atk_object_ref_state_set (object);
 335
 336   set = spi_state_set_new (atk_set);
 337   retval = CORBA_Object_duplicate (
 338                                   BONOBO_OBJREF(set),
 339                                   NULL);
 340
 341   g_object_unref (atk_set);
 342
 343   return retval;
 344 }
 345
 346 /*
 347  * CORBA Accessibility::Accessible::getRelationSet method implementation
 348  */
 349 static Accessibility_RelationSet *
 350 impl_accessibility_accessible_get_relation_set (PortableServer_Servant servant,
 351                                                 CORBA_Environment     *ev)
 352 {
 353   Accessibility_RelationSet *retval;
 354   gint n_relations = 0;
 355   gint i;
 356   AtkRelationSet *relation_set;
 357   AtkObject      *object = get_atkobject_from_servant (servant);
 358
 359   bonobo_return_val_if_fail (object != NULL, NULL, ev);
 360
 361   relation_set = atk_object_ref_relation_set (object);
 362
 363   if (relation_set)
 364     n_relations = atk_relation_set_get_n_relations (relation_set);
 365
 366   retval = CORBA_sequence_Accessibility_Relation__alloc ();
 367   retval->_length = retval->_maximum = n_relations;
 368   retval->_buffer = CORBA_sequence_Accessibility_Relation_allocbuf (n_relations);
 369   CORBA_sequence_set_release (retval, CORBA_TRUE);
 370
 371   for (i = 0; i < n_relations; ++i)
 372     {
 373       retval->_buffer[i] =
 374         CORBA_Object_duplicate (
 375           BONOBO_OBJREF (
 376             spi_relation_new (atk_relation_set_get_relation (relation_set, i))),
 377           NULL);
 378     }
 379
 380   return retval;
 381 }
 382
 383 /*
 384  * CORBA Accessibility::Accessible::getRole method implementation
 385  */
 386 static Accessibility_Role
 387 impl_accessibility_accessible_get_role (PortableServer_Servant servant,
 388                                         CORBA_Environment     *ev)
 389 {
 390   AtkRole            role;
 391   Accessibility_Role retval;
 392   AtkObject         *object = get_atkobject_from_servant (servant);
 393
 394   g_return_val_if_fail (object != NULL, 0);
 395
 396   role = atk_object_get_role (object);
 397   retval = spi_role_from_atk_role (role);
 398
 399   return retval;
 400 }
 401
 402 /*
 403  * CORBA Accessibility::Accessible::getRole method implementation
 404  */
 405 static CORBA_char *
 406 impl_accessibility_accessible_get_role_name (PortableServer_Servant servant,
 407                                              CORBA_Environment     *ev)
 408 {
 409   const gchar     *role_name;
 410   AtkRole    role;
 411   AtkObject *object = get_atkobject_from_servant (servant);
 412
 413   g_return_val_if_fail (object != NULL, NULL);
 414
 415   role = atk_object_get_role (object);
 416
 417   role_name = atk_role_get_name (role);
 418   if (role_name)
 419     return CORBA_string_dup (role_name);
 420   else
 421     return CORBA_string_dup ("");
 422 }
 423
 424 /*
 425  * CORBA Accessibility::Accessible::getLocalizedRole method implementation
 426  */
 427 static CORBA_char *
 428 impl_accessibility_accessible_get_local_role_name (PortableServer_Servant servant,
 429                                                    CORBA_Environment     *ev)
 430 {
 431   const gchar     *role_name;
 432   AtkRole    role;
 433   AtkObject *object = get_atkobject_from_servant (servant);
 434
 435   g_return_val_if_fail (object != NULL, NULL);
 436
 437   role = atk_object_get_role (object);
 438
 439   role_name = atk_role_get_localized_name (role);
 440   if (role_name)
 441     return CORBA_string_dup (role_name);
 442   else
 443     return CORBA_string_dup ("");
 444 }
 445
 446 static Accessibility_Accessible
 447 impl_accessibility_accessible_get_application (PortableServer_Servant servant,
 448                                                CORBA_Environment     *ev)
 449 {
 450     return spi_accessible_new_return (atk_get_root (), FALSE, ev);
 451 }
 452
 453 static Accessibility_AttributeSet*
 454 impl_accessibility_accessible_get_attributes (PortableServer_Servant servant,
 455                                                CORBA_Environment     *ev)
 456 {
 457     Accessibility_AttributeSet *retval;
 458     AtkAttributeSet *attributes = NULL;
 459     AtkAttribute *attr = NULL;
 460     gint n_attributes = 0;
 461     gint i;
 462
 463     AtkObject *object = get_atkobject_from_servant (servant);
 464
 465     g_return_val_if_fail (object != NULL, NULL);
 466     attributes = atk_object_get_attributes (object);
 467
 468     if (attributes)
 469       n_attributes = g_slist_length (attributes);
 470
 471     retval = CORBA_sequence_CORBA_string__alloc ();
 472     retval->_length = retval->_maximum = n_attributes;
 473     retval->_buffer = CORBA_sequence_CORBA_string_allocbuf (n_attributes);
 474     CORBA_sequence_set_release (retval, CORBA_TRUE);
 475
 476     for (i = 0; i < n_attributes; ++i)
 477     {
 478         attr = g_slist_nth_data (attributes, i);
 479         retval->_buffer[i] = CORBA_string_dup (g_strconcat (attr->name, ":", attr->value, NULL));
 480     }
 481
 482     atk_attribute_set_free (attributes);
 483
 484   return retval;
 485 }
 486
 487 static void
 488 spi_accessible_class_init (SpiAccessibleClass *klass)
 489 {
 490         POA_Accessibility_Accessible__epv *epv = &klass->epv;
 491
 492         epv->_get_name = impl_accessibility_accessible_get_name;
 493         epv->_set_name = impl_accessibility_accessible_set_name;
 494         epv->_get_description = impl_accessibility_accessible_get_description;
 495         epv->_set_description = impl_accessibility_accessible_set_description;
 496
 497         epv->_get_parent = impl_accessibility_accessible_get_parent;
 498         epv->_get_childCount = impl_accessibility_accessible_get_child_count;
 499         epv->getChildAtIndex = impl_accessibility_accessible_get_child_at_index;
 500         epv->getIndexInParent = impl_accessibility_accessible_get_index_in_parent;
 501
 502         epv->getRelationSet = impl_accessibility_accessible_get_relation_set;
 503         epv->getState = impl_accessibility_accessible_get_state;
 504         epv->getRole = impl_accessibility_accessible_get_role;
 505         epv->getRoleName = impl_accessibility_accessible_get_role_name;
 506         epv->getLocalizedRoleName = impl_accessibility_accessible_get_local_role_name;
 507         epv->getApplication = impl_accessibility_accessible_get_application;
 508         epv->getAttributes = impl_accessibility_accessible_get_attributes;
 509 }
 510
 511 static void
 512 spi_accessible_init (SpiAccessible *accessible)
 513 {
 514 }
 515
 516 BONOBO_TYPE_FUNC_FULL (SpiAccessible,
 517                        Accessibility_Accessible,
 518                        PARENT_TYPE,
 519                        spi_accessible)
 520
 521 static GHashTable *public_corba_refs = NULL;
 522
 523 static GHashTable *
 524 get_public_refs (void)
 525 {
 526   if (!public_corba_refs)
 527     {
 528       public_corba_refs = g_hash_table_new (NULL, NULL);
 529     }
 530   return public_corba_refs;
 531 }
 532
 533 static void
 534 de_register_public_ref (SpiBase *object)
 535 {
 536   g_hash_table_remove (get_public_refs (), object->gobj);
 537 }
 538
 539 SpiAccessible *
 540 spi_accessible_new (AtkObject *o)
 541 {
 542   return spi_accessible_construct (SPI_ACCESSIBLE_TYPE, o);
 543 }
 544
 545 SpiAccessible *
 546 spi_accessible_construct (GType type, AtkObject *o)
 547 {
 548     SpiAccessible *retval;
 549     CORBA_Environment ev;
 550
 551     CORBA_exception_init (&ev);
 552
 553     g_assert (o);
 554     g_assert (g_type_is_a (type, SPI_ACCESSIBLE_TYPE));
 555
 556     if ((retval = g_hash_table_lookup (get_public_refs (), o)))
 557       {
 558         bonobo_object_ref (BONOBO_OBJECT (retval));
 559         return retval;
 560       }
 561     else
 562       {
 563         retval = g_object_new (type, NULL);
 564         spi_base_construct (SPI_BASE (retval), G_OBJECT(o));
 565       }
 566
 567     g_hash_table_insert (get_public_refs (), o, retval);
 568     g_signal_connect (G_OBJECT (retval), "destroy",
 569                       G_CALLBACK (de_register_public_ref),
 570                       NULL);
 571
 572     /* aggregate appropriate SPI interfaces based on ATK interfaces */
 573
 574     if (ATK_IS_ACTION (o))
 575       {
 576         bonobo_object_add_interface (bonobo_object (retval),
 577                 BONOBO_OBJECT (spi_action_interface_new (o)));
 578       }
 579
 580     if (ATK_IS_COMPONENT (o))
 581       {
 582         bonobo_object_add_interface (bonobo_object (retval),
 583                                      BONOBO_OBJECT (spi_component_interface_new (o)));
 584       }
 585
 586     if (ATK_IS_EDITABLE_TEXT (o))
 587       {
 588          bonobo_object_add_interface (bonobo_object (retval),
 589                                       BONOBO_OBJECT(spi_editable_text_interface_new (o)));
 590       }
 591
 592     else if (ATK_IS_TEXT (o))
 593        {
 594          bonobo_object_add_interface (bonobo_object (retval),
 595                                       BONOBO_OBJECT (spi_text_interface_new (o)));
 596        }
 597
 598     if (ATK_IS_HYPERTEXT (o))
 599       {
 600         bonobo_object_add_interface (bonobo_object (retval),
 601                                      BONOBO_OBJECT (spi_hypertext_interface_new (o)));
 602       }
 603
 604     if (ATK_IS_IMAGE (o))
 605       {
 606         bonobo_object_add_interface (bonobo_object (retval),
 607                                      BONOBO_OBJECT (spi_image_interface_new (o)));
 608       }
 609
 610     if (ATK_IS_SELECTION (o))
 611       {
 612         bonobo_object_add_interface (bonobo_object (retval),
 613                                      BONOBO_OBJECT (spi_selection_interface_new (o)));
 614       }
 615
 616     if (ATK_IS_TABLE (o))
 617       {
 618         bonobo_object_add_interface (bonobo_object (retval),
 619                                      BONOBO_OBJECT (spi_table_interface_new (o)));
 620       }
 621
 622     if (ATK_IS_VALUE (o))
 623       {
 624         bonobo_object_add_interface (bonobo_object (retval),
 625                                      BONOBO_OBJECT (spi_value_interface_new (o)));
 626       }
 627
 628     if (ATK_IS_STREAMABLE_CONTENT (o))
 629       {
 630         bonobo_object_add_interface (bonobo_object (retval),
 631                                      BONOBO_OBJECT (spi_streamable_interface_new (o)));
 632       }
 633     if (ATK_IS_DOCUMENT (o)) /* We add collection interface to document */
 634       {
 635
 636
 637          SpiDocument *doc = spi_document_interface_new (o);
 638          bonobo_object_add_interface (BONOBO_OBJECT (doc),
 639                                       BONOBO_OBJECT (spi_collection_interface_new (o)));
 640
 641          bonobo_object_add_interface (bonobo_object (retval),
 642                                         BONOBO_OBJECT (doc));
 643       }
 644     if (ATK_IS_HYPERLINK_IMPL (o))
 645       {
 646           /* !!! the cast below is used instead of the ATK_HYPERLINK macro, since
 647            the object 'o' is not really a hyperlink, but is in fact an AtkHyperlinkImpl.
 648            Ouch.  This works since it gets cast back to GObject, but it's nasty and needs
 649            to be cleaned up.
 650           */
 651         bonobo_object_add_interface (bonobo_object (retval),
 652                                      BONOBO_OBJECT (spi_hyperlink_new ((AtkHyperlink*)o)));
 653       }
 654
 655     return retval;
 656 }
 657
 658 /**
 659  * spi_accessible_new_return:
 660  * @o: an AtkObject or NULL
 661  * @release_ref: whether to unref this AtkObject before return
 662  * @ev: a CORBA environment
 663  *
 664  * A helper function to instantiate a CORBA accessiblility
 665  * proxy from an AtkObject.
 666  *
 667  * Return value: the proxy or CORBA_OBJECT_NIL
 668  **/
 669 Accessibility_Accessible
 670 spi_accessible_new_return (AtkObject         *o,
 671                            gboolean           release_ref,
 672                            CORBA_Environment *ev)
 673 {
 674   SpiAccessible *accessible;
 675   Accessibility_Accessible retval;
 676
 677   if (!o)
 678     {
 679       return CORBA_OBJECT_NIL;
 680     }
 681   else if (SPI_IS_REMOTE_OBJECT (o))
 682     {
 683       retval = spi_remote_object_get_accessible (SPI_REMOTE_OBJECT (o));
 684     }
 685   else
 686     {
 687       accessible = spi_accessible_construct (SPI_ACCESSIBLE_TYPE, o);
 688       retval = CORBA_Object_duplicate (BONOBO_OBJREF (accessible), ev);
 689     }
 690
 691   if (release_ref)
 692     {
 693       g_object_unref (G_OBJECT (o));
 694     }
 695
 696   return retval;
 697 }