cspi/spi.h

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2001, 2002 Sun Microsystems Inc.,
   6  * Copyright 2001, 2002 Ximian, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #ifndef _SPI_H
  25 #define _SPI_H
  26
  27 #include <cspi/spi-impl.h>
  28 /*
  29  * Definitions for AccessibleRole, AccessibleState,
  30  * and event listeners.
  31  */
  32 #include <cspi/spi-roletypes.h>
  33 #include <cspi/spi-statetypes.h>
  34 #include <cspi/spi-listener.h>
  35
  36 /*
  37  * Auxiliary typedefs and mask definitions
  38  */
  39 #include <libspi/keymasks.h>
  40
  41 #ifdef  __cplusplus
  42 extern "C" {
  43 #endif
  44
  45 /*
  46  * Enumerated type for text boundary types
  47  */
  48 typedef enum
  49 {
  50   SPI_TEXT_BOUNDARY_CHAR,
  51   SPI_TEXT_BOUNDARY_CURSOR_POS,
  52   SPI_TEXT_BOUNDARY_WORD_START,
  53   SPI_TEXT_BOUNDARY_WORD_END,
  54   SPI_TEXT_BOUNDARY_SENTENCE_START,
  55   SPI_TEXT_BOUNDARY_SENTENCE_END,
  56   SPI_TEXT_BOUNDARY_LINE_START,
  57   SPI_TEXT_BOUNDARY_LINE_END,
  58   SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE
  59 } AccessibleTextBoundaryType;
  60
  61 /*
  62  * Enumerated type for text bounds clipping types
  63  */
  64 typedef enum
  65 {
  66   SPI_TEXT_CLIP_NONE,
  67   SPI_TEXT_CLIP_MIN,
  68   SPI_TEXT_CLIP_MAX,
  69   SPI_TEXT_CLIP_BOTH
  70 } AccessibleTextClipType;
  71
  72 /*
  73  *
  74  * Enumerated type for relation types
  75  *
  76  */
  77
  78 typedef enum
  79 {
  80   SPI_RELATION_NULL,
  81   SPI_RELATION_LABEL_FOR,
  82   SPI_RELATION_LABELED_BY,
  83   SPI_RELATION_CONTROLLER_FOR,
  84   SPI_RELATION_CONTROLLED_BY,
  85   SPI_RELATION_MEMBER_OF,
  86   SPI_RELATION_NODE_CHILD_OF,
  87   SPI_RELATION_EXTENDED,
  88   SPI_RELATION_FLOWS_TO,
  89   SPI_RELATION_FLOWS_FROM,
  90   SPI_RELATION_SUBWINDOW_OF,
  91   SPI_RELATION_EMBEDS,
  92   SPI_RELATION_EMBEDDED_BY,
  93   SPI_RELATION_LAST_DEFINED
  94 } AccessibleRelationType;
  95
  96
  97 /* don't change the order of these ! */
  98 typedef enum {
  99   SPI_COORD_TYPE_SCREEN,
 100   SPI_COORD_TYPE_WINDOW
 101 } AccessibleCoordType;
 102
 103 typedef enum {
 104   SPI_KEY_PRESS,
 105   SPI_KEY_RELEASE,
 106   SPI_KEY_PRESSRELEASE,
 107   SPI_KEY_SYM,
 108   SPI_KEY_STRING
 109 } AccessibleKeySynthType;
 110
 111 typedef enum {
 112   SPI_KEYLISTENER_NOSYNC = 0,
 113   SPI_KEYLISTENER_SYNCHRONOUS = 1,
 114   SPI_KEYLISTENER_CANCONSUME = 2,
 115   SPI_KEYLISTENER_ALL_WINDOWS = 4
 116 } AccessibleKeyListenerSyncType;
 117
 118 typedef unsigned long AccessibleKeyEventMask;
 119 typedef unsigned long AccessibleDeviceEventMask;
 120
 121 /**
 122  * AccessibleComponentLayer:
 123  * @SPI_LAYER_INVALID: The layer cannot be determined or is somehow undefined.
 124  * @SPI_LAYER_BACKGROUND: Component belongs to the destop background.
 125  * @SPI_LAYER_CANVAS: Component is a canvas backdrop or drawing area.
 126  * @SPI_LAYER_WIDGET: Component is a 'normal' widget.
 127  * @SPI_LAYER_MDI: Component is drawn in the MDI layer and may have valid
 128  *                          Z-information relative to other MDI-layer components.
 129  * @SPI_LAYER_POPUP: Component is in the popup layer, above other widgets and
 130  *                          MDI components.
 131  * @SPI_LAYER_OVERLAY: Component is in the overlay plane - this value is reserved
 132  *                          for future use.
 133  * @SPI_LAYER_WINDOW: Component is in the window layer and have valid Z-information
 134  *                    relative to other window-layer components.
 135  * @SPI_LAYER_LAST_DEFINED: Used to determine the last valid value in the enum,
 136  *                          should not be encountered.
 137  **/
 138 typedef enum {
 139     SPI_LAYER_INVALID,
 140     SPI_LAYER_BACKGROUND,
 141     SPI_LAYER_CANVAS,
 142     SPI_LAYER_WIDGET,
 143     SPI_LAYER_MDI,
 144     SPI_LAYER_POPUP,
 145     SPI_LAYER_OVERLAY,
 146     SPI_LAYER_WINDOW,
 147     SPI_LAYER_LAST_DEFINED
 148 } AccessibleComponentLayer;
 149
 150
 151 /**
 152  * AccessibleTextRange:
 153  * @start: the first nominal character position within the range.
 154  * @end: the first nominal character position following the range.
 155  * @content: The actual text content between @start and @end, as a UTF-8 string.
 156  *
 157  * Structure which encapsulates a text range - must be associated with an
 158  *          AccessibleText-implementing object.
 159  **/
 160 typedef struct _AccessibleTextRange
 161 {
 162   long int        start;
 163   long int        end;
 164   char           *contents;
 165 } AccessibleTextRange;
 166
 167 /**
 168  * AccessibleKeySet:
 169  * @keysyms:
 170  * @keycodes:
 171  * @len:
 172  *
 173  * Structure containing identifying information about a set of keycode or
 174  *        keysyms.
 175  **/
 176 typedef struct _AccessibleKeySet
 177 {
 178   unsigned long  *keysyms;
 179   unsigned short *keycodes;
 180   char          **keystrings;
 181   short           len;
 182 } AccessibleKeySet;
 183
 184 /**
 185  * SPI_KEYSET_ALL_KEYS:
 186  * @SPI_KEYSET_ALL_KEYS: A special value for an AccessibleKeySet type, which tacitly
 187  *                       includes all keycodes and keyvals for the specified modifier set.
 188  **/
 189 #define SPI_KEYSET_ALL_KEYS NULL
 190
 191 typedef unsigned long AccessibleModifierMaskType;
 192 typedef AccessibleModifierMaskType AccessibleKeyMaskType;
 193
 194 /* Basic SPI initialization and event loop function prototypes */
 195
 196 int              SPI_init         (void);
 197 void             SPI_event_main   (void);
 198 void             SPI_event_quit   (void);
 199 SPIBoolean       SPI_eventIsReady (void);
 200 AccessibleEvent *SPI_nextEvent    (SPIBoolean waitForEvent);
 201 int              SPI_exit         (void);
 202
 203 /* Event Listener creation and support.  */
 204
 205 void                      SPI_freeAccessibleKeySet (
 206                                                    AccessibleKeySet         *keyset);
 207 AccessibleKeySet        * SPI_createAccessibleKeySet (
 208                                                    int                       len,
 209                                                    const char               *keysyms,
 210                                                    short                    *keycodes,
 211                                                    const char              **keystrings);
 212 AccessibleEventListener * SPI_createAccessibleEventListener (
 213                                                    AccessibleEventListenerCB callback,
 214                                                    void                     *user_data);
 215 SPIBoolean                AccessibleEventListener_addCallback (
 216                                                    AccessibleEventListener  *listener,
 217                                                    AccessibleEventListenerCB callback,
 218                                                    void                     *user_data);
 219 SPIBoolean                AccessibleEventListener_removeCallback (
 220                                                    AccessibleEventListener  *listener,
 221                                                    AccessibleEventListenerCB callback);
 222 void                      AccessibleEventListener_unref (
 223                                                    AccessibleEventListener  *listener);
 224
 225 /* Device Event Listener creation and support.  */
 226
 227 /* First four are deprecated in favor of the last four; really just a re-name */
 228
 229 AccessibleKeystrokeListener * SPI_createAccessibleKeystrokeListener (
 230                                         AccessibleKeystrokeListenerCB callback,
 231                                         void                         *user_data);
 232 SPIBoolean                    AccessibleKeystrokeListener_addCallback (
 233                                         AccessibleKeystrokeListener  *listener,
 234                                         AccessibleKeystrokeListenerCB callback,
 235                                         void                         *user_data);
 236 SPIBoolean                    AccessibleKeystrokeListener_removeCallback (
 237                                         AccessibleKeystrokeListener *listener,
 238                                         AccessibleKeystrokeListenerCB callback);
 239 void                          AccessibleKeystrokeListener_unref (
 240                                         AccessibleKeystrokeListener *listener);
 241
 242 AccessibleDeviceListener   * SPI_createAccessibleDeviceListener (
 243                                         AccessibleDeviceListenerCB callback,
 244                                         void                      *user_data);
 245 SPIBoolean                    AccessibleDeviceListener_addCallback (
 246                                         AccessibleDeviceListener  *listener,
 247                                         AccessibleDeviceListenerCB callback,
 248                                         void                      *user_data);
 249 SPIBoolean                    AccessibleDeviceListener_removeCallback (
 250                                         AccessibleDeviceListener  *listener,
 251                                         AccessibleDeviceListenerCB callback);
 252 void                          AccessibleDeviceListener_unref (
 253                                         AccessibleDeviceListener *listener);
 254
 255 /* Global functions serviced by the registry */
 256
 257 SPIBoolean SPI_registerGlobalEventListener           (
 258                                        AccessibleEventListener *listener,
 259                                        const char              *eventType);
 260 SPIBoolean SPI_deregisterGlobalEventListener         (
 261                                        AccessibleEventListener *listener,
 262                                        const char              *eventType);
 263 SPIBoolean SPI_deregisterGlobalEventListenerAll      (
 264                                        AccessibleEventListener *listener);
 265 SPIBoolean SPI_registerAccessibleKeystrokeListener   (
 266                                        AccessibleKeystrokeListener *listener,
 267                                        AccessibleKeySet             *keys,
 268                                        AccessibleKeyMaskType         modmask,
 269                                        AccessibleKeyEventMask        eventmask,
 270                                        AccessibleKeyListenerSyncType sync_type);
 271 SPIBoolean SPI_deregisterAccessibleKeystrokeListener (
 272                                        AccessibleKeystrokeListener *listener,
 273                                        AccessibleKeyMaskType        modmask);
 274
 275 SPIBoolean SPI_registerDeviceEventListener   (
 276                                        AccessibleDeviceListener   *listener,
 277                                        AccessibleDeviceEventMask   eventmask,
 278                                        void                       *filter);
 279 SPIBoolean SPI_deregisterDeviceEventListener (
 280                                        AccessibleDeviceListener   *listener,
 281                                        void                       *filter);
 282
 283 int         SPI_getDesktopCount                  (void);
 284 Accessible *SPI_getDesktop                       (int i);
 285 int         SPI_getDesktopList                   (Accessible ***desktop_list);
 286 void        SPI_freeDesktopList                  (Accessible  **desktop_list);
 287
 288 SPIBoolean  SPI_generateKeyboardEvent            (long int                    keyval,
 289                                                   char                       *keystring,
 290                                                   AccessibleKeySynthType      synth_type);
 291
 292 SPIBoolean  SPI_generateMouseEvent               (long int x, long int y, char *name);
 293
 294 /* Accessible function prototypes  */
 295
 296 void                 Accessible_ref              (Accessible *obj);
 297 void                 Accessible_unref            (Accessible *obj);
 298 char *               Accessible_getName          (Accessible *obj);
 299 char *               Accessible_getDescription   (Accessible *obj);
 300 Accessible *         Accessible_getParent        (Accessible *obj);
 301 long                 Accessible_getChildCount    (Accessible *obj);
 302 Accessible *         Accessible_getChildAtIndex  (Accessible *obj,
 303                                                   long int    childIndex);
 304 long                 Accessible_getIndexInParent (Accessible *obj);
 305 AccessibleRelation **Accessible_getRelationSet   (Accessible *obj);
 306 AccessibleRole       Accessible_getRole          (Accessible *obj);
 307 char *               Accessible_getRoleName      (Accessible *obj);
 308 AccessibleStateSet * Accessible_getStateSet      (Accessible *obj);
 309
 310 /* Interface query methods */
 311
 312 SPIBoolean Accessible_isAction            (Accessible *obj);
 313 SPIBoolean Accessible_isApplication       (Accessible *obj);
 314 SPIBoolean Accessible_isComponent         (Accessible *obj);
 315 SPIBoolean Accessible_isEditableText      (Accessible *obj);
 316 SPIBoolean Accessible_isHypertext         (Accessible *obj);
 317 SPIBoolean Accessible_isImage             (Accessible *obj);
 318 SPIBoolean Accessible_isSelection         (Accessible *obj);
 319 SPIBoolean Accessible_isStreamableContent (Accessible *obj);
 320 SPIBoolean Accessible_isTable             (Accessible *obj);
 321 SPIBoolean Accessible_isText              (Accessible *obj);
 322 SPIBoolean Accessible_isValue             (Accessible *obj);
 323
 324 AccessibleAction *            Accessible_getAction            (Accessible *obj);
 325 AccessibleApplication *       Accessible_getApplication       (Accessible *obj);
 326 AccessibleComponent *         Accessible_getComponent         (Accessible *obj);
 327 AccessibleEditableText *      Accessible_getEditableText      (Accessible *obj);
 328 AccessibleHypertext *         Accessible_getHypertext         (Accessible *obj);
 329 AccessibleImage *             Accessible_getImage             (Accessible *obj);
 330 AccessibleSelection *         Accessible_getSelection         (Accessible *obj);
 331 AccessibleStreamableContent * Accessible_getStreamableContent (Accessible *obj);
 332 AccessibleTable *             Accessible_getTable             (Accessible *obj);
 333 AccessibleText *              Accessible_getText              (Accessible *obj);
 334 AccessibleValue *             Accessible_getValue             (Accessible *obj);
 335 AccessibleUnknown *           Accessible_queryInterface       (Accessible *obj,
 336                                                    const char *interface_name);
 337
 338 /* AccessibleAction function prototypes  */
 339
 340 void       AccessibleAction_ref            (AccessibleAction *obj);
 341 void       AccessibleAction_unref          (AccessibleAction *obj);
 342 long       AccessibleAction_getNActions    (AccessibleAction *obj);
 343 char      *AccessibleAction_getName        (AccessibleAction *obj,
 344                                             long int          i);
 345 char      *AccessibleAction_getDescription (AccessibleAction *obj,
 346                                             long int          i);
 347 SPIBoolean AccessibleAction_doAction       (AccessibleAction *obj,
 348                                             long int          i);
 349 char      *AccessibleAction_getKeyBinding  (AccessibleAction *obj,
 350                                             long int          i);
 351
 352 /* AccessibleApplication function prototypes  */
 353
 354 void       AccessibleApplication_ref            (AccessibleApplication *obj);
 355 void       AccessibleApplication_unref          (AccessibleApplication *obj);
 356 char      *AccessibleApplication_getToolkitName (AccessibleApplication *obj);
 357 char      *AccessibleApplication_getVersion     (AccessibleApplication *obj);
 358 long       AccessibleApplication_getID          (AccessibleApplication *obj);
 359 SPIBoolean AccessibleApplication_pause          (AccessibleApplication *obj);
 360 SPIBoolean AccessibleApplication_resume         (AccessibleApplication *obj);
 361
 362 /* AccessibleComponent function prototypes */
 363
 364 void        AccessibleComponent_ref         (AccessibleComponent *obj);
 365 void        AccessibleComponent_unref       (AccessibleComponent *obj);
 366 SPIBoolean  AccessibleComponent_contains    (AccessibleComponent *obj,
 367                                              long int             x,
 368                                              long int             y,
 369                                              AccessibleCoordType  ctype);
 370 Accessible *AccessibleComponent_getAccessibleAtPoint (
 371                                              AccessibleComponent *obj,
 372                                              long int             x,
 373                                              long int             y,
 374                                              AccessibleCoordType  ctype);
 375 void        AccessibleComponent_getExtents  (AccessibleComponent *obj,
 376                                              long int            *x,
 377                                              long int            *y,
 378                                              long int            *width,
 379                                              long int            *height,
 380                                              AccessibleCoordType  ctype);
 381 void        AccessibleComponent_getPosition (AccessibleComponent *obj,
 382                                              long int            *x,
 383                                              long int            *y,
 384                                              AccessibleCoordType  ctype);
 385 void        AccessibleComponent_getSize     (AccessibleComponent *obj,
 386                                              long int            *width,
 387                                              long int            *height);
 388 AccessibleComponentLayer
 389             AccessibleComponent_getLayer    (AccessibleComponent *obj);
 390 SPIBoolean  AccessibleComponent_grabFocus   (AccessibleComponent *obj);
 391 short       AccessibleComponent_getMDIZOrder(AccessibleComponent *obj);
 392
 393 /* AccessibleEditableText function prototypes  */
 394
 395 void
 396 AccessibleEditableText_ref (AccessibleEditableText *obj);
 397
 398 void
 399 AccessibleEditableText_unref (AccessibleEditableText *obj);
 400
 401 SPIBoolean
 402 AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
 403                                       const char *attributes,
 404                                       long int startOffset,
 405                                       long int endOffset);
 406
 407 SPIBoolean
 408 AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
 409                                         const char *newContents);
 410
 411 SPIBoolean
 412 AccessibleEditableText_insertText (AccessibleEditableText *obj,
 413                                    long int position,
 414                                    const char *text,
 415                                    long int length);
 416
 417 SPIBoolean
 418 AccessibleEditableText_copyText (AccessibleText *obj,
 419                                  long int startPos,
 420                                  long int endPos);
 421
 422 SPIBoolean
 423 AccessibleEditableText_cutText (AccessibleEditableText *obj,
 424                                 long int startPos,
 425                                 long int endPos);
 426
 427 SPIBoolean
 428 AccessibleEditableText_deleteText (AccessibleEditableText *obj,
 429                                    long int startPos,
 430                                    long int endPos);
 431
 432 SPIBoolean
 433 AccessibleEditableText_pasteText (AccessibleEditableText *obj,
 434                                   long int position);
 435
 436 /*
 437  *
 438  * AccessibleHyperlink function prototypes
 439  *
 440  */
 441 void
 442 AccessibleHyperlink_ref (AccessibleHyperlink *obj);
 443 void
 444 AccessibleHyperlink_unref (AccessibleHyperlink *obj);
 445
 446 long
 447 AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
 448
 449 char *
 450 AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
 451                             long int i);
 452
 453 Accessible *
 454 AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
 455                                long int i);
 456
 457 void
 458 AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
 459                                    long int *startIndex,
 460                                    long int *endIndex);
 461
 462 SPIBoolean
 463 AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
 464
 465 /*
 466  *
 467  * AccessibleHypertext function prototypes
 468  *
 469  */
 470
 471 void
 472 AccessibleHypertext_ref (AccessibleHypertext *obj);
 473
 474 void
 475 AccessibleHypertext_unref (AccessibleHypertext *obj);
 476
 477 long
 478 AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
 479
 480 AccessibleHyperlink *
 481 AccessibleHypertext_getLink (AccessibleHypertext *obj,
 482                              long int linkIndex);
 483
 484 long
 485 AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
 486                                   long int characterOffset);
 487
 488 /*
 489  *
 490  * AccessibleImage function prototypes
 491  *
 492  */
 493
 494 void
 495 AccessibleImage_ref (AccessibleImage *obj);
 496
 497 void
 498 AccessibleImage_unref (AccessibleImage *obj);
 499
 500 char *
 501 AccessibleImage_getImageDescription (AccessibleImage *obj);
 502
 503 void
 504 AccessibleImage_getImageSize (AccessibleImage *obj,
 505                               long int *width,
 506                               long int *height);
 507
 508 void
 509 AccessibleImage_getImagePosition (AccessibleImage *obj,
 510                                   long int *x,
 511                                   long int *y,
 512                                   AccessibleCoordType ctype);
 513
 514 void
 515 AccessibleImage_getImageExtents (AccessibleImage *obj,
 516                                  long int *x,
 517                                  long int *y,
 518                                  long int *width,
 519                                  long int *height,
 520                                  AccessibleCoordType ctype);
 521 /*
 522  *
 523  * AccessibleRelation function prototypes
 524  *
 525  */
 526
 527 void AccessibleRelation_ref   (AccessibleRelation *obj);
 528 void AccessibleRelation_unref (AccessibleRelation *obj);
 529
 530 AccessibleRelationType
 531 AccessibleRelation_getRelationType (AccessibleRelation *obj);
 532
 533 int
 534 AccessibleRelation_getNTargets (AccessibleRelation *obj);
 535
 536 Accessible *
 537 AccessibleRelation_getTarget (AccessibleRelation *obj, int i);
 538
 539
 540 /*
 541  *
 542  * AccessibleSelection function prototypes
 543  *
 544  */
 545
 546 void AccessibleSelection_ref   (AccessibleSelection *obj);
 547 void AccessibleSelection_unref (AccessibleSelection *obj);
 548
 549 long
 550 AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj);
 551
 552 Accessible *
 553 AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
 554                                       long int selectedChildIndex);
 555
 556 SPIBoolean
 557 AccessibleSelection_selectChild (AccessibleSelection *obj,
 558                                  long int childIndex);
 559
 560 SPIBoolean
 561 AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
 562                                            long int selectedChildIndex);
 563
 564 SPIBoolean
 565 AccessibleSelection_isChildSelected (AccessibleSelection *obj,
 566                                      long int childIndex);
 567
 568 SPIBoolean
 569 AccessibleSelection_selectAll (AccessibleSelection *obj);
 570
 571 SPIBoolean
 572 AccessibleSelection_clearSelection (AccessibleSelection *obj);
 573
 574
 575 /*
 576  *
 577  * AccessibleStateSet function prototypes
 578  *
 579  */
 580
 581 void AccessibleStateSet_ref   (AccessibleStateSet *obj);
 582 void AccessibleStateSet_unref (AccessibleStateSet *obj);
 583
 584 SPIBoolean
 585 AccessibleStateSet_contains (AccessibleStateSet *obj,
 586                              AccessibleState state);
 587
 588 void
 589 AccessibleStateSet_add (AccessibleStateSet *obj,
 590                         AccessibleState state);
 591
 592 void
 593 AccessibleStateSet_remove (AccessibleStateSet *obj,
 594                            AccessibleState state);
 595
 596 SPIBoolean
 597 AccessibleStateSet_equals (AccessibleStateSet *obj,
 598                            AccessibleStateSet *obj2);
 599
 600 AccessibleStateSet *
 601 AccessibleStateSet_compare (AccessibleStateSet *obj,
 602                             AccessibleStateSet *obj2);
 603
 604 SPIBoolean
 605 AccessibleStateSet_isEmpty (AccessibleStateSet *obj);
 606
 607 void
 608 AccessibleStreamableContent_ref (AccessibleStreamableContent *obj);
 609 void
 610 AccessibleStreamableContent_unref (AccessibleStreamableContent *obj);
 611 char **
 612 AccessibleStreamableContent_getContentTypes (AccessibleStreamableContent *obj);
 613 SPIBoolean
 614 AccessibleStreamableContent_open (AccessibleStreamableContent *obj,
 615                                   const char *content_type);
 616 SPIBoolean
 617 AccessibleStreamableContent_seek (AccessibleStreamableContent *obj,
 618                                   long int offset,
 619                                   unsigned int seek_type);
 620 SPIBoolean
 621 AccessibleStreamableContent_read (AccessibleStreamableContent *obj,
 622                                   void *buff,
 623                                   long int nbytes,
 624                                   unsigned int read_type);
 625 /*
 626  *
 627  * AccessibleTable function prototypes
 628  *
 629  */
 630
 631 void AccessibleTable_ref   (AccessibleTable *obj);
 632 void AccessibleTable_unref (AccessibleTable *obj);
 633
 634 Accessible *
 635 AccessibleTable_getCaption (AccessibleTable *obj);
 636
 637 Accessible *
 638 AccessibleTable_getSummary (AccessibleTable *obj);
 639
 640 long
 641 AccessibleTable_getNRows (AccessibleTable *obj);
 642
 643 long
 644 AccessibleTable_getNColumns (AccessibleTable *obj);
 645
 646 Accessible *
 647 AccessibleTable_getAccessibleAt (AccessibleTable *obj,
 648                                  long int row,
 649                                  long int column);
 650
 651 long
 652 AccessibleTable_getIndexAt (AccessibleTable *obj,
 653                             long int row,
 654                             long int column);
 655
 656 long
 657 AccessibleTable_getRowAtIndex (AccessibleTable *obj,
 658                                long int index);
 659
 660 long
 661 AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
 662                                   long int index);
 663
 664 char *
 665 AccessibleTable_getRowDescription (AccessibleTable *obj,
 666                                    long int row);
 667
 668 char *
 669 AccessibleTable_getColumnDescription (AccessibleTable *obj,
 670                                       long int column);
 671
 672 long
 673 AccessibleTable_getRowExtentAt (AccessibleTable *obj,
 674                                 long int row,
 675                                 long int column);
 676
 677 long
 678 AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
 679                                    long int row,
 680                                    long int column);
 681
 682 Accessible *
 683 AccessibleTable_getRowHeader (AccessibleTable *obj,
 684                               long int row);
 685
 686 Accessible *
 687 AccessibleTable_getColumnHeader (AccessibleTable *obj,
 688                                  long int column);
 689
 690 long
 691 AccessibleTable_getNSelectedRows (AccessibleTable *obj);
 692
 693 long
 694 AccessibleTable_getSelectedRows (AccessibleTable *obj,
 695                                  long int **selectedRows);
 696
 697 long
 698 AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
 699
 700 long
 701 AccessibleTable_getSelectedColumns (AccessibleTable *obj,
 702                                     long int **selectedColumns);
 703
 704 SPIBoolean
 705 AccessibleTable_isRowSelected (AccessibleTable *obj,
 706                                long int row);
 707
 708 SPIBoolean
 709 AccessibleTable_isColumnSelected (AccessibleTable *obj,
 710                                   long int column);
 711
 712 SPIBoolean
 713 AccessibleTable_isSelected (AccessibleTable *obj,
 714                             long int row,
 715                             long int column);
 716
 717 /*
 718  *
 719  * AccessibleText function prototypes
 720  *
 721  */
 722
 723 void AccessibleText_ref   (AccessibleText *obj);
 724 void AccessibleText_unref (AccessibleText *obj);
 725
 726 long
 727 AccessibleText_getCharacterCount (AccessibleText *obj);
 728
 729 char *
 730 AccessibleText_getText (AccessibleText *obj,
 731                         long int startOffset,
 732                         long int endOffset);
 733
 734 long
 735 AccessibleText_getCaretOffset (AccessibleText *obj);
 736
 737 char *
 738 AccessibleText_getAttributes (AccessibleText *obj,
 739                                  long int offset,
 740                                  long int *startOffset,
 741                                  long int *endOffset);
 742
 743
 744 SPIBoolean
 745 AccessibleText_setCaretOffset (AccessibleText *obj,
 746                                long int newOffset);
 747
 748 char *
 749 AccessibleText_getTextBeforeOffset (AccessibleText *obj,
 750                                     long int offset,
 751                                     AccessibleTextBoundaryType type,
 752                                     long int *startOffset,
 753                                     long int *endOffset);
 754
 755 char *
 756 AccessibleText_getTextAtOffset (AccessibleText *obj,
 757                                 long int offset,
 758                                 AccessibleTextBoundaryType type,
 759                                 long int *startOffset,
 760                                 long int *endOffset);
 761
 762 char *
 763 AccessibleText_getTextAfterOffset (AccessibleText *obj,
 764                                    long int offset,
 765                                    AccessibleTextBoundaryType type,
 766                                    long int *startOffset,
 767                                    long int *endOffset);
 768
 769 unsigned long
 770 AccessibleText_getCharacterAtOffset (AccessibleText *obj,
 771                                      long int offset);
 772
 773 void
 774 AccessibleText_getCharacterExtents (AccessibleText *obj,
 775                                     long int offset,
 776                                     long int *x,
 777                                     long int *y,
 778                                     long int *width,
 779                                     long int *height,
 780                                     AccessibleCoordType type);
 781
 782 void
 783 AccessibleText_getRangeExtents (AccessibleText *obj,
 784                                 long int startOffset,
 785                                 long int endOffset,
 786                                 long int *x,
 787                                 long int *y,
 788                                 long int *width,
 789                                 long int *height,
 790                                 AccessibleCoordType type);
 791
 792 AccessibleTextRange **
 793 AccessibleText_getBoundedRanges (AccessibleText *obj,
 794                                  long int x,
 795                                  long int y,
 796                                  long int width,
 797                                  long int height,
 798                                  AccessibleCoordType type,
 799                                  AccessibleTextClipType clipTypeX,
 800                                  AccessibleTextClipType clipTypeY);
 801
 802 void
 803 AccessibleTextRange_freeRanges (AccessibleTextRange **ranges);
 804
 805 long
 806 AccessibleText_getOffsetAtPoint (AccessibleText *obj,
 807                                  long int x,
 808                                  long int y,
 809                                  AccessibleCoordType type);
 810
 811 long
 812 AccessibleText_getNSelections (AccessibleText *obj);
 813
 814 void
 815 AccessibleText_getSelection (AccessibleText *obj,
 816                              long int selectionNum,
 817                              long int *startOffset,
 818                              long int *endOffset);
 819
 820
 821 SPIBoolean
 822 AccessibleText_addSelection (AccessibleText *obj,
 823                              long int startOffset,
 824                              long int endOffset);
 825
 826 SPIBoolean
 827 AccessibleText_removeSelection (AccessibleText *obj,
 828                                 long int selectionNum);
 829
 830 SPIBoolean
 831 AccessibleText_setSelection (AccessibleText *obj,
 832                              long int selectionNum,
 833                              long int startOffset,
 834                              long int endOffset);
 835
 836 /* AccessibleValue Function Prototypes:  */
 837
 838 void       AccessibleValue_ref             (AccessibleValue *obj);
 839 void       AccessibleValue_unref           (AccessibleValue *obj);
 840 double     AccessibleValue_getMinimumValue (AccessibleValue *obj);
 841 double     AccessibleValue_getCurrentValue (AccessibleValue *obj);
 842 double     AccessibleValue_getMaximumValue (AccessibleValue *obj);
 843 SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj,
 844                                             double           newValue);
 845
 846 /* Persistance and lifecycle control for AccessibleEvents. */
 847 SPIBoolean AccessibleEvent_ref (const AccessibleEvent *e);
 848 void AccessibleEvent_unref (const AccessibleEvent *e);
 849
 850 /*
 851  * Prototypes for accessor functions, to obtain context
 852  * information for accessible events.
 853  */
 854
 855 char*        AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e);
 856 Accessible * AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e);
 857
 858 Accessible * AccessibleParentChangedEvent_getParentAccessible (const AccessibleEvent *e);
 859
 860 char*        AccessibleTextSelectionChangedEvent_getSelectionString (const AccessibleEvent *e);
 861
 862 char*        AccessibleWindowEvent_getTitleString (const AccessibleEvent *e);
 863
 864 Accessible * AccessibleActiveDescendantChangedEvent_getActiveDescendant (const AccessibleEvent *e);
 865
 866 Accessible * AccessibleTableSummaryChangedEvent_getSummaryAccessible (const AccessibleEvent *e);
 867
 868 Accessible * AccessibleTableHeaderChangedEvent_getHeaderAccessible (const AccessibleEvent *e);
 869
 870 char *       AccessibleTableCaptionChangedEvent_getCaptionString (const AccessibleEvent *e);
 871
 872 char *       AccessibleTableRowDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
 873
 874 char *       AccessibleTableColumnDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
 875
 876 char *       AccessibleDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
 877
 878 char *       AccessibleNameChangedEvent_getNameString (const AccessibleEvent *e);
 879
 880 /* Misc methods */
 881 void SPI_freeString (char *s);
 882
 883 #ifdef  __cplusplus
 884 }
 885 #endif
 886
 887 #endif