libspi/accessible.c

   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 /* accessible.c: the core of the accessibility implementation */
  24
  25 #include <config.h>
  26 #include <stdio.h>
  27 #include <bonobo/bonobo-exception.h>
  28 #include <atk/atk.h>
  29 #include <libspi/libspi.h>
  30
  31 /* Our parent Gtk object type  */
  32 #define PARENT_TYPE SPI_TYPE_BASE
  33
  34 static gboolean spi_init_role_lookup_table (Accessibility_Role *role_table);
  35 static Accessibility_Role spi_role_from_atk_role (AtkRole role);
  36
  37 static gboolean
  38 spi_init_role_lookup_table (Accessibility_Role *role_table)
  39 {
  40   int i;
  41   /* if it's not in the list below, dunno what it is */
  42   for (i = 0; i < ATK_ROLE_LAST_DEFINED; ++i)
  43     {
  44       role_table [i] = Accessibility_ROLE_UNKNOWN;
  45     }
  46
  47   role_table [ATK_ROLE_INVALID] =          Accessibility_ROLE_INVALID;
  48   role_table [ATK_ROLE_ACCEL_LABEL] =      Accessibility_ROLE_ACCELERATOR_LABEL;
  49   role_table [ATK_ROLE_ALERT] =            Accessibility_ROLE_ALERT;
  50   role_table [ATK_ROLE_ANIMATION] =        Accessibility_ROLE_ANIMATION;
  51   role_table [ATK_ROLE_ARROW] =            Accessibility_ROLE_ARROW;
  52   role_table [ATK_ROLE_CALENDAR] =         Accessibility_ROLE_CALENDAR;
  53   role_table [ATK_ROLE_CANVAS] =           Accessibility_ROLE_CANVAS;
  54   role_table [ATK_ROLE_CHECK_BOX] =        Accessibility_ROLE_CHECK_BOX;
  55   role_table [ATK_ROLE_CHECK_MENU_ITEM] =  Accessibility_ROLE_CHECK_MENU_ITEM;
  56   role_table [ATK_ROLE_COLOR_CHOOSER] =    Accessibility_ROLE_COLOR_CHOOSER;
  57   role_table [ATK_ROLE_COLUMN_HEADER] =    Accessibility_ROLE_COLUMN_HEADER;
  58   role_table [ATK_ROLE_COMBO_BOX] =        Accessibility_ROLE_COMBO_BOX;
  59   role_table [ATK_ROLE_DATE_EDITOR] =      Accessibility_ROLE_DATE_EDITOR;
  60   role_table [ATK_ROLE_DESKTOP_ICON] =     Accessibility_ROLE_DESKTOP_ICON;
  61   role_table [ATK_ROLE_DESKTOP_FRAME] =    Accessibility_ROLE_DESKTOP_FRAME;
  62   role_table [ATK_ROLE_DIAL] =             Accessibility_ROLE_DIAL;
  63   role_table [ATK_ROLE_DIALOG] =           Accessibility_ROLE_DIALOG;
  64   role_table [ATK_ROLE_DIRECTORY_PANE] =   Accessibility_ROLE_DIRECTORY_PANE;
  65   role_table [ATK_ROLE_FILE_CHOOSER] =     Accessibility_ROLE_FILE_CHOOSER;
  66   role_table [ATK_ROLE_FILLER] =           Accessibility_ROLE_FILLER;
  67   role_table [ATK_ROLE_FONT_CHOOSER] =     Accessibility_ROLE_FONT_CHOOSER;
  68   role_table [ATK_ROLE_FRAME] =            Accessibility_ROLE_FRAME;
  69   role_table [ATK_ROLE_GLASS_PANE] =       Accessibility_ROLE_GLASS_PANE;
  70   role_table [ATK_ROLE_HTML_CONTAINER] =   Accessibility_ROLE_HTML_CONTAINER;
  71   role_table [ATK_ROLE_ICON] =             Accessibility_ROLE_ICON;
  72   role_table [ATK_ROLE_IMAGE] =            Accessibility_ROLE_IMAGE;
  73   role_table [ATK_ROLE_INTERNAL_FRAME] =   Accessibility_ROLE_INTERNAL_FRAME;
  74   role_table [ATK_ROLE_LABEL] =            Accessibility_ROLE_LABEL;
  75   role_table [ATK_ROLE_LAYERED_PANE] =     Accessibility_ROLE_LAYERED_PANE;
  76   role_table [ATK_ROLE_LIST] =             Accessibility_ROLE_LIST;
  77   role_table [ATK_ROLE_LIST_ITEM] =        Accessibility_ROLE_LIST_ITEM;
  78   role_table [ATK_ROLE_MENU] =             Accessibility_ROLE_MENU;
  79   role_table [ATK_ROLE_MENU_BAR] =         Accessibility_ROLE_MENU_BAR;
  80   role_table [ATK_ROLE_MENU_ITEM] =        Accessibility_ROLE_MENU_ITEM;
  81   role_table [ATK_ROLE_OPTION_PANE] =      Accessibility_ROLE_OPTION_PANE;
  82   role_table [ATK_ROLE_PAGE_TAB] =         Accessibility_ROLE_PAGE_TAB;
  83   role_table [ATK_ROLE_PAGE_TAB_LIST] =    Accessibility_ROLE_PAGE_TAB_LIST;
  84   role_table [ATK_ROLE_PANEL] =            Accessibility_ROLE_PANEL;
  85   role_table [ATK_ROLE_PASSWORD_TEXT] =    Accessibility_ROLE_PASSWORD_TEXT;
  86   role_table [ATK_ROLE_POPUP_MENU] =       Accessibility_ROLE_POPUP_MENU;
  87   role_table [ATK_ROLE_PROGRESS_BAR] =     Accessibility_ROLE_PROGRESS_BAR;
  88   role_table [ATK_ROLE_PUSH_BUTTON] =      Accessibility_ROLE_PUSH_BUTTON;
  89   role_table [ATK_ROLE_RADIO_BUTTON] =     Accessibility_ROLE_RADIO_BUTTON;
  90   role_table [ATK_ROLE_RADIO_MENU_ITEM] =  Accessibility_ROLE_RADIO_MENU_ITEM;
  91   role_table [ATK_ROLE_ROOT_PANE] =        Accessibility_ROLE_ROOT_PANE;
  92   role_table [ATK_ROLE_ROW_HEADER] =       Accessibility_ROLE_ROW_HEADER;
  93   role_table [ATK_ROLE_SCROLL_BAR] =       Accessibility_ROLE_SCROLL_BAR;
  94   role_table [ATK_ROLE_SCROLL_PANE] =      Accessibility_ROLE_SCROLL_PANE;
  95   role_table [ATK_ROLE_SEPARATOR] =        Accessibility_ROLE_SEPARATOR;
  96   role_table [ATK_ROLE_SLIDER] =           Accessibility_ROLE_SLIDER;
  97   role_table [ATK_ROLE_SPLIT_PANE] =       Accessibility_ROLE_SPLIT_PANE;
  98   role_table [ATK_ROLE_SPIN_BUTTON] =      Accessibility_ROLE_SPIN_BUTTON;
  99   role_table [ATK_ROLE_STATUSBAR] =        Accessibility_ROLE_STATUS_BAR;
 100   role_table [ATK_ROLE_TABLE] =            Accessibility_ROLE_TABLE;
 101   role_table [ATK_ROLE_TABLE_CELL] =       Accessibility_ROLE_TABLE_CELL;
 102   role_table [ATK_ROLE_TABLE_COLUMN_HEADER] =
 103                                            Accessibility_ROLE_COLUMN_HEADER;
 104   role_table [ATK_ROLE_TABLE_ROW_HEADER] = Accessibility_ROLE_ROW_HEADER;
 105   role_table [ATK_ROLE_TEAR_OFF_MENU_ITEM] =
 106                                            Accessibility_ROLE_TEAROFF_MENU_ITEM;
 107   role_table [ATK_ROLE_TERMINAL] =         Accessibility_ROLE_TERMINAL;
 108   role_table [ATK_ROLE_TEXT] =             Accessibility_ROLE_TEXT;
 109   role_table [ATK_ROLE_TOGGLE_BUTTON] =    Accessibility_ROLE_TOGGLE_BUTTON;
 110   role_table [ATK_ROLE_TOOL_BAR] =         Accessibility_ROLE_TOOL_BAR;
 111   role_table [ATK_ROLE_TOOL_TIP] =         Accessibility_ROLE_TOOL_TIP;
 112   role_table [ATK_ROLE_TREE] =             Accessibility_ROLE_TREE;
 113   role_table [ATK_ROLE_TREE_TABLE] =       Accessibility_ROLE_TREE_TABLE;
 114   role_table [ATK_ROLE_UNKNOWN] =          Accessibility_ROLE_UNKNOWN;
 115   role_table [ATK_ROLE_VIEWPORT] =         Accessibility_ROLE_VIEWPORT;
 116   role_table [ATK_ROLE_WINDOW] =           Accessibility_ROLE_WINDOW;
 117   role_table [ATK_ROLE_LAST_DEFINED] =     Accessibility_ROLE_EXTENDED;
 118
 119   return TRUE;
 120 }
 121
 122 static Accessibility_Role
 123 spi_role_from_atk_role (AtkRole role)
 124 {
 125   static gboolean is_initialized = FALSE;
 126   static Accessibility_Role spi_role_table [ATK_ROLE_LAST_DEFINED];
 127   Accessibility_Role spi_role;
 128
 129   if (!is_initialized)
 130    {
 131      is_initialized = spi_init_role_lookup_table (spi_role_table);
 132    }
 133
 134   if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)
 135     {
 136       spi_role = spi_role_table [role];
 137     }
 138   else
 139     {
 140       spi_role = Accessibility_ROLE_EXTENDED;
 141     }
 142   return spi_role;
 143 }
 144
 145 static AtkObject *
 146 get_accessible_from_servant (PortableServer_Servant servant)
 147 {
 148   SpiBase *object = SPI_BASE (bonobo_object_from_servant (servant));
 149
 150   if (!object)
 151     {
 152       return NULL;
 153     }
 154
 155   return object->atko;
 156 }
 157
 158 /*
 159  * CORBA Accessibility::Accessible::get_name method implementation
 160  */
 161 static CORBA_char *
 162 impl_accessibility_accessible_get_name (PortableServer_Servant servant,
 163                                         CORBA_Environment     *ev)
 164 {
 165   const gchar *name;
 166   CORBA_char  *retval;
 167   AtkObject   *object = get_accessible_from_servant (servant);
 168
 169   g_return_val_if_fail (object != NULL, CORBA_string_dup (""));
 170
 171   name = atk_object_get_name (object);
 172
 173   if (name)
 174     {
 175       retval = CORBA_string_dup (name);
 176     }
 177   else
 178     {
 179       retval = CORBA_string_dup ("");
 180     }
 181
 182   return retval;
 183 }
 184
 185 /*
 186  * CORBA Accessibility::Accessible::set_name method implementation
 187  */
 188 static void
 189 impl_accessibility_accessible_set_name (PortableServer_Servant servant,
 190                                         const CORBA_char      *name,
 191                                         CORBA_Environment     *ev)
 192 {
 193   AtkObject *object = get_accessible_from_servant (servant);
 194
 195   g_return_if_fail (object != NULL);
 196
 197   atk_object_set_name (object, name);
 198 }
 199
 200 /*
 201  * CORBA Accessibility::Accessible::get_description method implementation
 202  */
 203 static CORBA_char *
 204 impl_accessibility_accessible_get_description (PortableServer_Servant servant,
 205                                                CORBA_Environment     *ev)
 206 {
 207   const gchar *descr;
 208   CORBA_char  *retval;
 209   AtkObject   *object = get_accessible_from_servant (servant);
 210
 211   g_return_val_if_fail (object != NULL, CORBA_string_dup (""));
 212
 213   descr = atk_object_get_description (object);
 214
 215   if (descr)
 216     {
 217       retval = CORBA_string_dup (descr);
 218     }
 219   else
 220     {
 221       retval = CORBA_string_dup ("");
 222     }
 223
 224   return retval;
 225 }
 226
 227 /*
 228  * CORBA Accessibility::Accessible::set_description method implementation
 229  */
 230 static void
 231 impl_accessibility_accessible_set_description (PortableServer_Servant servant,
 232                                                const CORBA_char      *descr,
 233                                                CORBA_Environment     *ev)
 234 {
 235   AtkObject *object = get_accessible_from_servant (servant);
 236
 237   g_return_if_fail (object != NULL);
 238
 239   atk_object_set_description (object, descr);
 240 }
 241
 242 /*
 243  * CORBA Accessibility::Accessible::get_parent method implementation
 244  */
 245 static Accessibility_Accessible
 246 impl_accessibility_accessible_get_parent (PortableServer_Servant servant,
 247                                           CORBA_Environment     *ev)
 248 {
 249   AtkObject *parent;
 250   AtkObject *object = get_accessible_from_servant (servant);
 251
 252   g_return_val_if_fail (object != NULL, CORBA_OBJECT_NIL);
 253
 254   parent = atk_object_get_parent (object);
 255
 256   return spi_accessible_new_return (parent, FALSE, ev);
 257 }
 258
 259 /*
 260  * CORBA Accessibility::Accessible::get_IndexInParent method implementation
 261  */
 262 static CORBA_long
 263 impl_accessibility_accessible_get_index_in_parent (PortableServer_Servant servant,
 264                                                    CORBA_Environment     *ev)
 265 {
 266   AtkObject *object = get_accessible_from_servant (servant);
 267
 268   g_return_val_if_fail (object != NULL, -1);
 269
 270   return atk_object_get_index_in_parent (object);
 271 }
 272
 273 /*
 274  * CORBA Accessibility::Accessible::get_childCount method implementation
 275  */
 276 static CORBA_long
 277 impl_accessibility_accessible_get_child_count (PortableServer_Servant servant,
 278                                                CORBA_Environment     *ev)
 279 {
 280   AtkObject *object = get_accessible_from_servant (servant);
 281
 282   g_return_val_if_fail (object != NULL, 0);
 283
 284   return atk_object_get_n_accessible_children (object);
 285 }
 286
 287 /*
 288  * CORBA Accessibility::Accessible::getChildAtIndex method implementation
 289  */
 290 static Accessibility_Accessible
 291 impl_accessibility_accessible_get_child_at_index (PortableServer_Servant servant,
 292                                                   const CORBA_long      index,
 293                                                   CORBA_Environment     *ev)
 294 {
 295   AtkObject *child;
 296   AtkObject *object = get_accessible_from_servant (servant);
 297
 298   g_return_val_if_fail (object != NULL, 0);
 299
 300   child = atk_object_ref_accessible_child (object, index);
 301
 302   return spi_accessible_new_return (child, TRUE, ev);
 303 }
 304
 305 /*
 306  * CORBA Accessibility::Accessible::getState method implementation
 307  */
 308 static Accessibility_StateSet
 309 impl_accessibility_accessible_get_state (PortableServer_Servant servant,
 310                                          CORBA_Environment     *ev)
 311 {
 312   AtkObject *object = get_accessible_from_servant (servant);
 313
 314   bonobo_return_val_if_fail (object != NULL, NULL, ev);
 315
 316   printf ("SpiAccessible get_state.\n");
 317
 318   /* TODO: implement the bonobo stateset class */
 319   return (Accessibility_StateSet) NULL;
 320 }
 321
 322 /*
 323  * CORBA Accessibility::Accessible::getRelationSet method implementation
 324  */
 325 static Accessibility_RelationSet *
 326 impl_accessibility_accessible_get_relation_set (PortableServer_Servant servant,
 327                                                 CORBA_Environment     *ev)
 328 {
 329   Accessibility_RelationSet *retval;
 330   gint n_relations;
 331   gint i;
 332   AtkRelationSet *relation_set;
 333   AtkObject      *object = get_accessible_from_servant (servant);
 334
 335   bonobo_return_val_if_fail (object != NULL, NULL, ev);
 336
 337   relation_set = atk_object_ref_relation_set (object);
 338
 339   n_relations = atk_relation_set_get_n_relations (relation_set);
 340   retval = CORBA_sequence_Accessibility_Relation__alloc ();
 341   CORBA_sequence_Accessibility_Relation_allocbuf (n_relations);
 342
 343   for (i = 0; i < n_relations; ++i)
 344     {
 345       retval->_buffer[i] =
 346         bonobo_object_dup_ref (
 347           BONOBO_OBJREF (
 348             spi_relation_new (atk_relation_set_get_relation (relation_set, i))),
 349           ev);
 350     }
 351
 352   printf ("SpiAccessible get_relation_set.\n");
 353   return retval;
 354 }
 355
 356 /*
 357  * CORBA Accessibility::Accessible::getRole method implementation
 358  */
 359 static Accessibility_Role
 360 impl_accessibility_accessible_get_role (PortableServer_Servant servant,
 361                                         CORBA_Environment     *ev)
 362 {
 363   AtkRole            role;
 364   Accessibility_Role retval;
 365   AtkObject         *object = get_accessible_from_servant (servant);
 366
 367   g_return_val_if_fail (object != NULL, 0);
 368
 369   role = atk_object_get_role (object);
 370   retval = spi_role_from_atk_role (role);
 371
 372   return retval;
 373 }
 374
 375 /*
 376  * CORBA Accessibility::Accessible::getRole method implementation
 377  */
 378 static CORBA_char *
 379 impl_accessibility_accessible_get_role_name (PortableServer_Servant servant,
 380                                              CORBA_Environment     *ev)
 381 {
 382   AtkRole            role;
 383   Accessibility_Role retval;
 384   AtkObject         *object = get_accessible_from_servant (servant);
 385
 386   g_return_val_if_fail (object != NULL, 0);
 387
 388   role = atk_object_get_role (object);
 389
 390   return CORBA_string_dup (atk_role_get_name (role));
 391 }
 392
 393 static void
 394 spi_accessible_class_init (SpiAccessibleClass *klass)
 395 {
 396         POA_Accessibility_Accessible__epv *epv = &klass->epv;
 397
 398         epv->_get_name = impl_accessibility_accessible_get_name;
 399         epv->_set_name = impl_accessibility_accessible_set_name;
 400         epv->_get_description = impl_accessibility_accessible_get_description;
 401         epv->_set_description = impl_accessibility_accessible_set_description;
 402
 403         epv->_get_parent = impl_accessibility_accessible_get_parent;
 404         epv->_get_childCount = impl_accessibility_accessible_get_child_count;
 405         epv->getChildAtIndex = impl_accessibility_accessible_get_child_at_index;
 406         epv->getIndexInParent = impl_accessibility_accessible_get_index_in_parent;
 407
 408         epv->getRelationSet = impl_accessibility_accessible_get_relation_set;
 409         epv->getState = impl_accessibility_accessible_get_state;
 410         epv->getRole = impl_accessibility_accessible_get_role;
 411         epv->getRoleName = impl_accessibility_accessible_get_role_name;
 412 }
 413
 414 static void
 415 spi_accessible_init (SpiAccessible *accessible)
 416 {
 417 }
 418
 419 BONOBO_TYPE_FUNC_FULL (SpiAccessible,
 420                        Accessibility_Accessible,
 421                        PARENT_TYPE,
 422                        spi_accessible);
 423
 424 static GHashTable *public_corba_refs = NULL;
 425
 426 static GHashTable *
 427 get_public_refs (void)
 428 {
 429   if (!public_corba_refs)
 430     {
 431       public_corba_refs = g_hash_table_new (NULL, NULL);
 432     }
 433   return public_corba_refs;
 434 }
 435
 436 static void
 437 de_register_public_ref (SpiBase *object)
 438 {
 439   g_hash_table_remove (get_public_refs (), object->atko);
 440 }
 441
 442 SpiAccessible *
 443 spi_accessible_new (AtkObject *o)
 444 {
 445     SpiAccessible *retval;
 446     CORBA_Environment ev;
 447
 448     CORBA_exception_init (&ev);
 449
 450     g_assert (o);
 451
 452     if ((retval = g_hash_table_lookup (get_public_refs (), o)))
 453       {
 454         bonobo_object_ref (BONOBO_OBJECT (retval));
 455         return retval;
 456       }
 457
 458     retval = g_object_new (SPI_ACCESSIBLE_TYPE, NULL);
 459
 460     spi_base_construct (SPI_BASE (retval), o);
 461
 462     g_hash_table_insert (get_public_refs (), o, retval);
 463     g_signal_connect (G_OBJECT (retval), "destroy",
 464                       G_CALLBACK (de_register_public_ref),
 465                       NULL);
 466
 467     /* aggregate appropriate SPI interfaces based on ATK interfaces */
 468
 469     if (ATK_IS_ACTION (o))
 470       {
 471         bonobo_object_add_interface (bonobo_object (retval),
 472                                      BONOBO_OBJECT (spi_action_interface_new (o)));
 473       }
 474
 475     if (ATK_IS_COMPONENT (o))
 476       {
 477         bonobo_object_add_interface (bonobo_object (retval),
 478                                      BONOBO_OBJECT (spi_component_interface_new (o)));
 479       }
 480
 481     if (ATK_IS_EDITABLE_TEXT (o))
 482       {
 483         bonobo_object_add_interface (bonobo_object (retval),
 484                                      BONOBO_OBJECT(spi_editable_text_interface_new (o)));
 485       }
 486
 487     else if (ATK_IS_HYPERTEXT (o))
 488       {
 489         bonobo_object_add_interface (bonobo_object (retval),
 490                                      BONOBO_OBJECT (spi_hypertext_interface_new (o)));
 491       }
 492
 493     else if (ATK_IS_TEXT (o))
 494       {
 495         bonobo_object_add_interface (bonobo_object (retval),
 496                                      BONOBO_OBJECT (spi_text_interface_new (o)));
 497       }
 498
 499     if (ATK_IS_IMAGE (o))
 500       {
 501         bonobo_object_add_interface (bonobo_object (retval),
 502                                      BONOBO_OBJECT (spi_image_interface_new (o)));
 503       }
 504
 505     if (ATK_IS_SELECTION (o))
 506       {
 507         bonobo_object_add_interface (bonobo_object (retval),
 508                                      BONOBO_OBJECT (spi_selection_interface_new (o)));
 509       }
 510
 511     if (ATK_IS_TABLE (o))
 512       {
 513         bonobo_object_add_interface (bonobo_object (retval),
 514                                      BONOBO_OBJECT (spi_table_interface_new (o)));
 515       }
 516
 517     if (ATK_IS_VALUE (o))
 518       {
 519         bonobo_object_add_interface (bonobo_object (retval),
 520                                      BONOBO_OBJECT (spi_value_interface_new (o)));
 521       }
 522
 523     return retval;
 524 }
 525
 526 /**
 527  * spi_accessible_new_return:
 528  * @o: an AtkObject or NULL
 529  * @release_ref: whether to unref this AtkObject before return
 530  * @ev: a CORBA environment
 531  *
 532  * A helper function to instantiate a CORBA accessiblility
 533  * proxy from an AtkObject.
 534  *
 535  * Return value: the proxy or CORBA_OBJECT_NIL
 536  **/
 537 Accessibility_Accessible
 538 spi_accessible_new_return (AtkObject         *o,
 539                            gboolean           release_ref,
 540                            CORBA_Environment *ev)
 541 {
 542   SpiAccessible *accessible;
 543
 544   if (!o)
 545     {
 546       return CORBA_OBJECT_NIL;
 547     }
 548
 549   accessible = spi_accessible_new (o);
 550
 551   if (release_ref)
 552     {
 553       g_object_unref (G_OBJECT (o));
 554     }
 555
 556   return CORBA_Object_duplicate (BONOBO_OBJREF (accessible), ev);
 557 }