cspi/spi.h

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