Registry queries
3
AT-SPI-CSPI Library

# Registry queries

## Synopsis

    enum                AccessibleKeySynthType;
    int                 SPI_getDesktopCount                 (void);
    Accessible*         SPI_getDesktop                      (int i);
    int                 SPI_getDesktopList                  (Accessible ***desktop_list);
    void                SPI_freeDesktopList                 (Accessible **desktop_list);

    SPIBoolean          (*AccessibleKeystrokeListenerCB)    (const AccessibleKeystroke *stroke,
                                                             void *user_data);
    typedef             AccessibleKeyEventMask;
    typedef             AccessibleModifierMaskType;
    typedef             AccessibleKeyMaskType;
    typedef             AccessibleKeyEventType;
    enum                AccessibleKeyListenerSyncType;
    typedef             AccessibleKeystroke;
    AccessibleKeySet*   SPI_createAccessibleKeySet          (int len,
                                                             const char *keysyms,
                                                             short *keycodes,
                                                             const char **keystrings);
    void                SPI_freeAccessibleKeySet            (AccessibleKeySet *keyset);
    AccessibleKeystrokeListener* SPI_createAccessibleKeystrokeListener
                                                            (AccessibleKeystrokeListenerCB callback,
                                                             void *user_data);
    SPIBoolean          SPI_registerGlobalEventListener     (AccessibleEventListener *listener,
                                                             const char *eventType);
    SPIBoolean          SPI_deregisterGlobalEventListener   (AccessibleEventListener *listener,
                                                             const char *eventType);
    SPIBoolean          SPI_deregisterGlobalEventListenerAll
                                                            (AccessibleEventListener *listener);
    SPIBoolean          SPI_registerAccessibleKeystrokeListener
                                                            (AccessibleKeystrokeListener *listener,
                                                             AccessibleKeySet *keys,
                                                             AccessibleKeyMaskType modmask,
                                                             AccessibleKeyEventMask eventmask,
                                                             AccessibleKeyListenerSyncType sync_type);
    SPIBoolean          SPI_deregisterAccessibleKeystrokeListener
                                                            (AccessibleKeystrokeListener *listener,
                                                             AccessibleKeyMaskType modmask);
    void                AccessibleKeystrokeListener_unref   (AccessibleKeystrokeListener *listener);
    SPIBoolean          AccessibleKeystrokeListener_removeCallback
                                                            (AccessibleKeystrokeListener *listener,
                                                             AccessibleKeystrokeListenerCB callback);
    SPIBoolean          AccessibleKeystrokeListener_addCallback
                                                            (AccessibleKeystrokeListener *listener,
                                                             AccessibleKeystrokeListenerCB callback,
                                                             void *user_data);
    SPIBoolean          SPI_generateKeyboardEvent           (long int keyval,
                                                             char *keystring,
                                                             AccessibleKeySynthType synth_type);
    SPIBoolean          SPI_generateMouseEvent              (long int x,
                                                             long int y,
                                                             char *name);
                        AccessibleDeviceEvent;
    typedef             AccessibleDeviceEventMask;
    enum                AccessibleDeviceEventType;
    SPIBoolean          (*AccessibleDeviceListenerCB)       (const AccessibleDeviceEvent *stroke,
                                                             void *user_data);
    AccessibleDeviceListener* SPI_createAccessibleDeviceListener
                                                            (AccessibleDeviceListenerCB callback,
                                                             void *user_data);
    SPIBoolean          SPI_registerDeviceEventListener     (AccessibleDeviceListener *listener,
                                                             AccessibleDeviceEventMask eventmask,
                                                             void *filter);
    SPIBoolean          SPI_deregisterDeviceEventListener   (AccessibleDeviceListener *listener,
                                                             void *filter);
    SPIBoolean          AccessibleDeviceListener_addCallback
                                                            (AccessibleDeviceListener *listener,
                                                             AccessibleDeviceListenerCB callback,
                                                             void *user_data);
    SPIBoolean          AccessibleDeviceListener_removeCallback
                                                            (AccessibleDeviceListener *listener,
                                                             AccessibleDeviceListenerCB callback);
    void                AccessibleDeviceListener_unref      (AccessibleDeviceListener *listener);

## Description

## Details

### enum AccessibleKeySynthType

    typedef enum {
      SPI_KEY_PRESS,
      SPI_KEY_RELEASE,
      SPI_KEY_PRESSRELEASE,
      SPI_KEY_SYM,
      SPI_KEY_STRING
    } AccessibleKeySynthType;

