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