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  *AccessibleTextBoundaryType:
  47  *@SPI_TEXT_BOUNDARY_CHAR:
  48  *@SPI_TEXT_BOUNDARY_CURSOR_POS:
  49  *@SPI_TEXT_BOUNDARY_WORD_START:
  50  *@SPI_TEXT_BOUNDARY_WORD_END:
  51  *@SPI_TEXT_BOUNDARY_SENTENCE_START:
  52  *@SPI_TEXT_BOUNDARY_SENTENCE_END:
  53  *@SPI_TEXT_BOUNDARY_LINE_START:
  54  *@SPI_TEXT_BOUNDARY_LINE_END:
  55  *@SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE:
  56  *
  57  *Text boundary types used for specifying boundaries for regions of text
  58  **/
  59 typedef enum
  60 {
  61   SPI_TEXT_BOUNDARY_CHAR,
  62   SPI_TEXT_BOUNDARY_CURSOR_POS,
  63   SPI_TEXT_BOUNDARY_WORD_START,
  64   SPI_TEXT_BOUNDARY_WORD_END,
  65   SPI_TEXT_BOUNDARY_SENTENCE_START,
  66   SPI_TEXT_BOUNDARY_SENTENCE_END,
  67   SPI_TEXT_BOUNDARY_LINE_START,
  68   SPI_TEXT_BOUNDARY_LINE_END,
  69   SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE
  70 } AccessibleTextBoundaryType;
  71
  72 /**
  73  *AccessibleTextClipType
  74  *@SPI_TEXT_CLIP_NONE: No clipping to be done
  75  *@SPI_TEXT_CLIP_MIN: Text clipped by min coordinate is omitted
  76  *@SPI_TEXT_CLIP_MAX: Text clipped by max coordinate is omitted
  77  *@SPI_TEXT_CLIP_BOTH: Only text fully within mix/max bound is retained
  78  *
  79  *Describes the type of clipping required.
  80  **/
  81 typedef enum
  82 {
  83   SPI_TEXT_CLIP_NONE,
  84   SPI_TEXT_CLIP_MIN,
  85   SPI_TEXT_CLIP_MAX,
  86   SPI_TEXT_CLIP_BOTH
  87 } AccessibleTextClipType;
  88
  89 /**
  90  *AccessibleRelationType:
  91  *@SPI_RELATION_NULL:
  92  *@SPI_RELATION_LABEL_FOR: Indicates an object is a label for one or more target objects.
  93  *@SPI_RELATION_LABELED_BY: Indicates an object is labelled by one or more target objects.
  94  *@SPI_RELATION_CONTROLLED_BY: Indicates an object controlled by one or more target objects.
  95  *@SPI_RELATION_CONTROLLER_FOR: Indicates an object is an controller for one or more target objects.
  96  *@SPI_RELATION_MEMBER_OF: Indicates an object is a member of a group of one or
  97 more target objects.
  98  *@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.
  99  *@SPI_RELATION_EXTENDED:
 100  *@SPI_RELATION_FLOWS_TO: Indicates that the object has content that flows logically to another
 101  *  AtkObject in a sequential way, (for instance text-flow).
 102  *@SPI_RELATION_FLOWS_FROM: Indicates that the object has content that flows logically from
 103  *  another AtkObject in a sequential way, (for instance text-flow).
 104  *@SPI_RELATION_SUBWINDOW_OF: Indicates a subwindow attached to a component but otherwise has no connection in the UI heirarchy to that component.
 105  *@SPI_RELATION_EMBEDS: Indicates that the object visually embeds
 106  *  another object's content, i.e. this object's content flows around
 107  *  another's content.
 108  *@SPI_RELATION_EMBEDDED_BY: Inverse of %SPI_RELATION_EMBEDS, indicates that
 109  *  this object's content is visualy embedded in another object.
 110  *@SPI_RELATION_POPUP_FOR: Indicates that an object is a popup for another objec
 111 t.
 112  *@SPI_RELATION_LAST_DEFINED:
 113  *
 114  *Describes the type of the relation
 115  **/
 116 typedef enum
 117 {
 118   SPI_RELATION_NULL,
 119   SPI_RELATION_LABEL_FOR,
 120   SPI_RELATION_LABELED_BY,
 121   SPI_RELATION_CONTROLLER_FOR,
 122   SPI_RELATION_CONTROLLED_BY,
 123   SPI_RELATION_MEMBER_OF,
 124   SPI_RELATION_NODE_CHILD_OF,
 125   SPI_RELATION_EXTENDED,
 126   SPI_RELATION_FLOWS_TO,
 127   SPI_RELATION_FLOWS_FROM,
 128   SPI_RELATION_SUBWINDOW_OF,
 129   SPI_RELATION_EMBEDS,
 130   SPI_RELATION_EMBEDDED_BY,
 131   SPI_RELATION_POPUP_FOR,
 132   SPI_RELATION_LAST_DEFINED
 133 } AccessibleRelationType;
 134
 135
 136 /* don't change the order of these ! */
 137 /**
 138  *AccessibleCoordType:
 139  *@SPI_COORD_TYPE_SCREEN: specifies xy coordinates relative to the screen
 140  *@SPI_COORD_TYPE_WINDOW: specifies xy coordinates relative to an object's
 141  * top-level window
 142  *
 143  *Specifies how xy coordinates are to be interpreted. Used by functions such
 144  *as AccessibleComponent_getPosition() and AccessibleText_getCharacterExtents()
 145  **/
 146 typedef enum {
 147   SPI_COORD_TYPE_SCREEN,
 148   SPI_COORD_TYPE_WINDOW
 149 } AccessibleCoordType;
 150
 151 /**
 152  *AccessibleKeySynthType:
 153  *@SPI_KEY_PRESS:
 154  *@SPI_KEY_RELEASE:
 155  *@SPI_KEY_PRESSRELEASE:
 156  *@SPI_KEY_SYM:
 157  *@SPI_KEY_STRING:
 158  *
 159  *Specified the type of a generated event.
 160  **/
 161 typedef enum {
 162   SPI_KEY_PRESS,
 163   SPI_KEY_RELEASE,
 164   SPI_KEY_PRESSRELEASE,
 165   SPI_KEY_SYM,
 166   SPI_KEY_STRING
 167 } AccessibleKeySynthType;
 168
 169 /**
 170  *AccessibleKeyListenerSyncType:
 171  *@SPI_KEYLISTENER_NOSYNC:
 172  *@SPI_KEYLISTENER_SYNCHRONOUS:
 173  *@SPI_KEYLISTENER_CANCONSUME:
 174  *@SPI_KEYLISTENER_ALL_WINDOWS:
 175  *
 176  *Specified the tyupe of a key listener event.
 177  **/
 178 typedef enum {
 179   SPI_KEYLISTENER_NOSYNC = 0,
 180   SPI_KEYLISTENER_SYNCHRONOUS = 1,
 181   SPI_KEYLISTENER_CANCONSUME = 2,
 182   SPI_KEYLISTENER_ALL_WINDOWS = 4
 183 } AccessibleKeyListenerSyncType;
 184
 185
 186 /**
 187  *AccessibleStreamableContentSeekType
 188  *@SPI_STREAM_SEEK_SET: seek from the 'top' of the streamable
 189  *@SPI_STREAM_SEEK_CUR: seek from the current position in the stream
 190  *@SPI_STREAM_SEEK_END: seek from the end of the stream (if known)
 191  *
 192  *The seek type for a specified offset in AccessibleStreamableContent_seek.
 193  **/
 194 typedef enum
 195 {
 196   SPI_STREAM_SEEK_SET,
 197   SPI_STREAM_SEEK_CUR,
 198   SPI_STREAM_SEEK_END
 199 } AccessibleStreamableContentSeekType;
 200
 201 typedef struct _SPIException SPIException;
 202
 203 typedef SPIBoolean
 204 (* SPIExceptionHandler) (SPIException *err, SPIBoolean is_fatal);
 205
 206 typedef enum {
 207         SPI_EXCEPTION_UNSPECIFIED,
 208         SPI_EXCEPTION_DISCONNECT,
 209         SPI_EXCEPTION_NO_IMPL,
 210         SPI_EXCEPTION_IO,
 211         SPI_EXCEPTION_BAD_DATA
 212 } SPIExceptionCode;
 213
 214 typedef enum {
 215         SPI_EXCEPTION_SOURCE_UNSPECIFIED,
 216         SPI_EXCEPTION_SOURCE_ACCESSIBLE,
 217         SPI_EXCEPTION_SOURCE_REGISTRY,
 218         SPI_EXCEPTION_SOURCE_DEVICE
 219 } SPIExceptionType;
 220
 221 typedef unsigned long AccessibleKeyEventMask;
 222 typedef unsigned long AccessibleDeviceEventMask;
 223
 224 typedef struct {
 225         long x;
 226         long y;
 227         long width;
 228         long height;
 229 } SPIRect;
 230
 231 /**
 232  *AccessibleComponentLayer:
 233  *@SPI_LAYER_INVALID: The layer cannot be determined or is somehow undefined.
 234  *@SPI_LAYER_BACKGROUND: Component belongs to the destop background.
 235  *@SPI_LAYER_CANVAS: Component is a canvas backdrop or drawing area.
 236  *@SPI_LAYER_WIDGET: Component is a 'normal' widget.
 237  *@SPI_LAYER_MDI: Component is drawn in the MDI layer and may have valid
 238  *                         Z-information relative to other MDI-layer components.
 239  *@SPI_LAYER_POPUP: Component is in the popup layer, above other widgets and
 240  *                         MDI components.
 241  *@SPI_LAYER_OVERLAY: Component is in the overlay plane - this value is reserved
 242  *                         for future use.
 243  *@SPI_LAYER_WINDOW: Component is in the window layer and have valid Z-information
 244  *                   relative to other window-layer components.
 245  *@SPI_LAYER_LAST_DEFINED: Used to determine the last valid value in the enum,
 246  *                         should not be encountered.
 247  *
 248  * Describes the layer of a component.
 249  *
 250  * These enumerated "layer values" are used when determining which UI
 251  * rendering layer a component is drawn into, which can help in making
 252  * determinations of when components occlude one another.
 253  **/
 254 typedef enum {
 255     SPI_LAYER_INVALID,
 256     SPI_LAYER_BACKGROUND,
 257     SPI_LAYER_CANVAS,
 258     SPI_LAYER_WIDGET,
 259     SPI_LAYER_MDI,
 260     SPI_LAYER_POPUP,
 261     SPI_LAYER_OVERLAY,
 262     SPI_LAYER_WINDOW,
 263     SPI_LAYER_LAST_DEFINED
 264 } AccessibleComponentLayer;
 265
 266
 267 /**
 268  * AccessibleTextRange:
 269  * @start: the first nominal character position within the range.
 270  * @end: the first nominal character position following the range.
 271  * @content: The actual text content between @start and @end, as a UTF-8 string.
 272  *
 273  * Structure which encapsulates a text range - must be associated with an
 274  *          AccessibleText-implementing object.
 275  **/
 276 typedef struct _AccessibleTextRange
 277 {
 278   long int        start;
 279   long int        end;
 280   char           *contents;
 281 } AccessibleTextRange;
 282
 283 /**
 284  * AccessibleKeySet:
 285  * @keysyms:
 286  * @keycodes:
 287  * @len:
 288  *
 289  * Structure containing identifying information about a set of keycode or
 290  *        keysyms.
 291  **/
 292 typedef struct _AccessibleKeySet
 293 {
 294   unsigned long  *keysyms;
 295   unsigned short *keycodes;
 296   char          **keystrings;
 297   short           len;
 298 } AccessibleKeySet;
 299
 300 /*
 301  * A special value for an AccessibleKeySet type, which tacitly
 302  * includes all keycodes and keyvals for the specified modifier set.
 303  */
 304 #define SPI_KEYSET_ALL_KEYS NULL
 305
 306 typedef unsigned long AccessibleModifierMaskType;
 307 /**
 308  *AccessibleKeyMaskType:
 309  *
 310  *AccessibleKeyMaskType is a mask which is a set of key event modifiers
 311  *which is specified in SPI_registerAccessibleKeystrokeListener.
 312  **/
 313
 314 typedef AccessibleModifierMaskType AccessibleKeyMaskType;
 315
 316 typedef struct _AccessibleAttributeSet
 317 {
 318     int len;
 319     char **attributes;
 320 } AccessibleAttributeSet;
 321
 322 /* Basic SPI initialization and event loop function prototypes */
 323
 324 int              SPI_init         (void);
 325 void             SPI_event_main   (void);
 326 void             SPI_event_quit   (void);
 327 SPIBoolean       SPI_eventIsReady (void);
 328 AccessibleEvent *SPI_nextEvent    (SPIBoolean waitForEvent);
 329 int              SPI_exit         (void);
 330
 331 /* Event Listener creation and support.  */
 332
 333 void                      SPI_freeAccessibleKeySet (
 334                                                    AccessibleKeySet         *keyset);
 335 AccessibleKeySet        * SPI_createAccessibleKeySet (
 336                                                    int                       len,
 337                                                    const char               *keysyms,
 338                                                    short                    *keycodes,
 339                                                    const char              **keystrings);
 340 AccessibleEventListener * SPI_createAccessibleEventListener (
 341                                                    AccessibleEventListenerCB callback,
 342                                                    void                     *user_data);
 343 SPIBoolean                AccessibleEventListener_addCallback (
 344                                                    AccessibleEventListener  *listener,
 345                                                    AccessibleEventListenerCB callback,
 346                                                    void                     *user_data);
 347 SPIBoolean                AccessibleEventListener_removeCallback (
 348                                                    AccessibleEventListener  *listener,
 349                                                    AccessibleEventListenerCB callback);
 350 void                      AccessibleEventListener_unref (
 351                                                    AccessibleEventListener  *listener);
 352
 353 /* Device Event Listener creation and support.  */
 354
 355 /* First four are deprecated in favor of the last four; really just a re-name */
 356
 357 AccessibleKeystrokeListener * SPI_createAccessibleKeystrokeListener (
 358                                         AccessibleKeystrokeListenerCB callback,
 359                                         void                         *user_data);
 360 SPIBoolean                    AccessibleKeystrokeListener_addCallback (
 361                                         AccessibleKeystrokeListener  *listener,
 362                                         AccessibleKeystrokeListenerCB callback,
 363                                         void                         *user_data);
 364 SPIBoolean                    AccessibleKeystrokeListener_removeCallback (
 365                                         AccessibleKeystrokeListener *listener,
 366                                         AccessibleKeystrokeListenerCB callback);
 367 void                          AccessibleKeystrokeListener_unref (
 368                                         AccessibleKeystrokeListener *listener);
 369
 370 AccessibleDeviceListener   * SPI_createAccessibleDeviceListener (
 371                                         AccessibleDeviceListenerCB callback,
 372                                         void                      *user_data);
 373 SPIBoolean                    AccessibleDeviceListener_addCallback (
 374                                         AccessibleDeviceListener  *listener,
 375                                         AccessibleDeviceListenerCB callback,
 376                                         void                      *user_data);
 377 SPIBoolean                    AccessibleDeviceListener_removeCallback (
 378                                         AccessibleDeviceListener  *listener,
 379                                         AccessibleDeviceListenerCB callback);
 380 void                          AccessibleDeviceListener_unref (
 381                                         AccessibleDeviceListener *listener);
 382
 383 /* Global functions serviced by the registry */
 384
 385 SPIBoolean SPI_registerGlobalEventListener           (
 386                                        AccessibleEventListener *listener,
 387                                        const char              *eventType);
 388 SPIBoolean SPI_deregisterGlobalEventListener         (
 389                                        AccessibleEventListener *listener,
 390                                        const char              *eventType);
 391 SPIBoolean SPI_deregisterGlobalEventListenerAll      (
 392                                        AccessibleEventListener *listener);
 393 SPIBoolean SPI_registerAccessibleKeystrokeListener   (
 394                                        AccessibleKeystrokeListener *listener,
 395                                        AccessibleKeySet             *keys,
 396                                        AccessibleKeyMaskType         modmask,
 397                                        AccessibleKeyEventMask        eventmask,
 398                                        AccessibleKeyListenerSyncType sync_type);
 399 SPIBoolean SPI_deregisterAccessibleKeystrokeListener (
 400                                        AccessibleKeystrokeListener *listener,
 401                                        AccessibleKeyMaskType        modmask);
 402
 403 SPIBoolean SPI_registerDeviceEventListener   (
 404                                        AccessibleDeviceListener   *listener,
 405                                        AccessibleDeviceEventMask   eventmask,
 406                                        void                       *filter);
 407 SPIBoolean SPI_deregisterDeviceEventListener (
 408                                        AccessibleDeviceListener   *listener,
 409                                        void                       *filter);
 410
 411 int         SPI_getDesktopCount                  (void);
 412 Accessible *SPI_getDesktop                       (int i);
 413 int         SPI_getDesktopList                   (Accessible ***desktop_list);
 414 void        SPI_freeDesktopList                  (Accessible  **desktop_list);
 415
 416 SPIBoolean  SPI_generateKeyboardEvent            (long int                    keyval,
 417                                                   char                       *keystring,
 418                                                   AccessibleKeySynthType      synth_type);
 419
 420 SPIBoolean  SPI_generateMouseEvent               (long int x, long int y, char *name);
 421
 422 /* Accessible function prototypes  */
 423
 424 void                 Accessible_ref              (Accessible *obj);
 425 void                 Accessible_unref            (Accessible *obj);
 426 char *               Accessible_getName          (Accessible *obj);
 427 char *               Accessible_getDescription   (Accessible *obj);
 428 Accessible *         Accessible_getParent        (Accessible *obj);
 429 long                 Accessible_getChildCount    (Accessible *obj);
 430 Accessible *         Accessible_getChildAtIndex  (Accessible *obj,
 431                                                   long int    childIndex);
 432 long                 Accessible_getIndexInParent (Accessible *obj);
 433 AccessibleRelation **Accessible_getRelationSet   (Accessible *obj);
 434 AccessibleRole       Accessible_getRole          (Accessible *obj);
 435 char *               Accessible_getRoleName      (Accessible *obj);
 436 char *               Accessible_getLocalizedRoleName (Accessible *obj);
 437 AccessibleStateSet * Accessible_getStateSet      (Accessible *obj);
 438 AccessibleAttributeSet *Accessible_getAttributes (Accessible *obj);
 439 AccessibleApplication *Accessible_getHostApplication (Accessible *obj);
 440
 441 /* Interface query methods */
 442
 443 SPIBoolean Accessible_isAction            (Accessible *obj);
 444 SPIBoolean Accessible_isApplication       (Accessible *obj);
 445 SPIBoolean Accessible_isComponent         (Accessible *obj);
 446 SPIBoolean Accessible_isEditableText      (Accessible *obj);
 447 SPIBoolean Accessible_isHypertext         (Accessible *obj);
 448 SPIBoolean Accessible_isImage             (Accessible *obj);
 449 SPIBoolean Accessible_isSelection         (Accessible *obj);
 450 SPIBoolean Accessible_isStreamableContent (Accessible *obj);
 451 SPIBoolean Accessible_isTable             (Accessible *obj);
 452 SPIBoolean Accessible_isText              (Accessible *obj);
 453 SPIBoolean Accessible_isValue             (Accessible *obj);
 454
 455 AccessibleAction *            Accessible_getAction            (Accessible *obj);
 456 AccessibleApplication *       Accessible_getApplication       (Accessible *obj);
 457 AccessibleComponent *         Accessible_getComponent         (Accessible *obj);
 458 AccessibleEditableText *      Accessible_getEditableText      (Accessible *obj);
 459 AccessibleHypertext *         Accessible_getHypertext         (Accessible *obj);
 460 AccessibleImage *             Accessible_getImage             (Accessible *obj);
 461 AccessibleSelection *         Accessible_getSelection         (Accessible *obj);
 462 AccessibleStreamableContent * Accessible_getStreamableContent (Accessible *obj);
 463 AccessibleTable *             Accessible_getTable             (Accessible *obj);
 464 AccessibleText *              Accessible_getText              (Accessible *obj);
 465 AccessibleValue *             Accessible_getValue             (Accessible *obj);
 466 AccessibleUnknown *           Accessible_queryInterface       (Accessible *obj,
 467                                                    const char *interface_name);
 468
 469 /* AccessibleAction function prototypes  */
 470
 471 void       AccessibleAction_ref            (AccessibleAction *obj);
 472 void       AccessibleAction_unref          (AccessibleAction *obj);
 473 long       AccessibleAction_getNActions    (AccessibleAction *obj);
 474 char      *AccessibleAction_getName        (AccessibleAction *obj,
 475                                             long int          i);
 476 char      *AccessibleAction_getDescription (AccessibleAction *obj,
 477                                             long int          i);
 478 SPIBoolean AccessibleAction_doAction       (AccessibleAction *obj,
 479                                             long int          i);
 480 char      *AccessibleAction_getKeyBinding  (AccessibleAction *obj,
 481                                             long int          i);
 482
 483 /* AccessibleApplication function prototypes  */
 484
 485 void       AccessibleApplication_ref            (AccessibleApplication *obj);
 486 void       AccessibleApplication_unref          (AccessibleApplication *obj);
 487 char      *AccessibleApplication_getToolkitName (AccessibleApplication *obj);
 488 char      *AccessibleApplication_getVersion     (AccessibleApplication *obj);
 489 long       AccessibleApplication_getID          (AccessibleApplication *obj);
 490 char      *AccessibleApplication_getLocale      (AccessibleApplication *obj, int lc_category);
 491 SPIBoolean AccessibleApplication_pause          (AccessibleApplication *obj);
 492 SPIBoolean AccessibleApplication_resume         (AccessibleApplication *obj);
 493
 494 /* AccessibleComponent function prototypes */
 495
 496 void        AccessibleComponent_ref         (AccessibleComponent *obj);
 497 void        AccessibleComponent_unref       (AccessibleComponent *obj);
 498 SPIBoolean  AccessibleComponent_contains    (AccessibleComponent *obj,
 499                                              long int             x,
 500                                              long int             y,
 501                                              AccessibleCoordType  ctype);
 502 Accessible *AccessibleComponent_getAccessibleAtPoint (
 503                                              AccessibleComponent *obj,
 504                                              long int             x,
 505                                              long int             y,
 506                                              AccessibleCoordType  ctype);
 507 void        AccessibleComponent_getExtents  (AccessibleComponent *obj,
 508                                              long int            *x,
 509                                              long int            *y,
 510                                              long int            *width,
 511                                              long int            *height,
 512                                              AccessibleCoordType  ctype);
 513 void        AccessibleComponent_getPosition (AccessibleComponent *obj,
 514                                              long int            *x,
 515                                              long int            *y,
 516                                              AccessibleCoordType  ctype);
 517 void        AccessibleComponent_getSize     (AccessibleComponent *obj,
 518                                              long int            *width,
 519                                              long int            *height);
 520 AccessibleComponentLayer
 521             AccessibleComponent_getLayer    (AccessibleComponent *obj);
 522 SPIBoolean  AccessibleComponent_grabFocus   (AccessibleComponent *obj);
 523 short       AccessibleComponent_getMDIZOrder(AccessibleComponent *obj);
 524 double      AccessibleComponent_getAlpha    (AccessibleComponent *obj);
 525
 526 /* AccessibleEditableText function prototypes  */
 527
 528 void
 529 AccessibleEditableText_ref (AccessibleEditableText *obj);
 530
 531 void
 532 AccessibleEditableText_unref (AccessibleEditableText *obj);
 533
 534 SPIBoolean
 535 AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
 536                                       const char *attributes,
 537                                       long int startOffset,
 538                                       long int endOffset);
 539
 540 SPIBoolean
 541 AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
 542                                         const char *newContents);
 543
 544 SPIBoolean
 545 AccessibleEditableText_insertText (AccessibleEditableText *obj,
 546                                    long int position,
 547                                    const char *text,
 548                                    long int length);
 549
 550 SPIBoolean
 551 AccessibleEditableText_copyText (AccessibleText *obj,
 552                                  long int startPos,
 553                                  long int endPos);
 554
 555 SPIBoolean
 556 AccessibleEditableText_cutText (AccessibleEditableText *obj,
 557                                 long int startPos,
 558                                 long int endPos);
 559
 560 SPIBoolean
 561 AccessibleEditableText_deleteText (AccessibleEditableText *obj,
 562                                    long int startPos,
 563                                    long int endPos);
 564
 565 SPIBoolean
 566 AccessibleEditableText_pasteText (AccessibleEditableText *obj,
 567                                   long int position);
 568
 569 /*
 570  *
 571  * AccessibleHyperlink function prototypes
 572  *
 573  */
 574 void
 575 AccessibleHyperlink_ref (AccessibleHyperlink *obj);
 576 void
 577 AccessibleHyperlink_unref (AccessibleHyperlink *obj);
 578
 579 long
 580 AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
 581
 582 char *
 583 AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
 584                             long int i);
 585
 586 Accessible *
 587 AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
 588                                long int i);
 589
 590 void
 591 AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
 592                                    long int *startIndex,
 593                                    long int *endIndex);
 594
 595 SPIBoolean
 596 AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
 597
 598 /*
 599  *
 600  * AccessibleHypertext function prototypes
 601  *
 602  */
 603
 604 void
 605 AccessibleHypertext_ref (AccessibleHypertext *obj);
 606
 607 void
 608 AccessibleHypertext_unref (AccessibleHypertext *obj);
 609
 610 long
 611 AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
 612
 613 AccessibleHyperlink *
 614 AccessibleHypertext_getLink (AccessibleHypertext *obj,
 615                              long int linkIndex);
 616
 617 long
 618 AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
 619                                   long int characterOffset);
 620
 621 /*
 622  *
 623  * AccessibleImage function prototypes
 624  *
 625  */
 626
 627 void
 628 AccessibleImage_ref (AccessibleImage *obj);
 629
 630 void
 631 AccessibleImage_unref (AccessibleImage *obj);
 632
 633 char *
 634 AccessibleImage_getImageDescription (AccessibleImage *obj);
 635
 636 void
 637 AccessibleImage_getImageSize (AccessibleImage *obj,
 638                               long int *width,
 639                               long int *height);
 640
 641 void
 642 AccessibleImage_getImagePosition (AccessibleImage *obj,
 643                                   long int *x,
 644                                   long int *y,
 645                                   AccessibleCoordType ctype);
 646
 647 void
 648 AccessibleImage_getImageExtents (AccessibleImage *obj,
 649                                  long int *x,
 650                                  long int *y,
 651                                  long int *width,
 652                                  long int *height,
 653                                  AccessibleCoordType ctype);
 654 char *
 655 AccessibleImage_getImageLocale  (AccessibleImage *obj);
 656
 657 /*
 658  *
 659  * AccessibleRelation function prototypes
 660  *
 661  */
 662
 663 void AccessibleRelation_ref   (AccessibleRelation *obj);
 664 void AccessibleRelation_unref (AccessibleRelation *obj);
 665
 666 AccessibleRelationType
 667 AccessibleRelation_getRelationType (AccessibleRelation *obj);
 668
 669 int
 670 AccessibleRelation_getNTargets (AccessibleRelation *obj);
 671
 672 Accessible *
 673 AccessibleRelation_getTarget (AccessibleRelation *obj, int i);
 674
 675
 676 /*
 677  *
 678  * AccessibleSelection function prototypes
 679  *
 680  */
 681
 682 void AccessibleSelection_ref   (AccessibleSelection *obj);
 683 void AccessibleSelection_unref (AccessibleSelection *obj);
 684
 685 long
 686 AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj);
 687
 688 Accessible *
 689 AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
 690                                       long int selectedChildIndex);
 691
 692 SPIBoolean
 693 AccessibleSelection_selectChild (AccessibleSelection *obj,
 694                                  long int childIndex);
 695
 696 SPIBoolean
 697 AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
 698                                            long int selectedChildIndex);
 699
 700 SPIBoolean
 701 AccessibleSelection_isChildSelected (AccessibleSelection *obj,
 702                                      long int childIndex);
 703
 704 SPIBoolean
 705 AccessibleSelection_selectAll (AccessibleSelection *obj);
 706
 707 SPIBoolean
 708 AccessibleSelection_clearSelection (AccessibleSelection *obj);
 709
 710
 711 /*
 712  *
 713  * AccessibleStateSet function prototypes
 714  *
 715  */
 716
 717 void AccessibleStateSet_ref   (AccessibleStateSet *obj);
 718 void AccessibleStateSet_unref (AccessibleStateSet *obj);
 719
 720 SPIBoolean
 721 AccessibleStateSet_contains (AccessibleStateSet *obj,
 722                              AccessibleState state);
 723
 724 void
 725 AccessibleStateSet_add (AccessibleStateSet *obj,
 726                         AccessibleState state);
 727
 728 void
 729 AccessibleStateSet_remove (AccessibleStateSet *obj,
 730                            AccessibleState state);
 731
 732 SPIBoolean
 733 AccessibleStateSet_equals (AccessibleStateSet *obj,
 734                            AccessibleStateSet *obj2);
 735
 736 AccessibleStateSet *
 737 AccessibleStateSet_compare (AccessibleStateSet *obj,
 738                             AccessibleStateSet *obj2);
 739
 740 SPIBoolean
 741 AccessibleStateSet_isEmpty (AccessibleStateSet *obj);
 742
 743 void
 744 AccessibleStreamableContent_ref (AccessibleStreamableContent *obj);
 745 void
 746 AccessibleStreamableContent_unref (AccessibleStreamableContent *obj);
 747 char **
 748 AccessibleStreamableContent_getContentTypes (AccessibleStreamableContent *obj);
 749 void
 750 AccessibleStreamableContent_freeContentTypeList (AccessibleStreamableContent *obj,
 751                                                  char **list);
 752 SPIBoolean
 753 AccessibleStreamableContent_open (AccessibleStreamableContent *obj,
 754                                   const char *content_type);
 755 SPIBoolean
 756 AccessibleStreamableContent_close (AccessibleStreamableContent *obj);
 757
 758 long int
 759 AccessibleStreamableContent_seek (AccessibleStreamableContent *obj,
 760                                   long int offset,
 761                                   AccessibleStreamableContentSeekType seek_type);
 762 SPIBoolean
 763 AccessibleStreamableContent_read (AccessibleStreamableContent *obj,
 764                                   void *buff,
 765                                   long int nbytes,
 766                                   unsigned int read_type);
 767 /*
 768  *
 769  * AccessibleTable function prototypes
 770  *
 771  */
 772
 773 void AccessibleTable_ref   (AccessibleTable *obj);
 774 void AccessibleTable_unref (AccessibleTable *obj);
 775
 776 Accessible *
 777 AccessibleTable_getCaption (AccessibleTable *obj);
 778
 779 Accessible *
 780 AccessibleTable_getSummary (AccessibleTable *obj);
 781
 782 long
 783 AccessibleTable_getNRows (AccessibleTable *obj);
 784
 785 long
 786 AccessibleTable_getNColumns (AccessibleTable *obj);
 787
 788 Accessible *
 789 AccessibleTable_getAccessibleAt (AccessibleTable *obj,
 790                                  long int row,
 791                                  long int column);
 792
 793 long
 794 AccessibleTable_getIndexAt (AccessibleTable *obj,
 795                             long int row,
 796                             long int column);
 797
 798 long
 799 AccessibleTable_getRowAtIndex (AccessibleTable *obj,
 800                                long int index);
 801
 802 long
 803 AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
 804                                   long int index);
 805
 806 char *
 807 AccessibleTable_getRowDescription (AccessibleTable *obj,
 808                                    long int row);
 809
 810 char *
 811 AccessibleTable_getColumnDescription (AccessibleTable *obj,
 812                                       long int column);
 813
 814 long
 815 AccessibleTable_getRowExtentAt (AccessibleTable *obj,
 816                                 long int row,
 817                                 long int column);
 818
 819 long
 820 AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
 821                                    long int row,
 822                                    long int column);
 823
 824 Accessible *
 825 AccessibleTable_getRowHeader (AccessibleTable *obj,
 826                               long int row);
 827
 828 Accessible *
 829 AccessibleTable_getColumnHeader (AccessibleTable *obj,
 830                                  long int column);
 831
 832 long
 833 AccessibleTable_getNSelectedRows (AccessibleTable *obj);
 834
 835 long
 836 AccessibleTable_getSelectedRows (AccessibleTable *obj,
 837                                  long int **selectedRows);
 838
 839 long
 840 AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
 841
 842 long
 843 AccessibleTable_getSelectedColumns (AccessibleTable *obj,
 844                                     long int **selectedColumns);
 845
 846 SPIBoolean
 847 AccessibleTable_isRowSelected (AccessibleTable *obj,
 848                                long int row);
 849
 850 SPIBoolean
 851 AccessibleTable_isColumnSelected (AccessibleTable *obj,
 852                                   long int column);
 853
 854 SPIBoolean
 855 AccessibleTable_isSelected (AccessibleTable *obj,
 856                             long int row,
 857                             long int column);
 858
 859 SPIBoolean
 860 AccessibleTable_addRowSelection (AccessibleTable *obj,
 861                                  long int row);
 862 SPIBoolean
 863 AccessibleTable_addColumnSelection (AccessibleTable *obj,
 864                                     long int column);
 865
 866 SPIBoolean
 867 AccessibleTable_removeRowSelection (AccessibleTable *obj,
 868                                     long int row);
 869 SPIBoolean
 870 AccessibleTable_removeColumnSelection (AccessibleTable *obj,
 871                                        long int column);
 872
 873 /*
 874  *
 875  * AccessibleText function prototypes
 876  *
 877  */
 878
 879 void AccessibleText_ref   (AccessibleText *obj);
 880 void AccessibleText_unref (AccessibleText *obj);
 881
 882 long
 883 AccessibleText_getCharacterCount (AccessibleText *obj);
 884
 885 char *
 886 AccessibleText_getText (AccessibleText *obj,
 887                         long int startOffset,
 888                         long int endOffset);
 889
 890 long
 891 AccessibleText_getCaretOffset (AccessibleText *obj);
 892
 893 char *
 894 AccessibleText_getAttributes (AccessibleText *obj,
 895                                  long int offset,
 896                                  long int *startOffset,
 897                                  long int *endOffset);
 898
 899 char *
 900 AccessibleText_getDefaultAttributes (AccessibleText *obj);
 901
 902 SPIBoolean
 903 AccessibleText_setCaretOffset (AccessibleText *obj,
 904                                long int newOffset);
 905
 906 char *
 907 AccessibleText_getTextBeforeOffset (AccessibleText *obj,
 908                                     long int offset,
 909                                     AccessibleTextBoundaryType type,
 910                                     long int *startOffset,
 911                                     long int *endOffset);
 912
 913 char *
 914 AccessibleText_getTextAtOffset (AccessibleText *obj,
 915                                 long int offset,
 916                                 AccessibleTextBoundaryType type,
 917                                 long int *startOffset,
 918                                 long int *endOffset);
 919
 920 char *
 921 AccessibleText_getTextAfterOffset (AccessibleText *obj,
 922                                    long int offset,
 923                                    AccessibleTextBoundaryType type,
 924                                    long int *startOffset,
 925                                    long int *endOffset);
 926
 927 unsigned long
 928 AccessibleText_getCharacterAtOffset (AccessibleText *obj,
 929                                      long int offset);
 930
 931 void
 932 AccessibleText_getCharacterExtents (AccessibleText *obj,
 933                                     long int offset,
 934                                     long int *x,
 935                                     long int *y,
 936                                     long int *width,
 937                                     long int *height,
 938                                     AccessibleCoordType type);
 939
 940 void
 941 AccessibleText_getRangeExtents (AccessibleText *obj,
 942                                 long int startOffset,
 943                                 long int endOffset,
 944                                 long int *x,
 945                                 long int *y,
 946                                 long int *width,
 947                                 long int *height,
 948                                 AccessibleCoordType type);
 949
 950 AccessibleTextRange **
 951 AccessibleText_getBoundedRanges (AccessibleText *obj,
 952                                  long int x,
 953                                  long int y,
 954                                  long int width,
 955                                  long int height,
 956                                  AccessibleCoordType type,
 957                                  AccessibleTextClipType clipTypeX,
 958                                  AccessibleTextClipType clipTypeY);
 959
 960 void
 961 AccessibleTextRange_freeRanges (AccessibleTextRange **ranges);
 962
 963 long
 964 AccessibleText_getOffsetAtPoint (AccessibleText *obj,
 965                                  long int x,
 966                                  long int y,
 967                                  AccessibleCoordType type);
 968
 969 long
 970 AccessibleText_getNSelections (AccessibleText *obj);
 971
 972 void
 973 AccessibleText_getSelection (AccessibleText *obj,
 974                              long int selectionNum,
 975                              long int *startOffset,
 976                              long int *endOffset);
 977
 978
 979 SPIBoolean
 980 AccessibleText_addSelection (AccessibleText *obj,
 981                              long int startOffset,
 982                              long int endOffset);
 983
 984 SPIBoolean
 985 AccessibleText_removeSelection (AccessibleText *obj,
 986                                 long int selectionNum);
 987
 988 SPIBoolean
 989 AccessibleText_setSelection (AccessibleText *obj,
 990                              long int selectionNum,
 991                              long int startOffset,
 992                              long int endOffset);
 993
 994 /* AccessibleValue Function Prototypes:  */
 995
 996 void       AccessibleValue_ref             (AccessibleValue *obj);
 997 void       AccessibleValue_unref           (AccessibleValue *obj);
 998 double     AccessibleValue_getMinimumValue (AccessibleValue *obj);
 999 double     AccessibleValue_getCurrentValue (AccessibleValue *obj);
