src/lib/evas/canvas/evas_events.c

   1 #define EFL_INPUT_EVENT_PROTECTED
   2
   3 #include "evas_common_private.h"
   4 #include "evas_private.h"
   5
   6 int _evas_event_counter = 0;
   7
   8 static Eina_List *
   9 _evas_event_object_list_in_get(Evas *eo_e, Eina_List *in,
  10                                const Eina_Inlist *ilist,
  11                                const Eina_List *list,
  12                                Evas_Object *stop,
  13                                int x, int y, int *no_rep, Eina_Bool source);
  14
  15 /* FIXME: use eina_list_clone */
  16 static Eina_List *
  17 evas_event_list_copy(Eina_List *list);
  18
  19 static void
  20 _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev);
  21
  22 static void
  23 _canvas_event_feed_multi_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev);
  24
  25 static void
  26 _canvas_event_feed_multi_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev);
  27
  28 static void
  29 _canvas_event_feed_mouse_move_legacy(Evas *eo_e, Evas_Public_Data *e, int x, int y,
  30                                      unsigned int timestamp, const void *data);
  31
  32 static inline void
  33 _evas_event_feed_check(Evas_Public_Data *e)
  34 {
  35    if (EINA_LIKELY(!e->running_post_events)) return;
  36    /* TIZEN_ONLY(20190906): do not to cause abort by input event feed from post
  37     *                       event callback.
  38     *                       e.g. "drag,start" callback of elm_interface_scroller
  39     *                       is called in mouse move post event. If app sets size
  40     *                       of an object in "drag,start" callback, then it may
  41     *                       cause mouse move event again in the mouse move post
  42     *                       event and the CRI log message is called. But since
  43     *                       "drag,start" callback is called only once, the mouse
  44     *                       move event is not called recursively.
  45     */
  46    //CRI("Feeding new input events from a post-event callback is risky!");
  47    DBG("Feeding new input events from a post-event callback is risky!");
  48    /* END(20190906) */
  49 }
  50
  51 static inline Eina_Bool
  52 _evas_event_object_pointer_allow(Eo *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Pointer_Data *obj_pdata)
  53 {
  54    return (obj->is_event_parent || evas_object_clippers_is_visible(eo_obj, obj) || obj_pdata->mouse_grabbed) &&
  55            (!evas_event_passes_through(eo_obj, obj)) &&
  56            (!evas_event_freezes_through(eo_obj, obj)) &&
  57            (!obj->clip.clipees);
  58 }
  59
  60 static inline Eina_Bool
  61 _evas_event_object_pointer_allow_precise(Eo *eo_obj, Evas_Object_Protected_Data *obj, int x, int y, const Eina_List *ins)
  62 {
  63    return eina_list_data_find(ins, eo_obj) &&
  64      ((!obj->precise_is_inside) || evas_object_is_inside(eo_obj, obj, x, y));
  65 }
  66
  67 #define EVAS_EVENT_FEED_SAFETY_CHECK(evas) _evas_event_feed_check(evas)
  68
  69 static Eina_Bool
  70 _evas_event_havemap_adjust_f_inline(Evas_Object_Protected_Data *obj, Eina_Vector2 *point, Eina_Bool mouse_grabbed)
  71 {
  72    Eina_Bool ret = EINA_FALSE;
  73
  74    if (obj->smart.parent)
  75      {
  76         Evas_Object_Protected_Data *smart_parent_obj = efl_data_scope_get(obj->smart.parent, EFL_CANVAS_OBJECT_CLASS);
  77         ret |= _evas_event_havemap_adjust_f_inline(smart_parent_obj, point, mouse_grabbed);
  78      }
  79
  80    if ((!obj->map->cur.usemap) || (!obj->map->cur.map)) return ret;
  81
  82    //FIXME: Unless map_coords_get() supports grab mode and extrapolate coords
  83    //outside map, this should check the return value for outside case.
  84
  85    //FIXME: When Mouse Out, it fails. but the coordiates might be transformed as well.
  86    if (evas_map_coords_get(obj->map->cur.map, point->x, point->y, &point->x, &point->y, mouse_grabbed))
  87      {
  88         point->x += obj->cur->geometry.x;
  89         point->y += obj->cur->geometry.y;
  90         return EINA_TRUE;
  91      }
  92    return ret;
  93 }
  94
  95 static void
  96 _evas_event_havemap_adjust_f(Evas_Object_Protected_Data *obj, Eina_Vector2 *cur_pt, Eina_Vector2 *prev_pt, Eina_Bool mouse_grabbed)
  97 {
  98    Eina_Vector2 tmp_pt = *cur_pt;
  99    if (!_evas_event_havemap_adjust_f_inline(obj, &tmp_pt, mouse_grabbed)) return;
 100
 101    prev_pt->x += (tmp_pt.x - cur_pt->x);
 102    prev_pt->y += (tmp_pt.y - cur_pt->y);
 103    *cur_pt = tmp_pt;
 104 }
 105
 106 #if 0
 107 # define DDD_DO 1
 108 # define DDD(...) do { for (int _i = 0; _i < spaces; _i++) printf(" "); printf(__VA_ARGS__); } while (0)
 109 # define D(...) do { printf(__VA_ARGS__); } while (0)
 110 # define DDD_STATIC static
 111 #else
 112 # define DDD(...) do { } while (0)
 113 # define D(...) do { } while (0)
 114 # define DDD_STATIC
 115 #endif
 116
 117 #ifdef DDD_DO
 118 static void
 119 walk_clippers_print(int spaces, Evas_Object_Protected_Data *obj)
 120 {
 121    DDD("<<< CLIP %p c[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i]\n",
 122        obj->object,
 123        obj->cur->geometry.x, obj->cur->geometry.y,
 124        obj->cur->geometry.w, obj->cur->geometry.h,
 125        obj->cur->cache.clip.x, obj->cur->cache.clip.y,
 126        obj->cur->cache.clip.w, obj->cur->cache.clip.h
 127       );
 128    if (obj->cur->clipper) walk_clippers_print(spaces + 1, obj->cur->clipper);
 129 }
 130 #endif
 131
 132 static void
 133 clip_calc(Evas_Object_Protected_Data *obj, Eina_Rectangle *c)
 134 {
 135    if (!obj) return;
 136    RECTS_CLIP_TO_RECT(c->x, c->y, c->w, c->h,
 137                       obj->cur->geometry.x, obj->cur->geometry.y,
 138                       obj->cur->geometry.w, obj->cur->geometry.h);
 139    clip_calc(obj->cur->clipper, c);
 140 }
 141
 142 static Eina_List *
 143 _evas_event_object_list_raw_in_get_single(Evas *eo_e, Evas_Object_Protected_Data *obj, Eina_List *in, Evas_Object *stop,
 144                                           int x, int y, int *no_rep, Eina_Bool source, int spaces EINA_UNUSED)
 145 {
 146    Eina_Rectangle c;
 147    int inside;
 148    Evas_Object *eo_obj = obj->object;
 149    if (eo_obj == stop)
 150      {
 151         *no_rep = 1;
 152         DDD("***** NO REP - STOP *****\n");
 153         return in;
 154      }
 155
 156    //TIZEN_ONLY(20190708):evas_event: fix proxy event is not passed through
 157    if (evas_event_passes_through(eo_obj, obj)) return in;
 158    //
 159
 160    //TIZEN_ONLY(20230203):evas_event: only frame object is operated in frame area.
 161    int vx = 0, vy = 0, vw = 0, vh = 0;
 162    int fw = 0, fh = 0;
 163    evas_output_viewport_get(eo_e, &vx, &vy, &vw, &vh);
 164    evas_output_framespace_get(eo_e, NULL, NULL, &fw, &fh);
 165
 166    if ((!RECTS_INTERSECT(x, y, 1, 1, vx, vy, vw - fw, vh - fh)) && (!obj->is_frame)) return in;
 167    //
 168
 169    if ((!obj->cur->visible) && (!obj->is_event_parent)) return in;
 170    // XXX: this below DYNAMICALLY calculates the current clip rect
 171    // by walking clippers to each parent clipper until there are
 172    // no more of them. this is a necessary hack because cache.clip
 173    // cooreds are broken. somewhere along the way in the past few years
 174    // someone has forgotten to flag them as dirty and update them
 175    // so a clicp recalce caqn work... somewhere. maybe a prexy or map fix
 176    // or an optimization. finding this is really hard, so i'm going
 177    // for plan b and doing this on the fly. it's only for event or
 178    // callback handling so its a small percentage of the time, but
 179    // it's better that we get this right
 180
 181    if (EINA_UNLIKELY((!!obj->map) && (obj->map->cur.map)
 182                      && (obj->map->cur.usemap)))
 183      c = obj->map->cur.map->normal_geometry;
 184    else
 185      {
 186         if (obj->is_smart)
 187           {
 188              Eina_Rectangle bounding_box = { 0, };
 189
 190              evas_object_smart_bounding_box_update(obj);
 191              evas_object_smart_bounding_box_get(obj, &bounding_box, NULL);
 192              c = bounding_box;
 193           }
 194         else
 195           {
 196              if (obj->clip.clipees) return in;
 197              c = obj->cur->geometry;
 198           }
 199      }
 200    clip_calc(obj->cur->clipper, &c);
 201    // only worry about objects that intersect INCLUDING clippint
 202    if ((!RECTS_INTERSECT(x, y, 1, 1, c.x, c.y, c.w, c.h)) && (!obj->child_has_map))
 203      {
 204 #ifdef DDD_DO
 205         if (obj->is_smart)
 206           {
 207              Eina_Rectangle bounding_box = { 0, 0, 0, 0 };
 208
 209              evas_object_smart_bounding_box_get(obj, &bounding_box, NULL);
 210              DDD("___  %p g[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i] b[%6i %6i %6ix%6i] %s\n",
 211                  obj->object,
 212                  obj->cur->geometry.x, obj->cur->geometry.y,
 213                  obj->cur->geometry.w, obj->cur->geometry.h,
 214                  obj->cur->cache.clip.x, obj->cur->cache.clip.y,
 215                  obj->cur->cache.clip.w, obj->cur->cache.clip.h,
 216                  bounding_box.x, bounding_box.y,
 217                  bounding_box.w, bounding_box.h,
 218                  obj->type);
 219           }
 220         else
 221           {
 222              DDD("___  %p g[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i] %s\n",
 223                  obj->object,
 224                  obj->cur->geometry.x, obj->cur->geometry.y,
 225                  obj->cur->geometry.w, obj->cur->geometry.h,
 226                  obj->cur->cache.clip.x, obj->cur->cache.clip.y,
 227                  obj->cur->cache.clip.w, obj->cur->cache.clip.h,
 228                  obj->type);
 229           }
 230         if (!strcmp(obj->type, "e_layout"))
 231           {
 232              if (obj->cur->clipper)
 233                walk_clippers_print(spaces + 1, obj->cur->clipper);
 234           }
 235 #endif
 236         return in;
 237      }
 238 #ifdef DDD_DO
 239    else
 240      {
 241         if (obj->is_smart)
 242           {
 243              Eina_Rectangle bounding_box = { 0, 0, 0, 0 };
 244
 245              evas_object_smart_bounding_box_get(obj, &bounding_box, NULL);
 246              DDD("OBJ  %p g[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i] b[%6i %6i %6ix%6i] %s\n",
 247                  obj->object,
 248                  obj->cur->geometry.x, obj->cur->geometry.y,
 249                  obj->cur->geometry.w, obj->cur->geometry.h,
 250                  obj->cur->cache.clip.x, obj->cur->cache.clip.y,
 251                  obj->cur->cache.clip.w, obj->cur->cache.clip.h,
 252                  bounding_box.x, bounding_box.y,
 253                  bounding_box.w, bounding_box.h,
 254                  obj->type);
 255           }
 256         else
 257           {
 258              DDD("OBJ  %p g[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i] %s\n",
 259                  obj->object,
 260                  obj->cur->geometry.x, obj->cur->geometry.y,
 261                  obj->cur->geometry.w, obj->cur->geometry.h,
 262                  obj->cur->cache.clip.x, obj->cur->cache.clip.y,
 263                  obj->cur->cache.clip.w, obj->cur->cache.clip.h,
 264                  obj->type);
 265           }
 266 //             if (!strcmp(obj->type, "e_layout"))
 267           {
 268              if (obj->cur->clipper)
 269                walk_clippers_print(spaces + 1, obj->cur->clipper);
 270           }
 271      }
 272 #endif
 273
 274    if (!source)
 275      {
 276         if (evas_object_is_source_invisible(eo_obj, obj)) return in;
 277      }
 278    if ((obj->delete_me == 0) &&
 279        ((source) || ((obj->cur->visible || obj->is_event_parent) && (!obj->clip.clipees) &&
 280         (obj->is_event_parent || evas_object_clippers_is_visible(eo_obj, obj)))))
 281      {
 282         if (obj->is_smart)
 283           {
 284              DDD("CHILDREN ->\n");
 285              Evas_Object_Protected_Data *clip = obj->cur->clipper;
 286              int norep = 0;
 287
 288              if (clip && clip->mask->is_mask && clip->precise_is_inside)
 289                if (!evas_object_is_inside(clip->object, clip, x, y))
 290                  return in;
 291
 292              if ((obj->map->cur.usemap) && (obj->map->cur.map))
 293                {
 294                   inside = evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1);
 295                   if (inside)
 296                     {
 297                        if (!evas_map_coords_get(obj->map->cur.map, x, y,
 298                                                 &(obj->map->cur.map->mx),
 299                                                 &(obj->map->cur.map->my), 0))
 300                          {
 301                             inside = 0;
 302                          }
 303                        else
 304                          {
 305                             in = _evas_event_object_list_in_get
 306                                (eo_e, in,
 307                                 evas_object_smart_members_get_direct(eo_obj),
 308                                 NULL,
 309                                 stop,
 310                                 obj->cur->geometry.x + obj->map->cur.map->mx,
 311                                 obj->cur->geometry.y + obj->map->cur.map->my,
 312                                 &norep, source);
 313                          }
 314                     }
 315                }
 316              else
 317                {
 318                   Eina_Rectangle bounding_box = { 0, };
 319
 320                   if (!obj->child_has_map)
 321                     evas_object_smart_bounding_box_update(obj);
 322
 323                   evas_object_smart_bounding_box_get(obj, &bounding_box, NULL);
 324
 325                   if (obj->child_has_map ||
 326                       (bounding_box.x <= x &&
 327                        bounding_box.x + bounding_box.w >= x &&
 328                        bounding_box.y <= y &&
 329                        bounding_box.y + bounding_box.h >= y) ||
 330                       (obj->cur->geometry.x <= x &&
 331                        obj->cur->geometry.x + obj->cur->geometry.w >= x &&
 332                        obj->cur->geometry.y <= y &&
 333                        obj->cur->geometry.y + obj->cur->geometry.h >= y))
 334                     in = _evas_event_object_list_in_get
 335                       (eo_e, in, evas_object_smart_members_get_direct(eo_obj), NULL,
 336                        stop, x, y, &norep, source);
 337                }
 338              if (norep)
 339                {
 340                   if (!obj->repeat_events)
 341                     {
 342                        *no_rep = 1;
 343                        DDD("***** NO REP1 *****\n");
 344                        return in;
 345                     }
 346                }
 347           }
 348         else if (obj->is_event_parent)
 349           {
 350              int norep = 0;
 351              in = _evas_event_object_list_in_get(eo_e, in,
 352                NULL, evas_object_event_grabber_members_list(eo_obj),
 353                stop, x, y, &norep, source);
 354              if (norep)
 355                {
 356                   if (!obj->repeat_events)
 357                     {
 358                        *no_rep = 1;
 359                        DDD("***** NO REP1 *****\n");
 360                        return in;
 361                     }
 362                }
 363           }
 364         else
 365           {
 366              Evas_Object_Protected_Data *clip = obj->cur->clipper;
 367              if (clip && clip->mask->is_mask && clip->precise_is_inside)
 368                inside = evas_object_is_inside(clip->object, clip, x, y);
 369              else
 370                inside = evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1);
 371
 372              if (inside)
 373                {
 374                   if ((obj->map->cur.usemap) && (obj->map->cur.map))
 375                     {
 376                        if (!evas_map_coords_get(obj->map->cur.map, x, y,
 377                                                 &(obj->map->cur.map->mx),
 378                                                 &(obj->map->cur.map->my), 0))
 379                          {
 380                             inside = 0;
 381                          }
 382                     }
 383                }
 384              if (inside && ((!obj->precise_is_inside) ||
 385                             (evas_object_is_inside(eo_obj, obj, x, y))))
 386                {
 387                   if (!evas_event_freezes_through(eo_obj, obj))
 388                     {
 389                        DDD("----------------> ADD obj %p\n", obj->object);
 390                        in = eina_list_append(in, eo_obj);
 391                     }
 392                   if (!obj->repeat_events)
 393                     {
 394                        *no_rep = 1;
 395                        DDD("***** NO REP2 *****\n");
 396                        return in;
 397                     }
 398                }
 399           }
 400      }
 401    return in;
 402 }
 403
 404 static Eina_List *
 405 _evas_event_object_list_raw_in_get(Evas *eo_e, Eina_List *in,
 406                                    const Eina_Inlist *ilist,
 407                                    const Eina_List *list,
 408                                    Evas_Object *stop,
 409                                    int x, int y, int *no_rep, Eina_Bool source,
 410                                    Eina_Bool must_walk_last)
 411 {
 412    Evas_Object_Protected_Data *obj = NULL;
 413    DDD_STATIC int spaces = 0;
 414
 415    if ((!ilist) && (!list)) return in;
 416
 417    spaces++;
 418    if (ilist)
 419      {
 420         Eina_Inlist *last;
 421
 422         if (must_walk_last) last = eina_inlist_last(ilist);
 423         else last = ilist->last;
 424         for (obj = _EINA_INLIST_CONTAINER(obj, last);
 425              obj;
 426              obj = _EINA_INLIST_CONTAINER(obj, EINA_INLIST_GET(obj)->prev))
 427           {
 428              if (obj->events->parent) continue;
 429              in = _evas_event_object_list_raw_in_get_single(eo_e, obj, in, stop, x, y, no_rep, source, spaces);
 430              if (*no_rep) goto end;
 431           }
 432      }
 433    else
 434      {
 435         Eina_List *l;
 436
 437         EINA_LIST_REVERSE_FOREACH(list, l, obj)
 438           {
 439              in = _evas_event_object_list_raw_in_get_single(eo_e, obj, in, stop, x, y, no_rep, source, spaces);
 440              if (*no_rep) goto end;
 441           }
 442      }
 443    *no_rep = 0;
 444
 445 end:
 446    spaces--;
 447    return in;
 448 }
 449
 450 static void
 451 _transform_to_src_space_f(Evas_Object_Protected_Data *obj, Evas_Object_Protected_Data *src,
 452                           Eina_Vector2 *cur_pt, Eina_Vector2 *prev_pt)
 453 {
 454    double obj_w = obj->cur->geometry.w, obj_h = obj->cur->geometry.h;
 455    double src_w = src->cur->geometry.w, src_h = src->cur->geometry.h;
 456
 457    //Current Point
 458    cur_pt->x -= obj->cur->geometry.x;
 459    cur_pt->y -= obj->cur->geometry.y;
 460
 461    if (!EINA_DBL_EQ(obj_w, src_w)) cur_pt->x *= (src_w / obj_w);
 462    if (!EINA_DBL_EQ(obj_h, src_h)) cur_pt->y *= (src_h / obj_h);
 463
 464    cur_pt->x += src->cur->geometry.x;
 465    cur_pt->y += src->cur->geometry.y;
 466
 467    //Prev Point
 468    prev_pt->x -= obj->cur->geometry.x;
 469    prev_pt->y -= obj->cur->geometry.y;
 470
 471    if (!EINA_DBL_EQ(obj_w, src_w)) prev_pt->x *= (src_w / obj_w);
 472    if (!EINA_DBL_EQ(obj_h, src_h)) prev_pt->y *= (src_h / obj_h);
 473
 474    prev_pt->x += src->cur->geometry.x;
 475    prev_pt->y += src->cur->geometry.y;
 476 }
 477
 478 static Efl_Input_Device *
 479 _evas_event_legacy_device_get(Eo *evas, Eina_Bool mouse)
 480 {
 481    Efl_Input_Device *dev = _evas_device_top_get(evas);
 482    //The user did not push a device, use the default mouse/keyboard instead.
 483    if (!dev)
 484      {
 485         Evas_Public_Data *e = efl_data_scope_get(evas, EVAS_CANVAS_CLASS);
 486         //TIZEN_ONLY(20180530): add storing last mouse device.
 487         if (mouse)
 488           {
 489              if (e->last_mouse) return e->last_mouse;
 490              return e->default_mouse;
 491           }
 492         //
 493         return e->default_keyboard;
 494      }
 495    return dev;
 496 }
 497
 498 //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
 499 void
 500 _source_child_del_cb(void *data, const Efl_Event *event)
 501 {
 502    Eo *eo_src = data;
 503    Eo *obj = event->object;
 504    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
 505
 506    if (!src || src->delete_me) return;
 507
 508    EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
 509       proxy_write->src_event_in = eina_list_remove(proxy_write->src_event_in, obj);
 510    EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
 511 }
 512
 513 static void
 514 _source_child_callback_add(Evas_Object *eo_src)
 515 {
 516    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
 517    Evas_Object *eo_child;
 518    Eina_List *l;
 519
 520    EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
 521      {
 522         efl_event_callback_add(eo_child, EFL_EVENT_DEL, _source_child_del_cb, eo_src);
 523      }
 524 }
 525
 526 static void
 527 _source_child_callback_del(Evas_Object *eo_src)
 528 {
 529    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
 530    Evas_Object *eo_child;
 531    Eina_List *l;
 532
 533    EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
 534      {
 535         efl_event_callback_del(eo_child, EFL_EVENT_DEL, _source_child_del_cb, eo_src);
 536      }
 537 }
 538 //
 539
 540 static void
 541 _evas_event_source_mouse_down_events(Evas_Object *eo_obj, Evas *eo_e,
 542                                      Efl_Input_Pointer *parent_ev,
 543                                      Evas_Pointer_Data *pdata,
 544                                      int event_id)
 545 {
 546    Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
 547    Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
 548    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
 549    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
 550    Evas_Object_Protected_Data *child;
 551    Evas_Object *eo_child;
 552    Eina_List *copy, *l;
 553    Efl_Input_Pointer_Data *ev;
 554    Efl_Input_Pointer *evt;
 555    Eina_Vector2 cur_pt, prev_pt;
 556    int addgrab = 0;
 557    int no_rep = 0;
 558    int srcgrab = 0;
 559
 560    if (obj->delete_me || src->delete_me || e->is_frozen) return;
 561
 562    evt = efl_duplicate(parent_ev);
 563    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
 564    if (!ev) return;
 565
 566    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
 567
 568    cur_pt = ev->cur;
 569    prev_pt = ev->prev;
 570    ev->source = eo_obj;
 571    ev->touch_id = 0;
 572
 573    EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
 574      {
 575         Evas_Object_Pointer_Data *obj_pdata;
 576
 577         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
 578         obj_pdata = _evas_object_pointer_data_get(pdata, child);
 579         if (!obj_pdata)
 580           {
 581              ERR("Could not find the object pointer data for device %p",
 582                  ev->device);
 583              continue;
 584           }
 585         srcgrab += obj_pdata->mouse_grabbed;
 586      }
 587
 588    if (srcgrab == 0)
 589      {
 590         EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
 591           {
 592              if (proxy_write->src_event_in)
 593                {
 594                   //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
 595                   _source_child_callback_del(eo_src);
 596                   proxy_write->src_event_in = eina_list_free(proxy_write->src_event_in);
 597                   //
 598                }
 599
 600              if (src->is_smart)
 601                {
 602                   proxy_write->src_event_in = _evas_event_object_list_raw_in_get
 603                      (eo_e, proxy_write->src_event_in,
 604                       evas_object_smart_members_get_direct(eo_src), NULL,
 605                       NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
 606                }
 607              else if (src->is_event_parent)
 608                {
 609                   proxy_write->src_event_in = _evas_event_object_list_raw_in_get
 610                      (eo_e, proxy_write->src_event_in,
 611                       NULL, evas_object_event_grabber_members_list(eo_src),
 612                       NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
 613                }
 614              else
 615                proxy_write->src_event_in = eina_list_append(proxy_write->src_event_in, eo_src);
 616           }
 617         EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
 618
 619         //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
 620         _source_child_callback_add(eo_src);
 621         //
 622      }
 623
 624    if (pdata->seat->mouse_grabbed == 0)
 625      {
 626         if (pdata->seat->downs > 1) addgrab = pdata->seat->downs - 1;
 627      }
 628
 629    EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
 630      {
 631         Evas_Object_Pointer_Data *obj_pdata;
 632
 633         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
 634         obj_pdata = _evas_object_pointer_data_get(pdata, child);
 635         if (!obj_pdata)
 636           {
 637              ERR("Could not find the object pointer data for device %p",
 638                  ev->device);
 639              continue;
 640           }
 641         if ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
 642             (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN))
 643           {
 644              obj_pdata->mouse_grabbed += (addgrab + 1);
 645              pdata->seat->mouse_grabbed += (addgrab + 1);
 646              if (obj_pdata->pointer_mode ==
 647                  EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
 648                {
 649                   pdata->seat->nogrep++;
 650                   break;
 651                }
 652           }
 653      }
 654
 655    copy = evas_event_list_copy(src->proxy->src_event_in);
 656    EINA_LIST_FOREACH(copy, l, eo_child)
 657      {
 658         Evas_Object_Pointer_Data *obj_pdata;
 659         Evas_Object_Pointer_Mode pointer_mode;
 660
 661         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
 662         obj_pdata = _evas_object_pointer_data_get(pdata, child);
 663         if (!obj_pdata)
 664           {
 665              ERR("Could not find the object pointer data for device %p",
 666                  ev->device);
 667              continue;
 668           }
 669         pointer_mode = obj_pdata->pointer_mode;
 670
 671         ev->cur = cur_pt;
 672         ev->prev = prev_pt;
 673
 674         _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
 675
 676         evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_DOWN, evt,
 677                                         event_id, EFL_EVENT_POINTER_DOWN);
 678         if (e->delete_me) break;
 679         if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
 680           break;
 681      }
 682    eina_list_free(copy);
 683
 684    efl_unref(evt);
 685 }
 686
 687 static void
 688 _evas_event_mouse_in_set(Evas_Pointer_Seat *pseat,
 689                          Evas_Object_Protected_Data *obj, Eina_Bool mouse_in)
 690 {
 691    Evas_Pointer_Data *pdata;
 692    Evas_Object_Pointer_Data *obj_pdata;
 693
 694    if ((!pseat) || (!obj)) return;
 695
 696    EINA_INLIST_FOREACH(pseat->pointers, pdata)
 697      {
 698         obj_pdata = _evas_object_pointer_data_get(pdata, obj);
 699         if (obj_pdata)
 700           obj_pdata->mouse_in = mouse_in;
 701      }
 702 }
 703
 704 static void
 705 _evas_event_source_mouse_move_events(Evas_Object *eo_obj, Evas *eo_e,
 706                                      Efl_Input_Pointer *parent_ev,
 707                                      Evas_Pointer_Data *pdata,
 708                                      int event_id)
 709 {
 710    Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
 711    Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
 712    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
 713    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
 714    Evas_Object_Protected_Data *child;
 715    Evas_Object *eo_child;
 716    Eina_List *l;
 717    Efl_Input_Pointer_Data *ev;
 718    Efl_Input_Pointer *evt;
 719    Eina_Vector2 cur_pt_real, prev_pt_real, cur_pt, prev_pt;
 720    Evas_Object_Pointer_Data *obj_pdata;
 721
 722    if (obj->delete_me || src->delete_me || e->is_frozen) return;
 723
 724    evt = efl_duplicate(parent_ev);
 725    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
 726    if (!ev) return;
 727
 728    cur_pt_real = ev->cur;
 729    prev_pt_real = ev->prev;
 730
 731    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
 732
 733    cur_pt = ev->cur;
 734    prev_pt = ev->prev;
 735    ev->source = eo_obj;
 736    ev->touch_id = 0;
 737
 738    if (pdata->seat->mouse_grabbed)
 739      {
 740         Eina_List *outs = NULL;
 741         Eina_List *copy = evas_event_list_copy(src->proxy->src_event_in);
 742
 743         EINA_LIST_FOREACH(copy, l, eo_child)
 744           {
 745              child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
 746              //FIXME: When object is deleted in the src_event_in list,
 747              //the src_event_in list should be updated. But now there is no way.
 748              //So add checking NULL logic, please delete it if you make a better way.
 749              if (!child) continue;
 750
 751              obj_pdata = _evas_object_pointer_data_get(pdata, child);
 752              if (!obj_pdata)
 753                {
 754                   ERR("Could not find the object pointer data for device %p",
 755                       ev->device);
 756                   continue;
 757                }
 758
 759              if (_evas_event_object_pointer_allow(eo_child, child, obj_pdata))
 760                {
 761                   ev->cur = cur_pt;
 762                   ev->prev = prev_pt;
 763
 764                   _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
 765
 766                   ev->action = EFL_POINTER_ACTION_MOVE;
 767                   evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
 768                                                   event_id, EFL_EVENT_POINTER_MOVE);
 769                }
 770              else
 771                outs = eina_list_append(outs, eo_child);
 772              if (e->delete_me || e->is_frozen) break;
 773              //FIXME: take care nograb object
 774           }
 775         eina_list_free(copy);
 776
 777         EINA_LIST_FREE(outs, eo_child)
 778           {
 779              child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
 780              if (child->delete_me) continue;
 781              obj_pdata = _evas_object_pointer_data_get(pdata, child);
 782              if (!obj_pdata)
 783                {
 784                   ERR("Could not find the object pointer data for device %p",
 785                       ev->device);
 786                   continue;
 787                }
 788              if ((obj_pdata->mouse_grabbed == 0) && (!e->delete_me))
 789                {
 790                   if (obj_pdata->mouse_in) continue; /* FIXME: dubious logic! */
 791                   _evas_event_mouse_in_set(pdata->seat, child, 0);
 792                   if (e->is_frozen) continue;
 793
 794                   ev->cur = cur_pt_real;
 795                   ev->prev = prev_pt_real;
 796
 797                   _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
 798
 799                   //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
 800                   efl_event_callback_del(eo_child, EFL_EVENT_DEL, _source_child_del_cb, eo_src);
 801                   //
 802                   EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
 803                     proxy_write->src_event_in = eina_list_remove(proxy_write->src_event_in, eo_child);
 804                   EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
 805
 806                   ev->action = EFL_POINTER_ACTION_OUT;
 807                   evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_OUT, evt,
 808                                                   event_id, EFL_EVENT_POINTER_OUT);
 809                }
 810           }
 811      }
 812    else
 813      {
 814         Eina_List *ins = NULL;
 815         Eina_List *copy = evas_event_list_copy(src->proxy->src_event_in);
 816
 817         if (src->is_smart)
 818           {
 819              int no_rep = 0;
 820              ins = _evas_event_object_list_raw_in_get(eo_e, ins, evas_object_smart_members_get_direct(eo_src),
 821                                                       NULL, NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
 822           }
 823         else if (src->is_event_parent)
 824           {
 825              int no_rep = 0;
 826              ins = _evas_event_object_list_raw_in_get(eo_e, ins, NULL,
 827                                                       evas_object_event_grabber_members_list(eo_src),
 828                                                       NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
 829           }
 830         else
 831           ins = eina_list_append(ins, eo_src);
 832
 833         EINA_LIST_FOREACH(copy, l, eo_child)
 834           {
 835              child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
 836              //FIXME: When object is deleted in the src_event_in list,
 837              //the src_event_in list should be updated. But now there is no way.
 838              //So add checking NULL logic, please delete it if you make a better way.
 839              if (!child) continue;
 840
 841              obj_pdata = _evas_object_pointer_data_get(pdata, child);
 842              if (!obj_pdata)
 843                {
 844                   ERR("Could not find the object pointer data for device %p",
 845                       ev->device);
 846                   continue;
 847                }
 848              ev->cur = cur_pt;
 849              ev->prev = prev_pt;
 850
 851              _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
 852
 853              if (evas_object_is_in_output_rect(eo_child, child,
 854                                                ev->cur.x, ev->cur.y, 1, 1) &&
 855                 _evas_event_object_pointer_allow(eo_child, child, obj_pdata) &&
 856                 _evas_event_object_pointer_allow_precise(eo_child, child, ev->cur.x, ev->cur.y, ins))
 857                {
 858                   ev->action = EFL_POINTER_ACTION_MOVE;
 859                  evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
 860                                                   event_id, EFL_EVENT_POINTER_MOVE);
 861                }
 862              else if (obj_pdata->mouse_in)
 863                {
 864                   _evas_event_mouse_in_set(pdata->seat, child, 0);
 865                   if (e->is_frozen) continue;
 866                   ev->action = EFL_POINTER_ACTION_OUT;
 867                   evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_OUT, evt,
 868                                                   event_id, EFL_EVENT_POINTER_OUT);
 869                   if (e->delete_me) break;
 870
 871                }
 872              if (e->delete_me || e->is_frozen) break;
 873           }
 874         eina_list_free(copy);
 875
 876         int event_id2 = _evas_object_event_new();
 877         EINA_LIST_FOREACH(ins, l, eo_child)
 878           {
 879              child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
 880              obj_pdata = _evas_object_pointer_data_get(pdata, child);
 881              if (!obj_pdata)
 882                {
 883                   ERR("Could not find the object pointer data for device %p",
 884                       ev->device);
 885                   continue;
 886                }
 887               if (!eina_list_data_find(src->proxy->src_event_in, eo_child))
 888                 {
 889                    if (!obj_pdata->mouse_in)
 890                      {
 891                         _evas_event_mouse_in_set(pdata->seat, child, 1);
 892                         if (e->is_frozen) continue;
 893
 894                         ev->cur = cur_pt;
 895                         ev->prev = prev_pt;
 896
 897                         _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
 898
 899                         ev->action = EFL_POINTER_ACTION_IN;
 900                         evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_IN, evt,
 901                                                         event_id2, EFL_EVENT_POINTER_IN);
 902                         if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
 903                           {
 904                              ev->action = EFL_POINTER_ACTION_MOVE;
 905                              evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
 906                                                              event_id2, EFL_EVENT_POINTER_MOVE);
 907                           }
 908                         if (e->delete_me) break;
 909                      }
 910                 }
 911           }
 912
 913         if (pdata->seat->mouse_grabbed == 0)
 914           {
 915              //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
 916              _source_child_callback_del(eo_src);
 917              //
 918
 919              EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
 920                {
 921                   eina_list_free(proxy_write->src_event_in);
 922                   proxy_write->src_event_in = ins;
 923                }
 924              EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
 925
 926              //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
 927              _source_child_callback_add(eo_src);
 928              //
 929           }
 930         else
 931           {
 932              if (ins) eina_list_free(ins);
 933           }
 934      }
 935
 936    efl_unref(evt);
 937 }
 938
 939 static void
 940 _evas_event_source_mouse_up_events(Evas_Object *eo_obj, Evas *eo_e,
 941                                    Efl_Input_Pointer *parent_ev,
 942                                    Evas_Pointer_Data *pdata,
 943                                    int event_id, Eina_Bool cancel)
 944 {
 945    Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
 946    Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
 947    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
 948    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
 949    Evas_Object_Protected_Data *child;
 950    Evas_Object *eo_child;
 951    Eina_List *copy, *l;
 952    Efl_Input_Pointer_Data *ev;
 953    Efl_Input_Pointer *evt;
 954    Eina_Vector2 cur_pt, prev_pt;
 955
 956    if (obj->delete_me || src->delete_me || e->is_frozen) return;
 957
 958    evt = efl_duplicate(parent_ev);
 959    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
 960    if (!ev) return;
 961
 962    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
 963
 964    cur_pt = ev->cur;
 965    prev_pt = ev->prev;
 966    ev->source = eo_obj;
 967    ev->touch_id = 0;
 968
 969    copy = evas_event_list_copy(src->proxy->src_event_in);
 970    EINA_LIST_FOREACH(copy, l, eo_child)
 971      {
 972         Evas_Object_Pointer_Data *obj_pdata;
 973         Evas_Object_Pointer_Mode pointer_mode;
 974
 975         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
 976         obj_pdata = _evas_object_pointer_data_get(pdata, child);
 977         if (!obj_pdata)
 978           {
 979              ERR("Could not find the object pointer data for device %p",
 980                  ev->device);
 981              continue;
 982           }
 983         if ((!cancel) && ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
 984              (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
 985             (obj_pdata->mouse_grabbed > 0))
 986           {
 987              obj_pdata->mouse_grabbed--;
 988              pdata->seat->mouse_grabbed--;
 989           }
 990
 991         pointer_mode = obj_pdata->pointer_mode;
 992
 993         ev->cur = cur_pt;
 994         ev->prev = prev_pt;
 995
 996         _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
 997
 998         if (cancel)
 999           efl_event_callback_call(eo_child, EFL_EVENT_POINTER_CANCEL, evt);
1000         else
1001           evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_UP, evt,
1002                                           event_id, EFL_EVENT_POINTER_UP);
1003         if (e->delete_me) break;
1004         if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
1005           {
1006              if ((!cancel) && (pdata->seat->nogrep > 0)) pdata->seat->nogrep--;
1007              break;
1008           }
1009      }
1010    eina_list_free(copy);
1011
1012    efl_unref(evt);
1013 }
1014
1015 static void
1016 _evas_event_source_hold_events(Evas_Object *eo_obj, int event_id, Efl_Input_Hold *evt)
1017 {
1018    Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1019    Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
1020    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1021    Evas_Object_Protected_Data *child;
1022    Evas_Object *eo_child;
1023    Eina_List *l;
1024
1025    if (obj->layer->evas->is_frozen) return;
1026
1027    EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
1028      {
1029         if (src->delete_me) return;
1030         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1031         evas_object_event_callback_call(eo_child, child,
1032                                         EVAS_CALLBACK_HOLD, evt,
1033                                         event_id, EFL_EVENT_HOLD);
1034         if (src->layer->evas->delete_me) break;
1035      }
1036 }
1037
1038 static void
1039 _evas_event_source_wheel_events(Evas_Object *eo_obj, Evas *eo_e,
1040                                 Efl_Input_Pointer *parent_ev, int event_id)
1041 {
1042    Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1043    Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
1044    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1045    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1046    Evas_Object_Protected_Data *child;
1047    Evas_Object *eo_child;
1048    Eina_List *copy, *l;
1049    Efl_Input_Pointer_Data *ev;
1050    Efl_Input_Pointer *evt;
1051    Eina_Vector2 cur_pt, prev_pt;
1052    Evas_Pointer_Data *pdata;
1053
1054    if (obj->delete_me || src->delete_me || obj->layer->evas->is_frozen) return;
1055
1056    evt = efl_duplicate(parent_ev);
1057    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1058    if (!ev) return;
1059
1060    pdata = _evas_pointer_data_by_device_get(e, ev->device);
1061    if (!pdata) return;
1062
1063    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1064
1065    cur_pt = ev->cur;
1066    prev_pt = ev->prev;
1067    ev->source = eo_obj;
1068
1069    copy = evas_event_list_copy(src->proxy->src_event_in);
1070    EINA_LIST_FOREACH(copy, l, eo_child)
1071      {
1072         Evas_Object_Pointer_Data *obj_pdata;
1073
1074         if (src->delete_me) return;
1075         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1076         //FIXME: When object is deleted in the src_event_in list,
1077         //the src_event_in list should be updated. But now there is no way.
1078         //So add checking NULL logic, please delete it if you make a better way.
1079         if (!child) continue;
1080
1081         obj_pdata = _evas_object_pointer_data_get(pdata, child);
1082         if (!obj_pdata)
1083           {
1084              ERR("Could not find the object pointer data for device %p",
1085                  ev->device);
1086              continue;
1087           }
1088         ev->cur = cur_pt;
1089         ev->prev = prev_pt;
1090         _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1091
1092         evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_WHEEL, evt,
1093                                         event_id, EFL_EVENT_POINTER_WHEEL);
1094         if (e->delete_me) break;
1095      }
1096    eina_list_free(copy);
1097
1098    efl_unref(evt);
1099 }
1100
1101 static void
1102 _evas_event_source_multi_down_events(Evas_Object_Protected_Data *obj, Evas_Public_Data *e,
1103                                      Efl_Input_Pointer *parent_ev, Evas_Pointer_Data *pdata,
1104                                      int event_id)
1105 {
1106    Evas_Object *eo_src = _evas_object_image_source_get(obj->object);
1107    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1108    Evas_Object_Protected_Data *child;
1109    Evas_Object *eo_child;
1110    Eina_List *copy, *l;
1111    Efl_Input_Pointer_Data *ev;
1112    Efl_Input_Pointer *evt;
1113    Eina_Vector2 cur_pt, prev_pt;
1114    Evas_Object_Pointer_Data *obj_pdata;
1115    int addgrab = 0;
1116
1117    if (obj->delete_me || src->delete_me || obj->layer->evas->is_frozen) return;
1118
1119    evt = efl_duplicate(parent_ev);
1120    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1121    if (!ev) return;
1122
1123    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1124
1125    cur_pt = ev->cur;
1126    prev_pt = ev->prev;
1127    ev->source = obj->object;
1128    ev->action = EFL_POINTER_ACTION_DOWN;
1129
1130    if (pdata->seat->mouse_grabbed == 0)
1131      {
1132         if (pdata->seat->downs > 1)
1133           addgrab = pdata->seat->downs - 1;
1134         else  /* this is the first touch, which means it's also a move event, which means we need to redo this */
1135           {
1136              Eina_List *ins = NULL;
1137
1138              if (src->is_smart)
1139                {
1140                   int no_rep = 0;
1141                   ins = _evas_event_object_list_raw_in_get
1142                         (e->evas, ins, evas_object_smart_members_get_direct(eo_src), NULL, NULL,
1143                          ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1144                }
1145              if (src->is_event_parent)
1146                {
1147                   int no_rep = 0;
1148                   ins = _evas_event_object_list_raw_in_get
1149                         (e->evas, ins, NULL, evas_object_event_grabber_members_list(eo_src), NULL,
1150                          ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1151                }
1152              else
1153                ins = eina_list_append(ins, eo_src);
1154              EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
1155                {
1156                   eina_list_free(proxy_write->src_event_in);
1157                   proxy_write->src_event_in = ins;
1158                }
1159              EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
1160           }
1161      }
1162
1163    EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
1164      {
1165         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1166         obj_pdata = _evas_object_pointer_data_get(pdata, child);
1167         if (!obj_pdata)
1168           {
1169              ERR("Could not find the object pointer data for device %p",
1170                  ev->device);
1171              continue;
1172           }
1173         if (obj_pdata->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB)
1174           {
1175              obj_pdata->mouse_grabbed += (addgrab + 1);
1176              pdata->seat->mouse_grabbed += (addgrab + 1);
1177           }
1178      }
1179
1180    copy = evas_event_list_copy(src->proxy->src_event_in);
1181    EINA_LIST_FOREACH(copy, l, eo_child)
1182      {
1183         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1184         obj_pdata = _evas_object_pointer_data_get(pdata, child);
1185         if (!obj_pdata)
1186           {
1187              ERR("Could not find the object pointer data for device %p",
1188                  ev->device);
1189              continue;
1190           }
1191         ev->cur = cur_pt;
1192         ev->prev = prev_pt;
1193
1194         _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1195
1196         evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_DOWN, evt,
1197                                         event_id, EFL_EVENT_FINGER_DOWN);
1198         if (e->delete_me) break;
1199      }
1200    eina_list_free(copy);
1201
1202    efl_unref(evt);
1203 }
1204
1205 static void
1206 _evas_event_source_multi_up_events(Evas_Object_Protected_Data *obj, Evas_Public_Data *e,
1207                                    Efl_Input_Pointer *parent_ev, Evas_Pointer_Data *pdata,
1208                                    int event_id)
1209 {
1210    Evas_Object *eo_src = _evas_object_image_source_get(obj->object);
1211    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1212    Evas_Object_Protected_Data *child;
1213    Evas_Object *eo_child;
1214    Eina_List *copy, *l;
1215    Efl_Input_Pointer_Data *ev;
1216    Efl_Input_Pointer *evt;
1217    Eina_Vector2 cur_pt, prev_pt;
1218
1219    if (obj->delete_me || src->delete_me || obj->layer->evas->is_frozen) return;
1220
1221    evt = efl_duplicate(parent_ev);
1222    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1223    if (!ev) return;
1224
1225    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1226
1227    cur_pt = ev->cur;
1228    prev_pt = ev->prev;
1229
1230    ev->source = obj->object;
1231    ev->action = EFL_POINTER_ACTION_UP;
1232
1233    copy = evas_event_list_copy(src->proxy->src_event_in);
1234    EINA_LIST_FOREACH(copy, l, eo_child)
1235      {
1236         Evas_Object_Pointer_Data *obj_pdata;
1237
1238         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1239
1240         obj_pdata = _evas_object_pointer_data_get(pdata, child);
1241         if (!obj_pdata)
1242           {
1243              ERR("Could not find the object pointer data for device %p",
1244                  ev->device);
1245              continue;
1246           }
1247
1248         if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
1249              (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
1250             (obj_pdata->mouse_grabbed > 0))
1251           {
1252              obj_pdata->mouse_grabbed--;
1253              pdata->seat->mouse_grabbed--;
1254           }
1255         ev->cur = cur_pt;
1256         ev->prev = prev_pt;
1257         _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1258
1259         evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_UP, evt,
1260                                         event_id, EFL_EVENT_FINGER_UP);
1261         if (e->delete_me || e->is_frozen) break;
1262      }
1263     eina_list_free(copy);
1264
1265     efl_unref(evt);
1266 }
1267
1268 static void
1269 _evas_event_source_multi_move_events(Evas_Object_Protected_Data *obj, Evas_Public_Data *e,
1270                                      Efl_Input_Pointer *parent_ev, Evas_Pointer_Data *pdata,
1271                                      int event_id)
1272 {
1273    Evas_Object *eo_src = _evas_object_image_source_get(obj->object);
1274    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1275    Evas_Object_Protected_Data *child;
1276    Evas_Object *eo_child;
1277    Eina_List *copy, *l;
1278    Efl_Input_Pointer_Data *ev;
1279    Efl_Input_Pointer *evt;
1280    Eina_Vector2 cur_pt, prev_pt;
1281    Evas_Object_Pointer_Data *obj_pdata;
1282    Evas *eo_e = e->evas;
1283
1284    if (obj->delete_me || src->delete_me || e->is_frozen) return;
1285
1286    evt = efl_duplicate(parent_ev);
1287    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1288    if (!ev) return;
1289
1290    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1291
1292    cur_pt = ev->cur;
1293    prev_pt = ev->prev;
1294    ev->source = obj->object;
1295    ev->action = EFL_POINTER_ACTION_UP;
1296
1297    /* Why a new event id here? Other 'source' events keep the same id. */
1298    event_id = _evas_object_event_new();
1299
1300    if (pdata->seat->mouse_grabbed > 0)
1301      {
1302         copy = evas_event_list_copy(src->proxy->src_event_in);
1303         EINA_LIST_FOREACH(copy, l, eo_child)
1304           {
1305              child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1306              obj_pdata = _evas_object_pointer_data_get(pdata, child);
1307              if (!obj_pdata)
1308                {
1309                   ERR("Could not find the object pointer data for device %p",
1310                       ev->device);
1311                   continue;
1312                }
1313              if (_evas_event_object_pointer_allow(eo_child, child, obj_pdata))
1314                {
1315                   ev->cur = cur_pt;
1316                   ev->prev = prev_pt;
1317                   _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1318
1319                   evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
1320                                                   event_id, EFL_EVENT_FINGER_MOVE);
1321                   if (e->delete_me || e->is_frozen) break;
1322                }
1323           }
1324         eina_list_free(copy);
1325      }
1326    else
1327      {
1328         Eina_List *ins = NULL;
1329
1330         if (src->is_smart)
1331           {
1332              int no_rep = 0;
1333              ins = _evas_event_object_list_raw_in_get
1334                    (eo_e, ins, evas_object_smart_members_get_direct(eo_src), NULL, NULL,
1335                     ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1336           }
1337         if (src->is_event_parent)
1338           {
1339              int no_rep = 0;
1340              ins = _evas_event_object_list_raw_in_get
1341                    (eo_e, ins, NULL, evas_object_event_grabber_members_list(eo_src), NULL,
1342                     ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1343           }
1344         else
1345           ins = eina_list_append(ins, eo_src);
1346
1347         copy = evas_event_list_copy(src->proxy->src_event_in);
1348         EINA_LIST_FOREACH(copy, l, eo_child)
1349           {
1350              child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1351              obj_pdata = _evas_object_pointer_data_get(pdata, child);
1352              if (!obj_pdata)
1353                {
1354                   ERR("Could not find the object pointer data for device %p",
1355                       ev->device);
1356                   continue;
1357                }
1358
1359              ev->cur = cur_pt;
1360              ev->prev = prev_pt;
1361              _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1362
1363              if (evas_object_is_in_output_rect(eo_child, child, ev->cur.x, ev->cur.y, 1, 1) &&
1364                 _evas_event_object_pointer_allow(eo_child, child, obj_pdata) &&
1365                 _evas_event_object_pointer_allow_precise(eo_child, child, ev->cur.x, ev->cur.y, ins))
1366                {
1367                   evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
1368                                                   event_id, EFL_EVENT_FINGER_MOVE);
1369                   if (e->delete_me || e->is_frozen) break;
1370                }
1371           }
1372         eina_list_free(copy);
1373         if (pdata->seat->mouse_grabbed == 0)
1374           {
1375              //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
1376              _source_child_callback_del(eo_src);
1377              //
1378
1379              EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
1380                {
1381                   eina_list_free(proxy_write->src_event_in);
1382                   proxy_write->src_event_in = ins;
1383                }
1384              EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
1385
1386              //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
1387              _source_child_callback_add(eo_src);
1388              //
1389           }
1390         else
1391           eina_list_free(ins);
1392      }
1393
1394    efl_unref(evt);
1395 }
1396
1397 static void
1398 _evas_event_source_mouse_in_events(Evas_Object *eo_obj, Evas *eo_e,
1399                                    Efl_Input_Pointer *parent_ev, int event_id)
1400 {
1401    Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1402    Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
1403    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1404    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1405    Evas_Object_Protected_Data *child;
1406    Evas_Object *eo_child;
1407    Eina_List *ins = NULL, *l;
1408    Efl_Input_Pointer_Data *ev;
1409    Efl_Input_Pointer *evt;
1410    Eina_Vector2 cur_pt, prev_pt;
1411    Evas_Pointer_Data *pdata;
1412
1413    if (obj->delete_me || src->delete_me || e->is_frozen) return;
1414    evt = efl_duplicate(parent_ev);
1415
1416    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1417    if (!ev) return;
1418
1419    pdata = _evas_pointer_data_by_device_get(e, ev->device);
1420    if (!pdata) return;
1421
1422    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1423
1424    cur_pt = ev->cur;
1425    prev_pt = ev->prev;
1426    ev->source = eo_obj;
1427    ev->action = EFL_POINTER_ACTION_IN;
1428
1429    if (src->is_smart)
1430      {
1431         int no_rep = 0;
1432         ins = _evas_event_object_list_raw_in_get(eo_e, ins, evas_object_smart_members_get_direct(eo_src),
1433                                                  NULL, NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1434
1435      }
1436    else if (src->is_event_parent)
1437      {
1438         int no_rep = 0;
1439         ins = _evas_event_object_list_raw_in_get(eo_e, ins, NULL, evas_object_event_grabber_members_list(eo_src),
1440                                                  NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1441
1442      }
1443    else
1444      ins = eina_list_append(ins, eo_src);
1445
1446    EINA_LIST_FOREACH(ins, l, eo_child)
1447      {
1448         Evas_Object_Pointer_Data *obj_pdata;
1449
1450         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1451         obj_pdata = _evas_object_pointer_data_get(pdata, child);
1452         if (!obj_pdata)
1453           {
1454              ERR("Could not find the object pointer data for device %p",
1455                  ev->device);
1456              continue;
1457           }
1458
1459         if (!eina_list_data_find(src->proxy->src_event_in, eo_child))
1460           {
1461              if (obj_pdata->mouse_in) continue;
1462              _evas_event_mouse_in_set(pdata->seat, child, 1);
1463
1464              ev->cur = cur_pt;
1465              ev->prev = prev_pt;
1466              _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1467
1468              ev->action = EFL_POINTER_ACTION_IN;
1469              evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_IN, evt,
1470                                              event_id, EFL_EVENT_POINTER_IN);
1471              if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
1472                {
1473                   ev->action = EFL_POINTER_ACTION_MOVE;
1474                   evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
1475                                                   event_id, EFL_EVENT_POINTER_MOVE);
1476                }
1477              if (e->delete_me || e->is_frozen) break;
1478           }
1479      }
1480
1481    //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
1482    _source_child_callback_del(eo_src);
1483    //
1484
1485    EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
1486      {
1487        eina_list_free(proxy_write->src_event_in);
1488        proxy_write->src_event_in = ins;
1489      }
1490    EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
1491
1492    //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
1493    _source_child_callback_add(eo_src);
1494    //
1495
1496    efl_unref(evt);
1497 }
1498
1499 static void
1500 _evas_event_source_mouse_out_events(Evas_Object *eo_obj, Evas *eo_e,
1501                                     Efl_Input_Pointer *parent_ev, int event_id)
1502 {
1503    Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1504    Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
1505    Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1506    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1507    Evas_Object_Protected_Data *child;
1508    Evas_Object *eo_child;
1509    Eina_List *copy, *l;
1510    Efl_Input_Pointer_Data *ev;
1511    Efl_Input_Pointer *evt;
1512    Eina_Vector2 cur_pt, prev_pt;
1513    Evas_Pointer_Data *pdata;
1514
1515    if (obj->delete_me || src->delete_me || e->is_frozen) return;
1516
1517    evt = efl_duplicate(parent_ev);
1518    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1519    if (!ev) return;
1520
1521    pdata = _evas_pointer_data_by_device_get(e, ev->device);
1522    if (!pdata) return;
1523
1524    _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1525
1526    cur_pt = ev->cur;
1527    prev_pt = ev->prev;
1528    ev->source = eo_obj;
1529    ev->action = EFL_POINTER_ACTION_OUT;
1530
1531    copy = evas_event_list_copy(src->proxy->src_event_in);
1532    EINA_LIST_FOREACH(copy, l, eo_child)
1533      {
1534         Evas_Object_Pointer_Data *obj_pdata;
1535         child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1536         obj_pdata = _evas_object_pointer_data_get(pdata, child);
1537         if (!obj_pdata)
1538           {
1539              ERR("Could not find the object pointer data for device %p",
1540                  ev->device);
1541              continue;
1542           }
1543
1544         if (!obj_pdata->mouse_in) continue;
1545         _evas_event_mouse_in_set(pdata->seat, child, 0);
1546         if (child->delete_me) continue;
1547
1548         ev->cur = cur_pt;
1549         ev->prev = prev_pt;
1550         _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1551
1552         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
1553                                         event_id, EFL_EVENT_POINTER_OUT);
1554         if (e->is_frozen) continue;
1555      }
1556    eina_list_free(copy);
1557
1558    //TIZEN_ONLY(20200213): remove child object from list when child is deleted.
1559    _source_child_callback_del(eo_src);
1560    //
1561
1562    EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
1563      proxy_write->src_event_in = eina_list_free(proxy_write->src_event_in);
1564    EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
1565
1566    efl_unref(evt);
1567 }
1568
1569 static Eina_List *
1570 _evas_event_object_list_in_get(Evas *eo_e, Eina_List *in,
1571                                const Eina_Inlist *ilist,
1572                                const Eina_List *list,
1573                                Evas_Object *stop,
1574                                int x, int y, int *no_rep, Eina_Bool source)
1575 {
1576    return _evas_event_object_list_raw_in_get(eo_e, in, ilist, list, stop, x, y,
1577                                              no_rep, source, EINA_FALSE);
1578 }
1579
1580 static Eina_List *
1581 _evas_event_objects_event_list_no_frozen_check(Evas *eo_e, Evas_Object *stop, int x, int y)
1582 {
1583    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1584    Evas_Layer *lay;
1585    Eina_List *in = NULL;
1586
1587    if (!e->layers) return NULL;
1588
1589    D("@@@@@ layer count = %i\n", eina_inlist_count(EINA_INLIST_GET(e->layers)));
1590    EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay)
1591      {
1592         int no_rep = 0;
1593         D("############################# check layer %i\n", lay->layer);
1594         in = _evas_event_object_list_in_get(eo_e, in,
1595                                             EINA_INLIST_GET(lay->objects), NULL,
1596                                             stop, x, y, &no_rep, EINA_FALSE);
1597         if (no_rep) return in;
1598      }
1599    return in;
1600 }
1601
1602 EOLIAN Eina_List*
1603 _evas_canvas_tree_objects_at_xy_get(Eo *eo_e, Evas_Public_Data *e EINA_UNUSED, Evas_Object *stop, int x, int y)
1604 {
1605    return _evas_event_objects_event_list_no_frozen_check(eo_e, stop, x, y);
1606 }
1607
1608 Eina_List *
1609 evas_event_objects_event_list(Evas *eo_e, Evas_Object *stop, int x, int y)
1610 {
1611    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1612
1613    if ((!e->layers) || (e->is_frozen)) return NULL;
1614    D("------------------------------GET EVETNS AT ............... %i %i\n", x, y);
1615    return _evas_event_objects_event_list_no_frozen_check(eo_e, stop, x, y);
1616 }
1617
1618 static Eina_List *
1619 evas_event_list_copy(Eina_List *list)
1620 {
1621    Eina_List *l, *new_l = NULL;
1622    const void *data;
1623
1624    EINA_LIST_FOREACH(list, l, data)
1625      new_l = eina_list_append(new_l, data);
1626    return new_l;
1627 }
1628 /* public functions */
1629
1630 EOLIAN void
1631 _evas_canvas_event_default_flags_set(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Evas_Event_Flags flags)
1632 {
1633    e->default_event_flags = flags;
1634 }
1635
1636 EOLIAN Evas_Event_Flags
1637 _evas_canvas_event_default_flags_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e)
1638 {
1639    return e->default_event_flags;
1640 }
1641
1642 static inline void
1643 _canvas_event_thaw_eval_internal(Eo *eo_e, Evas_Public_Data *e)
1644 {
1645    Evas_Pointer_Data *pdata = _evas_pointer_data_by_device_get(e, NULL);
1646    if (!pdata) return;
1647    _canvas_event_feed_mouse_move_legacy(eo_e, e, pdata->seat->x, pdata->seat->y,
1648                                         e->last_timestamp, NULL);
1649 }
1650
1651 EAPI void
1652 evas_event_freeze(Evas *eo_e)
1653 {
1654    efl_event_freeze(eo_e);
1655 }
1656
1657 EAPI void
1658 evas_event_thaw(Evas *eo_e)
1659 {
1660    efl_event_thaw(eo_e);
1661 }
1662
1663 EOLIAN void
1664 _evas_canvas_efl_object_event_freeze(Eo *eo_e, Evas_Public_Data *e)
1665 {
1666    efl_event_freeze(efl_super(eo_e, EVAS_CANVAS_CLASS));
1667    e->is_frozen = EINA_TRUE;
1668 }
1669
1670 EOLIAN void
1671 _evas_canvas_efl_object_event_thaw(Eo *eo_e, Evas_Public_Data *e)
1672 {
1673    int fcount = -1;
1674    efl_event_thaw(efl_super(eo_e, EVAS_CANVAS_CLASS));
1675    fcount = efl_event_freeze_count_get(efl_super(eo_e, EVAS_CANVAS_CLASS));
1676    if (0 == fcount)
1677      {
1678         Evas_Layer *lay;
1679
1680         e->is_frozen = EINA_FALSE;
1681         EINA_INLIST_FOREACH((EINA_INLIST_GET(e->layers)), lay)
1682           {
1683              Evas_Object_Protected_Data *obj;
1684
1685              EINA_INLIST_FOREACH(lay->objects, obj)
1686                {
1687                   evas_object_clip_recalc(obj);
1688                   evas_object_recalc_clippees(obj);
1689                }
1690           }
1691
1692         _canvas_event_thaw_eval_internal(eo_e, e);
1693      }
1694 }
1695
1696 EAPI int
1697 evas_event_freeze_get(const Evas *eo_e)
1698 {
1699    return efl_event_freeze_count_get(eo_e);
1700 }
1701
1702 EAPI void
1703 evas_event_thaw_eval(Evas *eo_e)
1704 {
1705    if (!evas_event_freeze_get(eo_e))
1706      {
1707         EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
1708         Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1709         _canvas_event_thaw_eval_internal(eo_e, e);
1710      }
1711 }
1712
1713 static void
1714 _canvas_event_feed_mouse_down_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
1715 {
1716    Efl_Input_Pointer *evt;
1717    Eina_List *l, *copy;
1718    Evas_Object *eo_obj;
1719    int event_id, b;
1720    Evas *eo_e;
1721    int addgrab = 0;
1722    Evas_Pointer_Data *pdata;
1723    Evas_Object_Pointer_Data *obj_pdata;
1724
1725    static const int value_flags =
1726          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
1727          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
1728          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
1729          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID) |
1730          _efl_input_value_mask(EFL_INPUT_VALUE_BUTTON);
1731
1732    if (!e || !ev) return;
1733    EVAS_EVENT_FEED_SAFETY_CHECK(e);
1734
1735    pdata = _evas_pointer_data_by_device_get(e, ev->device);
1736    if (!pdata) return;
1737
1738    b = ev->button;
1739    DBG("ButtonEvent:down time=%u button=%d downs=%d",
1740        ev->timestamp, b, pdata->seat->downs);
1741    if ((b < 1) || (b > 32)) return;
1742
1743    pdata->button |= (1u << (b - 1));
1744    pdata->seat->downs++;
1745
1746    if (e->is_frozen) return;
1747    e->last_timestamp = ev->timestamp;
1748    eo_e = e->evas;
1749    evt = ev->eo;
1750
1751    event_id = _evas_object_event_new();
1752
1753    ev->cur.x = pdata->seat->x;
1754    ev->cur.y = pdata->seat->y;
1755    ev->modifiers = &(e->modifiers);
1756    ev->locks = &(e->locks);
1757    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
1758    ev->touch_id = 0;
1759    ev->action = EFL_POINTER_ACTION_DOWN;
1760    ev->value_flags |= value_flags;
1761    if (ev->device) efl_ref(ev->device);
1762
1763    _evas_walk(e);
1764    /* append new touch point to the touch point list */
1765    _evas_touch_point_append(e->evas, 0, pdata->seat->x, pdata->seat->y);
1766    /* If this is the first finger down, i.e no other fingers pressed,
1767     * get a new event list, otherwise, keep the current grabbed list. */
1768    if (pdata->seat->mouse_grabbed == 0)
1769      {
1770         Eina_List *ins = evas_event_objects_event_list(eo_e,
1771                                                        NULL,
1772                                                        pdata->seat->x,
1773                                                        pdata->seat->y);
1774         /* free our old list of ins */
1775         eina_list_free(pdata->seat->object.in);
1776         /* and set up the new one */
1777         pdata->seat->object.in = ins;
1778         /* adjust grabbed count by the nuymber of currently held down
1779          * fingers/buttons */
1780         if (pdata->seat->downs > 1) addgrab = pdata->seat->downs - 1;
1781      }
1782    copy = evas_event_list_copy(pdata->seat->object.in);
1783    EINA_LIST_FOREACH(copy, l, eo_obj)
1784      {
1785         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1786         obj_pdata = _evas_object_pointer_data_get(pdata, obj);
1787         if (!obj_pdata)
1788           {
1789              ERR("Could not find the object pointer data for device %p",
1790                  ev->device);
1791              continue;
1792           }
1793
1794         if ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
1795             (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN))
1796           {
1797              obj_pdata->mouse_grabbed += addgrab + 1;
1798              pdata->seat->mouse_grabbed += addgrab + 1;
1799              if (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
1800                {
1801                   pdata->seat->nogrep++;
1802                   break;
1803                }
1804           }
1805      }
1806    EINA_LIST_FOREACH(copy, l, eo_obj)
1807      {
1808         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1809         Evas_Object_Pointer_Mode pointer_mode;
1810         if (obj->delete_me) continue;
1811         obj_pdata = _evas_object_pointer_data_get(pdata, obj);
1812         if (!obj_pdata)
1813           {
1814              ERR("Could not find the object pointer data for device %p",
1815                  ev->device);
1816              continue;
1817           }
1818         pointer_mode = obj_pdata->pointer_mode;
1819
1820         ev->cur.x = pdata->seat->x;
1821         ev->cur.y = pdata->seat->y;
1822         ev->prev.x = pdata->seat->prev.x;
1823         ev->prev.y = pdata->seat->prev.y;
1824         _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1825
1826         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_DOWN, evt,
1827                                         event_id, EFL_EVENT_POINTER_DOWN);
1828         if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
1829           _evas_event_source_mouse_down_events(eo_obj, eo_e, evt, pdata, event_id);
1830         if (e->is_frozen || e->delete_me)  break;
1831         if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
1832           break;
1833      }
1834    if (copy) eina_list_free(copy);
1835    e->last_mouse_down_counter++;
1836    _evas_post_event_callback_call(eo_e, e, event_id);
1837    /* update touch point's state to EVAS_TOUCH_POINT_STILL */
1838    _evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_STILL);
1839    _evas_unwalk(e);
1840
1841    if (ev->device) efl_unref(ev->device);
1842 }
1843
1844 static void
1845 _post_up_handle(Evas_Public_Data *e, Efl_Input_Pointer *parent_ev,
1846                 Evas_Pointer_Data *pdata)
1847 {
1848    Eina_List *l, *copy, *ins, *ll;
1849    Efl_Input_Pointer_Data *ev;
1850    Efl_Input_Pointer *evt;
1851    Evas_Object *eo_obj;
1852    Evas *eo_e = e->evas;
1853    Evas_Object_Pointer_Data *obj_pdata;
1854    int event_id;
1855
1856    /* Duplicating UP event */
1857    evt = efl_duplicate(parent_ev);
1858    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1859    if (!ev) return;
1860
1861    event_id = _evas_object_event_new();
1862
1863    /* Actually we want an OUT */
1864    ev->action = EFL_POINTER_ACTION_OUT;
1865
1866    /* get new list of ins */
1867    ins = evas_event_objects_event_list(eo_e, NULL, pdata->seat->x, pdata->seat->y);
1868    /* go thru old list of in objects */
1869    copy = evas_event_list_copy(pdata->seat->object.in);
1870    EINA_LIST_FOREACH(copy, ll, eo_obj)
1871      {
1872         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1873         if ((!eina_list_data_find(ins, eo_obj)) || (!pdata->seat->inside))
1874           {
1875              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
1876              if (!obj_pdata)
1877                {
1878                   ERR("Could not find the object pointer data for device %p",
1879                       ev->device);
1880                   continue;
1881                }
1882              if (!obj_pdata->mouse_in) continue;
1883              _evas_event_mouse_in_set(pdata->seat, obj, 0);
1884              if (!e->is_frozen)
1885                {
1886                   ev->cur.x = pdata->seat->x;
1887                   ev->cur.y = pdata->seat->y;
1888                   ev->prev.x = pdata->seat->prev.x;
1889                   ev->prev.y = pdata->seat->prev.y;
1890
1891                   _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1892
1893                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
1894                                                   event_id, EFL_EVENT_POINTER_OUT);
1895                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
1896                     _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
1897                   if (e->delete_me) break;
1898                }
1899           }
1900      }
1901    _evas_post_event_callback_call(eo_e, e, event_id);
1902
1903    eina_list_free(copy);
1904
1905    if (pdata->seat->inside)
1906      {
1907         Evas_Object *eo_obj_itr;
1908
1909         event_id = _evas_object_event_new();
1910         ev->action = EFL_POINTER_ACTION_IN;
1911
1912         EINA_LIST_FOREACH(ins, l, eo_obj_itr)
1913           {
1914              Evas_Object_Protected_Data *obj_itr = efl_data_scope_get(eo_obj_itr, EFL_CANVAS_OBJECT_CLASS);
1915              if (!eina_list_data_find(pdata->seat->object.in, eo_obj_itr))
1916                {
1917                   obj_pdata = _evas_object_pointer_data_get(pdata, obj_itr);
1918                   if (!obj_pdata)
1919                     {
1920                        ERR("Could not find the object pointer data for device %p",
1921                            ev->device);
1922                        continue;
1923                     }
1924                   if (obj_pdata->mouse_in) continue;
1925                   _evas_event_mouse_in_set(pdata->seat, obj_itr, 1);
1926                   if (e->is_frozen) continue;
1927
1928                   ev->cur.x = pdata->seat->x;
1929                   ev->cur.y = pdata->seat->y;
1930                   ev->prev.x = pdata->seat->prev.x;
1931                   ev->prev.y = pdata->seat->prev.y;
1932
1933                   _evas_event_havemap_adjust_f(obj_itr, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1934
1935                   ev->action = EFL_POINTER_ACTION_IN;
1936                   evas_object_event_callback_call(eo_obj_itr, obj_itr, EVAS_CALLBACK_MOUSE_IN, evt,
1937                                                   event_id, EFL_EVENT_POINTER_IN);
1938                   if ((pdata->seat->x != pdata->seat->prev.x) && (pdata->seat->y != pdata->seat->prev.y))
1939                     {
1940                        ev->action = EFL_POINTER_ACTION_MOVE;
1941                        evas_object_event_callback_call(eo_obj_itr, obj_itr, EVAS_CALLBACK_MOUSE_MOVE, evt,
1942                                                        event_id, EFL_EVENT_POINTER_MOVE);
1943                     }
1944                   if ((obj_itr->proxy->is_proxy) &&
1945                       (obj_itr->proxy->src_events))
1946                     _evas_event_source_mouse_in_events(eo_obj_itr, eo_e, evt, event_id);
1947                   if (e->delete_me) break;
1948                }
1949           }
1950         _evas_post_event_callback_call(eo_e, e, event_id);
1951      }
1952    else
1953      {
1954         ins = eina_list_free(ins);
1955      }
1956
1957    if (pdata->seat->mouse_grabbed == 0)
1958      {
1959         /* free our old list of ins */
1960         eina_list_free(pdata->seat->object.in);
1961         /* and set up the new one */
1962         pdata->seat->object.in = ins;
1963      }
1964    else
1965      {
1966         /* free our cur ins */
1967         eina_list_free(ins);
1968      }
1969    if (pdata->seat->inside)
1970      _evas_canvas_event_pointer_move_event_dispatch(e, pdata, ev->data);
1971
1972    efl_unref(evt);
1973 }
1974
1975 static void
1976 _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
1977 {
1978    Efl_Input_Pointer *evt;
1979    Eina_List *l, *copy;
1980    Evas_Object *eo_obj;
1981    int event_id = 0, b;
1982    Evas *eo_e;
1983    Evas_Pointer_Data *pdata;
1984    Eina_Bool cancel;
1985
1986    static const int value_flags =
1987          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
1988          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
1989          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
1990          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID) |
1991          _efl_input_value_mask(EFL_INPUT_VALUE_BUTTON);
1992
1993    if (!e || !ev) return;
1994    EVAS_EVENT_FEED_SAFETY_CHECK(e);
1995
1996    pdata = _evas_pointer_data_by_device_get(e, ev->device);
1997    if (!pdata) return;
1998
1999    b = ev->button;
2000    cancel = ev->action == EFL_POINTER_ACTION_CANCEL;
2001    if (cancel)
2002      DBG("ButtonEvent:cancel time=%u button=%d downs=%d",
2003          ev->timestamp, b, pdata->seat->downs);
2004    else
2005      DBG("ButtonEvent:up time=%u button=%d downs=%d",
2006          ev->timestamp, b, pdata->seat->downs);
2007    if ((b < 1) || (b > 32)) return;
2008    if (pdata->seat->downs <= 0) return;
2009
2010    if (!cancel)
2011      {
2012         pdata->button &= ~(1u << (b - 1));
2013         pdata->seat->downs--;
2014      }
2015
2016    if (e->is_frozen) return;
2017    e->last_timestamp = ev->timestamp;
2018    eo_e = e->evas;
2019    evt = ev->eo;
2020
2021    if (!cancel)
2022      event_id = _evas_object_event_new();
2023
2024    ev->cur.x = pdata->seat->x;
2025    ev->cur.y = pdata->seat->y;
2026    ev->modifiers = &(e->modifiers);
2027    ev->locks = &(e->locks);
2028    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
2029    ev->touch_id = 0;
2030    ev->value_flags |= value_flags;
2031    if (ev->device) efl_ref(ev->device);
2032
2033    _evas_walk(e);
2034    if (!cancel)
2035      /* update released touch point */
2036      _evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_UP);
2037    copy = evas_event_list_copy(pdata->seat->object.in);
2038    EINA_LIST_FOREACH(copy, l, eo_obj)
2039      {
2040         Evas_Object_Pointer_Mode pointer_mode;
2041         Evas_Object_Pointer_Data *obj_pdata;
2042         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2043
2044         if (obj->delete_me) continue;
2045         obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2046         if (!obj_pdata)
2047           {
2048              ERR("Could not find the object pointer data for device %p",
2049                  ev->device);
2050              continue;
2051           }
2052         if ((!cancel) && ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
2053              (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
2054             (obj_pdata->mouse_grabbed > 0))
2055           {
2056              obj_pdata->mouse_grabbed--;
2057              pdata->seat->mouse_grabbed--;
2058           }
2059         pointer_mode = obj_pdata->pointer_mode;
2060         if ((!e->is_frozen) &&
2061             (!evas_event_freezes_through(eo_obj, obj)))
2062           {
2063              ev->cur.x = pdata->seat->x;
2064              ev->cur.y = pdata->seat->y;
2065              ev->prev.x = pdata->seat->prev.x;
2066              ev->prev.y = pdata->seat->prev.y;
2067
2068              _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2069
2070              if (cancel)
2071                efl_event_callback_call(eo_obj, EFL_EVENT_POINTER_CANCEL, evt);
2072              else
2073                evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_UP, evt,
2074                                                event_id, EFL_EVENT_POINTER_UP);
2075              if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2076                _evas_event_source_mouse_up_events(eo_obj, eo_e, evt, pdata, event_id, cancel);
2077              if (e->delete_me) break;
2078           }
2079         else if (evas_event_freezes_through(eo_obj, obj) &&
2080                  (obj->proxy->is_proxy) && (obj->proxy->src_events))
2081           {
2082              Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
2083              Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
2084              Evas_Object_Protected_Data *child;
2085              Evas_Object *eo_child;
2086              Eina_List *copy_events;
2087
2088              if (src->delete_me) continue;
2089              copy_events = evas_event_list_copy(src->proxy->src_event_in);
2090              EINA_LIST_FREE(copy_events, eo_child)
2091                {
2092                   Evas_Object_Pointer_Data *obj_pdata;
2093
2094                   child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
2095                   obj_pdata = _evas_object_pointer_data_get(pdata, child);
2096                   if (!obj_pdata)
2097                     {
2098                        ERR("Could not find the object pointer data for device %p",
2099                            ev->device);
2100                        continue;
2101                     }
2102                   if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
2103                        (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
2104                       (obj_pdata->mouse_grabbed > 0))
2105                     {
2106                        obj_pdata->mouse_grabbed--;
2107                        pdata->seat->mouse_grabbed--;
2108                     }
2109                 }
2110           }
2111         if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
2112           {
2113              if ((!cancel) && (pdata->seat->nogrep > 0)) pdata->seat->nogrep--;
2114              break;
2115           }
2116      }
2117    eina_list_free(copy);
2118    if (!cancel)
2119      {
2120         e->last_mouse_up_counter++;
2121         _evas_post_event_callback_call(eo_e, e, event_id);
2122
2123         if (pdata->seat->mouse_grabbed == 0)
2124           _post_up_handle(e, evt, pdata);
2125
2126         if (pdata->seat->mouse_grabbed < 0)
2127           {
2128              ERR("BUG? pdata->seat->mouse_grabbed (=%d) < 0!",
2129                  pdata->seat->mouse_grabbed);
2130           }
2131      }
2132    /* remove released touch point from the touch point list */
2133    _evas_touch_point_remove(eo_e, 0);
2134    _evas_unwalk(e);
2135
2136    if (ev->device) efl_unref(ev->device);
2137 }
2138
2139 static void
2140 _canvas_event_feed_mouse_updown(Eo *eo_e, int b, Evas_Button_Flags flags,
2141                                 unsigned int timestamp, const void *data,
2142                                 Eina_Bool down, Efl_Input_Device *device, Eina_Bool cancel)
2143 {
2144    Efl_Input_Pointer_Data *ev = NULL;
2145    Efl_Input_Pointer *evt;
2146    Evas_Public_Data *e;
2147
2148    e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2149    if (!e) return;
2150    EVAS_EVENT_FEED_SAFETY_CHECK(e);
2151
2152    evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
2153    if (!ev) return;
2154
2155    ev->data = (void *) data;
2156    ev->timestamp = timestamp;
2157    ev->device = efl_ref(device ? device : _evas_event_legacy_device_get(eo_e, EINA_TRUE));
2158    if (cancel)
2159      ev->action = EFL_POINTER_ACTION_CANCEL;
2160    else
2161      ev->action = down ? EFL_POINTER_ACTION_DOWN : EFL_POINTER_ACTION_UP;
2162    ev->button = b;
2163    ev->button_flags = (Efl_Pointer_Flags)flags;
2164    ev->radius = 1;
2165    ev->radius_x = 1;
2166    ev->radius_y = 1;
2167    ev->pressure = 1;
2168    ev->angle = 0;
2169    //ev->window_pos = ?;
2170    //ev->fake = 1;
2171
2172    /* first, send the cancel action through to trigger POINTER_CANCEL on all
2173     * relevant objects.
2174     * this does not change canvas state in any way.
2175     * note that the 'down' branch can only occur if 'cancel' is not true
2176     */
2177    if (down)
2178      _canvas_event_feed_mouse_down_internal(e, ev);
2179    else
2180      _canvas_event_feed_mouse_up_internal(e, ev);
2181
2182    efl_unref(evt);
2183
2184    /* next, emit actual up event and perform state changes */
2185    if (cancel)
2186      _canvas_event_feed_mouse_updown(eo_e, b, flags, timestamp, data, down, device, EINA_FALSE);
2187 }
2188
2189 static void
2190 _canvas_event_feed_mouse_updown_legacy(Eo *eo_e, int b, Evas_Button_Flags flags,
2191                                        unsigned int timestamp, const void *data,
2192                                        Eina_Bool down)
2193 {
2194    _canvas_event_feed_mouse_updown(eo_e, b, flags, timestamp, data, down, NULL, EINA_FALSE);
2195 }
2196
2197 EAPI void
2198 evas_event_feed_mouse_down(Eo *eo_e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
2199 {
2200    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2201    _canvas_event_feed_mouse_updown_legacy(eo_e, b, flags, timestamp, data, 1);
2202 }
2203
2204 EAPI void
2205 evas_event_feed_mouse_up(Eo *eo_e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
2206 {
2207    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2208    _canvas_event_feed_mouse_updown_legacy(eo_e, b, flags, timestamp, data, 0);
2209 }
2210
2211 // TIZEN_ONLY(20160429): add multi_info(radius, pressure and angle) to Evas_Event_Mouse_XXX
2212 static void
2213 _canvas_event_feed_mouse_updown_with_multi_info(Eo *eo_e, int b, Evas_Button_Flags flags,
2214                                 unsigned int timestamp, const void *data,
2215                                 Eina_Bool down, Efl_Input_Device *device,
2216                                 double radius, double radius_x, double radius_y,
2217                                 double pressure, double angle)
2218 {
2219    Efl_Input_Pointer_Data *ev = NULL;
2220    Efl_Input_Pointer *evt;
2221    Evas_Public_Data *e;
2222
2223    e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2224    if (!e) return;
2225    EVAS_EVENT_FEED_SAFETY_CHECK(e);
2226
2227    evt = efl_input_pointer_instance_get(eo_e, (void **) &ev);
2228    if (!ev) return;
2229
2230    ev->data = (void *) data;
2231    ev->timestamp = timestamp;
2232    ev->device = efl_ref(device ? device : _evas_event_legacy_device_get(eo_e, EINA_TRUE));
2233    ev->action = down ? EFL_POINTER_ACTION_DOWN : EFL_POINTER_ACTION_UP;
2234    ev->button = b;
2235    ev->button_flags = flags;
2236    ev->radius = radius;
2237    ev->radius_x = radius_x;
2238    ev->radius_y = radius_y;
2239    ev->pressure = pressure;
2240    ev->angle = angle;
2241    //ev->window_pos = ?;
2242    //ev->fake = 1;
2243
2244    if (down)
2245      _canvas_event_feed_mouse_down_internal(e, ev);
2246    else
2247      _canvas_event_feed_mouse_up_internal(e, ev);
2248
2249    efl_unref(evt);
2250 }
2251
2252 static void
2253 _canvas_event_feed_mouse_updown_with_multi_info_legacy(Eo *eo_e, int b, Evas_Button_Flags flags,
2254                                        unsigned int timestamp, const void *data,
2255                                        Eina_Bool down,
2256                                        double radius, double radius_x, double radius_y,
2257                                        double pressure, double angle)
2258 {
2259    _canvas_event_feed_mouse_updown_with_multi_info(eo_e, b, flags, timestamp, data, down, NULL, radius, radius_x, radius_y, pressure, angle);
2260 }
2261
2262 EAPI void
2263 evas_event_feed_mouse_down_with_multi_info(Eo *eo_e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data, double radius, double radius_x, double radius_y, double pressure, double angle)
2264 {
2265    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2266    _canvas_event_feed_mouse_updown_with_multi_info_legacy(eo_e, b, flags, timestamp, data, 1, radius, radius_x, radius_y, pressure, angle);
2267 }
2268
2269 EAPI void
2270 evas_event_feed_mouse_up_with_multi_info(Eo *eo_e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data, double radius, double radius_x, double radius_y, double pressure, double angle)
2271 {
2272    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2273    _canvas_event_feed_mouse_updown_with_multi_info_legacy(eo_e, b, flags, timestamp, data, 0, radius, radius_x, radius_y, pressure, angle);
2274 }
2275 //
2276
2277 static void
2278 _canvas_event_feed_mouse_cancel_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
2279 {
2280    Evas_Coord_Touch_Point *point;
2281    Efl_Input_Pointer_Data save;
2282    Eina_List *l, *ll;
2283    Evas_Event_Flags flags;
2284    Evas *eo_e;
2285    int i;
2286    Evas_Pointer_Data *pdata;
2287
2288    static const int value_flags =
2289          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
2290          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
2291          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
2292          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
2293
2294    if (!e || !ev) return;
2295    if (e->is_frozen) return;
2296    EVAS_EVENT_FEED_SAFETY_CHECK(e);
2297
2298    pdata = _evas_pointer_data_by_device_get(e, ev->device);
2299    if (!pdata) return;
2300
2301    save = *ev;
2302    eo_e = e->evas;
2303    _evas_walk(e);
2304
2305    flags = evas_event_default_flags_get(eo_e);
2306    evas_event_default_flags_set(eo_e, (flags | EVAS_EVENT_FLAG_ON_HOLD));
2307
2308    for (i = 0; i < 32; i++)
2309      {
2310         if ((pdata->button & (1u << i)))
2311           _canvas_event_feed_mouse_updown(eo_e, i + 1, 0, ev->timestamp, ev->data, 0, ev->device, EINA_TRUE);
2312      }
2313
2314    ev->action = EFL_POINTER_ACTION_CANCEL;
2315    ev->value_flags |= value_flags;
2316    ev->event_flags = (Efl_Input_Flags)flags;
2317    EINA_LIST_FOREACH_SAFE(e->touch_points, l, ll, point)
2318      {
2319         if ((point->state == EVAS_TOUCH_POINT_DOWN) ||
2320             (point->state == EVAS_TOUCH_POINT_MOVE) ||
2321             (point->state == EVAS_TOUCH_POINT_STILL))
2322           {
2323              ev->touch_id = point->id;
2324              ev->cur.x = point->x;
2325              ev->cur.y = point->y;
2326              ev->prev = ev->cur;
2327              _canvas_event_feed_multi_up_internal(e, ev);
2328           }
2329      }
2330    evas_event_default_flags_set(eo_e, flags);
2331    _evas_unwalk(e);
2332
2333    *ev = save;
2334 }
2335
2336 EAPI void
2337 evas_event_feed_mouse_cancel(Eo *eo_e, unsigned int timestamp, const void *data)
2338 {
2339    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2340    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2341    Efl_Input_Pointer_Data *ev = NULL;
2342    Efl_Input_Pointer *evt;
2343
2344    evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
2345    if (!ev) return;
2346    EVAS_EVENT_FEED_SAFETY_CHECK(e);
2347
2348    ev->timestamp = timestamp;
2349    ev->data = (void *) data;
2350    ev->device = efl_ref(_evas_event_legacy_device_get(e->evas, EINA_TRUE));
2351
2352    _canvas_event_feed_mouse_cancel_internal(e, ev);
2353
2354    efl_unref(evt);
2355 }
2356
2357 static void
2358 _canvas_event_feed_mouse_wheel_internal(Eo *eo_e, Efl_Input_Pointer_Data *pe)
2359 {
2360    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2361    Efl_Input_Pointer_Data *ev = NULL;
2362    Efl_Input_Pointer *evt;
2363    Eina_List *l, *copy;
2364    Evas_Object *eo_obj;
2365    int event_id = 0;
2366    Evas_Pointer_Data *pdata;
2367
2368    static const int value_flags =
2369          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
2370          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
2371          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
2372          _efl_input_value_mask(EFL_INPUT_VALUE_WHEEL_DELTA) |
2373          _efl_input_value_mask(EFL_INPUT_VALUE_WHEEL_HORIZONTAL);
2374
2375    if (e->is_frozen) return;
2376    EVAS_EVENT_FEED_SAFETY_CHECK(e);
2377
2378    pdata = _evas_pointer_data_by_device_get(e, pe->device);
2379    if (!pdata) return;
2380    e->last_timestamp = pe->timestamp;
2381
2382    event_id = _evas_object_event_new();
2383
2384    evt = efl_duplicate(pe->eo);
2385    ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
2386    if (!ev) return;
2387
2388    // adjust missing data based on evas state
2389    ev->cur.x = pdata->seat->x;
2390    ev->cur.y = pdata->seat->y;
2391    ev->modifiers = &(e->modifiers);
2392    ev->locks = &(e->locks);
2393    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
2394    ev->action = EFL_POINTER_ACTION_WHEEL;
2395    ev->value_flags |= value_flags;
2396
2397    _evas_walk(e);
2398    copy = evas_event_list_copy(pdata->seat->object.in);
2399
2400    EINA_LIST_FOREACH(copy, l, eo_obj)
2401      {
2402         Evas_Object_Pointer_Data *obj_pdata;
2403         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2404         if (!evas_event_freezes_through(eo_obj, obj))
2405           {
2406              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2407              if (!obj_pdata)
2408                {
2409                   ERR("Could not find the object pointer data for device %p",
2410                       ev->device);
2411                   continue;
2412                }
2413              ev->cur.x = pdata->seat->x;
2414              ev->cur.y = pdata->seat->y;
2415              ev->prev.x = pdata->seat->prev.x;
2416              ev->prev.y = pdata->seat->prev.y;
2417
2418              _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2419
2420              evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_WHEEL, evt,
2421                                              event_id, EFL_EVENT_POINTER_WHEEL);
2422              if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2423                _evas_event_source_wheel_events(eo_obj, eo_e, evt, event_id);
2424              if (e->delete_me || e->is_frozen) break;
2425           }
2426      }
2427    eina_list_free(copy);
2428    _evas_post_event_callback_call(eo_e, e, event_id);
2429
2430    efl_unref(evt);
2431    _evas_unwalk(e);
2432 }
2433
2434 EAPI void
2435 evas_event_feed_mouse_wheel(Eo *eo_e, int direction, int z, unsigned int timestamp, const void *data)
2436 {
2437    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2438    Efl_Input_Pointer_Data *ev = NULL;
2439    Efl_Input_Pointer *evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
2440
2441    if (!ev) return;
2442
2443    ev->wheel.horizontal = !!direction;
2444    ev->wheel.z = z;
2445    ev->timestamp = timestamp;
2446    ev->data = (void *) data;
2447    ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
2448
2449    _canvas_event_feed_mouse_wheel_internal(eo_e, ev);
2450    efl_unref(evt);
2451 }
2452
2453 static void
2454 _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
2455 {
2456    Evas_Object *nogrep_obj = NULL;
2457    Evas_Object_Protected_Data *obj;
2458    Efl_Input_Pointer *evt;
2459    Eina_List *l, *copy;
2460    Evas_Object *eo_obj;
2461    Eina_Vector2 cur_pt, prev_pt;
2462    Evas *eo_e;
2463    int event_id;
2464    Evas_Pointer_Data *pdata;
2465    //TIZEN_ONLY(20200213): add checking mouse grab count
2466    Evas_Object_Pointer_Data *obj_pdata, *obj_pdata2;
2467    //
2468
2469    // inform which values are valid
2470    static const int value_flags =
2471          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
2472          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
2473          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
2474          _efl_input_value_mask(EFL_INPUT_VALUE_PREVIOUS_X) |
2475          _efl_input_value_mask(EFL_INPUT_VALUE_PREVIOUS_Y) |
2476          _efl_input_value_mask(EFL_INPUT_VALUE_DX) |
2477          _efl_input_value_mask(EFL_INPUT_VALUE_DY) |
2478          _efl_input_value_mask(EFL_INPUT_VALUE_BUTTONS_PRESSED) |
2479          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
2480
2481    if (!e || !ev) return;
2482    if (e->is_frozen) return;
2483    EVAS_EVENT_FEED_SAFETY_CHECK(e);
2484
2485    if (ev->device)
2486      {
2487         pdata = _evas_pointer_data_by_device_get(e, ev->device);
2488         if (!pdata) return;
2489      }
2490    else
2491      {
2492         Evas_Pointer_Seat *pseat;
2493         if (!e->seats) return;
2494         pseat = EINA_INLIST_CONTAINER_GET(e->seats, Evas_Pointer_Seat);
2495         pseat->inside = 1;
2496         e->last_timestamp = ev->timestamp;
2497         pseat->prev.x = pseat->x;
2498         pseat->prev.y = pseat->y;
2499
2500         // new pos
2501         pseat->x = ev->cur.x;
2502         pseat->y = ev->cur.y;
2503         return;
2504      }
2505
2506    eo_e = e->evas;
2507    e->last_timestamp = ev->timestamp;
2508
2509    ev->prev.x = pdata->seat->x;
2510    ev->prev.y = pdata->seat->y;
2511
2512    // prev pos
2513    prev_pt.x = pdata->seat->prev.x = ev->prev.x;
2514    prev_pt.y = pdata->seat->prev.y = ev->prev.y;
2515
2516    // new pos
2517    cur_pt.x = pdata->seat->x = ev->cur.x;
2518    cur_pt.y = pdata->seat->y = ev->cur.y;
2519
2520    if ((!pdata->seat->inside) && (pdata->seat->mouse_grabbed == 0)) return;
2521
2522    evt = ev->eo;
2523    ev->modifiers = &(e->modifiers);
2524    ev->locks = &(e->locks);
2525    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
2526    ev->pressed_buttons = pdata->button;
2527    ev->touch_id = 0;
2528    ev->value_flags |= value_flags;
2529    if (ev->device) efl_ref(ev->device);
2530
2531    _evas_walk(e);
2532    /* update moved touch point */
2533    if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2534      _evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_MOVE);
2535    /* if our mouse button is grabbed to any objects */
2536    if (pdata->seat->mouse_grabbed > 0)
2537      {
2538         Eina_List *outs = NULL;
2539
2540         /* Send normal mouse move events */
2541         ev->action = EFL_POINTER_ACTION_MOVE;
2542
2543         event_id = _evas_object_event_new();
2544
2545         /* go thru old list of in objects */
2546         copy = evas_event_list_copy(pdata->seat->object.in);
2547         EINA_LIST_FOREACH(copy, l, eo_obj)
2548           {
2549              Eina_Bool check_nogrep = EINA_FALSE;
2550
2551              obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2552              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2553              if (!obj_pdata)
2554                {
2555                   ERR("Could not find the object pointer data for device %p",
2556                       ev->device);
2557                   continue;
2558                }
2559              if ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) &&
2560                  (pdata->seat->nogrep > 0))
2561                check_nogrep = EINA_TRUE;
2562              if ((!e->is_frozen) &&
2563                  _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
2564                  (!evas_object_is_source_invisible(eo_obj, obj) ||
2565                   obj_pdata->mouse_grabbed))
2566                {
2567                   ev->cur = cur_pt;
2568                   ev->prev = prev_pt;
2569
2570                   if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2571                     {
2572                        _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2573
2574                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2575                                                        event_id, EFL_EVENT_POINTER_MOVE);
2576                        if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2577                          _evas_event_source_mouse_move_events(eo_obj, eo_e, evt, pdata, event_id);
2578                     }
2579                }
2580              else
2581                 outs = eina_list_append(outs, eo_obj);
2582              if (check_nogrep)
2583                {
2584                   eina_list_free(copy);
2585                   eina_list_free(outs);
2586                   nogrep_obj = eo_obj;
2587                   goto nogrep;
2588                }
2589              if (e->delete_me) break;
2590           }
2591         eina_list_free(copy);
2592         _evas_post_event_callback_call(eo_e, e, event_id);
2593
2594
2595         /* Send mouse out events */
2596         ev->action = EFL_POINTER_ACTION_OUT;
2597
2598         event_id = _evas_object_event_new();
2599
2600         //TIZEN_ONLY(20200213): add checking mouse grab count
2601         Eina_Bool mouse_grabbed = EINA_FALSE;
2602         //
2603         EINA_LIST_FREE(outs, eo_obj)
2604           {
2605              obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2606              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2607              if (!obj_pdata)
2608                {
2609                   ERR("Could not find the object pointer data for device %p",
2610                       ev->device);
2611                   continue;
2612                }
2613              //TIZEN_ONLY(20200213): add checking mouse grab count
2614              mouse_grabbed = EINA_FALSE;
2615              EINA_INLIST_FOREACH(obj->events->pointer_grabs, obj_pdata2)
2616                {
2617                   if (obj_pdata2->mouse_grabbed > 0)
2618                     {
2619                        mouse_grabbed = EINA_TRUE;
2620                        break;
2621                     }
2622                }
2623              //
2624              if ((!mouse_grabbed) && (!e->delete_me))
2625                {
2626                   if (!obj_pdata->mouse_in) continue;
2627                   _evas_event_mouse_in_set(pdata->seat, obj, 0);
2628                   if (obj->delete_me || e->is_frozen) continue;
2629                   pdata->seat->object.in = eina_list_remove(pdata->seat->object.in, eo_obj);
2630
2631                   ev->cur = cur_pt;
2632                   ev->prev = prev_pt;
2633
2634                   _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2635
2636                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
2637                                                   event_id, EFL_EVENT_POINTER_OUT);
2638                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2639                     _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
2640                }
2641           }
2642         _evas_post_event_callback_call(eo_e, e, event_id);
2643      }
2644    else
2645      {
2646         Eina_List *ins;
2647
2648         event_id = _evas_object_event_new();
2649
2650         /* get all new in objects */
2651         ins = evas_event_objects_event_list(eo_e, NULL, cur_pt.x, cur_pt.y);
2652         /* go thru old list of in objects */
2653         copy = evas_event_list_copy(pdata->seat->object.in);
2654         EINA_LIST_FOREACH(copy, l, eo_obj)
2655           {
2656              obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2657              if (!obj) continue;
2658              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2659              if (!obj_pdata)
2660                {
2661                   ERR("Could not find the object pointer data for device %p",
2662                       ev->device);
2663                   continue;
2664                }
2665
2666              /* if its under the pointer and its visible and its in the new */
2667              /* in list */
2668              // FIXME: i don't think we need this
2669              //      evas_object_clip_recalc(eo_obj);
2670
2671              ev->cur = cur_pt;
2672              ev->prev = prev_pt;
2673
2674              _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2675
2676              if ((!e->is_frozen) &&
2677                  (evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1)) &&
2678                  _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
2679                  _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, ins) &&
2680                  (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
2681                {
2682                   if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2683                     {
2684                        ev->action = EFL_POINTER_ACTION_MOVE;
2685                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2686                                                        event_id, EFL_EVENT_POINTER_MOVE);
2687                        if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2688                          _evas_event_source_mouse_move_events(eo_obj, eo_e, evt, pdata, event_id);
2689                     }
2690                }
2691              /* otherwise it has left the object */
2692              else if (obj_pdata->mouse_in)
2693                {
2694                   _evas_event_mouse_in_set(pdata->seat, obj, 0);
2695                   if (e->is_frozen) continue;
2696                   ev->action = EFL_POINTER_ACTION_OUT;
2697                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
2698                                                   event_id, EFL_EVENT_POINTER_OUT);
2699                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2700                     _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
2701                   if (e->delete_me) break;
2702                }
2703           }
2704         eina_list_free(copy);
2705         _evas_post_event_callback_call(eo_e, e, event_id);
2706
2707         /* new event id for mouse in */
2708         event_id = _evas_object_event_new();
2709
2710         /* go thru our current list of ins */
2711         EINA_LIST_FOREACH(ins, l, eo_obj)
2712           {
2713              obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2714              /* if its not in the old list of ins send an enter event */
2715              if (!eina_list_data_find(pdata->seat->object.in, eo_obj))
2716                {
2717                   obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2718                   if (!obj_pdata)
2719                     {
2720                        ERR("Could not find the object pointer data for device %p",
2721                            ev->device);
2722                        continue;
2723                     }
2724                   if (!obj_pdata->mouse_in)
2725                     {
2726                        _evas_event_mouse_in_set(pdata->seat, obj, 1);
2727                        if (e->is_frozen) continue;
2728
2729                        ev->cur = cur_pt;
2730                        ev->prev = prev_pt;
2731
2732                        _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2733
2734                        ev->action = EFL_POINTER_ACTION_IN;
2735                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
2736                                                        event_id, EFL_EVENT_POINTER_IN);
2737                        if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2738                           {
2739                              ev->action = EFL_POINTER_ACTION_MOVE;
2740                              evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2741                                                              event_id, EFL_EVENT_POINTER_MOVE);
2742                           }
2743                        if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2744                          _evas_event_source_mouse_in_events(eo_obj, eo_e, evt, event_id);
2745
2746                        if (e->delete_me) break;
2747                     }
2748                }
2749           }
2750         if (pdata->seat->mouse_grabbed == 0)
2751           {
2752              /* free our old list of ins */
2753              eina_list_free(pdata->seat->object.in);
2754              /* and set up the new one */
2755              pdata->seat->object.in = ins;
2756           }
2757         else
2758           {
2759              /* free our cur ins */
2760              eina_list_free(ins);
2761           }
2762         _evas_post_event_callback_call(eo_e, e, event_id);
2763      }
2764
2765 nogrep:
2766    if (nogrep_obj)
2767      {
2768         Eina_List *ins = NULL, *newin = NULL, *lst = NULL;
2769         Evas_Object *eo_below_obj;
2770
2771         event_id = _evas_object_event_new();
2772
2773         /* go thru old list of in objects */
2774         copy = evas_event_list_copy(pdata->seat->object.in);
2775         EINA_LIST_FOREACH(copy, l, eo_obj)
2776           {
2777              if (eo_obj == nogrep_obj)
2778                {
2779                   lst = l->next;
2780                   break;
2781                }
2782           }
2783
2784         /* get all new in objects */
2785         eo_below_obj = evas_object_below_get(nogrep_obj);
2786         if (eo_below_obj)
2787           {
2788              Evas_Object_Protected_Data *below_obj = efl_data_scope_get(eo_below_obj, EFL_CANVAS_OBJECT_CLASS);
2789              int norep = 0;
2790              ins = _evas_event_object_list_raw_in_get(eo_e, NULL,
2791                                                       EINA_INLIST_GET(below_obj), NULL, NULL,
2792                                                       pdata->seat->x, pdata->seat->y,
2793                                                       &norep, EINA_FALSE, EINA_TRUE);
2794           }
2795
2796         EINA_LIST_FOREACH(copy, l, eo_obj)
2797           {
2798              newin = eina_list_append(newin, eo_obj);
2799              if (eo_obj == nogrep_obj) break;
2800           }
2801
2802         // NOTE: was foreach + append without free (smelled bad)
2803         newin = eina_list_merge(newin, ins);
2804         EINA_LIST_FOREACH(lst, l, eo_obj)
2805           {
2806              obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2807              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2808              if (!obj_pdata)
2809                {
2810                   ERR("Could not find the object pointer data for device %p",
2811                       ev->device);
2812                   continue;
2813                }
2814              /* if its under the pointer and its visible and its in the new */
2815              /* in list */
2816              // FIXME: i don't think we need this
2817              //      evas_object_clip_recalc(eo_obj);
2818
2819              ev->cur = cur_pt;
2820              ev->prev = prev_pt;
2821
2822              _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2823
2824              if ((!e->is_frozen) &&
2825                  evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1) &&
2826                  _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
2827                  _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, newin) &&
2828                  (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
2829                {
2830                   if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2831                     {
2832                        ev->action = EFL_POINTER_ACTION_MOVE;
2833                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2834                                                        event_id, EFL_EVENT_POINTER_MOVE);
2835                        if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2836                          _evas_event_source_mouse_move_events(eo_obj, eo_e, evt, pdata, event_id);
2837                     }
2838                }
2839              else
2840                {
2841                   /* otherwise it has left the object */
2842                   if (!obj_pdata->mouse_in) continue;
2843                   _evas_event_mouse_in_set(pdata->seat, obj, 0);
2844                   if (e->is_frozen) continue;
2845                   ev->action = EFL_POINTER_ACTION_OUT;
2846                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
2847                                                   event_id, EFL_EVENT_POINTER_OUT);
2848                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2849                     _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
2850                }
2851              if (e->delete_me) break;
2852           }
2853         eina_list_free(copy);
2854         _evas_post_event_callback_call(eo_e, e, event_id);
2855
2856         event_id = _evas_object_event_new();
2857
2858         /* go thru our current list of ins */
2859         EINA_LIST_FOREACH(newin, l, eo_obj)
2860           {
2861              obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2862              /* if its not in the old list of ins send an enter event */
2863              if (!eina_list_data_find(pdata->seat->object.in, eo_obj))
2864                {
2865                   obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2866                   if (!obj_pdata)
2867                     {
2868                        ERR("Could not find the object pointer data for device %p",
2869                            ev->device);
2870                        continue;
2871                     }
2872                   if (obj_pdata->mouse_in) continue;
2873                   _evas_event_mouse_in_set(pdata->seat, obj, 1);
2874                   if (e->is_frozen) continue;
2875
2876                   ev->cur = cur_pt;
2877                   ev->prev = prev_pt;
2878
2879                   _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2880
2881                   ev->action = EFL_POINTER_ACTION_IN;
2882                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
2883                                                   event_id, EFL_EVENT_POINTER_IN);
2884                   if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2885                     {
2886                        ev->action = EFL_POINTER_ACTION_MOVE;
2887                        evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2888                                                        event_id, EFL_EVENT_POINTER_MOVE);
2889                     }
2890                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2891                     _evas_event_source_mouse_in_events(eo_obj, eo_e, evt, event_id);
2892                   if (e->delete_me) break;
2893                }
2894           }
2895         /* free our old list of ins */
2896         eina_list_free(pdata->seat->object.in);
2897         /* and set up the new one */
2898         pdata->seat->object.in = newin;
2899
2900         _evas_post_event_callback_call(eo_e, e, event_id);
2901      }
2902
2903    _evas_unwalk(e);
2904    if (ev->device) efl_unref(ev->device);
2905 }
2906
2907 static void
2908 _canvas_event_feed_mouse_move_legacy(Evas *eo_e, Evas_Public_Data *e, int x, int y,
2909                                      unsigned int timestamp, const void *data)
2910 {
2911    Efl_Input_Pointer_Data *ev = NULL;
2912    Efl_Input_Pointer *evt;
2913
2914    evt = efl_input_pointer_instance_get(eo_e, (void **) &ev);
2915    if (!ev) return;
2916
2917    ev->data = (void *) data;
2918    ev->timestamp = timestamp;
2919    ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
2920    ev->cur.x = x;
2921    ev->cur.y = y;
2922
2923    _canvas_event_feed_mouse_move_internal(e, ev);
2924
2925    efl_unref(evt);
2926 }
2927
2928 EAPI void
2929 evas_event_input_mouse_move(Eo *eo_e, int x, int y, unsigned int timestamp, const void *data)
2930 {
2931    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2932    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2933    _canvas_event_feed_mouse_move_legacy(eo_e, e, x - e->framespace.x, y - e->framespace.y, timestamp, data);
2934 }
2935
2936 EAPI void
2937 evas_event_feed_mouse_move(Eo *eo_e, int x, int y, unsigned int timestamp, const void *data)
2938 {
2939    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2940    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2941    _canvas_event_feed_mouse_move_legacy(eo_e, e, x, y, timestamp, data);
2942 }
2943
2944 // TIZEN_ONLY(20160429): add multi_info(radius, pressure and angle) to Evas_Event_Mouse_XXX
2945 static void
2946 _canvas_event_feed_mouse_move_with_multi_info_legacy(Evas *eo_e, Evas_Public_Data *e, int x, int y,
2947                                      unsigned int timestamp, const void *data,
2948                                      double radius, double radius_x, double radius_y, double pressure, double angle)
2949 {
2950    Efl_Input_Pointer_Data *ev = NULL;
2951    Efl_Input_Pointer *evt;
2952
2953    evt = efl_input_pointer_instance_get(eo_e, (void **) &ev);
2954    if (!ev) return;
2955
2956    ev->data = (void *) data;
2957    ev->timestamp = timestamp;
2958    ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
2959    ev->cur.x = x;
2960    ev->cur.y = y;
2961    ev->radius = radius;
2962    ev->radius_x = radius_x;
2963    ev->radius_y = radius_y;
2964    ev->pressure = pressure;
2965    ev->angle = angle;
2966
2967    _canvas_event_feed_mouse_move_internal(e, ev);
2968
2969    efl_unref(evt);
2970 }
2971
2972 EAPI void
2973 evas_event_input_mouse_move_with_multi_info(Eo *eo_e, int x, int y, unsigned int timestamp, const void *data, double radius, double radius_x, double radius_y, double pressure, double angle)
2974 {
2975    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2976    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2977    _canvas_event_feed_mouse_move_with_multi_info_legacy(eo_e, e, x - e->framespace.x, y - e->framespace.y, timestamp, data, radius, radius_x, radius_y, pressure, angle);
2978 }
2979
2980 EAPI void
2981 evas_event_feed_mouse_move_with_multi_info(Eo *eo_e, int x, int y, unsigned int timestamp, const void *data, double radius, double radius_x, double radius_y, double pressure, double angle)
2982 {
2983    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2984    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2985    _canvas_event_feed_mouse_move_with_multi_info_legacy(eo_e, e, x, y, timestamp, data, radius, radius_x, radius_y, pressure, angle);
2986 }
2987 //
2988
2989 static void
2990 _canvas_event_feed_mouse_in_internal(Evas *eo_e, Efl_Input_Pointer_Data *ev)
2991 {
2992    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2993    Efl_Input_Pointer *evt;
2994    Eina_List *ins;
2995    Eina_List *l;
2996    Evas_Object *eo_obj;
2997    int event_id;
2998    Evas_Pointer_Data *pdata;
2999
3000    static const int value_flags =
3001          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
3002          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
3003          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
3004          _efl_input_value_mask(EFL_INPUT_VALUE_BUTTONS_PRESSED) |
3005          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
3006
3007    if (!e || !ev) return;
3008    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3009
3010    if (ev->device)
3011      {
3012         pdata = _evas_pointer_data_by_device_get(e, ev->device);
3013         if (!pdata) return;
3014      }
3015    else
3016      {
3017         Evas_Pointer_Seat *pseat;
3018         if (!e->seats) return;
3019         pseat = EINA_INLIST_CONTAINER_GET(e->seats, Evas_Pointer_Seat);
3020         pseat->inside = 1;
3021         return;
3022      }
3023
3024    pdata->seat->inside = 1;
3025    if (e->is_frozen) return;
3026
3027    e->last_timestamp = ev->timestamp;
3028    if (pdata->seat->mouse_grabbed != 0) return;
3029
3030    evt = ev->eo;
3031    ev->action = EFL_POINTER_ACTION_IN;
3032    ev->pressed_buttons = pdata->button;
3033    ev->cur.x = pdata->seat->x;
3034    ev->cur.y = pdata->seat->y;
3035    ev->modifiers = &(e->modifiers);
3036    ev->locks = &(e->locks);
3037    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3038    ev->value_flags |= value_flags;
3039    if (ev->device) efl_ref(ev->device);
3040
3041    event_id = _evas_object_event_new();
3042
3043    _evas_walk(e);
3044    /* get new list of ins */
3045    ins = evas_event_objects_event_list(eo_e, NULL, pdata->seat->x, pdata->seat->y);
3046    EINA_LIST_FOREACH(ins, l, eo_obj)
3047      {
3048         Evas_Object_Pointer_Data *obj_pdata;
3049         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3050         if ((!obj) || (obj->delete_me)) continue;
3051         if (!eina_list_data_find(pdata->seat->object.in, eo_obj))
3052           {
3053              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3054              if (!obj_pdata)
3055                {
3056                   ERR("Could not find the object pointer data for device %p",
3057                       ev->device);
3058                   continue;
3059                }
3060              if (obj_pdata->mouse_in) continue;
3061              _evas_event_mouse_in_set(pdata->seat, obj, 1);
3062
3063              ev->cur.x = pdata->seat->x;
3064              ev->cur.y = pdata->seat->y;
3065              ev->prev.x = pdata->seat->prev.x;
3066              ev->prev.y = pdata->seat->prev.y;
3067              _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3068
3069              ev->action = EFL_POINTER_ACTION_IN;
3070              efl_ref(eo_obj);
3071              evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
3072                                              event_id, EFL_EVENT_POINTER_IN);
3073              if (!EINA_DBL_EQ(pdata->seat->x, ev->prev.x) &&
3074                  !EINA_DBL_EQ(pdata->seat->y, ev->prev.y))
3075                {
3076                   ev->action = EFL_POINTER_ACTION_MOVE;
3077                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
3078                                                   event_id, EFL_EVENT_POINTER_MOVE);
3079                }
3080              if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3081                _evas_event_source_mouse_in_events(eo_obj, eo_e, evt, event_id);
3082              efl_unref(eo_obj);
3083              if (e->delete_me || e->is_frozen) break;
3084           }
3085      }
3086    /* free our old list of ins */
3087    eina_list_free(pdata->seat->object.in);
3088    /* and set up the new one */
3089    pdata->seat->object.in = ins;
3090    _evas_post_event_callback_call(eo_e, e, event_id);
3091    _canvas_event_feed_mouse_move_internal(e, ev);
3092    _evas_unwalk(e);
3093
3094    if (ev->device) efl_unref(ev->device);
3095 }
3096
3097 static void
3098 _canvas_event_feed_mouse_out_internal(Evas *eo_e, Efl_Input_Pointer_Data *ev)
3099 {
3100    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3101    Efl_Input_Pointer *evt;
3102    Eina_List *l, *copy;
3103    Evas_Object *eo_obj;
3104    int event_id;
3105    Evas_Pointer_Data *pdata;
3106
3107    static const int value_flags =
3108          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
3109          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
3110          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
3111          _efl_input_value_mask(EFL_INPUT_VALUE_BUTTONS_PRESSED) |
3112          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
3113
3114    if (!e || !ev) return;
3115    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3116    if (ev->device)
3117      {
3118         pdata = _evas_pointer_data_by_device_get(e, ev->device);
3119         if (!pdata) return;
3120      }
3121    else
3122      {
3123         Evas_Pointer_Seat *pseat;
3124         if (!e->seats) return;
3125         pseat = EINA_INLIST_CONTAINER_GET(e->seats, Evas_Pointer_Seat);
3126         pseat->inside = 0;
3127         return;
3128      }
3129    pdata->seat->inside = 0;
3130
3131    if (e->is_frozen) return;
3132    e->last_timestamp = ev->timestamp;
3133
3134    event_id = _evas_object_event_new();
3135
3136    evt = ev->eo;
3137    ev->action = EFL_POINTER_ACTION_OUT;
3138    ev->pressed_buttons = pdata->button;
3139    ev->cur.x = pdata->seat->x;
3140    ev->cur.y = pdata->seat->y;
3141    ev->modifiers = &(e->modifiers);
3142    ev->locks = &(e->locks);
3143    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3144    ev->value_flags |= value_flags;
3145    if (ev->device) efl_ref(ev->device);
3146
3147    _evas_walk(e);
3148    /* if our mouse button is inside any objects */
3149    /* go thru old list of in objects */
3150    copy = evas_event_list_copy(pdata->seat->object.in);
3151    EINA_LIST_FOREACH(copy, l, eo_obj)
3152      {
3153         Evas_Object_Pointer_Data *obj_pdata;
3154         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3155         if ((!obj) || (obj->delete_me)) continue;
3156         obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3157         if (!obj_pdata)
3158           {
3159              ERR("Could not find the object pointer data for device %p",
3160                  ev->device);
3161              continue;
3162           }
3163         if (!obj_pdata->mouse_in) continue;
3164         _evas_event_mouse_in_set(pdata->seat, obj, 0);
3165         efl_ref(eo_obj);
3166
3167         ev->cur.x = pdata->seat->x;
3168         ev->cur.y = pdata->seat->y;
3169         ev->prev.x = pdata->seat->prev.x;
3170         ev->prev.y = pdata->seat->prev.y;
3171         _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3172
3173         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
3174                                         event_id, EFL_EVENT_POINTER_OUT);
3175         if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3176           _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
3177         efl_unref(eo_obj);
3178         if (e->delete_me || e->is_frozen) break;
3179         obj_pdata->mouse_grabbed = 0;
3180      }
3181    eina_list_free(copy);
3182
3183    /* free our old list of ins */
3184    pdata->seat->object.in =  eina_list_free(pdata->seat->object.in);
3185    pdata->seat->mouse_grabbed = 0;
3186    _evas_post_event_callback_call(eo_e, e, event_id);
3187    _evas_unwalk(e);
3188
3189    if (ev->device) efl_unref(ev->device);
3190 }
3191
3192 static void
3193 _canvas_event_feed_mouse_inout_legacy(Eo *eo_e, unsigned int timestamp,
3194                                       const void *data, Eina_Bool in)
3195 {
3196    Efl_Input_Pointer_Data *ev = NULL;
3197    Efl_Input_Pointer *evt;
3198
3199    evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
3200    if (!ev) return;
3201
3202    ev->timestamp = timestamp;
3203    ev->data = (void *) data;
3204    ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
3205
3206    if (in)
3207      _canvas_event_feed_mouse_in_internal(eo_e, ev);
3208    else
3209      _canvas_event_feed_mouse_out_internal(eo_e, ev);
3210
3211    efl_unref(evt);
3212 }
3213
3214 EAPI void
3215 evas_event_feed_mouse_in(Eo *eo_e, unsigned int timestamp, const void *data)
3216 {
3217    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3218    _canvas_event_feed_mouse_inout_legacy(eo_e, timestamp, data, EINA_TRUE);
3219 }
3220
3221 EAPI void
3222 evas_event_feed_mouse_out(Eo *eo_e, unsigned int timestamp, const void *data)
3223 {
3224    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3225    _canvas_event_feed_mouse_inout_legacy(eo_e, timestamp, data, EINA_FALSE);
3226 }
3227
3228 static void
3229 _canvas_event_feed_multi_down_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
3230 {
3231    Efl_Input_Pointer *evt;
3232    Eina_List *l, *copy;
3233    Evas_Object *eo_obj;
3234    Eina_Vector2 point;
3235    Evas *eo_e;
3236    int event_id;
3237    int addgrab = 0;
3238    Evas_Pointer_Data *pdata;
3239    Evas_Object_Pointer_Data *obj_pdata;
3240
3241    static const int value_flags =
3242          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
3243          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
3244          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
3245          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID) |
3246          _efl_input_value_mask(EFL_INPUT_VALUE_BUTTON);
3247
3248    if (!e || !ev) return;
3249    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3250
3251    pdata = _evas_pointer_data_by_device_get(e, ev->device);
3252    if (!pdata) return;
3253    eo_e = e->evas;
3254    DBG("ButtonEvent:multi down time=%u button=%d downs=%d",
3255        ev->timestamp, ev->touch_id, pdata->seat->downs);
3256    pdata->seat->downs++;
3257    if (e->is_frozen) return;
3258    e->last_timestamp = ev->timestamp;
3259
3260    event_id = _evas_object_event_new();
3261
3262    point = ev->cur;
3263    evt = ev->eo;
3264    ev->action = EFL_POINTER_ACTION_DOWN;
3265    ev->modifiers = &(e->modifiers);
3266    ev->locks = &(e->locks);
3267    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3268    ev->value_flags |= value_flags;
3269    if (ev->device) efl_ref(ev->device);
3270
3271    _evas_walk(e);
3272    /* append new touch point to the touch point list */
3273    _evas_touch_point_append(eo_e, ev->touch_id, ev->cur.x, ev->cur.y);
3274    if (pdata->seat->mouse_grabbed == 0)
3275      {
3276         if (pdata->seat->downs > 1)
3277           addgrab = pdata->seat->downs - 1;
3278         else /* this is the first touch, which means it's also a move event, which means we need to redo this */
3279           {
3280              /* get all new in objects */
3281              Eina_List *ins = evas_event_objects_event_list(eo_e, NULL, ev->cur.x, ev->cur.y);
3282              /* free our old list of ins */
3283              eina_list_free(pdata->seat->object.in);
3284              /* and set up the new one */
3285              pdata->seat->object.in = ins;
3286           }
3287      }
3288    copy = evas_event_list_copy(pdata->seat->object.in);
3289    EINA_LIST_FOREACH(copy, l, eo_obj)
3290      {
3291         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3292         obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3293         if (!obj_pdata)
3294           {
3295              ERR("Could not find the object pointer data for device %p",
3296                  ev->device);
3297              continue;
3298           }
3299         if (obj_pdata->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB)
3300           {
3301              obj_pdata->mouse_grabbed += addgrab + 1;
3302              pdata->seat->mouse_grabbed += addgrab + 1;
3303           }
3304      }
3305    EINA_LIST_FOREACH(copy, l, eo_obj)
3306      {
3307         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3308         obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3309         if (!obj_pdata)
3310           {
3311              ERR("Could not find the object pointer data for device %p",
3312                  ev->device);
3313              continue;
3314           }
3315         ev->cur = point;
3316         ev->prev.x = pdata->seat->prev.x;
3317         ev->prev.y = pdata->seat->prev.y;
3318         _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3319
3320         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_DOWN, evt,
3321                                         event_id, EFL_EVENT_FINGER_DOWN);
3322         if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3323           _evas_event_source_multi_down_events(obj, e, evt, pdata, event_id);
3324         if (e->delete_me || e->is_frozen) break;
3325      }
3326    eina_list_free(copy);
3327
3328    _evas_post_event_callback_call(eo_e, e, event_id);
3329    /* update touch point's state to EVAS_TOUCH_POINT_STILL */
3330    _evas_touch_point_update(eo_e, ev->touch_id, ev->cur.x, ev->cur.y, EVAS_TOUCH_POINT_STILL);
3331    _evas_unwalk(e);
3332
3333    if (ev->device) efl_unref(ev->device);
3334 }
3335
3336 static void
3337 _canvas_event_feed_multi_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
3338 {
3339    Efl_Input_Pointer *evt;
3340    Eina_List *l, *copy;
3341    Evas_Object *eo_obj;
3342    Eina_Vector2 point;
3343    Evas *eo_e;
3344    int event_id;
3345    Evas_Pointer_Data *pdata;
3346
3347    static const int value_flags =
3348          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
3349          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
3350          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
3351          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
3352
3353    if (!e || !ev) return;
3354    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3355
3356    pdata = _evas_pointer_data_by_device_get(e, ev->device);
3357    if (!pdata) return;
3358    eo_e = e->evas;
3359    DBG("ButtonEvent:multi up time=%u device=%d downs=%d",
3360        ev->timestamp, ev->touch_id, pdata->seat->downs);
3361    if (pdata->seat->downs <= 0) return;
3362    pdata->seat->downs--;
3363    if (e->is_frozen) return;
3364    e->last_timestamp = ev->timestamp;
3365
3366    event_id = _evas_object_event_new();
3367
3368    point = ev->cur;
3369    evt = ev->eo;
3370    ev->action = EFL_POINTER_ACTION_UP;
3371    ev->modifiers = &(e->modifiers);
3372    ev->locks = &(e->locks);
3373    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3374    ev->value_flags |= value_flags;
3375    if (ev->device) efl_ref(ev->device);
3376
3377    _evas_walk(e);
3378    /* update released touch point */
3379    _evas_touch_point_update(eo_e, ev->touch_id, ev->cur.x, ev->cur.y, EVAS_TOUCH_POINT_UP);
3380    copy = evas_event_list_copy(pdata->seat->object.in);
3381    EINA_LIST_FOREACH(copy, l, eo_obj)
3382      {
3383         Evas_Object_Pointer_Data *obj_pdata;
3384         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3385         obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3386         if (!obj_pdata)
3387           {
3388              ERR("Could not find the object pointer data for device %p",
3389                  ev->device);
3390              continue;
3391           }
3392         ev->cur = point;
3393         ev->prev.x = pdata->seat->prev.x;
3394         ev->prev.y = pdata->seat->prev.y;
3395
3396         _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3397         if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
3398             (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
3399             (obj_pdata->mouse_grabbed > 0))
3400           {
3401              obj_pdata->mouse_grabbed--;
3402              pdata->seat->mouse_grabbed--;
3403           }
3404         evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_UP, evt,
3405                                         event_id, EFL_EVENT_FINGER_UP);
3406         if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3407           _evas_event_source_multi_up_events(obj, e, evt, pdata, event_id);
3408         if (e->delete_me || e->is_frozen) break;
3409      }
3410    eina_list_free(copy);
3411    if (pdata->seat->mouse_grabbed == 0)
3412      {
3413         _post_up_handle(e, evt, pdata);
3414         _evas_post_event_callback_call(eo_e, e, event_id);
3415      }
3416
3417    /* remove released touch point from the touch point list */
3418    _evas_touch_point_remove(eo_e, ev->touch_id);
3419    _evas_unwalk(e);
3420
3421    if (ev->device) efl_unref(ev->device);
3422 }
3423
3424 static inline void
3425 _canvas_event_feed_multi_internal(Evas *eo_e, Evas_Public_Data *e,
3426                                   int d, int x, int y,
3427                                   double rad, double radx, double rady,
3428                                   double pres, double ang,
3429                                   double fx, double fy,
3430                                   Evas_Button_Flags flags,
3431                                   unsigned int timestamp,
3432                                   const void *data, Efl_Pointer_Action action)
3433 {
3434    Efl_Input_Pointer_Data *ev = NULL;
3435    Efl_Input_Pointer *evt;
3436
3437    evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
3438    if (!e || !ev) return;
3439    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3440
3441    if (EINA_DBL_EQ(fx, 0.0)) fx = x;
3442    if (EINA_DBL_EQ(fy, 0.0)) fy = y;
3443
3444    ev->action = action;
3445    ev->touch_id = d;
3446    ev->cur.x = fx;
3447    ev->cur.y = fy;
3448    ev->pressure = pres;
3449    ev->angle = ang;
3450    ev->radius = rad;
3451    ev->radius_x = radx;
3452    ev->radius_y = rady;
3453    ev->button_flags = (Efl_Pointer_Flags)flags;
3454    ev->timestamp = timestamp;
3455    ev->data = (void *) data;
3456    ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
3457
3458    switch (action)
3459      {
3460       case EFL_POINTER_ACTION_DOWN:
3461         _canvas_event_feed_multi_down_internal(e, ev);
3462         break;
3463
3464       case EFL_POINTER_ACTION_UP:
3465         _canvas_event_feed_multi_up_internal(e, ev);
3466         break;
3467
3468       case EFL_POINTER_ACTION_MOVE:
3469         _canvas_event_feed_multi_move_internal(e, ev);
3470         break;
3471
3472       default: break;
3473      }
3474
3475    efl_unref(evt);
3476 }
3477
3478 EAPI void
3479 evas_event_input_multi_down(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
3480 {
3481    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3482    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3483    _canvas_event_feed_multi_internal(eo_e, e, d,
3484                                      x - e->framespace.x, y - e->framespace.y,
3485                                      rad, radx, rady, pres, ang,
3486                                      fx, fy, flags, timestamp, data, EFL_POINTER_ACTION_DOWN);
3487 }
3488
3489 EAPI void
3490 evas_event_feed_multi_down(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
3491 {
3492    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3493    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3494    _canvas_event_feed_multi_internal(eo_e, e, d, x, y, rad, radx, rady, pres, ang,
3495                                      fx, fy, flags, timestamp, data, EFL_POINTER_ACTION_DOWN);
3496 }
3497
3498 EAPI void
3499 evas_event_input_multi_up(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
3500 {
3501    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3502    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3503    _canvas_event_feed_multi_internal(eo_e, e, d,
3504                                      x - e->framespace.x, y - e->framespace.y,
3505                                      rad, radx, rady, pres, ang,
3506                                      fx, fy, flags, timestamp, data, EFL_POINTER_ACTION_UP);
3507 }
3508
3509 EAPI void
3510 evas_event_feed_multi_up(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
3511 {
3512    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3513    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3514    _canvas_event_feed_multi_internal(eo_e, e, d, x, y, rad, radx, rady, pres, ang,
3515                                      fx, fy, flags, timestamp, data, EFL_POINTER_ACTION_UP);
3516 }
3517
3518 static void
3519 _canvas_event_feed_multi_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
3520 {
3521    Efl_Input_Pointer *evt;
3522    Eina_List *l, *copy;
3523    Evas_Object *eo_obj;
3524    Eina_Vector2 cur_pt, prev_pt;
3525    Evas *eo_e;
3526    int event_id;
3527    Evas_Pointer_Data *pdata;
3528    Evas_Object_Pointer_Data *obj_pdata;
3529
3530    /* FIXME: Add previous x,y information (from evas touch point list) */
3531    static const int value_flags =
3532          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
3533          _efl_input_value_mask(EFL_INPUT_VALUE_X) |
3534          _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
3535          _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
3536
3537    if (!e || !ev) return;
3538    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3539
3540    pdata = _evas_pointer_data_by_device_get(e, ev->device);
3541    if (!pdata) return;
3542    eo_e = e->evas;
3543    event_id = _evas_object_event_new();
3544
3545    if (e->is_frozen) return;
3546    e->last_timestamp = ev->timestamp;
3547
3548    if ((!pdata->seat->inside) && (pdata->seat->mouse_grabbed == 0)) return;
3549
3550    evt = ev->eo;
3551    ev->modifiers = &(e->modifiers);
3552    ev->locks = &(e->locks);
3553    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3554    ev->action = EFL_POINTER_ACTION_MOVE;
3555    ev->value_flags |= value_flags;
3556    if (ev->device) efl_ref(ev->device);
3557
3558    cur_pt = ev->cur;
3559    prev_pt = ev->prev;
3560
3561    _evas_walk(e);
3562    /* update moved touch point */
3563    _evas_touch_point_update(eo_e, ev->touch_id, ev->cur.x, ev->cur.y, EVAS_TOUCH_POINT_MOVE);
3564    /* if our mouse button is grabbed to any objects */
3565    if (pdata->seat->mouse_grabbed > 0)
3566      {
3567         /* go thru old list of in objects */
3568         copy = evas_event_list_copy(pdata->seat->object.in);
3569         EINA_LIST_FOREACH(copy, l, eo_obj)
3570           {
3571              Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3572              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3573              if (!obj_pdata)
3574                {
3575                   ERR("Could not find the object pointer data for device %p",
3576                       ev->device);
3577                   continue;
3578                }
3579              if (_evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
3580                  (!evas_object_is_source_invisible(eo_obj, obj) ||
3581                   obj_pdata->mouse_grabbed))
3582                {
3583                   ev->cur = cur_pt;
3584                   ev->prev = prev_pt;
3585                   _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3586                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
3587                                                   event_id, EFL_EVENT_FINGER_MOVE);
3588                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3589                     _evas_event_source_multi_move_events(obj, e, evt, pdata, event_id);
3590
3591                   if (e->delete_me || e->is_frozen) break;
3592                }
3593           }
3594         eina_list_free(copy);
3595         _evas_post_event_callback_call(eo_e, e, event_id);
3596      }
3597    else
3598      {
3599         Eina_List *ins;
3600
3601         /* get all new in objects */
3602         ins = evas_event_objects_event_list(eo_e, NULL, ev->cur.x, ev->cur.y);
3603         /* go thru old list of in objects */
3604         copy = evas_event_list_copy(pdata->seat->object.in);
3605         EINA_LIST_FOREACH(copy, l, eo_obj)
3606           {
3607              Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3608              obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3609              if (!obj_pdata)
3610                {
3611                   ERR("Could not find the object pointer data for device %p",
3612                       ev->device);
3613                   continue;
3614                }
3615              /* if its under the pointer and its visible and its in the new */
3616              /* in list */
3617              // FIXME: i don't think we need this
3618              //      evas_object_clip_recalc(eo_obj);
3619
3620              ev->cur = cur_pt;
3621              ev->prev = prev_pt;
3622
3623              _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3624
3625              if (evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1) &&
3626                  _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
3627                  _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, ins) &&
3628                  (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
3629                {
3630                   evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
3631                                                   event_id, EFL_EVENT_FINGER_MOVE);
3632                   if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3633                     _evas_event_source_multi_move_events(obj, e, evt, pdata, event_id);
3634                }
3635              if (e->delete_me || e->is_frozen) break;
3636           }
3637         eina_list_free(copy);
3638         if (pdata->seat->mouse_grabbed == 0)
3639           {
3640              /* free our old list of ins */
3641              eina_list_free(pdata->seat->object.in);
3642              /* and set up the new one */
3643              pdata->seat->object.in = ins;
3644           }
3645         else
3646           {
3647              /* free our cur ins */
3648              eina_list_free(ins);
3649           }
3650         _evas_post_event_callback_call(eo_e, e, event_id);
3651      }
3652    _evas_unwalk(e);
3653
3654    if (ev->device) efl_unref(ev->device);
3655 }
3656
3657 EAPI void
3658 evas_event_input_multi_move(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, unsigned int timestamp, const void *data)
3659 {
3660    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3661    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3662    _canvas_event_feed_multi_internal(eo_e, e, d, x - e->framespace.x, y - e->framespace.y,
3663                                      rad, radx, rady,
3664                                      pres, ang, fx, fy, EVAS_BUTTON_NONE, timestamp, data,
3665                                      EFL_POINTER_ACTION_MOVE);
3666 }
3667
3668 EAPI void
3669 evas_event_feed_multi_move(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, unsigned int timestamp, const void *data)
3670 {
3671    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3672    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3673    _canvas_event_feed_multi_internal(eo_e, e, d, x, y, rad, radx, rady,
3674                                      pres, ang, fx, fy, EVAS_BUTTON_NONE, timestamp, data,
3675                                      EFL_POINTER_ACTION_MOVE);
3676 }
3677
3678 static void
3679 _key_event_dispatch(Evas_Public_Data *e, void *event_info,
3680                     Efl_Input_Device *device,
3681                     const Efl_Event_Description *efl_event_desc,
3682                     Evas_Callback_Type evas_event_type, int event_id)
3683 {
3684    Eo *focused;
3685
3686    if (!device)
3687      device = e->default_seat;
3688    else
3689      {
3690         const char *name = efl_name_get(device);
3691
3692         device = efl_input_device_seat_get(device);
3693         if (!device)
3694           {
3695              ERR("Could not find the parent seat from device name '%s'. Using default seat instead", name);
3696              device = e->default_seat;
3697           }
3698      }
3699
3700    focused = eina_hash_find(e->focused_objects, &device);
3701
3702    if (!focused)
3703      return;
3704
3705    Evas_Object_Protected_Data *focused_obj =
3706      efl_data_scope_get(focused, EFL_CANVAS_OBJECT_CLASS);
3707
3708    if (!focused_obj)
3709      {
3710         WRN("No element focused");
3711         return;
3712      }
3713
3714    if (!e->is_frozen && !evas_event_freezes_through(focused, focused_obj))
3715      {
3716         evas_object_event_callback_call(focused, focused_obj,
3717                                         evas_event_type, event_info,
3718                                         event_id, efl_event_desc);
3719      }
3720 }
3721
3722 static void
3723 _canvas_event_feed_key_down_internal(Evas_Public_Data *e, Efl_Input_Key_Data *ev)
3724 {
3725    Eina_Bool exclusive = EINA_FALSE;
3726    Efl_Input_Pointer *evt;
3727    int event_id = 0;
3728    Eo *eo_e;
3729
3730    if (!e || !ev) return;
3731    if (e->is_frozen) return;
3732    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3733
3734    eo_e = e->evas;
3735    e->last_timestamp = ev->timestamp;
3736    _evas_walk(e);
3737
3738    event_id = _evas_object_event_new();
3739
3740    evt = ev->eo;
3741    ev->modifiers = &(e->modifiers);
3742    ev->locks = &(e->locks);
3743    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3744    if (ev->device) efl_ref(ev->device);
3745
3746    if (e->grabs)
3747      {
3748         Eina_List *l;
3749         Evas_Key_Grab *g;
3750         Evas_Modifier_Mask *seat_mask, modifier_mask;
3751         Efl_Input_Device *seat = NULL;
3752
3753         e->walking_grabs++;
3754         if (ev->device)
3755           seat = efl_input_device_seat_get(ev->device);
3756         seat_mask = eina_hash_find(e->modifiers.masks, &seat);
3757         modifier_mask = seat_mask ? *seat_mask : 0;
3758         EINA_LIST_FOREACH(e->grabs, l, g)
3759           {
3760              if (g->just_added)
3761                {
3762                   g->just_added = EINA_FALSE;
3763                   continue;
3764                }
3765              if (g->delete_me) continue;
3766              if (!g->object) continue;
3767              if (!g->is_active) continue;
3768              if (((modifier_mask & g->modifiers) ||
3769                   (g->modifiers == modifier_mask)) &&
3770                  (!strcmp(ev->keyname, g->keyname)))
3771                {
3772                   if (!(modifier_mask & g->not_modifiers))
3773                     {
3774                        Evas_Object_Protected_Data *object_obj = efl_data_scope_get(g->object, EFL_CANVAS_OBJECT_CLASS);
3775                        if (!e->is_frozen &&
3776                            !evas_event_freezes_through(g->object, object_obj))
3777                          {
3778                             evas_object_event_callback_call(g->object, object_obj, EVAS_CALLBACK_KEY_DOWN, evt,
3779                                                             event_id, EFL_EVENT_KEY_DOWN);
3780                          }
3781                        if (g->exclusive) exclusive = EINA_TRUE;
3782                     }
3783                }
3784              if (e->delete_me) break;
3785           }
3786         e->walking_grabs--;
3787         if (e->walking_grabs <= 0)
3788           {
3789              while (e->delete_grabs > 0)
3790                {
3791                   e->delete_grabs--;
3792                   for (l = e->grabs; l;)
3793                     {
3794                        g = eina_list_data_get(l);
3795                        l = eina_list_next(l);
3796                        if (g->delete_me)
3797                          {
3798                             Evas_Object_Protected_Data *g_object_obj = efl_data_scope_get(g->object, EFL_CANVAS_OBJECT_CLASS);
3799                             evas_key_grab_free(g->object, g_object_obj, g->keyname,
3800                                                g->modifiers, g->not_modifiers);
3801                          }
3802                     }
3803                }
3804           }
3805      }
3806    if (!exclusive)
3807      _key_event_dispatch(e, evt, ev->device, EFL_EVENT_KEY_DOWN,
3808                          EVAS_CALLBACK_KEY_DOWN, event_id);
3809    _evas_post_event_callback_call(eo_e, e, event_id);
3810    _evas_unwalk(e);
3811
3812    if (ev->device) efl_unref(ev->device);
3813 }
3814
3815 static void
3816 _canvas_event_feed_key_up_internal(Evas_Public_Data *e, Efl_Input_Key_Data *ev)
3817 {
3818    Eina_Bool exclusive = EINA_FALSE;
3819    Efl_Input_Pointer *evt;
3820    int event_id = 0;
3821    Eo *eo_e;
3822
3823    if (!e || !ev) return;
3824    if (e->is_frozen) return;
3825    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3826
3827    eo_e = e->evas;
3828    e->last_timestamp = ev->timestamp;
3829    _evas_walk(e);
3830
3831    event_id = _evas_object_event_new();
3832
3833    evt = ev->eo;
3834    ev->modifiers = &(e->modifiers);
3835    ev->locks = &(e->locks);
3836    ev->event_flags |= (Efl_Input_Flags)e->default_event_flags;
3837    if (ev->device) efl_ref(ev->device);
3838
3839    if (e->grabs)
3840      {
3841         Eina_List *l;
3842         Evas_Key_Grab *g;
3843         Evas_Modifier_Mask *seat_mask, modifier_mask;
3844         Efl_Input_Device *seat = NULL;
3845
3846         e->walking_grabs++;
3847         if (ev->device)
3848           seat = efl_input_device_seat_get(ev->device);
3849         seat_mask = eina_hash_find(e->modifiers.masks, &seat);
3850         modifier_mask = seat_mask ? *seat_mask : 0;
3851         EINA_LIST_FOREACH(e->grabs, l, g)
3852           {
3853              if (g->just_added)
3854                {
3855                   g->just_added = EINA_FALSE;
3856                   continue;
3857                }
3858              if (g->delete_me) continue;
3859              if (!g->object) continue;
3860              if (!g->is_active) continue;
3861              if (((modifier_mask & g->modifiers) ||
3862                   (g->modifiers == modifier_mask)) &&
3863                  (!(modifier_mask & g->not_modifiers)) &&
3864                  (!strcmp(ev->keyname, g->keyname)))
3865                {
3866                   Evas_Object_Protected_Data *object_obj = efl_data_scope_get(g->object, EFL_CANVAS_OBJECT_CLASS);
3867                   if (!e->is_frozen &&
3868                         !evas_event_freezes_through(g->object, object_obj))
3869                     {
3870                        evas_object_event_callback_call
3871                              (g->object, object_obj, EVAS_CALLBACK_KEY_UP, evt,
3872                               event_id, EFL_EVENT_KEY_UP);
3873                     }
3874                   if (g->exclusive) exclusive = EINA_TRUE;
3875                }
3876              if (e->delete_me) break;
3877           }
3878         e->walking_grabs--;
3879         if (e->walking_grabs <= 0)
3880           {
3881              while (e->delete_grabs > 0)
3882                {
3883                   Eina_List *ll, *l_next;
3884                   Evas_Key_Grab *gr;
3885
3886                   e->delete_grabs--;
3887                   EINA_LIST_FOREACH_SAFE(e->grabs, ll, l_next, gr)
3888                     {
3889                        if (gr->delete_me)
3890                          {
3891                             Evas_Object_Protected_Data *gr_object_obj =
3892                                efl_data_scope_get(gr->object, EFL_CANVAS_OBJECT_CLASS);
3893                             evas_key_grab_free(gr->object, gr_object_obj, gr->keyname,
3894                                             gr->modifiers, gr->not_modifiers);
3895                          }
3896                     }
3897                }
3898           }
3899      }
3900    if (!exclusive)
3901      _key_event_dispatch(e, evt, ev->device, EFL_EVENT_KEY_UP,
3902                          EVAS_CALLBACK_KEY_UP, event_id);
3903    _evas_post_event_callback_call(eo_e, e, event_id);
3904    _evas_unwalk(e);
3905
3906    if (ev->device) efl_unref(ev->device);
3907 }
3908
3909 static void
3910 _canvas_event_feed_key_legacy(Eo *eo_e, Evas_Public_Data *e,
3911                               const char *keyname, const char *key,
3912                               const char *string, const char *compose,
3913                               unsigned int timestamp, const void *data,
3914                               unsigned int keycode, Eina_Bool down)
3915 {
3916    Efl_Input_Key_Data *ev = NULL;
3917    Efl_Input_Key *evt;
3918
3919    if (!keyname) return;
3920
3921    evt = efl_input_key_instance_get( eo_e, (void **) &ev);
3922    if (!ev) return;
3923
3924    ev->keyname = (char *) keyname;
3925    ev->data = (void *) data;
3926    ev->key = key;
3927    ev->string = string;
3928    ev->compose = compose;
3929    ev->timestamp = timestamp;
3930    ev->keycode = keycode;
3931    ev->pressed = down;
3932    ev->no_stringshare = EINA_TRUE;
3933    ev->device = efl_ref(_evas_event_legacy_device_get(e->evas, EINA_FALSE));
3934
3935
3936    if (down)
3937      _canvas_event_feed_key_down_internal(e, ev);
3938    else
3939      _canvas_event_feed_key_up_internal(e, ev);
3940
3941    efl_unref(evt);
3942 }
3943
3944 EAPI void
3945 evas_event_feed_key_down(Eo *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data)
3946 {
3947    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3948    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3949    _canvas_event_feed_key_legacy(eo_e, e, keyname, key, string,
3950                                  compose, timestamp, data, 0, 1);
3951 }
3952
3953 EAPI void
3954 evas_event_feed_key_up(Eo *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data)
3955 {
3956    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3957    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3958    _canvas_event_feed_key_legacy(eo_e, e, keyname, key, string,
3959                                  compose, timestamp, data, 0, 0);
3960 }
3961
3962 EAPI void
3963 evas_event_feed_key_down_with_keycode(Eo *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data, unsigned int keycode)
3964 {
3965    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3966    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3967    _canvas_event_feed_key_legacy(eo_e, e, keyname, key, string,
3968                                  compose, timestamp, data, keycode, 1);
3969 }
3970
3971 EAPI void
3972 evas_event_feed_key_up_with_keycode(Eo *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data, unsigned int keycode)
3973 {
3974    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3975    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3976    _canvas_event_feed_key_legacy(eo_e, e, keyname, key, string,
3977                                  compose, timestamp, data, keycode, 0);
3978 }
3979
3980 EAPI void
3981 evas_event_feed_hold(Eo *eo_e, int hold, unsigned int timestamp, const void *data)
3982 {
3983    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3984    Efl_Input_Hold_Data *ev = NULL;
3985    Efl_Input_Hold *evt;
3986    Eina_List *l, *copy;
3987    Evas_Object *eo_obj;
3988    int event_id = 0;
3989    Evas_Pointer_Data *pdata;
3990
3991    if (e->is_frozen) return;
3992    EVAS_EVENT_FEED_SAFETY_CHECK(e);
3993    e->last_timestamp = timestamp;
3994
3995    event_id = _evas_object_event_new();
3996
3997    evt = efl_input_hold_instance_get(eo_e, (void **) &ev);
3998    if (!ev) return;
3999
4000    ev->hold = !!hold;
4001    ev->data = (void *) data;
4002    ev->timestamp = timestamp;
4003    ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
4004    ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
4005
4006    pdata = _evas_pointer_data_by_device_get(e, ev->device);
4007    if (!pdata) return;
4008
4009
4010    _evas_walk(e);
4011    copy = evas_event_list_copy(pdata->seat->object.in);
4012    EINA_LIST_FOREACH(copy, l, eo_obj)
4013      {
4014         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
4015         if ( !evas_event_freezes_through(eo_obj, obj))
4016           {
4017              evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_HOLD, evt,
4018                                              event_id, EFL_EVENT_HOLD);
4019              if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
4020                _evas_event_source_hold_events(eo_obj, event_id, evt);
4021           }
4022         if (e->delete_me || e->is_frozen) break;
4023      }
4024    eina_list_free(copy);
4025    _evas_post_event_callback_call(eo_e, e, event_id);
4026    _evas_unwalk(e);
4027    _evas_object_event_new();
4028
4029    efl_unref(evt);
4030 }
4031
4032 void
4033 _canvas_event_feed_axis_update_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
4034 {
4035    Efl_Input_Pointer *evt;
4036    Eina_List *l, *copy;
4037    Evas_Object *eo_obj;
4038    int event_id = 0;
4039    Evas *eo_e;
4040    Evas_Pointer_Data *pdata;
4041
4042    static const int value_flags =
4043          _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP);
4044
4045    if (!e || !ev) return;
4046    if (e->is_frozen) return;
4047    EVAS_EVENT_FEED_SAFETY_CHECK(e);
4048
4049    pdata = _evas_pointer_data_by_device_get(e, ev->device);
4050    if (!pdata) return;
4051    eo_e = e->evas;
4052    e->last_timestamp = ev->timestamp;
4053
4054    ev->action = EFL_POINTER_ACTION_AXIS;
4055    ev->value_flags |= value_flags;
4056    event_id = _evas_object_event_new();
4057    evt = ev->eo;
4058
4059    if (ev->device) efl_ref(ev->device);
4060
4061    _evas_walk(e);
4062    copy = evas_event_list_copy(pdata->seat->object.in);
4063
4064    EINA_LIST_FOREACH(copy, l, eo_obj)
4065      {
4066         Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
4067         if (!evas_event_freezes_through(eo_obj, obj))
4068           {
4069              evas_object_event_callback_call(eo_obj, obj,
4070                                              EVAS_CALLBACK_AXIS_UPDATE, evt,
4071                                              event_id, EFL_EVENT_POINTER_AXIS);
4072              if (e->delete_me || e->is_frozen) break;
4073           }
4074      }
4075    eina_list_free(copy);
4076    _evas_post_event_callback_call(eo_e, e, event_id);
4077
4078    _evas_unwalk(e);
4079    if (ev->device) efl_unref(ev->device);
4080 }
4081
4082 EAPI void
4083 evas_event_feed_axis_update(Evas *eo_e, unsigned int timestamp, int device, int toolid, int naxis, const Evas_Axis *axes, const void *data)
4084 {
4085    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
4086    Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
4087    Efl_Input_Pointer_Data *ev = NULL;
4088    Eina_Bool haswinx = 0, haswiny = 0;
4089    Efl_Input_Pointer *evt;
4090    double x = 0, y = 0;
4091    int n;
4092
4093    if (!e) return;
4094    EVAS_EVENT_FEED_SAFETY_CHECK(e);
4095
4096    evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
4097    if (!ev) return;
4098
4099    ev->data = (void *) data;
4100    ev->timestamp = timestamp;
4101    ev->action = EFL_POINTER_ACTION_AXIS;
4102    ev->touch_id = toolid;
4103
4104    // see also ecore_evas.c
4105    for (n = 0; n < naxis; n++)
4106      {
4107         const Evas_Axis *axis = &(axes[n]);
4108         switch (axis->label)
4109           {
4110            case EVAS_AXIS_LABEL_WINDOW_X:
4111              _efl_input_value_mark(ev, EFL_INPUT_VALUE_X);
4112              x = axis->value;
4113              haswinx = EINA_TRUE;
4114              break;
4115
4116            case EVAS_AXIS_LABEL_WINDOW_Y:
4117              _efl_input_value_mark(ev, EFL_INPUT_VALUE_Y);
4118              y = axis->value;
4119              haswiny = EINA_TRUE;
4120              break;
4121
4122            case EVAS_AXIS_LABEL_X:
4123              if (!haswinx)
4124                {
4125                   _efl_input_value_mark(ev, EFL_INPUT_VALUE_X);
4126                   x = axis->value;
4127                }
4128              ev->raw.x = axis->value;
4129              ev->has_raw = EINA_TRUE;
4130              break;
4131
4132            case EVAS_AXIS_LABEL_Y:
4133              if (!haswiny)
4134                {
4135                   _efl_input_value_mark(ev, EFL_INPUT_VALUE_Y);
4136                   y = axis->value;
4137                }
4138              ev->raw.y = axis->value;
4139              ev->has_raw = EINA_TRUE;
4140              break;
4141
4142            case EVAS_AXIS_LABEL_NORMAL_X:
4143              ev->norm.x = axis->value;
4144              ev->has_norm = EINA_TRUE;
4145              break;
4146
4147            case EVAS_AXIS_LABEL_NORMAL_Y:
4148              ev->norm.y = axis->value;
4149              ev->has_norm = EINA_TRUE;
4150              break;
4151
4152            case EVAS_AXIS_LABEL_PRESSURE:
4153              _efl_input_value_mark(ev, EFL_INPUT_VALUE_PRESSURE);
4154              ev->pressure = axis->value;
4155              break;
4156
4157            case EVAS_AXIS_LABEL_DISTANCE:
4158              _efl_input_value_mark(ev, EFL_INPUT_VALUE_DISTANCE);
4159              ev->distance = axis->value;
4160              break;
4161
4162            case EVAS_AXIS_LABEL_AZIMUTH:
4163              _efl_input_value_mark(ev, EFL_INPUT_VALUE_AZIMUTH);
4164              ev->azimuth = axis->value;
4165              break;
4166
4167            case EVAS_AXIS_LABEL_TILT:
4168              _efl_input_value_mark(ev, EFL_INPUT_VALUE_TILT);
4169              ev->tilt = axis->value;
4170              break;
4171
4172            case EVAS_AXIS_LABEL_TWIST:
4173              _efl_input_value_mark(ev, EFL_INPUT_VALUE_TWIST);
4174              ev->twist = axis->value;
4175              break;
4176
4177            case EVAS_AXIS_LABEL_UNKNOWN:
4178            case EVAS_AXIS_LABEL_TOUCH_WIDTH_MAJOR:
4179            case EVAS_AXIS_LABEL_TOUCH_WIDTH_MINOR:
4180            case EVAS_AXIS_LABEL_TOOL_WIDTH_MAJOR:
4181            case EVAS_AXIS_LABEL_TOOL_WIDTH_MINOR:
4182            default:
4183              DBG("Unsupported axis label %d, value %f (discarded)",
4184                  axis->label, axis->value);
4185              break;
4186           }
4187      }
4188
4189    ev->cur.x = x;
4190    ev->cur.y = y;
4191
4192    /* FIXME: set proper device based on the device id (X or WL specific) */
4193    ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE)); // FIXME
4194    (void) device;
4195
4196    _canvas_event_feed_axis_update_internal(e, ev);
4197
4198    efl_unref(evt);
4199 }
4200
4201 static void
4202 _feed_mouse_move_eval_internal(Eo *eo_obj, Evas_Object_Protected_Data *obj)
4203 {
4204    Evas_Public_Data *evas = obj->layer->evas;
4205    Eina_Bool in_output_rect;
4206    Evas_Pointer_Data *pdata = _evas_pointer_data_by_device_get(evas, NULL);
4207
4208    if (!pdata) return;
4209    in_output_rect = evas_object_is_in_output_rect(eo_obj, obj, pdata->seat->x,
4210                                                   pdata->seat->y, 1, 1);
4211    if ((in_output_rect) &&
4212        ((!obj->precise_is_inside) || (evas_object_is_inside(eo_obj, obj,
4213                                                             pdata->seat->x,
4214                                                             pdata->seat->y))))
4215      {
4216         _canvas_event_feed_mouse_move_legacy(evas->evas, evas,
4217                                              pdata->seat->x, pdata->seat->y,
4218                                              evas->last_timestamp, NULL);
4219      }
4220 }
4221 EOLIAN void
4222 _efl_canvas_object_efl_object_event_freeze(Eo *obj, Evas_Object_Protected_Data *pd)
4223 {
4224    efl_event_freeze(efl_super(obj, EFL_CANVAS_OBJECT_CLASS));
4225    if (efl_event_freeze_count_get(obj) == 1)
4226      {
4227         pd->freeze_events = EINA_TRUE;
4228         evas_object_smart_member_cache_invalidate(obj, EINA_FALSE, EINA_TRUE,
4229                                                   EINA_FALSE);
4230      }
4231 }
4232
4233 EOLIAN void
4234 _efl_canvas_object_efl_object_event_thaw(Eo *obj, Evas_Object_Protected_Data *pd)
4235 {
4236    if (efl_event_freeze_count_get(obj) == 1)
4237      {
4238         pd->freeze_events = EINA_FALSE;
4239         evas_object_smart_member_cache_invalidate(obj, EINA_FALSE, EINA_TRUE,
4240                                                   EINA_FALSE);
4241         _feed_mouse_move_eval_internal(obj, pd);
4242      }
4243    efl_event_thaw(efl_super(obj, EFL_CANVAS_OBJECT_CLASS));
4244 }
4245
4246 EAPI void
4247 evas_object_freeze_events_set(Eo *eo_obj, Eina_Bool freeze)
4248 {
4249    Evas_Object_Protected_Data *pd = EVAS_OBJECT_DATA_SAFE_GET(eo_obj);
4250    EINA_SAFETY_ON_NULL_RETURN(pd);
4251
4252    freeze = !!freeze;
4253    if (pd->freeze_events == freeze) return;
4254
4255    if (freeze)
4256      efl_event_freeze(eo_obj);
4257    else
4258      // The following check is needed, as eo does not accept more thaw calls than freeze calls.
4259      // However, evas legacy stuff accepted multiple flase sets
4260      if (efl_event_freeze_count_get(eo_obj) > 0)
4261        efl_event_thaw(eo_obj);
4262 }
4263
4264 EAPI Eina_Bool
4265 evas_object_freeze_events_get(const Eo *eo_obj EINA_UNUSED)
4266 {
4267    return (efl_event_freeze_count_get(eo_obj) > 0);
4268 }
4269
4270 EOLIAN void
4271 _efl_canvas_object_pass_events_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Eina_Bool pass)
4272 {
4273    pass = !!pass;
4274    if (obj->pass_events == pass) return;
4275    obj->pass_events = pass;
4276    evas_object_smart_member_cache_invalidate(eo_obj, EINA_TRUE, EINA_FALSE, EINA_FALSE);
4277    _feed_mouse_move_eval_internal(eo_obj, obj);
4278 }
4279
4280 EOLIAN Eina_Bool
4281 _efl_canvas_object_pass_events_get(const Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj)
4282 {
4283    return obj->pass_events;
4284 }
4285
4286 EOLIAN void
4287 _efl_canvas_object_repeat_events_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Eina_Bool repeat)
4288 {
4289    repeat = !!repeat;
4290    if (obj->repeat_events == repeat) return;
4291    obj->repeat_events = repeat;
4292    _feed_mouse_move_eval_internal(eo_obj, obj);
4293 }
4294
4295 EOLIAN Eina_Bool
4296 _efl_canvas_object_repeat_events_get(const Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj)
4297 {
4298    return obj->repeat_events;
4299 }
4300
4301 EOLIAN void
4302 _efl_canvas_object_propagate_events_set(Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, Eina_Bool prop)
4303 {
4304    obj->no_propagate = !prop;
4305 }
4306
4307 EOLIAN Eina_Bool
4308 _efl_canvas_object_propagate_events_get(const Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj)
4309 {
4310    return !(obj->no_propagate);
4311 }
4312
4313 EOLIAN Eina_Bool
4314 _efl_canvas_object_pointer_mode_by_device_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Efl_Input_Device *dev, Evas_Object_Pointer_Mode setting)
4315 {
4316    int addgrab;
4317    Evas_Object *cobj;
4318    const Eina_List *l;
4319    Evas_Pointer_Data *pdata;
4320    Evas_Object_Pointer_Data *obj_pdata;
4321
4322    pdata = _evas_pointer_data_by_device_get(obj->layer->evas, dev);
4323    if (!pdata) return EINA_FALSE;
4324
4325    obj_pdata = _evas_object_pointer_data_get(pdata, obj);
4326    EINA_SAFETY_ON_NULL_RETURN_VAL(obj_pdata, EINA_FALSE);
4327
4328    /* ignore no-ops */
4329    if (obj_pdata->pointer_mode == setting) return EINA_FALSE;
4330
4331    /* adjust by number of pointer down events */
4332    addgrab = pdata->seat->downs;
4333    switch (obj_pdata->pointer_mode)
4334      {
4335       /* nothing needed */
4336       case EVAS_OBJECT_POINTER_MODE_NOGRAB: break;
4337       /* decrement canvas nogrep (NO Grab/REPeat) counter */
4338       case EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN:
4339         if (obj_pdata->mouse_grabbed)
4340           pdata->seat->nogrep--;
4341         /* fall through */
4342       /* remove related grabs from canvas and object */
4343       case EVAS_OBJECT_POINTER_MODE_AUTOGRAB:
4344         if (obj_pdata->mouse_grabbed)
4345           {
4346              pdata->seat->mouse_grabbed -= obj_pdata->mouse_grabbed;
4347              obj_pdata->mouse_grabbed = 0;
4348           }
4349      }
4350    /* adjustments for new mode */
4351    switch (setting)
4352      {
4353       /* nothing needed */
4354       case EVAS_OBJECT_POINTER_MODE_NOGRAB: break;
4355       /* increment canvas nogrep (NO Grab/REPeat) counter */
4356       case EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN:
4357         pdata->seat->nogrep++;
4358         /* having nogrep set indicates that any object following it in
4359          * the pointer.object.in list will not be receiving events, meaning
4360          * that they will fail to unset any existing grabs/flags. unset them
4361          * now to avoid breaking the canvas
4362          */
4363         EINA_LIST_FOREACH(pdata->seat->object.in, l, cobj)
4364           {
4365              Evas_Object_Protected_Data *cobj_data;
4366
4367              /* skip to the current object */
4368              if (cobj != eo_obj) continue;
4369              /* only change objects past it */
4370              EINA_LIST_FOREACH(l->next, l, cobj)
4371                {
4372                   Evas_Object_Pointer_Data *cobj_pdata;
4373                   cobj_data = efl_data_scope_get(cobj, EFL_CANVAS_OBJECT_CLASS);
4374                   cobj_pdata = _evas_object_pointer_data_get(pdata, cobj_data);
4375                   if (!cobj_pdata) continue;
4376                   if (!cobj_pdata->mouse_grabbed) continue;
4377                   cobj_pdata->mouse_grabbed -= addgrab;
4378                   pdata->seat->mouse_grabbed -= addgrab;
4379                   if (cobj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
4380                     pdata->seat->nogrep--;
4381                }
4382              break;
4383           }
4384         /* fall through */
4385       /* add all button grabs to this object */
4386       case EVAS_OBJECT_POINTER_MODE_AUTOGRAB:
4387         obj_pdata->mouse_grabbed += addgrab;
4388         pdata->seat->mouse_grabbed += addgrab;
4389      }
4390    obj_pdata->pointer_mode = setting;
4391    return EINA_TRUE;
4392 }
4393
4394 EOLIAN Evas_Object_Pointer_Mode
4395 _efl_canvas_object_pointer_mode_by_device_get(const Eo *eo_obj EINA_UNUSED,
4396                                               Evas_Object_Protected_Data *obj,
4397                                               Efl_Input_Device *dev)
4398 {
4399
4400    Evas_Pointer_Data *pdata;
4401    Evas_Object_Pointer_Data *obj_pdata;
4402
4403    pdata = _evas_pointer_data_by_device_get(obj->layer->evas, dev);
4404    EINA_SAFETY_ON_NULL_RETURN_VAL(pdata, EVAS_OBJECT_POINTER_MODE_AUTOGRAB);
4405
4406    obj_pdata = _evas_object_pointer_data_get(pdata, obj);
4407    EINA_SAFETY_ON_NULL_RETURN_VAL(obj_pdata, EVAS_OBJECT_POINTER_MODE_AUTOGRAB);
4408    return obj_pdata->pointer_mode;
4409 }
4410
4411 EOLIAN Eina_Bool
4412 _efl_canvas_object_pointer_mode_set(Eo *eo_obj, Evas_Object_Protected_Data *obj,
4413                                     Evas_Object_Pointer_Mode setting)
4414 {
4415    return _efl_canvas_object_pointer_mode_by_device_set(eo_obj, obj, NULL, setting);
4416 }
4417
4418 EOLIAN Evas_Object_Pointer_Mode
4419 _efl_canvas_object_pointer_mode_get(const Eo *eo_obj, Evas_Object_Protected_Data *obj)
4420 {
4421    return _efl_canvas_object_pointer_mode_by_device_get(eo_obj, obj, NULL);
4422 }
4423
4424 EOLIAN Eina_Bool
4425 _efl_canvas_object_efl_canvas_pointer_pointer_inside_get(const Eo *eo_obj,
4426                                                          Evas_Object_Protected_Data *obj,
4427                                                          Efl_Input_Device *pointer)
4428 {
4429    Evas_Object_Protected_Data *in, *parent;
4430    Eo *eo_in, *eo_parent;
4431    Eina_List *l;
4432    Evas_Object_Pointer_Data *obj_pdata;
4433    Evas_Pointer_Data *pdata;
4434
4435    EVAS_OBJECT_DATA_ALIVE_CHECK(obj, EINA_FALSE);
4436
4437    if (!pointer)
4438      //TIZEN_ONLY(20180530): add storing last mouse device.
4439      //pointer = obj->layer->evas->default_mouse;
4440      pointer = (obj->layer->evas->last_mouse ? obj->layer->evas->last_mouse :
4441                 obj->layer->evas->default_mouse);
4442      //
4443
4444    if (!pointer) return EINA_FALSE;
4445
4446    pdata = _evas_pointer_data_by_device_get(obj->layer->evas, pointer);
4447    if (!pdata) return EINA_FALSE;
4448    obj_pdata = _evas_object_pointer_data_get(pdata, obj);
4449    if (!obj_pdata) return EINA_FALSE;
4450    if (!obj->is_smart)
4451      return obj_pdata->mouse_in;
4452
4453    /* This is to keep the legacy APIs evas_object_pointer_inside_by_device_get() &
4454     * evas_object_pointer_inside_get() old behaviour. */
4455    if (obj->is_pointer_inside_legacy) return EINA_FALSE;
4456
4457    /* For smart objects, this is a bit expensive obj->mouse_in will not be set.
4458     * Alternatively we could count the number of in and out events propagated
4459     * to the smart object, assuming they always match. */
4460    EINA_LIST_FOREACH(pdata->seat->object.in, l, eo_in)
4461      {
4462         if (EINA_UNLIKELY(eo_in == eo_obj))
4463           return EINA_TRUE;
4464
4465         in = EVAS_OBJECT_DATA_GET(eo_in);
4466         if (!EVAS_OBJECT_DATA_ALIVE(in)) continue;
4467         eo_parent = in->smart.parent;
4468         while (eo_parent)
4469           {
4470              if ((eo_parent == eo_obj) && !in->no_propagate)
4471                return EINA_TRUE;
4472              parent = EVAS_OBJECT_DATA_GET(eo_parent);
4473              if (!EVAS_OBJECT_DATA_ALIVE(parent)) break;
4474              eo_parent = parent->smart.parent;
4475           }
4476      }
4477
4478    return EINA_FALSE;
4479 }
4480
4481 EAPI void
4482 evas_event_refeed_event(Eo *eo_e, void *event_copy, Evas_Callback_Type event_type)
4483 {
4484    EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
4485    if (!event_copy) return;
4486
4487    switch (event_type)
4488      {
4489       case EVAS_CALLBACK_MOUSE_IN:
4490           {
4491              Evas_Event_Mouse_In *ev = event_copy;
4492              evas_event_feed_mouse_in(eo_e, ev->timestamp, ev->data);
4493              break;
4494           }
4495       case EVAS_CALLBACK_MOUSE_OUT:
4496           {
4497              Evas_Event_Mouse_Out *ev = event_copy;
4498              evas_event_feed_mouse_out(eo_e, ev->timestamp, ev->data);
4499              break;
4500           }
4501       case EVAS_CALLBACK_MOUSE_DOWN:
4502           {
4503              Evas_Event_Mouse_Down *ev = event_copy;
4504              evas_event_feed_mouse_down(eo_e, ev->button, ev->flags, ev-> timestamp, ev->data);
4505              break;
4506           }
4507       case EVAS_CALLBACK_MOUSE_UP:
4508           {
4509              Evas_Event_Mouse_Up *ev = event_copy;
4510              evas_event_feed_mouse_up(eo_e, ev->button, ev->flags, ev-> timestamp, ev->data);
4511              break;
4512           }
4513       case EVAS_CALLBACK_MOUSE_MOVE:
4514           {
4515              Evas_Event_Mouse_Move *ev = event_copy;
4516              evas_event_feed_mouse_move(eo_e, ev->cur.canvas.x, ev->cur.canvas.y, ev->timestamp, ev->data);
4517              break;
4518           }
4519       case EVAS_CALLBACK_MOUSE_WHEEL:
4520           {
4521              Evas_Event_Mouse_Wheel *ev = event_copy;
4522              evas_event_feed_mouse_wheel(eo_e, ev->direction, ev-> z, ev->timestamp, ev->data);
4523              break;
4524           }
4525       case EVAS_CALLBACK_MULTI_DOWN:
4526           {
4527              Evas_Event_Multi_Down *ev = event_copy;
4528              evas_event_feed_multi_down(eo_e, ev->device, ev->canvas.x, ev->canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->canvas.xsub, ev->canvas.ysub, ev->flags, ev->timestamp, ev->data);
4529              break;
4530           }
4531       case EVAS_CALLBACK_MULTI_UP:
4532           {
4533              Evas_Event_Multi_Up *ev = event_copy;
4534              evas_event_feed_multi_up(eo_e, ev->device, ev->canvas.x, ev->canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->canvas.xsub, ev->canvas.ysub, ev->flags, ev->timestamp, ev->data);
4535              break;
4536           }
4537       case EVAS_CALLBACK_MULTI_MOVE:
4538           {
4539              Evas_Event_Multi_Move *ev = event_copy;
4540              evas_event_feed_multi_move(eo_e, ev->device, ev->cur.canvas.x, ev->cur.canvas.y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, ev->cur.canvas.xsub, ev->cur.canvas.ysub, ev->timestamp, ev->data);
4541              break;
4542           }
4543       case EVAS_CALLBACK_KEY_DOWN:
4544           {
4545              Evas_Event_Key_Down *ev = event_copy;
4546              evas_event_feed_key_down(eo_e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data);
4547              break;
4548           }
4549       case EVAS_CALLBACK_KEY_UP:
4550           {
4551              Evas_Event_Key_Up *ev = event_copy;
4552              evas_event_feed_key_up(eo_e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data);
4553              break;
4554           }
4555       case EVAS_CALLBACK_AXIS_UPDATE:
4556           {
4557              Evas_Event_Axis_Update *ev = event_copy;
4558              evas_event_feed_axis_update(eo_e, ev->timestamp, ev->device, ev->toolid, ev->naxis, ev->axis, ev->data);
4559              break;
4560           }
4561       default: /* All non-input events are not handeled */
4562         break;
4563      }
4564 }
4565
4566
4567 EOLIAN int
4568 _evas_canvas_event_down_count_by_device_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e,
4569                                             Efl_Input_Device *dev)
4570 {
4571    Evas_Pointer_Data *pdata = _evas_pointer_data_by_device_get(e, dev);
4572    EINA_SAFETY_ON_NULL_RETURN_VAL(pdata, 0);
4573    return pdata->seat->downs;
4574 }
4575
4576 EOLIAN int
4577 _evas_canvas_event_down_count_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e)
4578 {
4579    return _evas_canvas_event_down_count_by_device_get(eo_e, e, NULL);
4580 }
4581
4582 static void
4583 _evas_canvas_event_pointer_cb(void *data, const Efl_Event *event)
4584 {
4585    Efl_Input_Pointer_Data *ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
4586    Evas_Public_Data *e = data;
4587    Evas *eo_e = event->object;
4588    Eina_Bool nodev = 0;
4589
4590    if (!ev) return;
4591
4592    ev->evas_done = EINA_TRUE;
4593    ev->modifiers = &e->modifiers;
4594    ev->locks = &e->locks;
4595
4596    //TIZEN_ONLY(20180530): add storing last mouse device.
4597    if (!ev->device)
4598      {
4599         nodev = 1;
4600         ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
4601      }
4602    else
4603      e->last_mouse = ev->device;
4604    //
4605
4606    switch (ev->action)
4607      {
4608       case EFL_POINTER_ACTION_MOVE:
4609         if (ev->touch_id == 0)
4610           _canvas_event_feed_mouse_move_internal(e, ev);
4611         else
4612           _canvas_event_feed_multi_move_internal(e, ev);
4613         break;
4614
4615       case EFL_POINTER_ACTION_DOWN:
4616         if (ev->touch_id == 0)
4617           _canvas_event_feed_mouse_down_internal(e, ev);
4618         else
4619           _canvas_event_feed_multi_down_internal(e, ev);
4620         break;
4621
4622       case EFL_POINTER_ACTION_UP:
4623         if (ev->touch_id == 0)
4624           _canvas_event_feed_mouse_up_internal(e, ev);
4625         else
4626           _canvas_event_feed_multi_up_internal(e, ev);
4627         break;
4628
4629       case EFL_POINTER_ACTION_CANCEL:
4630         _canvas_event_feed_mouse_cancel_internal(e, ev);
4631         break;
4632
4633       case EFL_POINTER_ACTION_IN:
4634         _canvas_event_feed_mouse_in_internal(eo_e, ev);
4635         break;
4636
4637       case EFL_POINTER_ACTION_OUT:
4638         _canvas_event_feed_mouse_out_internal(eo_e, ev);
4639         break;
4640
4641       case EFL_POINTER_ACTION_WHEEL:
4642         _canvas_event_feed_mouse_wheel_internal(eo_e, ev);
4643         break;
4644
4645       case EFL_POINTER_ACTION_AXIS:
4646         _canvas_event_feed_axis_update_internal(e, ev);
4647         break;
4648
4649       default:
4650         ERR("unsupported event type: %d", ev->action);
4651         ev->evas_done = EINA_FALSE;
4652         break;
4653      }
4654
4655    if (nodev) ev->device = NULL;
4656 }
4657
4658 static void
4659 _evas_canvas_event_key_cb(void *data, const Efl_Event *event)
4660 {
4661    Efl_Input_Key *evt = event->info;
4662    Evas_Public_Data *e = data;
4663    Efl_Input_Key_Data *ev;
4664    Eina_Bool nodev = 0;
4665
4666    ev = efl_data_scope_get(evt, EFL_INPUT_KEY_CLASS);
4667    if (!ev) return;
4668
4669    if (!ev->device)
4670      {
4671         nodev = 1;
4672         ev->device = _evas_event_legacy_device_get(e->evas, EINA_FALSE);
4673      }
4674
4675    ev->modifiers = &e->modifiers;
4676    ev->locks = &e->locks;
4677
4678    if (ev->pressed)
4679      _canvas_event_feed_key_down_internal(e, ev);
4680    else
4681      _canvas_event_feed_key_up_internal(e, ev);
4682
4683    if (nodev) ev->device = NULL;
4684    ev->evas_done = EINA_TRUE;
4685 }
4686
4687 static void
4688 _evas_canvas_event_focus_cb(void *data, const Efl_Event *event)
4689 {
4690    Efl_Input_Device *seat = efl_canvas_scene_seat_default_get(event->object);
4691    Evas_Public_Data *e = data;
4692
4693    EINA_SAFETY_ON_NULL_RETURN(seat);
4694
4695    if (event->desc == EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN)
4696      {
4697         if (eina_list_data_find(e->focused_by, seat)) return;
4698         e->focused_by = eina_list_append(e->focused_by, seat);
4699      }
4700    else
4701      {
4702         if (!eina_list_data_find(e->focused_by, seat)) return;
4703         e->focused_by = eina_list_remove(e->focused_by, seat);
4704      }
4705 }
4706
4707 // note: "hold" event comes from above (elm), not below (ecore)
4708 EFL_CALLBACKS_ARRAY_DEFINE(_evas_canvas_event_pointer_callbacks,
4709 { EFL_EVENT_POINTER_MOVE, _evas_canvas_event_pointer_cb },
4710 { EFL_EVENT_POINTER_DOWN, _evas_canvas_event_pointer_cb },
4711 { EFL_EVENT_POINTER_UP, _evas_canvas_event_pointer_cb },
4712 { EFL_EVENT_POINTER_IN, _evas_canvas_event_pointer_cb },
4713 { EFL_EVENT_POINTER_OUT, _evas_canvas_event_pointer_cb },
4714 { EFL_EVENT_POINTER_CANCEL, _evas_canvas_event_pointer_cb },
4715 { EFL_EVENT_POINTER_WHEEL, _evas_canvas_event_pointer_cb },
4716 { EFL_EVENT_POINTER_AXIS, _evas_canvas_event_pointer_cb },
4717 { EFL_EVENT_FINGER_MOVE, _evas_canvas_event_pointer_cb },
4718 { EFL_EVENT_FINGER_DOWN, _evas_canvas_event_pointer_cb },
4719 { EFL_EVENT_FINGER_UP, _evas_canvas_event_pointer_cb },
4720 { EFL_EVENT_KEY_DOWN, _evas_canvas_event_key_cb },
4721 { EFL_EVENT_KEY_UP, _evas_canvas_event_key_cb },
4722 { EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN, _evas_canvas_event_focus_cb },
4723 { EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT, _evas_canvas_event_focus_cb })
4724
4725 void
4726 _evas_canvas_event_init(Evas *eo_e, Evas_Public_Data *e)
4727 {
4728    efl_event_callback_array_add(eo_e, _evas_canvas_event_pointer_callbacks(), e);
4729 }
4730
4731 void
4732 _evas_canvas_event_shutdown(Evas *eo_e, Evas_Public_Data *e)
4733 {
4734    efl_event_callback_array_del(eo_e, _evas_canvas_event_pointer_callbacks(), e);
4735 }
4736
4737 void
4738 _evas_canvas_event_pointer_move_event_dispatch(Evas_Public_Data *edata,
4739                                                Evas_Pointer_Data *pdata,
4740                                                void *data)
4741 {
4742    Efl_Input_Pointer_Data *ev = NULL;
4743    Efl_Input_Pointer *evt;
4744
4745    evt = efl_input_pointer_instance_get( edata->evas,
4746                                 (void **) &ev);
4747    if (!evt) return;
4748
4749    ev->data = (void *) data;
4750    ev->timestamp = edata->last_timestamp;
4751    ev->device = efl_ref(pdata->pointer);
4752    ev->cur.x = pdata->seat->x;
4753    ev->cur.y = pdata->seat->y;
4754
4755    _canvas_event_feed_mouse_move_internal(edata, ev);
4756
4757    efl_unref(evt);
4758 }
4759
4760 void
4761 _evas_canvas_event_pointer_in_rect_mouse_move_feed(Evas_Public_Data *edata,
4762                                                    Evas_Object *obj,
4763                                                    Evas_Object_Protected_Data *obj_data,
4764                                                    int w, int h,
4765                                                    Eina_Bool in_objects_list,
4766                                                    void *data)
4767 {
4768    Evas_Pointer_Seat *pseat;
4769
4770    EINA_INLIST_FOREACH(edata->seats, pseat)
4771      {
4772         if (!pseat->pointers) continue;
4773         if (!evas_object_is_in_output_rect(obj, obj_data, pseat->x,
4774                                            pseat->y, w, h))
4775           continue;
4776         if ((in_objects_list && eina_list_data_find(pseat->object.in, obj)) || !in_objects_list)
4777           {
4778              //TIZEN_ONLY(20180530): add storing last mouse device.
4779              //Evas_Pointer_Data *pdata = EINA_INLIST_CONTAINER_GET(pseat->pointers, Evas_Pointer_Data);
4780              Evas_Pointer_Data *pdata = NULL;
4781              if (edata->last_mouse)
4782                {
4783                   pdata = _evas_pointer_data_by_device_get(edata, edata->last_mouse);
4784                   //TIZEN_ONLY(20200213): add checking mouse grab count
4785                   if (!pdata) pdata = EINA_INLIST_CONTAINER_GET(pseat->pointers, Evas_Pointer_Data);
4786                   //
4787                }
4788              else
4789                pdata = EINA_INLIST_CONTAINER_GET(pseat->pointers, Evas_Pointer_Data);
4790              //
4791              _evas_canvas_event_pointer_move_event_dispatch(edata, pdata, data);
4792           }
4793      }
4794 }
4795
4796 void
4797 _evas_canvas_event_pointer_in_list_mouse_move_feed(Evas_Public_Data *edata,
4798                                                    Eina_List *was,
4799                                                    Evas_Object *obj,
4800                                                    Evas_Object_Protected_Data *obj_data,
4801                                                    int w, int h,
4802                                                    Eina_Bool xor_rule,
4803                                                    void *data)
4804 {
4805    Evas_Pointer_Seat *pseat;
4806
4807    EINA_INLIST_FOREACH(edata->seats, pseat)
4808      {
4809         Evas_Pointer_Data *pdata, *found = NULL;
4810         Eina_List *l;
4811         int in;
4812
4813         if (!pseat->pointers) continue;
4814         in = evas_object_is_in_output_rect(obj, obj_data, pseat->x,
4815                                                pseat->y, w, h);
4816         EINA_LIST_FOREACH(was, l, pdata)
4817           if (pdata->seat == pseat)
4818             {
4819                found = pdata;
4820                break;
4821             }
4822
4823         if ((xor_rule && ((in && !found) || (!in && found))) ||
4824             (!xor_rule && (in || found)))
4825           {
4826              //TIZEN_ONLY(20180530): add storing last mouse device.
4827              //TIZEN_ONLY(20181006): Now, last_mouse is always used even pdata is founded.
4828              //if (!pdata) pdata = EINA_INLIST_CONTAINER_GET(pseat->pointers, Evas_Pointer_Data);
4829              if (edata->last_mouse)
4830                {
4831                   pdata = _evas_pointer_data_by_device_get(edata, edata->last_mouse);
4832                   //TIZEN_ONLY(20200213): add checking mouse grab count
4833                   if (!pdata) pdata = EINA_INLIST_CONTAINER_GET(pseat->pointers, Evas_Pointer_Data);
4834                   //
4835                }
4836              else if (!pdata)
4837                pdata = EINA_INLIST_CONTAINER_GET(pseat->pointers, Evas_Pointer_Data);
4838              //
4839              _evas_canvas_event_pointer_move_event_dispatch(edata, pdata, data);
4840           }
4841      }
4842 }