Registry queries

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.
Generated by GTK-Doc V1.11