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