#include <string.h>
#include <getopt.h>
#include <stdbool.h>
+#include <gio/gio.h>
#include <assert.h>
+#include <stdint.h>
#define ERROR_STATE -1
#define SAFE_BUFFER_SIZE 2048
#define CHECK 1
#define FIRST_MATCH 2
#define RELATION_TABLE_COLUMN_COUNT 7
-#define RELATION_COLUMN_WIDTH 20
+#define ATTRIBUTE_TABLE_COLUMN_COUNT 3
+#define RELATION_TABLE_COLUMN_WIDTH 20
+#define ATTRIBUTE_TABLE_BASE_COLUMN_WIDTH 20
#define VERSION "1.1"
static unsigned indent_width = 2;
return state_string;
}
-static char *_get_attributes(AtspiAccessible *node, int length_limit)
+static char *_get_attributes(AtspiAccessible *node, int length_limit, bool *attributes_are_too_long)
{
GHashTable *attributes = atspi_accessible_get_attributes(node, NULL);
g_hash_table_iter_init (&attributes_iter, attributes);
char *result = NULL;
while (g_hash_table_iter_next (&attributes_iter, &attr_key, &attr_value)) {
- char attributes_string[ATTR_WIDTH];
- int ret = snprintf(attributes_string, ATTR_WIDTH, "(%s=%s)", (char *)attr_key, (char *)attr_value);
- if (ret >= ATTR_WIDTH)
- fprintf(stderr, "\n_get_attributes: generated string is too long. Buffer overflow\n");
+ char attributes_string[SAFE_BUFFER_SIZE];
+ int ret = snprintf(attributes_string, SAFE_BUFFER_SIZE, "(%s=%s)", (char *)attr_key, (char *)attr_value);
+ if (ret >= SAFE_BUFFER_SIZE)
+ fprintf(stderr, "\n%s, %s %d: generated string is too long. Buffer overflow\n", __FILE__, __FUNCTION__, __LINE__);
_combine_strings(&result, attributes_string);
}
g_hash_table_unref(attributes);
- _truncate_string(result, length_limit);
+ int real_truncate_size = (length_limit < ATTR_WIDTH && length_limit > MINIMAL_MODULE_WIDTH) ? length_limit : ATTR_WIDTH;
+ if (result && attributes_are_too_long && strlen(result) > real_truncate_size)
+ *attributes_are_too_long = true;
+
+ _truncate_string(result, real_truncate_size);
return result;
}
-static char *_get_info(AtspiAccessible *node, int length_limit)
+static char *_get_info(AtspiAccessible *node, int length_limit, bool *attributes_are_too_long, bool *app_has_relations)
{
if (!node)
return NULL;
char *node_name = atspi_accessible_get_name(node, NULL);
char *node_role_name = atspi_accessible_get_role_name(node, NULL);
+ char *unique_id = atspi_accessible_get_unique_id(node, NULL);
char *path = atspi_accessible_get_path(node, NULL);
+ unsigned long long eo_ptr = 0;
+ sscanf(path, "%llu", &eo_ptr);
- char *attributes = _get_attributes(node, length_limit);
+ char *attributes = _get_attributes(node, length_limit, attributes_are_too_long);
Box_Size *box_size = _get_box_size(node);
char *states = _get_states(node, length_limit);
GArray *relations = atspi_accessible_get_relation_set(node, NULL);
+ bool current_node_has_relations = (relations && relations->len);
char result[SAFE_BUFFER_SIZE];
- int ret = snprintf(result, SAFE_BUFFER_SIZE, "[[%s],[%s],[%s],[%s,%s,%s,%s],[%s],[%s],[%s]]",
- path,
+ int ret = snprintf(result, SAFE_BUFFER_SIZE, "[[%s(%p)],[%s],[%s],[%s,%s,%s,%s],[%s],[%s],[%s]]",
+ unique_id, (uintptr_t)eo_ptr,
node_role_name,
attributes,
box_size->x,
box_size->height,
node_name,
states,
- (relations && relations->len) ? "*" : "");
+ current_node_has_relations ? "*" : "");
if (ret >= SAFE_BUFFER_SIZE)
- fprintf(stderr, "\n%s, %s %s: generated string is too long. Buffer overflow\n", __FILE__, __FUNCTION__, __LINE__);
+ fprintf(stderr, "\n%s, %s %d: generated string is too long. Buffer overflow\n", __FILE__, __FUNCTION__, __LINE__);
+
+ if (current_node_has_relations)
+ *app_has_relations = true;
free(node_name);
free(node_role_name);
+ free(unique_id);
free(path);
free(attributes);
if (box_size) {
char parent_status[NUMBER_WIDTH];
if (parent == NULL)
- strncpy(parent_status, NUMBER_WIDTH, "_");
+ strncpy(parent_status, "_", NUMBER_WIDTH);
else
snprintf(parent_status, NUMBER_WIDTH, "%d", parent_index);
- char *parent_path = atspi_accessible_get_path(parent, NULL);
- char *parent_candidate_path = atspi_accessible_get_path(parent_candidate, NULL);
+ char *parent_unique_id = atspi_accessible_get_unique_id(parent, NULL);
+ char *parent_candidate_unique_id = atspi_accessible_get_unique_id(parent_candidate, NULL);
snprintf(output, CHECK_OUTPUT_WIDTH, "[FAIL<%d,%s><%s,%s>]", parent_candidate_index, parent_status,
- parent_candidate_path, parent_path);
- free(parent_path);
- free(parent_candidate_path);
+ parent_candidate_unique_id, parent_unique_id);
+ free(parent_unique_id);
+ free(parent_candidate_unique_id);
} else {
snprintf(output, CHECK_OUTPUT_WIDTH, "[OK]");
printf("%-*s\t", CHECK_OUTPUT_WIDTH, output);
}
-static int _print_atspi_tree_verify_maybe_r(int indent_number, AtspiAccessible *object, bool check_integrity, int length_limit)
+static int _print_atspi_tree_verify_maybe_r(int indent_number, AtspiAccessible *object, bool check_integrity, int length_limit,
+ bool *attributes_are_too_long, bool *app_has_relations)
{
char *indent = _multiply_string(' ', indent_number*indent_width);
if (indent != NULL) {
free(indent);
}
- char *node_info = _get_info(object, length_limit);
+ char *node_info = _get_info(object, length_limit, attributes_are_too_long, app_has_relations);
if (node_info != NULL) {
printf("%s\n", node_info);
free(node_info);
if (check_integrity)
_test_atspi_parent_child_relation(child, object, i);
- _print_atspi_tree_verify_maybe_r(indent_number + 1, child, check_integrity, length_limit);
+ _print_atspi_tree_verify_maybe_r(indent_number + 1, child, check_integrity, length_limit, attributes_are_too_long, app_has_relations);
}
}
return 0;
printf("-v, --version\t\tshow actual version of tool\n");
printf("-g, --show-legend\tprint AT-SPI state legend\n");
printf("-l, --list-apps\t\tlist all applications of desktop\n");
+ printf("-a, --at-spi-client <true|false>\tenable/disable org.a11y.Status.IsEnabled property\n");
+ printf("-s, --sleep <N>\tsleep N seconds\n");
printf("-d, --tree-dump\t\tdump tree for selected application\n");
printf("-c, --tree-check\tcheck tree for selected application\n");
printf("-f, --first-match\tperform dump or check only for first matching application\n");
printf("AT-SPI2-CORE-UTIL v%s\n", VERSION);
}
-static void _print_horizontal_line_in_relation_table() {
+static void _print_horizontal_line_in_relations_table() {
for (int i = 0; i < RELATION_TABLE_COLUMN_COUNT; i++) {
- for (int j = 0; j < RELATION_COLUMN_WIDTH; j++)
+ for (int j = 0; j < RELATION_TABLE_COLUMN_WIDTH; j++)
printf("-");
printf("+");
}
printf("\n");
}
-static void _print_legend_for_relation_table() {
- char *table[] = {"OBJECT", "CONTROLLER_FOR", "CONTROLLED_BY", "FLOWS_TO", "FLOWS_FROM", "DESCRIBED_BY", "OTHER RELATION [ID]"};
- assert(sizeof(table) / sizeof(table[0]) == RELATION_TABLE_COLUMN_COUNT);
- for(int i = 0; i < RELATION_TABLE_COLUMN_COUNT; i++)
- printf("%*s|", RELATION_COLUMN_WIDTH , table[i]);
- printf("\n");
- _print_horizontal_line_in_relation_table();
-}
-
-static char *_get_path_to_object_in_relation(AtspiRelation *relation) {
+static char *_get_unique_id_of_object_in_relation(AtspiRelation *relation) {
if (!relation)
return NULL;
+
gint last_index = atspi_relation_get_n_targets(relation) - 1;
AtspiAccessible *target = atspi_relation_get_target(relation, last_index);
- return atspi_accessible_get_path(target, NULL);
+ return atspi_accessible_get_unique_id(target, NULL);
}
static void _print_relations_for_object(AtspiAccessible *node) {
if (!relations)
return;
- if (relations->len) {
- int size = RELATION_TABLE_COLUMN_COUNT * sizeof(char *);
- char **table = malloc(size);
- memset(table, 0, size);
- table[0] = atspi_accessible_get_path(node, NULL);
- char buf[8] = "";
- for (int i = 0; i < relations->len; i++) {
- AtspiRelation *relation = g_array_index(relations, AtspiRelation *, i);
- AtspiRelationType type = atspi_relation_get_relation_type(relation);
- switch (type) {
- case ATSPI_RELATION_CONTROLLER_FOR:
- table[1] = _get_path_to_object_in_relation(relation);
- break;
- case ATSPI_RELATION_CONTROLLED_BY:
- table[2] = _get_path_to_object_in_relation(relation);
- break;
- case ATSPI_RELATION_FLOWS_TO:
- table[3] = _get_path_to_object_in_relation(relation);
- break;
- case ATSPI_RELATION_FLOWS_FROM:
- table[4] = _get_path_to_object_in_relation(relation);
- break;
- case ATSPI_RELATION_DESCRIBED_BY:
- table[5] = _get_path_to_object_in_relation(relation);
- break;
- default:
- snprintf(buf, 8, " [%d]", type);
- _combine_strings(&table[RELATION_TABLE_COLUMN_COUNT - 1], buf);
- }
+ if (!relations->len) {
+ g_array_free(relations, FALSE);
+ return;
+ }
+
+ char **table = calloc(RELATION_TABLE_COLUMN_COUNT, sizeof(char *));
+ if (!table) {
+ fprintf(stderr, "Calloc failed. Can't alloc memory for object relations string\n");
+ return;
+ }
+
+ table[0] = atspi_accessible_get_unique_id(node, NULL);
+ for (int i = 0; i < relations->len; i++) {
+ AtspiRelation *relation = g_array_index(relations, AtspiRelation *, i);
+ AtspiRelationType type = atspi_relation_get_relation_type(relation);
+ int idx;
+ switch (type) {
+ case ATSPI_RELATION_CONTROLLER_FOR: idx = 1; break;
+ case ATSPI_RELATION_CONTROLLED_BY: idx = 2; break;
+ case ATSPI_RELATION_FLOWS_TO: idx = 3; break;
+ case ATSPI_RELATION_FLOWS_FROM: idx = 4; break;
+ case ATSPI_RELATION_DESCRIBED_BY: idx = 5; break;
+ default: idx = 0;
}
- for (int i = 0; i < RELATION_TABLE_COLUMN_COUNT; i++) {
- printf("%*s|", RELATION_COLUMN_WIDTH, table[i] ? table[i] : "");
- free(table[i]);
+ if (idx > 0)
+ table[idx] = _get_unique_id_of_object_in_relation(relation);
+ else {
+ char buf[16];
+ snprintf(buf, sizeof(buf), " [%d]", type);
+ _combine_strings(&table[RELATION_TABLE_COLUMN_COUNT - 1], buf);
}
- free(table);
+ }
- printf("\n");
- _print_horizontal_line_in_relation_table();
+ for (int i = 0; i < RELATION_TABLE_COLUMN_COUNT; i++) {
+ printf("%*s|", RELATION_TABLE_COLUMN_WIDTH, table[i] ? table[i] : "");
+ free(table[i]);
}
+ free(table);
+
+ printf("\n");
+ _print_horizontal_line_in_relations_table();
g_array_free(relations, TRUE);
+}
+
+typedef void (*print_information_about_object_function)(AtspiAccessible *);
+
+static void _iterate_over_tree(print_information_about_object_function func, AtspiAccessible *node) {
+ func(node);
int count = atspi_accessible_get_child_count(node, NULL);
for (int i = 0; i < count; i++) {
AtspiAccessible *child = atspi_accessible_get_child_at_index(node, i, NULL);
if (child)
- _print_relations_for_object(child);
+ _iterate_over_tree(func, child);
+ }
+}
+
+static void _print_relations_for_objects_in_tree(AtspiAccessible *node) {
+ _iterate_over_tree(_print_relations_for_object, node);
+}
+
+static void _print_header_for_relation_table() {
+ char *table[] = {"OBJECT", "CONTROLLER_FOR", "CONTROLLED_BY", "FLOWS_TO", "FLOWS_FROM", "DESCRIBED_BY", "OTHER RELATION [ID]"};
+ assert(ARRAY_SIZE(table) == RELATION_TABLE_COLUMN_COUNT);
+
+ _print_horizontal_line_in_relations_table();
+
+ for (int i = 0; i < RELATION_TABLE_COLUMN_COUNT; i++)
+ printf("%*s|", RELATION_TABLE_COLUMN_WIDTH , table[i]);
+
+ printf("\n");
+ _print_horizontal_line_in_relations_table();
+}
+
+static void _print_relations_table(AtspiAccessible *node) {
+ printf("\nRELATIONS TABLE\n");
+ _print_header_for_relation_table();
+ _print_relations_for_objects_in_tree(node);
+}
+
+static void _print_horizontal_line_in_attributes_table() {
+ int size_factor = 1;
+ for (int i = 0; i < ATTRIBUTE_TABLE_COLUMN_COUNT; i++) {
+ if (i == ATTRIBUTE_TABLE_COLUMN_COUNT - 1)
+ size_factor = 4;
+ for (int j = 0; j < ATTRIBUTE_TABLE_BASE_COLUMN_WIDTH * size_factor; j++)
+ printf("-");
+ printf("+");
}
+ printf("\n");
}
-static void _atspi_tree_traverse(AtspiAccessible *desktop, const char *app_name, bool dump, bool check, bool first_match, int length_limit)
+static void _print_attributes_for_object(AtspiAccessible *node) {
+ GHashTable *attributes = atspi_accessible_get_attributes(node, NULL);
+
+ if (!attributes)
+ return;
+
+ char *unique_id = atspi_accessible_get_unique_id(node, NULL);
+ GHashTableIter attributes_iter;
+ gpointer attr_key;
+ gpointer attr_value;
+
+ g_hash_table_iter_init (&attributes_iter, attributes);
+ while (g_hash_table_iter_next (&attributes_iter, &attr_key, &attr_value)) {
+ printf("%*s|", ATTRIBUTE_TABLE_BASE_COLUMN_WIDTH, unique_id ? unique_id : "");
+ printf("%*s|", ATTRIBUTE_TABLE_BASE_COLUMN_WIDTH, attr_key ? (char *) attr_key : "");
+ printf("%*s|\n", ATTRIBUTE_TABLE_BASE_COLUMN_WIDTH * 4, attr_value ? (char *) attr_value : "");
+ }
+
+ if (g_hash_table_size (attributes))
+ _print_horizontal_line_in_attributes_table();
+
+ g_hash_table_unref(attributes);
+ free(unique_id);
+}
+
+static void _print_attributes_for_objects_in_tree(AtspiAccessible *node) {
+ _iterate_over_tree(_print_attributes_for_object, node);
+}
+
+static void _print_header_for_attributes_table() {
+ char *table[] = {"OBJECT", "ATTRIBUTE KEY", "ATTRIBUTE VALUE"};
+ assert(ARRAY_SIZE(table) == ATTRIBUTE_TABLE_COLUMN_COUNT);
+
+ _print_horizontal_line_in_attributes_table();
+
+ int size_factor = 1;
+ for (int i = 0; i < ATTRIBUTE_TABLE_COLUMN_COUNT; i++) {
+ if (i == ATTRIBUTE_TABLE_COLUMN_COUNT - 1)
+ size_factor = 4;
+ printf("%*s|", ATTRIBUTE_TABLE_BASE_COLUMN_WIDTH * size_factor , table[i]);
+ }
+
+ printf("\n");
+ _print_horizontal_line_in_attributes_table();
+}
+
+static void _print_attributes_table(AtspiAccessible *node) {
+ printf("\nATTRIBUTES TABLE\n");
+ _print_header_for_attributes_table();
+ _print_attributes_for_objects_in_tree(node);
+}
+
+static void _atspi_tree_traverse(const char *app_name, bool dump, bool check, bool first_match, int length_limit)
{
+
+ AtspiAccessible *desktop = atspi_get_desktop(0);
+ if (!desktop) {
+ fprintf(stderr, "atspi_get_desktop failed\n");
+ return;
+ }
+
int count = atspi_accessible_get_child_count(desktop, NULL);
bool app_name_matched = false;
+
for (int i = 0; i < count; i++) {
AtspiAccessible *child = atspi_accessible_get_child_at_index(desktop, i, NULL);
if (child == NULL) {
- fprintf(stderr, "\n%s, %s %s: Null child occured. Results may be misleading.\n", __FILE__, __FUNCTION__, __LINE__);
+ fprintf(stderr, "\n%s, %s %d: Null application occured. Results may be misleading.\n", __FILE__, __FUNCTION__, __LINE__);
continue;
}
char *name = atspi_accessible_get_name(child, NULL);
+ bool attributes_are_too_long = false;
+ bool app_has_relations = false;
if (!dump && !check)
printf("%s\n", name);
if (check)
_test_atspi_parent_child_relation(child, desktop, i);
- _print_atspi_tree_verify_maybe_r(0, child, check, length_limit);
+ _print_atspi_tree_verify_maybe_r(0, child, check, length_limit, &attributes_are_too_long, &app_has_relations);
+
+ if (app_has_relations)
+ _print_relations_table(child);
+
+ if (attributes_are_too_long)
+ _print_attributes_table(child);
if (first_match) {
free(name);
break;
} else {
printf("\n");
- _print_legend_for_relation_table();
- _print_relations_for_object(child);
}
free(name);
if (!app_name_matched && (dump || check))
fprintf(stderr, "There is no application with name: %s. Try again.\n", app_name);
+
+ g_object_unref(desktop);
+}
+
+static void _at_spi_client_enable(gboolean enabled)
+{
+ static GDBusProxy *proxy = NULL; //we keep proxy (dbus connection) until program exits
+ GVariant *result;
+ GError *error = NULL;
+ GDBusProxyFlags flags = G_DBUS_PROXY_FLAGS_NONE;
+
+
+ if (!proxy) {
+ proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+ flags,
+ NULL, /* GDBusInterfaceInfo */
+ "org.a11y.Bus",
+ "/org/a11y/bus",
+ "org.freedesktop.DBus.Properties",
+ NULL, /* GCancellable */
+ &error);
+ if (error) {
+ fprintf(stderr, "Failed to create proxy object for '/org/a11y/bus': %s\n", error->message);
+ g_error_free(error);
+ return;
+ }
+ }
+
+ result = g_dbus_proxy_call_sync(proxy,
+ "Set",
+ g_variant_new ("(ssv)", "org.a11y.Status", "IsEnabled", g_variant_new_boolean(enabled)),
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (result)
+ g_variant_unref(result);
+
+ if (error) {
+ fprintf(stderr, "Fail to call org.freedesktop.DBus.Properties.Set: %s\n", error->message);
+ g_error_free(error);
+ }
}
-static void _run_command(int argc, char *argv[], AtspiAccessible *desktop)
+static void _run_command(int argc, char *argv[])
{
struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"show-legend", no_argument, 0, 'g'},
{"list-apps", no_argument, 0, 'l'},
+ {"at-spi-client", no_argument, 0, 'a'},
+ {"sleep", required_argument, 0, 's'},
{"tree-dump", required_argument, 0, 'd'},
{"tree-check", required_argument, 0, 'c'},
{"first-match", no_argument, 0, 'f'},
int option_index = 0;
bool traverse_flags[FLAG_NO] = {false};
char *app_name = NULL;
+ gboolean enable_at_spi_client;
while (TRUE) {
- command = getopt_long(argc, argv, "hvgld:c:ft:i:", long_options, &option_index);
+ command = getopt_long(argc, argv, "hvgla:s:d:c:ft:i:", long_options, &option_index);
if (command == ERROR_STATE)
break;
break;
case 'l':
- _atspi_tree_traverse(desktop, NULL, false, false, false, module_name_limit);
+ _atspi_tree_traverse(NULL, false, false, false, module_name_limit);
+ break;
+
+ case 'a':
+ enable_at_spi_client = TRUE;
+ if (optarg[0] == 'f' || optarg[0] == '0')
+ enable_at_spi_client = FALSE;
+
+ _at_spi_client_enable(enable_at_spi_client);
+ break;
+
+ case 's':
+ sleep(atoi(optarg));
break;
case 'd':
}
if (traverse_flags[DUMP] || traverse_flags[CHECK])
- _atspi_tree_traverse(desktop, app_name, traverse_flags[DUMP], traverse_flags[CHECK], traverse_flags[FIRST_MATCH], module_name_limit);
+ _atspi_tree_traverse(app_name, traverse_flags[DUMP], traverse_flags[CHECK], traverse_flags[FIRST_MATCH], module_name_limit);
}
int main(int argc, char *argv[])
return -1;
}
- AtspiAccessible *desktop = atspi_get_desktop(0);
- if (!desktop) {
- fprintf(stderr, "atspi_get_desktop failed\n");
- return -1;
- }
-
- _run_command(argc, argv, desktop);
+ _run_command(argc, argv);
return 0;
}
projects / platform / upstream / at-spi2-core.git / blobdiff