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