atspi-table

## atspi-table atspi-table |

## Synopsis

                        AtspiTable;
    AtspiAccessible *   atspi_table_get_caption             (AtspiTable *obj,
                                                             GError **error);
    AtspiAccessible *   atspi_table_get_summary             (AtspiTable *obj,
                                                             GError **error);
    gint                atspi_table_get_n_rows              (AtspiTable *obj,
                                                             GError **error);
    gint                atspi_table_get_n_columns           (AtspiTable *obj,
                                                             GError **error);
    AtspiAccessible *   atspi_table_get_accessible_at       (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);
    gint                atspi_table_get_index_at            (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);
    gint                atspi_table_get_row_at_index        (AtspiTable *obj,
                                                             gint index,
                                                             GError **error);
    gint                atspi_table_get_column_at_index     (AtspiTable *obj,
                                                             gint index,
                                                             GError **error);
    gchar *             atspi_table_get_row_description     (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);
    gchar *             atspi_table_get_column_description  (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);
    gint                atspi_table_get_row_extent_at       (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);
    gint                atspi_table_get_column_extent_at    (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);
    AtspiAccessible *   atspi_table_get_row_header          (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);
    AtspiAccessible *   atspi_table_get_column_header       (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);
    gint                atspi_table_get_n_selected_rows     (AtspiTable *obj,
                                                             GError **error);
    GArray *            atspi_table_get_selected_rows       (AtspiTable *obj,
                                                             GError **error);
    GArray *            atspi_table_get_selected_columns    (AtspiTable *obj,
                                                             GError **error);
    gint                atspi_table_get_n_selected_columns  (AtspiTable *obj,
                                                             GError **error);
    gboolean            atspi_table_is_row_selected         (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);
    gboolean            atspi_table_is_column_selected      (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);
    gboolean            atspi_table_add_row_selection       (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);
    gboolean            atspi_table_add_column_selection    (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);
    gboolean            atspi_table_remove_row_selection    (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);
    gboolean            atspi_table_remove_column_selection (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);
    gboolean            atspi_table_get_row_column_extents_at_index
                                                            (AtspiTable *obj,
                                                             gint index,
                                                             gint *row,
                                                             gint *col,
                                                             gint *row_extents,
                                                             gint *col_extents,
                                                             gboolean *is_selected,
                                                             GError **error);
    gboolean            atspi_table_is_selected             (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);

## Object Hierarchy

      GInterface
       +----AtspiTable

## Known Implementations

AtspiTable is implemented by AtspiAccessible.

## Description

## Details

### AtspiTable

    typedef struct _AtspiTable AtspiTable;

### atspi_table_get_caption ()

    AtspiAccessible *   atspi_table_get_caption             (AtspiTable *obj,
                                                             GError **error);

Get an accessible representation of the caption for an AtspiTable.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`error` : |
Returns : | an Accessible object that serves as the table's caption. [transfer full]

### atspi_table_get_summary ()

    AtspiAccessible *   atspi_table_get_summary             (AtspiTable *obj,
                                                             GError **error);

Get an accessible object which summarizes the contents of an AtspiTable.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`error` : |
Returns : | an AtspiAccessible object that serves as the table's summary (often a reduced AtspiTable). [transfer full]

### atspi_table_get_n_rows ()

    gint                atspi_table_get_n_rows              (AtspiTable *obj,
                                                             GError **error);

Get the number of rows in an AtspiTable, exclusive of any rows that are programmatically hidden, but inclusive of rows that may be outside of the current scrolling window or viewport.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`error` : |
Returns : | an integer indicating the number of rows in the table.

### atspi_table_get_n_columns ()

    gint                atspi_table_get_n_columns           (AtspiTable *obj,
                                                             GError **error);

Get the number of columns in an AtspiTable, exclusive of any columns that are programmatically hidden, but inclusive of columns that may be outside of the current scrolling window or viewport.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`error` : |
Returns : | an integer indicating the number of columns in the table.

### atspi_table_get_accessible_at ()

    AtspiAccessible *   atspi_table_get_accessible_at       (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);

