From ea8c6e5632beb4c5cf1e445473ca85b0135a4aa9 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Andre Date: Tue, 10 May 2016 21:26:07 +0900 Subject: [PATCH] Evas: Extend pointer events and add legacy conversion routines To be honest, this commit is a bit of a mess since it's a rebased version of some temporary work patches. --- src/Makefile_Evas.am | 1 + src/lib/efl/interfaces/efl_common_internal.h | 36 +- src/lib/efl/interfaces/efl_event.eo | 3 + src/lib/efl/interfaces/efl_pointer_event.c | 130 ++++++- src/lib/efl/interfaces/efl_pointer_event.eo | 31 +- src/lib/elementary/elm_win.eo | 2 +- src/lib/evas/canvas/evas_canvas.eo | 14 +- src/lib/evas/canvas/evas_events.c | 69 +++- src/lib/evas/canvas/evas_events_legacy.c | 349 +++++++++++++++++++ src/lib/evas/canvas/evas_main.c | 3 + src/lib/evas/include/evas_private.h | 7 + 11 files changed, 592 insertions(+), 53 deletions(-) create mode 100644 src/lib/evas/canvas/evas_events_legacy.c diff --git a/src/Makefile_Evas.am b/src/Makefile_Evas.am index 19fea04991..e9ee137d43 100644 --- a/src/Makefile_Evas.am +++ b/src/Makefile_Evas.am @@ -152,6 +152,7 @@ lib/evas/canvas/evas_common_interface.c \ lib/evas/canvas/evas_data.c \ lib/evas/canvas/evas_device.c \ lib/evas/canvas/evas_events.c \ +lib/evas/canvas/evas_events_legacy.c \ lib/evas/canvas/evas_focus.c \ lib/evas/canvas/evas_key.c \ lib/evas/canvas/evas_key_grab.c \ diff --git a/src/lib/efl/interfaces/efl_common_internal.h b/src/lib/efl/interfaces/efl_common_internal.h index 32d5471b07..d2467d2d98 100644 --- a/src/lib/efl/interfaces/efl_common_internal.h +++ b/src/lib/efl/interfaces/efl_common_internal.h @@ -23,19 +23,27 @@ typedef struct _Efl_Input_State_Data Efl_Input_State_Data; //typedef struct _Evas_Lock Evas_Lock; #endif +struct _Efl_Input_State_Data +{ + Eo *eo; + /* FIXME / TODO */ +// Evas_Modifier *modifiers; +// Evas_Lock *locks; +}; + struct _Efl_Pointer_Event_Data { Eo *eo; unsigned int timestamp; /* FIXME: store as double? */ int button; unsigned int pressed_buttons; + int finger; + double radius, radius_x, radius_y; + double pressure; + double angle; struct { - struct { - int x, y; - } output; - struct { - int x, y; - } canvas; + int x, y; + double xsub, ysub; // couldn't we just cast from double to int? } cur, prev; struct { Efl_Orient dir; @@ -48,17 +56,11 @@ struct _Efl_Pointer_Event_Data Efl_Pointer_Event_Flags event_flags; void *data; /* evas data - whatever that is */ const Eo_Event_Description *event_desc; - //Efl_Input_State state; -}; - -struct _Efl_Input_State_Data -{ - Eo *eo; - /* FIXME / TODO */ -#if 0 - Evas_Modifier *modifiers; - Evas_Lock *locks; -#endif + Eina_Bool window_pos; /* true if positions are window-relative + (see input vs. feed: this is "input") */ + //Efl_Input_State *state; + void *legacy; /* DO NOT TOUCH */ + Eina_Bool evas_done; /* set by evas */ }; struct _Efl_Input_Device_Data diff --git a/src/lib/efl/interfaces/efl_event.eo b/src/lib/efl/interfaces/efl_event.eo index 076bc1562d..f00a0472cb 100644 --- a/src/lib/efl/interfaces/efl_event.eo +++ b/src/lib/efl/interfaces/efl_event.eo @@ -34,5 +34,8 @@ interface Efl.Event type: const(Eo_Event_Description)*; } } + reset { + [[Resets the internal data to 0 or default values.]] + } } } diff --git a/src/lib/efl/interfaces/efl_pointer_event.c b/src/lib/efl/interfaces/efl_pointer_event.c index 7e479024b6..b55da3f407 100644 --- a/src/lib/efl/interfaces/efl_pointer_event.c +++ b/src/lib/efl/interfaces/efl_pointer_event.c @@ -20,14 +20,77 @@ * Do not add any logic here. */ +static Efl_Pointer_Event *s_cached_event = NULL; + +static void +_del_hook(Eo *evt) +{ + if (!s_cached_event) + { + if (eo_parent_get(evt)) + { + eo_ref(evt); + eo_parent_set(evt, NULL); + } + s_cached_event = evt; + } + else + { + eo_del_intercept_set(evt, NULL); + eo_unref(evt); + } +} + +EOLIAN static Efl_Pointer_Event * +_efl_pointer_event_instance_get(Eo_Class *klass EINA_UNUSED, void *pd EINA_UNUSED, + Eo *owner, void **priv) +{ + Efl_Pointer_Event *evt; + + if (s_cached_event) + { + evt = s_cached_event; + s_cached_event = NULL; + efl_event_reset(evt); + eo_parent_set(evt, owner); + } + else + { + evt = eo_add(EFL_POINTER_EVENT_CLASS, owner); + eo_del_intercept_set(evt, _del_hook); + } + + if (priv) + *priv = eo_data_scope_get(evt, EFL_POINTER_EVENT_CLASS); + + return evt; +} + +EOLIAN static void +_efl_pointer_event_class_destructor(Eo_Class *klass EINA_UNUSED) +{ + // this is a strange situation... + eo_unref(s_cached_event); + s_cached_event = NULL; +} + EOLIAN static Eo_Base * -_efl_pointer_event_eo_base_constructor(Eo *obj, Efl_Pointer_Event_Data *pd) +_efl_pointer_event_eo_base_constructor(Eo *obj, Efl_Pointer_Event_Data *pd EINA_UNUSED) { eo_constructor(eo_super(obj, MY_CLASS)); - pd->eo = obj; + efl_event_reset(obj); return obj; } +EOLIAN static void +_efl_pointer_event_efl_event_reset(Eo *obj, Efl_Pointer_Event_Data *pd) +{ + free(pd->legacy); + memset(pd, 0, sizeof(*pd)); + pd->eo = obj; + pd->wheel.dir = EFL_ORIENT_VERTICAL; +} + EOLIAN static void _efl_pointer_event_action_set(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, Efl_Pointer_Action act) { @@ -72,37 +135,35 @@ _efl_pointer_event_button_pressed_get(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Dat } EOLIAN static void -_efl_pointer_event_position_set(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, int x, int y) +_efl_pointer_event_position_set(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, int x, int y, double xsub, double ysub) { - pd->cur.canvas.x = x; - pd->cur.canvas.y = y; - /* FIXME: What is the difference??? */ - pd->cur.output.x = x; - pd->cur.output.y = y; + pd->cur.x = x; + pd->cur.y = y; + pd->cur.xsub = xsub; + pd->cur.ysub = ysub; } EOLIAN static void -_efl_pointer_event_position_get(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, int *x, int *y) +_efl_pointer_event_position_get(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, int *x, int *y, double *xsub, double *ysub) { - if (x) *x = pd->cur.canvas.x; - if (y) *y = pd->cur.canvas.y; + if (x) *x = pd->cur.x; + if (y) *y = pd->cur.y; + if (xsub) *xsub = pd->cur.xsub; + if (ysub) *ysub = pd->cur.ysub; } EOLIAN static void _efl_pointer_event_previous_position_set(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, int x, int y) { - pd->prev.canvas.x = x; - pd->prev.canvas.y = y; - /* FIXME: What is the difference??? */ - pd->prev.output.x = x; - pd->prev.output.y = y; + pd->prev.x = x; + pd->prev.y = y; } EOLIAN static void _efl_pointer_event_previous_position_get(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, int *x, int *y) { - if (x) *x = pd->prev.canvas.x; - if (y) *y = pd->prev.canvas.y; + if (x) *x = pd->prev.x; + if (y) *y = pd->prev.y; } @@ -219,4 +280,37 @@ _efl_pointer_event_wheel_distance_get(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Dat return pd->wheel.z; } +EOLIAN static int +_efl_pointer_event_finger_get(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd) +{ + return pd->finger; +} + +EOLIAN static void +_efl_pointer_event_finger_set(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, int id) +{ + pd->finger = id; +} + +EOLIAN static void +_efl_pointer_event_touch_get(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, double *r, double *rx, double *ry, double *press, double *angle) +{ + if (r) *r = pd->radius; + if (rx) *rx = pd->radius_x; + if (ry) *ry = pd->radius_y; + if (press) *press = pd->pressure; + if (angle) *angle = pd->angle; +} + + +EOLIAN static void +_efl_pointer_event_touch_set(Eo *obj EINA_UNUSED, Efl_Pointer_Event_Data *pd, double r, double rx, double ry, double press, double angle) +{ + pd->radius = r; + pd->radius_x = rx; + pd->radius_y = ry; + pd->pressure = press; + pd->angle = angle; +} + #include "interfaces/efl_pointer_event.eo.c" diff --git a/src/lib/efl/interfaces/efl_pointer_event.eo b/src/lib/efl/interfaces/efl_pointer_event.eo index 2ee4625177..05268c852e 100644 --- a/src/lib/efl/interfaces/efl_pointer_event.eo +++ b/src/lib/efl/interfaces/efl_pointer_event.eo @@ -7,7 +7,6 @@ class Efl.Pointer.Event (Eo.Base, Efl.Event) @since 1.18 ]] - legacy_prefix: null; methods { @property action { [[The action represented by this event.]] @@ -36,6 +35,8 @@ class Efl.Pointer.Event (Eo.Base, Efl.Event) values { x: int; y: int; + xsub: double; + ysub: double; } } @property previous_position { @@ -63,6 +64,22 @@ class Efl.Pointer.Event (Eo.Base, Efl.Event) dev: Efl.Input.Device; } } + @property finger { + [[Finger ID in case of a multi touch event.]] + values { + id: int; + } + } + @property touch { + [[Touch information about a specific finger or pointer.]] + values { + radius: double; + rad_x: double; + rad_y: double; + pressure: double; + angle: double; + } + } @property source { [[The object where this event first originated, in case of propagation or repetition of the event. @@ -94,9 +111,21 @@ class Efl.Pointer.Event (Eo.Base, Efl.Event) dist: int; } } + instance_get @class { + [[Creates an instance of this events or returns a fresh one from + a memory pool. + ]] + params { + @in owner: Eo.Base; [[The parent object.]] + @out priv: void*; [[Pointer to the internal data of the object.]] + } + return: own(Efl.Pointer.Event); + } } implements { Eo.Base.constructor; + class.destructor; + Efl.Event.reset; Efl.Event.timestamp.set; Efl.Event.timestamp.get; Efl.Event.event_type.set; diff --git a/src/lib/elementary/elm_win.eo b/src/lib/elementary/elm_win.eo index 6fe5b41422..0dcccca9c0 100644 --- a/src/lib/elementary/elm_win.eo +++ b/src/lib/elementary/elm_win.eo @@ -830,7 +830,7 @@ class Elm.Win (Elm.Widget, Elm.Interface.Atspi.Window, name: const(char)* @nullable; } } - @property type { + @property type { /* FIXME: before finalize */ [[The type of the window. It is a hint of how the Window Manager should handle it. diff --git a/src/lib/evas/canvas/evas_canvas.eo b/src/lib/evas/canvas/evas_canvas.eo index b05e906904..8bcf38cd48 100644 --- a/src/lib/evas/canvas/evas_canvas.eo +++ b/src/lib/evas/canvas/evas_canvas.eo @@ -410,8 +410,8 @@ class Evas.Canvas (Eo.Base, Evas.Common_Interface, Efl.Animator) canvas. When this function is called it will return a value of either - $false or $true, depending on if @.event_feed_mouse_in or - @.event_feed_mouse_out have been called to feed in a mouse + $false or $true, depending on if $event_feed_mouse_in or + $event_feed_mouse_out have been called to feed in a mouse enter event into the canvas. A return value of $true indicates the mouse is logically @@ -504,7 +504,7 @@ class Evas.Canvas (Eo.Base, Evas.Common_Interface, Efl.Animator) any host system's pointing device abilities. A canvas by default begins with no mouse buttons being - pressed and only calls to @.event_feed can alter that. + pressed and only calls to $event_feed can alter that. The least significant bit corresponds to the first mouse button (button 1) and the most significant bit corresponds @@ -1553,13 +1553,6 @@ class Evas.Canvas (Eo.Base, Evas.Common_Interface, Efl.Animator) @in data: const(void)*; [[Data for canvas.]] } } - event_feed { - [[Feed an input event.]] - legacy: null; - params { - event: const(Efl.Pointer.Event); - } - } } implements { Eo.Base.constructor; @@ -1580,5 +1573,6 @@ class Evas.Canvas (Eo.Base, Evas.Common_Interface, Efl.Animator) device,changed; axis,update; viewport,resize; + pointer; } } diff --git a/src/lib/evas/canvas/evas_events.c b/src/lib/evas/canvas/evas_events.c index 7fc0c8ff40..9379b4bf8a 100644 --- a/src/lib/evas/canvas/evas_events.c +++ b/src/lib/evas/canvas/evas_events.c @@ -1421,9 +1421,8 @@ evas_event_feed_mouse_wheel(Eo *eo_e, int direction, int z, unsigned int timesta } static void -_canvas_event_feed_mouse_move_internal(Eo *eo_e, void *_pd, int x, int y, unsigned int timestamp, const void *data) +_canvas_event_feed_mouse_move_internal(Eo *eo_e, Evas_Public_Data *e, int x, int y, unsigned int timestamp, const void *data) { - Evas_Public_Data *e = _pd; Evas_Object *nogrep_obj = NULL; int px, py; @@ -3033,9 +3032,67 @@ _evas_canvas_event_down_count_get(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e) return e->pointer.downs; } -EOLIAN void -_evas_canvas_event_feed(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, const Efl_Pointer_Event *event) +static Eina_Bool +_evas_canvas_event_pointer_cb(void *data, const Eo_Event *event) { - Efl_Pointer_Event_Data *ev = eo_data_scope_get(event, EFL_POINTER_EVENT_CLASS); - /* TODO */ + Efl_Pointer_Event_Data *ev = eo_data_scope_get(event->info, EFL_POINTER_EVENT_CLASS); + Evas_Public_Data *e = data; + Evas *eo_e = event->object; + + if (!ev) return EO_CALLBACK_CONTINUE; + + /* TODO: + * - pass event to the internal functions + * - implement legacy over oo instead of this + */ + + switch (ev->action) + { + case EFL_POINTER_ACTION_MOUSE_MOVE: + if (ev->window_pos) + { + _canvas_event_feed_mouse_move_internal(eo_e, e, + ev->cur.x - e->framespace.x, + ev->cur.y - e->framespace.y, + ev->timestamp, ev->data); + } + else + { + _canvas_event_feed_mouse_move_internal(eo_e, e, ev->cur.x, ev->cur.y, + ev->timestamp, ev->data); + } + break; + + case EFL_POINTER_ACTION_MOUSE_DOWN: + evas_event_feed_mouse_down(eo_e, ev->button, ev->button_flags, ev->timestamp, ev->data); + break; + + case EFL_POINTER_ACTION_MOUSE_UP: + evas_event_feed_mouse_up(eo_e, ev->button, ev->button_flags, ev->timestamp, ev->data); + break; + + case EFL_POINTER_ACTION_MOUSE_WHEEL: + evas_event_feed_mouse_wheel(eo_e, + (ev->wheel.dir == EFL_ORIENT_HORIZONTAL) ? 1 : 0, + ev->wheel.z, ev->timestamp, ev->data); + break; + + default: + ERR("not implemented yet"); + break; + } + + return EO_CALLBACK_CONTINUE; +} + +void +_evas_canvas_event_init(Evas *eo_e, Evas_Public_Data *e) +{ + eo_event_callback_add(eo_e, EVAS_CANVAS_EVENT_POINTER, _evas_canvas_event_pointer_cb, e); +} + +void +_evas_canvas_event_shutdown(Evas *eo_e, Evas_Public_Data *e) +{ + eo_event_callback_del(eo_e, EVAS_CANVAS_EVENT_POINTER, _evas_canvas_event_pointer_cb, e); } diff --git a/src/lib/evas/canvas/evas_events_legacy.c b/src/lib/evas/canvas/evas_events_legacy.c new file mode 100644 index 0000000000..4a0d7fdb2c --- /dev/null +++ b/src/lib/evas/canvas/evas_events_legacy.c @@ -0,0 +1,349 @@ +#include "evas_common_private.h" +#include "evas_private.h" + +#define EFL_INTERNAL_UNSTABLE +#include "interfaces/efl_common_internal.h" + +Eina_Bool +efl_pointer_event_legacy_info_set(Efl_Pointer_Event *evt, const void *event_info, Evas_Callback_Type type) +{ + Efl_Pointer_Event_Data *ev = eo_data_scope_get(evt, EFL_POINTER_EVENT_CLASS); + if (!ev || !event_info) return EINA_FALSE; + + /* FIXME/TODO: + * + * Some things that are not supported or should be eo-ified somehow + * + * 1. Lock + * 2. Modifiers + * 3. data + * + * Some events definitely don't have all the info they could have. Need + * to get it from ecore! + */ + +#warning Modifiers and locks not supported yet - very bad! + + switch (type) + { + //cse EVAS_CALLBACK_MOUSE_IN: + //case EVAS_CALLBACK_MOUSE_OUT: + case EVAS_CALLBACK_MOUSE_DOWN: + { + const Evas_Event_Mouse_Down *e = event_info; + ev->action = EFL_POINTER_ACTION_MOUSE_DOWN; + ev->button = e->button; + ev->cur.x = e->canvas.x; + ev->cur.y = e->canvas.y; + ev->cur.xsub = e->canvas.x; + ev->cur.ysub = e->canvas.y; + ev->data = e->data; + ev->button_flags = e->flags; + ev->timestamp = e->timestamp; + ev->event_flags = e->event_flags; + ev->device = e->dev; + ev->source = e->event_src; + break; + } + + case EVAS_CALLBACK_MOUSE_UP: + { + const Evas_Event_Mouse_Up *e = event_info; + ev->action = EFL_POINTER_ACTION_MOUSE_UP; + ev->button = e->button; + ev->cur.x = e->canvas.x; + ev->cur.y = e->canvas.y; + ev->cur.xsub = e->canvas.x; + ev->cur.ysub = e->canvas.y; + ev->data = e->data; + ev->button_flags = e->flags; + ev->timestamp = e->timestamp; + ev->event_flags = e->event_flags; + ev->device = e->dev; + ev->source = e->event_src; + break; + } + + case EVAS_CALLBACK_MOUSE_MOVE: + { + const Evas_Event_Mouse_Move *e = event_info; + ev->action = EFL_POINTER_ACTION_MOUSE_MOVE; + ev->pressed_buttons = e->buttons; + ev->cur.x = e->cur.canvas.x; + ev->cur.y = e->cur.canvas.y; + ev->cur.xsub = e->cur.canvas.x; + ev->cur.ysub = e->cur.canvas.y; + ev->prev.x = e->prev.canvas.x; + ev->prev.y = e->prev.canvas.y; + ev->prev.xsub = e->prev.canvas.x; + ev->prev.ysub = e->prev.canvas.y; + ev->data = e->data; + ev->timestamp = e->timestamp; + ev->event_flags = e->event_flags; + ev->device = e->dev; + ev->source = e->event_src; + break; + } + + case EVAS_CALLBACK_MOUSE_WHEEL: + { + const Evas_Event_Mouse_Wheel *e = event_info; + ev->action = EFL_POINTER_ACTION_MOUSE_WHEEL; + ev->wheel.dir = (e->direction ? EFL_ORIENT_HORIZONTAL : EFL_ORIENT_VERTICAL); + ev->wheel.z = e->z; + ev->cur.x = e->canvas.x; + ev->cur.y = e->canvas.y; + ev->cur.xsub = e->canvas.x; + ev->cur.ysub = e->canvas.y; + ev->data = e->data; + ev->timestamp = e->timestamp; + ev->event_flags = e->event_flags; + ev->device = e->dev; + break; + } + + case EVAS_CALLBACK_MULTI_DOWN: + { + const Evas_Event_Multi_Down *e = event_info; + ev->action = EFL_POINTER_ACTION_MOUSE_DOWN; // TOUCH DOWN??? + ev->finger = e->device; + ev->radius = e->radius; + ev->radius_x = e->radius_x; + ev->radius_y = e->radius_y; + ev->pressure = e->pressure; + ev->angle = e->angle; + ev->cur.x = e->canvas.x; + ev->cur.y = e->canvas.y; + ev->cur.xsub = e->canvas.xsub; + ev->cur.ysub = e->canvas.ysub; + ev->data = e->data; + ev->button_flags = e->flags; + ev->timestamp = e->timestamp; + ev->event_flags = e->event_flags; + ev->device = e->dev; + break; + } + + case EVAS_CALLBACK_MULTI_UP: + { + const Evas_Event_Multi_Up *e = event_info; + ev->action = EFL_POINTER_ACTION_MOUSE_UP; + ev->finger = e->device; + ev->radius = e->radius; + ev->radius_x = e->radius_x; + ev->radius_y = e->radius_y; + ev->pressure = e->pressure; + ev->angle = e->angle; + ev->cur.x = e->canvas.x; + ev->cur.y = e->canvas.y; + ev->cur.xsub = e->canvas.xsub; + ev->cur.ysub = e->canvas.ysub; + ev->data = e->data; + ev->button_flags = e->flags; + ev->timestamp = e->timestamp; + ev->event_flags = e->event_flags; + ev->device = e->dev; + break; + } + + case EVAS_CALLBACK_MULTI_MOVE: + { + const Evas_Event_Multi_Move *e = event_info; + ev->action = EFL_POINTER_ACTION_MOUSE_MOVE; + ev->finger = e->device; + ev->radius = e->radius; + ev->radius_x = e->radius_x; + ev->radius_y = e->radius_y; + ev->pressure = e->pressure; + ev->angle = e->angle; + ev->cur.x = e->cur.canvas.x; + ev->cur.y = e->cur.canvas.y; + ev->cur.xsub = e->cur.canvas.xsub; + ev->cur.ysub = e->cur.canvas.ysub; + ev->data = e->data; + ev->timestamp = e->timestamp; + ev->event_flags = e->event_flags; + ev->device = e->dev; + break; + } + + default: + ERR("invalid event type %d", type); + return EINA_FALSE; + } + + return EINA_TRUE; +} + +const void * +efl_pointer_event_legacy_info_get(const Efl_Pointer_Event *evt, Evas_Callback_Type *ptype, Eina_Bool multi) +{ + Efl_Pointer_Event_Data *ev = eo_data_scope_get(evt, EFL_POINTER_EVENT_CLASS); + if (!ev) return NULL; + + switch (ev->action) + { + case EFL_POINTER_ACTION_MOUSE_DOWN: + if (!ev->finger || !multi) + { + Evas_Event_Mouse_Down *e = calloc(1, sizeof(*e)); + if (ptype) *ptype = EVAS_CALLBACK_MOUSE_DOWN; + ev->legacy = e; + + e->button = ev->button; + e->canvas.x = ev->cur.x; + e->canvas.y = ev->cur.y; + e->output.x = ev->cur.x; + e->output.y = ev->cur.y; + e->data = ev->data; + e->flags = ev->button_flags; + e->timestamp = ev->timestamp; + e->event_flags = ev->event_flags; + e->dev = ev->device; + e->event_src = ev->source; + } + else + { + Evas_Event_Multi_Down *e = calloc(1, sizeof(*e)); + if (ptype) *ptype = EVAS_CALLBACK_MULTI_DOWN; + ev->legacy = e; + + e->device = ev->finger; + e->radius = ev->radius; + e->radius_x = ev->radius_x; + e->radius_y = ev->radius_y; + e->pressure = ev->pressure; + e->angle = ev->angle; + e->canvas.x = ev->cur.x; + e->canvas.y = ev->cur.y; + e->canvas.xsub = ev->cur.xsub; + e->canvas.ysub = ev->cur.ysub; + e->output.x = ev->cur.x; + e->output.y = ev->cur.y; + e->data = ev->data; + e->flags = ev->button_flags; + e->timestamp = ev->timestamp; + e->event_flags = ev->event_flags; + e->dev = ev->device; + } + break; + + case EFL_POINTER_ACTION_MOUSE_UP: + if (!ev->finger || !multi) + { + Evas_Event_Mouse_Up *e = calloc(1, sizeof(*e)); + if (ptype) *ptype = EVAS_CALLBACK_MOUSE_UP; + ev->legacy = e; + + e->button = ev->button; + e->canvas.x = ev->cur.x; + e->canvas.y = ev->cur.y; + e->output.x = ev->cur.x; + e->output.y = ev->cur.y; + e->data = ev->data; + e->flags = ev->button_flags; + e->timestamp = ev->timestamp; + e->event_flags = ev->event_flags; + e->dev = ev->device; + e->event_src = ev->source; + } + else + { + Evas_Event_Multi_Down *e = calloc(1, sizeof(*e)); + if (ptype) *ptype = EVAS_CALLBACK_MULTI_UP; + ev->legacy = e; + + e->device = ev->finger; + e->radius = ev->radius; + e->radius_x = ev->radius_x; + e->radius_y = ev->radius_y; + e->pressure = ev->pressure; + e->angle = ev->angle; + e->canvas.x = ev->cur.x; + e->canvas.y = ev->cur.y; + e->canvas.xsub = ev->cur.xsub; + e->canvas.ysub = ev->cur.ysub; + e->output.x = ev->cur.x; + e->output.y = ev->cur.y; + e->data = ev->data; + e->flags = ev->button_flags; + e->timestamp = ev->timestamp; + e->event_flags = ev->event_flags; + e->dev = ev->device; + break; + } + break; + + case EFL_POINTER_ACTION_MOUSE_MOVE: + if (!ev->finger || !multi) + { + Evas_Event_Mouse_Move *e = calloc(1, sizeof(*e)); + if (ptype) *ptype = EVAS_CALLBACK_MOUSE_MOVE; + ev->legacy = e; + + e->buttons = ev->pressed_buttons; + e->cur.canvas.x = ev->cur.x; + e->cur.canvas.y = ev->cur.y; + e->cur.output.x = ev->cur.x; + e->cur.output.y = ev->cur.y; + e->prev.canvas.x = ev->prev.x; + e->prev.canvas.y = ev->prev.y; + e->prev.output.x = ev->prev.x; + e->prev.output.y = ev->prev.y; + e->data = ev->data; + e->timestamp = ev->timestamp; + e->event_flags = ev->event_flags; + e->dev = ev->device; + e->event_src = ev->source; + } + else + { + Evas_Event_Multi_Move *e = calloc(1, sizeof(*e)); + if (ptype) *ptype = EVAS_CALLBACK_MULTI_MOVE; + ev->legacy = e; + + e->device = ev->finger; + e->radius = ev->radius; + e->radius_x = ev->radius_x; + e->radius_y = ev->radius_y; + e->pressure = ev->pressure; + e->angle = ev->angle; + e->cur.canvas.x = ev->cur.x; + e->cur.canvas.y = ev->cur.y; + e->cur.canvas.xsub = ev->cur.xsub; + e->cur.canvas.ysub = ev->cur.ysub; + e->cur.output.x = ev->cur.x; + e->cur.output.y = ev->cur.y; + e->data = ev->data; + e->timestamp = ev->timestamp; + e->event_flags = ev->event_flags; + e->dev = ev->device; + } + break; + + case EFL_POINTER_ACTION_MOUSE_WHEEL: + { + Evas_Event_Mouse_Wheel *e = calloc(1, sizeof(*e)); + if (ptype) *ptype = EVAS_CALLBACK_MOUSE_WHEEL; + ev->legacy = e; + + e->direction = (ev->wheel.dir == EFL_ORIENT_VERTICAL); + e->z = ev->wheel.z; + e->canvas.x = ev->cur.x; + e->canvas.y = ev->cur.y; + e->output.x = ev->cur.x; + e->output.y = ev->cur.y; + e->data = ev->data; + e->timestamp = ev->timestamp; + e->event_flags = ev->event_flags; + e->dev = ev->device; + break; + } + + default: + ERR("invalid event type %d", ev->action); + return NULL; + } + + return ev->legacy; +} diff --git a/src/lib/evas/canvas/evas_main.c b/src/lib/evas/canvas/evas_main.c index ae434d0a61..844b3364d6 100644 --- a/src/lib/evas/canvas/evas_main.c +++ b/src/lib/evas/canvas/evas_main.c @@ -199,6 +199,8 @@ _evas_canvas_eo_base_constructor(Eo *eo_obj, Evas_Public_Data *e) eina_lock_new(&(e->lock_objects)); eina_spinlock_new(&(e->render.lock)); + _evas_canvas_event_init(eo_obj, e); + return eo_obj; } @@ -230,6 +232,7 @@ _evas_canvas_eo_base_destructor(Eo *eo_e, Evas_Public_Data *e) evas_render_idle_flush(eo_e); _evas_post_event_callback_free(eo_e); + _evas_canvas_event_shutdown(eo_e, e); del = EINA_TRUE; e->walking_list++; diff --git a/src/lib/evas/include/evas_private.h b/src/lib/evas/include/evas_private.h index e6ff51a0bb..5bf9b99d5d 100644 --- a/src/lib/evas/include/evas_private.h +++ b/src/lib/evas/include/evas_private.h @@ -1881,6 +1881,9 @@ struct _Evas_Proxy_Render_Data Eina_Bool source_clip : 1; }; +void _evas_canvas_event_init(Evas *eo_e, Evas_Public_Data *e); +void _evas_canvas_event_shutdown(Evas *eo_e, Evas_Public_Data *e); + int evas_async_events_init(void); int evas_async_events_shutdown(void); int evas_async_target_del(const void *target); @@ -1933,6 +1936,10 @@ void _evas_touch_point_remove(Evas *e, int id); void _evas_device_cleanup(Evas *e); Evas_Device *_evas_device_top_get(const Evas *e); +/* legacy/eo events */ +Eina_Bool efl_pointer_event_legacy_info_set(Efl_Pointer_Event *evt, const void *event_info, Evas_Callback_Type type); +const void *efl_pointer_event_legacy_info_get(const Efl_Pointer_Event *evt, Evas_Callback_Type *ptype, Eina_Bool multi); + Eina_Bool evas_vg_loader_svg(Evas_Object *vg, const Eina_File *f, const char *key EINA_UNUSED); void *_evas_object_image_surface_get(Evas_Object *eo, Evas_Object_Protected_Data *obj);