/** * atspi_table_cell_get_row_column_span: * @obj: a GObject instance that implements AtspiTableCellIface * @row: (out): the row index of the given cell. * @column: (out): the column index of the given cell. * @row_span: (out): the number of rows occupied by this cell. * @column_span: (out): the number of columns occupied by this cell. * * Gets the row and column indexes and extents of this cell accessible. */ void atspi_table_cell_get_row_column_span (AtspiTableCell *obj, gint *row, gint *column, gint *row_span, gint *column_span, GError **error) { dbus_int32_t d_row = 0, d_column = 0, d_row_span = 0, d_column_span = 0; if (row) *row = -1; if (column) *column = -1; if (row_span) *row_span = -1; if (column_span) *column_span = -1; g_return_if_fail (obj != NULL); _atspi_dbus_call (obj, atspi_interface_table_cell, "GetRowColumnSpan", error, "=>iiii", &d_row, &d_column, &d_row_span, &d_column_span); if (row) *row = d_row; if (column) *column = d_column; if (row_span) *row_span = d_row_span; if (column_span) *column_span = d_column_span; }
/** * atspi_hypertext_get_n_links: * @obj: a pointer to the #AtspiHypertext implementor on which to operate. * * Gets the total number of #AtspiHyperlink objects that an * #AtspiHypertext implementor has. * * Returns: a #gint indicating the number of #AtspiHyperlink objects * of the #AtspiHypertext implementor, or -1 if * the number cannot be determined (for example, if the * #AtspiHypertext object is so large that it is not * all currently in the memory cache). **/ gint atspi_hypertext_get_n_links (AtspiHypertext *obj, GError **error) { dbus_int32_t retval = 0; g_return_val_if_fail (obj != NULL, FALSE); _atspi_dbus_call (obj, atspi_interface_hypertext, "GetNLinks", error, "=>i", &retval); return retval; }
/** * atspi_hyperlink_is_valid: * @obj: a pointer to the #AtspiHyperlink on which to operate. * * Tells whether an #AtspiHyperlink object is still valid with respect to its * originating hypertext object. * * Returns: #TRUE if the specified #AtspiHyperlink is still valid with respect * to its originating #AtspiHypertext object, #FALSE otherwise. **/ gboolean atspi_hyperlink_is_valid (AtspiHyperlink *obj, GError **error) { dbus_bool_t retval = FALSE; g_return_val_if_fail (obj != NULL, FALSE); _atspi_dbus_call (obj, atspi_interface_hyperlink, "IsValid", error, "=>b", &retval); return retval; }
/** * atspi_action_get_key_binding: * @obj: a pointer to the #AtspiAction implementor to query. * @i: an integer indicating which action to query. * * Get the keybindings for the @i-th action invocable on an * object implementing #AtspiAction, if any are defined. * The keybindings string format is as follows: * there are multiple parts to a keybinding string (typically 3). * They are delimited with ";". The first is the action's * keybinding which is usable if the object implementing the action * is currently posted to the screen, e.g. if a menu is posted * then these keybindings for the corresponding menu-items are * available. The second keybinding substring is the full key sequence * necessary to post the action's widget and activate it, e.g. for * a menu item such as "File->Open" it would both post the menu and * activate the item. Thus the second keybinding string is available * during the lifetime of the containing toplevel window as a whole, * whereas the first keybinding string only works while the object * implementing AtkAction is posted. The third (and optional) * keybinding string is the "keyboard shortcut" which invokes the * action without posting any menus. * Meta-keys are indicated by the conventional strings * "<Control>", "<Alt>", "<Shift>", "<Mod2>", * etc. (we use the same string as gtk_accelerator_name() in * gtk+-2.X. * * Returns: a UTF-8 string which can be parsed to determine the @i-th * invocable action's keybindings. **/ gchar * atspi_action_get_key_binding (AtspiAction *obj, gint i, GError **error) { dbus_int32_t d_i = i; char *retval = NULL; g_return_val_if_fail (obj != NULL, NULL); _atspi_dbus_call (obj, atspi_interface_action, "GetKeyBinding", error, "i=>s", d_i, &retval); return retval; }
/** * atspi_action_get_description: * @obj: a pointer to the #AtspiAction implementor to query. * @i: an integer indicating which action to query. * * Get the description of '@i-th' action invocable on an * object implementing #AtspiAction. * * Returns: a UTF-8 string describing the '@i-th' invocable action. **/ gchar * atspi_action_get_description (AtspiAction *obj, int i, GError **error) { dbus_int32_t d_i = i; char *retval = NULL; g_return_val_if_fail (obj != NULL, NULL); _atspi_dbus_call (obj, atspi_interface_action, "GetDescription", error, "i=>s", d_i, &retval); return retval; }
/** * atspi_action_do_action: * @obj: a pointer to the #AtspiAction 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. **/ gboolean atspi_action_do_action (AtspiAction *obj, gint i, GError **error) { dbus_int32_t d_i = i; dbus_bool_t retval = FALSE; g_return_val_if_fail (obj != NULL, FALSE); _atspi_dbus_call (obj, atspi_interface_action, "DoAction", error, "i=>b", d_i, &retval); return retval; }
/** * atspi_hypertext_get_link_index: * @obj: a pointer to the #AtspiHypertext implementor on which to operate. * @character_offset: a #gint specifying the character offset to query. * * Gets the index of the #AtspiHyperlink object at a specified * character offset. * * Returns: the linkIndex of the #AtspiHyperlink active at * character offset @character_offset, or -1 if there is * no hyperlink at the specified character offset. **/ int atspi_hypertext_get_link_index (AtspiHypertext *obj, gint character_offset, GError **error) { dbus_int32_t d_character_offset = character_offset; dbus_int32_t retval = -1; g_return_val_if_fail (obj != NULL, -1); _atspi_dbus_call (obj, atspi_interface_hypertext, "GetLinkIndex", error, "i=>i", d_character_offset, &retval); return retval; }
/** * atspi_hyperlink_get_uri: * @obj: a pointer to the #AtspiHyperlink implementor on which to operate. * @i: a (zero-index) integer indicating which hyperlink anchor to query. * * Gets the URI associated with a particular hyperlink anchor. * * Returns: a UTF-8 string giving the URI of the @ith hyperlink anchor. **/ gchar * atspi_hyperlink_get_uri (AtspiHyperlink *obj, int i, GError **error) { dbus_int32_t d_i = i; char *retval = NULL; g_return_val_if_fail (obj != NULL, NULL); _atspi_dbus_call (obj, atspi_interface_hyperlink, "GetURI", error, "i=>s", d_i, &retval); if (!retval) retval = g_strdup (""); return retval; }
/** * atspi_hyperlink_get_index_range: * @obj: a pointer to the #AtspiHyperlink implementor on which to operate. * * * Gets the starting and ending character offsets of the text range * associated with an #AtspiHyperlink, in its originating #AtspiHypertext. **/ AtspiRange * atspi_hyperlink_get_index_range (AtspiHyperlink *obj, GError **error) { dbus_int32_t d_start_offset, d_end_offset; AtspiRange *ret = g_new (AtspiRange, 1); ret->start_offset = ret->end_offset = -1; if (!obj) return ret; _atspi_dbus_call (obj, atspi_interface_hyperlink, "GetIndexRange", error, "=>ii", &d_start_offset, &d_end_offset); ret->start_offset = d_start_offset; ret->end_offset = d_end_offset; return ret; }