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
  22 GType
  23 atk_table_get_type ()
  24 {
  25   static GType type = 0;
  26
  27   if (!type) {
  28     GTypeInfo tinfo =
  29     {
  30       sizeof (AtkTableIface),
  31       NULL,
  32       NULL,
  33
  34     };
  35
  36     type = g_type_register_static (G_TYPE_INTERFACE, "AtkTable", &tinfo, 0);
  37   }
  38
  39   return type;
  40 }
  41
  42 /**
  43  * atk_table_ref_at:
  44  * @obj: a GObject instance that implements AtkTableIface
  45  * return values: a AtkObject* representing the referred to accessible
  46  *
  47  * Get a reference to the table cell at #row, #column
  48  *
  49  **/
  50 AtkObject*
  51 atk_table_ref_at (AtkTable *obj,
  52                   gint     row,
  53                   gint     column)
  54 {
  55   AtkTableIface *iface;
  56
  57   g_return_val_if_fail (obj != NULL, NULL);
  58   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
  59
  60   iface = ATK_TABLE_GET_IFACE (obj);
  61
  62   if (iface->ref_at)
  63     return (iface->ref_at) (obj, row, column);
  64   else
  65     return NULL;
  66 }
  67
  68 /**
  69  * atk_table_get_index_at:
  70  * @value: a GObject instance that implements AtkTableIface
  71  * @return: a gint representing the index at specified position, or 0
  72  * if value does not implement this interface.
  73  *
  74  * WARNING: callers should not rely on %NULL or on a zero value for
  75  * indication of whether AtkSelectionIface is implemented, they should
  76  * use type checking/interface checking macros or the
  77  * atk_get_accessible_table() convenience method.
  78  **/
  79 gint
  80 atk_table_get_index_at (AtkTable *obj,
  81                         gint     row,
  82                         gint     column)
  83 {
  84   AtkTableIface *iface;
  85
  86   g_return_val_if_fail (obj != NULL, 0);
  87   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
  88
  89   iface = ATK_TABLE_GET_IFACE (obj);
  90
  91   if (iface->get_index_at)
  92     return (iface->get_index_at) (obj, row, column);
  93   else
  94     return 0;
  95 }
  96
  97 /**
  98  * atk_table_get_row_at_index:
  99  * @value: a GObject instance that implements AtkTableInterface
 100  * @return: a gint representing the row at the specified  index, or 0
 101  * if value does not implement this interface.
 102  *
 103  * WARNING: callers should not rely on %NULL or on a zero value for
 104  * indication of whether AtkSelectionIface is implemented, they should
 105  * use type checking/interface checking macros or the
 106  * atk_get_accessible_table() convenience method.
 107  **/
 108 gint
 109 atk_table_get_row_at_index (AtkTable *obj,
 110                             gint     index)
 111 {
 112   AtkTableIface *iface;
 113
 114   g_return_val_if_fail (obj != NULL, 0);
 115   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 116
 117   iface = ATK_TABLE_GET_IFACE (obj);
 118
 119   if (iface->get_row_at_index)
 120     return (iface->get_row_at_index) (obj, index);
 121   else
 122     return 0;
 123 }
 124
 125 /**
 126  * atk_table_get_column_at_index:
 127  * @value: a GObject instance that implements AtkTableInterface
 128  * @return: a gint representing the column at the specified  index, or 0
 129  * if value does not implement this interface.
 130  *
 131  * WARNING: callers should not rely on %NULL or on a zero value for
 132  * indication of whether AtkSelectionIface is implemented, they should
 133  * use type checking/interface checking macros or the
 134  * atk_get_accessible_table() convenience method.
 135  **/
 136 gint
 137 atk_table_get_column_at_index (AtkTable *obj,
 138                                gint     index)
 139 {
 140   AtkTableIface *iface;
 141
 142   g_return_val_if_fail (obj != NULL, 0);
 143   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 144
 145   iface = ATK_TABLE_GET_IFACE (obj);
 146
 147   if (iface->get_column_at_index)
 148     return (iface->get_column_at_index) (obj, index);
 149   else
 150     return 0;
 151 }
 152
 153 /**
 154  * atk_table_get_caption:
 155  * @value: a GObject instance that implements AtkTableInterface
 156  * @return: a AtkObject* representing the table caption, or NULL
 157  * if value does not implement this interface.
 158  *
 159  * WARNING: callers should not rely on %NULL or on a zero value for
 160  * indication of whether AtkSelectionIface is implemented, they should
 161  * use type checking/interface checking macros or the
 162  * atk_get_accessible_table() convenience method.
 163  **/
 164 AtkObject*
 165 atk_table_get_caption (AtkTable *obj)
 166 {
 167   AtkTableIface *iface;
 168
 169   g_return_val_if_fail (obj != NULL, NULL);
 170   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 171
 172   iface = ATK_TABLE_GET_IFACE (obj);
 173
 174   if (iface->get_caption)
 175     return (iface->get_caption) (obj);
 176   else
 177     return NULL;
 178 }
 179
 180 /**
 181  * atk_table_get_n_columns:
 182  * @value: a GObject instance that implements AtkTableIface
 183  * @return: a gint representing the number of columns, or 0
 184  * if value does not implement this interface.
 185  *
 186  * WARNING: callers should not rely on %NULL or on a zero value for
 187  * indication of whether AtkSelectionIface is implemented, they should
 188  * use type checking/interface checking macros or the
 189  * atk_get_accessible_table() convenience method.
 190  **/
 191 gint
 192 atk_table_get_n_columns (AtkTable *obj)
 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_n_columns)
 202     return (iface->get_n_columns) (obj);
 203   else
 204     return 0;
 205 }
 206
 207 /**
 208  * atk_table_get_column_description:
 209  * @value: a GObject instance that implements AtkTableIface
 210  * @return: a AtkObject* representing the table description, or NULL
 211  * if value does not implement this interface.
 212  *
 213  * WARNING: callers should not rely on %NULL or on a zero value for
 214  * indication of whether AtkSelectionIface is implemented, they should
 215  * use type checking/interface checking macros or the
 216  * atk_get_accessible_table() convenience method.
 217  **/
 218 AtkObject*
 219 atk_table_get_column_description (AtkTable *obj,
 220                                   gint     column)
 221 {
 222   AtkTableIface *iface;
 223
 224   g_return_val_if_fail (obj != NULL, NULL);
 225   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 226
 227   iface = ATK_TABLE_GET_IFACE (obj);
 228
 229   if (iface->get_column_description)
 230     return (iface->get_column_description) (obj, column);
 231   else
 232     return NULL;
 233 }
 234
 235 /**
 236  * atk_table_get_column_extent_at:
 237  * @value: a GObject instance that implements AtkTableIface
 238  * @return: a gint representing the column extent at specified position, or 0
 239  * if value does not implement this interface.
 240  *
 241  * WARNING: 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 gint
 247 atk_table_get_column_extent_at (AtkTable *obj,
 248                                 gint     row,
 249                                 gint     column)
 250 {
 251   AtkTableIface *iface;
 252
 253   g_return_val_if_fail (obj != NULL, 0);
 254   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 255
 256   iface = ATK_TABLE_GET_IFACE (obj);
 257
 258   if (iface->get_column_extent_at)
 259     return (iface->get_column_extent_at) (obj, row, column);
 260   else
 261     return 0;
 262 }
 263
 264 /**
 265  * atk_table_get_column_header:
 266  * @value: a GObject instance that implements AtkTableIface
 267  * @return: a AtkObject* representing the column headers, or NULL
 268  * if value does not implement this interface.
 269  *
 270  * WARNING: callers should not rely on %NULL or on a zero value for
 271  * indication of whether AtkSelectionIface is implemented, they should
 272  * use type checking/interface checking macros or the
 273  * atk_get_accessible_table() convenience method.
 274  **/
 275 AtkTable*
 276 atk_table_get_column_header (AtkTable *obj)
 277 {
 278   AtkTableIface *iface;
 279
 280   g_return_val_if_fail (obj != NULL, NULL);
 281   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 282
 283   iface = ATK_TABLE_GET_IFACE (obj);
 284
 285   if (iface->get_column_header)
 286     return (iface->get_column_header) (obj);
 287   else
 288     return NULL;
 289 }
 290
 291 /**
 292  * atk_table_get_n_rows:
 293  * @value: a GObject instance that implements AtkTableIface
 294  * @return: a gint representing the number of rows, or 0
 295  * if value does not implement this interface.
 296  *
 297  * WARNING: callers should not rely on %NULL or on a zero value for
 298  * indication of whether AtkSelectionIface is implemented, they should
 299  * use type checking/interface checking macros or the
 300  * atk_get_accessible_table() convenience method.
 301  **/
 302 gint
 303 atk_table_get_n_rows (AtkTable *obj)
 304 {
 305   AtkTableIface *iface;
 306
 307   g_return_val_if_fail (obj != NULL, 0);
 308   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 309
 310   iface = ATK_TABLE_GET_IFACE (obj);
 311
 312   if (iface->get_n_rows)
 313     return (iface->get_n_rows) (obj);
 314   else
 315     return 0;
 316 }
 317
 318 /**
 319  * atk_table_get_row_description:
 320  * @value: a GObject instance that implements AtkTableIface
 321  * @return: a AtkObject* representing the table description, or NULL
 322  * if value does not implement this interface.
 323  *
 324  * WARNING: callers should not rely on %NULL or on a zero value for
 325  * indication of whether AtkSelectionIface is implemented, they should
 326  * use type checking/interface checking macros or the
 327  * atk_get_accessible_table() convenience method.
 328  **/
 329 AtkObject*
 330 atk_table_get_row_description (AtkTable *obj,
 331                                gint      row)
 332 {
 333   AtkTableIface *iface;
 334
 335   g_return_val_if_fail (obj != NULL, NULL);
 336   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 337
 338   iface = ATK_TABLE_GET_IFACE (obj);
 339
 340   if (iface->get_row_description)
 341     return (iface->get_row_description) (obj, row);
 342   else
 343     return NULL;
 344 }
 345
 346 /**
 347  * atk_table_get_row_extent_at:
 348  * @value: a GObject instance that implements AtkTableIface
 349  * @return: a gint representing the row extent at specified position, or 0
 350  * if value does not implement this interface.
 351  *
 352  * WARNING: callers should not rely on %NULL or on a zero value for
 353  * indication of whether AtkSelectionIface is implemented, they should
 354  * use type checking/interface checking macros or the
 355  * atk_get_accessible_table() convenience method.
 356  **/
 357 gint
 358 atk_table_get_row_extent_at (AtkTable *obj,
 359                              gint     row,
 360                              gint     column)
 361 {
 362   AtkTableIface *iface;
 363
 364   g_return_val_if_fail (obj != NULL, 0);
 365   g_return_val_if_fail (ATK_IS_TABLE (obj), 0);
 366
 367   iface = ATK_TABLE_GET_IFACE (obj);
 368
 369   if (iface->get_row_extent_at)
 370     return (iface->get_row_extent_at) (obj, row, column);
 371   else
 372     return 0;
 373 }
 374
 375 /**
 376  * atk_table_get_row_header:
 377  * @value: a GObject instance that implements AtkTableIface
 378  * @return: a AtkTable* representing the row headers, or NULL
 379  * if value does not implement this interface.
 380  *
 381  * WARNING: callers should not rely on %NULL or on a zero value for
 382  * indication of whether AtkSelectionIface is implemented, they should
 383  * use type checking/interface checking macros or the
 384  * atk_get_accessible_table() convenience method.
 385  **/
 386 AtkTable*
 387 atk_table_get_row_header (AtkTable *obj)
 388 {
 389   AtkTableIface *iface;
 390
 391   g_return_val_if_fail (obj != NULL, NULL);
 392   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 393
 394   iface = ATK_TABLE_GET_IFACE (obj);
 395
 396   if (iface->get_row_header)
 397     return (iface->get_row_header) (obj);
 398   else
 399     return NULL;
 400 }
 401
 402 /**
 403  * atk_table_get_summary:
 404  * @value: a GObject instance that implements AtkTableIface
 405  * @return: a AtkObject* representing a sumary description of the table,
 406  * or NULL if value does not implement this interface.
 407  *
 408  * WARNING: callers should not rely on %NULL or on a zero value for
 409  * indication of whether AtkSelectionIface is implemented, they should
 410  * use type checking/interface checking macros or the
 411  * atk_get_accessible_table() convenience method.
 412  **/
 413 AtkObject*
 414 atk_table_get_summary (AtkTable *obj)
 415 {
 416   AtkTableIface *iface;
 417
 418   g_return_val_if_fail (obj != NULL, NULL);
 419   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 420
 421   iface = ATK_TABLE_GET_IFACE (obj);
 422
 423   if (iface->get_summary)
 424     return (iface->get_summary) (obj);
 425   else
 426     return NULL;
 427 }
 428
 429 /**
 430  * atk_table_get_selected_rows:
 431  * @value: a GObject instance that implements AtkTableIface
 432  * @return: a gint* representing the selected rows,
 433  * or NULL if value does not implement this interface.
 434  *
 435  * WARNING: callers should not rely on %NULL or on a zero value for
 436  * indication of whether AtkSelectionIface is implemented, they should
 437  * use type checking/interface checking macros or the
 438  * atk_get_accessible_table() convenience method.
 439  **/
 440 gint*
 441 atk_table_get_selected_rows (AtkTable *obj)
 442 {
 443   AtkTableIface *iface;
 444
 445   g_return_val_if_fail (obj != NULL, NULL);
 446   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 447
 448   iface = ATK_TABLE_GET_IFACE (obj);
 449
 450   if (iface->get_selected_rows)
 451     return (iface->get_selected_rows) (obj);
 452   else
 453     return NULL;
 454 }
 455
 456 /**
 457  * atk_table_get_selected_columns:
 458  * @value: a GObject instance that implements AtkTableIface
 459  * @return: a gint* representing the selected columns,
 460  * or NULL if value does not implement this interface.
 461  *
 462  * WARNING: callers should not rely on %NULL or on a zero value for
 463  * indication of whether AtkSelectionIface is implemented, they should
 464  * use type checking/interface checking macros or the
 465  * atk_get_accessible_table() convenience method.
 466  **/
 467 gint*
 468 atk_table_get_selected_columns (AtkTable *obj)
 469 {
 470   AtkTableIface *iface;
 471
 472   g_return_val_if_fail (obj != NULL, NULL);
 473   g_return_val_if_fail (ATK_IS_TABLE (obj), NULL);
 474
 475   iface = ATK_TABLE_GET_IFACE (obj);
 476
 477   if (iface->get_selected_columns)
 478     return (iface->get_selected_columns) (obj);
 479   else
 480     return NULL;
 481 }
 482
 483 /**
 484  * atk_table_is_column_selected:
 485  * @value: a GObject instance that implements AtkTableIface
 486  * @return: a gboolean representing the column is selected, or 0
 487  * if value does not implement this interface.
 488  *
 489  * WARNING: 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 gboolean
 495 atk_table_is_column_selected (AtkTable *obj,
 496                               gint     column)
 497 {
 498   AtkTableIface *iface;
 499
 500   g_return_val_if_fail (obj != NULL, FALSE);
 501   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 502
 503   iface = ATK_TABLE_GET_IFACE (obj);
 504
 505   if (iface->is_column_selected)
 506     return (iface->is_column_selected) (obj, column);
 507   else
 508     return FALSE;
 509 }
 510
 511 /**
 512  * atk_table_is_row_selected:
 513  * @value: a GObject instance that implements AtkTableIface
 514  * @return: a gboolean representing the row is selected, or 0
 515  * if value does not implement this interface.
 516  *
 517  * WARNING: callers should not rely on %NULL or on a zero value for
 518  * indication of whether AtkSelectionIface is implemented, they should
 519  * use type checking/interface checking macros or the
 520  * atk_get_accessible_table() convenience method.
 521  **/
 522 gboolean
 523 atk_table_is_row_selected (AtkTable *obj,
 524                            gint     row)
 525 {
 526   AtkTableIface *iface;
 527
 528   g_return_val_if_fail (obj != NULL, FALSE);
 529   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 530
 531   iface = ATK_TABLE_GET_IFACE (obj);
 532
 533   if (iface->is_row_selected)
 534     return (iface->is_row_selected) (obj, row);
 535   else
 536     return FALSE;
 537 }
 538
 539 /**
 540  * atk_table_is_selected:
 541  * @value: a GObject instance that implements AtkTableIface
 542  * @return: a gboolean representing the cell is selected, or 0
 543  * if value does not implement this interface.
 544  *
 545  * WARNING: callers should not rely on %NULL or on a zero value for
 546  * indication of whether AtkSelectionIface is implemented, they should
 547  * use type checking/interface checking macros or the
 548  * atk_get_accessible_table() convenience method.
 549  **/
 550 gboolean
 551 atk_table_is_selected (AtkTable *obj,
 552                        gint     row,
 553                        gint     column)
 554 {
 555   AtkTableIface *iface;
 556
 557   g_return_val_if_fail (obj != NULL, FALSE);
 558   g_return_val_if_fail (ATK_IS_TABLE (obj), FALSE);
 559
 560   iface = ATK_TABLE_GET_IFACE (obj);
 561
 562   if (iface->is_selected)
 563     return (iface->is_selected) (obj, row, column);
 564   else
 565     return FALSE;
 566 }
 567
 568 /**
 569  * atk_table_set_caption:
 570  * @value: a GObject instance that implements AtkTableIface
 571  * @return: void
 572  **/
 573 void
 574 atk_table_set_caption (AtkTable       *obj,
 575                        AtkObject      *accessible)
 576 {
 577   AtkTableIface *iface;
 578
 579   g_return_if_fail (obj != NULL);
 580   g_return_if_fail (ATK_IS_TABLE (obj));
 581
 582   iface = ATK_TABLE_GET_IFACE (obj);
 583
 584   if (iface->set_caption)
 585     (iface->set_caption) (obj, accessible);
 586 }
 587
 588 /**
 589  * atk_table_set_column_description:
 590  * @value: a GObject instance that implements AtkTableIface
 591  * @return: void
 592  **/
 593 void
 594 atk_table_set_column_description (AtkTable       *obj,
 595                                   gint           column,
 596                                   AtkObject      *accessible)
 597 {
 598   AtkTableIface *iface;
 599
 600   g_return_if_fail (obj != NULL);
 601   g_return_if_fail (ATK_IS_TABLE (obj));
 602
 603   iface = ATK_TABLE_GET_IFACE (obj);
 604
 605   if (iface->set_column_description)
 606     (iface->set_column_description) (obj, column, accessible);
 607 }
 608
 609 /**
 610  * atk_table_set_column_header:
 611  * @value: a GObject instance that implements AtkTableIface
 612  * @return: void
 613  **/
 614 void
 615 atk_table_set_column_header (AtkTable *obj,
 616                              gint     column,
 617                              AtkTable *header)
 618 {
 619   AtkTableIface *iface;
 620
 621   g_return_if_fail (obj != NULL);
 622   g_return_if_fail (ATK_IS_TABLE (obj));
 623
 624   iface = ATK_TABLE_GET_IFACE (obj);
 625
 626   if (iface->set_column_header)
 627     (iface->set_column_header) (obj, column, header);
 628 }
 629
 630 /**
 631  * atk_table_set_row_description:
 632  * @value: a GObject instance that implements AtkTableIface
 633  * @return: void
 634  **/
 635 void
 636 atk_table_set_row_description (AtkTable       *obj,
 637                                gint           row,
 638                                AtkObject      *accessible)
 639 {
 640   AtkTableIface *iface;
 641
 642   g_return_if_fail (obj != NULL);
 643   g_return_if_fail (ATK_IS_TABLE (obj));
 644
 645   iface = ATK_TABLE_GET_IFACE (obj);
 646
 647   if (iface->set_row_description)
 648     (iface->set_row_description) (obj, row, accessible);
 649 }
 650
 651 /**
 652  * atk_table_set_row_header:
 653  * @value: a GObject instance that implements AtkTableIface
 654  * @return: void
 655  **/
 656 void
 657 atk_table_set_row_header (AtkTable *obj,
 658                           gint     row,
 659                           AtkTable *header)
 660 {
 661   AtkTableIface *iface;
 662
 663   g_return_if_fail (obj != NULL);
 664   g_return_if_fail (ATK_IS_TABLE (obj));
 665
 666   iface = ATK_TABLE_GET_IFACE (obj);
 667
 668   if (iface->set_row_header)
 669     (iface->set_row_header) (obj, row, header);
 670 }
 671
 672 /**
 673  * atk_table_set_summary:
 674  * @value: a GObject instance that implements AtkTableIface
 675  * @return: void
 676  **/
 677 void
 678 atk_table_set_summary (AtkTable       *obj,
 679                        AtkObject      *accessible)
 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_summary)
 689     (iface->set_summary) (obj, accessible);
 690 }