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