## State and StateSets

State and StateSets —

##

# Synopsis

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

## Description

## Details

### enum AccessibleState

    typedef enum
    {
      SPI_STATE_INVALID,
      SPI_STATE_ACTIVE,
      SPI_STATE_ARMED,
      SPI_STATE_BUSY,
      SPI_STATE_CHECKED,
      SPI_STATE_COLLAPSED,
      SPI_STATE_DEFUNCT,
      SPI_STATE_EDITABLE,
      SPI_STATE_ENABLED,
      SPI_STATE_EXPANDABLE,
      SPI_STATE_EXPANDED,
      SPI_STATE_FOCUSABLE,
      SPI_STATE_FOCUSED,
      SPI_STATE_HORIZONTAL,
      SPI_STATE_ICONIFIED,
      SPI_STATE_MODAL,
      SPI_STATE_MULTI_LINE,
      SPI_STATE_MULTISELECTABLE,
      SPI_STATE_OPAQUE,
      SPI_STATE_PRESSED,
      SPI_STATE_RESIZABLE,
      SPI_STATE_SELECTABLE,
      SPI_STATE_SELECTED,
      SPI_STATE_SENSITIVE,
      SPI_STATE_SHOWING,
      SPI_STATE_SINGLE_LINE,
      SPI_STATE_STALE,
      SPI_STATE_TRANSIENT,
      SPI_STATE_VERTICAL,
      SPI_STATE_VISIBLE,
      SPI_STATE_MANAGES_DESCENDANTS,
      SPI_STATE_INDETERMINATE,
      SPI_STATE_LAST_DEFINED
    } AccessibleState;

The possibles states of an object.

`SPI_STATE_INVALID` | Indicates an invalid state
`SPI_STATE_ACTIVE` | Indicates a window is currently the active window
`SPI_STATE_ARMED` | Indicates that the object is armed
`SPI_STATE_BUSY` | Indicates the current object is busy
`SPI_STATE_CHECKED` | Indicates this object is currently checked
`SPI_STATE_COLLAPSED` | Indicates this object is collapsed
`SPI_STATE_DEFUNCT` | Indicates the user interface object corresponding to this object no longer exists
`SPI_STATE_EDITABLE` | Indicates the user can change the contents of this object
`SPI_STATE_ENABLED` | Indicates that this object is enabled
`SPI_STATE_EXPANDABLE` | Indicates this object allows progressive disclosure of its children
`SPI_STATE_EXPANDED` | Indicates this object its expanded
`SPI_STATE_FOCUSABLE` | 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_FOCUSED` | Indicates this object currently has the keyboard focus
`SPI_STATE_HORIZONTAL` | Indicates the orientation of thsi object is horizontal
`SPI_STATE_ICONIFIED` | Indicates this object is minimized and is represented only by an icon
`SPI_STATE_MODAL` | Indicates something must be done with this object before the user can interact with an object in a different window
`SPI_STATE_MULTI_LINE` | Indicates this (text) object can contain multiple lines of text
`SPI_STATE_MULTISELECTABLE` | Indicates this object allows more than one of its children to be selected at the same time
`SPI_STATE_OPAQUE` | Indicates this object paints every pixel within its rectangular region
`SPI_STATE_PRESSED` | Indicates this object is currently pressed
`SPI_STATE_RESIZABLE` | Indicates the size of this object is not fixed
`SPI_STATE_SELECTABLE` | 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_SELECTED` | 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_SENSITIVE` | Indicates this object is sensitive
`SPI_STATE_SHOWING` | Indicates this object, the object's parent, the object's parent's parent, and so on, are all visible
`SPI_STATE_SINGLE_LINE` | Indicates this (text) object can contain only a single line of text
`SPI_STATE_STALE` | Indicates that the index associated with this object has changed since the user accessed the object
`SPI_STATE_TRANSIENT` | Indicates this object is transient
`SPI_STATE_VERTICAL` | Indicates the orientation of this object is vertical
`SPI_STATE_VISIBLE` | Indicates this object is visible
`SPI_STATE_MANAGES_DESCENDANTS` | Indicates that "active-descendant-changed" event is sent when children become 'active' (i.e. are selected or navigated to onscreen). Used to prevent need to enumerate all children in very large containers, like tables.
`SPI_STATE_INDETERMINATE` | Indicates that a check box is in a state other than checked or not checked.
`SPI_STATE_LAST_DEFINED` | Not a valid state, used for finding end of enumeration

### struct AccessibleStateSet

    struct AccessibleStateSet {

    	guint   ref_count;
    	GArray *states;
    };

An AccessibleStateSet determines a component's state set. It is composed of a set of AccessibleState values.

### AccessibleStateSet_ref ()

    void        AccessibleStateSet_ref          (AccessibleStateSet *obj);

Increment the reference count for an AccessibleStateSet object.

`obj` : | a pointer to the AccessibleStateSet object on which to operate.

### AccessibleStateSet_unref ()

    void        AccessibleStateSet_unref        (AccessibleStateSet *obj);

Decrement the reference count for an AccessibleStateSet object.

`obj` : | a pointer to the AccessibleStateSet object on which to operate.

### 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 ()

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

Determine the differences between two instances of AccessibleStateSet. Not Yet Implemented. . `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.
Returns : | an AccessibleStateSet object containing all states contained on one of the two sets but not the other.

### AccessibleStateSet_contains ()

    SPIBoolean  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 ()

    SPIBoolean  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 ()

    SPIBoolean  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