1000 double     AccessibleValue_getMaximumValue (AccessibleValue *obj);
1001 SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj,
1002                                             double           newValue);
1003
1004 /* Persistance and lifecycle control for AccessibleEvents. */
1005 SPIBoolean AccessibleEvent_ref (const AccessibleEvent *e);
1006 void AccessibleEvent_unref (const AccessibleEvent *e);
1007
1008 /*
1009  * Prototypes for accessor functions, to obtain context
1010  * information for accessible events.
1011  */
1012
1013 char*                  AccessibleEvent_getSourceName (const AccessibleEvent *e);
1014 AccessibleRole         AccessibleEvent_getSourceRole (const AccessibleEvent *e);
1015 AccessibleApplication* AccessibleEvent_getSourceApplication (const AccessibleEvent *e);
1016 SPIBoolean             AccessibleEvent_getSourceDetails (const AccessibleEvent *e, char **name,
1017                                                          AccessibleRole *role,
1018                                                          AccessibleApplication **app);
1019
1020 char*        AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e);
1021 Accessible * AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e);
1022
1023 Accessible * AccessibleParentChangedEvent_getParentAccessible (const AccessibleEvent *e);
1024
1025 char*        AccessibleTextSelectionChangedEvent_getSelectionString (const AccessibleEvent *e);
1026
1027 char*        AccessibleWindowEvent_getTitleString (const AccessibleEvent *e);
1028
1029 Accessible * AccessibleActiveDescendantChangedEvent_getActiveDescendant (const AccessibleEvent *e);
1030
1031 Accessible * AccessibleTableSummaryChangedEvent_getSummaryAccessible (const AccessibleEvent *e);
1032
1033 Accessible * AccessibleTableHeaderChangedEvent_getHeaderAccessible (const AccessibleEvent *e);
1034
1035 char *       AccessibleTableCaptionChangedEvent_getCaptionString (const AccessibleEvent *e);
1036
1037 char *       AccessibleTableRowDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
1038
1039 char *       AccessibleTableColumnDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
1040
1041 char *       AccessibleDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
1042
1043 char *       AccessibleNameChangedEvent_getNameString (const AccessibleEvent *e);
1044 SPIRect *    AccessibleBoundsChangedEvent_getNewBounds (const AccessibleEvent *e);
1045
1046 /* Misc methods and error handling */
1047 void SPI_freeString (char *s);
1048
1049 char* SPI_dupString (char *s);
1050
1051 void SPI_freeRect (SPIRect *rect);
1052
1053 SPIBoolean SPI_exceptionHandlerPush (SPIExceptionHandler *handler);
1054
1055 SPIExceptionHandler* SPI_exceptionHandlerPop (void);
1056
1057 SPIExceptionType SPIException_getSourceType (SPIException *err);
1058
1059 SPIExceptionCode SPIException_getExceptionCode (SPIException *err);
1060
1061 Accessible* SPIAccessibleException_getSource (SPIException *err);
1062
1063 char* SPIException_getDescription (SPIException *err);
1064
1065 #ifdef  __cplusplus
1066 }
1067 #endif
1068
1069 #endif