Get the table cell at the specified row and column indices. To get the accessible object at a particular (x, y) screen coordinate, use #`atspi_component_get_accessible_at_point()`.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the specified table row, zero-indexed.
`column` : | the specified table column, zero-indexed.
`error` : |
Returns : | an AtspiAccessible object representing the specified table cell. [transfer full]

### atspi_table_get_index_at ()

    gint                atspi_table_get_index_at            (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);

Get the 1-D child index corresponding to the specified 2-D row and column indices. To get the accessible object at a particular (x, y) screen coordinate, use #`Accessible_getAccessibleAtPoint()`. `see` #`atspi_table_getRowAtIndex()`, #`atspi_table_getColumnAtIndex()`

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the specified table row, zero-indexed.
`column` : | the specified table column, zero-indexed.
`error` : |
Returns : | a long integer which serves as the index of a specified cell in the table, in a form usable by #`Accessible_getChildAtIndex()`.

### atspi_table_get_row_at_index ()

    gint                atspi_table_get_row_at_index        (AtspiTable *obj,
                                                             gint index,
                                                             GError **error);

Get the table row index occupied by the child at a particular 1-D child index.

`see` #`atspi_table_get_indexAt()`, #`atspi_table_get_columnAtIndex()`

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`index` : | the specified child index, zero-indexed.
`error` : |
Returns : | a long integer indicating the first row spanned by the child of a table, at the specified 1-D (zero-offset) `index`.

### atspi_table_get_column_at_index ()

    gint                atspi_table_get_column_at_index     (AtspiTable *obj,
                                                             gint index,
                                                             GError **error);

Get the table column index occupied by the child at a particular 1-D child index.

`see` #`atspi_table_getIndexAt()`, #`atspi_table_getRowAtIndex()`

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`index` : | the specified child index, zero-indexed.
`error` : |
Returns : | a long integer indicating the first column spanned by the child of a table, at the specified 1-D (zero-offset) `index`.

### atspi_table_get_row_description ()

    gchar *             atspi_table_get_row_description     (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);

Get a text description of a particular table row. This differs from atspi_table_get_row_header, which returns an AtspiAccessible.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the specified table row, zero-indexed.
`error` : |
Returns : | a UTF-8 string describing the specified table row, if available.

### atspi_table_get_column_description ()

    gchar *             atspi_table_get_column_description  (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);

Get a text description of a particular table column. This differs from atspi_table_get_column_header, which returns an Accessible.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`column` : | the specified table column, zero-indexed.
`error` : |
Returns : | a UTF-8 string describing the specified table column, if available.

### atspi_table_get_row_extent_at ()

    gint                atspi_table_get_row_extent_at       (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);

Get the number of rows spanned by the table cell at the specific row and column. (some tables can have cells which span multiple rows and/or columns).

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the specified table row, zero-indexed.
`column` : | the specified table column, zero-indexed.
`error` : |
Returns : | a long integer indicating the number of rows spanned by the specified cell.

### atspi_table_get_column_extent_at ()

    gint                atspi_table_get_column_extent_at    (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);

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).

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the specified table row, zero-indexed.
`column` : | the specified table column, zero-indexed.
`error` : |
Returns : | a long integer indicating the number of columns spanned by the specified cell.

### atspi_table_get_row_header ()

    AtspiAccessible *   atspi_table_get_row_header          (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);

Get the header associated with a table row, if available. This differs from atspi_table_get_row_description, which returns a string.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the specified table row, zero-indexed.
`error` : |
Returns : | a Accessible representatin of the specified table row, if available. [transfer full]

### atspi_table_get_column_header ()

    AtspiAccessible *   atspi_table_get_column_header       (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);

Get the header associated with a table column, if available. This differs from atspi_table_get_column_description, which returns a string.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`column` : | the specified table column, zero-indexed.
`error` : |
Returns : | a AtspiAccessible representation of the specified table column, if available. [transfer full]

