src/lib/canvas/evas_events.c

   1 #include "evas_common.h"
   2 #include "evas_private.h"
   3
   4 static Eina_List *
   5 _evas_event_object_list_in_get(Evas *e, Eina_List *in,
   6                                const Eina_Inlist *list, Evas_Object *stop,
   7                                int x, int y, int *no_rep);
   8
   9 static void
  10 _evas_event_havemap_adjust(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Eina_Bool mouse_grabbed)
  11 {
  12    if (obj->smart.parent)
  13       _evas_event_havemap_adjust(obj->smart.parent, x, y, mouse_grabbed);
  14
  15    if ((!obj->cur.usemap) || (!obj->cur.map) || (!obj->cur.map->count == 4))
  16       return;
  17
  18    evas_map_coords_get(obj->cur.map, *x, *y, x, y, mouse_grabbed);
  19    *x += obj->cur.geometry.x;
  20    *y += obj->cur.geometry.y;
  21 }
  22
  23 static Eina_List *
  24 _evas_event_object_list_raw_in_get(Evas *e, Eina_List *in,
  25                                    const Eina_Inlist *list, Evas_Object *stop,
  26                                    int x, int y, int *no_rep)
  27 {
  28    Evas_Object *obj;
  29    int inside;
  30
  31    if (!list) return in;
  32    for (obj = _EINA_INLIST_CONTAINER(obj, list);
  33         obj;
  34         obj = _EINA_INLIST_CONTAINER(obj, EINA_INLIST_GET(obj)->prev))
  35      {
  36         if (obj == stop)
  37           {
  38              *no_rep = 1;
  39              return in;
  40           }
  41         if (evas_event_passes_through(obj)) continue;
  42         if ((obj->cur.visible) && (obj->delete_me == 0) &&
  43             (!obj->clip.clipees) &&
  44             (evas_object_clippers_is_visible(obj)))
  45           {
  46              if (obj->smart.smart)
  47                {
  48                   int norep = 0;
  49
  50                   if ((obj->cur.usemap) && (obj->cur.map) &&
  51                       (obj->cur.map->count == 4))
  52                     {
  53                        inside = evas_object_is_in_output_rect(obj, x, y, 1, 1);
  54                        if (inside)
  55                          {
  56                             if (!evas_map_coords_get(obj->cur.map, x, y,
  57                                                      &(obj->cur.map->mx),
  58                                                      &(obj->cur.map->my), 0))
  59                               {
  60                                  inside = 0;
  61                               }
  62                             else
  63                               {
  64                                  in = _evas_event_object_list_in_get
  65                                     (e, in,
  66                                      evas_object_smart_members_get_direct(obj),
  67                                      stop,
  68                                      obj->cur.geometry.x + obj->cur.map->mx,
  69                                      obj->cur.geometry.y + obj->cur.map->my,
  70                                      &norep);
  71                               }
  72                          }
  73                     }
  74                   else
  75                     {
  76                        if (!obj->child_has_map)
  77                          evas_object_smart_bouding_box_update(obj);
  78                        if (obj->child_has_map ||
  79                            (obj->cur.bounding_box.x <= x &&
  80                             obj->cur.bounding_box.x + obj->cur.bounding_box.w >= x &&
  81                             obj->cur.bounding_box.y <= y &&
  82                             obj->cur.bounding_box.y + obj->cur.bounding_box.h >= y) ||
  83                            (obj->cur.geometry.x <= x &&
  84                             obj->cur.geometry.y + obj->cur.geometry.w >= x &&
  85                             obj->cur.geometry.y <= y &&
  86                             obj->cur.geometry.y + obj->cur.geometry.h >= y))
  87                          in = _evas_event_object_list_in_get
  88                             (e, in, evas_object_smart_members_get_direct(obj),
  89                             stop, x, y, &norep);
  90                     }
  91                   if (norep)
  92                     {
  93                        if (!obj->repeat_events)
  94                          {
  95                             *no_rep = 1;
  96                             return in;
  97                          }
  98                     }
  99                }
 100              else
 101                {
 102                   inside = evas_object_is_in_output_rect(obj, x, y, 1, 1);
 103
 104                   if (inside)
 105                     {
 106                        if ((obj->cur.usemap) && (obj->cur.map) &&
 107                            (obj->cur.map->count == 4))
 108                          {
 109                             if (!evas_map_coords_get(obj->cur.map, x, y,
 110                                                      &(obj->cur.map->mx),
 111                                                      &(obj->cur.map->my), 0))
 112                               {
 113                                  inside = 0;
 114                               }
 115                          }
 116                     }
 117                   if (inside && ((!obj->precise_is_inside) ||
 118                                  (evas_object_is_inside(obj, x, y))))
 119                     {
 120                        if (!evas_event_freezes_through(obj))
 121                          in = eina_list_append(in, obj);
 122                        if (!obj->repeat_events)
 123                          {
 124                             *no_rep = 1;
 125                             return in;
 126                          }
 127                     }
 128                }
 129           }
 130      }
 131    *no_rep = 0;
 132    return in;
 133 }
 134
 135 static Eina_List *
 136 _evas_event_object_list_in_get(Evas *e, Eina_List *in,
 137                                const Eina_Inlist *list, Evas_Object *stop,
 138                                int x, int y, int *no_rep)
 139 {
 140    if (!list) return NULL;
 141    return _evas_event_object_list_raw_in_get(e, in, list->last, stop, x, y,
 142                                              no_rep);
 143 }
 144
 145 Eina_List *
 146 evas_event_objects_event_list(Evas *e, Evas_Object *stop, int x, int y)
 147 {
 148    Evas_Layer *lay;
 149    Eina_List *in = NULL;
 150
 151    if ((!e->layers) || (e->events_frozen > 0)) return NULL;
 152    EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay)
 153      {
 154         int no_rep = 0;
 155         in = _evas_event_object_list_in_get(e, in,
 156                                             EINA_INLIST_GET(lay->objects),
 157                                             stop, x, y, &no_rep);
 158         if (no_rep) return in;
 159      }
 160    return in;
 161 }
 162
 163 static Eina_List *
 164 evas_event_list_copy(Eina_List *list)
 165 {
 166    Eina_List *l, *new_l = NULL;
 167    const void *data;
 168
 169    EINA_LIST_FOREACH(list, l, data)
 170      new_l = eina_list_append(new_l, data);
 171    return new_l;
 172 }
 173 /* public functions */
 174
 175 EAPI void
 176 evas_event_default_flags_set(Evas *e, Evas_Event_Flags flags)
 177 {
 178    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 179    return;
 180    MAGIC_CHECK_END();
 181    e->default_event_flags = flags;
 182 }
 183
 184 EAPI Evas_Event_Flags
 185 evas_event_default_flags_get(const Evas *e)
 186 {
 187    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 188    return EVAS_EVENT_FLAG_ON_HOLD;
 189    MAGIC_CHECK_END();
 190    return e->default_event_flags;
 191 }
 192
 193 EAPI void
 194 evas_event_freeze(Evas *e)
 195 {
 196    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 197    return;
 198    MAGIC_CHECK_END();
 199    e->events_frozen++;
 200 }
 201
 202 EAPI void
 203 evas_event_thaw(Evas *e)
 204 {
 205    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 206    return;
 207    MAGIC_CHECK_END();
 208    e->events_frozen--;
 209    if (e->events_frozen == 0)
 210      {
 211         Evas_Layer *lay;
 212
 213         EINA_INLIST_FOREACH((EINA_INLIST_GET(e->layers)), lay)
 214           {
 215              Evas_Object *obj;
 216
 217              EINA_INLIST_FOREACH(lay->objects, obj)
 218                {
 219                   evas_object_clip_recalc(obj);
 220                   evas_object_recalc_clippees(obj);
 221                }
 222           }
 223      }
 224    if (e->events_frozen < 0)
 225      evas_debug_generic("  Thaw of events when already thawed!!!\n");
 226 }
 227
 228 EAPI int
 229 evas_event_freeze_get(const Evas *e)
 230 {
 231    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 232    return 0;
 233    MAGIC_CHECK_END();
 234    return e->events_frozen;
 235 }
 236
 237 EAPI void
 238 evas_event_thaw_eval(Evas *e)
 239 {
 240    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 241    return;
 242    MAGIC_CHECK_END();
 243    if (e->events_frozen != 0) return;
 244
 245    evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y,
 246                               e->last_timestamp, NULL);
 247 }
 248
 249 EAPI void
 250 evas_event_feed_mouse_down(Evas *e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
 251 {
 252    Eina_List *l, *copy;
 253    Evas_Event_Mouse_Down ev;
 254    Evas_Object *obj;
 255    int addgrab = 0;
 256    int event_id = 0;
 257
 258    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 259    return;
 260    MAGIC_CHECK_END();
 261
 262    if ((b < 1) || (b > 32)) return;
 263
 264    e->pointer.button |= (1 << (b - 1));
 265    e->pointer.downs++;
 266
 267    if (e->events_frozen > 0) return;
 268    e->last_timestamp = timestamp;
 269
 270    _evas_object_event_new();
 271
 272    event_id = _evas_event_counter;
 273    ev.button = b;
 274    ev.output.x = e->pointer.x;
 275    ev.output.y = e->pointer.y;
 276    ev.canvas.x = e->pointer.x;
 277    ev.canvas.y = e->pointer.y;
 278    ev.data = (void *)data;
 279    ev.modifiers = &(e->modifiers);
 280    ev.locks = &(e->locks);
 281    ev.flags = flags;
 282    ev.timestamp = timestamp;
 283    ev.event_flags = e->default_event_flags;
 284
 285    _evas_walk(e);
 286    /* append new touch point to the touch point list */
 287    _evas_touch_point_append(e, 0, e->pointer.x, e->pointer.y);
 288    /* If this is the first finger down, i.e no other fingers pressed,
 289     * get a new event list, otherwise, keep the current grabbed list. */
 290    if (e->pointer.mouse_grabbed == 0)
 291      {
 292         Eina_List *ins = evas_event_objects_event_list(e,
 293                                                        NULL,
 294                                                        e->pointer.x,
 295                                                        e->pointer.y);
 296         /* free our old list of ins */
 297         e->pointer.object.in = eina_list_free(e->pointer.object.in);
 298         /* and set up the new one */
 299         e->pointer.object.in = ins;
 300         /* adjust grabbed count by the nuymber of currently held down
 301          * fingers/buttons */
 302         if (e->pointer.downs > 1) addgrab = e->pointer.downs - 1;
 303      }
 304    copy = evas_event_list_copy(e->pointer.object.in);
 305    EINA_LIST_FOREACH(copy, l, obj)
 306      {
 307         if ((obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
 308             (obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN))
 309           {
 310              obj->mouse_grabbed += addgrab + 1;
 311              e->pointer.mouse_grabbed += addgrab + 1;
 312              if (obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
 313                {
 314                   e->pointer.nogrep++;
 315                   break;
 316                }
 317           }
 318      }
 319    EINA_LIST_FOREACH(copy, l, obj)
 320      {
 321         if (obj->delete_me) continue;
 322         ev.canvas.x = e->pointer.x;
 323         ev.canvas.y = e->pointer.y;
 324         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
 325
 326         if (e->events_frozen <= 0)
 327           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_DOWN, &ev, event_id);
 328         if (e->delete_me) break;
 329         if (obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
 330           break;
 331      }
 332    if (copy) eina_list_free(copy);
 333    e->last_mouse_down_counter++;
 334    _evas_post_event_callback_call(e);
 335    /* update touch point's state to EVAS_TOUCH_POINT_STILL */
 336    _evas_touch_point_update(e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_STILL);
 337    _evas_unwalk(e);
 338 }
 339
 340 static int
 341 _post_up_handle(Evas *e, unsigned int timestamp, const void *data)
 342 {
 343    Eina_List *l, *copy, *ins, *ll;
 344    Evas_Event_Mouse_Out ev;
 345    Evas_Object *obj;
 346    int post_called = 0;
 347    int event_id = 0;
 348
 349    _evas_object_event_new();
 350
 351    event_id = _evas_event_counter;
 352    ev.buttons = e->pointer.button;
 353    ev.output.x = e->pointer.x;
 354    ev.output.y = e->pointer.y;
 355    ev.canvas.x = e->pointer.x;
 356    ev.canvas.y = e->pointer.y;
 357    ev.data = (void *)data;
 358    ev.modifiers = &(e->modifiers);
 359    ev.locks = &(e->locks);
 360    ev.timestamp = timestamp;
 361    ev.event_flags = e->default_event_flags;
 362
 363    /* get new list of ins */
 364    ins = evas_event_objects_event_list(e, NULL, e->pointer.x, e->pointer.y);
 365    /* go thru old list of in objects */
 366    copy = evas_event_list_copy(e->pointer.object.in);
 367    EINA_LIST_FOREACH(copy, ll, obj)
 368      {
 369         ev.canvas.x = e->pointer.x;
 370         ev.canvas.y = e->pointer.y;
 371         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
 372         if ((!eina_list_data_find(ins, obj)) ||
 373             (!e->pointer.inside))
 374           {
 375              if (obj->mouse_in)
 376                {
 377                   obj->mouse_in = 0;
 378                   if (e->events_frozen <= 0)
 379                      evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id);
 380                }
 381           }
 382         if (e->delete_me) break;
 383      }
 384    _evas_post_event_callback_call(e);
 385
 386    if (copy) copy = eina_list_free(copy);
 387    if (e->pointer.inside)
 388      {
 389         Evas_Event_Mouse_In ev_in;
 390         Evas_Object *obj_itr;
 391
 392         _evas_object_event_new();
 393
 394         event_id = _evas_event_counter;
 395         ev_in.buttons = e->pointer.button;
 396         ev_in.output.x = e->pointer.x;
 397         ev_in.output.y = e->pointer.y;
 398         ev_in.canvas.x = e->pointer.x;
 399         ev_in.canvas.y = e->pointer.y;
 400         ev_in.data = (void *)data;
 401         ev_in.modifiers = &(e->modifiers);
 402         ev_in.locks = &(e->locks);
 403         ev_in.timestamp = timestamp;
 404         ev_in.event_flags = e->default_event_flags;
 405
 406         EINA_LIST_FOREACH(ins, l, obj_itr)
 407           {
 408              ev_in.canvas.x = e->pointer.x;
 409              ev_in.canvas.y = e->pointer.y;
 410              _evas_event_havemap_adjust(obj_itr, &ev_in.canvas.x, &ev_in.canvas.y, obj_itr->mouse_grabbed);
 411              if (!eina_list_data_find(e->pointer.object.in, obj_itr))
 412                {
 413                   if (!obj_itr->mouse_in)
 414                     {
 415                        obj_itr->mouse_in = 1;
 416                        if (e->events_frozen <= 0)
 417                           evas_object_event_callback_call(obj_itr, EVAS_CALLBACK_MOUSE_IN, &ev_in, event_id);
 418                     }
 419                }
 420              if (e->delete_me) break;
 421           }
 422         post_called = 1;
 423         _evas_post_event_callback_call(e);
 424      }
 425    else
 426      {
 427         ins = eina_list_free(ins);
 428      }
 429
 430    if (e->pointer.mouse_grabbed == 0)
 431      {
 432         /* free our old list of ins */
 433         eina_list_free(e->pointer.object.in);
 434         /* and set up the new one */
 435         e->pointer.object.in = ins;
 436      }
 437    else
 438      {
 439         /* free our cur ins */
 440         eina_list_free(ins);
 441      }
 442    if (e->pointer.inside)
 443       evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y, timestamp, data);
 444    return post_called;
 445 }
 446
 447 EAPI void
 448 evas_event_feed_mouse_up(Evas *e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
 449 {
 450    Eina_List *l, *copy;
 451
 452    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 453    return;
 454    MAGIC_CHECK_END();
 455
 456    if ((b < 1) || (b > 32)) return;
 457
 458    e->pointer.button &= ~(1 << (b - 1));
 459    e->pointer.downs--;
 460
 461    if (e->events_frozen > 0) return;
 462    e->last_timestamp = timestamp;
 463
 464      {
 465         Evas_Event_Mouse_Up ev;
 466         Evas_Object *obj;
 467         int event_id = 0;
 468
 469         _evas_object_event_new();
 470
 471         event_id = _evas_event_counter;
 472         ev.button = b;
 473         ev.output.x = e->pointer.x;
 474         ev.output.y = e->pointer.y;
 475         ev.canvas.x = e->pointer.x;
 476         ev.canvas.y = e->pointer.y;
 477         ev.data = (void *)data;
 478         ev.modifiers = &(e->modifiers);
 479         ev.locks = &(e->locks);
 480         ev.flags = flags;
 481         ev.timestamp = timestamp;
 482         ev.event_flags = e->default_event_flags;
 483
 484         _evas_walk(e);
 485         /* update released touch point */
 486         _evas_touch_point_update(e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_UP);
 487         copy = evas_event_list_copy(e->pointer.object.in);
 488         EINA_LIST_FOREACH(copy, l, obj)
 489           {
 490              ev.canvas.x = e->pointer.x;
 491              ev.canvas.y = e->pointer.y;
 492              _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
 493              if ((obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) &&
 494                  (obj->mouse_grabbed > 0))
 495                {
 496                   obj->mouse_grabbed--;
 497                   e->pointer.mouse_grabbed--;
 498                }
 499              if (!obj->delete_me)
 500                {
 501                   if ((e->events_frozen <= 0) &&
 502                       (!evas_event_freezes_through(obj)))
 503                       evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_UP, &ev, event_id);
 504                }
 505              if (e->delete_me) break;
 506              if (obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
 507                {
 508                   if (e->pointer.nogrep > 0) e->pointer.nogrep--;
 509                   break;
 510                }
 511           }
 512         if (copy) copy = eina_list_free(copy);
 513         e->last_mouse_up_counter++;
 514         _evas_post_event_callback_call(e);
 515      }
 516
 517    if (e->pointer.mouse_grabbed == 0)
 518      {
 519         _post_up_handle(e, timestamp, data);
 520      }
 521
 522    if (e->pointer.mouse_grabbed < 0)
 523      {
 524         ERR("BUG? e->pointer.mouse_grabbed (=%d) < 0!",
 525             e->pointer.mouse_grabbed);
 526      }
 527    /* remove released touch point from the touch point list */
 528    _evas_touch_point_remove(e, 0);
 529
 530    _evas_unwalk(e);
 531 }
 532
 533 EAPI void
 534 evas_event_feed_mouse_cancel(Evas *e, unsigned int timestamp, const void *data)
 535 {
 536    int i;
 537
 538    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 539    return;
 540    MAGIC_CHECK_END();
 541
 542    if (e->events_frozen > 0) return;
 543
 544    _evas_walk(e);
 545    for (i = 0; i < 32; i++)
 546      {
 547         if ((e->pointer.button & (1 << i)))
 548           evas_event_feed_mouse_up(e, i + 1, 0, timestamp, data);
 549      }
 550    // FIXME: multi cancel too?
 551    _evas_unwalk(e);
 552 }
 553
 554 EAPI void
 555 evas_event_feed_mouse_wheel(Evas *e, int direction, int z, unsigned int timestamp, const void *data)
 556 {
 557    Eina_List *l, *copy;
 558    Evas_Event_Mouse_Wheel ev;
 559    Evas_Object *obj;
 560    int event_id = 0;
 561
 562    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 563    return;
 564    MAGIC_CHECK_END();
 565
 566    if (e->events_frozen > 0) return;
 567    e->last_timestamp = timestamp;
 568
 569    _evas_object_event_new();
 570
 571    event_id = _evas_event_counter;
 572    ev.direction = direction;
 573    ev.z = z;
 574    ev.output.x = e->pointer.x;
 575    ev.output.y = e->pointer.y;
 576    ev.canvas.x = e->pointer.x;
 577    ev.canvas.y = e->pointer.y;
 578    ev.data = (void *) data;
 579    ev.modifiers = &(e->modifiers);
 580    ev.locks = &(e->locks);
 581    ev.timestamp = timestamp;
 582    ev.event_flags = e->default_event_flags;
 583
 584    _evas_walk(e);
 585    copy = evas_event_list_copy(e->pointer.object.in);
 586
 587    EINA_LIST_FOREACH(copy, l, obj)
 588      {
 589         ev.canvas.x = e->pointer.x;
 590         ev.canvas.y = e->pointer.y;
 591         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
 592         if ((e->events_frozen <= 0) && !evas_event_freezes_through(obj))
 593           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_WHEEL, &ev, event_id);
 594         if (e->delete_me) break;
 595      }
 596    if (copy) copy = eina_list_free(copy);
 597    _evas_post_event_callback_call(e);
 598
 599    _evas_unwalk(e);
 600 }
 601
 602 EAPI void
 603 evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const void *data)
 604 {
 605    Evas_Object *nogrep_obj = NULL;
 606    int px, py;
 607 ////   Evas_Coord pcx, pcy;
 608
 609    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 610    return;
 611    MAGIC_CHECK_END();
 612
 613    px = e->pointer.x;
 614    py = e->pointer.y;
 615 ////   pcx = e->pointer.canvas_x;
 616 ////   pcy = e->pointer.canvas_y;
 617
 618    if (e->events_frozen > 0) return;
 619    e->last_timestamp = timestamp;
 620
 621    e->pointer.x = x;
 622    e->pointer.y = y;
 623 ////   e->pointer.canvas_x = x;
 624 ////   e->pointer.canvas_y = y;
 625 ////   e->pointer.canvas_x = evas_coord_screen_x_to_world(e, x);
 626 ////   e->pointer.canvas_y = evas_coord_screen_y_to_world(e, y);
 627    if ((!e->pointer.inside) && (e->pointer.mouse_grabbed == 0)) return;
 628    _evas_walk(e);
 629    /* update moved touch point */
 630    if ((px != x) || (py != y))
 631      _evas_touch_point_update(e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_MOVE);
 632    /* if our mouse button is grabbed to any objects */
 633    if (e->pointer.mouse_grabbed > 0)
 634      {
 635         /* go thru old list of in objects */
 636         Eina_List *outs = NULL;
 637         Eina_List *l, *copy;
 638
 639           {
 640              Evas_Event_Mouse_Move ev;
 641              Evas_Object *obj;
 642              int event_id = 0;
 643
 644              _evas_object_event_new();
 645
 646              event_id = _evas_event_counter;
 647              ev.buttons = e->pointer.button;
 648              ev.cur.output.x = e->pointer.x;
 649              ev.cur.output.y = e->pointer.y;
 650              ev.cur.canvas.x = e->pointer.x;
 651              ev.cur.canvas.y = e->pointer.y;
 652              ev.prev.output.x = px;
 653              ev.prev.output.y = py;
 654              ev.prev.canvas.x = px;
 655              ev.prev.canvas.y = py;
 656              ev.data = (void *)data;
 657              ev.modifiers = &(e->modifiers);
 658              ev.locks = &(e->locks);
 659              ev.timestamp = timestamp;
 660              ev.event_flags = e->default_event_flags;
 661              copy = evas_event_list_copy(e->pointer.object.in);
 662              EINA_LIST_FOREACH(copy, l, obj)
 663                {
 664                   ev.cur.canvas.x = e->pointer.x;
 665                   ev.cur.canvas.y = e->pointer.y;
 666                   _evas_event_havemap_adjust(obj, &ev.cur.canvas.x,
 667                                              &ev.cur.canvas.y,
 668                                              obj->mouse_grabbed);
 669                   if ((e->events_frozen <= 0) &&
 670                       (evas_object_clippers_is_visible(obj) ||
 671                        obj->mouse_grabbed) &&
 672                       (!evas_event_passes_through(obj)) &&
 673                       (!evas_event_freezes_through(obj)) &&
 674                       (!obj->clip.clipees))
 675                     {
 676                        if ((px != x) || (py != y))
 677                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id);
 678                     }
 679                   else
 680                     outs = eina_list_append(outs, obj);
 681                   if ((obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) &&
 682                       (e->pointer.nogrep > 0))
 683                     {
 684                        eina_list_free(copy);
 685                        nogrep_obj = obj;
 686                        goto nogrep;
 687                     }
 688                   if (e->delete_me) break;
 689                }
 690              _evas_post_event_callback_call(e);
 691           }
 692           {
 693              Evas_Event_Mouse_Out ev;
 694              int event_id = 0;
 695
 696              _evas_object_event_new();
 697
 698              event_id = _evas_event_counter;
 699              ev.buttons = e->pointer.button;
 700              ev.output.x = e->pointer.x;
 701              ev.output.y = e->pointer.y;
 702              ev.canvas.x = e->pointer.x;
 703              ev.canvas.y = e->pointer.y;
 704              ev.data = (void *)data;
 705              ev.modifiers = &(e->modifiers);
 706              ev.locks = &(e->locks);
 707              ev.timestamp = timestamp;
 708              ev.event_flags = e->default_event_flags;
 709
 710              if (copy) eina_list_free(copy);
 711              while (outs)
 712                {
 713                   Evas_Object *obj;
 714
 715                   obj = outs->data;
 716                   outs = eina_list_remove(outs, obj);
 717                   if ((obj->mouse_grabbed == 0) && (!e->delete_me))
 718                     {
 719                        ev.canvas.x = e->pointer.x;
 720                        ev.canvas.y = e->pointer.y;
 721                        _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
 722                        e->pointer.object.in = eina_list_remove(e->pointer.object.in, obj);
 723                        if (obj->mouse_in)
 724                          {
 725                             obj->mouse_in = 0;
 726                             if (!obj->delete_me)
 727                               {
 728                                  if (e->events_frozen <= 0)
 729                                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id);
 730                               }
 731                          }
 732                     }
 733                }
 734              _evas_post_event_callback_call(e);
 735           }
 736      }
 737    else
 738      {
 739         Eina_List *ins;
 740         Eina_List *l, *copy;
 741         Evas_Event_Mouse_Move ev;
 742         Evas_Event_Mouse_Out ev2;
 743         Evas_Event_Mouse_In ev3;
 744         Evas_Object *obj;
 745         int event_id = 0, event_id2 = 0;
 746
 747         _evas_object_event_new();
 748
 749         event_id = _evas_event_counter;
 750         ev.buttons = e->pointer.button;
 751         ev.cur.output.x = e->pointer.x;
 752         ev.cur.output.y = e->pointer.y;
 753         ev.cur.canvas.x = e->pointer.x;
 754         ev.cur.canvas.y = e->pointer.y;
 755         ev.prev.output.x = px;
 756         ev.prev.output.y = py;
 757         ev.prev.canvas.x = px;
 758         ev.prev.canvas.y = py;
 759         ev.data = (void *)data;
 760         ev.modifiers = &(e->modifiers);
 761         ev.locks = &(e->locks);
 762         ev.timestamp = timestamp;
 763         ev.event_flags = e->default_event_flags;
 764
 765         ev2.buttons = e->pointer.button;
 766         ev2.output.x = e->pointer.x;
 767         ev2.output.y = e->pointer.y;
 768         ev2.canvas.x = e->pointer.x;
 769         ev2.canvas.y = e->pointer.y;
 770         ev2.data = (void *)data;
 771         ev2.modifiers = &(e->modifiers);
 772         ev2.locks = &(e->locks);
 773         ev2.timestamp = timestamp;
 774         ev2.event_flags = e->default_event_flags;
 775
 776         ev3.buttons = e->pointer.button;
 777         ev3.output.x = e->pointer.x;
 778         ev3.output.y = e->pointer.y;
 779         ev3.canvas.x = e->pointer.x;
 780         ev3.canvas.y = e->pointer.y;
 781         ev3.data = (void *)data;
 782         ev3.modifiers = &(e->modifiers);
 783         ev3.locks = &(e->locks);
 784         ev3.timestamp = timestamp;
 785         ev3.event_flags = e->default_event_flags;
 786
 787         /* get all new in objects */
 788         ins = evas_event_objects_event_list(e, NULL, x, y);
 789         /* go thru old list of in objects */
 790         copy = evas_event_list_copy(e->pointer.object.in);
 791         EINA_LIST_FOREACH(copy, l, obj)
 792           {
 793              /* if its under the pointer and its visible and its in the new */
 794              /* in list */
 795              // FIXME: i don't think we need this
 796              //      evas_object_clip_recalc(obj);
 797              if ((e->events_frozen <= 0) &&
 798                  evas_object_is_in_output_rect(obj, x, y, 1, 1) &&
 799                  (evas_object_clippers_is_visible(obj) ||
 800                   obj->mouse_grabbed) &&
 801                  eina_list_data_find(ins, obj) &&
 802                  (!evas_event_passes_through(obj)) &&
 803                  (!evas_event_freezes_through(obj)) &&
 804                  (!obj->clip.clipees) &&
 805                  ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y))
 806                 )
 807                {
 808                   if ((px != x) || (py != y))
 809                     {
 810                        ev.cur.canvas.x = e->pointer.x;
 811                        ev.cur.canvas.y = e->pointer.y;
 812                        _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed);
 813                        evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id);
 814                     }
 815                }
 816              /* otherwise it has left the object */
 817              else
 818                {
 819                   if (obj->mouse_in)
 820                     {
 821                        obj->mouse_in = 0;
 822                        ev2.canvas.x = e->pointer.x;
 823                        ev2.canvas.y = e->pointer.y;
 824                        _evas_event_havemap_adjust(obj, &ev2.canvas.x, &ev2.canvas.y, obj->mouse_grabbed);
 825                        if (e->events_frozen <= 0)
 826                           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev2, event_id);
 827                     }
 828                }
 829              if (e->delete_me) break;
 830           }
 831         _evas_post_event_callback_call(e);
 832
 833         _evas_object_event_new();
 834
 835         event_id2 = _evas_event_counter;
 836         if (copy) copy = eina_list_free(copy);
 837         /* go thru our current list of ins */
 838         EINA_LIST_FOREACH(ins, l, obj)
 839           {
 840              ev3.canvas.x = e->pointer.x;
 841              ev3.canvas.y = e->pointer.y;
 842              _evas_event_havemap_adjust(obj, &ev3.canvas.x, &ev3.canvas.y, obj->mouse_grabbed);
 843              /* if its not in the old list of ins send an enter event */
 844              if (!eina_list_data_find(e->pointer.object.in, obj))
 845                {
 846                   if (!obj->mouse_in)
 847                     {
 848                        obj->mouse_in = 1;
 849                        if (e->events_frozen <= 0)
 850                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev3, event_id2);
 851                     }
 852                }
 853              if (e->delete_me) break;
 854           }
 855         if (e->pointer.mouse_grabbed == 0)
 856           {
 857              /* free our old list of ins */
 858              eina_list_free(e->pointer.object.in);
 859              /* and set up the new one */
 860              e->pointer.object.in = ins;
 861           }
 862         else
 863           {
 864              /* free our cur ins */
 865              eina_list_free(ins);
 866           }
 867         _evas_post_event_callback_call(e);
 868      }
 869    _evas_unwalk(e);
 870    return;
 871 nogrep:
 872      {
 873         Eina_List *ins = NULL;
 874         Eina_List *newin = NULL;
 875         Eina_List *l, *copy, *lst = NULL;
 876         Evas_Event_Mouse_Move ev;
 877         Evas_Event_Mouse_Out ev2;
 878         Evas_Event_Mouse_In ev3;
 879         Evas_Object *obj, *below_obj;
 880         int event_id = 0, event_id2 = 0;
 881         int norep = 0, breaknext = 0;
 882
 883         _evas_object_event_new();
 884
 885         event_id = _evas_event_counter;
 886         ev.buttons = e->pointer.button;
 887         ev.cur.output.x = e->pointer.x;
 888         ev.cur.output.y = e->pointer.y;
 889         ev.cur.canvas.x = e->pointer.x;
 890         ev.cur.canvas.y = e->pointer.y;
 891         ev.prev.output.x = px;
 892         ev.prev.output.y = py;
 893         ev.prev.canvas.x = px;
 894         ev.prev.canvas.y = py;
 895         ev.data = (void *)data;
 896         ev.modifiers = &(e->modifiers);
 897         ev.locks = &(e->locks);
 898         ev.timestamp = timestamp;
 899         ev.event_flags = e->default_event_flags;
 900
 901         ev2.buttons = e->pointer.button;
 902         ev2.output.x = e->pointer.x;
 903         ev2.output.y = e->pointer.y;
 904         ev2.canvas.x = e->pointer.x;
 905         ev2.canvas.y = e->pointer.y;
 906         ev2.data = (void *)data;
 907         ev2.modifiers = &(e->modifiers);
 908         ev2.locks = &(e->locks);
 909         ev2.timestamp = timestamp;
 910         ev2.event_flags = e->default_event_flags;
 911
 912         ev3.buttons = e->pointer.button;
 913         ev3.output.x = e->pointer.x;
 914         ev3.output.y = e->pointer.y;
 915         ev3.canvas.x = e->pointer.x;
 916         ev3.canvas.y = e->pointer.y;
 917         ev3.data = (void *)data;
 918         ev3.modifiers = &(e->modifiers);
 919         ev3.locks = &(e->locks);
 920         ev3.timestamp = timestamp;
 921         ev3.event_flags = e->default_event_flags;
 922
 923         /* go thru old list of in objects */
 924         copy = evas_event_list_copy(e->pointer.object.in);
 925         EINA_LIST_FOREACH(copy, l, obj)
 926           {
 927              if (breaknext)
 928                {
 929                   lst = l;
 930                   break;
 931                }
 932              if (obj == nogrep_obj) breaknext = 1;
 933           }
 934
 935         /* get all new in objects */
 936         below_obj = evas_object_below_get(nogrep_obj);
 937         if (below_obj)
 938           ins = _evas_event_object_list_raw_in_get(e, NULL,
 939                                                    EINA_INLIST_GET(below_obj), NULL,
 940                                                    e->pointer.x, e->pointer.y,
 941                                                    &norep);
 942         EINA_LIST_FOREACH(copy, l, obj)
 943           {
 944              newin = eina_list_append(newin, obj);
 945              if (obj == nogrep_obj) break;
 946           }
 947         EINA_LIST_FOREACH(ins, l, obj)
 948           {
 949              newin = eina_list_append(newin, obj);
 950           }
 951
 952         EINA_LIST_FOREACH(lst, l, obj)
 953           {
 954              /* if its under the pointer and its visible and its in the new */
 955              /* in list */
 956              // FIXME: i don't think we need this
 957              //      evas_object_clip_recalc(obj);
 958              if ((e->events_frozen <= 0) &&
 959                  evas_object_is_in_output_rect(obj, x, y, 1, 1) &&
 960                  (evas_object_clippers_is_visible(obj) ||
 961                   obj->mouse_grabbed) &&
 962                  eina_list_data_find(newin, obj) &&
 963                  (!evas_event_passes_through(obj)) &&
 964                  (!evas_event_freezes_through(obj)) &&
 965                  (!obj->clip.clipees) &&
 966                  ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y))
 967                 )
 968                {
 969                   if ((px != x) || (py != y))
 970                     {
 971                        ev.cur.canvas.x = e->pointer.x;
 972                        ev.cur.canvas.y = e->pointer.y;
 973                        _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed);
 974                        evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id);
 975                     }
 976                }
 977              /* otherwise it has left the object */
 978              else
 979                {
 980                   if (obj->mouse_in)
 981                     {
 982                        obj->mouse_in = 0;
 983                        ev2.canvas.x = e->pointer.x;
 984                        ev2.canvas.y = e->pointer.y;
 985                        _evas_event_havemap_adjust(obj, &ev2.canvas.x, &ev2.canvas.y, obj->mouse_grabbed);
 986                        if (e->events_frozen <= 0)
 987                           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev2, event_id);
 988                     }
 989                }
 990              if (e->delete_me) break;
 991           }
 992         _evas_post_event_callback_call(e);
 993
 994         _evas_object_event_new();
 995
 996         event_id2 = _evas_event_counter;
 997         if (copy) copy = eina_list_free(copy);
 998         /* go thru our current list of ins */
 999         EINA_LIST_FOREACH(newin, l, obj)