Specifies the type of a generated event.

`SPI_KEY_PRESS`

  Generates a keypress event (requires a subsequent SPI_KEY_RELEASE event)

`SPI_KEY_RELEASE`

  Generates a key-release event

`SPI_KEY_PRESSRELEASE`

  Generates a key press/release event pair.

`SPI_KEY_SYM`

  Injects a "keysym" event into the stream, as if a press/release pair occurred; allows the user to specify the key via its symbolic name, as opposed to simulating a hardware press of a specific key.

`SPI_KEY_STRING`

  Injects one or more keysym events into the keyboard buffer, or directly inserts a string value into the currently focussed text widget, if the widgets supports this. SPI_KEY_STRING synthesis provides a shortcut for text substring insertion, and also allows the insertion of text which is not currently available via the current keyboard's keymap.

### SPI_getDesktopCount ()

    int                 SPI_getDesktopCount                 (void);

Get the number of virtual desktops. NOTE: currently multiple virtual desktops are not implemented, this function always returns '1'.

Returns :

  an integer indicating the number of active virtual desktops.

### SPI_getDesktop ()

    Accessible*         SPI_getDesktop                      (int i);

Get the virtual desktop indicated by index `i`. NOTE: currently multiple virtual desktops are not implemented, this function always returns '1'.

`i` :

  an integer indicating which of the accessible desktops is to be returned.

Returns :

  a pointer to the 'i-th' virtual desktop's Accessible representation.

### SPI_getDesktopList ()

    int                 SPI_getDesktopList                  (Accessible ***desktop_list);

Get the list of virtual desktops. On return, `list` will point to a newly-created, NULL terminated array of virtual desktop pointers. It is the responsibility of the caller to free this array when it is no longer needed.

Not Yet Implemented : this implementation always returns a single Accessible desktop.

`desktop_list` :

  a pointer to an array of Accessible references.

Returns :

  an integer indicating how many virtual desktops have been placed in the list pointed to by parameter `list`.

### SPI_freeDesktopList ()

    void                SPI_freeDesktopList                 (Accessible **desktop_list);

This routine frees the memory associated with the list.

`desktop_list` :

  a pointer to an array of Accessible objects as returned from `SPI_getDesktopList`

### AccessibleKeystrokeListenerCB ()

    SPIBoolean          (*AccessibleKeystrokeListenerCB)    (const AccessibleKeystroke *stroke,
                                                             void *user_data);

A function prototype for a callback function called when a key event notification takes place.

This is a function which is specified when creating a KeystrokeListener. It is called when an event being listened for occurs. If it returns TRUE, this indicates that the event should be consumed rather than passed through; only callbacks whose listeners are registered with the SPI_KEYLISTENER_ALL_WINDOWS or SPI_KEYLISTENER_CANCONSUME flags can be consumed.

`stroke` :

  the AccessibleKeystroke event for which notification is taking place.

`user_data` :

  data passed to the callback each time it is notified, according to the data which was passed in when the listener/callback was registered.

Returns :

  `TRUE` if the client wishes to consume the event and prevent its dispatch to other listeners or the currently focussed application, if the relevant callback was registered with the SPI_KEYLISTENER_CANCONSUME flag.

### AccessibleKeyEventMask

    typedef unsigned long AccessibleKeyEventMask;

AccessibleKeyEventMask is a set of types of key events. It is used in SPI_registerAccessibleKeystroketListener to specify the events to be listener for.

### AccessibleModifierMaskType

    typedef unsigned long AccessibleModifierMaskType;

AccessibleModifierMaskType is a synonym for AccessibleKeymaskType. The defined values for AccessibleModifierMaskType can be found in libspi/keymasks.h.

### AccessibleKeyMaskType

    typedef AccessibleModifierMaskType AccessibleKeyMaskType;

AccessibleKeyMaskType is a mask which is a set of key event modifiers which is specified in SPI_registerAccessibleKeystrokeListener.

### AccessibleKeyEventType

    typedef AccessibleDeviceEventType AccessibleKeyEventType;

This is a synonym for AccessibleDeviceEventType

