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