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