State and StateSets

Name

State and StateSets -- 

Synopsis



enum        AccessibleState;
int         AccessibleStateSet_ref          (AccessibleStateSet *obj);
int         AccessibleStateSet_unref        (AccessibleStateSet *obj);
void        AccessibleStateSet_add          (AccessibleStateSet *obj,
                                             AccessibleState state);
void        AccessibleStateSet_compare      (AccessibleStateSet *obj,
                                             AccessibleStateSet *obj2,
                                             AccessibleStateSet **differenceSet);
boolean     AccessibleStateSet_contains     (AccessibleStateSet *obj,
                                             AccessibleState state);
boolean     AccessibleStateSet_equals       (AccessibleStateSet *obj,
                                             AccessibleStateSet *obj2);
boolean     AccessibleStateSet_isEmpty      (AccessibleStateSet *obj);
void        AccessibleStateSet_remove       (AccessibleStateSet *obj,
                                             AccessibleState state);

Description

Details

enum AccessibleState

typedef enum
{
  SPI_STATE_INVALID,
  /* Indicates a window is currently the active window */
  SPI_STATE_ACTIVE,
  /* Indicates that the object is armed */
  SPI_STATE_ARMED,
  /* Indicates the current object is busy */
  SPI_STATE_BUSY,
  /* Indicates this object is currently checked */
  SPI_STATE_CHECKED,
  /* Indicates this object is collapsed */
  SPI_STATE_COLLAPSED,
  /* Indicates the user can change the contents of this object */
  SPI_STATE_EDITABLE,
  /* Indicates this object allows progressive disclosure of its children */
  SPI_STATE_EXPANDABLE,
  /* Indicates this object its expanded */
  SPI_STATE_EXPANDED,
  /*
   * Indicates this object can accept keyboard focus, which means all
   * events resulting from typing on the keyboard will normally be passed
   * to it when it has focus
   */
  SPI_STATE_FOCUSABLE,
  /* Indicates this object currently has the keyboard focus */
  SPI_STATE_FOCUSED,
  /* Indicates the orientation of thsi object is horizontal */
  SPI_STATE_HORIZONTAL,
  /* Indicates this object is minimized and is represented only by an icon */
  SPI_STATE_ICONIFIED,
  /*
   * Indicates something must be done with this object before the user can
   * interact with an object in a different window.
   */
  SPI_STATE_MODAL,
  /* Indicates this (text) object can contain multiple lines of text */
  SPI_STATE_MULTI_LINE,
  /*
   * Indicates this object allows more than one of its children to be
   * selected at the same time
   */
  SPI_STATE_MULTISELECSPI_TABLE,
  /* Indicates this object paints every pixel within its rectangular region. */
  SPI_STATE_OPAQUE,
  /* Indicates this object is currently pressed */
  SPI_STATE_PRESSED,
  /* Indicates the size of this object is not fixed */
  SPI_STATE_RESIZABLE,
  /*
   * Indicates this object is the child of an object that allows its
   * children to be selected and that this child is one of those children
   * that can be selected.
   */
  SPI_STATE_SELECSPI_TABLE,
  /*
   * Indicates this object is the child of an object that allows its
   * children to be selected and that this child is one of those children
   * that has been selected.
   */
  SPI_STATE_SELECTED,
  /* Indicates this object is sensitive */
  SPI_STATE_SENSITIVE,
  /*
   * Indicates this object, the object's parent, the object's parent's
   * parent, and so on, are all visible
   */
  SPI_STATE_SHOWING,
  /* Indicates this (text) object can contain only a single line of text */
  SPI_STATE_SINGLE_LINE,
  /* Indicates this object is transient */
  SPI_STATE_TRANSIENT,
  /* Indicates the orientation of this object is vertical */
  SPI_STATE_VERTICAL,
  /* Indicates this object is visible */
  SPI_STATE_VISIBLE,
  SPI_STATE_LAST_DEFINED
} AccessibleState;


AccessibleStateSet_ref ()

int         AccessibleStateSet_ref          (AccessibleStateSet *obj);

Increment the reference count for an AccessibleStateSet object.

obj : a pointer to the AccessibleStateSet object on which to operate.
Returns : (no return code implemented yet).


AccessibleStateSet_unref ()

int         AccessibleStateSet_unref        (AccessibleStateSet *obj);

Decrement the reference count for an AccessibleStateSet object.

obj : a pointer to the AccessibleStateSet object on which to operate.
Returns : (no return code implemented yet).


AccessibleStateSet_add ()

void        AccessibleStateSet_add          (AccessibleStateSet *obj,
                                             AccessibleState state);

Add a particular AccessibleState to an AccessibleStateSet (i.e. set the given state to TRUE in the stateset.

obj : a pointer to the AccessibleStateSet object on which to operate.
state : an AccessibleState to be added to the specified AccessibleStateSet


AccessibleStateSet_compare ()

void        AccessibleStateSet_compare      (AccessibleStateSet *obj,
                                             AccessibleStateSet *obj2,
                                             AccessibleStateSet **differenceSet);

Determine the differences between two instances of AccessibleStateSet. . see AccessibleStateSet_equals().

obj : a pointer to the first AccessibleStateSet object on which to operate.
obj2 : a pointer to the second AccessibleStateSet object on which to operate.
differenceSet : a pointer to an array of AccessibleStates, which is set when the fuction returns to point to an array of states representing the states which the two state sets do not have in common.


AccessibleStateSet_contains ()

boolean     AccessibleStateSet_contains     (AccessibleStateSet *obj,
                                             AccessibleState state);

Determine whether a given AccessibleStateSet includes a given state; that is, whether state is true for the stateset in question.

obj : a pointer to the AccessibleStateSet object on which to operate.
state : an AccessibleState for which the specified AccessibleStateSet will be queried.
Returns : TRUE if state is true/included in the given AccessibleStateSet, otherwise FALSE.


AccessibleStateSet_equals ()

boolean     AccessibleStateSet_equals       (AccessibleStateSet *obj,
                                             AccessibleStateSet *obj2);

Determine whether two instances of AccessibleStateSet are equivalent (i.e. consist of the same AccessibleStates). Useful for checking multiple state variables at once; construct the target state then compare against it.

see AccessibleStateSet_compare().

obj : a pointer to the first AccessibleStateSet object on which to operate.
obj2 : a pointer to the second AccessibleStateSet object on which to operate.
Returns : TRUE if the two AccessibleStateSets are equivalent, otherwise FALSE.


AccessibleStateSet_isEmpty ()

boolean     AccessibleStateSet_isEmpty      (AccessibleStateSet *obj);

Determine whether a given AccessibleStateSet is the empty set.

obj : a pointer to the AccessibleStateSet object on which to operate.
Returns : TRUE if the given AccessibleStateSet contains no (true) states, otherwise FALSE.


AccessibleStateSet_remove ()

void        AccessibleStateSet_remove       (AccessibleStateSet *obj,
                                             AccessibleState state);

Remove a particular AccessibleState to an AccessibleStateSet (i.e. set the given state to FALSE in the stateset.)

obj : a pointer to the AccessibleStateSet object on which to operate.
state : an AccessibleState to be removed from the specified AccessibleStateSet