All files in atk-adaptor now use gnu style indentation.
'indent --no-tabs'
#include "accessible-register.h"
static dbus_bool_t
-impl_get_Name (DBusMessageIter *iter, void *user_data)
+impl_get_Name (DBusMessageIter * iter, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
}
static dbus_bool_t
-impl_set_Name (DBusMessageIter *iter, void *user_data)
+impl_set_Name (DBusMessageIter * iter, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
const char *name = droute_get_v_string (iter);
}
static dbus_bool_t
-impl_get_Description (DBusMessageIter *iter, void *user_data)
+impl_get_Description (DBusMessageIter * iter, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
}
static dbus_bool_t
-impl_set_Description (DBusMessageIter *iter, void *user_data)
+impl_set_Description (DBusMessageIter * iter, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
const char *description = droute_get_v_string (iter);
}
static dbus_bool_t
-impl_get_Parent (DBusMessageIter *iter, void *user_data)
+impl_get_Parent (DBusMessageIter * iter, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
g_return_val_if_fail (ATK_IS_OBJECT (user_data), FALSE);
return spi_dbus_return_v_object (iter,
- atk_object_get_parent (object),
- FALSE);
+ atk_object_get_parent (object), FALSE);
}
static dbus_bool_t
-impl_get_ChildCount (DBusMessageIter *iter, void *user_data)
+impl_get_ChildCount (DBusMessageIter * iter, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
}
static DBusMessage *
-impl_GetChildAtIndex (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetChildAtIndex (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
DBusError error;
dbus_error_init (&error);
g_return_val_if_fail (ATK_IS_OBJECT (user_data),
droute_not_yet_handled_error (message));
- if (!dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID))
+ if (!dbus_message_get_args
+ (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID))
{
return droute_invalid_arguments_error (message);
}
}
static DBusMessage *
-impl_GetChildren (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetChildren (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
gint i;
droute_not_yet_handled_error (message));
count = atk_object_get_n_accessible_children (object);
reply = dbus_message_new_method_return (message);
- if (!reply) goto oom;
+ if (!reply)
+ goto oom;
dbus_message_iter_init_append (reply, &iter);
if (!dbus_message_iter_open_container
(&iter, DBUS_TYPE_ARRAY, "o", &iter_array))
AtkObject *child = atk_object_ref_accessible_child (object, i);
char *path = atk_dbus_object_to_path (child, FALSE);
if (path)
- {
- dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_OBJECT_PATH,
- &path);
- g_free (path);
- }
+ {
+ dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_OBJECT_PATH,
+ &path);
+ g_free (path);
+ }
if (child)
- g_object_unref (child);
+ g_object_unref (child);
}
if (!dbus_message_iter_close_container (&iter, &iter_array))
goto oom;
}
static DBusMessage *
-impl_GetIndexInParent (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetIndexInParent (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
dbus_uint32_t rv;
if (reply)
{
dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INVALID);
}
return reply;
}
static gboolean
-spi_init_relation_type_table (Accessibility_RelationType *types)
+spi_init_relation_type_table (Accessibility_RelationType * types)
{
gint i;
types[ATK_RELATION_EMBEDS] = Accessibility_RELATION_EMBEDS;
types[ATK_RELATION_EMBEDDED_BY] = Accessibility_RELATION_EMBEDDED_BY;
types[ATK_RELATION_POPUP_FOR] = Accessibility_RELATION_POPUP_FOR;
- types[ATK_RELATION_PARENT_WINDOW_OF] = Accessibility_RELATION_PARENT_WINDOW_OF;
- types[ATK_RELATION_DESCRIPTION_FOR] = Accessibility_RELATION_DESCRIPTION_FOR;
+ types[ATK_RELATION_PARENT_WINDOW_OF] =
+ Accessibility_RELATION_PARENT_WINDOW_OF;
+ types[ATK_RELATION_DESCRIPTION_FOR] =
+ Accessibility_RELATION_DESCRIPTION_FOR;
types[ATK_RELATION_DESCRIBED_BY] = Accessibility_RELATION_DESCRIBED_BY;
return TRUE;
spi_relation_type_from_atk_relation_type (AtkRelationType type)
{
static gboolean is_initialized = FALSE;
- static Accessibility_RelationType spi_relation_type_table [ATK_RELATION_LAST_DEFINED];
+ static Accessibility_RelationType
+ spi_relation_type_table[ATK_RELATION_LAST_DEFINED];
Accessibility_RelationType spi_type;
if (!is_initialized)
- is_initialized = spi_init_relation_type_table (spi_relation_type_table);
+ is_initialized = spi_init_relation_type_table (spi_relation_type_table);
if (type > ATK_RELATION_NULL && type < ATK_RELATION_LAST_DEFINED)
spi_type = spi_relation_type_table[type];
}
static DBusMessage *
-impl_GetRelationSet (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetRelationSet (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
DBusMessage *reply;
g_return_val_if_fail (ATK_IS_OBJECT (user_data),
droute_not_yet_handled_error (message));
reply = dbus_message_new_method_return (message);
- if (!reply) return NULL;
+ if (!reply)
+ return NULL;
set = atk_object_ref_relation_set (object);
dbus_message_iter_init_append (reply, &iter);
- if (!dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(ua(so))", &iter_array))
- {
- goto oom;
- }
- count = atk_relation_set_get_n_relations (set);
- for (i = 0; i < count; i++)
- {
- AtkRelation *r = atk_relation_set_get_relation (set, i);
- AtkRelationType rt;
- GPtrArray *target;
- dbus_uint32_t type;
- if (!r) continue;
- rt= atk_relation_get_relation_type (r);
- type = spi_relation_type_from_atk_relation_type (rt);
- target = atk_relation_get_target (r);
- if (!dbus_message_iter_open_container (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct))
- {
- goto oom;
- }
- dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &type);
- if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "(so)", &iter_targets))
+ if (!dbus_message_iter_open_container
+ (&iter, DBUS_TYPE_ARRAY, "(ua(so))", &iter_array))
{
goto oom;
}
- for (j = 0; j < target->len; j++)
+ count = atk_relation_set_get_n_relations (set);
+ for (i = 0; i < count; i++)
{
- AtkObject *obj = target->pdata[j];
- char *path;
- if (!obj) continue;
- path = atk_dbus_object_to_path (obj, FALSE);
- if (!path)
- {
- g_warning ("Unknown object in relation type %d\n", type);
- continue;
- }
- spi_dbus_append_name_and_path_inner (&iter_targets, NULL, path);
+ AtkRelation *r = atk_relation_set_get_relation (set, i);
+ AtkRelationType rt;
+ GPtrArray *target;
+ dbus_uint32_t type;
+ if (!r)
+ continue;
+ rt = atk_relation_get_relation_type (r);
+ type = spi_relation_type_from_atk_relation_type (rt);
+ target = atk_relation_get_target (r);
+ if (!dbus_message_iter_open_container
+ (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct))
+ {
+ goto oom;
+ }
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &type);
+ if (!dbus_message_iter_open_container
+ (&iter_struct, DBUS_TYPE_ARRAY, "(so)", &iter_targets))
+ {
+ goto oom;
+ }
+ for (j = 0; j < target->len; j++)
+ {
+ AtkObject *obj = target->pdata[j];
+ char *path;
+ if (!obj)
+ continue;
+ path = atk_dbus_object_to_path (obj, FALSE);
+ if (!path)
+ {
+ g_warning ("Unknown object in relation type %d\n", type);
+ continue;
+ }
+ spi_dbus_append_name_and_path_inner (&iter_targets, NULL, path);
+ }
+ dbus_message_iter_close_container (&iter_struct, &iter_targets);
+ dbus_message_iter_close_container (&iter_array, &iter_struct);
}
- dbus_message_iter_close_container (&iter_struct, &iter_targets);
- dbus_message_iter_close_container (&iter_array, &iter_struct);
- }
dbus_message_iter_close_container (&iter, &iter_array);
oom:
// TODO: handle out of memory */
}
static DBusMessage *
-impl_GetRole (DBusConnection *bus, DBusMessage *message, void *user_data)
+impl_GetRole (DBusConnection * bus, DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
gint role;
if (reply)
{
dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INVALID);
}
return reply;
}
{
g_return_val_if_fail (ATK_IS_OBJECT (datum), g_strdup (""));
return g_strdup_printf ("%d",
- spi_accessible_role_from_atk_role
- (atk_object_get_role ((AtkObject *) datum)));
+ spi_accessible_role_from_atk_role
+ (atk_object_get_role ((AtkObject *) datum)));
}
static DBusMessage *
-impl_GetRoleName (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetRoleName (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
gint role;
if (reply)
{
dbus_message_append_args (reply, DBUS_TYPE_STRING, &role_name,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INVALID);
}
return reply;
}
static DBusMessage *
-impl_GetLocalizedRoleName (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetLocalizedRoleName (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
gint role;
if (reply)
{
dbus_message_append_args (reply, DBUS_TYPE_STRING, &role_name,
- DBUS_TYPE_INVALID);
+ DBUS_TYPE_INVALID);
}
return reply;
}
static DBusMessage *
-impl_GetState (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetState (DBusConnection * bus, DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
- DBusMessage *reply = NULL;
+ DBusMessage *reply = NULL;
DBusMessageIter iter, iter_array;
- dbus_uint32_t states [2];
+ dbus_uint32_t states[2];
guint count;
dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "u", &iter_array);
for (count = 0; count < 2; count++)
{
- dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_UINT32, &states[count]);
+ dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_UINT32,
+ &states[count]);
}
dbus_message_iter_close_container (&iter, &iter_array);
return reply;
}
static DBusMessage *
-impl_GetAttributes (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetAttributes (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
DBusMessage *reply = NULL;
}
static DBusMessage *
-impl_GetApplication (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetApplication (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *root = atk_get_root ();
return spi_dbus_return_object (message, root, FALSE, FALSE);
}
static DBusMessage *
-impl_GetInterfaces (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetInterfaces (DBusConnection * bus,
+ DBusMessage * message, void *user_data)
{
AtkObject *object = (AtkObject *) user_data;
gint role;
if (reply)
{
dbus_message_iter_init_append (reply, &iter);
- dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &iter_array);
+ dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s",
+ &iter_array);
append_atk_object_interfaces (object, &iter_array);
dbus_message_iter_close_container (&iter, &iter_array);
}
};
void
-spi_initialize_accessible (DRoutePath *path)
+spi_initialize_accessible (DRoutePath * path)
{
droute_path_add_interface (path,
SPI_DBUS_INTERFACE_ACCESSIBLE,
- methods,
- properties);
+ methods, properties);
};
/*---------------------------------------------------------------------------*/
void
-spi_dbus_append_name_and_path_inner (DBusMessageIter *iter, const char *bus_name, const char *path)
+spi_dbus_append_name_and_path_inner (DBusMessageIter * iter,
+ const char *bus_name, const char *path)
{
DBusMessageIter iter_struct;
if (!path)
path = SPI_DBUS_PATH_NULL;
- dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL, &iter_struct);
+ dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL,
+ &iter_struct);
dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &bus_name);
dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH, &path);
dbus_message_iter_close_container (iter, &iter_struct);
extern gchar *atspi_dbus_name;
void
-spi_dbus_append_name_and_path (DBusMessage *message, DBusMessageIter *iter, AtkObject *obj, gboolean do_register, gboolean unref)
+spi_dbus_append_name_and_path (DBusMessage * message, DBusMessageIter * iter,
+ AtkObject * obj, gboolean do_register,
+ gboolean unref)
{
gchar *path;
DBusMessageIter iter_struct;
* Unrefs the AtkObject if unref is true.
*/
DBusMessage *
-spi_dbus_return_object (DBusMessage *message, AtkObject *obj, gboolean do_register, gboolean unref)
+spi_dbus_return_object (DBusMessage * message, AtkObject * obj,
+ gboolean do_register, gboolean unref)
{
DBusMessage *reply;
reply = dbus_message_new_method_return (message);
}
DBusMessage *
-spi_dbus_return_hyperlink (DBusMessage *message, AtkHyperlink *link, AtkObject *container, gboolean unref)
+spi_dbus_return_hyperlink (DBusMessage * message, AtkHyperlink * link,
+ AtkObject * container, gboolean unref)
{
- return spi_dbus_return_sub_object (message, G_OBJECT (link), G_OBJECT (container), unref);
+ return spi_dbus_return_sub_object (message, G_OBJECT (link),
+ G_OBJECT (container), unref);
}
DBusMessage *
-spi_dbus_return_sub_object (DBusMessage *message, GObject *sub, GObject *container, gboolean unref)
+spi_dbus_return_sub_object (DBusMessage * message, GObject * sub,
+ GObject * container, gboolean unref)
{
DBusMessage *reply;
gchar *path;
* Unrefs the object if unref is true.
*/
dbus_bool_t
-spi_dbus_return_v_object (DBusMessageIter *iter, AtkObject *obj, int unref)
+spi_dbus_return_v_object (DBusMessageIter * iter, AtkObject * obj, int unref)
{
DBusMessageIter iter_variant;
char *path;
if (unref)
g_object_unref (obj);
- dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "(so)", &iter_variant);
+ dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "(so)",
+ &iter_variant);
spi_dbus_append_name_and_path_inner (&iter_variant, NULL, path);
dbus_message_iter_close_container (iter, &iter_variant);
return TRUE;
/*---------------------------------------------------------------------------*/
void
-append_atk_object_interfaces (AtkObject *object, DBusMessageIter *iter)
+append_atk_object_interfaces (AtkObject * object, DBusMessageIter * iter)
{
const gchar *itf;
* be registered with D-Bus and have been given a D-Bus object path.
*/
void
-spi_atk_append_accessible(AtkObject *obj, gpointer data)
+spi_atk_append_accessible (AtkObject * obj, gpointer data)
{
DBusMessageIter iter_struct, iter_sub_array;
- dbus_uint32_t states [2];
+ dbus_uint32_t states[2];
int count;
AtkStateSet *set;
- DBusMessageIter *iter_array = (DBusMessageIter *)data;
+ DBusMessageIter *iter_array = (DBusMessageIter *) data;
const char *name, *desc;
dbus_uint32_t role;
set = atk_object_ref_state_set (obj);
- {
- AtkObject *parent;
- gchar *path;
- gchar *bus_parent = NULL, *path_parent = NULL;
+ {
+ AtkObject *parent;
+ gchar *path;
+ gchar *bus_parent = NULL, *path_parent;
- /* Marshall object path */
- path = atk_dbus_object_to_path (obj, FALSE);
+ /* Marshall object path */
+ path = atk_dbus_object_to_path (obj, FALSE);
- role = spi_accessible_role_from_atk_role (atk_object_get_role (obj));
+ role = spi_accessible_role_from_atk_role (atk_object_get_role (obj));
- /* Marshall parent */
- parent = atk_object_get_parent(obj);
- if (parent == NULL)
- {
- /* TODO: Support getting parent of an AtkPlug */
+ /* Marshall parent */
+ parent = atk_object_get_parent (obj);
+ if (parent == NULL)
+ {
+ /* TODO: Support getting parent of an AtkPlug */
#ifdef __ATK_PLUG_H__
if (ATK_IS_PLUG (obj))
{
}
else if (role != Accessibility_ROLE_APPLICATION)
#else
- if (role != Accessibility_ROLE_APPLICATION)
+ if (role != Accessibility_ROLE_APPLICATION)
#endif
- path_parent = g_strdup (SPI_DBUS_PATH_NULL);
- else
- path_parent = atk_dbus_desktop_object_path ();
- }
- else
- {
- path_parent = atk_dbus_object_to_path (parent, FALSE);
- if (!path_parent)
- {
- /* This should only happen if a widget is re-parented to
- * an AtkObject that has not been registered and is then
- * updated. Ideally objects would be de-registered when
- * they are removed from a registered tree object, but
- * this would invalidate a huge amount of cache when
- * re-parenting.
- */
+ path_parent = g_strdup (SPI_DBUS_PATH_NULL);
+ else
+ path_parent = atk_dbus_desktop_object_path ();
+ }
+ else
+ {
+ path_parent = atk_dbus_object_to_path (parent, FALSE);
+ if (!path_parent)
+ {
+ /* This should only happen if a widget is re-parented to
+ * an AtkObject that has not been registered and is then
+ * updated. Ideally objects would be de-registered when
+ * they are removed from a registered tree object, but
+ * this would invalidate a huge amount of cache when
+ * re-parenting.
+ */
#if SPI_ATK_DEBUG
- g_warning ("AT-SPI: Registered accessible marshalled when parent not registered");
+ g_warning
+ ("AT-SPI: Registered accessible marshalled when parent not registered");
#endif
- path_parent = atk_dbus_desktop_object_path ();
- }
- }
-
- dbus_message_iter_open_container (iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct);
- dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH, &path);
- spi_dbus_append_name_and_path_inner (&iter_struct, bus_parent, path_parent);
- g_free(path_parent);
- g_free (bus_parent);
-
- /* Marshall children */
- dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "(so)", &iter_sub_array);
- if (!atk_state_set_contains_state (set, ATK_STATE_MANAGES_DESCENDANTS))
- {
- gint childcount, i;
-
- childcount = atk_object_get_n_accessible_children (obj);
- for (i = 0; i < childcount; i++)
- {
- AtkObject *child;
- gchar *child_path;
-
- child = atk_object_ref_accessible_child (obj, i);
- child_path = atk_dbus_object_to_path (child, FALSE);
- if (child_path)
- {
- spi_dbus_append_name_and_path_inner (&iter_sub_array, NULL, child_path);
- g_free (child_path);
- }
- g_object_unref(G_OBJECT(child));
- }
- }
+ path_parent = atk_dbus_desktop_object_path ();
+ }
+ }
+
+ dbus_message_iter_open_container (iter_array, DBUS_TYPE_STRUCT, NULL,
+ &iter_struct);
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH,
+ &path);
+ spi_dbus_append_name_and_path_inner (&iter_struct, bus_parent,
+ path_parent);
+ g_free (path_parent);
+ g_free (bus_parent);
+
+ /* Marshall children */
+ dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "(so)",
+ &iter_sub_array);
+ if (!atk_state_set_contains_state (set, ATK_STATE_MANAGES_DESCENDANTS))
+ {
+ gint childcount, i;
+
+ childcount = atk_object_get_n_accessible_children (obj);
+ for (i = 0; i < childcount; i++)
+ {
+ AtkObject *child;
+ gchar *child_path;
+
+ child = atk_object_ref_accessible_child (obj, i);
+ child_path = atk_dbus_object_to_path (child, FALSE);
+ if (child_path)
+ {
+ spi_dbus_append_name_and_path_inner (&iter_sub_array, NULL,
+ child_path);
+ g_free (child_path);
+ }
+ g_object_unref (G_OBJECT (child));
+ }
+ }
#ifdef __ATK_PLUG_H__
- if (ATK_IS_SOCKET (obj) && atk_socket_is_occupied (ATK_SOCKET(obj)))
- {
- AtkSocket *socket = ATK_SOCKET(obj);
- gchar *child_name, *child_path;
- child_name = g_strdup (socket->embedded_plug_id);
- child_path = g_utf8_strchr (child_name + 1, -1, ':');
- if (child_path)
- {
- *(child_path++) = '\0';
- spi_dbus_append_name_and_path_inner (&iter_sub_array, child_name, child_path);
- }
- g_free (child_name);
- }
+ if (ATK_IS_SOCKET (obj) && atk_socket_is_occupied (ATK_SOCKET (obj)))
+ {
+ AtkSocket *socket = ATK_SOCKET (obj);
+ gchar *child_name, *child_path;
+ child_name = g_strdup (socket->embedded_plug_id);
+ child_path = g_utf8_strchr (child_name + 1, -1, ':');
+ if (child_path)
+ {
+ *(child_path++) = '\0';
+ spi_dbus_append_name_and_path_inner (&iter_sub_array, child_name,
+ child_path);
+ }
+ g_free (child_name);
+ }
#endif
- dbus_message_iter_close_container (&iter_struct, &iter_sub_array);
-
- /* Marshall interfaces */
- dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "s", &iter_sub_array);
- append_atk_object_interfaces (obj, &iter_sub_array);
- dbus_message_iter_close_container (&iter_struct, &iter_sub_array);
-
- /* Marshall name */
- name = atk_object_get_name (obj);
- if (!name)
- name = "";
- dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &name);
-
- /* Marshall role */
- dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &role);
-
- /* Marshall description */
- desc = atk_object_get_description (obj);
- if (!desc)
- desc = "";
- dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &desc);
-
- g_free(path);
-
- /* Marshall state set */
- spi_atk_state_set_to_dbus_array (set, states);
- dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "u", &iter_sub_array);
- for (count = 0; count < 2; count++)
- {
- dbus_message_iter_append_basic (&iter_sub_array, DBUS_TYPE_UINT32, &states[count]);
- }
- dbus_message_iter_close_container (&iter_struct, &iter_sub_array);
- }
+ dbus_message_iter_close_container (&iter_struct, &iter_sub_array);
+
+ /* Marshall interfaces */
+ dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "s",
+ &iter_sub_array);
+ append_atk_object_interfaces (obj, &iter_sub_array);
+ dbus_message_iter_close_container (&iter_struct, &iter_sub_array);
+
+ /* Marshall name */
+ name = atk_object_get_name (obj);
+ if (!name)
+ name = "";
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &name);
+
+ /* Marshall role */
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &role);
+
+ /* Marshall description */
+ desc = atk_object_get_description (obj);
+ if (!desc)
+ desc = "";
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &desc);
+
+ g_free (path);
+
+ /* Marshall state set */
+ spi_atk_state_set_to_dbus_array (set, states);
+ dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "u",
+ &iter_sub_array);
+ for (count = 0; count < 2; count++)
+ {
+ dbus_message_iter_append_basic (&iter_sub_array, DBUS_TYPE_UINT32,
+ &states[count]);
+ }
+ dbus_message_iter_close_container (&iter_struct, &iter_sub_array);
+ }
dbus_message_iter_close_container (iter_array, &iter_struct);
g_object_unref (set);
}
void
-spi_atk_append_attribute_set (DBusMessageIter *iter, AtkAttributeSet *attr)
+spi_atk_append_attribute_set (DBusMessageIter * iter, AtkAttributeSet * attr)
{
DBusMessageIter dictIter;
}
void
-spi_atk_append_attribute_set_inner (DBusMessageIter *iter, AtkAttributeSet *attr)
+spi_atk_append_attribute_set_inner (DBusMessageIter * iter,
+ AtkAttributeSet * attr)
{
DBusMessageIter dictEntryIter;
while (attr)
{
AtkAttribute *attribute = (AtkAttribute *) attr->data;
- dbus_message_iter_open_container (iter, DBUS_TYPE_DICT_ENTRY, NULL, &dictEntryIter);
- dbus_message_iter_append_basic (&dictEntryIter, DBUS_TYPE_STRING, &attribute->name);
- dbus_message_iter_append_basic (&dictEntryIter, DBUS_TYPE_STRING, &attribute->value);
+ dbus_message_iter_open_container (iter, DBUS_TYPE_DICT_ENTRY, NULL,
+ &dictEntryIter);
+ dbus_message_iter_append_basic (&dictEntryIter, DBUS_TYPE_STRING,
+ &attribute->name);
+ dbus_message_iter_append_basic (&dictEntryIter, DBUS_TYPE_STRING,
+ &attribute->value);
dbus_message_iter_close_container (iter, &dictEntryIter);
attr = g_slist_next (attr);
}
}
/*END------------------------------------------------------------------------*/
-
#include <atk/atk.h>
void
-spi_dbus_append_name_and_path_inner (DBusMessageIter *iter, const char *bus_name, const char *path);
+spi_dbus_append_name_and_path_inner (DBusMessageIter * iter,
+ const char *bus_name, const char *path);
void
-spi_dbus_append_name_and_path (DBusMessage *message, DBusMessageIter *iter, AtkObject *obj, gboolean do_register, gboolean unref);
+spi_dbus_append_name_and_path (DBusMessage * message, DBusMessageIter * iter,
+ AtkObject * obj, gboolean do_register,
+ gboolean unref);
-DBusMessage *
-spi_dbus_return_object (DBusMessage *message, AtkObject *obj, gboolean do_register, gboolean unref);
+DBusMessage *spi_dbus_return_object (DBusMessage * message, AtkObject * obj,
+ gboolean do_register, gboolean unref);
-DBusMessage *
-spi_dbus_return_hyperlink (DBusMessage *message, AtkHyperlink *link, AtkObject *container, gboolean unref);
+DBusMessage *spi_dbus_return_hyperlink (DBusMessage * message,
+ AtkHyperlink * link,
+ AtkObject * container,
+ gboolean unref);
-DBusMessage *
-spi_dbus_return_sub_object (DBusMessage *message, GObject *sub, GObject *container, gboolean unref);
+DBusMessage *spi_dbus_return_sub_object (DBusMessage * message, GObject * sub,
+ GObject * container, gboolean unref);
dbus_bool_t
-spi_dbus_return_v_object (DBusMessageIter *iter, AtkObject *obj, int unref);
+spi_dbus_return_v_object (DBusMessageIter * iter, AtkObject * obj, int unref);
-void
-spi_atk_append_accessible(AtkObject *obj, gpointer iter);
+void spi_atk_append_accessible (AtkObject * obj, gpointer iter);
void
-spi_atk_append_attribute_set (DBusMessageIter *iter, AtkAttributeSet *attr);
+spi_atk_append_attribute_set (DBusMessageIter * iter, AtkAttributeSet * attr);
void
-spi_atk_append_attribute_set_inner (DBusMessageIter *iter, AtkAttributeSet *attr);
+spi_atk_append_attribute_set_inner (DBusMessageIter * iter,
+ AtkAttributeSet * attr);
void
-append_atk_object_interfaces (AtkObject *object, DBusMessageIter *iter);
+append_atk_object_interfaces (AtkObject * object, DBusMessageIter * iter);
#endif /* ACCESSIBLE_MARSHALLER */
#define SPI_ATK_OBJECT_REFERENCE_TEMPLATE SPI_ATK_OBJECT_PATH_PREFIX "/%d"
-static GHashTable *ref2ptr = NULL; /* Used for converting a D-Bus path (Reference) to the object pointer */
+static GHashTable *ref2ptr = NULL; /* Used for converting a D-Bus path (Reference) to the object pointer */
static GHashTable *objects_with_subrefs = NULL;
static GHashTable *leased_refs = NULL;
static int leased_refs_count;
/*---------------------------------------------------------------------------*/
-static GStaticMutex recursion_check_guard = G_STATIC_MUTEX_INIT;
-static gboolean recursion_check = FALSE;
+static GStaticMutex recursion_check_guard = G_STATIC_MUTEX_INIT;
+static gboolean recursion_check = FALSE;
static int last_gc_time;
-static void deregister_sub_accessible (gpointer key, gpointer obj_data, gpointer iter);
+static void deregister_sub_accessible (gpointer key, gpointer obj_data,
+ gpointer iter);
-static void deregister_sub_hyperlink (gpointer key, gpointer obj_data, gpointer iter);
+static void deregister_sub_hyperlink (gpointer key, gpointer obj_data,
+ gpointer iter);
static gboolean
recursion_check_and_set ()
{
gboolean ret;
- g_static_mutex_lock (&recursion_check_guard);
+ g_static_mutex_lock (&recursion_check_guard);
ret = recursion_check;
recursion_check = TRUE;
g_static_mutex_unlock (&recursion_check_guard);
static void
recursion_check_unset ()
{
- g_static_mutex_lock (&recursion_check_guard);
+ g_static_mutex_lock (&recursion_check_guard);
recursion_check = FALSE;
g_static_mutex_unlock (&recursion_check_guard);
}
* AtkObject.
*/
static guint
-assign_reference(void)
+assign_reference (void)
{
reference_counter++;
/* Reference of 0 not allowed as used as direct key in hash table */
* Returns the reference of the object, or 0 if it is not registered.
*/
static guint
-gobject_to_ref (GObject *gobj)
+gobject_to_ref (GObject * gobj)
{
- return GPOINTER_TO_INT(g_object_get_data (gobj, "dbus-id"));
+ return GPOINTER_TO_INT (g_object_get_data (gobj, "dbus-id"));
}
static guint
-object_to_ref (AtkObject *accessible)
+object_to_ref (AtkObject * accessible)
{
return gobject_to_ref (G_OBJECT (accessible));
}
static guint
-hyperlink_to_ref (AtkHyperlink *link)
+hyperlink_to_ref (AtkHyperlink * link)
{
return gobject_to_ref (G_OBJECT (link));
}
gchar *
atk_dbus_ref_to_path (guint ref)
{
- return g_strdup_printf(SPI_ATK_OBJECT_REFERENCE_TEMPLATE, ref);
+ return g_strdup_printf (SPI_ATK_OBJECT_REFERENCE_TEMPLATE, ref);
}
/*---------------------------------------------------------------------------*/
* it is no longer exposed over D-Bus.
*/
static void
-deregister_object (gpointer data, GObject *gobj)
+deregister_object (gpointer data, GObject * gobj)
{
guint ref;
GHashTable *subrefs_atk;
g_return_if_fail (ATK_IS_OBJECT (gobj) || ATK_IS_HYPERLINK (gobj));
subrefs_atk = (GHashTable *) g_object_get_data (gobj, "dbus-subrefs-atk");
- subrefs_hyperlink = (GHashTable *) g_object_get_data (gobj, "dbus-subrefs-hyperlink");
+ subrefs_hyperlink =
+ (GHashTable *) g_object_get_data (gobj, "dbus-subrefs-hyperlink");
if (subrefs_atk)
- {
- g_hash_table_foreach (subrefs_atk, deregister_sub_accessible, data);
- g_hash_table_unref (subrefs_atk);
- }
-
+ {
+ g_hash_table_foreach (subrefs_atk, deregister_sub_accessible, data);
+ g_hash_table_unref (subrefs_atk);
+ }
+
if (subrefs_hyperlink)
- {
- g_hash_table_foreach (subrefs_hyperlink, deregister_sub_hyperlink, data);
- g_hash_table_unref (subrefs_hyperlink);
- }
-
+ {
+ g_hash_table_foreach (subrefs_hyperlink, deregister_sub_hyperlink,
+ data);
+ g_hash_table_unref (subrefs_hyperlink);
+ }
+
if (subrefs_atk || subrefs_hyperlink)
g_hash_table_remove (objects_with_subrefs, gobj);
if (ATK_IS_OBJECT (gobj))
- {
- ref = object_to_ref (ATK_OBJECT (gobj));
- if (ref != 0)
- {
- spi_emit_cache_removal (ref, atk_adaptor_app_data->bus);
- g_hash_table_remove(ref2ptr, GINT_TO_POINTER(ref));
- }
+ {
+ ref = object_to_ref (ATK_OBJECT (gobj));
+ if (ref != 0)
+ {
+ spi_emit_cache_removal (ref, atk_adaptor_app_data->bus);
+ g_hash_table_remove (ref2ptr, GINT_TO_POINTER (ref));
+ }
}
- }
+}
static void
deregister_sub_accessible (gpointer key, gpointer obj_data, gpointer iter)
ref = gobject_to_ref (ghyperlink);
if (ref != 0)
{
- g_hash_table_remove(ref2ptr, GINT_TO_POINTER(ref));
+ g_hash_table_remove (ref2ptr, GINT_TO_POINTER (ref));
}
g_object_unref (ghyperlink);
}
static void
-register_gobject (GObject *gobj, GObject *container)
+register_gobject (GObject * gobj, GObject * container)
{
guint ref;
- g_return_if_fail (G_IS_OBJECT(gobj));
+ g_return_if_fail (G_IS_OBJECT (gobj));
- ref = assign_reference();
+ ref = assign_reference ();
- g_hash_table_insert (ref2ptr, GINT_TO_POINTER(ref), gobj);
- g_object_set_data (G_OBJECT(gobj), "dbus-id", GINT_TO_POINTER(ref));
- g_object_weak_ref(G_OBJECT(gobj), deregister_object, NULL);
+ g_hash_table_insert (ref2ptr, GINT_TO_POINTER (ref), gobj);
+ g_object_set_data (G_OBJECT (gobj), "dbus-id", GINT_TO_POINTER (ref));
+ g_object_weak_ref (G_OBJECT (gobj), deregister_object, NULL);
if (container)
- {
- GHashTable *subrefs = (GHashTable *) g_object_get_data (G_OBJECT (container), "dbus-subrefs-atk");
- if (!subrefs)
{
- subrefs = g_hash_table_new(g_direct_hash, g_direct_equal);
- g_object_set_data (G_OBJECT (container), "dbus-subrefs-atk", subrefs);
+ GHashTable *subrefs =
+ (GHashTable *) g_object_get_data (G_OBJECT (container),
+ "dbus-subrefs-atk");
+ if (!subrefs)
+ {
+ subrefs = g_hash_table_new (g_direct_hash, g_direct_equal);
+ g_object_set_data (G_OBJECT (container), "dbus-subrefs-atk",
+ subrefs);
+ }
+ g_hash_table_insert (subrefs, GINT_TO_POINTER (ref), gobj);
+ g_hash_table_insert (objects_with_subrefs, gobj, subrefs);
}
- g_hash_table_insert (subrefs, GINT_TO_POINTER(ref), gobj);
- g_hash_table_insert (objects_with_subrefs, gobj, subrefs);
- }
if (ATK_IS_HYPERLINK (gobj))
g_object_ref (gobj);
else if (ATK_IS_OBJECT (gobj))
- {
- AtkObject *accessible = ATK_OBJECT (gobj);
- AtkStateSet *state = atk_object_ref_state_set (accessible);
- if (atk_state_set_contains_state (state, ATK_STATE_TRANSIENT))
{
- g_object_ref (gobj);
- /* We should only get here as the result of a query other than GetTree */
- spi_emit_cache_update (accessible, atk_adaptor_app_data->bus);
+ AtkObject *accessible = ATK_OBJECT (gobj);
+ AtkStateSet *state = atk_object_ref_state_set (accessible);
+ if (atk_state_set_contains_state (state, ATK_STATE_TRANSIENT))
+ {
+ g_object_ref (gobj);
+ /* We should only get here as the result of a query other than GetTree */
+ spi_emit_cache_update (accessible, atk_adaptor_app_data->bus);
+ }
+ g_object_unref (state);
}
- g_object_unref (state);
- }
}
/*
* Called to register an AtkObject with AT-SPI and expose it over D-Bus.
*/
static void
-register_accessible (AtkObject *accessible, AtkObject *container)
+register_accessible (AtkObject * accessible, AtkObject * container)
{
- g_return_if_fail (ATK_IS_OBJECT(accessible));
+ g_return_if_fail (ATK_IS_OBJECT (accessible));
register_gobject (G_OBJECT (accessible), G_OBJECT (container));
}
static void
-register_hyperlink (AtkHyperlink *hyperlink, AtkObject *container)
+register_hyperlink (AtkHyperlink * hyperlink, AtkObject * container)
{
guint ref;
g_return_if_fail (ATK_IS_HYPERLINK (hyperlink));
g_return_if_fail (container);
- ref = assign_reference();
+ ref = assign_reference ();
- g_hash_table_insert (ref2ptr, GINT_TO_POINTER(ref), hyperlink);
- g_object_set_data (G_OBJECT(hyperlink), "dbus-id", GINT_TO_POINTER(ref));
+ g_hash_table_insert (ref2ptr, GINT_TO_POINTER (ref), hyperlink);
+ g_object_set_data (G_OBJECT (hyperlink), "dbus-id", GINT_TO_POINTER (ref));
g_object_ref (G_OBJECT (hyperlink));
- GHashTable *subrefs = (GHashTable *) g_object_get_data (G_OBJECT (container), "dbus-subrefs-hyperlink");
+ GHashTable *subrefs =
+ (GHashTable *) g_object_get_data (G_OBJECT (container),
+ "dbus-subrefs-hyperlink");
if (!subrefs)
- {
- subrefs = g_hash_table_new(g_direct_hash, g_direct_equal);
- g_object_set_data (G_OBJECT (container), "dbus-subrefs-hyperlink", GINT_TO_POINTER(ref));
- }
- g_hash_table_insert (subrefs, GINT_TO_POINTER(ref), hyperlink);
+ {
+ subrefs = g_hash_table_new (g_direct_hash, g_direct_equal);
+ g_object_set_data (G_OBJECT (container), "dbus-subrefs-hyperlink",
+ GINT_TO_POINTER (ref));
+ }
+ g_hash_table_insert (subrefs, GINT_TO_POINTER (ref), hyperlink);
}
/*---------------------------------------------------------------------------*/
* TODO Add debug wrapper
*/
static gboolean
-non_owned_accessible (AtkObject *accessible)
-{
- if ((G_OBJECT (accessible))->ref_count <= 1)
- {
- g_warning ("AT-SPI: Child referenced that is not owned by its parent");
- return TRUE;
- }
- else
- {
- return FALSE;
- }
+non_owned_accessible (AtkObject * accessible)
+{
+ if ((G_OBJECT (accessible))->ref_count <= 1)
+ {
+ g_warning ("AT-SPI: Child referenced that is not owned by its parent");
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
}
#endif /* SPI_ATK_DEBUG */
* Currently true if TRANSIENT and not SHOWING
*/
static gboolean
-object_is_moot (AtkObject *accessible)
+object_is_moot (AtkObject * accessible)
{
- AtkStateSet *state;
- gboolean result = FALSE;
+ AtkStateSet *state;
+ gboolean result = FALSE;
- /* This is dangerous, refing the state set
- * seems to do wierd things to the tree & cause recursion
- * by modifying the tree alot.
- */
- state = atk_object_ref_state_set (accessible);
- if ( atk_state_set_contains_state (state, ATK_STATE_TRANSIENT) &&
- !atk_state_set_contains_state (state, ATK_STATE_SHOWING))
- {
- result = TRUE;
- }
- g_object_unref (state);
+ /* This is dangerous, refing the state set
+ * seems to do wierd things to the tree & cause recursion
+ * by modifying the tree alot.
+ */
+ state = atk_object_ref_state_set (accessible);
+ if (atk_state_set_contains_state (state, ATK_STATE_TRANSIENT) &&
+ !atk_state_set_contains_state (state, ATK_STATE_SHOWING))
+ {
+ result = TRUE;
+ }
+ g_object_unref (state);
- return result;
+ return result;
}
static void
-append_children (AtkObject *accessible, GQueue *traversal)
+append_children (AtkObject * accessible, GQueue * traversal)
{
AtkObject *current;
guint i;
gint count = atk_object_get_n_accessible_children (accessible);
- if (count < 0) count = 0;
- for (i =0; i < count; i++)
+ if (count < 0)
+ count = 0;
+ for (i = 0; i < count; i++)
{
current = atk_object_ref_accessible_child (accessible, i);
if (current)
* or if it has already been registered.
*/
void
-register_subtree (AtkObject *accessible)
+register_subtree (AtkObject * accessible)
{
AtkObject *current;
- GQueue *traversal;
- GQueue *emit_update;
+ GQueue *traversal;
+ GQueue *emit_update;
g_return_if_fail (ATK_IS_OBJECT (accessible));
{
register_accessible (current, NULL);
#ifdef SPI_ATK_DEBUG
- g_debug ("REG - %s - %d - %s", atk_object_get_name (current),
- atk_object_get_role (current),
- atk_dbus_object_to_path (current));
+ g_debug ("REG - %s - %d - %s", atk_object_get_name (current),
+ atk_object_get_role (current),
+ atk_dbus_object_to_path (current));
#endif
append_children (current, traversal);
}
* way that client side cache needs to be updated.
*/
static void
-update_accessible (AtkObject *accessible)
+update_accessible (AtkObject * accessible)
{
- guint ref = 0;
- g_return_if_fail (ATK_IS_OBJECT(accessible));
+ guint ref = 0;
+ g_return_if_fail (ATK_IS_OBJECT (accessible));
ref = object_to_ref (accessible);
if (ref)
/*---------------------------------------------------------------------------*/
void
-atk_dbus_foreach_registered(GHFunc func, gpointer data)
+atk_dbus_foreach_registered (GHFunc func, gpointer data)
{
- g_hash_table_foreach(ref2ptr, func, data);
+ g_hash_table_foreach (ref2ptr, func, data);
}
/*
g_return_val_if_fail (path, NULL);
- if (strncmp(path, SPI_ATK_OBJECT_PATH_PREFIX, SPI_ATK_PATH_PREFIX_LENGTH) != 0)
+ if (strncmp (path, SPI_ATK_OBJECT_PATH_PREFIX, SPI_ATK_PATH_PREFIX_LENGTH)
+ != 0)
return NULL;
- path += SPI_ATK_PATH_PREFIX_LENGTH; /* Skip over the prefix */
+ path += SPI_ATK_PATH_PREFIX_LENGTH; /* Skip over the prefix */
if (!g_strcmp0 (SPI_ATK_OBJECT_PATH_DESKTOP, path))
- return G_OBJECT (atk_get_root());
+ return G_OBJECT (atk_get_root ());
if (path[0] != '/')
- return NULL;
+ return NULL;
path++;
index = atoi (path);
- data = g_hash_table_lookup (ref2ptr, GINT_TO_POINTER(index));
+ data = g_hash_table_lookup (ref2ptr, GINT_TO_POINTER (index));
if (data)
- {
- GObject *gobj = G_OBJECT (data);
- g_object_set_data (gobj, "last-ref-time", (gpointer) time (NULL));
- return gobj;
- }
+ {
+ GObject *gobj = G_OBJECT (data);
+ g_object_set_data (gobj, "last-ref-time", (gpointer) time (NULL));
+ return gobj;
+ }
else
return NULL;
}
* object that has not already been registered.
*/
gchar *
-atk_dbus_object_attempt_registration (AtkObject *accessible)
+atk_dbus_object_attempt_registration (AtkObject * accessible)
{
guint ref;
prev = accessible;
current = atk_object_get_parent (accessible);
if (current)
- cref = object_to_ref (current);
+ cref = object_to_ref (current);
while (current && !cref)
{
prev = current;
current = atk_object_get_parent (current);
if (current)
- cref = object_to_ref (current);
+ cref = object_to_ref (current);
}
/* A registered parent, with non-registered child, has been found */
else
{
#ifdef SPI_ATK_DEBUG
- g_debug ("AT-SPI: Could not register a non-attached accessible object");
+ g_debug
+ ("AT-SPI: Could not register a non-attached accessible object");
#endif
return NULL;
}
* Used to lookup a D-Bus path from the AtkObject.
*/
static gchar *
-atk_dbus_gobject_to_path_internal (GObject *gobj, gboolean do_register, GObject *container)
+atk_dbus_gobject_to_path_internal (GObject * gobj, gboolean do_register,
+ GObject * container)
{
guint ref;
ref = gobject_to_ref (gobj);
if (!ref && do_register)
- {
- register_gobject (gobj, container);
- ref = gobject_to_ref (gobj);
- }
+ {
+ register_gobject (gobj, container);
+ ref = gobject_to_ref (gobj);
+ }
if (!ref)
- return NULL;
+ return NULL;
else
- return atk_dbus_ref_to_path (ref);
+ return atk_dbus_ref_to_path (ref);
}
gchar *
-atk_dbus_object_to_path (AtkObject *accessible, gboolean do_register)
+atk_dbus_object_to_path (AtkObject * accessible, gboolean do_register)
{
- AtkObject *container = (accessible && do_register? atk_object_get_parent (accessible): NULL);
- return atk_dbus_gobject_to_path_internal (G_OBJECT (accessible), do_register, G_OBJECT (container));
+ AtkObject *container = (accessible
+ && do_register ? atk_object_get_parent (accessible)
+ : NULL);
+ return atk_dbus_gobject_to_path_internal (G_OBJECT (accessible),
+ do_register,
+ G_OBJECT (container));
}
gchar *
-atk_dbus_sub_object_to_path (GObject *gobj, GObject *container)
+atk_dbus_sub_object_to_path (GObject * gobj, GObject * container)
{
return atk_dbus_gobject_to_path_internal (gobj, TRUE, container);
}
gchar *
-atk_dbus_hyperlink_to_path (AtkHyperlink *hyperlink, AtkObject *container)
+atk_dbus_hyperlink_to_path (AtkHyperlink * hyperlink, AtkObject * container)
{
guint ref;
ref = gobject_to_ref (G_OBJECT (hyperlink));
if (!ref && container)
- {
- register_hyperlink (hyperlink, container);
- ref = hyperlink_to_ref (hyperlink);
- }
+ {
+ register_hyperlink (hyperlink, container);
+ ref = hyperlink_to_ref (hyperlink);
+ }
if (!ref)
- return NULL;
+ return NULL;
else
- return atk_dbus_ref_to_path (ref);
+ return atk_dbus_ref_to_path (ref);
}
gchar *
/*---------------------------------------------------------------------------*/
-typedef gboolean (*TreeUpdateAction) (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data,
- AtkObject *accessible);
+typedef gboolean (*TreeUpdateAction) (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values,
+ gpointer data, AtkObject * accessible);
/*
* Events are not evaluated for non-registered accessibles.
*/
/* TODO Turn this function into a macro? */
static gboolean
-tree_update_wrapper (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data,
- TreeUpdateAction action)
+tree_update_wrapper (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values,
+ gpointer data, TreeUpdateAction action)
{
AtkObject *accessible;
/* Ensure that only registered accessibles
* have their signals processed.
*/
- accessible = ATK_OBJECT(g_value_get_object (¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
g_return_val_if_fail (ATK_IS_OBJECT (accessible), TRUE);
if (object_to_ref (accessible))
{
#ifdef SPI_ATK_DEBUG
if (recursion_check_and_set ())
- g_warning ("AT-SPI: Recursive use of registration module");
+ g_warning ("AT-SPI: Recursive use of registration module");
g_debug ("AT-SPI: Tree update listener");
#endif
static gboolean
maybe_expire_lease (gpointer key, gpointer obj_data, gpointer iter)
{
- time_t secs = time (NULL) - (time_t)obj_data;
+ time_t secs = time (NULL) - (time_t) obj_data;
if (secs < 30)
return FALSE;
static void
expire_old_leases_in (gpointer key, gpointer obj_data, gpointer iter)
{
- g_hash_table_foreach_remove ((GHashTable *)obj_data, maybe_expire_lease, NULL);
+ g_hash_table_foreach_remove ((GHashTable *) obj_data, maybe_expire_lease,
+ NULL);
}
static void
}
static gboolean
-tree_update_state_action (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data,
- AtkObject *accessible)
+tree_update_state_action (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values,
+ gpointer data, AtkObject * accessible)
{
const gchar *name;
gboolean state;
if (n_param_values < 3)
- {
- g_warning ("at-spi: Not enough params in state-changed signal");
- return TRUE;
- }
+ {
+ g_warning ("at-spi: Not enough params in state-changed signal");
+ return TRUE;
+ }
name = g_value_get_string (param_values + 1);
state = g_value_get_boolean (param_values + 2);
if (!strcmp (name, "visible"))
- {
- AtkStateSet *set = atk_object_ref_state_set (accessible);
- if (atk_state_set_contains_state (set, ATK_STATE_TRANSIENT))
{
- if (state == 0)
- {
- g_hash_table_insert (leased_refs, accessible, (gpointer) time (NULL));
- leased_refs_count++;
- /* todo: Set to a high number: 5 for dbg. */
- if (leased_refs_count > 5)
- expire_old_leases ();
- }
- else
- {
- g_hash_table_remove (leased_refs, accessible);
- leased_refs_count--;
- }
+ AtkStateSet *set = atk_object_ref_state_set (accessible);
+ if (atk_state_set_contains_state (set, ATK_STATE_TRANSIENT))
+ {
+ if (state == 0)
+ {
+ g_hash_table_insert (leased_refs, accessible,
+ (gpointer) time (NULL));
+ leased_refs_count++;
+ /* todo: Set to a high number: 5 for dbg. */
+ if (leased_refs_count > 5)
+ expire_old_leases ();
+ }
+ else
+ {
+ g_hash_table_remove (leased_refs, accessible);
+ leased_refs_count--;
+ }
+ }
+ g_object_unref (set);
}
- g_object_unref (set);
- }
- update_accessible (accessible);
+ update_accessible (accessible);
return TRUE;
}
static gboolean
-tree_update_state_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+tree_update_state_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
- tree_update_wrapper (signal_hint, n_param_values, param_values, data, tree_update_state_action);
+ tree_update_wrapper (signal_hint, n_param_values, param_values, data,
+ tree_update_state_action);
return TRUE;
}
static gboolean
-tree_update_property_action (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data,
- AtkObject *accessible)
-{
- AtkPropertyValues *values;
- const gchar *pname = NULL;
-
- values = (AtkPropertyValues*) g_value_get_pointer (¶m_values[1]);
- pname = values[0].property_name;
- if (strcmp (pname, "accessible-name") == 0 ||
- strcmp (pname, "accessible-description") == 0 ||
- strcmp (pname, "accessible-parent") == 0 ||
- strcmp (pname, "accessible-role") == 0)
- {
- update_accessible (accessible);
- }
- /* Parent value us updated by child-add signal of parent object */
- return TRUE;
+tree_update_property_action (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values,
+ gpointer data, AtkObject * accessible)
+{
+ AtkPropertyValues *values;
+ const gchar *pname = NULL;
+
+ values = (AtkPropertyValues *) g_value_get_pointer (¶m_values[1]);
+ pname = values[0].property_name;
+ if (strcmp (pname, "accessible-name") == 0 ||
+ strcmp (pname, "accessible-description") == 0 ||
+ strcmp (pname, "accessible-parent") == 0 ||
+ strcmp (pname, "accessible-role") == 0)
+ {
+ update_accessible (accessible);
+ }
+ /* Parent value us updated by child-add signal of parent object */
+ return TRUE;
}
static gboolean
-tree_update_property_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+tree_update_property_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
- tree_update_wrapper (signal_hint, n_param_values, param_values, data, tree_update_property_action);
+ tree_update_wrapper (signal_hint, n_param_values, param_values, data,
+ tree_update_property_action);
return TRUE;
}
static gboolean
-tree_update_children_action (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data,
- AtkObject *accessible)
+tree_update_children_action (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values,
+ gpointer data, AtkObject * accessible)
{
- const gchar *detail = NULL;
- AtkObject *child;
+ const gchar *detail = NULL;
+ AtkObject *child;
- if (signal_hint->detail)
- detail = g_quark_to_string (signal_hint->detail);
+ if (signal_hint->detail)
+ detail = g_quark_to_string (signal_hint->detail);
- if (!strcmp (detail, "add"))
- {
- gpointer child;
- int index = g_value_get_uint (param_values + 1);
- child = g_value_get_pointer (param_values + 2);
+ if (!strcmp (detail, "add"))
+ {
+ gpointer child;
+ int index = g_value_get_uint (param_values + 1);
+ child = g_value_get_pointer (param_values + 2);
- if (!ATK_IS_OBJECT (child))
- {
- child = atk_object_ref_accessible_child (accessible, index);
+ if (!ATK_IS_OBJECT (child))
+ {
+ child = atk_object_ref_accessible_child (accessible, index);
#ifdef SPI_ATK_DEBUG
- non_owned_accessible (child);
+ non_owned_accessible (child);
#endif
- }
- register_subtree (child);
- update_accessible (accessible);
}
- else if (!strcmp (detail, "remove"))
- {
- update_accessible (accessible);
- }
- return TRUE;
+ register_subtree (child);
+ update_accessible (accessible);
+ }
+ else if (!strcmp (detail, "remove"))
+ {
+ update_accessible (accessible);
+ }
+ return TRUE;
}
static gboolean
-tree_update_children_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+tree_update_children_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
- tree_update_wrapper (signal_hint, n_param_values, param_values, data, tree_update_children_action);
- return TRUE;
+ tree_update_wrapper (signal_hint, n_param_values, param_values, data,
+ tree_update_children_action);
+ return TRUE;
}
/*---------------------------------------------------------------------------*/
static void
-spi_atk_register_toplevel_added (AtkObject *accessible,
- guint index,
- AtkObject *child)
+spi_atk_register_toplevel_added (AtkObject * accessible,
+ guint index, AtkObject * child)
{
g_static_rec_mutex_lock (®istration_mutex);
{
#ifdef SPI_ATK_DEBUG
if (recursion_check_and_set ())
- g_warning ("AT-SPI: Recursive use of registration module");
+ g_warning ("AT-SPI: Recursive use of registration module");
g_debug ("AT-SPI: Toplevel added listener");
#endif
}
static void
-spi_atk_register_toplevel_removed (AtkObject *accessible,
- guint index,
- AtkObject *child)
+spi_atk_register_toplevel_removed (AtkObject * accessible,
+ guint index, AtkObject * child)
{
g_static_rec_mutex_lock (®istration_mutex);
{
#ifdef SPI_ATK_DEBUG
if (recursion_check_and_set ())
- g_warning ("AT-SPI: Recursive use of registration module");
+ g_warning ("AT-SPI: Recursive use of registration module");
g_debug ("AT-SPI: Toplevel removed listener");
#endif
* Initializes all of the required D-Bus interfaces.
*/
void
-atk_dbus_initialize (AtkObject *root)
+atk_dbus_initialize (AtkObject * root)
{
if (!ref2ptr)
- ref2ptr = g_hash_table_new(g_direct_hash, g_direct_equal);
+ ref2ptr = g_hash_table_new (g_direct_hash, g_direct_equal);
if (!objects_with_subrefs)
- objects_with_subrefs = g_hash_table_new(g_direct_hash, g_direct_equal);
+ objects_with_subrefs = g_hash_table_new (g_direct_hash, g_direct_equal);
if (!leased_refs)
- leased_refs = g_hash_table_new(g_direct_hash, g_direct_equal);
+ leased_refs = g_hash_table_new (g_direct_hash, g_direct_equal);
#ifdef SPI_ATK_DEBUG
if (g_thread_supported ())
- g_message ("AT-SPI: Threads enabled");
+ g_message ("AT-SPI: Threads enabled");
g_debug ("AT-SPI: Initial Atk tree regisration");
#endif
register_subtree (root);
- atk_add_global_event_listener (tree_update_property_listener, "Gtk:AtkObject:property-change");
- atk_add_global_event_listener (tree_update_children_listener, "Gtk:AtkObject:children-changed");
- atk_add_global_event_listener (tree_update_state_listener, "Gtk:AtkObject:state-change");
+ atk_add_global_event_listener (tree_update_property_listener,
+ "Gtk:AtkObject:property-change");
+ atk_add_global_event_listener (tree_update_children_listener,
+ "Gtk:AtkObject:children-changed");
+ atk_add_global_event_listener (tree_update_state_listener,
+ "Gtk:AtkObject:state-change");
g_signal_connect (root,
"children-changed::add",
- (GCallback) spi_atk_register_toplevel_added,
- NULL);
+ (GCallback) spi_atk_register_toplevel_added, NULL);
g_signal_connect (root,
"children-changed::remove",
- (GCallback) spi_atk_register_toplevel_removed,
- NULL);
+ (GCallback) spi_atk_register_toplevel_removed, NULL);
}
/*END------------------------------------------------------------------------*/
#include <atk/atk.h>
#include <glib.h>
-void
-atk_dbus_foreach_registered(GHFunc func, gpointer data);
+void atk_dbus_foreach_registered (GHFunc func, gpointer data);
/*---------------------------------------------------------------------------*/
-GObject *
-atk_dbus_path_to_gobject (const char *path);
+GObject *atk_dbus_path_to_gobject (const char *path);
-AtkObject *
-atk_dbus_path_to_object (const char *path);
+AtkObject *atk_dbus_path_to_object (const char *path);
-gchar *
-atk_dbus_object_attempt_registration (AtkObject *accessible);
+gchar *atk_dbus_object_attempt_registration (AtkObject * accessible);
-gchar *
-atk_dbus_object_to_path (AtkObject *accessible, gboolean do_register);
+gchar *atk_dbus_object_to_path (AtkObject * accessible, gboolean do_register);
-gchar *
-atk_dbus_sub_object_to_path (GObject *accessible, GObject *container);
+gchar *atk_dbus_sub_object_to_path (GObject * accessible,
+ GObject * container);
-gchar *
-atk_dbus_hyperlink_to_path (AtkHyperlink *hyperlink, AtkObject *container);
+gchar *atk_dbus_hyperlink_to_path (AtkHyperlink * hyperlink,
+ AtkObject * container);
-gchar *
-atk_dbus_desktop_object_path ();
+gchar *atk_dbus_desktop_object_path ();
-gchar *
-atk_dbus_ref_to_path (guint ref);
+gchar *atk_dbus_ref_to_path (guint ref);
#endif /* ACCESSIBLE_REGISTER */
#include "common/spi-dbus.h"
static dbus_bool_t
-impl_get_NActions (DBusMessageIter *iter, void *user_data)
+impl_get_NActions (DBusMessageIter * iter, void *user_data)
{
AtkAction *action = (AtkAction *) user_data;
}
static DBusMessage *
-impl_get_description (DBusConnection *bus, DBusMessage *message, void *user_data)
+impl_get_description (DBusConnection * bus, DBusMessage * message,
+ void *user_data)
{
AtkAction *action = (AtkAction *) user_data;
DBusError error;
dbus_error_init (&error);
g_return_val_if_fail (ATK_IS_ACTION (user_data),
droute_not_yet_handled_error (message));
- if (!dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &index, DBUS_TYPE_INVALID))
- {
- return droute_invalid_arguments_error (message);
- }
- desc = atk_action_get_description(action, index);
- if (!desc) desc = "";
+ if (!dbus_message_get_args
+ (message, &error, DBUS_TYPE_INT32, &index, DBUS_TYPE_INVALID))
+ {
+ return droute_invalid_arguments_error (message);
+ }
+ desc = atk_action_get_description (action, index);
+ if (!desc)
+ desc = "";
reply = dbus_message_new_method_return (message);
if (reply)
- {
- dbus_message_append_args (reply, DBUS_TYPE_STRING, &desc, DBUS_TYPE_INVALID);
- }
+ {
+ dbus_message_append_args (reply, DBUS_TYPE_STRING, &desc,
+ DBUS_TYPE_INVALID);
+ }
return reply;
}
static DBusMessage *
-impl_get_name (DBusConnection *bus, DBusMessage *message, void *user_data)
+impl_get_name (DBusConnection * bus, DBusMessage * message, void *user_data)
{
DBusMessage *reply;
DBusError error;
dbus_error_init (&error);
g_return_val_if_fail (ATK_IS_ACTION (user_data),
droute_not_yet_handled_error (message));
- if (!dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &index, DBUS_TYPE_INVALID))
- {
- return droute_invalid_arguments_error (message);
- }
- name = atk_action_get_name(action, index);
- if (!name) name = "";
+ if (!dbus_message_get_args
+ (message, &error, DBUS_TYPE_INT32, &index, DBUS_TYPE_INVALID))
+ {
+ return droute_invalid_arguments_error (message);
+ }
+ name = atk_action_get_name (action, index);
+ if (!name)
+ name = "";
reply = dbus_message_new_method_return (message);
if (reply)
- {
- dbus_message_append_args (reply, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID);
- }
+ {
+ dbus_message_append_args (reply, DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID);
+ }
return reply;
}
static DBusMessage *
-impl_get_keybinding (DBusConnection *bus, DBusMessage *message, void *user_data)
+impl_get_keybinding (DBusConnection * bus, DBusMessage * message,
+ void *user_data)
{
DBusMessage *reply;
DBusError error;
dbus_error_init (&error);
g_return_val_if_fail (ATK_IS_ACTION (user_data),
droute_not_yet_handled_error (message));
- if (!dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &index, DBUS_TYPE_INVALID))
- {
- return droute_invalid_arguments_error (message);
- }
- kb = atk_action_get_keybinding(action, index);
- if (!kb) kb = "";
+ if (!dbus_message_get_args
+ (message, &error, DBUS_TYPE_INT32, &index, DBUS_TYPE_INVALID))
+ {
+ return droute_invalid_arguments_error (message);
+ }
+ kb = atk_action_get_keybinding (action, index);
+ if (!kb)
+ kb = "";
reply = dbus_message_new_method_return (message);
if (reply)
- {
- dbus_message_append_args (reply, DBUS_TYPE_STRING, &kb, DBUS_TYPE_INVALID);
- }
+ {
+ dbus_message_append_args (reply, DBUS_TYPE_STRING, &kb,
+ DBUS_TYPE_INVALID);
+ }
return reply;
}
-static DBusMessage *impl_GetActions(DBusConnection *bus, DBusMessage *message, void *user_data)
+static DBusMessage *
+impl_GetActions (DBusConnection * bus, DBusMessage * message, void *user_data)
{
AtkAction *action = (AtkAction *) user_data;
DBusMessage *reply;
g_return_val_if_fail (ATK_IS_ACTION (user_data),
droute_not_yet_handled_error (message));
- count = atk_action_get_n_actions(action);
+ count = atk_action_get_n_actions (action);
reply = dbus_message_new_method_return (message);
- if (!reply) goto oom;
+ if (!reply)
+ goto oom;
dbus_message_iter_init_append (reply, &iter);
if (!dbus_message_iter_open_container
(&iter, DBUS_TYPE_ARRAY, "(sss)", &iter_array))
goto oom;
for (i = 0; i < count; i++)
{
- const char *name = atk_action_get_name(action, i);
- const char *desc = atk_action_get_description(action, i);
- const char *kb = atk_action_get_keybinding(action, i);
- if (!name) name = "";
- if (!desc) desc = "";
- if (!kb) kb = "";
- if (!dbus_message_iter_open_container(&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct)) goto oom;
- dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &name);
- dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &desc);
- dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_STRING, &kb);
- if (!dbus_message_iter_close_container(&iter_array, &iter_struct)) goto oom;
+ const char *name = atk_action_get_name (action, i);
+ const char *desc = atk_action_get_description (action, i);
+ const char *kb = atk_action_get_keybinding (action, i);
+ if (!name)
+ name = "";
+ if (!desc)
+ desc = "";
+ if (!kb)
+ kb = "";
+ if (!dbus_message_iter_open_container
+ (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct))
+ goto oom;
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &name);
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &desc);
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &kb);
+ if (!dbus_message_iter_close_container (&iter_array, &iter_struct))
+ goto oom;
}
if (!dbus_message_iter_close_container (&iter, &iter_array))
goto oom;
return reply;
}
-static DBusMessage *impl_DoAction(DBusConnection *bus, DBusMessage *message, void *user_data)
+static DBusMessage *
+impl_DoAction (DBusConnection * bus, DBusMessage * message, void *user_data)
{
AtkAction *action = (AtkAction *) user_data;
DBusError error;
{
return droute_invalid_arguments_error (message);
}
- rv = atk_action_do_action(action, index);
+ rv = atk_action_do_action (action, index);
reply = dbus_message_new_method_return (message);
if (reply)
{
- dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &rv, DBUS_TYPE_INVALID);
+ dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &rv,
+ DBUS_TYPE_INVALID);
}
return reply;
}
-DRouteMethod methods[] =
-{
- { impl_get_description, "GetDescription" },
- { impl_get_name, "GetName" },
- { impl_get_keybinding, "GetKeyBinding" },
- {impl_GetActions, "GetActions"},
- {impl_DoAction, "DoAction"},
- {NULL, NULL }
+DRouteMethod methods[] = {
+ {impl_get_description, "GetDescription"}
+ ,
+ {impl_get_name, "GetName"}
+ ,
+ {impl_get_keybinding, "GetKeyBinding"}
+ ,
+ {impl_GetActions, "GetActions"}
+ ,
+ {impl_DoAction, "DoAction"}
+ ,
+ {NULL, NULL}
};
-static DRouteProperty properties[] =
-{
- { impl_get_NActions, NULL, "NActions" },
- { NULL, NULL }
+static DRouteProperty properties[] = {
+ {impl_get_NActions, NULL, "NActions"},
+ {NULL, NULL}
};
void
-spi_initialize_action (DRoutePath *path)
+spi_initialize_action (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_ACTION,
- methods,
- properties);
+ SPI_DBUS_INTERFACE_ACTION, methods, properties);
};
Accessibility_Role spi_accessible_role_from_atk_role (AtkRole role);
-void spi_initialize_accessible (DRoutePath *path);
-void spi_initialize_action (DRoutePath *path);
-void spi_initialize_application (DRoutePath *path);
-void spi_initialize_collection (DRoutePath *path);
-void spi_initialize_component (DRoutePath *path);
-void spi_initialize_document (DRoutePath *path);
-void spi_initialize_editabletext (DRoutePath *path);
-void spi_initialize_hyperlink (DRoutePath *path);
-void spi_initialize_hypertext (DRoutePath *path);
-void spi_initialize_image (DRoutePath *path);
-void spi_initialize_selection (DRoutePath *path);
-void spi_initialize_table (DRoutePath *path);
-void spi_initialize_text (DRoutePath *path);
-void spi_initialize_value (DRoutePath *path);
-void spi_initialize_tree (DRoutePath *path);
+void spi_initialize_accessible (DRoutePath * path);
+void spi_initialize_action (DRoutePath * path);
+void spi_initialize_application (DRoutePath * path);
+void spi_initialize_collection (DRoutePath * path);
+void spi_initialize_component (DRoutePath * path);
+void spi_initialize_document (DRoutePath * path);
+void spi_initialize_editabletext (DRoutePath * path);
+void spi_initialize_hyperlink (DRoutePath * path);
+void spi_initialize_hypertext (DRoutePath * path);
+void spi_initialize_image (DRoutePath * path);
+void spi_initialize_selection (DRoutePath * path);
+void spi_initialize_table (DRoutePath * path);
+void spi_initialize_text (DRoutePath * path);
+void spi_initialize_value (DRoutePath * path);
+void spi_initialize_tree (DRoutePath * path);
#endif /* ADAPTORS_H */
#include "common/spi-dbus.h"
static dbus_bool_t
-impl_get_ToolkitName (DBusMessageIter * iter,
- void *user_data)
+impl_get_ToolkitName (DBusMessageIter * iter, void *user_data)
{
return droute_return_v_string (iter, atk_get_toolkit_name ());
}
static DBusMessage *
impl_registerToolkitEventListener (DBusConnection * bus,
- DBusMessage * message, void *user_data)
+ DBusMessage * message, void *user_data)
{
return NULL;
}
static DBusMessage *
impl_registerObjectEventListener (DBusConnection * bus, DBusMessage * message,
- void *user_data)
+ void *user_data)
{
return NULL;
}
}*/
void
-spi_initialize_application (DRoutePath *path)
+spi_initialize_application (DRoutePath * path)
{
droute_path_add_interface (path,
SPI_DBUS_INTERFACE_APPLICATION,
- methods,
- properties);
+ methods, properties);
};
* Provides the path for the introspection directory.
*/
#if !defined ATSPI_INTROSPECTION_PATH
- #error "No introspection XML directory defined"
+#error "No introspection XML directory defined"
#endif
/*---------------------------------------------------------------------------*/
* with the screen number stripped off if present.
*
*/
-static const gchar*
+static const gchar *
spi_display_name (void)
{
- static const char *canonical_display_name = NULL;
- if (!canonical_display_name)
- {
- const gchar *display_env = g_getenv ("AT_SPI_DISPLAY");
- if (!display_env)
- {
- display_env = g_getenv ("DISPLAY");
- if (!display_env || !display_env[0])
- canonical_display_name = ":0";
- else
- {
- gchar *display_p, *screen_p;
- canonical_display_name = g_strdup (display_env);
- display_p = strrchr (canonical_display_name, ':');
- screen_p = strrchr (canonical_display_name, '.');
- if (screen_p && display_p && (screen_p > display_p))
- {
- *screen_p = '\0';
- }
- }
- }
- else
- {
- canonical_display_name = display_env;
- }
- }
- return canonical_display_name;
+ static const char *canonical_display_name = NULL;
+ if (!canonical_display_name)
+ {
+ const gchar *display_env = g_getenv ("AT_SPI_DISPLAY");
+ if (!display_env)
+ {
+ display_env = g_getenv ("DISPLAY");
+ if (!display_env || !display_env[0])
+ canonical_display_name = ":0";
+ else
+ {
+ gchar *display_p, *screen_p;
+ canonical_display_name = g_strdup (display_env);
+ display_p = strrchr (canonical_display_name, ':');
+ screen_p = strrchr (canonical_display_name, '.');
+ if (screen_p && display_p && (screen_p > display_p))
+ {
+ *screen_p = '\0';
+ }
+ }
+ }
+ else
+ {
+ canonical_display_name = display_env;
+ }
+ }
+ return canonical_display_name;
}
/*---------------------------------------------------------------------------*/
static DBusConnection *
spi_atk_bridge_get_bus (void)
{
- Atom AT_SPI_BUS;
- Atom actual_type;
- Display *bridge_display;
- int actual_format;
- unsigned char *data = NULL;
- unsigned long nitems;
- unsigned long leftover;
-
- DBusConnection *bus = NULL;
- DBusError error;
-
- bridge_display = XOpenDisplay (spi_display_name ());
- if (!bridge_display)
- g_error ("AT_SPI: Could not get the display\n");
-
- AT_SPI_BUS = XInternAtom (bridge_display, "AT_SPI_BUS", False);
- XGetWindowProperty(bridge_display,
- XDefaultRootWindow (bridge_display),
- AT_SPI_BUS, 0L,
- (long)BUFSIZ, False,
- (Atom) 31, &actual_type, &actual_format,
- &nitems, &leftover, &data);
-
- dbus_error_init (&error);
-
- if (data == NULL)
- {
- g_warning ("AT-SPI: Accessibility bus not found - Using session bus.\n");
- bus = dbus_bus_get (DBUS_BUS_SESSION, &error);
- if (!bus)
- g_error ("AT-SPI: Couldn't connect to bus: %s\n", error.message);
- }
- else
- {
- bus = dbus_connection_open (data, &error);
- if (!bus)
- {
- g_error ("AT-SPI: Couldn't connect to bus: %s\n", error.message);
- }
- else
- {
- if (!dbus_bus_register (bus, &error))
- g_error ("AT-SPI: Couldn't register with bus: %s\n");
- }
- }
-
- return bus;
+ Atom AT_SPI_BUS;
+ Atom actual_type;
+ Display *bridge_display;
+ int actual_format;
+ unsigned char *data = NULL;
+ unsigned long nitems;
+ unsigned long leftover;
+
+ DBusConnection *bus = NULL;
+ DBusError error;
+
+ bridge_display = XOpenDisplay (spi_display_name ());
+ if (!bridge_display)
+ g_error ("AT_SPI: Could not get the display\n");
+
+ AT_SPI_BUS = XInternAtom (bridge_display, "AT_SPI_BUS", False);
+ XGetWindowProperty (bridge_display,
+ XDefaultRootWindow (bridge_display),
+ AT_SPI_BUS, 0L,
+ (long) BUFSIZ, False,
+ (Atom) 31, &actual_type, &actual_format,
+ &nitems, &leftover, &data);
+
+ dbus_error_init (&error);
+
+ if (data == NULL)
+ {
+ g_warning
+ ("AT-SPI: Accessibility bus not found - Using session bus.\n");
+ bus = dbus_bus_get (DBUS_BUS_SESSION, &error);
+ if (!bus)
+ g_error ("AT-SPI: Couldn't connect to bus: %s\n", error.message);
+ }
+ else
+ {
+ bus = dbus_connection_open (data, &error);
+ if (!bus)
+ {
+ g_error ("AT-SPI: Couldn't connect to bus: %s\n", error.message);
+ }
+ else
+ {
+ if (!dbus_bus_register (bus, &error))
+ g_error ("AT-SPI: Couldn't register with bus: %s\n");
+ }
+ }
+
+ return bus;
}
/*---------------------------------------------------------------------------*/
static void
-register_application (SpiAppData *app)
+register_application (SpiAppData * app)
{
DBusMessage *message;
DBusMessageIter iter;
"RegisterApplication");
dbus_message_set_no_reply (message, TRUE);
- uname = dbus_bus_get_unique_name(app->bus);
+ uname = dbus_bus_get_unique_name (app->bus);
if (!uname)
- {
+ {
g_error ("AT-SPI: Couldn't get unique name for this connection");
- }
+ }
- dbus_message_iter_init_append(message, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &uname);
+ dbus_message_iter_init_append (message, &iter);
+ dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &uname);
dbus_connection_send (app->bus, message, NULL);
- if (message) dbus_message_unref (message);
+ if (message)
+ dbus_message_unref (message);
}
/*---------------------------------------------------------------------------*/
static void
-deregister_application (SpiAppData *app)
+deregister_application (SpiAppData * app)
{
DBusMessage *message;
DBusMessageIter iter;
"DeregisterApplication");
dbus_message_set_no_reply (message, TRUE);
- uname = dbus_bus_get_unique_name(app->bus);
+ uname = dbus_bus_get_unique_name (app->bus);
- dbus_message_iter_init_append(message, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &uname);
+ dbus_message_iter_init_append (message, &iter);
+ dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &uname);
dbus_connection_send (app->bus, message, NULL);
- if (message) dbus_message_unref (message);
+ if (message)
+ dbus_message_unref (message);
}
/*---------------------------------------------------------------------------*/
}
spi_atk_tidy_windows ();
- spi_atk_deregister_event_listeners();
+ spi_atk_deregister_event_listeners ();
deregister_application (atk_adaptor_app_data);
- g_free(atk_adaptor_app_data);
+ g_free (atk_adaptor_app_data);
atk_adaptor_app_data = NULL;
/* Not currently creating an XDisplay */
static AtkSocketClass *socket_class;
static gchar *
-get_plug_id (AtkPlug *plug)
+get_plug_id (AtkPlug * plug)
{
- const char *uname = dbus_bus_get_unique_name(atk_adaptor_app_data->bus);
+ const char *uname = dbus_bus_get_unique_name (atk_adaptor_app_data->bus);
gchar *path;
GString *str = g_string_new (NULL);
- path = atk_dbus_object_to_path (ATK_OBJECT(plug), TRUE);
+ path = atk_dbus_object_to_path (ATK_OBJECT (plug), TRUE);
g_string_printf (str, "%s:%s", uname, path);
g_free (path);
return g_string_free (str, FALSE);
}
static void
-socket_embed_hook (AtkSocket *socket, gchar *plug_id)
+socket_embed_hook (AtkSocket * socket, gchar * plug_id)
{
AtkObject *accessible = ATK_OBJECT(socket);
gchar *plug_name, *plug_path;
install_plug_hooks ()
{
gpointer data;
-
+
data = g_type_class_ref (ATK_TYPE_PLUG);
plug_class = ATK_PLUG_CLASS (data);
data = g_type_class_ref (ATK_TYPE_SOCKET);
gchar *atspi_dbus_name = NULL;
static gboolean atspi_no_register = FALSE;
-static GOptionEntry atspi_option_entries[] =
-{
- {"atspi-dbus-name", 0, 0, G_OPTION_ARG_STRING, &atspi_dbus_name, "D-Bus bus name to register as", NULL},
- {"atspi-no-register", 0, 0, G_OPTION_ARG_NONE, &atspi_no_register, "Do not register with Registry Daemon", NULL},
+static GOptionEntry atspi_option_entries[] = {
+ {"atspi-dbus-name", 0, 0, G_OPTION_ARG_STRING, &atspi_dbus_name,
+ "D-Bus bus name to register as", NULL},
+ {"atspi-no-register", 0, 0, G_OPTION_ARG_NONE, &atspi_no_register,
+ "Do not register with Registry Daemon", NULL},
{NULL}
};
*
*/
static int
-adaptor_init (gint *argc, gchar **argv[])
+adaptor_init (gint * argc, gchar ** argv[])
{
GOptionContext *opt;
GError *err = NULL;
g_return_val_if_fail (root, 0);
/* Parse command line options */
- opt = g_option_context_new(NULL);
- g_option_context_add_main_entries(opt, atspi_option_entries, NULL);
- g_option_context_set_ignore_unknown_options(opt, TRUE);
- if (!g_option_context_parse(opt, argc, argv, &err))
- g_warning("AT-SPI Option parsing failed: %s\n", err->message);
+ opt = g_option_context_new (NULL);
+ g_option_context_add_main_entries (opt, atspi_option_entries, NULL);
+ g_option_context_set_ignore_unknown_options (opt, TRUE);
+ if (!g_option_context_parse (opt, argc, argv, &err))
+ g_warning ("AT-SPI Option parsing failed: %s\n", err->message);
/* Allocate global data and do ATK initializations */
atk_adaptor_app_data = g_new0 (SpiAppData, 1);
dbus_error_init (&error);
atk_adaptor_app_data->bus = spi_atk_bridge_get_bus ();
if (!atk_adaptor_app_data->bus)
- {
- g_free(atk_adaptor_app_data);
- atk_adaptor_app_data = NULL;
- return 0;
- }
-
- if (atspi_dbus_name != NULL)
- {
- if (dbus_bus_request_name(atk_adaptor_app_data->bus, atspi_dbus_name, 0, &error))
{
- g_print("AT-SPI Recieved D-Bus name - %s\n", atspi_dbus_name);
+ g_free (atk_adaptor_app_data);
+ atk_adaptor_app_data = NULL;
+ return 0;
}
- else
+
+ if (atspi_dbus_name != NULL)
{
- g_print("AT-SPI D-Bus name requested but could not be allocated - %s\n", atspi_dbus_name);
+ if (dbus_bus_request_name
+ (atk_adaptor_app_data->bus, atspi_dbus_name, 0, &error))
+ {
+ g_print ("AT-SPI Recieved D-Bus name - %s\n", atspi_dbus_name);
+ }
+ else
+ {
+ g_print
+ ("AT-SPI D-Bus name requested but could not be allocated - %s\n",
+ atspi_dbus_name);
+ }
}
- }
- dbus_connection_setup_with_g_main(atk_adaptor_app_data->bus, g_main_context_default());
+ dbus_connection_setup_with_g_main (atk_adaptor_app_data->bus,
+ g_main_context_default ());
/* Get D-Bus introspection directory */
- introspection_directory = (char *) g_getenv("ATSPI_INTROSPECTION_PATH");
+ introspection_directory = (char *) g_getenv ("ATSPI_INTROSPECTION_PATH");
if (introspection_directory == NULL)
- introspection_directory = ATSPI_INTROSPECTION_PATH;
+ introspection_directory = ATSPI_INTROSPECTION_PATH;
/* Register droute for routing AT-SPI messages */
- atk_adaptor_app_data->droute = droute_new (atk_adaptor_app_data->bus, introspection_directory);
+ atk_adaptor_app_data->droute =
+ droute_new (atk_adaptor_app_data->bus, introspection_directory);
treepath = droute_add_one (atk_adaptor_app_data->droute,
- "/org/freedesktop/atspi/tree",
- NULL);
+ "/org/freedesktop/atspi/tree", NULL);
accpath = droute_add_many (atk_adaptor_app_data->droute,
"/org/freedesktop/atspi/accessible",
NULL,
- (DRouteGetDatumFunction) atk_dbus_path_to_gobject);
+ (DRouteGetDatumFunction)
+ atk_dbus_path_to_gobject);
/* Register all interfaces with droute and set up application accessible db */
spi_initialize_tree (treepath);
spi_initialize_accessible (accpath);
spi_initialize_application (accpath);
- spi_initialize_action(accpath);
+ spi_initialize_action (accpath);
spi_initialize_collection (accpath);
spi_initialize_component (accpath);
spi_initialize_document (accpath);
/*---------------------------------------------------------------------------*/
int
-gtk_module_init (gint *argc, gchar **argv[])
+gtk_module_init (gint * argc, gchar ** argv[])
{
const gchar *load_bridge = g_getenv ("NO_AT_BRIDGE");
if (!load_bridge || g_ascii_strtod (load_bridge, NULL) == 0)
{
- return adaptor_init (argc, argv);
+ return adaptor_init (argc, argv);
}
return 0;
}
if (g_getenv ("AT_SPI_DEBUG"))
{
- g_print("Atk Accessibility bridge initialized\n");
+ g_print ("Atk Accessibility bridge initialized\n");
}
}
}
spi_atk_deregister_event_listeners ();
exit_func ();
}
+
/*END------------------------------------------------------------------------*/
typedef struct _SpiAppData SpiAppData;
struct _SpiAppData
{
- AtkObject *root;
+ AtkObject *root;
- DBusConnection *bus;
- DRouteContext *droute;
+ DBusConnection *bus;
+ DRouteContext *droute;
};
extern SpiAppData *atk_adaptor_app_data;
for (i = 0; set[i] != BITARRAY_SEQ_TERM; i++)
{
if (!atk_state_set_contains_state (chs, set[i]))
- {
- ret = FALSE;
- break;
- }
+ {
+ ret = FALSE;
+ break;
+ }
}
g_object_unref (chs);
for (i = 0; set[i] != BITARRAY_SEQ_TERM; i++)
{
if (!atk_state_set_contains_state (chs, set[i]))
- {
- ret = TRUE;
- break;
- }
+ {
+ ret = TRUE;
+ break;
+ }
}
g_object_unref (chs);
for (i = 0; set[i] != BITARRAY_SEQ_TERM; i++)
{
if (atk_state_set_contains_state (chs, set[i]))
- {
- ret = FALSE;
- break;
- }
+ {
+ ret = FALSE;
+ break;
+ }
}
g_object_unref (chs);
{
case Accessibility_Collection_MATCH_ALL:
if (match_states_all_p (child, mrp->states))
- return TRUE;
+ return TRUE;
break;
case Accessibility_Collection_MATCH_ANY:
if (match_states_any_p (child, mrp->states))
- return TRUE;
+ return TRUE;
break;
case Accessibility_Collection_MATCH_NONE:
if (match_states_none_p (child, mrp->states))
- return TRUE;
+ return TRUE;
break;
default:
{
case Accessibility_Collection_MATCH_ALL:
if (match_roles_all_p (child, mrp->roles))
- return TRUE;
+ return TRUE;
break;
case Accessibility_Collection_MATCH_ANY:
if (match_roles_any_p (child, mrp->roles))
- return TRUE;
+ return TRUE;
break;
case Accessibility_Collection_MATCH_NONE:
if (match_roles_none_p (child, mrp->roles))
- return TRUE;
+ return TRUE;
break;
default:
for (i = 0; ifaces[i]; i++)
if (!child_interface_p (obj, ifaces[i]))
{
- return FALSE;
+ return FALSE;
}
return TRUE;
}
for (i = 0; ifaces[i]; i++)
if (child_interface_p (obj, ifaces[i]))
{
- return TRUE;
+ return TRUE;
}
return FALSE;
}
case Accessibility_Collection_MATCH_ALL:
if (match_interfaces_all_p (child, mrp->ifaces))
- return TRUE;
+ return TRUE;
break;
case Accessibility_Collection_MATCH_ANY:
if (match_interfaces_any_p (child, mrp->ifaces))
- return TRUE;
+ return TRUE;
break;
case Accessibility_Collection_MATCH_NONE:
if (match_interfaces_none_p (child, mrp->ifaces))
- return TRUE;
+ return TRUE;
break;
default:
{
AtkAttribute *attr = g_slist_nth_data (attributes, i);
for (k = 0; k < oa_length; k++)
- {
- AtkAttribute *oa_attr = g_slist_nth_data (attributes, i);
- if (!g_ascii_strcasecmp (oa_attr->name, attr->name) &&
- !g_ascii_strcasecmp (oa_attr->value, attr->value))
- {
- flag = TRUE;
- break;
- }
- else
- flag = FALSE;
- }
+ {
+ AtkAttribute *oa_attr = g_slist_nth_data (attributes, i);
+ if (!g_ascii_strcasecmp (oa_attr->name, attr->name) &&
+ !g_ascii_strcasecmp (oa_attr->value, attr->value))
+ {
+ flag = TRUE;
+ break;
+ }
+ else
+ flag = FALSE;
+ }
if (!flag)
- {
- atk_attribute_set_free (oa);
- return FALSE;
- }
+ {
+ atk_attribute_set_free (oa);
+ return FALSE;
+ }
}
atk_attribute_set_free (oa);
return TRUE;
{
AtkAttribute *attr = g_slist_nth_data (attributes, i);
for (k = 0; k < oa_length; k++)
- {
- AtkAttribute *oa_attr = g_slist_nth_data (attributes, i);
- if (!g_ascii_strcasecmp (oa_attr->name, attr->name) &&
- !g_ascii_strcasecmp (oa_attr->value, attr->value))
- {
- atk_attribute_set_free (oa);
- return TRUE;
- }
- }
+ {
+ AtkAttribute *oa_attr = g_slist_nth_data (attributes, i);
+ if (!g_ascii_strcasecmp (oa_attr->name, attr->name) &&
+ !g_ascii_strcasecmp (oa_attr->value, attr->value))
+ {
+ atk_attribute_set_free (oa);
+ return TRUE;
+ }
+ }
}
atk_attribute_set_free (oa);
return FALSE;
{
AtkAttribute *attr = g_slist_nth_data (attributes, i);
for (k = 0; k < oa_length; k++)
- {
- AtkAttribute *oa_attr = g_slist_nth_data (attributes, i);
- if (!g_ascii_strcasecmp (oa_attr->name, attr->name) &&
- !g_ascii_strcasecmp (oa_attr->value, attr->value))
- {
- atk_attribute_set_free (oa);
- return FALSE;
- }
- }
+ {
+ AtkAttribute *oa_attr = g_slist_nth_data (attributes, i);
+ if (!g_ascii_strcasecmp (oa_attr->name, attr->name) &&
+ !g_ascii_strcasecmp (oa_attr->value, attr->value))
+ {
+ atk_attribute_set_free (oa);
+ return FALSE;
+ }
+ }
}
atk_attribute_set_free (oa);
return TRUE;
case Accessibility_Collection_MATCH_ALL:
if (match_attributes_all_p (child, mrp->attributes))
- return TRUE;
+ return TRUE;
break;
case Accessibility_Collection_MATCH_ANY:
if (match_attributes_any_p (child, mrp->attributes))
- return TRUE;
+ return TRUE;
break;
case Accessibility_Collection_MATCH_NONE:
if (match_attributes_none_p (child, mrp->attributes))
- return TRUE;
+ return TRUE;
break;
default:
static int
sort_order_canonical (MatchRulePrivate * mrp, GList * ls,
- gint kount, gint max,
- AtkObject * obj, glong index, gboolean flag,
- AtkObject * pobj, gboolean recurse, gboolean traverse)
+ gint kount, gint max,
+ AtkObject * obj, glong index, gboolean flag,
+ AtkObject * pobj, gboolean recurse, gboolean traverse)
{
gint i = index;
glong acount = atk_object_get_n_accessible_children (obj);
g_object_unref (child);
if (prev && child == pobj)
- {
- return kount;
- }
+ {
+ return kount;
+ }
if (flag && match_interfaces_lookup (child, mrp)
- && match_states_lookup (child, mrp)
- && match_roles_lookup (child, mrp)
- && match_attributes_lookup (child, mrp))
- {
+ && match_states_lookup (child, mrp)
+ && match_roles_lookup (child, mrp)
+ && match_attributes_lookup (child, mrp))
+ {
- ls = g_list_append (ls, child);
- kount++;
- }
+ ls = g_list_append (ls, child);
+ kount++;
+ }
if (!flag)
- flag = TRUE;
+ flag = TRUE;
if (recurse && traverse_p (child, traverse))
- kount = sort_order_canonical (mrp, ls, kount,
- max, child, 0, TRUE,
- pobj, recurse, traverse);
+ kount = sort_order_canonical (mrp, ls, kount,
+ max, child, 0, TRUE,
+ pobj, recurse, traverse);
}
return kount;
}
static int
sort_order_rev_canonical (MatchRulePrivate * mrp, GList * ls,
- gint kount, gint max,
- AtkObject * obj, gboolean flag, AtkObject * pobj)
+ gint kount, gint max,
+ AtkObject * obj, gboolean flag, AtkObject * pobj)
{
AtkObject *nextobj;
AtkObject *parent;
/* Now, drill down the right side to the last descendant */
while (atk_object_get_n_accessible_children (nextobj) > 0)
- {
- nextobj = atk_object_ref_accessible_child (nextobj,
- atk_object_get_n_accessible_children
- (nextobj) - 1);
- g_object_unref (nextobj);
- }
+ {
+ nextobj = atk_object_ref_accessible_child (nextobj,
+ atk_object_get_n_accessible_children
+ (nextobj) - 1);
+ g_object_unref (nextobj);
+ }
/* recurse with the last descendant */
kount = sort_order_rev_canonical (mrp, ls, kount, max,
- nextobj, TRUE, pobj);
+ nextobj, TRUE, pobj);
}
else
{
/* no more siblings so next node must be the parent */
kount = sort_order_rev_canonical (mrp, ls, kount, max,
- parent, TRUE, pobj);
+ parent, TRUE, pobj);
}
return kount;
static int
query_exec (MatchRulePrivate * mrp, Accessibility_Collection_SortOrder sortby,
- GList * ls, gint kount, gint max,
- AtkObject * obj, glong index,
- gboolean flag,
- AtkObject * pobj, gboolean recurse, gboolean traverse)
+ GList * ls, gint kount, gint max,
+ AtkObject * obj, glong index,
+ gboolean flag,
+ AtkObject * pobj, gboolean recurse, gboolean traverse)
{
switch (sortby)
{
case Accessibility_Collection_SORT_ORDER_CANONICAL:
kount = sort_order_canonical (mrp, ls, 0, max, obj, index, flag,
- pobj, recurse, traverse);
+ pobj, recurse, traverse);
break;
case Accessibility_Collection_SORT_ORDER_REVERSE_CANONICAL:
kount = sort_order_canonical (mrp, ls, 0, max, obj, index, flag,
- pobj, recurse, traverse);
+ pobj, recurse, traverse);
break;
default:
kount = 0;
for (i = 0; i < array_count; i++)
{
for (j = 0; j < 32; j++)
- {
- if (array[i] & (1 << j))
- {
- if (out_count == out_size - 2)
- {
- out_size <<= 1;
- out = (int *) g_realloc (out, out_size * sizeof (int));
- if (!out)
- return FALSE;
- }
- out[out_count++] = i * 32 + j;
- }
- }
+ {
+ if (array[i] & (1 << j))
+ {
+ if (out_count == out_size - 2)
+ {
+ out_size <<= 1;
+ out = (int *) g_realloc (out, out_size * sizeof (int));
+ if (!out)
+ return FALSE;
+ }
+ out[out_count++] = i * 32 + j;
+ }
+ }
}
out[out_count] = BITARRAY_SEQ_TERM;
*ret = out;
dbus_message_iter_get_basic (&mrc, &str);
attributes = g_strsplit (str, "\n", -1);
for (pp = attributes; *pp; pp++)
- {
- str = *pp;
- attr = g_new (AtkAttribute, 1);
- if (attr)
- {
- int len = strcspn (str, ":");
- attr->name = g_strndup (str, len);
- if (str[len] == ':')
- {
- len++;
- if (str[len] == ' ')
- len++;
- attr->value = g_strdup (str + len);
- }
- else
- attr->value = NULL;
- mrp->attributes = g_slist_prepend (mrp->attributes, attr);
- }
- }
+ {
+ str = *pp;
+ attr = g_new (AtkAttribute, 1);
+ if (attr)
+ {
+ int len = strcspn (str, ":");
+ attr->name = g_strndup (str, len);
+ if (str[len] == ':')
+ {
+ len++;
+ if (str[len] == ' ')
+ len++;
+ attr->value = g_strdup (str + len);
+ }
+ else
+ attr->value = NULL;
+ mrp->attributes = g_slist_prepend (mrp->attributes, attr);
+ }
+ }
g_strfreev (attributes);
}
else
{
dbus_message_iter_recurse (&mrc, &arrayc);
while (dbus_message_iter_get_arg_type (&arrayc) != DBUS_TYPE_INVALID)
- {
- dbus_message_iter_get_basic (&arrayc, &str);
- // TODO: remove this print
- g_print ("Got attribute: %s\n", str);
- attr = g_new (AtkAttribute, 1);
- if (attr)
- {
- int len = strcspn (str, ":");
- attr->name = g_strndup (str, len);
- if (str[len] == ':')
- {
- len++;
- if (str[len] == ' ')
- len++;
- attr->value = g_strdup (str + len);
- }
- else
- attr->value = NULL;
- mrp->attributes = g_slist_prepend (mrp->attributes, attr);
- }
- dbus_message_iter_next (&arrayc);
- }
+ {
+ dbus_message_iter_get_basic (&arrayc, &str);
+ // TODO: remove this print
+ g_print ("Got attribute: %s\n", str);
+ attr = g_new (AtkAttribute, 1);
+ if (attr)
+ {
+ int len = strcspn (str, ":");
+ attr->name = g_strndup (str, len);
+ if (str[len] == ':')
+ {
+ len++;
+ if (str[len] == ' ')
+ len++;
+ attr->value = g_strdup (str + len);
+ }
+ else
+ attr->value = NULL;
+ mrp->attributes = g_slist_prepend (mrp->attributes, attr);
+ }
+ dbus_message_iter_next (&arrayc);
+ }
}
dbus_message_iter_next (&mrc);
dbus_message_iter_get_basic (&mrc, &matchType);
for (item = ls; item; item = g_list_next (item))
{
spi_dbus_append_name_and_path (message, &iter_array,
- ATK_OBJECT (item->data), TRUE, FALSE);
+ ATK_OBJECT (item->data), TRUE, FALSE);
}
if (!dbus_message_iter_close_container (&iter, &iter_array))
goto oom;
static DBusMessage *
GetMatchesFrom (DBusMessage * message,
- AtkObject * current_object,
- MatchRulePrivate * mrp,
- const Accessibility_Collection_SortOrder sortby,
- const dbus_bool_t isrestrict,
- dbus_int32_t count, const dbus_bool_t traverse)
+ AtkObject * current_object,
+ MatchRulePrivate * mrp,
+ const Accessibility_Collection_SortOrder sortby,
+ const dbus_bool_t isrestrict,
+ dbus_int32_t count, const dbus_bool_t traverse)
{
GList *ls = NULL;
AtkObject *parent;
{
parent = atk_object_get_parent (current_object);
kount = query_exec (mrp, sortby, ls, 0, count, parent, index,
- FALSE, NULL, TRUE, traverse);
+ FALSE, NULL, TRUE, traverse);
}
else
kount = query_exec (mrp, sortby, ls, 0, count,
- current_object, 0, FALSE, NULL, TRUE, traverse);
+ current_object, 0, FALSE, NULL, TRUE, traverse);
ls = g_list_remove (ls, ls->data);
static int
inorder (AtkObject * collection, MatchRulePrivate * mrp,
- GList * ls, gint kount, gint max,
- AtkObject * obj,
- gboolean flag, AtkObject * pobj, dbus_bool_t traverse)
+ GList * ls, gint kount, gint max,
+ AtkObject * obj,
+ gboolean flag, AtkObject * pobj, dbus_bool_t traverse)
{
int i = 0;
/* First, look through the children recursively. */
kount = sort_order_canonical (mrp, ls, kount, max, obj, 0, TRUE,
- NULL, TRUE, TRUE);
+ NULL, TRUE, TRUE);
/* Next, we look through the right subtree */
while ((max == 0 || kount < max) && obj != collection)
AtkObject *parent = atk_object_get_parent (obj);
i = atk_object_get_index_in_parent (obj);
kount = sort_order_canonical (mrp, ls, kount, max, parent,
- i + 1, TRUE, FALSE, TRUE, TRUE);
+ i + 1, TRUE, FALSE, TRUE, TRUE);
obj = parent;
}
if (kount < max)
{
kount = sort_order_canonical (mrp, ls, kount, max,
- obj, i + 1, TRUE, FALSE, TRUE, TRUE);
+ obj, i + 1, TRUE, FALSE, TRUE, TRUE);
}
return kount;
static DBusMessage *
GetMatchesInOrder (DBusMessage * message,
- AtkObject * current_object,
- MatchRulePrivate * mrp,
- const Accessibility_Collection_SortOrder sortby,
- const dbus_bool_t recurse,
- dbus_int32_t count, const dbus_bool_t traverse)
+ AtkObject * current_object,
+ MatchRulePrivate * mrp,
+ const Accessibility_Collection_SortOrder sortby,
+ const dbus_bool_t recurse,
+ dbus_int32_t count, const dbus_bool_t traverse)
{
GList *ls = NULL;
AtkObject *obj;
obj = atk_dbus_path_to_object (dbus_message_get_path (message));
kount = inorder (obj, mrp, ls, 0, count,
- current_object, TRUE, NULL, traverse);
+ current_object, TRUE, NULL, traverse);
ls = g_list_remove (ls, ls->data);
static DBusMessage *
GetMatchesInBackOrder (DBusMessage * message,
- AtkObject * current_object,
- MatchRulePrivate * mrp,
- const Accessibility_Collection_SortOrder sortby,
- dbus_int32_t count)
+ AtkObject * current_object,
+ MatchRulePrivate * mrp,
+ const Accessibility_Collection_SortOrder sortby,
+ dbus_int32_t count)
{
GList *ls = NULL;
AtkObject *collection;
collection = atk_dbus_path_to_object (dbus_message_get_path (message));
kount = sort_order_rev_canonical (mrp, ls, 0, count, current_object,
- FALSE, collection);
+ FALSE, collection);
ls = g_list_remove (ls, ls->data);
static DBusMessage *
GetMatchesTo (DBusMessage * message,
- AtkObject * current_object,
- MatchRulePrivate * mrp,
- const Accessibility_Collection_SortOrder sortby,
- const dbus_bool_t recurse,
- const dbus_bool_t isrestrict,
- dbus_int32_t count, const dbus_bool_t traverse)
+ AtkObject * current_object,
+ MatchRulePrivate * mrp,
+ const Accessibility_Collection_SortOrder sortby,
+ const dbus_bool_t recurse,
+ const dbus_bool_t isrestrict,
+ dbus_int32_t count, const dbus_bool_t traverse)
{
GList *ls = NULL;
AtkObject *obj;
{
obj = atk_object_get_parent (current_object);
kount = query_exec (mrp, sortby, ls, 0, count,
- obj, 0, TRUE, current_object, TRUE, traverse);
+ obj, 0, TRUE, current_object, TRUE, traverse);
}
else
{
obj = atk_dbus_path_to_object (dbus_message_get_path (message));
kount = query_exec (mrp, sortby, ls, 0, count,
- obj, 0, TRUE, current_object, TRUE, traverse);
+ obj, 0, TRUE, current_object, TRUE, traverse);
}
static DBusMessage *
impl_GetMatchesFrom (DBusConnection * bus, DBusMessage * message,
- void *user_data)
+ void *user_data)
{
char *current_object_path = NULL;
AtkObject *current_object;
{
case Accessibility_Collection_TREE_RESTRICT_CHILDREN:
return GetMatchesFrom (message, current_object,
- &rule, sortby, TRUE, count, traverse);
+ &rule, sortby, TRUE, count, traverse);
break;
case Accessibility_Collection_TREE_RESTRICT_SIBLING:
return GetMatchesFrom (message, current_object,
- &rule, sortby, FALSE, count, traverse);
+ &rule, sortby, FALSE, count, traverse);
break;
case Accessibility_Collection_TREE_INORDER:
return GetMatchesInOrder (message, current_object,
- &rule, sortby, TRUE, count, traverse);
+ &rule, sortby, TRUE, count, traverse);
break;
default:
return NULL;
static DBusMessage *
impl_GetMatchesTo (DBusConnection * bus, DBusMessage * message,
- void *user_data)
+ void *user_data)
{
char *current_object_path = NULL;
AtkObject *current_object;
{
case Accessibility_Collection_TREE_RESTRICT_CHILDREN:
return GetMatchesTo (message, current_object,
- &rule, sortby, recurse, TRUE, count, traverse);
+ &rule, sortby, recurse, TRUE, count, traverse);
break;
case Accessibility_Collection_TREE_RESTRICT_SIBLING:
return GetMatchesTo (message, current_object,
- &rule, sortby, recurse, FALSE, count, traverse);
+ &rule, sortby, recurse, FALSE, count, traverse);
break;
case Accessibility_Collection_TREE_INORDER:
return GetMatchesInBackOrder (message, current_object,
- &rule, sortby, count);
+ &rule, sortby, count);
break;
default:
return NULL;
dbus_message_iter_next (&iter);
ls = g_list_prepend (ls, obj);
count = query_exec (&rule, sortby, ls, 0, count,
- obj, 0, TRUE, NULL, TRUE, traverse);
+ obj, 0, TRUE, NULL, TRUE, traverse);
ls = g_list_remove (ls, ls->data);
if (sortby == Accessibility_Collection_SORT_ORDER_REVERSE_CANONICAL)
spi_initialize_collection (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_COLLECTION, methods, NULL);
+ SPI_DBUS_INTERFACE_COLLECTION, methods, NULL);
};
reply = dbus_message_new_method_return (message);
if (reply)
{
- dbus_message_append_args (reply, DBUS_TYPE_INT16, &rv, DBUS_TYPE_INVALID);
+ dbus_message_append_args (reply, DBUS_TYPE_INT16, &rv,
+ DBUS_TYPE_INVALID);
}
return reply;
}
};
void
-spi_initialize_component (DRoutePath *path)
+spi_initialize_component (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_COMPONENT,
- methods,
- NULL);
+ SPI_DBUS_INTERFACE_COMPONENT, methods, NULL);
};
#include "accessible-marshaller.h"
static DBusMessage *
-impl_GetLocale (DBusConnection *bus,
- DBusMessage *message,
- void *user_data)
+impl_GetLocale (DBusConnection * bus, DBusMessage * message, void *user_data)
{
AtkDocument *document = (AtkDocument *) user_data;
const gchar *lc;
};
void
-spi_initialize_document (DRoutePath *path)
+spi_initialize_document (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_DOCUMENT,
- methods,
- NULL);
+ SPI_DBUS_INTERFACE_DOCUMENT, methods, NULL);
};
};
void
-spi_initialize_editabletext (DRoutePath *path)
+spi_initialize_editabletext (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_EDITABLE_TEXT,
- methods,
- NULL);
+ SPI_DBUS_INTERFACE_EDITABLE_TEXT, methods, NULL);
};
/*---------------------------------------------------------------------------*/
static void
-set_reply (DBusPendingCall *pending, void *user_data)
+set_reply (DBusPendingCall * pending, void *user_data)
{
- void **replyptr = (void **)user_data;
+ void **replyptr = (void **) user_data;
- *replyptr = dbus_pending_call_steal_reply (pending);
+ *replyptr = dbus_pending_call_steal_reply (pending);
}
static DBusMessage *
-send_and_allow_reentry (DBusConnection *bus, DBusMessage *message)
+send_and_allow_reentry (DBusConnection * bus, DBusMessage * message)
{
- DBusPendingCall *pending;
- DBusMessage *reply = NULL;
+ DBusPendingCall *pending;
+ DBusMessage *reply = NULL;
- if (!dbus_connection_send_with_reply (bus, message, &pending, -1))
+ if (!dbus_connection_send_with_reply (bus, message, &pending, -1))
{
- return NULL;
+ return NULL;
}
- dbus_pending_call_set_notify (pending, set_reply, (void *)&reply, NULL);
- while (!reply)
+ dbus_pending_call_set_notify (pending, set_reply, (void *) &reply, NULL);
+ while (!reply)
{
- if (!dbus_connection_read_write_dispatch (bus, -1)) return NULL;
+ if (!dbus_connection_read_write_dispatch (bus, -1))
+ return NULL;
}
- return reply;
+ return reply;
}
static gboolean
-Accessibility_DeviceEventController_NotifyListenersSync(const Accessibility_DeviceEvent *key_event)
+Accessibility_DeviceEventController_NotifyListenersSync (const
+ Accessibility_DeviceEvent
+ * key_event)
{
DBusMessage *message;
DBusError error;
dbus_bool_t consumed = FALSE;
message =
- dbus_message_new_method_call(SPI_DBUS_NAME_REGISTRY,
- SPI_DBUS_PATH_DEC,
- SPI_DBUS_INTERFACE_DEC,
- "NotifyListenersSync");
-
- dbus_error_init(&error);
- if (spi_dbus_marshal_deviceEvent(message, key_event))
- {
- DBusMessage *reply = send_and_allow_reentry (atk_adaptor_app_data->bus, message);
- if (reply)
+ dbus_message_new_method_call (SPI_DBUS_NAME_REGISTRY,
+ SPI_DBUS_PATH_DEC,
+ SPI_DBUS_INTERFACE_DEC,
+ "NotifyListenersSync");
+
+ dbus_error_init (&error);
+ if (spi_dbus_marshal_deviceEvent (message, key_event))
{
- DBusError error;
- dbus_error_init(&error);
- dbus_message_get_args(reply, &error, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID);
- dbus_message_unref(reply);
+ DBusMessage *reply =
+ send_and_allow_reentry (atk_adaptor_app_data->bus, message);
+ if (reply)
+ {
+ DBusError error;
+ dbus_error_init (&error);
+ dbus_message_get_args (reply, &error, DBUS_TYPE_BOOLEAN, &consumed,
+ DBUS_TYPE_INVALID);
+ dbus_message_unref (reply);
+ }
}
- }
- dbus_message_unref(message);
+ dbus_message_unref (message);
return consumed;
}
static void
-spi_init_keystroke_from_atk_key_event (Accessibility_DeviceEvent *keystroke,
- AtkKeyEventStruct *event)
+spi_init_keystroke_from_atk_key_event (Accessibility_DeviceEvent * keystroke,
+ AtkKeyEventStruct * event)
{
- keystroke->id = (dbus_int32_t) event->keyval;
- keystroke->hw_code = (dbus_int16_t) event->keycode;
+ keystroke->id = (dbus_int32_t) event->keyval;
+ keystroke->hw_code = (dbus_int16_t) event->keycode;
keystroke->timestamp = (dbus_uint32_t) event->timestamp;
keystroke->modifiers = (dbus_uint16_t) (event->state & 0xFFFF);
if (event->string)
keystroke->type = 0;
break;
}
-#if 0
- g_print ("key_event type %d; val=%d code=%d modifiers=%x name=%s is_text=%d, time=%lx\n",
- (int) keystroke->type, (int) keystroke->id, (int) keystroke->hw_code,
- (int) keystroke->modifiers,
- keystroke->event_string, (int) keystroke->is_text, (unsigned long) keystroke->timestamp);
+#if 0
+ g_print
+ ("key_event type %d; val=%d code=%d modifiers=%x name=%s is_text=%d, time=%lx\n",
+ (int) keystroke->type, (int) keystroke->id, (int) keystroke->hw_code,
+ (int) keystroke->modifiers, keystroke->event_string,
+ (int) keystroke->is_text, (unsigned long) keystroke->timestamp);
#endif
}
static gint
-spi_atk_bridge_key_listener (AtkKeyEventStruct *event, gpointer data)
+spi_atk_bridge_key_listener (AtkKeyEventStruct * event, gpointer data)
{
- gboolean result;
+ gboolean result;
Accessibility_DeviceEvent key_event;
spi_init_keystroke_from_atk_key_event (&key_event, event);
- result = Accessibility_DeviceEventController_NotifyListenersSync (&key_event);
+ result =
+ Accessibility_DeviceEventController_NotifyListenersSync (&key_event);
- if (key_event.event_string) g_free (key_event.event_string);
+ if (key_event.event_string)
+ g_free (key_event.event_string);
return result;
}
*/
static gchar *
-DBusSignalName (const gchar *s)
+DBusSignalName (const gchar * s)
{
gchar *ret = g_strdup (s);
gchar *t;
if (!ret)
return NULL;
- ret [0] = toupper (ret [0]);
+ ret[0] = toupper (ret[0]);
while ((t = strchr (ret, '-')) != NULL)
- {
- memmove (t, t + 1, strlen (t));
- *t = toupper (*t);
- }
+ {
+ memmove (t, t + 1, strlen (t));
+ *t = toupper (*t);
+ }
return ret;
}
-static void
-emit(AtkObject *accessible,
- const char *klass,
- const char *major,
- const char *minor,
- dbus_int32_t detail1,
- dbus_int32_t detail2,
- const char *type,
- const void *val)
+static void
+emit (AtkObject * accessible,
+ const char *klass,
+ const char *major,
+ const char *minor,
+ dbus_int32_t detail1,
+ dbus_int32_t detail2, const char *type, const void *val)
{
gchar *path;
gchar *cname;
* objects that have not yet been added to the accessible tree.
*/
if (path == NULL)
- {
+ {
#ifdef SPI_ATK_DEBUG
g_debug ("AT-SPI: Event recieved from non-registered object");
#endif
return;
- }
+ }
cname = DBusSignalName (major);
- spi_dbus_emit_signal (atk_adaptor_app_data->bus, path, klass, cname, minor, detail1, detail2, type, val);
+ spi_dbus_emit_signal (atk_adaptor_app_data->bus, path, klass, cname, minor,
+ detail1, detail2, type, val);
g_free (cname);
- g_free(path);
+ g_free (path);
}
/*---------------------------------------------------------------------------*/
* 'any_data' variant of the event.
*/
static void
-emit_rect(AtkObject *accessible,
- const char *klass,
- const char *major,
- const char *minor,
- AtkRectangle *rect)
+emit_rect (AtkObject * accessible,
+ const char *klass,
+ const char *major, const char *minor, AtkRectangle * rect)
{
DBusMessage *sig;
DBusMessageIter iter, variant, sub;
* objects that have not yet been added to the accessible tree.
*/
if (path == NULL)
- return;
+ return;
- if (!klass) klass = "";
- if (!major) major = "";
- if (!minor) minor = "";
+ if (!klass)
+ klass = "";
+ if (!major)
+ major = "";
+ if (!minor)
+ minor = "";
/*
* This is very annoying, but as '-' isn't a legal signal
*/
cname = DBusSignalName (major);
- sig = dbus_message_new_signal(path, klass, cname);
- g_free(path);
- g_free(cname);
+ sig = dbus_message_new_signal (path, klass, cname);
+ g_free (path);
+ g_free (cname);
dbus_message_iter_init_append (sig, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &minor);
+ dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &minor);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &dummy);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &dummy);
- dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "(iiii)", &variant);
- dbus_message_iter_open_container (&variant, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->x));
- dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->y));
- dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->width));
- dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->height));
- dbus_message_iter_close_container (&variant, &sub);
+ dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "(iiii)",
+ &variant);
+ dbus_message_iter_open_container (&variant, DBUS_TYPE_STRUCT, NULL, &sub);
+ dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->x));
+ dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->y));
+ dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->width));
+ dbus_message_iter_append_basic (&sub, DBUS_TYPE_INT32, &(rect->height));
+ dbus_message_iter_close_container (&variant, &sub);
dbus_message_iter_close_container (&iter, &variant);
- dbus_connection_send(atk_adaptor_app_data->bus, sig, NULL);
+ dbus_connection_send (atk_adaptor_app_data->bus, sig, NULL);
dbus_message_unref (sig);
}
* as the AT-SPI event, 'focus:'
*/
static void
-focus_tracker (AtkObject *accessible)
+focus_tracker (AtkObject * accessible)
{
- emit(accessible, ITF_EVENT_FOCUS, "focus", "", 0, 0, DBUS_TYPE_INT32_AS_STRING, 0);
+ emit (accessible, ITF_EVENT_FOCUS, "focus", "", 0, 0,
+ DBUS_TYPE_INT32_AS_STRING, 0);
}
/*---------------------------------------------------------------------------*/
* The property-name is part of the ATK property-change signal.
*/
static gboolean
-property_event_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+property_event_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
AtkPropertyValues *values;
gint i;
accessible = g_value_get_object (¶m_values[0]);
- values = (AtkPropertyValues*) g_value_get_pointer (¶m_values[1]);
+ values = (AtkPropertyValues *) g_value_get_pointer (¶m_values[1]);
pname = values[0].property_name;
if (strcmp (pname, "accessible-name") == 0 ||
strcmp (pname, "accessible-description") == 0 ||
strcmp (pname, "accessible-role") == 0 ||
strcmp (pname, "accessible-parent") == 0)
- {
+ {
return TRUE;
- }
+ }
/* TODO Could improve this control statement by matching
* on only the end of the signal names,
*/
if (strcmp (pname, "accessible-table-summary") == 0)
{
- otemp = atk_table_get_summary(ATK_TABLE (accessible));
+ otemp = atk_table_get_summary (ATK_TABLE (accessible));
stemp = atk_dbus_object_to_path (otemp, FALSE);
if (stemp != NULL)
- emit(accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0, DBUS_TYPE_OBJECT_PATH_AS_STRING, stemp);
+ emit (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
+ DBUS_TYPE_OBJECT_PATH_AS_STRING, stemp);
}
else if (strcmp (pname, "accessible-table-column-header") == 0)
{
i = g_value_get_int (&(values->new_value));
- otemp = atk_table_get_column_header(ATK_TABLE (accessible), i);
+ otemp = atk_table_get_column_header (ATK_TABLE (accessible), i);
stemp = atk_dbus_object_to_path (otemp, FALSE);
if (stemp != NULL)
- emit(accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0, DBUS_TYPE_OBJECT_PATH_AS_STRING, stemp);
+ emit (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
+ DBUS_TYPE_OBJECT_PATH_AS_STRING, stemp);
}
else if (strcmp (pname, "accessible-table-row-header") == 0)
{
i = g_value_get_int (&(values->new_value));
- otemp = atk_table_get_row_header(ATK_TABLE (accessible), i);
+ otemp = atk_table_get_row_header (ATK_TABLE (accessible), i);
stemp = atk_dbus_object_to_path (otemp, FALSE);
if (stemp != NULL)
- emit(accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0, DBUS_TYPE_OBJECT_PATH_AS_STRING, stemp);
+ emit (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
+ DBUS_TYPE_OBJECT_PATH_AS_STRING, stemp);
}
else if (strcmp (pname, "accessible-table-row-description") == 0)
{
i = g_value_get_int (&(values->new_value));
- stemp = atk_table_get_row_description(ATK_TABLE (accessible), i);
- emit(accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0, DBUS_TYPE_STRING_AS_STRING, stemp);
+ stemp = atk_table_get_row_description (ATK_TABLE (accessible), i);
+ emit (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
+ DBUS_TYPE_STRING_AS_STRING, stemp);
}
else if (strcmp (pname, "accessible-table-column-description") == 0)
{
i = g_value_get_int (&(values->new_value));
- stemp = atk_table_get_column_description(ATK_TABLE (accessible), i);
- emit(accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0, DBUS_TYPE_STRING_AS_STRING, stemp);
+ stemp = atk_table_get_column_description (ATK_TABLE (accessible), i);
+ emit (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
+ DBUS_TYPE_STRING_AS_STRING, stemp);
}
else if (strcmp (pname, "accessible-table-caption-object") == 0)
{
- otemp = atk_table_get_caption(ATK_TABLE(accessible));
- stemp = atk_object_get_name(otemp);
- emit(accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0, DBUS_TYPE_STRING_AS_STRING, stemp);
+ otemp = atk_table_get_caption (ATK_TABLE (accessible));
+ stemp = atk_object_get_name (otemp);
+ emit (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
+ DBUS_TYPE_STRING_AS_STRING, stemp);
}
else
{
- emit(accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0, DBUS_TYPE_INT32_AS_STRING, 0);
+ emit (accessible, ITF_EVENT_OBJECT, PCHANGE, pname, 0, 0,
+ DBUS_TYPE_INT32_AS_STRING, 0);
}
return TRUE;
}
* the param-name is part of the ATK state-change signal.
*/
static gboolean
-state_event_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+state_event_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
gchar *pname;
guint detail1;
- accessible = ATK_OBJECT(g_value_get_object (¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
pname = g_strdup (g_value_get_string (¶m_values[1]));
/* TODO - Possibly ignore a change to the 'defunct' state.
* This is because without reference counting defunct objects should be removed.
*/
detail1 = (g_value_get_boolean (¶m_values[2])) ? 1 : 0;
- emit(accessible, ITF_EVENT_OBJECT, STATE_CHANGED, pname, detail1, 0, DBUS_TYPE_INT32_AS_STRING, 0);
+ emit (accessible, ITF_EVENT_OBJECT, STATE_CHANGED, pname, detail1, 0,
+ DBUS_TYPE_INT32_AS_STRING, 0);
g_free (pname);
return TRUE;
}
* window:deactivate -> window:deactivate
*/
static gboolean
-window_event_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+window_event_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
GSignalQuery signal_query;
const gchar *name, *s;
-
+
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
- accessible = ATK_OBJECT(g_value_get_object(¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
s = atk_object_get_name (accessible);
- emit(accessible, ITF_EVENT_WINDOW, name, "", 0, 0, DBUS_TYPE_STRING_AS_STRING, s);
+ emit (accessible, ITF_EVENT_WINDOW, name, "", 0, 0,
+ DBUS_TYPE_STRING_AS_STRING, s);
return TRUE;
}
* Gtk:AtkDocument:reload -> document:reload
*/
static gboolean
-document_event_listener (GSignalInvocationHint *signal_hint,
+document_event_listener (GSignalInvocationHint * signal_hint,
guint n_param_values,
- const GValue *param_values,
- gpointer data)
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
GSignalQuery signal_query;
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
- accessible = ATK_OBJECT(g_value_get_object(¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
s = atk_object_get_name (accessible);
- emit(accessible, ITF_EVENT_DOCUMENT, name, "", 0, 0, DBUS_TYPE_STRING_AS_STRING, s);
+ emit (accessible, ITF_EVENT_DOCUMENT, name, "", 0, 0,
+ DBUS_TYPE_STRING_AS_STRING, s);
return TRUE;
}
* this to an AT-SPI event - "object:bounds-changed".
*/
static gboolean
-bounds_event_listener (GSignalInvocationHint *signal_hint,
+bounds_event_listener (GSignalInvocationHint * signal_hint,
guint n_param_values,
- const GValue *param_values,
- gpointer data)
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
AtkRectangle *atk_rect;
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
- accessible = ATK_OBJECT(g_value_get_object(¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
if (G_VALUE_HOLDS_BOXED (param_values + 1))
atk_rect = g_value_get_boxed (param_values + 1);
- emit_rect(accessible, ITF_EVENT_OBJECT, name, "", atk_rect);
+ emit_rect (accessible, ITF_EVENT_OBJECT, name, "", atk_rect);
return TRUE;
}
*
*/
static gboolean
-active_descendant_event_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+active_descendant_event_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
AtkObject *child;
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
- accessible = ATK_OBJECT(g_value_get_object(¶m_values[0]));
- child = ATK_OBJECT(g_value_get_pointer (¶m_values[1]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
+ child = ATK_OBJECT (g_value_get_pointer (¶m_values[1]));
g_return_val_if_fail (ATK_IS_OBJECT (child), TRUE);
minor = g_quark_to_string (signal_hint->detail);
return TRUE;
}
- emit(accessible, ITF_EVENT_OBJECT, name, "", detail1, 0, DBUS_TYPE_OBJECT_PATH_AS_STRING, s);
- g_free(s);
+ emit (accessible, ITF_EVENT_OBJECT, name, "", detail1, 0,
+ DBUS_TYPE_OBJECT_PATH_AS_STRING, s);
+ g_free (s);
return TRUE;
}
*
*/
static gboolean
-link_selected_event_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+link_selected_event_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
GSignalQuery signal_query;
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
- accessible = ATK_OBJECT(g_value_get_object(¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
minor = g_quark_to_string (signal_hint->detail);
if (G_VALUE_TYPE (¶m_values[1]) == G_TYPE_INT)
- detail1 = g_value_get_int (¶m_values[1]);
+ detail1 = g_value_get_int (¶m_values[1]);
- emit(accessible, ITF_EVENT_OBJECT, name, minor, detail1, 0, DBUS_TYPE_INT32_AS_STRING, 0);
+ emit (accessible, ITF_EVENT_OBJECT, name, minor, detail1, 0,
+ DBUS_TYPE_INT32_AS_STRING, 0);
return TRUE;
}
*
*/
static gboolean
-text_changed_event_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+text_changed_event_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
GSignalQuery signal_query;
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
- accessible = ATK_OBJECT(g_value_get_object(¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
minor = g_quark_to_string (signal_hint->detail);
if (G_VALUE_TYPE (¶m_values[1]) == G_TYPE_INT)
- detail1 = g_value_get_int (¶m_values[1]);
+ detail1 = g_value_get_int (¶m_values[1]);
if (G_VALUE_TYPE (¶m_values[2]) == G_TYPE_INT)
- detail2 = g_value_get_int (¶m_values[2]);
+ detail2 = g_value_get_int (¶m_values[2]);
- selected = atk_text_get_text (ATK_TEXT (accessible), detail1, detail1+detail2);
+ selected =
+ atk_text_get_text (ATK_TEXT (accessible), detail1, detail1 + detail2);
- emit(accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2, DBUS_TYPE_STRING_AS_STRING, selected);
+ emit (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
+ DBUS_TYPE_STRING_AS_STRING, selected);
return TRUE;
}
*
*/
static gboolean
-text_selection_changed_event_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+text_selection_changed_event_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values,
+ gpointer data)
{
AtkObject *accessible;
GSignalQuery signal_query;
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
- accessible = ATK_OBJECT(g_value_get_object(¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
minor = g_quark_to_string (signal_hint->detail);
if (G_VALUE_TYPE (¶m_values[1]) == G_TYPE_INT)
- detail1 = g_value_get_int (¶m_values[1]);
+ detail1 = g_value_get_int (¶m_values[1]);
if (G_VALUE_TYPE (¶m_values[2]) == G_TYPE_INT)
- detail2 = g_value_get_int (¶m_values[2]);
+ detail2 = g_value_get_int (¶m_values[2]);
- emit(accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2, DBUS_TYPE_STRING_AS_STRING, "");
+ emit (accessible, ITF_EVENT_OBJECT, name, minor, detail1, detail2,
+ DBUS_TYPE_STRING_AS_STRING, "");
return TRUE;
}
* any_data is NULL.
*/
static gboolean
-generic_event_listener (GSignalInvocationHint *signal_hint,
- guint n_param_values,
- const GValue *param_values,
- gpointer data)
+generic_event_listener (GSignalInvocationHint * signal_hint,
+ guint n_param_values,
+ const GValue * param_values, gpointer data)
{
AtkObject *accessible;
GSignalQuery signal_query;
g_signal_query (signal_hint->signal_id, &signal_query);
name = signal_query.signal_name;
- accessible = ATK_OBJECT(g_value_get_object(¶m_values[0]));
+ accessible = ATK_OBJECT (g_value_get_object (¶m_values[0]));
if (n_param_values > 1 && G_VALUE_TYPE (¶m_values[1]) == G_TYPE_INT)
- detail1 = g_value_get_int (¶m_values[1]);
+ detail1 = g_value_get_int (¶m_values[1]);
if (n_param_values > 2 && G_VALUE_TYPE (¶m_values[2]) == G_TYPE_INT)
- detail2 = g_value_get_int (¶m_values[2]);
+ detail2 = g_value_get_int (¶m_values[2]);
- emit(accessible, ITF_EVENT_OBJECT, name, "", detail1, detail2, DBUS_TYPE_INT32_AS_STRING, 0);
+ emit (accessible, ITF_EVENT_OBJECT, name, "", detail1, detail2,
+ DBUS_TYPE_INT32_AS_STRING, 0);
return TRUE;
}
* Kludge to make sure the Atk interface types are registered, otherwise
* the AtkText signal handlers below won't get registered
*/
- GObject *ao = g_object_new (ATK_TYPE_OBJECT, NULL);
+ GObject *ao = g_object_new (ATK_TYPE_OBJECT, NULL);
AtkObject *bo = atk_no_op_object_new (ao);
g_object_unref (G_OBJECT (bo));
atk_bridge_focus_tracker_id = atk_add_focus_tracker (focus_tracker);
- add_signal_listener (property_event_listener, "Gtk:AtkObject:property-change");
- add_signal_listener (window_event_listener, "window:create");
- add_signal_listener (window_event_listener, "window:destroy");
- add_signal_listener (window_event_listener, "window:minimize");
- add_signal_listener (window_event_listener, "window:maximize");
- add_signal_listener (window_event_listener, "window:restore");
- add_signal_listener (window_event_listener, "window:activate");
- add_signal_listener (window_event_listener, "window:deactivate");
- add_signal_listener (document_event_listener, "Gtk:AtkDocument:load-complete");
- add_signal_listener (document_event_listener, "Gtk:AtkDocument:reload");
- add_signal_listener (document_event_listener, "Gtk:AtkDocument:load-stopped");
+ add_signal_listener (property_event_listener,
+ "Gtk:AtkObject:property-change");
+ add_signal_listener (window_event_listener, "window:create");
+ add_signal_listener (window_event_listener, "window:destroy");
+ add_signal_listener (window_event_listener, "window:minimize");
+ add_signal_listener (window_event_listener, "window:maximize");
+ add_signal_listener (window_event_listener, "window:restore");
+ add_signal_listener (window_event_listener, "window:activate");
+ add_signal_listener (window_event_listener, "window:deactivate");
+ add_signal_listener (document_event_listener,
+ "Gtk:AtkDocument:load-complete");
+ add_signal_listener (document_event_listener, "Gtk:AtkDocument:reload");
+ add_signal_listener (document_event_listener,
+ "Gtk:AtkDocument:load-stopped");
/* TODO Fake this event on the client side */
- add_signal_listener (state_event_listener, "Gtk:AtkObject:state-change");
+ add_signal_listener (state_event_listener, "Gtk:AtkObject:state-change");
/* TODO */
- add_signal_listener (active_descendant_event_listener, "Gtk:AtkObject:active-descendant-changed");
- add_signal_listener (bounds_event_listener, "Gtk:AtkComponent:bounds-changed");
- add_signal_listener (text_selection_changed_event_listener, "Gtk:AtkText:text-selection-changed");
- add_signal_listener (text_changed_event_listener, "Gtk:AtkText:text-changed");
- add_signal_listener (link_selected_event_listener, "Gtk:AtkHypertext:link-selected");
- add_signal_listener (generic_event_listener, "Gtk:AtkObject:visible-data-changed");
- add_signal_listener (generic_event_listener, "Gtk:AtkSelection:selection-changed");
- add_signal_listener (generic_event_listener, "Gtk:AtkText:text-attributes-changed");
- add_signal_listener (generic_event_listener, "Gtk:AtkText:text-caret-moved");
- add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-inserted");
- add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-reordered");
- add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-deleted");
- add_signal_listener (generic_event_listener, "Gtk:AtkTable:column-inserted");
- add_signal_listener (generic_event_listener, "Gtk:AtkTable:column-reordered");
- add_signal_listener (generic_event_listener, "Gtk:AtkTable:column-deleted");
- add_signal_listener (generic_event_listener, "Gtk:AtkTable:model-changed");
+ add_signal_listener (active_descendant_event_listener,
+ "Gtk:AtkObject:active-descendant-changed");
+ add_signal_listener (bounds_event_listener,
+ "Gtk:AtkComponent:bounds-changed");
+ add_signal_listener (text_selection_changed_event_listener,
+ "Gtk:AtkText:text-selection-changed");
+ add_signal_listener (text_changed_event_listener,
+ "Gtk:AtkText:text-changed");
+ add_signal_listener (link_selected_event_listener,
+ "Gtk:AtkHypertext:link-selected");
+ add_signal_listener (generic_event_listener,
+ "Gtk:AtkObject:visible-data-changed");
+ add_signal_listener (generic_event_listener,
+ "Gtk:AtkSelection:selection-changed");
+ add_signal_listener (generic_event_listener,
+ "Gtk:AtkText:text-attributes-changed");
+ add_signal_listener (generic_event_listener,
+ "Gtk:AtkText:text-caret-moved");
+ add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-inserted");
+ add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-reordered");
+ add_signal_listener (generic_event_listener, "Gtk:AtkTable:row-deleted");
+ add_signal_listener (generic_event_listener,
+ "Gtk:AtkTable:column-inserted");
+ add_signal_listener (generic_event_listener,
+ "Gtk:AtkTable:column-reordered");
+ add_signal_listener (generic_event_listener, "Gtk:AtkTable:column-deleted");
+ add_signal_listener (generic_event_listener, "Gtk:AtkTable:model-changed");
/*
* May add the following listeners to implement preemptive key listening for GTK+
* atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-press-event");
* atk_add_global_event_listener (spi_atk_bridge_widgetkey_listener, "Gtk:GtkWidget:key-release-event");
*/
- atk_bridge_key_event_listener_id = atk_add_key_event_listener (spi_atk_bridge_key_listener, NULL);
+ atk_bridge_key_event_listener_id =
+ atk_add_key_event_listener (spi_atk_bridge_key_listener, NULL);
}
/*---------------------------------------------------------------------------*/
listener_ids = NULL;
if (atk_bridge_focus_tracker_id)
- atk_remove_focus_tracker (atk_bridge_focus_tracker_id);
-
+ atk_remove_focus_tracker (atk_bridge_focus_tracker_id);
+
for (i = 0; ids && i < ids->len; i++)
{
- atk_remove_global_event_listener (g_array_index (ids, guint, i));
+ atk_remove_global_event_listener (g_array_index (ids, guint, i));
}
-
+
if (atk_bridge_key_event_listener_id)
- atk_remove_key_event_listener (atk_bridge_key_event_listener_id);
+ atk_remove_key_event_listener (atk_bridge_key_event_listener_id);
}
/*---------------------------------------------------------------------------*/
AtkObject *child;
AtkStateSet *stateset;
const gchar *name;
-
+
child = atk_object_ref_accessible_child (root, i);
stateset = atk_object_ref_state_set (child);
-
+
name = atk_object_get_name (child);
if (atk_state_set_contains_state (stateset, ATK_STATE_ACTIVE))
{
- emit(child, ITF_EVENT_WINDOW, "deactivate", NULL, 0, 0, DBUS_TYPE_STRING_AS_STRING, name);
+ emit (child, ITF_EVENT_WINDOW, "deactivate", NULL, 0, 0,
+ DBUS_TYPE_STRING_AS_STRING, name);
}
g_object_unref (stateset);
- emit(child, ITF_EVENT_WINDOW, "destroy", NULL, 0, 0, DBUS_TYPE_STRING_AS_STRING, name);
+ emit (child, ITF_EVENT_WINDOW, "destroy", NULL, 0, 0,
+ DBUS_TYPE_STRING_AS_STRING, name);
g_object_unref (child);
}
}
#include <common/spi-types.h>
-void spi_atk_register_event_listeners (void);
+void spi_atk_register_event_listeners (void);
void spi_atk_deregister_event_listeners (void);
-void spi_atk_tidy_windows (void);
+void spi_atk_tidy_windows (void);
#endif /* EVENT_H */
static dbus_bool_t
-impl_get_StartIndex (DBusMessageIter * iter,
- void *user_data)
+impl_get_StartIndex (DBusMessageIter * iter, void *user_data)
{
AtkHyperlink *link = get_hyperlink (user_data);
g_return_val_if_fail (ATK_IS_HYPERLINK (user_data), FALSE);
return droute_invalid_arguments_error (message);
}
atk_object = atk_hyperlink_get_object (link, i);
- return spi_dbus_return_sub_object (message, G_OBJECT (atk_object), G_OBJECT (link), FALSE);
+ return spi_dbus_return_sub_object (message, G_OBJECT (atk_object),
+ G_OBJECT (link), FALSE);
}
static DBusMessage *
};
void
-spi_initialize_hyperlink (DRoutePath *path)
+spi_initialize_hyperlink (DRoutePath * path)
{
droute_path_add_interface (path,
SPI_DBUS_INTERFACE_HYPERLINK,
- methods,
- properties);
+ methods, properties);
};
return droute_invalid_arguments_error (message);
}
link = atk_hypertext_get_link (hypertext, linkIndex);
- return spi_dbus_return_hyperlink (message, link, ATK_OBJECT(hypertext), TRUE);
+ return spi_dbus_return_hyperlink (message, link, ATK_OBJECT (hypertext),
+ TRUE);
}
static DBusMessage *
};
void
-spi_initialize_hypertext (DRoutePath *path)
+spi_initialize_hypertext (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_HYPERTEXT,
- methods,
- NULL);
+ SPI_DBUS_INTERFACE_HYPERTEXT, methods, NULL);
};
#include "common/spi-dbus.h"
static dbus_bool_t
-impl_get_ImageDescription (DBusMessageIter * iter,
- void *user_data)
+impl_get_ImageDescription (DBusMessageIter * iter, void *user_data)
{
AtkImage *image = (AtkImage *) user_data;
g_return_val_if_fail (ATK_IS_IMAGE (user_data), FALSE);
}
static dbus_bool_t
-impl_get_ImageLocale (DBusMessageIter * iter,
- void *user_data)
+impl_get_ImageLocale (DBusMessageIter * iter, void *user_data)
{
AtkImage *image = (AtkImage *) user_data;
g_return_val_if_fail (ATK_IS_IMAGE (user_data), FALSE);
};
void
-spi_initialize_image (DRoutePath *path)
+spi_initialize_image (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_IMAGE,
- methods,
- properties);
+ SPI_DBUS_INTERFACE_IMAGE, methods, properties);
};
#include "common/spi-dbus.h"
static gboolean
-spi_init_relation_type_table (Accessibility_RelationType *types)
+spi_init_relation_type_table (Accessibility_RelationType * types)
{
gint i;
types[ATK_RELATION_EMBEDS] = Accessibility_RELATION_EMBEDS;
types[ATK_RELATION_EMBEDDED_BY] = Accessibility_RELATION_EMBEDDED_BY;
types[ATK_RELATION_POPUP_FOR] = Accessibility_RELATION_POPUP_FOR;
- types[ATK_RELATION_PARENT_WINDOW_OF] = Accessibility_RELATION_PARENT_WINDOW_OF;
- types[ATK_RELATION_DESCRIPTION_FOR] = Accessibility_RELATION_DESCRIPTION_FOR;
+ types[ATK_RELATION_PARENT_WINDOW_OF] =
+ Accessibility_RELATION_PARENT_WINDOW_OF;
+ types[ATK_RELATION_DESCRIPTION_FOR] =
+ Accessibility_RELATION_DESCRIPTION_FOR;
types[ATK_RELATION_DESCRIBED_BY] = Accessibility_RELATION_DESCRIBED_BY;
return TRUE;
spi_relation_type_from_atk_relation_type (AtkRelationType type)
{
static gboolean is_initialized = FALSE;
- static Accessibility_RelationType spi_relation_type_table [ATK_RELATION_LAST_DEFINED];
+ static Accessibility_RelationType
+ spi_relation_type_table[ATK_RELATION_LAST_DEFINED];
Accessibility_RelationType spi_type;
if (!is_initialized)
- is_initialized = spi_init_relation_type_table (spi_relation_type_table);
+ is_initialized = spi_init_relation_type_table (spi_relation_type_table);
if (type > ATK_RELATION_NULL && type < ATK_RELATION_LAST_DEFINED)
spi_type = spi_relation_type_table[type];
static AtkRelation *
get_relation_from_servant (PortableServer_Servant servant)
{
- SpiBase *base = SPI_BASE (bonobo_object_from_servant(servant));
+ SpiBase *base = SPI_BASE (bonobo_object_from_servant (servant));
g_return_val_if_fail (base, NULL);
- return ATK_RELATION(base->gobj);
+ return ATK_RELATION (base->gobj);
}
static Accessibility_RelationType
-impl_getRelationType (PortableServer_Servant servant,
- CORBA_Environment * ev)
+impl_getRelationType (PortableServer_Servant servant, CORBA_Environment * ev)
{
AtkRelation *relation = get_relation_from_servant (servant);
AtkRelationType type;
static CORBA_short
-impl_getNTargets (PortableServer_Servant servant,
- CORBA_Environment * ev)
+impl_getNTargets (PortableServer_Servant servant, CORBA_Environment * ev)
{
- AtkRelation *relation = get_relation_from_servant(servant);
+ AtkRelation *relation = get_relation_from_servant (servant);
g_return_val_if_fail (relation != NULL, 0);
return relation->target ? relation->target->len : 0;
static CORBA_Object
impl_getTarget (PortableServer_Servant servant,
- const CORBA_short index,
- CORBA_Environment * ev)
+ const CORBA_short index, CORBA_Environment * ev)
{
AtkObject *atk_object;
AtkRelation *relation = get_relation_from_servant (servant);
g_return_val_if_fail (relation, NULL);
- if (!relation->target ||
- index < 0 ||
- index >= relation->target->len)
+ if (!relation->target || index < 0 || index >= relation->target->len)
return CORBA_OBJECT_NIL;
atk_object = g_ptr_array_index (relation->target, index);
SpiRelation *
-spi_relation_new (AtkRelation *obj)
+spi_relation_new (AtkRelation * obj)
{
SpiRelation *new_relation = g_object_new (SPI_RELATION_TYPE, NULL);
spi_base_construct (SPI_BASE (new_relation), G_OBJECT (obj));
static void
-spi_relation_class_init (SpiRelationClass *klass)
+spi_relation_class_init (SpiRelationClass * klass)
{
POA_Accessibility_Relation__epv *epv = &klass->epv;
- epv->getRelationType = impl_getRelationType;
- epv->getNTargets = impl_getNTargets;
- epv->getTarget = impl_getTarget;
+ epv->getRelationType = impl_getRelationType;
+ epv->getNTargets = impl_getNTargets;
+ epv->getTarget = impl_getTarget;
}
static void
-spi_relation_init (SpiRelation *relation)
+spi_relation_init (SpiRelation * relation)
{
}
BONOBO_TYPE_FUNC_FULL (SpiRelation,
- Accessibility_Relation,
- SPI_TYPE_BASE,
- spi_relation)
+ Accessibility_Relation, SPI_TYPE_BASE, spi_relation)
#include "accessible-marshaller.h"
static dbus_bool_t
-impl_get_NSelectedChildren (DBusMessageIter * iter,
- void *user_data)
+impl_get_NSelectedChildren (DBusMessageIter * iter, void *user_data)
{
AtkSelection *selection = (AtkSelection *) user_data;
g_return_val_if_fail (ATK_IS_SELECTION (user_data), FALSE);
};
void
-spi_initialize_selection (DRoutePath *path)
+spi_initialize_selection (DRoutePath * path)
{
droute_path_add_interface (path,
SPI_DBUS_INTERFACE_SELECTION,
- methods,
- properties);
+ methods, properties);
};
typedef struct _SpiContentStream SpiContentStream;
typedef struct _SpiContentStreamClass SpiContentStreamClass;
-struct _SpiContentStream {
+struct _SpiContentStream
+{
BonoboObject parent;
GIOChannel *gio;
};
-struct _SpiContentStreamClass {
+struct _SpiContentStreamClass
+{
BonoboObjectClass parent_class;
POA_Accessibility_ContentStream__epv epv;
};
-GType spi_content_stream_get_type (void);
+GType spi_content_stream_get_type (void);
-static SpiContentStream*
-spi_content_stream_new (GIOChannel *gio)
+static SpiContentStream *
+spi_content_stream_new (GIOChannel * gio)
{
SpiContentStream *new_stream = g_object_new (SPI_CONTENT_STREAM_TYPE, NULL);
new_stream->gio = gio;
}
static void
-spi_content_stream_dispose (GObject *o)
+spi_content_stream_dispose (GObject * o)
{
- if (SPI_IS_CONTENT_STREAM (o))
+ if (SPI_IS_CONTENT_STREAM (o))
{
- SpiContentStream *stream = SPI_CONTENT_STREAM (o);
- if (stream->gio) g_io_channel_unref (stream->gio);
+ SpiContentStream *stream = SPI_CONTENT_STREAM (o);
+ if (stream->gio)
+ g_io_channel_unref (stream->gio);
}
}
static CORBA_long
impl_content_stream_seek (PortableServer_Servant servant,
- const CORBA_long offset,
- const Accessibility_ContentStream_SeekType whence,
- CORBA_Environment *ev)
+ const CORBA_long offset,
+ const Accessibility_ContentStream_SeekType whence,
+ CORBA_Environment * ev)
{
- SpiContentStream *stream = SPI_CONTENT_STREAM (bonobo_object_from_servant(servant));
+ SpiContentStream *stream =
+ SPI_CONTENT_STREAM (bonobo_object_from_servant (servant));
if (stream && stream->gio)
- {
+ {
GError *err;
GSeekType seektype = G_SEEK_SET;
- switch (whence) {
- case Accessibility_ContentStream_SEEK_CURRENT:
- seektype = G_SEEK_CUR;
- break;
- case Accessibility_ContentStream_SEEK_END:
- seektype = G_SEEK_END;
- break;
- }
- if (g_io_channel_seek_position (stream->gio, (gint64) offset,
- seektype, &err) == G_IO_STATUS_NORMAL)
- return offset;
+ switch (whence)
+ {
+ case Accessibility_ContentStream_SEEK_CURRENT:
+ seektype = G_SEEK_CUR;
+ break;
+ case Accessibility_ContentStream_SEEK_END:
+ seektype = G_SEEK_END;
+ break;
+ }
+ if (g_io_channel_seek_position (stream->gio, (gint64) offset,
+ seektype, &err) == G_IO_STATUS_NORMAL)
+ return offset;
else
- return -1;
- }
+ return -1;
+ }
else
- return -1;
+ return -1;
}
static CORBA_long
impl_content_stream_read (PortableServer_Servant servant,
- const CORBA_long count,
- Accessibility_ContentStream_iobuf** buffer,
- CORBA_Environment *ev)
+ const CORBA_long count,
+ Accessibility_ContentStream_iobuf ** buffer,
+ CORBA_Environment * ev)
{
- SpiContentStream *stream = SPI_CONTENT_STREAM (bonobo_object_from_servant(servant));
+ SpiContentStream *stream =
+ SPI_CONTENT_STREAM (bonobo_object_from_servant (servant));
CORBA_long realcount = 0;
if (stream && stream->gio)
- {
+ {
gchar *gbuf = NULL;
GIOStatus status;
GError *err = NULL;
-
- /* read the giochannel and determine the actual bytes read...*/
- if (count != -1) {
- gbuf = g_malloc (count+1);
- status = g_io_channel_read_chars (stream->gio, gbuf, count, &realcount, &err);
- }
+
+ /* read the giochannel and determine the actual bytes read... */
+ if (count != -1)
+ {
+ gbuf = g_malloc (count + 1);
+ status =
+ g_io_channel_read_chars (stream->gio, gbuf, count, &realcount,
+ &err);
+ }
else
- status = g_io_channel_read_to_end (stream->gio, &gbuf, &realcount, &err);
+ status =
+ g_io_channel_read_to_end (stream->gio, &gbuf, &realcount, &err);
if (status == G_IO_STATUS_NORMAL || status == G_IO_STATUS_EOF)
- {
- *buffer = Bonobo_Stream_iobuf__alloc ();
- CORBA_sequence_set_release (*buffer, TRUE);
+ {
+ *buffer = Bonobo_Stream_iobuf__alloc ();
+ CORBA_sequence_set_release (*buffer, TRUE);
+
+ (*buffer)->_buffer =
+ CORBA_sequence_CORBA_octet_allocbuf (realcount);
+ (*buffer)->_length = realcount;
- (*buffer)->_buffer = CORBA_sequence_CORBA_octet_allocbuf (realcount);
- (*buffer)->_length = realcount;
-
- g_memmove ((*buffer)->_buffer, gbuf, realcount);
- }
+ g_memmove ((*buffer)->_buffer, gbuf, realcount);
+ }
g_free (gbuf);
- }
+ }
return realcount;
}
static void
-impl_content_stream_close (PortableServer_Servant servant,
- CORBA_Environment *ev)
+impl_content_stream_close (PortableServer_Servant servant,
+ CORBA_Environment * ev)
{
- GIOStatus status;
- GError *err;
- SpiContentStream *stream = SPI_CONTENT_STREAM (bonobo_object_from_servant(servant));
- if (stream && stream->gio) {
- status = g_io_channel_shutdown (stream->gio, TRUE, &err);
- g_io_channel_unref (stream->gio);
+ GIOStatus status;
+ GError *err;
+ SpiContentStream *stream =
+ SPI_CONTENT_STREAM (bonobo_object_from_servant (servant));
+ if (stream && stream->gio)
+ {
+ status = g_io_channel_shutdown (stream->gio, TRUE, &err);
+ g_io_channel_unref (stream->gio);
}
- if (err) g_free (err);
+ if (err)
+ g_free (err);
}
static void
-spi_content_stream_class_init (SpiContentStreamClass *klass)
+spi_content_stream_class_init (SpiContentStreamClass * klass)
{
POA_Accessibility_ContentStream__epv *epv = &klass->epv;
- GObjectClass * object_class = (GObjectClass *) klass;
+ GObjectClass *object_class = (GObjectClass *) klass;
epv->seek = impl_content_stream_seek;
epv->read = impl_content_stream_read;
static void
-spi_content_stream_init (SpiContentStream *stream)
+spi_content_stream_init (SpiContentStream * stream)
{
}
BONOBO_TYPE_FUNC_FULL (SpiContentStream,
- Accessibility_ContentStream,
- BONOBO_TYPE_OBJECT,
- spi_content_stream)
-
-static AtkStreamableContent *
-get_streamable_from_servant (PortableServer_Servant servant)
+ Accessibility_ContentStream,
+ BONOBO_TYPE_OBJECT, spi_content_stream)
+ static AtkStreamableContent
+ *get_streamable_from_servant (PortableServer_Servant servant)
{
SpiBase *object = SPI_BASE (bonobo_object_from_servant (servant));
g_return_val_if_fail (object != NULL, NULL);
- g_return_val_if_fail (ATK_IS_STREAMABLE_CONTENT(object->gobj), NULL);
+ g_return_val_if_fail (ATK_IS_STREAMABLE_CONTENT (object->gobj), NULL);
return ATK_STREAMABLE_CONTENT (object->gobj);
}
/*
* CORBA Accessibility::StreamableContent::getContentTypes method implementation
*/
-static Accessibility_StringSeq*
-impl_accessibility_streamable_get_content_types (PortableServer_Servant servant,
- CORBA_Environment *ev)
+static Accessibility_StringSeq *
+impl_accessibility_streamable_get_content_types (PortableServer_Servant
+ servant,
+ CORBA_Environment * ev)
{
Accessibility_StringSeq *typelist = Accessibility_StringSeq__alloc ();
AtkStreamableContent *streamable = get_streamable_from_servant (servant);
n_types = atk_streamable_content_get_n_mime_types (streamable);
if (n_types)
- {
+ {
typelist->_length = typelist->_maximum = n_types;
typelist->_buffer = Accessibility_StringSeq_allocbuf (n_types);
- for (i = 0; i < n_types; ++i) {
- const gchar *mimetype = atk_streamable_content_get_mime_type (streamable, i);
- typelist->_buffer[i] = CORBA_string_dup (mimetype ? mimetype : "");
- }
- }
+ for (i = 0; i < n_types; ++i)
+ {
+ const gchar *mimetype =
+ atk_streamable_content_get_mime_type (streamable, i);
+ typelist->_buffer[i] = CORBA_string_dup (mimetype ? mimetype : "");
+ }
+ }
return typelist;
}
*/
static Bonobo_Stream
impl_accessibility_streamable_get_content (PortableServer_Servant servant,
- const CORBA_char * content_type,
- CORBA_Environment *ev)
+ const CORBA_char * content_type,
+ CORBA_Environment * ev)
{
Bonobo_Stream stream;
AtkStreamableContent *streamable = get_streamable_from_servant (servant);
gio = atk_streamable_content_get_stream (streamable, content_type);
- stream = CORBA_OBJECT_NIL; /* deprecated,
- * and it was never implemented,
- * so don't bother fixing this
- */
+ stream = CORBA_OBJECT_NIL; /* deprecated,
+ * and it was never implemented,
+ * so don't bother fixing this
+ */
return stream;
}
*/
static Accessibility_ContentStream
impl_accessibility_streamable_get_stream (PortableServer_Servant servant,
- const CORBA_char * content_type,
- CORBA_Environment *ev)
+ const CORBA_char * content_type,
+ CORBA_Environment * ev)
{
SpiContentStream *stream;
AtkStreamableContent *streamable = get_streamable_from_servant (servant);
gio = atk_streamable_content_get_stream (streamable, content_type);
- stream = spi_content_stream_new (gio);
+ stream = spi_content_stream_new (gio);
return bonobo_object_dup_ref (BONOBO_OBJREF (stream), ev);
}
*/
static CORBA_string
impl_accessibility_streamable_get_uri (PortableServer_Servant servant,
- const CORBA_char * content_type,
- CORBA_Environment *ev)
+ const CORBA_char * content_type,
+ CORBA_Environment * ev)
{
gchar *uri;
AtkStreamableContent *streamable = get_streamable_from_servant (servant);
}
static void
-spi_streamable_class_init (SpiStreamableClass *klass)
+spi_streamable_class_init (SpiStreamableClass * klass)
{
- POA_Accessibility_StreamableContent__epv *epv = &klass->epv;
- spi_streamable_parent_class = g_type_class_peek_parent (klass);
+ POA_Accessibility_StreamableContent__epv *epv = &klass->epv;
+ spi_streamable_parent_class = g_type_class_peek_parent (klass);
- epv->getContentTypes = impl_accessibility_streamable_get_content_types;
- epv->getContent = impl_accessibility_streamable_get_content;
- epv->getStream = impl_accessibility_streamable_get_stream;
- epv->GetURI = impl_accessibility_streamable_get_uri;
+ epv->getContentTypes = impl_accessibility_streamable_get_content_types;
+ epv->getContent = impl_accessibility_streamable_get_content;
+ epv->getStream = impl_accessibility_streamable_get_stream;
+ epv->GetURI = impl_accessibility_streamable_get_uri;
}
static void
-spi_streamable_init (SpiStreamable *streamable)
+spi_streamable_init (SpiStreamable * streamable)
{
}
SpiStreamable *
-spi_streamable_interface_new (AtkObject *o)
+spi_streamable_interface_new (AtkObject * o)
{
- SpiStreamable *retval = g_object_new (SPI_STREAMABLE_TYPE, NULL);
+ SpiStreamable *retval = g_object_new (SPI_STREAMABLE_TYPE, NULL);
- spi_base_construct (SPI_BASE (retval), G_OBJECT(o));
+ spi_base_construct (SPI_BASE (retval), G_OBJECT (o));
- return retval;
+ return retval;
}
BONOBO_TYPE_FUNC_FULL (SpiStreamable,
- Accessibility_StreamableContent,
- PARENT_TYPE,
- spi_streamable)
+ Accessibility_StreamableContent,
+ PARENT_TYPE, spi_streamable)
}
static dbus_bool_t
-impl_get_NSelectedRows (DBusMessageIter * iter,
- void *user_data)
+impl_get_NSelectedRows (DBusMessageIter * iter, void *user_data)
{
AtkTable *table = (AtkTable *) user_data;
gint *selected_rows = NULL;
}
static dbus_bool_t
-impl_get_NSelectedColumns (DBusMessageIter * iter,
- void *user_data)
+impl_get_NSelectedColumns (DBusMessageIter * iter, void *user_data)
{
AtkTable *table = (AtkTable *) user_data;
gint *selected_columns = NULL;
};
void
-spi_initialize_table (DRoutePath *path)
+spi_initialize_table (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_TABLE,
- methods,
- properties);
+ SPI_DBUS_INTERFACE_TABLE, methods, properties);
};
#include "accessible-marshaller.h"
static dbus_bool_t
-impl_get_CharacterCount (DBusMessageIter * iter,
- void *user_data)
+impl_get_CharacterCount (DBusMessageIter * iter, void *user_data)
{
AtkText *text = (AtkText *) user_data;
g_return_val_if_fail (ATK_IS_TEXT (user_data), FALSE);
}
static dbus_bool_t
-impl_get_CaretOffset (DBusMessageIter * iter,
- void *user_data)
+impl_get_CaretOffset (DBusMessageIter * iter, void *user_data)
{
AtkText *text = (AtkText *) user_data;
g_return_val_if_fail (ATK_IS_TEXT (user_data), FALSE);
reply = dbus_message_new_method_return (message);
if (reply)
{
- dbus_message_append_args (reply, DBUS_TYPE_STRING, &txt, DBUS_TYPE_INT32,
- &startOffset, DBUS_TYPE_INT32, &endOffset,
+ dbus_message_append_args (reply, DBUS_TYPE_STRING, &txt,
+ DBUS_TYPE_INT32, &startOffset,
+ DBUS_TYPE_INT32, &endOffset,
DBUS_TYPE_INVALID);
}
g_free (txt);
reply = dbus_message_new_method_return (message);
if (reply)
{
- dbus_message_append_args (reply, DBUS_TYPE_STRING, &txt, DBUS_TYPE_INT32,
- &startOffset, DBUS_TYPE_INT32, &endOffset,
+ dbus_message_append_args (reply, DBUS_TYPE_STRING, &txt,
+ DBUS_TYPE_INT32, &startOffset,
+ DBUS_TYPE_INT32, &endOffset,
DBUS_TYPE_INVALID);
}
g_free (txt);
reply = dbus_message_new_method_return (message);
if (reply)
{
- dbus_message_append_args (reply, DBUS_TYPE_STRING, &txt, DBUS_TYPE_INT32,
- &startOffset, DBUS_TYPE_INT32, &endOffset,
+ dbus_message_append_args (reply, DBUS_TYPE_STRING, &txt,
+ DBUS_TYPE_INT32, &startOffset,
+ DBUS_TYPE_INT32, &endOffset,
DBUS_TYPE_INVALID);
}
g_free (txt);
static DBusMessage *
impl_GetCharacterAtOffset (DBusConnection * bus, DBusMessage * message,
- void *user_data)
+ void *user_data)
{
AtkText *text = (AtkText *) user_data;
dbus_int32_t offset;
reply = dbus_message_new_method_return (message);
if (reply)
{
- dbus_message_append_args (reply, DBUS_TYPE_INT32, &ch, DBUS_TYPE_INVALID);
+ dbus_message_append_args (reply, DBUS_TYPE_INT32, &ch,
+ DBUS_TYPE_INVALID);
}
return reply;
}
{
dbus_message_append_args (reply, DBUS_TYPE_STRING, &rv, DBUS_TYPE_INT32,
&startOffset, DBUS_TYPE_INT32, &endOffset,
- DBUS_TYPE_BOOLEAN, &defined, DBUS_TYPE_INVALID);
+ DBUS_TYPE_BOOLEAN, &defined,
+ DBUS_TYPE_INVALID);
}
atk_attribute_set_free (set);
return reply;
dbus_message_iter_init_append (reply, &iter);
spi_atk_append_attribute_set (&iter, set);
dbus_message_append_args (reply, DBUS_TYPE_INT32, &startOffset,
- DBUS_TYPE_INT32, &endOffset, DBUS_TYPE_INVALID);
+ DBUS_TYPE_INT32, &endOffset,
+ DBUS_TYPE_INVALID);
}
atk_attribute_set_free (set);
return reply;
droute_not_yet_handled_error (message));
dbus_error_init (&error);
if (!dbus_message_get_args
- (message, &error, DBUS_TYPE_INT32, &offset, DBUS_TYPE_UINT32, &coordType,
- DBUS_TYPE_INVALID))
+ (message, &error, DBUS_TYPE_INT32, &offset, DBUS_TYPE_UINT32,
+ &coordType, DBUS_TYPE_INVALID))
{
return droute_invalid_arguments_error (message);
}
return NULL;
dbus_message_iter_init_append (reply, &iter);
- dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{ss}", &iterArray);
+ dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{ss}",
+ &iterArray);
spi_atk_append_attribute_set_inner (&iterArray, attributes);
if (includeDefaults)
{
};
void
-spi_initialize_text (DRoutePath *path)
+spi_initialize_text (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_TEXT,
- methods,
- properties);
+ SPI_DBUS_INTERFACE_TEXT, methods, properties);
};
{
/* Make sure it isn't a hyperlink */
if (ATK_IS_OBJECT (obj_data))
- spi_atk_append_accessible (ATK_OBJECT(obj_data), data);
+ spi_atk_append_accessible (ATK_OBJECT (obj_data), data);
}
/*---------------------------------------------------------------------------*/
void
-spi_emit_cache_removal (guint ref, DBusConnection *bus)
+spi_emit_cache_removal (guint ref, DBusConnection * bus)
{
DBusMessage *message;
if ((message = dbus_message_new_signal ("/org/freedesktop/atspi/tree",
SPI_DBUS_INTERFACE_TREE,
- "RemoveAccessible"))) {
- DBusMessageIter iter;
- gchar *path;
+ "RemoveAccessible")))
+ {
+ DBusMessageIter iter;
+ gchar *path;
- dbus_message_iter_init_append (message, &iter);
+ dbus_message_iter_init_append (message, &iter);
- path = atk_dbus_ref_to_path (ref);
- dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &path);
+ path = atk_dbus_ref_to_path (ref);
+ dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &path);
- dbus_connection_send(bus, message, NULL);
+ dbus_connection_send (bus, message, NULL);
- dbus_message_unref (message);
- }
+ dbus_message_unref (message);
+ }
}
void
-spi_emit_cache_update (AtkObject *accessible, DBusConnection *bus)
+spi_emit_cache_update (AtkObject * accessible, DBusConnection * bus)
{
DBusMessage *message;
if ((message = dbus_message_new_signal ("/org/freedesktop/atspi/tree",
SPI_DBUS_INTERFACE_TREE,
- "UpdateAccessible"))) {
- DBusMessageIter iter;
+ "UpdateAccessible")))
+ {
+ DBusMessageIter iter;
- dbus_message_iter_init_append (message, &iter);
- spi_atk_append_accessible (accessible, &iter);
+ dbus_message_iter_init_append (message, &iter);
+ spi_atk_append_accessible (accessible, &iter);
- dbus_connection_send(bus, message, NULL);
+ dbus_connection_send (bus, message, NULL);
- dbus_message_unref (message);
- }
+ dbus_message_unref (message);
+ }
}
/*---------------------------------------------------------------------------*/
static DBusMessage *
-impl_GetRoot (DBusConnection *bus, DBusMessage *message, void *user_data)
+impl_GetRoot (DBusConnection * bus, DBusMessage * message, void *user_data)
{
- AtkObject *root = atk_get_root();
+ AtkObject *root = atk_get_root ();
char *path;
DBusMessage *reply;
- gchar *errmsg;
+ gchar *errmsg;
if (!root)
{
"No root accessible available");
}
reply = dbus_message_new_method_return (message);
- dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
+ dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
g_free (path);
return reply;
}
/*---------------------------------------------------------------------------*/
static DBusMessage *
-impl_GetTree (DBusConnection *bus, DBusMessage *message, void *user_data)
+impl_GetTree (DBusConnection * bus, DBusMessage * message, void *user_data)
{
DBusMessage *reply;
DBusMessageIter iter, iter_array;
reply = dbus_message_new_method_return (message);
dbus_message_iter_init_append (reply, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(o(so)a(so)assusau)", &iter_array);
- atk_dbus_foreach_registered(append_accessible_hf, &iter_array);
- dbus_message_iter_close_container(&iter, &iter_array);
+ dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
+ "(o(so)a(so)assusau)", &iter_array);
+ atk_dbus_foreach_registered (append_accessible_hf, &iter_array);
+ dbus_message_iter_close_container (&iter, &iter_array);
return reply;
}
};
void
-spi_initialize_tree (DRoutePath *path)
+spi_initialize_tree (DRoutePath * path)
{
- droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_TREE,
- methods,
- NULL);
+ droute_path_add_interface (path, SPI_DBUS_INTERFACE_TREE, methods, NULL);
};
/*END------------------------------------------------------------------------*/
#include <atk/atk.h>
#include <dbus/dbus.h>
-void
-spi_emit_cache_update (AtkObject *accessible, DBusConnection *bus);
+void spi_emit_cache_update (AtkObject * accessible, DBusConnection * bus);
-void
-spi_emit_cache_removal (guint ref, DBusConnection *bus);
+void spi_emit_cache_removal (guint ref, DBusConnection * bus);
#endif /* TREE_ADAPTOR_H */
#include "common/spi-dbus.h"
static dbus_bool_t
-impl_get_MinimumValue (DBusMessageIter * iter,
- void *user_data)
+impl_get_MinimumValue (DBusMessageIter * iter, void *user_data)
{
AtkValue *value = (AtkValue *) user_data;
- GValue src = {0};
- GValue dest = {0};
+ GValue src = { 0 };
+ GValue dest = { 0 };
gdouble dub;
g_return_val_if_fail (ATK_IS_VALUE (user_data), FALSE);
}
static dbus_bool_t
-impl_get_MaximumValue (DBusMessageIter * iter,
- void *user_data)
+impl_get_MaximumValue (DBusMessageIter * iter, void *user_data)
{
AtkValue *value = (AtkValue *) user_data;
- GValue src = {0};
- GValue dest = {0};
+ GValue src = { 0 };
+ GValue dest = { 0 };
gdouble dub;
g_return_val_if_fail (ATK_IS_VALUE (user_data), FALSE);
}
static dbus_bool_t
-impl_get_MinimumIncrement (DBusMessageIter * iter,
- void *user_data)
+impl_get_MinimumIncrement (DBusMessageIter * iter, void *user_data)
{
AtkValue *value = (AtkValue *) user_data;
- GValue src = {0};
- GValue dest = {0};
+ GValue src = { 0 };
+ GValue dest = { 0 };
gdouble dub;
g_return_val_if_fail (ATK_IS_VALUE (user_data), FALSE);
}
static dbus_bool_t
-impl_get_CurrentValue (DBusMessageIter * iter,
- void *user_data)
+impl_get_CurrentValue (DBusMessageIter * iter, void *user_data)
{
AtkValue *value = (AtkValue *) user_data;
- GValue src = {0};
- GValue dest = {0};
+ GValue src = { 0 };
+ GValue dest = { 0 };
gdouble dub;
g_return_val_if_fail (ATK_IS_VALUE (user_data), FALSE);
}
static dbus_bool_t
-impl_set_currentValue (DBusMessageIter * iter,
- void *user_data)
+impl_set_currentValue (DBusMessageIter * iter, void *user_data)
{
AtkValue *value = (AtkValue *) user_data;
- GValue src = {0};
- GValue dest = {0};
+ GValue src = { 0 };
+ GValue dest = { 0 };
gdouble dub;
DBusMessageIter iter_variant;
dbus_message_iter_recurse (iter, &iter_variant);
if (dbus_message_iter_get_arg_type (&iter_variant) != DBUS_TYPE_DOUBLE)
- {
- g_warning ("TODO: Support setting value from a non-double");
- return FALSE;
- }
+ {
+ g_warning ("TODO: Support setting value from a non-double");
+ return FALSE;
+ }
dbus_message_iter_get_basic (&iter_variant, &dub);
g_value_init (&src, G_TYPE_DOUBLE);
g_value_set_double (&src, dub);
};
void
-spi_initialize_value (DRoutePath *path)
+spi_initialize_value (DRoutePath * path)
{
droute_path_add_interface (path,
- SPI_DBUS_INTERFACE_VALUE,
- NULL,
- properties);
+ SPI_DBUS_INTERFACE_VALUE, NULL, properties);
};
projects / platform / core / uifw / at-spi2-atk.git / commitdiff