evas events: fix corrupted mouse events behavior on mapped object.

Summary:
This fixes an issue that inproper mapped object in/out events triggering.
The previous mouse event logic didn't care the transformed cooridates
if a child object belongs to a mapped parents in its hierarchy.

When checking the object boundary for the child on mouse moving,
it must consider if the child were belonged to the mapped parent space.

Plus, this improves the coordiates to be transformed properly for the prev cooridates,
So that user could compare cur/prev cooridnates properly in the same space
in its events callbacks.

@fix

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D9751

1 files changed, 274 insertions, 149 deletions

diff --git a/src/lib/evas/canvas/evas_events.c b/src/lib/evas/canvas/evas_events.c
index dae351c008..46a765e32c 100644
--- a/src/lib/evas/canvas/evas_events.c
+++ b/src/lib/evas/canvas/evas_events.c
@@ -57,26 +57,41 @@ _evas_event_object_pointer_allow_precise(Eo *eo_obj, Evas_Object_Protected_Data
 
 #define EVAS_EVENT_FEED_SAFETY_CHECK(evas) _evas_event_feed_check(evas)
 
-static void
-_evas_event_havemap_adjust_f(Evas_Object *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, Eina_Vector2 *point, Eina_Bool mouse_grabbed)
+static Eina_Bool
+_evas_event_havemap_adjust_f_inline(Evas_Object_Protected_Data *obj, Eina_Vector2 *point, Eina_Bool mouse_grabbed)
 {
+   Eina_Bool ret = EINA_FALSE;
+
    if (obj->smart.parent)
      {
         Evas_Object_Protected_Data *smart_parent_obj = efl_data_scope_get(obj->smart.parent, EFL_CANVAS_OBJECT_CLASS);
-        _evas_event_havemap_adjust_f(obj->smart.parent, smart_parent_obj, point, mouse_grabbed);
+        ret |= _evas_event_havemap_adjust_f_inline(smart_parent_obj, point, mouse_grabbed);
      }
 
-   if ((!obj->map->cur.usemap) || (!obj->map->cur.map) ||
-       (obj->map->cur.map->count != 4))
-      return;
+   if ((!obj->map->cur.usemap) || (!obj->map->cur.map)) return ret;
 
    //FIXME: Unless map_coords_get() supports grab mode and extrapolate coords
    //outside map, this should check the return value for outside case.
+
+   //FIXME: When Mouse Out, it fails. but the coordiates might be transformed as well.
    if (evas_map_coords_get(obj->map->cur.map, point->x, point->y, &point->x, &point->y, mouse_grabbed))
      {
         point->x += obj->cur->geometry.x;
         point->y += obj->cur->geometry.y;
+        return EINA_TRUE;
      }
+   return ret;
+}
+
+static void
+_evas_event_havemap_adjust_f(Evas_Object_Protected_Data *obj, Eina_Vector2 *cur_pt, Eina_Vector2 *prev_pt, Eina_Bool mouse_grabbed)
+{
+   Eina_Vector2 tmp_pt = *cur_pt;
+   if (!_evas_event_havemap_adjust_f_inline(obj, &tmp_pt, mouse_grabbed)) return;
+
+   prev_pt->x += (tmp_pt.x - cur_pt->x);
+   prev_pt->y += (tmp_pt.x - cur_pt->y);
+   *cur_pt = tmp_pt;
 }
 
 #if 0
@@ -411,25 +426,31 @@ end:
 }
 
 static void
