atspi-private.h \
atspi-registry.c \
atspi-registry.h \
+ atspi-relation.c \
+ atspi-relation.h \
atspi-selection.c \
atspi-selection.h \
atspi-stateset.c \
}
static void
+atspi_collection_interface_init (AtspiCollection *component)
+{
+}
+
+static void
atspi_component_interface_init (AtspiComponent *component)
{
}
G_DEFINE_TYPE_WITH_CODE (AtspiAccessible, atspi_accessible, ATSPI_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (ATSPI_TYPE_ACTION, atspi_action_interface_init)
+ G_IMPLEMENT_INTERFACE (ATSPI_TYPE_COLLECTION, atspi_collection_interface_init)
G_IMPLEMENT_INTERFACE (ATSPI_TYPE_COMPONENT, atspi_component_interface_init)
G_IMPLEMENT_INTERFACE (ATSPI_TYPE_EDITABLE_TEXT, atspi_editable_text_interface_init)
G_IMPLEMENT_INTERFACE (ATSPI_TYPE_IMAGE, atspi_image_interface_init)
* Get the set of #AtspiRelation objects which describe this #AtspiAccessible object's
* relationships with other #AtspiAccessible objects.
*
- * Returns: an array of #AtspiAccessibleRelation pointers. or NULL on exception
- * TODO:: Annotate array type
+ * Returns: (element-type AtspiAccessible*) (transfer full): an array of
+ * #AtspiAccessibleRelation pointers. or NULL on exception
**/
GArray *
atspi_accessible_get_relation_set (AtspiAccessible *obj, GError **error)
{
- int i;
- int n_relations;
- GArray *relation_set;
+ DBusMessage *reply;
+ DBusMessageIter iter, iter_array;
+ GArray *ret;
g_return_val_if_fail (obj != NULL, NULL);
- if (!_atspi_dbus_call (obj, atspi_interface_accessible, "GetRelationSet", error, "=>a(uao)", &relation_set))
- return NULL;
+ reply = _atspi_dbus_call_partial (obj, atspi_interface_accessible, "GetRelationSet", error, "");
+ _ATSPI_DBUS_CHECK_SIG (reply, "a(ua(so))", NULL);
- return relation_set;
+ ret = g_array_new (TRUE, TRUE, sizeof (AtspiRelation *));
+ dbus_message_iter_init (reply, &iter);
+ dbus_message_iter_recurse (&iter, &iter_array);
+ while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
+ {
+ GArray *new_array;
+ AtspiRelation *relation;
+ relation = _atspi_relation_new_from_iter (&iter_array);
+ new_array = g_array_append_val (ret, relation);
+ if (new_array)
+ ret = new_array;
+ dbus_message_iter_next (&iter_array);
+ }
+ return ret;
}
/**
DBusMessageIter iter;
dbus_message_iter_init_append (message, &iter);
- return _atspi_match_rule_marshal (&iter, rule);
+ return _atspi_match_rule_marshal (rule, &iter);
}
static gboolean
append_accessible (DBusMessage *message, AtspiAccessible *accessible)
{
- DBusMessageIter iter, iter_struct;
+ DBusMessageIter iter;
dbus_message_iter_init_append (message, &iter);
- dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL, &iter_struct);
- dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING,
- &accessible->parent.app->bus_name);
- dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH,
+ dbus_message_iter_append_basic (&iter, DBUS_TYPE_OBJECT_PATH,
&accessible->parent.path);
}
DBusMessageIter iter, iter_array;
GArray *ret = g_array_new (TRUE, TRUE, sizeof (AtspiAccessible *));
- _ATSPI_DBUS_CHECK_SIG (message, "(so)", NULL);
+ _ATSPI_DBUS_CHECK_SIG (message, "a(so)", NULL);
dbus_message_iter_init (message, &iter);
dbus_message_iter_recurse (&iter, &iter_array);
new_array = g_array_append_val (ret, accessible);
if (new_array)
ret = new_array;
- dbus_message_iter_next (&iter_array);
+ /* Iter was moved already, so no need to call dbus_message_iter_next */
}
dbus_message_unref (message);
return ret;
if (!append_match_rule (message, rule))
return NULL;
- dbus_message_append_args (message, DBUS_TYPE_INT32, &d_sortby,
+ dbus_message_append_args (message, DBUS_TYPE_UINT32, &d_sortby,
DBUS_TYPE_INT32, &d_count,
DBUS_TYPE_BOOLEAN, &d_traverse,
DBUS_TYPE_INVALID);
return NULL;
if (!append_match_rule (message, rule))
return NULL;
- dbus_message_append_args (message, DBUS_TYPE_INT32, &d_sortby,
- DBUS_TYPE_INT32, &d_tree,
+ dbus_message_append_args (message, DBUS_TYPE_UINT32, &d_sortby,
+ DBUS_TYPE_UINT32, &d_tree,
DBUS_TYPE_BOOLEAN, &d_recurse,
DBUS_TYPE_INT32, &d_count,
DBUS_TYPE_BOOLEAN, &d_traverse,
return NULL;
if (!append_match_rule (message, rule))
return NULL;
- dbus_message_append_args (message, DBUS_TYPE_INT32, &d_sortby,
- DBUS_TYPE_INT32, &d_tree,
+ dbus_message_append_args (message, DBUS_TYPE_UINT32, &d_sortby,
+ DBUS_TYPE_UINT32, &d_tree,
DBUS_TYPE_INT32, &d_count,
DBUS_TYPE_BOOLEAN, &d_traverse,
DBUS_TYPE_INVALID);
g_object_unref (rule->states);
if (rule->attributes)
g_hash_table_unref (rule->attributes);
- if (rule->roles)
- g_array_free (rule->roles, TRUE);
/* TODO: Check that interfaces don't leak */
if (rule->interfaces)
g_array_free (rule->interfaces, TRUE);
* attributes to match.
* @attributematchtype: An #AtspiCollectionMatchType specifying how to
* interpret @attributes.
- * @roles: (element-type AtspiRole): A #GArray of roles to match, or NULL if
- * not applicable.
* @interfaces: (element-type gchar*): An array of interfaces to match, or
- * NUL if not appliable. Interface names should be specified
+ * NUL if not applicable. Interface names should be specified
* by their DBus names (org.a11y.Atspi.Accessible,
* org.a11y.Atspi.Component, etc).
* @interfacematchtype: An #AtspiCollectionMatchType specifying how to
* interpret @interfaces.
+ * @roles: (element-type AtspiRole): A #GArray of roles to match, or NULL if
+ * not applicable.
+ * @rolematchtype: An #AtspiCollectionMatchType specifying how to
+ * interpret @roles.
* @invert: Specifies whether results should be inverted.
* TODO: Document this parameter better.
*
AtspiCollectionMatchType attributematchtype,
GArray *roles,
AtspiCollectionMatchType rolematchtype,
+ GArray *interfaces,
+ AtspiCollectionMatchType interfacematchtype,
gboolean invert)
{
AtspiMatchRule *rule = g_object_new (ATSPI_TYPE_MATCH_RULE, NULL);
+ int i;
if (!rule)
return NULL;
rule->statematchtype = statematchtype;
if (attributes)
- rule->attributes = g_object_ref (attributes);
+ rule->attributes = g_hash_table_ref (attributes);
rule->attributematchtype = attributematchtype;
+ if (interfaces)
+ rule->interfaces = g_array_ref (interfaces);
+ rule->interfacematchtype = interfacematchtype;
+
if (roles)
- rule->roles = g_array_ref(roles);
+ {
+ for (i = 0; i < roles->len; i++)
+ {
+ AtspiRole role = g_array_index (roles, AtspiRole, i);
+ if (role < 128)
+ rule->roles [role / 32] |= (1 << (role % 32));
+ else
+ g_warning ("Atspi: unexpected role %d\n", role);
+ }
+ }
+ else
+ rule->roles [0] = rule->roles [1] = 0;
rule->rolematchtype = rolematchtype;
rule->invert = invert;
dbus_uint32_t d_rolematchtype = rule->rolematchtype;
dbus_bool_t d_invert = rule->invert;
gint i;
+ dbus_int32_t d_role;
- if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, "(aiiasiaiisib)",
+ if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL,
&iter_struct))
return FALSE;
{
states [0] = states [1] = 0;
}
- dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "u", &iter_array);
+ dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "i", &iter_array);
dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &states [0]);
dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &states [1]);
dbus_message_iter_close_container (&iter_struct, &iter_array);
dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &d_statematchtype);
/* attributes */
- if (!dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY, "{ss}",
+ if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "{ss}",
&iter_dict))
return FALSE;
g_hash_table_foreach (rule->attributes, append_entry, &iter_dict);
- dbus_message_iter_close_container (iter, &iter_dict);
+ dbus_message_iter_close_container (&iter_struct, &iter_dict);
dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &d_attributematchtype);
- /* roles */
if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "i",
&iter_array))
return FALSE;
- if (rule->roles)
+ d_role = rule->roles [0];
+ dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+ d_role = rule->roles [1];
+ dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+ d_role = rule->roles [2];
+ dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+ d_role = rule->roles [3];
+ dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+ dbus_message_iter_close_container (&iter_struct, &iter_array);
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32,
+ &d_rolematchtype);
+
+ /* interfaces */
+ if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "s",
+ &iter_array))
+ return FALSE;
+ if (rule->interfaces)
{
- for (i = 0; i < rule->roles->len; i++)
+ for (i = 0; i < rule->interfaces->len; i++)
{
- dbus_int32_t d_role = g_array_index (rule->roles, AtspiRole, i);
- dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+ char *val = g_array_index (rule->interfaces, gchar *, i);
+ dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_STRING, &val);
}
}
dbus_message_iter_close_container (&iter_struct, &iter_array);
- dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32,
- &d_rolematchtype);
+ dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &d_interfacematchtype);
dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_BOOLEAN, &d_invert);
typedef struct _AtspiMatchRule AtspiMatchRule;
struct _AtspiMatchRule
{
+ GObject parent;
AtspiStateSet *states;
AtspiCollectionMatchType statematchtype;
GHashTable *attributes;
AtspiCollectionMatchType attributematchtype;
- GArray *roles;
- AtspiCollectionMatchType rolematchtype;
GArray *interfaces;
AtspiCollectionMatchType interfacematchtype;
+ gint roles [4];
+ AtspiCollectionMatchType rolematchtype;
gboolean invert;
};
GObjectClass parent_class;
};
+GType atspi_match_rule_get_type ();
+
AtspiMatchRule *
atspi_match_rule_new (AtspiStateSet *states,
AtspiCollectionMatchType statematchtype,
AtspiCollectionMatchType attributematchtype,
GArray *roles,
AtspiCollectionMatchType rolematchtype,
+ GArray *interfaces,
+ AtspiCollectionMatchType interfacematchtype,
gboolean invert);
gboolean
p = type;
dbus_message_iter_init_append (msg, &iter);
- dbind_any_marshal_va (&iter, &p, &args);
+ dbind_any_marshal_va (&iter, &p, args);
reply = dbind_send_and_allow_reentry (_atspi_bus(), msg, &err);
out:
_atspi_dbus_hash_from_message (DBusMessage *message)
{
DBusMessageIter iter;
- const char *signature;
- signature = dbus_message_get_signature (message);
-
- if (strcmp (signature, "a{ss}") != 0)
- {
- g_warning ("Trying to get hash from message of unexpected type %s\n", signature);
- return NULL;
- }
+ _ATSPI_DBUS_CHECK_SIG (message, "a{ss}", NULL);
dbus_message_iter_init (message, &iter);
return _atspi_dbus_hash_from_iter (&iter);
const char *name, *value;
dbus_message_iter_recurse (&iter_array, &iter_dict);
dbus_message_iter_get_basic (&iter_dict, &name);
+ dbus_message_iter_next (&iter_dict);
dbus_message_iter_get_basic (&iter_dict, &value);
g_hash_table_insert (hash, g_strdup (name), g_strdup (value));
dbus_message_iter_next (&iter_array);
_atspi_dbus_attribute_array_from_message (DBusMessage *message)
{
DBusMessageIter iter;
- const char *signature;
- signature = dbus_message_get_signature (message);
+ _ATSPI_DBUS_CHECK_SIG (message, "a{ss}", NULL);
- if (strcmp (signature, "a{ss}") != 0)
- {
- g_warning ("Trying to get hash from message of unexpected type %s\n", signature);
- return NULL;
- }
+ dbus_message_iter_init (message, &iter);
return _atspi_dbus_attribute_array_from_iter (&iter);
}
GArray *new_array;
dbus_message_iter_recurse (&iter_array, &iter_dict);
dbus_message_iter_get_basic (&iter_dict, &name);
+ dbus_message_iter_next (&iter_dict);
dbus_message_iter_get_basic (&iter_dict, &value);
- str = g_strdup_printf ("%s:;%s", name, value);
+ str = g_strdup_printf ("%s:%s", name, value);
new_array = g_array_append_val (array, str);
if (new_array)
array = new_array;
- dbus_message_iter_next (iter);;
+ dbus_message_iter_next (&iter_array);;
}
return array;
}
for (i = 0; i < states->len; i++)
atspi_state_set_add (set, g_array_index (states, AtspiStateType, i));
- return states;
+ return set;
}
AtspiStateSet *
atspi_state_set_add (AtspiStateSet *set, AtspiStateType state)
{
g_return_if_fail (set != NULL);
- set->states |= (1 << state);
+ set->states |= (((gint64)1) << state);
}
/**
#include "atspi-matchrule.h"
#include "atspi-misc.h"
#include "atspi-registry.h"
+#include "atspi-relation.h"
#include "atspi-selection.h"
+#include "atspi-stateset.h"
#include "atspi-table.h"
#include "atspi-text.h"
#include "atspi-value.h"
void
dbind_any_marshal_va (DBusMessageIter *iter,
const char **arg_types,
- va_list *args)
+ va_list args)
{
const char *p = *arg_types;
case DBUS_TYPE_UINT16:
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
- intarg = va_arg (*args, int);
+ intarg = va_arg (args, int);
arg = &intarg;
break;
case DBUS_TYPE_INT64:
case DBUS_TYPE_UINT64:
- int64arg = va_arg (*args, dbus_int64_t);
+ int64arg = va_arg (args, dbus_int64_t);
arg = &int64arg;
break;
case DBUS_TYPE_DOUBLE:
- doublearg = va_arg (*args, double);
+ doublearg = va_arg (args, double);
arg = &doublearg;
break;
/* ptr types */
case DBUS_TYPE_SIGNATURE:
case DBUS_TYPE_ARRAY:
case DBUS_TYPE_DICT_ENTRY:
- ptrarg = va_arg (*args, void *);
+ ptrarg = va_arg (args, void *);
arg = &ptrarg;
break;
case DBUS_STRUCT_BEGIN_CHAR:
- ptrarg = va_arg (*args, void *);
+ ptrarg = va_arg (args, void *);
arg = ptrarg;
break;
case DBUS_DICT_ENTRY_BEGIN_CHAR:
- ptrarg = va_arg (*args, void *);
+ ptrarg = va_arg (args, void *);
arg = ptrarg;
break;
case DBUS_TYPE_VARIANT:
fprintf (stderr, "No variant support yet - very toolkit specific\n");
- ptrarg = va_arg (*args, void *);
+ ptrarg = va_arg (args, void *);
arg = &ptrarg;
break;
default:
void
dbind_any_demarshal_va (DBusMessageIter *iter,
const char **arg_types,
- va_list *args)
+ va_list args)
{
const char *p = *arg_types;
+
+ /* Pass in args */
+ for (;*p != '\0' && *p != '=';) {
+ int intarg;
+ void *ptrarg;
+ double doublearg;
+ dbus_int64_t int64arg;
+ void *arg = NULL;
+
+ switch (*p) {
+ case DBUS_TYPE_BYTE:
+ case DBUS_TYPE_BOOLEAN:
+ case DBUS_TYPE_INT16:
+ case DBUS_TYPE_UINT16:
+ case DBUS_TYPE_INT32:
+ case DBUS_TYPE_UINT32:
+ intarg = va_arg (args, int);
+ break;
+ case DBUS_TYPE_INT64:
+ case DBUS_TYPE_UINT64:
+ int64arg = va_arg (args, dbus_int64_t);
+ break;
+ case DBUS_TYPE_DOUBLE:
+ doublearg = va_arg (args, double);
+ break;
+ /* ptr types */
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ case DBUS_TYPE_ARRAY:
+ case DBUS_TYPE_DICT_ENTRY:
+ ptrarg = va_arg (args, void *);
+ break;
+ case DBUS_STRUCT_BEGIN_CHAR:
+ ptrarg = va_arg (args, void *);
+ break;
+ case DBUS_DICT_ENTRY_BEGIN_CHAR:
+ ptrarg = va_arg (args, void *);
+ break;
+
+ case DBUS_TYPE_VARIANT:
+ fprintf (stderr, "No variant support yet - very toolkit specific\n");
+ ptrarg = va_arg (args, void *);
+ break;
+ default:
+ fprintf (stderr, "Unknown / invalid arg type %c\n", *p);
+ break;
+ }
+ p++;
+ }
+
+ if (p [0] == '=' && p[1] == '>')
+ p += 2;
+
for (;*p != '\0';) {
- void *arg = va_arg (*args, void *);
+ void *arg = va_arg (args, void *);
dbind_any_demarshal (iter, &p, &arg);
}
}
void **val);
void dbind_any_marshal_va (DBusMessageIter *iter,
- const const char **arg_types,
- va_list *args);
+ const char **arg_types,
+ va_list args);
void dbind_any_demarshal (DBusMessageIter *iter,
const char **type,
void dbind_any_demarshal_va (DBusMessageIter *iter,
const char **arg_types,
- va_list *args);
+ va_list args);
void dbind_any_free (const char *type,
void *ptr_to_ptr);
DBusMessageIter iter;
DBusError *err, real_err;
const char *p;
+ va_list args_demarshal;
+ va_copy (args_demarshal, args);
if (opt_error)
err = opt_error;
else {
p = arg_types;
dbus_message_iter_init_append (msg, &iter);
- dbind_any_marshal_va (&iter, &p, &args);
+ dbind_any_marshal_va (&iter, &p, args);
reply = dbind_send_and_allow_reentry (cnx, msg, err);
if (!reply)
if (p[0] == '=' && p[1] == '>')
{
DBusMessageIter iter;
- p += 2;
dbus_message_iter_init (reply, &iter);
- dbind_any_demarshal_va (&iter, &p, &args);
+ p = arg_types;
+ dbind_any_demarshal_va (&iter, &p, args_demarshal);
}
success = TRUE;
if (err == &real_err)
dbus_error_free (err);
+ va_end (args_demarshal);
return success;
}
p = arg_types;
dbus_message_iter_init_append (msg, &iter);
- dbind_any_marshal_va (&iter, &p, &args);
+ dbind_any_marshal_va (&iter, &p, args);
if (!dbus_connection_send (cnx, msg, NULL))
goto out;