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   MODEL_CHANGED,
  25   LAST_SIGNAL
  26 };
  27
  28 struct _AtkTableIfaceClass
  29 {
  30   GObjectClass parent;
  31 };
  32
  33 typedef struct _AtkTableIfaceClass AtkTableIfaceClass;
  34
  35 static void atk_table_base_init (gpointer *g_class);
  36
  37 static guint atk_table_signals[LAST_SIGNAL] = { 0 };
  38
  39 GType
  40 atk_table_get_type ()
  41 {
  42   static GType type = 0;
  43
  44   if (!type) {
  45     GTypeInfo tinfo =
  46     {
  47       sizeof (AtkTableIface),
  48       (GBaseInitFunc) atk_table_base_init,
  49       (GBaseFinalizeFunc) NULL,
  50
  51     };
  52
  53     type = g_type_register_static (G_TYPE_INTERFACE, "AtkTable", &tinfo, 0);
  54   }
  55
  56   return type;
  57 }
  58
  59
  60 static void
  61 atk_table_base_init (gpointer *g_class)
  62 {
  63   static gboolean initialized = FALSE;
  64
  65   if (! initialized)
  66   {
  67     atk_table_signals[MODEL_CHANGED] =
  68       g_signal_newc ("model_changed",
  69                      ATK_TYPE_TABLE,
  70                      G_SIGNAL_RUN_LAST,
  71                      G_STRUCT_OFFSET (AtkTableIface, model_changed),
  72                      (GSignalAccumulator) NULL, NULL,
  73                      atk_marshal_VOID__INT_INT_INT_INT_INT,
  74                      G_TYPE_NONE,
  75                      5, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT,
  76                      G_TYPE_INT);
  77     initialized = TRUE;
  78   }
  79 }
  80
  81 /**
  82  * atk_table_ref_at:
  83  * @table: a GObject instance that implements AtkTableIface
  84  * @row: a #gint representing a row in @table
  85  * @column: a #gint representing a column in @table
  86  *
  87  * Get a reference to the table cell at @row, @column
  88  *
  89  * Returns: a AtkObject* representing the referred to accessible
  90  **/
  91 AtkObject*
  92 atk_table_ref_at (AtkTable *obj,
  93                   gint     row,
  94                   gint     column)
  95 {
  96   AtkTableIface *iface;
  97
  98   g_return_val_if_fail (obj != NULL, NULL);
  99   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 100
 101   iface = ATK_TABLE_GET_IFACE (obj);
 102
 103   if (iface->ref_at)
 104     return (iface->ref_at) (obj, row, column);
 105   else
 106     return NULL;
 107 }
 108
 109 /**
 110  * atk_table_get_index_at:
 111  * @table: a GObject instance that implements AtkTableIface
 112  * @row: a #gint representing a row in @table
 113  * @column: a #gint representing a column in @table
 114  *
 115  * Gets a #gint representing the index at the specified @row and @column,
 116  * or 0 if value does not implement this interface.
 117  * Note: callers should not rely on %NULL or on a zero value for
 118  * indication of whether AtkSelectionIface is implemented, they should
 119  * use type checking/interface checking macros or the
 120  * atk_get_accessible_table() convenience method.
 121  *
 122  * Returns: a #gint representing the index at specified position, or 0
 123  * if value does not implement this interface.
 124  **/
 125 gint
 126 atk_table_get_index_at (AtkTable *obj,
 127                         gint     row,
 128                         gint     column)
 129 {
 130   AtkTableIface *iface;
 131
 132   g_return_val_if_fail (obj != NULL, 0);
 133   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 134
 135   iface = ATK_TABLE_GET_IFACE (obj);
 136
 137   if (iface->get_index_at)
 138     return (iface->get_index_at) (obj, row, column);
 139   else
 140     return 0;
 141 }
 142
 143 /**
 144  * atk_table_get_row_at_index:
 145  * @table: a GObject instance that implements AtkTableInterface
 146  * @index: a #gint representing an index in @table
 147  *
 148  * Gets a #gint representing the row at the specified @index, or 0
 149  * if the value does not implement this interface
 150  * Note: callers should not rely on %NULL or on a zero value for
 151  * indication of whether AtkSelectionIface is implemented, they should
 152  * use type checking/interface checking macros or the
 153  * atk_get_accessible_table() convenience method.
 154  *
 155  * Returns: a gint representing the row at the specified  index, or 0
 156  * if value does not implement this interface.
 157  **/
 158 gint
 159 atk_table_get_row_at_index (AtkTable *obj,
 160                             gint     index)
 161 {
 162   AtkTableIface *iface;
 163
 164   g_return_val_if_fail (obj != NULL, 0);
 165   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 166
 167   iface = ATK_TABLE_GET_IFACE (obj);
 168
 169   if (iface->get_row_at_index)
 170     return (iface->get_row_at_index) (obj, index);
 171   else
 172     return 0;
 173 }
 174
 175 /**
 176  * atk_table_get_column_at_index:
 177  * @table: a GObject instance that implements AtkTableInterface
 178  * @index: a #gint representing an index in @table
 179  *
 180  * Gets a #gint representing the column at the specified @index, or 0
 181  * if the value does not implement this interface
 182  * Note: callers should not rely on %NULL or on a zero value for
 183  * indication of whether AtkSelectionIface is implemented, they should
 184  * use type checking/interface checking macros or the
 185  * atk_get_accessible_table() convenience method.
 186  *
 187  * Returns: a gint representing the column at the specified  index, or 0
 188  * if value does not implement this interface.
 189  **/
 190 gint
 191 atk_table_get_column_at_index (AtkTable *obj,
 192                                gint     index)
 193 {
 194   AtkTableIface *iface;
 195
 196   g_return_val_if_fail (obj != NULL, 0);
 197   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 198
 199   iface = ATK_TABLE_GET_IFACE (obj);
 200
 201   if (iface->get_column_at_index)
 202     return (iface->get_column_at_index) (obj, index);
 203   else
 204     return 0;
 205 }
 206
 207 /**
 208  * atk_table_get_caption:
 209  * @table: a GObject instance that implements AtkTableInterface
 210  *
 211  * Gets the caption for the @table.
 212  * Note: callers should not rely on %NULL or on a zero value for
 213  * indication of whether AtkSelectionIface is implemented, they should
 214  * use type checking/interface checking macros or the
 215  * atk_get_accessible_table() convenience method.
 216  *
 217  * Returns: a gchar* representing the table caption, or %NULL
 218  * if value does not implement this interface.
 219  **/
 220 gchar*
 221 atk_table_get_caption (AtkTable *obj)
 222 {
 223   AtkTableIface *iface;
 224
 225   g_return_val_if_fail (obj != NULL, NULL);
 226   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 227
 228   iface = ATK_TABLE_GET_IFACE (obj);
 229
 230   if (iface->get_caption)
 231     return (iface->get_caption) (obj);
 232   else
 233     return NULL;
 234 }
 235
 236 /**
 237  * atk_table_get_n_columns:
 238  * @table: a GObject instance that implements AtkTableIface
 239  *
 240  * Gets the number of columns in the table.
 241  * Note: callers should not rely on %NULL or on a zero value for
 242  * indication of whether AtkSelectionIface is implemented, they should
 243  * use type checking/interface checking macros or the
 244  * atk_get_accessible_table() convenience method.
 245  *
 246  * Returns: a gint representing the number of columns, or 0
 247  * if value does not implement this interface.
 248  **/
 249 gint
 250 atk_table_get_n_columns (AtkTable *obj)
 251 {
 252   AtkTableIface *iface;
 253
 254   g_return_val_if_fail (obj != NULL, 0);
 255   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 256
 257   iface = ATK_TABLE_GET_IFACE (obj);
 258
 259   if (iface->get_n_columns)
 260     return (iface->get_n_columns) (obj);
 261   else
 262     return 0;
 263 }
 264
 265 /**
 266  * atk_table_get_column_description:
 267  * @table: a GObject instance that implements AtkTableIface
 268  * @column: a #gint representing a column in @table
 269  *
 270  * Gets the description text of the specified @column in the table
 271  * Note: callers should not rely on %NULL or on a zero value for
 272  * indication of whether AtkSelectionIface is implemented, they should
 273  * use type checking/interface checking macros or the
 274  * atk_get_accessible_table() convenience method.
 275  *
 276  * Returns: a gchar* representing the column description, or %NULL
 277  * if value does not implement this interface.
 278  **/
 279 gchar*
 280 atk_table_get_column_description (AtkTable *obj,
 281                                   gint     column)
 282 {
 283   AtkTableIface *iface;
 284
 285   g_return_val_if_fail (obj != NULL, NULL);
 286   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 287
 288   iface = ATK_TABLE_GET_IFACE (obj);
 289
 290   if (iface->get_column_description)
 291     return (iface->get_column_description) (obj, column);
 292   else
 293     return NULL;
 294 }
 295
 296 /**
 297  * atk_table_get_column_extent_at:
 298  * @table: a GObject instance that implements AtkTableIface
 299  * @row: a #gint representing a row in @table
 300  * @column: a #gint representing a column in @table
 301  *
 302  * Gets the number of columns occupied by the accessible object
 303  * at the specified @row and @column in the @table.
 304  * Note: callers should not rely on %NULL or on a zero value for
 305  * indication of whether AtkSelectionIface is implemented, they should
 306  * use type checking/interface checking macros or the
 307  * atk_get_accessible_table() convenience method.
 308  *
 309  * Returns: a gint representing the column extent at specified position, or 0
 310  * if value does not implement this interface.
 311  **/
 312 gint
 313 atk_table_get_column_extent_at (AtkTable *obj,
 314                                 gint     row,
 315                                 gint     column)
 316 {
 317   AtkTableIface *iface;
 318
 319   g_return_val_if_fail (obj != NULL, 0);
 320   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 321
 322   iface = ATK_TABLE_GET_IFACE (obj);
 323
 324   if (iface->get_column_extent_at)
 325     return (iface->get_column_extent_at) (obj, row, column);
 326   else
 327     return 0;
 328 }
 329
 330 /**
 331  * atk_table_get_column_header:
 332  * @table: a GObject instance that implements AtkTableIface
 333  * @column: a #gint representing a column in the table
 334  *
 335  * Gets the column header of a specified column in an accessible table.
 336  * Note: callers should not rely on %NULL or on a zero value for
 337  * indication of whether AtkSelectionIface is implemented, they should
 338  * use type checking/interface checking macros or the
 339  * atk_get_accessible_table() convenience method.
 340  *
 341  * Returns: a AtkObject* representing the specified column header, or
 342  * %NULL if value does not implement this interface.
 343  **/
 344 AtkObject*
 345 atk_table_get_column_header (AtkTable *obj, gint column)
 346 {
 347   AtkTableIface *iface;
 348
 349   g_return_val_if_fail (obj != NULL, NULL);
 350   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 351
 352   iface = ATK_TABLE_GET_IFACE (obj);
 353
 354   if (iface->get_column_header)
 355     return (iface->get_column_header) (obj, column);
 356   else
 357     return NULL;
 358 }
 359
 360 /**
 361  * atk_table_get_n_rows:
 362  * @table: a GObject instance that implements AtkTableIface
 363  *
 364  * Gets the number of rows in the table.
 365  * Note: callers should not rely on %NULL or on a zero value for
 366  * indication of whether AtkSelectionIface is implemented, they should
 367  * use type checking/interface checking macros or the
 368  * atk_get_accessible_table() convenience method.
 369  *
 370  * Returns: a gint representing the number of rows, or 0
 371  * if value does not implement this interface.
 372  **/
 373 gint
 374 atk_table_get_n_rows (AtkTable *obj)
 375 {
 376   AtkTableIface *iface;
 377
 378   g_return_val_if_fail (obj != NULL, 0);
 379   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 380
 381   iface = ATK_TABLE_GET_IFACE (obj);
 382
 383   if (iface->get_n_rows)
 384     return (iface->get_n_rows) (obj);
 385   else
 386     return 0;
 387 }
 388
 389 /**
 390  * atk_table_get_row_description:
 391  * @table: a GObject instance that implements AtkTableIface
 392  * @r: a #gint representing a row in @table
 393  *
 394  * Gets the description text of the specified row in the table
 395  * Note: callers should not rely on %NULL or on a zero value for
 396  * indication of whether AtkSelectionIface is implemented, they should
 397  * use type checking/interface checking macros or the
 398  * atk_get_accessible_table() convenience method.
 399  *
 400  * Returns: a gchar* representing the row description, or %NULL
 401  * if value does not implement this interface.
 402  **/
 403 gchar*
 404 atk_table_get_row_description (AtkTable *obj,
 405                                gint      row)
 406 {
 407   AtkTableIface *iface;
 408
 409   g_return_val_if_fail (obj != NULL, NULL);
 410   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 411
 412   iface = ATK_TABLE_GET_IFACE (obj);
 413
 414   if (iface->get_row_description)
 415     return (iface->get_row_description) (obj, row);
 416   else
 417     return NULL;
 418 }
 419
 420 /**
 421  * atk_table_get_row_extent_at:
 422  * @table: a GObject instance that implements AtkTableIface
 423  * @row: a #gint representing a row in @table
 424  * @column: a #gint representing a column in @table
 425  *
 426  * Gets the number of rows occupied by the accessible object
 427  * at a specified @row and @column in the @table.
 428  * Note: callers should not rely on %NULL or on a zero value for
 429  * indication of whether AtkSelectionIface is implemented, they should
 430  * use type checking/interface checking macros or the
 431  * atk_get_accessible_table() convenience method.
 432  *
 433  * Returns: a gint representing the row extent at specified position, or 0
 434  * if value does not implement this interface.
 435  **/
 436 gint
 437 atk_table_get_row_extent_at (AtkTable *obj,
 438                              gint     row,
 439                              gint     column)
 440 {
 441   AtkTableIface *iface;
 442
 443   g_return_val_if_fail (obj != NULL, 0);
 444   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 445
 446   iface = ATK_TABLE_GET_IFACE (obj);
 447
 448   if (iface->get_row_extent_at)
 449     return (iface->get_row_extent_at) (obj, row, column);
 450   else
 451     return 0;
 452 }
 453
 454 /**
 455  * atk_table_get_row_header:
 456  * @table: a GObject instance that implements AtkTableIface
 457  * @row: a #gint representing a row in the table
 458  *
 459  * Gets the row header of a specified row in an accessible table.
 460  * Note: callers should not rely on %NULL or on a zero value for
 461  * indication of whether AtkSelectionIface is implemented, they should
 462  * use type checking/interface checking macros or the
 463  * atk_get_accessible_table() convenience method.
 464  *
 465  * Returns: a AtkObject* representing the specified row header, or
 466  * %NULL if value does not implement this interface.
 467  **/
 468 AtkObject*
 469 atk_table_get_row_header (AtkTable *obj, gint row)
 470 {
 471   AtkTableIface *iface;
 472
 473   g_return_val_if_fail (obj != NULL, NULL);
 474   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 475
 476   iface = ATK_TABLE_GET_IFACE (obj);
 477
 478   if (iface->get_row_header)
 479     return (iface->get_row_header) (obj, row);
 480   else
 481     return NULL;
 482 }
 483
 484 /**
 485  * atk_table_get_summary:
 486  * @table: a GObject instance that implements AtkTableIface
 487  *
 488  * Gets the summary description of the table.
 489  * Note: callers should not rely on %NULL or on a zero value for
 490  * indication of whether AtkSelectionIface is implemented, they should
 491  * use type checking/interface checking macros or the
 492  * atk_get_accessible_table() convenience method.
 493  *
 494  * Returns: a AtkObject* representing a sumary description of the table,
 495  * or %NULL if value does not implement this interface.
 496  **/
 497 AtkObject*
 498 atk_table_get_summary (AtkTable *obj)
 499 {
 500   AtkTableIface *iface;
 501
 502   g_return_val_if_fail (obj != NULL, NULL);
 503   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 504
 505   iface = ATK_TABLE_GET_IFACE (obj);
 506
 507   if (iface->get_summary)
 508     return (iface->get_summary) (obj);
 509   else
 510     return NULL;
 511 }
 512
 513 /**
 514  * atk_table_get_selected_rows:
 515  * @table: a GObject instance that implements AtkTableIface
 516  *
 517  * Gets the selected rows of the table.
 518  * Note: callers should not rely on %NULL or on a zero value for
 519  * indication of whether AtkSelectionIface is implemented, they should
 520  * use type checking/interface checking macros or the
 521  * atk_get_accessible_table() convenience method.
 522  *
 523  * Returns: a gint* representing the selected rows,
 524  * or %NULL if value does not implement this interface.
 525  **/
 526 gint*
 527 atk_table_get_selected_rows (AtkTable *obj)
 528 {
 529   AtkTableIface *iface;
 530
 531   g_return_val_if_fail (obj != NULL, NULL);
 532   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 533
 534   iface = ATK_TABLE_GET_IFACE (obj);
 535
 536   if (iface->get_selected_rows)
 537     return (iface->get_selected_rows) (obj);
 538   else
 539     return NULL;
 540 }
 541
 542 /**
 543  * atk_table_get_selected_columns:
 544  * @table: a GObject instance that implements AtkTableIface
 545  *
 546  * Gets the selected columns of the table.
 547  * Note: callers should not rely on %NULL or on a zero value for
 548  * indication of whether AtkSelectionIface is implemented, they should
 549  * use type checking/interface checking macros or the
 550  * atk_get_accessible_table() convenience method.
 551  *
 552  * Returns: a gint* representing the selected columns,
 553  * or %NULL if value does not implement this interface.
 554  *
 555  **/
 556 gint*
 557 atk_table_get_selected_columns (AtkTable *obj)
 558 {
 559   AtkTableIface *iface;
 560
 561   g_return_val_if_fail (obj != NULL, NULL);
 562   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 563
 564   iface = ATK_TABLE_GET_IFACE (obj);
 565
 566   if (iface->get_selected_columns)
 567     return (iface->get_selected_columns) (obj);
 568   else
 569     return NULL;
 570 }
 571
 572 /**
 573  * atk_table_is_column_selected:
 574  * @table: a GObject instance that implements AtkTableIface
 575  * @column: a #gint representing a column in @table
 576  *
 577  * Gets a boolean value indicating whether the specified @column
 578  * is selected
 579  * Note: callers should not rely on %NULL or on a zero value for
 580  * indication of whether AtkSelectionIface is implemented, they should
 581  * use type checking/interface checking macros or the
 582  * atk_get_accessible_table() convenience method.
 583  *
 584  * Returns: a gboolean representing if the column is selected, or 0
 585  * if value does not implement this interface.
 586  **/
 587 gboolean
 588 atk_table_is_column_selected (AtkTable *obj,
 589                               gint     column)
 590 {
 591   AtkTableIface *iface;
 592
 593   g_return_val_if_fail (obj != NULL, FALSE);
 594   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 595
 596   iface = ATK_TABLE_GET_IFACE (obj);
 597
 598   if (iface->is_column_selected)
 599     return (iface->is_column_selected) (obj, column);
 600   else
 601     return FALSE;
 602 }
 603
 604 /**
 605  * atk_table_is_row_selected:
 606  * @table: a GObject instance that implements AtkTableIface
 607  * @row: a #gint representing a row in @table
 608  *
 609  * Gets a boolean value indicating whether the specified @row
 610  * is selected
 611  * Note: callers should not rely on %NULL or on a zero value for
 612  * indication of whether AtkSelectionIface is implemented, they should
 613  * use type checking/interface checking macros or the
 614  * atk_get_accessible_table() convenience method.
 615  *
 616  * Returns: a gboolean representing if the row is selected, or 0
 617  * if value does not implement this interface.
 618  **/
 619 gboolean
 620 atk_table_is_row_selected (AtkTable *obj,
 621                            gint     row)
 622 {
 623   AtkTableIface *iface;
 624
 625   g_return_val_if_fail (obj != NULL, FALSE);
 626   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 627
 628   iface = ATK_TABLE_GET_IFACE (obj);
 629
 630   if (iface->is_row_selected)
 631     return (iface->is_row_selected) (obj, row);
 632   else
 633     return FALSE;
 634 }
 635
 636 /**
 637  * atk_table_is_selected:
 638  * @table: a GObject instance that implements AtkTableIface
 639  * @row: a #gint representing a row in @table
 640  * @column: a #gint representing a column in @table
 641  *
 642  * Gets a boolean value indicating whether the acessible object
 643  * at the specified @row and @column is selected
 644  * Note: callers should not rely on %NULL or on a zero value for
 645  * indication of whether AtkSelectionIface is implemented, they should
 646  * use type checking/interface checking macros or the
 647  * atk_get_accessible_table() convenience method.
 648  *
 649  * Returns: a gboolean representing if the cell is selected, or 0
 650  * if value does not implement this interface.
 651  **/
 652 gboolean
 653 atk_table_is_selected (AtkTable *obj,
 654                        gint     row,
 655                        gint     column)
 656 {
 657   AtkTableIface *iface;
 658
 659   g_return_val_if_fail (obj != NULL, FALSE);
 660   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 661
 662   iface = ATK_TABLE_GET_IFACE (obj);
 663
 664   if (iface->is_selected)
 665     return (iface->is_selected) (obj, row, column);
 666   else
 667     return FALSE;
 668 }
 669
 670 /**
 671  * atk_table_set_caption:
 672  * @table: a GObject instance that implements AtkTableIface
 673  * @caption: a #gchar representing the caption to set for @table
 674  *
 675  * Sets the caption for the table.
 676  **/
 677 void
 678 atk_table_set_caption (AtkTable       *obj,
 679                        gchar          *caption)
 680 {
 681   AtkTableIface *iface;
 682
 683   g_return_if_fail (obj != NULL);
 684   g_return_if_fail (ATK_IS_TABLE (obj));
 685
 686   iface = ATK_TABLE_GET_IFACE (obj);
 687
 688   if (iface->set_caption)
 689     (iface->set_caption) (obj, caption);
 690 }
 691
 692 /**
 693  * atk_table_set_column_description:
 694  * @table: a GObject instance that implements AtkTableIface
 695  * @column: a #gint representing a column in @table
 696  * @description: a #gchar representing the description text
 697  * to set for the specified @column of the @table
 698  *
 699  * Sets the description text for the specified @column of the @table.
 700  **/
 701 void
 702 atk_table_set_column_description (AtkTable       *obj,
 703                                   gint           column,
 704                                   gchar          *description)
 705 {
 706   AtkTableIface *iface;
 707
 708   g_return_if_fail (obj != NULL);
 709   g_return_if_fail (ATK_IS_TABLE (obj));
 710
 711   iface = ATK_TABLE_GET_IFACE (obj);
 712
 713   if (iface->set_column_description)
 714     (iface->set_column_description) (obj, column, description);
 715 }
 716
 717 /**
 718  * atk_table_set_column_header:
 719  * @table: a GObject instance that implements AtkTableIface
 720  * @column: a #gint representing a column in @table
 721  * @header: an #AtkTable
 722  *
 723  * Sets the specified column header to @header
 724  **/
 725 void
 726 atk_table_set_column_header (AtkTable  *obj,
 727                              gint      column,
 728                              AtkObject *header)
 729 {
 730   AtkTableIface *iface;
 731
 732   g_return_if_fail (obj != NULL);
 733   g_return_if_fail (ATK_IS_TABLE (obj));
 734
 735   iface = ATK_TABLE_GET_IFACE (obj);
 736
 737   if (iface->set_column_header)
 738     (iface->set_column_header) (obj, column, header);
 739 }
 740
 741 /**
 742  * atk_table_set_row_description:
 743  * @table: a GObject instance that implements AtkTableIface
 744  * @row: a #gint representing a row in @table
 745  * @description: a #gchar representing the description text
 746  * to set for the specified @row of @table
 747  *
 748  * Sets the description text for the specified @row of @table.
 749  **/
 750 void
 751 atk_table_set_row_description (AtkTable       *obj,
 752                                gint           row,
 753                                gchar          *description)
 754 {
 755   AtkTableIface *iface;
 756
 757   g_return_if_fail (obj != NULL);
 758   g_return_if_fail (ATK_IS_TABLE (obj));
 759
 760   iface = ATK_TABLE_GET_IFACE (obj);
 761
 762   if (iface->set_row_description)
 763     (iface->set_row_description) (obj, row, description);
 764 }
 765
 766 /**
 767  * atk_table_set_row_header:
 768  * @table: a GObject instance that implements AtkTableIface
 769  * @row: a #gint representing a row in @table
 770  * @header: an #AtkTable
 771  *
 772  * Sets the specified row header to @header
 773  **/
 774 void
 775 atk_table_set_row_header (AtkTable  *obj,
 776                           gint      row,
 777                           AtkObject *header)
 778 {
 779   AtkTableIface *iface;
 780
 781   g_return_if_fail (obj != NULL);
 782   g_return_if_fail (ATK_IS_TABLE (obj));
 783
 784   iface = ATK_TABLE_GET_IFACE (obj);
 785
 786   if (iface->set_row_header)
 787     (iface->set_row_header) (obj, row, header);
 788 }
 789
 790 /**
 791  * atk_table_set_summary:
 792  * @table: a GObject instance that implements AtkTableIface
 793  * @accessible: an #AtkObject representing the summary description
 794  * to set for @table
 795  *
 796  * Sets the summary description of the table
 797  **/
 798 void
 799 atk_table_set_summary (AtkTable       *obj,
 800                        AtkObject      *accessible)
 801 {
 802   AtkTableIface *iface;
 803
 804   g_return_if_fail (obj != NULL);
 805   g_return_if_fail (ATK_IS_TABLE (obj));
 806
 807   iface = ATK_TABLE_GET_IFACE (obj);
 808
 809   if (iface->set_summary)
 810     (iface->set_summary) (obj, accessible);
 811 }