### enum AccessibleKeyListenerSyncType

    typedef enum {
      SPI_KEYLISTENER_NOSYNC = 0,
      SPI_KEYLISTENER_SYNCHRONOUS = 1,
      SPI_KEYLISTENER_CANCONSUME = 2,
      SPI_KEYLISTENER_ALL_WINDOWS = 4
    } AccessibleKeyListenerSyncType;

Specified the tyupe of a key listener event. Certain of the values above can and should be bitwise-'OR'ed together, observing the compatibility limitations specified in the description of each value. For instance, SPI_KEYLISTENER_ALL_WINDOWS | SPI_KEYLISTENER_CANCONSUME is a commonly used combination which gives the AT complete control over the delivery of matching events. However, such filters should be used sparingly as they may have a negative impact on system performance.

`SPI_KEYLISTENER_NOSYNC`

  Events may be delivered asynchronously, which means in some cases they may already have been delivered to the application before the AT client receives the notification.

`SPI_KEYLISTENER_SYNCHRONOUS`

  Events are delivered synchronously, before the currently focussed application sees them.

`SPI_KEYLISTENER_CANCONSUME`

  Events may be consumed by the AT client. Presumes and requires SPI_KEYLISTENER_SYNCHRONOUS, incompatible with SPI_KEYLISTENER_NOSYNC.

`SPI_KEYLISTENER_ALL_WINDOWS`

  Events are received not from the application toolkit layer, but from the device driver or windowing system subsystem; such notifications are 'global' in the sense that they are not broken or defeated by applications that participate poorly in the accessibility APIs, or not at all; however because of the intrusive nature of such snooping, it can have side-effects on certain older platforms. If unconditional event notifications, even when inaccessible or "broken" applications have focus, are not required, it may be best to avoid this enum value/flag.

### AccessibleKeystroke

    typedef AccessibleDeviceEvent AccessibleKeystroke;

This is a synonym for AccessibleDeviceEvent.

### SPI_createAccessibleKeySet ()

    AccessibleKeySet*   SPI_createAccessibleKeySet          (int len,
                                                             const char *keysyms,
                                                             short *keycodes,
                                                             const char **keystrings);

Create a new AccessibleKeySet of a specified length. A KeySet is used typically to match key event values, and a matches are made using the following criteria: a match exists with a key event if all non-null i-th members of the keyset match the key event. If both keystring and keysym values are NULL, a keycode value match is forced, thus the match for keysym=0, keycode=0, keystring=NULL is keycode 0.

`len` :

  the number of key values in the key set.

`keysyms` :

  a UTF-8 string containing symbolic key values to be matched, or NULL if matching is performed against other key values instead.

`keycodes` :

  an array of unsigned short values which are the hardware keycodes to be matched, or NULL if the keyset is specified solely by keysyms and/or keystrings.

`keystrings` :

  an array of null-terminated character strings which specify key name values to match, or NULL if the keyset is specified solely by keycodes and/or keysyms.

Returns :

  a pointer to a newly-created AccessibleKeySet.

### SPI_freeAccessibleKeySet ()

    void                SPI_freeAccessibleKeySet            (AccessibleKeySet *keyset);

Release the memory used by an AccessibleKeySet.

`keyset` :

  An AccessibleKeyset to free.

### SPI_createAccessibleKeystrokeListener ()

    AccessibleKeystrokeListener* SPI_createAccessibleKeystrokeListener
                                                            (AccessibleKeystrokeListenerCB callback,
                                                             void *user_data);

Create a new AccessibleKeystrokeListener with a specified callback function.

`callback` :

  an AccessibleKeystrokeListenerCB callback function, or NULL.

`user_data` :

  a pointer to data which will be passed to the callback when invoked.

Returns :

  a pointer to a newly-created AccessibleKeystrokeListener.

### SPI_registerGlobalEventListener ()

    SPIBoolean          SPI_registerGlobalEventListener     (AccessibleEventListener *listener,
                                                             const char *eventType);

Legal object event types:

(property change events)

object:property-change object:property-change:accessible-name object:property-change:accessible-description object:property-change:accessible-parent object:property-change:accessible-value object:property-change:accessible-role object:property-change:accessible-table-caption object:property-change:accessible-table-column-description object:property-change:accessible-table-column-header object:property-change:accessible-table-row-description object:property-change:accessible-table-row-header object:property-change:accessible-table-summary

(other object events)

object:state-changed object:children-changed object:visible-data-changed object:selection-changed object:text-selection-changed object:text-changed object:text-caret-moved object:row-inserted object:row-reordered object:row-deleted object:column-inserted object:column-reordered object:column-deleted object:model-changed object:active-descendant-changed

