cspi/spi.h

   1 #ifndef _SPI_H
   2 #define _SPI_H
   3
   4 #include <glib/gmacros.h>
   5
   6 #include <cspi/spi-impl.h>
   7 /*
   8  * Definitions for AccessibleRole, AccessibleState,
   9  * AccessibleEvent, and event listeners.
  10  */
  11 #include <cspi/spi-roletypes.h>
  12 #include <cspi/spi-statetypes.h>
  13 #include <cspi/spi-listener.h>
  14
  15 /*
  16  * Auxiliary typedefs and mask definitions
  17  */
  18 #include <libspi/keymasks.h>
  19
  20 G_BEGIN_DECLS
  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 void        registerAccessibleKeystrokeListener (
 171                                               AccessibleKeystrokeListener *listener,
 172                                               AccessibleKeySet             *keys,
 173                                               AccessibleKeyMaskType         modmask,
 174                                               AccessibleKeyEventMask        eventmask,
 175                                               AccessibleKeyListenerSyncType sync_type);
 176 void        deregisterAccessibleKeystrokeListener (
 177                                               AccessibleKeystrokeListener *listener,
 178                                               AccessibleKeyMaskType        modmask);
 179
 180 int         getDesktopCount                  (void);
 181 Accessible *getDesktop                       (int i);
 182 int         getDesktopList                   (Accessible **list);
 183
 184 void        generateKeyEvent                 (long int                    keyval,
 185                                               AccessibleKeySynthType      synth_type);
 186 void        generateMouseEvent               (long int x, long int y, char *name);
 187
 188 /* Accessible function prototypes  */
 189
 190 int                  Accessible_ref              (Accessible *obj);
 191 int                  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 GenericInterface *       Accessible_queryInterface  (Accessible *obj,
 227                                                      const char *interface_name);
 228
 229 /*
 230  * AccessibleAction function prototypes
 231  */
 232
 233 int
 234 AccessibleAction_ref (AccessibleAction *obj);
 235
 236 int
 237 AccessibleAction_unref (AccessibleAction *obj);
 238
 239 long
 240 AccessibleAction_getNActions (AccessibleAction *obj);
 241
 242 /**
 243  * AccessibleAction_getName:
 244  * @obj: a pointer to the #AccessibleAction implementor to query.
 245  * @i: a long integer indicating which action to query.
 246  *
 247  * Get the name of the '@i-th' action invokable on an
 248  *      object implementing #AccessibleAction.
 249  *
 250  * Returns: the 'event type' name of the action, as a UTF-8 string.
 251  *
 252  **/
 253 char *
 254 AccessibleAction_getName (AccessibleAction *obj, long int i);
 255
 256 /**
 257  * AccessibleAction_getDescription:
 258  * @obj: a pointer to the #AccessibleAction to query.
 259  * @i: a long integer indicating which action to query.
 260  *
 261  * Get the description of '@i-th' action invokable on an
 262  *      object implementing #AccessibleAction.
 263  *
 264  * Returns: a UTF-8 string describing the '@i-th' invokable action.
 265  *
 266  **/
 267 char *
 268 AccessibleAction_getDescription (AccessibleAction *obj,
 269                                  long int i);
 270
 271 SPIBoolean
 272 AccessibleAction_doAction (AccessibleAction *obj,
 273                            long int i);
 274
 275 /**
 276  * AccessibleAction_getKeybinding:
 277  * @obj: a pointer to the #AccessibleAction implementor to query.
 278  * @i: a long integer indicating which action to query.
 279  *
 280  * Get the keybindings for the @i-th action invokable on an
 281  *      object implementing #AccessibleAction, if any are defined.
 282  *
 283  * Returns: a UTF-8 string which can be parsed to determine the @i-th
 284  * invokable action's keybindings.
 285  *
 286  **/
 287 char *
 288 AccessibleAction_getKeyBinding (AccessibleAction *obj,
 289                                 long int i);
 290
 291 /*
 292  *
 293  * AccessibleApplication function prototypes
 294  *
 295  */
 296
 297 /**
 298  * AccessibleApplication_unref:
 299  * @obj: a pointer to the #AccessibleApplication on which to operate.
 300  *
 301  * Decrement the reference count for an #AccessibleApplication.
 302  *
 303  * Returns: (no return code implemented yet).
 304  *
 305  **/
 306 int
 307 AccessibleApplication_ref (AccessibleApplication *obj);
 308
 309 /**
 310  * AccessibleApplication_unref:
 311  * @obj: a pointer to the #AccessibleApplication object on which to operate.
 312  *
 313  * Decrement the reference count for an #AccessibleApplication.
 314  *
 315  * Returns: (no return code implemented yet).
 316  *
 317  **/
 318 int
 319 AccessibleApplication_unref (AccessibleApplication *obj);
 320
 321 /**
 322  * AccessibleApplication_getToolkitName:
 323  * @obj: a pointer to the #AccessibleApplication to query.
 324  *
 325  * Get the name of the UI toolkit used by an #AccessibleApplication.
 326  *
 327  * Returns: a UTF-8 string indicating which UI toolkit is
 328  *          used by an application.
 329  *
 330  **/
 331 char *
 332 AccessibleApplication_getToolkitName (AccessibleApplication *obj);
 333
 334 /**
 335  * AccessibleApplication_getVersion:
 336  * @obj: a pointer to the #AccessibleApplication being queried.
 337  *
 338  * Get the version of the at-spi bridge exported by an
 339  *      #AccessibleApplication instance.
 340  *
 341  * Returns: a UTF-8 string indicating the application's
 342  *          at-spi version.
 343  *
 344  **/
 345 char *
 346 AccessibleApplication_getVersion (AccessibleApplication *obj);
 347
 348 /**
 349  * AccessibleApplication_getID:
 350  * @obj: a pointer to the #AccessibleApplication being queried.
 351  *
 352  * Get the unique ID assigned by the Registry to an
 353  *      #AccessibleApplication instance.
 354  * (Not Yet Implemented by the registry).
 355  *
 356  * Returns: a unique #long integer associated with the application
 357  *          by the Registry, or 0 if the application is not registered.
 358  **/
 359 long
 360 AccessibleApplication_getID (AccessibleApplication *obj);
 361
 362 /**
 363  * AccessibleApplication_pause:
 364  * @obj: a pointer to the #Accessible object on which to operate.
 365  *
 366  * Attempt to pause the application (used when client event queue is
 367  *  over-full).
 368  * Not Yet Implemented.
 369  *
 370  * Returns: #TRUE if the application was paused successfully, #FALSE otherwise.
 371  *
 372  **/
 373 SPIBoolean
 374 AccessibleApplication_pause (AccessibleApplication *obj);
 375
 376 /**
 377  * AccessibleApplication_resume:
 378  * @obj: a pointer to the #Accessible object on which to operate.
 379  *
 380  * Attempt to resume the application (used after #AccessibleApplication_pause).
 381  * Not Yet Implemented.
 382  *
 383  * Returns: #TRUE if application processing resumed successfully, #FALSE otherwise.
 384  *
 385  **/
 386 SPIBoolean
 387 AccessibleApplication_resume (AccessibleApplication *obj);
 388
 389 /*
 390  *
 391  * AccessibleComponent function prototypes
 392  *
 393  */
 394
 395 int
 396 AccessibleComponent_ref (AccessibleComponent *obj);
 397
 398 int
 399 AccessibleComponent_unref (AccessibleComponent *obj);
 400
 401 SPIBoolean
 402 AccessibleComponent_contains (AccessibleComponent *obj,
 403                               long int x,
 404                               long int y,
 405                               AccessibleCoordType ctype);
 406
 407 Accessible *
 408 AccessibleComponent_getAccessibleAtPoint (AccessibleComponent *obj,
 409                                           long int x,
 410                                           long int y,
 411                                           AccessibleCoordType ctype);
 412
 413 /**
 414  * AccessibleComponent_getExtents:
 415  * @obj: a pointer to the #AccessibleComponent to query.
 416  * @x: a pointer to a #long into which the minimum x coordinate will be returned.
 417  * @y: a pointer to a #long into which the minimum y coordinate will be returned.
 418  * @width: a pointer to a #long into which the x extents (width) will be returned.
 419  * @height: a pointer to a #long into which the y extents (height) will be returned.
 420  * @ctype: the desired coordinate system into which to return the results,
 421  *         (e.g. COORD_TYPE_WINDOW, COORD_TYPE_SCREEN).
 422  *
 423  * Get the bounding box of the specified #AccessibleComponent.
 424  *
 425  **/
 426 void
 427 AccessibleComponent_getExtents (AccessibleComponent *obj,
 428                                 long int *x,
 429                                 long int *y,
 430                                 long int *width,
 431                                 long int *height,
 432                                 AccessibleCoordType ctype);
 433
 434 void
 435 AccessibleComponent_getPosition (AccessibleComponent *obj,
 436                                  long int *x,
 437                                  long int *y,
 438                                  AccessibleCoordType ctype);
 439
 440 void
 441 AccessibleComponent_getSize (AccessibleComponent *obj,
 442                              long int *width,
 443                              long int *height);
 444
 445 /**
 446  * AccessibleComponent_getLayer:
 447  * @obj: a pointer to the #AccessibleComponent to query.
 448  *
 449  * Query which layer the component is painted into, to help determine its
 450  *      visibility in terms of stacking order.
 451  *
 452  * Returns: the #AccessibleComponentLayer into which this component is painted.
 453  **/
 454 AccessibleComponentLayer
 455 AccessibleComponent_getLayer (AccessibleComponent *obj);
 456
 457 /**
 458  * AccessibleComponent_getMDIZOrder:
 459  * @obj: a pointer to the #AccessibleComponent to query.
 460  *
 461  * Query the z stacking order of a component which is in the MDI layer.
 462  *
 463  * Returns: a short integer indicating the stacking order of the component
 464  *       in the MDI layer, or -1 if the component is not in the MDI layer.
 465  **/
 466 short
 467 AccessibleComponent_getMDIZOrder (AccessibleComponent *obj);
 468
 469 void
 470 AccessibleComponent_grabFocus (AccessibleComponent *obj);
 471
 472 /*
 473  *
 474  * AccessibleEditableText function prototypes
 475  *
 476  */
 477
 478 int
 479 AccessibleEditableText_ref (AccessibleEditableText *obj);
 480
 481 int
 482 AccessibleEditableText_unref (AccessibleEditableText *obj);
 483
 484 SPIBoolean
 485 AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
 486                                       const char *attributes,
 487                                       long int startOffset,
 488                                       long int endOffset);
 489
 490 SPIBoolean
 491 AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
 492                                         const char *newContents);
 493
 494 SPIBoolean
 495 AccessibleEditableText_insertText (AccessibleEditableText *obj,
 496                                    long int position,
 497                                    const char *text,
 498                                    long int length);
 499
 500 SPIBoolean
 501 AccessibleEditableText_copyText (AccessibleText *obj,
 502                                  long int startPos,
 503                                  long int endPos);
 504
 505 SPIBoolean
 506 AccessibleEditableText_cutText (AccessibleEditableText *obj,
 507                                 long int startPos,
 508                                 long int endPos);
 509
 510 SPIBoolean
 511 AccessibleEditableText_deleteText (AccessibleEditableText *obj,
 512                                    long int startPos,
 513                                    long int endPos);
 514
 515 SPIBoolean
 516 AccessibleEditableText_pasteText (AccessibleEditableText *obj,
 517                                   long int position);
 518
 519 /*
 520  *
 521  * AccessibleHyperlink function prototypes
 522  *
 523  */
 524
 525 long
 526 AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
 527
 528 char *
 529 AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
 530                             long int i);
 531
 532 Accessible *
 533 AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
 534                                long int i);
 535
 536 void
 537 AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
 538                                    long int *startIndex,
 539                                    long int *endIndex);
 540
 541 SPIBoolean
 542 AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
 543
 544 /*
 545  *
 546  * AccessibleHypertext function prototypes
 547  *
 548  */
 549
 550 int
 551 AccessibleHypertext_ref (AccessibleHypertext *obj);
 552
 553 int
 554 AccessibleHypertext_unref (AccessibleHypertext *obj);
 555
 556 long
 557 AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
 558
 559 AccessibleHyperlink *
 560 AccessibleHypertext_getLink (AccessibleHypertext *obj,
 561                              long int linkIndex);
 562
 563 long
 564 AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
 565                                   long int characterOffset);
 566
 567 /*
 568  *
 569  * AccessibleImage function prototypes
 570  *
 571  */
 572
 573 int
 574 AccessibleImage_ref (AccessibleImage *obj);
 575
 576 int
 577 AccessibleImage_unref (AccessibleImage *obj);
 578
 579 char *
 580 AccessibleImage_getImageDescription (AccessibleImage *obj);
 581
 582 void
 583 AccessibleImage_getImageSize (AccessibleImage *obj,
 584                               long int *width,
 585                               long int *height);
 586
 587 void
 588 AccessibleImage_getImagePosition (AccessibleImage *obj,
 589                                   long int *x,
 590                                   long int *y,
 591                                   AccessibleCoordType ctype);
 592
 593 void
 594 AccessibleImage_getImageExtents (AccessibleImage *obj,
 595                                  long int *x,
 596                                  long int *y,
 597                                  long int *width,
 598                                  long int *height,
 599                                  AccessibleCoordType ctype);
 600 /*
 601  *
 602  * AccessibleRelation function prototypes
 603  *
 604  */
 605
 606 int
 607 AccessibleRelation_ref (AccessibleRelation *obj);
 608
 609 int
 610 AccessibleRelation_unref (AccessibleRelation *obj);
 611
 612 AccessibleRelationType
 613 AccessibleRelation_getRelationType (AccessibleRelation *obj);
 614
 615 int
 616 AccessibleRelation_getNTargets (AccessibleRelation *obj);
 617
 618 Accessible *
 619 AccessibleRelation_getTarget (AccessibleRelation *obj, int i);
 620
 621
 622 /*
 623  *
 624  * AccessibleSelection function prototypes
 625  *
 626  */
 627
 628 int
 629 AccessibleSelection_ref (AccessibleSelection *obj);
 630
 631 int
 632 AccessibleSelection_unref (AccessibleSelection *obj);
 633
 634 long
 635 AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj);
 636
 637 Accessible *
 638 AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
 639                                       long int selectedChildIndex);
 640
 641 SPIBoolean
 642 AccessibleSelection_selectChild (AccessibleSelection *obj,
 643                                  long int childIndex);
 644
 645 SPIBoolean
 646 AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
 647                                            long int selectedChildIndex);
 648
 649 SPIBoolean
 650 AccessibleSelection_isChildSelected (AccessibleSelection *obj,
 651                                      long int childIndex);
 652
 653 SPIBoolean
 654 AccessibleSelection_selectAll (AccessibleSelection *obj);
 655
 656 void
 657 AccessibleSelection_clearSelection (AccessibleSelection *obj);
 658
 659
 660 /*
 661  *
 662  * AccessibleStateSet function prototypes
 663  *
 664  */
 665
 666 int
 667 AccessibleStateSet_ref (AccessibleStateSet *obj);
 668
 669 int
 670 AccessibleStateSet_unref (AccessibleStateSet *obj);
 671
 672 SPIBoolean
 673 AccessibleStateSet_contains (AccessibleStateSet *obj,
 674                              AccessibleState state);
 675
 676 void
 677 AccessibleStateSet_add (AccessibleStateSet *obj,
 678                         AccessibleState state);
 679
 680 void
 681 AccessibleStateSet_remove (AccessibleStateSet *obj,
 682                            AccessibleState state);
 683
 684 SPIBoolean
 685 AccessibleStateSet_equals (AccessibleStateSet *obj,
 686                            AccessibleStateSet *obj2);
 687
 688 AccessibleStateSet *
 689 AccessibleStateSet_compare (AccessibleStateSet *obj,
 690                             AccessibleStateSet *obj2);
 691
 692 SPIBoolean
 693 AccessibleStateSet_isEmpty (AccessibleStateSet *obj);
 694
 695
 696 /*
 697  *
 698  * AccessibleTable function prototypes
 699  *
 700  */
 701
 702 int
 703 AccessibleTable_ref (AccessibleTable *obj);
 704
 705 int
 706 AccessibleTable_unref (AccessibleTable *obj);
 707
 708 Accessible *
 709 AccessibleTable_getCaption (AccessibleTable *obj);
 710
 711 Accessible *
 712 AccessibleTable_getSummary (AccessibleTable *obj);
 713
 714 long
 715 AccessibleTable_getNRows (AccessibleTable *obj);
 716
 717 long
 718 AccessibleTable_getNColumns (AccessibleTable *obj);
 719
 720 Accessible *
 721 AccessibleTable_getAccessibleAt (AccessibleTable *obj,
 722                                  long int row,
 723                                  long int column);
 724
 725 long
 726 AccessibleTable_getIndexAt (AccessibleTable *obj,
 727                             long int row,
 728                             long int column);
 729
 730 long
 731 AccessibleTable_getRowAtIndex (AccessibleTable *obj,
 732                                long int index);
 733
 734 long
 735 AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
 736                                   long int index);
 737
 738 char *
 739 AccessibleTable_getRowDescription (AccessibleTable *obj,
 740                                    long int row);
 741
 742 char *
 743 AccessibleTable_getColumnDescription (AccessibleTable *obj,
 744                                       long int column);
 745
 746 long
 747 AccessibleTable_getRowExtentAt (AccessibleTable *obj,
 748                                 long int row,
 749                                 long int column);
 750
 751 long
 752 AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
 753                                    long int row,
 754                                    long int column);
 755
 756 Accessible *
 757 AccessibleTable_getRowHeader (AccessibleTable *obj,
 758                               long int row);
 759
 760 Accessible *
 761 AccessibleTable_getColumnHeader (AccessibleTable *obj,
 762                                  long int column);
 763
 764 long
 765 AccessibleTable_getNSelectedRows (AccessibleTable *obj);
 766
 767 long
 768 AccessibleTable_getSelectedRows (AccessibleTable *obj,
 769                                  long int **selectedRows);
 770
 771 long
 772 AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
 773
 774 long
 775 AccessibleTable_getSelectedColumns (AccessibleTable *obj,
 776                                     long int **selectedColumns);
 777
 778 SPIBoolean
 779 AccessibleTable_isRowSelected (AccessibleTable *obj,
 780                                long int row);
 781
 782 SPIBoolean
 783 AccessibleTable_isColumnSelected (AccessibleTable *obj,
 784                                   long int column);
 785
 786 SPIBoolean
 787 AccessibleTable_isSelected (AccessibleTable *obj,
 788                             long int row,
 789                             long int column);
 790
 791 /*
 792  *
 793  * AccessibleText function prototypes
 794  *
 795  */
 796
 797 int
 798 AccessibleText_ref (AccessibleText *obj);
 799
 800 int
 801 AccessibleText_unref (AccessibleText *obj);
 802
 803 long
 804 AccessibleText_getCharacterCount (AccessibleText *obj);
 805
 806 char *
 807 AccessibleText_getText (AccessibleText *obj,
 808                         long int startOffset,
 809                         long int endOffset);
 810
 811 long
 812 AccessibleText_getCaretOffset (AccessibleText *obj);
 813
 814 char *
 815 AccessibleText_getAttributes (AccessibleText *obj,
 816                                  long int offset,
 817                                  long int *startOffset,
 818                                  long int *endOffset);
 819
 820
 821 SPIBoolean
 822 AccessibleText_setCaretOffset (AccessibleText *obj,
 823                                long int newOffset);
 824
 825 char *
 826 AccessibleText_getTextBeforeOffset (AccessibleText *obj,
 827                                     long int offset,
 828                                     AccessibleTextBoundaryType type,
 829                                     long int *startOffset,
 830                                     long int *endOffset);
 831
 832 char *
 833 AccessibleText_getTextAtOffset (AccessibleText *obj,
 834                                 long int offset,
 835                                 AccessibleTextBoundaryType type,
 836                                 long int *startOffset,
 837                                 long int *endOffset);
 838
 839 char *
 840 AccessibleText_getTextAfterOffset (AccessibleText *obj,
 841                                    long int offset,
 842                                    AccessibleTextBoundaryType type,
 843                                    long int *startOffset,
 844                                    long int *endOffset);
 845
 846 unsigned long
 847 AccessibleText_getCharacterAtOffset (AccessibleText *obj,
 848                                      long int offset);
 849
 850 void
 851 AccessibleText_getCharacterExtents (AccessibleText *obj,
 852                                     long int offset,
 853                                     long int *x,
 854                                     long int *y,
 855                                     long int *width,
 856                                     long int *height,
 857                                     AccessibleCoordType type);
 858
 859 long
 860 AccessibleText_getOffsetAtPoint (AccessibleText *obj,
 861                                  long int x,
 862                                  long int y,
 863                                  AccessibleCoordType type);
 864
 865 long
 866 AccessibleText_getNSelections (AccessibleText *obj);
 867
 868 void
 869 AccessibleText_getSelection (AccessibleText *obj,
 870                              long int selectionNum,
 871                              long int *startOffset,
 872                              long int *endOffset);
 873
 874
 875 SPIBoolean
 876 AccessibleText_addSelection (AccessibleText *obj,
 877                              long int startOffset,
 878                              long int endOffset);
 879
 880 SPIBoolean
 881 AccessibleText_removeSelection (AccessibleText *obj,
 882                                 long int selectionNum);
 883
 884 SPIBoolean
 885 AccessibleText_setSelection (AccessibleText *obj,
 886                              long int selectionNum,
 887                              long int startOffset,
 888                              long int endOffset);
 889
 890 /*
 891  *
 892  * AccessibleValue Function Prototypes:
 893  *
 894  */
 895
 896 int
 897 AccessibleValue_ref (AccessibleValue *obj);
 898
 899 int
 900 AccessibleValue_unref (AccessibleValue *obj);
 901
 902 float
 903 AccessibleValue_getMinimumValue (AccessibleValue *obj);
 904
 905 float
 906 AccessibleValue_getCurrentValue (AccessibleValue *obj);
 907
 908 float
 909 AccessibleValue_getMaximumValue (AccessibleValue *obj);
 910
 911 SPIBoolean
 912 AccessibleValue_setCurrentValue (AccessibleValue *obj,
 913                                  float newValue);
 914
 915 void
 916 SPI_freeString (char *s);
 917
 918 G_END_DECLS
 919
 920 #endif