hugok
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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
This commit is contained in:
Lukasz Stanislawski 2014-01-13 15:24:35 +09:00 committed by Carsten Haitzler (Rasterman)
parent cc03e646c9
commit fb01f98afd
8 changed files with 1809 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
legacy/elementary/src/lib/Elementary.h.in
View File

@ -161,6 +161,7 @@ EAPI extern Elm_Version *elm_version;
/* special widgets - types used elsewhere */
#include <elm_access.h>
#include <elm_atspi_object.h>
#include <elm_icon.h>
#include <elm_scroller.h>
#include <elm_entry.h>

8
legacy/elementary/src/lib/Makefile.am
View File

@ -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@ \

692
legacy/elementary/src/lib/elm_atspi_bridge.c
View File

@ -2,6 +2,7 @@
# include "elementary_config.h"
#endif
#include <stdint.h>
#include <Elementary.h>
#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 }
};
@ -80,6 +271,428 @@ static const Eldbus_Service_Interface_Desc accessible_iface_desc = {
ATSPI_DBUS_INTERFACE_ACCESSIBLE, accessible_methods, NULL, accessible_properties, _accessible_property_get, NULL
};
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)
{
@ -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;
}
}

824
legacy/elementary/src/lib/elm_atspi_object.c Normal file
View File

@ -0,0 +1,824 @@
#ifdef HAVE_CONFIG_H
# include "elementary_config.h"
#endif
#include <Elementary.h>
#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;
}

9
legacy/elementary/src/lib/elm_atspi_object.h Normal file
View File

@ -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

1
legacy/elementary/src/lib/elm_atspi_object_common.h Normal file
View File

@ -0,0 +1 @@
typedef Eo Elm_Atspi_Object;

311
legacy/elementary/src/lib/elm_atspi_object_eo.h Normal file
View File

@ -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)

1
legacy/elementary/src/lib/elm_atspi_object_legacy.h Normal file
View File

@ -0,0 +1 @@
EAPI Elm_Atspi_Object * elm_atspi_root_object_get(void);