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