cspi/spi_accessible.c

   1 #define MAX_ROLES 100
   2
   3 static char *role_names [MAX_ROLES] =
   4 {
   5   " ",
   6   "accelerator label",
   7   "alert",
   8   "animation",
   9   "arrow",
  10   "calendar",
  11   "canvas",
  12   "check box",
  13   "menu item",
  14   "color chooser",
  15   "column header",
  16   "combo box",
  17   "date editor",
  18   "desktop icon",
  19   "desktop frame",
  20   "dial",
  21   "dialog",
  22   "directory pane",
  23   "drawing area",
  24   "file chooser",
  25   "filler",
  26   "font chooser",
  27   "frame",
  28   "glass pane",
  29   "HTML container",
  30   "icon",
  31   "image",
  32   "internal frame",
  33   "label",
  34   "layered pane",
  35   "list",
  36   "list item",
  37   "menu",
  38   "menubar",
  39   "menu item",
  40   "option pane",
  41   "page tab",
  42   "page tab list",
  43   "panel",
  44   "password text",
  45   "popup menu",
  46   "progress bar",
  47   "pushbutton",
  48   "radiobutton",
  49   "radio menu item",
  50   "root pane",
  51   "row header",
  52   "scrollbar",
  53   "scrollpane",
  54   "separator",
  55   "slider",
  56   "split pane",
  57   "spin button",
  58   "status bar",
  59   "table",
  60   "table cell",
  61   "table column header",
  62   "table row header",
  63   "tearoff menu item",
  64   "text",
  65   "toggle button",
  66   "toolbar",
  67   "tooltip",
  68   "tree",
  69   " ",
  70   "viewport",
  71   "window",
  72 };
  73
  74 /*
  75  * Returns a localizable string name for an AtkRole enumerated type.
  76  */
  77 char*
  78 Accessible_Role_getName (Accessibility_Role role)
  79 {
  80   if (role < MAX_ROLES) return role_names [(int) role];
  81   else return "";
  82 }
  83
  84
  85
  86 /**
  87  * Accessible_ref:
  88  * @obj: a pointer to the #Accessible object on which to operate.
  89  *
  90  * Increment the reference count for an #Accessible object.
  91  *
  92  * Returns: (no return code implemented yet).
  93  *
  94  **/
  95 int
  96 Accessible_ref (Accessible *obj)
  97 {
  98   Accessibility_Accessible_ref (*obj, &ev);
  99   spi_check_ev (&ev, "ref");
 100   return 0;
 101 }
 102
 103
 104 /**
 105  * Accessible_unref:
 106  * @obj: a pointer to the #Accessible object on which to operate.
 107  *
 108  * Decrement the reference count for an #Accessible object.
 109  *
 110  * Returns: (no return code implemented yet).
 111  *
 112  **/
 113 int
 114 Accessible_unref (Accessible *obj)
 115 {
 116   Accessibility_Accessible_unref (*obj, &ev);
 117   spi_check_ev (&ev, "unref");
 118   return 0;
 119 }
 120
 121 /**
 122  * Accessible_getName:
 123  * @obj: a pointer to the #Accessible object on which to operate.
 124  *
 125  * Get the name of an #Accessible object.
 126  *
 127  * Returns: a UTF-8 string indicating the name of the #Accessible object.
 128  *
 129  **/
 130 char *
 131 Accessible_getName (Accessible *obj)
 132 {
 133   char *retval =
 134     (char *)
 135     Accessibility_Accessible__get_name (*obj, &ev);
 136   spi_check_ev (&ev, "getName");
 137   return retval;
 138 }
 139
 140 /**
 141  * Accessible_getDescription:
 142  * @obj: a pointer to the #Accessible object on which to operate.
 143  *
 144  * Get the description of an #Accessible object.
 145  *
 146  * Returns: a UTF-8 string describing the #Accessible object.
 147  *
 148  **/
 149 char *
 150 Accessible_getDescription (Accessible *obj)
 151 {
 152   char *retval = (char *)
 153     Accessibility_Accessible__get_description (*obj, &ev);
 154   spi_check_ev (&ev, "getDescription");
 155   return retval;
 156 }
 157
 158 /**
 159  * Accessible_getParent:
 160  * @obj: a pointer to the #Accessible object to query.
 161  *
 162  * Get an #Accessible object's parent container.
 163  *
 164  * Returns: a pointer tothe #Accessible object which contains the given
 165  *          #Accessible instance, or NULL if the @obj has no parent container.
 166  *
 167  **/
 168 Accessible *
 169 Accessible_getParent (Accessible *obj)
 170 {
 171   Accessible *retval =
 172       Obj_Add (Accessibility_Accessible__get_parent (*obj, &ev));
 173   spi_check_ev (&ev, "getParent");
 174   return retval;
 175 }
 176
 177 /**
 178  * Accessible_getChildCount:
 179  * @obj: a pointer to the #Accessible object on which to operate.
 180  *
 181  * Get the number of children contained by an #Accessible object.
 182  *
 183  * Returns: a #long indicating the number of #Accessible children
 184  *          contained by an #Accessible object.
 185  *
 186  **/
 187 long
 188 Accessible_getChildCount (Accessible *obj)
 189 {
 190   long retval = (long) Accessibility_Accessible__get_childCount (*obj, &ev);
 191   spi_check_ev (&ev, "getChildCount");
 192   return retval;
 193 }
 194
 195 /**
 196  * Accessible_getChildAtIndex:
 197  * @obj: a pointer to the #Accessible object on which to operate.
 198  * @childIndex: a #long indicating which child is specified.
 199  *
 200  * Get the #Accessible child of an #Accessible object at a given index.
 201  *
 202  * Returns: a pointer to the #Accessible child object at index
 203  *          @childIndex.
 204  *
 205  **/
 206 Accessible *
 207 Accessible_getChildAtIndex (Accessible *obj,
 208                             long int childIndex)
 209 {
 210   Accessible *retval = Obj_Add (Accessibility_Accessible_getChildAtIndex (*obj, childIndex, &ev));
 211   spi_check_ev (&ev, "getChildAtIndex");
 212   return retval;
 213 }
 214
 215 /**
 216  * Accessible_getIndexInParent:
 217  * @obj: a pointer to the #Accessible object on which to operate.
 218  *
 219  * Get the index of an #Accessible object in its containing #Accessible.
 220  *
 221  * Returns: a #long indicating the index of the #Accessible object
 222  *          in its parent (i.e. containing) #Accessible instance,
 223  *          or -1 if @obj has no containing parent.
 224  *
 225  **/
 226 long
 227 Accessible_getIndexInParent (Accessible *obj)
 228 {
 229   long retval = (long) Accessibility_Accessible_getIndexInParent (*obj, &ev);
 230   spi_check_ev (&ev, "getIndexInParent");
 231   return retval;
 232 }
 233
 234 /**
 235  * Accessible_getRelationSet:
 236  * @obj: a pointer to the #Accessible object on which to operate.
 237  *
 238  * Not Yet Implemented.
 239  *
 240  * Returns: a pointer to an array of #AccessibleRelations.
 241  *
 242  **/
 243 AccessibleRelation **
 244 Accessible_getRelationSet (Accessible *obj)
 245 {
 246   return NULL;
 247 }
 248
 249 /**
 250  * Accessible_getRole:
 251  * @obj: a pointer to the #Accessible object on which to operate.
 252  *
 253  * Get the UI role of an #Accessible object.
 254  *
 255  * Returns: a UTF-8 string indicating the UI role of the #Accessible object.
 256  *
 257  **/
 258 char *
 259 Accessible_getRole (Accessible *obj)
 260 {
 261   char *retval = Accessible_Role_getName (
 262                   Accessibility_Accessible_getRole (*obj, &ev));
 263   spi_check_ev (&ev, "getRole");
 264   return retval;
 265 }
 266
 267 /**
 268  * Accessible_getStateSet:
 269  * @obj: a pointer to the #Accessible object on which to operate.
 270  *
 271  * Not Yet Implemented.
 272  *
 273  * Returns: a pointer to an #AccessibleStateSet representing the object's current state.
 274  **/
 275 AccessibleStateSet *
 276 Accessible_getStateSet (Accessible *obj)
 277 {
 278   return NULL;
 279 }
 280
 281 /* Interface query methods */
 282
 283 /**
 284  * Accessible_isAction:
 285  * @obj: a pointer to the #Accessible instance to query.
 286  *
 287  * Query whether the specified #Accessible implements #AccessibleAction.
 288  *
 289  * Returns: #TRUE if @obj implements the #AccessibleAction interface,
 290  *          #FALSE otherwise.
 291  **/
 292 boolean
 293 Accessible_isAction (Accessible *obj)
 294 {
 295   Bonobo_Unknown iface =
 296     Accessibility_Accessible_queryInterface (*obj,
 297                                              "IDL:Accessibility/Action:1.0",
 298                                              &ev);
 299   spi_warn_ev (&ev, "isAction");
 300
 301   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 302 }
 303
 304 /**
 305  * Accessible_isComponent:
 306  * @obj: a pointer to the #Accessible instance to query.
 307  *
 308  * Query whether the specified #Accessible implements #AccessibleComponent.
 309  *
 310  * Returns: #TRUE if @obj implements the #AccessibleComponent interface,
 311  *          #FALSE otherwise.
 312  **/
 313 boolean
 314 Accessible_isComponent (Accessible *obj)
 315 {
 316   Bonobo_Unknown iface =
 317     Accessibility_Accessible_queryInterface (*obj,
 318                                              "IDL:Accessibility/Component:1.0",
 319                                              &ev);
 320   spi_warn_ev (&ev, "isComponent");
 321
 322   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 323 }
 324
 325 /**
 326  * Accessible_isEditableText:
 327  * @obj: a pointer to the #Accessible instance to query.
 328  *
 329  * Query whether the specified #Accessible implements #AccessibleEditableText.
 330  *
 331  * Returns: #TRUE if @obj implements the #AccessibleEditableText interface,
 332  *          #FALSE otherwise.
 333  **/
 334 boolean
 335 Accessible_isEditableText (Accessible *obj)
 336 {
 337   Bonobo_Unknown iface =
 338     Accessibility_Accessible_queryInterface (*obj,
 339                                              "IDL:Accessibility/EditableText:1.0",
 340                                              &ev);
 341   spi_check_ev (&ev, "isEditableText");
 342
 343   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 344 }
 345
 346 /**
 347  * Accessible_isHypertext:
 348  * @obj: a pointer to the #Accessible instance to query.
 349  *
 350  * Query whether the specified #Accessible implements #AccessibleHypertext.
 351  *
 352  * Returns: #TRUE if @obj implements the #AccessibleHypertext interface,
 353  *          #FALSE otherwise.
 354  **/
 355 boolean
 356 Accessible_isHypertext (Accessible *obj)
 357 {
 358   Bonobo_Unknown iface =
 359     Accessibility_Accessible_queryInterface (*obj,
 360                                              "IDL:Accessibility/Hypertext:1.0",
 361                                              &ev);
 362
 363   spi_check_ev (&ev, "isHypertext");
 364
 365   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 366 }
 367
 368 /**
 369  * Accessible_isImage:
 370  * @obj: a pointer to the #Accessible instance to query.
 371  *
 372  * Query whether the specified #Accessible implements #AccessibleImage.
 373  *
 374  * Returns: #TRUE if @obj implements the #AccessibleImage interface,
 375  *          #FALSE otherwise.
 376 **/
 377 boolean
 378 Accessible_isImage (Accessible *obj)
 379 {
 380   Bonobo_Unknown iface =
 381     Accessibility_Accessible_queryInterface (*obj,
 382                                              "IDL:Accessibility/Image:1.0",
 383                                              &ev);
 384   spi_check_ev (&ev, "isImage");
 385
 386   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 387 }
 388
 389 /**
 390  * Accessible_isSelection:
 391  * @obj: a pointer to the #Accessible instance to query.
 392  *
 393  * Query whether the specified #Accessible implements #AccessibleSelection.
 394  *
 395  * Returns: #TRUE if @obj implements the #AccessibleSelection interface,
 396  *          #FALSE otherwise.
 397 **/
 398 boolean
 399 Accessible_isSelection (Accessible *obj)
 400 {
 401   Bonobo_Unknown iface =
 402     Accessibility_Accessible_queryInterface (*obj,
 403                                              "IDL:Accessibility/Selection:1.0",
 404                                              &ev);
 405   spi_warn_ev (&ev, "isSelection");
 406
 407   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 408
 409 }
 410
 411 /**
 412  * Accessible_isTable:
 413  * @obj: a pointer to the #Accessible instance to query.
 414  *
 415  * Query whether the specified #Accessible implements #AccessibleTable.
 416  *
 417  * Returns: #TRUE if @obj implements the #AccessibleTable interface,
 418  *          #FALSE otherwise.
 419 **/
 420 boolean
 421 Accessible_isTable (Accessible *obj)
 422 {
 423   Bonobo_Unknown iface =
 424     Accessibility_Accessible_queryInterface (*obj,
 425                                              "IDL:Accessibility/Table:1.0",
 426                                              &ev);
 427   spi_check_ev (&ev, "isTable");
 428
 429   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 430
 431 }
 432
 433 /**
 434  * Accessible_isText:
 435  * @obj: a pointer to the #Accessible instance to query.
 436  *
 437  * Query whether the specified #Accessible implements #AccessibleText.
 438  *
 439  * Returns: #TRUE if @obj implements the #AccessibleText interface,
 440  *          #FALSE otherwise.
 441 **/
 442 boolean
 443 Accessible_isText (Accessible *obj)
 444 {
 445   Bonobo_Unknown iface =
 446     Accessibility_Accessible_queryInterface (*obj,
 447                                              "IDL:Accessibility/Text:1.0",
 448                                              &ev);
 449   spi_warn_ev (&ev, "isText");
 450
 451   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 452 }
 453
 454 /**
 455  * Accessible_isValue:
 456  * @obj: a pointer to the #Accessible instance to query.
 457  *
 458  * Query whether the specified #Accessible implements #AccessibleValue.
 459  *
 460  * Returns: #TRUE if @obj implements the #AccessibleValue interface,
 461  *          #FALSE otherwise.
 462 **/
 463 boolean
 464 Accessible_isValue (Accessible *obj)
 465 {
 466   Bonobo_Unknown iface =
 467     Accessibility_Accessible_queryInterface (*obj,
 468                                              "IDL:Accessibility/Value:1.0",
 469                                              &ev);
 470   spi_check_ev (&ev, "isValue");
 471
 472   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 473 }
 474
 475 /**
 476  * Accessible_getAction:
 477  * @obj: a pointer to the #Accessible instance to query.
 478  *
 479  * Get the #AccessibleAction interface for an #Accessible.
 480  *
 481  * Returns: a pointer to an #AccessibleAction interface instance, or
 482  *          NULL if @obj does not implement #AccessibleAction.
 483  **/
 484 AccessibleAction *
 485 Accessible_getAction (Accessible *obj)
 486 {
 487   Bonobo_Unknown iface =
 488     Accessibility_Accessible_queryInterface (*obj,
 489                                              "IDL:Accessibility/Action:1.0",
 490                                              &ev);
 491   spi_check_ev (&ev, "getAction");
 492
 493   return (AccessibleAction *)
 494           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 495 }
 496
 497 /**
 498  * Accessible_getComponent:
 499  * @obj: a pointer to the #Accessible instance to query.
 500  *
 501  * Get the #AccessibleComponent interface for an #Accessible.
 502  *
 503  * Returns: a pointer to an #AccessibleComponent interface instance, or
 504  *          NULL if @obj does not implement #AccessibleComponent.
 505  **/
 506 AccessibleComponent *
 507 Accessible_getComponent (Accessible *obj)
 508 {
 509   Bonobo_Unknown iface =
 510     Accessibility_Accessible_queryInterface (*obj,
 511                                              "IDL:Accessibility/Component:1.0",
 512                                              &ev);
 513   spi_check_ev (&ev, "getComponent");
 514
 515   return (AccessibleComponent *) ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 516 }
 517
 518 /**
 519  * Accessible_getEditableText:
 520  * @obj: a pointer to the #Accessible instance to query.
 521  *
 522  * Get the #AccessibleEditableText interface for an #Accessible.
 523  *
 524  * Returns: a pointer to an #AccessibleEditableText interface instance, or
 525  *          NULL if @obj does not implement #AccessibleEditableText.
 526  **/
 527 AccessibleEditableText *
 528 Accessible_getEditableText (Accessible *obj)
 529 {
 530   Bonobo_Unknown iface =
 531     Accessibility_Accessible_queryInterface (*obj,
 532                                              "IDL:Accessibility/EditableText:1.0",
 533                                              &ev);
 534   spi_check_ev (&ev, "getEditableText");
 535
 536   return (AccessibleEditableText *)
 537           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 538 }
 539
 540
 541
 542 /**
 543  * Accessible_getHypertext:
 544  * @obj: a pointer to the #Accessible instance to query.
 545  *
 546  * Get the #AccessibleHypertext interface for an #Accessible.
 547  *
 548  * Returns: a pointer to an #AccessibleHypertext interface instance, or
 549  *          NULL if @obj does not implement #AccessibleHypertext.
 550  **/
 551 AccessibleHypertext *
 552 Accessible_getHypertext (Accessible *obj)
 553 {
 554   Bonobo_Unknown iface =
 555     Accessibility_Accessible_queryInterface (*obj,
 556                                              "IDL:Accessibility/Hypertext:1.0",
 557                                              &ev);
 558   spi_check_ev (&ev, "getHypertext");
 559
 560   return (AccessibleHypertext *)
 561           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 562 }
 563
 564
 565
 566 /**
 567  * Accessible_getImage:
 568  * @obj: a pointer to the #Accessible instance to query.
 569  *
 570  * Get the #AccessibleImage interface for an #Accessible.
 571  *
 572  * Returns: a pointer to an #AccessibleImage interface instance, or
 573  *          NULL if @obj does not implement #AccessibleImage.
 574  **/
 575 AccessibleImage *
 576 Accessible_getImage (Accessible *obj)
 577 {
 578   Bonobo_Unknown iface =
 579     Accessibility_Accessible_queryInterface (*obj,
 580                                              "IDL:Accessibility/Image:1.0",
 581                                              &ev);
 582   spi_check_ev (&ev, "getImage");
 583
 584   return (AccessibleImage *)
 585           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 586 }
 587
 588
 589
 590 /**
 591  * Accessible_getSelection:
 592  * @obj: a pointer to the #Accessible instance to query.
 593  *
 594  * Get the #AccessibleSelection interface for an #Accessible.
 595  *
 596  * Returns: a pointer to an #AccessibleSelection interface instance, or
 597  *          NULL if @obj does not implement #AccessibleSelection.
 598  **/
 599 AccessibleSelection *
 600 Accessible_getSelection (Accessible *obj)
 601 {
 602   Bonobo_Unknown iface =
 603     Accessibility_Accessible_queryInterface (*obj,
 604                                              "IDL:Accessibility/Selection:1.0",
 605                                              &ev);
 606   spi_warn_ev (&ev, "getSelection");
 607
 608   return (AccessibleSelection *)
 609           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 610 }
 611
 612
 613
 614 /**
 615  * Accessible_getTable:
 616  * @obj: a pointer to the #Accessible instance to query.
 617  *
 618  * Get the #AccessibleTable interface for an #Accessible.
 619  *
 620  * Returns: a pointer to an #AccessibleTable interface instance, or
 621  *          NULL if @obj does not implement #AccessibleTable.
 622  **/
 623 AccessibleTable *
 624 Accessible_getTable (Accessible *obj)
 625 {
 626   Bonobo_Unknown iface =
 627     Accessibility_Accessible_queryInterface (*obj,
 628                                              "IDL:Accessibility/Table:1.0",
 629                                              &ev);
 630   spi_check_ev (&ev, "getTable");
 631
 632   return (AccessibleTable *)
 633           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 634 }
 635
 636 /**
 637  * Accessible_getText:
 638  * @obj: a pointer to the #Accessible instance to query.
 639  *
 640  * Get the #AccessibleText interface for an #Accessible.
 641  *
 642  * Returns: a pointer to an #AccessibleText interface instance, or
 643  *          NULL if @obj does not implement #AccessibleText.
 644  **/
 645 AccessibleText *
 646 Accessible_getText (Accessible *obj)
 647 {
 648   Bonobo_Unknown iface =
 649     Accessibility_Accessible_queryInterface (*obj,
 650                                              "IDL:Accessibility/Text:1.0",
 651                                              &ev);
 652
 653   spi_check_ev (&ev, "getText");
 654
 655   return (AccessibleText *)
 656           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 657 }
 658
 659
 660
 661 /**
 662  * Accessible_getValue:
 663  * @obj: a pointer to the #Accessible instance to query.
 664  *
 665  * Get the #AccessibleValue interface for an #Accessible.
 666  *
 667  * Returns: a pointer to an #AccessibleValue interface instance, or
 668  *          NULL if @obj does not implement #AccessibleValue.
 669  **/
 670 AccessibleValue *
 671 Accessible_getValue (Accessible *obj)
 672 {
 673   Bonobo_Unknown iface =
 674     Accessibility_Accessible_queryInterface (*obj,
 675                                              "IDL:Accessibility/Value:1.0",
 676                                              &ev);
 677   return (AccessibleValue *)
 678           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 679 }
 680
 681
 682
 683 /**
 684  * Accessible_queryInterface:
 685  * @obj: a pointer to the #Accessible instance to query.
 686  * @interface_name: a UTF-8 character string specifiying the requested interface.
 687  *
 688  * Query an #Accessible object to for a named interface.
 689  *
 690  * Returns: an instance of the named interface object, if it is implemented
 691  *          by @obj, or NULL otherwise.
 692  *
 693  **/
 694 GenericInterface *
 695 Accessible_queryInterface (Accessible *obj, char *interface_name)
 696 {
 697   GenericInterface iface;
 698   iface = Accessibility_Accessible_queryInterface (*obj,
 699                                                     interface_name,
 700                                                     &ev);
 701   return (iface != NULL) ? Obj_Add (iface) : NULL;
 702 }
 703