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, model_changed),
  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, model_changed),
  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, model_changed),
  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, model_changed),
 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, model_changed),
 113                      (GSignalAccumulator) NULL, NULL,
 114                      atk_marshal_VOID__INT_INT,
 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, model_changed),
 122                      (GSignalAccumulator) NULL, NULL,
 123                      atk_marshal_VOID__INT_INT,
 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 *obj,
 142                   gint     row,
 143                   gint     column)
 144 {
 145   AtkTableIface *iface;
 146
 147   g_return_val_if_fail (obj != NULL, NULL);
 148   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 149
 150   iface = ATK_TABLE_GET_IFACE (obj);
 151
 152   if (iface->ref_at)
 153     return (iface->ref_at) (obj, 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 *obj,
 176                         gint     row,
 177                         gint     column)
 178 {
 179   AtkTableIface *iface;
 180
 181   g_return_val_if_fail (obj != NULL, 0);
 182   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 183
 184   iface = ATK_TABLE_GET_IFACE (obj);
 185
 186   if (iface->get_index_at)
 187     return (iface->get_index_at) (obj, 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 *obj,
 209                             gint     index)
 210 {
 211   AtkTableIface *iface;
 212
 213   g_return_val_if_fail (obj != NULL, 0);
 214   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 215
 216   iface = ATK_TABLE_GET_IFACE (obj);
 217
 218   if (iface->get_row_at_index)
 219     return (iface->get_row_at_index) (obj, 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 *obj,
 241                                gint     index)
 242 {
 243   AtkTableIface *iface;
 244
 245   g_return_val_if_fail (obj != NULL, 0);
 246   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 247
 248   iface = ATK_TABLE_GET_IFACE (obj);
 249
 250   if (iface->get_column_at_index)
 251     return (iface->get_column_at_index) (obj, 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 *obj)
 271 {
 272   AtkTableIface *iface;
 273
 274   g_return_val_if_fail (obj != NULL, NULL);
 275   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 276
 277   iface = ATK_TABLE_GET_IFACE (obj);
 278
 279   if (iface->get_caption)
 280     return (iface->get_caption) (obj);
 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 *obj)
 300 {
 301   AtkTableIface *iface;
 302
 303   g_return_val_if_fail (obj != NULL, 0);
 304   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 305
 306   iface = ATK_TABLE_GET_IFACE (obj);
 307
 308   if (iface->get_n_columns)
 309     return (iface->get_n_columns) (obj);
 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 *obj,
 330                                   gint     column)
 331 {
 332   AtkTableIface *iface;
 333
 334   g_return_val_if_fail (obj != NULL, NULL);
 335   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 336
 337   iface = ATK_TABLE_GET_IFACE (obj);
 338
 339   if (iface->get_column_description)
 340     return (iface->get_column_description) (obj, 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 *obj,
 363                                 gint     row,
 364                                 gint     column)
 365 {
 366   AtkTableIface *iface;
 367
 368   g_return_val_if_fail (obj != NULL, 0);
 369   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 370
 371   iface = ATK_TABLE_GET_IFACE (obj);
 372
 373   if (iface->get_column_extent_at)
 374     return (iface->get_column_extent_at) (obj, 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 *obj, gint column)
 395 {
 396   AtkTableIface *iface;
 397
 398   g_return_val_if_fail (obj != NULL, NULL);
 399   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 400
 401   iface = ATK_TABLE_GET_IFACE (obj);
 402
 403   if (iface->get_column_header)
 404     return (iface->get_column_header) (obj, 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 *obj)
 424 {
 425   AtkTableIface *iface;
 426
 427   g_return_val_if_fail (obj != NULL, 0);
 428   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 429
 430   iface = ATK_TABLE_GET_IFACE (obj);
 431
 432   if (iface->get_n_rows)
 433     return (iface->get_n_rows) (obj);
 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 *obj,
 454                                gint      row)
 455 {
 456   AtkTableIface *iface;
 457
 458   g_return_val_if_fail (obj != NULL, NULL);
 459   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 460
 461   iface = ATK_TABLE_GET_IFACE (obj);
 462
 463   if (iface->get_row_description)
 464     return (iface->get_row_description) (obj, 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 *obj,
 487                              gint     row,
 488                              gint     column)
 489 {
 490   AtkTableIface *iface;
 491
 492   g_return_val_if_fail (obj != NULL, 0);
 493   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 494
 495   iface = ATK_TABLE_GET_IFACE (obj);
 496
 497   if (iface->get_row_extent_at)
 498     return (iface->get_row_extent_at) (obj, 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 *obj, gint row)
 519 {
 520   AtkTableIface *iface;
 521
 522   g_return_val_if_fail (obj != NULL, NULL);
 523   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 524
 525   iface = ATK_TABLE_GET_IFACE (obj);
 526
 527   if (iface->get_row_header)
 528     return (iface->get_row_header) (obj, 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 sumary description of the table,
 544  * or %NULL if value does not implement this interface.
 545  **/
 546 AtkObject*
 547 atk_table_get_summary (AtkTable *obj)
 548 {
 549   AtkTableIface *iface;
 550
 551   g_return_val_if_fail (obj != NULL, NULL);
 552   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 553
 554   iface = ATK_TABLE_GET_IFACE (obj);
 555
 556   if (iface->get_summary)
 557     return (iface->get_summary) (obj);
 558   else
 559     return NULL;
 560 }
 561
 562 /**
 563  * atk_table_get_selected_rows:
 564  * @table: a GObject instance that implements AtkTableIface
 565  *
 566  * Gets the selected rows of the table.
 567  * Note: callers should not rely on %NULL or on a zero value for
 568  * indication of whether AtkSelectionIface is implemented, they should
 569  * use type checking/interface checking macros or the
 570  * atk_get_accessible_table() convenience method.
 571  *
 572  * Returns: a gint* representing the selected rows,
 573  * or %NULL if value does not implement this interface.
 574  **/
 575 gint*
 576 atk_table_get_selected_rows (AtkTable *obj)
 577 {
 578   AtkTableIface *iface;
 579
 580   g_return_val_if_fail (obj != NULL, NULL);
 581   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 582
 583   iface = ATK_TABLE_GET_IFACE (obj);
 584
 585   if (iface->get_selected_rows)
 586     return (iface->get_selected_rows) (obj);
 587   else
 588     return NULL;
 589 }
 590
 591 /**
 592  * atk_table_get_selected_columns:
 593  * @table: a GObject instance that implements AtkTableIface
 594  *
 595  * Gets the selected columns of the table.
 596  * Note: callers should not rely on %NULL or on a zero value for
 597  * indication of whether AtkSelectionIface is implemented, they should
 598  * use type checking/interface checking macros or the
 599  * atk_get_accessible_table() convenience method.
 600  *
 601  * Returns: a gint* representing the selected columns,
 602  * or %NULL if value does not implement this interface.
 603  *
 604  **/
 605 gint*
 606 atk_table_get_selected_columns (AtkTable *obj)
 607 {
 608   AtkTableIface *iface;
 609
 610   g_return_val_if_fail (obj != NULL, NULL);
 611   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 612
 613   iface = ATK_TABLE_GET_IFACE (obj);
 614
 615   if (iface->get_selected_columns)
 616     return (iface->get_selected_columns) (obj);
 617   else
 618     return NULL;
 619 }
 620
 621 /**
 622  * atk_table_is_column_selected:
 623  * @table: a GObject instance that implements AtkTableIface
 624  * @column: a #gint representing a column in @table
 625  *
 626  * Gets a boolean value indicating whether the specified @column
 627  * is selected
 628  * Note: callers should not rely on %NULL or on a zero value for
 629  * indication of whether AtkSelectionIface is implemented, they should
 630  * use type checking/interface checking macros or the
 631  * atk_get_accessible_table() convenience method.
 632  *
 633  * Returns: a gboolean representing if the column is selected, or 0
 634  * if value does not implement this interface.
 635  **/
 636 gboolean
 637 atk_table_is_column_selected (AtkTable *obj,
 638                               gint     column)
 639 {
 640   AtkTableIface *iface;
 641
 642   g_return_val_if_fail (obj != NULL, FALSE);
 643   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 644
 645   iface = ATK_TABLE_GET_IFACE (obj);
 646
 647   if (iface->is_column_selected)
 648     return (iface->is_column_selected) (obj, column);
 649   else
 650     return FALSE;
 651 }
 652
 653 /**
 654  * atk_table_is_row_selected:
 655  * @table: a GObject instance that implements AtkTableIface
 656  * @row: a #gint representing a row in @table
 657  *
 658  * Gets a boolean value indicating whether the specified @row
 659  * is selected
 660  * Note: callers should not rely on %NULL or on a zero value for
 661  * indication of whether AtkSelectionIface is implemented, they should
 662  * use type checking/interface checking macros or the
 663  * atk_get_accessible_table() convenience method.
 664  *
 665  * Returns: a gboolean representing if the row is selected, or 0
 666  * if value does not implement this interface.
 667  **/
 668 gboolean
 669 atk_table_is_row_selected (AtkTable *obj,
 670                            gint     row)
 671 {
 672   AtkTableIface *iface;
 673
 674   g_return_val_if_fail (obj != NULL, FALSE);
 675   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 676
 677   iface = ATK_TABLE_GET_IFACE (obj);
 678
 679   if (iface->is_row_selected)
 680     return (iface->is_row_selected) (obj, row);
 681   else
 682     return FALSE;
 683 }
 684
 685 /**
 686  * atk_table_is_selected:
 687  * @table: a GObject instance that implements AtkTableIface
 688  * @row: a #gint representing a row in @table
 689  * @column: a #gint representing a column in @table
 690  *
 691  * Gets a boolean value indicating whether the acessible object
 692  * at the specified @row and @column is selected
 693  * Note: callers should not rely on %NULL or on a zero value for
 694  * indication of whether AtkSelectionIface is implemented, they should
 695  * use type checking/interface checking macros or the
 696  * atk_get_accessible_table() convenience method.
 697  *
 698  * Returns: a gboolean representing if the cell is selected, or 0
 699  * if value does not implement this interface.
 700  **/
 701 gboolean
 702 atk_table_is_selected (AtkTable *obj,
 703                        gint     row,
 704                        gint     column)
 705 {
 706   AtkTableIface *iface;
 707
 708   g_return_val_if_fail (obj != NULL, FALSE);
 709   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 710
 711   iface = ATK_TABLE_GET_IFACE (obj);
 712
 713   if (iface->is_selected)
 714     return (iface->is_selected) (obj, row, column);
 715   else
 716     return FALSE;
 717 }
 718
 719 /**
 720  * atk_table_set_caption:
 721  * @table: a GObject instance that implements AtkTableIface
 722  * @caption: a #gchar representing the caption to set for @table
 723  *
 724  * Sets the caption for the table.
 725  **/
 726 void
 727 atk_table_set_caption (AtkTable       *obj,
 728                        gchar          *caption)
 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_caption)
 738     (iface->set_caption) (obj, caption);
 739 }
 740
 741 /**
 742  * atk_table_set_column_description:
 743  * @table: a GObject instance that implements AtkTableIface
 744  * @column: a #gint representing a column in @table
 745  * @description: a #gchar representing the description text
 746  * to set for the specified @column of the @table
 747  *
 748  * Sets the description text for the specified @column of the @table.
 749  **/
 750 void
 751 atk_table_set_column_description (AtkTable       *obj,
 752                                   gint           column,
 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_column_description)
 763     (iface->set_column_description) (obj, column, description);
 764 }
 765
 766 /**
 767  * atk_table_set_column_header:
 768  * @table: a GObject instance that implements AtkTableIface
 769  * @column: a #gint representing a column in @table
 770  * @header: an #AtkTable
 771  *
 772  * Sets the specified column header to @header
 773  **/
 774 void
 775 atk_table_set_column_header (AtkTable  *obj,
 776                              gint      column,
 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_column_header)
 787     (iface->set_column_header) (obj, column, header);
 788 }
 789
 790 /**
 791  * atk_table_set_row_description:
 792  * @table: a GObject instance that implements AtkTableIface
 793  * @row: a #gint representing a row in @table
 794  * @description: a #gchar representing the description text
 795  * to set for the specified @row of @table
 796  *
 797  * Sets the description text for the specified @row of @table.
 798  **/
 799 void
 800 atk_table_set_row_description (AtkTable       *obj,
 801                                gint           row,
 802                                gchar          *description)
 803 {
 804   AtkTableIface *iface;
 805
 806   g_return_if_fail (obj != NULL);
 807   g_return_if_fail (ATK_IS_TABLE (obj));
 808
 809   iface = ATK_TABLE_GET_IFACE (obj);
 810
 811   if (iface->set_row_description)
 812     (iface->set_row_description) (obj, row, description);
 813 }
 814
 815 /**
 816  * atk_table_set_row_header:
 817  * @table: a GObject instance that implements AtkTableIface
 818  * @row: a #gint representing a row in @table
 819  * @header: an #AtkTable
 820  *
 821  * Sets the specified row header to @header
 822  **/
 823 void
 824 atk_table_set_row_header (AtkTable  *obj,
 825                           gint      row,
 826                           AtkObject *header)
 827 {
 828   AtkTableIface *iface;
 829
 830   g_return_if_fail (obj != NULL);
 831   g_return_if_fail (ATK_IS_TABLE (obj));
 832
 833   iface = ATK_TABLE_GET_IFACE (obj);
 834
 835   if (iface->set_row_header)
 836     (iface->set_row_header) (obj, row, header);
 837 }
 838
 839 /**
 840  * atk_table_set_summary:
 841  * @table: a GObject instance that implements AtkTableIface
 842  * @accessible: an #AtkObject representing the summary description
 843  * to set for @table
 844  *
 845  * Sets the summary description of the table
 846  **/
 847 void
 848 atk_table_set_summary (AtkTable       *obj,
 849                        AtkObject      *accessible)
 850 {
 851   AtkTableIface *iface;
 852
 853   g_return_if_fail (obj != NULL);
 854   g_return_if_fail (ATK_IS_TABLE (obj));
 855
 856   iface = ATK_TABLE_GET_IFACE (obj);
 857
 858   if (iface->set_summary)
 859     (iface->set_summary) (obj, accessible);
 860 }