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