atk-adaptor/adaptors/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), FALSE);
  86 }
  87
  88 static dbus_bool_t
  89 impl_get_ChildCount (DBusMessageIter * iter, void *user_data)
  90 {
  91   AtkObject *object = (AtkObject *) user_data;
  92
  93   g_return_val_if_fail (ATK_IS_OBJECT (user_data), FALSE);
  94
  95   return droute_return_v_int32 (iter,
  96                                 atk_object_get_n_accessible_children
  97                                 (object));
  98 }
  99
 100 static DBusMessage *
 101 impl_GetChildAtIndex (DBusConnection * bus,
 102                       DBusMessage * message, void *user_data)
 103 {
 104   AtkObject *object = (AtkObject *) user_data;
 105   DBusError error;
 106   dbus_int32_t i;
 107   AtkObject *child;
 108
 109   dbus_error_init (&error);
 110   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 111                         droute_not_yet_handled_error (message));
 112   if (!dbus_message_get_args
 113        (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID))
 114     {
 115       return droute_invalid_arguments_error (message);
 116     }
 117   child = atk_object_ref_accessible_child (object, i);
 118   return spi_dbus_return_object (message, child, TRUE, TRUE);
 119 }
 120
 121 static DBusMessage *
 122 impl_GetChildren (DBusConnection * bus,
 123                   DBusMessage * message, 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)
 136     goto oom;
 137   dbus_message_iter_init_append (reply, &iter);
 138   if (!dbus_message_iter_open_container
 139       (&iter, DBUS_TYPE_ARRAY, "o", &iter_array))
 140     goto oom;
 141   for (i = 0; i < count; i++)
 142     {
 143       AtkObject *child = atk_object_ref_accessible_child (object, i);
 144       char *path = atk_dbus_object_to_path (child, FALSE);
 145       if (path)
 146         {
 147           dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_OBJECT_PATH,
 148                                           &path);
 149           g_free (path);
 150         }
 151       if (child)
 152         g_object_unref (child);
 153     }
 154   if (!dbus_message_iter_close_container (&iter, &iter_array))
 155     goto oom;
 156   return reply;
 157 oom:
 158   // TODO: handle out-of-memory
 159   return reply;
 160 }
 161
 162 static DBusMessage *
 163 impl_GetIndexInParent (DBusConnection * bus,
 164                        DBusMessage * message, 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] =
 203     Accessibility_RELATION_PARENT_WINDOW_OF;
 204   types[ATK_RELATION_DESCRIPTION_FOR] =
 205     Accessibility_RELATION_DESCRIPTION_FOR;
 206   types[ATK_RELATION_DESCRIBED_BY] = Accessibility_RELATION_DESCRIBED_BY;
 207
 208   return TRUE;
 209 }
 210
 211 static Accessibility_RelationType
 212 spi_relation_type_from_atk_relation_type (AtkRelationType type)
 213 {
 214   static gboolean is_initialized = FALSE;
 215   static Accessibility_RelationType
 216     spi_relation_type_table[ATK_RELATION_LAST_DEFINED];
 217   Accessibility_RelationType spi_type;
 218
 219   if (!is_initialized)
 220     is_initialized = spi_init_relation_type_table (spi_relation_type_table);
 221
 222   if (type > ATK_RELATION_NULL && type < ATK_RELATION_LAST_DEFINED)
 223     spi_type = spi_relation_type_table[type];
 224   else
 225     spi_type = Accessibility_RELATION_EXTENDED;
 226   return spi_type;
 227 }
 228
 229 static DBusMessage *
 230 impl_GetRelationSet (DBusConnection * bus,
 231                      DBusMessage * message, void *user_data)
 232 {
 233   AtkObject *object = (AtkObject *) user_data;
 234   DBusMessage *reply;
 235   AtkRelationSet *set;
 236   DBusMessageIter iter, iter_array, iter_struct, iter_targets;
 237   gint count;
 238   gint i, j;
 239
 240   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 241                         droute_not_yet_handled_error (message));
 242   reply = dbus_message_new_method_return (message);
 243   if (!reply)
 244     return NULL;
 245   set = atk_object_ref_relation_set (object);
 246   dbus_message_iter_init_append (reply, &iter);
 247   if (!dbus_message_iter_open_container
 248       (&iter, DBUS_TYPE_ARRAY, "(ua(so))", &iter_array))
 249     {
 250       goto oom;
 251     }
 252   count = atk_relation_set_get_n_relations (set);
 253   for (i = 0; i < count; i++)
 254     {
 255       AtkRelation *r = atk_relation_set_get_relation (set, i);
 256       AtkRelationType rt;
 257       GPtrArray *target;
 258       dbus_uint32_t type;
 259       if (!r)
 260         continue;
 261       rt = atk_relation_get_relation_type (r);
 262       type = spi_relation_type_from_atk_relation_type (rt);
 263       target = atk_relation_get_target (r);
 264       if (!dbus_message_iter_open_container
 265           (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct))
 266         {
 267           goto oom;
 268         }
 269       dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &type);
 270       if (!dbus_message_iter_open_container
 271           (&iter_struct, DBUS_TYPE_ARRAY, "(so)", &iter_targets))
 272         {
 273           goto oom;
 274         }
 275       for (j = 0; j < target->len; j++)
 276         {
 277           AtkObject *obj = target->pdata[j];
 278           char *path;
 279           if (!obj)
 280             continue;
 281           path = atk_dbus_object_to_path (obj, FALSE);
 282           if (!path)
 283             {
 284               g_warning ("Unknown object in relation type %d\n", type);
 285               continue;
 286             }
 287           spi_dbus_append_name_and_path_inner (&iter_targets, NULL, path);
 288         }
 289       dbus_message_iter_close_container (&iter_struct, &iter_targets);
 290       dbus_message_iter_close_container (&iter_array, &iter_struct);
 291     }
 292   dbus_message_iter_close_container (&iter, &iter_array);
 293 oom:
 294   // TODO: handle out of memory */
 295   return reply;
 296 }
 297
 298 static gboolean
 299 spi_init_role_lookup_table (Accessibility_Role * role_table)
 300 {
 301   int i;
 302   /* if it's not in the list below, dunno what it is */
 303   for (i = 0; i < ATK_ROLE_LAST_DEFINED; ++i)
 304     {
 305       role_table[i] = Accessibility_ROLE_UNKNOWN;
 306     }
 307
 308   role_table[ATK_ROLE_INVALID] = Accessibility_ROLE_INVALID;
 309   role_table[ATK_ROLE_ACCEL_LABEL] = Accessibility_ROLE_ACCELERATOR_LABEL;
 310   role_table[ATK_ROLE_ALERT] = Accessibility_ROLE_ALERT;
 311   role_table[ATK_ROLE_ANIMATION] = Accessibility_ROLE_ANIMATION;
 312   role_table[ATK_ROLE_ARROW] = Accessibility_ROLE_ARROW;
 313   role_table[ATK_ROLE_CALENDAR] = Accessibility_ROLE_CALENDAR;
 314   role_table[ATK_ROLE_CANVAS] = Accessibility_ROLE_CANVAS;
 315   role_table[ATK_ROLE_CHECK_BOX] = Accessibility_ROLE_CHECK_BOX;
 316   role_table[ATK_ROLE_CHECK_MENU_ITEM] = Accessibility_ROLE_CHECK_MENU_ITEM;
 317   role_table[ATK_ROLE_COLOR_CHOOSER] = Accessibility_ROLE_COLOR_CHOOSER;
 318   role_table[ATK_ROLE_COLUMN_HEADER] = Accessibility_ROLE_COLUMN_HEADER;
 319   role_table[ATK_ROLE_COMBO_BOX] = Accessibility_ROLE_COMBO_BOX;
 320   role_table[ATK_ROLE_DATE_EDITOR] = Accessibility_ROLE_DATE_EDITOR;
 321   role_table[ATK_ROLE_DESKTOP_ICON] = Accessibility_ROLE_DESKTOP_ICON;
 322   role_table[ATK_ROLE_DESKTOP_FRAME] = Accessibility_ROLE_DESKTOP_FRAME;
 323   role_table[ATK_ROLE_DIAL] = Accessibility_ROLE_DIAL;
 324   role_table[ATK_ROLE_DIALOG] = Accessibility_ROLE_DIALOG;
 325   role_table[ATK_ROLE_DIRECTORY_PANE] = Accessibility_ROLE_DIRECTORY_PANE;
 326   role_table[ATK_ROLE_DRAWING_AREA] = Accessibility_ROLE_DRAWING_AREA;
 327   role_table[ATK_ROLE_FILE_CHOOSER] = Accessibility_ROLE_FILE_CHOOSER;
 328   role_table[ATK_ROLE_FILLER] = Accessibility_ROLE_FILLER;
 329   role_table[ATK_ROLE_FONT_CHOOSER] = Accessibility_ROLE_FONT_CHOOSER;
 330   role_table[ATK_ROLE_FRAME] = Accessibility_ROLE_FRAME;
 331   role_table[ATK_ROLE_GLASS_PANE] = Accessibility_ROLE_GLASS_PANE;
 332   role_table[ATK_ROLE_HTML_CONTAINER] = Accessibility_ROLE_HTML_CONTAINER;
 333   role_table[ATK_ROLE_ICON] = Accessibility_ROLE_ICON;
 334   role_table[ATK_ROLE_IMAGE] = Accessibility_ROLE_IMAGE;
 335   role_table[ATK_ROLE_INTERNAL_FRAME] = Accessibility_ROLE_INTERNAL_FRAME;
 336   role_table[ATK_ROLE_LABEL] = Accessibility_ROLE_LABEL;
 337   role_table[ATK_ROLE_LAYERED_PANE] = Accessibility_ROLE_LAYERED_PANE;
 338   role_table[ATK_ROLE_LIST] = Accessibility_ROLE_LIST;
 339   role_table[ATK_ROLE_LIST_ITEM] = Accessibility_ROLE_LIST_ITEM;
 340   role_table[ATK_ROLE_MENU] = Accessibility_ROLE_MENU;
 341   role_table[ATK_ROLE_MENU_BAR] = Accessibility_ROLE_MENU_BAR;
 342   role_table[ATK_ROLE_MENU_ITEM] = Accessibility_ROLE_MENU_ITEM;
 343   role_table[ATK_ROLE_OPTION_PANE] = Accessibility_ROLE_OPTION_PANE;
 344   role_table[ATK_ROLE_PAGE_TAB] = Accessibility_ROLE_PAGE_TAB;
 345   role_table[ATK_ROLE_PAGE_TAB_LIST] = Accessibility_ROLE_PAGE_TAB_LIST;
 346   role_table[ATK_ROLE_PANEL] = Accessibility_ROLE_PANEL;
 347   role_table[ATK_ROLE_PASSWORD_TEXT] = Accessibility_ROLE_PASSWORD_TEXT;
 348   role_table[ATK_ROLE_POPUP_MENU] = Accessibility_ROLE_POPUP_MENU;
 349   role_table[ATK_ROLE_PROGRESS_BAR] = Accessibility_ROLE_PROGRESS_BAR;
 350   role_table[ATK_ROLE_PUSH_BUTTON] = Accessibility_ROLE_PUSH_BUTTON;
 351   role_table[ATK_ROLE_RADIO_BUTTON] = Accessibility_ROLE_RADIO_BUTTON;
 352   role_table[ATK_ROLE_RADIO_MENU_ITEM] = Accessibility_ROLE_RADIO_MENU_ITEM;
 353   role_table[ATK_ROLE_ROOT_PANE] = Accessibility_ROLE_ROOT_PANE;
 354   role_table[ATK_ROLE_ROW_HEADER] = Accessibility_ROLE_ROW_HEADER;
 355   role_table[ATK_ROLE_SCROLL_BAR] = Accessibility_ROLE_SCROLL_BAR;
 356   role_table[ATK_ROLE_SCROLL_PANE] = Accessibility_ROLE_SCROLL_PANE;
 357   role_table[ATK_ROLE_SEPARATOR] = Accessibility_ROLE_SEPARATOR;
 358   role_table[ATK_ROLE_SLIDER] = Accessibility_ROLE_SLIDER;
 359   role_table[ATK_ROLE_SPIN_BUTTON] = Accessibility_ROLE_SPIN_BUTTON;
 360   role_table[ATK_ROLE_SPLIT_PANE] = Accessibility_ROLE_SPLIT_PANE;
 361   role_table[ATK_ROLE_STATUSBAR] = Accessibility_ROLE_STATUS_BAR;
 362   role_table[ATK_ROLE_TABLE] = Accessibility_ROLE_TABLE;
 363   role_table[ATK_ROLE_TABLE_CELL] = Accessibility_ROLE_TABLE_CELL;
 364   role_table[ATK_ROLE_TABLE_COLUMN_HEADER] =
 365     Accessibility_ROLE_TABLE_COLUMN_HEADER;
 366   role_table[ATK_ROLE_TABLE_ROW_HEADER] = Accessibility_ROLE_TABLE_ROW_HEADER;
 367   role_table[ATK_ROLE_TEAR_OFF_MENU_ITEM] =
 368     Accessibility_ROLE_TEAROFF_MENU_ITEM;
 369   role_table[ATK_ROLE_TERMINAL] = Accessibility_ROLE_TERMINAL;
 370   role_table[ATK_ROLE_TEXT] = Accessibility_ROLE_TEXT;
 371   role_table[ATK_ROLE_TOGGLE_BUTTON] = Accessibility_ROLE_TOGGLE_BUTTON;
 372   role_table[ATK_ROLE_TOOL_BAR] = Accessibility_ROLE_TOOL_BAR;
 373   role_table[ATK_ROLE_TOOL_TIP] = Accessibility_ROLE_TOOL_TIP;
 374   role_table[ATK_ROLE_TREE] = Accessibility_ROLE_TREE;
 375   role_table[ATK_ROLE_TREE_TABLE] = Accessibility_ROLE_TREE_TABLE;
 376   role_table[ATK_ROLE_UNKNOWN] = Accessibility_ROLE_UNKNOWN;
 377   role_table[ATK_ROLE_VIEWPORT] = Accessibility_ROLE_VIEWPORT;
 378   role_table[ATK_ROLE_WINDOW] = Accessibility_ROLE_WINDOW;
 379   role_table[ATK_ROLE_HEADER] = Accessibility_ROLE_HEADER;
 380   role_table[ATK_ROLE_FOOTER] = Accessibility_ROLE_FOOTER;
 381   role_table[ATK_ROLE_PARAGRAPH] = Accessibility_ROLE_PARAGRAPH;
 382   role_table[ATK_ROLE_RULER] = Accessibility_ROLE_RULER;
 383   role_table[ATK_ROLE_APPLICATION] = Accessibility_ROLE_APPLICATION;
 384   role_table[ATK_ROLE_AUTOCOMPLETE] = Accessibility_ROLE_AUTOCOMPLETE;
 385   role_table[ATK_ROLE_EDITBAR] = Accessibility_ROLE_EDITBAR;
 386   role_table[ATK_ROLE_EMBEDDED] = Accessibility_ROLE_EMBEDDED;
 387   role_table[ATK_ROLE_ENTRY] = Accessibility_ROLE_ENTRY;
 388   role_table[ATK_ROLE_CHART] = Accessibility_ROLE_CHART;
 389   role_table[ATK_ROLE_CAPTION] = Accessibility_ROLE_CAPTION;
 390   role_table[ATK_ROLE_DOCUMENT_FRAME] = Accessibility_ROLE_DOCUMENT_FRAME;
 391   role_table[ATK_ROLE_HEADING] = Accessibility_ROLE_HEADING;
 392   role_table[ATK_ROLE_PAGE] = Accessibility_ROLE_PAGE;
 393   role_table[ATK_ROLE_SECTION] = Accessibility_ROLE_SECTION;
 394   role_table[ATK_ROLE_FORM] = Accessibility_ROLE_FORM;
 395   role_table[ATK_ROLE_REDUNDANT_OBJECT] = Accessibility_ROLE_REDUNDANT_OBJECT;
 396   role_table[ATK_ROLE_LINK] = Accessibility_ROLE_LINK;
 397   role_table[ATK_ROLE_INPUT_METHOD_WINDOW] =
 398     Accessibility_ROLE_INPUT_METHOD_WINDOW;
 399   return TRUE;
 400 }
 401
 402 Accessibility_Role
 403 spi_accessible_role_from_atk_role (AtkRole role)
 404 {
 405   static gboolean is_initialized = FALSE;
 406   static Accessibility_Role spi_role_table[ATK_ROLE_LAST_DEFINED];
 407   Accessibility_Role spi_role;
 408
 409   if (!is_initialized)
 410     {
 411       is_initialized = spi_init_role_lookup_table (spi_role_table);
 412     }
 413
 414   if (role >= 0 && role < ATK_ROLE_LAST_DEFINED)
 415     {
 416       spi_role = spi_role_table[role];
 417     }
 418   else
 419     {
 420       spi_role = Accessibility_ROLE_EXTENDED;
 421     }
 422   return spi_role;
 423 }
 424
 425 static DBusMessage *
 426 impl_GetRole (DBusConnection * bus, DBusMessage * message, void *user_data)
 427 {
 428   AtkObject *object = (AtkObject *) user_data;
 429   gint role;
 430   dbus_uint32_t rv;
 431   DBusMessage *reply;
 432
 433   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 434                         droute_not_yet_handled_error (message));
 435   role = atk_object_get_role (object);
 436   rv = spi_accessible_role_from_atk_role (role);
 437   reply = dbus_message_new_method_return (message);
 438   if (reply)
 439     {
 440       dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv,
 441                                 DBUS_TYPE_INVALID);
 442     }
 443   return reply;
 444 }
 445
 446 static char *
 447 impl_get_role_str (void *datum)
 448 {
 449   g_return_val_if_fail (ATK_IS_OBJECT (datum), g_strdup (""));
 450   return g_strdup_printf ("%d",
 451                           spi_accessible_role_from_atk_role
 452                           (atk_object_get_role ((AtkObject *) datum)));
 453 }
 454
 455 static DBusMessage *
 456 impl_GetRoleName (DBusConnection * bus,
 457                   DBusMessage * message, void *user_data)
 458 {
 459   AtkObject *object = (AtkObject *) user_data;
 460   gint role;
 461   const char *role_name;
 462   DBusMessage *reply;
 463
 464   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 465                         droute_not_yet_handled_error (message));
 466   role = atk_object_get_role (object);
 467   role_name = atk_role_get_name (role);
 468   if (!role_name)
 469     role_name = "";
 470   reply = dbus_message_new_method_return (message);
 471   if (reply)
 472     {
 473       dbus_message_append_args (reply, DBUS_TYPE_STRING, &role_name,
 474                                 DBUS_TYPE_INVALID);
 475     }
 476   return reply;
 477 }
 478
 479 static DBusMessage *
 480 impl_GetLocalizedRoleName (DBusConnection * bus,
 481                            DBusMessage * message, void *user_data)
 482 {
 483   AtkObject *object = (AtkObject *) user_data;
 484   gint role;
 485   const char *role_name;
 486   DBusMessage *reply;
 487
 488   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 489                         droute_not_yet_handled_error (message));
 490   role = atk_object_get_role (object);
 491   role_name = atk_role_get_localized_name (role);
 492   if (!role_name)
 493     role_name = "";
 494   reply = dbus_message_new_method_return (message);
 495   if (reply)
 496     {
 497       dbus_message_append_args (reply, DBUS_TYPE_STRING, &role_name,
 498                                 DBUS_TYPE_INVALID);
 499     }
 500   return reply;
 501 }
 502
 503 static DBusMessage *
 504 impl_GetState (DBusConnection * bus, DBusMessage * message, void *user_data)
 505 {
 506   AtkObject *object = (AtkObject *) user_data;
 507
 508   DBusMessage *reply = NULL;
 509   DBusMessageIter iter, iter_array;
 510
 511   dbus_uint32_t states[2];
 512
 513   guint count;
 514
 515   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 516                         droute_not_yet_handled_error (message));
 517
 518   reply = dbus_message_new_method_return (message);
 519   dbus_message_iter_init_append (reply, &iter);
 520
 521   spi_atk_state_to_dbus_array (object, states);
 522   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "u", &iter_array);
 523   for (count = 0; count < 2; count++)
 524     {
 525       dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_UINT32,
 526                                       &states[count]);
 527     }
 528   dbus_message_iter_close_container (&iter, &iter_array);
 529   return reply;
 530 }
 531
 532 static DBusMessage *
 533 impl_GetAttributes (DBusConnection * bus,
 534                     DBusMessage * message, void *user_data)
 535 {
 536   AtkObject *object = (AtkObject *) user_data;
 537   DBusMessage *reply = NULL;
 538
 539   AtkAttributeSet *attributes;
 540   DBusMessageIter iter;
 541
 542   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 543                         droute_not_yet_handled_error (message));
 544
 545   attributes = atk_object_get_attributes (object);
 546
 547   reply = dbus_message_new_method_return (message);
 548   dbus_message_iter_init_append (reply, &iter);
 549   spi_atk_append_attribute_set (&iter, attributes);
 550
 551   if (attributes)
 552     atk_attribute_set_free (attributes);
 553
 554   return reply;
 555 }
 556
 557 static DBusMessage *
 558 impl_GetApplication (DBusConnection * bus,
 559                      DBusMessage * message, void *user_data)
 560 {
 561   AtkObject *root = atk_get_root ();
 562   return spi_dbus_return_object (message, root, FALSE, FALSE);
 563 }
 564
 565 static DBusMessage *
 566 impl_GetInterfaces (DBusConnection * bus,
 567                     DBusMessage * message, void *user_data)
 568 {
 569   AtkObject *object = (AtkObject *) user_data;
 570   gint role;
 571   const char *role_name;
 572   DBusMessage *reply;
 573   DBusMessageIter iter, iter_array;
 574
 575   g_return_val_if_fail (ATK_IS_OBJECT (user_data),
 576                         droute_not_yet_handled_error (message));
 577   reply = dbus_message_new_method_return (message);
 578   if (reply)
 579     {
 580       dbus_message_iter_init_append (reply, &iter);
 581       dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s",
 582                                         &iter_array);
 583       append_atk_object_interfaces (object, &iter_array);
 584       dbus_message_iter_close_container (&iter, &iter_array);
 585     }
 586   return reply;
 587 }
 588
 589 static DBusMessage *
 590 impl_Embedded (DBusConnection *bus,
 591                     DBusMessage *message,
 592                     void *user_data)
 593 {
 594   AtkObject *object = (AtkObject *) user_data;
 595   char *path;
 596   gchar *id;
 597
 598   if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID))
 599     {
 600       return droute_invalid_arguments_error (message);
 601     }
 602   id = g_object_get_data (G_OBJECT (object), "dbus-plug-parent");
 603   if (id)
 604     g_free (id);
 605   id = g_strconcat (dbus_message_get_sender (message), ":", path, NULL);
 606   g_object_set_data (G_OBJECT (object), "dbus-plug-parent", id);
 607   return dbus_message_new_method_return (message);
 608 }
 609
 610 static DRouteMethod methods[] = {
 611   {impl_GetChildAtIndex, "GetChildAtIndex"},
 612   {impl_GetChildren, "GetChildren"},
 613   {impl_GetIndexInParent, "GetIndexInParent"},
 614   {impl_GetRelationSet, "GetRelationSet"},
 615   {impl_GetRole, "GetRole"},
 616   {impl_GetRoleName, "GetRoleName"},
 617   {impl_GetLocalizedRoleName, "GetLocalizedRoleName"},
 618   {impl_GetState, "GetState"},
 619   {impl_GetAttributes, "GetAttributes"},
 620   {impl_GetApplication, "GetApplication"},
 621   {impl_GetInterfaces, "GetInterfaces"},
 622   {impl_Embedded, "Embedded"},
 623   {NULL, NULL}
 624 };
 625
 626 static DRouteProperty properties[] = {
 627   {impl_get_Name, impl_set_Name, "Name"},
 628   {impl_get_Description, impl_set_Description, "Description"},
 629   {impl_get_Parent, NULL, "Parent"},
 630   {impl_get_ChildCount, NULL, "ChildCount"},
 631   {NULL, NULL, NULL}
 632 };
 633
 634 void
 635 spi_initialize_accessible (DRoutePath * path)
 636 {
 637   droute_path_add_interface (path,
 638                              SPI_DBUS_INTERFACE_ACCESSIBLE,
 639                              methods, properties);
 640 };