X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=cspi%2Fspi.h;h=de73082f6b928b306b8c635347434f6d3b30c627;hb=66c4375c7cd9a0a01e79f562e1bb0326fc4dcd21;hp=7fd1ec0d4869ec5370f4f971e8aa398219d87151;hpb=fa9134cfafbbbb69a4aaa5ea280cd507c8e510ba;p=platform%2Fcore%2Fuifw%2Fat-spi2-atk.git diff --git a/cspi/spi.h b/cspi/spi.h index 7fd1ec0..de73082 100644 --- a/cspi/spi.h +++ b/cspi/spi.h @@ -2,9 +2,14 @@ #ifndef _SPI_H #define _SPI_H +/* Implementation private definitions */ #include "spi-impl.h" -/* definitions for ACCESSIBLE_STATE */ +/* + * Definitions for SPI_ACCESSIBLE_STATE , SPI_ACCESSIBLE_ROLE, SpiAccessibleEvent, + * and event listeners. + */ + #include "spi-roletypes.h" #include "spi-statetypes.h" #include "spi-listener.h" @@ -17,16 +22,16 @@ typedef enum { - TEXT_BOUNDARY_CHAR, - TEXT_BOUNDARY_CURSOR_POS, - TEXT_BOUNDARY_WORD_START, - TEXT_BOUNDARY_WORD_END, - TEXT_BOUNDARY_SENTENCE_START, - TEXT_BOUNDARY_SENTENCE_END, - TEXT_BOUNDARY_LINE_START, - TEXT_BOUNDARY_LINE_END, - TEXT_BOUNDARY_ATTRIBUTE_RANGE -} TEXT_BOUNDARY_TYPE; + SPI_TEXT_BOUNDARY_CHAR, + SPI_TEXT_BOUNDARY_CURSOR_POS, + SPI_TEXT_BOUNDARY_WORD_START, + SPI_TEXT_BOUNDARY_WORD_END, + SPI_TEXT_BOUNDARY_SENTENCE_START, + SPI_TEXT_BOUNDARY_SENTENCE_END, + SPI_TEXT_BOUNDARY_LINE_START, + SPI_TEXT_BOUNDARY_LINE_END, + SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE +} SPI_TEXT_BOUNDARY_TYPE; @@ -46,12 +51,48 @@ typedef enum } RELATION_TYPE; - +/* don't change the order of these ! */ typedef enum _AccessibleCoordType { - COORD_TYPE_WINDOW, - COORD_TYPE_SCREEN -} AccessibleCoordType; + 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 _KeyListenerSyncType { + KEYSPI_LISTENER_SYNCHRONOUS = 1, + KEYSPI_LISTENER_CANCONSUME = 2, + KEYSPI_LISTENER_ALLWINDOWS = 4 +} KeyListenerSyncType; + +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) /* * @@ -59,35 +100,150 @@ typedef enum _AccessibleCoordType { * */ +/** + * SPI_init: + * + * Connects to the accessibility registry and initializes the SPI. + * + * Returns: 0 on success, otherwise an integer error code. + **/ 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); +/** + * 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. + * + **/ boolean SPI_eventIsReady (); -AccessibleEvent * +/** + * 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 #AccessibleEvent in the SPI event queue. + * + **/ +SpiAccessibleEvent * SPI_nextEvent (boolean waitForEvent); +/** + * SPI_exit: + * + * Disconnects from the Accessibility SpiRegistry and releases resources. + * Not Yet Implemented. + * + **/ void SPI_exit (void); /* - * Event Listener creation and support. + * Event SpiListener creation and support. */ -AccessibleEventListener * -createEventListener (AccessibleEventListenerCB callback); +/** + * createEventListener: + * @callback : an #AccessibleEventListenerCB callback function, or NULL. + * + * Create a new #AccessibleEventListener with a specified callback function. + * + * Returns: a pointer to a newly-created #AccessibleEventListener. + * + **/ +SpiAccessibleEventListener * +createEventListener (SpiAccessibleEventListenerCB callback); + +/** + * EventListener_addCallback: + * @listener: the #AccessibleEventListener instance to modify. + * @callback: an #AccessibleEventListenerCB function pointer. + * + * Add an in-process callback function to an existing SpiAccessibleEventListener. + * + * Returns: #TRUE if successful, otherwise #FALSE. + * + **/ +boolean +EventListener_addCallback (SpiAccessibleEventListener *listener, + SpiAccessibleEventListenerCB callback); + +/** + * EventListener_removeCallback: + * @listener: the #AccessibleEventListener instance to modify. + * @callback: an #AccessibleEventListenerCB 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); +/** + * createKeyListener: + * @callback : an #KeystrokeListenerCB callback function, or NULL. + * + * Create a new #KeystrokeListener with a specified callback function. + * + * Returns: a pointer to a newly-created #KeystrokeListener. + * + **/ +KeystrokeListener * +createKeystrokeListener (KeystrokeListenerCB callback); + +/** + * 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. + * + **/ boolean -EventListener_addCallback (AccessibleEventListener *listener, - AccessibleEventListenerCB callback); +KeystrokeListener_addCallback (KeystrokeListener *listener, + KeystrokeListenerCB callback); +/** + * KeystrokeListener_removeCallback: + * @listener: the #KeystrokeListener instance to modify. + * @callback: an #KeystrokeListenerCB function pointer. + * + * Remove an in-process callback function from an existing #KeystrokeListener. + * + * Returns: #TRUE if successful, otherwise #FALSE. + * + **/ boolean -EventListener_removeCallback (AccessibleEventListener *listener, - AccessibleEventListenerCB callback); +KeystrokeListener_removeCallback (KeystrokeListener *listener, + KeystrokeListenerCB callback); /* * @@ -95,582 +251,1077 @@ EventListener_removeCallback (AccessibleEventListener *listener, * */ +/** + * registerGlobalEventListener: + * @listener: the #AccessibleEventListener 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. + * + **/ boolean -RegisterGlobalEventListener (AccessibleEventListener *listener, +registerGlobalEventListener (SpiAccessibleEventListener *listener, char *eventType); +/** + * 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. + * + **/ int -GetDesktopCount (); +getDesktopCount (); -Accessible -*getDesktop (int n); +/** + * 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 #Accessible representation. + * + **/ +SpiAccessible* +getDesktop (int n); +/** + * getDesktopList: + * @list: a pointer to an array of #Accessible 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. + **/ int -getDesktopList (Accessible **list); +getDesktopList (SpiAccessible **list); +/** + * registerKeystrokeListener: + * @listener: a pointer to the #KeystrokeListener for which + * keystroke events are requested. + * + * Not Yet Implemented. + * + **/ void -registerKeystrokeListener (KeystrokeListener *listener); - +registerKeystrokeListener (KeystrokeListener *listener, + KeySet *keys, + KeyMaskType modmask, + KeyEventMask eventmask, + KeyListenerSyncType 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). + * + **/ void -generateKeyEvent (long keyCode, long meta); - +generateKeyEvent (long keyCode, KeySynthType synth_type); + +/** + * 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. + * + **/ void generateMouseEvent (long x, long y, char *name); /* * - * Accessible function prototypes + * SpiAccessible function prototypes * */ +/** + * SpiAccessible_ref: + * @obj: a pointer to the #Accessible object on which to operate. + * + * Increment the reference count for an #Accessible object. + * + * Returns: (no return code implemented yet). + * + **/ int -Accessible_ref (Accessible *obj); +SpiAccessible_ref (SpiAccessible *obj); +/** + * SpiAccessible_unref: + * @obj: a pointer to the #Accessible object on which to operate. + * + * Decrement the reference count for an #Accessible object. + * + * Returns: (no return code implemented yet). + * + **/ int -Accessible_unref (Accessible *obj); +SpiAccessible_unref (SpiAccessible *obj); +/** + * SpiAccessible_getName: + * @obj: a pointer to the #Accessible object on which to operate. + * + * Get the name of an #Accessible object. + * + * Returns: a UTF-8 string indicating the name of the #Accessible object. + * + **/ char * -Accessible_getName (Accessible *obj); +SpiAccessible_getName (SpiAccessible *obj); +/** + * SpiAccessible_getDescription: + * @obj: a pointer to the #Accessible object on which to operate. + * + * Get the description of an #Accessible object. + * + * Returns: a UTF-8 string describing the #Accessible object. + * + **/ char * -Accessible_getDescription (Accessible *obj); +SpiAccessible_getDescription (SpiAccessible *obj); -Accessible * -Accessible_getParent (Accessible *obj); +/** + * SpiAccessible_getParent: + * @obj: a pointer to the #Accessible object to query. + * + * Get an #Accessible object's parent container. + * + * Returns: a pointer to the #Accessible object which contains the given + * #Accessible instance, or NULL if the @obj has no parent container. + * + **/ +SpiAccessible * +SpiAccessible_getParent (SpiAccessible *obj); +/** + * SpiAccessible_getChildCount: + * + * @obj: a pointer to the #Accessible object on which to operate. + * + * Get the number of children contained by an #Accessible object. + * + * Returns: a #long indicating the number of #Accessible children + * contained by an #Accessible object. + * + **/ long -Accessible_getChildCount (Accessible *obj); +SpiAccessible_getChildCount (SpiAccessible *obj); -Accessible * -Accessible_getChildAtIndex (Accessible *obj, +/** + * SpiAccessible_getChildAtIndex: + * + * @obj: a pointer to the #Accessible object on which to operate. + * @childIndex: a #long indicating which child is specified. + * + * Get the #Accessible child of an #Accessible object at a given index. + * + * Returns: a pointer to the #Accessible child object at index + * @childIndex. + * + **/ +SpiAccessible * +SpiAccessible_getChildAtIndex (SpiAccessible *obj, long childIndex); +/** + * SpiAccessible_getIndexInParent: + * + * @obj: a pointer to the #Accessible object on which to operate. + * + * Get the index of an #Accessible object in its containing #Accessible. + * + * Returns: a #long indicating the index of the #Accessible object + * in its parent (i.e. containing) #Accessible instance, + * or -1 if @obj has no containing parent. + * + **/ long -Accessible_getIndexInParent (Accessible *obj); +SpiAccessible_getIndexInParent (SpiAccessible *obj); -AccessibleRelation ** -Accessible_getRelationSet (Accessible *obj); +/** + * SpiAccessible_getRelationSet: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleRelation ** +SpiAccessible_getRelationSet (SpiAccessible *obj); +/** + * SpiAccessible_getRole: + * @obj: a pointer to the #Accessible object on which to operate. + * + * Get the UI role of an #Accessible object. + * + * Returns: a UTF-8 string indicating the UI role of the #Accessible object. + * + **/ char * -Accessible_getRole (Accessible *obj); +SpiAccessible_getRole (SpiAccessible *obj); -AccessibleStateSet * -Accessible_getStateSet (Accessible *obj); +/** + * SpiAccessible_getStateSet: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleStateSet * +SpiAccessible_getStateSet (SpiAccessible *obj); + +/* Interface query methods */ +/** + * SpiAccessible_isAction: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements #AccessibleAction. + * Not Yet Implemented. + * + * Returns: #TRUE if @obj implements the #AccessibleAction interface, + * #FALSE otherwise. + **/ +boolean +SpiAccessible_isAction (SpiAccessible *obj); + +/** + * SpiAccessible_isComponent: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements #AccessibleComponent. + * + * Returns: #TRUE if @obj implements the #AccessibleComponent interface, + * #FALSE otherwise. + **/ +boolean +SpiAccessible_isComponent (SpiAccessible *obj); + +/** + * SpiAccessible_isEditableText: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements #AccessibleEditableText. + * Not Yet Implemented. + * + * Returns: #TRUE if @obj implements the #AccessibleEditableText interface, + * #FALSE otherwise. + **/ +boolean +SpiAccessible_isEditableText (SpiAccessible *obj); + +/** + * SpiAccessible_isHypertext: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements #AccessibleHypertext. + * Not Yet Implemented. + * + * Returns: #TRUE if @obj implements the #AccessibleHypertext interface, + * #FALSE otherwise. + **/ +boolean +SpiAccessible_isHypertext (SpiAccessible *obj); + +/** + * SpiAccessible_isImage: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements #AccessibleImage. + * Not Yet Implemented. + * + * Returns: #TRUE if @obj implements the #AccessibleImage interface, + * #FALSE otherwise. +**/ +boolean +SpiAccessible_isImage (SpiAccessible *obj); + +/** + * SpiAccessible_isSelection: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements #AccessibleSelection. + * Not Yet Implemented. + * + * Returns: #TRUE if @obj implements the #AccessibleSelection interface, + * #FALSE otherwise. +**/ +boolean +SpiAccessible_isSelection (SpiAccessible *obj); + +/** + * SpiAccessible_isTable: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements #AccessibleTable. + * Not Yet Implemented. + * + * Returns: #TRUE if @obj implements the #AccessibleTable interface, + * #FALSE otherwise. +**/ +boolean +SpiAccessible_isTable (SpiAccessible *obj); + +/** + * SpiAccessible_isText: + * @obj: a pointer to the #Accessible instance to query. + * + * Query whether the specified #Accessible implements #AccessibleText. + * Not Yet Implemented. + * + * Returns: #TRUE if @obj implements the #AccessibleText interface, + * #FALSE otherwise. +**/ +boolean +SpiAccessible_isText (SpiAccessible *obj); + +/** + * SpiAccessible_getAction: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleAction * +SpiAccessible_getAction (SpiAccessible *obj); + +/** + * SpiAccessible_getComponent: + * @obj: a pointer to the #Accessible instance to query. + * + * Get the #AccessibleComponent interface for an #Accessible. + * + * Returns: a pointer to an #AccessibleComponent interface instance, or + * NULL if @obj does not implement #AccessibleComponent. + **/ +SpiAccessibleComponent * +SpiAccessible_getComponent (SpiAccessible *obj); + +/** + * SpiAccessible_getEditableText: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleEditableText * +SpiAccessible_getEditableText (SpiAccessible *obj); + +/** + * SpiAccessible_getHypertext: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleHypertext * +SpiAccessible_getHypertext (SpiAccessible *obj); + +/** + * SpiAccessible_getImage: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleImage * +SpiAccessible_getImage (SpiAccessible *obj); + +/** + * SpiAccessible_getSelection: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleSelection * +SpiAccessible_getSelection (SpiAccessible *obj); + +/** + * SpiAccessible_getTable: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleTable * +SpiAccessible_getTable (SpiAccessible *obj); + +/** + * SpiAccessible_getText: + * + * Not Yet Implemented. + * + **/ +SpiAccessibleText * +SpiAccessible_getText (SpiAccessible *obj); + +/** + * SpiAccessible_queryInterface: + * @obj: a pointer to the #Accessible instance to query. + * @interface_name: a UTF-8 character string specifiying the requested interface. + * + * Query an #Accessible 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); /* * - * AccessibleAction function prototypes + * SpiAccessibleAction function prototypes * */ int -AccessibleAction_ref ( - AccessibleAction *obj); +SpiAccessibleAction_ref ( + SpiAccessibleAction *obj); int -AccessibleAction_unref (AccessibleAction *obj); +SpiAccessibleAction_unref (SpiAccessibleAction *obj); long -AccessibleAction_getNActions (AccessibleAction *obj); +SpiAccessibleAction_getNActions (SpiAccessibleAction *obj); +/** + * SpiAccessibleAction_getDescription: + * @obj: a pointer to the #AccessibleAction to query. + * + * Get the description of 'i-th' action invokable on an + * object implementing #AccessibleAction. + * + * Not Yet Implemented. + * + * Returns: a UTF-8 string describing the 'i-th' invokable action. + * + **/ char * -AccessibleAction_getDescription (AccessibleAction *obj, +SpiAccessibleAction_getDescription (SpiAccessibleAction *obj, long index); -void -AccessibleAction_doAction (AccessibleAction *obj, +boolean +SpiAccessibleAction_doAction (SpiAccessibleAction *obj, long index); char * -AccessibleAction_getKeyBinding (AccessibleAction *obj, +SpiAccessibleAction_getKeyBinding (SpiAccessibleAction *obj, long index); /* * - * AccessibleApplication function prototypes + * SpiAccessibleApplication function prototypes * */ +/** + * SpiAccessibleApplication_unref: + * @obj: a pointer to the #AccessibleApplication on which to operate. + * + * Decrement the reference count for an #AccessibleApplication. + * + * Returns: (no return code implemented yet). + * + **/ int -AccessibleApplication_ref (AccessibleApplication *obj); +SpiAccessibleApplication_ref (SpiAccessibleApplication *obj); +/** + * SpiAccessibleApplication_unref: + * @obj: a pointer to the #AccessibleApplication object on which to operate. + * + * Decrement the reference count for an #AccessibleApplication. + * + * Returns: (no return code implemented yet). + * + **/ int -AccessibleApplication_unref (AccessibleApplication *obj); +SpiAccessibleApplication_unref (SpiAccessibleApplication *obj); +/** + * SpiAccessibleApplication_getToolkitName: + * @obj: a pointer to the #AccessibleApplication to query. + * + * Get the name of the UI toolkit used by an #AccessibleApplication. + * + * Returns: a UTF-8 string indicating which UI toolkit is + * used by an application. + * + **/ char * -AccessibleApplication_getToolkitName (AccessibleApplication *obj); +SpiAccessibleApplication_getToolkitName (SpiAccessibleApplication *obj); +/** + * SpiAccessibleApplication_getVersion: + * @obj: a pointer to the #AccessibleApplication being queried. + * + * Get the version of the at-spi bridge exported by an + * #AccessibleApplication instance. + * + * Returns: a UTF-8 string indicating the application's + * at-spi version. + * + **/ char * -AccessibleApplication_getVersion (AccessibleApplication *obj); +SpiAccessibleApplication_getVersion (SpiAccessibleApplication *obj); +/** + * SpiAccessibleApplication_getID: + * @obj: a pointer to the #AccessibleApplication being queried. + * + * Get the unique ID assigned by the SpiRegistry to an + * #AccessibleApplication 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 -AccessibleApplication_getID (AccessibleApplication *obj); +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 -AccessibleApplication_pause (AccessibleApplication *obj); +SpiAccessibleApplication_pause (SpiAccessibleApplication *obj); +/** + * SpiAccessibleApplication_pause: + * + * Attempt to resume the application (used after #AccessibleApplication_pause). + * Not Yet Implemented. + * + * Returns: #TRUE if application processing resumed successfully, #FALSE otherwise. + * + **/ boolean -AccessibleApplication_resume (AccessibleApplication *obj); +SpiAccessibleApplication_resume (SpiAccessibleApplication *obj); /* * - * AccessibleComponent function prototypes + * SpiAccessibleComponent function prototypes * */ int -AccessibleComponent_ref (AccessibleComponent *obj); +SpiAccessibleComponent_ref (SpiAccessibleComponent *obj); int -AccessibleComponent_unref (AccessibleComponent *obj); +SpiAccessibleComponent_unref (SpiAccessibleComponent *obj); boolean -AccessibleComponent_contains (AccessibleComponent *obj, +SpiAccessibleComponent_contains (SpiAccessibleComponent *obj, long x, long y, - AccessibleCoordType ctype); + SpiAccessibleCoordType ctype); -Accessible * -AccessibleComponent_getAccessibleAtPoint (AccessibleComponent *obj, +SpiAccessible * +SpiAccessibleComponent_getAccessibleAtPoint (SpiAccessibleComponent *obj, long x, long y, - AccessibleCoordType ctype); - + SpiAccessibleCoordType ctype); + +/** + * SpiAccessibleComponent_getExtents: + * @obj: a pointer to the #AccessibleComponent 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 #AccessibleComponent. + * + **/ void -AccessibleComponent_getExtents (AccessibleComponent *obj, +SpiAccessibleComponent_getExtents (SpiAccessibleComponent *obj, long *x, long *y, long *width, long *height, - AccessibleCoordType ctype); + SpiAccessibleCoordType ctype); void -AccessibleComponent_getPosition (AccessibleComponent *obj, +SpiAccessibleComponent_getPosition (SpiAccessibleComponent *obj, long *x, long *y, - AccessibleCoordType ctype); + SpiAccessibleCoordType ctype); void -AccessibleComponent_getSize (AccessibleComponent *obj, +SpiAccessibleComponent_getSize (SpiAccessibleComponent *obj, long *width, long *height); void -AccessibleComponent_grabFocus (AccessibleComponent *obj); +SpiAccessibleComponent_grabFocus (SpiAccessibleComponent *obj); /* * - * AccessibleEditableText function prototypes + * SpiAccessibleEditableText function prototypes * */ int -AccessibleEditableText_ref (AccessibleEditableText *obj); +SpiAccessibleEditableText_ref (SpiAccessibleEditableText *obj); int -AccessibleEditableText_unref (AccessibleEditableText *obj); +SpiAccessibleEditableText_unref (SpiAccessibleEditableText *obj); + +boolean +SpiAccessibleEditableText_setRunAttributes (SpiAccessibleEditableText *obj, + const char *attributes, + long startPos, long endPos); void -AccessibleEditableText_setTextContents (AccessibleEditableText *obj, - char *newContents); +SpiAccessibleEditableText_setTextContents (SpiAccessibleEditableText *obj, + const char *newContents); void -AccessibleEditableText_insertText (AccessibleEditableText *obj, +SpiAccessibleEditableText_insertText (SpiAccessibleEditableText *obj, long position, char *text, long length); -boolean -AccessibleEditableText_selectText (AccessibleEditableText *obj, - long startPos, - long endPos); - -boolean -AccessibleEditableText_setAttributes (AccessibleEditableText *obj, - long startPos, - long endPos, - char *attributes); - void -AccessibleEditableText_copyText (AccessibleText *obj, +SpiAccessibleEditableText_copyText (SpiAccessibleText *obj, long startPos, long endPos); void -AccessibleEditableText_cutText (AccessibleEditableText *obj, +SpiAccessibleEditableText_cutText (SpiAccessibleEditableText *obj, long startPos, long endPos); void -AccessibleEditableText_deleteText (AccessibleEditableText *obj, +SpiAccessibleEditableText_deleteText (SpiAccessibleEditableText *obj, long startPos, long endPos); void -AccessibleEditableText_pasteText (AccessibleEditableText *obj, +SpiAccessibleEditableText_pasteText (SpiAccessibleEditableText *obj, long position); /* * - * AccessibleHyperlink function prototypes + * SpiAccessibleHyperlink function prototypes * */ int -AccessibleHyperlink_ref (AccessibleHyperlink *obj); +SpiAccessibleHyperlink_ref (SpiAccessibleHyperlink *obj); int -AccessibleHyperlink_unref (AccessibleHyperlink *obj); +SpiAccessibleHyperlink_unref (SpiAccessibleHyperlink *obj); long -AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj); +SpiAccessibleHyperlink_getNAnchors (SpiAccessibleHyperlink *obj); char * -AccessibleHyperlink_getURI (AccessibleHyperlink *obj, +SpiAccessibleHyperlink_getURI (SpiAccessibleHyperlink *obj, long i); -Accessible -AccessibleHyperlink_getAnchor (AccessibleHyperlink *obj, +SpiAccessible +SpiAccessibleHyperlink_getObject (SpiAccessibleHyperlink *obj, long i); void -AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj, +SpiAccessibleHyperlink_getIndexRange (SpiAccessibleHyperlink *obj, long *startIndex, long *endIndex); boolean -AccessibleHyperlink_isValid (AccessibleHyperlink *obj); +SpiAccessibleHyperlink_isValid (SpiAccessibleHyperlink *obj); /* * - * AccessibleHypertext function prototypes + * SpiAccessibleHypertext function prototypes * */ int -AccessibleHypertext_ref (AccessibleHypertext *obj); +SpiAccessibleHypertext_ref (SpiAccessibleHypertext *obj); int -AccessibleHypertext_unref (AccessibleHypertext *obj); +SpiAccessibleHypertext_unref (SpiAccessibleHypertext *obj); long -AccessibleHypertext_getNLinks (AccessibleHypertext *obj); +SpiAccessibleHypertext_getNLinks (SpiAccessibleHypertext *obj); -AccessibleHyperlink * -AccessibleHyperText_getLink (AccessibleHypertext *obj, +SpiAccessibleHyperlink * +SpiAccessibleHyperText_getLink (SpiAccessibleHypertext *obj, long linkIndex); long -AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj, +SpiAccessibleHypertext_getLinkIndex (SpiAccessibleHypertext *obj, long characterIndex); /* * - * AccessibleImage function prototypes + * SpiAccessibleImage function prototypes * */ int -AccessibleImage_ref (AccessibleImage *obj); +SpiAccessibleImage_ref (SpiAccessibleImage *obj); int -AccessibleImage_unref (AccessibleImage *obj); +SpiAccessibleImage_unref (SpiAccessibleImage *obj); char * -AccessibleImage_getImageDescription (AccessibleImage *obj); +SpiAccessibleImage_getImageDescription (SpiAccessibleImage *obj); void -AccessibleImage_getImageSize (AccessibleImage *obj, +SpiAccessibleImage_getImageSize (SpiAccessibleImage *obj, long *width, - long *height, - AccessibleCoordType ctype); + long *height); + void -AccessibleImage_getImagePosition (AccessibleImage *obj, +SpiAccessibleImage_getImagePosition (SpiAccessibleImage *obj, long *x, long *y, - AccessibleCoordType ctype); + SpiAccessibleCoordType ctype); /* * - * AccessibleRelation function prototypes + * SpiAccessibleRelation function prototypes * */ int -AccessibleRelation_ref (AccessibleRelation *obj); +SpiAccessibleRelation_ref (SpiAccessibleRelation *obj); int -AccessibleRelation_unref (AccessibleRelation *obj); +SpiAccessibleRelation_unref (SpiAccessibleRelation *obj); RELATION_TYPE -AccessibleRelation_getRelationType (AccessibleRelation *obj); +SpiAccessibleRelation_getRelationType (SpiAccessibleRelation *obj); -Accessible * -AccessibleRelation_getTarget (AccessibleRelation *obj); +SpiAccessible * +SpiAccessibleRelation_getTarget (SpiAccessibleRelation *obj); /* * - * AccessibleSelection function prototypes + * SpiAccessibleSelection function prototypes * */ int -AccessibleSelection_ref (AccessibleSelection *obj); +SpiAccessibleSelection_ref (SpiAccessibleSelection *obj); int -AccessibleSelection_unref (AccessibleSelection *obj); +SpiAccessibleSelection_unref (SpiAccessibleSelection *obj); long -AccessibleSelwection_getNSelectedChildren (AccessibleSelection *obj); +SpiAccessibleSelection_getNSelectedChildren (SpiAccessibleSelection *obj); -Accessible * -AccessibleSelection_getSelectedChild (AccessibleSelection *obj, +SpiAccessible * +SpiAccessibleSelection_getSelectedChild (SpiAccessibleSelection *obj, long selectedChildIndex); boolean -AccessibleSelection_selectChild (AccessibleSelection *obj, +SpiAccessibleSelection_selectChild (SpiAccessibleSelection *obj, long childIndex); boolean -AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj, +SpiAccessibleSelection_deselectSelectedChild (SpiAccessibleSelection *obj, long selectedChildIndex); boolean -AccessibleSelection_isChildSelected (AccessibleSelection *obj, +SpiAccessibleSelection_isChildSelected (SpiAccessibleSelection *obj, long childIndex); void -AccessibleSelection_selectAll (AccessibleSelection *obj); +SpiAccessibleSelection_selectAll (SpiAccessibleSelection *obj); void -AccessibleSelection_clearSelection (AccessibleSelection *obj); +SpiAccessibleSelection_clearSelection (SpiAccessibleSelection *obj); /* * - * AccessibleStateSet function prototypes + * SpiAccessibleStateSet function prototypes * */ int -AccessibleStateSet_ref (AccessibleStateSet *obj); +SpiAccessibleStateSet_ref (SpiAccessibleStateSet *obj); int -AccessibleStateSet_unref (AccessibleStateSet *obj); +SpiAccessibleStateSet_unref (SpiAccessibleStateSet *obj); boolean -AccessibleStateSet_contains (AccessibleStateSet *obj, - ACCESSIBLE_STATE state); +SpiAccessibleStateSet_contains (SpiAccessibleStateSet *obj, + SPI_ACCESSIBLE_STATE state); void -AccessibleStateSet_add (AccessibleStateSet *obj, - ACCESSIBLE_STATE state); +SpiAccessibleStateSet_add (SpiAccessibleStateSet *obj, + SPI_ACCESSIBLE_STATE state); void -AccessibleStateSet_remove (AccessibleStateSet *obj, - ACCESSIBLE_STATE state); +SpiAccessibleStateSet_remove (SpiAccessibleStateSet *obj, + SPI_ACCESSIBLE_STATE state); boolean -AccessibleStateSet_equals (AccessibleStateSet *obj, - AccessibleStateSet *obj2); +SpiAccessibleStateSet_equals (SpiAccessibleStateSet *obj, + SpiAccessibleStateSet *obj2); void -AccessibleStateSet_compare (AccessibleStateSet *obj, - AccessibleStateSet *obj2, - AccessibleStateSet **differenceSet); +SpiAccessibleStateSet_compare (SpiAccessibleStateSet *obj, + SpiAccessibleStateSet *obj2, + SpiAccessibleStateSet **differenceSet); boolean -AccessibleStateSet_isEmpty (AccessibleStateSet *obj); +SpiAccessibleStateSet_isEmpty (SpiAccessibleStateSet *obj); /* * - * AccessibleTable function prototypes + * SpiAccessibleTable function prototypes * */ int -AccessibleTable_ref (AccessibleTable *obj); +SpiAccessibleTable_ref (SpiAccessibleTable *obj); int -AccessibleTable_unref (AccessibleTable *obj); +SpiAccessibleTable_unref (SpiAccessibleTable *obj); -Accessible * -AccessibleTable_getCaption (AccessibleTable *obj); +SpiAccessible * +SpiAccessibleTable_getCaption (SpiAccessibleTable *obj); -Accessible * -AccessibleTable_getSummary (AccessibleTable *obj); +SpiAccessible * +SpiAccessibleTable_getSummary (SpiAccessibleTable *obj); long -AccessibleTable_getNRows (AccessibleTable *obj); +SpiAccessibleTable_getNRows (SpiAccessibleTable *obj); long -AccessibleTable_getNColumns (AccessibleTable *obj); +SpiAccessibleTable_getNColumns (SpiAccessibleTable *obj); -Accessible * -AccessibleTable_getAccessibleAt (AccessibleTable *obj, +SpiAccessible * +SpiAccessibleTable_refAt (SpiAccessibleTable *obj, long row, long column); long -AccessibleTable_getIndexAt (AccessibleTable *obj, +SpiAccessibleTable_getIndexAt (SpiAccessibleTable *obj, long row, long column); long -AccessibleTable_getRowAtIndex (AccessibleTable *obj, +SpiAccessibleTable_getRowAtIndex (SpiAccessibleTable *obj, long index); long -AccessibleTable_getColumnAtIndex (AccessibleTable *obj, +SpiAccessibleTable_getColumnAtIndex (SpiAccessibleTable *obj, long index); char * -AccessibleTable_getRowDescription (AccessibleTable *obj); +SpiAccessibleTable_getRowDescription (SpiAccessibleTable *obj, + long row); char * -AccessibleTable_getColumnDescription (AccessibleTable *obj); +SpiAccessibleTable_getColumnDescription (SpiAccessibleTable *obj, + long column); long -AccessibleTable_getRowExtentAt (AccessibleTable *obj, +SpiAccessibleTable_getRowExtentAt (SpiAccessibleTable *obj, long row, long column); long -AccessibleTable_getColumnExtentAt (AccessibleTable *obj, +SpiAccessibleTable_getColumnExtentAt (SpiAccessibleTable *obj, long row, long column); -AccessibleTable * -AccessibleTable_getRowHeaders (AccessibleTable *obj); +SpiAccessible * +SpiAccessibleTable_getRowHeader (SpiAccessibleTable *obj, + long row); -AccessibleTable * -AccessibleTable_getColumnHeaders (AccessibleTable *obj); +SpiAccessible * +SpiAccessibleTable_getColumnHeader (SpiAccessibleTable *obj, + long column); long -AccessibleTable_getNSelectedRows (AccessibleTable *obj); +SpiAccessibleTable_getNSelectedRows (SpiAccessibleTable *obj); -void -AccessibleTable_getSelectedRows (AccessibleTable *obj, +long +SpiAccessibleTable_getSelectedRows (SpiAccessibleTable *obj, long **selectedRows); long -AccessibleTable_getNSelectedColumns (AccessibleTable *obj); +SpiAccessibleTable_getNSelectedColumns (SpiAccessibleTable *obj); -void -AccessibleTable_getSelectedColumns (AccessibleTable *obj, +long +SpiAccessibleTable_getSelectedColumns (SpiAccessibleTable *obj, long **selectedColumns); boolean -AccessibleTable_isRowSelected (AccessibleTable *obj, +SpiAccessibleTable_isRowSelected (SpiAccessibleTable *obj, long row); boolean -AccessibleTable_isColumnSelected (AccessibleTable *obj, +SpiAccessibleTable_isColumnSelected (SpiAccessibleTable *obj, long column); boolean -AccessibleTable_isSelected (AccessibleTable *obj, +SpiAccessibleTable_isSelected (SpiAccessibleTable *obj, long row, long column); /* * - * AccessibleText function prototypes + * SpiAccessibleText function prototypes * */ int -AccessibleText_ref (AccessibleText *obj); +SpiAccessibleText_ref (SpiAccessibleText *obj); int -AccessibleText_unref (AccessibleText *obj); +SpiAccessibleText_unref (SpiAccessibleText *obj); long -AccessibleText_getCharacterCount (AccessibleText *obj); +SpiAccessibleText_getCharacterCount (SpiAccessibleText *obj); char * -AccessibleText_getText (AccessibleText *obj, +SpiAccessibleText_getText (SpiAccessibleText *obj, long startOffset, long endOffset); long -AccessibleText_getCaretOffset (AccessibleText *obj); +SpiAccessibleText_getCaretOffset (SpiAccessibleText *obj); + +char * +SpiAccessibleText_getAttributes (SpiAccessibleText *obj, + long offset, + long *startOffset, + long *endOfset); + boolean -AccessibleText_setCaretOffset (AccessibleText *obj, +SpiAccessibleText_setCaretOffset (SpiAccessibleText *obj, long newOffset); char * -AccessibleText_getTextBeforeOffset (AccessibleText *obj, +SpiAccessibleText_getTextBeforeOffset (SpiAccessibleText *obj, long offset, - TEXT_BOUNDARY_TYPE type); + SPI_TEXT_BOUNDARY_TYPE type, + long *startOffset, long *endOffset); char * -AccessibleText_getTextAtOffset (Accessible *obj, - long offset, - TEXT_BOUNDARY_TYPE type); +SpiAccessibleText_getTextAtOffset (SpiAccessibleText *obj, + long offset, + SPI_TEXT_BOUNDARY_TYPE type, + long *startOffset, long *endOffset); char * -AccessibleText_getTextAfterOffset (AccessibleText *obj, - long offset, - TEXT_BOUNDARY_TYPE type); - -char -AccessibleText_getCharacterAtOffset (AccessibleText *obj, +SpiAccessibleText_getTextAfterOffset (SpiAccessibleText *obj, + long offset, + SPI_TEXT_BOUNDARY_TYPE type, + long *startOffset, long *endOffset); +unsigned long +SpiAccessibleText_getCharacterAtOffset (SpiAccessibleText *obj, long offset); -char * -AccessibleText_getAttributes (AccessibleText *obj, - long startOffset, - long endOffset); - -boolean -AccessibleText_getCharacterExtents (AccessibleText *obj, +void +SpiAccessibleText_getCharacterExtents (SpiAccessibleText *obj, long offset, long *x, long *y, long *width, - long *height); + long *height, SpiAccessibleCoordType type); long -AccessibleText_getOffsetAtPoint (AccessibleText *obj, +SpiAccessibleText_getOffsetAtPoint (SpiAccessibleText *obj, long x, - long y); + long y, SpiAccessibleCoordType type); -char * -AccessibleText_getSelectedText (AccessibleText *obj); +long +SpiAccessibleText_getNSelections (SpiAccessibleText *obj); void -AccessibleText_getSelectionBounds (AccessibleText *obj, - long *startOffset, - long *endOffset); +SpiAccessibleText_getSelection (SpiAccessibleText *obj, + long selectionNum, long *startOffset, + long *endOffset); + boolean -AccessibleText_setSelectionBounds (AccessibleText *obj, - long startOffset, - long endOffset); +SpiAccessibleText_addSelection (SpiAccessibleText *obj, + long startOffset, long endOffset); + +boolean +SpiAccessibleText_removeSelection (SpiAccessibleText *obj, + long selectionNum); + +boolean +SpiAccessibleText_setSelection (SpiAccessibleText *obj, + long selectionNum, + long startOffset, + long endOffset); /* * - * AccessibleValue Function Prototypes: + * SpiAccessibleValue Function Prototypes: * */ float -AccessibleValue_getMinimumValue (AccessibleValue *value); +SpiAccessibleValue_getMinimumValue (SpiAccessibleValue *value); float -AccessibleValue_getCurrentValue (AccessibleValue *value); +SpiAccessibleValue_getCurrentValue (SpiAccessibleValue *value); float -AccessibleValue_getMaximumValue (AccessibleValue *value); +SpiAccessibleValue_getMaximumValue (SpiAccessibleValue *value); boolean -AccessibleValue_setCurrentValue (AccessibleValue *value, +SpiAccessibleValue_setCurrentValue (SpiAccessibleValue *value, float newValue); +void +spi_freeString (char *s); + #endif