2013-04-25 22:13:00 -07:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "elementary_config.h"
|
|
|
|
#endif
|
|
|
|
|
2017-10-18 18:13:54 -07:00
|
|
|
#define EFL_ACCESS_PROTECTED
|
2016-06-19 23:45:33 -07:00
|
|
|
#define ELM_INTERFACE_ATSPI_WIDGET_ACTION_PROTECTED
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
#include <Elementary.h>
|
|
|
|
#include "elm_priv.h"
|
|
|
|
|
2014-06-03 03:35:28 -07:00
|
|
|
#define MY_CLASS ELM_ACCESS_CLASS
|
2012-11-25 22:32:53 -08:00
|
|
|
|
2013-11-07 03:44:22 -08:00
|
|
|
#define MY_CLASS_NAME "Elm_Access"
|
|
|
|
#define MY_CLASS_NAME_LEGACY "elm_access"
|
2012-06-25 22:54:45 -07:00
|
|
|
|
2013-04-17 18:52:01 -07:00
|
|
|
struct _Func_Data
|
|
|
|
{
|
|
|
|
void *user_data; /* Holds user data to CB */
|
|
|
|
Elm_Access_Action_Cb cb;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct _Func_Data Func_Data;
|
|
|
|
|
|
|
|
struct _Action_Info
|
|
|
|
{
|
|
|
|
Evas_Object *obj;
|
|
|
|
Func_Data fn[ELM_ACCESS_ACTION_LAST + 1]; /* Callback for specific action */
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct _Action_Info Action_Info;
|
|
|
|
|
2013-01-17 03:32:14 -08:00
|
|
|
static Eina_Bool mouse_event_enable = EINA_TRUE;
|
2013-09-09 22:01:50 -07:00
|
|
|
static Eina_Bool auto_highlight = EINA_FALSE;
|
2013-04-17 18:52:01 -07:00
|
|
|
static Elm_Access_Action_Type action_by = ELM_ACCESS_ACTION_FIRST;
|
2013-01-17 03:32:14 -08:00
|
|
|
|
2012-06-25 22:54:45 -07:00
|
|
|
static Evas_Object * _elm_access_add(Evas_Object *parent);
|
|
|
|
|
2013-07-17 20:48:22 -07:00
|
|
|
static void _access_object_unregister(Evas_Object *obj);
|
|
|
|
|
2017-04-05 03:58:46 -07:00
|
|
|
static const char SIG_ACTIVATED[] = "access,activated";
|
|
|
|
static const Evas_Smart_Cb_Description _smart_callbacks[] =
|
|
|
|
{
|
|
|
|
{SIG_ACTIVATED, ""},
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2014-03-18 04:47:23 -07:00
|
|
|
EOLIAN static void
|
2016-06-17 01:26:08 -07:00
|
|
|
_elm_access_efl_canvas_group_group_add(Eo *obj, void *_pd EINA_UNUSED)
|
2012-06-25 22:54:45 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
efl_canvas_group_add(efl_super(obj, MY_CLASS));
|
2013-09-24 21:33:39 -07:00
|
|
|
elm_widget_sub_object_parent_add(obj);
|
2012-06-25 22:54:45 -07:00
|
|
|
}
|
|
|
|
|
2013-04-17 18:52:01 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_access_action_callback_call(Evas_Object *obj,
|
|
|
|
Elm_Access_Action_Type type,
|
|
|
|
Elm_Access_Action_Info *action_info)
|
|
|
|
{
|
|
|
|
Elm_Access_Action_Info *ai = NULL;
|
|
|
|
Action_Info *a;
|
|
|
|
Eina_Bool ret;
|
|
|
|
|
|
|
|
ret = EINA_FALSE;
|
|
|
|
a = evas_object_data_get(obj, "_elm_access_action_info");
|
|
|
|
|
|
|
|
if (!action_info)
|
|
|
|
{
|
|
|
|
ai = calloc(1, sizeof(Elm_Access_Action_Info));
|
|
|
|
action_info = ai;
|
|
|
|
}
|
|
|
|
|
|
|
|
action_info->action_type = type;
|
|
|
|
|
|
|
|
if ((type == ELM_ACCESS_ACTION_HIGHLIGHT) &&
|
|
|
|
(action_by != ELM_ACCESS_ACTION_FIRST))
|
|
|
|
action_info->action_by = action_by;
|
|
|
|
|
|
|
|
if (a && (a->fn[type].cb))
|
|
|
|
ret = a->fn[type].cb(a->fn[type].user_data, obj, action_info);
|
|
|
|
|
2014-01-21 18:08:47 -08:00
|
|
|
free(ai);
|
2013-04-17 18:52:01 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-03-18 04:47:23 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2017-10-15 21:33:52 -07:00
|
|
|
_elm_access_elm_widget_on_access_activate(Eo *obj, void *_pd EINA_UNUSED, Efl_Ui_Activate act)
|
2012-06-25 22:54:45 -07:00
|
|
|
{
|
2013-04-17 18:52:01 -07:00
|
|
|
int type = ELM_ACCESS_ACTION_FIRST;
|
|
|
|
|
|
|
|
Action_Info *a;
|
|
|
|
a = evas_object_data_get(obj, "_elm_access_action_info");
|
|
|
|
|
|
|
|
switch (act)
|
|
|
|
{
|
2017-10-15 21:33:52 -07:00
|
|
|
case EFL_UI_ACTIVATE_DEFAULT:
|
2013-04-17 18:52:01 -07:00
|
|
|
type = ELM_ACCESS_ACTION_ACTIVATE;
|
|
|
|
break;
|
|
|
|
|
2017-10-15 21:33:52 -07:00
|
|
|
case EFL_UI_ACTIVATE_UP:
|
2013-04-17 18:52:01 -07:00
|
|
|
type = ELM_ACCESS_ACTION_UP;
|
|
|
|
break;
|
|
|
|
|
2017-10-15 21:33:52 -07:00
|
|
|
case EFL_UI_ACTIVATE_DOWN:
|
2013-04-17 18:52:01 -07:00
|
|
|
type = ELM_ACCESS_ACTION_DOWN;
|
|
|
|
break;
|
|
|
|
|
2017-10-15 21:33:52 -07:00
|
|
|
case EFL_UI_ACTIVATE_RIGHT:
|
2013-04-17 18:52:01 -07:00
|
|
|
break;
|
|
|
|
|
2017-10-15 21:33:52 -07:00
|
|
|
case EFL_UI_ACTIVATE_LEFT:
|
2013-04-17 18:52:01 -07:00
|
|
|
break;
|
|
|
|
|
2017-10-15 21:33:52 -07:00
|
|
|
case EFL_UI_ACTIVATE_BACK:
|
2013-04-17 18:52:01 -07:00
|
|
|
type = ELM_ACCESS_ACTION_BACK;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-03-18 04:47:23 -07:00
|
|
|
if (type == ELM_ACCESS_ACTION_FIRST) return EINA_FALSE;
|
2013-04-17 18:52:01 -07:00
|
|
|
|
|
|
|
/* if an access object has a callback, it would have the intention to do
|
|
|
|
something. so, check here and return EINA_TRUE. */
|
|
|
|
if ((a) && (type > ELM_ACCESS_ACTION_FIRST) &&
|
|
|
|
(type < ELM_ACCESS_ACTION_LAST) &&
|
|
|
|
(a->fn[type].cb))
|
|
|
|
{
|
|
|
|
_access_action_callback_call(obj, type, NULL);
|
2014-03-18 04:47:23 -07:00
|
|
|
return EINA_TRUE;
|
2013-04-17 18:52:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: deprecate below? */
|
2017-10-15 21:33:52 -07:00
|
|
|
if (act != EFL_UI_ACTIVATE_DEFAULT) return EINA_FALSE;
|
2012-11-12 21:50:08 -08:00
|
|
|
|
|
|
|
Elm_Access_Info *ac = evas_object_data_get(obj, "_elm_access");
|
2014-03-18 04:47:23 -07:00
|
|
|
if (!ac) return EINA_FALSE;
|
2012-11-12 21:50:08 -08:00
|
|
|
|
|
|
|
if (ac->activate)
|
2013-01-03 01:31:33 -08:00
|
|
|
ac->activate(ac->activate_data, ac->part_object,
|
2014-08-19 00:52:24 -07:00
|
|
|
ac->widget_item->eo_obj);
|
2012-11-12 21:50:08 -08:00
|
|
|
|
2014-03-18 04:47:23 -07:00
|
|
|
return EINA_TRUE;
|
2012-11-12 21:50:08 -08:00
|
|
|
}
|
|
|
|
|
2014-03-18 04:47:23 -07:00
|
|
|
EOLIAN static Eina_Bool
|
2017-08-30 23:20:33 -07:00
|
|
|
_elm_access_elm_widget_on_focus_update(Eo *obj, void *_pd EINA_UNUSED, Elm_Object_Item *item EINA_UNUSED)
|
2012-06-25 22:54:45 -07:00
|
|
|
{
|
2012-11-25 22:32:53 -08:00
|
|
|
evas_object_focus_set(obj, elm_widget_focus_get(obj));
|
2012-06-25 22:54:45 -07:00
|
|
|
|
2014-03-18 04:47:23 -07:00
|
|
|
return EINA_TRUE;
|
2012-06-25 22:54:45 -07:00
|
|
|
}
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
typedef struct _Mod_Api Mod_Api;
|
|
|
|
|
|
|
|
struct _Mod_Api
|
|
|
|
{
|
|
|
|
void (*out_read) (const char *txt);
|
|
|
|
void (*out_read_done) (void);
|
|
|
|
void (*out_cancel) (void);
|
|
|
|
void (*out_done_callback_set) (void (*func) (void *data), const void *data);
|
|
|
|
};
|
|
|
|
|
|
|
|
static int initted = 0;
|
|
|
|
static Mod_Api *mapi = NULL;
|
|
|
|
|
|
|
|
static void
|
|
|
|
_access_init(void)
|
|
|
|
{
|
|
|
|
Elm_Module *m;
|
2016-12-07 20:28:39 -08:00
|
|
|
|
|
|
|
if (initted > 0) return;
|
2011-08-19 04:07:42 -07:00
|
|
|
if (!(m = _elm_module_find_as("access/api"))) return;
|
2016-12-07 20:28:39 -08:00
|
|
|
if (m->init_func(m) < 0) return;
|
|
|
|
initted++;
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
m->api = malloc(sizeof(Mod_Api));
|
|
|
|
if (!m->api) return;
|
|
|
|
((Mod_Api *)(m->api) )->out_read = // called to read out some text
|
|
|
|
_elm_module_symbol_get(m, "out_read");
|
|
|
|
((Mod_Api *)(m->api) )->out_read_done = // called to set a done marker so when it is reached the done callback is called
|
|
|
|
_elm_module_symbol_get(m, "out_read_done");
|
|
|
|
((Mod_Api *)(m->api) )->out_cancel = // called to read out some text
|
|
|
|
_elm_module_symbol_get(m, "out_cancel");
|
|
|
|
((Mod_Api *)(m->api) )->out_done_callback_set = // called when last read done
|
|
|
|
_elm_module_symbol_get(m, "out_done_callback_set");
|
|
|
|
mapi = m->api;
|
|
|
|
}
|
|
|
|
|
2013-02-03 20:51:26 -08:00
|
|
|
static void
|
|
|
|
_access_shutdown(void)
|
|
|
|
{
|
|
|
|
Elm_Module *m;
|
|
|
|
if (initted == 0) return;
|
|
|
|
if (!(m = _elm_module_find_as("access/api"))) return;
|
|
|
|
|
|
|
|
m->shutdown_func(m);
|
|
|
|
|
|
|
|
initted = 0;
|
|
|
|
|
2013-07-05 03:02:57 -07:00
|
|
|
/* _elm_module_unload(); could access m->api and try to free(); */
|
|
|
|
ELM_SAFE_FREE(m->api, free);
|
2016-03-03 22:33:49 -08:00
|
|
|
mapi = NULL;
|
2013-02-03 20:51:26 -08:00
|
|
|
}
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
static Elm_Access_Item *
|
|
|
|
_access_add_set(Elm_Access_Info *ac, int type)
|
|
|
|
{
|
|
|
|
Elm_Access_Item *ai;
|
|
|
|
Eina_List *l;
|
|
|
|
|
|
|
|
if (!ac) return NULL;
|
|
|
|
EINA_LIST_FOREACH(ac->items, l, ai)
|
|
|
|
{
|
|
|
|
if (ai->type == type)
|
|
|
|
{
|
|
|
|
if (!ai->func)
|
|
|
|
{
|
2014-01-21 17:12:44 -08:00
|
|
|
eina_stringshare_del(ai->data);
|
2011-08-19 04:07:42 -07:00
|
|
|
}
|
|
|
|
ai->func = NULL;
|
|
|
|
ai->data = NULL;
|
|
|
|
return ai;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ai = calloc(1, sizeof(Elm_Access_Item));
|
|
|
|
ai->type = type;
|
|
|
|
ac->items = eina_list_prepend(ac->items, ai);
|
|
|
|
return ai;
|
|
|
|
}
|
2011-08-19 07:39:27 -07:00
|
|
|
|
2013-03-07 18:44:49 -08:00
|
|
|
static Evas_Object *
|
|
|
|
_access_highlight_object_get(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *o, *ho;
|
|
|
|
|
|
|
|
o = evas_object_name_find(evas_object_evas_get(obj), "_elm_access_disp");
|
|
|
|
if (!o) return NULL;
|
|
|
|
|
|
|
|
ho = evas_object_data_get(o, "_elm_access_target");
|
|
|
|
|
|
|
|
return ho;
|
|
|
|
}
|
|
|
|
|
2013-03-22 16:45:26 -07:00
|
|
|
static void
|
|
|
|
_access_highlight_read(Elm_Access_Info *ac, Evas_Object *obj)
|
|
|
|
{
|
2013-04-17 01:22:13 -07:00
|
|
|
int type;
|
|
|
|
char *txt = NULL;
|
|
|
|
Eina_Strbuf *strbuf;
|
|
|
|
|
|
|
|
strbuf = eina_strbuf_new();
|
|
|
|
|
2013-03-22 16:45:26 -07:00
|
|
|
if (_elm_config->access_mode != ELM_ACCESS_MODE_OFF)
|
|
|
|
{
|
|
|
|
if (ac->on_highlight) ac->on_highlight(ac->on_highlight_data);
|
2013-10-31 07:01:56 -07:00
|
|
|
_elm_access_object_highlight(obj);
|
2013-04-17 01:22:13 -07:00
|
|
|
|
|
|
|
for (type = ELM_ACCESS_INFO_FIRST + 1; type < ELM_ACCESS_INFO_LAST; type++)
|
|
|
|
{
|
|
|
|
txt = _elm_access_text_get(ac, type, obj);
|
|
|
|
if (txt && (strlen(txt) > 0))
|
|
|
|
{
|
|
|
|
if (eina_strbuf_length_get(strbuf) > 0)
|
|
|
|
eina_strbuf_append_printf(strbuf, ", %s", txt);
|
|
|
|
else
|
|
|
|
eina_strbuf_append(strbuf, txt);
|
|
|
|
}
|
2014-03-20 10:33:22 -07:00
|
|
|
free(txt);
|
2013-04-17 01:22:13 -07:00
|
|
|
}
|
2013-03-22 16:45:26 -07:00
|
|
|
}
|
2013-04-17 01:22:13 -07:00
|
|
|
|
|
|
|
txt = eina_strbuf_string_steal(strbuf);
|
|
|
|
eina_strbuf_free(strbuf);
|
|
|
|
|
|
|
|
_elm_access_say(txt);
|
|
|
|
free(txt);
|
2013-03-22 16:45:26 -07:00
|
|
|
}
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_access_obj_over_timeout_cb(void *data)
|
|
|
|
{
|
2013-03-07 18:44:49 -08:00
|
|
|
Elm_Access_Info *ac;
|
|
|
|
Evas_Object *ho;
|
|
|
|
|
|
|
|
if (!data) return EINA_FALSE;
|
|
|
|
|
|
|
|
ac = evas_object_data_get(data, "_elm_access");
|
2011-08-19 04:07:42 -07:00
|
|
|
if (!ac) return EINA_FALSE;
|
2013-03-07 18:44:49 -08:00
|
|
|
|
2013-03-22 16:45:26 -07:00
|
|
|
ho = _access_highlight_object_get(data);
|
|
|
|
if (ho != data) _access_highlight_read(ac, data);
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
ac->delay_timer = NULL;
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_hover_mouse_in_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
2011-08-19 04:07:42 -07:00
|
|
|
{
|
2013-01-17 03:32:14 -08:00
|
|
|
Elm_Access_Info *ac;
|
|
|
|
if (!mouse_event_enable) return;
|
|
|
|
|
|
|
|
ac = evas_object_data_get(data, "_elm_access");
|
2011-08-19 04:07:42 -07:00
|
|
|
if (!ac) return;
|
|
|
|
|
2013-05-29 04:22:16 -07:00
|
|
|
ELM_SAFE_FREE(ac->delay_timer, ecore_timer_del);
|
2013-05-21 10:24:02 -07:00
|
|
|
|
2011-08-19 07:39:27 -07:00
|
|
|
if (_elm_config->access_mode != ELM_ACCESS_MODE_OFF)
|
|
|
|
ac->delay_timer = ecore_timer_add(0.2, _access_obj_over_timeout_cb, data);
|
2011-08-19 04:07:42 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_hover_mouse_out_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
2011-08-19 04:07:42 -07:00
|
|
|
{
|
2013-01-17 03:32:14 -08:00
|
|
|
Elm_Access_Info *ac;
|
|
|
|
if (!mouse_event_enable) return;
|
|
|
|
|
|
|
|
ac = evas_object_data_get(data, "_elm_access");
|
2011-08-19 04:07:42 -07:00
|
|
|
if (!ac) return;
|
2013-01-17 03:32:14 -08:00
|
|
|
|
2014-05-07 19:14:36 -07:00
|
|
|
_elm_access_object_unhighlight(data);
|
2013-05-21 10:24:02 -07:00
|
|
|
|
2013-05-29 04:22:16 -07:00
|
|
|
ELM_SAFE_FREE(ac->delay_timer, ecore_timer_del);
|
2011-08-19 04:07:42 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_read_done(void *data EINA_UNUSED)
|
2011-08-19 04:07:42 -07:00
|
|
|
{
|
2013-06-04 22:40:03 -07:00
|
|
|
DBG("read done");
|
2011-08-23 23:29:13 -07:00
|
|
|
// FIXME: produce event here
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_2nd_click_del_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
|
2011-08-23 23:29:13 -07:00
|
|
|
{
|
|
|
|
Ecore_Timer *t;
|
|
|
|
|
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_DEL,
|
|
|
|
_access_2nd_click_del_cb, NULL);
|
|
|
|
t = evas_object_data_get(obj, "_elm_2nd_timeout");
|
|
|
|
if (t)
|
|
|
|
{
|
|
|
|
ecore_timer_del(t);
|
|
|
|
evas_object_data_del(obj, "_elm_2nd_timeout");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_access_2nd_click_timeout_cb(void *data)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full(data, EVAS_CALLBACK_DEL,
|
|
|
|
_access_2nd_click_del_cb, NULL);
|
|
|
|
evas_object_data_del(data, "_elm_2nd_timeout");
|
|
|
|
return EINA_FALSE;
|
2011-08-19 04:07:42 -07:00
|
|
|
}
|
|
|
|
|
2011-08-23 01:46:01 -07:00
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_obj_hilight_del_cb(void *data EINA_UNUSED, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
2011-08-23 01:46:01 -07:00
|
|
|
{
|
2013-10-31 07:01:56 -07:00
|
|
|
_elm_access_object_highlight_disable(e);
|
2011-08-23 01:46:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_obj_hilight_hide_cb(void *data EINA_UNUSED, Evas *e, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
|
2011-08-23 01:46:01 -07:00
|
|
|
{
|
2013-10-31 07:01:56 -07:00
|
|
|
_elm_access_object_highlight_disable(e);
|
2011-08-23 01:46:01 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_obj_hilight_move_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
|
2011-08-23 01:46:01 -07:00
|
|
|
{
|
|
|
|
Evas_Coord x, y;
|
|
|
|
Evas_Object *o;
|
2011-08-24 01:11:58 -07:00
|
|
|
|
2011-08-23 01:46:01 -07:00
|
|
|
o = evas_object_name_find(evas_object_evas_get(obj), "_elm_access_disp");
|
|
|
|
if (!o) return;
|
|
|
|
evas_object_geometry_get(obj, &x, &y, NULL, NULL);
|
|
|
|
evas_object_move(o, x, y);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_obj_hilight_resize_cb(void *data EINA_UNUSED, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
|
2011-08-23 01:46:01 -07:00
|
|
|
{
|
|
|
|
Evas_Coord w, h;
|
|
|
|
Evas_Object *o;
|
2011-08-24 01:11:58 -07:00
|
|
|
|
2011-08-23 01:46:01 -07:00
|
|
|
o = evas_object_name_find(evas_object_evas_get(obj), "_elm_access_disp");
|
|
|
|
if (!o) return;
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &w, &h);
|
|
|
|
evas_object_resize(o, w, h);
|
2012-11-30 03:50:52 -08:00
|
|
|
}
|
2011-08-23 01:46:01 -07:00
|
|
|
|
2013-02-07 05:01:34 -08:00
|
|
|
void
|
|
|
|
_elm_access_mouse_event_enabled_set(Eina_Bool enabled)
|
2013-01-17 03:32:14 -08:00
|
|
|
{
|
|
|
|
enabled = !!enabled;
|
|
|
|
if (mouse_event_enable == enabled) return;
|
|
|
|
mouse_event_enable = enabled;
|
|
|
|
}
|
|
|
|
|
2013-02-07 05:01:34 -08:00
|
|
|
void
|
2013-09-09 22:01:50 -07:00
|
|
|
_elm_access_auto_highlight_set(Eina_Bool enabled)
|
2013-01-28 03:13:18 -08:00
|
|
|
{
|
|
|
|
enabled = !!enabled;
|
2013-09-09 22:01:50 -07:00
|
|
|
if (auto_highlight == enabled) return;
|
|
|
|
auto_highlight = enabled;
|
2013-01-28 03:13:18 -08:00
|
|
|
}
|
|
|
|
|
2013-02-07 05:01:34 -08:00
|
|
|
Eina_Bool
|
2013-09-09 22:01:50 -07:00
|
|
|
_elm_access_auto_highlight_get(void)
|
2013-01-28 03:13:18 -08:00
|
|
|
{
|
2013-09-09 22:01:50 -07:00
|
|
|
return auto_highlight;
|
2013-01-28 03:13:18 -08:00
|
|
|
}
|
2013-02-03 20:51:26 -08:00
|
|
|
|
2013-02-07 05:01:34 -08:00
|
|
|
void
|
|
|
|
_elm_access_shutdown()
|
2013-02-03 20:51:26 -08:00
|
|
|
{
|
|
|
|
_access_shutdown();
|
|
|
|
}
|
|
|
|
|
2013-02-07 05:01:34 -08:00
|
|
|
static void
|
|
|
|
_access_order_del_cb(void *data,
|
2014-01-06 06:30:02 -08:00
|
|
|
Evas *e EINA_UNUSED,
|
2013-02-07 05:01:34 -08:00
|
|
|
Evas_Object *obj,
|
2014-01-06 06:30:02 -08:00
|
|
|
void *event_info EINA_UNUSED)
|
2013-02-07 05:01:34 -08:00
|
|
|
{
|
2014-08-13 06:36:29 -07:00
|
|
|
Elm_Widget_Item_Data *item = data;
|
2013-02-07 05:01:34 -08:00
|
|
|
|
|
|
|
item->access_order = eina_list_remove(item->access_order, obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-08-13 06:36:29 -07:00
|
|
|
_elm_access_widget_item_access_order_set(Elm_Widget_Item_Data *item,
|
2013-02-08 07:16:20 -08:00
|
|
|
Eina_List *objs)
|
2013-02-07 05:01:34 -08:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
|
|
|
Evas_Object *o;
|
|
|
|
|
|
|
|
if (!item) return;
|
|
|
|
|
|
|
|
_elm_access_widget_item_access_order_unset(item);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(objs, l, o)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_add(o, EVAS_CALLBACK_DEL,
|
|
|
|
_access_order_del_cb, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
item->access_order = objs;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Eina_List *
|
2014-08-13 06:36:29 -07:00
|
|
|
_elm_access_widget_item_access_order_get(const Elm_Widget_Item_Data *item)
|
2013-02-07 05:01:34 -08:00
|
|
|
{
|
|
|
|
if (!item) return NULL;
|
|
|
|
return item->access_order;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-08-13 06:36:29 -07:00
|
|
|
_elm_access_widget_item_access_order_unset(Elm_Widget_Item_Data *item)
|
2013-02-07 05:01:34 -08:00
|
|
|
{
|
|
|
|
Eina_List *l, *l_next;
|
|
|
|
Evas_Object *o;
|
|
|
|
|
|
|
|
if (!item) return;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH_SAFE(item->access_order, l, l_next, o)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full
|
|
|
|
(o, EVAS_CALLBACK_DEL, _access_order_del_cb, item);
|
|
|
|
item->access_order = eina_list_remove_list(item->access_order, l);
|
|
|
|
}
|
|
|
|
}
|
2013-04-17 18:52:01 -07:00
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_access_highlight_next_get(Evas_Object *obj, Elm_Focus_Direction dir)
|
|
|
|
{
|
|
|
|
int type;
|
|
|
|
Evas_Object *ho, *parent, *target;
|
|
|
|
Eina_Bool ret;
|
|
|
|
|
|
|
|
target = NULL;
|
|
|
|
ret = EINA_FALSE;
|
|
|
|
|
|
|
|
if (!elm_widget_is(obj)) return ret;
|
|
|
|
|
|
|
|
ho = _access_highlight_object_get(obj);
|
|
|
|
if (!ho) ho = obj;
|
|
|
|
|
|
|
|
parent = ho;
|
|
|
|
|
|
|
|
/* find highlight root */
|
|
|
|
do
|
|
|
|
{
|
2013-10-05 01:13:18 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(parent, wd, ret);
|
2013-04-17 18:52:01 -07:00
|
|
|
if (wd->highlight_root)
|
|
|
|
{
|
|
|
|
/* change highlight root */
|
|
|
|
obj = parent;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
parent = elm_widget_parent_get(parent);
|
|
|
|
}
|
|
|
|
while (parent);
|
|
|
|
|
2013-09-09 22:01:50 -07:00
|
|
|
_elm_access_auto_highlight_set(EINA_TRUE);
|
2013-04-17 18:52:01 -07:00
|
|
|
|
2013-07-05 22:41:00 -07:00
|
|
|
if (dir == ELM_FOCUS_NEXT)
|
|
|
|
type = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
|
|
|
|
else
|
|
|
|
type = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
|
2013-04-17 18:52:01 -07:00
|
|
|
|
2013-07-05 22:41:00 -07:00
|
|
|
/* this value is used in _elm_access_object_highlight();
|
|
|
|
to inform the target object of how to get highlight */
|
|
|
|
action_by = type;
|
|
|
|
|
|
|
|
if (!_access_action_callback_call(ho, type, NULL))
|
|
|
|
{
|
|
|
|
if (ho)
|
2013-04-17 18:52:01 -07:00
|
|
|
{
|
2013-07-30 20:53:04 -07:00
|
|
|
Elm_Access_Info *info = _elm_access_info_get(ho);
|
2013-07-05 22:41:00 -07:00
|
|
|
if (type == ELM_ACCESS_ACTION_HIGHLIGHT_NEXT && info->next)
|
|
|
|
target = info->next;
|
|
|
|
else if (type == ELM_ACCESS_ACTION_HIGHLIGHT_PREV && info->prev)
|
|
|
|
target = info->prev;
|
|
|
|
}
|
2013-04-17 18:52:01 -07:00
|
|
|
|
2013-07-05 22:41:00 -07:00
|
|
|
if (target)
|
|
|
|
{
|
2013-04-17 18:52:01 -07:00
|
|
|
_elm_access_highlight_set(target);
|
2013-07-05 22:41:00 -07:00
|
|
|
elm_widget_focus_region_show(target);
|
|
|
|
ret = EINA_TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-09-27 08:28:41 -07:00
|
|
|
Efl_Ui_Focus_Relations *rel;
|
|
|
|
|
|
|
|
rel = efl_ui_focus_manager_fetch(efl_ui_focus_user_manager_get(obj), obj);
|
|
|
|
|
|
|
|
if (rel)
|
|
|
|
{
|
|
|
|
if (dir == ELM_FOCUS_NEXT)
|
|
|
|
_elm_access_highlight_set(rel->next);
|
|
|
|
else
|
|
|
|
_elm_access_highlight_set(rel->prev);
|
|
|
|
|
|
|
|
free(rel);
|
|
|
|
}
|
2013-04-17 18:52:01 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-07-05 22:41:00 -07:00
|
|
|
action_by = ELM_ACCESS_ACTION_FIRST;
|
|
|
|
|
2013-09-09 22:01:50 -07:00
|
|
|
_elm_access_auto_highlight_set(EINA_FALSE);
|
2013-04-17 18:52:01 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
//-------------------------------------------------------------------------//
|
2012-06-25 22:54:45 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_access_highlight_set(Evas_Object* obj)
|
|
|
|
{
|
2013-03-22 16:45:26 -07:00
|
|
|
Elm_Access_Info *ac;
|
|
|
|
Evas_Object *ho;
|
|
|
|
|
|
|
|
if (!obj) return;
|
|
|
|
|
|
|
|
ho = _access_highlight_object_get(obj);
|
|
|
|
if (ho == obj) return;
|
|
|
|
|
|
|
|
ac = evas_object_data_get(obj, "_elm_access");
|
|
|
|
if (!ac) return;
|
|
|
|
|
|
|
|
_access_highlight_read(ac, obj);
|
2012-06-25 22:54:45 -07:00
|
|
|
}
|
2011-08-19 04:07:42 -07:00
|
|
|
|
|
|
|
EAPI void
|
|
|
|
_elm_access_clear(Elm_Access_Info *ac)
|
|
|
|
{
|
|
|
|
Elm_Access_Item *ai;
|
|
|
|
|
|
|
|
if (!ac) return;
|
2013-05-29 04:22:16 -07:00
|
|
|
ELM_SAFE_FREE(ac->delay_timer, ecore_timer_del);
|
2011-08-19 04:07:42 -07:00
|
|
|
EINA_LIST_FREE(ac->items, ai)
|
|
|
|
{
|
|
|
|
if (!ai->func)
|
|
|
|
{
|
2014-01-21 17:12:44 -08:00
|
|
|
eina_stringshare_del(ai->data);
|
2011-08-19 04:07:42 -07:00
|
|
|
}
|
|
|
|
free(ai);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
_elm_access_text_set(Elm_Access_Info *ac, int type, const char *text)
|
|
|
|
{
|
|
|
|
Elm_Access_Item *ai = _access_add_set(ac, type);
|
|
|
|
if (!ai) return;
|
2013-04-17 19:01:20 -07:00
|
|
|
ai->func = NULL;
|
2011-08-19 04:07:42 -07:00
|
|
|
ai->data = eina_stringshare_add(text);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2013-01-14 20:20:37 -08:00
|
|
|
_elm_access_callback_set(Elm_Access_Info *ac, int type, Elm_Access_Info_Cb func, const void *data)
|
2011-08-19 04:07:42 -07:00
|
|
|
{
|
|
|
|
Elm_Access_Item *ai = _access_add_set(ac, type);
|
|
|
|
if (!ai) return;
|
|
|
|
ai->func = func;
|
|
|
|
ai->data = data;
|
|
|
|
}
|
|
|
|
|
2012-06-29 23:21:14 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_access_on_highlight_hook_set(Elm_Access_Info *ac,
|
|
|
|
Elm_Access_On_Highlight_Cb func,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
if (!ac) return;
|
|
|
|
ac->on_highlight = func;
|
|
|
|
ac->on_highlight_data = data;
|
|
|
|
}
|
|
|
|
|
2012-11-12 21:50:08 -08:00
|
|
|
EAPI void
|
|
|
|
_elm_access_activate_callback_set(Elm_Access_Info *ac,
|
|
|
|
Elm_Access_Activate_Cb func,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
if (!ac) return;
|
|
|
|
ac->activate = func;
|
|
|
|
ac->activate_data = data;
|
|
|
|
}
|
|
|
|
|
2012-09-03 01:44:53 -07:00
|
|
|
EAPI void
|
2017-10-15 21:33:52 -07:00
|
|
|
_elm_access_highlight_object_activate(Evas_Object *obj, Efl_Ui_Activate act)
|
2012-09-03 01:44:53 -07:00
|
|
|
{
|
2012-11-30 03:50:52 -08:00
|
|
|
Evas_Object *highlight;
|
|
|
|
|
|
|
|
highlight = _access_highlight_object_get(obj);
|
|
|
|
if (!highlight) return;
|
|
|
|
|
2013-09-09 22:01:50 -07:00
|
|
|
_elm_access_auto_highlight_set(EINA_FALSE);
|
2013-01-28 03:13:18 -08:00
|
|
|
|
2013-03-01 01:58:25 -08:00
|
|
|
if (!elm_object_focus_get(highlight))
|
|
|
|
elm_object_focus_set(highlight, EINA_TRUE);
|
2013-01-03 01:31:33 -08:00
|
|
|
|
2013-03-01 01:58:25 -08:00
|
|
|
elm_widget_activate(highlight, act);
|
|
|
|
return;
|
2012-11-30 03:50:52 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
|
|
|
_elm_access_highlight_cycle(Evas_Object *obj, Elm_Focus_Direction dir)
|
|
|
|
{
|
2013-04-17 18:52:01 -07:00
|
|
|
int type;
|
|
|
|
Evas_Object *ho, *parent;
|
|
|
|
|
2013-02-14 01:20:54 -08:00
|
|
|
ho = _access_highlight_object_get(obj);
|
2013-03-01 02:03:36 -08:00
|
|
|
if (!ho) return;
|
2013-02-14 01:20:54 -08:00
|
|
|
|
2013-04-17 18:52:01 -07:00
|
|
|
parent = ho;
|
|
|
|
|
2013-02-14 01:20:54 -08:00
|
|
|
/* find highlight root */
|
|
|
|
do
|
|
|
|
{
|
2013-10-05 01:13:18 -07:00
|
|
|
ELM_WIDGET_DATA_GET_OR_RETURN(parent, wd);
|
2013-02-14 01:20:54 -08:00
|
|
|
if (wd->highlight_root)
|
|
|
|
{
|
|
|
|
/* change highlight root */
|
2013-04-17 18:52:01 -07:00
|
|
|
obj = parent;
|
2013-02-14 01:20:54 -08:00
|
|
|
break;
|
|
|
|
}
|
2013-04-17 18:52:01 -07:00
|
|
|
parent = elm_widget_parent_get(parent);
|
2013-02-14 01:20:54 -08:00
|
|
|
}
|
2013-04-17 18:52:01 -07:00
|
|
|
while (parent);
|
2013-02-14 01:20:54 -08:00
|
|
|
|
2013-09-09 22:01:50 -07:00
|
|
|
_elm_access_auto_highlight_set(EINA_TRUE);
|
2013-04-17 18:52:01 -07:00
|
|
|
|
|
|
|
if (dir == ELM_FOCUS_NEXT)
|
|
|
|
type = ELM_ACCESS_ACTION_HIGHLIGHT_NEXT;
|
|
|
|
else
|
|
|
|
type = ELM_ACCESS_ACTION_HIGHLIGHT_PREV;
|
|
|
|
|
|
|
|
action_by = type;
|
|
|
|
|
2013-10-08 03:57:40 -07:00
|
|
|
if (!_access_action_callback_call(ho, type, NULL))
|
2013-07-05 22:41:00 -07:00
|
|
|
{
|
2013-07-30 20:53:04 -07:00
|
|
|
Elm_Access_Info *info = _elm_access_info_get(ho);
|
2013-07-05 22:41:00 -07:00
|
|
|
Evas_Object *comming = NULL;
|
|
|
|
if (type == ELM_ACCESS_ACTION_HIGHLIGHT_NEXT)
|
|
|
|
{
|
|
|
|
if ((info) && (info->next)) comming = info->next;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ((info) && (info->prev)) comming = info->prev;
|
|
|
|
}
|
|
|
|
if (comming)
|
|
|
|
{
|
|
|
|
_elm_access_highlight_set(comming);
|
|
|
|
elm_widget_focus_region_show(comming);
|
|
|
|
}
|
|
|
|
else
|
2017-09-27 08:28:41 -07:00
|
|
|
{
|
|
|
|
elm_widget_focus_set(obj, EINA_TRUE);
|
|
|
|
efl_ui_focus_manager_move(elm_widget_top_get(obj), dir);
|
|
|
|
}
|
2013-07-05 22:41:00 -07:00
|
|
|
}
|
2013-04-17 18:52:01 -07:00
|
|
|
|
|
|
|
action_by = ELM_ACCESS_ACTION_FIRST;
|
|
|
|
|
2013-09-09 22:01:50 -07:00
|
|
|
_elm_access_auto_highlight_set(EINA_FALSE);
|
2012-09-03 01:44:53 -07:00
|
|
|
}
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
EAPI char *
|
2013-01-10 13:11:59 -08:00
|
|
|
_elm_access_text_get(const Elm_Access_Info *ac, int type, const Evas_Object *obj)
|
2011-08-19 04:07:42 -07:00
|
|
|
{
|
|
|
|
Elm_Access_Item *ai;
|
|
|
|
Eina_List *l;
|
2011-08-19 08:26:04 -07:00
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
if (!ac) return NULL;
|
|
|
|
EINA_LIST_FOREACH(ac->items, l, ai)
|
|
|
|
{
|
|
|
|
if (ai->type == type)
|
|
|
|
{
|
2013-01-10 13:11:59 -08:00
|
|
|
if (ai->func) return ai->func((void *)(ai->data), (Evas_Object *)obj);
|
2011-08-19 04:07:42 -07:00
|
|
|
else if (ai->data) return strdup(ai->data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2013-01-10 13:11:59 -08:00
|
|
|
_elm_access_read(Elm_Access_Info *ac, int type, const Evas_Object *obj)
|
2011-08-19 04:07:42 -07:00
|
|
|
{
|
2012-12-23 06:50:56 -08:00
|
|
|
char *txt = _elm_access_text_get(ac, type, obj);
|
2011-08-19 04:07:42 -07:00
|
|
|
|
|
|
|
_access_init();
|
|
|
|
if (mapi)
|
|
|
|
{
|
|
|
|
if (mapi->out_done_callback_set)
|
|
|
|
mapi->out_done_callback_set(_access_read_done, NULL);
|
|
|
|
if (type == ELM_ACCESS_DONE)
|
|
|
|
{
|
|
|
|
if (mapi->out_read_done) mapi->out_read_done();
|
|
|
|
}
|
|
|
|
else if (type == ELM_ACCESS_CANCEL)
|
|
|
|
{
|
|
|
|
if (mapi->out_cancel) mapi->out_cancel();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (txt)
|
|
|
|
{
|
|
|
|
if (mapi->out_read) mapi->out_read(txt);
|
|
|
|
if (mapi->out_read) mapi->out_read(".\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-01-21 18:08:47 -08:00
|
|
|
free(txt);
|
2011-08-19 04:07:42 -07:00
|
|
|
}
|
|
|
|
|
2011-08-19 04:47:30 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_access_say(const char *txt)
|
|
|
|
{
|
2013-02-03 20:51:26 -08:00
|
|
|
if (!_elm_config->access_mode) return;
|
|
|
|
|
2011-08-19 04:47:30 -07:00
|
|
|
_access_init();
|
|
|
|
if (mapi)
|
|
|
|
{
|
|
|
|
if (mapi->out_done_callback_set)
|
|
|
|
mapi->out_done_callback_set(_access_read_done, NULL);
|
|
|
|
if (mapi->out_cancel) mapi->out_cancel();
|
|
|
|
if (txt)
|
|
|
|
{
|
|
|
|
if (mapi->out_read) mapi->out_read(txt);
|
|
|
|
if (mapi->out_read) mapi->out_read(".\n");
|
|
|
|
}
|
|
|
|
if (mapi->out_read_done) mapi->out_read_done();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
EAPI Elm_Access_Info *
|
2013-07-30 20:53:04 -07:00
|
|
|
_elm_access_info_get(const Evas_Object *obj)
|
2011-08-19 04:07:42 -07:00
|
|
|
{
|
|
|
|
return evas_object_data_get(obj, "_elm_access");
|
|
|
|
}
|
|
|
|
|
2013-07-30 20:53:04 -07:00
|
|
|
EAPI Elm_Access_Info *
|
|
|
|
_elm_access_object_get(const Evas_Object *obj)
|
|
|
|
{
|
|
|
|
return _elm_access_info_get(obj);
|
|
|
|
}
|
|
|
|
|
2014-02-07 19:27:41 -08:00
|
|
|
static Evas_Object *
|
|
|
|
_elm_access_widget_target_get(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Evas_Object *o = obj;
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if (elm_widget_is(o))
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
o = elm_widget_parent_widget_get(o);
|
|
|
|
if (!o)
|
|
|
|
o = evas_object_smart_parent_get(o);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while (o);
|
|
|
|
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
2011-08-19 07:39:27 -07:00
|
|
|
EAPI void
|
2013-10-31 07:01:56 -07:00
|
|
|
_elm_access_object_highlight(Evas_Object *obj)
|
2011-08-19 07:39:27 -07:00
|
|
|
{
|
2014-02-07 19:27:41 -08:00
|
|
|
Evas_Object *o, *widget;
|
2011-08-23 01:46:01 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
2014-02-07 19:27:41 -08:00
|
|
|
Eina_Bool in_theme = EINA_FALSE;
|
2011-08-24 01:11:58 -07:00
|
|
|
|
2011-08-23 00:44:49 -07:00
|
|
|
o = evas_object_name_find(evas_object_evas_get(obj), "_elm_access_disp");
|
|
|
|
if (!o)
|
|
|
|
{
|
|
|
|
o = edje_object_add(evas_object_evas_get(obj));
|
|
|
|
evas_object_name_set(o, "_elm_access_disp");
|
|
|
|
evas_object_layer_set(o, ELM_OBJECT_LAYER_TOOLTIP);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Evas_Object *ptarget = evas_object_data_get(o, "_elm_access_target");
|
|
|
|
if (ptarget)
|
|
|
|
{
|
|
|
|
evas_object_data_del(o, "_elm_access_target");
|
2013-01-28 03:13:18 -08:00
|
|
|
elm_widget_parent_highlight_set(ptarget, EINA_FALSE);
|
|
|
|
|
2011-08-23 01:46:01 -07:00
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_DEL,
|
|
|
|
_access_obj_hilight_del_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_HIDE,
|
|
|
|
_access_obj_hilight_hide_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_MOVE,
|
|
|
|
_access_obj_hilight_move_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_RESIZE,
|
|
|
|
_access_obj_hilight_resize_cb, NULL);
|
2014-02-07 19:27:41 -08:00
|
|
|
|
|
|
|
widget = _elm_access_widget_target_get(ptarget);
|
|
|
|
if (widget)
|
|
|
|
{
|
|
|
|
if (elm_widget_access_highlight_in_theme_get(widget))
|
|
|
|
{
|
|
|
|
elm_widget_signal_emit(widget, "elm,action,access_highlight,hide", "elm");
|
|
|
|
}
|
|
|
|
}
|
2011-08-23 00:44:49 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
evas_object_data_set(o, "_elm_access_target", obj);
|
2013-01-28 03:13:18 -08:00
|
|
|
elm_widget_parent_highlight_set(obj, EINA_TRUE);
|
2012-12-23 06:50:56 -08:00
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
elm_widget_theme_object_set(obj, o, "access", "base", "default");
|
2012-12-23 06:50:56 -08:00
|
|
|
|
2011-08-23 01:46:01 -07:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
|
|
|
|
_access_obj_hilight_del_cb, NULL);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_HIDE,
|
|
|
|
_access_obj_hilight_hide_cb, NULL);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE,
|
|
|
|
_access_obj_hilight_move_cb, NULL);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE,
|
|
|
|
_access_obj_hilight_resize_cb, NULL);
|
2011-08-23 00:44:49 -07:00
|
|
|
evas_object_raise(o);
|
2011-08-23 01:46:01 -07:00
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
|
|
|
evas_object_move(o, x, y);
|
|
|
|
evas_object_resize(o, w, h);
|
2013-04-17 18:52:01 -07:00
|
|
|
|
2014-02-07 19:27:41 -08:00
|
|
|
widget = _elm_access_widget_target_get(obj);
|
|
|
|
if (widget)
|
|
|
|
{
|
|
|
|
if (elm_widget_access_highlight_in_theme_get(widget))
|
|
|
|
{
|
|
|
|
in_theme = EINA_TRUE;
|
|
|
|
elm_widget_signal_emit(widget, "elm,action,access_highlight,show", "elm");
|
|
|
|
}
|
|
|
|
}
|
2013-04-17 18:52:01 -07:00
|
|
|
/* use callback, should an access object do below every time when
|
|
|
|
* a window gets a client message ECORE_X_ATOM_E_ILLMUE_ACTION_READ? */
|
2014-02-07 19:27:41 -08:00
|
|
|
if (!in_theme &&
|
|
|
|
!_access_action_callback_call(obj, ELM_ACCESS_ACTION_HIGHLIGHT, NULL))
|
2013-04-17 18:52:01 -07:00
|
|
|
evas_object_show(o);
|
|
|
|
else
|
|
|
|
evas_object_hide(o);
|
2011-08-19 07:39:27 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2014-05-07 19:14:36 -07:00
|
|
|
_elm_access_object_unhighlight(Evas_Object *obj)
|
2011-08-19 07:39:27 -07:00
|
|
|
{
|
2011-08-23 00:44:49 -07:00
|
|
|
Evas_Object *o, *ptarget;
|
2011-08-24 01:11:58 -07:00
|
|
|
|
2011-08-23 00:44:49 -07:00
|
|
|
o = evas_object_name_find(evas_object_evas_get(obj), "_elm_access_disp");
|
|
|
|
if (!o) return;
|
|
|
|
ptarget = evas_object_data_get(o, "_elm_access_target");
|
2011-08-23 01:46:01 -07:00
|
|
|
if (ptarget == obj)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_DEL,
|
|
|
|
_access_obj_hilight_del_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_HIDE,
|
|
|
|
_access_obj_hilight_hide_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_MOVE,
|
|
|
|
_access_obj_hilight_move_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_RESIZE,
|
|
|
|
_access_obj_hilight_resize_cb, NULL);
|
|
|
|
evas_object_del(o);
|
2013-01-28 03:13:18 -08:00
|
|
|
elm_widget_parent_highlight_set(ptarget, EINA_FALSE);
|
2011-08-23 01:46:01 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-25 22:54:45 -07:00
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_content_resize(void *data, Evas *e EINA_UNUSED, Evas_Object *obj,
|
|
|
|
void *event_info EINA_UNUSED)
|
2012-06-25 22:54:45 -07:00
|
|
|
{
|
|
|
|
Evas_Object *accessobj;
|
|
|
|
Evas_Coord w, h;
|
|
|
|
|
|
|
|
accessobj = data;
|
|
|
|
if (!accessobj) return;
|
|
|
|
|
|
|
|
evas_object_geometry_get(obj, NULL, NULL, &w, &h);
|
|
|
|
evas_object_resize(accessobj, w, h);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_content_move(void *data, Evas *e EINA_UNUSED, Evas_Object *obj,
|
|
|
|
void *event_info EINA_UNUSED)
|
2012-06-25 22:54:45 -07:00
|
|
|
{
|
|
|
|
Evas_Object *accessobj;
|
|
|
|
Evas_Coord x, y;
|
|
|
|
|
|
|
|
accessobj = data;
|
|
|
|
if (!accessobj) return;
|
|
|
|
|
|
|
|
evas_object_geometry_get(obj, &x, &y, NULL, NULL);
|
|
|
|
evas_object_move(accessobj, x, y);
|
|
|
|
}
|
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
static Evas_Object *
|
|
|
|
_access_object_register(Evas_Object *obj, Evas_Object *parent)
|
2012-06-25 22:54:45 -07:00
|
|
|
{
|
|
|
|
Evas_Object *ao;
|
2012-11-12 21:50:08 -08:00
|
|
|
Elm_Access_Info *ac;
|
2013-01-10 04:00:05 -08:00
|
|
|
Evas_Coord x, y, w, h;
|
2012-06-25 22:54:45 -07:00
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
if (!obj) return NULL;
|
2012-06-25 22:54:45 -07:00
|
|
|
|
2016-11-09 04:13:57 -08:00
|
|
|
/* check previous access object */
|
|
|
|
ao = evas_object_data_get(obj, "_part_access_obj");
|
|
|
|
if (ao)
|
|
|
|
_access_object_unregister(obj);
|
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
/* create access object */
|
|
|
|
ao = _elm_access_add(parent);
|
2013-01-07 05:26:54 -08:00
|
|
|
if (!ao) return NULL;
|
2013-01-06 21:56:51 -08:00
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE,
|
2012-06-25 22:54:45 -07:00
|
|
|
_content_resize, ao);
|
2013-01-10 04:00:05 -08:00
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_MOVE,
|
2012-06-25 22:54:45 -07:00
|
|
|
_content_move, ao);
|
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
evas_object_geometry_get(obj, &x, &y, &w, &h);
|
2012-06-25 22:54:45 -07:00
|
|
|
evas_object_move(ao, x, y);
|
|
|
|
evas_object_resize(ao, w, h);
|
|
|
|
evas_object_show(ao);
|
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
/* register access object */
|
|
|
|
_elm_access_object_register(ao, obj);
|
|
|
|
|
|
|
|
/* set access object */
|
|
|
|
evas_object_data_set(obj, "_part_access_obj", ao);
|
2012-09-12 01:25:10 -07:00
|
|
|
|
2012-11-12 21:50:08 -08:00
|
|
|
/* set owner part object */
|
|
|
|
ac = evas_object_data_get(ao, "_elm_access");
|
2013-01-10 04:00:05 -08:00
|
|
|
ac->part_object = obj;
|
2012-11-12 21:50:08 -08:00
|
|
|
|
2012-06-25 22:54:45 -07:00
|
|
|
return ao;
|
|
|
|
}
|
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
static void
|
|
|
|
_access_object_unregister(Evas_Object *obj)
|
2012-09-12 01:25:10 -07:00
|
|
|
{
|
2013-02-07 22:16:03 -08:00
|
|
|
Elm_Access_Info *ac;
|
2012-09-12 01:25:10 -07:00
|
|
|
Evas_Object *ao;
|
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
if (!obj) return;
|
2012-09-12 01:25:10 -07:00
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
ao = evas_object_data_get(obj, "_part_access_obj");
|
2012-09-12 01:25:10 -07:00
|
|
|
|
2013-02-07 22:16:03 -08:00
|
|
|
if (ao)
|
|
|
|
{
|
2013-09-06 19:34:04 -07:00
|
|
|
/* delete callbacks and unregister access object in _access_obj_del_cb*/
|
2013-02-07 22:16:03 -08:00
|
|
|
evas_object_del(ao);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* button, check, label etc. */
|
|
|
|
ac = evas_object_data_get(obj, "_elm_access");
|
|
|
|
if (ac && ac->hoverobj)
|
|
|
|
_elm_access_object_unregister(obj, ac->hoverobj);
|
|
|
|
}
|
2012-09-12 01:25:10 -07:00
|
|
|
}
|
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
EAPI Evas_Object *
|
|
|
|
_elm_access_edje_object_part_object_register(Evas_Object* obj,
|
|
|
|
const Evas_Object *eobj,
|
|
|
|
const char* part)
|
|
|
|
{
|
|
|
|
Evas_Object *ao, *po;
|
|
|
|
|
|
|
|
po = (Evas_Object *)edje_object_part_object_get(eobj, part);
|
|
|
|
if (!obj || !po) return NULL;
|
|
|
|
|
|
|
|
/* check previous access object */
|
|
|
|
ao = evas_object_data_get(po, "_part_access_obj");
|
|
|
|
if (ao)
|
|
|
|
_elm_access_edje_object_part_object_unregister(obj, eobj, part);
|
|
|
|
|
|
|
|
ao = _access_object_register(po, obj);
|
|
|
|
|
|
|
|
return ao;
|
|
|
|
}
|
|
|
|
|
|
|
|
//FIXME: unused obj should be removed from here and each widget.
|
|
|
|
EAPI void
|
2014-01-06 06:30:02 -08:00
|
|
|
_elm_access_edje_object_part_object_unregister(Evas_Object* obj EINA_UNUSED,
|
2013-01-10 04:00:05 -08:00
|
|
|
const Evas_Object *eobj,
|
|
|
|
const char* part)
|
|
|
|
{
|
|
|
|
Evas_Object *po;
|
|
|
|
|
|
|
|
po = (Evas_Object *)edje_object_part_object_get(eobj, part);
|
|
|
|
if (!po) return;
|
|
|
|
|
|
|
|
_access_object_unregister(po);
|
|
|
|
}
|
|
|
|
|
2011-08-23 01:46:01 -07:00
|
|
|
EAPI void
|
2013-10-31 07:01:56 -07:00
|
|
|
_elm_access_object_highlight_disable(Evas *e)
|
2011-08-23 01:46:01 -07:00
|
|
|
{
|
|
|
|
Evas_Object *o, *ptarget;
|
|
|
|
|
|
|
|
o = evas_object_name_find(e, "_elm_access_disp");
|
|
|
|
if (!o) return;
|
|
|
|
ptarget = evas_object_data_get(o, "_elm_access_target");
|
|
|
|
if (ptarget)
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_DEL,
|
|
|
|
_access_obj_hilight_del_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_HIDE,
|
|
|
|
_access_obj_hilight_hide_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_MOVE,
|
|
|
|
_access_obj_hilight_move_cb, NULL);
|
|
|
|
evas_object_event_callback_del_full(ptarget, EVAS_CALLBACK_RESIZE,
|
|
|
|
_access_obj_hilight_resize_cb, NULL);
|
|
|
|
}
|
|
|
|
evas_object_del(o);
|
2013-01-28 03:13:18 -08:00
|
|
|
elm_widget_parent_highlight_set(ptarget, EINA_FALSE);
|
2011-08-19 07:39:27 -07:00
|
|
|
}
|
|
|
|
|
2013-09-06 19:34:04 -07:00
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_obj_del_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
|
2013-09-06 19:34:04 -07:00
|
|
|
{
|
|
|
|
|
|
|
|
Ecore_Job *ao_del_job = NULL;
|
|
|
|
|
|
|
|
evas_object_event_callback_del(obj, EVAS_CALLBACK_DEL, _access_obj_del_cb);
|
|
|
|
|
|
|
|
if (data) /* hover object */
|
|
|
|
{
|
|
|
|
evas_object_event_callback_del_full(data, EVAS_CALLBACK_RESIZE,
|
|
|
|
_content_resize, obj);
|
|
|
|
evas_object_event_callback_del_full(data, EVAS_CALLBACK_MOVE,
|
|
|
|
_content_move, obj);
|
|
|
|
|
|
|
|
_elm_access_object_unregister(obj, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
ao_del_job = evas_object_data_get(obj, "_access_obj_del_job");
|
|
|
|
|
|
|
|
if (ao_del_job)
|
|
|
|
{
|
|
|
|
ecore_job_del(ao_del_job);
|
|
|
|
evas_object_data_del(obj, "_access_obj_del_job");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_access_obj_del_job(void *data)
|
|
|
|
{
|
|
|
|
if (!data) return;
|
|
|
|
|
|
|
|
evas_object_data_del(data, "_access_obj_del_job");
|
|
|
|
|
|
|
|
evas_object_event_callback_del(data, EVAS_CALLBACK_DEL, _access_obj_del_cb);
|
|
|
|
evas_object_del(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2014-01-06 06:30:02 -08:00
|
|
|
_access_hover_del_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
|
2013-09-06 19:34:04 -07:00
|
|
|
{
|
|
|
|
Ecore_Job *ao_del_job = NULL;
|
|
|
|
|
|
|
|
/* data - access object - could be NULL */
|
|
|
|
if (!data) return;
|
|
|
|
|
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_RESIZE,
|
|
|
|
_content_resize, data);
|
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_MOVE,
|
|
|
|
_content_move, data);
|
|
|
|
|
|
|
|
_elm_access_object_unregister(data, obj);
|
|
|
|
|
|
|
|
/* delete access object in job */
|
|
|
|
ao_del_job = evas_object_data_get(data, "_access_obj_del_job");
|
|
|
|
if (ao_del_job)
|
|
|
|
{
|
|
|
|
ecore_job_del(ao_del_job);
|
|
|
|
evas_object_data_del(data, "_access_obj_del_job");
|
|
|
|
}
|
|
|
|
|
|
|
|
ao_del_job = ecore_job_add(_access_obj_del_job, data);
|
|
|
|
evas_object_data_set(data, "_access_obj_del_job", ao_del_job);
|
|
|
|
}
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
EAPI void
|
|
|
|
_elm_access_object_register(Evas_Object *obj, Evas_Object *hoverobj)
|
|
|
|
{
|
|
|
|
Elm_Access_Info *ac;
|
2011-08-19 08:26:04 -07:00
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
evas_object_event_callback_add(hoverobj, EVAS_CALLBACK_MOUSE_IN,
|
2013-09-06 19:34:04 -07:00
|
|
|
_access_hover_mouse_in_cb, obj);
|
2011-08-19 04:07:42 -07:00
|
|
|
evas_object_event_callback_add(hoverobj, EVAS_CALLBACK_MOUSE_OUT,
|
2013-09-06 19:34:04 -07:00
|
|
|
_access_hover_mouse_out_cb, obj);
|
2011-08-19 04:07:42 -07:00
|
|
|
evas_object_event_callback_add(hoverobj, EVAS_CALLBACK_DEL,
|
2013-09-06 19:34:04 -07:00
|
|
|
_access_hover_del_cb, obj);
|
|
|
|
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
|
|
|
|
_access_obj_del_cb, hoverobj);
|
|
|
|
|
2011-08-19 04:07:42 -07:00
|
|
|
ac = calloc(1, sizeof(Elm_Access_Info));
|
|
|
|
evas_object_data_set(obj, "_elm_access", ac);
|
2013-02-07 22:16:03 -08:00
|
|
|
|
|
|
|
ac->hoverobj = hoverobj;
|
2011-08-19 04:07:42 -07:00
|
|
|
}
|
|
|
|
|
2012-11-19 05:08:54 -08:00
|
|
|
EAPI void
|
|
|
|
_elm_access_object_unregister(Evas_Object *obj, Evas_Object *hoverobj)
|
|
|
|
{
|
|
|
|
Elm_Access_Info *ac;
|
2013-09-06 19:34:04 -07:00
|
|
|
Evas_Object *ao;
|
2012-11-19 05:08:54 -08:00
|
|
|
|
|
|
|
evas_object_event_callback_del_full(hoverobj, EVAS_CALLBACK_MOUSE_IN,
|
2013-09-06 19:34:04 -07:00
|
|
|
_access_hover_mouse_in_cb, obj);
|
2012-11-19 05:08:54 -08:00
|
|
|
evas_object_event_callback_del_full(hoverobj, EVAS_CALLBACK_MOUSE_OUT,
|
2013-09-06 19:34:04 -07:00
|
|
|
_access_hover_mouse_out_cb, obj);
|
2012-11-19 05:08:54 -08:00
|
|
|
evas_object_event_callback_del_full(hoverobj, EVAS_CALLBACK_DEL,
|
2013-09-06 19:34:04 -07:00
|
|
|
_access_hover_del_cb, obj);
|
|
|
|
|
|
|
|
/* _access_obj_del_cb and _access_hover_del_cb calls this function,
|
|
|
|
both do not need _part_access_obj data, so delete the data here. */
|
|
|
|
ao = evas_object_data_get(hoverobj, "_part_access_obj");
|
|
|
|
if (ao) evas_object_data_del(hoverobj, "_part_access_obj");
|
2012-11-19 05:08:54 -08:00
|
|
|
|
|
|
|
ac = evas_object_data_get(obj, "_elm_access");
|
|
|
|
evas_object_data_del(obj, "_elm_access");
|
|
|
|
if (ac)
|
|
|
|
{
|
|
|
|
_elm_access_clear(ac);
|
|
|
|
free(ac);
|
|
|
|
}
|
2013-04-17 18:52:01 -07:00
|
|
|
|
|
|
|
Action_Info *a;
|
|
|
|
a = evas_object_data_get(obj, "_elm_access_action_info");
|
2013-08-09 03:03:56 -07:00
|
|
|
evas_object_data_del(obj, "_elm_access_action_info");
|
2014-01-21 18:08:47 -08:00
|
|
|
free(a);
|
2012-11-19 05:08:54 -08:00
|
|
|
}
|
|
|
|
|
2012-06-29 23:21:14 -07:00
|
|
|
EAPI void
|
2014-08-13 06:36:29 -07:00
|
|
|
_elm_access_widget_item_register(Elm_Widget_Item_Data *item)
|
2012-06-29 23:21:14 -07:00
|
|
|
{
|
2012-10-03 19:47:15 -07:00
|
|
|
Evas_Object *ao, *ho;
|
2012-06-29 23:21:14 -07:00
|
|
|
Evas_Coord x, y, w, h;
|
2012-11-12 21:50:08 -08:00
|
|
|
Elm_Access_Info *ac;
|
2012-06-29 23:21:14 -07:00
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
2012-06-29 23:21:14 -07:00
|
|
|
|
2012-11-19 05:08:54 -08:00
|
|
|
/* check previous access object */
|
|
|
|
if (item->access_obj)
|
|
|
|
_elm_access_widget_item_unregister(item);
|
|
|
|
|
2012-06-29 23:21:14 -07:00
|
|
|
// create access object
|
2012-10-03 19:47:15 -07:00
|
|
|
ho = item->view;
|
2012-06-29 23:21:14 -07:00
|
|
|
ao = _elm_access_add(item->widget);
|
2013-01-06 21:56:51 -08:00
|
|
|
if (!ao) return;
|
|
|
|
|
2012-06-29 23:21:14 -07:00
|
|
|
evas_object_event_callback_add(ho, EVAS_CALLBACK_RESIZE,
|
|
|
|
_content_resize, ao);
|
|
|
|
evas_object_event_callback_add(ho, EVAS_CALLBACK_MOVE,
|
|
|
|
_content_move, ao);
|
|
|
|
|
|
|
|
evas_object_geometry_get(ho, &x, &y, &w, &h);
|
|
|
|
evas_object_move(ao, x, y);
|
|
|
|
evas_object_resize(ao, w, h);
|
|
|
|
evas_object_show(ao);
|
|
|
|
|
|
|
|
// register access object
|
|
|
|
_elm_access_object_register(ao, ho);
|
|
|
|
|
|
|
|
item->access_obj = ao;
|
2012-11-12 21:50:08 -08:00
|
|
|
|
|
|
|
/* set owner widget item */
|
|
|
|
ac = evas_object_data_get(ao, "_elm_access");
|
|
|
|
ac->widget_item = item;
|
2012-06-29 23:21:14 -07:00
|
|
|
}
|
|
|
|
|
2012-08-18 06:52:03 -07:00
|
|
|
EAPI void
|
2014-08-13 06:36:29 -07:00
|
|
|
_elm_access_widget_item_unregister(Elm_Widget_Item_Data *item)
|
2012-08-18 06:52:03 -07:00
|
|
|
{
|
2013-09-06 19:34:04 -07:00
|
|
|
Evas_Object *ao;
|
2012-08-18 06:52:03 -07:00
|
|
|
|
2013-01-10 04:00:05 -08:00
|
|
|
ELM_WIDGET_ITEM_CHECK_OR_RETURN(item);
|
|
|
|
|
|
|
|
if (!item->access_obj) return;
|
2012-08-18 06:52:03 -07:00
|
|
|
|
2013-09-06 19:34:04 -07:00
|
|
|
/* delete callbacks and unregister access object in _access_obj_del_cb*/
|
|
|
|
ao = item->access_obj;
|
2012-11-19 05:08:54 -08:00
|
|
|
item->access_obj = NULL;
|
2013-09-06 19:34:04 -07:00
|
|
|
|
|
|
|
evas_object_del(ao);
|
2012-08-18 06:52:03 -07:00
|
|
|
}
|
|
|
|
|
2011-08-19 07:39:27 -07:00
|
|
|
EAPI Eina_Bool
|
|
|
|
_elm_access_2nd_click_timeout(Evas_Object *obj)
|
|
|
|
{
|
|
|
|
Ecore_Timer *t;
|
|
|
|
|
|
|
|
t = evas_object_data_get(obj, "_elm_2nd_timeout");
|
|
|
|
if (t)
|
|
|
|
{
|
|
|
|
ecore_timer_del(t);
|
|
|
|
evas_object_data_del(obj, "_elm_2nd_timeout");
|
|
|
|
evas_object_event_callback_del_full(obj, EVAS_CALLBACK_DEL,
|
|
|
|
_access_2nd_click_del_cb, NULL);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
t = ecore_timer_add(0.3, _access_2nd_click_timeout_cb, obj);
|
|
|
|
evas_object_data_set(obj, "_elm_2nd_timeout", t);
|
|
|
|
evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL,
|
|
|
|
_access_2nd_click_del_cb, NULL);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
2012-06-25 22:54:45 -07:00
|
|
|
|
|
|
|
static Evas_Object *
|
|
|
|
_elm_access_add(Evas_Object *parent)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
|
2017-07-06 00:47:41 -07:00
|
|
|
return efl_add(MY_CLASS, parent, efl_canvas_object_legacy_ctor(efl_added));
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-06-25 22:54:45 -07:00
|
|
|
|
2015-05-19 05:34:07 -07:00
|
|
|
EOLIAN static Eo *
|
2016-08-10 07:23:04 -07:00
|
|
|
_elm_access_efl_object_constructor(Eo *obj, void *_pd EINA_UNUSED)
|
2012-11-25 22:32:53 -08:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_constructor(efl_super(obj, MY_CLASS));
|
2016-06-20 21:26:15 -07:00
|
|
|
efl_canvas_object_type_set(obj, MY_CLASS_NAME_LEGACY);
|
2017-04-05 03:58:46 -07:00
|
|
|
evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
|
2015-05-19 05:34:07 -07:00
|
|
|
|
|
|
|
return obj;
|
2012-11-25 22:32:53 -08:00
|
|
|
}
|
2012-06-25 22:54:45 -07:00
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI Evas_Object *
|
2013-01-10 04:00:05 -08:00
|
|
|
elm_access_object_register(Evas_Object *obj, Evas_Object *parent)
|
|
|
|
{
|
|
|
|
return _access_object_register(obj, parent);
|
2012-12-23 06:50:56 -08:00
|
|
|
}
|
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI void
|
2012-12-23 06:50:56 -08:00
|
|
|
elm_access_object_unregister(Evas_Object *obj)
|
|
|
|
{
|
2013-01-10 04:00:05 -08:00
|
|
|
_access_object_unregister(obj);
|
|
|
|
}
|
2012-12-23 06:50:56 -08:00
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI Evas_Object *
|
2013-01-14 22:31:35 -08:00
|
|
|
elm_access_object_get(const Evas_Object *obj)
|
2013-01-10 04:00:05 -08:00
|
|
|
{
|
|
|
|
return evas_object_data_get(obj, "_part_access_obj");
|
|
|
|
}
|
2012-12-23 06:50:56 -08:00
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI void
|
2013-01-14 20:20:37 -08:00
|
|
|
elm_access_info_set(Evas_Object *obj, int type, const char *text)
|
2013-01-10 04:00:05 -08:00
|
|
|
{
|
2013-07-30 20:53:04 -07:00
|
|
|
_elm_access_text_set(_elm_access_info_get(obj), type, text);
|
2013-01-10 04:00:05 -08:00
|
|
|
}
|
2012-12-23 06:50:56 -08:00
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI char *
|
2013-01-14 20:20:37 -08:00
|
|
|
elm_access_info_get(const Evas_Object *obj, int type)
|
2013-01-10 04:00:05 -08:00
|
|
|
{
|
2013-07-30 20:53:04 -07:00
|
|
|
return _elm_access_text_get(_elm_access_info_get(obj), type, obj);
|
2012-12-23 06:50:56 -08:00
|
|
|
}
|
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI void
|
2013-01-14 20:20:37 -08:00
|
|
|
elm_access_info_cb_set(Evas_Object *obj, int type,
|
|
|
|
Elm_Access_Info_Cb func, const void *data)
|
2013-01-03 01:31:33 -08:00
|
|
|
{
|
2013-07-30 20:53:04 -07:00
|
|
|
_elm_access_callback_set(_elm_access_info_get(obj), type, func, data);
|
2013-01-03 01:31:33 -08:00
|
|
|
}
|
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI void
|
2013-01-03 01:31:33 -08:00
|
|
|
elm_access_activate_cb_set(Evas_Object *obj,
|
2013-01-10 13:11:34 -08:00
|
|
|
Elm_Access_Activate_Cb func, void *data)
|
2013-01-03 01:31:33 -08:00
|
|
|
{
|
|
|
|
Elm_Access_Info *ac;
|
|
|
|
|
2013-07-30 20:53:04 -07:00
|
|
|
ac = _elm_access_info_get(obj);
|
2013-01-03 01:31:33 -08:00
|
|
|
if (!ac) return;
|
|
|
|
|
|
|
|
ac->activate = func;
|
|
|
|
ac->activate_data = data;
|
|
|
|
}
|
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI void
|
2013-02-05 02:11:42 -08:00
|
|
|
elm_access_say(const char *text)
|
|
|
|
{
|
|
|
|
if (!text) return;
|
|
|
|
|
|
|
|
_elm_access_say(text);
|
|
|
|
}
|
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI void
|
2013-02-05 02:11:42 -08:00
|
|
|
elm_access_highlight_set(Evas_Object* obj)
|
|
|
|
{
|
2013-03-22 16:45:26 -07:00
|
|
|
_elm_access_highlight_set(obj);
|
2013-02-05 02:11:42 -08:00
|
|
|
}
|
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI Eina_Bool
|
2013-04-17 18:52:01 -07:00
|
|
|
elm_access_action(Evas_Object *obj, const Elm_Access_Action_Type type, Elm_Access_Action_Info *action_info)
|
|
|
|
{
|
|
|
|
Evas *evas;
|
|
|
|
Evas_Object *ho;
|
2013-08-11 02:23:18 -07:00
|
|
|
Elm_Access_Action_Info *a = action_info;
|
2013-04-17 18:52:01 -07:00
|
|
|
|
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case ELM_ACCESS_ACTION_READ:
|
|
|
|
case ELM_ACCESS_ACTION_HIGHLIGHT:
|
|
|
|
evas = evas_object_evas_get(obj);
|
|
|
|
if (!evas) return EINA_FALSE;
|
|
|
|
|
|
|
|
evas_event_feed_mouse_in(evas, 0, NULL);
|
2013-09-09 22:01:50 -07:00
|
|
|
|
|
|
|
_elm_access_mouse_event_enabled_set(EINA_TRUE);
|
2013-04-17 18:52:01 -07:00
|
|
|
evas_event_feed_mouse_move(evas, a->x, a->y, 0, NULL);
|
|
|
|
_elm_access_mouse_event_enabled_set(EINA_FALSE);
|
|
|
|
|
|
|
|
ho = _access_highlight_object_get(obj);
|
|
|
|
if (ho)
|
|
|
|
_access_action_callback_call(ho, ELM_ACCESS_ACTION_READ, a);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_ACCESS_ACTION_UNHIGHLIGHT:
|
|
|
|
evas = evas_object_evas_get(obj);
|
|
|
|
if (!evas) return EINA_FALSE;
|
2013-10-31 07:01:56 -07:00
|
|
|
_elm_access_object_highlight_disable(evas);
|
2013-04-17 18:52:01 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_ACCESS_ACTION_HIGHLIGHT_NEXT:
|
|
|
|
if (a->highlight_cycle)
|
|
|
|
_elm_access_highlight_cycle(obj, ELM_FOCUS_NEXT);
|
|
|
|
else
|
|
|
|
return _access_highlight_next_get(obj, ELM_FOCUS_NEXT);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_ACCESS_ACTION_HIGHLIGHT_PREV:
|
|
|
|
if (a->highlight_cycle)
|
|
|
|
_elm_access_highlight_cycle(obj, ELM_FOCUS_PREVIOUS);
|
|
|
|
else
|
|
|
|
return _access_highlight_next_get(obj, ELM_FOCUS_PREVIOUS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_ACCESS_ACTION_ACTIVATE:
|
2017-10-15 21:33:52 -07:00
|
|
|
_elm_access_highlight_object_activate(obj, EFL_UI_ACTIVATE_DEFAULT);
|
2013-04-17 18:52:01 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_ACCESS_ACTION_UP:
|
2017-10-15 21:33:52 -07:00
|
|
|
_elm_access_highlight_object_activate(obj, EFL_UI_ACTIVATE_UP);
|
2013-04-17 18:52:01 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_ACCESS_ACTION_DOWN:
|
2017-10-15 21:33:52 -07:00
|
|
|
_elm_access_highlight_object_activate(obj, EFL_UI_ACTIVATE_DOWN);
|
2013-04-17 18:52:01 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_ACCESS_ACTION_SCROLL:
|
|
|
|
//TODO: SCROLL HIGHLIGHT OBJECT
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ELM_ACCESS_ACTION_BACK:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI void
|
2013-04-17 18:52:01 -07:00
|
|
|
elm_access_action_cb_set(Evas_Object *obj, const Elm_Access_Action_Type type, const Elm_Access_Action_Cb cb, const void *data)
|
|
|
|
{
|
|
|
|
Action_Info *a;
|
|
|
|
a = evas_object_data_get(obj, "_elm_access_action_info");
|
|
|
|
|
|
|
|
if (!a)
|
|
|
|
{
|
|
|
|
a = calloc(1, sizeof(Action_Info));
|
|
|
|
evas_object_data_set(obj, "_elm_access_action_info", a);
|
|
|
|
}
|
|
|
|
|
|
|
|
a->obj = obj;
|
|
|
|
a->fn[type].cb = cb;
|
|
|
|
a->fn[type].user_data = (void *)data;
|
|
|
|
}
|
2012-12-06 02:56:29 -08:00
|
|
|
EAPI void
|
|
|
|
elm_access_external_info_set(Evas_Object *obj, const char *text)
|
|
|
|
{
|
|
|
|
_elm_access_text_set
|
2013-07-30 20:53:04 -07:00
|
|
|
(_elm_access_info_get(obj), ELM_ACCESS_CONTEXT_INFO, text);
|
2012-12-06 02:56:29 -08:00
|
|
|
}
|
|
|
|
|
2012-12-06 04:21:19 -08:00
|
|
|
EAPI char *
|
2012-12-06 08:12:59 -08:00
|
|
|
elm_access_external_info_get(const Evas_Object *obj)
|
2012-12-06 04:21:19 -08:00
|
|
|
{
|
|
|
|
Elm_Access_Info *ac;
|
|
|
|
|
2013-07-30 20:53:04 -07:00
|
|
|
ac = _elm_access_info_get(obj);
|
2013-01-10 13:11:59 -08:00
|
|
|
return _elm_access_text_get(ac, ELM_ACCESS_CONTEXT_INFO, obj);
|
2012-12-06 04:21:19 -08:00
|
|
|
}
|
|
|
|
|
2013-12-15 23:02:17 -08:00
|
|
|
EAPI void
|
2013-07-05 22:41:00 -07:00
|
|
|
elm_access_highlight_next_set(Evas_Object *obj, Elm_Highlight_Direction dir, Evas_Object *next)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_FALSE_RETURN(obj);
|
|
|
|
EINA_SAFETY_ON_FALSE_RETURN(next);
|
|
|
|
|
2013-07-30 20:53:04 -07:00
|
|
|
Elm_Access_Info *info = _elm_access_info_get(obj);
|
|
|
|
Elm_Access_Info *info_next = _elm_access_info_get(next);
|
2013-07-05 22:41:00 -07:00
|
|
|
|
|
|
|
if (!info || !info_next)
|
|
|
|
{
|
|
|
|
ERR("There is no access information");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dir == ELM_HIGHLIGHT_DIR_NEXT)
|
|
|
|
{
|
|
|
|
info_next->prev = obj;
|
|
|
|
info->next = next;
|
|
|
|
}
|
|
|
|
else if (dir == ELM_HIGHLIGHT_DIR_PREVIOUS)
|
|
|
|
{
|
|
|
|
info_next->next = obj;
|
|
|
|
info->prev = next;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ERR("Not supported focus direction for access highlight [%d]", dir);
|
|
|
|
}
|
|
|
|
|
2014-03-18 04:47:23 -07:00
|
|
|
EOLIAN static void
|
2016-08-10 07:23:04 -07:00
|
|
|
_elm_access_class_constructor(Efl_Class *klass)
|
2013-01-10 13:11:34 -08:00
|
|
|
{
|
2013-11-07 03:44:22 -08:00
|
|
|
evas_smart_legacy_type_register(MY_CLASS_NAME_LEGACY, klass);
|
2013-01-10 13:11:34 -08:00
|
|
|
}
|
|
|
|
|
2016-06-19 23:45:33 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_access_atspi_action_do(Evas_Object *obj, const char *params)
|
|
|
|
{
|
|
|
|
Eina_Bool ret;
|
|
|
|
|
|
|
|
ret = EINA_FALSE;
|
|
|
|
if (!strcmp(params, "highlight"))
|
|
|
|
ret = _access_action_callback_call(obj, ELM_ACCESS_ACTION_HIGHLIGHT, NULL);
|
|
|
|
else if (!strcmp(params, "unhighlight"))
|
|
|
|
ret = _access_action_callback_call(obj, ELM_ACCESS_ACTION_UNHIGHLIGHT, NULL);
|
|
|
|
else if (!strcmp(params, "highlight,next"))
|
|
|
|
ret = _access_action_callback_call(obj, ELM_ACCESS_ACTION_HIGHLIGHT_NEXT, NULL);
|
|
|
|
else if (!strcmp(params, "highlight,prev"))
|
|
|
|
ret = _access_action_callback_call(obj, ELM_ACCESS_ACTION_HIGHLIGHT_PREV, NULL);
|
|
|
|
else if (!strcmp(params, "activate"))
|
2017-04-05 03:58:46 -07:00
|
|
|
{
|
2017-04-06 02:14:40 -07:00
|
|
|
evas_object_smart_callback_call(obj, SIG_ACTIVATED, NULL);
|
2017-04-05 03:58:46 -07:00
|
|
|
ret = _access_action_callback_call(obj, ELM_ACCESS_ACTION_ACTIVATE, NULL);
|
|
|
|
}
|
2016-06-19 23:45:33 -07:00
|
|
|
else if (!strcmp(params, "value,up"))
|
|
|
|
ret = _access_action_callback_call(obj, ELM_ACCESS_ACTION_UP, NULL);
|
|
|
|
else if (!strcmp(params, "value,down"))
|
|
|
|
ret = _access_action_callback_call(obj, ELM_ACCESS_ACTION_DOWN, NULL);
|
|
|
|
else if (!strcmp(params, "read"))
|
|
|
|
ret = _access_action_callback_call(obj, ELM_ACCESS_ACTION_READ, NULL);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN const Elm_Atspi_Action *
|
|
|
|
_elm_access_elm_interface_atspi_widget_action_elm_actions_get(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
static Elm_Atspi_Action atspi_actions[] = {
|
|
|
|
{ "highlight", NULL, "highlight", _access_atspi_action_do},
|
|
|
|
{ "unhighlight", NULL, "unhighlight", _access_atspi_action_do},
|
|
|
|
{ "highlight,next", NULL, "highlight,next", _access_atspi_action_do},
|
2016-07-25 03:02:21 -07:00
|
|
|
{ "highlight,prev", NULL, "highlight,prev", _access_atspi_action_do},
|
2016-06-19 23:45:33 -07:00
|
|
|
{ "activate", NULL, "activate", _access_atspi_action_do},
|
|
|
|
{ "value,up", NULL, "value,up", _access_atspi_action_do},
|
|
|
|
{ "value,down", NULL, "value,down", _access_atspi_action_do},
|
|
|
|
{ "read", NULL, "read", _access_atspi_action_do},
|
|
|
|
{ NULL, NULL, NULL, NULL }
|
|
|
|
};
|
|
|
|
return &atspi_actions[0];
|
|
|
|
}
|
|
|
|
|
2017-10-18 18:13:54 -07:00
|
|
|
EOLIAN static Efl_Access_State_Set
|
|
|
|
_elm_access_efl_access_state_set_get(Eo *obj, void *pd EINA_UNUSED)
|
2017-08-01 03:52:38 -07:00
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
Efl_Access_State_Set ret;
|
|
|
|
ret = efl_access_state_set_get(efl_super(obj, ELM_ACCESS_CLASS));
|
2017-08-01 03:52:38 -07:00
|
|
|
|
|
|
|
Elm_Access_Info *info = _elm_access_info_get(obj);
|
|
|
|
if (info && !evas_object_visible_get(info->part_object))
|
|
|
|
{
|
2017-10-18 18:13:54 -07:00
|
|
|
STATE_TYPE_UNSET(ret, EFL_ACCESS_STATE_VISIBLE);
|
|
|
|
STATE_TYPE_UNSET(ret, EFL_ACCESS_STATE_SHOWING);
|
2017-08-01 03:52:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-05-18 01:52:17 -07:00
|
|
|
/* Internal EO APIs and hidden overrides */
|
|
|
|
|
|
|
|
#define ELM_ACCESS_EXTRA_OPS \
|
|
|
|
EFL_CANVAS_GROUP_ADD_OPS(elm_access)
|
|
|
|
|
2014-03-18 04:47:23 -07:00
|
|
|
#include "elm_access.eo.c"
|