atk/atktable.c

   1 /* ATK -  Accessibility Toolkit
   2  * Copyright 2001 Sun Microsystems Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "atktable.h"
  21 #include "atkmarshal.h"
  22
  23 enum {
  24   ROW_INSERTED,
  25   ROW_DELETED,
  26   COLUMN_INSERTED,
  27   COLUMN_DELETED,
  28   ROW_REORDERED,
  29   COLUMN_REORDERED,
  30   LAST_SIGNAL
  31 };
  32
  33 struct _AtkTableIfaceClass
  34 {
  35   GObjectClass parent;
  36 };
  37
  38 typedef struct _AtkTableIfaceClass AtkTableIfaceClass;
  39
  40 static void atk_table_base_init (gpointer *g_class);
  41
  42 static guint atk_table_signals[LAST_SIGNAL] = { 0 };
  43
  44 GType
  45 atk_table_get_type ()
  46 {
  47   static GType type = 0;
  48
  49   if (!type) {
  50     GTypeInfo tinfo =
  51     {
  52       sizeof (AtkTableIface),
  53       (GBaseInitFunc) atk_table_base_init,
  54       (GBaseFinalizeFunc) NULL,
  55
  56     };
  57
  58     type = g_type_register_static (G_TYPE_INTERFACE, "AtkTable", &tinfo, 0);
  59   }
  60
  61   return type;
  62 }
  63
  64
  65 static void
  66 atk_table_base_init (gpointer *g_class)
  67 {
  68   static gboolean initialized = FALSE;
  69
  70   if (! initialized)
  71   {
  72     atk_table_signals[ROW_INSERTED] =
  73       g_signal_newc ("row_inserted",
  74                      ATK_TYPE_TABLE,
  75                      G_SIGNAL_RUN_LAST,
  76                      G_STRUCT_OFFSET (AtkTableIface, row_inserted),
  77                      (GSignalAccumulator) NULL, NULL,
  78                      atk_marshal_VOID__INT_INT,
  79                      G_TYPE_NONE,
  80                      2, G_TYPE_INT, G_TYPE_INT);
  81     atk_table_signals[COLUMN_INSERTED] =
  82       g_signal_newc ("column_inserted",
  83                      ATK_TYPE_TABLE,
  84                      G_SIGNAL_RUN_LAST,
  85                      G_STRUCT_OFFSET (AtkTableIface, column_inserted),
  86                      (GSignalAccumulator) NULL, NULL,
  87                      atk_marshal_VOID__INT_INT,
  88                      G_TYPE_NONE,
  89                      2, G_TYPE_INT, G_TYPE_INT);
  90     atk_table_signals[ROW_DELETED] =
  91       g_signal_newc ("row_deleted",
  92                      ATK_TYPE_TABLE,
  93                      G_SIGNAL_RUN_LAST,
  94                      G_STRUCT_OFFSET (AtkTableIface, row_deleted),
  95                      (GSignalAccumulator) NULL, NULL,
  96                      atk_marshal_VOID__INT_INT,
  97                      G_TYPE_NONE,
  98                      2, G_TYPE_INT, G_TYPE_INT);
  99     atk_table_signals[COLUMN_DELETED] =
 100       g_signal_newc ("column_deleted",
 101                      ATK_TYPE_TABLE,
 102                      G_SIGNAL_RUN_LAST,
 103                      G_STRUCT_OFFSET (AtkTableIface, column_deleted),
 104                      (GSignalAccumulator) NULL, NULL,
 105                      atk_marshal_VOID__INT_INT,
 106                      G_TYPE_NONE,
 107                      2, G_TYPE_INT, G_TYPE_INT);
 108     atk_table_signals[ROW_REORDERED] =
 109       g_signal_newc ("row_reordered",
 110                      ATK_TYPE_TABLE,
 111                      G_SIGNAL_RUN_LAST,
 112                      G_STRUCT_OFFSET (AtkTableIface, row_reordered),
 113                      (GSignalAccumulator) NULL, NULL,
 114                      g_cclosure_marshal_VOID__VOID,
 115                      G_TYPE_NONE,
 116                      0);
 117     atk_table_signals[COLUMN_REORDERED] =
 118       g_signal_newc ("column_reordered",
 119                      ATK_TYPE_TABLE,
 120                      G_SIGNAL_RUN_LAST,
 121                      G_STRUCT_OFFSET (AtkTableIface, column_reordered),
 122                      (GSignalAccumulator) NULL, NULL,
 123                      g_cclosure_marshal_VOID__VOID,
 124                      G_TYPE_NONE,
 125                      0);
 126     initialized = TRUE;
 127   }
 128 }
 129
 130 /**
 131  * atk_table_ref_at:
 132  * @table: a GObject instance that implements AtkTableIface
 133  * @row: a #gint representing a row in @table
 134  * @column: a #gint representing a column in @table
 135  *
 136  * Get a reference to the table cell at @row, @column.
 137  *
 138  * Returns: a AtkObject* representing the referred to accessible
 139  **/
 140 AtkObject*
 141 atk_table_ref_at (AtkTable *table,
 142                   gint     row,
 143                   gint     column)
 144 {
 145   AtkTableIface *iface;
 146
 147   g_return_val_if_fail (table != NULL, NULL);
 148   g_return_val_if_fail (ATK_IS_TABLE (table), NULL);
 149
 150   iface = ATK_TABLE_GET_IFACE (table);
 151
 152   if (iface->ref_at)
 153     return (iface->ref_at) (table, row, column);
 154   else
 155     return NULL;
 156 }
 157
 158 /**
 159  * atk_table_get_index_at:
 160  * @table: a GObject instance that implements AtkTableIface
 161  * @row: a #gint representing a row in @table
 162  * @column: a #gint representing a column in @table
 163  *
 164  * Gets a #gint representing the index at the specified @row and @column,
 165  * or 0 if value does not implement this interface.
 166  * Note: callers should not rely on %NULL or on a zero value for
 167  * indication of whether AtkSelectionIface is implemented, they should
 168  * use type checking/interface checking macros or the
 169  * atk_get_accessible_table() convenience method.
 170  *
 171  * Returns: a #gint representing the index at specified position, or 0
 172  * if value does not implement this interface.
 173  **/
 174 gint
 175 atk_table_get_index_at (AtkTable *table,
 176                         gint     row,
 177                         gint     column)
 178 {
 179   AtkTableIface *iface;
 180
 181   g_return_val_if_fail (table != NULL, 0);
 182   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 183
 184   iface = ATK_TABLE_GET_IFACE (table);
 185
 186   if (iface->get_index_at)
 187     return (iface->get_index_at) (table, row, column);
 188   else
 189     return 0;
 190 }
 191
 192 /**
 193  * atk_table_get_row_at_index:
 194  * @table: a GObject instance that implements AtkTableInterface
 195  * @index: a #gint representing an index in @table
 196  *
 197  * Gets a #gint representing the row at the specified @index, or 0
 198  * if the value does not implement this interface
 199  * Note: callers should not rely on %NULL or on a zero value for
 200  * indication of whether AtkSelectionIface is implemented, they should
 201  * use type checking/interface checking macros or the
 202  * atk_get_accessible_table() convenience method.
 203  *
 204  * Returns: a gint representing the row at the specified  index, or 0
 205  * if value does not implement this interface.
 206  **/
 207 gint
 208 atk_table_get_row_at_index (AtkTable *table,
 209                             gint     index)
 210 {
 211   AtkTableIface *iface;
 212
 213   g_return_val_if_fail (table != NULL, 0);
 214   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 215
 216   iface = ATK_TABLE_GET_IFACE (table);
 217
 218   if (iface->get_row_at_index)
 219     return (iface->get_row_at_index) (table, index);
 220   else
 221     return 0;
 222 }
 223
 224 /**
 225  * atk_table_get_column_at_index:
 226  * @table: a GObject instance that implements AtkTableInterface
 227  * @index: a #gint representing an index in @table
 228  *
 229  * Gets a #gint representing the column at the specified @index, or 0
 230  * if the value does not implement this interface
 231  * Note: callers should not rely on %NULL or on a zero value for
 232  * indication of whether AtkSelectionIface is implemented, they should
 233  * use type checking/interface checking macros or the
 234  * atk_get_accessible_table() convenience method.
 235  *
 236  * Returns: a gint representing the column at the specified  index, or 0
 237  * if value does not implement this interface.
 238  **/
 239 gint
 240 atk_table_get_column_at_index (AtkTable *table,
 241                                gint     index)
 242 {
 243   AtkTableIface *iface;
 244
 245   g_return_val_if_fail (table != NULL, 0);
 246   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 247
 248   iface = ATK_TABLE_GET_IFACE (table);
 249
 250   if (iface->get_column_at_index)
 251     return (iface->get_column_at_index) (table, index);
 252   else
 253     return 0;
 254 }
 255
 256 /**
 257  * atk_table_get_caption:
 258  * @table: a GObject instance that implements AtkTableInterface
 259  *
 260  * Gets the caption for the @table.
 261  * Note: callers should not rely on %NULL or on a zero value for
 262  * indication of whether AtkSelectionIface is implemented, they should
 263  * use type checking/interface checking macros or the
 264  * atk_get_accessible_table() convenience method.
 265  *
 266  * Returns: a gchar* representing the table caption, or %NULL
 267  * if value does not implement this interface.
 268  **/
 269 gchar*
 270 atk_table_get_caption (AtkTable *table)
 271 {
 272   AtkTableIface *iface;
 273
 274   g_return_val_if_fail (table != NULL, NULL);
 275   g_return_val_if_fail (ATK_IS_TABLE (table), NULL);
 276
 277   iface = ATK_TABLE_GET_IFACE (table);
 278
 279   if (iface->get_caption)
 280     return (iface->get_caption) (table);
 281   else
 282     return NULL;
 283 }
 284
 285 /**
 286  * atk_table_get_n_columns:
 287  * @table: a GObject instance that implements AtkTableIface
 288  *
 289  * Gets the number of columns in the table.
 290  * Note: callers should not rely on %NULL or on a zero value for
 291  * indication of whether AtkSelectionIface is implemented, they should
 292  * use type checking/interface checking macros or the
 293  * atk_get_accessible_table() convenience method.
 294  *
 295  * Returns: a gint representing the number of columns, or 0
 296  * if value does not implement this interface.
 297  **/
 298 gint
 299 atk_table_get_n_columns (AtkTable *table)
 300 {
 301   AtkTableIface *iface;
 302
 303   g_return_val_if_fail (table != NULL, 0);
 304   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 305
 306   iface = ATK_TABLE_GET_IFACE (table);
 307
 308   if (iface->get_n_columns)
 309     return (iface->get_n_columns) (table);
 310   else
 311     return 0;
 312 }
 313
 314 /**
 315  * atk_table_get_column_description:
 316  * @table: a GObject instance that implements AtkTableIface
 317  * @column: a #gint representing a column in @table
 318  *
 319  * Gets the description text of the specified @column in the table
 320  * Note: callers should not rely on %NULL or on a zero value for
 321  * indication of whether AtkSelectionIface is implemented, they should
 322  * use type checking/interface checking macros or the
 323  * atk_get_accessible_table() convenience method.
 324  *
 325  * Returns: a gchar* representing the column description, or %NULL
 326  * if value does not implement this interface.
 327  **/
 328 gchar*
 329 atk_table_get_column_description (AtkTable *table,
 330                                   gint     column)
 331 {
 332   AtkTableIface *iface;
 333
 334   g_return_val_if_fail (table != NULL, NULL);
 335   g_return_val_if_fail (ATK_IS_TABLE (table), NULL);
 336
 337   iface = ATK_TABLE_GET_IFACE (table);
 338
 339   if (iface->get_column_description)
 340     return (iface->get_column_description) (table, column);
 341   else
 342     return NULL;
 343 }
 344
 345 /**
 346  * atk_table_get_column_extent_at:
 347  * @table: a GObject instance that implements AtkTableIface
 348  * @row: a #gint representing a row in @table
 349  * @column: a #gint representing a column in @table
 350  *
 351  * Gets the number of columns occupied by the accessible object
 352  * at the specified @row and @column in the @table.
 353  * Note: callers should not rely on %NULL or on a zero value for
 354  * indication of whether AtkSelectionIface is implemented, they should
 355  * use type checking/interface checking macros or the
 356  * atk_get_accessible_table() convenience method.
 357  *
 358  * Returns: a gint representing the column extent at specified position, or 0
 359  * if value does not implement this interface.
 360  **/
 361 gint
 362 atk_table_get_column_extent_at (AtkTable *table,
 363                                 gint     row,
 364                                 gint     column)
 365 {
 366   AtkTableIface *iface;
 367
 368   g_return_val_if_fail (table != NULL, 0);
 369   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 370
 371   iface = ATK_TABLE_GET_IFACE (table);
 372
 373   if (iface->get_column_extent_at)
 374     return (iface->get_column_extent_at) (table, row, column);
 375   else
 376     return 0;
 377 }
 378
 379 /**
 380  * atk_table_get_column_header:
 381  * @table: a GObject instance that implements AtkTableIface
 382  * @column: a #gint representing a column in the table
 383  *
 384  * Gets the column header of a specified column in an accessible table.
 385  * Note: callers should not rely on %NULL or on a zero value for
 386  * indication of whether AtkSelectionIface is implemented, they should
 387  * use type checking/interface checking macros or the
 388  * atk_get_accessible_table() convenience method.
 389  *
 390  * Returns: a AtkObject* representing the specified column header, or
 391  * %NULL if value does not implement this interface.
 392  **/
 393 AtkObject*
 394 atk_table_get_column_header (AtkTable *table, gint column)
 395 {
 396   AtkTableIface *iface;
 397
 398   g_return_val_if_fail (table != NULL, NULL);
 399   g_return_val_if_fail (ATK_IS_TABLE (table), NULL);
 400
 401   iface = ATK_TABLE_GET_IFACE (table);
 402
 403   if (iface->get_column_header)
 404     return (iface->get_column_header) (table, column);
 405   else
 406     return NULL;
 407 }
 408
 409 /**
 410  * atk_table_get_n_rows:
 411  * @table: a GObject instance that implements AtkTableIface
 412  *
 413  * Gets the number of rows in the table.
 414  * Note: callers should not rely on %NULL or on a zero value for
 415  * indication of whether AtkSelectionIface is implemented, they should
 416  * use type checking/interface checking macros or the
 417  * atk_get_accessible_table() convenience method.
 418  *
 419  * Returns: a gint representing the number of rows, or 0
 420  * if value does not implement this interface.
 421  **/
 422 gint
 423 atk_table_get_n_rows (AtkTable *table)
 424 {
 425   AtkTableIface *iface;
 426
 427   g_return_val_if_fail (table != NULL, 0);
 428   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 429
 430   iface = ATK_TABLE_GET_IFACE (table);
 431
 432   if (iface->get_n_rows)
 433     return (iface->get_n_rows) (table);
 434   else
 435     return 0;
 436 }
 437
 438 /**
 439  * atk_table_get_row_description:
 440  * @table: a GObject instance that implements AtkTableIface
 441  * @r: a #gint representing a row in @table
 442  *
 443  * Gets the description text of the specified row in the table
 444  * Note: callers should not rely on %NULL or on a zero value for
 445  * indication of whether AtkSelectionIface is implemented, they should
 446  * use type checking/interface checking macros or the
 447  * atk_get_accessible_table() convenience method.
 448  *
 449  * Returns: a gchar* representing the row description, or %NULL
 450  * if value does not implement this interface.
 451  **/
 452 gchar*
 453 atk_table_get_row_description (AtkTable *table,
 454                                gint      row)
 455 {
 456   AtkTableIface *iface;
 457
 458   g_return_val_if_fail (table != NULL, NULL);
 459   g_return_val_if_fail (ATK_IS_TABLE (table), NULL);
 460
 461   iface = ATK_TABLE_GET_IFACE (table);
 462
 463   if (iface->get_row_description)
 464     return (iface->get_row_description) (table, row);
 465   else
 466     return NULL;
 467 }
 468
 469 /**
 470  * atk_table_get_row_extent_at:
 471  * @table: a GObject instance that implements AtkTableIface
 472  * @row: a #gint representing a row in @table
 473  * @column: a #gint representing a column in @table
 474  *
 475  * Gets the number of rows occupied by the accessible object
 476  * at a specified @row and @column in the @table.
 477  * Note: callers should not rely on %NULL or on a zero value for
 478  * indication of whether AtkSelectionIface is implemented, they should
 479  * use type checking/interface checking macros or the
 480  * atk_get_accessible_table() convenience method.
 481  *
 482  * Returns: a gint representing the row extent at specified position, or 0
 483  * if value does not implement this interface.
 484  **/
 485 gint
 486 atk_table_get_row_extent_at (AtkTable *table,
 487                              gint     row,
 488                              gint     column)
 489 {
 490   AtkTableIface *iface;
 491
 492   g_return_val_if_fail (table != NULL, 0);
 493   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 494
 495   iface = ATK_TABLE_GET_IFACE (table);
 496
 497   if (iface->get_row_extent_at)
 498     return (iface->get_row_extent_at) (table, row, column);
 499   else
 500     return 0;
 501 }
 502
 503 /**
 504  * atk_table_get_row_header:
 505  * @table: a GObject instance that implements AtkTableIface
 506  * @row: a #gint representing a row in the table
 507  *
 508  * Gets the row header of a specified row in an accessible table.
 509  * Note: callers should not rely on %NULL or on a zero value for
 510  * indication of whether AtkSelectionIface is implemented, they should
 511  * use type checking/interface checking macros or the
 512  * atk_get_accessible_table() convenience method.
 513  *
 514  * Returns: a AtkObject* representing the specified row header, or
 515  * %NULL if value does not implement this interface.
 516  **/
 517 AtkObject*
 518 atk_table_get_row_header (AtkTable *table, gint row)
 519 {
 520   AtkTableIface *iface;
 521
 522   g_return_val_if_fail (table != NULL, NULL);
 523   g_return_val_if_fail (ATK_IS_TABLE (table), NULL);
 524
 525   iface = ATK_TABLE_GET_IFACE (table);
 526
 527   if (iface->get_row_header)
 528     return (iface->get_row_header) (table, row);
 529   else
 530     return NULL;
 531 }
 532
 533 /**
 534  * atk_table_get_summary:
 535  * @table: a GObject instance that implements AtkTableIface
 536  *
 537  * Gets the summary description of the table.
 538  * Note: callers should not rely on %NULL or on a zero value for
 539  * indication of whether AtkSelectionIface is implemented, they should
 540  * use type checking/interface checking macros or the
 541  * atk_get_accessible_table() convenience method.
 542  *
 543  * Returns: a AtkObject* representing a summary description of the table,
 544  * or zero if value does not implement this interface.
 545  **/
 546 AtkObject*
 547 atk_table_get_summary (AtkTable *table)
 548 {
 549   AtkTableIface *iface;
 550
 551   g_return_val_if_fail (table != NULL, NULL);
 552   g_return_val_if_fail (ATK_IS_TABLE (table), NULL);
 553
 554   iface = ATK_TABLE_GET_IFACE (table);
 555
 556   if (iface->get_summary)
 557     return (iface->get_summary) (table);
 558   else
 559     return NULL;
 560 }
 561
 562 /**
 563  * atk_table_get_selected_rows:
 564  * @table: a GObject instance that implements AtkTableIface
 565  * @selected: a #gint** that is to contain the selected row numbers
 566  *
 567  * Gets the selected rows of the table by initializing **selected with
 568  * the selected row numbers. This array should be freed by the caller.
 569  * Note: callers should not rely on %NULL or on a zero value for
 570  * indication of whether AtkSelectionIface is implemented, they should
 571  * use type checking/interface checking macros or the
 572  * atk_get_accessible_table() convenience method.
 573  *
 574  * Returns: a gint representing the number of selected rows,
 575  * or zero if value does not implement this interface.
 576  **/
 577 gint
 578 atk_table_get_selected_rows (AtkTable *table, gint **selected)
 579 {
 580   AtkTableIface *iface;
 581
 582   g_return_val_if_fail (table != NULL, 0);
 583   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 584
 585   iface = ATK_TABLE_GET_IFACE (table);
 586
 587   if (iface->get_selected_rows)
 588     return (iface->get_selected_rows) (table, selected);
 589   else
 590     return 0;
 591 }
 592
 593 /**
 594  * atk_table_get_selected_columns:
 595  * @table: a GObject instance that implements AtkTableIface
 596  * @selected: a #gint** that is to contain the selected columns numbers
 597  *
 598  * Gets the selected columns of the table by initializing **selected with
 599  * the selected column numbers. This array should be freed by the caller.
 600  * Note: callers should not rely on %NULL or on a zero value for
 601  * indication of whether AtkSelectionIface is implemented, they should
 602  * use type checking/interface checking macros or the
 603  * atk_get_accessible_table() convenience method.
 604  *
 605  * Returns: a gint representing the number of selected columns,
 606  * or %0 if value does not implement this interface.
 607  **/
 608 gint
 609 atk_table_get_selected_columns (AtkTable *table, gint **selected)
 610 {
 611   AtkTableIface *iface;
 612
 613   g_return_val_if_fail (table != NULL, 0);
 614   g_return_val_if_fail (ATK_IS_TABLE (table), 0);
 615
 616   iface = ATK_TABLE_GET_IFACE (table);
 617
 618   if (iface->get_selected_columns)
 619     return (iface->get_selected_columns) (table, selected);
 620   else
 621     return 0;
 622 }
 623
 624 /**
 625  * atk_table_is_column_selected:
 626  * @table: a GObject instance that implements AtkTableIface
 627  * @column: a #gint representing a column in @table
 628  *
 629  * Gets a boolean value indicating whether the specified @column
 630  * is selected
 631  * Note: callers should not rely on %NULL or on a zero value for
 632  * indication of whether AtkSelectionIface is implemented, they should
 633  * use type checking/interface checking macros or the
 634  * atk_get_accessible_table() convenience method.
 635  *
 636  * Returns: a gboolean representing if the column is selected, or 0
 637  * if value does not implement this interface.
 638  **/
 639 gboolean
 640 atk_table_is_column_selected (AtkTable *table,
 641                               gint     column)
 642 {
 643   AtkTableIface *iface;
 644
 645   g_return_val_if_fail (table != NULL, FALSE);
 646   g_return_val_if_fail (ATK_IS_TABLE (table), FALSE);
 647
 648   iface = ATK_TABLE_GET_IFACE (table);
 649
 650   if (iface->is_column_selected)
 651     return (iface->is_column_selected) (table, column);
 652   else
 653     return FALSE;
 654 }
 655
 656 /**
 657  * atk_table_is_row_selected:
 658  * @table: a GObject instance that implements AtkTableIface
 659  * @row: a #gint representing a row in @table
 660  *
 661  * Gets a boolean value indicating whether the specified @row
 662  * is selected
 663  * Note: callers should not rely on %NULL or on a zero value for
 664  * indication of whether AtkSelectionIface is implemented, they should
 665  * use type checking/interface checking macros or the
 666  * atk_get_accessible_table() convenience method.
 667  *
 668  * Returns: a gboolean representing if the row is selected, or 0
 669  * if value does not implement this interface.
 670  **/
 671 gboolean
 672 atk_table_is_row_selected (AtkTable *table,
 673                            gint     row)
 674 {
 675   AtkTableIface *iface;
 676
 677   g_return_val_if_fail (table != NULL, FALSE);
 678   g_return_val_if_fail (ATK_IS_TABLE (table), FALSE);
 679
 680   iface = ATK_TABLE_GET_IFACE (table);
 681
 682   if (iface->is_row_selected)
 683     return (iface->is_row_selected) (table, row);
 684   else
 685     return FALSE;
 686 }
 687
 688 /**
 689  * atk_table_is_selected:
 690  * @table: a GObject instance that implements AtkTableIface
 691  * @row: a #gint representing a row in @table
 692  * @column: a #gint representing a column in @table
 693  *
 694  * Gets a boolean value indicating whether the accessible object
 695  * at the specified @row and @column is selected
 696  * Note: callers should not rely on %NULL or on a zero value for
 697  * indication of whether AtkSelectionIface is implemented, they should
 698  * use type checking/interface checking macros or the
 699  * atk_get_accessible_table() convenience method.
 700  *
 701  * Returns: a gboolean representing if the cell is selected, or 0
 702  * if value does not implement this interface.
 703  **/
 704 gboolean
 705 atk_table_is_selected (AtkTable *table,
 706                        gint     row,
 707                        gint     column)
 708 {
 709   AtkTableIface *iface;
 710
 711   g_return_val_if_fail (table != NULL, FALSE);
 712   g_return_val_if_fail (ATK_IS_TABLE (table), FALSE);
 713
 714   iface = ATK_TABLE_GET_IFACE (table);
 715
 716   if (iface->is_selected)
 717     return (iface->is_selected) (table, row, column);
 718   else
 719     return FALSE;
 720 }
 721
 722 /**
 723  * atk_table_add_row_selection:
 724  * @table: a GObject instance that implements AtkTableIface
 725  * @row: a #gint representing a row in @table
 726  *
 727  * Adds the specified @row to the selection.
 728  * Note: callers should not rely on %NULL or on a zero value for
 729  * indication of whether AtkSelectionIface is implemented, they should
 730  * use type checking/interface checking macros or the
 731  * atk_get_accessible_table() convenience method.
 732  *
 733  * Returns: a gboolean representing if row was successfully added to selection,
 734  * or 0 if value does not implement this interface.
 735  **/
 736 gboolean
 737 atk_table_add_row_selection (AtkTable *table,
 738                                  gint     row)
 739 {
 740   AtkTableIface *iface;
 741
 742   g_return_val_if_fail (table != NULL, FALSE);
 743   g_return_val_if_fail (ATK_IS_TABLE (table), FALSE);
 744
 745   iface = ATK_TABLE_GET_IFACE (table);
 746
 747   if (iface->add_row_selection)
 748     return (iface->add_row_selection) (table, row);
 749   else
 750     return FALSE;
 751 }
 752 /**
 753  * atk_table_remove_row_selection:
 754  * @table: a GObject instance that implements AtkTableIface
 755  * @row: a #gint representing a row in @table
 756  *
 757  * Removes the specified @row from the selection.
 758  * Note: callers should not rely on %NULL or on a zero value for
 759  * indication of whether AtkSelectionIface is implemented, they should
 760  * use type checking/interface checking macros or the
 761  * atk_get_accessible_table() convenience method.
 762  *
 763  * Returns: a gboolean representing if the row was successfully removed from
 764  * the selection, or 0 if value does not implement this interface.
 765  **/
 766 gboolean
 767 atk_table_remove_row_selection (AtkTable *table,
 768                                     gint     row)
 769 {
 770   AtkTableIface *iface;
 771
 772   g_return_val_if_fail (table != NULL, FALSE);
 773   g_return_val_if_fail (ATK_IS_TABLE (table), FALSE);
 774
 775   iface = ATK_TABLE_GET_IFACE (table);
 776
 777   if (iface->remove_row_selection)
 778     return (iface->remove_row_selection) (table, row);
 779   else
 780     return FALSE;
 781 }
 782 /**
 783  * atk_table_add_column_selection:
 784  * @table: a GObject instance that implements AtkTableIface
 785  * @column: a #gint representing a column in @table
 786  *
 787  * Adds the specified @column to the selection.
 788  * Note: callers should not rely on %NULL or on a zero value for
 789  * indication of whether AtkSelectionIface is implemented, they should
 790  * use type checking/interface checking macros or the
 791  * atk_get_accessible_table() convenience method.
 792  *
 793  * Returns: a gboolean representing if the column was successfully added to
 794  * the selection, or 0 if value does not implement this interface.
 795  **/
 796 gboolean
 797 atk_table_add_column_selection (AtkTable *table,
 798                                     gint     column)
 799 {
 800   AtkTableIface *iface;
 801
 802   g_return_val_if_fail (table != NULL, FALSE);
 803   g_return_val_if_fail (ATK_IS_TABLE (table), FALSE);
 804
 805   iface = ATK_TABLE_GET_IFACE (table);
 806
 807   if (iface->add_column_selection)
 808     return (iface->add_column_selection) (table, column);
 809   else
 810     return FALSE;
 811 }
 812 /**
 813  * atk_table_remove_column_selection:
 814  * @table: a GObject instance that implements AtkTableIface
 815  * @column: a #gint representing a column in @table
 816  *
 817  * Adds the specified @column to the selection.
 818  * Note: callers should not rely on %NULL or on a zero value for
 819  * indication of whether AtkSelectionIface is implemented, they should
 820  * use type checking/interface checking macros or the
 821  * atk_get_accessible_table() convenience method.
 822  *
 823  * Returns: a gboolean representing if the column was successfully removed from
 824  * the selection, or 0 if value does not implement this interface.
 825  **/
 826 gboolean
 827 atk_table_remove_column_selection (AtkTable *table,
 828                                            gint     column)
 829 {
 830   AtkTableIface *iface;
 831
 832   g_return_val_if_fail (table != NULL, FALSE);
 833   g_return_val_if_fail (ATK_IS_TABLE (table), FALSE);
 834
 835   iface = ATK_TABLE_GET_IFACE (table);
 836
 837   if (iface->remove_column_selection)
 838     return (iface->remove_column_selection) (table, column);
 839   else
 840     return FALSE;
 841 }
 842
 843 /**
 844  * atk_table_set_caption:
 845  * @table: a GObject instance that implements AtkTableIface
 846  * @caption: a #gchar representing the caption to set for @table
 847  *
 848  * Sets the caption for the table.
 849  **/
 850 void
 851 atk_table_set_caption (AtkTable       *table,
 852                        gchar          *caption)
 853 {
 854   AtkTableIface *iface;
 855
 856   g_return_if_fail (table != NULL);
 857   g_return_if_fail (ATK_IS_TABLE (table));
 858
 859   iface = ATK_TABLE_GET_IFACE (table);
 860
 861   if (iface->set_caption)
 862     (iface->set_caption) (table, caption);
 863 }
 864
 865 /**
 866  * atk_table_set_column_description:
 867  * @table: a GObject instance that implements AtkTableIface
 868  * @column: a #gint representing a column in @table
 869  * @description: a #gchar representing the description text
 870  * to set for the specified @column of the @table
 871  *
 872  * Sets the description text for the specified @column of the @table.
 873  **/
 874 void
 875 atk_table_set_column_description (AtkTable       *table,
 876                                   gint           column,
 877                                   gchar          *description)
 878 {
 879   AtkTableIface *iface;
 880
 881   g_return_if_fail (table != NULL);
 882   g_return_if_fail (ATK_IS_TABLE (table));
 883
 884   iface = ATK_TABLE_GET_IFACE (table);
 885
 886   if (iface->set_column_description)
 887     (iface->set_column_description) (table, column, description);
 888 }
 889
 890 /**
 891  * atk_table_set_column_header:
 892  * @table: a GObject instance that implements AtkTableIface
 893  * @column: a #gint representing a column in @table
 894  * @header: an #AtkTable
 895  *
 896  * Sets the specified column header to @header.
 897  **/
 898 void
 899 atk_table_set_column_header (AtkTable  *table,
 900                              gint      column,
 901                              AtkObject *header)
 902 {
 903   AtkTableIface *iface;
 904
 905   g_return_if_fail (table != NULL);
 906   g_return_if_fail (ATK_IS_TABLE (table));
 907
 908   iface = ATK_TABLE_GET_IFACE (table);
 909
 910   if (iface->set_column_header)
 911     (iface->set_column_header) (table, column, header);
 912 }
 913
 914 /**
 915  * atk_table_set_row_description:
 916  * @table: a GObject instance that implements AtkTableIface
 917  * @row: a #gint representing a row in @table
 918  * @description: a #gchar representing the description text
 919  * to set for the specified @row of @table
 920  *
 921  * Sets the description text for the specified @row of @table.
 922  **/
 923 void
 924 atk_table_set_row_description (AtkTable       *table,
 925                                gint           row,
 926                                gchar          *description)
 927 {
 928   AtkTableIface *iface;
 929
 930   g_return_if_fail (table != NULL);
 931   g_return_if_fail (ATK_IS_TABLE (table));
 932
 933   iface = ATK_TABLE_GET_IFACE (table);
 934
 935   if (iface->set_row_description)
 936     (iface->set_row_description) (table, row, description);
 937 }
 938
 939 /**
 940  * atk_table_set_row_header:
 941  * @table: a GObject instance that implements AtkTableIface
 942  * @row: a #gint representing a row in @table
 943  * @header: an #AtkTable
 944  *
 945  * Sets the specified row header to @header.
 946  **/
 947 void
 948 atk_table_set_row_header (AtkTable  *table,
 949                           gint      row,
 950                           AtkObject *header)
 951 {
 952   AtkTableIface *iface;
 953
 954   g_return_if_fail (table != NULL);
 955   g_return_if_fail (ATK_IS_TABLE (table));
 956
 957   iface = ATK_TABLE_GET_IFACE (table);
 958
 959   if (iface->set_row_header)
 960     (iface->set_row_header) (table, row, header);
 961 }
 962
 963 /**
 964  * atk_table_set_summary:
 965  * @table: a GObject instance that implements AtkTableIface
 966  * @accessible: an #AtkObject representing the summary description
 967  * to set for @table
 968  *
 969  * Sets the summary description of the table.
 970  **/
 971 void
 972 atk_table_set_summary (AtkTable       *table,
 973                        AtkObject      *accessible)
 974 {
 975   AtkTableIface *iface;
 976
 977   g_return_if_fail (table != NULL);
 978   g_return_if_fail (ATK_IS_TABLE (table));
 979
 980   iface = ATK_TABLE_GET_IFACE (table);
 981
 982   if (iface->set_summary)
 983     (iface->set_summary) (table, accessible);
 984 }