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