+/*
+ * AT-SPI - Assistive Technology Service Provider Interface
+ * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
+ *
+ * Copyright 2001, 2002 Sun Microsystems Inc.,
+ * Copyright 2001, 2002 Ximian, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
#include <stdlib.h> /* for malloc */
#include <cspi/spi-private.h>
Accessible *
AccessibleTable_getCaption (AccessibleTable *obj)
{
- return cspi_object_add (
- Accessibility_Table__get_caption (CSPI_OBJREF (obj), cspi_ev ()));
+ char *path;
+ Accessible *retval;
+
+ cspi_return_val_if_fail (obj != NULL, NULL);
+
+ cspi_dbus_get_property (obj, spi_interface_table, "caption", NULL, "o", &path);
+ cspi_return_val_if_ev ("getCaption", NULL);
+ retval = cspi_ref_related_accessible (obj, path);
+ g_free (path);
+ return retval;
}
/**
Accessible *
AccessibleTable_getSummary (AccessibleTable *obj)
{
- return cspi_object_add (
- Accessibility_Table__get_summary (CSPI_OBJREF (obj), cspi_ev ()));
+ char *path;
+ Accessible *retval;
+
+ cspi_return_val_if_fail (obj != NULL, NULL);
+
+ cspi_dbus_get_property (obj, spi_interface_table, "summary", NULL, "o", &path);
+ cspi_return_val_if_ev ("getSummary", NULL);
+ retval = cspi_ref_related_accessible (obj, path);
+ g_free (path);
+ return retval;
}
/**
long
AccessibleTable_getNRows (AccessibleTable *obj)
{
- long retval;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table__get_nRows (CSPI_OBJREF (obj), cspi_ev ());
+ cspi_dbus_get_property (obj, spi_interface_table, "nRows", NULL, "i", &retval);
cspi_return_val_if_ev ("getNRows", -1);
long
AccessibleTable_getNColumns (AccessibleTable *obj)
{
- long retval;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table__get_nColumns (CSPI_OBJREF (obj), cspi_ev ());
+ cspi_dbus_get_property (obj, spi_interface_table, "nColumns", NULL, "i", &retval);
- cspi_return_val_if_ev ("", -1);
+ cspi_return_val_if_ev ("getNColumns", -1);
return retval;
}
long int row,
long int column)
{
- return cspi_object_add (
- Accessibility_Table_getAccessibleAt (
- CSPI_OBJREF (obj), (CORBA_long) row,
- (CORBA_long) column, cspi_ev ()));
+ dbus_int32_t d_row = row, d_column = column;
+ char *path;
+ Accessible *retval;
+
+ cspi_return_val_if_fail (obj != NULL, NULL);
+
+ cspi_dbus_call (obj, spi_interface_table, "getAccessibleAt", NULL, "ii=>o", &d_row, &d_column, &path);
+ cspi_return_val_if_ev ("getAccessibleAt", NULL);
+ retval = cspi_ref_related_accessible (obj, path);
+ g_free (path);
+ return retval;
}
/**
long int row,
long int column)
{
- long retval;
+ dbus_int32_t d_row = row, d_column = column;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table_getIndexAt (
- CSPI_OBJREF (obj), (CORBA_long) row,
- (CORBA_long) column, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getIndexAt", NULL, "ii=>i", d_row, d_column, &retval);
cspi_return_val_if_ev ("getIndexAt", -1);
AccessibleTable_getRowAtIndex (AccessibleTable *obj,
long index)
{
- long retval;
+ dbus_int32_t d_index = index;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table_getRowAtIndex (CSPI_OBJREF (obj),
- (CORBA_long) index, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getRowAtIndex", NULL, "i=>i", d_index, &retval);
- cspi_return_val_if_ev ("", -1);
+ cspi_return_val_if_ev ("getRowAtIndex", -1);
return retval;
}
AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
long index)
{
- long retval;
+ dbus_int32_t d_index = index;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table_getColumnAtIndex (CSPI_OBJREF (obj),
- (CORBA_long) index, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getColumnAtIndex", NULL, "i=>i", d_index, &retval);
cspi_return_val_if_ev ("getColumnAtIndex", -1);
AccessibleTable_getRowDescription (AccessibleTable *obj,
long int row)
{
+ dbus_int32_t d_row = row;
char *retval;
cspi_return_val_if_fail (obj != NULL, NULL);
- retval =
- Accessibility_Table_getRowDescription (CSPI_OBJREF (obj),
- (CORBA_long) row, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getRowDescription", NULL, "i=>s", d_row, &retval);
cspi_return_val_if_ev ("getRowDescription", NULL);
AccessibleTable_getColumnDescription (AccessibleTable *obj,
long int column)
{
+ dbus_int32_t d_column = column;
char *retval;
cspi_return_val_if_fail (obj != NULL, NULL);
- retval =
- Accessibility_Table_getColumnDescription (CSPI_OBJREF (obj),
- (CORBA_long) column, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getColumnDescription", NULL, "i=>s", d_column, &retval);
cspi_return_val_if_ev ("getColumnDescription", NULL);
long int row,
long int column)
{
- long retval;
+ dbus_int32_t d_row = row, d_column = column;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table_getRowExtentAt (
- CSPI_OBJREF (obj), (CORBA_long) row,
- (CORBA_long) column, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getRowExtentAt", NULL, "ii=>i", d_row, d_column, &retval);
cspi_return_val_if_ev ("getRowExtentAt", -1);
long int row,
long int column)
{
- long retval;
+ dbus_int32_t d_row = row, d_column = column;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table_getColumnExtentAt (
- CSPI_OBJREF (obj), (CORBA_long) row,
- (CORBA_long) column, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getColumnExtentAt", NULL, "ii=>i", d_row, d_column, &retval);
cspi_return_val_if_ev ("getColumnExtentAt", -1);
AccessibleTable_getRowHeader (AccessibleTable *obj,
long int row)
{
- return cspi_object_add (
- Accessibility_Table_getRowHeader (CSPI_OBJREF (obj),
- (CORBA_long) row, cspi_ev ()));
+ dbus_int32_t d_row = row;
+ char *path;
+ Accessible *retval;
+
+ cspi_return_val_if_fail (obj != NULL, NULL);
+
+ cspi_dbus_call (obj, spi_interface_table, "getRowHeader", NULL, "i=>o", d_row, &path);
+ cspi_return_val_if_ev ("getRowHeader", NULL);
+ retval = cspi_ref_related_accessible (obj, path);
+ g_free (path);
+
+ return retval;
}
/**
AccessibleTable_getColumnHeader (AccessibleTable *obj,
long int column)
{
- return cspi_object_add (
- Accessibility_Table_getColumnHeader (CSPI_OBJREF (obj),
- (CORBA_long) column, cspi_ev ()));
+ dbus_int32_t d_column = column;
+ char *path;
+ Accessible *retval;
+
+ cspi_return_val_if_fail (obj != NULL, NULL);
+
+ cspi_dbus_call (obj, spi_interface_table, "getColumnHeader", NULL, "i=>o", d_column, &path);
+ cspi_return_val_if_ev ("getColumnHeader", NULL);
+ retval = cspi_ref_related_accessible (obj, path);
+ g_free (path);
+
+ return retval;
}
/**
long
AccessibleTable_getNSelectedRows (AccessibleTable *obj)
{
- long retval;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table__get_nSelectedRows (CSPI_OBJREF (obj), cspi_ev ());
+ cspi_dbus_get_property (obj, spi_interface_table, "nSelectedRows", NULL, "i", &retval);
cspi_return_val_if_ev ("getNSelectedRows", -1);
}
static long
-long_seq_to_array (Accessibility_LongSeq *seq, long int **array)
+cspi_long_seq_to_array (GArray *seq, long int **array)
{
- long *j, length, i;
+ long *j;
+ long length, i;
if (!cspi_check_ev ("getSelectionItems"))
{
return 0;
}
- length = seq->_length;
+ length = seq->len;
- j = *array = g_new (long, length);
+ j = *array = malloc (sizeof (long) * length);
for (i = 0; i < length; i++)
{
- j[i] = seq->_buffer [i];
+ j[i] = g_array_index (seq, long, i);
}
- CORBA_free (seq);
+ g_array_free (seq, TRUE);
return length;
}
AccessibleTable_getSelectedRows (AccessibleTable *obj,
long int **selectedRows)
{
- Accessibility_LongSeq *rows;
+ GArray *rows;
*selectedRows = NULL;
cspi_return_val_if_fail (obj != NULL, 0);
- rows = Accessibility_Table_getSelectedRows (CSPI_OBJREF (obj), cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getSelectedRows", NULL, "=>ai", &rows);
+
+ cspi_return_val_if_ev ("getSelectedRows", -1);
- return long_seq_to_array (rows, selectedRows);
+ return cspi_long_seq_to_array (rows, selectedRows);
}
/**
* AccessibleTable_getNSelectedColumns:
* @obj: a pointer to the #AccessibleTable implementor on which to operate.
*
- * Query a table to find out how many columnss are currently selected. Not all tables
+ * 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;
+ dbus_int32_t retval;
cspi_return_val_if_fail (obj != NULL, -1);
- retval =
- Accessibility_Table__get_nSelectedColumns (CSPI_OBJREF (obj), cspi_ev ());
+ cspi_dbus_get_property (obj, spi_interface_table, "nSelectedColumns", NULL, "i", &retval);
cspi_return_val_if_ev ("getNSelectedColumns", -1);
AccessibleTable_getSelectedColumns (AccessibleTable *obj,
long int **selectedColumns)
{
- Accessibility_LongSeq *columns;
+ GArray *columns;
*selectedColumns = NULL;
cspi_return_val_if_fail (obj != NULL, 0);
- columns = Accessibility_Table_getSelectedColumns (CSPI_OBJREF (obj), cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "getSelectedColumns", NULL, "=>ai", &columns);
- return long_seq_to_array (columns, selectedColumns);
+ cspi_return_val_if_ev ("getSelectedColumns", -1);
+ return cspi_long_seq_to_array (columns, selectedColumns);
}
/**
* AccessibleTable_isRowSelected:
* @obj: a pointer to the #AccessibleTable implementor on which to operate.
- * @row:
+ * @row: the zero-indexed row number of the row being queried.
*
* Determine whether a table row is selected. Not all tables support row selection.
*
AccessibleTable_isRowSelected (AccessibleTable *obj,
long int row)
{
- SPIBoolean retval;
+ dbus_int32_t d_row = row;
+ dbus_bool_t retval;
cspi_return_val_if_fail (obj != NULL, FALSE);
- retval =
- Accessibility_Table_isRowSelected (CSPI_OBJREF (obj),
- (CORBA_long) row, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "isRowSelected", NULL, "i=>b", d_row, &retval);
cspi_return_val_if_ev ("isRowSelected", FALSE);
/**
* AccessibleTable_isColumnSelected:
* @obj: a pointer to the #AccessibleTable implementor on which to operate.
- * @column:
+ * @column: the zero-indexed column number of the column being queried.
*
* Determine whether specified table column is selected.
* Not all tables support column selection.
AccessibleTable_isColumnSelected (AccessibleTable *obj,
long int column)
{
- SPIBoolean retval;
+ dbus_int32_t d_column = column;
+ dbus_bool_t retval;
cspi_return_val_if_fail (obj != NULL, FALSE);
- retval =
- Accessibility_Table_isColumnSelected (CSPI_OBJREF (obj),
- (CORBA_long) column, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "isColumnSelected", NULL, "i=>b", d_column, &retval);
cspi_return_val_if_ev ("isColumnSelected", FALSE);
}
/**
+ * 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)
+{
+ dbus_int32_t d_row = row;
+ dbus_bool_t retval;
+
+ cspi_return_val_if_fail (obj != NULL, FALSE);
+
+ cspi_dbus_call (obj, spi_interface_table, "addRowSelection", NULL, "i=>b", d_row, &retval);
+
+ cspi_return_val_if_ev ("addRowSelection", FALSE);
+
+ return retval;
+}
+
+/**
+ * AccessibleTable_addColumnSelection:
+ * @obj: a pointer to the #AccessibleTable implementor on which to operate.
+ * @column: the zero-indexed column number of the column being selected.
+ *
+ * Select the specified column, adding it to the current column selection.
+ * Not all tables support column selection.
+ *
+ * Returns: #TRUE if the specified column was successfully selected, #FALSE if not.
+ **/
+SPIBoolean
+AccessibleTable_addColumnSelection (AccessibleTable *obj,
+ long int column)
+{
+ dbus_int32_t d_column = column;
+ dbus_bool_t retval;
+
+ cspi_return_val_if_fail (obj != NULL, FALSE);
+
+ cspi_dbus_call (obj, spi_interface_table, "addColumnSelection", NULL, "i=>b", d_column, &retval);
+
+ cspi_return_val_if_ev ("addColumnSelection", FALSE);
+
+ return retval;
+}
+
+/**
+ * AccessibleTable_removeRowSelection:
+ * @obj: a pointer to the #AccessibleTable implementor on which to operate.
+ * @row: the zero-indexed number of the row being deselected.
+ *
+ * De-select the specified row, removing it to the current row selection.
+ * Not all tables support row selection.
+ *
+ * Returns: #TRUE if the specified row was successfully de-selected, #FALSE if not.
+ **/
+SPIBoolean
+AccessibleTable_removeRowSelection (AccessibleTable *obj,
+ long int row)
+{
+ dbus_int32_t d_row = row;
+ dbus_bool_t retval;
+
+ cspi_return_val_if_fail (obj != NULL, FALSE);
+
+ cspi_dbus_call (obj, spi_interface_table, "removeRowSelection", NULL, "i=>b", d_row, &retval);
+
+ cspi_return_val_if_ev ("removeRowSelection", FALSE);
+
+ 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)
+{
+ dbus_int32_t d_column = column;
+ dbus_bool_t retval;
+
+ cspi_return_val_if_fail (obj != NULL, FALSE);
+
+ cspi_dbus_call (obj, spi_interface_table, "removeColumnSelection", NULL, "i=>b", d_column, &retval);
+
+ cspi_return_val_if_ev ("removeColumnSelection", FALSE);
+
+ 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)
+{
+ dbus_int32_t d_index = index;
+ dbus_bool_t retval;
+ dbus_int32_t d_row, d_col, d_row_extents, d_col_extents;
+ dbus_bool_t d_is_selected;
+
+ cspi_return_val_if_fail (obj != NULL, FALSE);
+
+ cspi_dbus_call (obj, spi_interface_table, "getRowColumnExtentsAtIndex", NULL, "i=>iiiibb", d_index, &d_row, &d_col, &d_row_extents, &d_col_extents, &d_is_selected, &retval);
+
+ if (!cspi_check_ev ("getRowColumnExtentsAtIndex")){
+
+ *row = 0;
+ *col = 0;
+ *row_extents = 0;
+ *col_extents = 0;
+ *is_selected = FALSE;
+ retval = FALSE;
+ }
+
+ else {
+ *row = d_row;
+ *col = d_col;
+ *row_extents = d_row_extents;;
+ *col_extents = d_col_extents;
+ *is_selected = d_is_selected;;
+ }
+
+ return retval;
+}
+
+
+/**
* AccessibleTable_isSelected:
* @obj: a pointer to the #AccessibleTable implementor on which to operate.
- * @row:
- * @column:
+ * @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.
*
long int row,
long int column)
{
- SPIBoolean retval;
+ dbus_int32_t d_row = row, d_column = column;
+ dbus_bool_t retval;
cspi_return_val_if_fail (obj != NULL, FALSE);
- retval =
- Accessibility_Table_isSelected (CSPI_OBJREF (obj),
- (CORBA_long) row,
- (CORBA_long) column, cspi_ev ());
+ cspi_dbus_call (obj, spi_interface_table, "isSelected", NULL, "ii=>b", d_row, d_column, &retval);
cspi_return_val_if_ev ("isSelected", FALSE);
projects / platform / core / uifw / at-spi2-atk.git / blobdiff