cspi/spi.h

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