-_transform_to_src_space_f(Evas_Object_Protected_Data *obj, Evas_Object_Protected_Data *src, Eina_Vector2 *point)
+_transform_to_src_space_f(Evas_Object_Protected_Data *obj, Evas_Object_Protected_Data *src,
+                          Eina_Vector2 *cur_pt, Eina_Vector2 *prev_pt)
 {
    double obj_w = obj->cur->geometry.w, obj_h = obj->cur->geometry.h;
    double src_w = src->cur->geometry.w, src_h = src->cur->geometry.h;
-   double tmp_x = point->x;
-   double tmp_y = point->y;
 
-   tmp_x -= obj->cur->geometry.x;
-   tmp_y -= obj->cur->geometry.y;
+   //Current Point
+   cur_pt->x -= obj->cur->geometry.x;
+   cur_pt->y -= obj->cur->geometry.y;
 
-   if (!EINA_DBL_EQ(obj_w, src_w))
-     tmp_x = (tmp_x * (src_w / obj_w));
-   if (!EINA_DBL_EQ(obj_h, src_h))
-     tmp_y = (tmp_y * (src_h / obj_h));
+   if (!EINA_DBL_EQ(obj_w, src_w)) cur_pt->x *= (src_w / obj_w);
+   if (!EINA_DBL_EQ(obj_h, src_h)) cur_pt->y *= (src_h / obj_h);
 
-   tmp_x += src->cur->geometry.x;
-   tmp_y += src->cur->geometry.y;
-   point->x = tmp_x;
-   point->y = tmp_y;
+   cur_pt->x += src->cur->geometry.x;
+   cur_pt->y += src->cur->geometry.y;
+
+   //Prev Point
+   prev_pt->x -= obj->cur->geometry.x;
+   prev_pt->y -= obj->cur->geometry.y;
+
+   if (!EINA_DBL_EQ(obj_w, src_w)) prev_pt->x *= (src_w / obj_w);
+   if (!EINA_DBL_EQ(obj_h, src_h)) prev_pt->y *= (src_h / obj_h);
+
+   prev_pt->x += src->cur->geometry.x;
+   prev_pt->y += src->cur->geometry.y;
 }
 
 static Efl_Input_Device *
