cspi/spi.h

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #ifndef _SPI_H
  25 #define _SPI_H
  26
  27 #include <cspi/spi-impl.h>
  28 /*
  29  * Definitions for AccessibleRole, AccessibleState,
  30  * AccessibleEvent, and event listeners.
  31  */
  32 #include <cspi/spi-roletypes.h>
  33 #include <cspi/spi-statetypes.h>
  34 #include <cspi/spi-listener.h>
  35
  36 /*
  37  * Auxiliary typedefs and mask definitions
  38  */
  39 #include <libspi/keymasks.h>
  40
  41 #ifdef  __cplusplus
  42 extern "C" {
  43 #endif
  44
  45 /*
  46  * Enumerated type for text boundary types
  47  */
  48 typedef enum
  49 {
  50   SPI_TEXT_BOUNDARY_CHAR,
  51   SPI_TEXT_BOUNDARY_CURSOR_POS,
  52   SPI_TEXT_BOUNDARY_WORD_START,
  53   SPI_TEXT_BOUNDARY_WORD_END,
  54   SPI_TEXT_BOUNDARY_SENTENCE_START,
  55   SPI_TEXT_BOUNDARY_SENTENCE_END,
  56   SPI_TEXT_BOUNDARY_LINE_START,
  57   SPI_TEXT_BOUNDARY_LINE_END,
  58   SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE
  59 } AccessibleTextBoundaryType;
  60
  61 /*
  62  *
  63  * Enumerated type for relation types
  64  *
  65  */
  66
  67 typedef enum
  68 {
  69   SPI_RELATION_NULL,
  70   SPI_RELATION_LABEL_FOR,
  71   SPI_RELATION_LABELED_BY,
  72   SPI_RELATION_CONTROLLER_FOR,
  73   SPI_RELATION_CONTROLLED_BY,
  74   SPI_RELATION_MEMBER_OF,
  75   SPI_RELATION_NODE_CHILD_OF,
  76   SPI_RELATION_EXTENDED,
  77   SPI_RELATION_LAST_DEFINED
  78 } AccessibleRelationType;
  79
  80
  81 /* don't change the order of these ! */
  82 typedef enum {
  83   SPI_COORD_TYPE_SCREEN,
  84   SPI_COORD_TYPE_WINDOW
  85 } AccessibleCoordType;
  86
  87 typedef enum {
  88   SPI_KEY_PRESS,
  89   SPI_KEY_RELEASE,
  90   SPI_KEY_PRESSRELEASE,
  91   SPI_KEY_SYM,
  92   SPI_KEY_STRING
  93 } AccessibleKeySynthType;
  94
  95 typedef enum {
  96   SPI_KEYLISTENER_NOSYNC = 0,
  97   SPI_KEYLISTENER_SYNCHRONOUS = 1,
  98   SPI_KEYLISTENER_CANCONSUME = 2,
  99   SPI_KEYLISTENER_ALL_WINDOWS = 4
 100 } AccessibleKeyListenerSyncType;
 101
 102 typedef unsigned long AccessibleKeyEventMask;
 103
 104 /**
 105  * AccessibleComponentLayer:
 106  * @SPI_LAYER_INVALID: The layer cannot be determined or is somehow undefined.
 107  * @SPI_LAYER_BACKGROUND: Component belongs to the destop background.
 108  * @SPI_LAYER_CANVAS: Component is a canvas backdrop or drawing area.
 109  * @SPI_LAYER_WIDGET: Component is a 'normal' widget.
 110  * @SPI_LAYER_MDI: Component is drawn in the MDI layer and may have valid
 111  *                          Z-information relative to other MDI-layer components.
 112  * @SPI_LAYER_POPUP: Component is in the popup layer, above other widgets and
 113  *                          MDI components.
 114  * @SPI_LAYER_OVERLAY: Component is in the overlay plane - this value is reserved
 115  *                          for future use.
 116  * @SPI_LAYER_WINDOW: Component is in the window layer and have valid Z-information
 117  *                    relative to other window-layer components.
 118  * @SPI_LAYER_LAST_DEFINED: Used to determine the last valid value in the enum,
 119  *                          should not be encountered.
 120  **/
 121 typedef enum {
 122     SPI_LAYER_INVALID,
 123     SPI_LAYER_BACKGROUND,
 124     SPI_LAYER_CANVAS,
 125     SPI_LAYER_WIDGET,
 126     SPI_LAYER_MDI,
 127     SPI_LAYER_POPUP,
 128     SPI_LAYER_OVERLAY,
 129     SPI_LAYER_WINDOW,
 130     SPI_LAYER_LAST_DEFINED
 131 } AccessibleComponentLayer;
 132
 133
 134 /**
 135  * AccessibleKeySet:
 136  * @keysyms:
 137  * @keycodes:
 138  * @len:
 139  *
 140  * Structure containing identifying information about a set of keycode or
 141  *        keysyms.
 142  **/
 143 typedef struct _AccessibleKeySet
 144 {
 145   unsigned long  *keysyms;
 146   unsigned short *keycodes;
 147   char          **keystrings;
 148   short           len;
 149 } AccessibleKeySet;
 150
 151 /**
 152  * SPI_KEYSET_ALL_KEYS:
 153  * @SPI_KEYSET_ALL_KEYS: A special value for an AccessibleKeySet type, which tacitly
 154  *                       includes all keycodes and keyvals for the specified modifier set.
 155  **/
 156 #define SPI_KEYSET_ALL_KEYS NULL
 157
 158 typedef unsigned long AccessibleKeyMaskType;
 159
 160
 161 /* Basic SPI initialization and event loop function prototypes */
 162
 163 int              SPI_init         (void);
 164 void             SPI_event_main   (void);
 165 void             SPI_event_quit   (void);
 166 SPIBoolean       SPI_eventIsReady (void);
 167 AccessibleEvent *SPI_nextEvent    (SPIBoolean waitForEvent);
 168 int              SPI_exit         (void);
 169
 170 /* Event Listener creation and support.  */
 171
 172 void                      SPI_freeAccessibleKeySet (
 173                                                    AccessibleKeySet         *keyset);
 174 AccessibleKeySet        * SPI_createAccessibleKeySet (
 175                                                    int                       len,
 176                                                    const char               *keysyms,
 177                                                    short                    *keycodes,
 178                                                    const char              **keystrings);
 179 AccessibleEventListener * SPI_createAccessibleEventListener (
 180                                                    AccessibleEventListenerCB callback,
 181                                                    void                     *user_data);
 182 SPIBoolean                AccessibleEventListener_addCallback (
 183                                                    AccessibleEventListener  *listener,
 184                                                    AccessibleEventListenerCB callback,
 185                                                    void                     *user_data);
 186 SPIBoolean                AccessibleEventListener_removeCallback (
 187                                                    AccessibleEventListener  *listener,
 188                                                    AccessibleEventListenerCB callback);
 189 void                      AccessibleEventListener_unref (
 190                                                    AccessibleEventListener  *listener);
 191
 192 /* Keystroke Listener creation and support.  */
 193
 194 AccessibleKeystrokeListener * SPI_createAccessibleKeystrokeListener (
 195                                         AccessibleKeystrokeListenerCB callback,
 196                                         void                         *user_data);
 197 SPIBoolean                    AccessibleKeystrokeListener_addCallback (
 198                                         AccessibleKeystrokeListener  *listener,
 199                                         AccessibleKeystrokeListenerCB callback,
 200                                         void                         *user_data);
 201 SPIBoolean                    AccessibleKeystrokeListener_removeCallback (
 202                                         AccessibleKeystrokeListener *listener,
 203                                         AccessibleKeystrokeListenerCB callback);
 204 void                          AccessibleKeystrokeListener_unref (
 205                                         AccessibleKeystrokeListener *listener);
 206
 207 /* Global functions serviced by the registry */
 208
 209 SPIBoolean SPI_registerGlobalEventListener           (
 210                                        AccessibleEventListener *listener,
 211                                        const char              *eventType);
 212 SPIBoolean SPI_deregisterGlobalEventListener         (
 213                                        AccessibleEventListener *listener,
 214                                        const char              *eventType);
 215 SPIBoolean SPI_deregisterGlobalEventListenerAll      (
 216                                        AccessibleEventListener *listener);
 217 SPIBoolean SPI_registerAccessibleKeystrokeListener   (
 218                                        AccessibleKeystrokeListener *listener,
 219                                        AccessibleKeySet             *keys,
 220                                        AccessibleKeyMaskType         modmask,
 221                                        AccessibleKeyEventMask        eventmask,
 222                                        AccessibleKeyListenerSyncType sync_type);
 223 SPIBoolean SPI_deregisterAccessibleKeystrokeListener (
 224                                        AccessibleKeystrokeListener *listener,
 225                                        AccessibleKeyMaskType        modmask);
 226
 227 int         SPI_getDesktopCount                  (void);
 228 Accessible *SPI_getDesktop                       (int i);
 229 int         SPI_getDesktopList                   (Accessible ***desktop_list);
 230 void        SPI_freeDesktopList                  (Accessible  **desktop_list);
 231
 232 SPIBoolean  SPI_generateKeyboardEvent            (long int                    keyval,
 233                                                   char                       *keystring,
 234                                                   AccessibleKeySynthType      synth_type);
 235
 236 SPIBoolean  SPI_generateMouseEvent               (long int x, long int y, char *name);
 237
 238 /* Accessible function prototypes  */
 239
 240 void                 Accessible_ref              (Accessible *obj);
 241 void                 Accessible_unref            (Accessible *obj);
 242 char *               Accessible_getName          (Accessible *obj);
 243 char *               Accessible_getDescription   (Accessible *obj);
 244 Accessible *         Accessible_getParent        (Accessible *obj);
 245 long                 Accessible_getChildCount    (Accessible *obj);
 246 Accessible *         Accessible_getChildAtIndex  (Accessible *obj,
 247                                                   long int    childIndex);
 248 long                 Accessible_getIndexInParent (Accessible *obj);
 249 AccessibleRelation **Accessible_getRelationSet   (Accessible *obj);
 250 AccessibleRole       Accessible_getRole          (Accessible *obj);
 251 char *               Accessible_getRoleName      (Accessible *obj);
 252 AccessibleStateSet * Accessible_getStateSet      (Accessible *obj);
 253
 254 /* Interface query methods */
 255
 256 SPIBoolean Accessible_isAction            (Accessible *obj);
 257 SPIBoolean Accessible_isApplication       (Accessible *obj);
 258 SPIBoolean Accessible_isComponent         (Accessible *obj);
 259 SPIBoolean Accessible_isEditableText      (Accessible *obj);
 260 SPIBoolean Accessible_isHypertext         (Accessible *obj);
 261 SPIBoolean Accessible_isImage             (Accessible *obj);
 262 SPIBoolean Accessible_isSelection         (Accessible *obj);
 263 SPIBoolean Accessible_isStreamableContent (Accessible *obj);
 264 SPIBoolean Accessible_isTable             (Accessible *obj);
 265 SPIBoolean Accessible_isText              (Accessible *obj);
 266 SPIBoolean Accessible_isValue             (Accessible *obj);
 267
 268 AccessibleAction *            Accessible_getAction            (Accessible *obj);
 269 AccessibleApplication *       Accessible_getApplication       (Accessible *obj);
 270 AccessibleComponent *         Accessible_getComponent         (Accessible *obj);
 271 AccessibleEditableText *      Accessible_getEditableText      (Accessible *obj);
 272 AccessibleHypertext *         Accessible_getHypertext         (Accessible *obj);
 273 AccessibleImage *             Accessible_getImage             (Accessible *obj);
 274 AccessibleSelection *         Accessible_getSelection         (Accessible *obj);
 275 AccessibleStreamableContent * Accessible_getStreamableContent (Accessible *obj);
 276 AccessibleTable *             Accessible_getTable             (Accessible *obj);
 277 AccessibleText *              Accessible_getText              (Accessible *obj);
 278 AccessibleValue *             Accessible_getValue             (Accessible *obj);
 279 AccessibleUnknown *           Accessible_queryInterface       (Accessible *obj,
 280                                                    const char *interface_name);
 281
 282 /* AccessibleAction function prototypes  */
 283
 284 void       AccessibleAction_ref            (AccessibleAction *obj);
 285 void       AccessibleAction_unref          (AccessibleAction *obj);
 286 long       AccessibleAction_getNActions    (AccessibleAction *obj);
 287 char      *AccessibleAction_getName        (AccessibleAction *obj,
 288                                             long int          i);
 289 char      *AccessibleAction_getDescription (AccessibleAction *obj,
 290                                             long int          i);
 291 SPIBoolean AccessibleAction_doAction       (AccessibleAction *obj,
 292                                             long int          i);
 293 char      *AccessibleAction_getKeyBinding  (AccessibleAction *obj,
 294                                             long int          i);
 295
 296 /* AccessibleApplication function prototypes  */
 297
 298 void       AccessibleApplication_ref            (AccessibleApplication *obj);
 299 void       AccessibleApplication_unref          (AccessibleApplication *obj);
 300 char      *AccessibleApplication_getToolkitName (AccessibleApplication *obj);
 301 char      *AccessibleApplication_getVersion     (AccessibleApplication *obj);
 302 long       AccessibleApplication_getID          (AccessibleApplication *obj);
 303 SPIBoolean AccessibleApplication_pause          (AccessibleApplication *obj);
 304 SPIBoolean AccessibleApplication_resume         (AccessibleApplication *obj);
 305
 306 /* AccessibleComponent function prototypes */
 307
 308 void        AccessibleComponent_ref         (AccessibleComponent *obj);
 309 void        AccessibleComponent_unref       (AccessibleComponent *obj);
 310 SPIBoolean  AccessibleComponent_contains    (AccessibleComponent *obj,
 311                                              long int             x,
 312                                              long int             y,
 313                                              AccessibleCoordType  ctype);
 314 Accessible *AccessibleComponent_getAccessibleAtPoint (
 315                                              AccessibleComponent *obj,
 316                                              long int             x,
 317                                              long int             y,
 318                                              AccessibleCoordType  ctype);
 319 void        AccessibleComponent_getExtents  (AccessibleComponent *obj,
 320                                              long int            *x,
 321                                              long int            *y,
 322                                              long int            *width,
 323                                              long int            *height,
 324                                              AccessibleCoordType  ctype);
 325 void        AccessibleComponent_getPosition (AccessibleComponent *obj,
 326                                              long int            *x,
 327                                              long int            *y,
 328                                              AccessibleCoordType  ctype);
 329 void        AccessibleComponent_getSize     (AccessibleComponent *obj,
 330                                              long int            *width,
 331                                              long int            *height);
 332 AccessibleComponentLayer
 333             AccessibleComponent_getLayer    (AccessibleComponent *obj);
 334 SPIBoolean  AccessibleComponent_grabFocus   (AccessibleComponent *obj);
 335 short       AccessibleComponent_getMDIZOrder(AccessibleComponent *obj);
 336
 337 /* AccessibleEditableText function prototypes  */
 338
 339 void
 340 AccessibleEditableText_ref (AccessibleEditableText *obj);
 341
 342 void
 343 AccessibleEditableText_unref (AccessibleEditableText *obj);
 344
 345 SPIBoolean
 346 AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
 347                                       const char *attributes,
 348                                       long int startOffset,
 349                                       long int endOffset);
 350
 351 SPIBoolean
 352 AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
 353                                         const char *newContents);
 354
 355 SPIBoolean
 356 AccessibleEditableText_insertText (AccessibleEditableText *obj,
 357                                    long int position,
 358                                    const char *text,
 359                                    long int length);
 360
 361 SPIBoolean
 362 AccessibleEditableText_copyText (AccessibleText *obj,
 363                                  long int startPos,
 364                                  long int endPos);
 365
 366 SPIBoolean
 367 AccessibleEditableText_cutText (AccessibleEditableText *obj,
 368                                 long int startPos,
 369                                 long int endPos);
 370
 371 SPIBoolean
 372 AccessibleEditableText_deleteText (AccessibleEditableText *obj,
 373                                    long int startPos,
 374                                    long int endPos);
 375
 376 SPIBoolean
 377 AccessibleEditableText_pasteText (AccessibleEditableText *obj,
 378                                   long int position);
 379
 380 /*
 381  *
 382  * AccessibleHyperlink function prototypes
 383  *
 384  */
 385 void
 386 AccessibleHyperlink_ref (AccessibleHyperlink *obj);
 387 void
 388 AccessibleHyperlink_unref (AccessibleHyperlink *obj);
 389
 390 long
 391 AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
 392
 393 char *
 394 AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
 395                             long int i);
 396
 397 Accessible *
 398 AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
 399                                long int i);
 400
 401 void
 402 AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
 403                                    long int *startIndex,
 404                                    long int *endIndex);
 405
 406 SPIBoolean
 407 AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
 408
 409 /*
 410  *
 411  * AccessibleHypertext function prototypes
 412  *
 413  */
 414
 415 void
 416 AccessibleHypertext_ref (AccessibleHypertext *obj);
 417
 418 void
 419 AccessibleHypertext_unref (AccessibleHypertext *obj);
 420
 421 long
 422 AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
 423
 424 AccessibleHyperlink *
 425 AccessibleHypertext_getLink (AccessibleHypertext *obj,
 426                              long int linkIndex);
 427
 428 long
 429 AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
 430                                   long int characterOffset);
 431
 432 /*
 433  *
 434  * AccessibleImage function prototypes
 435  *
 436  */
 437
 438 void
 439 AccessibleImage_ref (AccessibleImage *obj);
 440
 441 void
 442 AccessibleImage_unref (AccessibleImage *obj);
 443
 444 char *
 445 AccessibleImage_getImageDescription (AccessibleImage *obj);
 446
 447 void
 448 AccessibleImage_getImageSize (AccessibleImage *obj,
 449                               long int *width,
 450                               long int *height);
 451
 452 void
 453 AccessibleImage_getImagePosition (AccessibleImage *obj,
 454                                   long int *x,
 455                                   long int *y,
 456                                   AccessibleCoordType ctype);
 457
 458 void
 459 AccessibleImage_getImageExtents (AccessibleImage *obj,
 460                                  long int *x,
 461                                  long int *y,
 462                                  long int *width,
 463                                  long int *height,
 464                                  AccessibleCoordType ctype);
 465 /*
 466  *
 467  * AccessibleRelation function prototypes
 468  *
 469  */
 470
 471 void AccessibleRelation_ref   (AccessibleRelation *obj);
 472 void AccessibleRelation_unref (AccessibleRelation *obj);
 473
 474 AccessibleRelationType
 475 AccessibleRelation_getRelationType (AccessibleRelation *obj);
 476
 477 int
 478 AccessibleRelation_getNTargets (AccessibleRelation *obj);
 479
 480 Accessible *
 481 AccessibleRelation_getTarget (AccessibleRelation *obj, int i);
 482
 483
 484 /*
 485  *
 486  * AccessibleSelection function prototypes
 487  *
 488  */
 489
 490 void AccessibleSelection_ref   (AccessibleSelection *obj);
 491 void AccessibleSelection_unref (AccessibleSelection *obj);
 492
 493 long
 494 AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj);
 495
 496 Accessible *
 497 AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
 498                                       long int selectedChildIndex);
 499
 500 SPIBoolean
 501 AccessibleSelection_selectChild (AccessibleSelection *obj,
 502                                  long int childIndex);
 503
 504 SPIBoolean
 505 AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
 506                                            long int selectedChildIndex);
 507
 508 SPIBoolean
 509 AccessibleSelection_isChildSelected (AccessibleSelection *obj,
 510                                      long int childIndex);
 511
 512 SPIBoolean
 513 AccessibleSelection_selectAll (AccessibleSelection *obj);
 514
 515 SPIBoolean
 516 AccessibleSelection_clearSelection (AccessibleSelection *obj);
 517
 518
 519 /*
 520  *
 521  * AccessibleStateSet function prototypes
 522  *
 523  */
 524
 525 void AccessibleStateSet_ref   (AccessibleStateSet *obj);
 526 void AccessibleStateSet_unref (AccessibleStateSet *obj);
 527
 528 SPIBoolean
 529 AccessibleStateSet_contains (AccessibleStateSet *obj,
 530                              AccessibleState state);
 531
 532 void
 533 AccessibleStateSet_add (AccessibleStateSet *obj,
 534                         AccessibleState state);
 535
 536 void
 537 AccessibleStateSet_remove (AccessibleStateSet *obj,
 538                            AccessibleState state);
 539
 540 SPIBoolean
 541 AccessibleStateSet_equals (AccessibleStateSet *obj,
 542                            AccessibleStateSet *obj2);
 543
 544 AccessibleStateSet *
 545 AccessibleStateSet_compare (AccessibleStateSet *obj,
 546                             AccessibleStateSet *obj2);
 547
 548 SPIBoolean
 549 AccessibleStateSet_isEmpty (AccessibleStateSet *obj);
 550
 551 void
 552 AccessibleStreamableContent_ref (AccessibleStreamableContent *obj);
 553 void
 554 AccessibleStreamableContent_unref (AccessibleStreamableContent *obj);
 555 char **
 556 AccessibleStreamableContent_getContentTypes (AccessibleStreamableContent *obj);
 557 SPIBoolean
 558 AccessibleStreamableContent_open (AccessibleStreamableContent *obj,
 559                                   const char *content_type);
 560 SPIBoolean
 561 AccessibleStreamableContent_seek (AccessibleStreamableContent *obj,
 562                                   long int offset,
 563                                   unsigned int seek_type);
 564 SPIBoolean
 565 AccessibleStreamableContent_read (AccessibleStreamableContent *obj,
 566                                   void *buff,
 567                                   long int nbytes,
 568                                   unsigned int read_type);
 569 /*
 570  *
 571  * AccessibleTable function prototypes
 572  *
 573  */
 574
 575 void AccessibleTable_ref   (AccessibleTable *obj);
 576 void AccessibleTable_unref (AccessibleTable *obj);
 577
 578 Accessible *
 579 AccessibleTable_getCaption (AccessibleTable *obj);
 580
 581 Accessible *
 582 AccessibleTable_getSummary (AccessibleTable *obj);
 583
 584 long
 585 AccessibleTable_getNRows (AccessibleTable *obj);
 586
 587 long
 588 AccessibleTable_getNColumns (AccessibleTable *obj);
 589
 590 Accessible *
 591 AccessibleTable_getAccessibleAt (AccessibleTable *obj,
 592                                  long int row,
 593                                  long int column);
 594
 595 long
 596 AccessibleTable_getIndexAt (AccessibleTable *obj,
 597                             long int row,
 598                             long int column);
 599
 600 long
 601 AccessibleTable_getRowAtIndex (AccessibleTable *obj,
 602                                long int index);
 603
 604 long
 605 AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
 606                                   long int index);
 607
 608 char *
 609 AccessibleTable_getRowDescription (AccessibleTable *obj,
 610                                    long int row);
 611
 612 char *
 613 AccessibleTable_getColumnDescription (AccessibleTable *obj,
 614                                       long int column);
 615
 616 long
 617 AccessibleTable_getRowExtentAt (AccessibleTable *obj,
 618                                 long int row,
 619                                 long int column);
 620
 621 long
 622 AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
 623                                    long int row,
 624                                    long int column);
 625
 626 Accessible *
 627 AccessibleTable_getRowHeader (AccessibleTable *obj,
 628                               long int row);
 629
 630 Accessible *
 631 AccessibleTable_getColumnHeader (AccessibleTable *obj,
 632                                  long int column);
 633
 634 long
 635 AccessibleTable_getNSelectedRows (AccessibleTable *obj);
 636
 637 long
 638 AccessibleTable_getSelectedRows (AccessibleTable *obj,
 639                                  long int **selectedRows);
 640
 641 long
 642 AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
 643
 644 long
 645 AccessibleTable_getSelectedColumns (AccessibleTable *obj,
 646                                     long int **selectedColumns);
 647
 648 SPIBoolean
 649 AccessibleTable_isRowSelected (AccessibleTable *obj,
 650                                long int row);
 651
 652 SPIBoolean
 653 AccessibleTable_isColumnSelected (AccessibleTable *obj,
 654                                   long int column);
 655
 656 SPIBoolean
 657 AccessibleTable_isSelected (AccessibleTable *obj,
 658                             long int row,
 659                             long int column);
 660
 661 /*
 662  *
 663  * AccessibleText function prototypes
 664  *
 665  */
 666
 667 void AccessibleText_ref   (AccessibleText *obj);
 668 void AccessibleText_unref (AccessibleText *obj);
 669
 670 long
 671 AccessibleText_getCharacterCount (AccessibleText *obj);
 672
 673 char *
 674 AccessibleText_getText (AccessibleText *obj,
 675                         long int startOffset,
 676                         long int endOffset);
 677
 678 long
 679 AccessibleText_getCaretOffset (AccessibleText *obj);
 680
 681 char *
 682 AccessibleText_getAttributes (AccessibleText *obj,
 683                                  long int offset,
 684                                  long int *startOffset,
 685                                  long int *endOffset);
 686
 687
 688 SPIBoolean
 689 AccessibleText_setCaretOffset (AccessibleText *obj,
 690                                long int newOffset);
 691
 692 char *
 693 AccessibleText_getTextBeforeOffset (AccessibleText *obj,
 694                                     long int offset,
 695                                     AccessibleTextBoundaryType type,
 696                                     long int *startOffset,
 697                                     long int *endOffset);
 698
 699 char *
 700 AccessibleText_getTextAtOffset (AccessibleText *obj,
 701                                 long int offset,
 702                                 AccessibleTextBoundaryType type,
 703                                 long int *startOffset,
 704                                 long int *endOffset);
 705
 706 char *
 707 AccessibleText_getTextAfterOffset (AccessibleText *obj,
 708                                    long int offset,
 709                                    AccessibleTextBoundaryType type,
 710                                    long int *startOffset,
 711                                    long int *endOffset);
 712
 713 unsigned long
 714 AccessibleText_getCharacterAtOffset (AccessibleText *obj,
 715                                      long int offset);
 716
 717 void
 718 AccessibleText_getCharacterExtents (AccessibleText *obj,
 719                                     long int offset,
 720                                     long int *x,
 721                                     long int *y,
 722                                     long int *width,
 723                                     long int *height,
 724                                     AccessibleCoordType type);
 725
 726 long
 727 AccessibleText_getOffsetAtPoint (AccessibleText *obj,
 728                                  long int x,
 729                                  long int y,
 730                                  AccessibleCoordType type);
 731
 732 long
 733 AccessibleText_getNSelections (AccessibleText *obj);
 734
 735 void
 736 AccessibleText_getSelection (AccessibleText *obj,
 737                              long int selectionNum,
 738                              long int *startOffset,
 739                              long int *endOffset);
 740
 741
 742 SPIBoolean
 743 AccessibleText_addSelection (AccessibleText *obj,
 744                              long int startOffset,
 745                              long int endOffset);
 746
 747 SPIBoolean
 748 AccessibleText_removeSelection (AccessibleText *obj,
 749                                 long int selectionNum);
 750
 751 SPIBoolean
 752 AccessibleText_setSelection (AccessibleText *obj,
 753                              long int selectionNum,
 754                              long int startOffset,
 755                              long int endOffset);
 756
 757 /* AccessibleValue Function Prototypes:  */
 758
 759 void       AccessibleValue_ref             (AccessibleValue *obj);
 760 void       AccessibleValue_unref           (AccessibleValue *obj);
 761 double     AccessibleValue_getMinimumValue (AccessibleValue *obj);
 762 double     AccessibleValue_getCurrentValue (AccessibleValue *obj);
 763 double     AccessibleValue_getMaximumValue (AccessibleValue *obj);
 764 SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj,
 765                                             double           newValue);
 766
 767 /* Misc methods */
 768 void SPI_freeString (char *s);
 769
 770 #ifdef  __cplusplus
 771 }
 772 #endif
 773
 774 #endif