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    if (e->pointer.downs <= 0) return;
 458
 459    e->pointer.button &= ~(1 << (b - 1));
 460    e->pointer.downs--;
 461
 462    if (e->events_frozen > 0) return;
 463    e->last_timestamp = timestamp;
 464
 465      {
 466         Evas_Event_Mouse_Up ev;
 467         Evas_Object *obj;
 468         int event_id = 0;
 469
 470         _evas_object_event_new();
 471
 472         event_id = _evas_event_counter;
 473         ev.button = b;
 474         ev.output.x = e->pointer.x;
 475         ev.output.y = e->pointer.y;
 476         ev.canvas.x = e->pointer.x;
 477         ev.canvas.y = e->pointer.y;
 478         ev.data = (void *)data;
 479         ev.modifiers = &(e->modifiers);
 480         ev.locks = &(e->locks);
 481         ev.flags = flags;
 482         ev.timestamp = timestamp;
 483         ev.event_flags = e->default_event_flags;
 484
 485         _evas_walk(e);
 486         /* update released touch point */
 487         _evas_touch_point_update(e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_UP);
 488         copy = evas_event_list_copy(e->pointer.object.in);
 489         EINA_LIST_FOREACH(copy, l, obj)
 490           {
 491              ev.canvas.x = e->pointer.x;
 492              ev.canvas.y = e->pointer.y;
 493              _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
 494              if ((obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) &&
 495                  (obj->mouse_grabbed > 0))
 496                {
 497                   obj->mouse_grabbed--;
 498                   e->pointer.mouse_grabbed--;
 499                }
 500              if (!obj->delete_me)
 501                {
 502                   if ((e->events_frozen <= 0) &&
 503                       (!evas_event_freezes_through(obj)))
 504                       evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_UP, &ev, event_id);
 505                }
 506              if (e->delete_me) break;
 507              if (obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
 508                {
 509                   if (e->pointer.nogrep > 0) e->pointer.nogrep--;
 510                   break;
 511                }
 512           }
 513         if (copy) copy = eina_list_free(copy);
 514         e->last_mouse_up_counter++;
 515         _evas_post_event_callback_call(e);
 516      }
 517
 518    if (e->pointer.mouse_grabbed == 0)
 519      {
 520         _post_up_handle(e, timestamp, data);
 521      }
 522
 523    if (e->pointer.mouse_grabbed < 0)
 524      {
 525         ERR("BUG? e->pointer.mouse_grabbed (=%d) < 0!",
 526             e->pointer.mouse_grabbed);
 527      }
 528    /* remove released touch point from the touch point list */
 529    _evas_touch_point_remove(e, 0);
 530
 531    _evas_unwalk(e);
 532 }
 533
 534 EAPI void
 535 evas_event_feed_mouse_cancel(Evas *e, unsigned int timestamp, const void *data)
 536 {
 537    int i;
 538
 539    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 540    return;
 541    MAGIC_CHECK_END();
 542
 543    if (e->events_frozen > 0) return;
 544
 545    _evas_walk(e);
 546    for (i = 0; i < 32; i++)
 547      {
 548         if ((e->pointer.button & (1 << i)))
 549           evas_event_feed_mouse_up(e, i + 1, 0, timestamp, data);
 550      }
 551    // FIXME: multi cancel too?
 552    _evas_unwalk(e);
 553 }
 554
 555 EAPI void
 556 evas_event_feed_mouse_wheel(Evas *e, int direction, int z, unsigned int timestamp, const void *data)
 557 {
 558    Eina_List *l, *copy;
 559    Evas_Event_Mouse_Wheel ev;
 560    Evas_Object *obj;
 561    int event_id = 0;
 562
 563    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 564    return;
 565    MAGIC_CHECK_END();
 566
 567    if (e->events_frozen > 0) return;
 568    e->last_timestamp = timestamp;
 569
 570    _evas_object_event_new();
 571
 572    event_id = _evas_event_counter;
 573    ev.direction = direction;
 574    ev.z = z;
 575    ev.output.x = e->pointer.x;
 576    ev.output.y = e->pointer.y;
 577    ev.canvas.x = e->pointer.x;
 578    ev.canvas.y = e->pointer.y;
 579    ev.data = (void *) data;
 580    ev.modifiers = &(e->modifiers);
 581    ev.locks = &(e->locks);
 582    ev.timestamp = timestamp;
 583    ev.event_flags = e->default_event_flags;
 584
 585    _evas_walk(e);
 586    copy = evas_event_list_copy(e->pointer.object.in);
 587
 588    EINA_LIST_FOREACH(copy, l, obj)
 589      {
 590         ev.canvas.x = e->pointer.x;
 591         ev.canvas.y = e->pointer.y;
 592         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
 593         if ((e->events_frozen <= 0) && !evas_event_freezes_through(obj))
 594           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_WHEEL, &ev, event_id);
 595         if (e->delete_me) break;
 596      }
 597    if (copy) copy = eina_list_free(copy);
 598    _evas_post_event_callback_call(e);
 599
 600    _evas_unwalk(e);
 601 }
 602
 603 EAPI void
 604 evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const void *data)
 605 {
 606    Evas_Object *nogrep_obj = NULL;
 607    int px, py;
 608 ////   Evas_Coord pcx, pcy;
 609
 610    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 611    return;
 612    MAGIC_CHECK_END();
 613
 614    px = e->pointer.x;
 615    py = e->pointer.y;
 616 ////   pcx = e->pointer.canvas_x;
 617 ////   pcy = e->pointer.canvas_y;
 618
 619    if (e->events_frozen > 0) return;
 620    e->last_timestamp = timestamp;
 621
 622    e->pointer.x = x;
 623    e->pointer.y = y;
 624 ////   e->pointer.canvas_x = x;
 625 ////   e->pointer.canvas_y = y;
 626 ////   e->pointer.canvas_x = evas_coord_screen_x_to_world(e, x);
 627 ////   e->pointer.canvas_y = evas_coord_screen_y_to_world(e, y);
 628    if ((!e->pointer.inside) && (e->pointer.mouse_grabbed == 0)) return;
 629    _evas_walk(e);
 630    /* update moved touch point */
 631    if ((px != x) || (py != y))
 632      _evas_touch_point_update(e, 0, e->pointer.x, e->pointer.y, EVAS_TOUCH_POINT_MOVE);
 633    /* if our mouse button is grabbed to any objects */
 634    if (e->pointer.mouse_grabbed > 0)
 635      {
 636         /* go thru old list of in objects */
 637         Eina_List *outs = NULL;
 638         Eina_List *l, *copy;
 639
 640           {
 641              Evas_Event_Mouse_Move ev;
 642              Evas_Object *obj;
 643              int event_id = 0;
 644
 645              _evas_object_event_new();
 646
 647              event_id = _evas_event_counter;
 648              ev.buttons = e->pointer.button;
 649              ev.cur.output.x = e->pointer.x;
 650              ev.cur.output.y = e->pointer.y;
 651              ev.cur.canvas.x = e->pointer.x;
 652              ev.cur.canvas.y = e->pointer.y;
 653              ev.prev.output.x = px;
 654              ev.prev.output.y = py;
 655              ev.prev.canvas.x = px;
 656              ev.prev.canvas.y = py;
 657              ev.data = (void *)data;
 658              ev.modifiers = &(e->modifiers);
 659              ev.locks = &(e->locks);
 660              ev.timestamp = timestamp;
 661              ev.event_flags = e->default_event_flags;
 662              copy = evas_event_list_copy(e->pointer.object.in);
 663              EINA_LIST_FOREACH(copy, l, obj)
 664                {
 665                   ev.cur.canvas.x = e->pointer.x;
 666                   ev.cur.canvas.y = e->pointer.y;
 667                   _evas_event_havemap_adjust(obj, &ev.cur.canvas.x,
 668                                              &ev.cur.canvas.y,
 669                                              obj->mouse_grabbed);
 670                   if ((e->events_frozen <= 0) &&
 671                       (evas_object_clippers_is_visible(obj) ||
 672                        obj->mouse_grabbed) &&
 673                       (!evas_event_passes_through(obj)) &&
 674                       (!evas_event_freezes_through(obj)) &&
 675                       (!obj->clip.clipees))
 676                     {
 677                        if ((px != x) || (py != y))
 678                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id);
 679                     }
 680                   else
 681                     outs = eina_list_append(outs, obj);
 682                   if ((obj->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) &&
 683                       (e->pointer.nogrep > 0))
 684                     {
 685                        eina_list_free(copy);
 686                        nogrep_obj = obj;
 687                        goto nogrep;
 688                     }
 689                   if (e->delete_me) break;
 690                }
 691              _evas_post_event_callback_call(e);
 692           }
 693           {
 694              Evas_Event_Mouse_Out ev;
 695              int event_id = 0;
 696
 697              _evas_object_event_new();
 698
 699              event_id = _evas_event_counter;
 700              ev.buttons = e->pointer.button;
 701              ev.output.x = e->pointer.x;
 702              ev.output.y = e->pointer.y;
 703              ev.canvas.x = e->pointer.x;
 704              ev.canvas.y = e->pointer.y;
 705              ev.data = (void *)data;
 706              ev.modifiers = &(e->modifiers);
 707              ev.locks = &(e->locks);
 708              ev.timestamp = timestamp;
 709              ev.event_flags = e->default_event_flags;
 710
 711              if (copy) eina_list_free(copy);
 712              while (outs)
 713                {
 714                   Evas_Object *obj;
 715
 716                   obj = outs->data;
 717                   outs = eina_list_remove(outs, obj);
 718                   if ((obj->mouse_grabbed == 0) && (!e->delete_me))
 719                     {
 720                        ev.canvas.x = e->pointer.x;
 721                        ev.canvas.y = e->pointer.y;
 722                        _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
 723                        e->pointer.object.in = eina_list_remove(e->pointer.object.in, obj);
 724                        if (obj->mouse_in)
 725                          {
 726                             obj->mouse_in = 0;
 727                             if (!obj->delete_me)
 728                               {
 729                                  if (e->events_frozen <= 0)
 730                                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id);
 731                               }
 732                          }
 733                     }
 734                }
 735              _evas_post_event_callback_call(e);
 736           }
 737      }
 738    else
 739      {
 740         Eina_List *ins;
 741         Eina_List *l, *copy;
 742         Evas_Event_Mouse_Move ev;
 743         Evas_Event_Mouse_Out ev2;
 744         Evas_Event_Mouse_In ev3;
 745         Evas_Object *obj;
 746         int event_id = 0, event_id2 = 0;
 747
 748         _evas_object_event_new();
 749
 750         event_id = _evas_event_counter;
 751         ev.buttons = e->pointer.button;
 752         ev.cur.output.x = e->pointer.x;
 753         ev.cur.output.y = e->pointer.y;
 754         ev.cur.canvas.x = e->pointer.x;
 755         ev.cur.canvas.y = e->pointer.y;
 756         ev.prev.output.x = px;
 757         ev.prev.output.y = py;
 758         ev.prev.canvas.x = px;
 759         ev.prev.canvas.y = py;
 760         ev.data = (void *)data;
 761         ev.modifiers = &(e->modifiers);
 762         ev.locks = &(e->locks);
 763         ev.timestamp = timestamp;
 764         ev.event_flags = e->default_event_flags;
 765
 766         ev2.buttons = e->pointer.button;
 767         ev2.output.x = e->pointer.x;
 768         ev2.output.y = e->pointer.y;
 769         ev2.canvas.x = e->pointer.x;
 770         ev2.canvas.y = e->pointer.y;
 771         ev2.data = (void *)data;
 772         ev2.modifiers = &(e->modifiers);
 773         ev2.locks = &(e->locks);
 774         ev2.timestamp = timestamp;
 775         ev2.event_flags = e->default_event_flags;
 776
 777         ev3.buttons = e->pointer.button;
 778         ev3.output.x = e->pointer.x;
 779         ev3.output.y = e->pointer.y;
 780         ev3.canvas.x = e->pointer.x;
 781         ev3.canvas.y = e->pointer.y;
 782         ev3.data = (void *)data;
 783         ev3.modifiers = &(e->modifiers);
 784         ev3.locks = &(e->locks);
 785         ev3.timestamp = timestamp;
 786         ev3.event_flags = e->default_event_flags;
 787
 788         /* get all new in objects */
 789         ins = evas_event_objects_event_list(e, NULL, x, y);
 790         /* go thru old list of in objects */
 791         copy = evas_event_list_copy(e->pointer.object.in);
 792         EINA_LIST_FOREACH(copy, l, obj)
 793           {
 794              /* if its under the pointer and its visible and its in the new */
 795              /* in list */
 796              // FIXME: i don't think we need this
 797              //      evas_object_clip_recalc(obj);
 798              if ((e->events_frozen <= 0) &&
 799                  evas_object_is_in_output_rect(obj, x, y, 1, 1) &&
 800                  (evas_object_clippers_is_visible(obj) ||
 801                   obj->mouse_grabbed) &&
 802                  eina_list_data_find(ins, obj) &&
 803                  (!evas_event_passes_through(obj)) &&
 804                  (!evas_event_freezes_through(obj)) &&
 805                  (!obj->clip.clipees) &&
 806                  ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y))
 807                 )
 808                {
 809                   if ((px != x) || (py != y))
 810                     {
 811                        ev.cur.canvas.x = e->pointer.x;
 812                        ev.cur.canvas.y = e->pointer.y;
 813                        _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed);
 814                        evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id);
 815                     }
 816                }
 817              /* otherwise it has left the object */
 818              else
 819                {
 820                   if (obj->mouse_in)
 821                     {
 822                        obj->mouse_in = 0;
 823                        ev2.canvas.x = e->pointer.x;
 824                        ev2.canvas.y = e->pointer.y;
 825                        _evas_event_havemap_adjust(obj, &ev2.canvas.x, &ev2.canvas.y, obj->mouse_grabbed);
 826                        if (e->events_frozen <= 0)
 827                           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev2, event_id);
 828                     }
 829                }
 830              if (e->delete_me) break;
 831           }
 832         _evas_post_event_callback_call(e);
 833
 834         _evas_object_event_new();
 835
 836         event_id2 = _evas_event_counter;
 837         if (copy) copy = eina_list_free(copy);
 838         /* go thru our current list of ins */
 839         EINA_LIST_FOREACH(ins, l, obj)
 840           {
 841              ev3.canvas.x = e->pointer.x;
 842              ev3.canvas.y = e->pointer.y;
 843              _evas_event_havemap_adjust(obj, &ev3.canvas.x, &ev3.canvas.y, obj->mouse_grabbed);
 844              /* if its not in the old list of ins send an enter event */
 845              if (!eina_list_data_find(e->pointer.object.in, obj))
 846                {
 847                   if (!obj->mouse_in)
 848                     {
 849                        obj->mouse_in = 1;
 850                        if (e->events_frozen <= 0)
 851                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev3, event_id2);
 852                     }
 853                }
 854              if (e->delete_me) break;
 855           }
 856         if (e->pointer.mouse_grabbed == 0)
 857           {
 858              /* free our old list of ins */
 859              eina_list_free(e->pointer.object.in);
 860              /* and set up the new one */
 861              e->pointer.object.in = ins;
 862           }
 863         else
 864           {
 865              /* free our cur ins */
 866              eina_list_free(ins);
 867           }
 868         _evas_post_event_callback_call(e);
 869      }
 870    _evas_unwalk(e);
 871    return;
 872 nogrep:
 873      {
 874         Eina_List *ins = NULL;
 875         Eina_List *newin = NULL;
 876         Eina_List *l, *copy, *lst = NULL;
 877         Evas_Event_Mouse_Move ev;
 878         Evas_Event_Mouse_Out ev2;
 879         Evas_Event_Mouse_In ev3;
 880         Evas_Object *obj, *below_obj;
 881         int event_id = 0, event_id2 = 0;
 882         int norep = 0, breaknext = 0;
 883
 884         _evas_object_event_new();
 885
 886         event_id = _evas_event_counter;
 887         ev.buttons = e->pointer.button;
 888         ev.cur.output.x = e->pointer.x;
 889         ev.cur.output.y = e->pointer.y;
 890         ev.cur.canvas.x = e->pointer.x;
 891         ev.cur.canvas.y = e->pointer.y;
 892         ev.prev.output.x = px;
 893         ev.prev.output.y = py;
 894         ev.prev.canvas.x = px;
 895         ev.prev.canvas.y = py;
 896         ev.data = (void *)data;
 897         ev.modifiers = &(e->modifiers);
 898         ev.locks = &(e->locks);
 899         ev.timestamp = timestamp;
 900         ev.event_flags = e->default_event_flags;
 901
 902         ev2.buttons = e->pointer.button;
 903         ev2.output.x = e->pointer.x;
 904         ev2.output.y = e->pointer.y;
 905         ev2.canvas.x = e->pointer.x;
 906         ev2.canvas.y = e->pointer.y;
 907         ev2.data = (void *)data;
 908         ev2.modifiers = &(e->modifiers);
 909         ev2.locks = &(e->locks);
 910         ev2.timestamp = timestamp;
 911         ev2.event_flags = e->default_event_flags;
 912
 913         ev3.buttons = e->pointer.button;
 914         ev3.output.x = e->pointer.x;
 915         ev3.output.y = e->pointer.y;
 916         ev3.canvas.x = e->pointer.x;
 917         ev3.canvas.y = e->pointer.y;
 918         ev3.data = (void *)data;
 919         ev3.modifiers = &(e->modifiers);
 920         ev3.locks = &(e->locks);
 921         ev3.timestamp = timestamp;
 922         ev3.event_flags = e->default_event_flags;
 923
 924         /* go thru old list of in objects */
 925         copy = evas_event_list_copy(e->pointer.object.in);
 926         EINA_LIST_FOREACH(copy, l, obj)
 927           {
 928              if (breaknext)
 929                {
 930                   lst = l;
 931                   break;
 932                }
 933              if (obj == nogrep_obj) breaknext = 1;
 934           }
 935
 936         /* get all new in objects */
 937         below_obj = evas_object_below_get(nogrep_obj);
 938         if (below_obj)
 939           ins = _evas_event_object_list_raw_in_get(e, NULL,
 940                                                    EINA_INLIST_GET(below_obj), NULL,
 941                                                    e->pointer.x, e->pointer.y,
 942                                                    &norep);
 943         EINA_LIST_FOREACH(copy, l, obj)
 944           {
 945              newin = eina_list_append(newin, obj);
 946              if (obj == nogrep_obj) break;
 947           }
 948         EINA_LIST_FOREACH(ins, l, obj)
 949           {
 950              newin = eina_list_append(newin, obj);
 951           }
 952
 953         EINA_LIST_FOREACH(lst, l, obj)
 954           {
 955              /* if its under the pointer and its visible and its in the new */
 956              /* in list */
 957              // FIXME: i don't think we need this
 958              //      evas_object_clip_recalc(obj);
 959              if ((e->events_frozen <= 0) &&
 960                  evas_object_is_in_output_rect(obj, x, y, 1, 1) &&
 961                  (evas_object_clippers_is_visible(obj) ||
 962                   obj->mouse_grabbed) &&
 963                  eina_list_data_find(newin, obj) &&
 964                  (!evas_event_passes_through(obj)) &&
 965                  (!evas_event_freezes_through(obj)) &&
 966                  (!obj->clip.clipees) &&
 967                  ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y))
 968                 )
 969                {
 970                   if ((px != x) || (py != y))
 971                     {
 972                        ev.cur.canvas.x = e->pointer.x;
 973                        ev.cur.canvas.y = e->pointer.y;
 974                        _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed);
 975                        evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev, event_id);
 976                     }
 977                }
 978              /* otherwise it has left the object */
 979              else
 980                {
 981                   if (obj->mouse_in)
 982                     {
 983                        obj->mouse_in = 0;
 984                        ev2.canvas.x = e->pointer.x;
 985                        ev2.canvas.y = e->pointer.y;
 986                        _evas_event_havemap_adjust(obj, &ev2.canvas.x, &ev2.canvas.y, obj->mouse_grabbed);
 987                        if (e->events_frozen <= 0)
 988                           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev2, event_id);
 989                     }
 990                }
 991              if (e->delete_me) break;
 992           }
 993         _evas_post_event_callback_call(e);
 994
 995         _evas_object_event_new();
 996
 997         event_id2 = _evas_event_counter;
 998         if (copy) copy = eina_list_free(copy);
 999         /* go thru our current list of ins */