(window events)

window:minimize window:maximize window:restore window:close window:create window:reparent window:desktop-create window:desktop-destroy window:activate window:deactivate window:raise window:lower window:move window:resize window:shade window:unshade window:restyle

(other events)

focus: mouse:abs mouse:rel mouse:b1p mouse:b1r mouse:b2p mouse:b2r mouse:b3p mouse:b3r

NOTE: this string may be UTF-8, but should not contain byte value 56 (ascii ':'), except as a delimiter, since non-UTF-8 string delimiting functions are used internally. In general, listening to toolkit-specific events is not recommended.

Add an in-process callback function to an existing AccessibleEventListener.

`listener` :

  the AccessibleEventListener to be registered against an event type.

`eventType` :

  a character string indicating the type of events for which notification is requested. Format is EventClass:major_type:minor_type:detail where all subfields other than EventClass are optional. EventClasses include "object", "window", "mouse", and toolkit events (e.g. "Gtk", "AWT"). Examples: "focus:", "Gtk:GtkWidget:button-press-event".

Returns :

  TRUE if successful, otherwise FALSE.

### SPI_deregisterGlobalEventListener ()

    SPIBoolean          SPI_deregisterGlobalEventListener   (AccessibleEventListener *listener,
                                                             const char *eventType);

deregisters an AccessibleEventListener from the registry, for a specific event type.

`listener` :

  the AccessibleEventListener registered against an event type.

`eventType` :

  a string specifying the event type for which this listener is to be deregistered.

Returns :

  TRUE if successful, otherwise FALSE.

### SPI_deregisterGlobalEventListenerAll ()

    SPIBoolean          SPI_deregisterGlobalEventListenerAll
                                                            (AccessibleEventListener *listener);

deregisters an AccessibleEventListener from the registry, for all event types it may be listening to. Use AccessibleEventListener_unref to release the listener reference.

`listener` :

  the AccessibleEventListener to be registered against an event type.

Returns :

  TRUE if successful, otherwise FALSE.

### SPI_registerAccessibleKeystrokeListener ()

    SPIBoolean          SPI_registerAccessibleKeystrokeListener
                                                            (AccessibleKeystrokeListener *listener,
                                                             AccessibleKeySet *keys,
                                                             AccessibleKeyMaskType modmask,
                                                             AccessibleKeyEventMask eventmask,
                                                             AccessibleKeyListenerSyncType sync_type);

Register a listener for keystroke events, either pre-emptively for all windows (SPI_KEYLISTENER_ALL_WINDOWS), non-preemptively (SPI_KEYLISTENER_NOSYNC), or pre-emptively at the toolkit level (SPI_KEYLISTENER_CANCONSUME). If ALL_WINDOWS or CANCONSUME are used, the event is consumed upon receipt if one of `listener`'s callbacks returns TRUE. ( Other sync_type values may be available in the future )

`listener` :

  a pointer to the AccessibleKeystrokeListener for which keystroke events are requested.

`keys` :

  a pointer to the AccessibleKeySet indicating which keystroke events are requested, or SPI_KEYSET_ALL_KEYS to indicate that all keycodes and keyvals for the specified modifier set are to be included.

`modmask` :

  an AccessibleKeyMaskType mask indicating which key event modifiers must be set in combination with `keys`, events will only be reported for key events for which all modifiers in `modmask` are set. If you wish to listen for events with multiple modifier combinations you must call `registerAccessibleKeystrokeListener()` once for each combination.

`eventmask` :

  an AccessibleKeyMaskType mask indicating which types of key events are requested (SPI_KEY_PRESSED, etc.).

`sync_type` :

  a AccessibleKeyListenerSyncType parameter indicating the behavior of the notification/listener transaction.

Returns :

  TRUE if successful, otherwise FALSE.

### SPI_deregisterAccessibleKeystrokeListener ()

    SPIBoolean          SPI_deregisterAccessibleKeystrokeListener
                                                            (AccessibleKeystrokeListener *listener,
                                                             AccessibleKeyMaskType modmask);

Removes a keystroke event listener from the registry's listener queue, ceasing notification of events with modifiers matching `modmask`.

`listener` :

  a pointer to the AccessibleKeystrokeListener for which keystroke events are requested.

