From b93cda6fb2cf86a88299c032f1db9e399e9a4f38 Mon Sep 17 00:00:00 2001 From: Lukasz Stanislawski Date: Mon, 13 Jan 2014 15:24:35 +0900 Subject: [PATCH] atspi: accessible and component interface implementation. Reviewers: raster, cedric, kimcinoo, seoz Reviewed By: raster CC: pkaczmarek-samsung, z.kosinski Differential Revision: https://phab.enlightenment.org/D378 --- src/lib/Elementary.h.in | 1 + src/lib/Makefile.am | 8 +- src/lib/elm_atspi_bridge.c | 692 ++++++++++++++++++++++++++++++-- src/lib/elm_atspi_object.c | 824 ++++++++++++++++++++++++++++++++++++++ src/lib/elm_atspi_object.h | 9 + src/lib/elm_atspi_object_common.h | 1 + src/lib/elm_atspi_object_eo.h | 311 ++++++++++++++ src/lib/elm_atspi_object_legacy.h | 1 + 8 files changed, 1809 insertions(+), 38 deletions(-) create mode 100644 src/lib/elm_atspi_object.c create mode 100644 src/lib/elm_atspi_object.h create mode 100644 src/lib/elm_atspi_object_common.h create mode 100644 src/lib/elm_atspi_object_eo.h create mode 100644 src/lib/elm_atspi_object_legacy.h diff --git a/src/lib/Elementary.h.in b/src/lib/Elementary.h.in index 30164d9..2bad289 100644 --- a/src/lib/Elementary.h.in +++ b/src/lib/Elementary.h.in @@ -161,6 +161,7 @@ EAPI extern Elm_Version *elm_version; /* special widgets - types used elsewhere */ #include +#include #include #include #include diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am index 7ea8e5a..c63863d 100644 --- a/src/lib/Makefile.am +++ b/src/lib/Makefile.am @@ -379,7 +379,11 @@ elm_web_legacy.h \ elm_win.h \ elm_win_common.h \ elm_win_eo.h \ -elm_win_legacy.h +elm_win_legacy.h \ +elm_atspi_object.h \ +elm_atspi_object_common.h \ +elm_atspi_object_eo.h \ +elm_atspi_object_legacy.h includesubdir = $(includedir)/elementary-@VMAJ@/ libelementary_la_SOURCES = \ @@ -483,9 +487,9 @@ els_box.c \ els_cursor.c \ els_tooltip.c \ elu_ews_wm.c \ +elm_atspi_object.c \ elm_atspi_bridge.c - libelementary_la_CFLAGS = libelementary_la_LIBADD = \ @my_libs@ \ diff --git a/src/lib/elm_atspi_bridge.c b/src/lib/elm_atspi_bridge.c index 79f5e26..3523322 100644 --- a/src/lib/elm_atspi_bridge.c +++ b/src/lib/elm_atspi_bridge.c @@ -2,6 +2,7 @@ # include "elementary_config.h" #endif +#include #include #include "elm_priv.h" @@ -14,58 +15,245 @@ #define A11Y_DBUS_PATH "/org/a11y/bus" #define A11Y_DBUS_INTERFACE "org.a11y.Bus" +#define CACHE_ITEM_SIGNATURE "((so)(so)(so)a(so)assusau)" +#define CACHE_INTERFACE_PATH "/org/a11y/atspi/cache" + +#define ELM_ACCESS_OBJECT_PATH_ROOT "root" +#define ELM_ACCESS_OBJECT_PATH_PREFIX "/org/a11y/atspi/accessible/" +#define ELM_ACCESS_OBJECT_REFERENCE_TEMPLATE ELM_ACCESS_OBJECT_PATH_PREFIX "%u" + static int _init_count = 0; static Eldbus_Connection *_a11y_bus = NULL; +static Elm_Atspi_Object *_root; +static Eina_Hash *_cache; +static Eldbus_Service_Interface *_cache_interface = NULL; +static Elm_Atspi_Object * _access_object_from_path(const char *path); +static char * _path_from_access_object(Elm_Atspi_Object *eo); +static void object_append_reference(Eldbus_Message_Iter *iter, Elm_Atspi_Object *obj); +static void object_append_desktop_reference(Eldbus_Message_Iter *iter); +static const Eldbus_Service_Interface_Desc accessible_iface_desc; + +enum +{ + ADD_ACCESSIBLE = 0, + REMOVE_ACCESSIBLE +}; static Eldbus_Message * -_role_get(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +_accessible_get_role(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) { + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + AtspiRole role; + + eo_do(obj, elm_atspi_obj_role_get(&role)); Eldbus_Message *ret = eldbus_message_method_return_new(msg); - eldbus_message_arguments_append(ret, "u", ATSPI_ROLE_APPLICATION); + eldbus_message_arguments_append(ret, "u", role); return ret; } static Eldbus_Message * -_role_name_get(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +_accessible_get_role_name(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) { - // Currently only root object is available. + const char *role_name, *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + + eo_do(obj, elm_atspi_obj_role_name_get(&role_name)); Eldbus_Message *ret = eldbus_message_method_return_new(msg); - eldbus_message_arguments_append(ret, "s", "application"); + eldbus_message_arguments_append(ret, "s", role_name); return ret; } -#ifdef ENABLE_NLS static Eldbus_Message * -_role_localized_name_get(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +_accessible_get_localized_role_name(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) { - // Currently only root object is available. + const char *l_role_name, *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + + eo_do(obj, elm_atspi_obj_localized_role_name_get(&l_role_name)); Eldbus_Message *ret = eldbus_message_method_return_new(msg); - eldbus_message_arguments_append(ret, "s", gettext("application")); + eldbus_message_arguments_append(ret, "s", l_role_name); + + return ret; +} + +static Eldbus_Message * +_accessible_get_children(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + Eina_List *children_list = NULL, *l; + Eldbus_Message *ret; + Eldbus_Message_Iter *iter, *iter_array; + Elm_Atspi_Object *children; + + eo_do(obj, elm_atspi_obj_children_get(&children_list)); + + ret = eldbus_message_method_return_new(msg); + iter = eldbus_message_iter_get(ret); + iter_array = eldbus_message_iter_container_new(iter, 'a', "(so)"); + + EINA_LIST_FOREACH(children_list, l, children) + object_append_reference(iter_array, children); + + eldbus_message_iter_container_close(iter, iter_array); + eina_list_free(children_list); + return ret; +} + +static Eldbus_Message * +_accessible_get_application(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + Eldbus_Message *ret = eldbus_message_method_return_new(msg); + Eldbus_Message_Iter *iter = eldbus_message_iter_get(ret); + object_append_reference(iter, _root); + + return ret; +} + +static Eldbus_Message * +_accessible_get_state(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + Eldbus_Message *ret = eldbus_message_method_return_new(msg); + Eldbus_Message_Iter *iter = eldbus_message_iter_get(ret); + Eldbus_Message_Iter *iter_array; + + iter_array = eldbus_message_iter_container_new(iter, 'a', "u"); + /* TODO: states are not implemented yet*/ + eldbus_message_iter_container_close(iter, iter_array); + + return ret; +} + +static Eldbus_Message * +_accessible_get_index_in_parent(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + Eldbus_Message *ret = eldbus_message_method_return_new(msg); + int index; + + eo_do(obj, elm_atspi_obj_index_in_parent_get(&index)); + eldbus_message_arguments_append(ret, "i", index); + + return ret; +} + +static Eldbus_Message * +_accessible_child_at_index(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + Elm_Atspi_Object *child; + int index; + Eldbus_Message *ret; + Eldbus_Message_Iter *iter; + + if (!eldbus_message_arguments_get(msg, "i", &index)) + return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid index type."); + + ret = eldbus_message_method_return_new(msg); + iter = eldbus_message_iter_get(ret); + eo_do(obj, elm_atspi_obj_child_at_index_get(index, &child)); + object_append_reference(iter, child); return ret; } -#endif static const Eldbus_Method accessible_methods[] = { - { "GetRole", NULL, ELDBUS_ARGS({"u", "Role"}), _role_get, 0 }, - { "GetRoleName", NULL, ELDBUS_ARGS({"s", "Name"}), _role_name_get, 0 }, -#ifdef ENABLE_NLS - { "GetLocalizedRoleName", NULL, ELDBUS_ARGS({"s", "LocalizedName"}), _role_localized_name_get, 0}, -#else - { "GetLocalizedRoleName", NULL, ELDBUS_ARGS({"s", "LocalizedName"}), _role_name_get, 0}, -#endif + { "GetChildAtIndex", ELDBUS_ARGS({"i", "index"}), ELDBUS_ARGS({"(so)", "Accessible"}), _accessible_child_at_index, 0 }, + { "GetChildren", NULL, ELDBUS_ARGS({"a(so)", "children"}), _accessible_get_children, 0 }, + { "GetIndexInParent", NULL, ELDBUS_ARGS({"i", "index"}), _accessible_get_index_in_parent, 0 }, + { "GetRelationSet", NULL, ELDBUS_ARGS({"a(ua(so))", NULL}), _accessible_get_state, 0 }, + { "GetRole", NULL, ELDBUS_ARGS({"u", "Role"}), _accessible_get_role, 0 }, + { "GetRoleName", NULL, ELDBUS_ARGS({"s", "Name"}), _accessible_get_role_name, 0 }, + { "GetLocalizedRoleName", NULL, ELDBUS_ARGS({"s", "LocalizedName"}), _accessible_get_localized_role_name, 0}, + { "GetState", NULL, ELDBUS_ARGS({"au", NULL}), _accessible_get_state, 0}, + { "GetApplication", NULL, ELDBUS_ARGS({"(so)", NULL}), _accessible_get_application, 0}, + //{ "GetAttributes", NULL, ELDBUS_ARGS({"a{ss}", NULL}), NULL, 0}, { NULL, NULL, NULL, NULL, 0 } }; +static Elm_Atspi_Object * +_access_object_from_path(const char *path) +{ + EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL); + uintptr_t eo_ptr = NULL; + Elm_Atspi_Object *eo = NULL; + const char* tmp = path; + + int len = (sizeof(ELM_ACCESS_OBJECT_PATH_PREFIX) / sizeof(char)) - 1; + + if (strncmp(path, ELM_ACCESS_OBJECT_PATH_PREFIX, len)) + return NULL; + + tmp = path + len; /* Skip over the prefix */ + if (!strcmp(ELM_ACCESS_OBJECT_PATH_ROOT, tmp)) + return _root; + + sscanf(tmp, "%u", &eo_ptr); + eo = (Elm_Atspi_Object *)eo_ptr; + return eo_isa(eo, ELM_ATSPI_CLASS) ? eo : NULL; +} + +static char * +_path_from_access_object(Elm_Atspi_Object *eo) +{ + char path[256]; + + EINA_SAFETY_ON_NULL_RETURN_VAL(eo, strdup(ATSPI_DBUS_PATH_NULL)); + if (eo == _root) + snprintf(path, sizeof(path), "%s%s", ELM_ACCESS_OBJECT_PATH_PREFIX, ELM_ACCESS_OBJECT_PATH_ROOT); + else + snprintf(path, sizeof(path), ELM_ACCESS_OBJECT_REFERENCE_TEMPLATE, (uintptr_t)eo); + return strdup(path); +} + static Eina_Bool -_accessible_property_get(const Eldbus_Service_Interface *interface EINA_UNUSED, const char *property, +_accessible_property_get(const Eldbus_Service_Interface *interface, const char *property, Eldbus_Message_Iter *iter, const Eldbus_Message *request_msg EINA_UNUSED, Eldbus_Message **error EINA_UNUSED) { + const char *ret, *obj_path = eldbus_service_object_path_get(interface); + + Elm_Atspi_Object *ret_obj = NULL, *obj = _access_object_from_path(obj_path); + + EINA_SAFETY_ON_NULL_RETURN_VAL(obj, EINA_FALSE); + if (!strcmp(property, "Name")) { - eldbus_message_iter_basic_append(iter, 's', elm_app_name_get()); + eo_do(obj, elm_atspi_obj_name_get(&ret)); + if (!ret) + ret = ""; + eldbus_message_iter_basic_append(iter, 's', ret); + return EINA_TRUE; + } + else if (!strcmp(property, "Description")) + { + eo_do(obj, elm_atspi_obj_description_get(&ret)); + if (!ret) + ret = ""; + eldbus_message_iter_basic_append(iter, 's', ret); + return EINA_TRUE; + } + else if (!strcmp(property, "Parent")) + { + eo_do(obj, elm_atspi_obj_parent_get(&ret_obj)); + AtspiRole role; + eo_do(obj, elm_atspi_obj_role_get(&role)); + if ((!ret_obj) && (ATSPI_ROLE_APPLICATION == role)) + object_append_desktop_reference(iter); + else + object_append_reference(iter, ret_obj); + return EINA_TRUE; + } + else if (!strcmp(property, "ChildCount")) + { + Eina_List *l = NULL; + eo_do(obj, elm_atspi_obj_children_get(&l)); + eldbus_message_iter_basic_append(iter, 'i', eina_list_count(l)); + eina_list_free(l); return EINA_TRUE; } return EINA_FALSE; @@ -73,6 +261,9 @@ _accessible_property_get(const Eldbus_Service_Interface *interface EINA_UNUSED, static const Eldbus_Property accessible_properties[] = { { "Name", "s", NULL, NULL, 0 }, + { "Description", "s", NULL, NULL, 0 }, + { "Parent", "(so)", NULL, NULL, 0 }, + { "ChildCount", "i", NULL, NULL, 0 }, { NULL, NULL, NULL, NULL, 0 } }; @@ -81,6 +272,428 @@ static const Eldbus_Service_Interface_Desc accessible_iface_desc = { }; static void +object_append_reference(Eldbus_Message_Iter *iter, Elm_Atspi_Object *obj){ + + Eldbus_Message_Iter *iter_struct = eldbus_message_iter_container_new(iter, 'r', NULL); + char *path = _path_from_access_object(obj); + eldbus_message_iter_basic_append(iter_struct, 's', eldbus_connection_unique_name_get(_a11y_bus)); + eldbus_message_iter_basic_append(iter_struct, 'o', path); + eldbus_message_iter_container_close(iter, iter_struct); + free(path); +} + +static void +object_append_desktop_reference(Eldbus_Message_Iter *iter){ + + Eldbus_Message_Iter *iter_struct = eldbus_message_iter_container_new(iter, 'r', NULL); + + eldbus_message_iter_basic_append(iter_struct, 's', ATSPI_DBUS_NAME_REGISTRY); + eldbus_message_iter_basic_append(iter_struct, 'o', ATSPI_DBUS_PATH_ROOT); + eldbus_message_iter_container_close(iter, iter_struct); +} + +static Eina_Bool +_append_item_fn(const Eina_Hash *hash EINA_UNUSED, const void *key EINA_UNUSED, void *data, void *fdata) +{ + + if (!eo_ref_get(data) || eo_destructed_is(data)) + return EINA_TRUE; + + Eldbus_Message_Iter *iter_struct, *iter_sub_array; + Eldbus_Message_Iter *iter_array = fdata; + + AtspiRole role; + eo_do(data, elm_atspi_obj_role_get(&role)); + + iter_struct = eldbus_message_iter_container_new(iter_array, 'r', NULL); + /* Marshall object path */ + object_append_reference(iter_struct, data); + + /* Marshall application */ + object_append_reference(iter_struct, _root); + + Elm_Atspi_Object *parent = NULL; + eo_do(data, elm_atspi_obj_parent_get(&parent)); + /* Marshall parent */ + if ((!parent) && (ATSPI_ROLE_APPLICATION == role)) + object_append_desktop_reference(iter_struct); + else + object_append_reference(iter_struct, parent); + + /* Marshall children */ + Eina_List *children_list = NULL, *l; + Elm_Atspi_Object *child; + + eo_do(data, elm_atspi_obj_children_get(&children_list)); + iter_sub_array = eldbus_message_iter_container_new(iter_struct, 'a', "(so)"); + EINA_LIST_FOREACH(children_list, l, child) + object_append_reference(iter_sub_array, child); + + eldbus_message_iter_container_close(iter_struct, iter_sub_array); + eina_list_free(children_list); + + /* Marshall interfaces */ + iter_sub_array = eldbus_message_iter_container_new(iter_struct, 'a', "s"); + + eldbus_message_iter_basic_append(iter_sub_array, 's', ATSPI_DBUS_INTERFACE_ACCESSIBLE); + if (eo_isa(data, ELM_ATSPI_COMPONENT_INTERFACE)) + eldbus_message_iter_basic_append(iter_sub_array, 's', ATSPI_DBUS_INTERFACE_COMPONENT); + + eldbus_message_iter_container_close(iter_struct, iter_sub_array); + + /* Marshall name */ + const char *name = NULL; + eo_do(data, elm_atspi_obj_name_get(&name)); + if (!name) + name = ""; + eldbus_message_iter_basic_append(iter_struct, 's', name); + + /* Marshall role */ + eldbus_message_iter_basic_append(iter_struct, 'u', role); + + /* Marshall description */ + const char* descritpion = NULL; + eo_do(data, elm_atspi_obj_description_get(&descritpion)); + if (!descritpion) + descritpion = ""; + eldbus_message_iter_basic_append(iter_struct, 's', descritpion); + + /* Marshall state set */ + iter_sub_array = eldbus_message_iter_container_new(iter_struct, 'a', "u"); + /* TODO: states are not implemented yet*/ + eldbus_message_iter_container_close(iter_struct, iter_sub_array); + + eldbus_message_iter_container_close(iter_array, iter_struct); + + return EINA_TRUE; +} + +static Eldbus_Message * +_cache_get_items(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + Eldbus_Message *ret = eldbus_message_method_return_new(msg); + Eldbus_Message_Iter *iter, *iter_array; + iter = eldbus_message_iter_get(ret); + iter_array = eldbus_message_iter_container_new(iter, 'a', CACHE_ITEM_SIGNATURE); + eina_hash_foreach(_cache, _append_item_fn, iter_array); + eldbus_message_iter_container_close(iter, iter_array); + return ret; +} + +static const Eldbus_Method cache_methods[] = { + { "GetItems", NULL, ELDBUS_ARGS({CACHE_ITEM_SIGNATURE, "items"}), _cache_get_items, 0 }, + { NULL, NULL, NULL, NULL, 0 } +}; + +static const Eldbus_Signal cache_signals[] = { + [ADD_ACCESSIBLE] = { "AddAccessible", ELDBUS_ARGS({"((so)(so)a(so)assusau)", "added"}), 0}, + [REMOVE_ACCESSIBLE] = { "RemoveAccessible", ELDBUS_ARGS({ "(so)", "removed" }), 0}, + {NULL, NULL, 0} +}; + +static const Eldbus_Service_Interface_Desc cache_iface_desc = { + ATSPI_DBUS_INTERFACE_CACHE, cache_methods, cache_signals, NULL, NULL, NULL +}; + +// Component interface +static Eldbus_Message * +_component_contains(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int x, y; + Eina_Bool contains; + AtspiCoordType coord_type; + Eldbus_Message *ret; + + if (!eldbus_message_arguments_get(msg, "iiu", &x, &y, &coord_type)) + return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid index type."); + + eo_do(obj, elm_atspi_component_interface_contains(x, y, coord_type, &contains)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "b", contains); + + return ret; +} + +static Eldbus_Message * +_component_get_accessible_at_point(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int x, y; + Elm_Atspi_Object *accessible; + AtspiCoordType coord_type; + Eldbus_Message *ret; + Eldbus_Message_Iter *iter; + + if (!eldbus_message_arguments_get(msg, "iiu", &x, &y, &coord_type)) + return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid index type."); + + ret = eldbus_message_method_return_new(msg); + iter = eldbus_message_iter_get(ret); + eo_do(obj, elm_atspi_component_interface_accessible_at_point_get(x, y, coord_type, &accessible)); + object_append_reference(iter, accessible); + + return ret; +} + +static Eldbus_Message * +_component_get_extents(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int x, y, w, h; + AtspiCoordType coord_type; + Eldbus_Message *ret; + Eldbus_Message_Iter *iter, *iter_struct; + + if (!eldbus_message_arguments_get(msg, "u", &coord_type)) + return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid index type."); + + ret = eldbus_message_method_return_new(msg); + iter = eldbus_message_iter_get(ret); + + eo_do(obj, elm_atspi_component_interface_extents_get(&x, &y, &w, &h, coord_type)); + iter_struct = eldbus_message_iter_container_new(iter, 'r', NULL); + eldbus_message_iter_basic_append(iter_struct, 'i', x); + eldbus_message_iter_basic_append(iter_struct, 'i', y); + eldbus_message_iter_basic_append(iter_struct, 'i', w); + eldbus_message_iter_basic_append(iter_struct, 'i', h); + eldbus_message_iter_container_close(iter, iter_struct); + + return ret; +} + +static Eldbus_Message * +_component_get_position(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int x, y; + AtspiCoordType coord_type; + Eldbus_Message *ret; + + if (!eldbus_message_arguments_get(msg, "u", &coord_type)) + return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid index type."); + + eo_do(obj, elm_atspi_component_interface_position_get(&x, &y, coord_type)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "i", x); + eldbus_message_arguments_append(ret, "i", y); + + return ret; +} + +static Eldbus_Message * +_component_get_size(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int x, y; + Eldbus_Message *ret; + + eo_do(obj, elm_atspi_component_interface_size_get(&x, &y)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "i", x); + eldbus_message_arguments_append(ret, "i", y); + + return ret; +} + +static Eldbus_Message * +_component_get_layer(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int layer; + Eldbus_Message *ret; + + eo_do(obj, elm_atspi_component_interface_layer_get(&layer)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "u", layer); + + return ret; +} + +static Eldbus_Message * +_component_grab_focus(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + Eldbus_Message *ret; + Eina_Bool focus; + + eo_do(obj, elm_atspi_component_interface_focus_grab(&focus)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "b", focus); + + return ret; +} + +static Eldbus_Message * +_component_get_alpha(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + Eldbus_Message *ret; + double alpha; + + eo_do(obj, elm_atspi_component_interface_alpha_get(&alpha)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "d", alpha); + + return ret; +} + +static Eldbus_Message * +_component_set_extends(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int x, y, w, h; + Eina_Bool result; + AtspiCoordType coord_type; + Eldbus_Message *ret; + + if (!eldbus_message_arguments_get(msg, "iiiiu", &x, &y, &w, &h, &coord_type)) + return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid index type."); + + eo_do(obj, elm_atspi_component_interface_extents_set(x, y, w, h, coord_type, &result)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "b", result); + + return ret; +} + +static Eldbus_Message * +_component_set_position(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int x, y; + Eina_Bool result; + AtspiCoordType coord_type; + Eldbus_Message *ret; + + if (!eldbus_message_arguments_get(msg, "iiu", &x, &y, &coord_type)) + return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid index type."); + + eo_do(obj, elm_atspi_component_interface_position_set(x, y, coord_type, &result)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "b", result); + + return ret; +} + +static Eldbus_Message * +_component_set_size(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg) +{ + const char *obj_path = eldbus_service_object_path_get(iface); + Elm_Atspi_Object *obj = _access_object_from_path(obj_path); + int w, h; + Eina_Bool result; + Eldbus_Message *ret; + + if (!eldbus_message_arguments_get(msg, "ii", &w, &h)) + return eldbus_message_error_new(msg, "org.freedesktop.DBus.Error.InvalidArgs", "Invalid index type."); + + eo_do(obj, elm_atspi_component_interface_size_set(w, h, &result)); + + ret = eldbus_message_method_return_new(msg); + eldbus_message_arguments_append(ret, "b", result); + + return ret; +} + +static const Eldbus_Method component_methods[] = { + { "Contains", ELDBUS_ARGS({"i", "x"}, {"i", "y"}, {"u", "coord_type"}), ELDBUS_ARGS({"b", "contains"}), _component_contains, 0 }, + { "GetAccessibleAtPoint", ELDBUS_ARGS({"i", "x"}, {"i", "y"}, {"u", "coord_type"}), ELDBUS_ARGS({"(so)", "accessible"}), _component_get_accessible_at_point, 0 }, + { "GetExtents", ELDBUS_ARGS({"u", "coord_type"}), ELDBUS_ARGS({"(iiii)", "extents"}), _component_get_extents, 0 }, + { "GetPosition", ELDBUS_ARGS({"u", "coord_type"}), ELDBUS_ARGS({"i", "x"}, {"i","y"}), _component_get_position, 0 }, + { "GetSize", NULL, ELDBUS_ARGS({"i", "w"}, {"i", "h"}), _component_get_size, 0 }, + { "GetLayer", NULL, ELDBUS_ARGS({"u", "layer"}), _component_get_layer, 0 }, +// { "GetMDIZOrder", NULL, ELDBUS_ARGS({"n", "MDIZOrder"}), _component_get_mdizorder, 0 }, + { "GrabFocus", NULL, ELDBUS_ARGS({"b", "focus"}), _component_grab_focus, 0 }, + { "GetAlpha", NULL, ELDBUS_ARGS({"d", "alpha"}), _component_get_alpha, 0 }, + { "SetExtents", ELDBUS_ARGS({"i", "x"}, {"i", "y"}, {"i", "width"}, {"i", "height"}, {"u", "coord_type"}), ELDBUS_ARGS({"b", "result"}), _component_set_extends, 0 }, + { "SetPosition", ELDBUS_ARGS({"i", "x"}, {"i", "y"}, {"u", "coord_type"}), ELDBUS_ARGS({"b", "result"}), _component_set_position, 0 }, + { "SetSize", ELDBUS_ARGS({"i", "width"}, {"i", "height"}), ELDBUS_ARGS({"b", "result"}), _component_set_size, 0 }, + { NULL, NULL, NULL, NULL, 0 } +}; + +static const Eldbus_Service_Interface_Desc component_iface_desc = { + ATSPI_DBUS_INTERFACE_COMPONENT, component_methods, NULL, NULL, NULL, NULL +}; + +static Eina_Bool +_atspi_object_del_cb(void *data, Eo *obj, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED) +{ + Eldbus_Message *signal; + Eldbus_Message_Iter *iter; + char* path; + + signal = eldbus_service_signal_new(_cache_interface, REMOVE_ACCESSIBLE); + iter = eldbus_message_iter_get(signal); + object_append_reference(iter, obj); + path = _path_from_access_object(obj); + + //ERR("_atspi_object_del_cbi: %d", eo_ref_get(obj)); + + eldbus_service_signal_send(_cache_interface, signal); + eina_hash_del(_cache, path, obj); + + eldbus_service_object_unregister(data); + + free(path); + return EO_CALLBACK_CONTINUE; +} + +static void +_atspi_object_register_interfaces(const char* path, Elm_Atspi_Object *node) +{ + Eldbus_Service_Interface *accessible = NULL; + + if (eo_isa(node, ELM_ATSPI_CLASS)) + { + accessible = eldbus_service_interface_register(_a11y_bus, path, &accessible_iface_desc); + eo_do(node, eo_event_callback_add(EO_EV_DEL, _atspi_object_del_cb, accessible)); + } + + if (eo_isa(node, ELM_ATSPI_COMPONENT_INTERFACE)) + eldbus_service_interface_register(_a11y_bus, path, &component_iface_desc); +} + +static void +_atspi_objects_register_rec(Elm_Atspi_Object *node) +{ + EINA_SAFETY_ON_NULL_RETURN(node); + Eina_List *children_list = NULL, *l; + Elm_Atspi_Object *child; + char* path = _path_from_access_object(node); + + // register in cache + eina_hash_add(_cache, path, node); + + _atspi_object_register_interfaces(path, node); + free(path); + + eo_do(node, elm_atspi_obj_children_get(&children_list)); + EINA_LIST_FOREACH(children_list, l, child) + _atspi_objects_register_rec(child); + + eina_list_free(children_list); +} + +static void _on_app_register(void *data EINA_UNUSED, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) { const char *errname, *errmsg; @@ -101,14 +714,8 @@ _app_register(Eldbus_Connection *a11y_bus) ATSPI_DBUS_INTERFACE_SOCKET, "Embed"); Eldbus_Message_Iter *iter = eldbus_message_iter_get(message); - Eldbus_Message_Iter *iter_struct = eldbus_message_iter_container_new(iter, 'r', NULL); - - const char *bus = eldbus_connection_unique_name_get(a11y_bus); - char *path = ATSPI_DBUS_PATH_ROOT; - eldbus_message_iter_basic_append(iter_struct, 's', bus); - eldbus_message_iter_basic_append(iter_struct, 'o', path); - eldbus_message_iter_container_close(iter, iter_struct); + object_append_reference(iter, _root); eldbus_connection_send(a11y_bus, message, _on_app_register, NULL, -1); @@ -116,20 +723,20 @@ _app_register(Eldbus_Connection *a11y_bus) } static void -_interfaces_register(Eldbus_Connection *a11y_bus) +_bus_objects_register(Eldbus_Connection *a11y_bus) { - eldbus_service_interface_register(a11y_bus, ATSPI_DBUS_PATH_ROOT, &accessible_iface_desc); + _cache_interface = eldbus_service_interface_register(a11y_bus, CACHE_INTERFACE_PATH, &cache_iface_desc); + _atspi_objects_register_rec(_root); + DBG("%d elements registered in cache", eina_hash_population(_cache)); } static void _a11y_bus_initialize(const char *socket_addr) { Eldbus_Connection *a11y_bus = eldbus_address_connection_get(socket_addr); - - _interfaces_register(a11y_bus); - _app_register(a11y_bus); - _a11y_bus = a11y_bus; + _bus_objects_register(a11y_bus); + _app_register(a11y_bus); } static void @@ -167,6 +774,8 @@ _elm_atspi_bridge_init(void) session_bus = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SESSION); msg = eldbus_message_method_call_new(A11Y_DBUS_NAME, A11Y_DBUS_PATH, A11Y_DBUS_INTERFACE, "GetAddress"); eldbus_connection_send(session_bus, msg, _a11y_bus_address_get, session_bus, -1); + _cache = eina_hash_string_superfast_new(NULL); + _root = elm_atspi_root_object_get(); _init_count = 1; } } @@ -176,9 +785,20 @@ _elm_atspi_bridge_shutdown(void) { if (_init_count) { - if (_a11y_bus) - eldbus_connection_unref(_a11y_bus); - _a11y_bus = NULL; - _init_count = 0; + eo_unref(_root); + + if (_cache_interface) + eldbus_service_object_unregister(_cache_interface); + _cache_interface = NULL; + + if (_a11y_bus) + eldbus_connection_unref(_a11y_bus); + _a11y_bus = NULL; + + if (_cache) + eina_hash_free(_cache); + _cache = NULL; + + _init_count = 0; } } diff --git a/src/lib/elm_atspi_object.c b/src/lib/elm_atspi_object.c new file mode 100644 index 0000000..53d8881 --- /dev/null +++ b/src/lib/elm_atspi_object.c @@ -0,0 +1,824 @@ +#ifdef HAVE_CONFIG_H +# include "elementary_config.h" +#endif + +#include +#include "elm_widget.h" +#include "elm_priv.h" + +#include "atspi/atspi-constants.h" + +const char* Atspi_Name[] = { + "invalid", + "accelerator label", + "alert", + "animation", + "arrow", + "calendar", + "canvas", + "check box", + "check menu item", + "color chooser", + "column header", + "combo box", + "dateeditor", + "desktop icon", + "desktop frame", + "dial", + "dialog", + "directory pane", + "drawing area", + "file chooser", + "filler", + "focus traversable", + "font chooser", + "frame", + "glass pane", + "html container", + "icon", + "image", + "internal frame", + "label", + "layered pane", + "list", + "list item", + "menu", + "menu bar", + "menu item", + "option pane", + "page tab", + "page tab list", + "panel", + "password text", + "popup menu", + "progress bar", + "push button", + "radio button", + "radio menu item", + "root pane", + "row header", + "scroll bar", + "scroll pane", + "separator", + "slider", + "spin button", + "split pane", + "status bar", + "table", + "table cell", + "table column header" + "table row header", + "tearoff menu item", + "terminal", + "text", + "toggle button", + "tool bar", + "tool tip", + "tree", + "tree table", + "unknown", + "viewport", + "window", + "extended", + "header", + "footer", + "paragraph", + "ruler", + "application", + "autocomplete", + "editbar", + "embedded", + "entry", + "chart", + "caption", + "document frame", + "heading", + "page", + "section", + "redundant object", + "form", + "link", + "input method window", + "table row", + "tree item", + "document spreadsheet", + "document presentation", + "document text", + "document web", + "document email", + "comment", + "list box", + "grouping", + "image map", + "notification", + "info bar", + "last defined" +}; + +#define ARG_GET(valist, type) va_arg(*valist, type) + +static Elm_Atspi_Object * _elm_atspi_factory_construct(Evas_Object *obj, Elm_Atspi_Object *); + +extern Eina_List *_elm_win_list; + +typedef struct _Atspi_Object_Data Atspi_Object_Data; + +struct _Atspi_Object_Data +{ + const char *name; + const char *description; + AtspiRole role; +}; + +EAPI Eo_Op ELM_ATSPI_OBJ_BASE_ID = EO_NOOP; + +static void +_description_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list) +{ + const char **ret = ARG_GET(list, const char **); + Atspi_Object_Data *ad = _pd; + + *ret = ad->description; +} + +static void +_description_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list) +{ + const char *desc = ARG_GET(list, const char *); + Atspi_Object_Data *ad = _pd; + + if (ad->description) + eina_stringshare_del(ad->description); + + ad->description = eina_stringshare_add(desc); +} + +static void +_parent_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + Elm_Atspi_Object **ret = ARG_GET(list, Elm_Atspi_Object**); + eo_do(obj, eo_parent_get(ret)); +} + +static void +_name_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + const char **ret = ARG_GET(list, const char **); + Atspi_Object_Data *ad = _pd; + + *ret = ad->name; +} + +static void +_name_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + const char *name = ARG_GET(list, const char *); + Atspi_Object_Data *ad = _pd; + + if (ad->name) + eina_stringshare_del(ad->name); + + ad->name = eina_stringshare_add(name); +} + +static void +_role_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + AtspiRole *ret = ARG_GET(list, int*); + Atspi_Object_Data *ad = _pd; + + *ret = ad->role; +} + +static void +_role_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + AtspiRole role = ARG_GET(list, int); + Atspi_Object_Data *ad = _pd; + + ad->role = role; +} + +static void +_constructor(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(obj, ELM_ATSPI_CLASS, eo_constructor()); + Atspi_Object_Data *ad = _pd; + ad->name = ad->description = NULL; +} + +static void +_destructor(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + Atspi_Object_Data *ad = _pd; + + if (ad->name) eina_stringshare_del(ad->name); + if (ad->description) eina_stringshare_del(ad->description); + + eo_do_super(obj, ELM_ATSPI_CLASS, eo_destructor()); +} + +static void +_role_name_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + const char **ret = ARG_GET(list, const char **); + Atspi_Object_Data *ad = _pd; + + *ret = Atspi_Name[ad->role]; +} + +static void +_localized_role_name_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + const char **ret = ARG_GET(list, const char **); + Atspi_Object_Data *ad = _pd; + +#ifdef ENABLE_NLS + *ret = gettext(Atspi_Name[ad->role]); +#else + *ret = Atspi_Name[ad->role]; +#endif +} + +static void +_child_at_index_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + int idx = ARG_GET(list, int); + Elm_Atspi_Object **ao = ARG_GET(list, Elm_Atspi_Object**); + Eina_List *children = NULL; + eo_do(obj, elm_atspi_obj_children_get(&children)); + + if (children) + *ao = eina_list_nth(children, idx); + else + *ao = NULL; + + eina_list_free(children); +} + +static void +_index_in_parent_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + unsigned int *idx = ARG_GET(list, unsigned int*); + Elm_Atspi_Object *chld, *parent = NULL; + Eina_List *l, *children = NULL; + unsigned int tmp = 0; + eo_do(obj, elm_atspi_obj_parent_get(&parent)); + + if (parent) + { + eo_do(parent, elm_atspi_obj_children_get(&children)); + EINA_LIST_FOREACH(children, l, chld) + { + if (chld == obj) + { + *idx = tmp; + break; + } + tmp++; + } + if (tmp == eina_list_count(children)) + ERR("Access object not present in parent's children list!"); + EINA_LIST_FREE(children, chld) + eo_unref(chld); + + eo_unref(parent); + } + else + DBG("Access Object has no parent."); +} + +static void +_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_NAME_GET), _name_get), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_NAME_SET), _name_set), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_DESCRIPTION_GET), _description_get), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_DESCRIPTION_SET), _description_set), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_PARENT_GET), _parent_get), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_CHILD_AT_INDEX_GET), _child_at_index_get), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_INDEX_IN_PARENT_GET), _index_in_parent_get), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_ROLE_GET), _role_get), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_ROLE_SET), _role_set), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_ROLE_NAME_GET), _role_name_get), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_LOCALIZED_ROLE_NAME_GET), _localized_role_name_get), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description op_desc[] = { + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_NAME_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_NAME_SET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_DESCRIPTION_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_DESCRIPTION_SET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_PARENT_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_CHILD_AT_INDEX_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_CHILDREN_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_INDEX_IN_PARENT_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_RELATION_SET_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_RELATION_SET_SET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_ROLE_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_ROLE_SET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_ROLE_NAME_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_LOCALIZED_ROLE_NAME_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_STATE_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_OBJ_SUB_ID_ATTRIBUTES_GET, ""), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description class_desc = { + EO_VERSION, + "Access_Object", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(&ELM_ATSPI_OBJ_BASE_ID, op_desc, ELM_ATSPI_OBJ_SUB_ID_LAST), + NULL, + sizeof(Atspi_Object_Data), + _class_constructor, + NULL +}; + +EO_DEFINE_CLASS(elm_atspi_obj_class_get, &class_desc, EO_BASE_CLASS, NULL); + +// Component interface +EAPI Eo_Op ELM_ATSPI_COMPONENT_INTERFACE_BASE_ID = EO_NOOP; + +static void +_comp_interface_position_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + int *x = ARG_GET(list, int*); + int *y = ARG_GET(list, int*); + AtspiCoordType type = ARG_GET(list, AtspiCoordType); + + eo_do(obj, elm_atspi_component_interface_extents_get(x, y, NULL, NULL, type)); +} + +static void +_comp_interface_position_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + int x = ARG_GET(list, int); + int y = ARG_GET(list, int); + AtspiCoordType type = ARG_GET(list, AtspiCoordType); + Eina_Bool *ret = ARG_GET(list, Eina_Bool*); + int c_w, c_h; + + eo_do(obj, elm_atspi_component_interface_extents_get(NULL, NULL, &c_w, &c_h, type)); + eo_do(obj, elm_atspi_component_interface_extents_set(x, y, c_w, c_h, type, ret)); +} + +static void +_comp_interface_size_set(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + int w = ARG_GET(list, int); + int h = ARG_GET(list, int); + Eina_Bool *ret = ARG_GET(list, Eina_Bool*); + int c_x, c_y; + + eo_do(obj, elm_atspi_component_interface_extents_get(&c_x, &c_y, NULL, NULL, ATSPI_COORD_TYPE_WINDOW)); + eo_do(obj, elm_atspi_component_interface_extents_set(c_x, c_y, w, h, ATSPI_COORD_TYPE_WINDOW, ret)); +} + +static void +_comp_interface_size_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + int *w = ARG_GET(list, int*); + int *h = ARG_GET(list, int*); + + eo_do(obj, elm_atspi_component_interface_extents_get(NULL, NULL, w, h, ATSPI_COORD_TYPE_WINDOW)); +} + +static void +_comp_interface_contains(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list) +{ + int x = ARG_GET(list, int); + int y = ARG_GET(list, int); + AtspiCoordType type = ARG_GET(list, AtspiCoordType); + Eina_Bool *ret = ARG_GET(list, Eina_Bool*); + int w_x, w_y, w_w, w_h; + + *ret = EINA_FALSE; + + if (!eo_do(obj, elm_atspi_component_interface_extents_get(&w_x, &w_y, &w_w, &w_h, type))) + return; + + if ((x >= w_x) && (x <= w_x + w_w) && (y >= w_y) && (y <= w_y + w_h)) + *ret = EINA_TRUE; +} + +static void +_component_constructor(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(obj, ELM_ATSPI_COMPONENT_INTERFACE, eo_constructor()); +} + +static void +_component_interface_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _component_constructor), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_POSITION_GET), _comp_interface_position_get), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_POSITION_SET), _comp_interface_position_set), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_CONTAINS), _comp_interface_contains), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_SIZE_GET), _comp_interface_size_get), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_SIZE_SET), _comp_interface_size_set), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} + + +static const Eo_Op_Description component_op_desc[] = { + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_CONTAINS, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_ACCESSIBLE_AT_POINT_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_EXTENTS_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_EXTENTS_SET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_POSITION_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_POSITION_SET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_SIZE_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_SIZE_SET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_LAYER_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_Z_ORDER_GET, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_FOCUS_GRAB, ""), + EO_OP_DESCRIPTION(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_ALPHA_GET, ""), + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description component_interface_desc = { + EO_VERSION, + "Elm_Atspi_Component_Interface", + EO_CLASS_TYPE_MIXIN, + EO_CLASS_DESCRIPTION_OPS(&ELM_ATSPI_COMPONENT_INTERFACE_BASE_ID, component_op_desc, ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_LAST), + NULL, + 0, + _component_interface_constructor, + NULL +}; + +EO_DEFINE_CLASS(elm_atspi_component_interface_get, &component_interface_desc, NULL, NULL); + +/// Elm_Atspi_Widget base class +#define ELM_ATSPI_WIDGET_CLASS elm_atspi_widget_obj_class_get() + +const Eo_Class *elm_atspi_widget_obj_class_get(void) EINA_CONST; + +typedef struct _Access_Widget_Object_Data Access_Widget_Object_Data; + +struct _Access_Widget_Object_Data +{ + Evas_Object *obj; +}; + +static void +_del_ao_obj(void *data, Evas *e EINA_UNUSED, Evas_Object *eo EINA_UNUSED, void *event_info EINA_UNUSED) +{ + Elm_Atspi_Object *obj = data; + Access_Widget_Object_Data *ad = eo_data_scope_get(obj, ELM_ATSPI_WIDGET_CLASS); + ad->obj = NULL; + // below will cause Accessibility object destruction while evas object is destroyed and access object has none extra refs + eo_unref(obj); +} + +static void +_widget_constructor(Eo *obj, void *_pd, va_list *list) +{ + Evas_Object *widget = ARG_GET(list, Evas_Object*); + Access_Widget_Object_Data *ad = _pd; + const char *name; + + eo_do_super(obj, ELM_ATSPI_WIDGET_CLASS, eo_constructor()); + name = evas_object_type_get(widget); + + evas_object_event_callback_add(widget, EVAS_CALLBACK_DEL, _del_ao_obj, obj); + + ad->obj = widget; + eo_do(obj, elm_atspi_obj_name_set(name)); + eo_do(obj, elm_atspi_obj_role_set(ATSPI_ROLE_UNKNOWN)); +} + +static void +_widget_destructor(Eo *obj, void *_pd, va_list *list EINA_UNUSED) +{ + Access_Widget_Object_Data *ad = _pd; + if (ad->obj) + evas_object_event_callback_del(ad->obj, EVAS_CALLBACK_DEL, _del_ao_obj); + + eo_do_super(obj, ELM_ATSPI_WIDGET_CLASS, eo_destructor()); +} + +static void +_widget_children_get(Eo *obj, void *_pd, va_list *list) +{ + Eina_List **ret = ARG_GET(list, Eina_List**); + Access_Widget_Object_Data *ad = _pd; + Eina_List *l, *al = NULL; + Evas_Object *sub; + Elm_Atspi_Object *ao; + Elm_Widget_Smart_Data *sd; + + EINA_SAFETY_ON_NULL_GOTO(ad->obj, fail); + + sd = eo_data_scope_get(ad->obj, ELM_OBJ_WIDGET_CLASS); + EINA_SAFETY_ON_NULL_GOTO(sd, fail); + + EINA_LIST_FOREACH(sd->subobjs, l, sub) { + if (!sub) continue; + ao = _elm_atspi_factory_construct(sub, obj); + if (ao) + al = eina_list_append(al, ao); + } + + *ret = al; + return; + +fail: + *ret = NULL; + return; +} + + +static void +_widget_state_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + // FIXME +} + + +static void +_widget_comp_access_at_point_get(Eo *obj, void *_pd, va_list *list) +{ + int x = ARG_GET(list, int); + int y = ARG_GET(list, int); + AtspiCoordType type = ARG_GET(list, AtspiCoordType); + Elm_Atspi_Object **ret = ARG_GET(list, Elm_Atspi_Object**); + int ee_x, ee_y; + Access_Widget_Object_Data *ad = _pd; + Eina_List *l, *objs; + Evas_Object *wid; + + if (ad->obj) + { + if (type == ATSPI_COORD_TYPE_SCREEN) + { + Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(ad->obj)); + ecore_evas_geometry_get(ee, &ee_x, &ee_y, NULL, NULL); + x -= ee_x; + y -= ee_y; + } + objs = evas_objects_at_xy_get(evas_object_evas_get(ad->obj), x, y, EINA_TRUE, EINA_TRUE); + EINA_LIST_FOREACH(objs, l, wid) + { + // return first only + if (elm_object_widget_check(wid)) + { + *ret = _elm_atspi_factory_construct(wid, obj); + break; + } + } + eina_list_free(objs); + } +} + +static void +_widget_comp_extents_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list) +{ + Access_Widget_Object_Data *ad = _pd; + int *x, *y, *w, *h; + int ee_x, ee_y; + x = ARG_GET(list, int*); + y = ARG_GET(list, int*); + w = ARG_GET(list, int*); + h = ARG_GET(list, int*); + AtspiCoordType type = ARG_GET(list, AtspiCoordType); + + if (ad->obj) + { + evas_object_geometry_get(ad->obj, x, y, w, h); + if (type == ATSPI_COORD_TYPE_SCREEN) + { + Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(ad->obj)); + ecore_evas_geometry_get(ee, &ee_x, &ee_y, NULL, NULL); + if (x) *x += ee_x; + if (y) *y += ee_y; + } + } +} + +static void +_widget_comp_extents_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list) +{ + Access_Widget_Object_Data *ad = _pd; + int x, y, w, h; + int wx, wy; + x = ARG_GET(list, int); + y = ARG_GET(list, int); + w = ARG_GET(list, int); + h = ARG_GET(list, int); + AtspiCoordType type = ARG_GET(list, AtspiCoordType); + Eina_Bool *ret = ARG_GET(list, Eina_Bool*); + + *ret = EINA_FALSE; + + if ((x < 0) || (y < 0) || (w < 0) || (h < 0)) return; + + if (ad->obj) + { + if (type == ATSPI_COORD_TYPE_SCREEN) + { + Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(ad->obj)); + evas_object_geometry_get(ad->obj, &wx, &wy, NULL, NULL); + ecore_evas_move(ee, x - wx, y - wy); + } + else + evas_object_move(ad->obj, x, y); + + evas_object_resize(ad->obj, w, h); + *ret = EINA_TRUE; + } +} + + +static void +_widget_comp_layer_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list) +{ + int *l = ARG_GET(list, int *); + Access_Widget_Object_Data *ad = _pd; + + if (ad->obj) + *l = evas_object_layer_get(ad->obj); +} + +static void +_widget_comp_z_order_get(Eo *obj EINA_UNUSED, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + // FIXME +} + +static void +_widget_comp_focus_grab(Eo *obj EINA_UNUSED, void *_pd, va_list *list) +{ + Eina_Bool *ret = ARG_GET(list, Eina_Bool*); + Access_Widget_Object_Data *ad = _pd; + + *ret = EINA_FALSE; + + if (ad->obj && elm_object_focus_allow_get(ad->obj)) + { + Ecore_Evas *ee = ecore_evas_ecore_evas_get(evas_object_evas_get(ad->obj)); + + ecore_evas_activate(ee); + elm_object_focus_set(ad->obj, EINA_TRUE); + *ret = EINA_TRUE; + } +} + +static void +_widget_comp_alpha_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list) +{ + double *ret = ARG_GET(list, double*); + int alpha; + Access_Widget_Object_Data *ad = _pd; + + if (ad->obj) + { + evas_object_color_get(ad->obj, NULL, NULL, NULL, &alpha); + *ret = (double)alpha/255.0; + } +} + +static void +_widget_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _widget_constructor), + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _widget_destructor), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_CHILDREN_GET), _widget_children_get), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_STATE_GET), _widget_state_get), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_ACCESSIBLE_AT_POINT_GET), _widget_comp_access_at_point_get), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_EXTENTS_GET), _widget_comp_extents_get), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_EXTENTS_SET), _widget_comp_extents_set), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_LAYER_GET), _widget_comp_layer_get), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_Z_ORDER_GET), _widget_comp_z_order_get), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_FOCUS_GRAB), _widget_comp_focus_grab), + EO_OP_FUNC(ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_ALPHA_GET), _widget_comp_alpha_get), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Class_Description widget_class_desc = { + EO_VERSION, + "Elm_Widget Access_Object", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + NULL, + sizeof(Access_Widget_Object_Data), + _widget_class_constructor, + NULL +}; + +EO_DEFINE_CLASS(elm_atspi_widget_obj_class_get, &widget_class_desc, ELM_ATSPI_CLASS, ELM_ATSPI_COMPONENT_INTERFACE, NULL); + +static Elm_Atspi_Object * +_elm_atspi_factory_construct(Evas_Object *obj, Elm_Atspi_Object *parent) +{ + Elm_Atspi_Object *ret; + EINA_SAFETY_ON_NULL_RETURN_VAL(obj, NULL); + EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL); + + if (!elm_object_widget_check(obj)) + return NULL; + + if (!strcmp(evas_object_type_get(obj), "elm_access")) + return NULL; + + ret = evas_object_data_get(obj, "_atspi_object"); + if (!ret) + { + ret = eo_add(ELM_ATSPI_WIDGET_CLASS, parent, obj); + evas_object_data_set(obj, "_atspi_object", ret); + eo_unref(ret); // only parent should hold reference to atspi object + } + else + { + Elm_Atspi_Object *tmp; + eo_do(ret, eo_parent_get(&tmp)); + if (!tmp) + eo_do(ret, eo_parent_set(parent)); + } + + return ret; +} + +/// Elm_Atspi_App base class +const Eo_Class *elm_atspi_app_obj_class_get(void) EINA_CONST; +#define ELM_ATSPI_APP_CLASS elm_atspi_app_obj_class_get() + +static void +_app_children_get(Eo *obj, void *_pd EINA_UNUSED, va_list *list) +{ + Eina_List **ret = ARG_GET(list, Eina_List**); + Eina_List *l, *objs = NULL; + Evas_Object *win; + Elm_Atspi_Object *o = NULL; + + EINA_LIST_FOREACH(_elm_win_list, l, win) + { + if (!win) continue; + o = _elm_atspi_factory_construct(win, obj); + if (o) + objs = eina_list_append(objs, o); + } + *ret = objs; +} + +static void +_app_constructor(Eo *obj, void *_pd EINA_UNUSED, va_list *list EINA_UNUSED) +{ + eo_do_super(obj, ELM_ATSPI_APP_CLASS, eo_constructor()); + + eo_do(obj, elm_atspi_obj_name_set(elm_app_name_get())); + eo_do(obj, elm_atspi_obj_role_set(ATSPI_ROLE_APPLICATION)); +} + +static void +_app_class_constructor(Eo_Class *klass) +{ + const Eo_Op_Func_Description func_desc[] = { + EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _app_constructor), + EO_OP_FUNC(ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_CHILDREN_GET), _app_children_get), + EO_OP_FUNC_SENTINEL + }; + eo_class_funcs_set(klass, func_desc); +} + +static const Eo_Op_Description app_op_desc[] = { + EO_OP_DESCRIPTION_SENTINEL +}; + +static const Eo_Class_Description app_class_desc = { + EO_VERSION, + "App Access_Object", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + NULL, + 0, + _app_class_constructor, + NULL +}; + +EO_DEFINE_CLASS(elm_atspi_app_obj_class_get, &app_class_desc, ELM_ATSPI_CLASS, NULL); + +Elm_Atspi_Object * elm_atspi_root_object_get(void) +{ + static Elm_Atspi_Object *app; + + if (!app) + app = eo_add(ELM_ATSPI_APP_CLASS, NULL); + else + eo_ref(app); + + return app; +} diff --git a/src/lib/elm_atspi_object.h b/src/lib/elm_atspi_object.h new file mode 100644 index 0000000..23fa3b4 --- /dev/null +++ b/src/lib/elm_atspi_object.h @@ -0,0 +1,9 @@ +#include "elm_atspi_object_common.h" + +#ifdef EFL_EO_API_SUPPORT +#include "elm_atspi_object_eo.h" +#endif +#ifndef EFL_NOLEGACY_API_SUPPORT +#include "elm_atspi_object_legacy.h" +#endif + diff --git a/src/lib/elm_atspi_object_common.h b/src/lib/elm_atspi_object_common.h new file mode 100644 index 0000000..fdc533b --- /dev/null +++ b/src/lib/elm_atspi_object_common.h @@ -0,0 +1 @@ +typedef Eo Elm_Atspi_Object; diff --git a/src/lib/elm_atspi_object_eo.h b/src/lib/elm_atspi_object_eo.h new file mode 100644 index 0000000..67a07c6 --- /dev/null +++ b/src/lib/elm_atspi_object_eo.h @@ -0,0 +1,311 @@ +#define ELM_ATSPI_CLASS elm_atspi_obj_class_get() + +const Eo_Class *elm_atspi_obj_class_get(void) EINA_CONST; + +extern EAPI Eo_Op ELM_ATSPI_OBJ_BASE_ID; + +enum +{ + ELM_ATSPI_OBJ_SUB_ID_NAME_GET, + ELM_ATSPI_OBJ_SUB_ID_NAME_SET, + ELM_ATSPI_OBJ_SUB_ID_DESCRIPTION_GET, + ELM_ATSPI_OBJ_SUB_ID_DESCRIPTION_SET, + ELM_ATSPI_OBJ_SUB_ID_PARENT_GET, + ELM_ATSPI_OBJ_SUB_ID_CHILD_AT_INDEX_GET, + ELM_ATSPI_OBJ_SUB_ID_CHILDREN_GET, + ELM_ATSPI_OBJ_SUB_ID_INDEX_IN_PARENT_GET, + ELM_ATSPI_OBJ_SUB_ID_RELATION_SET_GET, + ELM_ATSPI_OBJ_SUB_ID_RELATION_SET_SET, + ELM_ATSPI_OBJ_SUB_ID_ROLE_GET, + ELM_ATSPI_OBJ_SUB_ID_ROLE_SET, + ELM_ATSPI_OBJ_SUB_ID_ROLE_NAME_GET, + ELM_ATSPI_OBJ_SUB_ID_LOCALIZED_ROLE_NAME_GET, + ELM_ATSPI_OBJ_SUB_ID_STATE_GET, + ELM_ATSPI_OBJ_SUB_ID_ATTRIBUTES_GET, + ELM_ATSPI_OBJ_SUB_ID_LAST +}; + +#define ELM_ATSPI_OBJ_ID(sub_id) (ELM_ATSPI_OBJ_BASE_ID + sub_id) + +/* Component Interface */ +#define ELM_ATSPI_COMPONENT_INTERFACE elm_atspi_component_interface_get() + +const Eo_Class *elm_atspi_component_interface_get(void) EINA_CONST; + +extern EAPI Eo_Op ELM_ATSPI_COMPONENT_INTERFACE_BASE_ID; + +enum +{ + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_CONTAINS, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_ACCESSIBLE_AT_POINT_GET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_EXTENTS_GET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_EXTENTS_SET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_POSITION_GET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_POSITION_SET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_SIZE_GET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_SIZE_SET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_LAYER_GET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_Z_ORDER_GET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_FOCUS_GRAB, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_ALPHA_GET, + ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_LAST +}; + +#define ELM_ATSPI_COMPONENT_INTERFACE_ID(sub_id) (ELM_ATSPI_COMPONENT_INTERFACE_BASE_ID + sub_id) +/* Component Interface - END */ + +/* Action Interface */ +#define ELM_ATSPI_ACTION_INTERFACE elm_accessible_action_interface_get() + +const Eo_Class *elm_accessible_action_interface_get(void) EINA_CONST; + +extern EAPI Eo_Op ELM_ATSPI_ACTION_INTERFACE_BASE_ID; + +enum +{ + ELM_ATSPI_ACTION_INTERFACE_SUB_ID_ACTION_COUNT, + ELM_ATSPI_ACTION_INTERFACE_SUB_ID_ACTION_DO, + ELM_ATSPI_ACTION_INTERFACE_SUB_ID_DESCRIPTION_GET, + ELM_ATSPI_ACTION_INTERFACE_SUB_ID_NAME_GET, + ELM_ATSPI_ACTION_INTERFACE_SUB_ID_LOCALIZED_NAME_GET, + ELM_ATSPI_ACTION_INTERFACE_SUB_ID_KEY_BINDING_GET, + ELM_ATSPI_ACTION_INTERFACE_SUB_ID_LAST +}; +/* Action Interface - END */ + +/* Text Interface */ +#define ELM_ATSPI_TEXT_INTERFACE elm_accessible_text_interface_get() + +const Eo_Class *elm_accessible_text_interface_get(void) EINA_CONST; + +extern EAPI Eo_Op ELM_ATSPI_TEXT_INTERFACE_BASE_ID; + +enum +{ + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_CHARACTER_COUNT, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_CARET_OFFSET_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_CARET_OFFSET_SET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_TEXT_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_TEXT_BEFORE_OFFSET_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_TEXT_AT_OFFSET_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_TEXT_AFTER_OFFSET_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_CHARACTER_AT_OFFSET_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_ATTRIBUTE_VALUE_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_ATTRIBUTES_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_DEFAULT_ATTRIBUTES_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_CHARACTER_EXTENTS_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_OFFSET_AT_POINT_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_SELECTIONS_COUNT, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_SELECTION_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_SELECTION_ADD, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_SELECTION_REMOVE, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_SELECTION_SET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_RANGE_EXTENTS_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_BAOUNDED_RANGES_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_ATTRIBUTE_RUN_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_DEFAULT_ATTRIBUTE_SET_GET, + ELM_ATSPI_TEXT_INTERFACE_SUB_ID_LAST +}; +/* Text Interface - END */ + +/* EditableText Interface */ +#define ELM_ATSPI_EDITABLE_TEXT_INTERFACE elm_accessible_editable_text_interface_get() + +const Eo_Class *elm_accessible_editable_text_interface_get(void) EINA_CONST; + +extern EAPI Eo_Op ELM_ATSPI_EDITABLE_TEXT_INTERFACE_BASE_ID; + +enum +{ + ELM_ATSPI_EDITABLE_TEXT_INTERFACE_SUB_ID_TEXT_CONTENTS_SET, + ELM_ATSPI_EDITABLE_TEXT_INTERFACE_SUB_ID_TEXT_INSERT, + ELM_ATSPI_EDITABLE_TEXT_INTERFACE_SUB_ID_TEXT_COPY, + ELM_ATSPI_EDITABLE_TEXT_INTERFACE_SUB_ID_TEXT_CUT, + ELM_ATSPI_EDITABLE_TEXT_INTERFACE_SUB_ID_TEXT_DELETE, + ELM_ATSPI_EDITABLE_TEXT_INTERFACE_SUB_ID_TEXT_PASTE, + ELM_ATSPI_EDITABLE_TEXT_INTERFACE_SUB_ID_LAST +}; +/* EditableText Interface - END */ + +#define ELM_ATSPI_VALUE_INTERFACE elm_accessible_value_interface_get() + + +/* Value Interface */ +const Eo_Class *elm_accessible_value_interface_get(void) EINA_CONST; + +extern EAPI Eo_Op ELM_ATSPI_VALUE_INTERFACE_BASE_ID; + +enum +{ + ELM_ATSPI_VALUE_INTERFACE_SUB_ID_MINIMUM_GET, + ELM_ATSPI_VALUE_INTERFACE_SUB_ID_MAXIMUM_GET, + ELM_ATSPI_VALUE_INTERFACE_SUB_ID_MINIMUM_INCREMENT_GET, + ELM_ATSPI_VALUE_INTERFACE_SUB_ID_VALUE_GET, + ELM_ATSPI_VALUE_INTERFACE_SUB_ID_VALUE_SET, + ELM_ATSPI_VALUE_INTERFACE_SUB_ID_LAST +}; +/* Value Interface - END */ + + +/* Image Interface */ +const Eo_Class *elm_accessible_image_interface_get(void) EINA_CONST; + +extern EAPI Eo_Op ELM_ATSPI_IMAGE_INTERFACE_BASE_ID; + +enum +{ + ELM_ATSPI_IMAGE_INTERFACE_SUB_ID_IMAGE_DESCRIPTION_GET, + ELM_ATSPI_IMAGE_INTERFACE_SUB_ID_IMAGE_LOCALE_GET, + ELM_ATSPI_IMAGE_INTERFACE_SUB_ID_IMAGE_EXTENTS_GET, + ELM_ATSPI_IMAGE_INTERFACE_SUB_ID_IMAGE_POSITION_GET, + ELM_ATSPI_IMAGE_INTERFACE_SUB_ID_IMAGE_SIZE_GET, + ELM_ATSPI_IMAGE_INTERFACE_SUB_ID_LAST +}; +/* Image Interface - END */ + +/* Selection Interface */ +const Eo_Class *elm_accessible_selection_interface_get(void) EINA_CONST; + +extern EAPI Eo_Op ELM_ATSPI_SELECTION_INTERFACE_BASE_ID; + +enum +{ + ELM_ATSPI_SELECTION_INTERFACE_SUB_ID_SELECTED_CHILDREN_COUNT, + ELM_ATSPI_SELECTION_INTERFACE_SUB_ID_SELECTED_CHILD_GET, + ELM_ATSPI_SELECTION_INTERFACE_SUB_ID_CHILD_SELECT, + ELM_ATSPI_SELECTION_INTERFACE_SUB_ID_CHILD_DESELECT, + ELM_ATSPI_SELECTION_INTERFACE_SUB_ID_SELECT_ALL, + ELM_ATSPI_SELECTION_INTERFACE_SUB_ID_SELECTION_CLEAR, + ELM_ATSPI_SELECTION_INTERFACE_SUB_ID_LAST +}; +/* Selection Interface - END */ + +#define elm_atspi_obj_name_get(ret)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_NAME_GET), \ + EO_TYPECHECK(const char **, ret) + +#define elm_atspi_obj_name_set(name)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_NAME_SET),\ + EO_TYPECHECK(const char *, name) + +#define elm_atspi_obj_role_get(role)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_ROLE_GET), \ + EO_TYPECHECK(AtspiRole*, role) + +#define elm_atspi_obj_role_set(role)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_ROLE_SET),\ + EO_TYPECHECK(AtspiRole, role) + +#define elm_atspi_obj_role_name_get(ret)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_ROLE_NAME_GET),\ + EO_TYPECHECK(const char **, ret) + +#define elm_atspi_obj_localized_role_name_get(ret)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_LOCALIZED_ROLE_NAME_GET),\ + EO_TYPECHECK(const char **, ret) + +#define elm_atspi_obj_description_get(ret)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_DESCRIPTION_GET),\ + EO_TYPECHECK(const char **, ret) + +#define elm_atspi_obj_description_set(desc)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_DESCRIPTION_SET),\ + EO_TYPECHECK(const char *, desc) + +#define elm_atspi_obj_parent_get(ret)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_PARENT_GET),\ + EO_TYPECHECK(Elm_Atspi_Object**, ret) + +#define elm_atspi_obj_child_at_index_get(idx, ret)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_CHILD_AT_INDEX_GET), \ + EO_TYPECHECK(int, idx),\ + EO_TYPECHECK(Elm_Atspi_Object**, ret) + +#define elm_atspi_obj_children_get(ret)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_CHILDREN_GET),\ + EO_TYPECHECK(Eina_List**, ret) + +#define elm_atspi_obj_index_in_parent_get(ret)\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_INDEX_IN_PARENT_GET),\ + EO_TYPECHECK(int*, ret) + +#define elm_atspi_obj_relation_set_get()\ + ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_RELATION_SET_GET),\ + EO_TYPECHECK() + +#define elm_atspi_obj_relation_set_set() ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_RELATION_SET_SET), EO_TYPECHECK() + +#define elm_atspi_obj_state_get() ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_STATE_GET), EO_TYPECHECK() + +#define elm_atspi_obj_attributes_get() ELM_ATSPI_OBJ_ID(ELM_ATSPI_OBJ_SUB_ID_ATTRIBUTES_GET), EO_TYPECHECK() + +#define elm_atspi_component_interface_contains(x, y, type, ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_CONTAINS),\ + EO_TYPECHECK(int, x),\ + EO_TYPECHECK(int, y),\ + EO_TYPECHECK(AtspiCoordType, type),\ + EO_TYPECHECK(Eina_Bool*, ret) + +#define elm_atspi_component_interface_accessible_at_point_get(x, y, type, ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_ACCESSIBLE_AT_POINT_GET),\ + EO_TYPECHECK(int, x),\ + EO_TYPECHECK(int, y),\ + EO_TYPECHECK(AtspiCoordType, type),\ + EO_TYPECHECK(Elm_Atspi_Object**, ret) + +#define elm_atspi_component_interface_extents_get(x, y, w, h, type)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_EXTENTS_GET),\ + EO_TYPECHECK(int*, x),\ + EO_TYPECHECK(int*, y),\ + EO_TYPECHECK(int*, w),\ + EO_TYPECHECK(int*, h), \ + EO_TYPECHECK(AtspiCoordType, type) + +#define elm_atspi_component_interface_extents_set(x, y, w, h, type, ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_EXTENTS_SET),\ + EO_TYPECHECK(int, x),\ + EO_TYPECHECK(int, y),\ + EO_TYPECHECK(int, w),\ + EO_TYPECHECK(int, h),\ + EO_TYPECHECK(AtspiCoordType, type),\ + EO_TYPECHECK(Eina_Bool*, ret) + +#define elm_atspi_component_interface_position_get(x, y, type)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_POSITION_GET),\ + EO_TYPECHECK(int*, x),\ + EO_TYPECHECK(int*, y), \ + EO_TYPECHECK(AtspiCoordType, type) + +#define elm_atspi_component_interface_position_set(x, y, type, ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_POSITION_SET),\ + EO_TYPECHECK(int, x),\ + EO_TYPECHECK(int, y),\ + EO_TYPECHECK(AtspiCoordType, type),\ + EO_TYPECHECK(Eina_Bool*, ret) + +#define elm_atspi_component_interface_size_get(x, y)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_SIZE_GET),\ + EO_TYPECHECK(int*, x),\ + EO_TYPECHECK(int*, y) + +#define elm_atspi_component_interface_size_set(x, y, ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_SIZE_SET),\ + EO_TYPECHECK(int, x),\ + EO_TYPECHECK(int, y),\ + EO_TYPECHECK(Eina_Bool*, ret) + +#define elm_atspi_component_interface_layer_get(ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_LAYER_GET),\ + EO_TYPECHECK(int*, ret) + +#define elm_atspi_component_interface_z_order_get(ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_Z_ORDER_GET),\ + EO_TYPECHECK(int*, ret) + +#define elm_atspi_component_interface_focus_grab(ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_FOCUS_GRAB),\ + EO_TYPECHECK(Eina_Bool*, ret) + +#define elm_atspi_component_interface_alpha_get(ret)\ + ELM_ATSPI_COMPONENT_INTERFACE_ID(ELM_ATSPI_COMPONENT_INTERFACE_SUB_ID_ALPHA_GET),\ + EO_TYPECHECK(double*, ret) diff --git a/src/lib/elm_atspi_object_legacy.h b/src/lib/elm_atspi_object_legacy.h new file mode 100644 index 0000000..ea5e93b --- /dev/null +++ b/src/lib/elm_atspi_object_legacy.h @@ -0,0 +1 @@ +EAPI Elm_Atspi_Object * elm_atspi_root_object_get(void); -- 2.7.4