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 **list);
 204
 205 SPIBoolean  SPI_generateKeyboardEvent            (long int                    keyval,
 206                                                   char                       *keystring,
 207                                                   AccessibleKeySynthType      synth_type);
 208
 209 SPIBoolean  SPI_generateMouseEvent               (long int x, long int y, char *name);
 210
 211 /* Accessible function prototypes  */
 212
 213 void                 Accessible_ref              (Accessible *obj);
 214 void                 Accessible_unref            (Accessible *obj);
 215 char *               Accessible_getName          (Accessible *obj);
 216 char *               Accessible_getDescription   (Accessible *obj);
 217 Accessible *         Accessible_getParent        (Accessible *obj);
 218 long                 Accessible_getChildCount    (Accessible *obj);
 219 Accessible *         Accessible_getChildAtIndex  (Accessible *obj,
 220                                                   long int    childIndex);
 221 long                 Accessible_getIndexInParent (Accessible *obj);
 222 AccessibleRelation **Accessible_getRelationSet   (Accessible *obj);
 223 AccessibleRole       Accessible_getRole          (Accessible *obj);
 224 char *               Accessible_getRoleName      (Accessible *obj);
 225 AccessibleStateSet * Accessible_getStateSet      (Accessible *obj);
 226
 227 /* Interface query methods */
 228
 229 SPIBoolean Accessible_isAction            (Accessible *obj);
 230 SPIBoolean Accessible_isApplication       (Accessible *obj);
 231 SPIBoolean Accessible_isComponent         (Accessible *obj);
 232 SPIBoolean Accessible_isEditableText      (Accessible *obj);
 233 SPIBoolean Accessible_isHypertext         (Accessible *obj);
 234 SPIBoolean Accessible_isImage             (Accessible *obj);
 235 SPIBoolean Accessible_isSelection         (Accessible *obj);
 236 SPIBoolean Accessible_isStreamableContent (Accessible *obj);
 237 SPIBoolean Accessible_isTable             (Accessible *obj);
 238 SPIBoolean Accessible_isText              (Accessible *obj);
 239 SPIBoolean Accessible_isValue             (Accessible *obj);
 240
 241 AccessibleAction *            Accessible_getAction            (Accessible *obj);
 242 AccessibleApplication *       Accessible_getApplication       (Accessible *obj);
 243 AccessibleComponent *         Accessible_getComponent         (Accessible *obj);
 244 AccessibleEditableText *      Accessible_getEditableText      (Accessible *obj);
 245 AccessibleHypertext *         Accessible_getHypertext         (Accessible *obj);
 246 AccessibleImage *             Accessible_getImage             (Accessible *obj);
 247 AccessibleSelection *         Accessible_getSelection         (Accessible *obj);
 248 AccessibleStreamableContent * Accessible_getStreamableContent (Accessible *obj);
 249 AccessibleTable *             Accessible_getTable             (Accessible *obj);
 250 AccessibleText *              Accessible_getText              (Accessible *obj);
 251 AccessibleValue *             Accessible_getValue             (Accessible *obj);
 252 AccessibleUnknown *           Accessible_queryInterface       (Accessible *obj,
 253                                                    const char *interface_name);
 254
 255 /* AccessibleAction function prototypes  */
 256
 257 void       AccessibleAction_ref            (AccessibleAction *obj);
 258 void       AccessibleAction_unref          (AccessibleAction *obj);
 259 long       AccessibleAction_getNActions    (AccessibleAction *obj);
 260 char      *AccessibleAction_getName        (AccessibleAction *obj,
 261                                             long int          i);
 262 char      *AccessibleAction_getDescription (AccessibleAction *obj,
 263                                             long int          i);
 264 SPIBoolean AccessibleAction_doAction       (AccessibleAction *obj,
 265                                             long int          i);
 266 char      *AccessibleAction_getKeyBinding  (AccessibleAction *obj,
 267                                             long int          i);
 268
 269 /* AccessibleApplication function prototypes  */
 270
 271 void       AccessibleApplication_ref            (AccessibleApplication *obj);
 272 void       AccessibleApplication_unref          (AccessibleApplication *obj);
 273 char      *AccessibleApplication_getToolkitName (AccessibleApplication *obj);
 274 char      *AccessibleApplication_getVersion     (AccessibleApplication *obj);
 275 long       AccessibleApplication_getID          (AccessibleApplication *obj);
 276 SPIBoolean AccessibleApplication_pause          (AccessibleApplication *obj);
 277 SPIBoolean AccessibleApplication_resume         (AccessibleApplication *obj);
 278
 279 /* AccessibleComponent function prototypes */
 280
 281 void        AccessibleComponent_ref         (AccessibleComponent *obj);
 282 void        AccessibleComponent_unref       (AccessibleComponent *obj);
 283 SPIBoolean  AccessibleComponent_contains    (AccessibleComponent *obj,
 284                                              long int             x,
 285                                              long int             y,
 286                                              AccessibleCoordType  ctype);
 287 Accessible *AccessibleComponent_getAccessibleAtPoint (
 288                                              AccessibleComponent *obj,
 289                                              long int             x,
 290                                              long int             y,
 291                                              AccessibleCoordType  ctype);
 292 void        AccessibleComponent_getExtents  (AccessibleComponent *obj,
 293                                              long int            *x,
 294                                              long int            *y,
 295                                              long int            *width,
 296                                              long int            *height,
 297                                              AccessibleCoordType  ctype);
 298 void        AccessibleComponent_getPosition (AccessibleComponent *obj,
 299                                              long int            *x,
 300                                              long int            *y,
 301                                              AccessibleCoordType  ctype);
 302 void        AccessibleComponent_getSize     (AccessibleComponent *obj,
 303                                              long int            *width,
 304                                              long int            *height);
 305 AccessibleComponentLayer
 306             AccessibleComponent_getLayer    (AccessibleComponent *obj);
 307 void        AccessibleComponent_grabFocus   (AccessibleComponent *obj);
 308 short       AccessibleComponent_getMDIZOrder(AccessibleComponent *obj);
 309
 310 /* AccessibleEditableText function prototypes  */
 311
 312 void
 313 AccessibleEditableText_ref (AccessibleEditableText *obj);
 314
 315 void
 316 AccessibleEditableText_unref (AccessibleEditableText *obj);
 317
 318 SPIBoolean
 319 AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
 320                                       const char *attributes,
 321                                       long int startOffset,
 322                                       long int endOffset);
 323
 324 SPIBoolean
 325 AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
 326                                         const char *newContents);
 327
 328 SPIBoolean
 329 AccessibleEditableText_insertText (AccessibleEditableText *obj,
 330                                    long int position,
 331                                    const char *text,
 332                                    long int length);
 333
 334 SPIBoolean
 335 AccessibleEditableText_copyText (AccessibleText *obj,
 336                                  long int startPos,
 337                                  long int endPos);
 338
 339 SPIBoolean
 340 AccessibleEditableText_cutText (AccessibleEditableText *obj,
 341                                 long int startPos,
 342                                 long int endPos);
 343
 344 SPIBoolean
 345 AccessibleEditableText_deleteText (AccessibleEditableText *obj,
 346                                    long int startPos,
 347                                    long int endPos);
 348
 349 SPIBoolean
 350 AccessibleEditableText_pasteText (AccessibleEditableText *obj,
 351                                   long int position);
 352
 353 /*
 354  *
 355  * AccessibleHyperlink function prototypes
 356  *
 357  */
 358 void
 359 AccessibleHyperlink_ref (AccessibleHyperlink *obj);
 360 void
 361 AccessibleHyperlink_unref (AccessibleHyperlink *obj);
 362
 363 long
 364 AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
 365
 366 char *
 367 AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
 368                             long int i);
 369
 370 Accessible *
 371 AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
 372                                long int i);
 373
 374 void
 375 AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
 376                                    long int *startIndex,
 377                                    long int *endIndex);
 378
 379 SPIBoolean
 380 AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
 381
 382 /*
 383  *
 384  * AccessibleHypertext function prototypes
 385  *
 386  */
 387
 388 void
 389 AccessibleHypertext_ref (AccessibleHypertext *obj);
 390
 391 void
 392 AccessibleHypertext_unref (AccessibleHypertext *obj);
 393
 394 long
 395 AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
 396
 397 AccessibleHyperlink *
 398 AccessibleHypertext_getLink (AccessibleHypertext *obj,
 399                              long int linkIndex);
 400
 401 long
 402 AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
 403                                   long int characterOffset);
 404
 405 /*
 406  *
 407  * AccessibleImage function prototypes
 408  *
 409  */
 410
 411 void
 412 AccessibleImage_ref (AccessibleImage *obj);
 413
 414 void
 415 AccessibleImage_unref (AccessibleImage *obj);
 416
 417 char *
 418 AccessibleImage_getImageDescription (AccessibleImage *obj);
 419
 420 void
 421 AccessibleImage_getImageSize (AccessibleImage *obj,
 422                               long int *width,
 423                               long int *height);
 424
 425 void
 426 AccessibleImage_getImagePosition (AccessibleImage *obj,
 427                                   long int *x,
 428                                   long int *y,
 429                                   AccessibleCoordType ctype);
 430
 431 void
 432 AccessibleImage_getImageExtents (AccessibleImage *obj,
 433                                  long int *x,
 434                                  long int *y,
 435                                  long int *width,
 436                                  long int *height,
 437                                  AccessibleCoordType ctype);
 438 /*
 439  *
 440  * AccessibleRelation function prototypes
 441  *
 442  */
 443
 444 void AccessibleRelation_ref   (AccessibleRelation *obj);
 445 void AccessibleRelation_unref (AccessibleRelation *obj);
 446
 447 AccessibleRelationType
 448 AccessibleRelation_getRelationType (AccessibleRelation *obj);
 449
 450 int
 451 AccessibleRelation_getNTargets (AccessibleRelation *obj);
 452
 453 Accessible *
 454 AccessibleRelation_getTarget (AccessibleRelation *obj, int i);
 455
 456
 457 /*
 458  *
 459  * AccessibleSelection function prototypes
 460  *
 461  */
 462
 463 void AccessibleSelection_ref   (AccessibleSelection *obj);
 464 void AccessibleSelection_unref (AccessibleSelection *obj);
 465
 466 long
 467 AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj);
 468
 469 Accessible *
 470 AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
 471                                       long int selectedChildIndex);
 472
 473 SPIBoolean
 474 AccessibleSelection_selectChild (AccessibleSelection *obj,
 475                                  long int childIndex);
 476
 477 SPIBoolean
 478 AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
 479                                            long int selectedChildIndex);
 480
 481 SPIBoolean
 482 AccessibleSelection_isChildSelected (AccessibleSelection *obj,
 483                                      long int childIndex);
 484
 485 SPIBoolean
 486 AccessibleSelection_selectAll (AccessibleSelection *obj);
 487
 488 void
 489 AccessibleSelection_clearSelection (AccessibleSelection *obj);
 490
 491
 492 /*
 493  *
 494  * AccessibleStateSet function prototypes
 495  *
 496  */
 497
 498 void AccessibleStateSet_ref   (AccessibleStateSet *obj);
 499 void AccessibleStateSet_unref (AccessibleStateSet *obj);
 500
 501 SPIBoolean
 502 AccessibleStateSet_contains (AccessibleStateSet *obj,
 503                              AccessibleState state);
 504
 505 void
 506 AccessibleStateSet_add (AccessibleStateSet *obj,
 507                         AccessibleState state);
 508
 509 void
 510 AccessibleStateSet_remove (AccessibleStateSet *obj,
 511                            AccessibleState state);
 512
 513 SPIBoolean
 514 AccessibleStateSet_equals (AccessibleStateSet *obj,
 515                            AccessibleStateSet *obj2);
 516
 517 AccessibleStateSet *
 518 AccessibleStateSet_compare (AccessibleStateSet *obj,
 519                             AccessibleStateSet *obj2);
 520
 521 SPIBoolean
 522 AccessibleStateSet_isEmpty (AccessibleStateSet *obj);
 523
 524 void
 525 AccessibleStreamableContent_ref (AccessibleStreamableContent *obj);
 526 void
 527 AccessibleStreamableContent_unref (AccessibleStreamableContent *obj);
 528 char **
 529 AccessibleStreamableContent_getContentTypes (AccessibleStreamableContent *obj);
 530 SPIBoolean
 531 AccessibleStreamableContent_open (AccessibleStreamableContent *obj,
 532                                   const char *content_type);
 533 SPIBoolean
 534 AccessibleStreamableContent_seek (AccessibleStreamableContent *obj,
 535                                   long int offset);
 536 SPIBoolean
 537 AccessibleStreamableContent_read (AccessibleStreamableContent *obj,
 538                                   void *buff,
 539                                   long int nbytes,
 540                                   unsigned int read_type);
 541 /*
 542  *
 543  * AccessibleTable function prototypes
 544  *
 545  */
 546
 547 void AccessibleTable_ref   (AccessibleTable *obj);
 548 void AccessibleTable_unref (AccessibleTable *obj);
 549
 550 Accessible *
 551 AccessibleTable_getCaption (AccessibleTable *obj);
 552
 553 Accessible *
 554 AccessibleTable_getSummary (AccessibleTable *obj);
 555
 556 long
 557 AccessibleTable_getNRows (AccessibleTable *obj);
 558
 559 long
 560 AccessibleTable_getNColumns (AccessibleTable *obj);
 561
 562 Accessible *
 563 AccessibleTable_getAccessibleAt (AccessibleTable *obj,
 564                                  long int row,
 565                                  long int column);
 566
 567 long
 568 AccessibleTable_getIndexAt (AccessibleTable *obj,
 569                             long int row,
 570                             long int column);
 571
 572 long
 573 AccessibleTable_getRowAtIndex (AccessibleTable *obj,
 574                                long int index);
 575
 576 long
 577 AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
 578                                   long int index);
 579
 580 char *
 581 AccessibleTable_getRowDescription (AccessibleTable *obj,
 582                                    long int row);
 583
 584 char *
 585 AccessibleTable_getColumnDescription (AccessibleTable *obj,
 586                                       long int column);
 587
 588 long
 589 AccessibleTable_getRowExtentAt (AccessibleTable *obj,
 590                                 long int row,
 591                                 long int column);
 592
 593 long
 594 AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
 595                                    long int row,
 596                                    long int column);
 597
 598 Accessible *
 599 AccessibleTable_getRowHeader (AccessibleTable *obj,
 600                               long int row);
 601
 602 Accessible *
 603 AccessibleTable_getColumnHeader (AccessibleTable *obj,
 604                                  long int column);
 605
 606 long
 607 AccessibleTable_getNSelectedRows (AccessibleTable *obj);
 608
 609 long
 610 AccessibleTable_getSelectedRows (AccessibleTable *obj,
 611                                  long int **selectedRows);
 612
 613 long
 614 AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
 615
 616 long
 617 AccessibleTable_getSelectedColumns (AccessibleTable *obj,
 618                                     long int **selectedColumns);
 619
 620 SPIBoolean
 621 AccessibleTable_isRowSelected (AccessibleTable *obj,
 622                                long int row);
 623
 624 SPIBoolean
 625 AccessibleTable_isColumnSelected (AccessibleTable *obj,
 626                                   long int column);
 627
 628 SPIBoolean
 629 AccessibleTable_isSelected (AccessibleTable *obj,
 630                             long int row,
 631                             long int column);
 632
 633 /*
 634  *
 635  * AccessibleText function prototypes
 636  *
 637  */
 638
 639 void AccessibleText_ref   (AccessibleText *obj);
 640 void AccessibleText_unref (AccessibleText *obj);
 641
 642 long
 643 AccessibleText_getCharacterCount (AccessibleText *obj);
 644
 645 char *
 646 AccessibleText_getText (AccessibleText *obj,
 647                         long int startOffset,
 648                         long int endOffset);
 649
 650 long
 651 AccessibleText_getCaretOffset (AccessibleText *obj);
 652
 653 char *
 654 AccessibleText_getAttributes (AccessibleText *obj,
 655                                  long int offset,
 656                                  long int *startOffset,
 657                                  long int *endOffset);
 658
 659
 660 SPIBoolean
 661 AccessibleText_setCaretOffset (AccessibleText *obj,
 662                                long int newOffset);
 663
 664 char *
 665 AccessibleText_getTextBeforeOffset (AccessibleText *obj,
 666                                     long int offset,
 667                                     AccessibleTextBoundaryType type,
 668                                     long int *startOffset,
 669                                     long int *endOffset);
 670
 671 char *
 672 AccessibleText_getTextAtOffset (AccessibleText *obj,
 673                                 long int offset,
 674                                 AccessibleTextBoundaryType type,
 675                                 long int *startOffset,
 676                                 long int *endOffset);
 677
 678 char *
 679 AccessibleText_getTextAfterOffset (AccessibleText *obj,
 680                                    long int offset,
 681                                    AccessibleTextBoundaryType type,
 682                                    long int *startOffset,
 683                                    long int *endOffset);
 684
 685 unsigned long
 686 AccessibleText_getCharacterAtOffset (AccessibleText *obj,
 687                                      long int offset);
 688
 689 void
 690 AccessibleText_getCharacterExtents (AccessibleText *obj,
 691                                     long int offset,
 692                                     long int *x,
 693                                     long int *y,
 694                                     long int *width,
 695                                     long int *height,
 696                                     AccessibleCoordType type);
 697
 698 long
 699 AccessibleText_getOffsetAtPoint (AccessibleText *obj,
 700                                  long int x,
 701                                  long int y,
 702                                  AccessibleCoordType type);
 703
 704 long
 705 AccessibleText_getNSelections (AccessibleText *obj);
 706
 707 void
 708 AccessibleText_getSelection (AccessibleText *obj,
 709                              long int selectionNum,
 710                              long int *startOffset,
 711                              long int *endOffset);
 712
 713
 714 SPIBoolean
 715 AccessibleText_addSelection (AccessibleText *obj,
 716                              long int startOffset,
 717                              long int endOffset);
 718
 719 SPIBoolean
 720 AccessibleText_removeSelection (AccessibleText *obj,
 721                                 long int selectionNum);
 722
 723 SPIBoolean
 724 AccessibleText_setSelection (AccessibleText *obj,
 725                              long int selectionNum,
 726                              long int startOffset,
 727                              long int endOffset);
 728
 729 /* AccessibleValue Function Prototypes:  */
 730
 731 void       AccessibleValue_ref             (AccessibleValue *obj);
 732 void       AccessibleValue_unref           (AccessibleValue *obj);
 733 double     AccessibleValue_getMinimumValue (AccessibleValue *obj);
 734 double     AccessibleValue_getCurrentValue (AccessibleValue *obj);
 735 double     AccessibleValue_getMaximumValue (AccessibleValue *obj);
 736 SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj,
 737                                             double           newValue);
 738
 739 /* Misc methods */
 740 void SPI_freeString (char *s);
 741
 742 #ifdef  __cplusplus
 743 }
 744 #endif
 745
 746 #endif