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  *
 180  * @obj: a pointer to the #Accessible object on which to operate.
 181  *
 182  * Get the number of children contained by an #Accessible object.
 183  *
 184  * Returns: a #long indicating the number of #Accessible children
 185  *          contained by an #Accessible object.
 186  *
 187  **/
 188 long
 189 Accessible_getChildCount (Accessible *obj)
 190 {
 191   long retval = (long) Accessibility_Accessible__get_childCount (*obj, &ev);
 192   spi_check_ev (&ev, "getChildCount");
 193   return retval;
 194 }
 195
 196 /**
 197  * Accessible_getChildAtIndex:
 198  *
 199  * @obj: a pointer to the #Accessible object on which to operate.
 200  * @childIndex: a #long indicating which child is specified.
 201  *
 202  * Get the #Accessible child of an #Accessible object at a given index.
 203  *
 204  * Returns: a pointer to the #Accessible child object at index
 205  *          @childIndex.
 206  *
 207  **/
 208 Accessible *
 209 Accessible_getChildAtIndex (Accessible *obj,
 210                             long childIndex)
 211 {
 212   Accessible *retval = Obj_Add (Accessibility_Accessible_getChildAtIndex (*obj, childIndex, &ev));
 213   spi_check_ev (&ev, "getChildAtIndex");
 214   return retval;
 215 }
 216
 217 /**
 218  * Accessible_getIndexInParent:
 219  *
 220  * @obj: a pointer to the #Accessible object on which to operate.
 221  *
 222  * Get the index of an #Accessible object in its containing #Accessible.
 223  *
 224  * Returns: a #long indicating the index of the #Accessible object
 225  *          in its parent (i.e. containing) #Accessible instance,
 226  *          or -1 if @obj has no containing parent.
 227  *
 228  **/
 229 long
 230 Accessible_getIndexInParent (Accessible *obj)
 231 {
 232   long retval = (long) Accessibility_Accessible_getIndexInParent (*obj, &ev);
 233   spi_check_ev (&ev, "getIndexInParent");
 234   return retval;
 235 }
 236
 237 /**
 238  * Accessible_getRelationSet:
 239  *
 240  * Not Yet Implemented.
 241  *
 242  * Returns: a pointer to an array of #AccessibleRelations.
 243  *
 244  **/
 245 AccessibleRelation **
 246 Accessible_getRelationSet (Accessible *obj)
 247 {
 248   return NULL;
 249 }
 250
 251 /**
 252  * Accessible_getRole:
 253  * @obj: a pointer to the #Accessible object on which to operate.
 254  *
 255  * Get the UI role of an #Accessible object.
 256  *
 257  * Returns: a UTF-8 string indicating the UI role of the #Accessible object.
 258  *
 259  **/
 260 char *
 261 Accessible_getRole (Accessible *obj)
 262 {
 263   char *retval = Accessible_Role_getName (
 264                   Accessibility_Accessible_getRole (*obj, &ev));
 265   spi_check_ev (&ev, "getRole");
 266   return retval;
 267 }
 268
 269 /**
 270  * Accessible_getStateSet:
 271  *
 272  * Not Yet Implemented.
 273  *
 274  * Returns: a pointer to an #AccessibleStateSet representing the object's current state.
 275  **/
 276 AccessibleStateSet *
 277 Accessible_getStateSet (Accessible *obj)
 278 {
 279   return NULL;
 280 }
 281
 282 /* Interface query methods */
 283
 284 /**
 285  * Accessible_isAction:
 286  * @obj: a pointer to the #Accessible instance to query.
 287  *
 288  * Query whether the specified #Accessible implements #AccessibleAction.
 289  * Not Yet Implemented.
 290  *
 291  * Returns: #TRUE if @obj implements the #AccessibleAction interface,
 292  *          #FALSE otherwise.
 293  **/
 294 boolean
 295 Accessible_isAction (Accessible *obj)
 296 {
 297   Bonobo_Unknown iface =
 298     Accessibility_Accessible_queryInterface (*obj,
 299                                              "IDL:Accessibility/Action:1.0",
 300                                              &ev);
 301   spi_warn_ev (&ev, "isAction");
 302
 303   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 304 }
 305
 306 /**
 307  * Accessible_isComponent:
 308  * @obj: a pointer to the #Accessible instance to query.
 309  *
 310  * Query whether the specified #Accessible implements #AccessibleComponent.
 311  *
 312  * Returns: #TRUE if @obj implements the #AccessibleComponent interface,
 313  *          #FALSE otherwise.
 314  **/
 315 boolean
 316 Accessible_isComponent (Accessible *obj)
 317 {
 318   Bonobo_Unknown iface =
 319     Accessibility_Accessible_queryInterface (*obj,
 320                                              "IDL:Accessibility/Component:1.0",
 321                                              &ev);
 322   spi_warn_ev (&ev, "isComponent");
 323
 324   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 325 }
 326
 327 /**
 328  * Accessible_isEditableText:
 329  * @obj: a pointer to the #Accessible instance to query.
 330  *
 331  * Query whether the specified #Accessible implements #AccessibleEditableText.
 332  * Not Yet Implemented.
 333  *
 334  * Returns: #TRUE if @obj implements the #AccessibleEditableText interface,
 335  *          #FALSE otherwise.
 336  **/
 337 boolean
 338 Accessible_isEditableText (Accessible *obj)
 339 {
 340   Bonobo_Unknown iface =
 341     Accessibility_Accessible_queryInterface (*obj,
 342                                              "IDL:Accessibility/EditableText:1.0",
 343                                              &ev);
 344   spi_check_ev (&ev, "isEditableText");
 345
 346   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 347 }
 348
 349 /**
 350  * Accessible_isHypertext:
 351  * @obj: a pointer to the #Accessible instance to query.
 352  *
 353  * Query whether the specified #Accessible implements #AccessibleHypertext.
 354  * Not Yet Implemented.
 355  *
 356  * Returns: #TRUE if @obj implements the #AccessibleHypertext interface,
 357  *          #FALSE otherwise.
 358  **/
 359 boolean
 360 Accessible_isHypertext (Accessible *obj)
 361 {
 362   Bonobo_Unknown iface =
 363     Accessibility_Accessible_queryInterface (*obj,
 364                                              "IDL:Accessibility/Hypertext:1.0",
 365                                              &ev);
 366
 367   spi_check_ev (&ev, "isHypertext");
 368
 369   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 370 }
 371
 372 /**
 373  * Accessible_isImage:
 374  * @obj: a pointer to the #Accessible instance to query.
 375  *
 376  * Query whether the specified #Accessible implements #AccessibleImage.
 377  * Not Yet Implemented.
 378  *
 379  * Returns: #TRUE if @obj implements the #AccessibleImage interface,
 380  *          #FALSE otherwise.
 381 **/
 382 boolean
 383 Accessible_isImage (Accessible *obj)
 384 {
 385   Bonobo_Unknown iface =
 386     Accessibility_Accessible_queryInterface (*obj,
 387                                              "IDL:Accessibility/Image:1.0",
 388                                              &ev);
 389   spi_check_ev (&ev, "isImage");
 390
 391   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 392 }
 393
 394 /**
 395  * Accessible_isSelection:
 396  * @obj: a pointer to the #Accessible instance to query.
 397  *
 398  * Query whether the specified #Accessible implements #AccessibleSelection.
 399  * Not Yet Implemented.
 400  *
 401  * Returns: #TRUE if @obj implements the #AccessibleSelection interface,
 402  *          #FALSE otherwise.
 403 **/
 404 boolean
 405 Accessible_isSelection (Accessible *obj)
 406 {
 407   Bonobo_Unknown iface =
 408     Accessibility_Accessible_queryInterface (*obj,
 409                                              "IDL:Accessibility/Selection:1.0",
 410                                              &ev);
 411   spi_warn_ev (&ev, "isSelection");
 412
 413   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 414
 415 }
 416
 417 /**
 418  * Accessible_isTable:
 419  * @obj: a pointer to the #Accessible instance to query.
 420  *
 421  * Query whether the specified #Accessible implements #AccessibleTable.
 422  * Not Yet Implemented.
 423  *
 424  * Returns: #TRUE if @obj implements the #AccessibleTable interface,
 425  *          #FALSE otherwise.
 426 **/
 427 boolean
 428 Accessible_isTable (Accessible *obj)
 429 {
 430   Bonobo_Unknown iface =
 431     Accessibility_Accessible_queryInterface (*obj,
 432                                              "IDL:Accessibility/Table:1.0",
 433                                              &ev);
 434   spi_check_ev (&ev, "isTable");
 435
 436   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 437
 438 }
 439
 440 /**
 441  * Accessible_isText:
 442  * @obj: a pointer to the #Accessible instance to query.
 443  *
 444  * Query whether the specified #Accessible implements #AccessibleText.
 445  * Not Yet Implemented.
 446  *
 447  * Returns: #TRUE if @obj implements the #AccessibleText interface,
 448  *          #FALSE otherwise.
 449 **/
 450 boolean
 451 Accessible_isText (Accessible *obj)
 452 {
 453   Bonobo_Unknown iface =
 454     Accessibility_Accessible_queryInterface (*obj,
 455                                              "IDL:Accessibility/Text:1.0",
 456                                              &ev);
 457   spi_warn_ev (&ev, "isText");
 458
 459   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 460 }
 461
 462 /**
 463  * Accessible_isValue:
 464  * @obj: a pointer to the #Accessible instance to query.
 465  *
 466  * Query whether the specified #Accessible implements #AccessibleValue.
 467  *
 468  * Returns: #TRUE if @obj implements the #AccessibleValue interface,
 469  *          #FALSE otherwise.
 470 **/
 471 boolean
 472 Accessible_isValue (Accessible *obj)
 473 {
 474   Bonobo_Unknown iface =
 475     Accessibility_Accessible_queryInterface (*obj,
 476                                              "IDL:Accessibility/Value:1.0",
 477                                              &ev);
 478   spi_check_ev (&ev, "isValue");
 479
 480   return (CORBA_Object_is_nil (iface, &ev)) ? FALSE : TRUE;
 481 }
 482
 483 /**
 484  * Accessible_getAction:
 485  *
 486  *
 487  **/
 488 AccessibleAction *
 489 Accessible_getAction (Accessible *obj)
 490 {
 491   Bonobo_Unknown iface =
 492     Accessibility_Accessible_queryInterface (*obj,
 493                                              "IDL:Accessibility/Action:1.0",
 494                                              &ev);
 495   spi_check_ev (&ev, "getAction");
 496
 497   return (AccessibleAction *)
 498           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 499 }
 500
 501 /**
 502  * Accessible_getComponent:
 503  * @obj: a pointer to the #Accessible instance to query.
 504  *
 505  * Get the #AccessibleComponent interface for an #Accessible.
 506  *
 507  * Returns: a pointer to an #AccessibleComponent interface instance, or
 508  *          NULL if @obj does not implement #AccessibleComponent.
 509  **/
 510 AccessibleComponent *
 511 Accessible_getComponent (Accessible *obj)
 512 {
 513   Bonobo_Unknown iface =
 514     Accessibility_Accessible_queryInterface (*obj,
 515                                              "IDL:Accessibility/Component:1.0",
 516                                              &ev);
 517   spi_check_ev (&ev, "getComponent");
 518
 519   return (AccessibleComponent *) ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 520 }
 521
 522 AccessibleEditableText *
 523 Accessible_getEditableText (Accessible *obj)
 524 {
 525   Bonobo_Unknown iface =
 526     Accessibility_Accessible_queryInterface (*obj,
 527                                              "IDL:Accessibility/EditableText:1.0",
 528                                              &ev);
 529   spi_check_ev (&ev, "getEditableText");
 530
 531   return (AccessibleEditableText *)
 532           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 533 }
 534
 535
 536
 537 AccessibleHypertext *
 538 Accessible_getHypertext (Accessible *obj)
 539 {
 540   Bonobo_Unknown iface =
 541     Accessibility_Accessible_queryInterface (*obj,
 542                                              "IDL:Accessibility/Hypertext:1.0",
 543                                              &ev);
 544   spi_check_ev (&ev, "getHypertext");
 545
 546   return (AccessibleHypertext *)
 547           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 548 }
 549
 550
 551
 552 AccessibleImage *
 553 Accessible_getImage (Accessible *obj)
 554 {
 555   Bonobo_Unknown iface =
 556     Accessibility_Accessible_queryInterface (*obj,
 557                                              "IDL:Accessibility/Image:1.0",
 558                                              &ev);
 559   spi_check_ev (&ev, "getImage");
 560
 561   return (AccessibleImage *)
 562           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 563 }
 564
 565
 566
 567 AccessibleSelection *
 568 Accessible_getSelection (Accessible *obj)
 569 {
 570   Bonobo_Unknown iface =
 571     Accessibility_Accessible_queryInterface (*obj,
 572                                              "IDL:Accessibility/Selection:1.0",
 573                                              &ev);
 574   spi_warn_ev (&ev, "getSelection");
 575
 576   return (AccessibleSelection *)
 577           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 578 }
 579
 580
 581
 582 AccessibleTable *
 583 Accessible_getTable (Accessible *obj)
 584 {
 585   Bonobo_Unknown iface =
 586     Accessibility_Accessible_queryInterface (*obj,
 587                                              "IDL:Accessibility/Table:1.0",
 588                                              &ev);
 589   spi_check_ev (&ev, "getTable");
 590
 591   return (AccessibleTable *)
 592           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 593 }
 594
 595 AccessibleText *
 596 Accessible_getText (Accessible *obj)
 597 {
 598   Bonobo_Unknown iface =
 599     Accessibility_Accessible_queryInterface (*obj,
 600                                              "IDL:Accessibility/Text:1.0",
 601                                              &ev);
 602
 603   spi_check_ev (&ev, "getText");
 604
 605   return (AccessibleText *)
 606           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 607 }
 608
 609
 610
 611 AccessibleValue *
 612 Accessible_getValue (Accessible *obj)
 613 {
 614   Bonobo_Unknown iface =
 615     Accessibility_Accessible_queryInterface (*obj,
 616                                              "IDL:Accessibility/Value:1.0",
 617                                              &ev);
 618   return (AccessibleValue *)
 619           ((CORBA_Object_is_nil (iface, &ev)) ? 0 : Obj_Add (iface));
 620 }
 621
 622
 623
 624 /**
 625  * Accessible_queryInterface:
 626  * @obj: a pointer to the #Accessible instance to query.
 627  * @interface_name: a UTF-8 character string specifiying the requested interface.
 628  *
 629  * Query an #Accessible object to for a named interface.
 630  *
 631  * Returns: an instance of the named interface object, if it is implemented
 632  *          by @obj, or NULL otherwise.
 633  *
 634  **/
 635 GenericInterface *
 636 Accessible_queryInterface (Accessible *obj, char *interface_name)
 637 {
 638   GenericInterface iface;
 639   iface = Accessibility_Accessible_queryInterface (*obj,
 640                                                     interface_name,
 641                                                     &ev);
 642   return (iface != NULL) ? Obj_Add (iface) : NULL;
 643 }
 644