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:
 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 typedef struct _SPIException SPIException;
 187
 188 typedef SPIBoolean
 189 (* SPIExceptionHandler) (SPIException *err, SPIBoolean is_fatal);
 190
 191 typedef enum {
 192         SPI_EXCEPTION_UNSPECIFIED,
 193         SPI_EXCEPTION_DISCONNECT,
 194         SPI_EXCEPTION_NO_IMPL,
 195         SPI_EXCEPTION_IO,
 196         SPI_EXCEPTION_BAD_DATA
 197 } SPIExceptionCode;
 198
 199 typedef enum {
 200         SPI_EXCEPTION_SOURCE_UNSPECIFIED,
 201         SPI_EXCEPTION_SOURCE_ACCESSIBLE,
 202         SPI_EXCEPTION_SOURCE_REGISTRY,
 203         SPI_EXCEPTION_SOURCE_DEVICE
 204 } SPIExceptionType;
 205
 206 typedef unsigned long AccessibleKeyEventMask;
 207 typedef unsigned long AccessibleDeviceEventMask;
 208
 209 /**
 210  *AccessibleComponentLayer:
 211  *@SPI_LAYER_INVALID: The layer cannot be determined or is somehow undefined.
 212  *@SPI_LAYER_BACKGROUND: Component belongs to the destop background.
 213  *@SPI_LAYER_CANVAS: Component is a canvas backdrop or drawing area.
 214  *@SPI_LAYER_WIDGET: Component is a 'normal' widget.
 215  *@SPI_LAYER_MDI: Component is drawn in the MDI layer and may have valid
 216  *                         Z-information relative to other MDI-layer components.
 217  *@SPI_LAYER_POPUP: Component is in the popup layer, above other widgets and
 218  *                         MDI components.
 219  *@SPI_LAYER_OVERLAY: Component is in the overlay plane - this value is reserved
 220  *                         for future use.
 221  *@SPI_LAYER_WINDOW: Component is in the window layer and have valid Z-information
 222  *                   relative to other window-layer components.
 223  *@SPI_LAYER_LAST_DEFINED: Used to determine the last valid value in the enum,
 224  *                         should not be encountered.
 225  *
 226  * Describes the layer of a component.
 227  *
 228  * These enumerated "layer values" are used when determining which UI
 229  * rendering layer a component is drawn into, which can help in making
 230  * determinations of when components occlude one another.
 231  **/
 232 typedef enum {
 233     SPI_LAYER_INVALID,
 234     SPI_LAYER_BACKGROUND,
 235     SPI_LAYER_CANVAS,
 236     SPI_LAYER_WIDGET,
 237     SPI_LAYER_MDI,
 238     SPI_LAYER_POPUP,
 239     SPI_LAYER_OVERLAY,
 240     SPI_LAYER_WINDOW,
 241     SPI_LAYER_LAST_DEFINED
 242 } AccessibleComponentLayer;
 243
 244
 245 /**
 246  * AccessibleTextRange:
 247  * @start: the first nominal character position within the range.
 248  * @end: the first nominal character position following the range.
 249  * @content: The actual text content between @start and @end, as a UTF-8 string.
 250  *
 251  * Structure which encapsulates a text range - must be associated with an
 252  *          AccessibleText-implementing object.
 253  **/
 254 typedef struct _AccessibleTextRange
 255 {
 256   long int        start;
 257   long int        end;
 258   char           *contents;
 259 } AccessibleTextRange;
 260
 261 /**
 262  * AccessibleKeySet:
 263  * @keysyms:
 264  * @keycodes:
 265  * @len:
 266  *
 267  * Structure containing identifying information about a set of keycode or
 268  *        keysyms.
 269  **/
 270 typedef struct _AccessibleKeySet
 271 {
 272   unsigned long  *keysyms;
 273   unsigned short *keycodes;
 274   char          **keystrings;
 275   short           len;
 276 } AccessibleKeySet;
 277
 278 /*
 279  * A special value for an AccessibleKeySet type, which tacitly
 280  * includes all keycodes and keyvals for the specified modifier set.
 281  */
 282 #define SPI_KEYSET_ALL_KEYS NULL
 283
 284 typedef unsigned long AccessibleModifierMaskType;
 285 /**
 286  *AccessibleKeyMaskType:
 287  *
 288  *AccessibleKeyMaskType is a mask which is a set of key event modifiers
 289  *which is specified in SPI_registerAccessibleKeystrokeListener.
 290  **/
 291
 292 typedef AccessibleModifierMaskType AccessibleKeyMaskType;
 293
 294 /* Basic SPI initialization and event loop function prototypes */
 295
 296 int              SPI_init         (void);
 297 void             SPI_event_main   (void);
 298 void             SPI_event_quit   (void);
 299 SPIBoolean       SPI_eventIsReady (void);
 300 AccessibleEvent *SPI_nextEvent    (SPIBoolean waitForEvent);
 301 int              SPI_exit         (void);
 302
 303 /* Event Listener creation and support.  */
 304
 305 void                      SPI_freeAccessibleKeySet (
 306                                                    AccessibleKeySet         *keyset);
 307 AccessibleKeySet        * SPI_createAccessibleKeySet (
 308                                                    int                       len,
 309                                                    const char               *keysyms,
 310                                                    short                    *keycodes,
 311                                                    const char              **keystrings);
 312 AccessibleEventListener * SPI_createAccessibleEventListener (
 313                                                    AccessibleEventListenerCB callback,
 314                                                    void                     *user_data);
 315 SPIBoolean                AccessibleEventListener_addCallback (
 316                                                    AccessibleEventListener  *listener,
 317                                                    AccessibleEventListenerCB callback,
 318                                                    void                     *user_data);
 319 SPIBoolean                AccessibleEventListener_removeCallback (
 320                                                    AccessibleEventListener  *listener,
 321                                                    AccessibleEventListenerCB callback);
 322 void                      AccessibleEventListener_unref (
 323                                                    AccessibleEventListener  *listener);
 324
 325 /* Device Event Listener creation and support.  */
 326
 327 /* First four are deprecated in favor of the last four; really just a re-name */
 328
 329 AccessibleKeystrokeListener * SPI_createAccessibleKeystrokeListener (
 330                                         AccessibleKeystrokeListenerCB callback,
 331                                         void                         *user_data);
 332 SPIBoolean                    AccessibleKeystrokeListener_addCallback (
 333                                         AccessibleKeystrokeListener  *listener,
 334                                         AccessibleKeystrokeListenerCB callback,
 335                                         void                         *user_data);
 336 SPIBoolean                    AccessibleKeystrokeListener_removeCallback (
 337                                         AccessibleKeystrokeListener *listener,
 338                                         AccessibleKeystrokeListenerCB callback);
 339 void                          AccessibleKeystrokeListener_unref (
 340                                         AccessibleKeystrokeListener *listener);
 341
 342 AccessibleDeviceListener   * SPI_createAccessibleDeviceListener (
 343                                         AccessibleDeviceListenerCB callback,
 344                                         void                      *user_data);
 345 SPIBoolean                    AccessibleDeviceListener_addCallback (
 346                                         AccessibleDeviceListener  *listener,
 347                                         AccessibleDeviceListenerCB callback,
 348                                         void                      *user_data);
 349 SPIBoolean                    AccessibleDeviceListener_removeCallback (
 350                                         AccessibleDeviceListener  *listener,
 351                                         AccessibleDeviceListenerCB callback);
 352 void                          AccessibleDeviceListener_unref (
 353                                         AccessibleDeviceListener *listener);
 354
 355 /* Global functions serviced by the registry */
 356
 357 SPIBoolean SPI_registerGlobalEventListener           (
 358                                        AccessibleEventListener *listener,
 359                                        const char              *eventType);
 360 SPIBoolean SPI_deregisterGlobalEventListener         (
 361                                        AccessibleEventListener *listener,
 362                                        const char              *eventType);
 363 SPIBoolean SPI_deregisterGlobalEventListenerAll      (
 364                                        AccessibleEventListener *listener);
 365 SPIBoolean SPI_registerAccessibleKeystrokeListener   (
 366                                        AccessibleKeystrokeListener *listener,
 367                                        AccessibleKeySet             *keys,
 368                                        AccessibleKeyMaskType         modmask,
 369                                        AccessibleKeyEventMask        eventmask,
 370                                        AccessibleKeyListenerSyncType sync_type);
 371 SPIBoolean SPI_deregisterAccessibleKeystrokeListener (
 372                                        AccessibleKeystrokeListener *listener,
 373                                        AccessibleKeyMaskType        modmask);
 374
 375 SPIBoolean SPI_registerDeviceEventListener   (
 376                                        AccessibleDeviceListener   *listener,
 377                                        AccessibleDeviceEventMask   eventmask,
 378                                        void                       *filter);
 379 SPIBoolean SPI_deregisterDeviceEventListener (
 380                                        AccessibleDeviceListener   *listener,
 381                                        void                       *filter);
 382
 383 int         SPI_getDesktopCount                  (void);
 384 Accessible *SPI_getDesktop                       (int i);
 385 int         SPI_getDesktopList                   (Accessible ***desktop_list);
 386 void        SPI_freeDesktopList                  (Accessible  **desktop_list);
 387
 388 SPIBoolean  SPI_generateKeyboardEvent            (long int                    keyval,
 389                                                   char                       *keystring,
 390                                                   AccessibleKeySynthType      synth_type);
 391
 392 SPIBoolean  SPI_generateMouseEvent               (long int x, long int y, char *name);
 393
 394 /* Accessible function prototypes  */
 395
 396 void                 Accessible_ref              (Accessible *obj);
 397 void                 Accessible_unref            (Accessible *obj);
 398 char *               Accessible_getName          (Accessible *obj);
 399 char *               Accessible_getDescription   (Accessible *obj);
 400 Accessible *         Accessible_getParent        (Accessible *obj);
 401 long                 Accessible_getChildCount    (Accessible *obj);
 402 Accessible *         Accessible_getChildAtIndex  (Accessible *obj,
 403                                                   long int    childIndex);
 404 long                 Accessible_getIndexInParent (Accessible *obj);
 405 AccessibleRelation **Accessible_getRelationSet   (Accessible *obj);
 406 AccessibleRole       Accessible_getRole          (Accessible *obj);
 407 char *               Accessible_getRoleName      (Accessible *obj);
 408 char *               Accessible_getLocalizedRoleName (Accessible *obj);
 409 AccessibleStateSet * Accessible_getStateSet      (Accessible *obj);
 410
 411 /* Interface query methods */
 412
 413 SPIBoolean Accessible_isAction            (Accessible *obj);
 414 SPIBoolean Accessible_isApplication       (Accessible *obj);
 415 SPIBoolean Accessible_isComponent         (Accessible *obj);
 416 SPIBoolean Accessible_isEditableText      (Accessible *obj);
 417 SPIBoolean Accessible_isHypertext         (Accessible *obj);
 418 SPIBoolean Accessible_isImage             (Accessible *obj);
 419 SPIBoolean Accessible_isSelection         (Accessible *obj);
 420 SPIBoolean Accessible_isStreamableContent (Accessible *obj);
 421 SPIBoolean Accessible_isTable             (Accessible *obj);
 422 SPIBoolean Accessible_isText              (Accessible *obj);
 423 SPIBoolean Accessible_isValue             (Accessible *obj);
 424
 425 AccessibleAction *            Accessible_getAction            (Accessible *obj);
 426 AccessibleApplication *       Accessible_getApplication       (Accessible *obj);
 427 AccessibleComponent *         Accessible_getComponent         (Accessible *obj);
 428 AccessibleEditableText *      Accessible_getEditableText      (Accessible *obj);
 429 AccessibleHypertext *         Accessible_getHypertext         (Accessible *obj);
 430 AccessibleImage *             Accessible_getImage             (Accessible *obj);
 431 AccessibleSelection *         Accessible_getSelection         (Accessible *obj);
 432 AccessibleStreamableContent * Accessible_getStreamableContent (Accessible *obj);
 433 AccessibleTable *             Accessible_getTable             (Accessible *obj);
 434 AccessibleText *              Accessible_getText              (Accessible *obj);
 435 AccessibleValue *             Accessible_getValue             (Accessible *obj);
 436 AccessibleUnknown *           Accessible_queryInterface       (Accessible *obj,
 437                                                    const char *interface_name);
 438
 439 /* AccessibleAction function prototypes  */
 440
 441 void       AccessibleAction_ref            (AccessibleAction *obj);
 442 void       AccessibleAction_unref          (AccessibleAction *obj);
 443 long       AccessibleAction_getNActions    (AccessibleAction *obj);
 444 char      *AccessibleAction_getName        (AccessibleAction *obj,
 445                                             long int          i);
 446 char      *AccessibleAction_getDescription (AccessibleAction *obj,
 447                                             long int          i);
 448 SPIBoolean AccessibleAction_doAction       (AccessibleAction *obj,
 449                                             long int          i);
 450 char      *AccessibleAction_getKeyBinding  (AccessibleAction *obj,
 451                                             long int          i);
 452
 453 /* AccessibleApplication function prototypes  */
 454
 455 void       AccessibleApplication_ref            (AccessibleApplication *obj);
 456 void       AccessibleApplication_unref          (AccessibleApplication *obj);
 457 char      *AccessibleApplication_getToolkitName (AccessibleApplication *obj);
 458 char      *AccessibleApplication_getVersion     (AccessibleApplication *obj);
 459 long       AccessibleApplication_getID          (AccessibleApplication *obj);
 460 SPIBoolean AccessibleApplication_pause          (AccessibleApplication *obj);
 461 SPIBoolean AccessibleApplication_resume         (AccessibleApplication *obj);
 462
 463 /* AccessibleComponent function prototypes */
 464
 465 void        AccessibleComponent_ref         (AccessibleComponent *obj);
 466 void        AccessibleComponent_unref       (AccessibleComponent *obj);
 467 SPIBoolean  AccessibleComponent_contains    (AccessibleComponent *obj,
 468                                              long int             x,
 469                                              long int             y,
 470                                              AccessibleCoordType  ctype);
 471 Accessible *AccessibleComponent_getAccessibleAtPoint (
 472                                              AccessibleComponent *obj,
 473                                              long int             x,
 474                                              long int             y,
 475                                              AccessibleCoordType  ctype);
 476 void        AccessibleComponent_getExtents  (AccessibleComponent *obj,
 477                                              long int            *x,
 478                                              long int            *y,
 479                                              long int            *width,
 480                                              long int            *height,
 481                                              AccessibleCoordType  ctype);
 482 void        AccessibleComponent_getPosition (AccessibleComponent *obj,
 483                                              long int            *x,
 484                                              long int            *y,
 485                                              AccessibleCoordType  ctype);
 486 void        AccessibleComponent_getSize     (AccessibleComponent *obj,
 487                                              long int            *width,
 488                                              long int            *height);
 489 AccessibleComponentLayer
 490             AccessibleComponent_getLayer    (AccessibleComponent *obj);
 491 SPIBoolean  AccessibleComponent_grabFocus   (AccessibleComponent *obj);
 492 short       AccessibleComponent_getMDIZOrder(AccessibleComponent *obj);
 493
 494 /* AccessibleEditableText function prototypes  */
 495
 496 void
 497 AccessibleEditableText_ref (AccessibleEditableText *obj);
 498
 499 void
 500 AccessibleEditableText_unref (AccessibleEditableText *obj);
 501
 502 SPIBoolean
 503 AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
 504                                       const char *attributes,
 505                                       long int startOffset,
 506                                       long int endOffset);
 507
 508 SPIBoolean
 509 AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
 510                                         const char *newContents);
 511
 512 SPIBoolean
 513 AccessibleEditableText_insertText (AccessibleEditableText *obj,
 514                                    long int position,
 515                                    const char *text,
 516                                    long int length);
 517
 518 SPIBoolean
 519 AccessibleEditableText_copyText (AccessibleText *obj,
 520                                  long int startPos,
 521                                  long int endPos);
 522
 523 SPIBoolean
 524 AccessibleEditableText_cutText (AccessibleEditableText *obj,
 525                                 long int startPos,
 526                                 long int endPos);
 527
 528 SPIBoolean
 529 AccessibleEditableText_deleteText (AccessibleEditableText *obj,
 530                                    long int startPos,
 531                                    long int endPos);
 532
 533 SPIBoolean
 534 AccessibleEditableText_pasteText (AccessibleEditableText *obj,
 535                                   long int position);
 536
 537 /*
 538  *
 539  * AccessibleHyperlink function prototypes
 540  *
 541  */
 542 void
 543 AccessibleHyperlink_ref (AccessibleHyperlink *obj);
 544 void
 545 AccessibleHyperlink_unref (AccessibleHyperlink *obj);
 546
 547 long
 548 AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
 549
 550 char *
 551 AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
 552                             long int i);
 553
 554 Accessible *
 555 AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
 556                                long int i);
 557
 558 void
 559 AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
 560                                    long int *startIndex,
 561                                    long int *endIndex);
 562
 563 SPIBoolean
 564 AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
 565
 566 /*
 567  *
 568  * AccessibleHypertext function prototypes
 569  *
 570  */
 571
 572 void
 573 AccessibleHypertext_ref (AccessibleHypertext *obj);
 574
 575 void
 576 AccessibleHypertext_unref (AccessibleHypertext *obj);
 577
 578 long
 579 AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
 580
 581 AccessibleHyperlink *
 582 AccessibleHypertext_getLink (AccessibleHypertext *obj,
 583                              long int linkIndex);
 584
 585 long
 586 AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
 587                                   long int characterOffset);
 588
 589 /*
 590  *
 591  * AccessibleImage function prototypes
 592  *
 593  */
 594
 595 void
 596 AccessibleImage_ref (AccessibleImage *obj);
 597
 598 void
 599 AccessibleImage_unref (AccessibleImage *obj);
 600
 601 char *
 602 AccessibleImage_getImageDescription (AccessibleImage *obj);
 603
 604 void
 605 AccessibleImage_getImageSize (AccessibleImage *obj,
 606                               long int *width,
 607                               long int *height);
 608
 609 void
 610 AccessibleImage_getImagePosition (AccessibleImage *obj,
 611                                   long int *x,
 612                                   long int *y,
 613                                   AccessibleCoordType ctype);
 614
 615 void
 616 AccessibleImage_getImageExtents (AccessibleImage *obj,
 617                                  long int *x,
 618                                  long int *y,
 619                                  long int *width,
 620                                  long int *height,
 621                                  AccessibleCoordType ctype);
 622 /*
 623  *
 624  * AccessibleRelation function prototypes
 625  *
 626  */
 627
 628 void AccessibleRelation_ref   (AccessibleRelation *obj);
 629 void AccessibleRelation_unref (AccessibleRelation *obj);
 630
 631 AccessibleRelationType
 632 AccessibleRelation_getRelationType (AccessibleRelation *obj);
 633
 634 int
 635 AccessibleRelation_getNTargets (AccessibleRelation *obj);
 636
 637 Accessible *
 638 AccessibleRelation_getTarget (AccessibleRelation *obj, int i);
 639
 640
 641 /*
 642  *
 643  * AccessibleSelection function prototypes
 644  *
 645  */
 646
 647 void AccessibleSelection_ref   (AccessibleSelection *obj);
 648 void AccessibleSelection_unref (AccessibleSelection *obj);
 649
 650 long
 651 AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj);
 652
 653 Accessible *
 654 AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
 655                                       long int selectedChildIndex);
 656
 657 SPIBoolean
 658 AccessibleSelection_selectChild (AccessibleSelection *obj,
 659                                  long int childIndex);
 660
 661 SPIBoolean
 662 AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
 663                                            long int selectedChildIndex);
 664
 665 SPIBoolean
 666 AccessibleSelection_isChildSelected (AccessibleSelection *obj,
 667                                      long int childIndex);
 668
 669 SPIBoolean
 670 AccessibleSelection_selectAll (AccessibleSelection *obj);
 671
 672 SPIBoolean
 673 AccessibleSelection_clearSelection (AccessibleSelection *obj);
 674
 675
 676 /*
 677  *
 678  * AccessibleStateSet function prototypes
 679  *
 680  */
 681
 682 void AccessibleStateSet_ref   (AccessibleStateSet *obj);
 683 void AccessibleStateSet_unref (AccessibleStateSet *obj);
 684
 685 SPIBoolean
 686 AccessibleStateSet_contains (AccessibleStateSet *obj,
 687                              AccessibleState state);
 688
 689 void
 690 AccessibleStateSet_add (AccessibleStateSet *obj,
 691                         AccessibleState state);
 692
 693 void
 694 AccessibleStateSet_remove (AccessibleStateSet *obj,
 695                            AccessibleState state);
 696
 697 SPIBoolean
 698 AccessibleStateSet_equals (AccessibleStateSet *obj,
 699                            AccessibleStateSet *obj2);
 700
 701 AccessibleStateSet *
 702 AccessibleStateSet_compare (AccessibleStateSet *obj,
 703                             AccessibleStateSet *obj2);
 704
 705 SPIBoolean
 706 AccessibleStateSet_isEmpty (AccessibleStateSet *obj);
 707
 708 void
 709 AccessibleStreamableContent_ref (AccessibleStreamableContent *obj);
 710 void
 711 AccessibleStreamableContent_unref (AccessibleStreamableContent *obj);
 712 char **
 713 AccessibleStreamableContent_getContentTypes (AccessibleStreamableContent *obj);
 714 SPIBoolean
 715 AccessibleStreamableContent_open (AccessibleStreamableContent *obj,
 716                                   const char *content_type);
 717 SPIBoolean
 718 AccessibleStreamableContent_close (AccessibleStreamableContent *obj);
 719 SPIBoolean
 720 AccessibleStreamableContent_seek (AccessibleStreamableContent *obj,
 721                                   long int offset,
 722                                   unsigned int seek_type);
 723 SPIBoolean
 724 AccessibleStreamableContent_read (AccessibleStreamableContent *obj,
 725                                   void *buff,
 726                                   long int nbytes,
 727                                   unsigned int read_type);
 728 /*
 729  *
 730  * AccessibleTable function prototypes
 731  *
 732  */
 733
 734 void AccessibleTable_ref   (AccessibleTable *obj);
 735 void AccessibleTable_unref (AccessibleTable *obj);
 736
 737 Accessible *
 738 AccessibleTable_getCaption (AccessibleTable *obj);
 739
 740 Accessible *
 741 AccessibleTable_getSummary (AccessibleTable *obj);
 742
 743 long
 744 AccessibleTable_getNRows (AccessibleTable *obj);
 745
 746 long
 747 AccessibleTable_getNColumns (AccessibleTable *obj);
 748
 749 Accessible *
 750 AccessibleTable_getAccessibleAt (AccessibleTable *obj,
 751                                  long int row,
 752                                  long int column);
 753
 754 long
 755 AccessibleTable_getIndexAt (AccessibleTable *obj,
 756                             long int row,
 757                             long int column);
 758
 759 long
 760 AccessibleTable_getRowAtIndex (AccessibleTable *obj,
 761                                long int index);
 762
 763 long
 764 AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
 765                                   long int index);
 766
 767 char *
 768 AccessibleTable_getRowDescription (AccessibleTable *obj,
 769                                    long int row);
 770
 771 char *
 772 AccessibleTable_getColumnDescription (AccessibleTable *obj,
 773                                       long int column);
 774
 775 long
 776 AccessibleTable_getRowExtentAt (AccessibleTable *obj,
 777                                 long int row,
 778                                 long int column);
 779
 780 long
 781 AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
 782                                    long int row,
 783                                    long int column);
 784
 785 Accessible *
 786 AccessibleTable_getRowHeader (AccessibleTable *obj,
 787                               long int row);
 788
 789 Accessible *
 790 AccessibleTable_getColumnHeader (AccessibleTable *obj,
 791                                  long int column);
 792
 793 long
 794 AccessibleTable_getNSelectedRows (AccessibleTable *obj);
 795
 796 long
 797 AccessibleTable_getSelectedRows (AccessibleTable *obj,
 798                                  long int **selectedRows);
 799
 800 long
 801 AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
 802
 803 long
 804 AccessibleTable_getSelectedColumns (AccessibleTable *obj,
 805                                     long int **selectedColumns);
 806
 807 SPIBoolean
 808 AccessibleTable_isRowSelected (AccessibleTable *obj,
 809                                long int row);
 810
 811 SPIBoolean
 812 AccessibleTable_isColumnSelected (AccessibleTable *obj,
 813                                   long int column);
 814
 815 SPIBoolean
 816 AccessibleTable_isSelected (AccessibleTable *obj,
 817                             long int row,
 818                             long int column);
 819
 820 /*
 821  *
 822  * AccessibleText function prototypes
 823  *
 824  */
 825
 826 void AccessibleText_ref   (AccessibleText *obj);
 827 void AccessibleText_unref (AccessibleText *obj);
 828
 829 long
 830 AccessibleText_getCharacterCount (AccessibleText *obj);
 831
 832 char *
 833 AccessibleText_getText (AccessibleText *obj,
 834                         long int startOffset,
 835                         long int endOffset);
 836
 837 long
 838 AccessibleText_getCaretOffset (AccessibleText *obj);
 839
 840 char *
 841 AccessibleText_getAttributes (AccessibleText *obj,
 842                                  long int offset,
 843                                  long int *startOffset,
 844                                  long int *endOffset);
 845
 846 char *
 847 AccessibleText_getDefaultAttributes (AccessibleText *obj);
 848
 849 SPIBoolean
 850 AccessibleText_setCaretOffset (AccessibleText *obj,
 851                                long int newOffset);
 852
 853 char *
 854 AccessibleText_getTextBeforeOffset (AccessibleText *obj,
 855                                     long int offset,
 856                                     AccessibleTextBoundaryType type,
 857                                     long int *startOffset,
 858                                     long int *endOffset);
 859
 860 char *
 861 AccessibleText_getTextAtOffset (AccessibleText *obj,
 862                                 long int offset,
 863                                 AccessibleTextBoundaryType type,
 864                                 long int *startOffset,
 865                                 long int *endOffset);
 866
 867 char *
 868 AccessibleText_getTextAfterOffset (AccessibleText *obj,
 869                                    long int offset,
 870                                    AccessibleTextBoundaryType type,
 871                                    long int *startOffset,
 872                                    long int *endOffset);
 873
 874 unsigned long
 875 AccessibleText_getCharacterAtOffset (AccessibleText *obj,
 876                                      long int offset);
 877
 878 void
 879 AccessibleText_getCharacterExtents (AccessibleText *obj,
 880                                     long int offset,
 881                                     long int *x,
 882                                     long int *y,
 883                                     long int *width,
 884                                     long int *height,
 885                                     AccessibleCoordType type);
 886
 887 void
 888 AccessibleText_getRangeExtents (AccessibleText *obj,
 889                                 long int startOffset,
 890                                 long int endOffset,
 891                                 long int *x,
 892                                 long int *y,
 893                                 long int *width,
 894                                 long int *height,
 895                                 AccessibleCoordType type);
 896
 897 AccessibleTextRange **
 898 AccessibleText_getBoundedRanges (AccessibleText *obj,
 899                                  long int x,
 900                                  long int y,
 901                                  long int width,
 902                                  long int height,
 903                                  AccessibleCoordType type,
 904                                  AccessibleTextClipType clipTypeX,
 905                                  AccessibleTextClipType clipTypeY);
 906
 907 void
 908 AccessibleTextRange_freeRanges (AccessibleTextRange **ranges);
 909
 910 long
 911 AccessibleText_getOffsetAtPoint (AccessibleText *obj,
 912                                  long int x,
 913                                  long int y,
 914                                  AccessibleCoordType type);
 915
 916 long
 917 AccessibleText_getNSelections (AccessibleText *obj);
 918
 919 void
 920 AccessibleText_getSelection (AccessibleText *obj,
 921                              long int selectionNum,
 922                              long int *startOffset,
 923                              long int *endOffset);
 924
 925
 926 SPIBoolean
 927 AccessibleText_addSelection (AccessibleText *obj,
 928                              long int startOffset,
 929                              long int endOffset);
 930
 931 SPIBoolean
 932 AccessibleText_removeSelection (AccessibleText *obj,
 933                                 long int selectionNum);
 934
 935 SPIBoolean
 936 AccessibleText_setSelection (AccessibleText *obj,
 937                              long int selectionNum,
 938                              long int startOffset,
 939                              long int endOffset);
 940
 941 /* AccessibleValue Function Prototypes:  */
 942
 943 void       AccessibleValue_ref             (AccessibleValue *obj);
 944 void       AccessibleValue_unref           (AccessibleValue *obj);
 945 double     AccessibleValue_getMinimumValue (AccessibleValue *obj);
 946 double     AccessibleValue_getCurrentValue (AccessibleValue *obj);
 947 double     AccessibleValue_getMaximumValue (AccessibleValue *obj);
 948 SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj,
 949                                             double           newValue);
 950
 951 /* Persistance and lifecycle control for AccessibleEvents. */
 952 SPIBoolean AccessibleEvent_ref (const AccessibleEvent *e);
 953 void AccessibleEvent_unref (const AccessibleEvent *e);
 954
 955 /*
 956  * Prototypes for accessor functions, to obtain context
 957  * information for accessible events.
 958  */
 959
 960 char*        AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e);
 961 Accessible * AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e);
 962
 963 Accessible * AccessibleParentChangedEvent_getParentAccessible (const AccessibleEvent *e);
 964
 965 char*        AccessibleTextSelectionChangedEvent_getSelectionString (const AccessibleEvent *e);
 966
 967 char*        AccessibleWindowEvent_getTitleString (const AccessibleEvent *e);
 968
 969 Accessible * AccessibleActiveDescendantChangedEvent_getActiveDescendant (const AccessibleEvent *e);
 970
 971 Accessible * AccessibleTableSummaryChangedEvent_getSummaryAccessible (const AccessibleEvent *e);
 972
 973 Accessible * AccessibleTableHeaderChangedEvent_getHeaderAccessible (const AccessibleEvent *e);
 974
 975 char *       AccessibleTableCaptionChangedEvent_getCaptionString (const AccessibleEvent *e);
 976
 977 char *       AccessibleTableRowDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
 978
 979 char *       AccessibleTableColumnDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
 980
 981 char *       AccessibleDescriptionChangedEvent_getDescriptionString (const AccessibleEvent *e);
 982
 983 char *       AccessibleNameChangedEvent_getNameString (const AccessibleEvent *e);
 984
 985 /* Misc methods and error handling */
 986 void SPI_freeString (char *s);
 987
 988 char* SPI_dupString (char *s);
 989
 990 SPIBoolean SPI_exceptionHandlerPush (SPIExceptionHandler *handler);
 991
 992 SPIExceptionHandler* SPI_exceptionHandlerPop (void);
 993
 994 SPIExceptionType SPIException_getSourceType (SPIException *err);
 995
 996 SPIExceptionCode SPIException_getExceptionCode (SPIException *err);
 997
 998 Accessible* SPIAccessibleException_getSource (SPIException *err);
 999
1000 char* SPIException_getDescription (SPIException *err);
1001
1002 #ifdef  __cplusplus
1003 }
1004 #endif
1005
1006 #endif