atk-adaptor/accessible-adaptor.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2008 Novell, Inc.
   6  * Copyright 2001, 2002 Sun Microsystems Inc.,
   7  * Copyright 2001, 2002 Ximian, Inc.
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #include <atk/atk.h>
  26 #include <droute/droute.h>
  27
  28 #include "common/spi-dbus.h"
  29 #include "common/spi-stateset.h"
  30 #include "accessible-marshaller.h"
  31 #include "accessible-register.h"
  32
  33 static dbus_bool_t
  34 impl_get_name (DBusMessageIter *iter, void *user_data)
  35 {
  36   AtkObject *object = (AtkObject *) user_data;
  37
  38   g_return_val_if_fail (ATK_IS_OBJECT (user_data), FALSE);
  39
  40   return droute_return_v_string (iter, atk_object_get_name (object));
  41 }
  42
  43 static dbus_bool_t
  44 impl_set_name (DBusMessageIter *iter, void *user_data)
  45 {
  46   AtkObject *object = (AtkObject *) user_data;
  47   const char *name = droute_get_v_string (iter);
  48
  49   g_return_val_if_fail (ATK_IS_OBJECT (user_data), FALSE);
  50
  51   atk_object_set_name (object, name);
  52   return TRUE;
  53 }
  54
  55 static dbus_bool_t
  56 impl_get_description (DBusMessageIter *iter, void *user_data)
  57 {
  58   AtkObject *object = (AtkObject *) user_data;
  59
  60   g_return_val_if_fail (ATK_IS_OBJECT (user_data), FALSE);
  61
  62   return droute_return_v_string (iter, atk_object_get_description (object));
  63 }
  64
  65 static dbus_bool_t
  66 impl_set_description (DBusMessageIter *iter, void *user_data)
  67 {
  68   AtkObject *object = (AtkObject *) user_data;
  69   const char *description = droute_get_v_string (iter);
  70
  71   g_return_val_if_fail (ATK_IS_OBJECT (user_data), FALSE);
  72
  73   atk_object_set_description (object, description);
  74   return TRUE;
  75 }
  76
  77 static dbus_bool_t
  78 impl_get_parent (DBusMessageIter *iter, void *user_data)
  79 {
  80   AtkObject *object = (AtkObject *) user_data;
  81
  82   g_return_val_if_fail (ATK_IS_OBJECT (user_data), FALSE);
  83
  84   return spi_dbus_return_v_object (iter,
  85                                    atk_object_get_parent (object),
  86                                    FALSE);
  87 }
  88
  89 static dbus_bool_t
  90 impl_get_childCount (DBusMessageIter *iter, void *user_data)
  91 {
  92   AtkObject *object = (AtkObject *) user_data;
  93
  94   g_return_val_if_fail (ATK_IS_OBJECT (user_data), FALSE);
  95
  96   return droute_return_v_int32 (iter,
  97                                 atk_object_get_n_accessible_children
  98                                 (object));
  99 }
 100
 101 static DBusMessage *
 102 impl_getChildAtIndex (DBusConnection *bus,
 103                       DBusMessage *message,
 104                       void *user_data)
 105 {
 106   AtkObject *object = (AtkObject *) user_data;
 107   DBusError error;
 108   dbus_int32_t i;
 109   AtkObject *child;
 110
 111   dbus_error_init (&error);
 112   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 113                         droute_not_yet_handled_error (message));
 114   if (!dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID))
 115       return spi_dbus_general_error (message);
 116   child = atk_object_ref_accessible_child (object, i);
 117   return spi_dbus_return_object (message, child, FALSE);
 118 }
 119
 120 static DBusMessage *
 121 impl_getChildren (DBusConnection *bus,
 122                   DBusMessage *message,
 123                   void *user_data)
 124 {
 125   AtkObject *object = (AtkObject *) user_data;
 126   gint i;
 127   gint count;
 128   DBusMessage *reply;
 129   DBusMessageIter iter, iter_array;
 130
 131   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 132                         droute_not_yet_handled_error (message));
 133   count = atk_object_get_n_accessible_children (object);
 134   reply = dbus_message_new_method_return (message);
 135   if (!reply) goto oom;
 136   dbus_message_iter_init_append (reply, &iter);
 137   if (!dbus_message_iter_open_container
 138       (&iter, DBUS_TYPE_ARRAY, "o", &iter_array))
 139     goto oom;
 140   for (i = 0; i < count; i++)
 141     {
 142       AtkObject *child = atk_object_ref_accessible_child (object, i);
 143       char *path = atk_dbus_object_to_path (child);
 144       if (path)
 145         {
 146           dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_OBJECT_PATH,
 147                                           &path);
 148           g_free (path);
 149         }
 150       if (child)
 151         g_object_unref (child);
 152     }
 153   if (!dbus_message_iter_close_container (&iter, &iter_array))
 154     goto oom;
 155   return reply;
 156 oom:
 157   // TODO: handle out-of-memory
 158   return reply;
 159 }
 160
 161 static DBusMessage *
 162 impl_getIndexInParent (DBusConnection *bus,
 163                        DBusMessage *message,
 164                        void *user_data)
 165 {
 166   AtkObject *object = (AtkObject *) user_data;
 167   dbus_uint32_t rv;
 168   DBusMessage *reply;
 169
 170   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 171                         droute_not_yet_handled_error (message));
 172   rv = atk_object_get_index_in_parent (object);
 173   reply = dbus_message_new_method_return (message);
 174   if (reply)
 175     {
 176       dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv,
 177                                 DBUS_TYPE_INVALID);
 178     }
 179   return reply;
 180 }
 181
 182 static gboolean
 183 spi_init_relation_type_table (Accessibility_RelationType *types)
 184 {
 185   gint i;
 186
 187   for (i = 0; i < ATK_RELATION_LAST_DEFINED; i++)
 188     types[i] = Accessibility_RELATION_NULL;
 189
 190   types[ATK_RELATION_CONTROLLED_BY] = Accessibility_RELATION_CONTROLLED_BY;
 191   types[ATK_RELATION_CONTROLLER_FOR] = Accessibility_RELATION_CONTROLLER_FOR;
 192   types[ATK_RELATION_LABEL_FOR] = Accessibility_RELATION_LABEL_FOR;
 193   types[ATK_RELATION_LABELLED_BY] = Accessibility_RELATION_LABELLED_BY;
 194   types[ATK_RELATION_MEMBER_OF] = Accessibility_RELATION_MEMBER_OF;
 195   types[ATK_RELATION_NODE_CHILD_OF] = Accessibility_RELATION_NODE_CHILD_OF;
 196   types[ATK_RELATION_FLOWS_TO] = Accessibility_RELATION_FLOWS_TO;
 197   types[ATK_RELATION_FLOWS_FROM] = Accessibility_RELATION_FLOWS_FROM;
 198   types[ATK_RELATION_SUBWINDOW_OF] = Accessibility_RELATION_SUBWINDOW_OF;
 199   types[ATK_RELATION_EMBEDS] = Accessibility_RELATION_EMBEDS;
 200   types[ATK_RELATION_EMBEDDED_BY] = Accessibility_RELATION_EMBEDDED_BY;
 201   types[ATK_RELATION_POPUP_FOR] = Accessibility_RELATION_POPUP_FOR;
 202   types[ATK_RELATION_PARENT_WINDOW_OF] = Accessibility_RELATION_PARENT_WINDOW_OF;
 203   types[ATK_RELATION_DESCRIPTION_FOR] = Accessibility_RELATION_DESCRIPTION_FOR;
 204   types[ATK_RELATION_DESCRIBED_BY] = Accessibility_RELATION_DESCRIBED_BY;
 205
 206   return TRUE;
 207 }
 208
 209 static Accessibility_RelationType
 210 spi_relation_type_from_atk_relation_type (AtkRelationType type)
 211 {
 212   static gboolean is_initialized = FALSE;
 213   static Accessibility_RelationType spi_relation_type_table [ATK_RELATION_LAST_DEFINED];
 214   Accessibility_RelationType spi_type;
 215
 216   if (!is_initialized)
 217     is_initialized = spi_init_relation_type_table (spi_relation_type_table);
 218
 219   if (type > ATK_RELATION_NULL && type < ATK_RELATION_LAST_DEFINED)
 220     spi_type = spi_relation_type_table[type];
 221   else
 222     spi_type = Accessibility_RELATION_EXTENDED;
 223   return spi_type;
 224 }
 225
 226 static DBusMessage *
 227 impl_getRelationSet (DBusConnection *bus,
 228                      DBusMessage *message,
 229                      void *user_data)
 230 {
 231   AtkObject *object = (AtkObject *) user_data;
 232   DBusMessage *reply;
 233   AtkRelationSet *set;
 234   DBusMessageIter iter, iter_array, iter_struct, iter_targets;
 235   gint count;
 236   gint i, j;
 237
 238   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 239                         droute_not_yet_handled_error (message));
 240   reply = dbus_message_new_method_return (message);
 241   if (!reply) return NULL;
 242   set = atk_object_ref_relation_set (object);
 243   dbus_message_iter_init_append (reply, &iter);
 244   if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(uao)", &iter_array))
 245   {
 246     goto oom;
 247   }
 248   count = atk_relation_set_get_n_relations (set);
 249   for (i = 0; i < count; i++)
 250   {
 251     AtkRelation *r = atk_relation_set_get_relation (set, i);
 252     AtkRelationType rt;
 253     GPtrArray *target;
 254     dbus_uint32_t type;
 255     if (!r) continue;
 256     rt= atk_relation_get_relation_type (r);
 257     type = spi_relation_type_from_atk_relation_type (rt);
 258     target = atk_relation_get_target (r);
 259     if (!dbus_message_iter_open_container (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct))
 260     {
 261       goto oom;
 262     }
 263     dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &type);
 264     if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "o", &iter_targets))
 265     {
 266       goto oom;
 267     }
 268     for (j = 0; j < target->len; j++)
 269     {
 270       AtkObject *obj = target->pdata[j];
 271       char *path;
 272       if (!obj) continue;
 273       path = atk_dbus_object_to_path (obj);
 274       dbus_message_iter_append_basic (&iter_targets, DBUS_TYPE_OBJECT_PATH, &path);
 275     }
 276     dbus_message_iter_close_container (&iter_struct, &iter_targets);
 277     dbus_message_iter_close_container (&iter_array, &iter_struct);
 278   }
 279   dbus_message_iter_close_container (&iter, &iter_array);
 280 oom:
 281   // TODO: handle out of memory */
 282   return reply;
 283 }
 284
 285 static gboolean
 286 spi_init_role_lookup_table (Accessibility_Role * role_table)
 287 {
 288   int i;
 289   /* if it's not in the list below, dunno what it is */
 290   for (i = 0; i < ATK_ROLE_LAST_DEFINED; ++i)
 291     {
 292       role_table[i] = Accessibility_ROLE_UNKNOWN;
 293     }
 294
 295   role_table[ATK_ROLE_INVALID] = Accessibility_ROLE_INVALID;
 296   role_table[ATK_ROLE_ACCEL_LABEL] = Accessibility_ROLE_ACCELERATOR_LABEL;
 297   role_table[ATK_ROLE_ALERT] = Accessibility_ROLE_ALERT;
 298   role_table[ATK_ROLE_ANIMATION] = Accessibility_ROLE_ANIMATION;
 299   role_table[ATK_ROLE_ARROW] = Accessibility_ROLE_ARROW;
 300   role_table[ATK_ROLE_CALENDAR] = Accessibility_ROLE_CALENDAR;
 301   role_table[ATK_ROLE_CANVAS] = Accessibility_ROLE_CANVAS;
 302   role_table[ATK_ROLE_CHECK_BOX] = Accessibility_ROLE_CHECK_BOX;
 303   role_table[ATK_ROLE_CHECK_MENU_ITEM] = Accessibility_ROLE_CHECK_MENU_ITEM;
 304   role_table[ATK_ROLE_COLOR_CHOOSER] = Accessibility_ROLE_COLOR_CHOOSER;
 305   role_table[ATK_ROLE_COLUMN_HEADER] = Accessibility_ROLE_COLUMN_HEADER;
 306   role_table[ATK_ROLE_COMBO_BOX] = Accessibility_ROLE_COMBO_BOX;
 307   role_table[ATK_ROLE_DATE_EDITOR] = Accessibility_ROLE_DATE_EDITOR;
 308   role_table[ATK_ROLE_DESKTOP_ICON] = Accessibility_ROLE_DESKTOP_ICON;
 309   role_table[ATK_ROLE_DESKTOP_FRAME] = Accessibility_ROLE_DESKTOP_FRAME;
 310   role_table[ATK_ROLE_DIAL] = Accessibility_ROLE_DIAL;
 311   role_table[ATK_ROLE_DIALOG] = Accessibility_ROLE_DIALOG;
 312   role_table[ATK_ROLE_DIRECTORY_PANE] = Accessibility_ROLE_DIRECTORY_PANE;
 313   role_table[ATK_ROLE_DRAWING_AREA] = Accessibility_ROLE_DRAWING_AREA;
 314   role_table[ATK_ROLE_FILE_CHOOSER] = Accessibility_ROLE_FILE_CHOOSER;
 315   role_table[ATK_ROLE_FILLER] = Accessibility_ROLE_FILLER;
 316   role_table[ATK_ROLE_FONT_CHOOSER] = Accessibility_ROLE_FONT_CHOOSER;
 317   role_table[ATK_ROLE_FRAME] = Accessibility_ROLE_FRAME;
 318   role_table[ATK_ROLE_GLASS_PANE] = Accessibility_ROLE_GLASS_PANE;
 319   role_table[ATK_ROLE_HTML_CONTAINER] = Accessibility_ROLE_HTML_CONTAINER;
 320   role_table[ATK_ROLE_ICON] = Accessibility_ROLE_ICON;
 321   role_table[ATK_ROLE_IMAGE] = Accessibility_ROLE_IMAGE;
 322   role_table[ATK_ROLE_INTERNAL_FRAME] = Accessibility_ROLE_INTERNAL_FRAME;
 323   role_table[ATK_ROLE_LABEL] = Accessibility_ROLE_LABEL;
 324   role_table[ATK_ROLE_LAYERED_PANE] = Accessibility_ROLE_LAYERED_PANE;
 325   role_table[ATK_ROLE_LIST] = Accessibility_ROLE_LIST;
 326   role_table[ATK_ROLE_LIST_ITEM] = Accessibility_ROLE_LIST_ITEM;
 327   role_table[ATK_ROLE_MENU] = Accessibility_ROLE_MENU;
 328   role_table[ATK_ROLE_MENU_BAR] = Accessibility_ROLE_MENU_BAR;
 329   role_table[ATK_ROLE_MENU_ITEM] = Accessibility_ROLE_MENU_ITEM;
 330   role_table[ATK_ROLE_OPTION_PANE] = Accessibility_ROLE_OPTION_PANE;
 331   role_table[ATK_ROLE_PAGE_TAB] = Accessibility_ROLE_PAGE_TAB;
 332   role_table[ATK_ROLE_PAGE_TAB_LIST] = Accessibility_ROLE_PAGE_TAB_LIST;
 333   role_table[ATK_ROLE_PANEL] = Accessibility_ROLE_PANEL;
 334   role_table[ATK_ROLE_PASSWORD_TEXT] = Accessibility_ROLE_PASSWORD_TEXT;
 335   role_table[ATK_ROLE_POPUP_MENU] = Accessibility_ROLE_POPUP_MENU;
 336   role_table[ATK_ROLE_PROGRESS_BAR] = Accessibility_ROLE_PROGRESS_BAR;
 337   role_table[ATK_ROLE_PUSH_BUTTON] = Accessibility_ROLE_PUSH_BUTTON;
 338   role_table[ATK_ROLE_RADIO_BUTTON] = Accessibility_ROLE_RADIO_BUTTON;
 339   role_table[ATK_ROLE_RADIO_MENU_ITEM] = Accessibility_ROLE_RADIO_MENU_ITEM;
 340   role_table[ATK_ROLE_ROOT_PANE] = Accessibility_ROLE_ROOT_PANE;
 341   role_table[ATK_ROLE_ROW_HEADER] = Accessibility_ROLE_ROW_HEADER;
 342   role_table[ATK_ROLE_SCROLL_BAR] = Accessibility_ROLE_SCROLL_BAR;
 343   role_table[ATK_ROLE_SCROLL_PANE] = Accessibility_ROLE_SCROLL_PANE;
 344   role_table[ATK_ROLE_SEPARATOR] = Accessibility_ROLE_SEPARATOR;
 345   role_table[ATK_ROLE_SLIDER] = Accessibility_ROLE_SLIDER;
 346   role_table[ATK_ROLE_SPIN_BUTTON] = Accessibility_ROLE_SPIN_BUTTON;
 347   role_table[ATK_ROLE_SPLIT_PANE] = Accessibility_ROLE_SPLIT_PANE;
 348   role_table[ATK_ROLE_STATUSBAR] = Accessibility_ROLE_STATUS_BAR;
 349   role_table[ATK_ROLE_TABLE] = Accessibility_ROLE_TABLE;
 350   role_table[ATK_ROLE_TABLE_CELL] = Accessibility_ROLE_TABLE_CELL;
 351   role_table[ATK_ROLE_TABLE_COLUMN_HEADER] =
 352     Accessibility_ROLE_TABLE_COLUMN_HEADER;
 353   role_table[ATK_ROLE_TABLE_ROW_HEADER] = Accessibility_ROLE_TABLE_ROW_HEADER;
 354   role_table[ATK_ROLE_TEAR_OFF_MENU_ITEM] =
 355     Accessibility_ROLE_TEAROFF_MENU_ITEM;
 356   role_table[ATK_ROLE_TERMINAL] = Accessibility_ROLE_TERMINAL;
 357   role_table[ATK_ROLE_TEXT] = Accessibility_ROLE_TEXT;
 358   role_table[ATK_ROLE_TOGGLE_BUTTON] = Accessibility_ROLE_TOGGLE_BUTTON;
 359   role_table[ATK_ROLE_TOOL_BAR] = Accessibility_ROLE_TOOL_BAR;
 360   role_table[ATK_ROLE_TOOL_TIP] = Accessibility_ROLE_TOOL_TIP;
 361   role_table[ATK_ROLE_TREE] = Accessibility_ROLE_TREE;
 362   role_table[ATK_ROLE_TREE_TABLE] = Accessibility_ROLE_TREE_TABLE;
 363   role_table[ATK_ROLE_UNKNOWN] = Accessibility_ROLE_UNKNOWN;
 364   role_table[ATK_ROLE_VIEWPORT] = Accessibility_ROLE_VIEWPORT;
 365   role_table[ATK_ROLE_WINDOW] = Accessibility_ROLE_WINDOW;
 366   role_table[ATK_ROLE_HEADER] = Accessibility_ROLE_HEADER;
 367   role_table[ATK_ROLE_FOOTER] = Accessibility_ROLE_FOOTER;
 368   role_table[ATK_ROLE_PARAGRAPH] = Accessibility_ROLE_PARAGRAPH;
 369   role_table[ATK_ROLE_RULER] = Accessibility_ROLE_RULER;
 370   role_table[ATK_ROLE_APPLICATION] = Accessibility_ROLE_APPLICATION;
 371   role_table[ATK_ROLE_AUTOCOMPLETE] = Accessibility_ROLE_AUTOCOMPLETE;
 372   role_table[ATK_ROLE_EDITBAR] = Accessibility_ROLE_EDITBAR;
 373   role_table[ATK_ROLE_EMBEDDED] = Accessibility_ROLE_EMBEDDED;
 374   role_table[ATK_ROLE_ENTRY] = Accessibility_ROLE_ENTRY;
 375   role_table[ATK_ROLE_CHART] = Accessibility_ROLE_CHART;
 376   role_table[ATK_ROLE_CAPTION] = Accessibility_ROLE_CAPTION;
 377   role_table[ATK_ROLE_DOCUMENT_FRAME] = Accessibility_ROLE_DOCUMENT_FRAME;
 378   role_table[ATK_ROLE_HEADING] = Accessibility_ROLE_HEADING;
 379   role_table[ATK_ROLE_PAGE] = Accessibility_ROLE_PAGE;
 380   role_table[ATK_ROLE_SECTION] = Accessibility_ROLE_SECTION;
 381   role_table[ATK_ROLE_FORM] = Accessibility_ROLE_FORM;
 382   role_table[ATK_ROLE_REDUNDANT_OBJECT] = Accessibility_ROLE_REDUNDANT_OBJECT;
 383   role_table[ATK_ROLE_LINK] = Accessibility_ROLE_LINK;
 384   role_table[ATK_ROLE_INPUT_METHOD_WINDOW] =
 385     Accessibility_ROLE_INPUT_METHOD_WINDOW;
 386   return TRUE;
 387 }
 388
 389 Accessibility_Role
 390 spi_accessible_role_from_atk_role (AtkRole role)
 391 {
 392   static gboolean is_initialized = FALSE;
 393   static Accessibility_Role spi_role_table[ATK_ROLE_LAST_DEFINED];
 394   Accessibility_Role spi_role;
 395
 396   if (!is_initialized)
 397     {
 398       is_initialized = spi_init_role_lookup_table (spi_role_table);
 399     }
 400
 401   if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)
 402     {
 403       spi_role = spi_role_table[role];
 404     }
 405   else
 406     {
 407       spi_role = Accessibility_ROLE_EXTENDED;
 408     }
 409   return spi_role;
 410 }
 411
 412 static DBusMessage *
 413 impl_getRole (DBusConnection *bus, DBusMessage *message, void *user_data)
 414 {
 415   AtkObject *object = (AtkObject *) user_data;
 416   gint role;
 417   dbus_uint32_t rv;
 418   DBusMessage *reply;
 419
 420   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 421                         droute_not_yet_handled_error (message));
 422   role = atk_object_get_role (object);
 423   rv = spi_accessible_role_from_atk_role (role);
 424   reply = dbus_message_new_method_return (message);
 425   if (reply)
 426     {
 427       dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv,
 428                                 DBUS_TYPE_INVALID);
 429     }
 430   return reply;
 431 }
 432
 433 static char *
 434 impl_get_role_str (void *datum)
 435 {
 436   g_return_val_if_fail (ATK_IS_OBJECT (datum), g_strdup (""));
 437   return g_strdup_printf ("%d",
 438                           spi_accessible_role_from_atk_role
 439                           (atk_object_get_role ((AtkObject *) datum)));
 440 }
 441
 442 static DBusMessage *
 443 impl_getRoleName (DBusConnection *bus,
 444                   DBusMessage *message,
 445                   void *user_data)
 446 {
 447   AtkObject *object = (AtkObject *) user_data;
 448   gint role;
 449   const char *role_name;
 450   DBusMessage *reply;
 451
 452   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 453                         droute_not_yet_handled_error (message));
 454   role = atk_object_get_role (object);
 455   role_name = atk_role_get_name (role);
 456   if (!role_name)
 457     role_name = "";
 458   reply = dbus_message_new_method_return (message);
 459   if (reply)
 460     {
 461       dbus_message_append_args (reply, DBUS_TYPE_STRING, &role_name,
 462                                 DBUS_TYPE_INVALID);
 463     }
 464   return reply;
 465 }
 466
 467 static DBusMessage *
 468 impl_getLocalizedRoleName (DBusConnection *bus,
 469                            DBusMessage *message,
 470                            void *user_data)
 471 {
 472   AtkObject *object = (AtkObject *) user_data;
 473   gint role;
 474   const char *role_name;
 475   DBusMessage *reply;
 476
 477   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 478                         droute_not_yet_handled_error (message));
 479   role = atk_object_get_role (object);
 480   role_name = atk_role_get_localized_name (role);
 481   if (!role_name)
 482     role_name = "";
 483   reply = dbus_message_new_method_return (message);
 484   if (reply)
 485     {
 486       dbus_message_append_args (reply, DBUS_TYPE_STRING, &role_name,
 487                                 DBUS_TYPE_INVALID);
 488     }
 489   return reply;
 490 }
 491
 492 static DBusMessage *
 493 impl_getState (DBusConnection *bus,
 494                DBusMessage *message,
 495                void *user_data)
 496 {
 497   AtkObject *object = (AtkObject *) user_data;
 498   dbus_uint32_t rv[2];
 499   dbus_uint32_t *array = rv;
 500   DBusMessage *reply;
 501
 502   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 503                         droute_not_yet_handled_error (message));
 504   spi_atk_state_to_dbus_array (object, rv);
 505   reply = dbus_message_new_method_return (message);
 506   if (reply)
 507     {
 508       dbus_message_append_args (reply, DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &array,
 509                                 2, DBUS_TYPE_INVALID);
 510     }
 511   return reply;
 512 }
 513
 514 static DBusMessage *
 515 impl_getAttributes (DBusConnection *bus,
 516                     DBusMessage *message,
 517                     void *user_data)
 518 {
 519   AtkObject *object = (AtkObject *) user_data;
 520   DBusMessage *reply;
 521
 522   AtkAttributeSet *attributes;
 523   DBusMessageIter iter;
 524
 525   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 526                         droute_not_yet_handled_error (message));
 527
 528   attributes = atk_object_get_attributes (object);
 529
 530   reply = dbus_message_new_method_return (message);
 531   dbus_message_iter_init_append (reply, &iter);
 532   spi_atk_append_attribute_set (&iter, attributes);
 533
 534   if (attributes)
 535     atk_attribute_set_free (attributes);
 536
 537   return reply;
 538 }
 539
 540 static DBusMessage *
 541 impl_getApplication (DBusConnection *bus,
 542                      DBusMessage *message,
 543                      void *user_data)
 544 {
 545   AtkObject *root = atk_get_root ();
 546   return spi_dbus_return_object (message, root, FALSE);
 547 }
 548
 549 static DBusMessage *
 550 impl_getInterfaces (DBusConnection *bus,
 551                     DBusMessage *message,
 552                     void *user_data)
 553 {
 554   AtkObject *object = (AtkObject *) user_data;
 555   gint role;
 556   const char *role_name;
 557   DBusMessage *reply;
 558   DBusMessageIter iter, iter_array;
 559
 560   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 561                         droute_not_yet_handled_error (message));
 562   reply = dbus_message_new_method_return (message);
 563   if (reply)
 564     {
 565       dbus_message_iter_init_append (reply, &iter);
 566       dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &iter_array);
 567       append_atk_object_interfaces (object, &iter_array);
 568       dbus_message_iter_close_container (&iter, &iter_array);
 569     }
 570   return reply;
 571 }
 572
 573 static DRouteMethod methods[] = {
 574   {impl_getChildAtIndex, "getChildAtIndex"},
 575   {impl_getChildren, "getChildren"},
 576   {impl_getIndexInParent, "getIndexInParent"},
 577   {impl_getRelationSet, "getRelationSet"},
 578   {impl_getRole, "getRole"},
 579   {impl_getRoleName, "getRoleName"},
 580   {impl_getLocalizedRoleName, "getLocalizedRoleName"},
 581   {impl_getState, "getState"},
 582   {impl_getAttributes, "getAttributes"},
 583   {impl_getApplication, "getApplication"},
 584   {impl_getInterfaces, "getInterfaces"},
 585   {NULL, NULL}
 586 };
 587
 588 static DRouteProperty properties[] = {
 589   {impl_get_name, impl_set_name, "name"},
 590   {impl_get_description, impl_set_description, "description"},
 591   {impl_get_parent, NULL, "parent"},
 592   {impl_get_childCount, NULL, "childCount"},
 593   {NULL, NULL, NULL}
 594 };
 595
 596 void
 597 spi_initialize_accessible (DRoutePath *path)
 598 {
 599   droute_path_add_interface (path,
 600                              SPI_DBUS_INTERFACE_ACCESSIBLE,
 601                              methods,
 602                              properties);
 603 };