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  *AccessibleCollectionMatchType:
  47  *
  48  *@SPI_COLLECTION_MATCH_INVALID
  49  *@SPI_COLLECTION_MATCH_ALL     TRUE if all of the criteria are met
  50  *@SPI_COLLECTION_MATCH_ANY     TRUE if any of the criteria are met
  51  *@SPI_COLLECTION_MATCH_NONE    TRUE if none of the criteria are met
  52  *@SPI_COLLECTION_MATCH_EMPTY   Same as MATCH_ALL if the criteria is non-empty;
  53  * for empty criteria this rule requires returned value to also have empty set.
  54  *@SPI_COLLECTION_MATCH_LAST_DEFINED
  55  *
  56  **/
  57 typedef enum
  58 {
  59      SPI_COLLECTION_MATCH_INVALID,
  60      SPI_COLLECTION_MATCH_ALL,
  61      SPI_COLLECTION_MATCH_ANY,
  62      SPI_COLLECTION_MATCH_NONE,
  63      SPI_COLLECTION_MATCH_EMPTY,
  64      SPI_COLLECTION_MATCH_LAST_DEFINED
  65 }AccessibleCollectionMatchType;
  66
  67
  68 /**
  69  *AccessibleTextBoundaryType:
  70  *@SPI_TEXT_BOUNDARY_CHAR: Delimiter is the current character's bounds.
  71  *@SPI_TEXT_BOUNDARY_CURSOR_POS: Delimiter is the current text caret position.
  72  *@SPI_TEXT_BOUNDARY_WORD_START: Bounds run from the first character of a word to the first
  73  * character of the following word (i.e. including trailing whitespace, if any) within the text object.
  74  *@SPI_TEXT_BOUNDARY_WORD_END: Bounds run from the last character of a word to the last
  75  * character of the following word (i.e. including leading whitespace) within the text object.
  76  *@SPI_TEXT_BOUNDARY_SENTENCE_START: Bounds run from the first character of a sentence to the first
  77  * character of the next sentence in the text object.
  78  *@SPI_TEXT_BOUNDARY_SENTENCE_END: Bounds run from the last character of a sentence to the last
  79  * character of the next sentence in the text object.
  80  *@SPI_TEXT_BOUNDARY_LINE_START: Bounds span one line of text, with the line delimiter at the end of the
  81  * bounds, if present, within the current text object.
  82  *@SPI_TEXT_BOUNDARY_LINE_END: Bounds span one line of text, including a preceding line delimiter
  83  * if present within the current text object.
  84  *@SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE: Bounds span the run, relative to the specified offset and
  85  * text accessor API rules, over which the attributes of the text object are invariant.
  86  *
  87  *Text boundary types used for specifying boundaries for regions of text.
  88  **/
  89 typedef enum
  90 {
  91   SPI_TEXT_BOUNDARY_CHAR,
  92   SPI_TEXT_BOUNDARY_CURSOR_POS,
  93   SPI_TEXT_BOUNDARY_WORD_START,
  94   SPI_TEXT_BOUNDARY_WORD_END,
  95   SPI_TEXT_BOUNDARY_SENTENCE_START,
  96   SPI_TEXT_BOUNDARY_SENTENCE_END,
  97   SPI_TEXT_BOUNDARY_LINE_START,
  98   SPI_TEXT_BOUNDARY_LINE_END,
  99   SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE
 100 } AccessibleTextBoundaryType;
 101
 102 /**
 103  *AccessibleTextClipType
 104  *@SPI_TEXT_CLIP_NONE: No clipping to be done
 105  *@SPI_TEXT_CLIP_MIN: Text clipped by min coordinate is omitted
 106  *@SPI_TEXT_CLIP_MAX: Text clipped by max coordinate is omitted
 107  *@SPI_TEXT_CLIP_BOTH: Only text fully within mix/max bound is retained
 108  *
 109  *Describes the type of clipping required.
 110  **/
 111 typedef enum
 112 {
 113   SPI_TEXT_CLIP_NONE,
 114   SPI_TEXT_CLIP_MIN,
 115   SPI_TEXT_CLIP_MAX,
 116   SPI_TEXT_CLIP_BOTH
 117 } AccessibleTextClipType;
 118
 119 /**
 120  *AccessibleRelationType:
 121  *@SPI_RELATION_NULL: Not used, this is an invalid value for this enumeration.
 122  *@SPI_RELATION_LABEL_FOR: Indicates an object is a label for one or more target objects.
 123  *@SPI_RELATION_LABELED_BY: Indicates an object is labelled by one or more target objects.
 124  *@SPI_RELATION_CONTROLLED_BY: Indicates an object controlled by one or more target objects.
 125  *@SPI_RELATION_CONTROLLER_FOR: Indicates an object is an controller for one or more target objects.
 126  *@SPI_RELATION_MEMBER_OF: Indicates an object is a member of a group of one or
 127 more target objects.
 128  *@SPI_RELATION_NODE_CHILD_OF: Indicates an object is a cell in a treetable which is displayed because a cell in the same column is expanded and identifies that cell.
 129  *@SPI_RELATION_EXTENDED: This value indicates that a relation other than those pre-specified by this version of AT-SPI
 130  * is present.
 131  *@SPI_RELATION_FLOWS_TO: Indicates that the object has content that flows logically to another
 132  *  AtkObject in a sequential way, (for instance text-flow).
 133  *@SPI_RELATION_FLOWS_FROM: Indicates that the object has content that flows logically from
 134  *  another AtkObject in a sequential way, (for instance text-flow).
 135  *@SPI_RELATION_SUBWINDOW_OF: Indicates a subwindow attached to a component but otherwise has no connection in the UI heirarchy to that component.
 136  *@SPI_RELATION_EMBEDS: Indicates that the object visually embeds
 137  *  another object's content, i.e. this object's content flows around
 138  *  another's content.
 139  *@SPI_RELATION_EMBEDDED_BY: Inverse of %SPI_RELATION_EMBEDS, indicates that
 140  *  this object's content is visualy embedded in another object.
 141  *@SPI_RELATION_POPUP_FOR: Indicates that an object is a popup for another object.
 142  *@SPI_RELATION_PARENT_WINDOW_OF: Indicates that an object is a parent window of another object.
 143  *@SPI_RELATION_DESCRIBED_BY: Indicates that another object provides descriptive information about this object; more verbose than %SPI_RELATION_LABELLED_BY.
 144  *@SPI_RELATION_DESCRIPTION_FOR: Indicates that an object provides descriptive information about another object; more verbose than %SPI_RELATION_LABEL_FOR.
 145  *@SPI_RELATION_LAST_DEFINED: Do not use, this is an implementation detail used
 146  *  to identify the size of this enumeration.
 147  *
 148  *Describes the type of the relation
 149  **/
 150 typedef enum
 151 {
 152   SPI_RELATION_NULL,
 153   SPI_RELATION_LABEL_FOR,
 154   SPI_RELATION_LABELED_BY,
 155   SPI_RELATION_CONTROLLER_FOR,
 156   SPI_RELATION_CONTROLLED_BY,
 157   SPI_RELATION_MEMBER_OF,
 158   SPI_RELATION_NODE_CHILD_OF,
 159   SPI_RELATION_EXTENDED,
 160   SPI_RELATION_FLOWS_TO,
 161   SPI_RELATION_FLOWS_FROM,
 162   SPI_RELATION_SUBWINDOW_OF,
 163   SPI_RELATION_EMBEDS,
 164   SPI_RELATION_EMBEDDED_BY,
 165   SPI_RELATION_POPUP_FOR,
 166   SPI_RELATION_PARENT_WINDOW_OF,
 167   SPI_RELATION_DESCRIPTION_FOR,
 168   SPI_RELATION_DESCRIBED_BY,
 169   SPI_RELATION_LAST_DEFINED
 170 } AccessibleRelationType;
 171
 172
 173 /* don't change the order of these ! */
 174 /**
 175  *AccessibleCoordType:
 176  *@SPI_COORD_TYPE_SCREEN: specifies xy coordinates relative to the screen
 177  *@SPI_COORD_TYPE_WINDOW: specifies xy coordinates relative to an object's
 178  * top-level window
 179  *
 180  *Specifies how xy coordinates are to be interpreted. Used by functions such
 181  *as AccessibleComponent_getPosition() and AccessibleText_getCharacterExtents()
 182  **/
 183 typedef enum {
 184   SPI_COORD_TYPE_SCREEN,
 185   SPI_COORD_TYPE_WINDOW
 186 } AccessibleCoordType;
 187
 188 /**
 189  *AccessibleKeySynthType:
 190  *@SPI_KEY_PRESS: Generates a keypress event (requires a subsequent #SPI_KEY_RELEASE event)
 191  *@SPI_KEY_RELEASE: Generates a key-release event
 192  *@SPI_KEY_PRESSRELEASE: Generates a key press/release event pair.
 193  *@SPI_KEY_SYM: Injects a "keysym" event into the stream, as if a press/release pair occurred; allows
 194  * the user to specify the key via its symbolic name, as opposed to simulating a hardware press of a
 195  * specific key.
 196  *@SPI_KEY_STRING: Injects one or more keysym events into the keyboard buffer, or directly inserts
 197  * a string value into the currently focussed text widget, if the widgets supports this.
 198  * #SPI_KEY_STRING synthesis provides a shortcut for text substring insertion, and also allows the
 199  * insertion of text which is not currently available via the current keyboard's keymap.
 200  *
 201  * Specifies the type of a generated event.
 202  **/
 203 typedef enum {
 204   SPI_KEY_PRESS,
 205   SPI_KEY_RELEASE,
 206   SPI_KEY_PRESSRELEASE,
 207   SPI_KEY_SYM,
 208   SPI_KEY_STRING
 209 } AccessibleKeySynthType;
 210
 211 /**
 212  *AccessibleKeyListenerSyncType:
 213  *@SPI_KEYLISTENER_NOSYNC: Events may be delivered asynchronously,
 214  * which means in some cases they may already have been delivered to the
 215  * application before the AT client receives the notification.
 216  *@SPI_KEYLISTENER_SYNCHRONOUS: Events are delivered synchronously, before the
 217  * currently focussed application sees them.
 218  *@SPI_KEYLISTENER_CANCONSUME: Events may be consumed by the AT client.  Presumes and
 219  * requires #SPI_KEYLISTENER_SYNCHRONOUS, incompatible with #SPI_KEYLISTENER_NOSYNC.
 220  *@SPI_KEYLISTENER_ALL_WINDOWS: Events are received not from the application toolkit layer, but
 221  * from the device driver or windowing system subsystem; such notifications are 'global' in the
 222  * sense that they are not broken or defeated by applications that participate poorly
 223  * in the accessibility APIs, or not at all; however because of the intrusive nature of
 224  * such snooping, it can have side-effects on certain older platforms.  If unconditional
 225  * event notifications, even when inaccessible or "broken" applications have focus, are not
 226  * required, it may be best to avoid this enum value/flag.
 227  *
 228  *Specified the tyupe of a key listener event.
 229  * Certain of the values above can and should be bitwise-'OR'ed
 230  * together, observing the compatibility limitations specified in the description of
 231  * each value.  For instance, #SPI_KEYLISTENER_ALL_WINDOWS | #SPI_KEYLISTENER_CANCONSUME is
 232  * a commonly used combination which gives the AT complete control over the delivery of matching
 233  * events.  However, such filters should be used sparingly as they may have a negative impact on
 234  * system performance.
 235  **/
 236 typedef enum {
 237   SPI_KEYLISTENER_NOSYNC = 0,
 238   SPI_KEYLISTENER_SYNCHRONOUS = 1,
 239   SPI_KEYLISTENER_CANCONSUME = 2,
 240   SPI_KEYLISTENER_ALL_WINDOWS = 4
 241 } AccessibleKeyListenerSyncType;
 242
 243
 244 /**
 245  *AccessibleStreamableContentSeekType
 246  *@SPI_STREAM_SEEK_SET: seek from the 'top' of the streamable
 247  *@SPI_STREAM_SEEK_CUR: seek from the current position in the stream
 248  *@SPI_STREAM_SEEK_END: seek from the end of the stream (if known)
 249  *
 250  *The seek type for a specified offset in AccessibleStreamableContent_seek.
 251  **/
 252 typedef enum
 253 {
 254   SPI_STREAM_SEEK_SET,
 255   SPI_STREAM_SEEK_CUR,
 256   SPI_STREAM_SEEK_END
 257 } AccessibleStreamableContentSeekType;
 258
 259 /**
 260  * SPIException:
 261  * @type: private
 262  * @source: private
 263  * @ev: private
 264  * @code: private
 265  * @desc: private
 266  *
 267  * An opaque object encapsulating information about thrown exceptions.
 268  **/
 269 typedef struct _SPIException SPIException;
 270
 271 /**
 272  * SPIExceptionHandler:
 273  * @err: points to the SPIException opaque object.
 274  * @is_fatal: indicates whether the exception is a fatal error or not.
 275  *
 276  * A function type for functions to be called when exceptions occur.
 277  *
 278  * Returns
 279  **/
 280 typedef SPIBoolean (*SPIExceptionHandler) (SPIException *err, SPIBoolean is_fatal);
 281
 282 /**
 283  * SPIExceptionCode:
 284  * @SPI_EXCEPTION_UNSPECIFIED: An exception of unknown type, or which doesn't fit the other types.
 285  * @SPI_EXCEPTION_DISCONNECT: Communication with the object or service has been disconnected;
 286  * this usually means that the object or service has died or exited.
 287  * @SPI_EXCEPTION_NO_IMPL: The object or service is missing the implementation for a request.
 288  * @SPI_EXCEPTION_IO: The communications channel has become corrupted, blocked, or is otherwise in a bad state.
 289  * @SPI_EXCEPTION_BAD_DATA: The data received or sent over the interface has been identified as
 290  * improperly formatted or otherwise fails to match the expectations.
 291  *
 292  * Exception codes indicating what's gone wrong in an AT-SPI call.
 293  **/
 294 typedef enum {
 295         SPI_EXCEPTION_UNSPECIFIED,
 296         SPI_EXCEPTION_DISCONNECT,
 297         SPI_EXCEPTION_NO_IMPL,
 298         SPI_EXCEPTION_IO,
 299         SPI_EXCEPTION_BAD_DATA
 300 } SPIExceptionCode;
 301
 302 /**
 303  * SPIExceptionType:
 304  * @SPI_EXCEPTION_SOURCE_UNSPECIFIED: Don't know or can't tell where the problem is
 305  * @SPI_EXCEPTION_SOURCE_ACCESSIBLE: The source of an event or query (i.e. an app) has thrown the exception.
 306  * @SPI_EXCEPTION_SOURCE_REGISTRY: The AT-SPI registry has thrown the exception or cannot be reached.
 307  * @SPI_EXCEPTION_SOURCE_DEVICE: The device event subsystem has encountered an error condition.
 308  *
 309  * The general source of the failure, i.e. whether the app, registry, or device system has encountered trouble.
 310  **/
 311 typedef enum {
 312         SPI_EXCEPTION_SOURCE_UNSPECIFIED,
 313         SPI_EXCEPTION_SOURCE_ACCESSIBLE,
 314         SPI_EXCEPTION_SOURCE_REGISTRY,
 315         SPI_EXCEPTION_SOURCE_DEVICE
 316 } SPIExceptionType;
 317
 318 typedef unsigned long AccessibleKeyEventMask;
 319 typedef unsigned long AccessibleDeviceEventMask;
 320 /**
 321  * SPIRect:
 322  * @x: The position of the minimum x value of the rectangle (i.e. left hand corner)
 323  * @y: The position of the minimum y value of the rectangle's bounds.
 324  * @width: Width of the rectangle in pixels.
 325  * @height: Height of the rectangle in pixels.
 326  *
 327  * A structure encapsulating a rectangle.
 328  **/
 329 typedef struct {
 330         long x;
 331         long y;
 332         long width;
 333         long height;
 334 } SPIRect;
 335
 336 /**
 337  *AccessibleComponentLayer:
 338  *@SPI_LAYER_INVALID: The layer cannot be determined or is somehow undefined.
 339  *@SPI_LAYER_BACKGROUND: Component belongs to the destop background.
 340  *@SPI_LAYER_CANVAS: Component is a canvas backdrop or drawing area.
 341  *@SPI_LAYER_WIDGET: Component is a 'normal' widget.
 342  *@SPI_LAYER_MDI: Component is drawn in the MDI layer and may have valid
 343  *                         Z-information relative to other MDI-layer components.
 344  *@SPI_LAYER_POPUP: Component is in the popup layer, above other widgets and
 345  *                         MDI components.
 346  *@SPI_LAYER_OVERLAY: Component is in the overlay plane - this value is reserved
 347  *                         for future use.
 348  *@SPI_LAYER_WINDOW: Component is in the window layer and have valid Z-information
 349  *                   relative to other window-layer components.
 350  *@SPI_LAYER_LAST_DEFINED: Used to determine the last valid value in the enum,
 351  *                         should not be encountered.
 352  *
 353  * Describes the layer of a component.
 354  *
 355  * These enumerated "layer values" are used when determining which UI
 356  * rendering layer a component is drawn into, which can help in making
 357  * determinations of when components occlude one another.
 358  **/
 359 typedef enum {
 360     SPI_LAYER_INVALID,
 361     SPI_LAYER_BACKGROUND,
 362     SPI_LAYER_CANVAS,
 363     SPI_LAYER_WIDGET,
 364     SPI_LAYER_MDI,
 365     SPI_LAYER_POPUP,
 366     SPI_LAYER_OVERLAY,
 367     SPI_LAYER_WINDOW,
 368     SPI_LAYER_LAST_DEFINED
 369 } AccessibleComponentLayer;
 370
 371
 372 /**
 373  * AccessibleTextRange:
 374  * @start: the first nominal character position within the range.
 375  * @end: the first nominal character position following the range.
 376  * @content: The actual text content between @start and @end, as a UTF-8 string.
 377  *
 378  * Structure which encapsulates a text range - must be associated with an
 379  *          AccessibleText-implementing object.
 380  **/
 381 typedef struct _AccessibleTextRange
 382 {
 383   long int        start;
 384   long int        end;
 385   char           *contents;
 386 } AccessibleTextRange;
 387
 388 /**
 389  * AccessibleKeySet:
 390  * @keysyms:
 391  * @keycodes:
 392  * @len:
 393  *
 394  * Structure containing identifying information about a set of keycode or
 395  *        keysyms.
 396  **/
 397 typedef struct _AccessibleKeySet
 398 {
 399   unsigned long  *keysyms;
 400   unsigned short *keycodes;
 401   char          **keystrings;
 402   short           len;
 403 } AccessibleKeySet;
 404
 405 /*
 406  * A special value for an AccessibleKeySet type, which tacitly
 407  * includes all keycodes and keyvals for the specified modifier set.
 408  */
 409 #define SPI_KEYSET_ALL_KEYS NULL
 410
 411 typedef unsigned long AccessibleModifierMaskType;
 412 /**
 413  *AccessibleKeyMaskType:
 414  *
 415  *AccessibleKeyMaskType is a mask which is a set of key event modifiers
 416  *which is specified in SPI_registerAccessibleKeystrokeListener.
 417  **/
 418
 419 typedef AccessibleModifierMaskType AccessibleKeyMaskType;
 420
 421 typedef struct _AccessibleAttributeSet
 422 {
 423     int len;
 424     char **attributes;
 425 } AccessibleAttributeSet;
 426
 427 typedef struct _AccessibleRoleSet
 428 {
 429      int len;
 430      AccessibleRole *roles;
 431 } AccessibleRoleSet;
 432
 433
 434
 435 /* Basic SPI initialization and event loop function prototypes */
 436
 437 int              SPI_init         (void);
 438 void             SPI_event_main   (void);
 439 void             SPI_event_quit   (void);
 440 SPIBoolean       SPI_eventIsReady (void);
 441 AccessibleEvent *SPI_nextEvent    (SPIBoolean waitForEvent);
 442 int              SPI_exit         (void);
 443
 444 /* Event Listener creation and support.  */
 445
 446 void                      SPI_freeAccessibleKeySet (
 447                                                    AccessibleKeySet         *keyset);
 448 AccessibleKeySet        * SPI_createAccessibleKeySet (
 449                                                    int                       len,
 450                                                    const char               *keysyms,
 451                                                    short                    *keycodes,
 452                                                    const char              **keystrings);
 453 AccessibleEventListener * SPI_createAccessibleEventListener (
 454                                                    AccessibleEventListenerCB callback,
 455                                                    void                     *user_data);
 456 SPIBoolean                AccessibleEventListener_addCallback (
 457                                                    AccessibleEventListener  *listener,
 458                                                    AccessibleEventListenerCB callback,
 459                                                    void                     *user_data);
 460 SPIBoolean                AccessibleEventListener_removeCallback (
 461                                                    AccessibleEventListener  *listener,
 462                                                    AccessibleEventListenerCB callback);
 463 void                      AccessibleEventListener_unref (
 464                                                    AccessibleEventListener  *listener);
 465
 466 /* Device Event Listener creation and support.  */
 467
 468 /* First four are deprecated in favor of the last four; really just a re-name */
 469
 470 AccessibleKeystrokeListener * SPI_createAccessibleKeystrokeListener (
 471                                         AccessibleKeystrokeListenerCB callback,
 472                                         void                         *user_data);
 473 SPIBoolean                    AccessibleKeystrokeListener_addCallback (
 474                                         AccessibleKeystrokeListener  *listener,
 475                                         AccessibleKeystrokeListenerCB callback,
 476                                         void                         *user_data);
 477 SPIBoolean                    AccessibleKeystrokeListener_removeCallback (
 478                                         AccessibleKeystrokeListener *listener,
 479                                         AccessibleKeystrokeListenerCB callback);
 480 void                          AccessibleKeystrokeListener_unref (
 481                                         AccessibleKeystrokeListener *listener);
 482
 483 AccessibleDeviceListener   * SPI_createAccessibleDeviceListener (
 484                                         AccessibleDeviceListenerCB callback,
 485                                         void                      *user_data);
 486 SPIBoolean                    AccessibleDeviceListener_addCallback (
 487                                         AccessibleDeviceListener  *listener,
 488                                         AccessibleDeviceListenerCB callback,
 489                                         void                      *user_data);
 490 SPIBoolean                    AccessibleDeviceListener_removeCallback (
 491                                         AccessibleDeviceListener  *listener,
 492                                         AccessibleDeviceListenerCB callback);
 493 void                          AccessibleDeviceListener_unref (
 494                                         AccessibleDeviceListener *listener);
 495
 496 /* Global functions serviced by the registry */
 497
 498 SPIBoolean SPI_registerGlobalEventListener           (
 499                                        AccessibleEventListener *listener,
 500                                        const char              *eventType);
 501 SPIBoolean SPI_deregisterGlobalEventListener         (
 502                                        AccessibleEventListener *listener,
 503                                        const char              *eventType);
 504 SPIBoolean SPI_deregisterGlobalEventListenerAll      (
 505                                        AccessibleEventListener *listener);
 506 SPIBoolean SPI_registerAccessibleKeystrokeListener   (
 507                                        AccessibleKeystrokeListener *listener,
 508                                        AccessibleKeySet             *keys,
 509                                        AccessibleKeyMaskType         modmask,
 510                                        AccessibleKeyEventMask        eventmask,
 511                                        AccessibleKeyListenerSyncType sync_type);
 512 SPIBoolean SPI_deregisterAccessibleKeystrokeListener (
 513                                        AccessibleKeystrokeListener *listener,
 514                                        AccessibleKeyMaskType        modmask);
 515
 516 SPIBoolean SPI_registerDeviceEventListener   (
 517                                        AccessibleDeviceListener   *listener,
 518                                        AccessibleDeviceEventMask   eventmask,
 519                                        void                       *filter);
 520 SPIBoolean SPI_deregisterDeviceEventListener (
 521                                        AccessibleDeviceListener   *listener,
 522                                        void                       *filter);
 523
 524 int         SPI_getDesktopCount                  (void);
 525 Accessible *SPI_getDesktop                       (int i);
 526 int         SPI_getDesktopList                   (Accessible ***desktop_list);
 527 void        SPI_freeDesktopList                  (Accessible  **desktop_list);
 528
 529 SPIBoolean  SPI_generateKeyboardEvent            (long int                    keyval,
 530                                                   char                       *keystring,
 531                                                   AccessibleKeySynthType      synth_type);
 532
 533 SPIBoolean  SPI_generateMouseEvent               (long int x, long int y, char *name);
 534
 535 /* Accessible function prototypes  */
 536
 537 void                 Accessible_ref              (Accessible *obj);
 538 void                 Accessible_unref            (Accessible *obj);
 539 char *               Accessible_getName          (Accessible *obj);
 540 char *               Accessible_getDescription   (Accessible *obj);
 541 Accessible *         Accessible_getParent        (Accessible *obj);
 542 long                 Accessible_getChildCount    (Accessible *obj);
 543 Accessible *         Accessible_getChildAtIndex  (Accessible *obj,
 544                                                   long int    childIndex);
 545 long                 Accessible_getIndexInParent (Accessible *obj);
 546 AccessibleRelation **Accessible_getRelationSet   (Accessible *obj);
 547 AccessibleRole       Accessible_getRole          (Accessible *obj);
 548 char *               Accessible_getRoleName      (Accessible *obj);
 549 char *               Accessible_getLocalizedRoleName (Accessible *obj);
 550 AccessibleStateSet * Accessible_getStateSet      (Accessible *obj);
 551 AccessibleAttributeSet *Accessible_getAttributes (Accessible *obj);
 552 AccessibleApplication *Accessible_getHostApplication (Accessible *obj);
 553
 554 /* Interface query methods */
 555
 556 SPIBoolean Accessible_isAction            (Accessible *obj);
 557 SPIBoolean Accessible_isApplication       (Accessible *obj);
 558 SPIBoolean Accessible_isCollection        (Accessible *obj);
 559 SPIBoolean Accessible_isComponent         (Accessible *obj);
 560 SPIBoolean Accessible_isDocument          (Accessible *obj);
 561 SPIBoolean Accessible_isEditableText      (Accessible *obj);
 562 SPIBoolean Accessible_isHypertext         (Accessible *obj);
 563 SPIBoolean Accessible_isImage             (Accessible *obj);
 564 SPIBoolean Accessible_isMatchRule         (Accessible *obj);
 565 SPIBoolean Accessible_isSelection         (Accessible *obj);
 566 SPIBoolean Accessible_isStreamableContent (Accessible *obj);
 567 SPIBoolean Accessible_isTable             (Accessible *obj);
 568 SPIBoolean Accessible_isText              (Accessible *obj);
 569 SPIBoolean Accessible_isValue             (Accessible *obj);
 570
 571 AccessibleAction *            Accessible_getAction            (Accessible *obj);
 572 AccessibleApplication *       Accessible_getApplication       (Accessible *obj);
 573 AccessibleCollection *        Accessible_getCollection        (Accessible *obj);
 574 AccessibleComponent *         Accessible_getComponent         (Accessible *obj);
 575 AccessibleDocument *          Accessible_getDocument          (Accessible *obj);
 576 AccessibleEditableText *      Accessible_getEditableText      (Accessible *obj);
 577 AccessibleHypertext *         Accessible_getHypertext         (Accessible *obj);
 578 AccessibleImage *             Accessible_getImage             (Accessible *obj);
 579 AccessibleMatchRule *         Accessible_getMatchRule         (Accessible *obj);
 580 AccessibleSelection *         Accessible_getSelection         (Accessible *obj);
 581 AccessibleStreamableContent * Accessible_getStreamableContent (Accessible *obj);
 582 AccessibleTable *             Accessible_getTable             (Accessible *obj);
 583 AccessibleText *              Accessible_getText              (Accessible *obj);
 584 AccessibleValue *             Accessible_getValue             (Accessible *obj);
 585 AccessibleUnknown *           Accessible_queryInterface       (Accessible *obj,
 586                                                    const char *interface_name);
 587
 588 /* AccessibleAction function prototypes  */
 589
 590 void       AccessibleAction_ref            (AccessibleAction *obj);
 591 void       AccessibleAction_unref          (AccessibleAction *obj);
 592 long       AccessibleAction_getNActions    (AccessibleAction *obj);
 593 char      *AccessibleAction_getName        (AccessibleAction *obj,
 594                                             long int          i);
 595 char      *AccessibleAction_getDescription (AccessibleAction *obj,
 596                                             long int          i);
 597 SPIBoolean AccessibleAction_doAction       (AccessibleAction *obj,
 598                                             long int          i);
 599 char      *AccessibleAction_getKeyBinding  (AccessibleAction *obj,
 600                                             long int          i);
 601
 602 /* AccessibleApplication function prototypes  */
 603
 604 void       AccessibleApplication_ref            (AccessibleApplication *obj);
 605 void       AccessibleApplication_unref          (AccessibleApplication *obj);
 606 char      *AccessibleApplication_getToolkitName (AccessibleApplication *obj);
 607 char      *AccessibleApplication_getVersion     (AccessibleApplication *obj);
 608 long       AccessibleApplication_getID          (AccessibleApplication *obj);
 609 char      *AccessibleApplication_getLocale      (AccessibleApplication *obj, int lc_category);
 610 SPIBoolean AccessibleApplication_pause          (AccessibleApplication *obj);
 611 SPIBoolean AccessibleApplication_resume         (AccessibleApplication *obj);
 612
 613 /* AccessibleCollection function prototypes */
 614 void       AccessibleCollection_ref (AccessibleCollection *obj);
 615 void       AccessibleCollection_unref (AccessibleCollection *obj);
 616 AccessibleMatchRule *
 617 AccessibleCollection_createMatchRule (AccessibleCollection *obj,
 618                                       AccessibleStateSet *states,
 619                                       AccessibleCollectionMatchType statematchtype,
 620                                       AccessibleAttributeSet *attributes,
 621                                       AccessibleCollectionMatchType attributematchtype,
 622                                       AccessibleRoleSet *roles,
 623                                       AccessibleCollectionMatchType rolematchtype,
 624                                       char *interfaces,
 625                                       AccessibleCollectionMatchType interfacematchtype,
 626                                       long int invert);
 627 void
 628 AccessibleCollection_freeMatchRule (AccessibleCollection *obj,
 629                                     AccessibleMatchRule  *matchrule);
 630 /* AccessibleComponent function prototypes */
 631
 632 void        AccessibleComponent_ref         (AccessibleComponent *obj);
 633 void        AccessibleComponent_unref       (AccessibleComponent *obj);
 634 SPIBoolean  AccessibleComponent_contains    (AccessibleComponent *obj,
 635                                              long int             x,
 636                                              long int             y,
 637                                              AccessibleCoordType  ctype);
 638 Accessible *AccessibleComponent_getAccessibleAtPoint (
 639                                              AccessibleComponent *obj,
 640                                              long int             x,
 641                                              long int             y,
 642                                              AccessibleCoordType  ctype);
 643 void        AccessibleComponent_getExtents  (AccessibleComponent *obj,
 644                                              long int            *x,
 645                                              long int            *y,
 646                                              long int            *width,
 647                                              long int            *height,
 648                                              AccessibleCoordType  ctype);
 649 void        AccessibleComponent_getPosition (AccessibleComponent *obj,
 650                                              long int            *x,
 651                                              long int            *y,
 652                                              AccessibleCoordType  ctype);
 653 void        AccessibleComponent_getSize     (AccessibleComponent *obj,
 654                                              long int            *width,
 655                                              long int            *height);
 656 AccessibleComponentLayer
 657             AccessibleComponent_getLayer    (AccessibleComponent *obj);
 658 SPIBoolean  AccessibleComponent_grabFocus   (AccessibleComponent *obj);
 659 short       AccessibleComponent_getMDIZOrder(AccessibleComponent *obj);
 660 double      AccessibleComponent_getAlpha    (AccessibleComponent *obj);
 661
 662 /* AccessibleDocument function prototypes  */
 663
 664 void        AccessibleDocument_ref               (AccessibleDocument *obj);
 665 void        AccessibleDocument_unref             (AccessibleDocument *obj);
 666 char       *AccessibleDocument_getLocale         (AccessibleDocument *obj);
 667 char       *AccessibleDocument_getAttributeValue (AccessibleDocument *obj,
 668                                                   char *attribute);
 669 AccessibleAttributeSet *AccessibleDocument_getAttributes     (AccessibleDocument *obj);
 670
 671 /* AccessibleEditableText function prototypes  */
 672
 673 void
 674 AccessibleEditableText_ref (AccessibleEditableText *obj);
 675
 676 void
 677 AccessibleEditableText_unref (AccessibleEditableText *obj);
 678
 679 SPIBoolean
 680 AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
 681                                       const char *attributes,
 682                                       long int startOffset,
 683                                       long int endOffset);
 684
 685 SPIBoolean
 686 AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
 687                                         const char *newContents);
 688
 689 SPIBoolean
 690 AccessibleEditableText_insertText (AccessibleEditableText *obj,
 691                                    long int position,
 692                                    const char *text,
 693                                    long int length);
 694
 695 SPIBoolean
 696 AccessibleEditableText_copyText (AccessibleText *obj,
 697                                  long int startPos,
 698                                  long int endPos);
 699
 700 SPIBoolean
 701 AccessibleEditableText_cutText (AccessibleEditableText *obj,
 702                                 long int startPos,
 703                                 long int endPos);
 704
 705 SPIBoolean
 706 AccessibleEditableText_deleteText (AccessibleEditableText *obj,
 707                                    long int startPos,
 708                                    long int endPos);
 709
 710 SPIBoolean
 711 AccessibleEditableText_pasteText (AccessibleEditableText *obj,
 712                                   long int position);
 713
 714 /*
 715  *
 716  * AccessibleHyperlink function prototypes
 717  *
 718  */
 719 void
 720 AccessibleHyperlink_ref (AccessibleHyperlink *obj);
 721 void
 722 AccessibleHyperlink_unref (AccessibleHyperlink *obj);
 723
 724 long
 725 AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
 726
 727 char *
 728 AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
 729                             long int i);
 730
 731 Accessible *
 732 AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
 733                                long int i);
 734
 735 void
 736 AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
 737                                    long int *startIndex,
 738                                    long int *endIndex);
 739
 740 SPIBoolean
 741 AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
 742
 743 /*
 744  *
 745  * AccessibleHypertext function prototypes
 746  *
 747  */
 748
 749 void
 750 AccessibleHypertext_ref (AccessibleHypertext *obj);
 751
 752 void
 753 AccessibleHypertext_unref (AccessibleHypertext *obj);
 754
 755 long
 756 AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
 757
 758 AccessibleHyperlink *
 759 AccessibleHypertext_getLink (AccessibleHypertext *obj,
 760                              long int linkIndex);
 761
 762 long
 763 AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
 764                                   long int characterOffset);
 765
 766 /*
 767  *
 768  * AccessibleImage function prototypes
 769  *
 770  */
 771
 772 void
 773 AccessibleImage_ref (AccessibleImage *obj);
 774
 775 void
 776 AccessibleImage_unref (AccessibleImage *obj);
 777
 778 char *
 779 AccessibleImage_getImageDescription (AccessibleImage *obj);
 780
 781 void
 782 AccessibleImage_getImageSize (AccessibleImage *obj,
 783                               long int *width,
 784                               long int *height);
 785
 786 void
 787 AccessibleImage_getImagePosition (AccessibleImage *obj,
 788                                   long int *x,
 789                                   long int *y,
 790                                   AccessibleCoordType ctype);
 791
 792 void
 793 AccessibleImage_getImageExtents (AccessibleImage *obj,
 794                                  long int *x,
 795                                  long int *y,
 796                                  long int *width,
 797                                  long int *height,
 798                                  AccessibleCoordType ctype);
 799 char *
 800 AccessibleImage_getImageLocale  (AccessibleImage *obj);
 801
 802 /*
 803  *
 804  * AccessibleMatchRule function prototypes
 805  *
 806  */
 807 void       AccessibleMatchRule_ref (AccessibleMatchRule *obj);
 808 void       AccessibleMatchRule_unref (AccessibleMatchRule *obj);
 809
 810 /*
 811  *
 812  * AccessibleRelation function prototypes
 813  *
 814  */
 815
 816 void AccessibleRelation_ref   (AccessibleRelation *obj);
 817 void AccessibleRelation_unref (AccessibleRelation *obj);
 818
 819 AccessibleRelationType
 820 AccessibleRelation_getRelationType (AccessibleRelation *obj);
 821
 822 int
 823 AccessibleRelation_getNTargets (AccessibleRelation *obj);
 824
 825 Accessible *
 826 AccessibleRelation_getTarget (AccessibleRelation *obj, int i);
 827
 828
 829 /*
 830  *
 831  * AccessibleSelection function prototypes
 832  *
 833  */
 834
 835 void AccessibleSelection_ref   (AccessibleSelection *obj);
 836 void AccessibleSelection_unref (AccessibleSelection *obj);
 837
 838 long
 839 AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj);
 840
 841 Accessible *
 842 AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
 843                                       long int selectedChildIndex);
 844
 845 SPIBoolean
 846 AccessibleSelection_selectChild (AccessibleSelection *obj,
 847                                  long int childIndex);
 848
 849 SPIBoolean
 850 AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
 851                                            long int selectedChildIndex);
 852
 853 SPIBoolean
 854 AccessibleSelection_deselectChild (AccessibleSelection *obj,
 855                                    long int childIndex);
 856
 857 SPIBoolean
 858 AccessibleSelection_isChildSelected (AccessibleSelection *obj,
 859                                      long int childIndex);
 860
 861 SPIBoolean
 862 AccessibleSelection_selectAll (AccessibleSelection *obj);
 863
 864 SPIBoolean
 865 AccessibleSelection_clearSelection (AccessibleSelection *obj);
 866
 867
 868 /*
 869  *
 870  * AccessibleStateSet function prototypes
 871  *
 872  */
 873
 874 void AccessibleStateSet_ref   (AccessibleStateSet *obj);
 875 void AccessibleStateSet_unref (AccessibleStateSet *obj);
 876
 877 SPIBoolean
 878 AccessibleStateSet_contains (AccessibleStateSet *obj,
 879                              AccessibleState state);
 880
 881 void
 882 AccessibleStateSet_add (AccessibleStateSet *obj,
 883                         AccessibleState state);
 884
 885 void
 886 AccessibleStateSet_remove (AccessibleStateSet *obj,
 887                            AccessibleState state);
 888
 889 SPIBoolean
 890 AccessibleStateSet_equals (AccessibleStateSet *obj,
 891                            AccessibleStateSet *obj2);
 892
 893 AccessibleStateSet *
 894 AccessibleStateSet_compare (AccessibleStateSet *obj,
 895                             AccessibleStateSet *obj2);
 896
 897 SPIBoolean
 898 AccessibleStateSet_isEmpty (AccessibleStateSet *obj);
 899
 900 void
 901 AccessibleStreamableContent_ref (AccessibleStreamableContent *obj);
 902 void
 903 AccessibleStreamableContent_unref (AccessibleStreamableContent *obj);
 904 char **
 905 AccessibleStreamableContent_getContentTypes (AccessibleStreamableContent *obj);
 906
 907 void
 908 AccessibleStreamableContent_freeContentTypesList (AccessibleStreamableContent *obj,
 909                                                  char **content_types);
 910 #define AccessibleStreamableContent_freeContentTypeList(a, b) AccessibleStreamableContent_freeContentTypesList(a,b)
 911
 912 SPIBoolean
 913 AccessibleStreamableContent_open (AccessibleStreamableContent *obj,
 914                                   const char *content_type);
 915 SPIBoolean
 916 AccessibleStreamableContent_close (AccessibleStreamableContent *obj);
 917
 918 long
 919 AccessibleStreamableContent_seek (AccessibleStreamableContent *obj,
 920                                   long int offset,
 921                                   AccessibleStreamableContentSeekType seek_type);
 922 SPIBoolean
 923 AccessibleStreamableContent_read (AccessibleStreamableContent *obj,
 924                                   void *buff,
 925                                   long int nbytes,
 926                                   unsigned int read_type);
 927 /*
 928  *
 929  * AccessibleTable function prototypes
 930  *
 931  */
 932
 933 void AccessibleTable_ref   (AccessibleTable *obj);
 934 void AccessibleTable_unref (AccessibleTable *obj);
 935
 936 Accessible *
 937 AccessibleTable_getCaption (AccessibleTable *obj);
 938
 939 Accessible *
 940 AccessibleTable_getSummary (AccessibleTable *obj);
 941
 942 long
 943 AccessibleTable_getNRows (AccessibleTable *obj);
 944
 945 long
 946 AccessibleTable_getNColumns (AccessibleTable *obj);
 947
 948 Accessible *
 949 AccessibleTable_getAccessibleAt (AccessibleTable *obj,
 950                                  long int row,
 951                                  long int column);
 952
 953 long
 954 AccessibleTable_getIndexAt (AccessibleTable *obj,
 955                             long int row,
 956                             long int column);
 957
 958 long
 959 AccessibleTable_getRowAtIndex (AccessibleTable *obj,
 960                                long int index);
 961
 962 long
 963 AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
 964                                   long int index);
 965
 966 char *
 967 AccessibleTable_getRowDescription (AccessibleTable *obj,
 968                                    long int row);
 969
 970 char *
 971 AccessibleTable_getColumnDescription (AccessibleTable *obj,
 972                                       long int column);
 973
 974 long
 975 AccessibleTable_getRowExtentAt (AccessibleTable *obj,
 976                                 long int row,
 977                                 long int column);
 978
 979 long
 980 AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
 981                                    long int row,
 982                                    long int column);
 983
 984 SPIBoolean
 985 AccessibleTable_getRowColumnExtentsAtIndex (AccessibleTable *obj,
 986                                             long int index, long int *row, long int *col,
 987                                             long int *row_extents, long int *col_extents,
 988                                             long int *is_selected);
 989
 990 Accessible *
 991 AccessibleTable_getRowHeader (AccessibleTable *obj,
 992                               long int row);
 993
 994 Accessible *
 995 AccessibleTable_getColumnHeader (AccessibleTable *obj,
 996                                  long int column);
 997
 998 long
 999 AccessibleTable_getNSelectedRows (AccessibleTable *obj);
