src/lib/canvas/evas_events.c

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