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