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