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