Renamed SpiAccessibleEventListener to (just) SpiEventListener.
[platform/core/uifw/at-spi2-atk.git] / cspi / spi_text.c
index f1f083f..7656c89 100644 (file)
@@ -1,5 +1,14 @@
+/**
+ * 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
-SpiAccessibleText_ref (SpiAccessibleText *obj)
+AccessibleText_ref (AccessibleText *obj)
 {
   Accessibility_Text_ref (*obj, &ev);
   return 0;
@@ -7,17 +16,35 @@ SpiAccessibleText_ref (SpiAccessibleText *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
-SpiAccessibleText_unref (SpiAccessibleText *obj)
+AccessibleText_unref (AccessibleText *obj)
 {
   Accessibility_Text_unref (*obj, &ev);
   return 0;
 }
 
 
-
+/**
+ * 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
-SpiAccessibleText_getCharacterCount (SpiAccessibleText *obj)
+AccessibleText_getCharacterCount (AccessibleText *obj)
 {
   long retval;
 
@@ -32,33 +59,68 @@ SpiAccessibleText_getCharacterCount (SpiAccessibleText *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 *
-SpiAccessibleText_getText (SpiAccessibleText *obj,
-                        long startOffset,
-                        long endOffset)
+AccessibleText_getText (AccessibleText *obj,
+                        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
-SpiAccessibleText_getCaretOffset (SpiAccessibleText *obj)
+AccessibleText_getCaretOffset (AccessibleText *obj)
 {
   return (long)
     Accessibility_Text__get_caretOffset (*obj, &ev);
 }
 
 
-
+/**
+ * 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 *
-SpiAccessibleText_getAttributes (SpiAccessibleText *obj,
-                                long offset,
-                                long *startOffset,
-                                long *endOffset)
+AccessibleText_getAttributes (AccessibleText *obj,
+                             long int offset,
+                             long int *startOffset,
+                             long int *endOffset)
 {
   CORBA_long retStartOffset, retEndOffset;
   char *retval;        
@@ -75,22 +137,53 @@ SpiAccessibleText_getAttributes (SpiAccessibleText *obj,
 
 
 
+/**
+ * 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
-SpiAccessibleText_setCaretOffset (SpiAccessibleText *obj,
-                               long newOffset)
+AccessibleText_setCaretOffset (AccessibleText *obj,
+                               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 *
-SpiAccessibleText_getTextBeforeOffset (SpiAccessibleText *obj,
-                                    long offset,
-                                    SPI_TEXT_BOUNDARY_TYPE type,
-                                   long *startOffset, long *endOffset)
+AccessibleText_getTextBeforeOffset (AccessibleText *obj,
+                                    long int offset,
+                                    AccessibleTextBoundaryType type,
+                                   long int *startOffset,
+                                   long int *endOffset)
 {
   char *retval;
   CORBA_long retStartOffset, retEndOffset;
@@ -104,13 +197,33 @@ SpiAccessibleText_getTextBeforeOffset (SpiAccessibleText *obj,
   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 *
-SpiAccessibleText_getTextAtOffset (SpiAccessibleText *obj,
-                               long offset,
-                               SPI_TEXT_BOUNDARY_TYPE type,
-                               long *startOffset, long *endOffset)
+AccessibleText_getTextAtOffset (AccessibleText *obj,
+                               long int offset,
+                               AccessibleTextBoundaryType type,
+                               long int *startOffset, long int *endOffset)
 {
   CORBA_long corbaStartOffset;
   CORBA_long corbaEndOffset;
@@ -130,12 +243,33 @@ SpiAccessibleText_getTextAtOffset (SpiAccessibleText *obj,
 }
 
 
-
+/**
+ * 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 *
-SpiAccessibleText_getTextAfterOffset (SpiAccessibleText *obj,
-                                    long offset,
-                                    SPI_TEXT_BOUNDARY_TYPE type,
-                                   long *startOffset, long *endOffset)
+AccessibleText_getTextAfterOffset (AccessibleText *obj,
+                                  long int offset,
+                                  AccessibleTextBoundaryType type,
+                                  long int *startOffset, long int *endOffset)
 {
   char *retval;
   CORBA_long retStartOffset, retEndOffset;
@@ -151,25 +285,57 @@ SpiAccessibleText_getTextAfterOffset (SpiAccessibleText *obj,
 
 
 
+/**
+ * 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
-SpiAccessibleText_getCharacterAtOffset (SpiAccessibleText *obj,
-                                     long offset)
+AccessibleText_getCharacterAtOffset (AccessibleText *obj,
+                                     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
-SpiAccessibleText_getCharacterExtents (SpiAccessibleText *obj,
-                                    long offset,
-                                    long *x,
-                                    long *y,
-                                    long *width,
-                                    long *height,
-                                   SpiAccessibleCoordType type)
+AccessibleText_getCharacterExtents (AccessibleText *obj,
+                                    long int offset,
+                                    long int *x,
+                                    long int *y,
+                                    long int *width,
+                                    long int *height,
+                                   AccessibleCoordType type)
 {
   CORBA_long retX, retY, retWidth, retHeight;
   Accessibility_Text_getCharacterExtents (*obj,
@@ -186,12 +352,25 @@ SpiAccessibleText_getCharacterExtents (SpiAccessibleText *obj,
 }
 
 
-
+/**
+ * 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
-SpiAccessibleText_getOffsetAtPoint (SpiAccessibleText *obj,
-                                 long x,
-                                 long y,
-                                SpiAccessibleCoordType type)
+AccessibleText_getOffsetAtPoint (AccessibleText *obj,
+                                 long int x,
+                                 long int y,
+                                AccessibleCoordType type)
 {
   return (long)
     Accessibility_Text_getOffsetAtPoint (*obj,
@@ -199,9 +378,20 @@ SpiAccessibleText_getOffsetAtPoint (SpiAccessibleText *obj,
 }
 
 
-
+/**
+ * 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
-SpiAccessibleText_getNSelections (SpiAccessibleText *obj)
+AccessibleText_getNSelections (AccessibleText *obj)
 {
   return (long)
     Accessibility_Text_getNSelections (*obj, &ev);
@@ -209,10 +399,24 @@ SpiAccessibleText_getNSelections (SpiAccessibleText *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
-SpiAccessibleText_getSelection (SpiAccessibleText *obj,
-                            long selectionNum, long *startOffset,
-                            long *endOffset)
+AccessibleText_getSelection (AccessibleText *obj,
+                            long int selectionNum,
+                            long int *startOffset,
+                            long int *endOffset)
 {
   CORBA_long retStartOffset, retEndOffset;
   Accessibility_Text_getSelection (*obj,
@@ -225,9 +429,20 @@ SpiAccessibleText_getSelection (SpiAccessibleText *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
-SpiAccessibleText_addSelection (SpiAccessibleText *obj,
-                            long startOffset, long endOffset)
+AccessibleText_addSelection (AccessibleText *obj,
+                            long int startOffset, long int endOffset)
 {
   return (boolean)
     Accessibility_Text_addSelection (*obj,
@@ -236,23 +451,44 @@ SpiAccessibleText_addSelection (SpiAccessibleText *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
-SpiAccessibleText_removeSelection (SpiAccessibleText *obj,
-                               long selectionNum)
+AccessibleText_removeSelection (AccessibleText *obj,
+                               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
-SpiAccessibleText_setSelection (SpiAccessibleText *obj,
-                            long selectionNum,
-                            long startOffset,
-                            long endOffset)
+AccessibleText_setSelection (AccessibleText *obj,
+                            long int selectionNum,
+                            long int startOffset,
+                            long int endOffset)
 {
   return (boolean)
     Accessibility_Text_setSelection (*obj,