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