### atspi_table_get_n_selected_rows ()

    gint                atspi_table_get_n_selected_rows     (AtspiTable *obj,
                                                             GError **error);

Query a table to find out how many rows are currently selected. Not all tables support row selection.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`error` : |
Returns : | a long integer indicating the number of rows currently selected.

### atspi_table_get_selected_rows ()

    GArray *            atspi_table_get_selected_rows       (AtspiTable *obj,
                                                             GError **error);

Query a table for a list of indices of rows which are currently selected.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`error` : |
Returns : | an array of integers, specifying which rows are currently selected. [element-type gint][transfer full gint]

### atspi_table_get_selected_columns ()

    GArray *            atspi_table_get_selected_columns    (AtspiTable *obj,
                                                             GError **error);

Query a table for a list of indices of columns which are currently selected.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`error` : |
Returns : | an array of integers, specifying which columns are currently selected. [element-type gint][transfer full gint]

### atspi_table_get_n_selected_columns ()

    gint                atspi_table_get_n_selected_columns  (AtspiTable *obj,
                                                             GError **error);

Query a table to find out how many columns are currently selected. Not all tables support column selection.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`error` : |
Returns : | a long integer indicating the number of columns currently selected.

### atspi_table_is_row_selected ()

    gboolean            atspi_table_is_row_selected         (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);

Determine whether a table row is selected. Not all tables support row selection.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the zero-indexed row number of the row being queried.
`error` : |
Returns : | TRUE if the specified row is currently selected, FALSE if not.

### atspi_table_is_column_selected ()

    gboolean            atspi_table_is_column_selected      (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);

Determine whether specified table column is selected. Not all tables support column selection.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`column` : | the zero-indexed column number of the column being queried.
`error` : |
Returns : | TRUE if the specified column is currently selected, FALSE if not.

### atspi_table_add_row_selection ()

    gboolean            atspi_table_add_row_selection       (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);

Select the specified row, adding it to the current row selection. Not all tables support row selection.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the zero-indexed row number of the row being selected.
`error` : |
Returns : | TRUE if the specified row was successfully selected, FALSE if not.

### atspi_table_add_column_selection ()

    gboolean            atspi_table_add_column_selection    (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);

Select the specified column, adding it to the current column selection. Not all tables support column selection.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`column` : | the zero-indexed column number of the column being selected.
`error` : |
Returns : | TRUE if the specified column was successfully selected, FALSE if not.

### atspi_table_remove_row_selection ()

    gboolean            atspi_table_remove_row_selection    (AtspiTable *obj,
                                                             gint row,
                                                             GError **error);

De-select the specified row, removing it to the current row selection. Not all tables support row selection.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`row` : | the zero-indexed number of the row being deselected.
`error` : |
Returns : | TRUE if the specified row was successfully de-selected, FALSE if not.

### atspi_table_remove_column_selection ()

    gboolean            atspi_table_remove_column_selection (AtspiTable *obj,
                                                             gint column,
                                                             GError **error);

De-select the specified column, removing it to the current column selection. Not all tables support column selection.

`obj` : | a pointer to the AtspiTable implementor on which to operate.
`column` : | the zero-indexed column number of the column being de-selected.
`error` : |
Returns : | TRUE if the specified column was successfully de-selected, FALSE if not.

### atspi_table_get_row_column_extents_at_index ()

    gboolean            atspi_table_get_row_column_extents_at_index
                                                            (AtspiTable *obj,
                                                             gint index,
                                                             gint *row,
                                                             gint *col,
                                                             gint *row_extents,
                                                             gint *col_extents,
                                                             gboolean *is_selected,
                                                             GError **error);

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.

`obj` : | a pointer to the AtspiTable 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.
`error` : |
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.

### atspi_table_is_selected ()

    gboolean            atspi_table_is_selected             (AtspiTable *obj,
                                                             gint row,
                                                             gint column,
                                                             GError **error);

Determine whether the cell at a specific row and column is selected.

`obj` : | a pointer to the AtspiTable 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.
`error` : |
Returns : | TRUE if the specified cell is currently selected, FALSE if not.