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 #endif
 898 }
 899
 900 /**
 901  * Accessible_getComponent:
 902  * @obj: a pointer to the #Accessible instance to query.
 903  *
 904  * Get the #AccessibleComponent interface for an #Accessible.
 905  *
 906  * Returns: a pointer to an #AccessibleComponent interface instance, or
 907  *          NULL if @obj does not implement #AccessibleComponent.
 908  **/
 909 AccessibleComponent *
 910 Accessible_getComponent (Accessible *obj)
 911 {
 912   return (AccessibleComponent *) Accessible_queryInterface (
 913           obj, spi_interface_component);
 914 }
 915
 916 /**
 917  * Accessible_getDocument:
 918  * @obj: a pointer to the #Accessible instance to query.
 919  *
 920  * Get the #AccessibleDocument interface for an #Accessible.
 921  *
 922  * Returns: a pointer to an #AccessibleDocument interface instance, or
 923  *          NULL if @obj does not implement #AccessibleDocument.
 924  **/
 925 AccessibleDocument *
 926 Accessible_getDocument (Accessible *obj)
 927 {
 928   return (AccessibleDocument *) Accessible_queryInterface (
 929           obj, spi_interface_document);
 930 }
 931
 932 /**
 933  * Accessible_getEditableText:
 934  * @obj: a pointer to the #Accessible instance to query.
 935  *
 936  * Get the #AccessibleEditableText interface for an #Accessible.
 937  *
 938  * Returns: a pointer to an #AccessibleEditableText interface instance, or
 939  *          NULL if @obj does not implement #AccessibleEditableText.
 940  **/
 941 AccessibleEditableText *
 942 Accessible_getEditableText (Accessible *obj)
 943 {
 944   return (AccessibleEditableText *) Accessible_queryInterface (
 945           obj, spi_interface_editable_text);
 946 }
 947
 948
 949 /**
 950  * Accessible_getHypertext:
 951  * @obj: a pointer to the #Accessible instance to query.
 952  *
 953  * Get the #AccessibleHypertext interface for an #Accessible.
 954  *
 955  * Returns: a pointer to an #AccessibleHypertext interface instance, or
 956  *          NULL if @obj does not implement #AccessibleHypertext.
 957  **/
 958 AccessibleHypertext *
 959 Accessible_getHypertext (Accessible *obj)
 960 {
 961   return (AccessibleHypertext *) Accessible_queryInterface (
 962           obj, spi_interface_hypertext);
 963 }
 964
 965
 966
 967 /**
 968  * Accessible_getImage:
 969  * @obj: a pointer to the #Accessible instance to query.
 970  *
 971  * Get the #AccessibleImage interface for an #Accessible.
 972  *
 973  * Returns: a pointer to an #AccessibleImage interface instance, or
 974  *          NULL if @obj does not implement #AccessibleImage.
 975  **/
 976 AccessibleImage *
 977 Accessible_getImage (Accessible *obj)
 978 {
 979   return (AccessibleImage *) Accessible_queryInterface (
 980           obj, spi_interface_image);
 981 }
 982
 983 /**
 984  * Accessible_getMatchRule:
 985  * @obj: a pointer to the #Accessible instance to query.
 986  *
 987  * Get the #AccessibleMatchRule interface for an #Accessible.
 988  *
 989  * Returns: a pointer to an #AccessibleMatchRule interface instance, or
 990  *          NULL if @obj does not implement #AccessibleMatchRule.
 991  **/
 992 AccessibleMatchRule *
 993 Accessible_getMatchRule (Accessible *obj)
 994 {
 995 #if 0
 996   return (AccessibleMatchRule *) Accessible_queryInterface (
 997           obj, spi_interface_match_rule);
 998 #else
 999   g_warning ("Match rules not supported");
1000 #endif
1001 }
1002
1003 /**
1004  * Accessible_getSelection:
1005  * @obj: a pointer to the #Accessible instance to query.
1006  *
1007  * Get the #AccessibleSelection interface for an #Accessible.
1008  *
1009  * Returns: a pointer to an #AccessibleSelection interface instance, or
1010  *          NULL if @obj does not implement #AccessibleSelection.
1011  **/
1012 AccessibleSelection *
1013 Accessible_getSelection (Accessible *obj)
1014 {
1015   return (AccessibleSelection *) Accessible_queryInterface (
1016           obj, spi_interface_selection);
1017 }
1018
1019
1020
1021 /**
1022  * Accessible_getStreamableContent:
1023  * @obj: a pointer to the #Accessible instance to query.
1024  *
1025  * Get the #AccessibleStreamableContent interface for an #Accessible.
1026  *
1027  * Returns: a pointer to an #AccessibleStreamableContent interface instance, or
1028  *          NULL if @obj does not implement #AccessibleStreamableContent.
1029  **/
1030 AccessibleStreamableContent *
1031 Accessible_getStreamableContent (Accessible *obj)
1032 {
1033 #if 0
1034   return (AccessibleStreamableContent *) Accessible_queryInterface (
1035           obj, spi_interface_streamable_content);
1036 #else
1037   g_warning ("Streamable content not supported");
1038   return NULL;
1039 #endif
1040 }
1041
1042 /**
1043  * Accessible_getTable:
1044  * @obj: a pointer to the #Accessible instance to query.
1045  *
1046  * Get the #AccessibleTable interface for an #Accessible.
1047  *
1048  * Returns: a pointer to an #AccessibleTable interface instance, or
1049  *          NULL if @obj does not implement #AccessibleTable.
1050  **/
1051 AccessibleTable *
1052 Accessible_getTable (Accessible *obj)
1053 {
1054   return (AccessibleTable *) Accessible_queryInterface (
1055           obj, spi_interface_table);
1056 }
1057
1058 /**
1059  * Accessible_getText:
1060  * @obj: a pointer to the #Accessible instance to query.
1061  *
1062  * Get the #AccessibleText interface for an #Accessible.
1063  *
1064  * Returns: a pointer to an #AccessibleText interface instance, or
1065  *          NULL if @obj does not implement #AccessibleText.
1066  **/
1067 AccessibleText *
1068 Accessible_getText (Accessible *obj)
1069 {
1070   return (AccessibleText *) Accessible_queryInterface (
1071           obj, spi_interface_text);
1072 }
1073
1074
1075
1076 /**
1077  * Accessible_getValue:
1078  * @obj: a pointer to the #Accessible instance to query.
1079  *
1080  * Get the #AccessibleValue interface for an #Accessible.
1081  *
1082  * Returns: a pointer to an #AccessibleValue interface instance, or
1083  *          NULL if @obj does not implement #AccessibleValue.
1084  **/
1085 AccessibleValue *
1086 Accessible_getValue (Accessible *obj)
1087 {
1088   return (AccessibleValue *) Accessible_queryInterface (
1089           obj, spi_interface_value);
1090 }
1091
1092
1093
1094 /**
1095  * Accessible_queryInterface:
1096  * @obj: a pointer to the #Accessible instance to query.
1097  * @interface_name: a UTF-8 character string specifiying the requested interface.
1098  *
1099  * Query an #Accessible object to for a named interface.
1100  *
1101  * Returns: an instance of the named interface object, if it is implemented
1102  *          by @obj, or NULL otherwise.
1103  *
1104  **/
1105 AccessibleUnknown *
1106 Accessible_queryInterface (Accessible *obj,
1107                            const char *interface_name)
1108 {
1109   if (cspi_accessible_is_a (obj, interface_name))
1110   {
1111     /* The original code called cspi_object_add(obj) instead, but gok and
1112      * simple-at don't treat interfaces as references, so I'm confused
1113      * and not going to replicate this bit of code */
1114     return obj;
1115   }
1116   return NULL;
1117 }
1118
1119
1120 /**
1121  * AccessibleRelation_ref:
1122  * @obj: a pointer to the #AccessibleRelation object on which to operate.
1123  *
1124  * Increment the reference count for an #AccessibleRelation object.
1125  *
1126  **/
1127 void
1128 AccessibleRelation_ref (AccessibleRelation *obj)
1129 {
1130   obj->ref_count++;
1131 }
1132
1133 /**
1134  * AccessibleRelation_unref:
1135  * @obj: a pointer to the #AccessibleRelation object on which to operate.
1136  *
1137  * Decrement the reference count for an #AccessibleRelation object.
1138  *
1139  **/
1140 void
1141 AccessibleRelation_unref (AccessibleRelation *obj)
1142 {
1143   obj->ref_count--;
1144   if (obj->ref_count <= 0)
1145   {
1146     g_array_free (obj->targets, TRUE);
1147     g_free (obj);
1148   }
1149 }
1150
1151 static SPIBoolean
1152 cspi_init_relation_type_table (AccessibleRelationType *relation_type_table)
1153 {
1154   int i;
1155   for (i = 0; i < Accessibility_RELATION_LAST_DEFINED; ++i)
1156     {
1157       relation_type_table [i] = SPI_RELATION_NULL;
1158     }
1159   relation_type_table [Accessibility_RELATION_NULL] = SPI_RELATION_NULL;
1160   relation_type_table [Accessibility_RELATION_LABEL_FOR] = SPI_RELATION_LABEL_FOR;
1161   relation_type_table [Accessibility_RELATION_LABELLED_BY] = SPI_RELATION_LABELED_BY;
1162   relation_type_table [Accessibility_RELATION_CONTROLLER_FOR] = SPI_RELATION_CONTROLLER_FOR;
1163   relation_type_table [Accessibility_RELATION_CONTROLLED_BY] = SPI_RELATION_CONTROLLED_BY;
1164   relation_type_table [Accessibility_RELATION_MEMBER_OF] = SPI_RELATION_MEMBER_OF;
1165   relation_type_table [Accessibility_RELATION_TOOLTIP_FOR] = SPI_RELATION_NULL;
1166   relation_type_table [Accessibility_RELATION_NODE_CHILD_OF] = SPI_RELATION_NODE_CHILD_OF;
1167   relation_type_table [Accessibility_RELATION_EXTENDED] = SPI_RELATION_EXTENDED;
1168   relation_type_table [Accessibility_RELATION_FLOWS_TO] = SPI_RELATION_FLOWS_TO;
1169   relation_type_table [Accessibility_RELATION_FLOWS_FROM] = SPI_RELATION_FLOWS_FROM;
1170   relation_type_table [Accessibility_RELATION_SUBWINDOW_OF] = SPI_RELATION_SUBWINDOW_OF;
1171   relation_type_table [Accessibility_RELATION_EMBEDS] = SPI_RELATION_EMBEDS;
1172   relation_type_table [Accessibility_RELATION_EMBEDDED_BY] = SPI_RELATION_EMBEDDED_BY;
1173   relation_type_table [Accessibility_RELATION_POPUP_FOR] = SPI_RELATION_POPUP_FOR;
1174   relation_type_table [Accessibility_RELATION_PARENT_WINDOW_OF] = SPI_RELATION_PARENT_WINDOW_OF;
1175   relation_type_table [Accessibility_RELATION_DESCRIBED_BY] = SPI_RELATION_DESCRIBED_BY;
1176   relation_type_table [Accessibility_RELATION_DESCRIPTION_FOR] = SPI_RELATION_DESCRIPTION_FOR;
1177   return TRUE;
1178 }
1179
1180 static AccessibleRelationType
1181 cspi_relation_type_from_spi_relation_type (Accessibility_RelationType type)
1182 {
1183   /* array is sized according to IDL RelationType because IDL RelationTypes are the index */
1184   static AccessibleRelationType cspi_relation_type_table [Accessibility_RELATION_LAST_DEFINED];
1185   static SPIBoolean is_initialized = FALSE;
1186   AccessibleRelationType cspi_type;
1187   if (!is_initialized)
1188     {
1189       is_initialized = cspi_init_relation_type_table (cspi_relation_type_table);
1190     }
1191   if (type >= 0 && type < Accessibility_RELATION_LAST_DEFINED)
1192     {
1193       cspi_type = cspi_relation_type_table [type];
1194     }
1195   else
1196     {
1197       cspi_type = SPI_RELATION_NULL;
1198     }
1199   return cspi_type;
1200 }
1201 /**
1202  * AccessibleRelation_getRelationType:
1203  * @obj: a pointer to the #AccessibleRelation object to query.
1204  *
1205  * Get the type of relationship represented by an #AccessibleRelation.
1206  *
1207  * Returns: an #AccessibleRelationType indicating the type of relation
1208  *         encapsulated in this #AccessibleRelation object.
1209  *
1210  **/
1211 AccessibleRelationType
1212 AccessibleRelation_getRelationType (AccessibleRelation *obj)
1213 {
1214   cspi_return_val_if_fail (obj, SPI_RELATION_NULL);
1215   return cspi_relation_type_from_spi_relation_type (obj->type);
1216 }
1217
1218 /**
1219  * AccessibleRelation_getNTargets:
1220  * @obj: a pointer to the #AccessibleRelation object to query.
1221  *
1222  * Get the number of objects which this relationship has as its
1223  *       target objects (the subject is the #Accessible from which this
1224  *       #AccessibleRelation originated).
1225  *
1226  * Returns: a short integer indicating how many target objects which the
1227  *       originating #Accessible object has the #AccessibleRelation
1228  *       relationship with.
1229  **/
1230 int
1231 AccessibleRelation_getNTargets (AccessibleRelation *obj)
1232 {
1233   cspi_return_val_if_fail (obj, -1);
1234   return obj->targets->len;
1235 }
1236
1237 /**
1238  * AccessibleRelation_getTarget:
1239  * @obj: a pointer to the #AccessibleRelation object to query.
1240  * @i: a (zero-index) integer indicating which (of possibly several) target is requested.
1241  *
1242  * Get the @i-th target of a specified #AccessibleRelation relationship.
1243  *
1244  * Returns: an #Accessible which is the @i-th object with which the
1245  *      originating #Accessible has relationship specified in the
1246  *      #AccessibleRelation object.
1247  *
1248  **/
1249 Accessible *
1250 AccessibleRelation_getTarget (AccessibleRelation *obj, int i)
1251 {
1252   cspi_return_val_if_fail (obj, NULL);
1253
1254   if (i < 0 || i >= obj->targets->len) return NULL;
1255   return cspi_object_add (
1256                          g_array_index (obj->targets, Accessible *, i));
1257 }
1258
1259 /**
1260  * AccessibleStateSet_ref:
1261  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1262  *
1263  * Increment the reference count for an #AccessibleStateSet object.
1264  *
1265  **/
1266 void
1267 AccessibleStateSet_ref (AccessibleStateSet *obj)
1268 {
1269   spi_state_set_cache_ref (obj);
1270 }
1271
1272 /**
1273  * AccessibleStateSet_unref:
1274  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1275  *
1276  * Decrement the reference count for an #AccessibleStateSet object.
1277  *
1278  **/
1279 void
1280 AccessibleStateSet_unref (AccessibleStateSet *obj)
1281 {
1282   spi_state_set_cache_unref (obj);
1283 }
1284
1285 static Accessibility_StateType
1286 spi_state_to_dbus (AccessibleState state)
1287 {
1288 #define MAP_STATE(a) \
1289   case SPI_STATE_##a: \
1290     return Accessibility_STATE_##a
1291
1292   switch (state)
1293     {
1294       MAP_STATE (INVALID);
1295       MAP_STATE (ACTIVE);
1296       MAP_STATE (ARMED);
1297       MAP_STATE (BUSY);
1298       MAP_STATE (CHECKED);
1299       MAP_STATE (DEFUNCT);
1300       MAP_STATE (EDITABLE);
1301       MAP_STATE (ENABLED);
1302       MAP_STATE (EXPANDABLE);
1303       MAP_STATE (EXPANDED);
1304       MAP_STATE (FOCUSABLE);
1305       MAP_STATE (FOCUSED);
1306       MAP_STATE (HORIZONTAL);
1307       MAP_STATE (ICONIFIED);
1308       MAP_STATE (MODAL);
1309       MAP_STATE (MULTI_LINE);
1310       MAP_STATE (MULTISELECTABLE);
1311       MAP_STATE (OPAQUE);
1312       MAP_STATE (PRESSED);
1313       MAP_STATE (RESIZABLE);
1314       MAP_STATE (SELECTABLE);
1315       MAP_STATE (SELECTED);
1316       MAP_STATE (SENSITIVE);
1317       MAP_STATE (SHOWING);
1318       MAP_STATE (SINGLE_LINE);
1319       MAP_STATE (STALE);
1320       MAP_STATE (TRANSIENT);
1321       MAP_STATE (VERTICAL);
1322       MAP_STATE (VISIBLE);
1323       MAP_STATE (MANAGES_DESCENDANTS);
1324       MAP_STATE (INDETERMINATE);
1325       MAP_STATE (TRUNCATED);
1326       MAP_STATE (REQUIRED);
1327       MAP_STATE (INVALID_ENTRY);
1328       MAP_STATE (SUPPORTS_AUTOCOMPLETION);
1329       MAP_STATE (SELECTABLE_TEXT);
1330       MAP_STATE (IS_DEFAULT);
1331       MAP_STATE (VISITED);
1332     default:
1333       return Accessibility_STATE_INVALID;
1334   }
1335 #undef MAP_STATE
1336 }
1337
1338 /**
1339  * AccessibleStateSet_contains:
1340  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1341  * @state: an #AccessibleState for which the specified #AccessibleStateSet
1342  *       will be queried.
1343  *
1344  * Determine whether a given #AccessibleStateSet includes a given state; that is,
1345  *       whether @state is true for the stateset in question.
1346  *
1347  * Returns: #TRUE if @state is true/included in the given #AccessibleStateSet,
1348  *          otherwise #FALSE.
1349  *
1350  **/
1351 SPIBoolean
1352 AccessibleStateSet_contains (AccessibleStateSet *obj,
1353                              AccessibleState state)
1354 {
1355   return spi_state_set_cache_contains (obj, spi_state_to_dbus (state));
1356 }
1357
1358 /**
1359  * AccessibleStateSet_add:
1360  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1361  * @state: an #AccessibleState to be added to the specified #AccessibleStateSet
1362  *
1363  * Add a particular #AccessibleState to an #AccessibleStateSet (i.e. set the
1364  *       given state to #TRUE in the stateset.
1365  *
1366  **/
1367 void
1368 AccessibleStateSet_add (AccessibleStateSet *obj,
1369                         AccessibleState state)
1370 {
1371   spi_state_set_cache_add (obj, spi_state_to_dbus (state));
1372 }
1373
1374 /**
1375  * AccessibleStateSet_remove:
1376  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1377  * @state: an #AccessibleState to be removed from the specified #AccessibleStateSet
1378  *
1379  * Remove a particular #AccessibleState to an #AccessibleStateSet (i.e. set the
1380  *       given state to #FALSE in the stateset.)
1381  *
1382  **/
1383 void
1384 AccessibleStateSet_remove (AccessibleStateSet *obj,
1385                            AccessibleState state)
1386 {
1387   spi_state_set_cache_remove (obj, spi_state_to_dbus (state));
1388 }
1389
1390 /**
1391  * AccessibleStateSet_equals:
1392  * @obj: a pointer to the first #AccessibleStateSet object on which to operate.
1393  * @obj2: a pointer to the second #AccessibleStateSet object on which to operate.
1394  *
1395  * Determine whether two instances of #AccessibleStateSet are equivalent (i.e.
1396  *         consist of the same #AccessibleStates).  Useful for checking multiple
1397  *         state variables at once; construct the target state then compare against it.
1398  *
1399  * @see AccessibleStateSet_compare().
1400  *
1401  * Returns: #TRUE if the two #AccessibleStateSets are equivalent,
1402  *          otherwise #FALSE.
1403  *
1404  **/
1405 SPIBoolean
1406 AccessibleStateSet_equals (AccessibleStateSet *obj,
1407                            AccessibleStateSet *obj2)
1408 {
1409   SPIBoolean   eq;
1410   AtkStateSet *cmp;
1411
1412   if (obj == obj2)
1413     {
1414       return TRUE;
1415     }
1416
1417   cmp = spi_state_set_cache_xor (obj, obj2);
1418   eq = spi_state_set_cache_is_empty (cmp);
1419   spi_state_set_cache_unref (cmp);
1420
1421   return eq;
1422 }
1423
1424 /**
1425  * AccessibleStateSet_compare:
1426  * @obj: a pointer to the first #AccessibleStateSet object on which to operate.
1427  * @obj2: a pointer to the second #AccessibleStateSet object on which to operate.
1428  *
1429  * Determine the differences between two instances of #AccessibleStateSet.
1430  * Not Yet Implemented.
1431  *.
1432  * @see AccessibleStateSet_equals().
1433  *
1434  * Returns: an #AccessibleStateSet object containing all states contained on one of
1435  *          the two sets but not the other.
1436  *
1437  **/
1438 AccessibleStateSet *
1439 AccessibleStateSet_compare (AccessibleStateSet *obj,
1440                             AccessibleStateSet *obj2)
1441 {
1442   return spi_state_set_cache_xor (obj, obj2);
1443 }
1444
1445 /**
1446  * AccessibleStateSet_isEmpty:
1447  * @obj: a pointer to the #AccessibleStateSet object on which to operate.
1448  *
1449  * Determine whether a given #AccessibleStateSet is the empty set.
1450  *
1451  * Returns: #TRUE if the given #AccessibleStateSet contains no (true) states,
1452  *          otherwise #FALSE.
1453  *
1454  **/
1455 SPIBoolean
1456 AccessibleStateSet_isEmpty (AccessibleStateSet *obj)
1457 {
1458   return spi_state_set_cache_is_empty (obj);
1459 }
1460