cspi/spi_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 #include <stdlib.h> /* for malloc */
  25 #include <libspi/stateset.h>
  26 #include <cspi/spi-private.h>
  27
  28 static const char *role_names [] =
  29 {
  30   "invalid",
  31   "accel-label",
  32   "alert",
  33   "animation",
  34   "arrow",
  35   "calendar",
  36   "canvas",
  37   "check-box",
  38   "check-menu-item",
  39   "color-chooser",
  40   "column-header",
  41   "combo-box",
  42   "date-editor",
  43   "desktop-icon",
  44   "desktop-frame",
  45   "dial",
  46   "dialog",
  47   "directory-pane",
  48   "drawing-area",
  49   "file-chooser",
  50   "filler",
  51   "font-chooser",
  52   "frame",
  53   "glass-pane",
  54   "html-container",
  55   "icon",
  56   "image",
  57   "internalframe",
  58   "label",
  59   "layered-pane",
  60   "list",
  61   "list-item",
  62   "menu",
  63   "menu-bar",
  64   "menu-item",
  65   "option-pane",
  66   "page-tab",
  67   "page-tab-list",
  68   "panel",
  69   "password-text",
  70   "popup-menu",
  71   "progress-bar",
  72   "push-button",
  73   "radio-button",
  74   "radio-menu-item",
  75   "root-pane",
  76   "row-header",
  77   "scroll-bar",
  78   "scroll-pane",
  79   "separator",
  80   "slider",
  81   "spin-button",
  82   "split-pane",
  83   "statusbar",
  84   "table",
  85   "table-cell",
  86   "table-column-header",
  87   "table-row-header",
  88   "tear-off-menu-item",
  89   "terminal",
  90   "text",
  91   "toggle-button",
  92   "tool-bar",
  93   "tool-tip",
  94   "tree",
  95   "tree-table",
  96   "unknown",
  97   "viewport",
  98   "window",
  99   NULL,
 100   "header",
 101   "fooler",
 102   "paragraph",
 103   "ruler",
 104   "application"
 105 };
 106
 107 #define MAX_ROLES (sizeof (role_names) / sizeof (char *))
 108
 109 static SPIBoolean
 110 cspi_init_role_table (AccessibleRole *role_table)
 111 {
 112   int i;
 113   for (i = 0; i < Accessibility_ROLE_LAST_DEFINED; ++i)
 114     {
 115       role_table [i] = SPI_ROLE_UNKNOWN;
 116     }
 117   role_table [Accessibility_ROLE_INVALID] = SPI_ROLE_INVALID;
 118   role_table [Accessibility_ROLE_ACCELERATOR_LABEL] = SPI_ROLE_ACCEL_LABEL;
 119   role_table [Accessibility_ROLE_ALERT] = SPI_ROLE_ALERT;
 120   role_table [Accessibility_ROLE_ANIMATION] = SPI_ROLE_ANIMATION;
 121   role_table [Accessibility_ROLE_ARROW] = SPI_ROLE_ARROW;
 122   role_table [Accessibility_ROLE_CALENDAR] = SPI_ROLE_CALENDAR;
 123   role_table [Accessibility_ROLE_CANVAS] = SPI_ROLE_CANVAS;
 124   role_table [Accessibility_ROLE_CHECK_BOX] = SPI_ROLE_CHECK_BOX;
 125   role_table [Accessibility_ROLE_CHECK_MENU_ITEM] = SPI_ROLE_CHECK_MENU_ITEM;
 126   role_table [Accessibility_ROLE_COLOR_CHOOSER] = SPI_ROLE_COLOR_CHOOSER;
 127   role_table [Accessibility_ROLE_COLUMN_HEADER] = SPI_ROLE_COLUMN_HEADER;
 128   role_table [Accessibility_ROLE_COMBO_BOX] = SPI_ROLE_COMBO_BOX;
 129   role_table [Accessibility_ROLE_DATE_EDITOR] = SPI_ROLE_DATE_EDITOR;
 130   role_table [Accessibility_ROLE_DESKTOP_ICON] = SPI_ROLE_DESKTOP_ICON;
 131   role_table [Accessibility_ROLE_DESKTOP_FRAME] = SPI_ROLE_DESKTOP_FRAME;
 132   role_table [Accessibility_ROLE_DIAL] = SPI_ROLE_DIAL;
 133   role_table [Accessibility_ROLE_DIALOG] = SPI_ROLE_DIALOG;
 134   role_table [Accessibility_ROLE_DIRECTORY_PANE] = SPI_ROLE_DIRECTORY_PANE;
 135   role_table [Accessibility_ROLE_DRAWING_AREA] = SPI_ROLE_DRAWING_AREA;
 136   role_table [Accessibility_ROLE_FILE_CHOOSER] = SPI_ROLE_FILE_CHOOSER;
 137   role_table [Accessibility_ROLE_FILLER] = SPI_ROLE_FILLER;
 138   role_table [Accessibility_ROLE_FONT_CHOOSER] = SPI_ROLE_FONT_CHOOSER;
 139   role_table [Accessibility_ROLE_FRAME] = SPI_ROLE_FRAME;
 140   role_table [Accessibility_ROLE_GLASS_PANE] = SPI_ROLE_GLASS_PANE;
 141   role_table [Accessibility_ROLE_HTML_CONTAINER] = SPI_ROLE_HTML_CONTAINER;
 142   role_table [Accessibility_ROLE_ICON] = SPI_ROLE_ICON;
 143   role_table [Accessibility_ROLE_IMAGE] = SPI_ROLE_IMAGE;
 144   role_table [Accessibility_ROLE_INTERNAL_FRAME] = SPI_ROLE_INTERNAL_FRAME;
 145   role_table [Accessibility_ROLE_LABEL] = SPI_ROLE_LABEL;
 146   role_table [Accessibility_ROLE_LAYERED_PANE] = SPI_ROLE_LAYERED_PANE;
 147   role_table [Accessibility_ROLE_LIST] = SPI_ROLE_LIST;
 148   role_table [Accessibility_ROLE_LIST_ITEM] = SPI_ROLE_LIST_ITEM;
 149   role_table [Accessibility_ROLE_MENU] = SPI_ROLE_MENU;
 150   role_table [Accessibility_ROLE_MENU_BAR] = SPI_ROLE_MENU_BAR;
 151   role_table [Accessibility_ROLE_MENU_ITEM] = SPI_ROLE_MENU_ITEM;
 152   role_table [Accessibility_ROLE_OPTION_PANE] = SPI_ROLE_OPTION_PANE;
 153   role_table [Accessibility_ROLE_PAGE_TAB] = SPI_ROLE_PAGE_TAB;
 154   role_table [Accessibility_ROLE_PAGE_TAB_LIST] = SPI_ROLE_PAGE_TAB_LIST;
 155   role_table [Accessibility_ROLE_PANEL] = SPI_ROLE_PANEL;
 156   role_table [Accessibility_ROLE_PASSWORD_TEXT] = SPI_ROLE_PASSWORD_TEXT;
 157   role_table [Accessibility_ROLE_POPUP_MENU] = SPI_ROLE_POPUP_MENU;
 158   role_table [Accessibility_ROLE_PROGRESS_BAR] = SPI_ROLE_PROGRESS_BAR;
 159   role_table [Accessibility_ROLE_PUSH_BUTTON] = SPI_ROLE_PUSH_BUTTON;
 160   role_table [Accessibility_ROLE_RADIO_BUTTON] = SPI_ROLE_RADIO_BUTTON;
 161   role_table [Accessibility_ROLE_RADIO_MENU_ITEM] = SPI_ROLE_RADIO_MENU_ITEM;
 162   role_table [Accessibility_ROLE_ROOT_PANE] = SPI_ROLE_ROOT_PANE;
 163   role_table [Accessibility_ROLE_ROW_HEADER] = SPI_ROLE_ROW_HEADER;
 164   role_table [Accessibility_ROLE_SCROLL_BAR] = SPI_ROLE_SCROLL_BAR;
 165   role_table [Accessibility_ROLE_SCROLL_PANE] = SPI_ROLE_SCROLL_PANE;
 166   role_table [Accessibility_ROLE_SEPARATOR] = SPI_ROLE_SEPARATOR;
 167   role_table [Accessibility_ROLE_SLIDER] = SPI_ROLE_SLIDER;
 168   role_table [Accessibility_ROLE_SPIN_BUTTON] = SPI_ROLE_SPIN_BUTTON;
 169   role_table [Accessibility_ROLE_SPLIT_PANE] = SPI_ROLE_SPLIT_PANE;
 170   role_table [Accessibility_ROLE_STATUS_BAR] = SPI_ROLE_STATUS_BAR;
 171   role_table [Accessibility_ROLE_TABLE] = SPI_ROLE_TABLE;
 172   role_table [Accessibility_ROLE_TABLE_CELL] = SPI_ROLE_TABLE_CELL;
 173   role_table[Accessibility_ROLE_TABLE_COLUMN_HEADER] = SPI_ROLE_TABLE_COLUMN_HEADER;
 174   role_table[Accessibility_ROLE_TABLE_ROW_HEADER] = SPI_ROLE_TABLE_ROW_HEADER;
 175   role_table [Accessibility_ROLE_TEAROFF_MENU_ITEM] = SPI_ROLE_TEAROFF_MENU_ITEM;
 176   role_table[Accessibility_ROLE_TERMINAL] = SPI_ROLE_TERMINAL;
 177   role_table [Accessibility_ROLE_TEXT] = SPI_ROLE_TEXT;
 178   role_table [Accessibility_ROLE_TOGGLE_BUTTON] = SPI_ROLE_TOGGLE_BUTTON;
 179   role_table [Accessibility_ROLE_TOOL_BAR] = SPI_ROLE_TOOL_BAR;
 180   role_table [Accessibility_ROLE_TOOL_TIP] = SPI_ROLE_TOOL_TIP;
 181   role_table [Accessibility_ROLE_TREE] = SPI_ROLE_TREE;
 182   role_table [Accessibility_ROLE_TREE_TABLE] = SPI_ROLE_TREE_TABLE;
 183   role_table [Accessibility_ROLE_VIEWPORT] = SPI_ROLE_VIEWPORT;
 184   role_table [Accessibility_ROLE_WINDOW] = SPI_ROLE_WINDOW;
 185   role_table [Accessibility_ROLE_EXTENDED] = SPI_ROLE_EXTENDED;
 186   role_table [Accessibility_ROLE_HEADER] = SPI_ROLE_HEADER;
 187   role_table [Accessibility_ROLE_FOOTER] = SPI_ROLE_FOOTER;
 188   role_table [Accessibility_ROLE_PARAGRAPH] = SPI_ROLE_PARAGRAPH;
 189   role_table [Accessibility_ROLE_RULER] = SPI_ROLE_RULER;
 190   role_table [Accessibility_ROLE_APPLICATION] = SPI_ROLE_APPLICATION;
 191   role_table [Accessibility_ROLE_AUTOCOMPLETE] = SPI_ROLE_AUTOCOMPLETE;
 192
 193   return TRUE;
 194 }
 195
 196 static AccessibleRole
 197 cspi_role_from_spi_role (Accessibility_Role role)
 198 {
 199   /* array is sized according to IDL roles because IDL roles are the index */
 200   static AccessibleRole cspi_role_table [Accessibility_ROLE_LAST_DEFINED];
 201   static SPIBoolean is_initialized = FALSE;
 202   AccessibleRole cspi_role;
 203   if (!is_initialized)
 204     {
 205       is_initialized = cspi_init_role_table (cspi_role_table);
 206     }
 207   if (role >= 0 && role < Accessibility_ROLE_LAST_DEFINED)
 208     {
 209       cspi_role = cspi_role_table [role];
 210     }
 211   else
 212     {
 213       cspi_role = SPI_ROLE_EXTENDED;
 214     }
 215   return cspi_role;
 216 }
 217
 218 /**
 219  * AccessibleRole_getName:
 220  * @role: an #AccessibleRole object to query.
 221  *
 222  * Get a localizeable string that indicates the name of an #AccessibleRole.
 223  * <em>DEPRECATED.</em>
 224  *
 225  * Returns: a localizable string name for an #AccessibleRole enumerated type.
 226  **/
 227 char *
 228 AccessibleRole_getName (AccessibleRole role)
 229 {
 230   if (role < MAX_ROLES && role_names [(int) role])
 231     {
 232       return CORBA_string_dup (role_names [(int) role]);
 233     }
 234   else
 235     {
 236       return CORBA_string_dup ("");
 237     }
 238 }
 239
 240 /**
 241  * Accessible_ref:
 242  * @obj: a pointer to the #Accessible object on which to operate.
 243  *
 244  * Increment the reference count for an #Accessible object.
 245  **/
 246 void
 247 Accessible_ref (Accessible *obj)
 248 {
 249   cspi_object_ref (obj);
 250 }
 251
 252 /**
 253  * Accessible_unref:
 254  * @obj: a pointer to the #Accessible object on which to operate.
 255  *
 256  * Decrement the reference count for an #Accessible object.
 257  **/
 258 void
 259 Accessible_unref (Accessible *obj)
 260 {
 261   cspi_object_unref (obj);
 262 }
 263
 264 /**
 265  * Accessible_getName:
 266  * @obj: a pointer to the #Accessible object on which to operate.
 267  *
 268  * Get the name of an #Accessible object.
 269  *
 270  * Returns: a UTF-8 string indicating the name of the #Accessible object.
 271  * or NULL on exception
 272  **/
 273 char *
 274 Accessible_getName (Accessible *obj)
 275 {
 276   char *retval;
 277
 278   cspi_return_val_if_fail (obj != NULL, NULL);
 279
 280   retval = Accessibility_Accessible__get_name (CSPI_OBJREF (obj), cspi_ev ());
 281
 282   cspi_return_val_if_ev ("getName", NULL);
 283
 284   return retval;
 285 }
 286
 287 /**
 288  * Accessible_getDescription:
 289  * @obj: a pointer to the #Accessible object on which to operate.
 290  *
 291  * Get the description of an #Accessible object.
 292  *
 293  * Returns: a UTF-8 string describing the #Accessible object.
 294  * or NULL on exception
 295  **/
 296 char *
 297 Accessible_getDescription (Accessible *obj)
 298 {
 299   char *retval;
 300
 301   cspi_return_val_if_fail (obj != NULL, NULL);
 302
 303   retval = Accessibility_Accessible__get_description (CSPI_OBJREF (obj),
 304                                                cspi_ev ());
 305
 306   cspi_return_val_if_ev ("getDescription", NULL);
 307
 308   return retval;
 309 }
 310
 311 /**
 312  * Accessible_getParent:
 313  * @obj: a pointer to the #Accessible object to query.
 314  *
 315  * Get an #Accessible object's parent container.
 316  *
 317  * Returns: a pointer tothe #Accessible object which contains the given
 318  *          #Accessible instance, or NULL if the @obj has no parent container.
 319  *
 320  **/
 321 Accessible *
 322 Accessible_getParent (Accessible *obj)
 323 {
 324   Accessible *retval;
 325
 326   cspi_return_val_if_fail (obj != NULL, NULL);
 327
 328   retval = cspi_object_add (
 329     Accessibility_Accessible__get_parent (CSPI_OBJREF (obj),
 330                                           cspi_ev ()));
 331
 332   cspi_return_val_if_ev ("getParent", NULL);
 333
 334   return retval;
 335 }
 336
 337 /**
 338  * Accessible_getChildCount:
 339  * @obj: a pointer to the #Accessible object on which to operate.
 340  *
 341  * Get the number of children contained by an #Accessible object.
 342  *
 343  * Returns: a #long indicating the number of #Accessible children
 344  *          contained by an #Accessible object. or -1 on exception
 345  *
 346  **/
 347 long
 348 Accessible_getChildCount (Accessible *obj)
 349 {
 350   long retval;
 351
 352   cspi_return_val_if_fail (obj != NULL, -1);
 353
 354   retval = Accessibility_Accessible__get_childCount (CSPI_OBJREF (obj),
 355                                               cspi_ev ());
 356
 357   cspi_return_val_if_ev ("getChildCount", -1);
 358
 359   return retval;
 360 }
 361
 362 /**
 363  * Accessible_getChildAtIndex:
 364  * @obj: a pointer to the #Accessible object on which to operate.
 365  * @childIndex: a #long indicating which child is specified.
 366  *
 367  * Get the #Accessible child of an #Accessible object at a given index.
 368  *
 369  * Returns: a pointer to the #Accessible child object at index
 370  *          @childIndex. or NULL on exception
 371  **/
 372 Accessible *
 373 Accessible_getChildAtIndex (Accessible *obj,
 374                             long int    childIndex)
 375 {
 376   Accessible *retval;
 377
 378   cspi_return_val_if_fail (obj != NULL, NULL);
 379
 380   retval = cspi_object_add (
 381     Accessibility_Accessible_getChildAtIndex (CSPI_OBJREF (obj),
 382                                               childIndex, cspi_ev ()));
 383
 384   cspi_return_val_if_ev ("getChildAtIndex", NULL);
 385   return retval;
 386 }
 387
 388 /**
 389  * Accessible_getIndexInParent:
 390  * @obj: a pointer to the #Accessible object on which to operate.
 391  *
 392  * Get the index of an #Accessible object in its containing #Accessible.
 393  *
 394  * Returns: a #long indicating the index of the #Accessible object
 395  *          in its parent (i.e. containing) #Accessible instance,
 396  *          or -1 if @obj has no containing parent or on exception.
 397  **/
 398 long
 399 Accessible_getIndexInParent (Accessible *obj)
 400 {
 401   long retval;
 402
 403   cspi_return_val_if_fail (obj != NULL, -1);
 404
 405   retval = Accessibility_Accessible_getIndexInParent (CSPI_OBJREF (obj), cspi_ev ());
 406
 407   cspi_return_val_if_ev ("getIndexInparent", -1);
 408   return retval;
 409 }
 410
 411 /**
 412  * Accessible_getRelationSet:
 413  * @obj: a pointer to the #Accessible object on which to operate.
 414  *
 415  * Get the set of #AccessibleRelation objects which describe this #Accessible object's
 416  *       relationships with other #Accessible objects.
 417  *
 418  * Returns: an array of #AccessibleRelation pointers. or NULL on exception
 419  **/
 420 AccessibleRelation **
 421 Accessible_getRelationSet (Accessible *obj)
 422 {
 423   int i;
 424   int n_relations;
 425   AccessibleRelation **relations;
 426   Accessibility_RelationSet *relation_set;
 427
 428   cspi_return_val_if_fail (obj != NULL, NULL);
 429
 430   relation_set =
 431     Accessibility_Accessible_getRelationSet (CSPI_OBJREF (obj), cspi_ev ());
 432
 433   cspi_return_val_if_ev ("getRelationSet", NULL);
 434
 435   n_relations = relation_set->_length;
 436   relations = malloc (sizeof (AccessibleRelation *) * (n_relations + 1));
 437
 438   for (i = 0; i < n_relations; ++i)
 439     {
 440       relations[i] = cspi_object_add (CORBA_Object_duplicate (
 441               relation_set->_buffer[i], cspi_ev ()));
 442     }
 443   relations[i] = NULL;
 444
 445   CORBA_free (relation_set);
 446
 447   return relations;
 448 }
 449
 450 /**
 451  * Accessible_getRole:
 452  * @obj: a pointer to the #Accessible object on which to operate.
 453  *
 454  * Get the UI role of an #Accessible object.
 455  * A UTF-8 string describing this role can be obtained via Accessible_getRoleName ().
 456  *
 457  * Returns: the #AccessibleRole of the object.
 458  *
 459  **/
 460 AccessibleRole
 461 Accessible_getRole (Accessible *obj)
 462 {
 463   Accessibility_Role retval;
 464
 465   cspi_return_val_if_fail (obj != NULL, SPI_ROLE_INVALID);
 466
 467   retval =
 468     Accessibility_Accessible_getRole (CSPI_OBJREF (obj), cspi_ev ());
 469
 470   cspi_return_val_if_ev ("getRole", SPI_ROLE_INVALID);
 471
 472   return cspi_role_from_spi_role (retval);
 473 }
 474
 475 /**
 476  * Accessible_getRoleName:
 477  * @obj: a pointer to the #Accessible object on which to operate.
 478  *
 479  * Get a UTF-8 string describing the role this object plays in the UI.
 480  * This method will return useful values for roles that fall outside the
 481  * enumeration used in Accessible_getRole ().
 482  *
 483  * Returns: a UTF-8 string specifying the role of this #Accessible object.
 484  *
 485  **/
 486 char *
 487 Accessible_getRoleName (Accessible *obj)
 488 {
 489   char *retval;
 490
 491   cspi_return_val_if_fail (obj != NULL, CORBA_string_dup ("invalid"));
 492
 493   retval =
 494     Accessibility_Accessible_getRoleName (CSPI_OBJREF (obj), cspi_ev ());
 495
 496   cspi_return_val_if_ev ("getRoleName", CORBA_string_dup ("invalid"));
 497
 498   return retval;
 499 }
 500
 501 /**
 502  * Accessible_getStateSet:
 503  * @obj: a pointer to the #Accessible object on which to operate.
 504  *
 505  * Returns: a pointer to an #AccessibleStateSet representing the object's current state.
 506  **/
 507 AccessibleStateSet *
 508 Accessible_getStateSet (Accessible *obj)
 509 {
 510   AccessibleStateSet *retval;
 511   Accessibility_StateSet corba_stateset;
 512   Accessibility_StateSeq *corba_seq;
 513
 514   cspi_return_val_if_fail (obj != NULL, NULL);
 515
 516   corba_stateset = Accessibility_Accessible_getState (
 517           CSPI_OBJREF (obj), cspi_ev ());
 518   cspi_return_val_if_ev ("getState", NULL);
 519
 520   cspi_return_val_if_fail (corba_stateset != CORBA_OBJECT_NIL, NULL);
 521   cspi_return_val_if_fail (cspi_ping (corba_stateset), NULL);
 522   corba_seq = Accessibility_StateSet_getStates (corba_stateset, cspi_ev ());
 523   cspi_return_val_if_ev ("getState", NULL);
 524
 525   retval = spi_state_set_cache_new (corba_seq);
 526
 527   CORBA_free (corba_seq);
 528   cspi_release_unref (corba_stateset);
 529
 530   return retval;
 531 }
 532
 533 /* Interface query methods */
 534
 535 /**
 536  * Accessible_isAction:
 537  * @obj: a pointer to the #Accessible instance to query.
 538  *
 539  * Query whether the specified #Accessible implements #AccessibleAction.
 540  *
 541  * Returns: #TRUE if @obj implements the #AccessibleAction interface,
 542  *          #FALSE otherwise.
 543  **/
 544 SPIBoolean
 545 Accessible_isAction (Accessible *obj)
 546 {
 547   return cspi_accessible_is_a (obj,
 548                               "IDL:Accessibility/Action:1.0");
 549 }
 550
 551 /**
 552  * Accessible_isApplication:
 553  * @obj: a pointer to the #Accessible instance to query.
 554  *
 555  * Query whether the specified #Accessible implements #AccessibleApplication.
 556  *
 557  * Returns: #TRUE if @obj implements the #AccessibleApplication interface,
 558  *          #FALSE otherwise.
 559  **/
 560 SPIBoolean
 561 Accessible_isApplication (Accessible *obj)
 562 {
 563   return cspi_accessible_is_a (obj,
 564                               "IDL:Accessibility/Application:1.0");
 565 }
 566
 567 /**
 568  * Accessible_isComponent:
 569  * @obj: a pointer to the #Accessible instance to query.
 570  *
 571  * Query whether the specified #Accessible implements #AccessibleComponent.
 572  *
 573  * Returns: #TRUE if @obj implements the #AccessibleComponent interface,
 574  *          #FALSE otherwise.
 575  **/
 576 SPIBoolean
 577 Accessible_isComponent (Accessible *obj)
 578 {
 579   return cspi_accessible_is_a (obj,
 580                               "IDL:Accessibility/Component:1.0");
 581 }
 582
 583 /**
 584  * Accessible_isEditableText:
 585  * @obj: a pointer to the #Accessible instance to query.
 586  *
 587  * Query whether the specified #Accessible implements #AccessibleEditableText.
 588  *
 589  * Returns: #TRUE if @obj implements the #AccessibleEditableText interface,
 590  *          #FALSE otherwise.
 591  **/
 592 SPIBoolean
 593 Accessible_isEditableText (Accessible *obj)
 594 {
 595   return cspi_accessible_is_a (obj,
 596                               "IDL:Accessibility/EditableText:1.0");
 597 }
 598
 599 /**
 600  * Accessible_isHypertext:
 601  * @obj: a pointer to the #Accessible instance to query.
 602  *
 603  * Query whether the specified #Accessible implements #AccessibleHypertext.
 604  *
 605  * Returns: #TRUE if @obj implements the #AccessibleHypertext interface,
 606  *          #FALSE otherwise.
 607  **/
 608 SPIBoolean
 609 Accessible_isHypertext (Accessible *obj)
 610 {
 611   return cspi_accessible_is_a (obj,
 612                               "IDL:Accessibility/Hypertext:1.0");
 613 }
 614
 615 /**
 616  * Accessible_isImage:
 617  * @obj: a pointer to the #Accessible instance to query.
 618  *
 619  * Query whether the specified #Accessible implements #AccessibleImage.
 620  *
 621  * Returns: #TRUE if @obj implements the #AccessibleImage interface,
 622  *          #FALSE otherwise.
 623 **/
 624 SPIBoolean
 625 Accessible_isImage (Accessible *obj)
 626 {
 627   return cspi_accessible_is_a (obj,
 628                               "IDL:Accessibility/Image:1.0");
 629 }
 630
 631 /**
 632  * Accessible_isSelection:
 633  * @obj: a pointer to the #Accessible instance to query.
 634  *
 635  * Query whether the specified #Accessible implements #AccessibleSelection.
 636  *
 637  * Returns: #TRUE if @obj implements the #AccessibleSelection interface,
 638  *          #FALSE otherwise.
 639 **/
 640 SPIBoolean
 641 Accessible_isSelection (Accessible *obj)
 642 {
 643   return cspi_accessible_is_a (obj,
 644                               "IDL:Accessibility/Selection:1.0");
 645 }
 646
 647 /**
 648  * Accessible_isTable:
 649  * @obj: a pointer to the #Accessible instance to query.
 650  *
 651  * Query whether the specified #Accessible implements #AccessibleTable.
 652  *
 653  * Returns: #TRUE if @obj implements the #AccessibleTable interface,
 654  *          #FALSE otherwise.
 655 **/
 656 SPIBoolean
 657 Accessible_isTable (Accessible *obj)
 658 {
 659   return cspi_accessible_is_a (obj,
 660                               "IDL:Accessibility/Table:1.0");
 661 }
 662
 663 /**
 664  * Accessible_isStreamableContent:
 665  * @obj: a pointer to the #Accessible instance to query.
 666  *
 667  * Query whether the specified #Accessible implements
 668  *          #AccessibleStreamableContent.
 669  *
 670  * Returns: #TRUE if @obj implements the #AccessibleStreamableContent interface,
 671  *          #FALSE otherwise.
 672 **/
 673 SPIBoolean
 674 Accessible_isStreamableContent (Accessible *obj)
 675 {
 676   return cspi_accessible_is_a (obj,
 677                               "IDL:Accessibility/StreamableContent:1.0");
 678 }
 679
 680 /**
 681  * Accessible_isText:
 682  * @obj: a pointer to the #Accessible instance to query.
 683  *
 684  * Query whether the specified #Accessible implements #AccessibleText.
 685  *
 686  * Returns: #TRUE if @obj implements the #AccessibleText interface,
 687  *          #FALSE otherwise.
 688 **/
 689 SPIBoolean
 690 Accessible_isText (Accessible *obj)
 691 {
 692   return cspi_accessible_is_a (obj,
 693                               "IDL:Accessibility/Text:1.0");
 694 }
 695
 696 /**
 697  * Accessible_isValue:
 698  * @obj: a pointer to the #Accessible instance to query.
 699  *
 700  * Query whether the specified #Accessible implements #AccessibleValue.
 701  *
 702  * Returns: #TRUE if @obj implements the #AccessibleValue interface,
 703  *          #FALSE otherwise.
 704 **/
 705 SPIBoolean
 706 Accessible_isValue (Accessible *obj)
 707 {
 708   return cspi_accessible_is_a (obj,
 709                               "IDL:Accessibility/Value:1.0");
 710 }
 711
 712 /**
 713  * Accessible_getApplication:
 714  * @obj: a pointer to the #Accessible instance to query.
 715  *
 716  * Get the #AccessibleApplication interface for an #Accessible.
 717  *
 718  * Returns: a pointer to an #AccessibleApplication interface instance, or
 719  *          NULL if @obj does not implement #AccessibleApplication.
 720  **/
 721 AccessibleApplication *
 722 Accessible_getApplication (Accessible *obj)
 723 {
 724   return (AccessibleApplication *) Accessible_queryInterface (
 725           obj, "IDL:Accessibility/Application:1.0");
 726 }
 727
 728 /**
 729  * Accessible_getAction:
 730  * @obj: a pointer to the #Accessible instance to query.
 731  *
 732  * Get the #AccessibleAction interface for an #Accessible.
 733  *
 734  * Returns: a pointer to an #AccessibleAction interface instance, or
 735  *          NULL if @obj does not implement #AccessibleAction.
 736  **/
 737 AccessibleAction *
 738 Accessible_getAction (Accessible *obj)
 739 {
 740   return (AccessibleAction *) Accessible_queryInterface (
 741           obj, "IDL:Accessibility/Action:1.0");
 742 }
 743
 744 /**
 745  * Accessible_getComponent:
 746  * @obj: a pointer to the #Accessible instance to query.
 747  *
 748  * Get the #AccessibleComponent interface for an #Accessible.
 749  *
 750  * Returns: a pointer to an #AccessibleComponent interface instance, or
 751  *          NULL if @obj does not implement #AccessibleComponent.
 752  **/
 753 AccessibleComponent *
 754 Accessible_getComponent (Accessible *obj)
 755 {
 756   return (AccessibleComponent *) Accessible_queryInterface (
 757           obj, "IDL:Accessibility/Component:1.0");
 758 }
 759
 760 /**
 761  * Accessible_getEditableText:
 762  * @obj: a pointer to the #Accessible instance to query.
 763  *
 764  * Get the #AccessibleEditableText interface for an #Accessible.
 765  *
 766  * Returns: a pointer to an #AccessibleEditableText interface instance, or
 767  *          NULL if @obj does not implement #AccessibleEditableText.
 768  **/
 769 AccessibleEditableText *
 770 Accessible_getEditableText (Accessible *obj)
 771 {
 772   return (AccessibleEditableText *) Accessible_queryInterface (
 773           obj, "IDL:Accessibility/EditableText:1.0");
 774 }
 775
 776
 777
 778 /**
 779  * Accessible_getHypertext:
 780  * @obj: a pointer to the #Accessible instance to query.
 781  *
 782  * Get the #AccessibleHypertext interface for an #Accessible.
 783  *
 784  * Returns: a pointer to an #AccessibleHypertext interface instance, or
 785  *          NULL if @obj does not implement #AccessibleHypertext.
 786  **/
 787 AccessibleHypertext *
 788 Accessible_getHypertext (Accessible *obj)
 789 {
 790   return (AccessibleHypertext *) Accessible_queryInterface (
 791           obj, "IDL:Accessibility/Hypertext:1.0");
 792 }
 793
 794
 795
 796 /**
 797  * Accessible_getImage:
 798  * @obj: a pointer to the #Accessible instance to query.
 799  *
 800  * Get the #AccessibleImage interface for an #Accessible.
 801  *
 802  * Returns: a pointer to an #AccessibleImage interface instance, or
 803  *          NULL if @obj does not implement #AccessibleImage.
 804  **/
 805 AccessibleImage *
 806 Accessible_getImage (Accessible *obj)
 807 {
 808   return (AccessibleImage *) Accessible_queryInterface (
 809           obj, "IDL:Accessibility/Image:1.0");
 810 }
 811
 812
 813
 814 /**
 815  * Accessible_getSelection:
 816  * @obj: a pointer to the #Accessible instance to query.
 817  *
 818  * Get the #AccessibleSelection interface for an #Accessible.
 819  *
 820  * Returns: a pointer to an #AccessibleSelection interface instance, or
 821  *          NULL if @obj does not implement #AccessibleSelection.
 822  **/
 823 AccessibleSelection *
 824 Accessible_getSelection (Accessible *obj)
 825 {
 826   return (AccessibleSelection *) Accessible_queryInterface (
 827           obj, "IDL:Accessibility/Selection:1.0");
 828 }
 829
 830
 831
 832 /**
 833  * Accessible_getStreamableContent:
 834  * @obj: a pointer to the #Accessible instance to query.
 835  *
 836  * Get the #AccessibleStreamableContent interface for an #Accessible.
 837  *
 838  * Returns: a pointer to an #AccessibleStreamableContent interface instance, or
 839  *          NULL if @obj does not implement #AccessibleStreamableContent.
 840  **/
 841 AccessibleStreamableContent *
 842 Accessible_getStreamableContent (Accessible *obj)
 843 {
 844   return (AccessibleStreamableContent *) Accessible_queryInterface (
 845           obj, "IDL:Accessibility/StreamableContent:1.0");
 846 }
 847
 848 /**
 849  * Accessible_getTable:
 850  * @obj: a pointer to the #Accessible instance to query.
 851  *
 852  * Get the #AccessibleTable interface for an #Accessible.
 853  *
 854  * Returns: a pointer to an #AccessibleTable interface instance, or
 855  *          NULL if @obj does not implement #AccessibleTable.
 856  **/
 857 AccessibleTable *
 858 Accessible_getTable (Accessible *obj)
 859 {
 860   return (AccessibleTable *) Accessible_queryInterface (
 861           obj, "IDL:Accessibility/Table:1.0");
 862 }
 863
 864 /**
 865  * Accessible_getText:
 866  * @obj: a pointer to the #Accessible instance to query.
 867  *
 868  * Get the #AccessibleText interface for an #Accessible.
 869  *
 870  * Returns: a pointer to an #AccessibleText interface instance, or
 871  *          NULL if @obj does not implement #AccessibleText.
 872  **/
 873 AccessibleText *
 874 Accessible_getText (Accessible *obj)
 875 {
 876   return (AccessibleText *) Accessible_queryInterface (
 877           obj, "IDL:Accessibility/Text:1.0");
 878 }
 879
 880
 881
 882 /**
 883  * Accessible_getValue:
 884  * @obj: a pointer to the #Accessible instance to query.
 885  *
 886  * Get the #AccessibleValue interface for an #Accessible.
 887  *
 888  * Returns: a pointer to an #AccessibleValue interface instance, or
 889  *          NULL if @obj does not implement #AccessibleValue.
 890  **/
 891 AccessibleValue *
 892 Accessible_getValue (Accessible *obj)
 893 {
 894   return (AccessibleValue *) Accessible_queryInterface (
 895           obj, "IDL:Accessibility/Value:1.0");
 896 }
 897
 898
 899
 900 /**
 901  * Accessible_queryInterface:
 902  * @obj: a pointer to the #Accessible instance to query.
 903  * @interface_name: a UTF-8 character string specifiying the requested interface.
 904  *
 905  * Query an #Accessible object to for a named interface.
 906  *
 907  * Returns: an instance of the named interface object, if it is implemented
 908  *          by @obj, or NULL otherwise.
 909  *
 910  **/
 911 AccessibleUnknown *
 912 Accessible_queryInterface (Accessible *obj,
 913                            const char *interface_name)
 914 {
 915   Bonobo_Unknown iface;
 916
 917   if (!obj)
 918     {
 919       return NULL;
 920     }
 921
 922   iface = Accessibility_Accessible_queryInterface (CSPI_OBJREF (obj),
 923                                                    interface_name,
 924                                                    cspi_ev ());
 925
 926
 927   cspi_return_val_if_ev ("queryInterface", NULL);
 928
 929   /*
 930    * FIXME: we need to be fairly sure that references are going
 931    * to mach up if we are going to expose QueryInterface, ie. we
 932    * can't allow people to do:
 933    * b = a.qi ("b"); b.unref, b.unref to release a's reference.
 934    * this should be no real problem though for this level of API
 935    * user.
 936    */
 937
 938   return cspi_object_add (iface);
 939 }
 940
 941
 942 /**
 943  * AccessibleRelation_ref:
 944  * @obj: a pointer to the #AccessibleRelation object on which to operate.
 945  *
 946  * Increment the reference count for an #AccessibleRelation object.
 947  *
 948  **/
 949 void
 950 AccessibleRelation_ref (AccessibleRelation *obj)
 951 {
 952   cspi_object_ref (obj);
 953 }
 954
 955 /**
 956  * AccessibleRelation_unref:
 957  * @obj: a pointer to the #AccessibleRelation object on which to operate.
 958  *
 959  * Decrement the reference count for an #AccessibleRelation object.
 960  *
 961  **/
 962 void
 963 AccessibleRelation_unref (AccessibleRelation *obj)
 964 {
 965   cspi_object_unref (obj);
 966 }
 967
 968 static SPIBoolean
 969 cspi_init_relation_type_table (AccessibleRelationType *relation_type_table)
 970 {
 971   int i;
 972   for (i = 0; i < Accessibility_RELATION_LAST_DEFINED; ++i)
 973     {
 974       relation_type_table [i] = SPI_RELATION_NULL;
 975     }
 976   relation_type_table [Accessibility_RELATION_NULL] = SPI_RELATION_NULL;
 977   relation_type_table [Accessibility_RELATION_LABEL_FOR] = SPI_RELATION_LABEL_FOR;
 978   relation_type_table [Accessibility_RELATION_LABELLED_BY] = SPI_RELATION_LABELED_BY;
 979   relation_type_table [Accessibility_RELATION_CONTROLLER_FOR] = SPI_RELATION_CONTROLLER_FOR;
 980   relation_type_table [Accessibility_RELATION_CONTROLLED_BY] = SPI_RELATION_CONTROLLED_BY;
 981   relation_type_table [Accessibility_RELATION_MEMBER_OF] = SPI_RELATION_MEMBER_OF;
 982   relation_type_table [Accessibility_RELATION_TOOLTIP_FOR] = SPI_RELATION_NULL;
 983   relation_type_table [Accessibility_RELATION_NODE_CHILD_OF] = SPI_RELATION_NODE_CHILD_OF;
 984   relation_type_table [Accessibility_RELATION_EXTENDED] = SPI_RELATION_EXTENDED;
 985   relation_type_table [Accessibility_RELATION_FLOWS_TO] = SPI_RELATION_FLOWS_TO;
 986   relation_type_table [Accessibility_RELATION_FLOWS_FROM] = SPI_RELATION_FLOWS_FROM;
 987   relation_type_table [Accessibility_RELATION_SUBWINDOW_OF] = SPI_RELATION_SUBWINDOW_OF;
 988   relation_type_table [Accessibility_RELATION_EMBEDS] = SPI_RELATION_EMBEDS;
 989   relation_type_table [Accessibility_RELATION_EMBEDDED_BY] = SPI_RELATION_EMBEDDED_BY;
 990   relation_type_table [Accessibility_RELATION_POPUP_FOR] = SPI_RELATION_POPUP_FOR;
 991   return TRUE;
 992 }
 993
 994 static AccessibleRelationType
 995 cspi_relation_type_from_spi_relation_type (Accessibility_RelationType type)
 996 {
 997   /* array is sized according to IDL RelationType because IDL RelationTypes are the index */
 998   static AccessibleRelationType cspi_relation_type_table [Accessibility_RELATION_LAST_DEFINED];
 999   static SPIBoolean is_initialized = FALSE;
1000   AccessibleRelationType cspi_type;
1001   if (!is_initialized)
1002     {
1003       is_initialized = cspi_init_relation_type_table (cspi_relation_type_table);
1004     }
1005   if (type >= 0 && type < Accessibility_RELATION_LAST_DEFINED)
1006     {
1007       cspi_type = cspi_relation_type_table [type];
1008     }
1009   else
1010     {
1011       cspi_type = SPI_RELATION_NULL;
1012     }
1013   return cspi_type;
1014 }
1015 /**
1016  * AccessibleRelation_getRelationType:
1017  * @obj: a pointer to the #AccessibleRelation object to query.
1018  *
1019  * Get the type of relationship represented by an #AccessibleRelation.
1020  *
1021  * Returns: an #AccessibleRelationType indicating the type of relation
1022  *         encapsulated in this #AccessibleRelation object.
1023  *
1024  **/
1025 AccessibleRelationType
1026 AccessibleRelation_getRelationType (AccessibleRelation *obj)
1027 {
1028   Accessibility_RelationType retval;
1029
1030   cspi_return_val_if_fail (obj, SPI_RELATION_NULL);
1031   retval =
1032     Accessibility_Relation_getRelationType (CSPI_OBJREF (obj), cspi_ev());
1033   cspi_return_val_if_ev ("getRelationType", SPI_RELATION_NULL);
1034   return cspi_relation_type_from_spi_relation_type (retval);
1035 }
1036
1037 /**
1038  * AccessibleRelation_getNTargets:
1039  * @obj: a pointer to the #AccessibleRelation object to query.
1040  *
1041  * Get the number of objects which this relationship has as its
1042  *       target objects (the subject is the #Accessible from which this
1043  *       #AccessibleRelation originated).
1044  *
1045  * Returns: a short integer indicating how many target objects which the
1046  *       originating #Accessible object has the #AccessibleRelation
1047  *       relationship with.
1048  **/
1049 int
1050 AccessibleRelation_getNTargets (AccessibleRelation *obj)
1051 {
1052   int retval;
1053
1054   cspi_return_val_if_fail (obj, -1);
1055   retval = Accessibility_Relation_getNTargets (CSPI_OBJREF (obj), cspi_ev());
1056   cspi_return_val_if_ev ("getNTargets", -1);
1057   return retval;
1058 }
1059
1060 /**
1061  * AccessibleRelation_getTarget:
1062  * @obj: a pointer to the #AccessibleRelation object to query.
1063  * @i: a (zero-index) integer indicating which (of possibly several) target is requested.
1064  *
1065  * Get the @i-th target of a specified #AccessibleRelation relationship.
1066  *
1067  * Returns: an #Accessible which is the @i-th object with which the
1068  *      originating #Accessible has relationship specified in the
1069  *      #AccessibleRelation object.
1070  *
1071  **/
1072 Accessible *
1073 AccessibleRelation_getTarget (AccessibleRelation *obj, int i)
1074 {
1075   Accessible *retval;
1076
1077   cspi_return_val_if_fail (obj, NULL);
1078
1079   retval = cspi_object_add (
1080                          Accessibility_Relation_getTarget (CSPI_OBJREF(obj),
1081                                                            i, cspi_ev()));
1082   cspi_return_val_if_ev ("getTarget", NULL);
1083   return retval;
1084 }
1085
1086 /**
1087  * AccessibleStateSet_ref:
1088  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1089  *
1090  * Increment the reference count for an #AccessibleStateSet object.
1091  *
1092  **/
1093 void
1094 AccessibleStateSet_ref (AccessibleStateSet *obj)
1095 {
1096   spi_state_set_cache_ref (obj);
1097 }
1098
1099 /**
1100  * AccessibleStateSet_unref:
1101  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1102  *
1103  * Decrement the reference count for an #AccessibleStateSet object.
1104  *
1105  **/
1106 void
1107 AccessibleStateSet_unref (AccessibleStateSet *obj)
1108 {
1109   spi_state_set_cache_unref (obj);
1110 }
1111
1112 static Accessibility_StateType
1113 spi_state_to_corba (AccessibleState state)
1114 {
1115 #define MAP_STATE(a) \
1116   case SPI_STATE_##a: \
1117     return Accessibility_STATE_##a
1118
1119   switch (state)
1120     {
1121       MAP_STATE (INVALID);
1122       MAP_STATE (ACTIVE);
1123       MAP_STATE (ARMED);
1124       MAP_STATE (BUSY);
1125       MAP_STATE (CHECKED);
1126       MAP_STATE (DEFUNCT);
1127       MAP_STATE (EDITABLE);
1128       MAP_STATE (ENABLED);
1129       MAP_STATE (EXPANDABLE);
1130       MAP_STATE (EXPANDED);
1131       MAP_STATE (FOCUSABLE);
1132       MAP_STATE (FOCUSED);
1133       MAP_STATE (HORIZONTAL);
1134       MAP_STATE (ICONIFIED);
1135       MAP_STATE (MODAL);
1136       MAP_STATE (MULTI_LINE);
1137       MAP_STATE (MULTISELECTABLE);
1138       MAP_STATE (OPAQUE);
1139       MAP_STATE (PRESSED);
1140       MAP_STATE (RESIZABLE);
1141       MAP_STATE (SELECTABLE);
1142       MAP_STATE (SELECTED);
1143       MAP_STATE (SENSITIVE);
1144       MAP_STATE (SHOWING);
1145       MAP_STATE (SINGLE_LINE);
1146       MAP_STATE (STALE);
1147       MAP_STATE (TRANSIENT);
1148       MAP_STATE (VERTICAL);
1149       MAP_STATE (VISIBLE);
1150       MAP_STATE (MANAGES_DESCENDANTS);
1151       MAP_STATE (INDETERMINATE);
1152     default:
1153       return Accessibility_STATE_INVALID;
1154   }
1155 #undef MAP_STATE
1156 }
1157
1158 /**
1159  * AccessibleStateSet_contains:
1160  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1161  * @state: an #AccessibleState for which the specified #AccessibleStateSet
1162  *       will be queried.
1163  *
1164  * Determine whether a given #AccessibleStateSet includes a given state; that is,
1165  *       whether @state is true for the stateset in question.
1166  *
1167  * Returns: #TRUE if @state is true/included in the given #AccessibleStateSet,
1168  *          otherwise #FALSE.
1169  *
1170  **/
1171 SPIBoolean
1172 AccessibleStateSet_contains (AccessibleStateSet *obj,
1173                              AccessibleState state)
1174 {
1175   return spi_state_set_cache_contains (obj, spi_state_to_corba (state));
1176 }
1177
1178 /**
1179  * AccessibleStateSet_add:
1180  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1181  * @state: an #AccessibleState to be added to the specified #AccessibleStateSet
1182  *
1183  * Add a particular #AccessibleState to an #AccessibleStateSet (i.e. set the
1184  *       given state to #TRUE in the stateset.
1185  *
1186  **/
1187 void
1188 AccessibleStateSet_add (AccessibleStateSet *obj,
1189                         AccessibleState state)
1190 {
1191   spi_state_set_cache_add (obj, spi_state_to_corba (state));
1192 }
1193
1194 /**
1195  * AccessibleStateSet_remove:
1196  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1197  * @state: an #AccessibleState to be removed from the specified #AccessibleStateSet
1198  *
1199  * Remove a particular #AccessibleState to an #AccessibleStateSet (i.e. set the
1200  *       given state to #FALSE in the stateset.)
1201  *
1202  **/
1203 void
1204 AccessibleStateSet_remove (AccessibleStateSet *obj,
1205                            AccessibleState state)
1206 {
1207   spi_state_set_cache_remove (obj, spi_state_to_corba (state));
1208 }
1209
1210 /**
1211  * AccessibleStateSet_equals:
1212  * @obj: a pointer to the first #AccessibleStateSet object on which to operate.
1213  * @obj2: a pointer to the second #AccessibleStateSet object on which to operate.
1214  *
1215  * Determine whether two instances of #AccessibleStateSet are equivalent (i.e.
1216  *         consist of the same #AccessibleStates).  Useful for checking multiple
1217  *         state variables at once; construct the target state then compare against it.
1218  *
1219  * @see AccessibleStateSet_compare().
1220  *
1221  * Returns: #TRUE if the two #AccessibleStateSets are equivalent,
1222  *          otherwise #FALSE.
1223  *
1224  **/
1225 SPIBoolean
1226 AccessibleStateSet_equals (AccessibleStateSet *obj,
1227                            AccessibleStateSet *obj2)
1228 {
1229   SPIBoolean   eq;
1230   AtkStateSet *cmp;
1231
1232   if (obj == obj2)
1233     {
1234       return TRUE;
1235     }
1236
1237   cmp = spi_state_set_cache_xor (obj, obj2);
1238   eq = spi_state_set_cache_is_empty (cmp);
1239   spi_state_set_cache_unref (cmp);
1240
1241   return eq;
1242 }
1243
1244 /**
1245  * AccessibleStateSet_compare:
1246  * @obj: a pointer to the first #AccessibleStateSet object on which to operate.
1247  * @obj2: a pointer to the second #AccessibleStateSet object on which to operate.
1248  *
1249  * Determine the differences between two instances of #AccessibleStateSet.
1250  * Not Yet Implemented.
1251  *.
1252  * @see AccessibleStateSet_equals().
1253  *
1254  * Returns: an #AccessibleStateSet object containing all states contained on one of
1255  *          the two sets but not the other.
1256  *
1257  **/
1258 AccessibleStateSet *
1259 AccessibleStateSet_compare (AccessibleStateSet *obj,
1260                             AccessibleStateSet *obj2)
1261 {
1262   return spi_state_set_cache_xor (obj, obj2);
1263 }
1264
1265 /**
1266  * AccessibleStateSet_isEmpty:
1267  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1268  *
1269  * Determine whether a given #AccessibleStateSet is the empty set.
1270  *
1271  * Returns: #TRUE if the given #AccessibleStateSet contains no (true) states,
1272  *          otherwise #FALSE.
1273  *
1274  **/
1275 SPIBoolean
1276 AccessibleStateSet_isEmpty (AccessibleStateSet *obj)
1277 {
1278   return spi_state_set_cache_is_empty (obj);
1279 }
1280
1281