@@ -462,7 +483,7 @@ _evas_event_source_mouse_down_events(Evas_Object *eo_obj, Evas *eo_e,
    Eina_List *copy, *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
    int addgrab = 0;
    int no_rep = 0;
    int srcgrab = 0;
@@ -473,8 +494,10 @@ _evas_event_source_mouse_down_events(Evas_Object *eo_obj, Evas *eo_e,
    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
    if (!ev) return;
 
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   point = ev->cur;
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
    ev->source = eo_obj;
    ev->touch_id = 0;
 
@@ -558,7 +581,6 @@ _evas_event_source_mouse_down_events(Evas_Object *eo_obj, Evas *eo_e,
         Evas_Object_Pointer_Mode pointer_mode;
 
         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
-        ev->cur = point;
         obj_pdata = _evas_object_pointer_data_get(pdata, child);
         if (!obj_pdata)
           {
@@ -567,7 +589,12 @@ _evas_event_source_mouse_down_events(Evas_Object *eo_obj, Evas *eo_e,
              continue;
           }
         pointer_mode = obj_pdata->pointer_mode;
-        _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+
+        ev->cur = cur_pt;
+        ev->prev = prev_pt;
+
+        _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_DOWN, evt,
                                         event_id, EFL_EVENT_POINTER_DOWN);
         if (e->delete_me) break;
@@ -611,7 +638,7 @@ _evas_event_source_mouse_move_events(Evas_Object *eo_obj, Evas *eo_e,
    Eina_List *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 curpt, curpt_real, prevpt;
+   Eina_Vector2 cur_pt_real, prev_pt_real, cur_pt, prev_pt;
    Evas_Object_Pointer_Data *obj_pdata;
 
    if (obj->delete_me || src->delete_me || e->is_frozen) return;
@@ -620,11 +647,13 @@ _evas_event_source_mouse_move_events(Evas_Object *eo_obj, Evas *eo_e,
    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
    if (!ev) return;
 
-   curpt_real = ev->cur;
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   _transform_to_src_space_f(obj, src, &ev->prev);
-   curpt = ev->cur;
-   prevpt = ev->prev;
+   cur_pt_real = ev->cur;
+   prev_pt_real = ev->prev;
+
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
    ev->source = eo_obj;
    ev->touch_id = 0;
 
@@ -651,10 +680,10 @@ _evas_event_source_mouse_move_events(Evas_Object *eo_obj, Evas *eo_e,
 
              if (_evas_event_object_pointer_allow(eo_child, child, obj_pdata))
                {
-                  ev->cur = curpt;
-                  ev->prev = prevpt;
-                  _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
-                  _evas_event_havemap_adjust_f(eo_child, child, &ev->prev, obj_pdata->mouse_grabbed);
+                  ev->cur = cur_pt;
+                  ev->prev = prev_pt;
+
+                  _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
 
                   ev->action = EFL_POINTER_ACTION_MOVE;
                   evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
@@ -683,8 +712,12 @@ _evas_event_source_mouse_move_events(Evas_Object *eo_obj, Evas *eo_e,
                   if (obj_pdata->mouse_in) continue; /* FIXME: dubious logic! */
                   _evas_event_mouse_in_set(pdata->seat, child, 0);
                   if (e->is_frozen) continue;
-                  ev->cur = curpt_real;
-                  _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+
+                  ev->cur = cur_pt_real;
+                  ev->prev = prev_pt_real;
+
+                  _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                   EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
                     proxy_write->src_event_in = eina_list_remove(proxy_write->src_event_in, eo_child);
                   EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
@@ -731,23 +764,24 @@ _evas_event_source_mouse_move_events(Evas_Object *eo_obj, Evas *eo_e,
                       ev->device);
                   continue;
                }
-             ev->cur = curpt;
+             ev->cur = cur_pt;
+             ev->prev = prev_pt;
+
+             _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              if (evas_object_is_in_output_rect(eo_child, child,
                                                ev->cur.x, ev->cur.y, 1, 1) &&
                 _evas_event_object_pointer_allow(eo_child, child, obj_pdata) &&
                 _evas_event_object_pointer_allow_precise(eo_child, child, ev->cur.x, ev->cur.y, ins))
                {
                   ev->action = EFL_POINTER_ACTION_MOVE;
-                  _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
-                  evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
+                 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
                                                   event_id, EFL_EVENT_POINTER_MOVE);
                }
              else if (obj_pdata->mouse_in)
                {
                   _evas_event_mouse_in_set(pdata->seat, child, 0);
                   if (e->is_frozen) continue;
-                  ev->cur = curpt;
-                  _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
                   ev->action = EFL_POINTER_ACTION_OUT;
                   evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_OUT, evt,
                                                   event_id, EFL_EVENT_POINTER_OUT);
@@ -775,13 +809,16 @@ _evas_event_source_mouse_move_events(Evas_Object *eo_obj, Evas *eo_e,
                      {
                         _evas_event_mouse_in_set(pdata->seat, child, 1);
                         if (e->is_frozen) continue;
-                        ev->cur = curpt;
-                        _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+
+                        ev->cur = cur_pt;
+                        ev->prev = prev_pt;
+
+                        _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                         ev->action = EFL_POINTER_ACTION_IN;
                         evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_IN, evt,
                                                         event_id2, EFL_EVENT_POINTER_IN);
-                        if ((curpt.x != ev->prev.x) &&
-                            (curpt.y != ev->prev.y))
+                        if ((cur_pt.x != prev_pt.x) && (cur_pt.y != prev_pt.y))
                           {
                              ev->action = EFL_POINTER_ACTION_MOVE;
                              evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
@@ -825,7 +862,7 @@ _evas_event_source_mouse_up_events(Evas_Object *eo_obj, Evas *eo_e,
    Eina_List *copy, *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
 
    if (obj->delete_me || src->delete_me || e->is_frozen) return;
 
@@ -833,8 +870,10 @@ _evas_event_source_mouse_up_events(Evas_Object *eo_obj, Evas *eo_e,
    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
    if (!ev) return;
 
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   point = ev->cur;
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
    ev->source = eo_obj;
    ev->touch_id = 0;
 
@@ -860,9 +899,13 @@ _evas_event_source_mouse_up_events(Evas_Object *eo_obj, Evas *eo_e,
              pdata->seat->mouse_grabbed--;
           }
 
-        ev->cur = point;
         pointer_mode = obj_pdata->pointer_mode;
-        _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+
+        ev->cur = cur_pt;
+        ev->prev = prev_pt;
+
+        _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         if (cancel)
           efl_event_callback_call(eo_child, EFL_EVENT_POINTER_CANCEL, evt);
         else
@@ -916,7 +959,7 @@ _evas_event_source_wheel_events(Evas_Object *eo_obj, Evas *eo_e,
    Eina_List *copy, *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
    Evas_Pointer_Data *pdata;
 
    if (obj->delete_me || src->delete_me || obj->layer->evas->is_frozen) return;
@@ -928,8 +971,10 @@ _evas_event_source_wheel_events(Evas_Object *eo_obj, Evas *eo_e,
    pdata = _evas_pointer_data_by_device_get(e, ev->device);
    if (!pdata) return;
 
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   point = ev->cur;
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
    ev->source = eo_obj;
 
    copy = evas_event_list_copy(src->proxy->src_event_in);
@@ -951,8 +996,10 @@ _evas_event_source_wheel_events(Evas_Object *eo_obj, Evas *eo_e,
                  ev->device);
              continue;
           }
-        ev->cur = point;
-        _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+        ev->cur = cur_pt;
+        ev->prev = prev_pt;
+        _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_WHEEL, evt,
                                         event_id, EFL_EVENT_POINTER_WHEEL);
         if (e->delete_me) break;
@@ -974,7 +1021,7 @@ _evas_event_source_multi_down_events(Evas_Object_Protected_Data *obj, Evas_Publi
    Eina_List *copy, *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
    Evas_Object_Pointer_Data *obj_pdata;
    int addgrab = 0;
 
@@ -984,8 +1031,10 @@ _evas_event_source_multi_down_events(Evas_Object_Protected_Data *obj, Evas_Publi
    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
    if (!ev) return;
 
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   point = ev->cur;
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
    ev->source = obj->object;
    ev->action = EFL_POINTER_ACTION_DOWN;
 
@@ -1022,8 +1071,11 @@ _evas_event_source_multi_down_events(Evas_Object_Protected_Data *obj, Evas_Publi
                  ev->device);
              continue;
           }
-        ev->cur = point;
-        _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+        ev->cur = cur_pt;
+        ev->prev = prev_pt;
+
+        _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_DOWN, evt,
                                         event_id, EFL_EVENT_FINGER_DOWN);
         if (e->delete_me) break;
@@ -1045,7 +1097,7 @@ _evas_event_source_multi_up_events(Evas_Object_Protected_Data *obj, Evas_Public_
    Eina_List *copy, *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
 
    if (obj->delete_me || src->delete_me || obj->layer->evas->is_frozen) return;
 
@@ -1053,8 +1105,11 @@ _evas_event_source_multi_up_events(Evas_Object_Protected_Data *obj, Evas_Public_
    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
    if (!ev) return;
 
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   point = ev->cur;
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
+
    ev->source = obj->object;
    ev->action = EFL_POINTER_ACTION_UP;
 
@@ -1080,8 +1135,10 @@ _evas_event_source_multi_up_events(Evas_Object_Protected_Data *obj, Evas_Public_
              obj_pdata->mouse_grabbed--;
              pdata->seat->mouse_grabbed--;
           }
-        ev->cur = point;
-        _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+        ev->cur = cur_pt;
+        ev->prev = prev_pt;
+        _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_UP, evt,
                                         event_id, EFL_EVENT_FINGER_UP);
         if (e->delete_me || e->is_frozen) break;
@@ -1103,7 +1160,7 @@ _evas_event_source_multi_move_events(Evas_Object_Protected_Data *obj, Evas_Publi
    Eina_List *copy, *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
    Evas_Object_Pointer_Data *obj_pdata;
    Evas *eo_e = e->evas;
 
@@ -1113,8 +1170,10 @@ _evas_event_source_multi_move_events(Evas_Object_Protected_Data *obj, Evas_Publi
    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
    if (!ev) return;
 
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   point = ev->cur;
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
    ev->source = obj->object;
    ev->action = EFL_POINTER_ACTION_UP;
 
@@ -1136,8 +1195,10 @@ _evas_event_source_multi_move_events(Evas_Object_Protected_Data *obj, Evas_Publi
                }
              if (_evas_event_object_pointer_allow(eo_child, child, obj_pdata))
                {
-                  ev->cur = point;
-                  _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+                  ev->cur = cur_pt;
+                  ev->prev = prev_pt;
+                  _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                   evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
                                                   event_id, EFL_EVENT_FINGER_MOVE);
                   if (e->delete_me || e->is_frozen) break;
@@ -1170,7 +1231,6 @@ _evas_event_source_multi_move_events(Evas_Object_Protected_Data *obj, Evas_Publi
         EINA_LIST_FOREACH(copy, l, eo_child)
           {
              child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
-             ev->cur = point;
              obj_pdata = _evas_object_pointer_data_get(pdata, child);
              if (!obj_pdata)
                {
@@ -1179,11 +1239,14 @@ _evas_event_source_multi_move_events(Evas_Object_Protected_Data *obj, Evas_Publi
                   continue;
                }
 
+             ev->cur = cur_pt;
+             ev->prev = prev_pt;
+             _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              if (evas_object_is_in_output_rect(eo_child, child, ev->cur.x, ev->cur.y, 1, 1) &&
                 _evas_event_object_pointer_allow(eo_child, child, obj_pdata) &&
                 _evas_event_object_pointer_allow_precise(eo_child, child, ev->cur.x, ev->cur.y, ins))
                {
-                  _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
                   evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
                                                   event_id, EFL_EVENT_FINGER_MOVE);
                   if (e->delete_me || e->is_frozen) break;
@@ -1219,7 +1282,7 @@ _evas_event_source_mouse_in_events(Evas_Object *eo_obj, Evas *eo_e,
    Eina_List *ins = NULL, *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
    Evas_Pointer_Data *pdata;
 
    if (obj->delete_me || src->delete_me || e->is_frozen) return;
@@ -1231,8 +1294,10 @@ _evas_event_source_mouse_in_events(Evas_Object *eo_obj, Evas *eo_e,
    pdata = _evas_pointer_data_by_device_get(e, ev->device);
    if (!pdata) return;
 
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   point = ev->cur;
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
    ev->source = eo_obj;
    ev->action = EFL_POINTER_ACTION_IN;
 
@@ -1270,13 +1335,15 @@ _evas_event_source_mouse_in_events(Evas_Object *eo_obj, Evas *eo_e,
           {
              if (obj_pdata->mouse_in) continue;
              _evas_event_mouse_in_set(pdata->seat, child, 1);
-             ev->cur = point;
-             _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+
+             ev->cur = cur_pt;
+             ev->prev = prev_pt;
+             _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              ev->action = EFL_POINTER_ACTION_IN;
              evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_IN, evt,
                                              event_id, EFL_EVENT_POINTER_IN);
-             if ((ev->cur.x != ev->prev.x) &&
-                 (ev->cur.y != ev->prev.y))
+             if ((cur_pt.x != prev_pt.x) || (cur_pt.y != prev_pt.y))
                {
                   ev->action = EFL_POINTER_ACTION_MOVE;
                   evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
@@ -1309,7 +1376,7 @@ _evas_event_source_mouse_out_events(Evas_Object *eo_obj, Evas *eo_e,
    Eina_List *copy, *l;
    Efl_Input_Pointer_Data *ev;
    Efl_Input_Pointer *evt;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
    Evas_Pointer_Data *pdata;
 
    if (obj->delete_me || src->delete_me || e->is_frozen) return;
@@ -1320,8 +1387,11 @@ _evas_event_source_mouse_out_events(Evas_Object *eo_obj, Evas *eo_e,
 
    pdata = _evas_pointer_data_by_device_get(e, ev->device);
    if (!pdata) return;
-   _transform_to_src_space_f(obj, src, &ev->cur);
-   point = ev->cur;
+
+   _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
+
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
    ev->source = eo_obj;
    ev->action = EFL_POINTER_ACTION_OUT;
 
@@ -1342,8 +1412,10 @@ _evas_event_source_mouse_out_events(Evas_Object *eo_obj, Evas *eo_e,
         _evas_event_mouse_in_set(pdata->seat, child, 0);
         if (child->delete_me) continue;
 
-        ev->cur = point;
-        _evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
+        ev->cur = cur_pt;
+        ev->prev = prev_pt;
+        _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
                                         event_id, EFL_EVENT_POINTER_OUT);
         if (e->is_frozen) continue;
@@ -1606,10 +1678,14 @@ _canvas_event_feed_mouse_down_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
                  ev->device);
              continue;
           }
+        pointer_mode = obj_pdata->pointer_mode;
+
         ev->cur.x = pdata->seat->x;
         ev->cur.y = pdata->seat->y;
-        pointer_mode = obj_pdata->pointer_mode;
-        _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+        ev->prev.x = pdata->seat->prev.x;
+        ev->prev.y = pdata->seat->prev.y;
+        _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_DOWN, evt,
                                         event_id, EFL_EVENT_POINTER_DOWN);
         if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
@@ -1672,7 +1748,11 @@ _post_up_handle(Evas_Public_Data *e, Efl_Input_Pointer *parent_ev,
                {
                   ev->cur.x = pdata->seat->x;
                   ev->cur.y = pdata->seat->y;
-                  _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+                  ev->prev.x = pdata->seat->prev.x;
+                  ev->prev.y = pdata->seat->prev.y;
+
+                  _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
                                                   event_id, EFL_EVENT_POINTER_OUT);
                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
@@ -1707,14 +1787,18 @@ _post_up_handle(Evas_Public_Data *e, Efl_Input_Pointer *parent_ev,
                   if (obj_pdata->mouse_in) continue;
                   _evas_event_mouse_in_set(pdata->seat, obj_itr, 1);
                   if (e->is_frozen) continue;
+
                   ev->cur.x = pdata->seat->x;
                   ev->cur.y = pdata->seat->y;
-                  _evas_event_havemap_adjust_f(eo_obj_itr, obj_itr, &ev->cur, obj_pdata->mouse_grabbed);
+                  ev->prev.x = pdata->seat->prev.x;
+                  ev->prev.y = pdata->seat->prev.y;
+
+                  _evas_event_havemap_adjust_f(obj_itr, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                   ev->action = EFL_POINTER_ACTION_IN;
                   evas_object_event_callback_call(eo_obj_itr, obj_itr, EVAS_CALLBACK_MOUSE_IN, evt,
                                                   event_id, EFL_EVENT_POINTER_IN);
-                  if ((pdata->seat->x != ev->prev.x) &&
-                      (pdata->seat->y != ev->prev.y))
+                  if ((pdata->seat->x != pdata->seat->prev.x) && (pdata->seat->y != pdata->seat->prev.y))
                     {
                        ev->action = EFL_POINTER_ACTION_MOVE;
                        evas_object_event_callback_call(eo_obj_itr, obj_itr, EVAS_CALLBACK_MOUSE_MOVE, evt,
@@ -1841,7 +1925,11 @@ _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data
           {
              ev->cur.x = pdata->seat->x;
              ev->cur.y = pdata->seat->y;
-             _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+             ev->prev.x = pdata->seat->prev.x;
+             ev->prev.y = pdata->seat->prev.y;
+
+             _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              if (cancel)
                efl_event_callback_call(eo_obj, EFL_EVENT_POINTER_CANCEL, evt);
              else
@@ -2121,7 +2209,11 @@ _canvas_event_feed_mouse_wheel_internal(Eo *eo_e, Efl_Input_Pointer_Data *pe)
                }
              ev->cur.x = pdata->seat->x;
              ev->cur.y = pdata->seat->y;
-             _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+             ev->prev.x = pdata->seat->prev.x;
+             ev->prev.y = pdata->seat->prev.y;
+
+             _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_WHEEL, evt,
                                              event_id, EFL_EVENT_POINTER_WHEEL);
              if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
@@ -2163,10 +2255,9 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
    Efl_Input_Pointer *evt;
    Eina_List *l, *copy;
    Evas_Object *eo_obj;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
    Evas *eo_e;
    int event_id;
-   int x, y, px, py;
    Evas_Pointer_Data *pdata;
    Evas_Object_Pointer_Data *obj_pdata;
 
@@ -2210,16 +2301,16 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
    eo_e = e->evas;
    e->last_timestamp = ev->timestamp;
 
+   ev->prev.x = pdata->seat->x;
+   ev->prev.y = pdata->seat->y;
+
    // prev pos
-   pdata->seat->prev.x = pdata->seat->x;
-   pdata->seat->prev.y = pdata->seat->y;
-   px = ev->prev.x = pdata->seat->x;
-   py = ev->prev.y = pdata->seat->y;
+   prev_pt.x = pdata->seat->prev.x = ev->prev.x;
+   prev_pt.y = pdata->seat->prev.y = ev->prev.y;
 
    // new pos
-   x = pdata->seat->x = ev->cur.x;
-   y = pdata->seat->y = ev->cur.y;
-   point = ev->cur;
+   cur_pt.x = pdata->seat->x = ev->cur.x;
+   cur_pt.y = pdata->seat->y = ev->cur.y;
 
    if ((!pdata->seat->inside) && (pdata->seat->mouse_grabbed == 0)) return;
 
@@ -2234,7 +2325,7 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
 
    _evas_walk(e);
    /* update moved touch point */
-   if ((px != x) || (py != y))
+   if ((prev_pt.x != cur_pt.x) || (prev_pt.y != cur_pt.y))
      _evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_MOVE);
    /* if our mouse button is grabbed to any objects */
    if (pdata->seat->mouse_grabbed > 0)
@@ -2268,10 +2359,13 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
                  (!evas_object_is_source_invisible(eo_obj, obj) ||
                   obj_pdata->mouse_grabbed))
                {
-                  if ((px != x) || (py != y))
+                  ev->cur = cur_pt;
+                  ev->prev = prev_pt;
+
+                  if ((prev_pt.x != cur_pt.x) || (prev_pt.y != cur_pt.y))
                     {
-                       ev->cur = point;
-                       _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+                       _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
                                                        event_id, EFL_EVENT_POINTER_MOVE);
                        if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
@@ -2314,8 +2408,12 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
                   _evas_event_mouse_in_set(pdata->seat, obj, 0);
                   if (obj->delete_me || e->is_frozen) continue;
                   pdata->seat->object.in = eina_list_remove(pdata->seat->object.in, eo_obj);
-                  ev->cur = point;
-                  _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+
+                  ev->cur = cur_pt;
+                  ev->prev = prev_pt;
+
+                  _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
                                                   event_id, EFL_EVENT_POINTER_OUT);
                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
@@ -2331,7 +2429,7 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
         event_id = _evas_object_event_new();
 
         /* get all new in objects */
-        ins = evas_event_objects_event_list(eo_e, NULL, x, y);
+        ins = evas_event_objects_event_list(eo_e, NULL, cur_pt.x, cur_pt.y);
         /* go thru old list of in objects */
         copy = evas_event_list_copy(pdata->seat->object.in);
         EINA_LIST_FOREACH(copy, l, eo_obj)
@@ -2350,17 +2448,20 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
              /* in list */
              // FIXME: i don't think we need this
              //	     evas_object_clip_recalc(eo_obj);
+
+             ev->cur = cur_pt;
+             ev->prev = prev_pt;
+
+             _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              if ((!e->is_frozen) &&
-                 evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1) &&
+                 (evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1)) &&
                  _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
-                 _evas_event_object_pointer_allow_precise(eo_obj, obj, x, y, ins) &&
-                 (!evas_object_is_source_invisible(eo_obj, obj) ||
-                  obj_pdata->mouse_grabbed))
+                 _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, ins) &&
+                 (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
                {
-                  if ((px != x) || (py != y))
+                  if ((prev_pt.x != cur_pt.x) || (prev_pt.y != cur_pt.y))
                     {
-                       ev->cur = point;
-                       _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
                        ev->action = EFL_POINTER_ACTION_MOVE;
                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
                                                        event_id, EFL_EVENT_POINTER_MOVE);
@@ -2373,8 +2474,6 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
                {
                   _evas_event_mouse_in_set(pdata->seat, obj, 0);
                   if (e->is_frozen) continue;
-                  ev->cur = point;
-                  _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
                   ev->action = EFL_POINTER_ACTION_OUT;
                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
                                                   event_id, EFL_EVENT_POINTER_OUT);
@@ -2407,21 +2506,24 @@ _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
                     {
                        _evas_event_mouse_in_set(pdata->seat, obj, 1);
                        if (e->is_frozen) continue;
-                       ev->cur = point;
-                       _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+
+                       ev->cur = cur_pt;
+                       ev->prev = prev_pt;
+
+                       _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                        ev->action = EFL_POINTER_ACTION_IN;
                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
                                                        event_id, EFL_EVENT_POINTER_IN);
-                        if ((point.x != ev->prev.x) &&
-                            (point.y != ev->prev.y))
+                       if ((prev_pt.x != cur_pt.x) || (prev_pt.y != cur_pt.y))
                           {
                              ev->action = EFL_POINTER_ACTION_MOVE;
                              evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
                                                              event_id, EFL_EVENT_POINTER_MOVE);
                           }
-                       if ((obj->proxy->is_proxy) &&
-                           (obj->proxy->src_events))
+                       if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
                          _evas_event_source_mouse_in_events(eo_obj, eo_e, evt, event_id);
+
                        if (e->delete_me) break;
                     }
                }
@@ -2494,17 +2596,20 @@ nogrep:
              /* in list */
              // FIXME: i don't think we need this
              //	     evas_object_clip_recalc(eo_obj);
+
+             ev->cur = cur_pt;
+             ev->prev = prev_pt;
+
+             _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              if ((!e->is_frozen) &&
-                 evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1) &&
+                 evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1) &&
                  _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
-                 _evas_event_object_pointer_allow_precise(eo_obj, obj, x, y, newin) &&
-                 (!evas_object_is_source_invisible(eo_obj, obj) ||
-                  obj_pdata->mouse_grabbed))
+                 _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, newin) &&
+                 (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
                {
-                  if ((px != x) || (py != y))
+                  if ((prev_pt.x != cur_pt.x) || (prev_pt.y != cur_pt.y))
                     {
-                       ev->cur = point;
-                       _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
                        ev->action = EFL_POINTER_ACTION_MOVE;
                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
                                                        event_id, EFL_EVENT_POINTER_MOVE);
@@ -2518,8 +2623,6 @@ nogrep:
                   if (!obj_pdata->mouse_in) continue;
                   _evas_event_mouse_in_set(pdata->seat, obj, 0);
                   if (e->is_frozen) continue;
-                  ev->cur = point;
-                  _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
                   ev->action = EFL_POINTER_ACTION_OUT;
                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
                                                   event_id, EFL_EVENT_POINTER_OUT);
@@ -2550,13 +2653,16 @@ nogrep:
                   if (obj_pdata->mouse_in) continue;
                   _evas_event_mouse_in_set(pdata->seat, obj, 1);
                   if (e->is_frozen) continue;
-                  ev->cur = point;
-                  _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+
+                  ev->cur = cur_pt;
+                  ev->prev = prev_pt;
+
+                  _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
                   ev->action = EFL_POINTER_ACTION_IN;
                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
                                                   event_id, EFL_EVENT_POINTER_IN);
-                  if ((point.x != ev->prev.x) &&
-                      (point.y != ev->prev.y))
+                  if ((prev_pt.x != cur_pt.x) || (prev_pt.y != cur_pt.y))
                     {
                        ev->action = EFL_POINTER_ACTION_MOVE;
                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
@@ -2689,9 +2795,13 @@ _canvas_event_feed_mouse_in_internal(Evas *eo_e, Efl_Input_Pointer_Data *ev)
                }
              if (obj_pdata->mouse_in) continue;
              _evas_event_mouse_in_set(pdata->seat, obj, 1);
+
              ev->cur.x = pdata->seat->x;
              ev->cur.y = pdata->seat->y;
-             _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+             ev->prev.x = pdata->seat->prev.x;
+             ev->prev.y = pdata->seat->prev.y;
+             _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              ev->action = EFL_POINTER_ACTION_IN;
              efl_ref(eo_obj);
              evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
@@ -2788,10 +2898,14 @@ _canvas_event_feed_mouse_out_internal(Evas *eo_e, Efl_Input_Pointer_Data *ev)
           }
         if (!obj_pdata->mouse_in) continue;
         _evas_event_mouse_in_set(pdata->seat, obj, 0);
+        efl_ref(eo_obj);
+
         ev->cur.x = pdata->seat->x;
         ev->cur.y = pdata->seat->y;
-        efl_ref(eo_obj);
-        _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+        ev->prev.x = pdata->seat->prev.x;
+        ev->prev.y = pdata->seat->prev.y;
+        _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
                                         event_id, EFL_EVENT_POINTER_OUT);
         if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
@@ -2925,7 +3039,10 @@ _canvas_event_feed_multi_down_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
              continue;
           }
         ev->cur = point;
-        _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+        ev->prev.x = pdata->seat->prev.x;
+        ev->prev.y = pdata->seat->prev.y;
+        _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_DOWN, evt,
                                         event_id, EFL_EVENT_FINGER_DOWN);
         if ((obj->proxy->is_proxy) || (obj->proxy->src_events))
@@ -2999,7 +3116,10 @@ _canvas_event_feed_multi_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data
              continue;
           }
         ev->cur = point;
-        _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+        ev->prev.x = pdata->seat->prev.x;
+        ev->prev.y = pdata->seat->prev.y;
+
+        _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
         if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
             (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
             (obj_pdata->mouse_grabbed > 0))
@@ -3127,7 +3247,7 @@ _canvas_event_feed_multi_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
    Efl_Input_Pointer *evt;
    Eina_List *l, *copy;
    Evas_Object *eo_obj;
-   Eina_Vector2 point;
+   Eina_Vector2 cur_pt, prev_pt;
    Evas *eo_e;
    int event_id;
    Evas_Pointer_Data *pdata;
@@ -3161,7 +3281,8 @@ _canvas_event_feed_multi_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
    ev->value_flags |= value_flags;
    if (ev->device) efl_ref(ev->device);
 
-   point = ev->cur;
+   cur_pt = ev->cur;
+   prev_pt = ev->prev;
 
    _evas_walk(e);
    /* update moved touch point */
@@ -3185,8 +3306,9 @@ _canvas_event_feed_multi_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
                  (!evas_object_is_source_invisible(eo_obj, obj) ||
                   obj_pdata->mouse_grabbed))
                {
-                  ev->cur = point;
-                  _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
+                  ev->cur = cur_pt;
+                  ev->prev = prev_pt;
+                  _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
                                                   event_id, EFL_EVENT_FINGER_MOVE);
                   if ((obj->proxy->is_proxy) || (obj->proxy->src_events))
@@ -3220,14 +3342,17 @@ _canvas_event_feed_multi_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Da
              /* in list */
              // FIXME: i don't think we need this
              //	     evas_object_clip_recalc(eo_obj);
+
+             ev->cur = cur_pt;
+             ev->prev = prev_pt;
+
+             _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
+
              if (evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1) &&
                  _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
                  _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, ins) &&
-                 (!evas_object_is_source_invisible(eo_obj, obj) ||
-                  obj_pdata->mouse_grabbed))
+                 (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
                {
-                  ev->cur = point;
-                  _evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
                                                   event_id, EFL_EVENT_FINGER_MOVE);
                   if ((obj->proxy->is_proxy) || (obj->proxy->src_events))