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