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