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