* Copyright 2010, 2011 Novell, Inc.
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
*/
/*
#include "atspi-gmain.h"
#include <stdio.h>
#include <string.h>
+#include <ctype.h>
+
+/* This value is not fixed, could be changed. */
+#define HASH_TABLE_SIZE_MAX 3000
static void handle_get_items (DBusPendingCall *pending, void *user_data);
if (!bus)
atspi_init ();
if (!bus)
- g_error ("AT-SPI: Couldn't connect to accessibility bus. Is at-spi-bus-launcher running?");
+ {
+ g_warning ("AT-SPI: Couldn't connect to accessibility bus. Is at-spi-bus-launcher running?");
+ exit(0);
+ }
return bus;
}
static AtspiAccessible *desktop;
+static void cleanup_deferred_message (void);
+
static void
cleanup ()
{
GHashTable *refs;
- GList *l;
+ gint i;
refs = live_refs;
live_refs = NULL;
g_hash_table_destroy (refs);
}
- if (bus)
- {
- dbus_connection_close (bus);
- dbus_connection_unref (bus);
- bus = NULL;
- }
+ cleanup_deferred_message();
if (!desktop)
- return;
- for (l = desktop->children; l;)
+ goto end;
+
+ /* TODO: Do we need this code, or should we just dispose the desktop? */
+ for (i = desktop->children->len - 1; i >= 0; i--)
{
- GList *next = l->next;
- AtspiAccessible *child = l->data;
- g_object_run_dispose (G_OBJECT (child->parent.app));
+ AtspiAccessible *child = g_ptr_array_index (desktop->children, i);
+ if (child->parent.app)
+ g_object_run_dispose (G_OBJECT (child->parent.app));
g_object_run_dispose (G_OBJECT (child));
- l = next;
}
+
g_object_run_dispose (G_OBJECT (desktop->parent.app));
g_object_unref (desktop);
desktop = NULL;
+
+end:
+ if (bus)
+ {
+ dbus_connection_close (bus);
+ dbus_connection_unref (bus);
+ bus = NULL;
+ }
}
static gboolean atspi_inited = FALSE;
DBusMessage *message;
const char *address;
DBusPendingCall *new_pending;
+ dbus_bool_t result;
if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
{
dbus_connection_unref (app->bus);
}
app->bus = bus;
+ atspi_dbus_connection_setup_with_g_main(bus, g_main_context_default());
}
else
{
- g_warning ("Unable to open bus connection: %s", error.message);
+ if (!strcmp (error.name, DBUS_ERROR_FILE_NOT_FOUND))
+ g_warning ("AT-SPI: Unable to open bus connection: %s", error.message);
dbus_error_free (&error);
}
}
"/org/a11y/atspi/cache",
atspi_interface_cache, "GetItems");
- dbus_connection_send_with_reply (app->bus, message, &new_pending, 2000);
+ result = dbus_connection_send_with_reply (app->bus, message, &new_pending, 2000);
dbus_message_unref (message);
- if (!new_pending)
+ if (!result || !new_pending)
return;
dbus_pending_call_set_notify (new_pending, handle_get_items, app, NULL);
}
char *bus_name_dup;
DBusMessage *message;
DBusPendingCall *pending = NULL;
+ dbus_bool_t result;
if (!app_hash)
{
message = dbus_message_new_method_call (bus_name, atspi_path_root,
atspi_interface_application, "GetApplicationBusAddress");
- dbus_connection_send_with_reply (app->bus, message, &pending, 2000);
+ result = dbus_connection_send_with_reply (app->bus, message, &pending, 2000);
dbus_message_unref (message);
- if (!pending)
+ if (!result || !pending)
{
g_hash_table_remove (app_hash, bus_name_dup);
return NULL;
{
app->root = _atspi_accessible_new (app, atspi_path_root);
app->root->accessible_parent = atspi_get_desktop (0);
- app->root->accessible_parent->children = g_list_append (app->root->accessible_parent->children, g_object_ref (app->root));
+ g_ptr_array_add (app->root->accessible_parent->children, g_object_ref (app->root));
}
return g_object_ref (app->root);
}
a = _atspi_accessible_new (app, path);
if (!a)
return NULL;
+
+ if (g_hash_table_size (app->hash) > HASH_TABLE_SIZE_MAX)
+ {
+ g_warning ("Accessible hash table is bigger than MAX: %d\n", HASH_TABLE_SIZE_MAX);
+ g_hash_table_remove_all(app->hash);
+ }
+
g_hash_table_insert (app->hash, g_strdup (a->parent.path), g_object_ref (a));
return a;
}
return DBUS_HANDLER_RESULT_HANDLED;
}
+void
+remove_accessible_from_app_hash (const char *app_name, AtspiAccessible *a)
+{
+ AtspiApplication *app;
+
+ if (!a) return;
+
+ app = get_application (app_name);
+ if (!app) return;
+
+ if (!g_hash_table_lookup (app->hash, a->parent.path)) return;
+
+ g_hash_table_remove (app->hash, a->parent.path);
+}
+
static DBusHandlerResult
handle_name_owner_changed (DBusConnection *bus, DBusMessage *message, void *user_data)
{
AtspiAccessible *accessible;
const char *name, *description;
dbus_uint32_t role;
+ gboolean children_cached = FALSE;
+ dbus_int32_t count, index;
dbus_message_iter_recurse (iter, &iter_struct);
g_object_unref (accessible->accessible_parent);
accessible->accessible_parent = ref_accessible (app_name, path);
- /* Get children */
- while (accessible->children)
+ if (dbus_message_iter_get_arg_type (&iter_struct) == 'i')
{
- g_object_unref (accessible->children->data);
- accessible->children = g_list_remove (accessible->children, accessible->children->data);
+ /* Get index in parent */
+ dbus_message_iter_get_basic (&iter_struct, &index);
+ if (index >= 0 && accessible->accessible_parent)
+ {
+ if (index >= accessible->accessible_parent->children->len)
+ {
+ /* There is no room for this object */
+ g_ptr_array_set_size (accessible->accessible_parent->children, index + 1);
+ }
+ else
+ {
+ /* This place is already taken - let's free this place with dignity */
+ if (g_ptr_array_index (accessible->accessible_parent->children, index))
+ g_object_unref (g_ptr_array_index (accessible->accessible_parent->children, index));
+ }
+ g_ptr_array_index (accessible->accessible_parent->children, index) = g_object_ref (accessible);
+ }
+
+ /* get child count */
+ dbus_message_iter_next (&iter_struct);
+ dbus_message_iter_get_basic (&iter_struct, &count);
+ if (count >= 0)
+ {
+ g_ptr_array_set_size (accessible->children, count);
+ children_cached = TRUE;
+ }
}
- dbus_message_iter_recurse (&iter_struct, &iter_array);
- while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
+ else if (dbus_message_iter_get_arg_type (&iter_struct) == 'a')
{
- AtspiAccessible *child;
- get_reference_from_iter (&iter_array, &app_name, &path);
- child = ref_accessible (app_name, path);
- accessible->children = g_list_append (accessible->children, child);
+ /* It's the old API with a list of children */
+ /* TODO: Perhaps remove this code eventually */
+ dbus_message_iter_recurse (&iter_struct, &iter_array);
+ while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
+ {
+ AtspiAccessible *child;
+ get_reference_from_iter (&iter_array, &app_name, &path);
+ child = ref_accessible (app_name, path);
+ g_ptr_array_remove (accessible->children, child);
+ g_ptr_array_add (accessible->children, child);
+ }
+ children_cached = TRUE;
}
/* interfaces */
_atspi_accessible_add_cache (accessible, ATSPI_CACHE_NAME | ATSPI_CACHE_ROLE |
ATSPI_CACHE_PARENT | ATSPI_CACHE_DESCRIPTION);
if (!atspi_state_set_contains (accessible->states,
- ATSPI_STATE_MANAGES_DESCENDANTS))
+ ATSPI_STATE_MANAGES_DESCENDANTS) &&
+ children_cached)
_atspi_accessible_add_cache (accessible, ATSPI_CACHE_CHILDREN);
/* This is a bit of a hack since the cache holds a ref, so we don't need
{
const char *sender = dbus_message_get_sender (reply);
const char *error = NULL;
- dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &error,
- DBUS_TYPE_INVALID);
- g_warning ("AT-SPI: Error in GetItems, sender=%s, error=%s", sender, error);
+ const char *error_name = dbus_message_get_error_name (reply);
+ if (!strcmp (error_name, DBUS_ERROR_SERVICE_UNKNOWN)
+ || !strcmp (error_name, DBUS_ERROR_NO_REPLY))
+ {
+ }
+ else
+ {
+ dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &error,
+ DBUS_TYPE_INVALID);
+ g_warning ("AT-SPI: Error in GetItems, sender=%s, error=%s", sender, error);
+ }
dbus_message_unref (reply);
dbus_pending_call_unref (pending);
return;
get_reference_from_iter (&iter_array, &app_name, &path);
add_app_to_desktop (desktop, app_name);
}
- dbus_message_unref (reply);
/* Record the alternate name as an alias for org.a11y.atspi.Registry */
bus_name_dup = g_strdup (dbus_message_get_sender (reply));
if (bus_name_dup)
g_hash_table_insert (app_hash, bus_name_dup, app);
+ dbus_message_unref (reply);
+
return g_object_ref (desktop);
}
return ref_hyperlink (app_name, path);
}
-const char *cache_signal_type = "((so)(so)(so)a(so)assusau)";
+const char *cache_signal_type = "((so)(so)(so)iiassusau)";
+const char *old_cache_signal_type = "((so)(so)(so)a(so)assusau)";
static DBusHandlerResult
handle_add_accessible (DBusConnection *bus, DBusMessage *message, void *user_data)
{
DBusMessageIter iter;
+ const char *signature = dbus_message_get_signature (message);
- if (strcmp (dbus_message_get_signature (message), cache_signal_type) != 0)
+ if (strcmp (signature, cache_signal_type) != 0 &&
+ strcmp (signature, old_cache_signal_type) != 0)
{
- g_warning ("AT-SPI: AddAccessible with unknown signature %s\n",
- dbus_message_get_signature (message));
+ g_warning ("AT-SPI: AddAccessible with unknown signature %s\n", signature);
return DBUS_HANDLER_RESULT_HANDLED;
}
static GQueue *deferred_messages = NULL;
+static void
+destroy_deferred_message_item(gpointer ptr)
+{
+ /* TODO this is still memory leak on c->data */
+ BusDataClosure *c = ptr;
+ dbus_message_unref (c->message);
+ dbus_connection_unref (c->bus);
+ g_free (c);
+}
+
+static void
+cleanup_deferred_message(void)
+{
+ g_queue_free_full (deferred_messages, destroy_deferred_message_item);
+ deferred_messages = NULL;
+}
+
static gboolean
process_deferred_messages (void)
{
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
-/*
- * Returns a 'canonicalized' value for DISPLAY,
- * with the screen number stripped off if present.
- *
- * TODO: Avoid having duplicate functions for this here and in at-spi2-atk
- */
-static gchar *
-spi_display_name (void)
-{
- char *canonical_display_name = NULL;
- const gchar *display_env = g_getenv ("AT_SPI_DISPLAY");
-
- if (!display_env)
- {
- display_env = g_getenv ("DISPLAY");
- if (!display_env || !display_env[0])
- return NULL;
- else
- {
- gchar *display_p, *screen_p;
- canonical_display_name = g_strdup (display_env);
- display_p = g_utf8_strrchr (canonical_display_name, -1, ':');
- screen_p = g_utf8_strrchr (canonical_display_name, -1, '.');
- if (screen_p && display_p && (screen_p > display_p))
- {
- *screen_p = '\0';
- }
- }
- }
- else
- {
- canonical_display_name = g_strdup (display_env);
- }
-
- return canonical_display_name;
-}
-
/**
* atspi_init:
*
bus = atspi_get_a11y_bus ();
if (!bus)
return 2;
- dbus_bus_register (bus, NULL);
+ if (!dbus_bus_register (bus, NULL))
+ return 2;
atspi_dbus_connection_setup_with_g_main(bus, g_main_context_default());
dbus_connection_add_filter (bus, atspi_dbus_filter, NULL, NULL);
match = g_strdup_printf ("type='signal',interface='%s',member='AddAccessible'", atspi_interface_cache);
{
atspi_main_loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (atspi_main_loop);
+ g_main_loop_unref(atspi_main_loop);
atspi_main_loop = NULL;
}
static void
remove_hung_process (DBusPendingCall *pending, void *data)
{
-
hung_processes = g_slist_remove (hung_processes, data);
g_free (data);
dbus_pending_call_unref (pending);
process_deferred_messages ();
if (!reply)
{
- // TODO: throw exception
+ /* TODO: throw exception */
goto done;
}
dbus_message_iter_init (reply, &iter);
if (dbus_message_iter_get_arg_type (&iter) != 'v')
{
- g_warning ("AT-SPI: expected a variant when fetching %s from interface %s; got %s\n", name, interface, dbus_message_get_signature (reply));
+ g_warning ("atspi_dbus_get_property: expected a variant when fetching %s from interface %s; got %s\n", name, interface, dbus_message_get_signature (reply));
goto done;
}
dbus_message_iter_recurse (&iter, &iter_variant);
}
else
{
+ if (type [0] == 's')
+ {
+ *(char**) data = NULL;
+ }
+
dbus_message_iter_get_basic (&iter_variant, data);
+
if (type [0] == 's')
*(char **)data = g_strdup (*(char **)data);
}
accessible->interfaces = 0;
if (strcmp (iter_sig, "as") != 0)
{
- g_warning ("_atspi_dbus_set_interfaces: Passed iterator with invalid signature %s", dbus_message_iter_get_signature (iter));
+ g_warning ("_atspi_dbus_set_interfaces: Passed iterator with invalid signature %s", iter_sig);
dbus_free (iter_sig);
return;
}
* Gets the IOR from the XDisplay.
*/
#ifdef HAVE_X11
+/*
+ * Returns a 'canonicalized' value for DISPLAY,
+ * with the screen number stripped off if present.
+ *
+ * TODO: Avoid having duplicate functions for this here and in at-spi2-atk
+ */
+static gchar *
+spi_display_name (void)
+{
+ char *canonical_display_name = NULL;
+ const gchar *display_env = g_getenv ("AT_SPI_DISPLAY");
+
+ if (!display_env)
+ {
+ display_env = g_getenv ("DISPLAY");
+ if (!display_env || !display_env[0])
+ return NULL;
+ else
+ {
+ gchar *display_p, *screen_p;
+ canonical_display_name = g_strdup (display_env);
+ display_p = g_utf8_strrchr (canonical_display_name, -1, ':');
+ screen_p = g_utf8_strrchr (canonical_display_name, -1, '.');
+ if (screen_p && display_p && (screen_p > display_p))
+ {
+ *screen_p = '\0';
+ }
+ }
+ }
+ else
+ {
+ canonical_display_name = g_strdup (display_env);
+ }
+
+ return canonical_display_name;
+}
+
static char *
get_accessibility_bus_address_x11 (void)
{
dbus_error_init (&error);
reply = dbus_connection_send_with_reply_and_block (session_bus,
message,
- -1,
+ 15000,
&error);
dbus_message_unref (message);
if (!reply)
{
- g_warning ("Error retrieving accessibility bus address: %s: %s",
+ g_warning ("AT-SPI: Error retrieving accessibility bus address: %s: %s",
error.name, error.message);
dbus_error_free (&error);
goto out;
{
DBusError error;
char *address = NULL;
+ const char *address_env = NULL;
if (a11y_bus && dbus_connection_get_is_connected (a11y_bus))
return a11y_bus;
if (a11y_dbus_slot == -1)
if (!dbus_connection_allocate_data_slot (&a11y_dbus_slot))
- g_warning ("at-spi: Unable to allocate D-Bus slot");
+ g_warning ("AT-SPI: Unable to allocate D-Bus slot");
+ address_env = g_getenv ("AT_SPI_BUS_ADDRESS");
+ if (address_env != NULL && *address_env != 0)
+ address = g_strdup (address_env);
#ifdef HAVE_X11
- address = get_accessibility_bus_address_x11 ();
+ if (!address && g_getenv ("DISPLAY") != NULL &&
+ g_getenv ("WAYLAND_DISPLAY") == NULL)
+ address = get_accessibility_bus_address_x11 ();
#endif
if (!address)
address = get_accessibility_bus_address_dbus ();
if (!a11y_bus)
{
- g_warning ("Couldn't connect to accessibility bus: %s", error.message);
+ if (!g_getenv("SSH_CONNECTION"))
+ g_warning ("Couldn't connect to accessibility bus: %s", error.message);
dbus_error_free (&error);
return NULL;
}
}
atspi_main_context = cnx;
atspi_dbus_connection_setup_with_g_main (atspi_get_a11y_bus (), cnx);
+
+ if (desktop)
+ {
+ gint i;
+ for (i = desktop->children->len - 1; i >= 0; i--)
+ {
+ AtspiAccessible *child = g_ptr_array_index (desktop->children, i);
+ if (child->parent.app && child->parent.app->bus)
+ atspi_dbus_connection_setup_with_g_main (child->parent.app->bus, cnx);
+ }
+ }
}
#ifdef DEBUG_REF_COUNTS
g_set_error_literal (error, ATSPI_ERROR, ATSPI_ERROR_SYNC_NOT_ALLOWED,
_("Attempted synchronous call where prohibited"));
}
+
+static const char *sr_introspection = "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
+"\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
+"<node name=\"/org/a11y/atspi/screenreader\">\n"
+" <interface name=\"org.a11y.Atspi.ScreenReader\">\n"
+" <signal name=\"ReadingPosition\">\n"
+" <arg type=\"i\"/>\n"
+" <arg type=\"i\"/>\n"
+" </signal>\n"
+" </interface>\n"
+"</node>";
+
+static DBusHandlerResult
+screen_reader_filter (DBusConnection *bus, DBusMessage *message, void *user_data)
+{
+ if (dbus_message_is_method_call (message, DBUS_INTERFACE_INTROSPECTABLE,
+ "Introspect"))
+ {
+ DBusMessage *reply = dbus_message_new_method_return (message);
+ dbus_message_append_args (reply, DBUS_TYPE_STRING, &sr_introspection,
+ DBUS_TYPE_INVALID);
+ dbus_connection_send (bus, reply, NULL);
+ dbus_message_unref (reply);
+ return DBUS_HANDLER_RESULT_HANDLED;
+ }
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+gboolean
+_atspi_prepare_screen_reader_interface ()
+{
+ static gint initialized = 0;
+ DBusConnection *a11y_bus = _atspi_bus ();
+
+ if (initialized)
+ return (initialized > 0);
+
+ if (dbus_bus_request_name (a11y_bus, "org.a11y.Atspi.ScreenReader", 0, NULL) < 0)
+ {
+ initialized = -1;
+ return FALSE;
+ }
+
+ initialized = 1;
+ dbus_connection_add_filter (a11y_bus, screen_reader_filter, NULL, NULL);
+ return TRUE;
+}
+
+gchar *
+_atspi_strdup_and_adjust_for_dbus (const char *s)
+{
+ gchar *d = g_strdup (s);
+ gchar *p;
+ int parts = 0;
+
+ if (!d)
+ return NULL;
+
+ for (p = d; *p; p++)
+ {
+ if (*p == '-')
+ {
+ memmove (p, p + 1, g_utf8_strlen (p, -1));
+ *p = toupper (*p);
+ }
+ else if (*p == ':')
+ {
+ parts++;
+ if (parts == 2)
+ break;
+ p [1] = toupper (p [1]);
+ }
+ }
+
+ d [0] = toupper (d [0]);
+ return d;
+}
projects / platform / upstream / at-spi2-core.git / blobdiff