src/lib/canvas/evas_events.c

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