2002-11-08 00:02:15 -08:00
|
|
|
#include "evas_common.h"
|
|
|
|
#include "evas_private.h"
|
|
|
|
|
2010-03-04 06:48:21 -08:00
|
|
|
int _evas_event_counter = 0;
|
2002-12-14 16:33:57 -08:00
|
|
|
|
2010-11-26 02:01:18 -08:00
|
|
|
EVAS_MEMPOOL(_mp_pc);
|
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
extern Eina_Hash* signals_hash_table;
|
|
|
|
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_IN =
|
|
|
|
EO_EVENT_DESCRIPTION("Mouse In", "Mouse In Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_OUT =
|
|
|
|
EO_EVENT_DESCRIPTION("Mouse Out", "Mouse Out Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_DOWN =
|
|
|
|
EO_EVENT_DESCRIPTION("Mouse Down", "Mouse Button Down Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_UP =
|
|
|
|
EO_EVENT_DESCRIPTION("Mouse Up", "Mouse Button Up Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_MOVE =
|
|
|
|
EO_EVENT_DESCRIPTION("Mouse Move", "Mouse Move Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MOUSE_WHEEL =
|
|
|
|
EO_EVENT_DESCRIPTION("Mouse Wheel", "Mouse Wheel Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MULTI_DOWN =
|
|
|
|
EO_EVENT_DESCRIPTION("Multi Down", "Mouse-touch Down Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MULTI_UP =
|
|
|
|
EO_EVENT_DESCRIPTION("Multi Up", "Mouse-touch Up Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MULTI_MOVE =
|
|
|
|
EO_EVENT_DESCRIPTION("Multi Move", "Multi-touch Move Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_FREE =
|
|
|
|
EO_EVENT_DESCRIPTION("Free", "Object Being Freed (Called after Del)");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_KEY_DOWN =
|
|
|
|
EO_EVENT_DESCRIPTION("Key Down", "Key Press Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_KEY_UP =
|
|
|
|
EO_EVENT_DESCRIPTION("Key Up", "Key Release Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_FOCUS_IN =
|
|
|
|
EO_EVENT_DESCRIPTION("Focus In", "Focus In Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_FOCUS_OUT =
|
|
|
|
EO_EVENT_DESCRIPTION("Focus Out", "Focus Out Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_SHOW =
|
|
|
|
EO_EVENT_DESCRIPTION("Show", "Show Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_HIDE =
|
|
|
|
EO_EVENT_DESCRIPTION("Hide", "Hide Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_MOVE =
|
|
|
|
EO_EVENT_DESCRIPTION("Move", "Move Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_RESIZE =
|
|
|
|
EO_EVENT_DESCRIPTION("Resize", "Resize Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_RESTACK =
|
|
|
|
EO_EVENT_DESCRIPTION("Restack", "Restack Event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_DEL =
|
|
|
|
EO_EVENT_DESCRIPTION("Del", "Object Being Deleted (called before Free)");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_HOLD =
|
|
|
|
EO_EVENT_DESCRIPTION("Hold", "Events go on/off hold");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_CHANGED_SIZE_HINTS =
|
|
|
|
EO_EVENT_DESCRIPTION("Changed Size Hints", "Size hints changed event");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_IMAGE_PRELOADED =
|
|
|
|
EO_EVENT_DESCRIPTION("Image Preloaded", "Image has been preloaded");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_IMAGE_RESIZE=
|
|
|
|
EO_EVENT_DESCRIPTION("Image Resize", "Image resize");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_CANVAS_FOCUS_IN =
|
|
|
|
EO_EVENT_DESCRIPTION("Canvas Focus In", "Canvas got focus as a whole");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_CANVAS_FOCUS_OUT =
|
|
|
|
EO_EVENT_DESCRIPTION("Canvas Focus Out", "Canvas lost focus as a whole");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_RENDER_FLUSH_PRE =
|
|
|
|
EO_EVENT_DESCRIPTION("Render Flush Pre", "Called just before rendering is updated on the canvas target");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_RENDER_FLUSH_POST =
|
|
|
|
EO_EVENT_DESCRIPTION("Render Flush Post", "Called just after rendering is updated on the canvas target");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN =
|
|
|
|
EO_EVENT_DESCRIPTION("Canvas Object Focus In", "Canvas object got focus");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT =
|
|
|
|
EO_EVENT_DESCRIPTION("Canvas Object Focus Out", "Canvas object lost focus");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_IMAGE_UNLOADED =
|
|
|
|
EO_EVENT_DESCRIPTION("Image Unloaded", "Image data has been unloaded (by some mechanism in Evas that throw out original image data)");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_RENDER_PRE =
|
|
|
|
EO_EVENT_DESCRIPTION("Render Pre", "Called just before rendering starts on the canvas target @since 1.2");
|
|
|
|
EAPI const Eo_Event_Description _EVAS_EVENT_RENDER_POST =
|
|
|
|
EO_EVENT_DESCRIPTION("Render Post", "Called just after rendering stops on the canvas target @since 1.2");
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Evas events descriptions for Eo.
|
|
|
|
*/
|
|
|
|
static const Eo_Event_Description *_legacy_evas_callback_table[EVAS_CALLBACK_LAST] =
|
|
|
|
{
|
|
|
|
EVAS_EVENT_MOUSE_IN,
|
|
|
|
EVAS_EVENT_MOUSE_OUT,
|
|
|
|
EVAS_EVENT_MOUSE_DOWN,
|
|
|
|
EVAS_EVENT_MOUSE_UP,
|
|
|
|
EVAS_EVENT_MOUSE_MOVE,
|
|
|
|
EVAS_EVENT_MOUSE_WHEEL,
|
|
|
|
EVAS_EVENT_MULTI_DOWN,
|
|
|
|
EVAS_EVENT_MULTI_UP,
|
|
|
|
EVAS_EVENT_MULTI_MOVE,
|
|
|
|
EVAS_EVENT_FREE,
|
|
|
|
EVAS_EVENT_KEY_DOWN,
|
|
|
|
EVAS_EVENT_KEY_UP,
|
|
|
|
EVAS_EVENT_FOCUS_IN,
|
|
|
|
EVAS_EVENT_FOCUS_OUT,
|
|
|
|
EVAS_EVENT_SHOW,
|
|
|
|
EVAS_EVENT_HIDE,
|
|
|
|
EVAS_EVENT_MOVE,
|
|
|
|
EVAS_EVENT_RESIZE,
|
|
|
|
EVAS_EVENT_RESTACK,
|
|
|
|
EVAS_EVENT_DEL,
|
|
|
|
EVAS_EVENT_HOLD,
|
|
|
|
EVAS_EVENT_CHANGED_SIZE_HINTS,
|
|
|
|
EVAS_EVENT_IMAGE_PRELOADED,
|
|
|
|
EVAS_EVENT_IMAGE_RESIZE,
|
|
|
|
EVAS_EVENT_CANVAS_FOCUS_IN,
|
|
|
|
EVAS_EVENT_CANVAS_FOCUS_OUT,
|
|
|
|
EVAS_EVENT_RENDER_FLUSH_PRE,
|
|
|
|
EVAS_EVENT_RENDER_FLUSH_POST,
|
|
|
|
EVAS_EVENT_CANVAS_OBJECT_FOCUS_IN,
|
|
|
|
EVAS_EVENT_CANVAS_OBJECT_FOCUS_OUT,
|
|
|
|
EVAS_EVENT_IMAGE_UNLOADED,
|
|
|
|
EVAS_EVENT_RENDER_PRE,
|
|
|
|
EVAS_EVENT_RENDER_POST
|
|
|
|
};
|
2013-04-11 12:08:24 -07:00
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
EINA_INLIST;
|
|
|
|
Evas_Object_Event_Cb func;
|
|
|
|
void *data;
|
|
|
|
Evas_Callback_Type type;
|
|
|
|
} _eo_evas_object_cb_info;
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_eo_evas_object_cb(void *data, Eo *eo_obj, const Eo_Event_Description *desc EINA_UNUSED, void *event_info)
|
|
|
|
{
|
|
|
|
_eo_evas_object_cb_info *info = data;
|
|
|
|
if (info->func) info->func(info->data, evas_object_evas_get(eo_obj), eo_obj, event_info);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
EINA_INLIST;
|
|
|
|
Evas_Event_Cb func;
|
|
|
|
void *data;
|
|
|
|
Evas_Callback_Type type;
|
|
|
|
} _eo_evas_cb_info;
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_eo_evas_cb(void *data, Eo *eo_obj, const Eo_Event_Description *desc EINA_UNUSED, void *event_info)
|
|
|
|
{
|
|
|
|
_eo_evas_cb_info *info = data;
|
|
|
|
if (info->func) info->func(info->data, eo_obj, event_info);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2010-05-04 08:58:10 -07:00
|
|
|
void
|
2012-10-08 18:58:41 -07:00
|
|
|
_evas_post_event_callback_call(Evas *eo_e, Evas_Public_Data *e)
|
2010-05-04 08:58:10 -07:00
|
|
|
{
|
|
|
|
Evas_Post_Callback *pc;
|
|
|
|
int skip = 0;
|
|
|
|
|
|
|
|
if (e->delete_me) return;
|
|
|
|
_evas_walk(e);
|
|
|
|
EINA_LIST_FREE(e->post_events, pc)
|
|
|
|
{
|
|
|
|
if ((!skip) && (!e->delete_me) && (!pc->delete_me))
|
|
|
|
{
|
2012-10-08 18:58:41 -07:00
|
|
|
if (!pc->func((void*)pc->data, eo_e)) skip = 1;
|
2010-05-04 08:58:10 -07:00
|
|
|
}
|
2011-12-14 21:56:19 -08:00
|
|
|
EVAS_MEMPOOL_FREE(_mp_pc, pc);
|
2010-05-04 08:58:10 -07:00
|
|
|
}
|
|
|
|
_evas_unwalk(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-10-08 18:58:41 -07:00
|
|
|
_evas_post_event_callback_free(Evas *eo_e)
|
2010-05-04 08:58:10 -07:00
|
|
|
{
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS);
|
2010-05-04 08:58:10 -07:00
|
|
|
Evas_Post_Callback *pc;
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2010-05-04 08:58:10 -07:00
|
|
|
EINA_LIST_FREE(e->post_events, pc)
|
|
|
|
{
|
2011-12-14 21:56:19 -08:00
|
|
|
EVAS_MEMPOOL_FREE(_mp_pc, pc);
|
2010-05-04 08:58:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-31 20:26:55 -08:00
|
|
|
void
|
2013-04-11 12:08:24 -07:00
|
|
|
evas_object_event_callback_all_del(Evas_Object *eo_obj)
|
2003-01-19 19:54:00 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
_eo_evas_object_cb_info *info;
|
|
|
|
Eina_Inlist *itr;
|
|
|
|
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS);
|
2003-01-19 19:54:00 -08:00
|
|
|
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!obj) return;
|
2003-02-08 20:22:45 -08:00
|
|
|
if (!obj->callbacks) return;
|
2013-04-11 12:08:24 -07:00
|
|
|
EINA_INLIST_FOREACH_SAFE(obj->callbacks, itr, info)
|
2007-01-22 04:44:57 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
eo_do(eo_obj, eo_event_callback_del(
|
|
|
|
_legacy_evas_callback_table[info->type], _eo_evas_object_cb, info));
|
2003-01-19 19:54:00 -08:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
obj->callbacks =
|
|
|
|
eina_inlist_remove(obj->callbacks, EINA_INLIST_GET(info));
|
|
|
|
free(info);
|
2010-03-21 22:33:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-12-14 16:33:57 -08:00
|
|
|
void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_object_event_callback_cleanup(Evas_Object *eo_obj)
|
2002-12-14 16:33:57 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
evas_object_event_callback_all_del(eo_obj);
|
2002-12-14 16:33:57 -08:00
|
|
|
}
|
|
|
|
|
2010-03-28 22:03:25 -07:00
|
|
|
void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_event_callback_all_del(Evas *eo_e)
|
2010-03-28 22:03:25 -07:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
_eo_evas_object_cb_info *info;
|
|
|
|
Eina_Inlist *itr;
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS);
|
2010-03-28 22:03:25 -07:00
|
|
|
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!e) return;
|
2010-03-28 22:03:25 -07:00
|
|
|
if (!e->callbacks) return;
|
2013-04-11 12:08:24 -07:00
|
|
|
|
|
|
|
EINA_INLIST_FOREACH_SAFE(e->callbacks, itr, info)
|
|
|
|
{
|
|
|
|
eo_do(eo_e, eo_event_callback_del(
|
|
|
|
_legacy_evas_callback_table[info->type], _eo_evas_cb, info));
|
|
|
|
|
|
|
|
e->callbacks =
|
|
|
|
eina_inlist_remove(e->callbacks, EINA_INLIST_GET(info));
|
|
|
|
free(info);
|
|
|
|
}
|
2010-03-28 22:03:25 -07:00
|
|
|
}
|
|
|
|
|
2010-03-28 19:40:49 -07:00
|
|
|
void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_event_callback_cleanup(Evas *eo_e)
|
2010-03-28 19:40:49 -07:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
evas_event_callback_all_del(eo_e);
|
2010-03-28 19:40:49 -07:00
|
|
|
}
|
|
|
|
|
2010-01-31 20:26:55 -08:00
|
|
|
void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_event_callback_call(Evas *eo_e, Evas_Callback_Type type, void *event_info)
|
2010-01-31 20:26:55 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
eo_do(eo_e, eo_event_callback_call(_legacy_evas_callback_table[type], event_info, NULL));
|
2010-01-31 20:26:55 -08:00
|
|
|
}
|
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_object_event_callback_call(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Evas_Callback_Type type, void *event_info, int event_id)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2002-11-23 20:06:08 -08:00
|
|
|
/* MEM OK */
|
2006-08-25 13:47:32 -07:00
|
|
|
Evas_Button_Flags flags = EVAS_BUTTON_NONE;
|
2012-10-08 18:58:41 -07:00
|
|
|
Evas_Public_Data *e;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!obj) return;
|
2010-08-29 15:59:11 -07:00
|
|
|
if ((obj->delete_me) || (!obj->layer)) return;
|
2011-12-14 22:23:53 -08:00
|
|
|
if ((obj->last_event == event_id) &&
|
From: Hyoyoung Chang <hyoyoung.chang@samsung.com>
Subject: [E-devel] [patch] evas - add checking event type
Dear developers.
I found a bug about evas event handling.
In some situation, evas blocks some events by checking _evas_event_counter.
So I made a patch that is checking event type also event counter.
Reproduce steps:
1. make a window
2. show window before adding a elementary/genlist widget
--- codes ---
void _gl_mousedown_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
printf("_gl_mousedown_cb !! \n");
}
static Eina_Bool create_main_win(App *app)
{
app->win = elm_win_add(NULL, "genlist-win", ELM_WIN_BASIC);
evas_object_show(app->win); <-- position 1
Evas_Object *genlist = elm_genlist_add(app->win);
elm_win_resize_object_add(app->win, genlist);
evas_object_event_callback_add(genlist, EVAS_CALLBACK_MOUSE_DOWN, _gl_mousedown_cb, NULL);
evas_object_show(genlist);
evas_object_resize(app->win, 320, 240);
//evas_object_show(app->win); <-- position 2
return EINA_TRUE;
}
--- codes ---
In common use case, apps don't show main window at position 1.
However to reproduce, it can be at position 1. Then, focus is at just on main window.
In that situation, if a user clicks a genlist, its event is dropped by evas.
Because in mouse down callback, it give focus to genlist.
Then two events is made. First is mouse down, second is focus handling.
In event callback, evas processes mouse down after focus handling.
But evas found that mouse event is retarded event than focus handling.
So it ignores it.
This patch is introduce event handling type checking to
evas_object_event_callback_call.
SVN revision: 61026
2011-07-04 18:33:59 -07:00
|
|
|
(obj->last_event_type == type)) return;
|
2012-02-13 03:25:23 -08:00
|
|
|
if (obj->last_event > event_id)
|
|
|
|
{
|
|
|
|
if ((obj->last_event_type == EVAS_CALLBACK_MOUSE_OUT) &&
|
|
|
|
((type >= EVAS_CALLBACK_MOUSE_DOWN) &&
|
|
|
|
(type <= EVAS_CALLBACK_MULTI_MOVE)))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2011-12-14 22:23:53 -08:00
|
|
|
obj->last_event = event_id;
|
From: Hyoyoung Chang <hyoyoung.chang@samsung.com>
Subject: [E-devel] [patch] evas - add checking event type
Dear developers.
I found a bug about evas event handling.
In some situation, evas blocks some events by checking _evas_event_counter.
So I made a patch that is checking event type also event counter.
Reproduce steps:
1. make a window
2. show window before adding a elementary/genlist widget
--- codes ---
void _gl_mousedown_cb(void *data, Evas *evas, Evas_Object *obj, void *event_info)
{
printf("_gl_mousedown_cb !! \n");
}
static Eina_Bool create_main_win(App *app)
{
app->win = elm_win_add(NULL, "genlist-win", ELM_WIN_BASIC);
evas_object_show(app->win); <-- position 1
Evas_Object *genlist = elm_genlist_add(app->win);
elm_win_resize_object_add(app->win, genlist);
evas_object_event_callback_add(genlist, EVAS_CALLBACK_MOUSE_DOWN, _gl_mousedown_cb, NULL);
evas_object_show(genlist);
evas_object_resize(app->win, 320, 240);
//evas_object_show(app->win); <-- position 2
return EINA_TRUE;
}
--- codes ---
In common use case, apps don't show main window at position 1.
However to reproduce, it can be at position 1. Then, focus is at just on main window.
In that situation, if a user clicks a genlist, its event is dropped by evas.
Because in mouse down callback, it give focus to genlist.
Then two events is made. First is mouse down, second is focus handling.
In event callback, evas processes mouse down after focus handling.
But evas found that mouse event is retarded event than focus handling.
So it ignores it.
This patch is introduce event handling type checking to
evas_object_event_callback_call.
SVN revision: 61026
2011-07-04 18:33:59 -07:00
|
|
|
obj->last_event_type = type;
|
2010-08-29 15:59:11 -07:00
|
|
|
if (!(e = obj->layer->evas)) return;
|
2009-09-03 22:13:19 -07:00
|
|
|
|
2007-04-29 21:22:42 -07:00
|
|
|
_evas_walk(e);
|
2003-12-11 03:20:40 -08:00
|
|
|
{
|
2007-01-22 04:44:57 -08:00
|
|
|
switch (type)
|
|
|
|
{
|
2011-12-14 21:56:19 -08:00
|
|
|
case EVAS_CALLBACK_MOUSE_DOWN:
|
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
|
|
|
|
|
|
|
flags = ev->flags;
|
|
|
|
if (ev->flags & (EVAS_BUTTON_DOUBLE_CLICK | EVAS_BUTTON_TRIPLE_CLICK))
|
|
|
|
{
|
|
|
|
if (obj->last_mouse_down_counter < (e->last_mouse_down_counter - 1))
|
|
|
|
ev->flags &= ~(EVAS_BUTTON_DOUBLE_CLICK | EVAS_BUTTON_TRIPLE_CLICK);
|
|
|
|
}
|
|
|
|
obj->last_mouse_down_counter = e->last_mouse_down_counter;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case EVAS_CALLBACK_MOUSE_UP:
|
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
|
|
|
|
|
|
|
flags = ev->flags;
|
|
|
|
if (ev->flags & (EVAS_BUTTON_DOUBLE_CLICK | EVAS_BUTTON_TRIPLE_CLICK))
|
|
|
|
{
|
|
|
|
if (obj->last_mouse_up_counter < (e->last_mouse_up_counter - 1))
|
|
|
|
ev->flags &= ~(EVAS_BUTTON_DOUBLE_CLICK | EVAS_BUTTON_TRIPLE_CLICK);
|
|
|
|
}
|
|
|
|
obj->last_mouse_up_counter = e->last_mouse_up_counter;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
2007-01-22 04:44:57 -08:00
|
|
|
}
|
2009-09-03 22:13:19 -07:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
eo_do(eo_obj, eo_event_callback_call(_legacy_evas_callback_table[type], event_info, NULL));
|
2012-10-08 18:58:41 -07:00
|
|
|
|
2006-10-06 12:13:33 -07:00
|
|
|
if (type == EVAS_CALLBACK_MOUSE_DOWN)
|
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Down *ev = event_info;
|
|
|
|
ev->flags = flags;
|
|
|
|
}
|
|
|
|
else if (type == EVAS_CALLBACK_MOUSE_UP)
|
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Up *ev = event_info;
|
|
|
|
ev->flags = flags;
|
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
2009-09-03 22:13:19 -07:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
if (!obj->no_propagate)
|
2007-04-29 21:22:42 -07:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
if ((obj->smart.parent) && (type != EVAS_CALLBACK_FREE) &&
|
|
|
|
(type <= EVAS_CALLBACK_KEY_UP))
|
2011-12-14 21:56:19 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
Evas_Object_Protected_Data *smart_parent = eo_data_scope_get(obj->smart.parent, EVAS_OBJ_CLASS);
|
|
|
|
evas_object_event_callback_call(obj->smart.parent, smart_parent, type, event_info, event_id);
|
2011-12-14 21:56:19 -08:00
|
|
|
}
|
2007-04-29 21:22:42 -07:00
|
|
|
}
|
|
|
|
_evas_unwalk(e);
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_object_event_callback_add(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data)
|
2011-08-17 04:55:29 -07:00
|
|
|
{
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_object_event_callback_priority_add(eo_obj, type,
|
2011-12-14 21:56:19 -08:00
|
|
|
EVAS_CALLBACK_PRIORITY_DEFAULT, func, data);
|
2011-08-17 04:55:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_object_event_callback_priority_add(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Callback_Priority priority, Evas_Object_Event_Cb func, const void *data)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS);
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ);
|
2002-11-08 00:02:15 -08:00
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2002-11-08 00:02:15 -08:00
|
|
|
if (!func) return;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
_eo_evas_object_cb_info *cb_info = calloc(1, sizeof(*cb_info));
|
|
|
|
cb_info->func = func;
|
|
|
|
cb_info->data = (void *)data;
|
|
|
|
cb_info->type = type;
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
const Eo_Event_Description *desc = _legacy_evas_callback_table[type];
|
|
|
|
eo_do(eo_obj, eo_event_callback_priority_add(desc, priority, _eo_evas_object_cb, cb_info));
|
|
|
|
|
|
|
|
obj->callbacks =
|
|
|
|
eina_inlist_append(obj->callbacks, EINA_INLIST_GET(cb_info));
|
2002-11-08 00:02:15 -08:00
|
|
|
}
|
|
|
|
|
2006-01-06 15:05:17 -08:00
|
|
|
EAPI void *
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_object_event_callback_del(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Object_Event_Cb func)
|
2002-11-08 00:02:15 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
_eo_evas_object_cb_info *info;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ);
|
2002-11-08 00:02:15 -08:00
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS);
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!obj) return NULL;
|
2002-11-08 00:02:15 -08:00
|
|
|
if (!func) return NULL;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2003-02-08 20:22:45 -08:00
|
|
|
if (!obj->callbacks) return NULL;
|
2005-05-21 19:49:50 -07:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
EINA_INLIST_FOREACH(obj->callbacks, info)
|
2007-01-22 04:44:57 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
if ((info->func == func) && (info->type == type))
|
2011-12-14 21:56:19 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
void *tmp = info->data;
|
|
|
|
eo_do(eo_obj, eo_event_callback_del(
|
|
|
|
_legacy_evas_callback_table[type], _eo_evas_object_cb, info));
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
obj->callbacks =
|
|
|
|
eina_inlist_remove(obj->callbacks, EINA_INLIST_GET(info));
|
|
|
|
free(info);
|
2011-12-14 21:56:19 -08:00
|
|
|
return tmp;
|
|
|
|
}
|
2007-01-22 04:44:57 -08:00
|
|
|
}
|
2002-11-08 00:02:15 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
2008-06-03 13:33:40 -07:00
|
|
|
|
|
|
|
EAPI void *
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_object_event_callback_del_full(Evas_Object *eo_obj, Evas_Callback_Type type, Evas_Object_Event_Cb func, const void *data)
|
2008-06-03 13:33:40 -07:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
_eo_evas_object_cb_info *info;
|
2008-06-03 13:33:40 -07:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ);
|
2008-06-03 13:33:40 -07:00
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS);
|
2008-06-03 13:33:40 -07:00
|
|
|
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!obj) return NULL;
|
2008-06-03 13:33:40 -07:00
|
|
|
if (!func) return NULL;
|
|
|
|
|
|
|
|
if (!obj->callbacks) return NULL;
|
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
EINA_INLIST_FOREACH(obj->callbacks, info)
|
2008-06-03 13:33:40 -07:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
if ((info->func == func) && (info->type == type) && info->data == data)
|
2011-12-14 21:56:19 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
void *tmp = info->data;
|
|
|
|
eo_do(eo_obj, eo_event_callback_del(
|
|
|
|
_legacy_evas_callback_table[type], _eo_evas_object_cb, info));
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
obj->callbacks =
|
|
|
|
eina_inlist_remove(obj->callbacks, EINA_INLIST_GET(info));
|
|
|
|
free(info);
|
2011-12-14 21:56:19 -08:00
|
|
|
return tmp;
|
|
|
|
}
|
2008-06-03 13:33:40 -07:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-11-01 14:50:36 -07:00
|
|
|
|
2010-01-31 20:26:55 -08:00
|
|
|
EAPI void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_event_callback_add(Evas *eo_e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data)
|
2011-08-17 04:55:29 -07:00
|
|
|
{
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_event_callback_priority_add(eo_e, type, EVAS_CALLBACK_PRIORITY_DEFAULT,
|
2011-12-14 21:56:19 -08:00
|
|
|
func, data);
|
2011-08-17 04:55:29 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_event_callback_priority_add(Evas *eo_e, Evas_Callback_Type type, Evas_Callback_Priority priority, Evas_Event_Cb func, const void *data)
|
2010-01-31 20:26:55 -08:00
|
|
|
{
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS);
|
2010-01-31 20:26:55 -08:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS);
|
2010-01-31 20:26:55 -08:00
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
|
|
|
|
if (!func) return;
|
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
_eo_evas_cb_info *cb_info = calloc(1, sizeof(*cb_info));
|
|
|
|
cb_info->func = func;
|
|
|
|
cb_info->data = (void *)data;
|
|
|
|
cb_info->type = type;
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
const Eo_Event_Description *desc = _legacy_evas_callback_table[type];
|
|
|
|
eo_do(eo_e, eo_event_callback_priority_add(desc, priority, _eo_evas_cb, cb_info));
|
|
|
|
|
|
|
|
e->callbacks = eina_inlist_append(e->callbacks, EINA_INLIST_GET(cb_info));
|
2010-01-31 20:26:55 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_event_callback_del(Evas *eo_e, Evas_Callback_Type type, Evas_Event_Cb func)
|
2010-01-31 20:26:55 -08:00
|
|
|
{
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS);
|
2013-04-11 12:08:24 -07:00
|
|
|
_eo_evas_cb_info *info;
|
2010-01-31 20:26:55 -08:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS);
|
2010-01-31 20:26:55 -08:00
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
|
|
|
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!e) return NULL;
|
2010-01-31 20:26:55 -08:00
|
|
|
if (!func) return NULL;
|
|
|
|
|
|
|
|
if (!e->callbacks) return NULL;
|
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
EINA_INLIST_FOREACH(e->callbacks, info)
|
2010-01-31 20:26:55 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
if ((info->func == func) && (info->type == type))
|
2011-12-14 21:56:19 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
void *tmp = info->data;
|
|
|
|
eo_do(eo_e, eo_event_callback_del(
|
|
|
|
_legacy_evas_callback_table[type], _eo_evas_cb, info));
|
|
|
|
|
|
|
|
e->callbacks =
|
|
|
|
eina_inlist_remove(e->callbacks, EINA_INLIST_GET(info));
|
|
|
|
free(info);
|
|
|
|
return tmp;
|
2011-12-14 21:56:19 -08:00
|
|
|
}
|
2010-01-31 20:26:55 -08:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void *
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_event_callback_del_full(Evas *eo_e, Evas_Callback_Type type, Evas_Event_Cb func, const void *data)
|
2010-01-31 20:26:55 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
_eo_evas_cb_info *info;
|
2010-01-31 20:26:55 -08:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS);
|
2010-01-31 20:26:55 -08:00
|
|
|
return NULL;
|
|
|
|
MAGIC_CHECK_END();
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS);
|
2010-01-31 20:26:55 -08:00
|
|
|
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!e) return NULL;
|
2010-01-31 20:26:55 -08:00
|
|
|
if (!func) return NULL;
|
|
|
|
|
|
|
|
if (!e->callbacks) return NULL;
|
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
EINA_INLIST_FOREACH(e->callbacks, info)
|
2010-01-31 20:26:55 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
if ((info->func == func) && (info->type == type) && (info->data == data))
|
2011-12-14 21:56:19 -08:00
|
|
|
{
|
2013-04-11 12:08:24 -07:00
|
|
|
void *tmp = info->data;
|
|
|
|
eo_do(eo_e, eo_event_callback_del(
|
|
|
|
_legacy_evas_callback_table[type], _eo_evas_cb, info));
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2013-04-11 12:08:24 -07:00
|
|
|
e->callbacks =
|
|
|
|
eina_inlist_remove(e->callbacks, EINA_INLIST_GET(info));
|
|
|
|
free(info);
|
2011-12-14 21:56:19 -08:00
|
|
|
return tmp;
|
|
|
|
}
|
2010-01-31 20:26:55 -08:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-05-04 08:58:10 -07:00
|
|
|
EAPI void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_post_event_callback_push(Evas *eo_e, Evas_Object_Event_Post_Cb func, const void *data)
|
2010-05-04 08:58:10 -07:00
|
|
|
{
|
|
|
|
Evas_Post_Callback *pc;
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS);
|
2010-05-04 08:58:10 -07:00
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS);
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!e) return;
|
2010-11-26 02:01:18 -08:00
|
|
|
EVAS_MEMPOOL_INIT(_mp_pc, "evas_post_callback", Evas_Post_Callback, 64, );
|
|
|
|
pc = EVAS_MEMPOOL_ALLOC(_mp_pc, Evas_Post_Callback);
|
2010-05-04 08:58:10 -07:00
|
|
|
if (!pc) return;
|
2010-11-26 02:01:18 -08:00
|
|
|
EVAS_MEMPOOL_PREP(_mp_pc, pc, Evas_Post_Callback);
|
2010-05-04 08:58:10 -07:00
|
|
|
if (e->delete_me) return;
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2010-05-04 08:58:10 -07:00
|
|
|
pc->func = func;
|
|
|
|
pc->data = data;
|
|
|
|
e->post_events = eina_list_prepend(e->post_events, pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_post_event_callback_remove(Evas *eo_e, Evas_Object_Event_Post_Cb func)
|
2010-05-04 08:58:10 -07:00
|
|
|
{
|
|
|
|
Evas_Post_Callback *pc;
|
|
|
|
Eina_List *l;
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS);
|
2010-05-04 08:58:10 -07:00
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS);
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!e) return;
|
2010-05-04 08:58:10 -07:00
|
|
|
EINA_LIST_FOREACH(e->post_events, l, pc)
|
|
|
|
{
|
|
|
|
if (pc->func == func)
|
|
|
|
{
|
|
|
|
pc->delete_me = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EAPI void
|
2012-10-08 18:58:41 -07:00
|
|
|
evas_post_event_callback_remove_full(Evas *eo_e, Evas_Object_Event_Post_Cb func, const void *data)
|
2010-05-04 08:58:10 -07:00
|
|
|
{
|
|
|
|
Evas_Post_Callback *pc;
|
|
|
|
Eina_List *l;
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2012-10-08 18:58:41 -07:00
|
|
|
MAGIC_CHECK(eo_e, Evas, MAGIC_EVAS);
|
2010-05-04 08:58:10 -07:00
|
|
|
return;
|
|
|
|
MAGIC_CHECK_END();
|
2011-12-14 21:56:19 -08:00
|
|
|
|
2013-05-02 00:47:16 -07:00
|
|
|
Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS);
|
2012-11-11 18:22:39 -08:00
|
|
|
if (!e) return;
|
2010-05-04 08:58:10 -07:00
|
|
|
EINA_LIST_FOREACH(e->post_events, l, pc)
|
|
|
|
{
|
|
|
|
if ((pc->func == func) && (pc->data == data))
|
|
|
|
{
|
|
|
|
pc->delete_me = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|