+2001-16-11 Bill Haneman <bill.haneman@sun.com>
+
+ One last namespacing revision:
+ * libspi/accessibleeventlistener.[ch]:
+ Renamed SpiAccessibleEventListener to SpiEventListener,
+ (no need for two namespaces ;-)
+
+ And lots of documentation fixes:
+
+ * docs/at-spi-docs.sgml:
+ Fixed 'underscore vs. hyphen' bug that was preventing
+ the gtk-doc API docs from being automatically generated.
+
+ * cspi/spi-impl.h
+ * cspi/spi-listener.h
+ * cspi/spi.h
+ * cspi/spi_accessible.c
+ * cspi/spi_action.c
+ * cspi/spi_application.c
+ * cspi/spi_component.c
+ * cspi/spi_editabletext.c
+ * cspi/spi_event.c
+ * cspi/spi_hypertext.c
+ * cspi/spi_main.c
+ * cspi/spi_registry.c
+ * cspi/spi_selection.c
+ * cspi/spi_text.c
+ * cspi/spi_value.c
+ * docs/Makefile.am
+ * docs/at-spi-docs.sgml
+ * docs/at-spi-sections.txt
+
+ Added and fixed up gtk-doc documentation in cspi.
+
+ Interfaces now (fully) documented (subject to revision and enhancement):
+ SPI_main
+ Event Listener Support
+ Registry API
+ AccessibleApplication
+ Accessible
+ AccessibleAction
+ AccessibleComponent
+ AccessibleEditableText
+ AccessibleSelection
+ AccessibleText
+ AccessibleValue
+
+ still pending:
+ AccessibleStateSet
+ AccessibleRelationSet
+ AccessibleImage
+ AccessibleTable
+ AccessibleHyperlink
+
2001-14-11 Bill Haneman <bill.haneman@sun.com>
* at-bridge/bridge.c:
typedef CORBA_Object GenericInterface;
typedef SpiKeystrokeListener AccessibleKeystrokeListener;
-typedef SpiAccessibleEventListener AccessibleEventListener;
-
-typedef SpiKeyMaskType AccessibleKeyMaskType;
+typedef SpiEventListener AccessibleEventListener;
#endif
#include "accessibleeventlistener.h"
#include "keystrokelistener.h"
+#define SPI_KEYSET_ALL_KEYS ((void *)NULL)
+
/*
*
/*
*
* Function prototype typedefs for Event Listener Callbacks.
- * (see libspi/accessibleeventlistener.h for definition of VoidEventListenerCB).
+ * (see libspi/accessibleeventlistener.h for definition of SpiVoidEventListenerCB).
*
* usage: signatures should be
* void (*AccessibleEventListenerCB) (AccessibleEvent *event);
* boolean (*AccessibleKeystrokeListenerCB) (AccessibleKeystrokeEvent *Event);
*/
-typedef VoidEventListenerCB AccessibleEventListenerCB;
-typedef BooleanKeystrokeListenerCB AccessibleKeystrokeListenerCB;
+typedef VoidSpiEventListenerCB AccessibleEventListenerCB;
+typedef BooleanKeystrokeListenerCB AccessibleKeystrokeListenerCB;
#ifdef __cplusplus
}
#include "spi-listener.h"
/*
+ * Auxiliary typedefs and mask definitions
+ */
+#include <keymasks.h>
+
+/*
*
* Enumerated type for text boundary types
*
/* don't change the order of these ! */
-typedef enum _AccessibleCoordType {
+typedef enum {
SPI_COORD_TYPE_SCREEN,
SPI_COORD_TYPE_WINDOW
} AccessibleCoordType;
-typedef enum _AccessibleKeyEventType {
+typedef enum {
SPI_KEY_PRESSED,
SPI_KEY_RELEASED
} AccessibleKeyEventType;
-typedef enum _AccessibleKeySynthType {
+typedef enum {
SPI_KEY_PRESS,
SPI_KEY_RELEASE,
SPI_KEY_PRESSRELEASE,
SPI_KEY_SYM
} AccessibleKeySynthType;
-typedef enum _AccessibleKeyListenerSyncType {
+typedef enum {
SPI_KEYLISTENER_NOSYNC = 0,
SPI_KEYLISTENER_SYNCHRONOUS = 1,
SPI_KEYLISTENER_CANCONSUME = 2,
unsigned short modifiers;
} AccessibleKeyStroke;
-typedef struct _AccessibleAccessibleKeySet
+/**
+ * AccessibleKeySet:
+ * @keysyms:
+ * @keycodes:
+ * @len:
+ *
+ * Structure containing identifying information about a set of keycode or
+ * keysyms.
+ **/
+typedef struct _AccessibleKeySet
{
unsigned long *keysyms;
unsigned short *keycodes;
#define SPI_KEYSET_ALL_KEYS ((void *)NULL)
+typedef unsigned long AccessibleKeyMaskType;
+
/*
*
* Basic SPI initialization and event loop function prototypes
*/
/**
- * createEventListener:
+ * createAccessibleEventListener:
* @callback : an #AccessibleEventListenerCB callback function, or NULL.
*
* Create a new #AccessibleEventListener with a specified callback function.
*
**/
AccessibleEventListener *
-createEventListener (AccessibleEventListenerCB callback);
+createAccessibleEventListener (AccessibleEventListenerCB callback);
/**
- * EventListener_addCallback:
+ * AccessibleEventListener_addCallback:
* @listener: the #AccessibleEventListener instance to modify.
* @callback: an #AccessibleEventListenerCB function pointer.
*
boolean
registerGlobalEventListener (AccessibleEventListener *listener,
char *eventType);
+boolean
+deregisterGlobalEventListener (AccessibleEventListener *listener,
+ char *eventType);
+boolean
+deregisterGlobalEventListenerAll (AccessibleEventListener *listener);
+
/**
* getDesktopCount:
*
**/
Accessible*
-getDesktop (int n);
+getDesktop (int i);
/**
* getDesktopList:
void
deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
- AccessibleKeyMaskType keymask);
+ AccessibleKeyMaskType modmask);
/**
* generateKeyEvent:
- * @keycode: a #long indicating the keycode of the key event
+ * @keyval: a #long integer indicating the keycode or keysym of the key event
* being synthesized.
- * @synth_type: a #AccessibleKeySynthType indicating whether this should be a
- * SPI_KEY_PRESS, SPI_KEY_RELEASE, both (SPI_KEY_PRESSRELEASE), or
- * a press/release pair for a KEYSYM.
+ * @synth_type: a #AccessibleKeySynthType flag indicating whether @keyval
+ * is to be interpreted as a keysym rather than a keycode
+ * (SPI_KEYSYM) and whether to synthesize
+ * SPI_KEY_PRESS, SPI_KEY_RELEASE, or both (SPI_KEY_PRESSRELEASE).
*
* Synthesize a keyboard event (as if a hardware keyboard event occurred in the
* current UI context).
*
**/
void
-generateKeyEvent (long keyCode, AccessibleKeySynthType synth_type);
+generateKeyEvent (long int keyval, AccessibleKeySynthType 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.
+ * @x: a #long int indicating the screen x coordinate of the mouse event.
+ * @y: a #long int indicating the screen y coordinate of the mouse event.
* @name: a string indicating which mouse event to be synthesized
* (e.g. "button1", "button2", "mousemove").
*
*
**/
void
-generateMouseEvent (long x, long y, char *name);
+generateMouseEvent (long int x, long int y, char *name);
/*
*
/**
* Accessible_getChildCount:
- *
* @obj: a pointer to the #Accessible object on which to operate.
*
* Get the number of children contained by an #Accessible object.
**/
Accessible *
Accessible_getChildAtIndex (Accessible *obj,
- long childIndex);
+ long int childIndex);
/**
* Accessible_getIndexInParent:
/**
* Accessible_getRelationSet:
+ * @obj: a pointer to the #Accessible object on which to operate.
*
* Not Yet Implemented.
*
+ * Returns: a pointer to an array of #AccessibleRelations.
+ *
**/
AccessibleRelation **
Accessible_getRelationSet (Accessible *obj);
/**
* Accessible_getStateSet:
+ * @obj: a pointer to the #Accessible object on which to operate.
*
* Not Yet Implemented.
*
+ * Returns: a pointer to an #AccessibleStateSet representing the object's current state.
+ *
**/
AccessibleStateSet *
Accessible_getStateSet (Accessible *obj);
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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
Accessible_isText (Accessible *obj);
-/**
- * Accessible_getAction:
- *
- * Not Yet Implemented.
- *
- **/
AccessibleAction *
Accessible_getAction (Accessible *obj);
AccessibleAction_getNActions (AccessibleAction *obj);
/**
+ * AccessibleAction_getName:
+ * @obj: a pointer to the #AccessibleAction implementor to query.
+ * @i: a long integer indicating which action to query.
+ *
+ * Get the name of the '@i-th' action invokable on an
+ * object implementing #AccessibleAction.
+ *
+ * Returns: the 'event type' name of the action, as a UTF-8 string.
+ *
+ **/
+char *
+AccessibleAction_getName (AccessibleAction *obj, long int i);
+
+/**
* AccessibleAction_getDescription:
* @obj: a pointer to the #AccessibleAction to query.
+ * @i: a long integer indicating which action to query.
*
- * Get the description of 'i-th' action invokable on an
+ * 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.
+ * Returns: a UTF-8 string describing the '@i-th' invokable action.
*
**/
char *
AccessibleAction_getDescription (AccessibleAction *obj,
- long index);
+ long int i);
boolean
AccessibleAction_doAction (AccessibleAction *obj,
- long index);
+ long int i);
+/**
+ * AccessibleAction_getKeybinding:
+ * @obj: a pointer to the #AccessibleAction implementor to query.
+ * @i: a long integer indicating which action to query.
+ *
+ * Get the keybindings for the @i-th action invokable on an
+ * object implementing #AccessibleAction, if any are defined.
+ *
+ * Returns: a UTF-8 string which can be parsed to determine the @i-th
+ * invokable action's keybindings.
+ *
+ **/
char *
AccessibleAction_getKeyBinding (AccessibleAction *obj,
- long index);
+ long int i);
/*
*
/**
* AccessibleApplication_pause:
+ * @obj: a pointer to the #Accessible object on which to operate.
*
* Attempt to pause the application (used when client event queue is
* over-full).
AccessibleApplication_pause (AccessibleApplication *obj);
/**
- * AccessibleApplication_pause:
+ * AccessibleApplication_resume:
+ * @obj: a pointer to the #Accessible object on which to operate.
*
* Attempt to resume the application (used after #AccessibleApplication_pause).
* Not Yet Implemented.
boolean
AccessibleComponent_contains (AccessibleComponent *obj,
- long x,
- long y,
+ long int x,
+ long int y,
AccessibleCoordType ctype);
Accessible *
AccessibleComponent_getAccessibleAtPoint (AccessibleComponent *obj,
- long x,
- long y,
+ long int x,
+ long int y,
AccessibleCoordType ctype);
/**
**/
void
AccessibleComponent_getExtents (AccessibleComponent *obj,
- long *x,
- long *y,
- long *width,
- long *height,
+ long int *x,
+ long int *y,
+ long int *width,
+ long int *height,
AccessibleCoordType ctype);
void
AccessibleComponent_getPosition (AccessibleComponent *obj,
- long *x,
- long *y,
+ long int *x,
+ long int *y,
AccessibleCoordType ctype);
void
AccessibleComponent_getSize (AccessibleComponent *obj,
- long *width,
- long *height);
+ long int *width,
+ long int *height);
void
AccessibleComponent_grabFocus (AccessibleComponent *obj);
boolean
AccessibleEditableText_setRunAttributes (AccessibleEditableText *obj,
const char *attributes,
- long startPos, long endPos);
+ long int startPos, long int intendPos);
-void
+boolean
AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
const char *newContents);
-void
+boolean
AccessibleEditableText_insertText (AccessibleEditableText *obj,
- long position,
+ long int position,
char *text,
- long length);
+ long int length);
-void
+boolean
AccessibleEditableText_copyText (AccessibleText *obj,
- long startPos,
- long endPos);
+ long int startPos,
+ long int endPos);
-void
+boolean
AccessibleEditableText_cutText (AccessibleEditableText *obj,
- long startPos,
- long endPos);
+ long int startPos,
+ long int endPos);
-void
+boolean
AccessibleEditableText_deleteText (AccessibleEditableText *obj,
- long startPos,
- long endPos);
+ long int startPos,
+ long int endPos);
-void
+boolean
AccessibleEditableText_pasteText (AccessibleEditableText *obj,
- long position);
+ long int position);
/*
*
*
*/
-int
-AccessibleHyperlink_ref (AccessibleHyperlink *obj);
-
-int
-AccessibleHyperlink_unref (AccessibleHyperlink *obj);
-
long
AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
char *
AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
- long i);
+ long int i);
Accessible *
AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
- long i);
+ long int i);
void
AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
- long *startIndex,
- long *endIndex);
+ long int *startIndex,
+ long int *endIndex);
boolean
AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
AccessibleHyperlink *
-AccessibleHyperText_getLink (AccessibleHypertext *obj,
- long linkIndex);
+AccessibleHypertext_getLink (AccessibleHypertext *obj,
+ long int linkIndex);
long
AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
- long characterIndex);
+ long int characterIndex);
/*
*
void
AccessibleImage_getImageSize (AccessibleImage *obj,
- long *width,
- long *height);
+ long int *width,
+ long int *height);
void
AccessibleImage_getImagePosition (AccessibleImage *obj,
- long *x,
- long *y,
+ long int *x,
+ long int *y,
AccessibleCoordType ctype);
/*
Accessible *
AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
- long selectedChildIndex);
+ long int selectedChildIndex);
boolean
AccessibleSelection_selectChild (AccessibleSelection *obj,
- long childIndex);
+ long int childIndex);
boolean
AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
- long selectedChildIndex);
+ long int selectedChildIndex);
boolean
AccessibleSelection_isChildSelected (AccessibleSelection *obj,
- long childIndex);
+ long int childIndex);
-void
+boolean
AccessibleSelection_selectAll (AccessibleSelection *obj);
void
Accessible *
AccessibleTable_refAt (AccessibleTable *obj,
- long row,
- long column);
+ long int row,
+ long int column);
long
AccessibleTable_getIndexAt (AccessibleTable *obj,
- long row,
- long column);
+ long int row,
+ long int column);
long
AccessibleTable_getRowAtIndex (AccessibleTable *obj,
- long index);
+ long int index);
long
AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
- long index);
+ long int index);
char *
AccessibleTable_getRowDescription (AccessibleTable *obj,
- long row);
+ long int row);
char *
AccessibleTable_getColumnDescription (AccessibleTable *obj,
- long column);
+ long int column);
long
AccessibleTable_getRowExtentAt (AccessibleTable *obj,
- long row,
- long column);
+ long int row,
+ long int column);
long
AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
- long row,
- long column);
+ long int row,
+ long int column);
Accessible *
AccessibleTable_getRowHeader (AccessibleTable *obj,
- long row);
+ long int row);
Accessible *
AccessibleTable_getColumnHeader (AccessibleTable *obj,
- long column);
+ long int column);
long
AccessibleTable_getNSelectedRows (AccessibleTable *obj);
long
AccessibleTable_getSelectedRows (AccessibleTable *obj,
- long **selectedRows);
+ long int **selectedRows);
long
AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
long
AccessibleTable_getSelectedColumns (AccessibleTable *obj,
- long **selectedColumns);
+ long int **selectedColumns);
boolean
AccessibleTable_isRowSelected (AccessibleTable *obj,
- long row);
+ long int row);
boolean
AccessibleTable_isColumnSelected (AccessibleTable *obj,
- long column);
+ long int column);
boolean
AccessibleTable_isSelected (AccessibleTable *obj,
- long row,
- long column);
+ long int row,
+ long int column);
/*
*
char *
AccessibleText_getText (AccessibleText *obj,
- long startOffset,
- long endOffset);
+ long int startOffset,
+ long int endOffset);
long
AccessibleText_getCaretOffset (AccessibleText *obj);
char *
AccessibleText_getAttributes (AccessibleText *obj,
- long offset,
- long *startOffset,
- long *endOfset);
+ long int offset,
+ long int *startOffset,
+ long int *endOffset);
boolean
AccessibleText_setCaretOffset (AccessibleText *obj,
- long newOffset);
+ long int newOffset);
char *
AccessibleText_getTextBeforeOffset (AccessibleText *obj,
- long offset,
+ long int offset,
AccessibleTextBoundaryType type,
- long *startOffset, long *endOffset);
+ long int *startOffset,
+ long int *endOffset);
char *
AccessibleText_getTextAtOffset (AccessibleText *obj,
- long offset,
- AccessibleTextBoundaryType type,
- long *startOffset, long *endOffset);
+ long int offset,
+ AccessibleTextBoundaryType type,
+ long int *startOffset,
+ long int *endOffset);
char *
AccessibleText_getTextAfterOffset (AccessibleText *obj,
- long offset,
+ long int offset,
AccessibleTextBoundaryType type,
- long *startOffset, long *endOffset);
+ long int *startOffset,
+ long int *endOffset);
unsigned long
AccessibleText_getCharacterAtOffset (AccessibleText *obj,
- long offset);
+ long int offset);
void
AccessibleText_getCharacterExtents (AccessibleText *obj,
- long offset,
- long *x,
- long *y,
- long *width,
- long *height, AccessibleCoordType type);
+ long int offset,
+ long int *x,
+ long int *y,
+ long int *width,
+ long int *height,
+ AccessibleCoordType type);
long
AccessibleText_getOffsetAtPoint (AccessibleText *obj,
- long x,
- long y, AccessibleCoordType type);
+ long int x,
+ long int y,
+ AccessibleCoordType type);
long
AccessibleText_getNSelections (AccessibleText *obj);
void
AccessibleText_getSelection (AccessibleText *obj,
- long selectionNum, long *startOffset,
- long *endOffset);
+ long int selectionNum,
+ long int *startOffset,
+ long int *endOffset);
boolean
AccessibleText_addSelection (AccessibleText *obj,
- long startOffset, long endOffset);
+ long int startOffset,
+ long int endOffset);
boolean
AccessibleText_removeSelection (AccessibleText *obj,
- long selectionNum);
+ long int selectionNum);
boolean
AccessibleText_setSelection (AccessibleText *obj,
- long selectionNum,
- long startOffset,
- long endOffset);
+ long int selectionNum,
+ long int startOffset,
+ long int endOffset);
/*
*
*
*/
+int
+AccessibleValue_ref (AccessibleValue *obj);
+
+int
+AccessibleValue_unref (AccessibleValue *obj);
+
float
-AccessibleValue_getMinimumValue (AccessibleValue *value);
+AccessibleValue_getMinimumValue (AccessibleValue *obj);
float
-AccessibleValue_getCurrentValue (AccessibleValue *value);
+AccessibleValue_getCurrentValue (AccessibleValue *obj);
float
-AccessibleValue_getMaximumValue (AccessibleValue *value);
+AccessibleValue_getMaximumValue (AccessibleValue *obj);
boolean
-AccessibleValue_setCurrentValue (AccessibleValue *value,
+AccessibleValue_setCurrentValue (AccessibleValue *obj,
float newValue);
void
/**
* Accessible_getChildCount:
- *
* @obj: a pointer to the #Accessible object on which to operate.
*
* Get the number of children contained by an #Accessible object.
/**
* Accessible_getChildAtIndex:
- *
* @obj: a pointer to the #Accessible object on which to operate.
* @childIndex: a #long indicating which child is specified.
*
**/
Accessible *
Accessible_getChildAtIndex (Accessible *obj,
- long childIndex)
+ long int childIndex)
{
Accessible *retval = Obj_Add (Accessibility_Accessible_getChildAtIndex (*obj, childIndex, &ev));
spi_check_ev (&ev, "getChildAtIndex");
/**
* Accessible_getIndexInParent:
- *
* @obj: a pointer to the #Accessible object on which to operate.
*
* Get the index of an #Accessible object in its containing #Accessible.
/**
* Accessible_getRelationSet:
+ * @obj: a pointer to the #Accessible object on which to operate.
*
* Not Yet Implemented.
*
/**
* Accessible_getStateSet:
+ * @obj: a pointer to the #Accessible object on which to operate.
*
* Not Yet Implemented.
*
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
/**
* Accessible_getAction:
+ * @obj: a pointer to the #Accessible instance to query.
*
+ * Get the #AccessibleAction interface for an #Accessible.
*
+ * Returns: a pointer to an #AccessibleAction interface instance, or
+ * NULL if @obj does not implement #AccessibleAction.
**/
AccessibleAction *
Accessible_getAction (Accessible *obj)
return (AccessibleComponent *) ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
}
+/**
+ * Accessible_getEditableText:
+ * @obj: a pointer to the #Accessible instance to query.
+ *
+ * Get the #AccessibleEditableText interface for an #Accessible.
+ *
+ * Returns: a pointer to an #AccessibleEditableText interface instance, or
+ * NULL if @obj does not implement #AccessibleEditableText.
+ **/
AccessibleEditableText *
Accessible_getEditableText (Accessible *obj)
{
+/**
+ * Accessible_getHypertext:
+ * @obj: a pointer to the #Accessible instance to query.
+ *
+ * Get the #AccessibleHypertext interface for an #Accessible.
+ *
+ * Returns: a pointer to an #AccessibleHypertext interface instance, or
+ * NULL if @obj does not implement #AccessibleHypertext.
+ **/
AccessibleHypertext *
Accessible_getHypertext (Accessible *obj)
{
+/**
+ * Accessible_getImage:
+ * @obj: a pointer to the #Accessible instance to query.
+ *
+ * Get the #AccessibleImage interface for an #Accessible.
+ *
+ * Returns: a pointer to an #AccessibleImage interface instance, or
+ * NULL if @obj does not implement #AccessibleImage.
+ **/
AccessibleImage *
Accessible_getImage (Accessible *obj)
{
+/**
+ * Accessible_getSelection:
+ * @obj: a pointer to the #Accessible instance to query.
+ *
+ * Get the #AccessibleSelection interface for an #Accessible.
+ *
+ * Returns: a pointer to an #AccessibleSelection interface instance, or
+ * NULL if @obj does not implement #AccessibleSelection.
+ **/
AccessibleSelection *
Accessible_getSelection (Accessible *obj)
{
+/**
+ * Accessible_getTable:
+ * @obj: a pointer to the #Accessible instance to query.
+ *
+ * Get the #AccessibleTable interface for an #Accessible.
+ *
+ * Returns: a pointer to an #AccessibleTable interface instance, or
+ * NULL if @obj does not implement #AccessibleTable.
+ **/
AccessibleTable *
Accessible_getTable (Accessible *obj)
{
((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
}
+/**
+ * Accessible_getText:
+ * @obj: a pointer to the #Accessible instance to query.
+ *
+ * Get the #AccessibleText interface for an #Accessible.
+ *
+ * Returns: a pointer to an #AccessibleText interface instance, or
+ * NULL if @obj does not implement #AccessibleText.
+ **/
AccessibleText *
Accessible_getText (Accessible *obj)
{
+/**
+ * Accessible_getValue:
+ * @obj: a pointer to the #Accessible instance to query.
+ *
+ * Get the #AccessibleValue interface for an #Accessible.
+ *
+ * Returns: a pointer to an #AccessibleValue interface instance, or
+ * NULL if @obj does not implement #AccessibleValue.
+ **/
AccessibleValue *
Accessible_getValue (Accessible *obj)
{
+/**
+ * AccessibleAction_ref:
+ * @obj: a pointer to the #AccessibleAction on which to operate.
+ *
+ * Increment the reference count for an #AccessibleAction.
+ *
+ * Returns: 0 (no return code implemented yet).
+ *
+ **/
int
AccessibleAction_ref (
AccessibleAction *obj)
return 0;
}
+/**
+ * AccessibleAction_unref:
+ * @obj: a pointer to the #AccessibleAction on which to operate.
+ *
+ * Decrement the reference count for an #AccessibleAction.
+ *
+ * Returns: 0 (no return code implemented yet).
+ *
+ **/
int
AccessibleAction_unref (AccessibleAction *obj)
{
+/**
+ * AccessibleAction_getNActions:
+ * @obj: a pointer to the #AccessibleAction to query.
+ *
+ * Get the number of actions invokable on an #AccessibleAction implementor.
+ *
+ * Returns: a #long integer indicatin the number of invokable actions.
+ *
+ **/
long
AccessibleAction_getNActions (AccessibleAction *obj)
{
/**
* AccessibleAction_getDescription:
- * @obj: a pointer to the #AccessibleAction to query.
+ * @obj: a pointer to the #AccessibleAction implementor to query.
+ * @i: a long integer indicating which action to query.
*
- * Get the description of 'i-th' action invokable on an
+ * Get the description of '@i-th' action invokable on an
* object implementing #AccessibleAction.
*
- * Returns: a UTF-8 string describing the 'i-th' invokable action.
+ * Returns: a UTF-8 string describing the '@i-th' invokable action.
*
**/
char *
AccessibleAction_getDescription (AccessibleAction *obj,
- long index)
+ long int i)
{
return (char *)
Accessibility_Action_getDescription (*obj,
- (CORBA_long) index,
+ (CORBA_long) i,
&ev);
}
-
-
+/**
+ * AccessibleAction_getKeyBinding:
+ * @obj: a pointer to the #AccessibleAction implementor to query.
+ * @i: a long integer indicating which action to query.
+ *
+ * Get the keybindings for the @i-th action invokable on an
+ * object implementing #AccessibleAction, if any are defined.
+ *
+ * Returns: a UTF-8 string which can be parsed to determine the @i-th
+ * invokable action's keybindings.
+ *
+ **/
char *
AccessibleAction_getKeyBinding (AccessibleAction *obj,
- long index)
+ long int i)
{
return (char *)
Accessibility_Action_getKeyBinding (*obj,
- (CORBA_long) index,
+ (CORBA_long) i,
&ev);
}
+/**
+ * AccessibleAction_getName:
+ * @obj: a pointer to the #AccessibleAction implementor to query.
+ * @i: a long integer indicating which action to query.
+ *
+ * Get the name of the '@i-th' action invokable on an
+ * object implementing #AccessibleAction.
+ *
+ * Returns: the 'event type' name of the action, as a UTF-8 string.
+ *
+ **/
char *
AccessibleAction_getName (AccessibleAction *obj,
- long index)
+ long int i)
{
return (char *)
Accessibility_Action_getName (*obj,
- (CORBA_long) index,
+ (CORBA_long) i,
&ev);
}
+/**
+ * AccessibleAction_doAction:
+ * @obj: a pointer to the #AccessibleAction to query.
+ * @i: an integer specifying which action to invoke.
+ *
+ * Invoke the action indicated by #index.
+ *
+ * Returns: #TRUE if the action is successfully invoked, otherwise #FALSE.
+ *
+ **/
boolean
AccessibleAction_doAction (AccessibleAction *obj,
- long index)
+ long int i)
{
return (boolean)
Accessibility_Action_doAction (*obj,
- (CORBA_long) index,
+ (CORBA_long) i,
&ev);
}
*
* Returns: a unique #long integer associated with the application
* by the Registry, or 0 if the application is not registered.
+**/
long
AccessibleApplication_getID (AccessibleApplication *obj)
{
/**
* AccessibleApplication_pause:
+ * @obj: a pointer to the #Accessible object on which to operate.
*
* Attempt to pause the application (used when client event queue is
* over-full).
/**
* AccessibleApplication_resume:
+ * @obj: a pointer to the #Accessible object on which to operate.
*
* Attempt to resume the application (used after #AccessibleApplication_pause).
* Not Yet Implemented.
*
* Query whether a given #AccessibleComponent contains a particular point.
*
+ * Returns: a #TRUE if the specified component contains the point (@x, @y),
+ * otherwise #FALSE.
**/
boolean
AccessibleComponent_contains (AccessibleComponent *obj,
- long x,
- long y,
+ long int x,
+ long int y,
AccessibleCoordType ctype)
{
return Accessibility_Component_contains (*obj,
**/
Accessible *
AccessibleComponent_getAccessibleAtPoint (AccessibleComponent *obj,
- long x,
- long y,
+ long int x,
+ long int y,
AccessibleCoordType ctype)
{
Accessible child;
**/
void
AccessibleComponent_getExtents (AccessibleComponent *obj,
- long *x,
- long *y,
- long *width,
- long *height,
+ long int *x,
+ long int *y,
+ long int *width,
+ long int *height,
AccessibleCoordType ctype)
{
CORBA_long cx, cy, cw, ch;
**/
void
AccessibleComponent_getPosition (AccessibleComponent *obj,
- long *x,
- long *y,
+ long int *x,
+ long int *y,
AccessibleCoordType ctype)
{
Accessibility_Component_getPosition (*obj,
**/
void
AccessibleComponent_getSize (AccessibleComponent *obj,
- long *width,
- long *height)
+ long int *width,
+ long int *height)
{
Accessibility_Component_getSize (*obj,
(CORBA_long *) width,
&ev);
}
-/* Not Yet Implemented */
+/**
+ * AccessibleComponent_grabFocus:
+ * @obj: a pointer to the #AccessibleComponent on which to operate.
+ *
+ * Attempt to set the keyboard input focus to the specified
+ * #AccessibleComponent.
+ *
+ **/
void
AccessibleComponent_grabFocus (AccessibleComponent *obj)
{
+/**
+ * AccessibleEditableText_ref:
+ * @obj: a pointer to the #AccessibleEditableText object on which to operate.
+ *
+ * Increment the reference count for an #AccessibleEditableText object.
+ * Since AccessibleEditableText is derived from AccessibleText,
+ * this is the same as AccessibleText_ref().
+ *
+ * Returns: (no return code implemented yet).
+ *
+ **/
int
AccessibleEditableText_ref (AccessibleEditableText *obj)
{
+/**
+ * AccessibleEditableText_ref:
+ * @obj: a pointer to the #AccessibleEditableText object on which to operate.
+ *
+ * Decrement the reference count for an #AccessibleEdiitableText object.
+ * Since AccessibleEditableText is derived from AccessibleText,
+ * this is the same as AccessibleText_unref().
+ *
+ * Returns: (no return code implemented yet).
+ *
+ **/
int
AccessibleEditableText_unref (AccessibleEditableText *obj)
{
+/**
+ * AccessibleEditableText_setAttributes:
+ * @obj: a pointer to the #AccessibleEditableText object to modify.
+ * @startOffset: a #long indicating the start of the desired text range.
+ * @endOffset: a #long indicating the first character past the desired range.
+ *
+ * Set the attributes applied to a range of text from an #AccessibleEditableText
+ * object, and the bounds of the range.
+ *
+ * Returns: #TRUE if the operation was successful, otherwise #FALSE.
+ *
+ **/
boolean
AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
const char *attributes,
- long startPos, long endPos)
+ long int startPos,
+ long int endPos)
{
return (boolean)
Accessibility_EditableText_setAttributes (*obj,
(CORBA_char *) attributes,
- (CORBA_long) startPos, (CORBA_long) endPos, &ev);
+ (CORBA_long) startPos,
+ (CORBA_long) endPos, &ev);
}
-void
+/**
+ * AccessibleEditableText_setTextContents:
+ * @obj: a pointer to the #AccessibleEditableText object to modify.
+ * @newContents: a character string, encoded in UTF-8, which is to
+ * become the new text contents of the #AccessibleEditableText object.
+ *
+ * Replace the entire text contents of an #AccessibleEditableText object.
+ *
+ * Returns: #TRUE if the operation was successful, otherwise #FALSE.
+ *
+ **/
+boolean
AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
const char *newContents)
{
Accessibility_EditableText_setTextContents (*obj,
(CORBA_char *) newContents, &ev);
+ return TRUE; /* TODO: make bonobo method return a boolean */
}
-void
+/**
+ * AccessibleEditableText_insertText:
+ * @obj: a pointer to the #AccessibleEditableText object to modify.
+ * @position: an integer indicating the character offset at which to insert
+ * the new text.
+ * @text: a char* pointer to the text to insert, in UTF-8 encoding.
+ * @length: (frankly I'm not sure this parameter should be here)
+ *
+ * Insert text into an #AccessibleEditableText object.
+ * As with all character offsets, the specified @position may not be the
+ * same as the resulting byte offset, since the text is in a
+ * variable-width encoding.
+ *
+ * Returns: #TRUE if the operation was successful, otherwise #FALSE.
+ *
+ **/
+boolean
AccessibleEditableText_insertText (AccessibleEditableText *obj,
- long position,
+ long int position,
char *text,
- long length)
+ long int length)
{
Accessibility_EditableText_insertText (*obj,
(CORBA_long) position, (CORBA_char *) text,
(CORBA_long) length, &ev);
+ return TRUE;
}
-void
+/**
+ * AccessibleEditableText_copyText:
+ * @obj: a pointer to the #AccessibleEditableText object to modify.
+ * @startPos: an integer indicating the starting character offset
+ * of the text to copy.
+ * @endPos: an integer indicating the offset of the first character
+ * past the end of the text section to be copied.
+ *
+ * Copy text from an #AccessibleEditableText object into the clipboard.
+ *
+ * @see: AccessibleEditableText_pasteText
+ *
+ * Returns: #TRUE if the operation was successful, otherwise #FALSE.
+ *
+ **/
+boolean
AccessibleEditableText_copyText (AccessibleText *obj,
- long startPos,
- long endPos)
+ long int startPos,
+ long int endPos)
{
Accessibility_EditableText_copyText (*obj,
(CORBA_long) startPos, (CORBA_long) endPos, &ev);
+ return TRUE;
}
-
-void
+/**
+ * AccessibleEditableText_cutText:
+ * @obj: a pointer to the #AccessibleEditableText object to modify.
+ * @startPos: an integer indicating the starting character offset
+ * of the text to cut.
+ * @endPos: an integer indicating the offset of the first character
+ * past the end of the text section to be cut.
+ *
+ * Delete text from an #AccessibleEditableText object, copying the
+ * excised portion into the clipboard.
+ *
+ * @see: AccessibleEditableText_pasteText
+ *
+ * Returns: #TRUE if operation was successful, #FALSE otherwise.
+ *
+ **/
+boolean
AccessibleEditableText_cutText (AccessibleEditableText *obj,
- long startPos,
- long endPos)
+ long int startPos,
+ long int endPos)
{
Accessibility_EditableText_cutText (*obj,
(CORBA_long) startPos, (CORBA_long) endPos, &ev);
+ return TRUE;
}
-void
+/**
+ * AccessibleEditableText_deleteText:
+ * @obj: a pointer to the #AccessibleEditableText object to modify.
+ * @startPos: an integer indicating the starting character offset
+ * of the text to delete.
+ * @endPos: an integer indicating the offset of the first character
+ * past the end of the text section to be deleted.
+ *
+ * Delete text from an #AccessibleEditableText object, without copying the
+ * excised portion into the clipboard.
+ *
+ * @see: AccessibleEditableText_cutText
+ *
+ * Returns: #TRUE if the operation was successful, otherwise #FALSE.
+ *
+ **/
+boolean
AccessibleEditableText_deleteText (AccessibleEditableText *obj,
long startPos,
long endPos)
{
Accessibility_EditableText_deleteText (*obj,
(CORBA_long) startPos, (CORBA_long) endPos, &ev);
+ return TRUE;
}
-void
+/**
+ * AccessibleEditableText_pasteText:
+ * @obj: a pointer to the #AccessibleEditableText object to modify.
+ * @position: an integer indicating the character offset at which to insert
+ * the new text.
+ *
+ * Insert text from the clipboard into an #AccessibleEditableText object.
+ * As with all character offsets, the specified @position may not be the
+ * same as the resulting byte offset, since the text is in a
+ * variable-width encoding.
+ *
+ * Returns: #TRUE if the operation was successful, otherwise #FALSE.
+ *
+ **/
+boolean
AccessibleEditableText_pasteText (AccessibleEditableText *obj,
- long position)
+ long int position)
{
Accessibility_EditableText_pasteText (*obj,
(CORBA_long) position, &ev);
+ return TRUE;
}
* createAccessibleEventListener:
* @callback : an #AccessibleEventListenerCB callback function, or NULL.
*
- * Create a new #AccessibleEventListener with a specified callback function.
+ * Create a new #AccessibleEventListener with a specified (in-process) callback function.
*
* Returns: a pointer to a newly-created #AccessibleEventListener.
*
AccessibleEventListener *
createAccessibleEventListener (AccessibleEventListenerCB callback)
{
- AccessibleEventListener *listener = spi_accessible_event_listener_new ();
+ AccessibleEventListener *listener = spi_event_listener_new ();
if (callback)
{
- spi_accessible_event_listener_add_callback (listener, callback);
+ spi_event_listener_add_callback (listener, callback);
}
return listener;
}
* @callback: an #AccessibleEventListenerCB function pointer.
*
* Add an in-process callback function to an existing AccessibleEventListener.
+ * Note that the callback function must live in the same address
+ * space as the AccessibleEventListener implementation code, thus one should not
+ * use this function to attach callbacks to a 'remote' event listener
+ * (that is, one that was not created by a client call to
+ * createAccessibleEventListener ();
*
* Returns: #TRUE if successful, otherwise #FALSE.
*
**/
boolean
AccessibleEventListener_addCallback (AccessibleEventListener *listener,
- AccessibleEventListenerCB callback)
+ AccessibleEventListenerCB callback)
{
- spi_accessible_event_listener_add_callback (listener, callback);
+ spi_event_listener_add_callback (listener, callback);
return TRUE;
}
AccessibleEventListener_removeCallback (AccessibleEventListener *listener,
AccessibleEventListenerCB callback)
{
- spi_accessible_event_listener_remove_callback (listener, callback);
+ spi_event_listener_remove_callback (listener, callback);
return TRUE;
}
AccessibleHyperlink *
-AccessibleHyperText_getLink (AccessibleHypertext *obj,
+AccessibleHypertext_getLink (AccessibleHypertext *obj,
long linkIndex)
{
return (AccessibleHyperlink *)
/**
* SPI_event_main:
* @isGNOMEApp: a #boolean indicating whether the client of the SPI
- * will use the Gnome event loop or not.
+ * will use the Gnome event loop or not. Clients that have
+ * their own GUIS will usually specify #TRUE here, and must
+ * do so if they use Gnome GUI components.
*
* Starts/enters the main event loop for the SPI services.
*
}
/**
- * SPI_event_is_ready:
+ * SPI_eventIsReady:
*
* 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.
/**
* SPI_nextEvent:
+ * @waitForEvent: a #boolean indicating whether to block or not.
*
* Gets the next event in the SPI event queue; blocks if no event
- * is pending.
+ * is pending and @waitForEvent is #TRUE.
* Used by clients that don't wish to use SPI_event_main().
+ *
* Not Yet Implemented.
*
* Returns: the next #AccessibleEvent in the SPI event queue.
* SPI_exit:
*
* Disconnects from the Accessibility Registry and releases resources.
- * Not Yet Implemented.
*
**/
void
/**
* registerGlobalEventListener:
- * @listener: the #AccessibleEventListener to be registered against an event type.
- * @callback: a character string indicating the type of events for which
+ * @listener: the #AccessibleEventListener to be registered against an
+ * event type.
+ * @eventType: a character string indicating the type of events for which
* notification is requested. Format is
* EventClass:major_type:minor_type:detail
* where all subfields other than EventClass are optional.
* 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
+ * NOTE: this string may be UTF-8, but should not contain byte value 56
+ * (ascii ':'), except as a delimiter, since non-UTF-8 string
+ * delimiting functions are used internally.
+ * In general, listening to
* toolkit-specific events is not recommended.
*
* Add an in-process callback function to an existing AccessibleEventListener.
}
/**
- * deregisterGlobalEventListener:
- * @listener: the #AccessibleEventListener to be registered against an event type.
+ * deregisterGlobalEventListenerAll:
+ * @listener: the #AccessibleEventListener to be registered against
+ * an event type.
*
- * deregisters an AccessibleEventListener from the registry, for all event types it may be listening to.
+ * deregisters an AccessibleEventListener from the registry, for all
+ * event types it may be listening to.
*
* Returns: #TRUE if successful, otherwise #FALSE.
*
Accessibility_Registry_deregisterGlobalEventListenerAll (
registry,
(Accessibility_EventListener)
- CORBA_Object_duplicate (bonobo_object_corba_objref (bonobo_object (listener)), &ev),
+ CORBA_Object_duplicate (
+ bonobo_object_corba_objref (
+ bonobo_object (listener)), &ev),
&ev);
if (ev._major != CORBA_NO_EXCEPTION)
return TRUE;
}
}
+/**
+ * deregisterGlobalEventListener:
+ * @listener: the #AccessibleEventListener registered against an event type.
+ * @eventType: a string specifying the event type for which this
+ * listener is to be deregistered.
+ *
+ * deregisters an AccessibleEventListener from the registry, for a specific
+ * event type.
+ *
+ * Returns: #TRUE if successful, otherwise #FALSE.
+ *
+ **/
+boolean
+deregisterGlobalEventListener (AccessibleEventListener *listener,
+ char *eventType)
+{
+ Accessibility_Registry_deregisterGlobalEventListener (
+ registry,
+ (Accessibility_EventListener)
+ CORBA_Object_duplicate (
+ bonobo_object_corba_objref (bonobo_object (listener)), &ev),
+ (CORBA_char *) eventType,
+ &ev);
+
+ if (ev._major != CORBA_NO_EXCEPTION)
+ {
+ return FALSE;
+ }
+ else
+ {
+ return TRUE;
+ }
+}
/**
* getDesktopCount:
*
**/
Accessible*
-getDesktop (int n)
+getDesktop (int i)
{
- return Obj_Add (Accessibility_Registry_getDesktop (registry, (CORBA_short) n, &ev));
+ return Obj_Add (Accessibility_Registry_getDesktop (registry, (CORBA_short) i, &ev));
}
/**
* It is the responsibility of the caller to free this array when
* it is no longer needed.
*
- * Not Yet Implemented.
+ * Not Yet Implemented : this implementation always returns a single
+ * #Accessible desktop.
*
* Returns: an integer indicating how many virtual desktops have been
* placed in the list pointed to by parameter @list.
/**
* registerAccessibleKeystrokeListener:
- * @listener: a pointer to the #AccessibleKeystrokeListener for which
- * keystroke events are requested.
- *
+ * @listener: a pointer to the #AccessibleKeystrokeListener for which
+ * keystroke events are requested.
+ * @keys: a pointer to the #AccessibleKeySet indicating which
+ * keystroke events are requested, or #SPI_KEYSET_ALL_KEYS.
+ * @modmask: an #AccessibleKeyMaskType mask indicating which
+ * key event modifiers must be set in combination with @keys,
+ * events will only be reported for key events for which all
+ * modifiers in @modmask are set. If you wish to listen for
+ * events with multiple modifier combinations you must call
+ * registerAccessibleKeystrokeListener() once for each combination.
+ * @eventmask: an #AccessibleKeyMaskType mask indicating which
+ * types of key events are requested (#SPI_KEY_PRESSED, etc.).
+ * @sync_type: a #AccessibleKeyListenerSyncType parameter indicating
+ * the behavior of the notification/listener transaction.
+ *
+ * Register a listener for keystroke events, either pre-emptively for
+ * all windows (SPI_KEYLISTENER_ALL_WINDOWS), or
+ * non-preemptively (SPI_KEYLISTENER_NOSYNC).
+ * ( Other sync_type values may be available in the future.)
**/
void
registerAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
* deregisterAccessibleKeystrokeListener:
* @listener: a pointer to the #AccessibleKeystrokeListener for which
* keystroke events are requested.
+ * @modmask: the key modifier mask for which this listener is to be
+ * 'deregistered' (of type #AccessibleeyMaskType).
*
**/
void
-deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener, AccessibleKeyMaskType keymask)
+deregisterAccessibleKeystrokeListener (AccessibleKeystrokeListener *listener,
+ AccessibleKeyMaskType modmask)
{
Accessibility_ControllerEventMask *controller_event_mask =
Accessibility_ControllerEventMask__alloc();
Accessibility_KeyEventTypeSeq *key_events = Accessibility_KeyEventTypeSeq__alloc();
Accessibility_KeystrokeListener spi_listener_corba_ref;
Accessibility_DeviceEventController_unref (device_event_controller, &ev);
- controller_event_mask->value = (CORBA_unsigned_long) keymask;
+ controller_event_mask->value = (CORBA_unsigned_long) modmask;
controller_event_mask->refcount = (CORBA_unsigned_short) 1;
spi_listener_corba_ref = (Accessibility_KeystrokeListener)
/**
* generateKeyEvent:
- * @keycode: a #long indicating the keycode of the key event
+ * @keyval: a long integer indicating the keycode or keysym of the key event
* being synthesized.
- * @meta: a #long indicating the key modifiers to be sent
- * with the event, if any.
+ * @synth_type: a #AccessibleKeySynthType flag indicating whether @keyval
+ * is to be interpreted as a keysym rather than a keycode
+ * (SPI_KEYSYM), or whether to synthesize
+ * SPI_KEY_PRESS, SPI_KEY_RELEASE, or both (SPI_KEY_PRESSRELEASE).
*
* Synthesize a keyboard event (as if a hardware keyboard event occurred in the
* current UI context).
- * Not Yet Implemented.
*
**/
void
-generateKeyEvent (long keyval, AccessibleKeySynthType type)
+generateKeyEvent (long int keyval, AccessibleKeySynthType synth_type)
{
/* TODO: check current modifier status and
* send keycode to alter, if necessary
Accessibility_Registry_getDeviceEventController (registry, &ev);
Accessibility_DeviceEventController_generateKeyEvent (device_event_controller,
keyval,
- (unsigned long) type,
+ (unsigned long) synth_type,
&ev);
}
* (e.g. "button1", "button2", "mousemove").
*
* Synthesize a mouse event at a specific screen coordinate.
+ * Most AT clients should use the #AccessibleAction interface when
+ * tempted to generate mouse events, rather than this method.
* Not Yet Implemented.
*
**/
+/**
+ * AccessibleSelection_ref:
+ * @obj: a pointer to the #AccessibleSelecion implementor on which to operate.
+ *
+ * Increment the reference count for an #AccessibleSelection object.
+ *
+ * Returns: (no return code implemented yet).
+ *
+ **/
int
AccessibleSelection_ref (AccessibleSelection *obj)
{
}
-
+/**
+ * AccessibleSelection_unref:
+ * @obj: a pointer to the #AccessibleSelection implementor on which to operate.
+ *
+ * Decrement the reference count for an #Accessible object.
+ *
+ * Returns: (no return code implemented yet).
+ *
+ **/
int
AccessibleSelection_unref (AccessibleSelection *obj)
{
+/**
+ * AccessibleSelection_getNSelectedChildren:
+ * @obj: a pointer to the #AccessibleSelection implementor on which to operate.
+ *
+ * Get the number of children of an #AccessibleSelection implementor which are
+ * currently selected.
+ *
+ * Returns: a #long indicating the number of #Accessible children
+ * of the #AccessibleSelection implementor which are currently selected.
+ *
+ **/
long
AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj)
{
}
-
+/**
+ * AccessibleSelection_getSelectedChild:
+ * @obj: a pointer to the #AccessibleSelection on which to operate.
+ * @selectedChildIndex: a #long indicating which of the selected
+ * children is specified.
+ *
+ * Get the i-th selected #Accessible child of an #AccessibleSelection.
+ * Note that @childIndex refers to the index in the list of 'selected'
+ * children and generally differs from that used in
+ * #Accessible_getChildAtIndex() or returned by
+ * #Accessible_getIndexInParent(). @selectedChildIndex must lie between 0
+ * and #AccessibleSelection_getNSelectedChildren()-1, inclusive.
+ *
+ * Returns: a pointer to a selected #Accessible child object,
+ * specified by @childIndex.
+ *
+ **/
Accessible *
AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
- long selectedChildIndex)
+ long int selectedChildIndex)
{
Accessibility_Accessible child =
Accessibility_Selection_getSelectedChild (*obj,
return (Accessible *) ((CORBA_Object_is_nil (child, &ev)) ? NULL : Obj_Add (child));
}
+/**
+ * AccessibleSelection_selectChild:
+ * @obj: a pointer to the #AccessibleSelection on which to operate.
+ * @childIndex: a #long indicating which child of the #Accessible
+ * is to be selected.
+ *
+ * Add a child to the selected children list of an #AccessibleSelection.
+ * For #AccessibleSelection implementors that only allow
+ * single selections, this may replace the (single) current
+ * selection.
+ *
+ * Returns: #TRUE if the child was successfully selected, #FALSE otherwise.
+ *
+ **/
boolean
AccessibleSelection_selectChild (AccessibleSelection *obj,
- long childIndex)
+ long int childIndex)
{
return (boolean)
Accessibility_Selection_selectChild (*obj,
}
-
+/**
+ * AccessibleSelection_deselectSelectedChild:
+ * @obj: a pointer to the #AccessibleSelection on which to operate.
+ * @selectedChildIndex: a #long indicating which of the selected children
+ * of the #Accessible is to be selected.
+ *
+ * Remove a child to the selected children list of an #AccessibleSelection.
+ * Note that @childIndex is the index in the selected-children list,
+ * not the index in the parent container. @selectedChildIndex in this
+ * method, and @childIndex in #AccessibleSelection_selectChild
+ * are asymmettric.
+ *
+ * Returns: #TRUE if the child was successfully deselected, #FALSE otherwise.
+ *
+ **/
boolean
AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
- long selectedChildIndex)
+ long int selectedChildIndex)
{
Accessibility_Selection_deselectSelectedChild (*obj,
(CORBA_long) selectedChildIndex, &ev);
+/**
+ * AccessibleSelection_isChildSelected:
+ * @obj: a pointer to the #AccessibleSelection implementor on which to operate.
+ * @childIndex: an index into the #AccessibleSelection's list of children.
+ *
+ * Determine whether a particular child of an #AccessibleSelection implementor
+ * is currently selected. Note that @childIndex is the index into the
+ * standard #Accessible container's list of children.
+ *
+ * Returns: #TRUE if the specified child is currently selected,
+ * #FALSE otherwise.
+ *
+ **/
boolean
AccessibleSelection_isChildSelected (AccessibleSelection *obj,
- long childIndex)
+ long int childIndex)
{
return (boolean)
Accessibility_Selection_isChildSelected (*obj,
-void
+/**
+ * AccessibleSelection_selectAll:
+ * @obj: a pointer to the #AccessibleSelection implementor on which to operate.
+ *
+ * Attempt to select all of the children of an #AccessibleSelection implementor.
+ * Not all #AccessibleSelection implementors support this operation.
+ *
+ * Returns: #TRUE if successful, #FALSE otherwise.
+ *
+ **/
+boolean
AccessibleSelection_selectAll (AccessibleSelection *obj)
{
Accessibility_Selection_selectAll (*obj, &ev);
+ return TRUE; /* TODO: change the bonobo method to return boolean */
}
+/**
+ * AccessibleSelection_clearSelection:
+ * @obj: a pointer to the #AccessibleSelection implementor on which to operate.
+ *
+ * Clear the current selection, removing all selected children from the
+ * specified #AccessibleSelection implementor's selection list.
+ *
+ **/
void
AccessibleSelection_clearSelection (AccessibleSelection *obj)
{
+/**
+ * AccessibleText_ref:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ *
+ * Increment the reference count for an #AccessibleText object.
+ *
+ * Returns: (no return code implemented yet).
+ *
+ **/
int
AccessibleText_ref (AccessibleText *obj)
{
+/**
+ * AccessibleText_unref:
+ * @obj: a pointer to the #Accessible object on which to operate.
+ *
+ * Decrement the reference count for an #AccessibleText object.
+ *
+ * Returns: (no return code implemented yet).
+ *
+ **/
int
AccessibleText_unref (AccessibleText *obj)
{
}
-
+/**
+ * AccessibleText_getCharacterCount:
+ * @obj: a pointer to the #AccessibleText object to query.
+ *
+ * Get the character count of an #AccessibleText object.
+ *
+ * Returns: a long integer indicating the total number of
+ * characters in the #AccessibleText object.
+ *
+ **/
long
AccessibleText_getCharacterCount (AccessibleText *obj)
{
+/**
+ * AccessibleText_getText:
+ * @obj: a pointer to the #AccessibleText object to query.
+ * @startOffset: a #long indicating the start of the desired text range.
+ * @endOffset: a #long indicating the first character past the desired range.
+ *
+ * Get a range of text from an #AccessibleText object. The number of bytes
+ * in the returned string may exceed endOffset-startOffset, since
+ * UTF-8 is a variable-width encoding.
+ *
+ * Returns: a text string containing characters from @startOffset
+ * to @endOffset-1, inclusive, encoded as UTF-8.
+ *
+ **/
char *
AccessibleText_getText (AccessibleText *obj,
- long startOffset,
- long endOffset)
+ long int startOffset,
+ long int endOffset)
{
return (char *)
Accessibility_Text_getText (*obj,
(CORBA_long) startOffset, (CORBA_long) endOffset, &ev);
}
-
-
-
+/**
+ * AccessibleText_getCaretOffset:
+ * @obj: a pointer to the #AccessibleText object to query.
+ *
+ * Get the current offset of the text caret in an #AccessibleText object.
+ *
+ * Returns: a long integer indicating the current position of the text caret.
+ *
+ **/
long
AccessibleText_getCaretOffset (AccessibleText *obj)
{
}
-
+/**
+ * AccessibleText_getAttributes:
+ * @obj: a pointer to the #AccessibleText object to query.
+ * @offset: a long integer indicating the offset from which the attribute
+ * search is based.
+ * @startOffset: a #long indicating the start of the desired text range.
+ * @endOffset: a #long indicating the first character past the desired range.
+ *
+ * Get the attributes applied to a range of text from an #AccessibleText
+ * object, and the bounds of the range.
+ *
+ * Returns: a text string describing the attributes occurring within the
+ * attribute run containing @offset, encoded as UTF-8 and
+ * delimited by ':'
+ *
+ **/
char *
AccessibleText_getAttributes (AccessibleText *obj,
- long offset,
- long *startOffset,
- long *endOffset)
+ long int offset,
+ long int *startOffset,
+ long int *endOffset)
{
CORBA_long retStartOffset, retEndOffset;
char *retval;
+/**
+ * AccessibleText_setCaretOffset:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @newOffset: the offset to which the text caret is to be moved.
+ *
+ * Set the text caret position for an #AccessibleText object.
+ *
+ * Returns: #TRUE if successful, #FALSE otherwise.
+ *
+ **/
boolean
AccessibleText_setCaretOffset (AccessibleText *obj,
- long newOffset)
+ long int newOffset)
{
return (boolean)
Accessibility_Text_setCaretOffset (*obj,
(CORBA_long) newOffset, &ev);
}
-
-
+/**
+ * AccessibleText_getTextBeforeOffset:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @offset: a long integer indicating the offset from which the delimiter
+ * search is based.
+ * @type: an #AccessibleTextBoundaryType indicating whether the desired
+ * text string is a word, sentence, line, or attribute run.
+ * @startOffset: a pointer to a long integer which is assigned the
+ * starting offset of the returned string, relative to the
+ * original #AccessibleText.
+ * @endOffset: a pointer to a long integer which is assigned the
+ * ending offset of the returned string, relative to the original
+ * #AccessibleText.
+ *
+ * Get delimited text from an #AccessibleText object which precedes a given
+ * text offset.
+ *
+ * Returns: a UTF-8 string representing the delimited text, both of whose
+ * delimiting boundaries are before the current offset, or
+ * an empty string if no such text exists.
+ *
+ **/
char *
AccessibleText_getTextBeforeOffset (AccessibleText *obj,
- long offset,
+ long int offset,
AccessibleTextBoundaryType type,
- long *startOffset, long *endOffset)
+ long int *startOffset,
+ long int *endOffset)
{
char *retval;
CORBA_long retStartOffset, retEndOffset;
return retval;
}
-
-
+/**
+ * AccessibleText_getTextAtOffset:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @offset: a long integer indicating the offset from which the delimiter
+ * search is based.
+ * @type: an #AccessibleTextBoundaryType indicating whether the desired
+ * text string is a word, sentence, line, or attribute run.
+ * @startOffset: a pointer to a long integer which is assigned the
+ * starting offset of the returned string, relative to the
+ * original #AccessibleText.
+ * @endOffset: a pointer to a long integer which is assigned the
+ * ending offset of the returned string, relative to the original
+ * #AccessibleText.
+ *
+ * Get delimited text from an #AccessibleText object which includes a given
+ * text offset.
+ *
+ * Returns: a UTF-8 string representing the delimited text, whose
+ * delimiting boundaries bracket the current offset, or
+ * an empty string if no such text exists.
+ *
+ **/
char *
AccessibleText_getTextAtOffset (AccessibleText *obj,
- long offset,
+ long int offset,
AccessibleTextBoundaryType type,
- long *startOffset, long *endOffset)
+ long int *startOffset, long int *endOffset)
{
CORBA_long corbaStartOffset;
CORBA_long corbaEndOffset;
}
-
+/**
+ * AccessibleText_getTextAfterOffset:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @offset: a long integer indicating the offset from which the delimiter
+ * search is based.
+ * @type: an #AccessibleTextBoundaryType indicating whether the desired
+ * text string is a word, sentence, line, or attribute run.
+ * @startOffset: a pointer to a long integer which is assigned the
+ * starting offset of the returned string, relative to the
+ * original #AccessibleText.
+ * @endOffset: a pointer to a long integer which is assigned the
+ * ending offset of the returned string, relative to the original
+ * #AccessibleText.
+ *
+ * Get delimited text from an #AccessibleText object which follows a given
+ * text offset.
+ *
+ * Returns: a UTF-8 string representing the delimited text, both of whose
+ * delimiting boundaries are after or inclusive of the current
+ * offset, or an empty string if no such text exists.
+ *
+ **/
char *
AccessibleText_getTextAfterOffset (AccessibleText *obj,
- long offset,
+ long int offset,
AccessibleTextBoundaryType type,
- long *startOffset, long *endOffset)
+ long int *startOffset, long int *endOffset)
{
char *retval;
CORBA_long retStartOffset, retEndOffset;
+/**
+ * AccessibleText_getCharacterAtOffset:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @offset: a long integer indicating the text offset where the desired
+ * character is located.
+ *
+ * Get the character at a given offset for an #AccessibleText object.
+ *
+ * Returns: an #unsigned long integer which represents the
+ * UCS-4 unicode code point of the given character, or
+ * 0xFFFFFFFF if the character in question cannot be represented
+ * in the UCS-4 encoding.
+ *
+ **/
unsigned long
AccessibleText_getCharacterAtOffset (AccessibleText *obj,
- long offset)
+ long int offset)
{
return (unsigned long)
Accessibility_Text_getCharacterAtOffset (*obj,
(CORBA_long) offset, &ev);
}
-
-
+/**
+ * AccessibleText_getCharacterExtents:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @offset: an integer indicating the offset of the text character for
+ * whom boundary information is requested.
+ * @x: a pointer to a long integer into which the nominal x coordinate
+ * of the corresponding glyph will be returned.
+ * @y:a pointer to a long integer into which the nominal y coordinate
+ * of the corresponding glyph will be returned.
+ * @width:a pointer to a long integer into which the width
+ * of the corresponding glyph will be returned.
+ * @height: a pointer to a long integer into which the height
+ * of the corresponding glyph will be returned.
+ * @type: an #AccessibleCoordType indicating the coordinate system to use
+ * for the returned values.
+ *
+ * Get the bounding box containing the glyph representing
+ * the character at a particular text offset.
+ *
+ **/
void
AccessibleText_getCharacterExtents (AccessibleText *obj,
- long offset,
- long *x,
- long *y,
- long *width,
- long *height,
+ long int offset,
+ long int *x,
+ long int *y,
+ long int *width,
+ long int *height,
AccessibleCoordType type)
{
CORBA_long retX, retY, retWidth, retHeight;
}
-
+/**
+ * AccessibleText_getOffsetAtPoint:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @x: the x coordinate of the point to be queried.
+ * @y: the y coordinate of the point to be queried.
+ * @type: an #AccessibleCoordType indicating the coordinate system in which
+ * the values should be returned.
+ *
+ * Get the bounding box for a glyph at a certain #AccessibleText offset.
+ *
+ * Returns: the offset (as a long integer) at the point (@x, @y)
+ * in the specified coordinate system.
+ *
+ **/
long
AccessibleText_getOffsetAtPoint (AccessibleText *obj,
- long x,
- long y,
+ long int x,
+ long int y,
AccessibleCoordType type)
{
return (long)
}
+/**
+ * AccessibleText_getNSelections:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ *
+ * Get the number of active non-contiguous selections for an
+ * #AccessibleText object.
+ *
+ * Returns: a long integer indicating the current
+ * number of non-contiguous text selections active
+ * within an #AccessibleText object.
+ *
+ **/
long
AccessibleText_getNSelections (AccessibleText *obj)
{
+/**
+ * AccessibleText_getSelection:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @selectionNum: an integer indicating which selection to query.
+ * @startOffset: a pointer to a long integer into which the start offset
+ * of the selection will be returned.
+ * @endOffset: a pointer to a long integer into which the start offset
+ * of the selection will be returned.
+ *
+ * Get the bounds of the @selectionNum-th active text selection for an
+ * #AccessibleText object.
+ *
+ **/
void
AccessibleText_getSelection (AccessibleText *obj,
- long selectionNum, long *startOffset,
- long *endOffset)
+ long int selectionNum,
+ long int *startOffset,
+ long int *endOffset)
{
CORBA_long retStartOffset, retEndOffset;
Accessibility_Text_getSelection (*obj,
+/**
+ * AccessibleText_addSelection:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @startOffset: the starting offset of the desired new selection.
+ * @endOffset: the offset of the first character after the new selection.
+ *
+ * Select some text (add a text selection) in an #AccessibleText object.
+ *
+ * Returns: #TRUE if successful, #FALSE otherwise.
+ *
+ **/
boolean
AccessibleText_addSelection (AccessibleText *obj,
- long startOffset, long endOffset)
+ long int startOffset, long int endOffset)
{
return (boolean)
Accessibility_Text_addSelection (*obj,
}
+/**
+ * AccessibleText_removeSelection:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @selectionNum: an integer indicating which (possibly of several)
+ * text selection to remove.
+ *
+ * De-select a text selection.
+ *
+ * Returns: #TRUE if successful, #FALSE otherwise.
+ *
+ **/
boolean
AccessibleText_removeSelection (AccessibleText *obj,
- long selectionNum)
+ long int selectionNum)
{
return (boolean)
Accessibility_Text_removeSelection (*obj,
(CORBA_long) selectionNum, &ev);
}
-
-
+/**
+ * AccessibleText_setSelection:
+ * @obj: a pointer to the #AccessibleText object on which to operate.
+ * @selectionNum: a zero-offset index indicating which text selection to modify.
+ * @startOffset: a long int, the new starting offset for the selection.
+ * @endOffset: a long int, the desired new offset of the first character
+ * after the selection.
+ *
+ * Change the bounds of an existing #AccessibleText text selection.
+ *
+ * Returns: #TRUE if successful, #FALSE otherwise.
+ *
+ **/
boolean
AccessibleText_setSelection (AccessibleText *obj,
- long selectionNum,
- long startOffset,
- long endOffset)
+ long int selectionNum,
+ long int startOffset,
+ long int endOffset)
{
return (boolean)
Accessibility_Text_setSelection (*obj,
+/**
+ * AccessibleValue_ref:
+ * @obj: a pointer to the #AccessibleValue implementor on which to operate.
+ *
+ * Increment the reference count for an #AccessibleValue object.
+ *
+ * Returns: (no return code implemented yet).
+ *
+ **/
int
AccessibleValue_ref (AccessibleValue *obj)
{
+/**
+ * AccessibleValue_unref:
+ * @obj: a pointer to the #AccessibleValue implementor on which to operate.
+ *
+ * Decrement the reference count for an #AccessibleValue object.
+ *
+ * Returns: (no return code implemented yet).
+ *
+ **/
int
AccessibleValue_unref (AccessibleValue *obj)
{
+/**
+ * AccessibleValue_getMinimumValue:
+ * @obj: a pointer to the #AccessibleValue implementor on which to operate.
+ *
+ * Get the minimum allowed value for an #AccessibleValue.
+ *
+ * Returns: the minimum allowed value for this object.
+ *
+ **/
float
AccessibleValue_getMinimumValue (AccessibleValue *obj)
{
+/**
+ * AccessibleValue_getCurrentValue:
+ * @obj: a pointer to the #AccessibleValue implementor on which to operate.
+ *
+ * Get the current value for an #AccessibleValue.
+ *
+ * Returns: the current value for this object.
+ *
+ **/
float
AccessibleValue_getCurrentValue (AccessibleValue *obj)
{
+/**
+ * AccessibleValue_getMaximumValue:
+ * @obj: a pointer to the #AccessibleValue implementor on which to operate.
+ *
+ * Get the maximum allowed value for an #AccessibleValue.
+ *
+ * Returns: the maximum allowed value for this object.
+ *
+ **/
float
AccessibleValue_getMaximumValue (AccessibleValue *obj)
{
+/**
+ * AccessibleValue_setCurrentValue:
+ * @obj: a pointer to the #AccessibleValue implementor on which to operate.
+ * @newValue: a #float value which is the desired new value of the object.
+ *
+ * Set the current value of an #AccessibleValue.
+ *
+ * Returns: #TRUE if the value could be assigned the specified value,
+ * #FALSE otherwise.
+ *
+ **/
boolean
AccessibleValue_setCurrentValue (AccessibleValue *obj,
float newValue)
EXTRA_DIST = Makefile.am at-spi-docs.sgml at-spi-sections.txt
+# Files whose declarations are to be ignored (private)
+IGNORE_HFILES = spi-impl.h
+
# The name of the module.
DOC_MODULE=at-spi
<!doctype book PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
-<!entity at-spi-spi_main SYSTEM "sgml/spi_main.sgml">
-<!entity at-spi-spi_event SYSTEM "sgml/spi_event.sgml">
-<!entity at-spi-spi_registry SYSTEM "sgml/spi_registry.sgml">
-<!entity at-spi-spi_application SYSTEM "sgml/spi_application.sgml">
-<!entity at-spi-spi_accessible SYSTEM "sgml/spi_accessible.sgml">
-<!entity at-spi-spi_component SYSTEM "sgml/spi_component.sgml">
+<!entity at-spi-spi-main SYSTEM "sgml/spi_main.sgml">
+<!entity at-spi-spi-event SYSTEM "sgml/spi_event.sgml">
+<!entity at-spi-spi-registry SYSTEM "sgml/spi_registry.sgml">
+<!entity at-spi-spi-application SYSTEM "sgml/spi_application.sgml">
+<!entity at-spi-spi-accessible SYSTEM "sgml/spi_accessible.sgml">
+<!entity at-spi-spi-action SYSTEM "sgml/spi_action.sgml">
+<!entity at-spi-spi-component SYSTEM "sgml/spi_component.sgml">
+<!entity at-spi-spi-editabletext SYSTEM "sgml/spi_editabletext.sgml">
+<!entity at-spi-spi-hypertext SYSTEM "sgml/spi_hypertext.sgml">
+<!entity at-spi-spi-image SYSTEM "sgml/spi_image.sgml">
+<!entity at-spi-spi-selection SYSTEM "sgml/spi_selection.sgml">
+<!entity at-spi-spi-table SYSTEM "sgml/spi_table.sgml">
+<!entity at-spi-spi-text SYSTEM "sgml/spi_text.sgml">
+<!entity at-spi-spi-value SYSTEM "sgml/spi_value.sgml">
+<!entity at-spi-spi-hyperlink SYSTEM "sgml/spi_hyperlink.sgml">
+<!entity at-spi-spi-relation SYSTEM "sgml/spi_relation.sgml">
+<!entity at-spi-spi-stateset SYSTEM "sgml/spi_stateset.sgml">
]>
<book>
</bookinfo>
<chapter id="spi-main">
<title>SPI Main Event Loop and Registry</title>
- &at-spi-spi_main;
- &at-spi-spi_event;
- &at-spi-spi_registry;
+ &at-spi-spi-main;
+ &at-spi-spi-event;
+ &at-spi-spi-registry;
</chapter>
<chapter id="spi-application">
<title>AccessibleApplication Methods</title>
- &at-spi-spi_application;
+ &at-spi-spi-application;
</chapter>
<chapter id="spi-accessible">
<title>Basic Accessible Object Methods and Interface Query</title>
- &at-spi-spi_accessible;
+ &at-spi-spi-accessible;
+ &at-spi-spi-relation;
+ &at-spi-spi-stateset;
</chapter>
<chapter id="spi-component">
<title>Subinterface Methods</title>
- &at-spi-spi_component;
+ &at-spi-spi-action;
+ &at-spi-spi-component;
+ &at-spi-spi-editabletext;
+ &at-spi-spi-hypertext;
+ &at-spi-spi-image;
+ &at-spi-spi-selection;
+ &at-spi-spi-table;
+ &at-spi-spi-text;
+ &at-spi-spi-value;
+ </chapter>
+ <chapter>
+ <title>Auxiliary Types</title>
+ &at-spi-spi-hyperlink;
</chapter>
</book>
<SECTION>
<FILE>spi_event</FILE>
<TITLE>Event Listener Support</TITLE>
-createEventListener
-EventListener_addCallback
-EventListener_removeCallback
+AccessibleEvent
+AccessibleEventListenerCB
+createAccessibleEventListener
+AccessibleEventListener_addCallback
+AccessibleEventListener_removeCallback
</SECTION>
<SECTION>
<FILE>spi_registry</FILE>
<TITLE>Registry queries</TITLE>
+AccessibleKeySynthType
getDesktopCount
getDesktop
getDesktopList
<SUBSECTION Event Registration>
+AccessibleKeystrokeListenerCB
+AccessibleKeyEventMask
+AccessibleKeyMaskType
+AccessibleKeyEventType
+AccessibleKeyListenerSyncType
+SPI_KEYSET_ALL_KEYS
+createAccessibleKeystrokeListener
registerGlobalEventListener
-registerKeystrokeListener
+deregisterGlobalEventListener
+deregisterGlobalEventListenerAll
+registerAccessibleKeystrokeListener
+deregisterAccessibleKeystrokeListener
+AccessibleKeystrokeListener_removeCallback
+AccessibleKeystrokeListener_addCallback
generateKeyEvent
generateMouseEvent
</SECTION>
Accessible_getDescription
Accessible_getParent
Accessible_getChildCount
+Accessible_getChildAtIndex
Accessible_getIndexInParent
Accessible_getRelationSet
Accessible_getRole
Accessible_getTable
Accessible_getText
Accessible_queryInterface
+<SUBSECTION Auxiliary types>
+AccessibleRole
</SECTION>
<SECTION>
</SECTION>
<SECTION>
+<FILE>spi_action</FILE>
+<TITLE>AccessibleAction Interface</TITLE>
+AccessibleAction_ref
+AccessibleAction_unref
+AccessibleAction_getNActions
+AccessibleAction_doAction
+AccessibleAction_getKeyBinding
+AccessibleAction_getDescription
+</SECTION>
+
+<SECTION>
<FILE>spi_component</FILE>
<TITLE>AccessibleComponent Interface</TITLE>
+AccessibleCoordType
AccessibleComponent_ref
AccessibleComponent_unref
AccessibleComponent_contains
AccessibleComponent_getPosition
AccessibleComponent_getSize
AccessibleComponent_grabFocus
-</SECTION>
\ No newline at end of file
+</SECTION>
+
+<SECTION>
+<FILE>spi_editabletext</FILE>
+<TITLE>AccessibleEditableText Interface</TITLE>
+AccessibleEditableText_ref
+AccessibleEditableText_unref
+AccessibleEditableText_copyText
+AccessibleEditableText_deleteText
+AccessibleEditableText_insertText
+AccessibleEditableText_cutText
+AccessibleEditableText_pasteText
+AccessibleEditableText_setTextContents
+AccessibleEditableText_setRunAttributes
+</SECTION>
+
+<SECTION>
+<FILE>spi_hypertext</FILE>
+<TITLE>AccessibleHypertext Interface</TITLE>
+AccessibleHypertext_ref
+AccessibleHypertext_unref
+AccessibleHypertext_getNLinks
+AccessibleHypertext_getLink
+AccessibleHypertext_getLinkIndex
+</SECTION>
+
+<SECTION>
+<FILE>spi_image</FILE>
+<TITLE>AccessibleImage Interface</TITLE>
+AccessibleImage_ref
+AccessibleImage_unref
+AccessibleImage_getImageDescription
+AccessibleImage_getImageSize
+AccessibleImage_getImagePosition
+</SECTION>
+
+<SECTION>
+<FILE>spi_selection</FILE>
+<TITLE>AccessibleSelection Interface</TITLE>
+AccessibleSelection_ref
+AccessibleSelection_unref
+AccessibleSelection_getNSelectedChildren
+AccessibleSelection_getSelectedChild
+AccessibleSelection_selectChild
+AccessibleSelection_isChildSelected
+AccessibleSelection_deselectSelectedChild
+AccessibleSelection_clearSelection
+AccessibleSelection_selectAll
+</SECTION>
+
+<SECTION>
+<FILE>spi_table</FILE>
+<TITLE>AccessibleTable Interface</TITLE>
+AccessibleTable_ref
+AccessibleTable_unref
+AccessibleTable_getCaption
+AccessibleTable_getColumnAtIndex
+AccessibleTable_getColumnDescription
+AccessibleTable_getColumnExtentAt
+AccessibleTable_getColumnHeader
+AccessibleTable_getIndexAt
+AccessibleTable_getNColumns
+AccessibleTable_getNRows
+AccessibleTable_getNSelectedColumns
+AccessibleTable_getNSelectedRows
+AccessibleTable_getRowAtIndex
+AccessibleTable_getRowDescription
+AccessibleTable_getRowExtentAt
+AccessibleTable_getRowHeader
+AccessibleTable_getSelectedRows
+AccessibleTable_getSelectedColumns
+AccessibleTable_getSummary
+AccessibleTable_isColumnSelected
+AccessibleTable_isRowSelected
+AccessibleTable_isSelected
+AccessibleTable_refAt
+</SECTION>
+
+<SECTION>
+<FILE>spi_text</FILE>
+<TITLE>AccessibleText Interface</TITLE>
+AccessibleTextBoundaryType
+AccessibleText_ref
+AccessibleText_unref
+AccessibleText_addSelection
+AccessibleText_getAttributes
+AccessibleText_getCaretOffset
+AccessibleText_getCharacterCount
+AccessibleText_getCharacterExtents
+AccessibleText_getNSelections
+AccessibleText_getOffsetAtPoint
+AccessibleText_getSelection
+AccessibleText_getText
+AccessibleText_getTextBeforeOffset
+AccessibleText_getTextAfterOffset
+AccessibleText_getTextAtOffset
+AccessibleText_removeSelection
+AccessibleText_setCaretOffset
+AccessibleText_setSelection
+</SECTION>
+
+<SECTION>
+<FILE>spi_value</FILE>
+<TITLE>AccessibleValue Interface</TITLE>
+AccessibleValue_ref
+AccessibleValue_unref
+AccessibleValue_getCurrentValue
+AccessibleValue_getMaximumValue
+AccessibleValue_getMinimumValue
+AccessibleValue_setCurrentValue
+</SECTION>
+
+<SECTION>
+<FILE>spi_hyperlink</FILE>
+<TITLE>AccessibleHyperlink Interface</TITLE>
+AccessibleHyperlink_getNAnchors
+AccessibleHyperlink_getIndexRange
+AccessibleHyperlink_getObject
+AccessibleHyperlink_getURI
+AccessibleHyperlink_isValid
+</SECTION>
+
+<SECTION>
+<FILE>spi_stateset</FILE>
+<TITLE>State and StateSets</TITLE>
+AccessibleState
+AccessibleStateSet_ref
+AccessibleStateSet_unref
+AccessibleStateSet_add
+AccessibleStateSet_compare
+AccessibleStateSet_contains
+AccessibleStateSet_equals
+AccessibleStateSet_isEmpty
+AccessibleStateSet_remove
+
+</SECTION>
+
+<SECTION>
+<FILE>spi_relation</FILE>
+<TITLE>AccessibleRelations and RelationSets</TITLE>
+AccessibleRelationType
+AccessibleRelation_ref
+AccessibleRelation_unref
+AccessibleRelation_getTarget
+AccessibleRelation_getRelationType
+</SECTION>
/*
* A pointer to our parent object class
*/
-static SpiListenerClass *spi_accessible_event_listener_parent_class;
+static SpiListenerClass *spi_event_listener_parent_class;
/*
* Implemented GObject::finalize
*/
static void
-spi_accessible_event_listener_object_finalize (GObject *object)
+spi_event_listener_object_finalize (GObject *object)
{
#ifdef SPI_DEBUG
fprintf(stderr, "spi_listener_object_finalize called\n");
#endif
- ((GObjectClass *) spi_accessible_event_listener_parent_class)->finalize (object);
+ ((GObjectClass *) spi_event_listener_parent_class)->finalize (object);
}
/*
{
int n;
int len;
- VoidEventListenerCB cb;
- SpiAccessibleEventListener *listener = SPI_ACCESSIBLE_EVENT_SPI_LISTENER (
+ VoidSpiEventListenerCB cb;
+ SpiEventListener *listener = SPI_ACCESSIBLE_EVENT_SPI_LISTENER (
bonobo_object_from_servant (servant));
len = g_list_length (listener->callbacks);
for (n=0; n<len; ++n)
{
- cb = (VoidEventListenerCB) g_list_nth_data (listener->callbacks, n);
+ cb = (VoidSpiEventListenerCB) g_list_nth_data (listener->callbacks, n);
if (cb)
{
(*cb) (e);
}
static void
-spi_accessible_event_listener_class_init (SpiAccessibleEventListenerClass *klass)
+spi_event_listener_class_init (SpiEventListenerClass *klass)
{
GObjectClass * object_class = (GObjectClass *) klass;
SpiListenerClass * spi_listener_class = (SpiListenerClass *) klass;
POA_Accessibility_EventListener__epv *epv = &spi_listener_class->epv;
- spi_accessible_event_listener_parent_class = g_type_class_ref (SPI_LISTENER_TYPE);
+ spi_event_listener_parent_class = g_type_class_ref (SPI_LISTENER_TYPE);
- object_class->finalize = spi_accessible_event_listener_object_finalize;
+ object_class->finalize = spi_event_listener_object_finalize;
epv->notifyEvent = impl_accessible_event_notify_event;
}
static void
-spi_accessible_event_listener_init (SpiAccessibleEventListener *listener)
+spi_event_listener_init (SpiEventListener *listener)
{
listener->callbacks = NULL;
}
GType
-spi_accessible_event_listener_get_type (void)
+spi_event_listener_get_type (void)
{
static GType type = 0;
if (!type) {
static const GTypeInfo tinfo = {
- sizeof (SpiAccessibleEventListenerClass),
+ sizeof (SpiEventListenerClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
- (GClassInitFunc) spi_accessible_event_listener_class_init,
+ (GClassInitFunc) spi_event_listener_class_init,
(GClassFinalizeFunc) NULL,
NULL, /* class data */
sizeof (SpiListener),
0, /* n preallocs */
- (GInstanceInitFunc) spi_accessible_event_listener_init,
+ (GInstanceInitFunc) spi_event_listener_init,
NULL /* value table */
};
/*
NULL,
G_STRUCT_OFFSET (SpiListenerClass, epv),
&tinfo,
- "SpiAccessibleEventListener");
+ "SpiEventListener");
}
return type;
}
-SpiAccessibleEventListener *
-spi_accessible_event_listener_new ()
+SpiEventListener *
+spi_event_listener_new ()
{
- SpiAccessibleEventListener *retval =
- SPI_ACCESSIBLE_EVENT_SPI_LISTENER (g_object_new (spi_accessible_event_listener_get_type (), NULL));
+ SpiEventListener *retval =
+ SPI_ACCESSIBLE_EVENT_SPI_LISTENER (g_object_new (spi_event_listener_get_type (), NULL));
return retval;
}
-void spi_accessible_event_listener_add_callback (SpiAccessibleEventListener *listener,
- VoidEventListenerCB callback)
+void spi_event_listener_add_callback (SpiEventListener *listener,
+ VoidSpiEventListenerCB callback)
{
listener->callbacks = g_list_append (listener->callbacks, callback);
}
-void spi_accessible_event_listener_remove_callback (SpiAccessibleEventListener *listener,
- VoidEventListenerCB callback)
+void spi_event_listener_remove_callback (SpiEventListener *listener,
+ VoidSpiEventListenerCB callback)
{
listener->callbacks = g_list_remove (listener->callbacks, callback);
}
#include "listener.h"
-#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE (spi_accessible_event_listener_get_type ())
-#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE, SpiAccessibleEventListener))
-#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE, SpiAccessibleEventListenerClass))
+#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE (spi_event_listener_get_type ())
+#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE, SpiEventListener))
+#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE, SpiEventListenerClass))
#define IS_SPI_ACCESSIBLE_EVENT_SPI_LISTENER(o) (G_TYPE_CHECK__INSTANCE_TYPE ((o), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE))
#define IS_SPI_ACCESSIBLE_EVENT_SPI_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE))
-typedef void (*VoidEventListenerCB) (gpointer event_ptr);
+typedef void (*VoidSpiEventListenerCB) (gpointer event_ptr);
typedef struct {
SpiListener parent;
GList *callbacks;
-} SpiAccessibleEventListener;
+} SpiEventListener;
typedef struct {
SpiListenerClass parent_class;
-} SpiAccessibleEventListenerClass;
-
-GType spi_accessible_event_listener_get_type (void);
-SpiAccessibleEventListener *spi_accessible_event_listener_new (void);
-void spi_accessible_event_listener_add_callback (SpiAccessibleEventListener *listener,
- VoidEventListenerCB callback);
-void spi_accessible_event_listener_remove_callback (SpiAccessibleEventListener *listener,
- VoidEventListenerCB callback);
+} SpiEventListenerClass;
+
+GType spi_event_listener_get_type (void);
+SpiEventListener *spi_event_listener_new (void);
+void spi_event_listener_add_callback (SpiEventListener *listener,
+ VoidSpiEventListenerCB callback);
+void spi_event_listener_remove_callback (SpiEventListener *listener,
+ VoidSpiEventListenerCB callback);
#ifdef __cplusplus
}
/*
* A pointer to our parent object class
*/
-static SpiListenerClass *spi_accessible_event_listener_parent_class;
+static SpiListenerClass *spi_event_listener_parent_class;
/*
* Implemented GObject::finalize
*/
static void
-spi_accessible_event_listener_object_finalize (GObject *object)
+spi_event_listener_object_finalize (GObject *object)
{
#ifdef SPI_DEBUG
fprintf(stderr, "spi_listener_object_finalize called\n");
#endif
- ((GObjectClass *) spi_accessible_event_listener_parent_class)->finalize (object);
+ ((GObjectClass *) spi_event_listener_parent_class)->finalize (object);
}
/*
{
int n;
int len;
- VoidEventListenerCB cb;
- SpiAccessibleEventListener *listener = SPI_ACCESSIBLE_EVENT_SPI_LISTENER (
+ VoidSpiEventListenerCB cb;
+ SpiEventListener *listener = SPI_ACCESSIBLE_EVENT_SPI_LISTENER (
bonobo_object_from_servant (servant));
len = g_list_length (listener->callbacks);
for (n=0; n<len; ++n)
{
- cb = (VoidEventListenerCB) g_list_nth_data (listener->callbacks, n);
+ cb = (VoidSpiEventListenerCB) g_list_nth_data (listener->callbacks, n);
if (cb)
{
(*cb) (e);
}
static void
-spi_accessible_event_listener_class_init (SpiAccessibleEventListenerClass *klass)
+spi_event_listener_class_init (SpiEventListenerClass *klass)
{
GObjectClass * object_class = (GObjectClass *) klass;
SpiListenerClass * spi_listener_class = (SpiListenerClass *) klass;
POA_Accessibility_EventListener__epv *epv = &spi_listener_class->epv;
- spi_accessible_event_listener_parent_class = g_type_class_ref (SPI_LISTENER_TYPE);
+ spi_event_listener_parent_class = g_type_class_ref (SPI_LISTENER_TYPE);
- object_class->finalize = spi_accessible_event_listener_object_finalize;
+ object_class->finalize = spi_event_listener_object_finalize;
epv->notifyEvent = impl_accessible_event_notify_event;
}
static void
-spi_accessible_event_listener_init (SpiAccessibleEventListener *listener)
+spi_event_listener_init (SpiEventListener *listener)
{
listener->callbacks = NULL;
}
GType
-spi_accessible_event_listener_get_type (void)
+spi_event_listener_get_type (void)
{
static GType type = 0;
if (!type) {
static const GTypeInfo tinfo = {
- sizeof (SpiAccessibleEventListenerClass),
+ sizeof (SpiEventListenerClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
- (GClassInitFunc) spi_accessible_event_listener_class_init,
+ (GClassInitFunc) spi_event_listener_class_init,
(GClassFinalizeFunc) NULL,
NULL, /* class data */
sizeof (SpiListener),
0, /* n preallocs */
- (GInstanceInitFunc) spi_accessible_event_listener_init,
+ (GInstanceInitFunc) spi_event_listener_init,
NULL /* value table */
};
/*
NULL,
G_STRUCT_OFFSET (SpiListenerClass, epv),
&tinfo,
- "SpiAccessibleEventListener");
+ "SpiEventListener");
}
return type;
}
-SpiAccessibleEventListener *
-spi_accessible_event_listener_new ()
+SpiEventListener *
+spi_event_listener_new ()
{
- SpiAccessibleEventListener *retval =
- SPI_ACCESSIBLE_EVENT_SPI_LISTENER (g_object_new (spi_accessible_event_listener_get_type (), NULL));
+ SpiEventListener *retval =
+ SPI_ACCESSIBLE_EVENT_SPI_LISTENER (g_object_new (spi_event_listener_get_type (), NULL));
return retval;
}
-void spi_accessible_event_listener_add_callback (SpiAccessibleEventListener *listener,
- VoidEventListenerCB callback)
+void spi_event_listener_add_callback (SpiEventListener *listener,
+ VoidSpiEventListenerCB callback)
{
listener->callbacks = g_list_append (listener->callbacks, callback);
}
-void spi_accessible_event_listener_remove_callback (SpiAccessibleEventListener *listener,
- VoidEventListenerCB callback)
+void spi_event_listener_remove_callback (SpiEventListener *listener,
+ VoidSpiEventListenerCB callback)
{
listener->callbacks = g_list_remove (listener->callbacks, callback);
}
#include "listener.h"
-#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE (spi_accessible_event_listener_get_type ())
-#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE, SpiAccessibleEventListener))
-#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE, SpiAccessibleEventListenerClass))
+#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE (spi_event_listener_get_type ())
+#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE, SpiEventListener))
+#define SPI_ACCESSIBLE_EVENT_SPI_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE, SpiEventListenerClass))
#define IS_SPI_ACCESSIBLE_EVENT_SPI_LISTENER(o) (G_TYPE_CHECK__INSTANCE_TYPE ((o), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE))
#define IS_SPI_ACCESSIBLE_EVENT_SPI_LISTENER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SPI_ACCESSIBLE_EVENT_SPI_LISTENER_TYPE))
-typedef void (*VoidEventListenerCB) (gpointer event_ptr);
+typedef void (*VoidSpiEventListenerCB) (gpointer event_ptr);
typedef struct {
SpiListener parent;
GList *callbacks;
-} SpiAccessibleEventListener;
+} SpiEventListener;
typedef struct {
SpiListenerClass parent_class;
-} SpiAccessibleEventListenerClass;
-
-GType spi_accessible_event_listener_get_type (void);
-SpiAccessibleEventListener *spi_accessible_event_listener_new (void);
-void spi_accessible_event_listener_add_callback (SpiAccessibleEventListener *listener,
- VoidEventListenerCB callback);
-void spi_accessible_event_listener_remove_callback (SpiAccessibleEventListener *listener,
- VoidEventListenerCB callback);
+} SpiEventListenerClass;
+
+GType spi_event_listener_get_type (void);
+SpiEventListener *spi_event_listener_new (void);
+void spi_event_listener_add_callback (SpiEventListener *listener,
+ VoidSpiEventListenerCB callback);
+void spi_event_listener_remove_callback (SpiEventListener *listener,
+ VoidSpiEventListenerCB callback);
#ifdef __cplusplus
}
projects / platform / upstream / at-spi2-core.git / commitdiff