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