1000
1001 long
1002 AccessibleTable_getSelectedRows (AccessibleTable *obj,
1003                                  long int **selectedRows);
1004
1005 long
1006 AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
1007
1008 long
1009 AccessibleTable_getSelectedColumns (AccessibleTable *obj,
1010                                     long int **selectedColumns);
1011
1012 SPIBoolean
1013 AccessibleTable_isRowSelected (AccessibleTable *obj,
1014                                long int row);
1015
1016 SPIBoolean
1017 AccessibleTable_isColumnSelected (AccessibleTable *obj,
1018                                   long int column);
1019
1020 SPIBoolean
1021 AccessibleTable_isSelected (AccessibleTable *obj,
1022                             long int row,
1023                             long int column);
1024
1025 SPIBoolean
1026 AccessibleTable_addRowSelection (AccessibleTable *obj,
1027                                  long int row);
1028 SPIBoolean
1029 AccessibleTable_addColumnSelection (AccessibleTable *obj,
1030                                     long int column);
1031
1032 SPIBoolean
1033 AccessibleTable_removeRowSelection (AccessibleTable *obj,
1034                                     long int row);
1035 SPIBoolean
1036 AccessibleTable_removeColumnSelection (AccessibleTable *obj,
1037                                        long int column);
1038
1039 /*
1040  *
1041  * AccessibleText function prototypes
1042  *
1043  */
1044
1045 void AccessibleText_ref   (AccessibleText *obj);
1046 void AccessibleText_unref (AccessibleText *obj);
1047
1048 long
1049 AccessibleText_getCharacterCount (AccessibleText *obj);
1050
1051 char *
1052 AccessibleText_getText (AccessibleText *obj,
1053                         long int startOffset,
1054                         long int endOffset);
1055
1056 long
1057 AccessibleText_getCaretOffset (AccessibleText *obj);
1058
1059 char *
1060 AccessibleText_getAttributes (AccessibleText *obj,
1061                                  long int offset,
1062                                  long int *startOffset,
1063                                  long int *endOffset);
1064
1065 char *
1066 AccessibleText_getDefaultAttributes (AccessibleText *obj);
1067
1068 SPIBoolean
1069 AccessibleText_setCaretOffset (AccessibleText *obj,
1070                                long int newOffset);
1071
1072 char *
1073 AccessibleText_getTextBeforeOffset (AccessibleText *obj,
1074                                     long int offset,
1075                                     AccessibleTextBoundaryType type,
1076                                     long int *startOffset,
1077                                     long int *endOffset);
1078
1079 char *
1080 AccessibleText_getTextAtOffset (AccessibleText *obj,
1081                                 long int offset,
1082                                 AccessibleTextBoundaryType type,
1083                                 long int *startOffset,
1084                                 long int *endOffset);
1085
1086 char *
1087 AccessibleText_getTextAfterOffset (AccessibleText *obj,
1088                                    long int offset,
1089                                    AccessibleTextBoundaryType type,
1090                                    long int *startOffset,
1091                                    long int *endOffset);
1092
1093 unsigned long
1094 AccessibleText_getCharacterAtOffset (AccessibleText *obj,
1095                                      long int offset);
1096
1097 void
1098 AccessibleText_getCharacterExtents (AccessibleText *obj,
1099                                     long int offset,
1100                                     long int *x,
1101                                     long int *y,
1102                                     long int *width,
1103                                     long int *height,
1104                                     AccessibleCoordType type);
1105
1106 void
1107 AccessibleText_getRangeExtents (AccessibleText *obj,
1108                                 long int startOffset,
1109                                 long int endOffset,
1110                                 long int *x,
1111                                 long int *y,
1112                                 long int *width,
1113                                 long int *height,
1114                                 AccessibleCoordType type);
1115
1116 AccessibleTextRange **
1117 AccessibleText_getBoundedRanges (AccessibleText *obj,
1118                                  long int x,
1119                                  long int y,
1120                                  long int width,
1121                                  long int height,
1122                                  AccessibleCoordType type,
1123                                  AccessibleTextClipType clipTypeX,
1124                                  AccessibleTextClipType clipTypeY);
1125
1126 void
1127 AccessibleTextRange_freeRanges (AccessibleTextRange **ranges);
1128
1129 long
1130 AccessibleText_getOffsetAtPoint (AccessibleText *obj,
1131                                  long int x,
1132                                  long int y,
1133                                  AccessibleCoordType type);
1134
1135 long
1136 AccessibleText_getNSelections (AccessibleText *obj);
1137
1138 void
1139 AccessibleText_getSelection (AccessibleText *obj,
1140                              long int selectionNum,
1141                              long int *startOffset,
1142                              long int *endOffset);
1143
1144
1145 SPIBoolean
1146 AccessibleText_addSelection (AccessibleText *obj,
1147                              long int startOffset,
1148                              long int endOffset);
1149
1150 SPIBoolean
1151 AccessibleText_removeSelection (AccessibleText *obj,
1152                                 long int selectionNum);
1153
1154 SPIBoolean
1155 AccessibleText_setSelection (AccessibleText *obj,
1156                              long int selectionNum,
1157                              long int startOffset,
1158                              long int endOffset);
1159 AccessibleAttributeSet *
1160 AccessibleText_getAttributeRun  (AccessibleText *obj,
1161                                  long int offset,
1162                                  long int *startOffset,
1163                                  long int *endOffset,
1164                                  long int includeDefaults);
1165 AccessibleAttributeSet *
1166 AccessibleText_getDefaultAttributeSet (AccessibleText *obj);
1167
1168 /* AccessibleValue Function Prototypes:  */
1169
1170 void       AccessibleValue_ref             (AccessibleValue *obj);
1171 void       AccessibleValue_unref           (AccessibleValue *obj);
1172 double     AccessibleValue_getMinimumValue (AccessibleValue *obj);
1173 double     AccessibleValue_getCurrentValue (AccessibleValue *obj);
1174 double     AccessibleValue_getMaximumValue (AccessibleValue *obj);
1175 SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj,
1176                                             double           newValue);
1177 double     AccessibleValue_getMinimumIncrement (AccessibleValue *obj);
1178
1179 /* Persistance and lifecycle control for AccessibleEvents. */
1180 SPIBoolean AccessibleEvent_ref (const AccessibleEvent *e);
1181 void AccessibleEvent_unref (const AccessibleEvent *e);
1182
1183 /*
1184  * Prototypes for accessor functions, to obtain context
1185  * information for accessible events.
1186  */
1187
1188 char*                  AccessibleEvent_getSourceName (const AccessibleEvent *e);
1189 AccessibleRole         AccessibleEvent_getSourceRole (const AccessibleEvent *e);
1190 AccessibleApplication* AccessibleEvent_getSourceApplication (const AccessibleEvent *e);
1191 SPIBoolean             AccessibleEvent_getSourceDetails (const AccessibleEvent *e, char **name,
1192                                                          AccessibleRole *role,
1193                                                          AccessibleApplication **app);
1194
1195 char*        AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e);
1196 Accessible * AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e);
1197
1198 Accessible * AccessibleParentChangedEvent_getParentAccessible (const AccessibleEvent *e);
1199
1200 char*        AccessibleTextSelectionChangedEvent_getSelectionString (const AccessibleEvent *e);
1201
1202 char*        AccessibleWindowEvent_getTitleString (const AccessibleEvent *e);
1203
1204 Accessible * AccessibleActiveDescendantChangedEvent_getActiveDescendant (const AccessibleEvent *e);
1205
1206 Accessible * AccessibleTableSummaryChangedEvent_getSummaryAccessible (const AccessibleEvent *e);
1207
1208 Accessible * AccessibleTableHeaderChangedEvent_getHeaderAccessible (const AccessibleEvent *e);
1209
1210 char *       AccessibleTableCaptionChangedEvent_getCaptionString (const AccessibleEvent *e);
1211
1212 char *       AccessibleTableRowDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
1213
1214 char *       AccessibleTableColumnDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
1215
1216 char *       AccessibleDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
1217
1218 char *       AccessibleNameChangedEvent_getNameString (const AccessibleEvent *e);
1219 SPIRect *    AccessibleBoundsChangedEvent_getNewBounds (const AccessibleEvent *e);
1220
1221 /* Misc methods and error handling */
1222 void SPI_freeString (char *s);
1223
1224 char* SPI_dupString (char *s);
1225
1226 void SPI_freeRect (SPIRect *r);
1227
1228 SPIBoolean SPI_exceptionHandlerPush (SPIExceptionHandler *handler);
1229
1230 SPIExceptionHandler* SPI_exceptionHandlerPop (void);
1231
1232 SPIExceptionType SPIException_getSourceType (SPIException *err);
1233
1234 SPIExceptionCode SPIException_getExceptionCode (SPIException *err);
1235
1236 Accessible* SPIAccessibleException_getSource (SPIException *err);
1237
1238 char* SPIException_getDescription (SPIException *err);
1239
1240 #ifdef  __cplusplus
1241 }
1242 #endif
1243
1244 #endif