`modmask` :

  the key modifier mask for which this listener is to be 'deregistered' (of type AccessibleeyMaskType).

Returns :

  TRUE if successful, otherwise FALSE.

### AccessibleKeystrokeListener_unref ()

    void                AccessibleKeystrokeListener_unref   (AccessibleKeystrokeListener *listener);

Decrements an AccessibleKeystrokeListener's reference count.

`listener` :

  a pointer to the AccessibleKeystrokeListener being operated on.

### AccessibleKeystrokeListener_removeCallback ()

    SPIBoolean          AccessibleKeystrokeListener_removeCallback
                                                            (AccessibleKeystrokeListener *listener,
                                                             AccessibleKeystrokeListenerCB callback);

Remove an in-process callback function from an existing AccessibleKeystrokeListener.

`listener` :

  the AccessibleKeystrokeListener instance to modify.

`callback` :

  an AccessibleKeystrokeListenerCB function pointer.

Returns :

  TRUE if successful, otherwise FALSE.

### AccessibleKeystrokeListener_addCallback ()

    SPIBoolean          AccessibleKeystrokeListener_addCallback
                                                            (AccessibleKeystrokeListener *listener,
                                                             AccessibleKeystrokeListenerCB callback,
                                                             void *user_data);

Add an in-process callback function to an existing AccessibleKeystrokeListener.

`listener` :

  the AccessibleKeystrokeListener instance to modify.

`callback` :

  an AccessibleKeystrokeListenerCB function pointer.

`user_data` :

  a pointer to data which will be passed to the callback when invoked.

Returns :

  TRUE if successful, otherwise FALSE.

### SPI_generateKeyboardEvent ()

    SPIBoolean          SPI_generateKeyboardEvent           (long int keyval,
                                                             char *keystring,
                                                             AccessibleKeySynthType synth_type);

Synthesize a keyboard event (as if a hardware keyboard event occurred in the current UI context).

`keyval` :

  a long integer indicating the keycode or keysym of the key event being synthesized.

`keystring` :

  an (optional) UTF-8 string which, if `keyval` is NULL, indicates a 'composed' keyboard input string which is being synthesized; this type of keyboard event synthesis does not emulate hardware keypresses but injects the string as though a composing input method (such as XIM) were used.

`synth_type` :

  a AccessibleKeySynthType flag indicating whether `keyval` is to be interpreted as a keysym rather than a keycode (CSPI_KEYSYM), or whether to synthesize SPI_KEY_PRESS, SPI_KEY_RELEASE, or both (SPI_KEY_PRESSRELEASE).

Returns :

  TRUE if successful, otherwise FALSE.

### SPI_generateMouseEvent ()

    SPIBoolean          SPI_generateMouseEvent              (long int x,
                                                             long int y,
                                                             char *name);

Synthesize a mouse event at a specific screen coordinate. Most AT clients should use the AccessibleAction interface when tempted to generate mouse events, rather than this method. Event names: b1p = button 1 press; b2r = button 2 release; b3c = button 3 click; b2d = button 2 double-click; abs = absolute motion; rel = relative motion.

`x` :

  a long indicating the screen x coordinate of the mouse event.

`y` :

  a long indicating the screen y coordinate of the mouse event.

`name` :

  a string indicating which mouse event to be synthesized (e.g. "b1p", "b1c", "b2r", "rel", "abs").

Returns :

  TRUE if successful, otherwise FALSE.

### AccessibleDeviceEvent

    typedef struct {
      long                   keyID;
      short                  keycode;
      char *                 keystring;
      long                   timestamp;
      AccessibleDeviceEventType type;
      unsigned short         modifiers;
      SPIBoolean             is_text;
    } AccessibleDeviceEvent;

A structure encapsulating information relevant to a device event notification.

AccessibleDeviceEvent is a struct which encapsulates a device event.

char *keystring;

  A symbolic name for the key or switch, or, if is_text is true, a string approximating the inserted text characters which would result from this event, if a text entry field has keyboard focus.

AccessibleDeviceEventType type;

  The AccessibleDeviceEventType identifying the specific type of event.

unsigned short modifiers;

SPIBoolean is_text;

  A boolean value indicating whether the event represents 'printable' text (i.e. whether it changes the current insertion buffer of a focussed text entry component or not). Whitespace is considered "printable" in this context, since it typically inserts characters into the buffer.

### AccessibleDeviceEventMask

    typedef unsigned long AccessibleDeviceEventMask;

