X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi.h;h=9d258285de3cafd013c835c9af1d8d6b14a1399e;hb=b6a9e880c09f13a391a2a23b0dd685a518fe61a1;hp=cec91f829674d372e080725cb7a2a2f0cf322ca2;hpb=408978dd34f3338e49b6ace5f60b7606579ce7a9;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi.h b/cspi/spi.h index cec91f8..9d25828 100644 --- a/cspi/spi.h +++ b/cspi/spi.h @@ -1,25 +1,94 @@ +/* + * AT-SPI - Assistive Technology Service Provider Interface + * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap) + * + * Copyright 2001, 2002 Sun Microsystems Inc., + * Copyright 2001, 2002 Ximian, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ #ifndef _SPI_H #define _SPI_H -/* Implementation private definitions */ -#include "spi-impl.h" - +#include +#include +#include /* - * Definitions for SPI_ACCESSIBLE_STATE , SPI_ACCESSIBLE_ROLE, SpiAccessibleEvent, - * and event listeners. + * Definitions for AccessibleRole, AccessibleState, + * and event listeners. */ +#include +#include +#include -#include "spi-roletypes.h" -#include "spi-statetypes.h" -#include "spi-listener.h" /* + * Auxiliary typedefs and mask definitions + */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + *AccessibleCollectionMatchType: * - * Enumerated type for text boundary types + *@SPI_COLLECTION_MATCH_INVALID + *@SPI_COLLECTION_MATCH_ALL TRUE if all of the criteria are met + *@SPI_COLLECTION_MATCH_ANY TRUE if any of the criteria are met + *@SPI_COLLECTION_MATCH_NONE TRUE if none of the criteria are met + *@SPI_COLLECTION_MATCH_EMPTY Same as MATCH_ALL if the criteria is non-empty; + * for empty criteria this rule requires returned value to also have empty set. + *@SPI_COLLECTION_MATCH_LAST_DEFINED * - */ + **/ +typedef enum +{ + SPI_COLLECTION_MATCH_INVALID, + SPI_COLLECTION_MATCH_ALL, + SPI_COLLECTION_MATCH_ANY, + SPI_COLLECTION_MATCH_NONE, + SPI_COLLECTION_MATCH_EMPTY, + SPI_COLLECTION_MATCH_LAST_DEFINED +}AccessibleCollectionMatchType; + +/** + *AccessibleTextBoundaryType: + *@SPI_TEXT_BOUNDARY_CHAR: Delimiter is the current character's bounds. + *@SPI_TEXT_BOUNDARY_CURSOR_POS: Delimiter is the current text caret position. + *@SPI_TEXT_BOUNDARY_WORD_START: Bounds run from the first character of a word to the first + * character of the following word (i.e. including trailing whitespace, if any) within the text object. + *@SPI_TEXT_BOUNDARY_WORD_END: Bounds run from the last character of a word to the last + * character of the following word (i.e. including leading whitespace) within the text object. + *@SPI_TEXT_BOUNDARY_SENTENCE_START: Bounds run from the first character of a sentence to the first + * character of the next sentence in the text object. + *@SPI_TEXT_BOUNDARY_SENTENCE_END: Bounds run from the last character of a sentence to the last + * character of the next sentence in the text object. + *@SPI_TEXT_BOUNDARY_LINE_START: Bounds span one line of text, with the line delimiter at the end of the + * bounds, if present, within the current text object. + *@SPI_TEXT_BOUNDARY_LINE_END: Bounds span one line of text, including a preceding line delimiter + * if present within the current text object. + *@SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE: Bounds span the run, relative to the specified offset and + * text accessor API rules, over which the attributes of the text object are invariant. + * + *Text boundary types used for specifying boundaries for regions of text. + **/ typedef enum { SPI_TEXT_BOUNDARY_CHAR, @@ -31,1297 +100,1133 @@ typedef enum SPI_TEXT_BOUNDARY_LINE_START, SPI_TEXT_BOUNDARY_LINE_END, SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE -} SPI_TEXT_BOUNDARY_TYPE; - - - -/* - * - * Enumerated type for relation types - * - */ - -typedef enum -{ - RELATION_LABEL_FOR, - RELATION_LABELED_BY, - RELATION_CONTROLLER_FOR, - RELATION_CONTROLLED_BY, - RELATION_MEMBER_OF -} RELATION_TYPE; - - -/* don't change the order of these ! */ -typedef enum _SpiAccessibleCoordType { - COORD_TYPE_SCREEN, - COORD_TYPE_WINDOW -} SpiAccessibleCoordType; - -typedef enum _KeyEventType { - KEY_PRESSED, - KEY_RELEASED -} KeyEventType; - -typedef enum _KeySynthType { - KEY_PRESS, - KEY_RELEASE, - KEY_PRESSRELEASE, - KEY_SYM -} KeySynthType; - -typedef enum _KeySpiListenerSyncType { - KEYSPI_LISTENER_SYNCHRONOUS = 1, - KEYSPI_LISTENER_CANCONSUME = 2, - KEYSPI_LISTENER_ALLWINDOWS = 4 -} KeySpiListenerSyncType; - -typedef unsigned long KeyEventMask; - -typedef struct _KeyStroke -{ - long keyID; - short keycode; - KeyEventType type; - unsigned short modifiers; -} KeyStroke; - -typedef struct _KeySet -{ - unsigned long *keysyms; - unsigned short *keycodes; - short len; -} KeySet; - -#define ALL_KEYS ((void *)NULL) - -/* - * - * Basic SPI initialization and event loop function prototypes - * - */ +} AccessibleTextBoundaryType; /** - * SPI_init: + *AccessibleTextClipType + *@SPI_TEXT_CLIP_NONE: No clipping to be done + *@SPI_TEXT_CLIP_MIN: Text clipped by min coordinate is omitted + *@SPI_TEXT_CLIP_MAX: Text clipped by max coordinate is omitted + *@SPI_TEXT_CLIP_BOTH: Only text fully within mix/max bound is retained * - * Connects to the accessibility registry and initializes the SPI. - * - * Returns: 0 on success, otherwise an integer error code. + *Describes the type of clipping required. **/ -int -SPI_init (void); - -/** - * SPI_event_main: - * @isGNOMEApp: a #boolean indicating whether the client of the SPI - * will use the Gnome event loop or not. - * - * Starts/enters the main event loop for the SPI services. - * - * (NOTE: This method does not return control, it is exited via a call to exit() - * from within an event handler). - * - **/ -void -SPI_event_main (boolean isGNOMEApp); +typedef enum +{ + SPI_TEXT_CLIP_NONE, + SPI_TEXT_CLIP_MIN, + SPI_TEXT_CLIP_MAX, + SPI_TEXT_CLIP_BOTH +} AccessibleTextClipType; /** - * SPI_event_is_ready: - * - * Checks to see if an SPI event is waiting in the event queue. - * Used by clients that don't wish to use SPI_event_main(). - * Not Yet Implemented. - * - * Returns: #TRUE if an event is waiting, otherwise #FALSE. - * + *AccessibleRelationType: + *@SPI_RELATION_NULL: Not used, this is an invalid value for this enumeration. + *@SPI_RELATION_LABEL_FOR: Indicates an object is a label for one or more target objects. + *@SPI_RELATION_LABELED_BY: Indicates an object is labelled by one or more target objects. + *@SPI_RELATION_CONTROLLED_BY: Indicates an object controlled by one or more target objects. + *@SPI_RELATION_CONTROLLER_FOR: Indicates an object is an controller for one or more target objects. + *@SPI_RELATION_MEMBER_OF: Indicates an object is a member of a group of one or +more target objects. + *@SPI_RELATION_NODE_CHILD_OF: Indicates an object is a cell in a treetable which is displayed because a cell in the same column is expanded and identifies that cell. + *@SPI_RELATION_EXTENDED: This value indicates that a relation other than those pre-specified by this version of AT-SPI + * is present. + *@SPI_RELATION_FLOWS_TO: Indicates that the object has content that flows logically to another + * AtkObject in a sequential way, (for instance text-flow). + *@SPI_RELATION_FLOWS_FROM: Indicates that the object has content that flows logically from + * another AtkObject in a sequential way, (for instance text-flow). + *@SPI_RELATION_SUBWINDOW_OF: Indicates a subwindow attached to a component but otherwise has no connection in the UI heirarchy to that component. + *@SPI_RELATION_EMBEDS: Indicates that the object visually embeds + * another object's content, i.e. this object's content flows around + * another's content. + *@SPI_RELATION_EMBEDDED_BY: Inverse of %SPI_RELATION_EMBEDS, indicates that + * this object's content is visualy embedded in another object. + *@SPI_RELATION_POPUP_FOR: Indicates that an object is a popup for another object. + *@SPI_RELATION_PARENT_WINDOW_OF: Indicates that an object is a parent window of another object. + *@SPI_RELATION_DESCRIBED_BY: Indicates that another object provides descriptive information about this object; more verbose than %SPI_RELATION_LABELLED_BY. + *@SPI_RELATION_DESCRIPTION_FOR: Indicates that an object provides descriptive information about another object; more verbose than %SPI_RELATION_LABEL_FOR. + *@SPI_RELATION_LAST_DEFINED: Do not use, this is an implementation detail used + * to identify the size of this enumeration. + * + *Describes the type of the relation **/ -boolean -SPI_eventIsReady (); +typedef enum +{ + SPI_RELATION_NULL, + SPI_RELATION_LABEL_FOR, + SPI_RELATION_LABELED_BY, + SPI_RELATION_CONTROLLER_FOR, + SPI_RELATION_CONTROLLED_BY, + SPI_RELATION_MEMBER_OF, + SPI_RELATION_NODE_CHILD_OF, + SPI_RELATION_EXTENDED, + SPI_RELATION_FLOWS_TO, + SPI_RELATION_FLOWS_FROM, + SPI_RELATION_SUBWINDOW_OF, + SPI_RELATION_EMBEDS, + SPI_RELATION_EMBEDDED_BY, + SPI_RELATION_POPUP_FOR, + SPI_RELATION_PARENT_WINDOW_OF, + SPI_RELATION_DESCRIPTION_FOR, + SPI_RELATION_DESCRIBED_BY, + SPI_RELATION_LAST_DEFINED +} AccessibleRelationType; -/** - * SPI_nextEvent: - * - * Gets the next event in the SPI event queue; blocks if no event - * is pending. - * Used by clients that don't wish to use SPI_event_main(). - * Not Yet Implemented. - * - * Returns: the next #SpiAccessibleEvent in the SPI event queue. - * - **/ -SpiAccessibleEvent * -SPI_nextEvent (boolean waitForEvent); +/* don't change the order of these ! */ /** - * SPI_exit: - * - * Disconnects from the Accessibility SpiRegistry and releases resources. - * Not Yet Implemented. + *AccessibleCoordType: + *@SPI_COORD_TYPE_SCREEN: specifies xy coordinates relative to the screen + *@SPI_COORD_TYPE_WINDOW: specifies xy coordinates relative to an object's + * top-level window * + *Specifies how xy coordinates are to be interpreted. Used by functions such + *as AccessibleComponent_getPosition() and AccessibleText_getCharacterExtents() **/ -void -SPI_exit (void); - -/* - * Event SpiListener creation and support. - */ +typedef enum { + SPI_COORD_TYPE_SCREEN, + SPI_COORD_TYPE_WINDOW +} AccessibleCoordType; /** - * createEventListener: - * @callback : an #SpiAccessibleEventListenerCB callback function, or NULL. - * - * Create a new #SpiAccessibleEventListener with a specified callback function. - * - * Returns: a pointer to a newly-created #SpiAccessibleEventListener. - * + *AccessibleKeySynthType: + *@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. + * + * Specifies the type of a generated event. **/ -SpiAccessibleEventListener * -createEventListener (SpiAccessibleEventListenerCB callback); +typedef enum { + SPI_KEY_PRESS, + SPI_KEY_RELEASE, + SPI_KEY_PRESSRELEASE, + SPI_KEY_SYM, + SPI_KEY_STRING +} AccessibleKeySynthType; /** - * EventListener_addCallback: - * @listener: the #SpiAccessibleEventListener instance to modify. - * @callback: an #SpiAccessibleEventListenerCB function pointer. - * - * Add an in-process callback function to an existing SpiAccessibleEventListener. - * - * Returns: #TRUE if successful, otherwise #FALSE. - * + *AccessibleKeyListenerSyncType: + *@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. + * + *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. **/ -boolean -EventListener_addCallback (SpiAccessibleEventListener *listener, - SpiAccessibleEventListenerCB callback); +typedef enum { + SPI_KEYLISTENER_NOSYNC = 0, + SPI_KEYLISTENER_SYNCHRONOUS = 1, + SPI_KEYLISTENER_CANCONSUME = 2, + SPI_KEYLISTENER_ALL_WINDOWS = 4 +} AccessibleKeyListenerSyncType; -/** - * EventListener_removeCallback: - * @listener: the #SpiAccessibleEventListener instance to modify. - * @callback: an #SpiAccessibleEventListenerCB function pointer. - * - * Remove an in-process callback function from an existing SpiAccessibleEventListener. - * - * Returns: #TRUE if successful, otherwise #FALSE. - * - **/ -boolean -EventListener_removeCallback (SpiAccessibleEventListener *listener, - SpiAccessibleEventListenerCB callback); /** - * createKeySpiListener: - * @callback : an #KeystrokeListenerCB callback function, or NULL. - * - * Create a new #KeystrokeListener with a specified callback function. - * - * Returns: a pointer to a newly-created #KeystrokeListener. + *AccessibleStreamableContentSeekType + *@SPI_STREAM_SEEK_SET: seek from the 'top' of the streamable + *@SPI_STREAM_SEEK_CUR: seek from the current position in the stream + *@SPI_STREAM_SEEK_END: seek from the end of the stream (if known) * + *The seek type for a specified offset in AccessibleStreamableContent_seek. **/ -KeystrokeListener * -createKeystrokeListener (KeystrokeListenerCB callback); +typedef enum +{ + SPI_STREAM_SEEK_SET, + SPI_STREAM_SEEK_CUR, + SPI_STREAM_SEEK_END +} AccessibleStreamableContentSeekType; /** - * KeystrokeListener_addCallback: - * @listener: the #KeystrokeListener instance to modify. - * @callback: an #KeystrokeListenerCB function pointer. - * - * Add an in-process callback function to an existing #KeystrokeListener. - * - * Returns: #TRUE if successful, otherwise #FALSE. - * + * SPIException: + * @type: private + * @source: private + * @ev: private + * @code: private + * @desc: private + * + * An opaque object encapsulating information about thrown exceptions. **/ -boolean -KeystrokeListener_addCallback (KeystrokeListener *listener, - KeystrokeListenerCB callback); +typedef struct _SPIException SPIException; /** - * KeystrokeListener_removeCallback: - * @listener: the #KeystrokeListener instance to modify. - * @callback: an #KeystrokeListenerCB function pointer. - * - * Remove an in-process callback function from an existing #KeystrokeListener. + * SPIExceptionHandler: + * @err: points to the SPIException opaque object. + * @is_fatal: indicates whether the exception is a fatal error or not. * - * Returns: #TRUE if successful, otherwise #FALSE. + * A function type for functions to be called when exceptions occur. * + * Returns **/ -boolean -KeystrokeListener_removeCallback (KeystrokeListener *listener, - KeystrokeListenerCB callback); - -/* - * - * Global functions serviced by the registry - * - */ +typedef SPIBoolean (*SPIExceptionHandler) (SPIException *err, SPIBoolean is_fatal); /** - * registerGlobalEventListener: - * @listener: the #SpiAccessibleEventListener to be registered against an event type. - * @callback: 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 "Focus", "Window", "Mouse", - * and toolkit events (e.g. "Gtk", "AWT"). - * Examples: "focus:", "Gtk:GtkWidget:button_press_event". - * - * 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 SpiAccessibleEventListener. - * - * Returns: #TRUE if successful, otherwise #FALSE. - * + * SPIExceptionCode: + * @SPI_EXCEPTION_UNSPECIFIED: An exception of unknown type, or which doesn't fit the other types. + * @SPI_EXCEPTION_DISCONNECT: Communication with the object or service has been disconnected; + * this usually means that the object or service has died or exited. + * @SPI_EXCEPTION_NO_IMPL: The object or service is missing the implementation for a request. + * @SPI_EXCEPTION_IO: The communications channel has become corrupted, blocked, or is otherwise in a bad state. + * @SPI_EXCEPTION_BAD_DATA: The data received or sent over the interface has been identified as + * improperly formatted or otherwise fails to match the expectations. + * + * Exception codes indicating what's gone wrong in an AT-SPI call. **/ -boolean -registerGlobalEventListener (SpiAccessibleEventListener *listener, - char *eventType); +typedef enum { + SPI_EXCEPTION_UNSPECIFIED, + SPI_EXCEPTION_DISCONNECT, + SPI_EXCEPTION_NO_IMPL, + SPI_EXCEPTION_IO, + SPI_EXCEPTION_BAD_DATA +} SPIExceptionCode; /** - * getDesktopCount: - * - * 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. + * SPIExceptionType: + * @SPI_EXCEPTION_SOURCE_UNSPECIFIED: Don't know or can't tell where the problem is + * @SPI_EXCEPTION_SOURCE_ACCESSIBLE: The source of an event or query (i.e. an app) has thrown the exception. + * @SPI_EXCEPTION_SOURCE_REGISTRY: The AT-SPI registry has thrown the exception or cannot be reached. + * @SPI_EXCEPTION_SOURCE_DEVICE: The device event subsystem has encountered an error condition. * + * The general source of the failure, i.e. whether the app, registry, or device system has encountered trouble. **/ -int -getDesktopCount (); +typedef enum { + SPI_EXCEPTION_SOURCE_UNSPECIFIED, + SPI_EXCEPTION_SOURCE_ACCESSIBLE, + SPI_EXCEPTION_SOURCE_REGISTRY, + SPI_EXCEPTION_SOURCE_DEVICE +} SPIExceptionType; -/** - * getDesktop: - * @i: an integer indicating which of the accessible desktops is to be returned. - * - * Get the virtual desktop indicated by index @i. - * NOTE: currently multiple virtual desktops are not implemented, this - * function always returns '1'. - * - * Returns: a pointer to the 'i-th' virtual desktop's #SpiAccessible representation. - * - **/ -SpiAccessible* -getDesktop (int n); +typedef unsigned long AccessibleKeyEventMask; +typedef unsigned long AccessibleDeviceEventMask; /** - * getDesktopList: - * @list: a pointer to an array of #SpiAccessible objects. - * - * Get the list of virtual desktops. On return, @list will point - * to a newly-created 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. - * - * Returns: an integer indicating how many virtual desktops have been - * placed in the list pointed to by parameter @list. + *AccessibleComponentLayer: + *@SPI_LAYER_INVALID: The layer cannot be determined or is somehow undefined. + *@SPI_LAYER_BACKGROUND: Component belongs to the destop background. + *@SPI_LAYER_CANVAS: Component is a canvas backdrop or drawing area. + *@SPI_LAYER_WIDGET: Component is a 'normal' widget. + *@SPI_LAYER_MDI: Component is drawn in the MDI layer and may have valid + * Z-information relative to other MDI-layer components. + *@SPI_LAYER_POPUP: Component is in the popup layer, above other widgets and + * MDI components. + *@SPI_LAYER_OVERLAY: Component is in the overlay plane - this value is reserved + * for future use. + *@SPI_LAYER_WINDOW: Component is in the window layer and have valid Z-information + * relative to other window-layer components. + *@SPI_LAYER_LAST_DEFINED: Used to determine the last valid value in the enum, + * should not be encountered. + * + * Describes the layer of a component. + * + * These enumerated "layer values" are used when determining which UI + * rendering layer a component is drawn into, which can help in making + * determinations of when components occlude one another. **/ -int -getDesktopList (SpiAccessible **list); +typedef enum { + SPI_LAYER_INVALID, + SPI_LAYER_BACKGROUND, + SPI_LAYER_CANVAS, + SPI_LAYER_WIDGET, + SPI_LAYER_MDI, + SPI_LAYER_POPUP, + SPI_LAYER_OVERLAY, + SPI_LAYER_WINDOW, + SPI_LAYER_LAST_DEFINED +} AccessibleComponentLayer; -/** - * registerKeystrokeListener: - * @listener: a pointer to the #KeystrokeListener for which - * keystroke events are requested. - * - * Not Yet Implemented. - * - **/ -void -registerKeystrokeListener (KeystrokeListener *listener, - KeySet *keys, - KeyMaskType modmask, - KeyEventMask eventmask, - KeySpiListenerSyncType sync_type); /** - * generateKeyEvent: - * @keycode: a #long indicating the keycode of the key event - * being synthesized. - * @synth_type: a #KeySynthType indicating whether this should be a - * KEY_PRESS, KEY_RELEASE, both (KEY_PRESSRELEASE), or - * a press/release pair for a KEYSYM. - * - * Synthesize a keyboard event (as if a hardware keyboard event occurred in the - * current UI context). + * AccessibleTextRange: + * @start: the first nominal character position within the range. + * @end: the first nominal character position following the range. + * @content: The actual text content between @start and @end, as a UTF-8 string. * + * Structure which encapsulates a text range - must be associated with an + * AccessibleText-implementing object. **/ -void -generateKeyEvent (long keyCode, KeySynthType synth_type); +typedef struct _AccessibleTextRange +{ + long int start; + long int end; + char *contents; +} AccessibleTextRange; /** - * generateMouseEvent: - * @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. "button1", "button2", "mousemove"). - * - * Synthesize a mouse event at a specific screen coordinate. - * Not Yet Implemented. + * AccessibleKeySet: + * @keysyms: + * @keycodes: + * @len: * + * Structure containing identifying information about a set of keycode or + * keysyms. **/ -void -generateMouseEvent (long x, long y, char *name); +typedef struct _AccessibleKeySet +{ + unsigned long *keysyms; + unsigned short *keycodes; + char **keystrings; + short len; +} AccessibleKeySet; /* - * - * SpiAccessible function prototypes - * + * A special value for an AccessibleKeySet type, which tacitly + * includes all keycodes and keyvals for the specified modifier set. */ +#define SPI_KEYSET_ALL_KEYS NULL +typedef unsigned long AccessibleModifierMaskType; /** - * SpiAccessible_ref: - * @obj: a pointer to the #SpiAccessible object on which to operate. - * - * Increment the reference count for an #SpiAccessible object. - * - * Returns: (no return code implemented yet). - * - **/ -int -SpiAccessible_ref (SpiAccessible *obj); - -/** - * SpiAccessible_unref: - * @obj: a pointer to the #SpiAccessible object on which to operate. - * - * Decrement the reference count for an #SpiAccessible object. - * - * Returns: (no return code implemented yet). - * - **/ -int -SpiAccessible_unref (SpiAccessible *obj); - -/** - * SpiAccessible_getName: - * @obj: a pointer to the #SpiAccessible object on which to operate. - * - * Get the name of an #SpiAccessible object. - * - * Returns: a UTF-8 string indicating the name of the #SpiAccessible object. - * - **/ -char * -SpiAccessible_getName (SpiAccessible *obj); - -/** - * SpiAccessible_getDescription: - * @obj: a pointer to the #SpiAccessible object on which to operate. - * - * Get the description of an #SpiAccessible object. - * - * Returns: a UTF-8 string describing the #SpiAccessible object. - * - **/ -char * -SpiAccessible_getDescription (SpiAccessible *obj); - -/** - * SpiAccessible_getParent: - * @obj: a pointer to the #SpiAccessible object to query. - * - * Get an #SpiAccessible object's parent container. - * - * Returns: a pointer to the #SpiAccessible object which contains the given - * #SpiAccessible instance, or NULL if the @obj has no parent container. - * - **/ -SpiAccessible * -SpiAccessible_getParent (SpiAccessible *obj); - -/** - * SpiAccessible_getChildCount: - * - * @obj: a pointer to the #SpiAccessible object on which to operate. - * - * Get the number of children contained by an #SpiAccessible object. - * - * Returns: a #long indicating the number of #SpiAccessible children - * contained by an #SpiAccessible object. - * - **/ -long -SpiAccessible_getChildCount (SpiAccessible *obj); - -/** - * SpiAccessible_getChildAtIndex: - * - * @obj: a pointer to the #SpiAccessible object on which to operate. - * @childIndex: a #long indicating which child is specified. - * - * Get the #SpiAccessible child of an #SpiAccessible object at a given index. - * - * Returns: a pointer to the #SpiAccessible child object at index - * @childIndex. - * - **/ -SpiAccessible * -SpiAccessible_getChildAtIndex (SpiAccessible *obj, - long childIndex); - -/** - * SpiAccessible_getIndexInParent: - * - * @obj: a pointer to the #SpiAccessible object on which to operate. - * - * Get the index of an #SpiAccessible object in its containing #SpiAccessible. - * - * Returns: a #long indicating the index of the #SpiAccessible object - * in its parent (i.e. containing) #SpiAccessible instance, - * or -1 if @obj has no containing parent. + *AccessibleKeyMaskType: * + *AccessibleKeyMaskType is a mask which is a set of key event modifiers + *which is specified in SPI_registerAccessibleKeystrokeListener. **/ -long -SpiAccessible_getIndexInParent (SpiAccessible *obj); -/** - * SpiAccessible_getRelationSet: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleRelation ** -SpiAccessible_getRelationSet (SpiAccessible *obj); +typedef AccessibleModifierMaskType AccessibleKeyMaskType; -/** - * SpiAccessible_getRole: - * @obj: a pointer to the #SpiAccessible object on which to operate. - * - * Get the UI role of an #SpiAccessible object. - * - * Returns: a UTF-8 string indicating the UI role of the #SpiAccessible object. - * - **/ -char * -SpiAccessible_getRole (SpiAccessible *obj); +typedef struct _AccessibleAttributeSet +{ + int len; + char **attributes; +} AccessibleAttributeSet; -/** - * SpiAccessible_getStateSet: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleStateSet * -SpiAccessible_getStateSet (SpiAccessible *obj); +typedef struct _AccessibleRoleSet +{ + int len; + AccessibleRole *roles; +} AccessibleRoleSet; + + + +/* Basic SPI initialization and event loop function prototypes */ + +int SPI_init (void); +void SPI_event_main (void); +void SPI_event_quit (void); +SPIBoolean SPI_eventIsReady (void); +AccessibleEvent *SPI_nextEvent (SPIBoolean waitForEvent); +int SPI_exit (void); + +/* Event Listener creation and support. */ + +void SPI_freeAccessibleKeySet ( + AccessibleKeySet *keyset); +AccessibleKeySet * SPI_createAccessibleKeySet ( + int len, + const char *keysyms, + short *keycodes, + const char **keystrings); +AccessibleEventListener * SPI_createAccessibleEventListener ( + AccessibleEventListenerCB callback, + void *user_data); +SPIBoolean AccessibleEventListener_addCallback ( + AccessibleEventListener *listener, + AccessibleEventListenerCB callback, + void *user_data); +SPIBoolean AccessibleEventListener_removeCallback ( + AccessibleEventListener *listener, + AccessibleEventListenerCB callback); +void AccessibleEventListener_unref ( + AccessibleEventListener *listener); + +/* Device Event Listener creation and support. */ + +/* First four are deprecated in favor of the last four; really just a re-name */ + +AccessibleKeystrokeListener * SPI_createAccessibleKeystrokeListener ( + AccessibleKeystrokeListenerCB callback, + void *user_data); +SPIBoolean AccessibleKeystrokeListener_addCallback ( + AccessibleKeystrokeListener *listener, + AccessibleKeystrokeListenerCB callback, + void *user_data); +SPIBoolean AccessibleKeystrokeListener_removeCallback ( + AccessibleKeystrokeListener *listener, + AccessibleKeystrokeListenerCB callback); +void AccessibleKeystrokeListener_unref ( + AccessibleKeystrokeListener *listener); + +AccessibleDeviceListener * SPI_createAccessibleDeviceListener ( + AccessibleDeviceListenerCB callback, + void *user_data); +SPIBoolean AccessibleDeviceListener_addCallback ( + AccessibleDeviceListener *listener, + AccessibleDeviceListenerCB callback, + void *user_data); +SPIBoolean AccessibleDeviceListener_removeCallback ( + AccessibleDeviceListener *listener, + AccessibleDeviceListenerCB callback); +void AccessibleDeviceListener_unref ( + AccessibleDeviceListener *listener); + +/* Global functions serviced by the registry */ + +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); + +SPIBoolean SPI_registerDeviceEventListener ( + AccessibleDeviceListener *listener, + AccessibleDeviceEventMask eventmask, + void *filter); +SPIBoolean SPI_deregisterDeviceEventListener ( + AccessibleDeviceListener *listener, + void *filter); + +int SPI_getDesktopCount (void); +Accessible *SPI_getDesktop (int i); +int SPI_getDesktopList (Accessible ***desktop_list); +void SPI_freeDesktopList (Accessible **desktop_list); + +SPIBoolean SPI_generateKeyboardEvent (long int keyval, + char *keystring, + AccessibleKeySynthType synth_type); + +SPIBoolean SPI_generateMouseEvent (long int x, long int y, char *name); + +/* Accessible function prototypes */ + +void Accessible_ref (Accessible *obj); +void Accessible_unref (Accessible *obj); +char * Accessible_getName (Accessible *obj); +char * Accessible_getDescription (Accessible *obj); +Accessible * Accessible_getParent (Accessible *obj); +long Accessible_getChildCount (Accessible *obj); +Accessible * Accessible_getChildAtIndex (Accessible *obj, + long int childIndex); +long Accessible_getIndexInParent (Accessible *obj); +AccessibleRelation **Accessible_getRelationSet (Accessible *obj); +AccessibleRole Accessible_getRole (Accessible *obj); +char * Accessible_getRoleName (Accessible *obj); +char * Accessible_getLocalizedRoleName (Accessible *obj); +AccessibleStateSet * Accessible_getStateSet (Accessible *obj); +AccessibleAttributeSet *Accessible_getAttributes (Accessible *obj); +AccessibleApplication *Accessible_getHostApplication (Accessible *obj); /* Interface query methods */ -/** - * SpiAccessible_isSpiAction: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Query whether the specified #SpiAccessible implements #SpiAccessibleAction. - * Not Yet Implemented. - * - * Returns: #TRUE if @obj implements the #SpiAccessibleAction interface, - * #FALSE otherwise. - **/ -boolean -SpiAccessible_isSpiAction (SpiAccessible *obj); - -/** - * SpiAccessible_isSpiComponent: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Query whether the specified #SpiAccessible implements #SpiAccessibleComponent. - * - * Returns: #TRUE if @obj implements the #SpiAccessibleComponent interface, - * #FALSE otherwise. - **/ -boolean -SpiAccessible_isSpiComponent (SpiAccessible *obj); - -/** - * SpiAccessible_isSpiEditableText: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Query whether the specified #SpiAccessible implements #SpiAccessibleEditableText. - * Not Yet Implemented. - * - * Returns: #TRUE if @obj implements the #SpiAccessibleEditableText interface, - * #FALSE otherwise. - **/ -boolean -SpiAccessible_isSpiEditableText (SpiAccessible *obj); - -/** - * SpiAccessible_isSpiHypertext: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Query whether the specified #SpiAccessible implements #SpiAccessibleHypertext. - * Not Yet Implemented. - * - * Returns: #TRUE if @obj implements the #SpiAccessibleHypertext interface, - * #FALSE otherwise. - **/ -boolean -SpiAccessible_isSpiHypertext (SpiAccessible *obj); - -/** - * SpiAccessible_isSpiImage: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Query whether the specified #SpiAccessible implements #SpiAccessibleImage. - * Not Yet Implemented. - * - * Returns: #TRUE if @obj implements the #SpiAccessibleImage interface, - * #FALSE otherwise. -**/ -boolean -SpiAccessible_isSpiImage (SpiAccessible *obj); - -/** - * SpiAccessible_isSpiSelection: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Query whether the specified #SpiAccessible implements #SpiAccessibleSelection. - * Not Yet Implemented. - * - * Returns: #TRUE if @obj implements the #SpiAccessibleSelection interface, - * #FALSE otherwise. -**/ -boolean -SpiAccessible_isSpiSelection (SpiAccessible *obj); - -/** - * SpiAccessible_isSpiTable: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Query whether the specified #SpiAccessible implements #SpiAccessibleTable. - * Not Yet Implemented. - * - * Returns: #TRUE if @obj implements the #SpiAccessibleTable interface, - * #FALSE otherwise. -**/ -boolean -SpiAccessible_isSpiTable (SpiAccessible *obj); - -/** - * SpiAccessible_isSpiText: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Query whether the specified #SpiAccessible implements #SpiAccessibleText. - * Not Yet Implemented. - * - * Returns: #TRUE if @obj implements the #SpiAccessibleText interface, - * #FALSE otherwise. -**/ -boolean -SpiAccessible_isSpiText (SpiAccessible *obj); +SPIBoolean Accessible_isAction (Accessible *obj); +SPIBoolean Accessible_isApplication (Accessible *obj); +SPIBoolean Accessible_isCollection (Accessible *obj); +SPIBoolean Accessible_isComponent (Accessible *obj); +SPIBoolean Accessible_isDocument (Accessible *obj); +SPIBoolean Accessible_isEditableText (Accessible *obj); +SPIBoolean Accessible_isHypertext (Accessible *obj); +SPIBoolean Accessible_isImage (Accessible *obj); +SPIBoolean Accessible_isMatchRule (Accessible *obj); +SPIBoolean Accessible_isSelection (Accessible *obj); +SPIBoolean Accessible_isStreamableContent (Accessible *obj); +SPIBoolean Accessible_isTable (Accessible *obj); +SPIBoolean Accessible_isText (Accessible *obj); +SPIBoolean Accessible_isValue (Accessible *obj); + +AccessibleAction * Accessible_getAction (Accessible *obj); +AccessibleApplication * Accessible_getApplication (Accessible *obj); +AccessibleCollection * Accessible_getCollection (Accessible *obj); +AccessibleComponent * Accessible_getComponent (Accessible *obj); +AccessibleDocument * Accessible_getDocument (Accessible *obj); +AccessibleEditableText * Accessible_getEditableText (Accessible *obj); +AccessibleHypertext * Accessible_getHypertext (Accessible *obj); +AccessibleImage * Accessible_getImage (Accessible *obj); +AccessibleMatchRule * Accessible_getMatchRule (Accessible *obj); +AccessibleSelection * Accessible_getSelection (Accessible *obj); +AccessibleStreamableContent * Accessible_getStreamableContent (Accessible *obj); +AccessibleTable * Accessible_getTable (Accessible *obj); +AccessibleText * Accessible_getText (Accessible *obj); +AccessibleValue * Accessible_getValue (Accessible *obj); +AccessibleUnknown * Accessible_queryInterface (Accessible *obj, + const char *interface_name); + +/* AccessibleAction function prototypes */ + +void AccessibleAction_ref (AccessibleAction *obj); +void AccessibleAction_unref (AccessibleAction *obj); +long AccessibleAction_getNActions (AccessibleAction *obj); +char *AccessibleAction_getName (AccessibleAction *obj, + long int i); +char *AccessibleAction_getDescription (AccessibleAction *obj, + long int i); +SPIBoolean AccessibleAction_doAction (AccessibleAction *obj, + long int i); +char *AccessibleAction_getKeyBinding (AccessibleAction *obj, + long int i); + +/* AccessibleApplication function prototypes */ + +void AccessibleApplication_ref (AccessibleApplication *obj); +void AccessibleApplication_unref (AccessibleApplication *obj); +char *AccessibleApplication_getToolkitName (AccessibleApplication *obj); +char *AccessibleApplication_getVersion (AccessibleApplication *obj); +long AccessibleApplication_getID (AccessibleApplication *obj); +char *AccessibleApplication_getLocale (AccessibleApplication *obj, int lc_category); +SPIBoolean AccessibleApplication_pause (AccessibleApplication *obj); +SPIBoolean AccessibleApplication_resume (AccessibleApplication *obj); + +/* AccessibleCollection function prototypes */ +void AccessibleCollection_ref (AccessibleCollection *obj); +void AccessibleCollection_unref (AccessibleCollection *obj); +AccessibleMatchRule * +AccessibleCollection_createMatchRule (AccessibleCollection *obj, + AccessibleStateSet *states, + AccessibleCollectionMatchType statematchtype, + AccessibleAttributeSet *attributes, + AccessibleCollectionMatchType attributematchtype, + AccessibleRoleSet *roles, + AccessibleCollectionMatchType rolematchtype, + char *interfaces, + AccessibleCollectionMatchType interfacematchtype, + long int invert); +void +AccessibleCollection_freeMatchRule (AccessibleCollection *obj, + AccessibleMatchRule *matchrule); +/* AccessibleComponent function prototypes */ + +void AccessibleComponent_ref (AccessibleComponent *obj); +void AccessibleComponent_unref (AccessibleComponent *obj); +SPIBoolean AccessibleComponent_contains (AccessibleComponent *obj, + long int x, + long int y, + AccessibleCoordType ctype); +Accessible *AccessibleComponent_getAccessibleAtPoint ( + AccessibleComponent *obj, + long int x, + long int y, + AccessibleCoordType ctype); +void AccessibleComponent_getExtents (AccessibleComponent *obj, + long int *x, + long int *y, + long int *width, + long int *height, + AccessibleCoordType ctype); +void AccessibleComponent_getPosition (AccessibleComponent *obj, + long int *x, + long int *y, + AccessibleCoordType ctype); +void AccessibleComponent_getSize (AccessibleComponent *obj, + long int *width, + long int *height); +AccessibleComponentLayer + AccessibleComponent_getLayer (AccessibleComponent *obj); +SPIBoolean AccessibleComponent_grabFocus (AccessibleComponent *obj); +short AccessibleComponent_getMDIZOrder(AccessibleComponent *obj); +double AccessibleComponent_getAlpha (AccessibleComponent *obj); + +/* AccessibleDocument function prototypes */ + +void AccessibleDocument_ref (AccessibleDocument *obj); +void AccessibleDocument_unref (AccessibleDocument *obj); +char *AccessibleDocument_getLocale (AccessibleDocument *obj); +char *AccessibleDocument_getAttributeValue (AccessibleDocument *obj, + char *attribute); +AccessibleAttributeSet *AccessibleDocument_getAttributes (AccessibleDocument *obj); + +/* AccessibleEditableText function prototypes */ -/** - * SpiAccessible_getAction: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleAction * -SpiAccessible_getAction (SpiAccessible *obj); +void +AccessibleEditableText_ref (AccessibleEditableText *obj); -/** - * SpiAccessible_getComponent: - * @obj: a pointer to the #SpiAccessible instance to query. - * - * Get the #SpiAccessibleComponent interface for an #SpiAccessible. - * - * Returns: a pointer to an #SpiAccessibleComponent interface instance, or - * NULL if @obj does not implement #SpiAccessibleComponent. - **/ -SpiAccessibleComponent * -SpiAccessible_getComponent (SpiAccessible *obj); +void +AccessibleEditableText_unref (AccessibleEditableText *obj); -/** - * SpiAccessible_getEditableText: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleEditableText * -SpiAccessible_getEditableText (SpiAccessible *obj); +SPIBoolean +AccessibleEditableText_setAttributes (AccessibleEditableText *obj, + const char *attributes, + long int startOffset, + long int endOffset); -/** - * SpiAccessible_getHypertext: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleHypertext * -SpiAccessible_getHypertext (SpiAccessible *obj); +SPIBoolean +AccessibleEditableText_setTextContents (AccessibleEditableText *obj, + const char *newContents); -/** - * SpiAccessible_getImage: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleImage * -SpiAccessible_getImage (SpiAccessible *obj); +SPIBoolean +AccessibleEditableText_insertText (AccessibleEditableText *obj, + long int position, + const char *text, + long int length); -/** - * SpiAccessible_getSelection: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleSelection * -SpiAccessible_getSelection (SpiAccessible *obj); +SPIBoolean +AccessibleEditableText_copyText (AccessibleText *obj, + long int startPos, + long int endPos); -/** - * SpiAccessible_getTable: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleTable * -SpiAccessible_getTable (SpiAccessible *obj); +SPIBoolean +AccessibleEditableText_cutText (AccessibleEditableText *obj, + long int startPos, + long int endPos); -/** - * SpiAccessible_getText: - * - * Not Yet Implemented. - * - **/ -SpiAccessibleText * -SpiAccessible_getText (SpiAccessible *obj); +SPIBoolean +AccessibleEditableText_deleteText (AccessibleEditableText *obj, + long int startPos, + long int endPos); -/** - * SpiAccessible_queryInterface: - * @obj: a pointer to the #SpiAccessible instance to query. - * @interface_name: a UTF-8 character string specifiying the requested interface. - * - * Query an #SpiAccessible object to for a named interface. - * - * Returns: an instance of the named interface object, if it is implemented - * by @obj, or NULL otherwise. - * - **/ -GenericInterface * -SpiAccessible_queryInterface (SpiAccessible *obj, char *interface_name); +SPIBoolean +AccessibleEditableText_pasteText (AccessibleEditableText *obj, + long int position); /* * - * SpiAccessibleAction function prototypes + * AccessibleHyperlink function prototypes * */ - -int -SpiAccessibleAction_ref ( - SpiAccessibleAction *obj); - -int -SpiAccessibleAction_unref (SpiAccessibleAction *obj); +void +AccessibleHyperlink_ref (AccessibleHyperlink *obj); +void +AccessibleHyperlink_unref (AccessibleHyperlink *obj); long -SpiAccessibleAction_getNSpiActions (SpiAccessibleAction *obj); - -/** - * SpiAccessibleAction_getDescription: - * @obj: a pointer to the #SpiAccessibleAction to query. - * - * Get the description of 'i-th' action invokable on an - * object implementing #SpiAccessibleAction. - * - * Not Yet Implemented. - * - * Returns: a UTF-8 string describing the 'i-th' invokable action. - * - **/ -char * -SpiAccessibleAction_getDescription (SpiAccessibleAction *obj, - long index); - -boolean -SpiAccessibleAction_doSpiAction (SpiAccessibleAction *obj, - long index); +AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj); char * -SpiAccessibleAction_getKeyBinding (SpiAccessibleAction *obj, - long index); - -/* - * - * SpiAccessibleApplication function prototypes - * - */ - -/** - * SpiAccessibleApplication_unref: - * @obj: a pointer to the #SpiAccessibleApplication on which to operate. - * - * Decrement the reference count for an #SpiAccessibleApplication. - * - * Returns: (no return code implemented yet). - * - **/ -int -SpiAccessibleApplication_ref (SpiAccessibleApplication *obj); +AccessibleHyperlink_getURI (AccessibleHyperlink *obj, + long int i); -/** - * SpiAccessibleApplication_unref: - * @obj: a pointer to the #SpiAccessibleApplication object on which to operate. - * - * Decrement the reference count for an #SpiAccessibleApplication. - * - * Returns: (no return code implemented yet). - * - **/ -int -SpiAccessibleApplication_unref (SpiAccessibleApplication *obj); - -/** - * SpiAccessibleApplication_getToolkitName: - * @obj: a pointer to the #SpiAccessibleApplication to query. - * - * Get the name of the UI toolkit used by an #SpiAccessibleApplication. - * - * Returns: a UTF-8 string indicating which UI toolkit is - * used by an application. - * - **/ -char * -SpiAccessibleApplication_getToolkitName (SpiAccessibleApplication *obj); +Accessible * +AccessibleHyperlink_getObject (AccessibleHyperlink *obj, + long int i); -/** - * SpiAccessibleApplication_getVersion: - * @obj: a pointer to the #SpiAccessibleApplication being queried. - * - * Get the version of the at-spi bridge exported by an - * #SpiAccessibleApplication instance. - * - * Returns: a UTF-8 string indicating the application's - * at-spi version. - * - **/ -char * -SpiAccessibleApplication_getVersion (SpiAccessibleApplication *obj); - -/** - * SpiAccessibleApplication_getID: - * @obj: a pointer to the #SpiAccessibleApplication being queried. - * - * Get the unique ID assigned by the SpiRegistry to an - * #SpiAccessibleApplication instance. - * (Not Yet Implemented by the registry). - * - * Returns: a unique #long integer associated with the application - * by the SpiRegistry, or 0 if the application is not registered. - **/ -long -SpiAccessibleApplication_getID (SpiAccessibleApplication *obj); - -/** - * SpiAccessibleApplication_pause: - * - * Attempt to pause the application (used when client event queue is - * over-full). - * Not Yet Implemented. - * - * Returns: #TRUE if the application was paused successfully, #FALSE otherwise. - * - **/ -boolean -SpiAccessibleApplication_pause (SpiAccessibleApplication *obj); +void +AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj, + long int *startIndex, + long int *endIndex); -/** - * SpiAccessibleApplication_pause: - * - * Attempt to resume the application (used after #SpiAccessibleApplication_pause). - * Not Yet Implemented. - * - * Returns: #TRUE if application processing resumed successfully, #FALSE otherwise. - * - **/ -boolean -SpiAccessibleApplication_resume (SpiAccessibleApplication *obj); +SPIBoolean +AccessibleHyperlink_isValid (AccessibleHyperlink *obj); /* * - * SpiAccessibleComponent function prototypes + * AccessibleHypertext function prototypes * */ -int -SpiAccessibleComponent_ref (SpiAccessibleComponent *obj); - -int -SpiAccessibleComponent_unref (SpiAccessibleComponent *obj); - -boolean -SpiAccessibleComponent_contains (SpiAccessibleComponent *obj, - long x, - long y, - SpiAccessibleCoordType ctype); - -SpiAccessible * -SpiAccessibleComponent_getAccessibleAtPoint (SpiAccessibleComponent *obj, - long x, - long y, - SpiAccessibleCoordType ctype); - -/** - * SpiAccessibleComponent_getExtents: - * @obj: a pointer to the #SpiAccessibleComponent to query. - * @x: a pointer to a #long into which the minimum x coordinate will be returned. - * @y: a pointer to a #long into which the minimum y coordinate will be returned. - * @width: a pointer to a #long into which the x extents (width) will be returned. - * @height: a pointer to a #long into which the y extents (height) will be returned. - * @ctype: the desired coordinate system into which to return the results, - * (e.g. COORD_TYPE_WINDOW, COORD_TYPE_SCREEN). - * - * Get the bounding box of the specified #SpiAccessibleComponent. - * - **/ void -SpiAccessibleComponent_getExtents (SpiAccessibleComponent *obj, - long *x, - long *y, - long *width, - long *height, - SpiAccessibleCoordType ctype); +AccessibleHypertext_ref (AccessibleHypertext *obj); void -SpiAccessibleComponent_getPosition (SpiAccessibleComponent *obj, - long *x, - long *y, - SpiAccessibleCoordType ctype); +AccessibleHypertext_unref (AccessibleHypertext *obj); -void -SpiAccessibleComponent_getSize (SpiAccessibleComponent *obj, - long *width, - long *height); +long +AccessibleHypertext_getNLinks (AccessibleHypertext *obj); -void -SpiAccessibleComponent_grabFocus (SpiAccessibleComponent *obj); +AccessibleHyperlink * +AccessibleHypertext_getLink (AccessibleHypertext *obj, + long int linkIndex); + +long +AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj, + long int characterOffset); /* * - * SpiAccessibleEditableText function prototypes + * AccessibleImage function prototypes * */ -int -SpiAccessibleEditableText_ref (SpiAccessibleEditableText *obj); - -int -SpiAccessibleEditableText_unref (SpiAccessibleEditableText *obj); - -boolean -SpiAccessibleEditableText_setRunAttributes (SpiAccessibleEditableText *obj, - const char *attributes, - long startPos, long endPos); - void -SpiAccessibleEditableText_setTextContents (SpiAccessibleEditableText *obj, - const char *newContents); +AccessibleImage_ref (AccessibleImage *obj); void -SpiAccessibleEditableText_insertText (SpiAccessibleEditableText *obj, - long position, - char *text, - long length); +AccessibleImage_unref (AccessibleImage *obj); -void -SpiAccessibleEditableText_copySpiText (SpiAccessibleText *obj, - long startPos, - long endPos); +char * +AccessibleImage_getImageDescription (AccessibleImage *obj); void -SpiAccessibleEditableText_cutText (SpiAccessibleEditableText *obj, - long startPos, - long endPos); +AccessibleImage_getImageSize (AccessibleImage *obj, + long int *width, + long int *height); void -SpiAccessibleEditableText_deleteText (SpiAccessibleEditableText *obj, - long startPos, - long endPos); +AccessibleImage_getImagePosition (AccessibleImage *obj, + long int *x, + long int *y, + AccessibleCoordType ctype); void -SpiAccessibleEditableText_pasteText (SpiAccessibleEditableText *obj, - long position); +AccessibleImage_getImageExtents (AccessibleImage *obj, + long int *x, + long int *y, + long int *width, + long int *height, + AccessibleCoordType ctype); +char * +AccessibleImage_getImageLocale (AccessibleImage *obj); /* * - * SpiAccessibleHyperlink function prototypes + * AccessibleMatchRule function prototypes * */ - -int -SpiAccessibleHyperlink_ref (SpiAccessibleHyperlink *obj); - -int -SpiAccessibleHyperlink_unref (SpiAccessibleHyperlink *obj); - -long -SpiAccessibleHyperlink_getNAnchors (SpiAccessibleHyperlink *obj); - -char * -SpiAccessibleHyperlink_getURI (SpiAccessibleHyperlink *obj, - long i); - -SpiAccessible -SpiAccessibleHyperlink_getObject (SpiAccessibleHyperlink *obj, - long i); - -void -SpiAccessibleHyperlink_getIndexRange (SpiAccessibleHyperlink *obj, - long *startIndex, - long *endIndex); - -boolean -SpiAccessibleHyperlink_isValid (SpiAccessibleHyperlink *obj); +void AccessibleMatchRule_ref (AccessibleMatchRule *obj); +void AccessibleMatchRule_unref (AccessibleMatchRule *obj); /* * - * SpiAccessibleHypertext function prototypes + * AccessibleRelation function prototypes * */ -int -SpiAccessibleHyperspi_text_ref (SpiAccessibleHypertext *obj); +void AccessibleRelation_ref (AccessibleRelation *obj); +void AccessibleRelation_unref (AccessibleRelation *obj); -int -SpiAccessibleHyperspi_text_unref (SpiAccessibleHypertext *obj); +AccessibleRelationType +AccessibleRelation_getRelationType (AccessibleRelation *obj); -long -SpiAccessibleHyperspi_text_getNLinks (SpiAccessibleHypertext *obj); +int +AccessibleRelation_getNTargets (AccessibleRelation *obj); -SpiAccessibleHyperlink * -SpiAccessibleHyperSpiText_getLink (SpiAccessibleHypertext *obj, - long linkIndex); +Accessible * +AccessibleRelation_getTarget (AccessibleRelation *obj, int i); -long -SpiAccessibleHyperspi_text_getLinkIndex (SpiAccessibleHypertext *obj, - long characterIndex); /* * - * SpiAccessibleImage function prototypes + * AccessibleSelection function prototypes * */ -int -SpiAccessibleImage_ref (SpiAccessibleImage *obj); - -int -SpiAccessibleImage_unref (SpiAccessibleImage *obj); - -char * -SpiAccessibleImage_getImageDescription (SpiAccessibleImage *obj); +void AccessibleSelection_ref (AccessibleSelection *obj); +void AccessibleSelection_unref (AccessibleSelection *obj); -void -SpiAccessibleImage_getImageSize (SpiAccessibleImage *obj, - long *width, - long *height); +long +AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj); -void -SpiAccessibleImage_getImagePosition (SpiAccessibleImage *obj, - long *x, - long *y, - SpiAccessibleCoordType ctype); +Accessible * +AccessibleSelection_getSelectedChild (AccessibleSelection *obj, + long int selectedChildIndex); -/* - * - * SpiAccessibleRelation function prototypes - * - */ +SPIBoolean +AccessibleSelection_selectChild (AccessibleSelection *obj, + long int childIndex); -int -SpiAccessibleRelation_ref (SpiAccessibleRelation *obj); +SPIBoolean +AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj, + long int selectedChildIndex); -int -SpiAccessibleRelation_unref (SpiAccessibleRelation *obj); +SPIBoolean +AccessibleSelection_deselectChild (AccessibleSelection *obj, + long int childIndex); -RELATION_TYPE -SpiAccessibleRelation_getRelationType (SpiAccessibleRelation *obj); +SPIBoolean +AccessibleSelection_isChildSelected (AccessibleSelection *obj, + long int childIndex); -SpiAccessible * -SpiAccessibleRelation_getTarget (SpiAccessibleRelation *obj); +SPIBoolean +AccessibleSelection_selectAll (AccessibleSelection *obj); +SPIBoolean +AccessibleSelection_clearSelection (AccessibleSelection *obj); /* * - * SpiAccessibleSelection function prototypes + * AccessibleStateSet function prototypes * */ -int -SpiAccessibleSelection_ref (SpiAccessibleSelection *obj); - -int -SpiAccessibleSelection_unref (SpiAccessibleSelection *obj); +void AccessibleStateSet_ref (AccessibleStateSet *obj); +void AccessibleStateSet_unref (AccessibleStateSet *obj); -long -SpiAccessibleSelection_getNSelectedChildren (SpiAccessibleSelection *obj); - -SpiAccessible * -SpiAccessibleSelection_getSelectedChild (SpiAccessibleSelection *obj, - long selectedChildIndex); - -boolean -SpiAccessibleSelection_selectChild (SpiAccessibleSelection *obj, - long childIndex); - -boolean -SpiAccessibleSelection_deselectSelectedChild (SpiAccessibleSelection *obj, - long selectedChildIndex); - -boolean -SpiAccessibleSelection_isChildSelected (SpiAccessibleSelection *obj, - long childIndex); +SPIBoolean +AccessibleStateSet_contains (AccessibleStateSet *obj, + AccessibleState state); void -SpiAccessibleSelection_selectAll (SpiAccessibleSelection *obj); +AccessibleStateSet_add (AccessibleStateSet *obj, + AccessibleState state); void -SpiAccessibleSelection_clearSpiSelection (SpiAccessibleSelection *obj); - - -/* - * - * SpiAccessibleStateSet function prototypes - * - */ +AccessibleStateSet_remove (AccessibleStateSet *obj, + AccessibleState state); -int -SpiAccessibleStateSet_ref (SpiAccessibleStateSet *obj); +SPIBoolean +AccessibleStateSet_equals (AccessibleStateSet *obj, + AccessibleStateSet *obj2); -int -SpiAccessibleStateSet_unref (SpiAccessibleStateSet *obj); +AccessibleStateSet * +AccessibleStateSet_compare (AccessibleStateSet *obj, + AccessibleStateSet *obj2); -boolean -SpiAccessibleStateSet_contains (SpiAccessibleStateSet *obj, - SPI_ACCESSIBLE_STATE state); +SPIBoolean +AccessibleStateSet_isEmpty (AccessibleStateSet *obj); void -SpiAccessibleStateSet_add (SpiAccessibleStateSet *obj, - SPI_ACCESSIBLE_STATE state); - +AccessibleStreamableContent_ref (AccessibleStreamableContent *obj); void -SpiAccessibleStateSet_remove (SpiAccessibleStateSet *obj, - SPI_ACCESSIBLE_STATE state); - -boolean -SpiAccessibleStateSet_equals (SpiAccessibleStateSet *obj, - SpiAccessibleStateSet *obj2); +AccessibleStreamableContent_unref (AccessibleStreamableContent *obj); +char ** +AccessibleStreamableContent_getContentTypes (AccessibleStreamableContent *obj); void -SpiAccessibleStateSet_compare (SpiAccessibleStateSet *obj, - SpiAccessibleStateSet *obj2, - SpiAccessibleStateSet **differenceSet); - -boolean -SpiAccessibleStateSet_isEmpty (SpiAccessibleStateSet *obj); +AccessibleStreamableContent_freeContentTypesList (AccessibleStreamableContent *obj, + char **content_types); +#define AccessibleStreamableContent_freeContentTypeList(a, b) AccessibleStreamableContent_freeContentTypesList(a,b) +SPIBoolean +AccessibleStreamableContent_open (AccessibleStreamableContent *obj, + const char *content_type); +SPIBoolean +AccessibleStreamableContent_close (AccessibleStreamableContent *obj); +long +AccessibleStreamableContent_seek (AccessibleStreamableContent *obj, + long int offset, + AccessibleStreamableContentSeekType seek_type); +SPIBoolean +AccessibleStreamableContent_read (AccessibleStreamableContent *obj, + void *buff, + long int nbytes, + unsigned int read_type); /* * - * SpiAccessibleTable function prototypes + * AccessibleTable function prototypes * */ -int -SpiAccessibleTable_ref (SpiAccessibleTable *obj); +void AccessibleTable_ref (AccessibleTable *obj); +void AccessibleTable_unref (AccessibleTable *obj); -int -SpiAccessibleTable_unref (SpiAccessibleTable *obj); +Accessible * +AccessibleTable_getCaption (AccessibleTable *obj); -SpiAccessible * -SpiAccessibleTable_getCaption (SpiAccessibleTable *obj); - -SpiAccessible * -SpiAccessibleTable_getSummary (SpiAccessibleTable *obj); +Accessible * +AccessibleTable_getSummary (AccessibleTable *obj); long -SpiAccessibleTable_getNRows (SpiAccessibleTable *obj); +AccessibleTable_getNRows (AccessibleTable *obj); long -SpiAccessibleTable_getNColumns (SpiAccessibleTable *obj); +AccessibleTable_getNColumns (AccessibleTable *obj); -SpiAccessible * -SpiAccessibleTable_refAt (SpiAccessibleTable *obj, - long row, - long column); +Accessible * +AccessibleTable_getAccessibleAt (AccessibleTable *obj, + long int row, + long int column); long -SpiAccessibleTable_getIndexAt (SpiAccessibleTable *obj, - long row, - long column); +AccessibleTable_getIndexAt (AccessibleTable *obj, + long int row, + long int column); long -SpiAccessibleTable_getRowAtIndex (SpiAccessibleTable *obj, - long index); +AccessibleTable_getRowAtIndex (AccessibleTable *obj, + long int index); long -SpiAccessibleTable_getColumnAtIndex (SpiAccessibleTable *obj, - long index); +AccessibleTable_getColumnAtIndex (AccessibleTable *obj, + long int index); char * -SpiAccessibleTable_getRowDescription (SpiAccessibleTable *obj, - long row); +AccessibleTable_getRowDescription (AccessibleTable *obj, + long int row); char * -SpiAccessibleTable_getColumnDescription (SpiAccessibleTable *obj, - long column); +AccessibleTable_getColumnDescription (AccessibleTable *obj, + long int column); long -SpiAccessibleTable_getRowExtentAt (SpiAccessibleTable *obj, - long row, - long column); +AccessibleTable_getRowExtentAt (AccessibleTable *obj, + long int row, + long int column); long -SpiAccessibleTable_getColumnExtentAt (SpiAccessibleTable *obj, - long row, - long column); +AccessibleTable_getColumnExtentAt (AccessibleTable *obj, + long int row, + long int column); -SpiAccessible * -SpiAccessibleTable_getRowHeader (SpiAccessibleTable *obj, - long row); +SPIBoolean +AccessibleTable_getRowColumnExtentsAtIndex (AccessibleTable *obj, + long int index, long int *row, long int *col, + long int *row_extents, long int *col_extents, + long int *is_selected); -SpiAccessible * -SpiAccessibleTable_getColumnHeader (SpiAccessibleTable *obj, - long column); +Accessible * +AccessibleTable_getRowHeader (AccessibleTable *obj, + long int row); -long -SpiAccessibleTable_getNSelectedRows (SpiAccessibleTable *obj); +Accessible * +AccessibleTable_getColumnHeader (AccessibleTable *obj, + long int column); long -SpiAccessibleTable_getSelectedRows (SpiAccessibleTable *obj, - long **selectedRows); +AccessibleTable_getNSelectedRows (AccessibleTable *obj); long -SpiAccessibleTable_getNSelectedColumns (SpiAccessibleTable *obj); +AccessibleTable_getSelectedRows (AccessibleTable *obj, + long int **selectedRows); long -SpiAccessibleTable_getSelectedColumns (SpiAccessibleTable *obj, - long **selectedColumns); - -boolean -SpiAccessibleTable_isRowSelected (SpiAccessibleTable *obj, - long row); +AccessibleTable_getNSelectedColumns (AccessibleTable *obj); -boolean -SpiAccessibleTable_isColumnSelected (SpiAccessibleTable *obj, - long column); - -boolean -SpiAccessibleTable_isSelected (SpiAccessibleTable *obj, - long row, - long column); +long +AccessibleTable_getSelectedColumns (AccessibleTable *obj, + long int **selectedColumns); + +SPIBoolean +AccessibleTable_isRowSelected (AccessibleTable *obj, + long int row); + +SPIBoolean +AccessibleTable_isColumnSelected (AccessibleTable *obj, + long int column); + +SPIBoolean +AccessibleTable_isSelected (AccessibleTable *obj, + long int row, + long int column); + +SPIBoolean +AccessibleTable_addRowSelection (AccessibleTable *obj, + long int row); +SPIBoolean +AccessibleTable_addColumnSelection (AccessibleTable *obj, + long int column); + +SPIBoolean +AccessibleTable_removeRowSelection (AccessibleTable *obj, + long int row); +SPIBoolean +AccessibleTable_removeColumnSelection (AccessibleTable *obj, + long int column); /* * - * SpiAccessibleText function prototypes + * AccessibleText function prototypes * */ -int -SpiAccessibleText_ref (SpiAccessibleText *obj); - -int -SpiAccessibleText_unref (SpiAccessibleText *obj); +void AccessibleText_ref (AccessibleText *obj); +void AccessibleText_unref (AccessibleText *obj); long -SpiAccessibleText_getCharacterCount (SpiAccessibleText *obj); +AccessibleText_getCharacterCount (AccessibleText *obj); char * -SpiAccessibleText_getText (SpiAccessibleText *obj, - long startOffset, - long endOffset); +AccessibleText_getText (AccessibleText *obj, + long int startOffset, + long int endOffset); long -SpiAccessibleText_getCaretOffset (SpiAccessibleText *obj); +AccessibleText_getCaretOffset (AccessibleText *obj); char * -SpiAccessibleText_getAttributes (SpiAccessibleText *obj, - long offset, - long *startOffset, - long *endOfset); +AccessibleText_getAttributes (AccessibleText *obj, + long int offset, + long int *startOffset, + long int *endOffset); +char * +AccessibleText_getDefaultAttributes (AccessibleText *obj); -boolean -SpiAccessibleText_setCaretOffset (SpiAccessibleText *obj, - long newOffset); +SPIBoolean +AccessibleText_setCaretOffset (AccessibleText *obj, + long int newOffset); char * -SpiAccessibleText_getTextBeforeOffset (SpiAccessibleText *obj, - long offset, - SPI_TEXT_BOUNDARY_TYPE type, - long *startOffset, long *endOffset); +AccessibleText_getTextBeforeOffset (AccessibleText *obj, + long int offset, + AccessibleTextBoundaryType type, + long int *startOffset, + long int *endOffset); char * -SpiAccessibleText_getTextAtOffset (SpiAccessibleText *obj, - long offset, - SPI_TEXT_BOUNDARY_TYPE type, - long *startOffset, long *endOffset); +AccessibleText_getTextAtOffset (AccessibleText *obj, + long int offset, + AccessibleTextBoundaryType type, + long int *startOffset, + long int *endOffset); char * -SpiAccessibleText_getTextAfterOffset (SpiAccessibleText *obj, - long offset, - SPI_TEXT_BOUNDARY_TYPE type, - long *startOffset, long *endOffset); +AccessibleText_getTextAfterOffset (AccessibleText *obj, + long int offset, + AccessibleTextBoundaryType type, + long int *startOffset, + long int *endOffset); + unsigned long -SpiAccessibleText_getCharacterAtOffset (SpiAccessibleText *obj, - long offset); +AccessibleText_getCharacterAtOffset (AccessibleText *obj, + long int offset); + +void +AccessibleText_getCharacterExtents (AccessibleText *obj, + long int offset, + long int *x, + long int *y, + long int *width, + long int *height, + AccessibleCoordType type); void -SpiAccessibleText_getCharacterExtents (SpiAccessibleText *obj, - long offset, - long *x, - long *y, - long *width, - long *height, SpiAccessibleCoordType type); +AccessibleText_getRangeExtents (AccessibleText *obj, + long int startOffset, + long int endOffset, + long int *x, + long int *y, + long int *width, + long int *height, + AccessibleCoordType type); + +AccessibleTextRange ** +AccessibleText_getBoundedRanges (AccessibleText *obj, + long int x, + long int y, + long int width, + long int height, + AccessibleCoordType type, + AccessibleTextClipType clipTypeX, + AccessibleTextClipType clipTypeY); + +void +AccessibleTextRange_freeRanges (AccessibleTextRange **ranges); long -SpiAccessibleText_getOffsetAtPoint (SpiAccessibleText *obj, - long x, - long y, SpiAccessibleCoordType type); +AccessibleText_getOffsetAtPoint (AccessibleText *obj, + long int x, + long int y, + AccessibleCoordType type); long -SpiAccessibleText_getNSpiSelections (SpiAccessibleText *obj); +AccessibleText_getNSelections (AccessibleText *obj); void -SpiAccessibleText_getSelection (SpiAccessibleText *obj, - long selectionNum, long *startOffset, - long *endOffset); +AccessibleText_getSelection (AccessibleText *obj, + long int selectionNum, + long int *startOffset, + long int *endOffset); + + +SPIBoolean +AccessibleText_addSelection (AccessibleText *obj, + long int startOffset, + long int endOffset); + +SPIBoolean +AccessibleText_removeSelection (AccessibleText *obj, + long int selectionNum); + +SPIBoolean +AccessibleText_setSelection (AccessibleText *obj, + long int selectionNum, + long int startOffset, + long int endOffset); +AccessibleAttributeSet * +AccessibleText_getAttributeRun (AccessibleText *obj, + long int offset, + long int *startOffset, + long int *endOffset, + long int includeDefaults); +AccessibleAttributeSet * +AccessibleText_getDefaultAttributeSet (AccessibleText *obj); + +/* AccessibleValue Function Prototypes: */ + +void AccessibleValue_ref (AccessibleValue *obj); +void AccessibleValue_unref (AccessibleValue *obj); +double AccessibleValue_getMinimumValue (AccessibleValue *obj); +double AccessibleValue_getCurrentValue (AccessibleValue *obj); +double AccessibleValue_getMaximumValue (AccessibleValue *obj); +SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj, + double newValue); +double AccessibleValue_getMinimumIncrement (AccessibleValue *obj); + +/* Persistance and lifecycle control for AccessibleEvents. */ +SPIBoolean AccessibleEvent_ref (const AccessibleEvent *e); +void AccessibleEvent_unref (const AccessibleEvent *e); + +/* + * Prototypes for accessor functions, to obtain context + * information for accessible events. + */ +char* AccessibleEvent_getSourceName (const AccessibleEvent *e); +AccessibleRole AccessibleEvent_getSourceRole (const AccessibleEvent *e); +AccessibleApplication* AccessibleEvent_getSourceApplication (const AccessibleEvent *e); +SPIBoolean AccessibleEvent_getSourceDetails (const AccessibleEvent *e, char **name, + AccessibleRole *role, + AccessibleApplication **app); -boolean -SpiAccessibleText_addSpiSelection (SpiAccessibleText *obj, - long startOffset, long endOffset); +char* AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e); +Accessible * AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e); -boolean -SpiAccessibleText_removeSelection (SpiAccessibleText *obj, - long selectionNum); +Accessible * AccessibleParentChangedEvent_getParentAccessible (const AccessibleEvent *e); -boolean -SpiAccessibleText_setSelection (SpiAccessibleText *obj, - long selectionNum, - long startOffset, - long endOffset); +char* AccessibleTextSelectionChangedEvent_getSelectionString (const AccessibleEvent *e); -/* - * - * SpiAccessibleValue Function Prototypes: - * - */ +char* AccessibleWindowEvent_getTitleString (const AccessibleEvent *e); -float -SpiAccessibleValue_getMinimumSpiValue (SpiAccessibleValue *value); +Accessible * AccessibleActiveDescendantChangedEvent_getActiveDescendant (const AccessibleEvent *e); -float -SpiAccessibleValue_getCurrentValue (SpiAccessibleValue *value); +Accessible * AccessibleTableSummaryChangedEvent_getSummaryAccessible (const AccessibleEvent *e); -float -SpiAccessibleValue_getMaximumSpiValue (SpiAccessibleValue *value); +Accessible * AccessibleTableHeaderChangedEvent_getHeaderAccessible (const AccessibleEvent *e); -boolean -SpiAccessibleValue_setCurrentValue (SpiAccessibleValue *value, - float newSpiValue); +char * AccessibleTableCaptionChangedEvent_getCaptionString (const AccessibleEvent *e); -void -spi_freeString (char *s); +char * AccessibleTableRowDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e); + +char * AccessibleTableColumnDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e); + +char * AccessibleDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e); + +char * AccessibleNameChangedEvent_getNameString (const AccessibleEvent *e); +SPIRect * AccessibleBoundsChangedEvent_getNewBounds (const AccessibleEvent *e); + +/* Misc methods and error handling */ +void SPI_freeString (char *s); + +char* SPI_dupString (char *s); + +void SPI_freeRect (SPIRect *r); + +SPIBoolean SPI_exceptionHandlerPush (SPIExceptionHandler *handler); + +SPIExceptionHandler* SPI_exceptionHandlerPop (void); + +SPIExceptionType SPIException_getSourceType (SPIException *err); + +SPIExceptionCode SPIException_getExceptionCode (SPIException *err); + +Accessible* SPIAccessibleException_getSource (SPIException *err); + +char* SPIException_getDescription (SPIException *err); + +#ifdef __cplusplus +} +#endif #endif