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