/** * AccessibleHyperlink_getObject: * @obj: a pointer to the #AccessibleHyperlink implementor on which to operate. * @i: a (zero-index) long integer indicating which hyperlink anchor to query. * * Get the object associated with a particular hyperlink anchor, as an #Accessible. * * Returns: an #Accessible that represents the object associated with the @ith anchor * of the specified #AccessibleHyperlink. **/ Accessible* AccessibleHyperlink_getObject (AccessibleHyperlink *obj, long int i) { cspi_return_val_if_fail (obj != NULL, NULL); return cspi_object_add ( Accessibility_Hyperlink_getObject (CSPI_OBJREF (obj), i, cspi_ev ())); }
/** * AccessibleTable_getSummary: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * * Get an accessible object which summarizes the contents of an #AccessibleTable. * * Returns: an #Accessible object that serves as the table's summary (often a * reduced #AccessibleTable). **/ Accessible * AccessibleTable_getSummary (AccessibleTable *obj) { Accessible *retval; cspi_return_val_if_fail (obj != NULL, NULL); retval = cspi_object_add ( Accessibility_Table__get_summary (CSPI_OBJREF (obj), cspi_ev ())); cspi_return_val_if_ev ("getSummary", NULL); return retval; }
/** * AccessibleHypertext_getNLinks: * @obj: a pointer to the #AccessibleHypertext implementor on which to operate. * * Get the total number of #AccessibleHyperlinks which an * #AccessibleHypertext implementor has. * * Returns: a #long indicating the number of #AccessibleHyperlinks * of the #AccessibleHypertext implementor, or -1 if * the number cannot be determined (for example, if the * #AccessibleHypertext object is so large that it is not * all currently in the memory cache). **/ long AccessibleHypertext_getNLinks (AccessibleHypertext *obj) { dbus_int32_t retval; cspi_return_val_if_fail (obj != NULL, FALSE); cspi_dbus_call (obj, spi_interface_hypertext, "getNLinks", NULL, "=>i", &retval); cspi_return_val_if_ev ("getNLinks", -1); return retval; }
/** * AccessibleImage_getImageLocale: * @obj: The #AccessibleImage being queried. * * Get the locale associated with an image and its textual representation. * * Returns: A POSIX LC_MESSAGES-style Locale value for image description and text. **/ char * AccessibleImage_getImageLocale (AccessibleImage *obj) { char *retval = "C"; cspi_return_val_if_fail (obj != NULL, "C"); cspi_dbus_get_property (obj, spi_interface_image, "imageLocale", NULL, "=>s", &retval); cspi_return_val_if_ev ("getImageLocale", NULL); return retval; }
/** * AccessibleImage_getImageDescription: * @obj: a pointer to the #AccessibleImage implementor on which to operate. * * Get the description of the image displayed in an #AccessibleImage object. * * Returns: a UTF-8 string describing the image. **/ char * AccessibleImage_getImageDescription (AccessibleImage *obj) { char *retval; cspi_return_val_if_fail (obj != NULL, NULL); cspi_dbus_get_property (obj, spi_interface_image, "description", NULL, "s", &retval); cspi_return_val_if_ev ("getImageDescription", NULL); return retval; }
/** * 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) { dbus_int32_t retval; cspi_return_val_if_fail (obj != NULL, -1); cspi_dbus_get_property (obj, spi_interface_action, "nActions", NULL, "i", &retval); cspi_return_val_if_ev ("getNActions", -1); return retval; }
/** * AccessibleAction_getDescription: * @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 * object implementing #AccessibleAction. * * Returns: a UTF-8 string describing the '@i-th' invokable action. **/ char * AccessibleAction_getDescription (AccessibleAction *obj, long int i) { dbus_int32_t d_i = i; char *retval; cspi_return_val_if_fail (obj != NULL, NULL); cspi_dbus_call (obj, spi_interface_action, "getDescription", NULL, "i=>s", d_i, &retval); cspi_return_val_if_ev ("getDescription", NULL); return retval; }
/** * AccessibleHyperlink_isValid: * @obj: a pointer to the #AccessibleHyperlink on which to operate. * * Tell whether an #AccessibleHyperlink object is still valid with respect to its * originating hypertext object. * * Returns: #TRUE of the specified #AccessibleHyperlink is still valid with respect * to its originating #AccessibleHypertext object, #FALSE otherwise. **/ SPIBoolean AccessibleHyperlink_isValid (AccessibleHyperlink *obj) { SPIBoolean retval; cspi_return_val_if_fail (obj != NULL, FALSE); retval = Accessibility_Hyperlink_isValid (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("isValid", FALSE); return retval; }
/** * AccessibleHyperlink_getNAnchors: * @obj: a pointer to the #AccessibleHyperlink object on which to operate. * * Get the total number of anchors which an #AccessibleHyperlink implementor has. * Though typical hyperlinks have only one anchor, client-side image maps and * other hypertext objects may potentially activate or refer to multiple * URIs. For each anchor there is a corresponding URI and object. * @see AccessibleHyperlink_getURI() and AccessibleHyperlink_getObject(). * * Returns: a #long indicating the number of anchors in this hyperlink. **/ long AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj) { long retval; cspi_return_val_if_fail (obj != NULL, -1); retval = Accessibility_Hyperlink__get_nAnchors (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getNAnchors", -1); return retval; }
/** * AccessibleTable_getNSelectedColumns: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * * Query a table to find out how many columns are currently selected. Not all tables * support column selection. * * Returns: a long integer indicating the number of columns currently selected. **/ long AccessibleTable_getNSelectedColumns (AccessibleTable *obj) { long retval; cspi_return_val_if_fail (obj != NULL, -1); retval = Accessibility_Table__get_nSelectedColumns (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getNSelectedColumns", -1); return retval; }
/** * AccessibleHypertext_getLinkIndex: * @obj: a pointer to the #AccessibleHypertext implementor on which to operate. * @characterOffset: an integer specifying the character offset to query. * * Get the index of the #AccessibleHyperlink object at a specified * character offset. * * Returns: the linkIndex of the #AccessibleHyperlink active at * character offset @characterOffset, or -1 if there is * no hyperlink at the specified character offset. **/ long AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj, long int characterOffset) { dbus_int32_t d_characterOffset = characterOffset; dbus_int32_t retval; cspi_return_val_if_fail (obj != NULL, -1); cspi_dbus_call (obj, spi_interface_hypertext, "getLinkIndex", NULL, "i=>i", d_characterOffset, &retval); cspi_return_val_if_ev ("getLinkIndex", -1); return retval; }
/** * 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. **/ SPIBoolean AccessibleAction_doAction (AccessibleAction *obj, long int i) { dbus_int32_t d_i = i; dbus_bool_t retval; cspi_return_val_if_fail (obj != NULL, FALSE); cspi_dbus_call (obj, spi_interface_action, "doAction", NULL, "i=>b", d_i, &retval); cspi_return_val_if_ev ("doAction", FALSE); return retval; }
/** * AccessibleTable_getColumnHeader: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @column: the specified table column, zero-indexed. * * Get the header associated with a table column, if available. This differs from * AccessibleTable_getColumnDescription, which returns a string. * * Returns: a #Accessible representatin of the specified table column, if available. **/ Accessible * AccessibleTable_getColumnHeader (AccessibleTable *obj, long int column) { Accessible *retval; cspi_return_val_if_fail (obj != NULL, NULL); retval = cspi_object_add ( Accessibility_Table_getColumnHeader (CSPI_OBJREF (obj), column, cspi_ev ())); cspi_return_val_if_ev ("getColumnHeader", NULL); return retval; }
/** * AccessibleTable_getSelectedColumns: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @selectedColumns: a doubly indirected pointer which will be set to the address * of an array of long integers, specifying which columns are currently selected. * * Query a table for a list of indices of columns which are currently selected. * Not all tables support column selection. * * Returns: a long integer indicating the length of the array returned in @selectedColumns. **/ long AccessibleTable_getSelectedColumns (AccessibleTable *obj, long int **selectedColumns) { Accessibility_LongSeq *columns; *selectedColumns = NULL; cspi_return_val_if_fail (obj != NULL, 0); columns = Accessibility_Table_getSelectedColumns (CSPI_OBJREF (obj), cspi_ev ()); cspi_return_val_if_ev ("getSelectedColumns", -1); return cspi_long_seq_to_array (columns, selectedColumns); }
/** * AccessibleTable_getColumnDescription: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @column: the specified table column, zero-indexed. * * Get a text description of a particular table column. This differs from * AccessibleTable_getColumnHeader, which returns an #Accessible. * * Returns: a UTF-8 string describing the specified table column, if available. **/ char * AccessibleTable_getColumnDescription (AccessibleTable *obj, long int column) { char *retval; cspi_return_val_if_fail (obj != NULL, NULL); retval = Accessibility_Table_getColumnDescription (CSPI_OBJREF (obj), column, cspi_ev ()); cspi_return_val_if_ev ("getColumnDescription", NULL); return retval; }
/** * AccessibleTable_removeColumnSelection: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @column: the zero-indexed column number of the column being de-selected. * * De-select the specified column, removing it to the current column selection. * Not all tables support column selection. * * Returns: #TRUE if the specified column was successfully de-selected, #FALSE if not. **/ SPIBoolean AccessibleTable_removeColumnSelection (AccessibleTable *obj, long int column) { SPIBoolean retval; cspi_return_val_if_fail (obj != NULL, FALSE); retval = Accessibility_Table_removeColumnSelection (CSPI_OBJREF (obj), column, cspi_ev ()); cspi_return_val_if_ev ("removeColumnSelection", FALSE); return retval; }
/** * AccessibleTable_addRowSelection: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @row: the zero-indexed row number of the row being selected. * * Select the specified row, adding it to the current row selection. * Not all tables support row selection. * * Returns: #TRUE if the specified row was successfully selected, #FALSE if not. **/ SPIBoolean AccessibleTable_addRowSelection (AccessibleTable *obj, long int row) { SPIBoolean retval; cspi_return_val_if_fail (obj != NULL, FALSE); retval = Accessibility_Table_addRowSelection (CSPI_OBJREF (obj), row, cspi_ev ()); cspi_return_val_if_ev ("addRowSelection", FALSE); return retval; }
/** * AccessibleTable_getColumnAtIndex: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @index: the specified child index, zero-indexed. * * Get the table column index occupied by the child at a particular 1-D child index. * * @see #AccessibleTable_getIndexAt(), #AccessibleTable_getRowAtIndex() * * Returns: a long integer indicating the first column spanned by the child of a * table, at the specified 1-D (zero-offset) @index. **/ long AccessibleTable_getColumnAtIndex (AccessibleTable *obj, long index) { long retval; cspi_return_val_if_fail (obj != NULL, -1); retval = Accessibility_Table_getColumnAtIndex (CSPI_OBJREF (obj), index, cspi_ev ()); cspi_return_val_if_ev ("getColumnAtIndex", -1); return retval; }
/** * AccessibleHyperlink_getURI: * @obj: a pointer to the #AccessibleHyperlink implementor on which to operate. * @i: a (zero-index) long integer indicating which hyperlink anchor to query. * * Get the URI associated with a particular hyperlink anchor. * * Returns: a UTF-8 string giving the URI of the @ith hyperlink anchor. **/ char * AccessibleHyperlink_getURI (AccessibleHyperlink *obj, long int i) { char *retval; cspi_return_val_if_fail (obj != NULL, NULL); retval = Accessibility_Hyperlink_getURI (CSPI_OBJREF (obj), i, cspi_ev ()); cspi_return_val_if_ev ("getURI", NULL); return retval; }
/** * AccessibleTable_getColumnExtentAt: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @row: the specified table row, zero-indexed. * @column: the specified table column, zero-indexed. * * Get the number of columns spanned by the table cell at the specific row and column. * (some tables can have cells which span multiple rows and/or columns). * * Returns: a long integer indicating the number of columns spanned by the specified cell. **/ long AccessibleTable_getColumnExtentAt (AccessibleTable *obj, long int row, long int column) { long retval; cspi_return_val_if_fail (obj != NULL, -1); retval = Accessibility_Table_getColumnExtentAt ( CSPI_OBJREF (obj), row, column, cspi_ev ()); cspi_return_val_if_ev ("getColumnExtentAt", -1); return retval; }
/** * AccessibleTable_isSelected: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @row: the zero-indexed row of the cell being queried. * @column: the zero-indexed column of the cell being queried. * * Determine whether the cell at a specific row and column is selected. * * Returns: #TRUE if the specified cell is currently selected, #FALSE if not. **/ SPIBoolean AccessibleTable_isSelected (AccessibleTable *obj, long int row, long int column) { SPIBoolean retval; cspi_return_val_if_fail (obj != NULL, FALSE); retval = Accessibility_Table_isSelected (CSPI_OBJREF (obj), row, column, cspi_ev ()); cspi_return_val_if_ev ("isSelected", FALSE); return retval; }
/** * AccessibleHypertext_getLink: * @obj: a pointer to the #AccessibleHypertext implementor on which to operate. * @linkIndex: a (zero-index) long integer indicating which hyperlink to query. * * Get the #AccessibleHyperlink object at a specified index. * * Returns: the #AccessibleHyperlink object specified by #linkIndex. **/ AccessibleHyperlink * AccessibleHypertext_getLink (AccessibleHypertext *obj, long int linkIndex) { dbus_int32_t d_linkIndex = linkIndex; char *path; AccessibleHyperlink *retval; cspi_return_val_if_fail (obj != NULL, NULL); cspi_dbus_call (obj, spi_interface_hypertext, "getLink", NULL, "i=>o", d_linkIndex, &path); cspi_return_val_if_ev ("getLink", NULL); retval = cspi_ref_related_accessible (obj, path); g_free (path); return retval; }
/** * AccessibleTable_getRowColumnExtentsAtIndex: * @obj: a pointer to the #AccessibleTable implementor on which to operate. * @index: the index of the Table child whose row/column * extents are requested. * @row: back-filled with the first table row associated with * the cell with child index \c index. * @col: back-filled with the first table column associated * with the cell with child index \c index. * @row_extents: back-filled with the number of table rows * across which child \c i extends. * @col_extents: back-filled with the number of table columns * across which child \c i extends. * @is_selected: a boolean which is back-filled with \c True * if the child at index \c i corresponds to a selected table cell, * \c False otherwise. * * Given a child index, determine the row and column indices and * extents, and whether the cell is currently selected. If * the child at \c index is not a cell (for instance, if it is * a summary, caption, etc.), \c False is returned. * * Example: * If the Table child at index '6' extends across columns 5 and 6 of * row 2 of a Table instance, and is currently selected, then * * retval = table::getRowColumnExtentsAtIndex (6, row, col, * row_extents, * col_extents, * is_selected); * * will return True, and after the call * row, col, row_extents, col_extents, * and \c is_selected will contain 2, 5, 1, 2, and * True, respectively. * * Returns: \c True if the index is associated with a valid table * cell, \c False if the index does not correspond to a cell. If * \c False is returned, the values of the out parameters are * undefined. * * Since AT-SPI 1.7.0 **/ SPIBoolean AccessibleTable_getRowColumnExtentsAtIndex (AccessibleTable *obj, long int index, long int *row, long int *col, long int *row_extents, long int *col_extents, long int *is_selected){ SPIBoolean retval; CORBA_long cRow, cCol, cRow_extents, cCol_extents; CORBA_boolean cIs_selected; cspi_return_val_if_fail (obj != NULL, FALSE); retval = Accessibility_Table_getRowColumnExtentsAtIndex (CSPI_OBJREF (obj), index, &cRow, &cCol, &cRow_extents, &cCol_extents, &cIs_selected, cspi_ev ()); if (!cspi_check_ev ("getRowColumnExtentsAtIndex")){ *row = 0; *col = 0; *row_extents = 0; *col_extents = 0; *is_selected = FALSE; retval = FALSE; } else { *row = cRow; *col = cCol; *row_extents = cRow_extents;; *col_extents = cCol_extents; *is_selected = cIs_selected;; } return retval; }