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