2 * AT-SPI - Assistive Technology Service Provider Interface
3 * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
5 * Copyright 2001, 2002 Sun Microsystems Inc.,
6 * Copyright 2001, 2002 Ximian, Inc.
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
26 * Basic SPI initialization and event loop function prototypes
33 #include <cspi/spi-private.h>
38 static DBusConnection *bus = NULL;
39 static GHashTable *apps = NULL;
40 static GHashTable *live_refs = NULL;
41 static GQueue *exception_handlers = NULL;
42 static DBusError exception;
45 cspi_object_release (gpointer value)
50 cspi_exception_throw (DBusError *error, const char *desc_prefix)
52 SPIExceptionHandler *handler = NULL;
54 if (exception_handlers) handler = g_queue_peek_head (exception_handlers);
56 ex.type = SPI_EXCEPTION_SOURCE_UNSPECIFIED;
58 ex.code = SPI_EXCEPTION_UNSPECIFIED;
60 // TODO: Fill in description
63 return (*handler) (&ex, FALSE);
65 return FALSE; /* means exception was not handled */
68 const char *spi_path_dec = SPI_DBUS_PATH_DEC;
69 const char *spi_path_registry = SPI_DBUS_PATH_REGISTRY;
70 const char *spi_bus_registry = SPI_DBUS_NAME_REGISTRY;
71 const char *spi_path_desktop = SPI_DBUS_PATH_DESKTOP;
72 const char *spi_interface_accessible = SPI_DBUS_INTERFACE_ACCESSIBLE;
73 const char *spi_interface_action = SPI_DBUS_INTERFACE_ACTION;
74 const char *spi_interface_application = SPI_DBUS_INTERFACE_APPLICATION;
75 const char *spi_interface_component = SPI_DBUS_INTERFACE_COMPONENT;
76 const char *spi_interface_dec = SPI_DBUS_INTERFACE_DEC;
77 const char *spi_interface_desktop = SPI_DBUS_INTERFACE_DESKTOP;
78 const char *spi_interface_device_event_listener = SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER;
79 const char *spi_interface_document = SPI_DBUS_INTERFACE_DOCUMENT;
80 const char *spi_interface_editable_text = SPI_DBUS_INTERFACE_EDITABLE_TEXT;
81 const char *spi_interface_hyperlink = SPI_DBUS_INTERFACE_HYPERLINK;
82 const char *spi_interface_hypertext = SPI_DBUS_INTERFACE_HYPERTEXT;
83 const char *spi_interface_image = SPI_DBUS_INTERFACE_IMAGE;
84 const char *spi_interface_registry = SPI_DBUS_INTERFACE_REGISTRY;
85 const char *spi_interface_selection = SPI_DBUS_INTERFACE_SELECTION;
86 const char *spi_interface_table = SPI_DBUS_INTERFACE_TABLE;
87 const char *spi_interface_text = SPI_DBUS_INTERFACE_TEXT;
88 const char *spi_interface_tree = SPI_DBUS_INTERFACE_TREE;
89 const char *spi_interface_value = SPI_DBUS_INTERFACE_VALUE;
91 static const char *interfaces[] =
93 SPI_DBUS_INTERFACE_ACCESSIBLE,
94 SPI_DBUS_INTERFACE_ACTION,
95 SPI_DBUS_INTERFACE_APPLICATION,
96 SPI_DBUS_INTERFACE_COLLECTION,
97 SPI_DBUS_INTERFACE_COMPONENT,
98 SPI_DBUS_INTERFACE_DOCUMENT,
99 SPI_DBUS_INTERFACE_EDITABLE_TEXT,
100 SPI_DBUS_INTERFACE_HYPERLINK,
101 SPI_DBUS_INTERFACE_HYPERTEXT,
102 SPI_DBUS_INTERFACE_IMAGE,
103 "org.a11y.atspi.LoginHelper",
104 SPI_DBUS_INTERFACE_SELECTION,
105 "org.a11y.atspi.Selector",
106 SPI_DBUS_INTERFACE_TABLE,
107 SPI_DBUS_INTERFACE_TEXT,
108 SPI_DBUS_INTERFACE_VALUE,
112 static gint get_iface_num (const char *iface)
114 // TODO: Use a binary search or hash to improve performance
117 for (i = 0; interfaces[i]; i++)
119 if (!strcmp(iface, interfaces[i])) return i;
125 cspi_accessible_is_a (Accessible *accessible,
126 const char *interface_name)
130 if (accessible == NULL)
135 n = get_iface_num (interface_name);
136 if (n == -1) return FALSE;
137 return (SPIBoolean)((accessible->interfaces & (1 << n))? TRUE: FALSE);
141 cspi_get_live_refs (void)
145 live_refs = g_hash_table_new (g_direct_hash, g_direct_equal);
157 cspi_exception (void)
159 if (dbus_error_is_set (&exception))
161 dbus_error_free (&exception);
168 cspi_check_ev (const char *error_string)
170 if (dbus_error_is_set (&exception))
172 cspi_exception_throw (&exception, error_string);
179 cspi_object_add (Accessible *accessible)
181 if (accessible) cspi_object_ref (accessible);
186 cspi_object_ref (Accessible *accessible)
188 g_return_if_fail (accessible != NULL);
190 accessible->ref_count++;
191 g_hash_table_insert (live_refs, accessible, accessible);
194 #define APP_IS_REGISTRY(app) (!strcmp (app->bus_name, spi_bus_registry))
197 cspi_object_unref_internal (Accessible *accessible, gboolean defunct)
201 if (accessible == NULL)
206 if (--accessible->ref_count == 0 || (accessible->ref_count == 1 && !defunct) && g_hash_table_lookup (live_refs, accessible))
209 memset (&e, 0, sizeof(e));
210 e.type = "object:state-change:defunct";
211 e.source = accessible;
213 cspi_dispatch_event (&e);
214 g_hash_table_remove (live_refs, accessible);
216 if (accessible->ref_count == 0)
218 if (APP_IS_REGISTRY (accessible->app))
220 g_free (accessible->v.path);
222 if (accessible->states)
223 spi_state_set_cache_unref (accessible->states);
224 g_free (accessible->description);
225 g_free (accessible->name);
231 cspi_object_unref (Accessible *accessible)
233 cspi_object_unref_internal (accessible, FALSE);
241 cspi_streams_close_all ();
247 g_hash_table_destroy (refs);
251 static gboolean SPI_inited = FALSE;
253 static GHashTable *app_hash = NULL;
256 ref_accessible (CSpiApplication *app, const char *path)
261 if (sscanf (path, "/org/a11y/atspi/accessible/%d", &id) != 1)
265 Accessible *a = g_hash_table_lookup (app->hash, &id);
271 id_val = g_new (guint, 1);
272 if (!id_val) return NULL;
274 a = g_new0 (Accessible, 1);
280 g_hash_table_insert (app->hash, id_val, a);
283 a->ref_count = 2; /* one for the caller, one for the hash */
287 static CSpiApplication *
288 cspi_get_application (const char *bus_name)
290 CSpiApplication *app = NULL;
295 app_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)g_hash_table_unref);
296 if (!app_hash) return NULL;
298 app = g_hash_table_lookup (app_hash, bus_name);
300 bus_name_dup = g_strdup (bus_name);
301 if (!bus_name_dup) return NULL;
302 // TODO: change below to something that will send state-change:defunct notification if necessary */
303 app = g_new (CSpiApplication, 1);
306 g_free (bus_name_dup);
309 app->bus_name = bus_name_dup;
310 if (APP_IS_REGISTRY (app))
312 app->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, cspi_object_unref);
316 app->hash = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, cspi_object_unref);
318 g_hash_table_insert (app_hash, bus_name_dup, app);
331 GArray *state_bitflags;
335 handle_addition (CSpiApplication*app, CACHE_ADDITION *ca)
340 Accessible *a = ref_accessible (app, ca->path);
341 /* Note: children don't hold refs for their parents or vice versa */
342 a->parent = ref_accessible (app, ca->parent);
343 if (a->parent) cspi_object_unref (a->parent);
346 g_list_free (a->children);
349 for (i = 0; i < ca->children->len; i++)
351 const char *child_path = g_array_index (ca->children, const char *, i);
352 Accessible *child = ref_accessible (app, child_path);
353 new_list = g_list_append (a->children, child);
354 if (new_list) a->children = new_list;
355 cspi_object_unref (child);
358 for (i = 0; i < ca->interfaces->len; i++)
360 const char *iface = g_array_index (ca->interfaces, const char *, i);
361 if (!strcmp (iface, "org.freedesktop.DBus.Introspectable")) continue;
362 gint n = get_iface_num (iface);
365 g_warning ("Unknown interface %s", iface);
367 else a->interfaces |= (1 << n);
370 if (a->name) g_free (a->name);
373 if (a->description) g_free (a->description);
374 a->description = ca->description;
375 a->states = spi_state_set_cache_new (ca->state_bitflags);
376 g_array_free (ca->interfaces, TRUE);
377 g_array_free (ca->children, TRUE);
378 /* spi_state_set_cache_new frees state_bitflags */
379 /* This is a bit of a hack since ref_accessible sets ref_count to 2
380 * for a new object, one of the refs being for the cache */
381 cspi_object_unref (a);
384 /* Update the cache with added/modified objects and free the array */
386 handle_additions (CSpiApplication*app, GArray *additions)
394 for (i = 0; i < additions->len; i++)
396 CACHE_ADDITION *ca = &g_array_index (additions, CACHE_ADDITION, i);
397 handle_addition (app, ca);
401 static DBusHandlerResult
402 cspi_dbus_handle_remove_accessible (DBusConnection *bus, DBusMessage *message, void *user_data)
404 const char *sender = dbus_message_get_sender (message);
405 CSpiApplication *app = cspi_get_application (sender);
409 if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID))
411 g_warning ("Received RemoveAccessible with invalid arguments");
412 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
414 a = ref_accessible (app, path);
415 if (a->parent && g_list_find (a->parent->children, a))
417 a->parent->children = g_list_remove (a->parent->children, a);
418 // TODO: Send children-changed:remove event
419 /* Note: children don't hold refs for their parents or vice versa */
421 g_hash_table_remove (app->hash, &a->v.id);
422 cspi_object_unref_internal (a, TRUE); /* unref our own ref */
423 return DBUS_HANDLER_RESULT_HANDLED;
427 add_app_to_desktop (Accessible *a, const char *bus_name)
432 dbus_error_init (&error);
433 if (dbind_method_call_reentrant (bus, bus_name, "/org/a11y/atspi/tree", spi_interface_tree, "getRoot", &error, "=>o", &root_path))
435 Accessible *obj = cspi_ref_accessible (bus_name, root_path);
438 GList *new_list = g_list_append (a->children, obj);
441 a->children = new_list;
449 g_warning ("Error calling getRoot for %s: %s", bus_name, error.message);
455 send_children_changed (Accessible *parent, Accessible *child, gboolean add)
459 memset (&e, 0, sizeof(e));
460 e.type = (add? "object:children-changed:add": "object:children-changed:remove");
462 e.detail1 = g_list_index (parent->children, child);
463 cspi_dispatch_event (&e);
467 unref_object_and_children (Accessible *obj)
471 for (l = obj->children; l; l = l->next)
473 unref_object_and_children (l->data);
475 cspi_object_unref_internal (obj, TRUE);
479 remove_app_from_desktop (Accessible *a, const char *bus_name)
484 for (l = a->children; l; l = l->next)
487 if (!strcmp (bus_name, child->app->bus_name)) break;
491 g_warning ("Removing unregistered app %s; doing nothing\n", bus_name);
494 send_children_changed (a, child, FALSE);
495 a->children = g_list_remove (a->children, child);
496 unref_object_and_children (child);
500 static Accessible *desktop;
503 ref_accessible_desktop (CSpiApplication *app)
512 cspi_object_ref (desktop);
515 desktop = g_new0 (Accessible, 1);
520 g_hash_table_insert (app->hash, "", desktop);
522 desktop->ref_count = 2; /* one for the caller, one for the hash */
523 desktop->name = g_strdup ("");
524 dbus_error_init (&error);
525 if (!dbind_method_call_reentrant (bus, spi_bus_registry, spi_path_registry, spi_interface_registry, "getApplications", &error, "=>as", &apps))
527 g_error ("Couldn't get application list: %s", error.message);
529 for (i = 0; i < apps->len; i++)
531 const char *app_name = g_array_index (apps, char *, i);
532 if (app_name[0] == '\0')
534 g_warning ("Got empty app name");
537 CSpiApplication *app = cspi_get_application (app_name);
539 dbus_error_init (&error);
540 dbind_method_call_reentrant (bus, app_name, "/org/a11y/atspi/tree", spi_interface_tree, "getTree", &error, "=>a(ooaoassusau)", &additions);
543 g_warning ("getTree (%s): %s", app_name, error.message);
545 handle_additions (app, additions);
546 add_app_to_desktop (desktop, app_name);
548 g_array_free (apps, TRUE);
553 cspi_ref_accessible (const char *app, const char *path)
555 CSpiApplication *a = cspi_get_application (app);
557 if ( APP_IS_REGISTRY(a))
559 return ref_accessible_desktop (a);
561 return ref_accessible (a, path);
565 cspi_ref_related_accessible (Accessible *obj, const char *path)
567 return ref_accessible (obj->app, path);
570 static const char *cacheSignalType = "(ooaoassusau)";
572 static DBusHandlerResult
573 cspi_dbus_handle_update_accessible (DBusConnection *bus, DBusMessage *message, void *user_data)
575 DBusMessageIter iter;
578 const char *sender = dbus_message_get_sender (message);
579 CSpiApplication *app = cspi_get_application (sender);
580 const char *type = cacheSignalType;
584 g_warning ("UpdateAccessible from unknown app. Should we add it?", sender);
585 return DBUS_HANDLER_RESULT_HANDLED;
587 dbus_message_iter_init (message, &iter);
588 // TODO: Check signature
589 dbind_any_demarshal (&iter, &type, &p); /* additions */
590 handle_addition (app, &ca);
591 return DBUS_HANDLER_RESULT_HANDLED;
594 static DBusHandlerResult
595 cspi_dbus_handle_register_application (DBusConnection *bus, DBusMessage *message, void *user_data)
602 dbus_error_init (&error);
603 a = cspi_ref_accessible (spi_bus_registry, spi_path_registry);
604 if (add_app_to_desktop (a, dbus_message_get_sender (message)))
606 send_children_changed (a, g_list_last (a->children)->data, TRUE);
608 cspi_object_unref (a);
609 return DBUS_HANDLER_RESULT_HANDLED;
612 static DBusHandlerResult
613 cspi_dbus_handle_deregister_application (DBusConnection *bus, DBusMessage *message, void *user_data)
619 dbus_error_init (&error);
620 if (!dbus_message_get_args (message, &error, DBUS_TYPE_STRING, &bus_name, DBUS_TYPE_INVALID))
622 g_warning ("Error processing %s: %s\n", dbus_message_get_member(message), error.message);
623 dbus_error_free (&error);
624 return DBUS_HANDLER_RESULT_HANDLED;
627 a = cspi_ref_accessible (spi_bus_registry, spi_path_registry);
628 remove_app_from_desktop (a, bus_name);
629 cspi_object_unref (a);
630 return DBUS_HANDLER_RESULT_HANDLED;
634 static DBusHandlerResult
635 cspi_dbus_filter (DBusConnection *bus, DBusMessage *message, void *data)
637 int type = dbus_message_get_type (message);
638 const char *interface = dbus_message_get_interface (message);
639 const char *member = dbus_message_get_member (message);
643 if (type == DBUS_MESSAGE_TYPE_SIGNAL &&
644 !strncmp (interface, "org.a11y.atspi.Event.", 28))
646 return cspi_dbus_handle_event (bus, message, data);
648 if (dbus_message_is_method_call (message, spi_interface_device_event_listener, "notifyEvent"))
650 return cspi_dbus_handle_deviceEvent (bus, message, data);
652 if (dbus_message_is_signal (message, spi_interface_tree, "updateAccessible"))
654 return cspi_dbus_handle_update_accessible (bus, message, data);
656 if (dbus_message_is_signal (message, spi_interface_tree, "removeAccessible"))
658 return cspi_dbus_handle_remove_accessible (bus, message, data);
660 if (dbus_message_is_method_call (message, spi_interface_registry, "registerApplication"))
662 return cspi_dbus_handle_register_application (bus, message, data);
664 if (dbus_message_is_method_call (message, spi_interface_registry, "deregisterApplication"))
666 return cspi_dbus_handle_deregister_application (bus, message, data);
668 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
671 static const char *signal_interfaces[] =
673 "org.a11y.atspi.Event.Object",
674 "org.a11y.atspi.Event.Window",
675 "org.a11y.atspi.Event.Mouse",
676 "org.a11y.atspi.Event.Terminal",
677 "org.a11y.atspi.Event.Document",
678 "org.a11y.atspi.Event.Focus",
685 * Connects to the accessibility registry and initializes the SPI.
687 * Returns: 0 on success, otherwise an integer error code.
705 cspi_get_live_refs();
706 g_atexit (cspi_cleanup);
708 dbus_error_init (&error);
709 bus = dbus_bus_get (DBUS_BUS_SESSION, &error);
712 g_error ("Couldn't get session bus");
715 dbus_bus_register (bus, &error);
716 dbus_connection_setup_with_g_main(bus, g_main_context_default());
717 dbus_connection_add_filter (bus, cspi_dbus_filter, NULL, NULL);
718 match = g_strdup_printf ("type='signal',interface='%s',member='updateAccessible'", spi_interface_tree);
719 dbus_error_init (&error);
720 dbus_bus_add_match (bus, match, &error);
722 match = g_strdup_printf ("type='signal',interface='%s',member='removeAccessible'", spi_interface_tree);
723 dbus_error_init (&error);
724 dbus_bus_add_match (bus, match, &error);
726 match = g_strdup_printf ("type='method_call',interface='%s'", spi_interface_registry);
727 dbus_bus_add_match (bus, match, &error);
729 for (i = 0; signal_interfaces[i]; i++)
731 match = g_strdup_printf ("type='signal',interface='%s'", signal_interfaces[i]);
732 dbus_bus_add_match (bus, match, &error);
738 static GMainLoop *mainloop;
743 * Starts/enters the main event loop for the SPI services.
745 * (NOTE: This method does not return control, it is exited via a call to
746 * SPI_event_quit () from within an event handler).
750 SPI_event_main (void)
753 mainloop = g_main_loop_new (NULL, FALSE);
754 g_main_loop_run (mainloop);
760 * Quits the last main event loop for the SPI services,
764 SPI_event_quit (void)
766 g_main_loop_quit (mainloop);
772 * Checks to see if an SPI event is waiting in the event queue.
773 * Used by clients that don't wish to use SPI_event_main().
775 * Not Yet Implemented.
777 * Returns: #TRUE if an event is waiting, otherwise #FALSE.
781 SPI_eventIsReady (void)
788 * @waitForEvent: a #SPIBoolean indicating whether to block or not.
790 * Gets the next event in the SPI event queue; blocks if no event
791 * is pending and @waitForEvent is #TRUE.
792 * Used by clients that don't wish to use SPI_event_main().
794 * Not Yet Implemented.
796 * Returns: the next #AccessibleEvent in the SPI event queue.
799 SPI_nextEvent (SPIBoolean waitForEvent)
806 report_leaked_ref (gpointer key, gpointer val, gpointer user_data)
809 Accessible *a = (Accessible *) val;
811 name = Accessible_getName (a);
812 if (cspi_exception ())
817 role = Accessible_getRoleName (a);
818 if (cspi_exception ())
823 fprintf (stderr, "leaked %d references to object %s, role %s %p\n",
824 a->ref_count, name ? name : "<?>", role ? role : "<?>", a);
826 SPI_freeString (name);
833 * Disconnects from the Accessibility Registry and releases
834 * any floating resources. Call only once at exit.
836 * Returns: 0 if there were no leaks, otherwise non zero.
852 leaked = g_hash_table_size (live_refs);
854 fprintf (stderr, "Leaked %d SPI handles\n", leaked);
858 g_hash_table_foreach (live_refs, report_leaked_ref, NULL);
875 * @s: a character string returned from another at-spi call.
877 * Free a character string returned from an at-spi call. Clients of
878 * at-spi should use this function instead of free () or g_free().
879 * A NULL string @s will be silently ignored.
880 * This API should not be used to free strings
881 * from other libraries or allocated by the client.
884 SPI_freeString (char *s)
894 * @r: a pointer to an SPIRect returned from another at-spi call.
896 * Free a SPIRect structure returned from an at-spi call. Clients of
897 * at-spi should use this function instead of free () or g_free().
898 * A NULL rect @r will be silently ignored.
899 * This API should not be used to free data
900 * from other libraries or allocated by the client.
905 SPI_freeRect (SPIRect *r)
909 /* err, okay, in this case the client _could_
910 have called g_free, but we don't want to guarantee it */
917 * @s: a UTF-8 string to be duplicated
921 * Returns: a duplicate of the string passed as a parameter, which should
922 * be freed via SPI_freeString after use.
925 SPI_dupString (char *s)
936 * SPI_exceptionHandlerPush:
937 * @handler: an #SPIExceptionHandler to install as the first code to deal with exceptions.
939 * Install a client-side handler for #SPIException instances, which can see and handle any
940 * exceptions before chaining them to the next exception handler in the stack.
944 * Returns %TRUE if the result succeeded, %FALSE if @hander could not be registered.
946 SPIBoolean SPI_exceptionHandlerPush (SPIExceptionHandler *handler)
948 if (!exception_handlers)
949 exception_handlers = g_queue_new ();
950 g_queue_push_head (exception_handlers, handler);
955 * SPI_exceptionHandlerPop:
957 * Remove/pop an #SPIExceptionHandler off the error handler stack and return the new handler.
961 * Returns the #SPIExceptionHandler which is now at the top of the error handler stack after the call.
963 SPIExceptionHandler* SPI_exceptionHandlerPop (void)
965 return (SPIExceptionHandler *) g_queue_pop_head (exception_handlers);
969 * SPIException_getSourceType:
970 * @err: the exception being queried
972 * Get the #SPIExceptionType of an exception which has been thrown.
976 * Returns: the #SPIExceptionType corresponding to exception @err.
978 SPIExceptionType SPIException_getSourceType (SPIException *err)
983 return SPI_EXCEPTION_SOURCE_UNSPECIFIED;
987 * SPIException_getExceptionCode:
988 * @err: the #SPIException being queried.
990 * Get the #SPIExceptionCode telling what type of exception condition has occurred.
994 * Returns: the #SPIExceptionCode corresponding to exception @err.
996 SPIExceptionCode SPIException_getExceptionCode (SPIException *err)
1002 * SPIAccessibleException_getSource:
1003 * @err: the #SPIException being queried.
1005 * Get the identity of the object which threw an exception.
1007 * @Since: AT-SPI 1.4
1009 * Returns: a pointer to the #Accessible object which threw the exception.
1011 Accessible* SPIAccessibleException_getSource (SPIException *err)
1013 if (err->type == SPI_EXCEPTION_SOURCE_ACCESSIBLE)
1014 cspi_object_ref (err->source);
1020 * SPIException_getDescription:
1021 * @err: the #SPIException being queried.
1023 * Get a text description of the exception that has been thrown.
1024 * Unfortunately these descriptions tend to be terse and limited in
1025 * the detail which they can provide.
1027 * Returns: a brief character string describing the exception.
1029 char* SPIException_getDescription (SPIException *err)
1031 /* TODO: friendlier error messages? */
1033 return err->error->message;
1038 get_path (Accessible *obj)
1040 if (APP_IS_REGISTRY (obj->app))
1042 return g_strdup_printf (SPI_DBUS_PATH_REGISTRY);
1044 return g_strdup_printf ("/org/a11y/atspi/accessible/%d", obj->v.id);
1048 cspi_dbus_call (Accessible *obj, const char *interface, const char *method, DBusError *error, const char *type, ...)
1051 char *path = get_path (obj);
1055 if (!error) error = &err;
1056 dbus_error_init (error);
1057 va_start (args, type);
1058 retval = dbind_method_call_reentrant_va (SPI_bus(), obj->app->bus_name, path, interface, method, error, type, args);
1061 if (dbus_error_is_set (error))
1063 if (!dbus_error_is_set (&exception))
1065 // TODO: Should we call cspi_exception_throw?
1066 dbus_move_error (error, &exception);
1068 else if (error == &err) dbus_error_free (error);
1074 cspi_dbus_get_property (Accessible *obj, const char *interface, const char *name, DBusError *error, const char *type, void *data)
1076 DBusMessage *message, *reply;
1077 char *path = get_path (obj);
1078 DBusMessageIter iter, iter_variant;
1080 dbus_bool_t retval = FALSE;
1082 message = dbus_message_new_method_call (obj->app->bus_name, path, "org.freedesktop.DBus.Properties", "Get");
1085 // TODO: throw exception
1088 dbus_message_append_args (message, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
1089 if (!error) error = &err;
1090 dbus_error_init (error);
1091 reply = dbus_connection_send_with_reply_and_block (SPI_bus(), message, 1000, error);
1092 dbus_message_unref (message);
1095 // TODO: throw exception
1098 dbus_message_iter_init (reply, &iter);
1099 dbus_message_iter_recurse (&iter, &iter_variant);
1100 if (dbus_message_iter_get_arg_type (&iter_variant) != type[0])
1102 g_warning ("cspi_dbus_get_property: Wrong type: expected %s, got %c\n", type, dbus_message_iter_get_arg_type (&iter_variant));
1105 dbus_message_iter_get_basic (&iter_variant, data);
1106 dbus_message_unref (reply);
1107 if (type[0] == 's') *(char **)data = g_strdup (*(char **)data);