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   role_table [Accessibility_ROLE_EDITBAR] = SPI_ROLE_EDITBAR;
 193
 194   return TRUE;
 195 }
 196
 197 static AccessibleRole
 198 cspi_role_from_spi_role (Accessibility_Role role)
 199 {
 200   /* array is sized according to IDL roles because IDL roles are the index */
 201   static AccessibleRole cspi_role_table [Accessibility_ROLE_LAST_DEFINED];
 202   static SPIBoolean is_initialized = FALSE;
 203   AccessibleRole cspi_role;
 204   if (!is_initialized)
 205     {
 206       is_initialized = cspi_init_role_table (cspi_role_table);
 207     }
 208   if (role >= 0 && role < Accessibility_ROLE_LAST_DEFINED)
 209     {
 210       cspi_role = cspi_role_table [role];
 211     }
 212   else
 213     {
 214       cspi_role = SPI_ROLE_EXTENDED;
 215     }
 216   return cspi_role;
 217 }
 218
 219 /**
 220  * AccessibleRole_getName:
 221  * @role: an #AccessibleRole object to query.
 222  *
 223  * Get a localizeable string that indicates the name of an #AccessibleRole.
 224  * <em>DEPRECATED.</em>
 225  *
 226  * Returns: a localizable string name for an #AccessibleRole enumerated type.
 227  **/
 228 char *
 229 AccessibleRole_getName (AccessibleRole role)
 230 {
 231   if (role < MAX_ROLES && role_names [(int) role])
 232     {
 233       return CORBA_string_dup (role_names [(int) role]);
 234     }
 235   else
 236     {
 237       return CORBA_string_dup ("");
 238     }
 239 }
 240
 241 /**
 242  * Accessible_ref:
 243  * @obj: a pointer to the #Accessible object on which to operate.
 244  *
 245  * Increment the reference count for an #Accessible object.
 246  **/
 247 void
 248 Accessible_ref (Accessible *obj)
 249 {
 250   cspi_object_ref (obj);
 251 }
 252
 253 /**
 254  * Accessible_unref:
 255  * @obj: a pointer to the #Accessible object on which to operate.
 256  *
 257  * Decrement the reference count for an #Accessible object.
 258  **/
 259 void
 260 Accessible_unref (Accessible *obj)
 261 {
 262   cspi_object_unref (obj);
 263 }
 264
 265 /**
 266  * Accessible_getName:
 267  * @obj: a pointer to the #Accessible object on which to operate.
 268  *
 269  * Get the name of an #Accessible object.
 270  *
 271  * Returns: a UTF-8 string indicating the name of the #Accessible object.
 272  * or NULL on exception
 273  **/
 274 char *
 275 Accessible_getName (Accessible *obj)
 276 {
 277   char *retval;
 278
 279   cspi_return_val_if_fail (obj != NULL, NULL);
 280
 281   retval = Accessibility_Accessible__get_name (CSPI_OBJREF (obj), cspi_ev ());
 282
 283   cspi_return_val_if_ev ("getName", NULL);
 284
 285   return retval;
 286 }
 287
 288 /**
 289  * Accessible_getDescription:
 290  * @obj: a pointer to the #Accessible object on which to operate.
 291  *
 292  * Get the description of an #Accessible object.
 293  *
 294  * Returns: a UTF-8 string describing the #Accessible object.
 295  * or NULL on exception
 296  **/
 297 char *
 298 Accessible_getDescription (Accessible *obj)
 299 {
 300   char *retval;
 301
 302   cspi_return_val_if_fail (obj != NULL, NULL);
 303
 304   retval = Accessibility_Accessible__get_description (CSPI_OBJREF (obj),
 305                                                cspi_ev ());
 306
 307   cspi_return_val_if_ev ("getDescription", NULL);
 308
 309   return retval;
 310 }
 311
 312 /**
 313  * Accessible_getParent:
 314  * @obj: a pointer to the #Accessible object to query.
 315  *
 316  * Get an #Accessible object's parent container.
 317  *
 318  * Returns: a pointer tothe #Accessible object which contains the given
 319  *          #Accessible instance, or NULL if the @obj has no parent container.
 320  *
 321  **/
 322 Accessible *
 323 Accessible_getParent (Accessible *obj)
 324 {
 325   Accessible *retval;
 326
 327   cspi_return_val_if_fail (obj != NULL, NULL);
 328
 329   retval = cspi_object_add (
 330     Accessibility_Accessible__get_parent (CSPI_OBJREF (obj),
 331                                           cspi_ev ()));
 332
 333   cspi_return_val_if_ev ("getParent", NULL);
 334
 335   return retval;
 336 }
 337
 338 /**
 339  * Accessible_getChildCount:
 340  * @obj: a pointer to the #Accessible object on which to operate.
 341  *
 342  * Get the number of children contained by an #Accessible object.
 343  *
 344  * Returns: a #long indicating the number of #Accessible children
 345  *          contained by an #Accessible object. or -1 on exception
 346  *
 347  **/
 348 long
 349 Accessible_getChildCount (Accessible *obj)
 350 {
 351   long retval;
 352
 353   cspi_return_val_if_fail (obj != NULL, -1);
 354
 355   retval = Accessibility_Accessible__get_childCount (CSPI_OBJREF (obj),
 356                                               cspi_ev ());
 357
 358   cspi_return_val_if_ev ("getChildCount", -1);
 359
 360   return retval;
 361 }
 362
 363 /**
 364  * Accessible_getChildAtIndex:
 365  * @obj: a pointer to the #Accessible object on which to operate.
 366  * @childIndex: a #long indicating which child is specified.
 367  *
 368  * Get the #Accessible child of an #Accessible object at a given index.
 369  *
 370  * Returns: a pointer to the #Accessible child object at index
 371  *          @childIndex. or NULL on exception
 372  **/
 373 Accessible *
 374 Accessible_getChildAtIndex (Accessible *obj,
 375                             long int    childIndex)
 376 {
 377   Accessible *retval;
 378
 379   cspi_return_val_if_fail (obj != NULL, NULL);
 380
 381   retval = cspi_object_add (
 382     Accessibility_Accessible_getChildAtIndex (CSPI_OBJREF (obj),
 383                                               childIndex, cspi_ev ()));
 384
 385   cspi_return_val_if_ev ("getChildAtIndex", NULL);
 386   return retval;
 387 }
 388
 389 /**
 390  * Accessible_getIndexInParent:
 391  * @obj: a pointer to the #Accessible object on which to operate.
 392  *
 393  * Get the index of an #Accessible object in its containing #Accessible.
 394  *
 395  * Returns: a #long indicating the index of the #Accessible object
 396  *          in its parent (i.e. containing) #Accessible instance,
 397  *          or -1 if @obj has no containing parent or on exception.
 398  **/
 399 long
 400 Accessible_getIndexInParent (Accessible *obj)
 401 {
 402   long retval;
 403
 404   cspi_return_val_if_fail (obj != NULL, -1);
 405
 406   retval = Accessibility_Accessible_getIndexInParent (CSPI_OBJREF (obj), cspi_ev ());
 407
 408   cspi_return_val_if_ev ("getIndexInparent", -1);
 409   return retval;
 410 }
 411
 412 /**
 413  * Accessible_getRelationSet:
 414  * @obj: a pointer to the #Accessible object on which to operate.
 415  *
 416  * Get the set of #AccessibleRelation objects which describe this #Accessible object's
 417  *       relationships with other #Accessible objects.
 418  *
 419  * Returns: an array of #AccessibleRelation pointers. or NULL on exception
 420  **/
 421 AccessibleRelation **
 422 Accessible_getRelationSet (Accessible *obj)
 423 {
 424   int i;
 425   int n_relations;
 426   AccessibleRelation **relations;
 427   Accessibility_RelationSet *relation_set;
 428
 429   cspi_return_val_if_fail (obj != NULL, NULL);
 430
 431   relation_set =
 432     Accessibility_Accessible_getRelationSet (CSPI_OBJREF (obj), cspi_ev ());
 433
 434   cspi_return_val_if_ev ("getRelationSet", NULL);
 435
 436   n_relations = relation_set->_length;
 437   relations = malloc (sizeof (AccessibleRelation *) * (n_relations + 1));
 438
 439   for (i = 0; i < n_relations; ++i)
 440     {
 441       relations[i] = cspi_object_add (CORBA_Object_duplicate (
 442               relation_set->_buffer[i], cspi_ev ()));
 443     }
 444   relations[i] = NULL;
 445
 446   CORBA_free (relation_set);
 447
 448   return relations;
 449 }
 450
 451 /**
 452  * Accessible_getRole:
 453  * @obj: a pointer to the #Accessible object on which to operate.
 454  *
 455  * Get the UI role of an #Accessible object.
 456  * A UTF-8 string describing this role can be obtained via Accessible_getRoleName ().
 457  *
 458  * Returns: the #AccessibleRole of the object.
 459  *
 460  **/
 461 AccessibleRole
 462 Accessible_getRole (Accessible *obj)
 463 {
 464   Accessibility_Role retval;
 465
 466   cspi_return_val_if_fail (obj != NULL, SPI_ROLE_INVALID);
 467
 468   retval =
 469     Accessibility_Accessible_getRole (CSPI_OBJREF (obj), cspi_ev ());
 470
 471   cspi_return_val_if_ev ("getRole", SPI_ROLE_INVALID);
 472
 473   return cspi_role_from_spi_role (retval);
 474 }
 475
 476 /**
 477  * Accessible_getRoleName:
 478  * @obj: a pointer to the #Accessible object on which to operate.
 479  *
 480  * Get a UTF-8 string describing the role this object plays in the UI.
 481  * This method will return useful values for roles that fall outside the
 482  * enumeration used in Accessible_getRole ().
 483  *
 484  * Returns: a UTF-8 string specifying the role of this #Accessible object.
 485  *
 486  **/
 487 char *
 488 Accessible_getRoleName (Accessible *obj)
 489 {
 490   char *retval;
 491
 492   cspi_return_val_if_fail (obj != NULL, CORBA_string_dup ("invalid"));
 493
 494   retval =
 495     Accessibility_Accessible_getRoleName (CSPI_OBJREF (obj), cspi_ev ());
 496
 497   cspi_return_val_if_ev ("getRoleName", CORBA_string_dup ("invalid"));
 498
 499   return retval;
 500 }
 501
 502 /**
 503  * Accessible_getLocalizedRoleName:
 504  * @obj: a pointer to the #Accessible object on which to operate.
 505  *
 506  * Get a UTF-8 string describing the (localized) role this object plays in the UI.
 507  * This method will return useful values for roles that fall outside the
 508  * enumeration used in Accessible_getRole ().
 509  *
 510  * Returns: a UTF-8 string specifying the role of this #Accessible object.
 511  *
 512  **/
 513 char *
 514 Accessible_getLocalizedRoleName (Accessible *obj)
 515 {
 516   char *retval;
 517
 518   cspi_return_val_if_fail (obj != NULL, CORBA_string_dup ("invalid"));
 519
 520   retval =
 521     Accessibility_Accessible_getLocalizedRoleName (CSPI_OBJREF (obj), cspi_ev ());
 522
 523   cspi_return_val_if_ev ("getLocalizedRoleName", CORBA_string_dup ("invalid"));
 524
 525   return retval;
 526 }
 527
 528 /**
 529  * Accessible_getStateSet:
 530  * @obj: a pointer to the #Accessible object on which to operate.
 531  *
 532  * Returns: a pointer to an #AccessibleStateSet representing the object's current state.
 533  **/
 534 AccessibleStateSet *
 535 Accessible_getStateSet (Accessible *obj)
 536 {
 537   AccessibleStateSet *retval;
 538   Accessibility_StateSet corba_stateset;
 539   Accessibility_StateSeq *corba_seq;
 540
 541   cspi_return_val_if_fail (obj != NULL, NULL);
 542
 543   corba_stateset = Accessibility_Accessible_getState (
 544           CSPI_OBJREF (obj), cspi_ev ());
 545   cspi_return_val_if_ev ("getState", NULL);
 546
 547   cspi_return_val_if_fail (corba_stateset != CORBA_OBJECT_NIL, NULL);
 548   cspi_return_val_if_fail (cspi_ping (corba_stateset), NULL);
 549   corba_seq = Accessibility_StateSet_getStates (corba_stateset, cspi_ev ());
 550   cspi_return_val_if_ev ("getState", NULL);
 551
 552   retval = spi_state_set_cache_new (corba_seq);
 553
 554   CORBA_free (corba_seq);
 555   cspi_release_unref (corba_stateset);
 556
 557   return retval;
 558 }
 559
 560 /* Interface query methods */
 561
 562 /**
 563  * Accessible_isAction:
 564  * @obj: a pointer to the #Accessible instance to query.
 565  *
 566  * Query whether the specified #Accessible implements #AccessibleAction.
 567  *
 568  * Returns: #TRUE if @obj implements the #AccessibleAction interface,
 569  *          #FALSE otherwise.
 570  **/
 571 SPIBoolean
 572 Accessible_isAction (Accessible *obj)
 573 {
 574   return cspi_accessible_is_a (obj,
 575                               "IDL:Accessibility/Action:1.0");
 576 }
 577
 578 /**
 579  * Accessible_isApplication:
 580  * @obj: a pointer to the #Accessible instance to query.
 581  *
 582  * Query whether the specified #Accessible implements #AccessibleApplication.
 583  *
 584  * Returns: #TRUE if @obj implements the #AccessibleApplication interface,
 585  *          #FALSE otherwise.
 586  **/
 587 SPIBoolean
 588 Accessible_isApplication (Accessible *obj)
 589 {
 590   return cspi_accessible_is_a (obj,
 591                               "IDL:Accessibility/Application:1.0");
 592 }
 593
 594 /**
 595  * Accessible_isComponent:
 596  * @obj: a pointer to the #Accessible instance to query.
 597  *
 598  * Query whether the specified #Accessible implements #AccessibleComponent.
 599  *
 600  * Returns: #TRUE if @obj implements the #AccessibleComponent interface,
 601  *          #FALSE otherwise.
 602  **/
 603 SPIBoolean
 604 Accessible_isComponent (Accessible *obj)
 605 {
 606   return cspi_accessible_is_a (obj,
 607                               "IDL:Accessibility/Component:1.0");
 608 }
 609
 610 /**
 611  * Accessible_isEditableText:
 612  * @obj: a pointer to the #Accessible instance to query.
 613  *
 614  * Query whether the specified #Accessible implements #AccessibleEditableText.
 615  *
 616  * Returns: #TRUE if @obj implements the #AccessibleEditableText interface,
 617  *          #FALSE otherwise.
 618  **/
 619 SPIBoolean
 620 Accessible_isEditableText (Accessible *obj)
 621 {
 622   return cspi_accessible_is_a (obj,
 623                               "IDL:Accessibility/EditableText:1.0");
 624 }
 625
 626 /**
 627  * Accessible_isHypertext:
 628  * @obj: a pointer to the #Accessible instance to query.
 629  *
 630  * Query whether the specified #Accessible implements #AccessibleHypertext.
 631  *
 632  * Returns: #TRUE if @obj implements the #AccessibleHypertext interface,
 633  *          #FALSE otherwise.
 634  **/
 635 SPIBoolean
 636 Accessible_isHypertext (Accessible *obj)
 637 {
 638   return cspi_accessible_is_a (obj,
 639                               "IDL:Accessibility/Hypertext:1.0");
 640 }
 641
 642 /**
 643  * Accessible_isImage:
 644  * @obj: a pointer to the #Accessible instance to query.
 645  *
 646  * Query whether the specified #Accessible implements #AccessibleImage.
 647  *
 648  * Returns: #TRUE if @obj implements the #AccessibleImage interface,
 649  *          #FALSE otherwise.
 650 **/
 651 SPIBoolean
 652 Accessible_isImage (Accessible *obj)
 653 {
 654   return cspi_accessible_is_a (obj,
 655                               "IDL:Accessibility/Image:1.0");
 656 }
 657
 658 /**
 659  * Accessible_isSelection:
 660  * @obj: a pointer to the #Accessible instance to query.
 661  *
 662  * Query whether the specified #Accessible implements #AccessibleSelection.
 663  *
 664  * Returns: #TRUE if @obj implements the #AccessibleSelection interface,
 665  *          #FALSE otherwise.
 666 **/
 667 SPIBoolean
 668 Accessible_isSelection (Accessible *obj)
 669 {
 670   return cspi_accessible_is_a (obj,
 671                               "IDL:Accessibility/Selection:1.0");
 672 }
 673
 674 /**
 675  * Accessible_isTable:
 676  * @obj: a pointer to the #Accessible instance to query.
 677  *
 678  * Query whether the specified #Accessible implements #AccessibleTable.
 679  *
 680  * Returns: #TRUE if @obj implements the #AccessibleTable interface,
 681  *          #FALSE otherwise.
 682 **/
 683 SPIBoolean
 684 Accessible_isTable (Accessible *obj)
 685 {
 686   return cspi_accessible_is_a (obj,
 687                               "IDL:Accessibility/Table:1.0");
 688 }
 689
 690 /**
 691  * Accessible_isStreamableContent:
 692  * @obj: a pointer to the #Accessible instance to query.
 693  *
 694  * Query whether the specified #Accessible implements
 695  *          #AccessibleStreamableContent.
 696  *
 697  * Returns: #TRUE if @obj implements the #AccessibleStreamableContent interface,
 698  *          #FALSE otherwise.
 699 **/
 700 SPIBoolean
 701 Accessible_isStreamableContent (Accessible *obj)
 702 {
 703   return cspi_accessible_is_a (obj,
 704                               "IDL:Accessibility/StreamableContent:1.0");
 705 }
 706
 707 /**
 708  * Accessible_isText:
 709  * @obj: a pointer to the #Accessible instance to query.
 710  *
 711  * Query whether the specified #Accessible implements #AccessibleText.
 712  *
 713  * Returns: #TRUE if @obj implements the #AccessibleText interface,
 714  *          #FALSE otherwise.
 715 **/
 716 SPIBoolean
 717 Accessible_isText (Accessible *obj)
 718 {
 719   return cspi_accessible_is_a (obj,
 720                               "IDL:Accessibility/Text:1.0");
 721 }
 722
 723 /**
 724  * Accessible_isValue:
 725  * @obj: a pointer to the #Accessible instance to query.
 726  *
 727  * Query whether the specified #Accessible implements #AccessibleValue.
 728  *
 729  * Returns: #TRUE if @obj implements the #AccessibleValue interface,
 730  *          #FALSE otherwise.
 731 **/
 732 SPIBoolean
 733 Accessible_isValue (Accessible *obj)
 734 {
 735   return cspi_accessible_is_a (obj,
 736                               "IDL:Accessibility/Value:1.0");
 737 }
 738
 739 /**
 740  * Accessible_getApplication:
 741  * @obj: a pointer to the #Accessible instance to query.
 742  *
 743  * Get the #AccessibleApplication interface for an #Accessible.
 744  *
 745  * Returns: a pointer to an #AccessibleApplication interface instance, or
 746  *          NULL if @obj does not implement #AccessibleApplication.
 747  **/
 748 AccessibleApplication *
 749 Accessible_getApplication (Accessible *obj)
 750 {
 751   return (AccessibleApplication *) Accessible_queryInterface (
 752           obj, "IDL:Accessibility/Application:1.0");
 753 }
 754
 755 /**
 756  * Accessible_getAction:
 757  * @obj: a pointer to the #Accessible instance to query.
 758  *
 759  * Get the #AccessibleAction interface for an #Accessible.
 760  *
 761  * Returns: a pointer to an #AccessibleAction interface instance, or
 762  *          NULL if @obj does not implement #AccessibleAction.
 763  **/
 764 AccessibleAction *
 765 Accessible_getAction (Accessible *obj)
 766 {
 767   return (AccessibleAction *) Accessible_queryInterface (
 768           obj, "IDL:Accessibility/Action:1.0");
 769 }
 770
 771 /**
 772  * Accessible_getComponent:
 773  * @obj: a pointer to the #Accessible instance to query.
 774  *
 775  * Get the #AccessibleComponent interface for an #Accessible.
 776  *
 777  * Returns: a pointer to an #AccessibleComponent interface instance, or
 778  *          NULL if @obj does not implement #AccessibleComponent.
 779  **/
 780 AccessibleComponent *
 781 Accessible_getComponent (Accessible *obj)
 782 {
 783   return (AccessibleComponent *) Accessible_queryInterface (
 784           obj, "IDL:Accessibility/Component:1.0");
 785 }
 786
 787 /**
 788  * Accessible_getEditableText:
 789  * @obj: a pointer to the #Accessible instance to query.
 790  *
 791  * Get the #AccessibleEditableText interface for an #Accessible.
 792  *
 793  * Returns: a pointer to an #AccessibleEditableText interface instance, or
 794  *          NULL if @obj does not implement #AccessibleEditableText.
 795  **/
 796 AccessibleEditableText *
 797 Accessible_getEditableText (Accessible *obj)
 798 {
 799   return (AccessibleEditableText *) Accessible_queryInterface (
 800           obj, "IDL:Accessibility/EditableText:1.0");
 801 }
 802
 803
 804
 805 /**
 806  * Accessible_getHypertext:
 807  * @obj: a pointer to the #Accessible instance to query.
 808  *
 809  * Get the #AccessibleHypertext interface for an #Accessible.
 810  *
 811  * Returns: a pointer to an #AccessibleHypertext interface instance, or
 812  *          NULL if @obj does not implement #AccessibleHypertext.
 813  **/
 814 AccessibleHypertext *
 815 Accessible_getHypertext (Accessible *obj)
 816 {
 817   return (AccessibleHypertext *) Accessible_queryInterface (
 818           obj, "IDL:Accessibility/Hypertext:1.0");
 819 }
 820
 821
 822
 823 /**
 824  * Accessible_getImage:
 825  * @obj: a pointer to the #Accessible instance to query.
 826  *
 827  * Get the #AccessibleImage interface for an #Accessible.
 828  *
 829  * Returns: a pointer to an #AccessibleImage interface instance, or
 830  *          NULL if @obj does not implement #AccessibleImage.
 831  **/
 832 AccessibleImage *
 833 Accessible_getImage (Accessible *obj)
 834 {
 835   return (AccessibleImage *) Accessible_queryInterface (
 836           obj, "IDL:Accessibility/Image:1.0");
 837 }
 838
 839
 840
 841 /**
 842  * Accessible_getSelection:
 843  * @obj: a pointer to the #Accessible instance to query.
 844  *
 845  * Get the #AccessibleSelection interface for an #Accessible.
 846  *
 847  * Returns: a pointer to an #AccessibleSelection interface instance, or
 848  *          NULL if @obj does not implement #AccessibleSelection.
 849  **/
 850 AccessibleSelection *
 851 Accessible_getSelection (Accessible *obj)
 852 {
 853   return (AccessibleSelection *) Accessible_queryInterface (
 854           obj, "IDL:Accessibility/Selection:1.0");
 855 }
 856
 857
 858
 859 /**
 860  * Accessible_getStreamableContent:
 861  * @obj: a pointer to the #Accessible instance to query.
 862  *
 863  * Get the #AccessibleStreamableContent interface for an #Accessible.
 864  *
 865  * Returns: a pointer to an #AccessibleStreamableContent interface instance, or
 866  *          NULL if @obj does not implement #AccessibleStreamableContent.
 867  **/
 868 AccessibleStreamableContent *
 869 Accessible_getStreamableContent (Accessible *obj)
 870 {
 871   return (AccessibleStreamableContent *) Accessible_queryInterface (
 872           obj, "IDL:Accessibility/StreamableContent:1.0");
 873 }
 874
 875 /**
 876  * Accessible_getTable:
 877  * @obj: a pointer to the #Accessible instance to query.
 878  *
 879  * Get the #AccessibleTable interface for an #Accessible.
 880  *
 881  * Returns: a pointer to an #AccessibleTable interface instance, or
 882  *          NULL if @obj does not implement #AccessibleTable.
 883  **/
 884 AccessibleTable *
 885 Accessible_getTable (Accessible *obj)
 886 {
 887   return (AccessibleTable *) Accessible_queryInterface (
 888           obj, "IDL:Accessibility/Table:1.0");
 889 }
 890
 891 /**
 892  * Accessible_getText:
 893  * @obj: a pointer to the #Accessible instance to query.
 894  *
 895  * Get the #AccessibleText interface for an #Accessible.
 896  *
 897  * Returns: a pointer to an #AccessibleText interface instance, or
 898  *          NULL if @obj does not implement #AccessibleText.
 899  **/
 900 AccessibleText *
 901 Accessible_getText (Accessible *obj)
 902 {
 903   return (AccessibleText *) Accessible_queryInterface (
 904           obj, "IDL:Accessibility/Text:1.0");
 905 }
 906
 907
 908
 909 /**
 910  * Accessible_getValue:
 911  * @obj: a pointer to the #Accessible instance to query.
 912  *
 913  * Get the #AccessibleValue interface for an #Accessible.
 914  *
 915  * Returns: a pointer to an #AccessibleValue interface instance, or
 916  *          NULL if @obj does not implement #AccessibleValue.
 917  **/
 918 AccessibleValue *
 919 Accessible_getValue (Accessible *obj)
 920 {
 921   return (AccessibleValue *) Accessible_queryInterface (
 922           obj, "IDL:Accessibility/Value:1.0");
 923 }
 924
 925
 926
 927 /**
 928  * Accessible_queryInterface:
 929  * @obj: a pointer to the #Accessible instance to query.
 930  * @interface_name: a UTF-8 character string specifiying the requested interface.
 931  *
 932  * Query an #Accessible object to for a named interface.
 933  *
 934  * Returns: an instance of the named interface object, if it is implemented
 935  *          by @obj, or NULL otherwise.
 936  *
 937  **/
 938 AccessibleUnknown *
 939 Accessible_queryInterface (Accessible *obj,
 940                            const char *interface_name)
 941 {
 942   Bonobo_Unknown iface;
 943
 944   if (!obj)
 945     {
 946       return NULL;
 947     }
 948
 949   iface = Accessibility_Accessible_queryInterface (CSPI_OBJREF (obj),
 950                                                    interface_name,
 951                                                    cspi_ev ());
 952
 953
 954   cspi_return_val_if_ev ("queryInterface", NULL);
 955
 956   /*
 957    * FIXME: we need to be fairly sure that references are going
 958    * to mach up if we are going to expose QueryInterface, ie. we
 959    * can't allow people to do:
 960    * b = a.qi ("b"); b.unref, b.unref to release a's reference.
 961    * this should be no real problem though for this level of API
 962    * user.
 963    */
 964
 965   return cspi_object_add (iface);
 966 }
 967
 968
 969 /**
 970  * AccessibleRelation_ref:
 971  * @obj: a pointer to the #AccessibleRelation object on which to operate.
 972  *
 973  * Increment the reference count for an #AccessibleRelation object.
 974  *
 975  **/
 976 void
 977 AccessibleRelation_ref (AccessibleRelation *obj)
 978 {
 979   cspi_object_ref (obj);
 980 }
 981
 982 /**
 983  * AccessibleRelation_unref:
 984  * @obj: a pointer to the #AccessibleRelation object on which to operate.
 985  *
 986  * Decrement the reference count for an #AccessibleRelation object.
 987  *
 988  **/
 989 void
 990 AccessibleRelation_unref (AccessibleRelation *obj)
 991 {
 992   cspi_object_unref (obj);
 993 }
 994
 995 static SPIBoolean
 996 cspi_init_relation_type_table (AccessibleRelationType *relation_type_table)
 997 {
 998   int i;
 999   for (i = 0; i < Accessibility_RELATION_LAST_DEFINED; ++i)
1000     {
1001       relation_type_table [i] = SPI_RELATION_NULL;
1002     }
1003   relation_type_table [Accessibility_RELATION_NULL] = SPI_RELATION_NULL;
1004   relation_type_table [Accessibility_RELATION_LABEL_FOR] = SPI_RELATION_LABEL_FOR;
1005   relation_type_table [Accessibility_RELATION_LABELLED_BY] = SPI_RELATION_LABELED_BY;
1006   relation_type_table [Accessibility_RELATION_CONTROLLER_FOR] = SPI_RELATION_CONTROLLER_FOR;
1007   relation_type_table [Accessibility_RELATION_CONTROLLED_BY] = SPI_RELATION_CONTROLLED_BY;
1008   relation_type_table [Accessibility_RELATION_MEMBER_OF] = SPI_RELATION_MEMBER_OF;
1009   relation_type_table [Accessibility_RELATION_TOOLTIP_FOR] = SPI_RELATION_NULL;
1010   relation_type_table [Accessibility_RELATION_NODE_CHILD_OF] = SPI_RELATION_NODE_CHILD_OF;
1011   relation_type_table [Accessibility_RELATION_EXTENDED] = SPI_RELATION_EXTENDED;
1012   relation_type_table [Accessibility_RELATION_FLOWS_TO] = SPI_RELATION_FLOWS_TO;
1013   relation_type_table [Accessibility_RELATION_FLOWS_FROM] = SPI_RELATION_FLOWS_FROM;
1014   relation_type_table [Accessibility_RELATION_SUBWINDOW_OF] = SPI_RELATION_SUBWINDOW_OF;
1015   relation_type_table [Accessibility_RELATION_EMBEDS] = SPI_RELATION_EMBEDS;
1016   relation_type_table [Accessibility_RELATION_EMBEDDED_BY] = SPI_RELATION_EMBEDDED_BY;
1017   relation_type_table [Accessibility_RELATION_POPUP_FOR] = SPI_RELATION_POPUP_FOR;
1018   return TRUE;
1019 }
1020
1021 static AccessibleRelationType
1022 cspi_relation_type_from_spi_relation_type (Accessibility_RelationType type)
1023 {
1024   /* array is sized according to IDL RelationType because IDL RelationTypes are the index */
1025   static AccessibleRelationType cspi_relation_type_table [Accessibility_RELATION_LAST_DEFINED];
1026   static SPIBoolean is_initialized = FALSE;
1027   AccessibleRelationType cspi_type;
1028   if (!is_initialized)
1029     {
1030       is_initialized = cspi_init_relation_type_table (cspi_relation_type_table);
1031     }
1032   if (type >= 0 && type < Accessibility_RELATION_LAST_DEFINED)
1033     {
1034       cspi_type = cspi_relation_type_table [type];
1035     }
1036   else
1037     {
1038       cspi_type = SPI_RELATION_NULL;
1039     }
1040   return cspi_type;
1041 }
1042 /**
1043  * AccessibleRelation_getRelationType:
1044  * @obj: a pointer to the #AccessibleRelation object to query.
1045  *
1046  * Get the type of relationship represented by an #AccessibleRelation.
1047  *
1048  * Returns: an #AccessibleRelationType indicating the type of relation
1049  *         encapsulated in this #AccessibleRelation object.
1050  *
1051  **/
1052 AccessibleRelationType
1053 AccessibleRelation_getRelationType (AccessibleRelation *obj)
1054 {
1055   Accessibility_RelationType retval;
1056
1057   cspi_return_val_if_fail (obj, SPI_RELATION_NULL);
1058   retval =
1059     Accessibility_Relation_getRelationType (CSPI_OBJREF (obj), cspi_ev());
1060   cspi_return_val_if_ev ("getRelationType", SPI_RELATION_NULL);
1061   return cspi_relation_type_from_spi_relation_type (retval);
1062 }
1063
1064 /**
1065  * AccessibleRelation_getNTargets:
1066  * @obj: a pointer to the #AccessibleRelation object to query.
1067  *
1068  * Get the number of objects which this relationship has as its
1069  *       target objects (the subject is the #Accessible from which this
1070  *       #AccessibleRelation originated).
1071  *
1072  * Returns: a short integer indicating how many target objects which the
1073  *       originating #Accessible object has the #AccessibleRelation
1074  *       relationship with.
1075  **/
1076 int
1077 AccessibleRelation_getNTargets (AccessibleRelation *obj)
1078 {
1079   int retval;
1080
1081   cspi_return_val_if_fail (obj, -1);
1082   retval = Accessibility_Relation_getNTargets (CSPI_OBJREF (obj), cspi_ev());
1083   cspi_return_val_if_ev ("getNTargets", -1);
1084   return retval;
1085 }
1086
1087 /**
1088  * AccessibleRelation_getTarget:
1089  * @obj: a pointer to the #AccessibleRelation object to query.
1090  * @i: a (zero-index) integer indicating which (of possibly several) target is requested.
1091  *
1092  * Get the @i-th target of a specified #AccessibleRelation relationship.
1093  *
1094  * Returns: an #Accessible which is the @i-th object with which the
1095  *      originating #Accessible has relationship specified in the
1096  *      #AccessibleRelation object.
1097  *
1098  **/
1099 Accessible *
1100 AccessibleRelation_getTarget (AccessibleRelation *obj, int i)
1101 {
1102   Accessible *retval;
1103
1104   cspi_return_val_if_fail (obj, NULL);
1105
1106   retval = cspi_object_add (
1107                          Accessibility_Relation_getTarget (CSPI_OBJREF(obj),
1108                                                            i, cspi_ev()));
1109   cspi_return_val_if_ev ("getTarget", NULL);
1110   return retval;
1111 }
1112
1113 /**
1114  * AccessibleStateSet_ref:
1115  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1116  *
1117  * Increment the reference count for an #AccessibleStateSet object.
1118  *
1119  **/
1120 void
1121 AccessibleStateSet_ref (AccessibleStateSet *obj)
1122 {
1123   spi_state_set_cache_ref (obj);
1124 }
1125
1126 /**
1127  * AccessibleStateSet_unref:
1128  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1129  *
1130  * Decrement the reference count for an #AccessibleStateSet object.
1131  *
1132  **/
1133 void
1134 AccessibleStateSet_unref (AccessibleStateSet *obj)
1135 {
1136   spi_state_set_cache_unref (obj);
1137 }
1138
1139 static Accessibility_StateType
1140 spi_state_to_corba (AccessibleState state)
1141 {
1142 #define MAP_STATE(a) \
1143   case SPI_STATE_##a: \
1144     return Accessibility_STATE_##a
1145
1146   switch (state)
1147     {
1148       MAP_STATE (INVALID);
1149       MAP_STATE (ACTIVE);
1150       MAP_STATE (ARMED);
1151       MAP_STATE (BUSY);
1152       MAP_STATE (CHECKED);
1153       MAP_STATE (DEFUNCT);
1154       MAP_STATE (EDITABLE);
1155       MAP_STATE (ENABLED);
1156       MAP_STATE (EXPANDABLE);
1157       MAP_STATE (EXPANDED);
1158       MAP_STATE (FOCUSABLE);
1159       MAP_STATE (FOCUSED);
1160       MAP_STATE (HORIZONTAL);
1161       MAP_STATE (ICONIFIED);
1162       MAP_STATE (MODAL);
1163       MAP_STATE (MULTI_LINE);
1164       MAP_STATE (MULTISELECTABLE);
1165       MAP_STATE (OPAQUE);
1166       MAP_STATE (PRESSED);
1167       MAP_STATE (RESIZABLE);
1168       MAP_STATE (SELECTABLE);
1169       MAP_STATE (SELECTED);
1170       MAP_STATE (SENSITIVE);
1171       MAP_STATE (SHOWING);
1172       MAP_STATE (SINGLE_LINE);
1173       MAP_STATE (STALE);
1174       MAP_STATE (TRANSIENT);
1175       MAP_STATE (VERTICAL);
1176       MAP_STATE (VISIBLE);
1177       MAP_STATE (MANAGES_DESCENDANTS);
1178       MAP_STATE (INDETERMINATE);
1179     default:
1180       return Accessibility_STATE_INVALID;
1181   }
1182 #undef MAP_STATE
1183 }
1184
1185 /**
1186  * AccessibleStateSet_contains:
1187  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1188  * @state: an #AccessibleState for which the specified #AccessibleStateSet
1189  *       will be queried.
1190  *
1191  * Determine whether a given #AccessibleStateSet includes a given state; that is,
1192  *       whether @state is true for the stateset in question.
1193  *
1194  * Returns: #TRUE if @state is true/included in the given #AccessibleStateSet,
1195  *          otherwise #FALSE.
1196  *
1197  **/
1198 SPIBoolean
1199 AccessibleStateSet_contains (AccessibleStateSet *obj,
1200                              AccessibleState state)
1201 {
1202   return spi_state_set_cache_contains (obj, spi_state_to_corba (state));
1203 }
1204
1205 /**
1206  * AccessibleStateSet_add:
1207  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1208  * @state: an #AccessibleState to be added to the specified #AccessibleStateSet
1209  *
1210  * Add a particular #AccessibleState to an #AccessibleStateSet (i.e. set the
1211  *       given state to #TRUE in the stateset.
1212  *
1213  **/
1214 void
1215 AccessibleStateSet_add (AccessibleStateSet *obj,
1216                         AccessibleState state)
1217 {
1218   spi_state_set_cache_add (obj, spi_state_to_corba (state));
1219 }
1220
1221 /**
1222  * AccessibleStateSet_remove:
1223  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1224  * @state: an #AccessibleState to be removed from the specified #AccessibleStateSet
1225  *
1226  * Remove a particular #AccessibleState to an #AccessibleStateSet (i.e. set the
1227  *       given state to #FALSE in the stateset.)
1228  *
1229  **/
1230 void
1231 AccessibleStateSet_remove (AccessibleStateSet *obj,
1232                            AccessibleState state)
1233 {
1234   spi_state_set_cache_remove (obj, spi_state_to_corba (state));
1235 }
1236
1237 /**
1238  * AccessibleStateSet_equals:
1239  * @obj: a pointer to the first #AccessibleStateSet object on which to operate.
1240  * @obj2: a pointer to the second #AccessibleStateSet object on which to operate.
1241  *
1242  * Determine whether two instances of #AccessibleStateSet are equivalent (i.e.
1243  *         consist of the same #AccessibleStates).  Useful for checking multiple
1244  *         state variables at once; construct the target state then compare against it.
1245  *
1246  * @see AccessibleStateSet_compare().
1247  *
1248  * Returns: #TRUE if the two #AccessibleStateSets are equivalent,
1249  *          otherwise #FALSE.
1250  *
1251  **/
1252 SPIBoolean
1253 AccessibleStateSet_equals (AccessibleStateSet *obj,
1254                            AccessibleStateSet *obj2)
1255 {
1256   SPIBoolean   eq;
1257   AtkStateSet *cmp;
1258
1259   if (obj == obj2)
1260     {
1261       return TRUE;
1262     }
1263
1264   cmp = spi_state_set_cache_xor (obj, obj2);
1265   eq = spi_state_set_cache_is_empty (cmp);
1266   spi_state_set_cache_unref (cmp);
1267
1268   return eq;
1269 }
1270
1271 /**
1272  * AccessibleStateSet_compare:
1273  * @obj: a pointer to the first #AccessibleStateSet object on which to operate.
1274  * @obj2: a pointer to the second #AccessibleStateSet object on which to operate.
1275  *
1276  * Determine the differences between two instances of #AccessibleStateSet.
1277  * Not Yet Implemented.
1278  *.
1279  * @see AccessibleStateSet_equals().
1280  *
1281  * Returns: an #AccessibleStateSet object containing all states contained on one of
1282  *          the two sets but not the other.
1283  *
1284  **/
1285 AccessibleStateSet *
1286 AccessibleStateSet_compare (AccessibleStateSet *obj,
1287                             AccessibleStateSet *obj2)
1288 {
1289   return spi_state_set_cache_xor (obj, obj2);
1290 }
1291
1292 /**
1293  * AccessibleStateSet_isEmpty:
1294  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1295  *
1296  * Determine whether a given #AccessibleStateSet is the empty set.
1297  *
1298  * Returns: #TRUE if the given #AccessibleStateSet contains no (true) states,
1299  *          otherwise #FALSE.
1300  *
1301  **/
1302 SPIBoolean
1303 AccessibleStateSet_isEmpty (AccessibleStateSet *obj)
1304 {
1305   return spi_state_set_cache_is_empty (obj);
1306 }
1307
1308