1000         EINA_LIST_FOREACH(newin, l, obj)
1001           {
1002              ev3.canvas.x = e->pointer.x;
1003              ev3.canvas.y = e->pointer.y;
1004              _evas_event_havemap_adjust(obj, &ev3.canvas.x, &ev3.canvas.y, obj->mouse_grabbed);
1005              /* if its not in the old list of ins send an enter event */
1006              if (!eina_list_data_find(e->pointer.object.in, obj))
1007                {
1008                   if (!obj->mouse_in)
1009                     {
1010                        obj->mouse_in = 1;
1011                        if (e->events_frozen <= 0)
1012                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev3, event_id2);
1013                     }
1014                }
1015              if (e->delete_me) break;
1016           }
1017         /* free our old list of ins */
1018         eina_list_free(e->pointer.object.in);
1019         /* and set up the new one */
1020         e->pointer.object.in = newin;
1021
1022         _evas_post_event_callback_call(e);
1023      }
1024    _evas_unwalk(e);
1025 }
1026
1027 EAPI void
1028 evas_event_feed_mouse_in(Evas *e, unsigned int timestamp, const void *data)
1029 {
1030    Eina_List *ins;
1031    Eina_List *l;
1032    Evas_Event_Mouse_In ev;
1033    Evas_Object *obj;
1034    int event_id = 0;
1035
1036    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1037    return;
1038    MAGIC_CHECK_END();
1039    e->pointer.inside = 1;
1040
1041    if (e->events_frozen > 0) return;
1042    e->last_timestamp = timestamp;
1043
1044    if (e->pointer.mouse_grabbed != 0) return;
1045
1046    _evas_object_event_new();
1047
1048    event_id = _evas_event_counter;
1049    ev.buttons = e->pointer.button;
1050    ev.output.x = e->pointer.x;
1051    ev.output.y = e->pointer.y;
1052    ev.canvas.x = e->pointer.x;
1053    ev.canvas.y = e->pointer.y;
1054    ev.data = (void *)data;
1055    ev.modifiers = &(e->modifiers);
1056    ev.locks = &(e->locks);
1057    ev.timestamp = timestamp;
1058    ev.event_flags = e->default_event_flags;
1059
1060    _evas_walk(e);
1061    /* get new list of ins */
1062    ins = evas_event_objects_event_list(e, NULL, e->pointer.x, e->pointer.y);
1063    EINA_LIST_FOREACH(ins, l, obj)
1064      {
1065         ev.canvas.x = e->pointer.x;
1066         ev.canvas.y = e->pointer.y;
1067         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
1068         if (!eina_list_data_find(e->pointer.object.in, obj))
1069           {
1070              if (!obj->mouse_in)
1071                {
1072                   obj->mouse_in = 1;
1073                   if (e->events_frozen <= 0)
1074                      evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev, event_id);
1075                }
1076           }
1077         if (e->delete_me) break;
1078      }
1079    /* free our old list of ins */
1080    e->pointer.object.in = eina_list_free(e->pointer.object.in);
1081    /* and set up the new one */
1082    e->pointer.object.in = ins;
1083    _evas_post_event_callback_call(e);
1084    evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y, timestamp, data);
1085    _evas_unwalk(e);
1086 }
1087
1088 EAPI void
1089 evas_event_feed_mouse_out(Evas *e, unsigned int timestamp, const void *data)
1090 {
1091    Evas_Event_Mouse_Out ev;
1092    int event_id = 0;
1093
1094    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1095    return;
1096    MAGIC_CHECK_END();
1097    e->pointer.inside = 0;
1098
1099    if (e->events_frozen > 0) return;
1100    e->last_timestamp = timestamp;
1101
1102    _evas_object_event_new();
1103
1104    event_id = _evas_event_counter;
1105    ev.buttons = e->pointer.button;
1106    ev.output.x = e->pointer.x;
1107    ev.output.y = e->pointer.y;
1108    ev.canvas.x = e->pointer.x;
1109    ev.canvas.y = e->pointer.y;
1110    ev.data = (void *)data;
1111    ev.modifiers = &(e->modifiers);
1112    ev.locks = &(e->locks);
1113    ev.timestamp = timestamp;
1114    ev.event_flags = e->default_event_flags;
1115
1116    _evas_walk(e);
1117    /* if our mouse button is inside any objects */
1118      {
1119         /* go thru old list of in objects */
1120         Eina_List *l, *copy;
1121         Evas_Object *obj;
1122
1123         copy = evas_event_list_copy(e->pointer.object.in);
1124         EINA_LIST_FOREACH(copy, l, obj)
1125           {
1126              ev.canvas.x = e->pointer.x;
1127              ev.canvas.y = e->pointer.y;
1128              _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
1129              if (obj->mouse_in)
1130                {
1131                   obj->mouse_in = 0;
1132                   if (!obj->delete_me)
1133                     {
1134                        if (e->events_frozen <= 0)
1135                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev, event_id);
1136                     }
1137                   obj->mouse_grabbed = 0;
1138                }
1139              if (e->delete_me) break;
1140           }
1141         if (copy) copy = eina_list_free(copy);
1142         /* free our old list of ins */
1143         e->pointer.object.in =  eina_list_free(e->pointer.object.in);
1144         e->pointer.mouse_grabbed = 0;
1145         _evas_post_event_callback_call(e);
1146      }
1147    _evas_unwalk(e);
1148 }
1149
1150 EAPI void
1151 evas_event_feed_multi_down(Evas *e,
1152                            int d, int x, int y,
1153                            double rad, double radx, double rady,
1154                            double pres, double ang,
1155                            double fx, double fy,
1156                            Evas_Button_Flags flags, unsigned int timestamp,
1157                            const void *data)
1158 {
1159    Eina_List *l, *copy;
1160    Evas_Event_Multi_Down ev;
1161    Evas_Object *obj;
1162    int addgrab = 0;
1163    int event_id = 0;
1164
1165    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1166    return;
1167    MAGIC_CHECK_END();
1168
1169    e->pointer.downs++;
1170    if (e->events_frozen > 0) return;
1171    e->last_timestamp = timestamp;
1172
1173    _evas_object_event_new();
1174
1175    event_id = _evas_event_counter;
1176    ev.device = d;
1177    ev.output.x = x;
1178    ev.output.y = y;
1179    ev.canvas.x = x;
1180    ev.canvas.y = y;
1181    ev.radius = rad;
1182    ev.radius_x = radx;
1183    ev.radius_y = rady;
1184    ev.pressure = pres;
1185    ev.angle = ang;
1186    ev.canvas.xsub = fx;
1187    ev.canvas.ysub = fy;
1188    ev.data = (void *)data;
1189    ev.modifiers = &(e->modifiers);
1190    ev.locks = &(e->locks);
1191    ev.flags = flags;
1192    ev.timestamp = timestamp;
1193    ev.event_flags = e->default_event_flags;
1194
1195    _evas_walk(e);
1196    /* append new touch point to the touch point list */
1197    _evas_touch_point_append(e, d, x, y);
1198    if (e->pointer.mouse_grabbed == 0)
1199      {
1200         if (e->pointer.downs > 1) addgrab = e->pointer.downs - 1;
1201      }
1202    copy = evas_event_list_copy(e->pointer.object.in);
1203    EINA_LIST_FOREACH(copy, l, obj)
1204      {
1205         if (obj->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB)
1206           {
1207              obj->mouse_grabbed += addgrab + 1;
1208              e->pointer.mouse_grabbed += addgrab + 1;
1209           }
1210      }
1211    EINA_LIST_FOREACH(copy, l, obj)
1212      {
1213         ev.canvas.x = x;
1214         ev.canvas.y = y;
1215         ev.canvas.xsub = fx;
1216         ev.canvas.ysub = fy;
1217         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
1218         if (x != ev.canvas.x)
1219           ev.canvas.xsub = ev.canvas.x; // fixme - lost precision
1220         if (y != ev.canvas.y)
1221           ev.canvas.ysub = ev.canvas.y; // fixme - lost precision
1222         if (e->events_frozen <= 0)
1223           evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_DOWN, &ev, event_id);
1224         if (e->delete_me) break;
1225      }
1226    if (copy) eina_list_free(copy);
1227    _evas_post_event_callback_call(e);
1228    /* update touch point's state to EVAS_TOUCH_POINT_STILL */
1229    _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_STILL);
1230    _evas_unwalk(e);
1231 }
1232
1233 EAPI void
1234 evas_event_feed_multi_up(Evas *e,
1235                          int d, int x, int y,
1236                          double rad, double radx, double rady,
1237                          double pres, double ang,
1238                          double fx, double fy,
1239                          Evas_Button_Flags flags, unsigned int timestamp,
1240                          const void *data)
1241 {
1242    Eina_List *l, *copy;
1243    Evas_Event_Multi_Up ev;
1244    Evas_Object *obj;
1245    int event_id = 0;
1246
1247    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1248    return;
1249    MAGIC_CHECK_END();
1250
1251    if (e->pointer.downs <= 0) return;
1252    e->pointer.downs--;
1253    if (e->events_frozen > 0) return;
1254    e->last_timestamp = timestamp;
1255
1256    _evas_object_event_new();
1257
1258    event_id = _evas_event_counter;
1259    ev.device = d;
1260    ev.output.x = x;
1261    ev.output.y = y;
1262    ev.canvas.x = x;
1263    ev.canvas.y = y;
1264    ev.radius = rad;
1265    ev.radius_x = radx;
1266    ev.radius_y = rady;
1267    ev.pressure = pres;
1268    ev.angle = ang;
1269    ev.canvas.xsub = fx;
1270    ev.canvas.ysub = fy;
1271    ev.data = (void *)data;
1272    ev.modifiers = &(e->modifiers);
1273    ev.locks = &(e->locks);
1274    ev.flags = flags;
1275    ev.timestamp = timestamp;
1276    ev.event_flags = e->default_event_flags;
1277
1278    _evas_walk(e);
1279    /* update released touch point */
1280    _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_UP);
1281    copy = evas_event_list_copy(e->pointer.object.in);
1282    EINA_LIST_FOREACH(copy, l, obj)
1283      {
1284         ev.canvas.x = x;
1285         ev.canvas.y = y;
1286         ev.canvas.xsub = fx;
1287         ev.canvas.ysub = fy;
1288         _evas_event_havemap_adjust(obj, &ev.canvas.x, &ev.canvas.y, obj->mouse_grabbed);
1289         if (x != ev.canvas.x)
1290           ev.canvas.xsub = ev.canvas.x; // fixme - lost precision
1291         if (y != ev.canvas.y)
1292           ev.canvas.ysub = ev.canvas.y; // fixme - lost precision
1293         if ((obj->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB) &&
1294             (obj->mouse_grabbed > 0))
1295           {
1296              obj->mouse_grabbed--;
1297              e->pointer.mouse_grabbed--;
1298           }
1299         if (e->events_frozen <= 0)
1300           evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_UP, &ev, event_id);
1301         if (e->delete_me) break;
1302      }
1303    if (copy) copy = eina_list_free(copy);
1304    if ((e->pointer.mouse_grabbed == 0) && !_post_up_handle(e, timestamp, data))
1305       _evas_post_event_callback_call(e);
1306    /* remove released touch point from the touch point list */
1307    _evas_touch_point_remove(e, d);
1308    _evas_unwalk(e);
1309 }
1310
1311 EAPI void
1312 evas_event_feed_multi_move(Evas *e,
1313                            int d, int x, int y,
1314                            double rad, double radx, double rady,
1315                            double pres, double ang,
1316                            double fx, double fy,
1317                            unsigned int timestamp, const void *data)
1318 {
1319    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1320    return;
1321    MAGIC_CHECK_END();
1322
1323    if (e->events_frozen > 0) return;
1324    e->last_timestamp = timestamp;
1325
1326    if ((!e->pointer.inside) && (e->pointer.mouse_grabbed == 0)) return;
1327
1328    _evas_walk(e);
1329    /* update moved touch point */
1330    _evas_touch_point_update(e, d, x, y, EVAS_TOUCH_POINT_MOVE);
1331    /* if our mouse button is grabbed to any objects */
1332    if (e->pointer.mouse_grabbed > 0)
1333      {
1334         /* go thru old list of in objects */
1335         Eina_List *l, *copy;
1336         Evas_Event_Multi_Move ev;
1337         Evas_Object *obj;
1338         int event_id = 0;
1339
1340         _evas_object_event_new();
1341
1342         event_id = _evas_event_counter;
1343         ev.device = d;
1344         ev.cur.output.x = x;
1345         ev.cur.output.y = y;
1346         ev.cur.canvas.x = x;
1347         ev.cur.canvas.y = y;
1348         ev.radius = rad;
1349         ev.radius_x = radx;
1350         ev.radius_y = rady;
1351         ev.pressure = pres;
1352         ev.angle = ang;
1353         ev.cur.canvas.xsub = fx;
1354         ev.cur.canvas.ysub = fy;
1355         ev.data = (void *)data;
1356         ev.modifiers = &(e->modifiers);
1357         ev.locks = &(e->locks);
1358         ev.timestamp = timestamp;
1359         ev.event_flags = e->default_event_flags;
1360
1361         copy = evas_event_list_copy(e->pointer.object.in);
1362         EINA_LIST_FOREACH(copy, l, obj)
1363           {
1364              if ((e->events_frozen <= 0) &&
1365                  (evas_object_clippers_is_visible(obj) || obj->mouse_grabbed) &&
1366                  (!evas_event_passes_through(obj)) &&
1367                  (!evas_event_freezes_through(obj)) &&
1368                  (!obj->clip.clipees))
1369                {
1370                   ev.cur.canvas.x = x;
1371                   ev.cur.canvas.y = y;
1372                   ev.cur.canvas.xsub = fx;
1373                   ev.cur.canvas.ysub = fy;
1374                   _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed);
1375                   if (x != ev.cur.canvas.x)
1376                     ev.cur.canvas.xsub = ev.cur.canvas.x; // fixme - lost precision
1377                   if (y != ev.cur.canvas.y)
1378                     ev.cur.canvas.ysub = ev.cur.canvas.y; // fixme - lost precision
1379                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_MOVE, &ev, event_id);
1380                }
1381              if (e->delete_me) break;
1382           }
1383         _evas_post_event_callback_call(e);
1384      }
1385    else
1386      {
1387         Eina_List *ins;
1388         Eina_List *l, *copy;
1389         Evas_Event_Multi_Move ev;
1390         Evas_Object *obj;
1391         int event_id = 0;
1392
1393         _evas_object_event_new();
1394
1395         event_id = _evas_event_counter;
1396         ev.device = d;
1397         ev.cur.output.x = x;
1398         ev.cur.output.y = y;
1399         ev.cur.canvas.x = x;
1400         ev.cur.canvas.y = y;
1401         ev.radius = rad;
1402         ev.radius_x = radx;
1403         ev.radius_y = rady;
1404         ev.pressure = pres;
1405         ev.angle = ang;
1406         ev.cur.canvas.xsub = fx;
1407         ev.cur.canvas.ysub = fy;
1408         ev.data = (void *)data;
1409         ev.modifiers = &(e->modifiers);
1410         ev.locks = &(e->locks);
1411         ev.timestamp = timestamp;
1412         ev.event_flags = e->default_event_flags;
1413
1414         /* get all new in objects */
1415         ins = evas_event_objects_event_list(e, NULL, x, y);
1416         /* go thru old list of in objects */
1417         copy = evas_event_list_copy(e->pointer.object.in);
1418         EINA_LIST_FOREACH(copy, l, obj)
1419           {
1420              /* if its under the pointer and its visible and its in the new */
1421              /* in list */
1422              // FIXME: i don't think we need this
1423              //      evas_object_clip_recalc(obj);
1424              if ((e->events_frozen <= 0) &&
1425                  evas_object_is_in_output_rect(obj, x, y, 1, 1) &&
1426                  (evas_object_clippers_is_visible(obj) ||
1427                   obj->mouse_grabbed) &&
1428                  eina_list_data_find(ins, obj) &&
1429                  (!evas_event_passes_through(obj)) &&
1430                  (!evas_event_freezes_through(obj)) &&
1431                  (!obj->clip.clipees) &&
1432                  ((!obj->precise_is_inside) || evas_object_is_inside(obj, x, y))
1433                 )
1434                {
1435                   ev.cur.canvas.x = x;
1436                   ev.cur.canvas.y = y;
1437                   ev.cur.canvas.xsub = fx;
1438                   ev.cur.canvas.ysub = fy;
1439                   _evas_event_havemap_adjust(obj, &ev.cur.canvas.x, &ev.cur.canvas.y, obj->mouse_grabbed);
1440                   if (x != ev.cur.canvas.x)
1441                     ev.cur.canvas.xsub = ev.cur.canvas.x; // fixme - lost precision
1442                   if (y != ev.cur.canvas.y)
1443                     ev.cur.canvas.ysub = ev.cur.canvas.y; // fixme - lost precision
1444                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MULTI_MOVE, &ev, event_id);
1445                }
1446              if (e->delete_me) break;
1447           }
1448         if (copy) copy = eina_list_free(copy);
1449         if (e->pointer.mouse_grabbed == 0)
1450           {
1451              /* free our old list of ins */
1452              eina_list_free(e->pointer.object.in);
1453              /* and set up the new one */
1454              e->pointer.object.in = ins;
1455           }
1456         else
1457           {
1458              /* free our cur ins */
1459              eina_list_free(ins);
1460           }
1461         _evas_post_event_callback_call(e);
1462      }
1463    _evas_unwalk(e);
1464 }
1465
1466 EAPI void
1467 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)
1468 {
1469    int event_id = 0;
1470    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1471    return;
1472    MAGIC_CHECK_END();
1473
1474    if (!keyname) return;
1475    if (e->events_frozen > 0) return;
1476    e->last_timestamp = timestamp;
1477    _evas_walk(e);
1478
1479    Evas_Event_Key_Down ev;
1480    Eina_Bool exclusive;
1481
1482    _evas_object_event_new();
1483
1484    event_id = _evas_event_counter;
1485    exclusive = EINA_FALSE;
1486    ev.keyname = (char *)keyname;
1487    ev.data = (void *)data;
1488    ev.modifiers = &(e->modifiers);
1489    ev.locks = &(e->locks);
1490    ev.key = key;
1491    ev.string = string;
1492    ev.compose = compose;
1493    ev.timestamp = timestamp;
1494    ev.event_flags = e->default_event_flags;
1495
1496    if (e->grabs)
1497      {
1498         Eina_List *l;
1499         Evas_Key_Grab *g;
1500
1501         e->walking_grabs++;
1502         EINA_LIST_FOREACH(e->grabs, l, g)
1503           {
1504              if (g->just_added)
1505                {
1506                   g->just_added = EINA_FALSE;
1507                   continue;
1508                }
1509              if (g->delete_me) continue;
1510              if (((e->modifiers.mask & g->modifiers) ||
1511                   (g->modifiers == e->modifiers.mask)) &&
1512                  (!strcmp(keyname, g->keyname)))
1513                {
1514                   if (!(e->modifiers.mask & g->not_modifiers))
1515                     {
1516                        if (e->events_frozen <= 0 &&
1517                            !evas_event_freezes_through(g->object))
1518                          evas_object_event_callback_call(g->object,
1519                                                          EVAS_CALLBACK_KEY_DOWN,
1520                                                          &ev, event_id);
1521                        if (g->exclusive) exclusive = EINA_TRUE;
1522                     }
1523                }
1524              if (e->delete_me) break;
1525           }
1526         e->walking_grabs--;
1527         if (e->walking_grabs <= 0)
1528           {
1529              while (e->delete_grabs > 0)
1530                {
1531                   e->delete_grabs--;
1532                   for (l = e->grabs; l;)
1533                     {
1534                        g = eina_list_data_get(l);
1535                        l = eina_list_next(l);
1536                        if (g->delete_me)
1537                          evas_key_grab_free(g->object, g->keyname, g->modifiers,
1538                                             g->not_modifiers);
1539                     }
1540                }
1541           }
1542      }
1543    if ((e->focused) && (!exclusive))
1544      {
1545         if (e->events_frozen <= 0 && !evas_event_freezes_through(e->focused))
1546           evas_object_event_callback_call(e->focused, EVAS_CALLBACK_KEY_DOWN,
1547                                           &ev, event_id);
1548      }
1549    _evas_post_event_callback_call(e);
1550    _evas_unwalk(e);
1551 }
1552
1553 EAPI void
1554 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)
1555 {
1556    int event_id = 0;
1557    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1558    return;
1559    MAGIC_CHECK_END();
1560    if (!keyname) return;
1561    if (e->events_frozen > 0) return;
1562    e->last_timestamp = timestamp;
1563    _evas_walk(e);
1564
1565    Evas_Event_Key_Up ev;
1566    Eina_Bool exclusive;
1567
1568    _evas_object_event_new();
1569
1570    event_id = _evas_event_counter;
1571    exclusive = EINA_FALSE;
1572    ev.keyname = (char *)keyname;
1573    ev.data = (void *)data;
1574    ev.modifiers = &(e->modifiers);
1575    ev.locks = &(e->locks);
1576    ev.key = key;
1577    ev.string = string;
1578    ev.compose = compose;
1579    ev.timestamp = timestamp;
1580    ev.event_flags = e->default_event_flags;
1581
1582    if (e->grabs)
1583      {
1584         Eina_List *l;
1585         Evas_Key_Grab *g;
1586
1587         e->walking_grabs++;
1588         EINA_LIST_FOREACH(e->grabs, l, g)
1589           {
1590              if (g->just_added)
1591                {
1592                   g->just_added = EINA_FALSE;
1593                   continue;
1594                }
1595              if (g->delete_me) continue;
1596              if (((e->modifiers.mask & g->modifiers) ||
1597                   (g->modifiers == e->modifiers.mask)) &&
1598                  (!((e->modifiers.mask & g->not_modifiers) ||
1599                     (g->not_modifiers == ~e->modifiers.mask))) &&
1600                  (!strcmp(keyname, g->keyname)))
1601                {
1602                   if (e->events_frozen <= 0 &&
1603                       !evas_event_freezes_through(g->object))
1604                     evas_object_event_callback_call(g->object,
1605                                                     EVAS_CALLBACK_KEY_UP, &ev, event_id);
1606                   if (g->exclusive) exclusive = EINA_TRUE;
1607                }
1608              if (e->delete_me) break;
1609           }
1610         e->walking_grabs--;
1611         if (e->walking_grabs <= 0)
1612           {
1613              while (e->delete_grabs > 0)
1614                {
1615                   Eina_List *ll, *l_next;
1616                   Evas_Key_Grab *gr;
1617
1618                   e->delete_grabs--;
1619                   EINA_LIST_FOREACH_SAFE(e->grabs, ll, l_next, gr)
1620                     {
1621                        if (gr->delete_me)
1622                          evas_key_grab_free(gr->object, gr->keyname,
1623                                             gr->modifiers, gr->not_modifiers);
1624                     }
1625                }
1626           }
1627      }
1628    if ((e->focused) && (!exclusive))
1629      {
1630         if (e->events_frozen <= 0 && !evas_event_freezes_through(e->focused))
1631           evas_object_event_callback_call(e->focused, EVAS_CALLBACK_KEY_UP,
1632                                           &ev, event_id);
1633      }
1634    _evas_post_event_callback_call(e);
1635    _evas_unwalk(e);
1636 }
1637
1638 EAPI void
1639 evas_event_feed_hold(Evas *e, int hold, unsigned int timestamp, const void *data)
1640 {
1641    Eina_List *l, *copy;
1642    Evas_Event_Hold ev;
1643    Evas_Object *obj;
1644    int event_id = 0;
1645
1646    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1647    return;
1648    MAGIC_CHECK_END();
1649
1650    if (e->events_frozen > 0) return;
1651    e->last_timestamp = timestamp;
1652
1653    _evas_object_event_new();
1654
1655    event_id = _evas_event_counter;
1656    ev.hold = hold;
1657    ev.data = (void *)data;
1658    ev.timestamp = timestamp;
1659    ev.event_flags = e->default_event_flags;
1660
1661    _evas_walk(e);
1662    copy = evas_event_list_copy(e->pointer.object.in);
1663    EINA_LIST_FOREACH(copy, l, obj)
1664      {
1665         if ((e->events_frozen <= 0) && !evas_event_freezes_through(obj))
1666           evas_object_event_callback_call(obj, EVAS_CALLBACK_HOLD, &ev, event_id);
1667         if (e->delete_me) break;
1668      }
1669    if (copy) copy = eina_list_free(copy);
1670    _evas_post_event_callback_call(e);
1671    _evas_unwalk(e);
1672    _evas_object_event_new();
1673 }
1674
1675 EAPI void
1676 evas_object_freeze_events_set(Evas_Object *obj, Eina_Bool freeze)
1677 {
1678    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1679    return;
1680    MAGIC_CHECK_END();
1681
1682    freeze = !!freeze;
1683    if (obj->freeze_events == freeze) return;
1684    obj->freeze_events = freeze;
1685    evas_object_smart_member_cache_invalidate(obj, EINA_FALSE, EINA_TRUE);
1686 }
1687
1688 EAPI Eina_Bool
1689 evas_object_freeze_events_get(const Evas_Object *obj)
1690 {
1691    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1692    return EINA_FALSE;
1693    MAGIC_CHECK_END();
1694    return obj->freeze_events;
1695 }
1696
1697 EAPI void
1698 evas_object_pass_events_set(Evas_Object *obj, Eina_Bool pass)
1699 {
1700    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1701    return;
1702    MAGIC_CHECK_END();
1703    pass = !!pass;
1704    if (obj->pass_events == pass) return;
1705    obj->pass_events = pass;
1706    evas_object_smart_member_cache_invalidate(obj, EINA_TRUE, EINA_FALSE);
1707    if (evas_object_is_in_output_rect(obj,
1708                                      obj->layer->evas->pointer.x,
1709                                      obj->layer->evas->pointer.y, 1, 1) &&
1710        ((!obj->precise_is_inside) ||
1711         (evas_object_is_inside(obj,
1712                                obj->layer->evas->pointer.x,
1713                                obj->layer->evas->pointer.y))))
1714      evas_event_feed_mouse_move(obj->layer->evas,
1715                                 obj->layer->evas->pointer.x,
1716                                 obj->layer->evas->pointer.y,
1717                                 obj->layer->evas->last_timestamp,
1718                                 NULL);
1719 }
1720
1721 EAPI Eina_Bool
1722 evas_object_pass_events_get(const Evas_Object *obj)
1723 {
1724    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1725    return EINA_FALSE;
1726    MAGIC_CHECK_END();
1727    return obj->pass_events;
1728 }
1729
1730 EAPI void
1731 evas_object_repeat_events_set(Evas_Object *obj, Eina_Bool repeat)
1732 {
1733    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1734    return;
1735    MAGIC_CHECK_END();
1736    repeat = !!repeat;
1737    if (obj->repeat_events == repeat) return;
1738    obj->repeat_events = repeat;
1739    if (evas_object_is_in_output_rect(obj,
1740                                      obj->layer->evas->pointer.x,
1741                                      obj->layer->evas->pointer.y, 1, 1) &&
1742        ((!obj->precise_is_inside) ||
1743         (evas_object_is_inside(obj,
1744                                obj->layer->evas->pointer.x,
1745                                obj->layer->evas->pointer.y))))
1746      evas_event_feed_mouse_move(obj->layer->evas,
1747                                 obj->layer->evas->pointer.x,
1748                                 obj->layer->evas->pointer.y,
1749                                 obj->layer->evas->last_timestamp,
1750                                 NULL);
1751 }
1752
1753 EAPI Eina_Bool
1754 evas_object_repeat_events_get(const Evas_Object *obj)
1755 {
1756    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1757    return EINA_FALSE;
1758    MAGIC_CHECK_END();
1759    return obj->repeat_events;
1760 }
1761
1762 EAPI void
1763 evas_object_propagate_events_set(Evas_Object *obj, Eina_Bool prop)
1764 {
1765    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1766    return;
1767    MAGIC_CHECK_END();
1768    obj->no_propagate = !prop;
1769 }
1770
1771 EAPI Eina_Bool
1772 evas_object_propagate_events_get(const Evas_Object *obj)
1773 {
1774    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1775    return EINA_FALSE;
1776    MAGIC_CHECK_END();
1777    return !(obj->no_propagate);
1778 }
1779
1780 EAPI void
1781 evas_object_pointer_mode_set(Evas_Object *obj, Evas_Object_Pointer_Mode setting)
1782 {
1783    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1784    return;
1785    MAGIC_CHECK_END();
1786    obj->pointer_mode = setting;
1787 }
1788
1789 EAPI Evas_Object_Pointer_Mode
1790 evas_object_pointer_mode_get(const Evas_Object *obj)
1791 {
1792    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1793    return EVAS_OBJECT_POINTER_MODE_AUTOGRAB;
1794    MAGIC_CHECK_END();
1795    return obj->pointer_mode;
1796 }
1797
1798 EAPI void
1799 evas_event_refeed_event(Evas *e, void *event_copy, Evas_Callback_Type event_type)
1800 {
1801    if (!event_copy) return;
1802
1803    switch (event_type)
1804      {
1805       case EVAS_CALLBACK_MOUSE_IN:
1806           {
1807              Evas_Event_Mouse_In *ev = event_copy;
1808              evas_event_feed_mouse_in(e, ev->timestamp, ev->data);
1809              break;
1810           }
1811       case EVAS_CALLBACK_MOUSE_OUT:
1812           {
1813              Evas_Event_Mouse_Out *ev = event_copy;
1814              evas_event_feed_mouse_out(e, ev->timestamp, ev->data);
1815              break;
1816           }
1817       case EVAS_CALLBACK_MOUSE_DOWN:
1818           {
1819              Evas_Event_Mouse_Down *ev = event_copy;
1820              evas_event_feed_mouse_down(e, ev->button, ev->flags, ev-> timestamp, ev->data);
1821              break;
1822           }
1823       case EVAS_CALLBACK_MOUSE_UP:
1824           {
1825              Evas_Event_Mouse_Up *ev = event_copy;
1826              evas_event_feed_mouse_up(e, ev->button, ev->flags, ev-> timestamp, ev->data);
1827              break;
1828           }
1829       case EVAS_CALLBACK_MOUSE_MOVE:
1830           {
1831              Evas_Event_Mouse_Move *ev = event_copy;
1832              evas_event_feed_mouse_move(e, ev->cur.canvas.x, ev->cur.canvas.y, ev->timestamp, ev->data);
1833              break;
1834           }
1835       case EVAS_CALLBACK_MOUSE_WHEEL:
1836           {
1837              Evas_Event_Mouse_Wheel *ev = event_copy;
1838              evas_event_feed_mouse_wheel(e, ev->direction, ev-> z, ev->timestamp, ev->data);
1839              break;
1840           }
1841       case EVAS_CALLBACK_MULTI_DOWN:
1842           {
1843              Evas_Event_Multi_Down *ev = event_copy;
1844              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);
1845              break;
1846           }
1847       case EVAS_CALLBACK_MULTI_UP:
1848           {
1849              Evas_Event_Multi_Up *ev = event_copy;
1850              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);
1851              break;
1852           }
1853       case EVAS_CALLBACK_MULTI_MOVE:
1854           {
1855              Evas_Event_Multi_Move *ev = event_copy;
1856              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);
1857              break;
1858           }
1859       case EVAS_CALLBACK_KEY_DOWN:
1860           {
1861              Evas_Event_Key_Down *ev = event_copy;
1862              evas_event_feed_key_down(e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data);
1863              break;
1864           }
1865       case EVAS_CALLBACK_KEY_UP:
1866           {
1867              Evas_Event_Key_Up *ev = event_copy;
1868              evas_event_feed_key_up(e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data);
1869              break;
1870           }
1871       default: /* All non-input events are not handeled */
1872         break;
1873      }
1874 }
1875
1876 EAPI int
1877 evas_event_down_count_get(const Evas *e)
1878 {
1879    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1880    return 0;
1881    MAGIC_CHECK_END();
1882    return e->pointer.downs;
1883 }