AccessibleDeviceEventMask is a set of types of key events. It is used in SPI_registerDeviceEventListener to specify the events to be listener for.

### enum AccessibleDeviceEventType

    typedef enum {
      SPI_KEY_PRESSED  = 1<<0,
      SPI_KEY_RELEASED = 1<<1,
      SPI_BUTTON_PRESSED = 1<<2,
      SPI_BUTTON_RELEASED = 1<<3
    } AccessibleDeviceEventType;

The type of an AccessibleDeviceEvent.

`SPI_KEY_PRESSED`

  A device key has been pressed.

`SPI_KEY_RELEASED`

  A device key has been released.

`SPI_BUTTON_PRESSED`

  A device button or switch (other than a keyboard key) has been pressed.

`SPI_BUTTON_RELEASED`

  A device button or switch has been released.

### AccessibleDeviceListenerCB ()

    SPIBoolean          (*AccessibleDeviceListenerCB)       (const AccessibleDeviceEvent *stroke,
                                                             void *user_data);

A callback function prototype via which clients receive device event notifications.

This is a function which is specified when creating a DeviceListener. It is called when an event being listened for occurs.

`stroke` :

  The AccessibleDeviceEvent for which notification is being received.

`user_data` :

  Data which is passed to the client each time this callback is notified.

Returns :

  `TRUE` if the client wishes to consume/preempt the event, preventing it from being relayed to the currently focussed application, `FALSE` if the event delivery should proceed as normal.

### SPI_createAccessibleDeviceListener ()

    AccessibleDeviceListener* SPI_createAccessibleDeviceListener
                                                            (AccessibleDeviceListenerCB callback,
                                                             void *user_data);

Create a new AccessibleDeviceListener with a specified callback function.

`callback` :

  an AccessibleDeviceListenerCB callback function, or NULL.

`user_data` :

  a pointer to data which will be passed to the callback when invoked.

Returns :

  a pointer to a newly-created AccessibleDeviceListener.

### SPI_registerDeviceEventListener ()

    SPIBoolean          SPI_registerDeviceEventListener     (AccessibleDeviceListener *listener,
                                                             AccessibleDeviceEventMask eventmask,
                                                             void *filter);

Register a listener for device events, for instance button events.

`listener` :

  a pointer to the AccessibleDeviceListener which requests the events.

`eventmask` :

  an AccessibleDeviceEventMask mask indicating which types of key events are requested (SPI_KEY_PRESSED, etc.).

`filter` :

  Unused parameter.

Returns :

  TRUE if successful, otherwise FALSE.

### SPI_deregisterDeviceEventListener ()

    SPIBoolean          SPI_deregisterDeviceEventListener   (AccessibleDeviceListener *listener,
                                                             void *filter);

Removes a device event listener from the registry's listener queue, ceasing notification of events of the specified type.

`listener` :

  a pointer to the AccessibleDeviceListener for which device events are requested.

`filter` :

  Unused parameter.

Returns :

  TRUE if successful, otherwise FALSE.

### AccessibleDeviceListener_addCallback ()

    SPIBoolean          AccessibleDeviceListener_addCallback
                                                            (AccessibleDeviceListener *listener,
                                                             AccessibleDeviceListenerCB callback,
                                                             void *user_data);

Add an in-process callback function to an existing AccessibleDeviceListener.

`listener` :

  the AccessibleDeviceListener instance to modify.

`callback` :

  an AccessibleDeviceListenerCB function pointer.

`user_data` :

  a pointer to data which will be passed to the callback when invoked.

Returns :

  TRUE if successful, otherwise FALSE.

### AccessibleDeviceListener_removeCallback ()

    SPIBoolean          AccessibleDeviceListener_removeCallback
                                                            (AccessibleDeviceListener *listener,
                                                             AccessibleDeviceListenerCB callback);

Remove an in-process callback function from an existing AccessibleDeviceListener.

`listener` :

  the AccessibleDeviceListener instance to modify.

`callback` :

  an AccessibleDeviceListenerCB function pointer.

Returns :

  TRUE if successful, otherwise FALSE.

### AccessibleDeviceListener_unref ()

    void                AccessibleDeviceListener_unref      (AccessibleDeviceListener *listener);

Decrements an AccessibleDeviceListener's reference count.

`listener` :

  a pointer to the AccessibleDeviceListener being operated on.