atspi/atspi-table.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  * Copyright 2010, 2011 Novell, Inc.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include <stdlib.h> /* for malloc */
  26 #include "atspi-private.h"
  27
  28 /**
  29  * atspi_table_get_caption:
  30  * @obj: a pointer to the #AtspiTable implementor on which to operate.
  31  *
  32  * Gets an accessible representation of the caption for an #AtspiTable.
  33  *
  34  * Returns: (transfer full): an #AtspiAccessible object that serves as
  35  * the table's caption.
  36  *
  37  **/
  38 AtspiAccessible *
  39 atspi_table_get_caption (AtspiTable *obj, GError **error)
  40 {
  41   AtspiAccessible *retval = NULL;
  42
  43   g_return_val_if_fail (obj != NULL, NULL);
  44
  45   _atspi_dbus_get_property (obj, atspi_interface_table, "Caption", error, "(so)", &retval);
  46   return retval;
  47 }
  48
  49 /**
  50  * atspi_table_get_summary:
  51  * @obj: a pointer to the #AtspiTable implementor on which to operate.
  52  *
  53  * Gets an accessible object which summarizes the contents of an #AtspiTable.
  54  *
  55  * Returns: (transfer full): an #AtspiAccessible object that serves as the
  56  *          table's summary (often a reduced #AtspiTable).
  57  **/
  58 AtspiAccessible *
  59 atspi_table_get_summary (AtspiTable *obj, GError **error)
  60 {
  61   AtspiAccessible *retval;
  62
  63   g_return_val_if_fail (obj != NULL, NULL);
  64
  65   _atspi_dbus_get_property (obj, atspi_interface_table, "Summary", error, "(so)", &retval);
  66
  67  return retval;
  68 }
  69
  70 /**
  71  * atspi_table_get_n_rows:
  72  * @obj: a pointer to the #AtspiTable implementor on which to operate.
  73  *
  74  * Gets the number of rows in an #AtspiTable,
  75  *        exclusive of any rows that are programmatically hidden, but inclusive
  76  *        of rows that may be outside of the current scrolling window or viewport.
  77  *
  78  * Returns: a #gint indicating the number of rows in the table.
  79  **/
  80 gint
  81 atspi_table_get_n_rows (AtspiTable *obj, GError **error)
  82 {
  83   dbus_int32_t retval = -1;
  84
  85   g_return_val_if_fail (obj != NULL, -1);
  86
  87   _atspi_dbus_get_property (obj, atspi_interface_table, "NRows", error, "i", &retval);
  88
  89   return retval;
  90 }
  91
  92 /**
  93  * atspi_table_get_n_columns:
  94  * @obj: a pointer to the #AtspiTable implementor on which to operate.
  95  *
  96  * Gets the number of columns in an #AtspiTable,
  97  *        exclusive of any columns that are programmatically hidden, but inclusive
  98  *        of columns that may be outside of the current scrolling window or viewport.
  99  *
 100  * Returns: a #gint indicating the number of columns in the table.
 101  **/
 102 gint
 103 atspi_table_get_n_columns (AtspiTable *obj, GError **error)
 104 {
 105   dbus_int32_t retval = -1;
 106
 107   g_return_val_if_fail (obj != NULL, -1);
 108
 109   _atspi_dbus_get_property (obj, atspi_interface_table, "NColumns", error, "i", &retval);
 110
 111   return retval;
 112 }
 113
 114 /**
 115  * atspi_table_get_accessible_at:
 116  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 117  * @row: the specified table row, zero-indexed.
 118  * @column: the specified table column, zero-indexed.
 119  *
 120  * Gets the table cell at the specified row and column indices.
 121  * To get the accessible object at a particular (x, y) screen
 122  * coordinate, use #atspi_component_get_accessible_at_point.
 123  *
 124  * Returns: (transfer full): an #AtspiAccessible object representing the
 125  *          specified table cell.
 126  **/
 127 AtspiAccessible *
 128 atspi_table_get_accessible_at (AtspiTable *obj,
 129                                  gint row,
 130                                  gint column,
 131                                  GError **error)
 132 {
 133   dbus_int32_t d_row = row, d_column = column;
 134   DBusMessage *reply;
 135
 136   g_return_val_if_fail (obj != NULL, NULL);
 137
 138   reply = _atspi_dbus_call_partial (obj, atspi_interface_table, "GetAccessibleAt", error, "ii", d_row, d_column);
 139
 140   return _atspi_dbus_return_accessible_from_message (reply);
 141 }
 142
 143 /**
 144  * atspi_table_get_index_at:
 145  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 146  * @row: the specified table row, zero-indexed.
 147  * @column: the specified table column, zero-indexed.
 148  *
 149  * Gets the 1-D child index corresponding to the specified 2-D row and
 150  * column indices. To get the accessible object at a particular (x, y) screen
 151  * coordinate, use #atspi_component_get_accessible_at_point.
 152  *
 153  * @see #atspi_table_get_row_at_index, #atspi_table_get_column_at_index
 154  *
 155  * Returns: a #gint which serves as the index of a specified cell in the
 156  *          table, in a form usable by #atspi_get_child_at_index.
 157  **/
 158 gint
 159 atspi_table_get_index_at (AtspiTable *obj,
 160                             gint row,
 161                             gint column,
 162                             GError **error)
 163 {
 164   dbus_int32_t d_row = row, d_column = column;
 165   dbus_int32_t retval = -1;
 166
 167   g_return_val_if_fail (obj != NULL, -1);
 168
 169   _atspi_dbus_call (obj, atspi_interface_table, "GetIndexAt", error, "ii=>i", d_row, d_column, &retval);
 170
 171   return retval;
 172 }
 173
 174 /**
 175  * atspi_table_get_row_at_index:
 176  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 177  * @index: the specified child index, zero-indexed.
 178  *
 179  * Gets the table row index occupied by the child at a particular 1-D
 180  * child index.
 181  *
 182  * @see #atspi_table_get_index_at, #atspi_table_get_column_at_index
 183  *
 184  * Returns: a #gint indicating the first row spanned by the child of a
 185  *          table, at the specified 1-D (zero-offset) @index.
 186  **/
 187 gint
 188 atspi_table_get_row_at_index (AtspiTable *obj,
 189                                gint index,
 190                                GError **error)
 191 {
 192   dbus_int32_t d_index = index;
 193   dbus_int32_t retval = -1;
 194
 195   g_return_val_if_fail (obj != NULL, -1);
 196
 197   _atspi_dbus_call (obj, atspi_interface_table, "GetRowAtIndex", error, "i=>i", d_index, &retval);
 198
 199   return retval;
 200 }
 201
 202 /**
 203  * atspi_table_get_column_at_index:
 204  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 205  * @index: the specified child index, zero-indexed.
 206  *
 207  * Gets the table column index occupied by the child at a particular 1-D
 208  * child index.
 209  *
 210  * @see #atspi_table_get_index_at, #atspi_table_get_row_at_index
 211  *
 212  * Returns: a #gint indicating the first column spanned by the child of a
 213  *          table, at the specified 1-D (zero-offset) @index.
 214  **/
 215 gint
 216 atspi_table_get_column_at_index (AtspiTable *obj,
 217                                   gint index,
 218                                   GError **error)
 219 {
 220   dbus_int32_t d_index = index;
 221   dbus_int32_t retval = -1;
 222
 223   g_return_val_if_fail (obj != NULL, -1);
 224
 225   _atspi_dbus_call (obj, atspi_interface_table, "GetColumnAtIndex", error, "i=>i", d_index, &retval);
 226
 227   return retval;
 228 }
 229
 230 /**
 231  * atspi_table_get_row_description:
 232  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 233  * @row: the specified table row, zero-indexed.
 234  *
 235  * Gets a text description of a particular table row.  This differs from
 236  * #atspi_table_get_row_header, which returns an #AtspiAccessible.
 237  *
 238  * Returns: a UTF-8 string describing the specified table row, if available.
 239  **/
 240 gchar *
 241 atspi_table_get_row_description (AtspiTable *obj,
 242                                    gint  row,
 243                                    GError **error)
 244 {
 245   dbus_int32_t d_row = row;
 246   char *retval = NULL;
 247
 248   g_return_val_if_fail (obj != NULL, NULL);
 249
 250   _atspi_dbus_call (obj, atspi_interface_table, "GetRowDescription", error, "i=>s", d_row, &retval);
 251
 252   return retval;
 253 }
 254
 255 /**
 256  * atspi_table_get_column_description:
 257  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 258  * @column: the specified table column, zero-indexed.
 259  *
 260  * Gets a text description of a particular table column.  This differs from
 261  * #atspi_table_get_column_header, which returns an #Accessible.
 262  *
 263  * Returns: a UTF-8 string describing the specified table column, if available.
 264  **/
 265 gchar *
 266 atspi_table_get_column_description (AtspiTable *obj,
 267                                       gint         column, GError **error)
 268 {
 269   dbus_int32_t d_column = column;
 270   char *retval = NULL;
 271
 272   g_return_val_if_fail (obj != NULL, NULL);
 273
 274   _atspi_dbus_call (obj, atspi_interface_table, "GetColumnDescription", error, "i=>s", d_column, &retval);
 275
 276   return retval;
 277 }
 278
 279 /**
 280  * atspi_table_get_row_extent_at:
 281  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 282  * @row: the specified table row, zero-indexed.
 283  * @column: the specified table column, zero-indexed.
 284  *
 285  * Gets the number of rows spanned by the table cell at the specific row
 286  * and column. (some tables can have cells which span multiple rows
 287  * and/or columns).
 288  *
 289  * Returns: a #gint indicating the number of rows spanned by the specified cell.
 290  **/
 291 gint
 292 atspi_table_get_row_extent_at (AtspiTable *obj,
 293                                 gint         row,
 294                                 gint         column,
 295                                 GError **error)
 296 {
 297   dbus_int32_t d_row = row, d_column = column;
 298   dbus_int32_t retval = -1;
 299
 300   g_return_val_if_fail (obj != NULL, -1);
 301
 302   _atspi_dbus_call (obj, atspi_interface_table, "GetRowExtentAt", error, "ii=>i", d_row, d_column, &retval);
 303
 304   return retval;
 305 }
 306
 307 /**
 308  * atspi_table_get_column_extent_at:
 309  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 310  * @row: the specified table row, zero-indexed.
 311  * @column: the specified table column, zero-indexed.
 312  *
 313  * Gets the number of columns spanned by the table cell at the specific
 314  * row and column (some tables can have cells which span multiple
 315  * rows and/or columns).
 316  *
 317  * Returns: a #gint indicating the number of columns spanned by the specified cell.
 318  **/
 319 gint
 320 atspi_table_get_column_extent_at (AtspiTable *obj,
 321                                    gint         row,
 322                                    gint         column,
 323                                    GError **error)
 324 {
 325   dbus_int32_t d_row = row, d_column = column;
 326   dbus_int32_t retval = -1;
 327
 328   g_return_val_if_fail (obj != NULL, -1);
 329
 330   _atspi_dbus_call (obj, atspi_interface_table, "GetColumnExtentAt", error, "ii=>i", d_row, d_column, &retval);
 331
 332   return retval;
 333 }
 334
 335 /**
 336  * atspi_table_get_row_header:
 337  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 338  * @row: the specified table row, zero-indexed.
 339  *
 340  * Gets the header associated with a table row, if available. This differs from
 341  * #atspi_table_get_row_description, which returns a string.
 342  *
 343  * Returns: (transfer full): an #AtspiAccessible representation of the specified
 344  *          table row, if available.
 345  **/
 346 AtspiAccessible *
 347 atspi_table_get_row_header (AtspiTable *obj,
 348                               gint         row,
 349                               GError **error)
 350 {
 351   dbus_int32_t d_row = row;
 352   DBusMessage *reply;
 353
 354   g_return_val_if_fail (obj != NULL, NULL);
 355
 356   reply = _atspi_dbus_call_partial (obj, atspi_interface_table, "GetRowHeader", error, "i", d_row);
 357
 358   return _atspi_dbus_return_accessible_from_message (reply);
 359 }
 360
 361 /**
 362  * atspi_table_get_column_header:
 363  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 364  * @column: the specified table column, zero-indexed.
 365  *
 366  * Gets the header associated with a table column, if available.
 367  * This differs from #atspi_table_get_column_description, which
 368  * returns a string.
 369  *
 370  * Returns: (transfer full): an #AtspiAccessible representation of the
 371  *          specified table column, if available.
 372  **/
 373 AtspiAccessible *
 374 atspi_table_get_column_header (AtspiTable *obj,
 375                                  gint column,
 376                                  GError **error)
 377 {
 378   dbus_int32_t d_column = column;
 379   DBusMessage *reply;
 380
 381   g_return_val_if_fail (obj != NULL, NULL);
 382
 383   reply = _atspi_dbus_call_partial (obj, atspi_interface_table, "GetColumnHeader", error, "i", d_column);
 384
 385   return _atspi_dbus_return_accessible_from_message (reply);
 386 }
 387
 388 /**
 389  * atspi_table_get_n_selected_rows:
 390  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 391  *
 392  * Query a table to find out how many rows are currently selected.
 393  * Not all tables support row selection.
 394  *
 395  * Returns: a #gint indicating the number of rows currently selected.
 396  **/
 397 gint
 398 atspi_table_get_n_selected_rows (AtspiTable *obj, GError **error)
 399 {
 400   dbus_int32_t retval = -1;
 401
 402   g_return_val_if_fail (obj != NULL, -1);
 403
 404   _atspi_dbus_get_property (obj, atspi_interface_table, "NSelectedRows", error, "i", &retval);
 405
 406   return retval;
 407 }
 408
 409 /**
 410  * atspi_table_get_selected_rows:
 411  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 412  *
 413  * Queries a table for a list of indices of rows which are currently selected.
 414  *
 415  * Returns: (element-type gint) (transfer full): an array of #gint values,
 416  *          specifying which rows are currently selected.
 417  **/
 418 GArray *
 419 atspi_table_get_selected_rows (AtspiTable *obj,
 420                                  GError **error)
 421 {
 422   GArray *rows = NULL;
 423
 424   g_return_val_if_fail (obj != NULL, 0);
 425
 426   _atspi_dbus_call (obj, atspi_interface_table, "GetSelectedRows", error, "=>ai", &rows);
 427
 428   return rows;
 429 }
 430
 431 /**
 432  * atspi_table_get_selected_columns:
 433  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 434  *
 435  * Queries a table for a list of indices of columns which are currently
 436  * selected.
 437  *
 438  * Returns: (element-type gint) (transfer full): an array of #gint values,
 439  *          specifying which columns are currently selected.
 440  **/
 441 GArray *
 442 atspi_table_get_selected_columns (AtspiTable *obj,
 443                                  GError **error)
 444 {
 445   GArray *columns = NULL;
 446
 447   g_return_val_if_fail (obj != NULL, 0);
 448
 449   _atspi_dbus_call (obj, atspi_interface_table, "GetSelectedColumns", error, "=>ai", &columns);
 450
 451   return columns;
 452 }
 453
 454 /**
 455  * atspi_table_get_n_selected_columns:
 456  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 457  *
 458  * Queries a table to find out how many columns are currently selected.
 459  * Not all tables support column selection.
 460  *
 461  * Returns: a #gint indicating the number of columns currently selected.
 462  **/
 463 gint
 464 atspi_table_get_n_selected_columns (AtspiTable *obj, GError **error)
 465 {
 466   dbus_int32_t retval = -1;
 467
 468   g_return_val_if_fail (obj != NULL, -1);
 469
 470   _atspi_dbus_get_property (obj, atspi_interface_table, "NSelectedColumns", error, "i", &retval);
 471
 472   return retval;
 473 }
 474
 475 /**
 476  * atspi_table_is_row_selected:
 477  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 478  * @row: the zero-indexed row number of the row being queried.
 479  *
 480  * Determines whether a table row is selected.  Not all tables support
 481  * row selection.
 482  *
 483  * Returns: #TRUE if the specified row is currently selected, #FALSE if not.
 484  **/
 485 gboolean
 486 atspi_table_is_row_selected (AtspiTable *obj,
 487                                gint row,
 488                                GError **error)
 489 {
 490   dbus_int32_t d_row = row;
 491   dbus_bool_t retval = FALSE;
 492
 493   g_return_val_if_fail (obj != NULL, FALSE);
 494
 495   _atspi_dbus_call (obj, atspi_interface_table, "IsRowSelected", error, "i=>b", d_row, &retval);
 496
 497   return retval;
 498 }
 499
 500 /**
 501  * atspi_table_is_column_selected:
 502  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 503  * @column: the zero-indexed column number of the column being queried.
 504  *
 505  * Determines whether specified table column is selected.
 506  * Not all tables support column selection.
 507  *
 508  * Returns: #TRUE if the specified column is currently selected, #FALSE if not.
 509  **/
 510 gboolean
 511 atspi_table_is_column_selected (AtspiTable *obj,
 512                                   gint column,
 513                                   GError **error)
 514 {
 515   dbus_int32_t d_column = column;
 516   dbus_bool_t retval = FALSE;
 517
 518   g_return_val_if_fail (obj != NULL, FALSE);
 519
 520   _atspi_dbus_call (obj, atspi_interface_table, "IsColumnSelected", error, "i=>b", d_column, &retval);
 521
 522   return retval;
 523 }
 524
 525 /**
 526  * atspi_table_add_row_selection:
 527  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 528  * @row: the zero-indexed row number of the row being selected.
 529  *
 530  * Selects the specified row, adding it to the current row selection.
 531  * Not all tables support row selection.
 532  *
 533  * Returns: #TRUE if the specified row was successfully selected, #FALSE if not.
 534  **/
 535 gboolean
 536 atspi_table_add_row_selection (AtspiTable *obj,
 537                                  gint row,
 538                                  GError **error)
 539 {
 540   dbus_int32_t d_row = row;
 541   dbus_bool_t retval = FALSE;
 542
 543   g_return_val_if_fail (obj != NULL, FALSE);
 544
 545   _atspi_dbus_call (obj, atspi_interface_table, "AddRowSelection", error, "i=>b", d_row, &retval);
 546
 547   return retval;
 548 }
 549
 550 /**
 551  * atspi_table_add_column_selection:
 552  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 553  * @column: the zero-indexed column number of the column being selected.
 554  *
 555  * Selects the specified column, adding it to the current column selection.
 556  * Not all tables support column selection.
 557  *
 558  * Returns: #TRUE if the specified column was successfully selected, #FALSE if not.
 559  **/
 560 gboolean
 561 atspi_table_add_column_selection (AtspiTable *obj,
 562                                     gint column,
 563                                     GError **error)
 564 {
 565   dbus_int32_t d_column = column;
 566   dbus_bool_t retval = FALSE;
 567
 568   g_return_val_if_fail (obj != NULL, FALSE);
 569
 570   _atspi_dbus_call (obj, atspi_interface_table, "AddColumnSelection", error, "i=>b", d_column, &retval);
 571
 572   return retval;
 573 }
 574
 575 /**
 576  * atspi_table_remove_row_selection:
 577  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 578  * @row: the zero-indexed number of the row being de-selected.
 579  *
 580  * De-selects the specified row, removing it from the current row selection.
 581  * Not all tables support row selection.
 582  *
 583  * Returns: #TRUE if the specified row was successfully de-selected,
 584  * #FALSE if not.
 585  **/
 586 gboolean
 587 atspi_table_remove_row_selection (AtspiTable *obj,
 588                                     gint row,
 589                                     GError **error)
 590 {
 591   dbus_int32_t d_row = row;
 592   dbus_bool_t retval = FALSE;
 593
 594   g_return_val_if_fail (obj != NULL, FALSE);
 595
 596   _atspi_dbus_call (obj, atspi_interface_table, "RemoveRowSelection", error, "i=>b", d_row, &retval);
 597
 598   return retval;
 599 }
 600
 601 /**
 602  * atspi_table_remove_column_selection:
 603  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 604  * @column: the zero-indexed column number of the column being de-selected.
 605  *
 606  * De-selects the specified column, removing it from the current column
 607  * selection.
 608  * Not all tables support column selection.
 609  *
 610  * Returns: #TRUE if the specified column was successfully de-selected,
 611  * #FALSE if not.
 612  **/
 613 gboolean
 614 atspi_table_remove_column_selection (AtspiTable *obj,
 615                                        gint column,
 616                                        GError **error)
 617 {
 618   dbus_int32_t d_column = column;
 619   dbus_bool_t retval = FALSE;
 620
 621   g_return_val_if_fail (obj != NULL, FALSE);
 622
 623   _atspi_dbus_call (obj, atspi_interface_table, "RemoveColumnSelection", error, "i=>b", d_column, &retval);
 624
 625   return retval;
 626 }
 627
 628 /**
 629  * atspi_table_get_row_column_extents_at_index:
 630  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 631  * @index: the index of the #AtspiTable child whose row/column
 632  * extents are requested.
 633  * @row: (out): back-filled with the first table row associated with
 634  * the cell with child index.
 635  * @col: (out): back-filled with the first table column associated
 636  * with the cell with child index.
 637  * @row_extents: (out): back-filled with the number of table rows
 638  * across which child i extends.
 639  * @col_extents: (out): back-filled with the number of table columns
 640  * across which child i extends.
 641  * @is_selected: (out): a boolean which is back-filled with #TRUE
 642  * if the child at index i corresponds to a selected table cell,
 643  * #FALSE otherwise.
 644  *
 645  * Given a child index, determines the row and column indices and
 646  * extents, and whether the cell is currently selected.  If
 647  * the child at index is not a cell (for instance, if it is
 648  * a summary, caption, etc.), #FALSE is returned.
 649  *
 650  * Example:
 651  * If the #AtspiTable child at index '6' extends across columns 5 and 6 of
 652  * row 2 of an #AtspiTable instance, and is currently selected, then
 653  *
 654  * retval = atspi_table_get_row_column_extents_at_index (table, 6,
 655  *                                             row, col,
 656  *                                             row_extents,
 657  *                                             col_extents,
 658  *                                             is_selected);
 659  *
 660  * will return #TRUE, and after the call
 661  * row, col, row_extents, col_extents,
 662  * and is_selected will contain 2, 5, 1, 2, and
 663  * #TRUE, respectively.
 664  *
 665  * Returns: #TRUE if the index is associated with a valid table
 666  * cell, #FALSE if the index does not correspond to a cell.  If
 667  * #FALSE is returned, the values of the out parameters are
 668  * undefined.
 669  **/
 670 gboolean
 671 atspi_table_get_row_column_extents_at_index (AtspiTable *obj,
 672                                             gint index, gint *row, gint *col,
 673                                             gint *row_extents, gint *col_extents,
 674                                             gboolean *is_selected, GError **error)
 675 {
 676   dbus_int32_t d_index = index;
 677   dbus_bool_t retval = FALSE;
 678   dbus_int32_t d_row = 0,  d_col = 0, d_row_extents = 0, d_col_extents = 0;
 679   dbus_bool_t d_is_selected = FALSE;
 680
 681   g_return_val_if_fail (obj != NULL, FALSE);
 682
 683   _atspi_dbus_call (obj, atspi_interface_table, "GetRowColumnExtentsAtIndex",
 684                     error, "i=>biiiib", d_index, &retval, &d_row, &d_col,
 685                     &d_row_extents, &d_col_extents, &d_is_selected);
 686
 687   *row = d_row;
 688   *col = d_col;
 689   *row_extents = d_row_extents;;
 690   *col_extents = d_col_extents;
 691   *is_selected = d_is_selected;;
 692
 693   return retval;
 694 }
 695
 696
 697 /**
 698  * atspi_table_is_selected:
 699  * @obj: a pointer to the #AtspiTable implementor on which to operate.
 700  * @row: the zero-indexed row of the cell being queried.
 701  * @column: the zero-indexed column of the cell being queried.
 702  *
 703  * Determines whether the cell at a specific row and column is selected.
 704  *
 705  * Returns: #TRUE if the specified cell is currently selected, #FALSE if not.
 706  **/
 707 gboolean
 708 atspi_table_is_selected (AtspiTable *obj,
 709                             gint row,
 710                             gint column,
 711                             GError **error)
 712 {
 713   dbus_int32_t d_row = row, d_column = column;
 714   dbus_bool_t retval = FALSE;
 715
 716   g_return_val_if_fail (obj != NULL, FALSE);
 717
 718   _atspi_dbus_call (obj, atspi_interface_table, "IsSelected", error, "ii=>b", d_row, d_column, &retval);
 719
 720   return retval;
 721 }
 722
 723 static void
 724 atspi_table_base_init (AtspiTable *klass)
 725 {
 726 }
 727
 728 GType
 729 atspi_table_get_type (void)
 730 {
 731   static GType type = 0;
 732
 733   if (!type) {
 734     static const GTypeInfo tinfo =
 735     {
 736       sizeof (AtspiTable),
 737       (GBaseInitFunc) atspi_table_base_init,
 738       (GBaseFinalizeFunc) NULL,
 739     };
 740
 741     type = g_type_register_static (G_TYPE_INTERFACE, "AtspiTable", &tinfo, 0);
 742
 743   }
 744   return type;
 745 }