1000           {
1001              ev3.canvas.x = e->pointer.x;
1002              ev3.canvas.y = e->pointer.y;
1003              _evas_event_havemap_adjust(obj, &ev3.canvas.x, &ev3.canvas.y, obj->mouse_grabbed);
1004              /* if its not in the old list of ins send an enter event */
1005              if (!eina_list_data_find(e->pointer.object.in, obj))
1006                {
1007                   if (!obj->mouse_in)
1008                     {
1009                        obj->mouse_in = 1;
1010                        if (e->events_frozen <= 0)
1011                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev3, event_id2);
1012                     }
1013                }
1014              if (e->delete_me) break;
1015           }
1016         /* free our old list of ins */
1017         eina_list_free(e->pointer.object.in);
1018         /* and set up the new one */
1019         e->pointer.object.in = newin;
1020
1021         _evas_post_event_callback_call(e);
1022      }
1023    _evas_unwalk(e);
1024 }
1025
1026 EAPI void
1027 evas_event_feed_mouse_in(Evas *e, unsigned int timestamp, const void *data)
1028 {
1029    Eina_List *ins;
1030    Eina_List *l;
1031    Evas_Event_Mouse_In ev;
1032    Evas_Object *obj;
1033    int event_id = 0;
1034
1035    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1036    return;
1037    MAGIC_CHECK_END();
1038    e->pointer.inside = 1;
1039
1040    if (e->events_frozen > 0) return;
1041    e->last_timestamp = timestamp;
1042
1043    if (e->pointer.mouse_grabbed != 0) return;
1044
1045    _evas_object_event_new();
1046
1047    event_id = _evas_event_counter;
1048    ev.buttons = e->pointer.button;
1049    ev.output.x = e->pointer.x;
1050    ev.output.y = e->pointer.y;
1051    ev.canvas.x = e->pointer.x;
1052    ev.canvas.y = e->pointer.y;
1053    ev.data = (void *)data;
1054    ev.modifiers = &(e->modifiers);
1055    ev.locks = &(e->locks);
1056    ev.timestamp = timestamp;
1057    ev.event_flags = e->default_event_flags;
1058
1059    _evas_walk(e);
1060    /* get new list of ins */
1061    ins = evas_event_objects_event_list(e, NULL, e->pointer.x, e->pointer.y);
1062    EINA_LIST_FOREACH(ins, l, obj)
1063      {
1064         ev.canvas.x = e->pointer.x;
1065         ev.canvas.y = e->pointer.y;
1066         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
1067         if (!eina_list_data_find(e->pointer.object.in, obj))
1068           {
1069              if (!obj->mouse_in)
1070                {
1071                   obj->mouse_in = 1;
1072                   if (e->events_frozen <= 0)
1073                      evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev, event_id);
1074                }
1075           }
1076         if (e->delete_me) break;
1077      }
1078    /* free our old list of ins */
1079    e->pointer.object.in = eina_list_free(e->pointer.object.in);
1080    /* and set up the new one */
1081    e->pointer.object.in = ins;
1082    _evas_post_event_callback_call(e);
1083    evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y, timestamp, data);
1084    _evas_unwalk(e);
1085 }
1086
1087 EAPI void
1088 evas_event_feed_mouse_out(Evas *e, unsigned int timestamp, const void *data)
1089 {
1090    Evas_Event_Mouse_Out ev;
1091    int event_id = 0;
1092
1093    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1094    return;
1095    MAGIC_CHECK_END();
1096    e->pointer.inside = 0;
1097
1098    if (e->events_frozen > 0) return;
1099    e->last_timestamp = timestamp;
1100
1101    _evas_object_event_new();
1102
1103    event_id = _evas_event_counter;
1104    ev.buttons = e->pointer.button;
1105    ev.output.x = e->pointer.x;
1106    ev.output.y = e->pointer.y;
1107    ev.canvas.x = e->pointer.x;
1108    ev.canvas.y = e->pointer.y;
1109    ev.data = (void *)data;
1110    ev.modifiers = &(e->modifiers);
1111    ev.locks = &(e->locks);
1112    ev.timestamp = timestamp;
1113    ev.event_flags = e->default_event_flags;
1114
1115    _evas_walk(e);
1116    /* if our mouse button is inside any objects */
1117      {
1118         /* go thru old list of in objects */
1119         Eina_List *l, *copy;
1120         Evas_Object *obj;
1121
1122         copy = evas_event_list_copy(e->pointer.object.in);
1123         EINA_LIST_FOREACH(copy, l, obj)
1124           {
1125              ev.canvas.x = e->pointer.x;
1126              ev.canvas.y = e->pointer.y;
1127              _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
1128              if (obj->mouse_in)
1129                {
1130                   obj->mouse_in = 0;
1131                   if (!obj->delete_me)
1132                     {
1133                        if (e->events_frozen <= 0)
1134                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id);
1135                     }
1136                   obj->mouse_grabbed = 0;
1137                }
1138              if (e->delete_me) break;
1139           }
1140         if (copy) copy = eina_list_free(copy);
1141         /* free our old list of ins */
1142         e->pointer.object.in =  eina_list_free(e->pointer.object.in);
1143         e->pointer.mouse_grabbed = 0;
1144         _evas_post_event_callback_call(e);
1145      }
1146    _evas_unwalk(e);
1147 }
1148
1149 EAPI void
1150 evas_event_feed_multi_down(Evas *e,
1151                            int d, int x, int y,
1152                            double rad, double radx, double rady,
1153                            double pres, double ang,
1154                            double fx, double fy,
1155                            Evas_Button_Flags flags, unsigned int timestamp,
1156                            const void *data)
1157 {
1158    Eina_List *l, *copy;
1159    Evas_Event_Multi_Down ev;
1160    Evas_Object *obj;
1161    int addgrab = 0;
1162    int event_id = 0;
1163
1164    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1165    return;
1166    MAGIC_CHECK_END();
1167
1168    e->pointer.downs++;
1169    if (e->events_frozen > 0) return;
1170    e->last_timestamp = timestamp;
1171
1172    _evas_object_event_new();
1173
1174    event_id = _evas_event_counter;
1175    ev.device = d;
1176    ev.output.x = x;
1177    ev.output.y = y;
1178    ev.canvas.x = x;
1179    ev.canvas.y = y;
1180    ev.radius = rad;
1181    ev.radius_x = radx;
1182    ev.radius_y = rady;
1183    ev.pressure = pres;
1184    ev.angle = ang;
1185    ev.canvas.xsub = fx;
1186    ev.canvas.ysub = fy;
1187    ev.data = (void *)data;
1188    ev.modifiers = &(e->modifiers);
1189    ev.locks = &(e->locks);
1190    ev.flags = flags;
1191    ev.timestamp = timestamp;
1192    ev.event_flags = e->default_event_flags;
1193
1194    _evas_walk(e);
1195    /* append new touch point to the touch point list */
1196    _evas_touch_point_append(e, d, x, y);
1197    if (e->pointer.mouse_grabbed == 0)
1198      {
1199         if (e->pointer.downs > 1) addgrab = e->pointer.downs - 1;
1200      }
1201    copy = evas_event_list_copy(e->pointer.object.in);
1202    EINA_LIST_FOREACH(copy, l, obj)
1203      {
1204         if (obj->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB)
1205           {
1206              obj->mouse_grabbed += addgrab + 1;
1207              e->pointer.mouse_grabbed += addgrab + 1;
1208           }
1209      }
1210    EINA_LIST_FOREACH(copy, l, obj)
1211      {
1212         ev.canvas.x = x;
1213         ev.canvas.y = y;
1214         ev.canvas.xsub = fx;
1215         ev.canvas.ysub = fy;
1216         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
1217         if (x != ev.canvas.x)
1218           ev.canvas.xsub = ev.canvas.x; // fixme - lost precision
1219         if (y != ev.canvas.y)
1220           ev.canvas.ysub = ev.canvas.y; // fixme - lost precision
1221         if (e->events_frozen <= 0)
1222           evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_DOWN, &ev, event_id);
1223         if (e->delete_me) break;
1224      }
1225    if (copy) eina_list_free(copy);
1226    _evas_post_event_callback_call(e);
1227    /* update touch point's state to EVAS_TOUCH_POINT_STILL */
1228    _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_STILL);
1229    _evas_unwalk(e);
1230 }
1231
1232 EAPI void
1233 evas_event_feed_multi_up(Evas *e,
1234                          int d, int x, int y,
1235                          double rad, double radx, double rady,
1236                          double pres, double ang,
1237                          double fx, double fy,
1238                          Evas_Button_Flags flags, unsigned int timestamp,
1239                          const void *data)
1240 {
1241    Eina_List *l, *copy;
1242    Evas_Event_Multi_Up ev;
1243    Evas_Object *obj;
1244    int event_id = 0;
1245
1246    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1247    return;
1248    MAGIC_CHECK_END();
1249
1250    e->pointer.downs--;
1251    if (e->events_frozen > 0) return;
1252    e->last_timestamp = timestamp;
1253
1254    _evas_object_event_new();
1255
1256    event_id = _evas_event_counter;
1257    ev.device = d;
1258    ev.output.x = x;
1259    ev.output.y = y;
1260    ev.canvas.x = x;
1261    ev.canvas.y = y;
1262    ev.radius = rad;
1263    ev.radius_x = radx;
1264    ev.radius_y = rady;
1265    ev.pressure = pres;
1266    ev.angle = ang;
1267    ev.canvas.xsub = fx;
1268    ev.canvas.ysub = fy;
1269    ev.data = (void *)data;
1270    ev.modifiers = &(e->modifiers);
1271    ev.locks = &(e->locks);
1272    ev.flags = flags;
1273    ev.timestamp = timestamp;
1274    ev.event_flags = e->default_event_flags;
1275
1276    _evas_walk(e);
1277    /* update released touch point */
1278    _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_UP);
1279    copy = evas_event_list_copy(e->pointer.object.in);
1280    EINA_LIST_FOREACH(copy, l, obj)
1281      {
1282         ev.canvas.x = x;
1283         ev.canvas.y = y;
1284         ev.canvas.xsub = fx;
1285         ev.canvas.ysub = fy;
1286         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
1287         if (x != ev.canvas.x)
1288           ev.canvas.xsub = ev.canvas.x; // fixme - lost precision
1289         if (y != ev.canvas.y)
1290           ev.canvas.ysub = ev.canvas.y; // fixme - lost precision
1291         if ((obj->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB) &&
1292             (obj->mouse_grabbed > 0))
1293           {
1294              obj->mouse_grabbed--;
1295              e->pointer.mouse_grabbed--;
1296           }
1297         if (e->events_frozen <= 0)
1298           evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_UP, &ev, event_id);
1299         if (e->delete_me) break;
1300      }
1301    if (copy) copy = eina_list_free(copy);
1302    if ((e->pointer.mouse_grabbed == 0) && !_post_up_handle(e, timestamp, data))
1303       _evas_post_event_callback_call(e);
1304    /* remove released touch point from the touch point list */
1305    _evas_touch_point_remove(e, d);
1306    _evas_unwalk(e);
1307 }
1308
1309 EAPI void
1310 evas_event_feed_multi_move(Evas *e,
1311                            int d, int x, int y,
1312                            double rad, double radx, double rady,
1313                            double pres, double ang,
1314                            double fx, double fy,
1315                            unsigned int timestamp, const void *data)
1316 {
1317    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1318    return;
1319    MAGIC_CHECK_END();
1320
1321    if (e->events_frozen > 0) return;
1322    e->last_timestamp = timestamp;
1323
1324    if ((!e->pointer.inside) && (e->pointer.mouse_grabbed == 0)) return;
1325
1326    _evas_walk(e);
1327    /* update moved touch point */
1328    _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_MOVE);
1329    /* if our mouse button is grabbed to any objects */
1330    if (e->pointer.mouse_grabbed > 0)
1331      {
1332         /* go thru old list of in objects */
1333         Eina_List *l, *copy;
1334         Evas_Event_Multi_Move ev;
1335         Evas_Object *obj;
1336         int event_id = 0;
1337
1338         _evas_object_event_new();
1339
1340         event_id = _evas_event_counter;
1341         ev.device = d;
1342         ev.cur.output.x = x;
1343         ev.cur.output.y = y;
1344         ev.cur.canvas.x = x;
1345         ev.cur.canvas.y = y;
1346         ev.radius = rad;
1347         ev.radius_x = radx;
1348         ev.radius_y = rady;
1349         ev.pressure = pres;
1350         ev.angle = ang;
1351         ev.cur.canvas.xsub = fx;
1352         ev.cur.canvas.ysub = fy;
1353         ev.data = (void *)data;
1354         ev.modifiers = &(e->modifiers);
1355         ev.locks = &(e->locks);
1356         ev.timestamp = timestamp;
1357         ev.event_flags = e->default_event_flags;
1358
1359         copy = evas_event_list_copy(e->pointer.object.in);
1360         EINA_LIST_FOREACH(copy, l, obj)
1361           {
1362              if ((e->events_frozen <= 0) &&
1363                  (evas_object_clippers_is_visible(obj) || obj->mouse_grabbed) &&
1364                  (!evas_event_passes_through(obj)) &&
1365                  (!evas_event_freezes_through(obj)) &&
1366                  (!obj->clip.clipees))
1367                {
1368                   ev.cur.canvas.x = x;
1369                   ev.cur.canvas.y = y;
1370                   ev.cur.canvas.xsub = fx;
1371                   ev.cur.canvas.ysub = fy;
1372                   _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed);
1373                   if (x != ev.cur.canvas.x)
1374                     ev.cur.canvas.xsub = ev.cur.canvas.x; // fixme - lost precision
1375                   if (y != ev.cur.canvas.y)
1376                     ev.cur.canvas.ysub = ev.cur.canvas.y; // fixme - lost precision
1377                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_MOVE, &ev, event_id);
1378                }
1379              if (e->delete_me) break;
1380           }
1381         _evas_post_event_callback_call(e);
1382      }
1383    else
1384      {
1385         Eina_List *ins;
1386         Eina_List *l, *copy;
1387         Evas_Event_Multi_Move ev;
1388         Evas_Object *obj;
1389         int event_id = 0;
1390
1391         _evas_object_event_new();
1392
1393         event_id = _evas_event_counter;
1394         ev.device = d;
1395         ev.cur.output.x = x;
1396         ev.cur.output.y = y;
1397         ev.cur.canvas.x = x;
1398         ev.cur.canvas.y = y;
1399         ev.radius = rad;
1400         ev.radius_x = radx;
1401         ev.radius_y = rady;
1402         ev.pressure = pres;
1403         ev.angle = ang;
1404         ev.cur.canvas.xsub = fx;
1405         ev.cur.canvas.ysub = fy;
1406         ev.data = (void *)data;
1407         ev.modifiers = &(e->modifiers);
1408         ev.locks = &(e->locks);
1409         ev.timestamp = timestamp;
1410         ev.event_flags = e->default_event_flags;
1411
1412         /* get all new in objects */
1413         ins = evas_event_objects_event_list(e, NULL, x, y);
1414         /* go thru old list of in objects */
1415         copy = evas_event_list_copy(e->pointer.object.in);
1416         EINA_LIST_FOREACH(copy, l, obj)
1417           {
1418              /* if its under the pointer and its visible and its in the new */
1419              /* in list */
1420              // FIXME: i don't think we need this
1421              //      evas_object_clip_recalc(obj);
1422              if ((e->events_frozen <= 0) &&
1423                  evas_object_is_in_output_rect(obj, x, y, 1, 1) &&
1424                  (evas_object_clippers_is_visible(obj) ||
1425                   obj->mouse_grabbed) &&
1426                  eina_list_data_find(ins, obj) &&
1427                  (!evas_event_passes_through(obj)) &&
1428                  (!evas_event_freezes_through(obj)) &&
1429                  (!obj->clip.clipees) &&
1430                  ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y))
1431                 )
1432                {
1433                   ev.cur.canvas.x = x;
1434                   ev.cur.canvas.y = y;
1435                   ev.cur.canvas.xsub = fx;
1436                   ev.cur.canvas.ysub = fy;
1437                   _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed);
1438                   if (x != ev.cur.canvas.x)
1439                     ev.cur.canvas.xsub = ev.cur.canvas.x; // fixme - lost precision
1440                   if (y != ev.cur.canvas.y)
1441                     ev.cur.canvas.ysub = ev.cur.canvas.y; // fixme - lost precision
1442                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_MOVE, &ev, event_id);
1443                }
1444              if (e->delete_me) break;
1445           }
1446         if (copy) copy = eina_list_free(copy);
1447         if (e->pointer.mouse_grabbed == 0)
1448           {
1449              /* free our old list of ins */
1450              eina_list_free(e->pointer.object.in);
1451              /* and set up the new one */
1452              e->pointer.object.in = ins;
1453           }
1454         else
1455           {
1456              /* free our cur ins */
1457              eina_list_free(ins);
1458           }
1459         _evas_post_event_callback_call(e);
1460      }
1461    _evas_unwalk(e);
1462 }
1463
1464 EAPI void
1465 evas_event_feed_key_down(Evas *e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data)
1466 {
1467    int event_id = 0;
1468    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1469    return;
1470    MAGIC_CHECK_END();
1471
1472    if (!keyname) return;
1473    if (e->events_frozen > 0) return;
1474    e->last_timestamp = timestamp;
1475    _evas_walk(e);
1476
1477    Evas_Event_Key_Down ev;
1478    Eina_Bool exclusive;
1479
1480    _evas_object_event_new();
1481
1482    event_id = _evas_event_counter;
1483    exclusive = EINA_FALSE;
1484    ev.keyname = (char *)keyname;
1485    ev.data = (void *)data;
1486    ev.modifiers = &(e->modifiers);
1487    ev.locks = &(e->locks);
1488    ev.key = key;
1489    ev.string = string;
1490    ev.compose = compose;
1491    ev.timestamp = timestamp;
1492    ev.event_flags = e->default_event_flags;
1493
1494    if (e->grabs)
1495      {
1496         Eina_List *l;
1497         Evas_Key_Grab *g;
1498
1499         e->walking_grabs++;
1500         EINA_LIST_FOREACH(e->grabs, l, g)
1501           {
1502              if (g->just_added)
1503                {
1504                   g->just_added = EINA_FALSE;
1505                   continue;
1506                }
1507              if (g->delete_me) continue;
1508              if (((e->modifiers.mask & g->modifiers) ||
1509                   (g->modifiers == e->modifiers.mask)) &&
1510                  (!strcmp(keyname, g->keyname)))
1511                {
1512                   if (!(e->modifiers.mask & g->not_modifiers))
1513                     {
1514                        if (e->events_frozen <= 0 &&
1515                            !evas_event_freezes_through(g->object))
1516                          evas_object_event_callback_call(g->object,
1517                                                          EVAS_CALLBACK_KEY_DOWN,
1518                                                          &ev, event_id);
1519                        if (g->exclusive) exclusive = EINA_TRUE;
1520                     }
1521                }
1522              if (e->delete_me) break;
1523           }
1524         e->walking_grabs--;
1525         if (e->walking_grabs <= 0)
1526           {
1527              while (e->delete_grabs > 0)
1528                {
1529                   e->delete_grabs--;
1530                   for (l = e->grabs; l;)
1531                     {
1532                        g = eina_list_data_get(l);
1533                        l = eina_list_next(l);
1534                        if (g->delete_me)
1535                          evas_key_grab_free(g->object, g->keyname, g->modifiers,
1536                                             g->not_modifiers);
1537                     }
1538                }
1539           }
1540      }
1541    if ((e->focused) && (!exclusive))
1542      {
1543         if (e->events_frozen <= 0 && !evas_event_freezes_through(e->focused))
1544           evas_object_event_callback_call(e->focused, EVAS_CALLBACK_KEY_DOWN,
1545                                           &ev, event_id);
1546      }
1547    _evas_post_event_callback_call(e);
1548    _evas_unwalk(e);
1549 }
1550
1551 EAPI void
1552 evas_event_feed_key_up(Evas *e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data)
1553 {
1554    int event_id = 0;
1555    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1556    return;
1557    MAGIC_CHECK_END();
1558    if (!keyname) return;
1559    if (e->events_frozen > 0) return;
1560    e->last_timestamp = timestamp;
1561    _evas_walk(e);
1562
1563    Evas_Event_Key_Up ev;
1564    Eina_Bool exclusive;
1565
1566    _evas_object_event_new();
1567
1568    event_id = _evas_event_counter;
1569    exclusive = EINA_FALSE;
1570    ev.keyname = (char *)keyname;
1571    ev.data = (void *)data;
1572    ev.modifiers = &(e->modifiers);
1573    ev.locks = &(e->locks);
1574    ev.key = key;
1575    ev.string = string;
1576    ev.compose = compose;
1577    ev.timestamp = timestamp;
1578    ev.event_flags = e->default_event_flags;
1579
1580    if (e->grabs)
1581      {
1582         Eina_List *l;
1583         Evas_Key_Grab *g;
1584
1585         e->walking_grabs++;
1586         EINA_LIST_FOREACH(e->grabs, l, g)
1587           {
1588              if (g->just_added)
1589                {
1590                   g->just_added = EINA_FALSE;
1591                   continue;
1592                }
1593              if (g->delete_me) continue;
1594              if (((e->modifiers.mask & g->modifiers) ||
1595                   (g->modifiers == e->modifiers.mask)) &&
1596                  (!((e->modifiers.mask & g->not_modifiers) ||
1597                     (g->not_modifiers == ~e->modifiers.mask))) &&
1598                  (!strcmp(keyname, g->keyname)))
1599                {
1600                   if (e->events_frozen <= 0 &&
1601                       !evas_event_freezes_through(g->object))
1602                     evas_object_event_callback_call(g->object,
1603                                                     EVAS_CALLBACK_KEY_UP, &ev, event_id);
1604                   if (g->exclusive) exclusive = EINA_TRUE;
1605                }
1606              if (e->delete_me) break;
1607           }
1608         e->walking_grabs--;
1609         if (e->walking_grabs <= 0)
1610           {
1611              while (e->delete_grabs > 0)
1612                {
1613                   Eina_List *ll, *l_next;
1614                   Evas_Key_Grab *gr;
1615
1616                   e->delete_grabs--;
1617                   EINA_LIST_FOREACH_SAFE(e->grabs, ll, l_next, gr)
1618                     {
1619                        if (gr->delete_me)
1620                          evas_key_grab_free(gr->object, gr->keyname,
1621                                             gr->modifiers, gr->not_modifiers);
1622                     }
1623                }
1624           }
1625      }
1626    if ((e->focused) && (!exclusive))
1627      {
1628         if (e->events_frozen <= 0 && !evas_event_freezes_through(e->focused))
1629           evas_object_event_callback_call(e->focused, EVAS_CALLBACK_KEY_UP,
1630                                           &ev, event_id);
1631      }
1632    _evas_post_event_callback_call(e);
1633    _evas_unwalk(e);
1634 }
1635
1636 EAPI void
1637 evas_event_feed_hold(Evas *e, int hold, unsigned int timestamp, const void *data)
1638 {
1639    Eina_List *l, *copy;
1640    Evas_Event_Hold ev;
1641    Evas_Object *obj;
1642    int event_id = 0;
1643
1644    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1645    return;
1646    MAGIC_CHECK_END();
1647
1648    if (e->events_frozen > 0) return;
1649    e->last_timestamp = timestamp;
1650
1651    _evas_object_event_new();
1652
1653    event_id = _evas_event_counter;
1654    ev.hold = hold;
1655    ev.data = (void *)data;
1656    ev.timestamp = timestamp;
1657    ev.event_flags = e->default_event_flags;
1658
1659    _evas_walk(e);
1660    copy = evas_event_list_copy(e->pointer.object.in);
1661    EINA_LIST_FOREACH(copy, l, obj)
1662      {
1663         if ((e->events_frozen <= 0) && !evas_event_freezes_through(obj))
1664           evas_object_event_callback_call(obj, EVAS_CALLBACK_HOLD, &ev, event_id);
1665         if (e->delete_me) break;
1666      }
1667    if (copy) copy = eina_list_free(copy);
1668    _evas_post_event_callback_call(e);
1669    _evas_unwalk(e);
1670    _evas_object_event_new();
1671 }
1672
1673 EAPI void
1674 evas_object_freeze_events_set(Evas_Object *obj, Eina_Bool freeze)
1675 {
1676    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1677    return;
1678    MAGIC_CHECK_END();
1679
1680    freeze = !!freeze;
1681    if (obj->freeze_events == freeze) return;
1682    obj->freeze_events = freeze;
1683    evas_object_smart_member_cache_invalidate(obj, EINA_FALSE, EINA_TRUE);
1684 }
1685
1686 EAPI Eina_Bool
1687 evas_object_freeze_events_get(const Evas_Object *obj)
1688 {
1689    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1690    return EINA_FALSE;
1691    MAGIC_CHECK_END();
1692    return obj->freeze_events;
1693 }
1694
1695 EAPI void
1696 evas_object_pass_events_set(Evas_Object *obj, Eina_Bool pass)
1697 {
1698    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1699    return;
1700    MAGIC_CHECK_END();
1701    pass = !!pass;
1702    if (obj->pass_events == pass) return;
1703    obj->pass_events = pass;
1704    evas_object_smart_member_cache_invalidate(obj, EINA_TRUE, EINA_FALSE);
1705    if (evas_object_is_in_output_rect(obj,
1706                                      obj->layer->evas->pointer.x,
1707                                      obj->layer->evas->pointer.y, 1, 1) &&
1708        ((!obj->precise_is_inside) ||
1709         (evas_object_is_inside(obj,
1710                                obj->layer->evas->pointer.x,
1711                                obj->layer->evas->pointer.y))))
1712      evas_event_feed_mouse_move(obj->layer->evas,
1713                                 obj->layer->evas->pointer.x,
1714                                 obj->layer->evas->pointer.y,
1715                                 obj->layer->evas->last_timestamp,
1716                                 NULL);
1717 }
1718
1719 EAPI Eina_Bool
1720 evas_object_pass_events_get(const Evas_Object *obj)
1721 {
1722    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1723    return EINA_FALSE;
1724    MAGIC_CHECK_END();
1725    return obj->pass_events;
1726 }
1727
1728 EAPI void
1729 evas_object_repeat_events_set(Evas_Object *obj, Eina_Bool repeat)
1730 {
1731    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1732    return;
1733    MAGIC_CHECK_END();
1734    repeat = !!repeat;
1735    if (obj->repeat_events == repeat) return;
1736    obj->repeat_events = repeat;
1737    if (evas_object_is_in_output_rect(obj,
1738                                      obj->layer->evas->pointer.x,
1739                                      obj->layer->evas->pointer.y, 1, 1) &&
1740        ((!obj->precise_is_inside) ||
1741         (evas_object_is_inside(obj,
1742                                obj->layer->evas->pointer.x,
1743                                obj->layer->evas->pointer.y))))
1744      evas_event_feed_mouse_move(obj->layer->evas,
1745                                 obj->layer->evas->pointer.x,
1746                                 obj->layer->evas->pointer.y,
1747                                 obj->layer->evas->last_timestamp,
1748                                 NULL);
1749 }
1750
1751 EAPI Eina_Bool
1752 evas_object_repeat_events_get(const Evas_Object *obj)
1753 {
1754    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1755    return EINA_FALSE;
1756    MAGIC_CHECK_END();
1757    return obj->repeat_events;
1758 }
1759
1760 EAPI void
1761 evas_object_propagate_events_set(Evas_Object *obj, Eina_Bool prop)
1762 {
1763    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1764    return;
1765    MAGIC_CHECK_END();
1766    obj->no_propagate = !prop;
1767 }
1768
1769 EAPI Eina_Bool
1770 evas_object_propagate_events_get(const Evas_Object *obj)
1771 {
1772    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1773    return EINA_FALSE;
1774    MAGIC_CHECK_END();
1775    return !(obj->no_propagate);
1776 }
1777
1778 EAPI void
1779 evas_object_pointer_mode_set(Evas_Object *obj, Evas_Object_Pointer_Mode setting)
1780 {
1781    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1782    return;
1783    MAGIC_CHECK_END();
1784    obj->pointer_mode = setting;
1785 }
1786
1787 EAPI Evas_Object_Pointer_Mode
1788 evas_object_pointer_mode_get(const Evas_Object *obj)
1789 {
1790    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1791    return EVAS_OBJECT_POINTER_MODE_AUTOGRAB;
1792    MAGIC_CHECK_END();
1793    return obj->pointer_mode;
1794 }
1795
1796 EAPI void
1797 evas_event_refeed_event(Evas *e, void *event_copy, Evas_Callback_Type event_type)
1798 {
1799    if (!event_copy) return;
1800
1801    switch (event_type)
1802      {
1803       case EVAS_CALLBACK_MOUSE_IN:
1804           {
1805              Evas_Event_Mouse_In *ev = event_copy;
1806              evas_event_feed_mouse_in(e, ev->timestamp, ev->data);
1807              break;
1808           }
1809       case EVAS_CALLBACK_MOUSE_OUT:
1810           {
1811              Evas_Event_Mouse_Out *ev = event_copy;
1812              evas_event_feed_mouse_out(e, ev->timestamp, ev->data);
1813              break;
1814           }
1815       case EVAS_CALLBACK_MOUSE_DOWN:
1816           {
1817              Evas_Event_Mouse_Down *ev = event_copy;
1818              evas_event_feed_mouse_down(e, ev->button, ev->flags, ev-> timestamp, ev->data);
1819              break;
1820           }
1821       case EVAS_CALLBACK_MOUSE_UP:
1822           {
1823              Evas_Event_Mouse_Up *ev = event_copy;
1824              evas_event_feed_mouse_up(e, ev->button, ev->flags, ev-> timestamp, ev->data);
1825              break;
1826           }
1827       case EVAS_CALLBACK_MOUSE_MOVE:
1828           {
1829              Evas_Event_Mouse_Move *ev = event_copy;
1830              evas_event_feed_mouse_move(e, ev->cur.canvas.x, ev->cur.canvas.y, ev->timestamp, ev->data);
1831              break;
1832           }
1833       case EVAS_CALLBACK_MOUSE_WHEEL:
1834           {
1835              Evas_Event_Mouse_Wheel *ev = event_copy;
1836              evas_event_feed_mouse_wheel(e, ev->direction, ev-> z, ev->timestamp, ev->data);
1837              break;
1838           }
1839       case EVAS_CALLBACK_MULTI_DOWN:
1840           {
1841              Evas_Event_Multi_Down *ev = event_copy;
1842              evas_event_feed_multi_down(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);
1843              break;
1844           }
1845       case EVAS_CALLBACK_MULTI_UP:
1846           {
1847              Evas_Event_Multi_Up *ev = event_copy;
1848              evas_event_feed_multi_up(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);
1849              break;
1850           }
1851       case EVAS_CALLBACK_MULTI_MOVE:
1852           {
1853              Evas_Event_Multi_Move *ev = event_copy;
1854              evas_event_feed_multi_move(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);
1855              break;
1856           }
1857       case EVAS_CALLBACK_KEY_DOWN:
1858           {
1859              Evas_Event_Key_Down *ev = event_copy;
1860              evas_event_feed_key_down(e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data);
1861              break;
1862           }
1863       case EVAS_CALLBACK_KEY_UP:
1864           {
1865              Evas_Event_Key_Up *ev = event_copy;
1866              evas_event_feed_key_up(e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data);
1867              break;
1868           }
1869       default: /* All non-input events are not handeled */
1870         break;
1871      }
1872 }
1873
1874 EAPI int
1875 evas_event_down_count_get(const Evas *e)
1876 {
1877    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1878    return 0;
1879    MAGIC_CHECK_END();
1880    return e->pointer.downs;
1881 }