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  * Enumerated type for text boundary types
  47  */
  48 typedef enum
  49 {
  50   SPI_TEXT_BOUNDARY_CHAR,
  51   SPI_TEXT_BOUNDARY_CURSOR_POS,
  52   SPI_TEXT_BOUNDARY_WORD_START,
  53   SPI_TEXT_BOUNDARY_WORD_END,
  54   SPI_TEXT_BOUNDARY_SENTENCE_START,
  55   SPI_TEXT_BOUNDARY_SENTENCE_END,
  56   SPI_TEXT_BOUNDARY_LINE_START,
  57   SPI_TEXT_BOUNDARY_LINE_END,
  58   SPI_TEXT_BOUNDARY_ATTRIBUTE_RANGE
  59 } AccessibleTextBoundaryType;
  60
  61 /*
  62  *
  63  * Enumerated type for relation types
  64  *
  65  */
  66
  67 typedef enum
  68 {
  69   SPI_RELATION_NULL,
  70   SPI_RELATION_LABEL_FOR,
  71   SPI_RELATION_LABELED_BY,
  72   SPI_RELATION_CONTROLLER_FOR,
  73   SPI_RELATION_CONTROLLED_BY,
  74   SPI_RELATION_MEMBER_OF,
  75   SPI_RELATION_NODE_CHILD_OF,
  76   SPI_RELATION_EXTENDED,
  77   SPI_RELATION_FLOWS_TO,
  78   SPI_RELATION_FLOWS_FROM,
  79   SPI_RELATION_SUBWINDOW_OF,
  80   SPI_RELATION_EMBEDS,
  81   SPI_RELATION_EMBEDDED_BY,
  82   SPI_RELATION_LAST_DEFINED
  83 } AccessibleRelationType;
  84
  85
  86 /* don't change the order of these ! */
  87 typedef enum {
  88   SPI_COORD_TYPE_SCREEN,
  89   SPI_COORD_TYPE_WINDOW
  90 } AccessibleCoordType;
  91
  92 typedef enum {
  93   SPI_KEY_PRESS,
  94   SPI_KEY_RELEASE,
  95   SPI_KEY_PRESSRELEASE,
  96   SPI_KEY_SYM,
  97   SPI_KEY_STRING
  98 } AccessibleKeySynthType;
  99
 100 typedef enum {
 101   SPI_KEYLISTENER_NOSYNC = 0,
 102   SPI_KEYLISTENER_SYNCHRONOUS = 1,
 103   SPI_KEYLISTENER_CANCONSUME = 2,
 104   SPI_KEYLISTENER_ALL_WINDOWS = 4
 105 } AccessibleKeyListenerSyncType;
 106
 107 typedef unsigned long AccessibleKeyEventMask;
 108 typedef unsigned long AccessibleDeviceEventMask;
 109
 110 /**
 111  * AccessibleComponentLayer:
 112  * @SPI_LAYER_INVALID: The layer cannot be determined or is somehow undefined.
 113  * @SPI_LAYER_BACKGROUND: Component belongs to the destop background.
 114  * @SPI_LAYER_CANVAS: Component is a canvas backdrop or drawing area.
 115  * @SPI_LAYER_WIDGET: Component is a 'normal' widget.
 116  * @SPI_LAYER_MDI: Component is drawn in the MDI layer and may have valid
 117  *                          Z-information relative to other MDI-layer components.
 118  * @SPI_LAYER_POPUP: Component is in the popup layer, above other widgets and
 119  *                          MDI components.
 120  * @SPI_LAYER_OVERLAY: Component is in the overlay plane - this value is reserved
 121  *                          for future use.
 122  * @SPI_LAYER_WINDOW: Component is in the window layer and have valid Z-information
 123  *                    relative to other window-layer components.
 124  * @SPI_LAYER_LAST_DEFINED: Used to determine the last valid value in the enum,
 125  *                          should not be encountered.
 126  **/
 127 typedef enum {
 128     SPI_LAYER_INVALID,
 129     SPI_LAYER_BACKGROUND,
 130     SPI_LAYER_CANVAS,
 131     SPI_LAYER_WIDGET,
 132     SPI_LAYER_MDI,
 133     SPI_LAYER_POPUP,
 134     SPI_LAYER_OVERLAY,
 135     SPI_LAYER_WINDOW,
 136     SPI_LAYER_LAST_DEFINED
 137 } AccessibleComponentLayer;
 138
 139
 140 /**
 141  * AccessibleKeySet:
 142  * @keysyms:
 143  * @keycodes:
 144  * @len:
 145  *
 146  * Structure containing identifying information about a set of keycode or
 147  *        keysyms.
 148  **/
 149 typedef struct _AccessibleKeySet
 150 {
 151   unsigned long  *keysyms;
 152   unsigned short *keycodes;
 153   char          **keystrings;
 154   short           len;
 155 } AccessibleKeySet;
 156
 157 /**
 158  * SPI_KEYSET_ALL_KEYS:
 159  * @SPI_KEYSET_ALL_KEYS: A special value for an AccessibleKeySet type, which tacitly
 160  *                       includes all keycodes and keyvals for the specified modifier set.
 161  **/
 162 #define SPI_KEYSET_ALL_KEYS NULL
 163
 164 typedef unsigned long AccessibleModifierMaskType;
 165 typedef AccessibleModifierMaskType AccessibleKeyMaskType;
 166
 167 /* Basic SPI initialization and event loop function prototypes */
 168
 169 int              SPI_init         (void);
 170 void             SPI_event_main   (void);
 171 void             SPI_event_quit   (void);
 172 SPIBoolean       SPI_eventIsReady (void);
 173 AccessibleEvent *SPI_nextEvent    (SPIBoolean waitForEvent);
 174 int              SPI_exit         (void);
 175
 176 /* Event Listener creation and support.  */
 177
 178 void                      SPI_freeAccessibleKeySet (
 179                                                    AccessibleKeySet         *keyset);
 180 AccessibleKeySet        * SPI_createAccessibleKeySet (
 181                                                    int                       len,
 182                                                    const char               *keysyms,
 183                                                    short                    *keycodes,
 184                                                    const char              **keystrings);
 185 AccessibleEventListener * SPI_createAccessibleEventListener (
 186                                                    AccessibleEventListenerCB callback,
 187                                                    void                     *user_data);
 188 SPIBoolean                AccessibleEventListener_addCallback (
 189                                                    AccessibleEventListener  *listener,
 190                                                    AccessibleEventListenerCB callback,
 191                                                    void                     *user_data);
 192 SPIBoolean                AccessibleEventListener_removeCallback (
 193                                                    AccessibleEventListener  *listener,
 194                                                    AccessibleEventListenerCB callback);
 195 void                      AccessibleEventListener_unref (
 196                                                    AccessibleEventListener  *listener);
 197
 198 /* Device Event Listener creation and support.  */
 199
 200 /* First four are deprecated in favor of the last four; really just a re-name */
 201
 202 AccessibleKeystrokeListener * SPI_createAccessibleKeystrokeListener (
 203                                         AccessibleKeystrokeListenerCB callback,
 204                                         void                         *user_data);
 205 SPIBoolean                    AccessibleKeystrokeListener_addCallback (
 206                                         AccessibleKeystrokeListener  *listener,
 207                                         AccessibleKeystrokeListenerCB callback,
 208                                         void                         *user_data);
 209 SPIBoolean                    AccessibleKeystrokeListener_removeCallback (
 210                                         AccessibleKeystrokeListener *listener,
 211                                         AccessibleKeystrokeListenerCB callback);
 212 void                          AccessibleKeystrokeListener_unref (
 213                                         AccessibleKeystrokeListener *listener);
 214
 215 AccessibleDeviceListener   * SPI_createAccessibleDeviceListener (
 216                                         AccessibleDeviceListenerCB callback,
 217                                         void                      *user_data);
 218 SPIBoolean                    AccessibleDeviceListener_addCallback (
 219                                         AccessibleDeviceListener  *listener,
 220                                         AccessibleDeviceListenerCB callback,
 221                                         void                      *user_data);
 222 SPIBoolean                    AccessibleDeviceListener_removeCallback (
 223                                         AccessibleDeviceListener  *listener,
 224                                         AccessibleDeviceListenerCB callback);
 225 void                          AccessibleDeviceListener_unref (
 226                                         AccessibleDeviceListener *listener);
 227
 228 /* Global functions serviced by the registry */
 229
 230 SPIBoolean SPI_registerGlobalEventListener           (
 231                                        AccessibleEventListener *listener,
 232                                        const char              *eventType);
 233 SPIBoolean SPI_deregisterGlobalEventListener         (
 234                                        AccessibleEventListener *listener,
 235                                        const char              *eventType);
 236 SPIBoolean SPI_deregisterGlobalEventListenerAll      (
 237                                        AccessibleEventListener *listener);
 238 SPIBoolean SPI_registerAccessibleKeystrokeListener   (
 239                                        AccessibleKeystrokeListener *listener,
 240                                        AccessibleKeySet             *keys,
 241                                        AccessibleKeyMaskType         modmask,
 242                                        AccessibleKeyEventMask        eventmask,
 243                                        AccessibleKeyListenerSyncType sync_type);
 244 SPIBoolean SPI_deregisterAccessibleKeystrokeListener (
 245                                        AccessibleKeystrokeListener *listener,
 246                                        AccessibleKeyMaskType        modmask);
 247
 248 SPIBoolean SPI_registerDeviceEventListener   (
 249                                        AccessibleDeviceListener   *listener,
 250                                        AccessibleDeviceEventMask   eventmask,
 251                                        void                       *filter);
 252 SPIBoolean SPI_deregisterDeviceEventListener (
 253                                        AccessibleDeviceListener   *listener,
 254                                        void                       *filter);
 255
 256 int         SPI_getDesktopCount                  (void);
 257 Accessible *SPI_getDesktop                       (int i);
 258 int         SPI_getDesktopList                   (Accessible ***desktop_list);
 259 void        SPI_freeDesktopList                  (Accessible  **desktop_list);
 260
 261 SPIBoolean  SPI_generateKeyboardEvent            (long int                    keyval,
 262                                                   char                       *keystring,
 263                                                   AccessibleKeySynthType      synth_type);
 264
 265 SPIBoolean  SPI_generateMouseEvent               (long int x, long int y, char *name);
 266
 267 /* Accessible function prototypes  */
 268
 269 void                 Accessible_ref              (Accessible *obj);
 270 void                 Accessible_unref            (Accessible *obj);
 271 char *               Accessible_getName          (Accessible *obj);
 272 char *               Accessible_getDescription   (Accessible *obj);
 273 Accessible *         Accessible_getParent        (Accessible *obj);
 274 long                 Accessible_getChildCount    (Accessible *obj);
 275 Accessible *         Accessible_getChildAtIndex  (Accessible *obj,
 276                                                   long int    childIndex);
 277 long                 Accessible_getIndexInParent (Accessible *obj);
 278 AccessibleRelation **Accessible_getRelationSet   (Accessible *obj);
 279 AccessibleRole       Accessible_getRole          (Accessible *obj);
 280 char *               Accessible_getRoleName      (Accessible *obj);
 281 AccessibleStateSet * Accessible_getStateSet      (Accessible *obj);
 282
 283 /* Interface query methods */
 284
 285 SPIBoolean Accessible_isAction            (Accessible *obj);
 286 SPIBoolean Accessible_isApplication       (Accessible *obj);
 287 SPIBoolean Accessible_isComponent         (Accessible *obj);
 288 SPIBoolean Accessible_isEditableText      (Accessible *obj);
 289 SPIBoolean Accessible_isHypertext         (Accessible *obj);
 290 SPIBoolean Accessible_isImage             (Accessible *obj);
 291 SPIBoolean Accessible_isSelection         (Accessible *obj);
 292 SPIBoolean Accessible_isStreamableContent (Accessible *obj);
 293 SPIBoolean Accessible_isTable             (Accessible *obj);
 294 SPIBoolean Accessible_isText              (Accessible *obj);
 295 SPIBoolean Accessible_isValue             (Accessible *obj);
 296
 297 AccessibleAction *            Accessible_getAction            (Accessible *obj);
 298 AccessibleApplication *       Accessible_getApplication       (Accessible *obj);
 299 AccessibleComponent *         Accessible_getComponent         (Accessible *obj);
 300 AccessibleEditableText *      Accessible_getEditableText      (Accessible *obj);
 301 AccessibleHypertext *         Accessible_getHypertext         (Accessible *obj);
 302 AccessibleImage *             Accessible_getImage             (Accessible *obj);
 303 AccessibleSelection *         Accessible_getSelection         (Accessible *obj);
 304 AccessibleStreamableContent * Accessible_getStreamableContent (Accessible *obj);
 305 AccessibleTable *             Accessible_getTable             (Accessible *obj);
 306 AccessibleText *              Accessible_getText              (Accessible *obj);
 307 AccessibleValue *             Accessible_getValue             (Accessible *obj);
 308 AccessibleUnknown *           Accessible_queryInterface       (Accessible *obj,
 309                                                    const char *interface_name);
 310
 311 /* AccessibleAction function prototypes  */
 312
 313 void       AccessibleAction_ref            (AccessibleAction *obj);
 314 void       AccessibleAction_unref          (AccessibleAction *obj);
 315 long       AccessibleAction_getNActions    (AccessibleAction *obj);
 316 char      *AccessibleAction_getName        (AccessibleAction *obj,
 317                                             long int          i);
 318 char      *AccessibleAction_getDescription (AccessibleAction *obj,
 319                                             long int          i);
 320 SPIBoolean AccessibleAction_doAction       (AccessibleAction *obj,
 321                                             long int          i);
 322 char      *AccessibleAction_getKeyBinding  (AccessibleAction *obj,
 323                                             long int          i);
 324
 325 /* AccessibleApplication function prototypes  */
 326
 327 void       AccessibleApplication_ref            (AccessibleApplication *obj);
 328 void       AccessibleApplication_unref          (AccessibleApplication *obj);
 329 char      *AccessibleApplication_getToolkitName (AccessibleApplication *obj);
 330 char      *AccessibleApplication_getVersion     (AccessibleApplication *obj);
 331 long       AccessibleApplication_getID          (AccessibleApplication *obj);
 332 SPIBoolean AccessibleApplication_pause          (AccessibleApplication *obj);
 333 SPIBoolean AccessibleApplication_resume         (AccessibleApplication *obj);
 334
 335 /* AccessibleComponent function prototypes */
 336
 337 void        AccessibleComponent_ref         (AccessibleComponent *obj);
 338 void        AccessibleComponent_unref       (AccessibleComponent *obj);
 339 SPIBoolean  AccessibleComponent_contains    (AccessibleComponent *obj,
 340                                              long int             x,
 341                                              long int             y,
 342                                              AccessibleCoordType  ctype);
 343 Accessible *AccessibleComponent_getAccessibleAtPoint (
 344                                              AccessibleComponent *obj,
 345                                              long int             x,
 346                                              long int             y,
 347                                              AccessibleCoordType  ctype);
 348 void        AccessibleComponent_getExtents  (AccessibleComponent *obj,
 349                                              long int            *x,
 350                                              long int            *y,
 351                                              long int            *width,
 352                                              long int            *height,
 353                                              AccessibleCoordType  ctype);
 354 void        AccessibleComponent_getPosition (AccessibleComponent *obj,
 355                                              long int            *x,
 356                                              long int            *y,
 357                                              AccessibleCoordType  ctype);
 358 void        AccessibleComponent_getSize     (AccessibleComponent *obj,
 359                                              long int            *width,
 360                                              long int            *height);
 361 AccessibleComponentLayer
 362             AccessibleComponent_getLayer    (AccessibleComponent *obj);
 363 SPIBoolean  AccessibleComponent_grabFocus   (AccessibleComponent *obj);
 364 short       AccessibleComponent_getMDIZOrder(AccessibleComponent *obj);
 365
 366 /* AccessibleEditableText function prototypes  */
 367
 368 void
 369 AccessibleEditableText_ref (AccessibleEditableText *obj);
 370
 371 void
 372 AccessibleEditableText_unref (AccessibleEditableText *obj);
 373
 374 SPIBoolean
 375 AccessibleEditableText_setAttributes (AccessibleEditableText *obj,
 376                                       const char *attributes,
 377                                       long int startOffset,
 378                                       long int endOffset);
 379
 380 SPIBoolean
 381 AccessibleEditableText_setTextContents (AccessibleEditableText *obj,
 382                                         const char *newContents);
 383
 384 SPIBoolean
 385 AccessibleEditableText_insertText (AccessibleEditableText *obj,
 386                                    long int position,
 387                                    const char *text,
 388                                    long int length);
 389
 390 SPIBoolean
 391 AccessibleEditableText_copyText (AccessibleText *obj,
 392                                  long int startPos,
 393                                  long int endPos);
 394
 395 SPIBoolean
 396 AccessibleEditableText_cutText (AccessibleEditableText *obj,
 397                                 long int startPos,
 398                                 long int endPos);
 399
 400 SPIBoolean
 401 AccessibleEditableText_deleteText (AccessibleEditableText *obj,
 402                                    long int startPos,
 403                                    long int endPos);
 404
 405 SPIBoolean
 406 AccessibleEditableText_pasteText (AccessibleEditableText *obj,
 407                                   long int position);
 408
 409 /*
 410  *
 411  * AccessibleHyperlink function prototypes
 412  *
 413  */
 414 void
 415 AccessibleHyperlink_ref (AccessibleHyperlink *obj);
 416 void
 417 AccessibleHyperlink_unref (AccessibleHyperlink *obj);
 418
 419 long
 420 AccessibleHyperlink_getNAnchors (AccessibleHyperlink *obj);
 421
 422 char *
 423 AccessibleHyperlink_getURI (AccessibleHyperlink *obj,
 424                             long int i);
 425
 426 Accessible *
 427 AccessibleHyperlink_getObject (AccessibleHyperlink *obj,
 428                                long int i);
 429
 430 void
 431 AccessibleHyperlink_getIndexRange (AccessibleHyperlink *obj,
 432                                    long int *startIndex,
 433                                    long int *endIndex);
 434
 435 SPIBoolean
 436 AccessibleHyperlink_isValid (AccessibleHyperlink *obj);
 437
 438 /*
 439  *
 440  * AccessibleHypertext function prototypes
 441  *
 442  */
 443
 444 void
 445 AccessibleHypertext_ref (AccessibleHypertext *obj);
 446
 447 void
 448 AccessibleHypertext_unref (AccessibleHypertext *obj);
 449
 450 long
 451 AccessibleHypertext_getNLinks (AccessibleHypertext *obj);
 452
 453 AccessibleHyperlink *
 454 AccessibleHypertext_getLink (AccessibleHypertext *obj,
 455                              long int linkIndex);
 456
 457 long
 458 AccessibleHypertext_getLinkIndex (AccessibleHypertext *obj,
 459                                   long int characterOffset);
 460
 461 /*
 462  *
 463  * AccessibleImage function prototypes
 464  *
 465  */
 466
 467 void
 468 AccessibleImage_ref (AccessibleImage *obj);
 469
 470 void
 471 AccessibleImage_unref (AccessibleImage *obj);
 472
 473 char *
 474 AccessibleImage_getImageDescription (AccessibleImage *obj);
 475
 476 void
 477 AccessibleImage_getImageSize (AccessibleImage *obj,
 478                               long int *width,
 479                               long int *height);
 480
 481 void
 482 AccessibleImage_getImagePosition (AccessibleImage *obj,
 483                                   long int *x,
 484                                   long int *y,
 485                                   AccessibleCoordType ctype);
 486
 487 void
 488 AccessibleImage_getImageExtents (AccessibleImage *obj,
 489                                  long int *x,
 490                                  long int *y,
 491                                  long int *width,
 492                                  long int *height,
 493                                  AccessibleCoordType ctype);
 494 /*
 495  *
 496  * AccessibleRelation function prototypes
 497  *
 498  */
 499
 500 void AccessibleRelation_ref   (AccessibleRelation *obj);
 501 void AccessibleRelation_unref (AccessibleRelation *obj);
 502
 503 AccessibleRelationType
 504 AccessibleRelation_getRelationType (AccessibleRelation *obj);
 505
 506 int
 507 AccessibleRelation_getNTargets (AccessibleRelation *obj);
 508
 509 Accessible *
 510 AccessibleRelation_getTarget (AccessibleRelation *obj, int i);
 511
 512
 513 /*
 514  *
 515  * AccessibleSelection function prototypes
 516  *
 517  */
 518
 519 void AccessibleSelection_ref   (AccessibleSelection *obj);
 520 void AccessibleSelection_unref (AccessibleSelection *obj);
 521
 522 long
 523 AccessibleSelection_getNSelectedChildren (AccessibleSelection *obj);
 524
 525 Accessible *
 526 AccessibleSelection_getSelectedChild (AccessibleSelection *obj,
 527                                       long int selectedChildIndex);
 528
 529 SPIBoolean
 530 AccessibleSelection_selectChild (AccessibleSelection *obj,
 531                                  long int childIndex);
 532
 533 SPIBoolean
 534 AccessibleSelection_deselectSelectedChild (AccessibleSelection *obj,
 535                                            long int selectedChildIndex);
 536
 537 SPIBoolean
 538 AccessibleSelection_isChildSelected (AccessibleSelection *obj,
 539                                      long int childIndex);
 540
 541 SPIBoolean
 542 AccessibleSelection_selectAll (AccessibleSelection *obj);
 543
 544 SPIBoolean
 545 AccessibleSelection_clearSelection (AccessibleSelection *obj);
 546
 547
 548 /*
 549  *
 550  * AccessibleStateSet function prototypes
 551  *
 552  */
 553
 554 void AccessibleStateSet_ref   (AccessibleStateSet *obj);
 555 void AccessibleStateSet_unref (AccessibleStateSet *obj);
 556
 557 SPIBoolean
 558 AccessibleStateSet_contains (AccessibleStateSet *obj,
 559                              AccessibleState state);
 560
 561 void
 562 AccessibleStateSet_add (AccessibleStateSet *obj,
 563                         AccessibleState state);
 564
 565 void
 566 AccessibleStateSet_remove (AccessibleStateSet *obj,
 567                            AccessibleState state);
 568
 569 SPIBoolean
 570 AccessibleStateSet_equals (AccessibleStateSet *obj,
 571                            AccessibleStateSet *obj2);
 572
 573 AccessibleStateSet *
 574 AccessibleStateSet_compare (AccessibleStateSet *obj,
 575                             AccessibleStateSet *obj2);
 576
 577 SPIBoolean
 578 AccessibleStateSet_isEmpty (AccessibleStateSet *obj);
 579
 580 void
 581 AccessibleStreamableContent_ref (AccessibleStreamableContent *obj);
 582 void
 583 AccessibleStreamableContent_unref (AccessibleStreamableContent *obj);
 584 char **
 585 AccessibleStreamableContent_getContentTypes (AccessibleStreamableContent *obj);
 586 SPIBoolean
 587 AccessibleStreamableContent_open (AccessibleStreamableContent *obj,
 588                                   const char *content_type);
 589 SPIBoolean
 590 AccessibleStreamableContent_seek (AccessibleStreamableContent *obj,
 591                                   long int offset,
 592                                   unsigned int seek_type);
 593 SPIBoolean
 594 AccessibleStreamableContent_read (AccessibleStreamableContent *obj,
 595                                   void *buff,
 596                                   long int nbytes,
 597                                   unsigned int read_type);
 598 /*
 599  *
 600  * AccessibleTable function prototypes
 601  *
 602  */
 603
 604 void AccessibleTable_ref   (AccessibleTable *obj);
 605 void AccessibleTable_unref (AccessibleTable *obj);
 606
 607 Accessible *
 608 AccessibleTable_getCaption (AccessibleTable *obj);
 609
 610 Accessible *
 611 AccessibleTable_getSummary (AccessibleTable *obj);
 612
 613 long
 614 AccessibleTable_getNRows (AccessibleTable *obj);
 615
 616 long
 617 AccessibleTable_getNColumns (AccessibleTable *obj);
 618
 619 Accessible *
 620 AccessibleTable_getAccessibleAt (AccessibleTable *obj,
 621                                  long int row,
 622                                  long int column);
 623
 624 long
 625 AccessibleTable_getIndexAt (AccessibleTable *obj,
 626                             long int row,
 627                             long int column);
 628
 629 long
 630 AccessibleTable_getRowAtIndex (AccessibleTable *obj,
 631                                long int index);
 632
 633 long
 634 AccessibleTable_getColumnAtIndex (AccessibleTable *obj,
 635                                   long int index);
 636
 637 char *
 638 AccessibleTable_getRowDescription (AccessibleTable *obj,
 639                                    long int row);
 640
 641 char *
 642 AccessibleTable_getColumnDescription (AccessibleTable *obj,
 643                                       long int column);
 644
 645 long
 646 AccessibleTable_getRowExtentAt (AccessibleTable *obj,
 647                                 long int row,
 648                                 long int column);
 649
 650 long
 651 AccessibleTable_getColumnExtentAt (AccessibleTable *obj,
 652                                    long int row,
 653                                    long int column);
 654
 655 Accessible *
 656 AccessibleTable_getRowHeader (AccessibleTable *obj,
 657                               long int row);
 658
 659 Accessible *
 660 AccessibleTable_getColumnHeader (AccessibleTable *obj,
 661                                  long int column);
 662
 663 long
 664 AccessibleTable_getNSelectedRows (AccessibleTable *obj);
 665
 666 long
 667 AccessibleTable_getSelectedRows (AccessibleTable *obj,
 668                                  long int **selectedRows);
 669
 670 long
 671 AccessibleTable_getNSelectedColumns (AccessibleTable *obj);
 672
 673 long
 674 AccessibleTable_getSelectedColumns (AccessibleTable *obj,
 675                                     long int **selectedColumns);
 676
 677 SPIBoolean
 678 AccessibleTable_isRowSelected (AccessibleTable *obj,
 679                                long int row);
 680
 681 SPIBoolean
 682 AccessibleTable_isColumnSelected (AccessibleTable *obj,
 683                                   long int column);
 684
 685 SPIBoolean
 686 AccessibleTable_isSelected (AccessibleTable *obj,
 687                             long int row,
 688                             long int column);
 689
 690 /*
 691  *
 692  * AccessibleText function prototypes
 693  *
 694  */
 695
 696 void AccessibleText_ref   (AccessibleText *obj);
 697 void AccessibleText_unref (AccessibleText *obj);
 698
 699 long
 700 AccessibleText_getCharacterCount (AccessibleText *obj);
 701
 702 char *
 703 AccessibleText_getText (AccessibleText *obj,
 704                         long int startOffset,
 705                         long int endOffset);
 706
 707 long
 708 AccessibleText_getCaretOffset (AccessibleText *obj);
 709
 710 char *
 711 AccessibleText_getAttributes (AccessibleText *obj,
 712                                  long int offset,
 713                                  long int *startOffset,
 714                                  long int *endOffset);
 715
 716
 717 SPIBoolean
 718 AccessibleText_setCaretOffset (AccessibleText *obj,
 719                                long int newOffset);
 720
 721 char *
 722 AccessibleText_getTextBeforeOffset (AccessibleText *obj,
 723                                     long int offset,
 724                                     AccessibleTextBoundaryType type,
 725                                     long int *startOffset,
 726                                     long int *endOffset);
 727
 728 char *
 729 AccessibleText_getTextAtOffset (AccessibleText *obj,
 730                                 long int offset,
 731                                 AccessibleTextBoundaryType type,
 732                                 long int *startOffset,
 733                                 long int *endOffset);
 734
 735 char *
 736 AccessibleText_getTextAfterOffset (AccessibleText *obj,
 737                                    long int offset,
 738                                    AccessibleTextBoundaryType type,
 739                                    long int *startOffset,
 740                                    long int *endOffset);
 741
 742 unsigned long
 743 AccessibleText_getCharacterAtOffset (AccessibleText *obj,
 744                                      long int offset);
 745
 746 void
 747 AccessibleText_getCharacterExtents (AccessibleText *obj,
 748                                     long int offset,
 749                                     long int *x,
 750                                     long int *y,
 751                                     long int *width,
 752                                     long int *height,
 753                                     AccessibleCoordType type);
 754
 755 long
 756 AccessibleText_getOffsetAtPoint (AccessibleText *obj,
 757                                  long int x,
 758                                  long int y,
 759                                  AccessibleCoordType type);
 760
 761 long
 762 AccessibleText_getNSelections (AccessibleText *obj);
 763
 764 void
 765 AccessibleText_getSelection (AccessibleText *obj,
 766                              long int selectionNum,
 767                              long int *startOffset,
 768                              long int *endOffset);
 769
 770
 771 SPIBoolean
 772 AccessibleText_addSelection (AccessibleText *obj,
 773                              long int startOffset,
 774                              long int endOffset);
 775
 776 SPIBoolean
 777 AccessibleText_removeSelection (AccessibleText *obj,
 778                                 long int selectionNum);
 779
 780 SPIBoolean
 781 AccessibleText_setSelection (AccessibleText *obj,
 782                              long int selectionNum,
 783                              long int startOffset,
 784                              long int endOffset);
 785
 786 /* AccessibleValue Function Prototypes:  */
 787
 788 void       AccessibleValue_ref             (AccessibleValue *obj);
 789 void       AccessibleValue_unref           (AccessibleValue *obj);
 790 double     AccessibleValue_getMinimumValue (AccessibleValue *obj);
 791 double     AccessibleValue_getCurrentValue (AccessibleValue *obj);
 792 double     AccessibleValue_getMaximumValue (AccessibleValue *obj);
 793 SPIBoolean AccessibleValue_setCurrentValue (AccessibleValue *obj,
 794                                             double           newValue);
 795
 796 /*
 797  * Prototypes for accessor functions, to obtain context
 798  * information for accessible events.
 799  */
 800
 801 char*        AccessibleTextChangedEvent_getChangeString (const AccessibleEvent *e);
 802 Accessible * AccessibleChildChangedEvent_getChildAccessible (const AccessibleEvent *e);
 803
 804 /* Misc methods */
 805 void SPI_freeString (char *s);
 806
 807 #ifdef  __cplusplus
 808 }
 809 #endif
 810
 811 #endif