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
 122   return TRUE;
 123 }
 124
 125 static Accessibility_Role
 126 spi_role_from_atk_role (AtkRole role)
 127 {
 128   static gboolean is_initialized = FALSE;
 129   static Accessibility_Role spi_role_table [ATK_ROLE_LAST_DEFINED];
 130   Accessibility_Role spi_role;
 131
 132   if (!is_initialized)
 133    {
 134      is_initialized = spi_init_role_lookup_table (spi_role_table);
 135    }
 136
 137   if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)
 138     {
 139       spi_role = spi_role_table [role];
 140     }
 141   else
 142     {
 143       spi_role = Accessibility_ROLE_EXTENDED;
 144     }
 145   return spi_role;
 146 }
 147
 148 static AtkObject *
 149 get_atkobject_from_servant (PortableServer_Servant servant)
 150 {
 151   SpiBase *object = SPI_BASE (bonobo_object_from_servant (servant));
 152
 153   g_return_val_if_fail (object, NULL);
 154   g_return_val_if_fail (ATK_IS_OBJECT(object->gobj), NULL);
 155   return ATK_OBJECT(object->gobj);
 156 }
 157
 158 /*
 159  * CORBA Accessibility::Accessible::get_name method implementation
 160  */
 161 static CORBA_char *
 162 impl_accessibility_accessible_get_name (PortableServer_Servant servant,
 163                                         CORBA_Environment     *ev)
 164 {
 165   const gchar *name;
 166   CORBA_char  *retval;
 167   AtkObject   *object = get_atkobject_from_servant (servant);
 168
 169   g_return_val_if_fail (object != NULL, CORBA_string_dup (""));
 170
 171   name = atk_object_get_name (object);
 172
 173   if (name)
 174     {
 175       retval = CORBA_string_dup (name);
 176     }
 177   else
 178     {
 179       retval = CORBA_string_dup ("");
 180     }
 181
 182   return retval;
 183 }
 184
 185 /*
 186  * CORBA Accessibility::Accessible::set_name method implementation
 187  */
 188 static void
 189 impl_accessibility_accessible_set_name (PortableServer_Servant servant,
 190                                         const CORBA_char      *name,
 191                                         CORBA_Environment     *ev)
 192 {
 193   AtkObject *object = get_atkobject_from_servant (servant);
 194
 195   g_return_if_fail (object != NULL);
 196
 197   atk_object_set_name (object, name);
 198 }
 199
 200 /*
 201  * CORBA Accessibility::Accessible::get_description method implementation
 202  */
 203 static CORBA_char *
 204 impl_accessibility_accessible_get_description (PortableServer_Servant servant,
 205                                                CORBA_Environment     *ev)
 206 {
 207   const gchar *descr;
 208   CORBA_char  *retval;
 209   AtkObject   *object = get_atkobject_from_servant (servant);
 210
 211   g_return_val_if_fail (object != NULL, CORBA_string_dup (""));
 212
 213   descr = atk_object_get_description (object);
 214
 215   if (descr)
 216     {
 217       retval = CORBA_string_dup (descr);
 218     }
 219   else
 220     {
 221       retval = CORBA_string_dup ("");
 222     }
 223
 224   return retval;
 225 }
 226
 227 /*
 228  * CORBA Accessibility::Accessible::set_description method implementation
 229  */
 230 static void
 231 impl_accessibility_accessible_set_description (PortableServer_Servant servant,
 232                                                const CORBA_char      *descr,
 233                                                CORBA_Environment     *ev)
 234 {
 235   AtkObject *object = get_atkobject_from_servant (servant);
 236
 237   g_return_if_fail (object != NULL);
 238
 239   atk_object_set_description (object, descr);
 240 }
 241
 242 /*
 243  * CORBA Accessibility::Accessible::get_parent method implementation
 244  */
 245 static Accessibility_Accessible
 246 impl_accessibility_accessible_get_parent (PortableServer_Servant servant,
 247                                           CORBA_Environment     *ev)
 248 {
 249   AtkObject *parent;
 250   AtkObject *object = get_atkobject_from_servant (servant);
 251
 252   g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL);
 253
 254   parent = atk_object_get_parent (object);
 255
 256   return spi_accessible_new_return (parent, FALSE, ev);
 257 }
 258
 259 /*
 260  * CORBA Accessibility::Accessible::get_IndexInParent method implementation
 261  */
 262 static CORBA_long
 263 impl_accessibility_accessible_get_index_in_parent (PortableServer_Servant servant,
 264                                                    CORBA_Environment     *ev)
 265 {
 266   AtkObject *object = get_atkobject_from_servant (servant);
 267
 268   g_return_val_if_fail (object != NULL, -1);
 269
 270   return atk_object_get_index_in_parent (object);
 271 }
 272
 273 /*
 274  * CORBA Accessibility::Accessible::get_childCount method implementation
 275  */
 276 static CORBA_long
 277 impl_accessibility_accessible_get_child_count (PortableServer_Servant servant,
 278                                                CORBA_Environment     *ev)
 279 {
 280   AtkObject *object = get_atkobject_from_servant (servant);
 281
 282   g_return_val_if_fail (object != NULL, 0);
 283
 284   return atk_object_get_n_accessible_children (object);
 285 }
 286
 287 /*
 288  * CORBA Accessibility::Accessible::getChildAtIndex method implementation
 289  */
 290 static Accessibility_Accessible
 291 impl_accessibility_accessible_get_child_at_index (PortableServer_Servant servant,
 292                                                   const CORBA_long      index,
 293                                                   CORBA_Environment     *ev)
 294 {
 295   AtkObject *child;
 296   AtkObject *object = get_atkobject_from_servant (servant);
 297
 298   g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL);
 299
 300   child = atk_object_ref_accessible_child (object, index);
 301
 302   return spi_accessible_new_return (child, TRUE, ev);
 303 }
 304
 305 /*
 306  * CORBA Accessibility::Accessible::getState method implementation
 307  */
 308 static Accessibility_StateSet
 309 impl_accessibility_accessible_get_state (PortableServer_Servant servant,
 310                                          CORBA_Environment     *ev)
 311 {
 312   AtkObject *object = get_atkobject_from_servant (servant);
 313   AtkStateSet *atk_set;
 314   SpiStateSet *set;
 315   Accessibility_StateSet retval;
 316
 317   bonobo_return_val_if_fail (object != NULL, NULL, ev);
 318
 319   atk_set = atk_object_ref_state_set (object);
 320
 321   set = spi_state_set_new (atk_set);
 322   retval = bonobo_object_dup_ref (
 323                                   BONOBO_OBJREF(set),
 324                                   ev);
 325
 326   return retval;
 327 }
 328
 329 /*
 330  * CORBA Accessibility::Accessible::getRelationSet method implementation
 331  */
 332 static Accessibility_RelationSet *
 333 impl_accessibility_accessible_get_relation_set (PortableServer_Servant servant,
 334                                                 CORBA_Environment     *ev)
 335 {
 336   Accessibility_RelationSet *retval;
 337   gint n_relations;
 338   gint i;
 339   AtkRelationSet *relation_set;
 340   AtkObject      *object = get_atkobject_from_servant (servant);
 341
 342   bonobo_return_val_if_fail (object != NULL, NULL, ev);
 343
 344   relation_set = atk_object_ref_relation_set (object);
 345
 346   n_relations = atk_relation_set_get_n_relations (relation_set);
 347
 348   retval = CORBA_sequence_Accessibility_Relation__alloc ();
 349   retval->_length = retval->_maximum = n_relations;
 350   retval->_buffer = CORBA_sequence_Accessibility_Relation_allocbuf (n_relations);
 351   CORBA_sequence_set_release (retval, CORBA_TRUE);
 352
 353   for (i = 0; i < n_relations; ++i)
 354     {
 355       retval->_buffer[i] =
 356         bonobo_object_dup_ref (
 357           BONOBO_OBJREF (
 358             spi_relation_new (atk_relation_set_get_relation (relation_set, i))),
 359           ev);
 360     }
 361
 362   return retval;
 363 }
 364
 365 /*
 366  * CORBA Accessibility::Accessible::getRole method implementation
 367  */
 368 static Accessibility_Role
 369 impl_accessibility_accessible_get_role (PortableServer_Servant servant,
 370                                         CORBA_Environment     *ev)
 371 {
 372   AtkRole            role;
 373   Accessibility_Role retval;
 374   AtkObject         *object = get_atkobject_from_servant (servant);
 375
 376   g_return_val_if_fail (object != NULL, 0);
 377
 378   role = atk_object_get_role (object);
 379   retval = spi_role_from_atk_role (role);
 380
 381   return retval;
 382 }
 383
 384 /*
 385  * CORBA Accessibility::Accessible::getRole method implementation
 386  */
 387 static CORBA_char *
 388 impl_accessibility_accessible_get_role_name (PortableServer_Servant servant,
 389                                              CORBA_Environment     *ev)
 390 {
 391   const gchar     *role_name;
 392   AtkRole    role;
 393   AtkObject *object = get_atkobject_from_servant (servant);
 394
 395   g_return_val_if_fail (object != NULL, 0);
 396
 397   role = atk_object_get_role (object);
 398
 399   role_name = atk_role_get_name (role);
 400   if (role_name)
 401     return CORBA_string_dup (role_name);
 402   else
 403     return CORBA_string_dup ("");
 404 }
 405
 406 static void
 407 spi_accessible_class_init (SpiAccessibleClass *klass)
 408 {
 409         POA_Accessibility_Accessible__epv *epv = &klass->epv;
 410
 411         epv->_get_name = impl_accessibility_accessible_get_name;
 412         epv->_set_name = impl_accessibility_accessible_set_name;
 413         epv->_get_description = impl_accessibility_accessible_get_description;
 414         epv->_set_description = impl_accessibility_accessible_set_description;
 415
 416         epv->_get_parent = impl_accessibility_accessible_get_parent;
 417         epv->_get_childCount = impl_accessibility_accessible_get_child_count;
 418         epv->getChildAtIndex = impl_accessibility_accessible_get_child_at_index;
 419         epv->getIndexInParent = impl_accessibility_accessible_get_index_in_parent;
 420
 421         epv->getRelationSet = impl_accessibility_accessible_get_relation_set;
 422         epv->getState = impl_accessibility_accessible_get_state;
 423         epv->getRole = impl_accessibility_accessible_get_role;
 424         epv->getRoleName = impl_accessibility_accessible_get_role_name;
 425 }
 426
 427 static void
 428 spi_accessible_init (SpiAccessible *accessible)
 429 {
 430 }
 431
 432 BONOBO_TYPE_FUNC_FULL (SpiAccessible,
 433                        Accessibility_Accessible,
 434                        PARENT_TYPE,
 435                        spi_accessible)
 436
 437 static GHashTable *public_corba_refs = NULL;
 438
 439 static GHashTable *
 440 get_public_refs (void)
 441 {
 442   if (!public_corba_refs)
 443     {
 444       public_corba_refs = g_hash_table_new (NULL, NULL);
 445     }
 446   return public_corba_refs;
 447 }
 448
 449 static void
 450 de_register_public_ref (SpiBase *object)
 451 {
 452   g_hash_table_remove (get_public_refs (), object->gobj);
 453 }
 454
 455 SpiAccessible *
 456 spi_accessible_new (AtkObject *o)
 457 {
 458   return spi_accessible_construct (SPI_ACCESSIBLE_TYPE, o);
 459 }
 460
 461 SpiAccessible *
 462 spi_accessible_construct (GType type, AtkObject *o)
 463 {
 464     SpiAccessible *retval;
 465     CORBA_Environment ev;
 466
 467     CORBA_exception_init (&ev);
 468
 469     g_assert (o);
 470     g_assert (g_type_is_a (type, SPI_ACCESSIBLE_TYPE));
 471
 472     if ((retval = g_hash_table_lookup (get_public_refs (), o)))
 473       {
 474         bonobo_object_ref (BONOBO_OBJECT (retval));
 475         return retval;
 476       }
 477     else
 478       {
 479         retval = g_object_new (type, NULL);
 480         spi_base_construct (SPI_BASE (retval), G_OBJECT(o));
 481       }
 482
 483     g_hash_table_insert (get_public_refs (), o, retval);
 484     g_signal_connect (G_OBJECT (retval), "destroy",
 485                       G_CALLBACK (de_register_public_ref),
 486                       NULL);
 487
 488     /* aggregate appropriate SPI interfaces based on ATK interfaces */
 489
 490     if (ATK_IS_ACTION (o))
 491       {
 492         bonobo_object_add_interface (bonobo_object (retval),
 493                 BONOBO_OBJECT (spi_action_interface_new (o)));
 494       }
 495
 496     if (ATK_IS_COMPONENT (o))
 497       {
 498         bonobo_object_add_interface (bonobo_object (retval),
 499                                      BONOBO_OBJECT (spi_component_interface_new (o)));
 500       }
 501
 502     if (ATK_IS_EDITABLE_TEXT (o))
 503       {
 504          bonobo_object_add_interface (bonobo_object (retval),
 505                                       BONOBO_OBJECT(spi_editable_text_interface_new (o)));
 506       }
 507
 508     else if (ATK_IS_TEXT (o))
 509        {
 510          bonobo_object_add_interface (bonobo_object (retval),
 511                                       BONOBO_OBJECT (spi_text_interface_new (o)));
 512        }
 513
 514     if (ATK_IS_HYPERTEXT (o))
 515       {
 516         bonobo_object_add_interface (bonobo_object (retval),
 517                                      BONOBO_OBJECT (spi_hypertext_interface_new (o)));
 518       }
 519
 520     if (ATK_IS_IMAGE (o))
 521       {
 522         bonobo_object_add_interface (bonobo_object (retval),
 523                                      BONOBO_OBJECT (spi_image_interface_new (o)));
 524       }
 525
 526     if (ATK_IS_SELECTION (o))
 527       {
 528         bonobo_object_add_interface (bonobo_object (retval),
 529                                      BONOBO_OBJECT (spi_selection_interface_new (o)));
 530       }
 531
 532     if (ATK_IS_TABLE (o))
 533       {
 534         bonobo_object_add_interface (bonobo_object (retval),
 535                                      BONOBO_OBJECT (spi_table_interface_new (o)));
 536       }
 537
 538     if (ATK_IS_VALUE (o))
 539       {
 540         bonobo_object_add_interface (bonobo_object (retval),
 541                                      BONOBO_OBJECT (spi_value_interface_new (o)));
 542       }
 543
 544     return retval;
 545 }
 546
 547 /**
 548  * spi_accessible_new_return:
 549  * @o: an AtkObject or NULL
 550  * @release_ref: whether to unref this AtkObject before return
 551  * @ev: a CORBA environment
 552  *
 553  * A helper function to instantiate a CORBA accessiblility
 554  * proxy from an AtkObject.
 555  *
 556  * Return value: the proxy or CORBA_OBJECT_NIL
 557  **/
 558 Accessibility_Accessible
 559 spi_accessible_new_return (AtkObject         *o,
 560                            gboolean           release_ref,
 561                            CORBA_Environment *ev)
 562 {
 563   SpiAccessible *accessible;
 564   Accessibility_Accessible retval;
 565
 566   if (!o)
 567     {
 568       return CORBA_OBJECT_NIL;
 569     }
 570   else if (SPI_IS_REMOTE_OBJECT (o))
 571     {
 572       retval = spi_remote_object_get_accessible (SPI_REMOTE_OBJECT (o));
 573     }
 574   else
 575     {
 576       accessible = spi_accessible_construct (SPI_ACCESSIBLE_TYPE, o);
 577       retval = CORBA_Object_duplicate (BONOBO_OBJREF (accessible), ev);
 578     }
 579
 580   if (release_ref)
 581     {
 582       g_object_unref (G_OBJECT (o));
 583     }
 584
 585   return retval;
 586 }