src/lib/canvas/evas_events.c

   1 #include "evas_common.h"
   2 #include "evas_private.h"
   3
   4 static Evas_List *
   5 _evas_event_object_list_in_get(Evas *e, Evas_List *in, const Evas_Object_List *list, Evas_Object *stop, int x, int y, int *no_rep)
   6 {
   7    const Evas_Object_List *l;
   8
   9    if (!list) return in;
  10    for (l = list->last; l; l = l->prev)
  11      {
  12         Evas_Object *obj;
  13
  14         obj = (Evas_Object *)l;
  15         if (obj == stop)
  16           {
  17              *no_rep = 1;
  18              return in;
  19           }
  20         if (!evas_event_passes_through(obj))
  21           {
  22              if ((obj->cur.visible) && (obj->delete_me == 0) &&
  23                  (!obj->clip.clipees) &&
  24                  (evas_object_clippers_is_visible(obj)))
  25                {
  26                   if (obj->smart.smart)
  27                     {
  28                        int norep;
  29
  30                        norep = 0;
  31                        in = _evas_event_object_list_in_get(e, in,
  32                                                            evas_object_smart_members_get_direct(obj),
  33                                                            stop, x, y, &norep);
  34                        if (norep)
  35                          {
  36                             *no_rep = 1;
  37                             return in;
  38                          }
  39                     }
  40                   else
  41                     {
  42                        if (evas_object_is_in_output_rect(obj, x, y, 1, 1) &&
  43                            ((!obj->precise_is_inside) ||
  44                             (evas_object_is_inside(obj, x, y))))
  45                          {
  46                             in = evas_list_append(in, obj);
  47                             if (!obj->repeat_events)
  48                               {
  49                                  *no_rep = 1;
  50                                  return in;
  51                               }
  52                          }
  53                     }
  54                }
  55           }
  56      }
  57    *no_rep = 0;
  58    return in;
  59 }
  60
  61 Evas_List *
  62 evas_event_objects_event_list(Evas *e, Evas_Object *stop, int x, int y)
  63 {
  64    Evas_Object_List *l;
  65    Evas_List *in = NULL;
  66
  67    if (!e->layers) return NULL;
  68    for (l = ((Evas_Object_List *)(e->layers))->last; l; l = l->prev)
  69      {
  70         Evas_Layer *lay;
  71         int norep;
  72
  73         lay = (Evas_Layer *)l;
  74         norep = 0;
  75         in = _evas_event_object_list_in_get(e, in, (Evas_Object_List *)lay->objects, stop,
  76                                             x, y, &norep);
  77         if (norep) return in;
  78      }
  79    return in;
  80 }
  81
  82 static Evas_List *evas_event_list_copy(Evas_List *list);
  83 static Evas_List *
  84 evas_event_list_copy(Evas_List *list)
  85 {
  86    Evas_List *l, *new_l = NULL;
  87
  88    for (l = list; l; l = l->next)
  89      new_l = evas_list_append(new_l, l->data);
  90    return new_l;
  91 }
  92 /* public functions */
  93
  94 /**
  95  * @defgroup Evas_Event_Freezing_Group Evas Event Freezing Functions
  96  *
  97  * Functions that deal with the freezing of event processing of an evas.
  98  */
  99
 100 /**
 101  * Freeze all event processing
 102  * @param e The canvas to freeze event processing on
 103  *
 104  * This function will indicate to evas that the canvas @p e is to have all
 105  * event processing frozen until a matching evas_event_thaw() function is
 106  * called on the same canvas. Every freeze call must be matched by a thaw call
 107  * in order to completely thaw out a canvas.
 108  *
 109  * Example:
 110  * @code
 111  * extern Evas *evas;
 112  * extern Evas_Object *object;
 113  *
 114  * evas_event_freeze(evas);
 115  * evas_object_move(object, 50, 100);
 116  * evas_object_resize(object, 200, 200);
 117  * evas_event_thaw(evas);
 118  * @endcode
 119  * @ingroup Evas_Event_Freezing_Group
 120  */
 121 EAPI void
 122 evas_event_freeze(Evas *e)
 123 {
 124    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 125    return;
 126    MAGIC_CHECK_END();
 127    e->events_frozen++;
 128 }
 129
 130 /**
 131  * Thaw a canvas out after freezing
 132  * @param e The canvas to thaw out
 133  *
 134  * This will thaw out a canvas after a matching evas_event_freeze() call. If
 135  * this call completely thaws out a canvas, events will start being processed
 136  * again after this call, but this call will not invole any "missed" events
 137  * to be evaluated.
 138  *
 139  * See evas_event_freeze() for an example.
 140  * @ingroup Evas_Event_Freezing_Group
 141  */
 142 EAPI void
 143 evas_event_thaw(Evas *e)
 144 {
 145    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 146    return;
 147    MAGIC_CHECK_END();
 148    e->events_frozen--;
 149    if (e->events_frozen == 0)
 150      {
 151         Evas_Object_List *l;
 152
 153         for (l = (Evas_Object_List *)e->layers; l; l = l->next)
 154           {
 155              Evas_Object_List *l2;
 156              Evas_Layer *lay;
 157
 158              lay = (Evas_Layer *)l;
 159              for (l2 = (Evas_Object_List *)lay->objects; l2; l2 = l2->next)
 160                {
 161                   Evas_Object *obj;
 162
 163                   obj = (Evas_Object *)l2;
 164                   evas_object_clip_recalc(obj);
 165                   evas_object_recalc_clippees(obj);
 166                }
 167           }
 168      }
 169    if (e->events_frozen < 0)
 170      evas_debug_generic("  Thaw of events when already thawed!!!\n");
 171 }
 172
 173 /**
 174  * Return the freeze count of a given canvas
 175  * @param e The canvas to fetch the freeze count from
 176  *
 177  * This returns the number of times the canvas has been told to freeze events.
 178  * It is possible to call evas_event_freeze() multiple times, and these must
 179  * be matched by evas_event_thaw() calls. This call allows the program to
 180  * discover just how many times things have been frozen in case it may want
 181  * to break out of a deep freeze state where the count is high.
 182  *
 183  * Example:
 184  * @code
 185  * extern Evas *evas;
 186  *
 187  * while (evas_event_freeze_get(evas) > 0) evas_event_thaw(evas);
 188  * @endcode
 189  * @ingroup Evas_Event_Freezing_Group
 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 /**
 201  * To be documented.
 202  *
 203  * FIXME: To be fixed.
 204  *
 205  */
 206 EAPI void
 207 evas_event_feed_mouse_down(Evas *e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
 208 {
 209    Evas_List *l, *copy;
 210    Evas_Event_Mouse_Down ev;
 211
 212    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 213    return;
 214    MAGIC_CHECK_END();
 215
 216    if ((b < 1) || (b > 32)) return;
 217
 218    e->pointer.button |= (1 << (b - 1));
 219
 220    if (e->events_frozen > 0) return;
 221    e->last_timestamp = timestamp;
 222
 223    ev.button = b;
 224    ev.output.x = e->pointer.x;
 225    ev.output.y = e->pointer.y;
 226    ev.canvas.x = e->pointer.x;
 227    ev.canvas.y = e->pointer.y;
 228    ev.data = (void *)data;
 229    ev.modifiers = &(e->modifiers);
 230    ev.locks = &(e->locks);
 231    ev.flags = flags;
 232    ev.timestamp = timestamp;
 233    ev.event_flags = EVAS_EVENT_FLAG_NONE;
 234
 235    _evas_walk(e);
 236    copy = evas_event_list_copy(e->pointer.object.in);
 237    for (l = copy; l; l = l->next)
 238      {
 239         Evas_Object *obj;
 240
 241         obj = l->data;
 242         if (obj->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB)
 243           {
 244              obj->mouse_grabbed++;
 245              e->pointer.mouse_grabbed++;
 246           }
 247
 248         if (e->events_frozen <= 0)
 249           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_DOWN, &ev);
 250         if (e->delete_me) break;
 251      }
 252    if (copy) copy = evas_list_free(copy);
 253    e->last_mouse_down_counter++;
 254    _evas_unwalk(e);
 255 }
 256
 257 /**
 258  * To be documented.
 259  *
 260  * FIXME: To be fixed.
 261  *
 262  */
 263 EAPI void
 264 evas_event_feed_mouse_up(Evas *e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
 265 {
 266    Evas_List *l, *copy;
 267
 268    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 269    return;
 270    MAGIC_CHECK_END();
 271
 272    if ((b < 1) || (b > 32)) return;
 273
 274    e->pointer.button &= ~(1 << (b - 1));
 275
 276    if (e->events_frozen > 0) return;
 277    e->last_timestamp = timestamp;
 278
 279      {
 280         Evas_Event_Mouse_Up ev;
 281
 282         ev.button = b;
 283         ev.output.x = e->pointer.x;
 284         ev.output.y = e->pointer.y;
 285         ev.canvas.x = e->pointer.x;
 286         ev.canvas.y = e->pointer.y;
 287         ev.data = (void *)data;
 288         ev.modifiers = &(e->modifiers);
 289         ev.locks = &(e->locks);
 290         ev.flags = flags;
 291         ev.timestamp = timestamp;
 292         ev.event_flags = EVAS_EVENT_FLAG_NONE;
 293
 294         _evas_walk(e);
 295         copy = evas_event_list_copy(e->pointer.object.in);
 296         for (l = copy; l; l = l->next)
 297           {
 298              Evas_Object *obj;
 299
 300              obj = l->data;
 301              if ((obj->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB) &&
 302                  (obj->mouse_in) && (obj->mouse_grabbed > 0))
 303                {
 304                   obj->mouse_grabbed--;
 305                   e->pointer.mouse_grabbed--;
 306                }
 307              if (e->events_frozen <= 0)
 308                evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_UP, &ev);
 309              if (e->delete_me) break;
 310           }
 311         if (copy) copy = evas_list_free(copy);
 312         e->last_mouse_up_counter++;
 313      }
 314
 315    if (!e->pointer.button)
 316      {
 317         Evas_List *ins;
 318         Evas_List *l;
 319
 320           {
 321              Evas_Event_Mouse_Out ev;
 322
 323              ev.buttons = e->pointer.button;
 324              ev.output.x = e->pointer.x;
 325              ev.output.y = e->pointer.y;
 326              ev.canvas.x = e->pointer.x;
 327              ev.canvas.y = e->pointer.y;
 328              ev.data = (void *)data;
 329              ev.modifiers = &(e->modifiers);
 330              ev.locks = &(e->locks);
 331              ev.timestamp = timestamp;
 332              ev.event_flags = EVAS_EVENT_FLAG_NONE;
 333
 334              /* get new list of ins */
 335              ins = evas_event_objects_event_list(e, NULL, e->pointer.x, e->pointer.y);
 336              /* go thru old list of in objects */
 337              copy = evas_event_list_copy(e->pointer.object.in);
 338              for (l = copy; l; l = l->next)
 339                {
 340                   Evas_Object *obj;
 341
 342                   obj = l->data;
 343                   if ((!evas_list_find(ins, obj)) ||
 344                       (!e->pointer.inside))
 345                     {
 346
 347                        obj->mouse_in = 0;
 348                        if (e->events_frozen <= 0)
 349                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev);
 350                     }
 351                   if (e->delete_me) break;
 352                }
 353           }
 354         if (copy) copy = evas_list_free(copy);
 355         if (e->pointer.inside)
 356           {
 357              Evas_Event_Mouse_In ev;
 358
 359              ev.buttons = e->pointer.button;
 360              ev.output.x = e->pointer.x;
 361              ev.output.y = e->pointer.y;
 362              ev.canvas.x = e->pointer.x;
 363              ev.canvas.y = e->pointer.y;
 364              ev.data = (void *)data;
 365              ev.modifiers = &(e->modifiers);
 366              ev.locks = &(e->locks);
 367              ev.timestamp = timestamp;
 368              ev.event_flags = EVAS_EVENT_FLAG_NONE;
 369
 370              for (l = ins; l; l = l->next)
 371                {
 372                   Evas_Object *obj;
 373
 374                   obj = l->data;
 375
 376                   if (!evas_list_find(e->pointer.object.in, obj))
 377                     {
 378
 379                        obj->mouse_in = 1;
 380                        if (e->events_frozen <= 0)
 381                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev);
 382                     }
 383                   if (e->delete_me) break;
 384                }
 385           }
 386         else
 387           {
 388              ins = evas_list_free(ins);
 389           }
 390         /* free our old list of ins */
 391         e->pointer.object.in = evas_list_free(e->pointer.object.in);
 392         /* and set up the new one */
 393         e->pointer.object.in = ins;
 394         if (e->pointer.inside)
 395           evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y, timestamp, data);
 396      }
 397
 398    if (e->pointer.mouse_grabbed < 0)
 399      fprintf(stderr, "BUG? e->pointer.mouse_grabbed (=%d) < 0!\n",
 400              e->pointer.mouse_grabbed);
 401
 402    if ((e->pointer.button == 0) && (e->pointer.mouse_grabbed))
 403      {
 404         e->pointer.mouse_grabbed = 0;
 405      }
 406    _evas_unwalk(e);
 407 }
 408
 409 /**
 410  * To be documented.
 411  *
 412  * FIXME: To be fixed.
 413  *
 414  */
 415 EAPI void
 416 evas_event_feed_mouse_cancel(Evas *e, unsigned int timestamp, const void *data)
 417 {
 418    int i;
 419
 420    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 421    return;
 422    MAGIC_CHECK_END();
 423
 424    if (e->events_frozen > 0) return;
 425
 426    _evas_walk(e);
 427    for (i = 0; i < 32; i++)
 428      {
 429         if ((e->pointer.button & (1 << i)))
 430           evas_event_feed_mouse_up(e, i + 1, 0, timestamp, data);
 431      }
 432    _evas_unwalk(e);
 433 }
 434
 435 /**
 436  * To be documented.
 437  *
 438  * FIXME: To be fixed.
 439  *
 440  */
 441 EAPI void
 442 evas_event_feed_mouse_wheel(Evas *e, int direction, int z, unsigned int timestamp, const void *data)
 443 {
 444    Evas_List *l, *copy;
 445    Evas_Event_Mouse_Wheel ev;
 446
 447    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 448    return;
 449    MAGIC_CHECK_END();
 450
 451    if (e->events_frozen > 0) return;
 452    e->last_timestamp = timestamp;
 453
 454    ev.direction = direction;
 455    ev.z = z;
 456    ev.output.x = e->pointer.x;
 457    ev.output.y = e->pointer.y;
 458    ev.canvas.x = e->pointer.x;
 459    ev.canvas.y = e->pointer.y;
 460    ev.data = (void *) data;
 461    ev.modifiers = &(e->modifiers);
 462    ev.locks = &(e->locks);
 463    ev.timestamp = timestamp;
 464    ev.event_flags = EVAS_EVENT_FLAG_NONE;
 465
 466    _evas_walk(e);
 467    copy = evas_event_list_copy(e->pointer.object.in);
 468
 469    for (l = copy; l; l = l->next)
 470      {
 471         Evas_Object *obj = l->data;
 472
 473         if (e->events_frozen <= 0)
 474           evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_WHEEL, &ev);
 475         if (e->delete_me) break;
 476      }
 477    if (copy) copy = evas_list_free(copy);
 478
 479    _evas_unwalk(e);
 480 }
 481
 482 /**
 483  * To be documented.
 484  *
 485  * FIXME: To be fixed.
 486  *
 487  */
 488 EAPI void
 489 evas_event_feed_mouse_move(Evas *e, int x, int y, unsigned int timestamp, const void *data)
 490 {
 491    int px, py;
 492 ////   Evas_Coord pcx, pcy;
 493
 494    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 495    return;
 496    MAGIC_CHECK_END();
 497
 498    px = e->pointer.x;
 499    py = e->pointer.y;
 500 ////   pcx = e->pointer.canvas_x;
 501 ////   pcy = e->pointer.canvas_y;
 502
 503    if (e->events_frozen > 0) return;
 504    e->last_timestamp = timestamp;
 505
 506    e->pointer.x = x;
 507    e->pointer.y = y;
 508 ////   e->pointer.canvas_x = x;
 509 ////   e->pointer.canvas_y = y;
 510 ////   e->pointer.canvas_x = evas_coord_screen_x_to_world(e, x);
 511 ////   e->pointer.canvas_y = evas_coord_screen_y_to_world(e, y);
 512    if ((!e->pointer.inside) && (e->pointer.mouse_grabbed == 0)) return;
 513    _evas_walk(e);
 514    /* if our mouse button is grabbed to any objects */
 515    if (e->pointer.mouse_grabbed > 0)
 516      {
 517         /* go thru old list of in objects */
 518         Evas_List *outs = NULL;
 519         Evas_List *l, *copy;
 520
 521           {
 522              Evas_Event_Mouse_Move ev;
 523
 524              ev.buttons = e->pointer.button;
 525              ev.cur.output.x = e->pointer.x;
 526              ev.cur.output.y = e->pointer.y;
 527              ev.cur.canvas.x = e->pointer.x;
 528              ev.cur.canvas.y = e->pointer.y;
 529              ev.prev.output.x = px;
 530              ev.prev.output.y = py;
 531              ev.prev.canvas.x = px;
 532              ev.prev.canvas.y = py;
 533              ev.data = (void *)data;
 534              ev.modifiers = &(e->modifiers);
 535              ev.locks = &(e->locks);
 536              ev.timestamp = timestamp;
 537              ev.event_flags = EVAS_EVENT_FLAG_NONE;
 538              copy = evas_event_list_copy(e->pointer.object.in);
 539              for (l = copy; l; l = l->next)
 540                {
 541                   Evas_Object *obj;
 542
 543                   obj = l->data;
 544                   if ((obj->cur.visible) &&
 545                       (evas_object_clippers_is_visible(obj)) &&
 546                       (!evas_event_passes_through(obj)) &&
 547                       (!obj->clip.clipees))
 548                     {
 549                        if ((px != x) || (py != y))
 550                          {
 551                             if (e->events_frozen <= 0)
 552                               evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev);
 553                          }
 554                     }
 555                   else
 556                     outs = evas_list_append(outs, obj);
 557                   if (e->delete_me) break;
 558                }
 559           }
 560           {
 561              Evas_Event_Mouse_Out ev;
 562
 563              ev.buttons = e->pointer.button;
 564              ev.output.x = e->pointer.x;
 565              ev.output.y = e->pointer.y;
 566              ev.canvas.x = e->pointer.x;
 567              ev.canvas.y = e->pointer.y;
 568              ev.data = (void *)data;
 569              ev.modifiers = &(e->modifiers);
 570              ev.locks = &(e->locks);
 571              ev.timestamp = timestamp;
 572              ev.event_flags = EVAS_EVENT_FLAG_NONE;
 573
 574              if (copy) copy = evas_list_free(copy);
 575              while (outs)
 576                {
 577                   Evas_Object *obj;
 578
 579                   obj = outs->data;
 580                   outs = evas_list_remove(outs, obj);
 581                   if ((!obj->mouse_grabbed) && (!e->delete_me))
 582                     {
 583                        e->pointer.object.in = evas_list_remove(e->pointer.object.in, obj);
 584                          {
 585                             obj->mouse_in = 0;
 586                             if (e->events_frozen <= 0)
 587                               evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev);
 588                          }
 589                     }
 590                }
 591           }
 592      }
 593    else
 594      {
 595         Evas_List *ins;
 596         Evas_List *l, *copy;
 597         Evas_Event_Mouse_Move ev;
 598         Evas_Event_Mouse_Out ev2;
 599         Evas_Event_Mouse_In ev3;
 600
 601         ev.buttons = e->pointer.button;
 602         ev.cur.output.x = e->pointer.x;
 603         ev.cur.output.y = e->pointer.y;
 604         ev.cur.canvas.x = e->pointer.x;
 605         ev.cur.canvas.y = e->pointer.y;
 606         ev.prev.output.x = px;
 607         ev.prev.output.y = py;
 608         ev.prev.canvas.x = px;
 609         ev.prev.canvas.y = py;
 610         ev.data = (void *)data;
 611         ev.modifiers = &(e->modifiers);
 612         ev.locks = &(e->locks);
 613         ev.timestamp = timestamp;
 614         ev.event_flags = EVAS_EVENT_FLAG_NONE;
 615
 616         ev2.buttons = e->pointer.button;
 617         ev2.output.x = e->pointer.x;
 618         ev2.output.y = e->pointer.y;
 619         ev2.canvas.x = e->pointer.x;
 620         ev2.canvas.y = e->pointer.y;
 621         ev2.data = (void *)data;
 622         ev2.modifiers = &(e->modifiers);
 623         ev2.locks = &(e->locks);
 624         ev2.timestamp = timestamp;
 625         ev2.event_flags = EVAS_EVENT_FLAG_NONE;
 626
 627         ev3.buttons = e->pointer.button;
 628         ev3.output.x = e->pointer.x;
 629         ev3.output.y = e->pointer.y;
 630         ev3.canvas.x = e->pointer.x;
 631         ev3.canvas.y = e->pointer.y;
 632         ev3.data = (void *)data;
 633         ev3.modifiers = &(e->modifiers);
 634         ev3.locks = &(e->locks);
 635         ev3.timestamp = timestamp;
 636         ev3.event_flags = EVAS_EVENT_FLAG_NONE;
 637
 638         /* get all new in objects */
 639         ins = evas_event_objects_event_list(e, NULL, x, y);
 640         /* go thru old list of in objects */
 641         copy = evas_event_list_copy(e->pointer.object.in);
 642         for (l = copy; l; l = l->next)
 643           {
 644              Evas_Object *obj;
 645
 646              obj = l->data;
 647              /* if its under the pointer and its visible and its in the new */
 648              /* in list */
 649 // FIXME: i don't think we need this
 650 //           evas_object_clip_recalc(obj);
 651              if (evas_object_is_in_output_rect(obj, x, y, 1, 1) &&
 652                  (obj->cur.visible) &&
 653                  (evas_object_clippers_is_visible(obj)) &&
 654                  (evas_list_find(ins, obj)) &&
 655                  (!evas_event_passes_through(obj)) &&
 656                  (!obj->clip.clipees) &&
 657                  ((!obj->precise_is_inside) ||
 658                   (evas_object_is_inside(obj, x, y))))
 659                {
 660                   if ((px != x) || (py != y))
 661                     {
 662                        if (e->events_frozen <= 0)
 663                          evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_MOVE, &ev);
 664                     }
 665                }
 666              /* otherwise it has left the object */
 667              else
 668                {
 669                   obj->mouse_in = 0;
 670                   if (e->events_frozen <= 0)
 671                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev2);
 672                }
 673              if (e->delete_me) break;
 674           }
 675         if (copy) copy = evas_list_free(copy);
 676         /* go thru our current list of ins */
 677         for (l = ins; l; l = l->next)
 678           {
 679              Evas_Object *obj;
 680
 681              obj = l->data;
 682              /* if its not in the old list of ins send an enter event */
 683              if (!evas_list_find(e->pointer.object.in, obj))
 684                {
 685                   obj->mouse_in = 1;
 686
 687                   if (e->events_frozen <= 0)
 688                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev3);
 689                }
 690              if (e->delete_me) break;
 691           }
 692         /* free our old list of ins */
 693         evas_list_free(e->pointer.object.in);
 694         /* and set up the new one */
 695         e->pointer.object.in = ins;
 696      }
 697    _evas_unwalk(e);
 698 }
 699
 700 /**
 701  * To be documented.
 702  *
 703  * FIXME: To be fixed.
 704  *
 705  */
 706 EAPI void
 707 evas_event_feed_mouse_in(Evas *e, unsigned int timestamp, const void *data)
 708 {
 709    Evas_List *ins;
 710    Evas_List *l;
 711    Evas_Event_Mouse_In ev;
 712
 713    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 714    return;
 715    MAGIC_CHECK_END();
 716    e->pointer.inside = 1;
 717
 718    if (e->events_frozen > 0) return;
 719    e->last_timestamp = timestamp;
 720
 721    if (e->pointer.mouse_grabbed != 0) return;
 722
 723    ev.buttons = e->pointer.button;
 724    ev.output.x = e->pointer.x;
 725    ev.output.y = e->pointer.y;
 726    ev.canvas.x = e->pointer.x;
 727    ev.canvas.y = e->pointer.y;
 728    ev.data = (void *)data;
 729    ev.modifiers = &(e->modifiers);
 730    ev.locks = &(e->locks);
 731    ev.timestamp = timestamp;
 732    ev.event_flags = EVAS_EVENT_FLAG_NONE;
 733
 734    _evas_walk(e);
 735    /* get new list of ins */
 736    ins = evas_event_objects_event_list(e, NULL, e->pointer.x, e->pointer.y);
 737    for (l = ins; l; l = l->next)
 738      {
 739         Evas_Object *obj;
 740
 741         obj = l->data;
 742
 743         if (!evas_list_find(e->pointer.object.in, obj))
 744           {
 745
 746              obj->mouse_in = 1;
 747              if (e->events_frozen <= 0)
 748                evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_IN, &ev);
 749           }
 750         if (e->delete_me) break;
 751      }
 752    /* free our old list of ins */
 753    e->pointer.object.in = evas_list_free(e->pointer.object.in);
 754    /* and set up the new one */
 755    e->pointer.object.in = ins;
 756    evas_event_feed_mouse_move(e, e->pointer.x, e->pointer.y, timestamp, data);
 757    _evas_unwalk(e);
 758 }
 759
 760 /**
 761  * To be documented.
 762  *
 763  * FIXME: To be fixed.
 764  *
 765  */
 766 EAPI void
 767 evas_event_feed_mouse_out(Evas *e, unsigned int timestamp, const void *data)
 768 {
 769    Evas_Event_Mouse_Out ev;
 770
 771    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 772    return;
 773    MAGIC_CHECK_END();
 774    e->pointer.inside = 0;
 775
 776    if (e->events_frozen > 0) return;
 777    e->last_timestamp = timestamp;
 778
 779    ev.buttons = e->pointer.button;
 780    ev.output.x = e->pointer.x;
 781    ev.output.y = e->pointer.y;
 782    ev.canvas.x = e->pointer.x;
 783    ev.canvas.y = e->pointer.y;
 784    ev.data = (void *)data;
 785    ev.modifiers = &(e->modifiers);
 786    ev.locks = &(e->locks);
 787    ev.timestamp = timestamp;
 788    ev.event_flags = EVAS_EVENT_FLAG_NONE;
 789
 790    _evas_walk(e);
 791    /* if our mouse button is grabbed to any objects */
 792    if (e->pointer.mouse_grabbed == 0)
 793      {
 794         /* go thru old list of in objects */
 795         Evas_List *l, *copy;
 796
 797         copy = evas_event_list_copy(e->pointer.object.in);
 798         for (l = copy; l; l = l->next)
 799           {
 800              Evas_Object *obj;
 801
 802              obj = l->data;
 803                {
 804
 805                   obj->mouse_in = 0;
 806                   if (e->events_frozen <= 0)
 807                     evas_object_event_callback_call(obj, EVAS_CALLBACK_MOUSE_OUT, &ev);
 808                }
 809              if (e->delete_me) break;
 810           }
 811         if (copy) copy = evas_list_free(copy);
 812         /* free our old list of ins */
 813         e->pointer.object.in =  evas_list_free(e->pointer.object.in);
 814      }
 815    _evas_unwalk(e);
 816 }
 817
 818 /**
 819  * To be documented.
 820  *
 821  * FIXME: To be fixed.
 822  *
 823  */
 824 EAPI void
 825 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)
 826 {
 827    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 828    return;
 829    MAGIC_CHECK_END();
 830    if (!keyname) return;
 831    if (e->events_frozen > 0) return;
 832    e->last_timestamp = timestamp;
 833    _evas_walk(e);
 834      {
 835         Evas_Event_Key_Down ev;
 836         int exclusive;
 837
 838         exclusive = 0;
 839         ev.keyname = (char *)keyname;
 840         ev.data = (void *)data;
 841         ev.modifiers = &(e->modifiers);
 842         ev.locks = &(e->locks);
 843         ev.key = key;
 844         ev.string = string;
 845         ev.compose = compose;
 846         ev.timestamp = timestamp;
 847         ev.event_flags = EVAS_EVENT_FLAG_NONE;
 848         if (e->grabs)
 849           {
 850              Evas_List *l;
 851
 852              e->walking_grabs++;
 853              for (l = e->grabs; l; l= l->next)
 854                {
 855                   Evas_Key_Grab *g;
 856
 857                   g = l->data;
 858                   if (g->just_added)
 859                     {
 860                        g->just_added = 0;
 861                        continue;
 862                     }
 863                   if (g->delete_me) continue;
 864                   if (((e->modifiers.mask & g->modifiers) ||
 865                        (g->modifiers == e->modifiers.mask)) &&
 866                       (!strcmp(keyname, g->keyname)))
 867                     {
 868                        if (!(e->modifiers.mask & g->not_modifiers))
 869                          {
 870                             if (e->events_frozen <= 0)
 871                               evas_object_event_callback_call(g->object, EVAS_CALLBACK_KEY_DOWN, &ev);
 872                             if (g->exclusive) exclusive = 1;
 873                          }
 874                     }
 875                   if (e->delete_me) break;
 876                }
 877              e->walking_grabs--;
 878              if (e->walking_grabs <= 0)
 879                {
 880                   while (e->delete_grabs > 0)
 881                     {
 882                        Evas_List *l;
 883
 884                        e->delete_grabs--;
 885                        for (l = e->grabs; l;)
 886                          {
 887                             Evas_Key_Grab *g;
 888
 889                             g = l->data;
 890                             l = l->next;
 891                             if (g->delete_me)
 892                               evas_key_grab_free(g->object, g->keyname, g->modifiers, g->not_modifiers);
 893                          }
 894                     }
 895                }
 896           }
 897         if ((e->focused) && (!exclusive))
 898           {
 899              if (e->events_frozen <= 0)
 900                evas_object_event_callback_call(e->focused, EVAS_CALLBACK_KEY_DOWN, &ev);
 901           }
 902      }
 903    _evas_unwalk(e);
 904 }
 905
 906 /**
 907  * To be documented.
 908  *
 909  * FIXME: To be fixed.
 910  *
 911  */
 912 EAPI void
 913 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)
 914 {
 915    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
 916    return;
 917    MAGIC_CHECK_END();
 918    if (!keyname) return;
 919    if (e->events_frozen > 0) return;
 920    e->last_timestamp = timestamp;
 921    _evas_walk(e);
 922      {
 923         Evas_Event_Key_Up ev;
 924         int exclusive;
 925
 926         exclusive = 0;
 927         ev.keyname = (char *)keyname;
 928         ev.data = (void *)data;
 929         ev.modifiers = &(e->modifiers);
 930         ev.locks = &(e->locks);
 931         ev.key = key;
 932         ev.string = string;
 933         ev.compose = compose;
 934         ev.timestamp = timestamp;
 935         ev.event_flags = EVAS_EVENT_FLAG_NONE;
 936         if (e->grabs)
 937           {
 938              Evas_List *l;
 939
 940              e->walking_grabs++;
 941              for (l = e->grabs; l; l= l->next)
 942                {
 943                   Evas_Key_Grab *g;
 944
 945                   g = l->data;
 946                   if (g->just_added)
 947                     {
 948                        g->just_added = 0;
 949                        continue;
 950                     }
 951                   if (g->delete_me) continue;
 952                   if (((e->modifiers.mask & g->modifiers) ||
 953                        (g->modifiers == e->modifiers.mask)) &&
 954                       (!((e->modifiers.mask & g->not_modifiers) ||
 955                          (g->not_modifiers == ~e->modifiers.mask))) &&
 956                       (!strcmp(keyname, g->keyname)))
 957                     {
 958                        if (e->events_frozen <= 0)
 959                          evas_object_event_callback_call(g->object, EVAS_CALLBACK_KEY_UP, &ev);
 960                        if (g->exclusive) exclusive = 1;
 961                     }
 962                   if (e->delete_me) break;
 963                }
 964              e->walking_grabs--;
 965              if (e->walking_grabs <= 0)
 966                {
 967                   while (e->delete_grabs > 0)
 968                     {
 969                        Evas_List *l;
 970
 971                        e->delete_grabs--;
 972                        for (l = e->grabs; l; l= l->next)
 973                          {
 974                             Evas_Key_Grab *g;
 975
 976                             g = l->data;
 977                             l = l->next;
 978                             if (g->delete_me)
 979                               evas_key_grab_free(g->object, g->keyname, g->modifiers, g->not_modifiers);
 980                          }
 981                     }
 982                }
 983           }
 984         if ((e->focused) && (!exclusive))
 985           {
 986              if (e->events_frozen <= 0)
 987                evas_object_event_callback_call(e->focused, EVAS_CALLBACK_KEY_UP, &ev);
 988           }
 989      }
 990    _evas_unwalk(e);
 991 }
 992
 993 /**
 994  * To be documented.
 995  *
 996  * FIXME: To be fixed.
 997  *
 998  */
 999 EAPI void
1000 evas_event_feed_hold(Evas *e, int hold, unsigned int timestamp, const void *data)
1001 {
1002    Evas_List *l, *copy;
1003    Evas_Event_Hold ev;
1004
1005    MAGIC_CHECK(e, Evas, MAGIC_EVAS);
1006    return;
1007    MAGIC_CHECK_END();
1008
1009    if (e->events_frozen > 0) return;
1010    e->last_timestamp = timestamp;
1011
1012    ev.hold = hold;
1013    ev.data = (void *)data;
1014    ev.timestamp = timestamp;
1015    ev.event_flags = EVAS_EVENT_FLAG_NONE;
1016
1017    _evas_walk(e);
1018    copy = evas_event_list_copy(e->pointer.object.in);
1019    for (l = copy; l; l = l->next)
1020      {
1021         Evas_Object *obj;
1022
1023         obj = l->data;
1024         if (e->events_frozen <= 0)
1025           evas_object_event_callback_call(obj, EVAS_CALLBACK_HOLD, &ev);
1026         if (e->delete_me) break;
1027      }
1028    if (copy) copy = evas_list_free(copy);
1029    _evas_unwalk(e);
1030 }
1031
1032 /**
1033  * @defgroup Evas_Object_Event_Flags_Group Evas Object Event Flag Functions
1034  *
1035  * Functions that deal with how events on an Evas Object are processed.
1036  */
1037
1038 /**
1039  * Set an object's pass events state.
1040  * @param obj the evas object
1041  * @param pass whether to pass events or not
1042  *
1043  * If @p pass is true, this will cause events on @p obj to be ignored.
1044  * They will be triggered on the next lower object (that is not set to
1045  * pass events) instead.
1046  *
1047  * If @p pass is false, events will be processed as normal.
1048  *
1049  * @ingroup Evas_Object_Event_Flags_Group
1050  */
1051 EAPI void
1052 evas_object_pass_events_set(Evas_Object *obj, Evas_Bool pass)
1053 {
1054    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1055    return;
1056    MAGIC_CHECK_END();
1057    obj->pass_events = pass;
1058    evas_object_smart_member_cache_invalidate(obj);
1059    if (evas_object_is_in_output_rect(obj,
1060                                      obj->layer->evas->pointer.x,
1061                                      obj->layer->evas->pointer.y, 1, 1) &&
1062        ((!obj->precise_is_inside) ||
1063         (evas_object_is_inside(obj,
1064                                obj->layer->evas->pointer.x,
1065                                obj->layer->evas->pointer.y))))
1066      evas_event_feed_mouse_move(obj->layer->evas,
1067                                 obj->layer->evas->pointer.x,
1068                                 obj->layer->evas->pointer.y,
1069                                 obj->layer->evas->last_timestamp,
1070                                 NULL);
1071 }
1072
1073 /**
1074  * Determine whether an object is set to pass events.
1075  * @param obj
1076  * @return pass events state
1077  *
1078  * @ingroup Evas_Object_Event_Flags_Group
1079  */
1080 EAPI Evas_Bool
1081 evas_object_pass_events_get(const Evas_Object *obj)
1082 {
1083    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1084    return 0;
1085    MAGIC_CHECK_END();
1086    return obj->pass_events;
1087 }
1088
1089 /**
1090  * Set an object's repeat events state.
1091  * @param obj the object
1092  * @param repeat wheter to repeat events or not
1093  *
1094  * If @p repeat is true, this will cause events on @p obj to trigger
1095  * callbacks, but also to be repeated on the next lower object in the
1096  * stack.
1097  *
1098  * If @p repeat is false, events occuring on @p obj will be processed
1099  * normally.
1100  *
1101  * @ingroup Evas_Object_Event_Flags_Group
1102  */
1103 EAPI void
1104 evas_object_repeat_events_set(Evas_Object *obj, Evas_Bool repeat)
1105 {
1106    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1107    return;
1108    MAGIC_CHECK_END();
1109    obj->repeat_events = repeat;
1110    if (evas_object_is_in_output_rect(obj,
1111                                      obj->layer->evas->pointer.x,
1112                                      obj->layer->evas->pointer.y, 1, 1) &&
1113        ((!obj->precise_is_inside) ||
1114         (evas_object_is_inside(obj,
1115                                obj->layer->evas->pointer.x,
1116                                obj->layer->evas->pointer.y))))
1117      evas_event_feed_mouse_move(obj->layer->evas,
1118                                 obj->layer->evas->pointer.x,
1119                                 obj->layer->evas->pointer.y,
1120                                 obj->layer->evas->last_timestamp,
1121                                 NULL);
1122 }
1123
1124 /**
1125  * Determine whether an object is set to repeat events.
1126  * @param obj
1127  * @return repeat events state
1128  *
1129  * @ingroup Evas_Object_Event_Flags_Group
1130  */
1131 EAPI Evas_Bool
1132 evas_object_repeat_events_get(const Evas_Object *obj)
1133 {
1134    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1135    return 0;
1136    MAGIC_CHECK_END();
1137    return obj->repeat_events;
1138 }
1139
1140 /**
1141  * Set whether events on a smart member object should propagate to its parent.
1142  *
1143  * @param obj the smart member object
1144  * @param prop wheter to propagate events or not
1145  *
1146  * This function has no effect if @p obj is not a member of a smart
1147  * object.
1148  *
1149  * If @p prop is true, events occuring on this object will propagate on
1150  * to the smart object of which @p obj is a member.
1151  *
1152  * If @p prop is false, events for which callbacks are set on the member
1153  * object, @p obj, will not be passed on to the parent smart object.
1154  *
1155  * The default value is true.
1156  * @ingroup Evas_Object_Event_Flags_Group
1157  */
1158 EAPI void
1159 evas_object_propagate_events_set(Evas_Object *obj, Evas_Bool prop)
1160 {
1161    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1162    return;
1163    MAGIC_CHECK_END();
1164    obj->no_propagate = !prop;
1165 }
1166
1167 /**
1168  * Determine whether an object is set to propagate events.
1169  * @param obj
1170  * @return propogate events state
1171  *
1172  * @ingroup Evas_Object_Event_Flags_Group
1173  */
1174 EAPI Evas_Bool
1175 evas_object_propagate_events_get(const Evas_Object *obj)
1176 {
1177    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1178    return 0;
1179    MAGIC_CHECK_END();
1180    return !(obj->no_propagate);
1181 }
1182
1183 /**
1184  * Set pointer behavior.
1185  *
1186  * @param obj
1187  * @param setting desired behavior.
1188  *
1189  * This function has direct effect on event callbacks related to mouse.
1190  *
1191  * If @p setting is EVAS_OBJECT_POINTER_MODE_AUTOGRAB, then when mouse is
1192  * down at this object, events will be restricted to it as source, mouse
1193  * moves, for example, will be emitted even if outside this object area.
1194  *
1195  * If @p setting is EVAS_OBJECT_POINTER_MODE_NOGRAB, then events will be
1196  * emitted just when inside this object area.
1197  *
1198  * The default value is EVAS_OBJECT_POINTER_MODE_AUTOGRAB.
1199  */
1200 EAPI void
1201 evas_object_pointer_mode_set(Evas_Object *obj, Evas_Object_Pointer_Mode setting)
1202 {
1203    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1204    return;
1205    MAGIC_CHECK_END();
1206    obj->pointer_mode = setting;
1207 }
1208
1209 /**
1210  * Determine how pointer will behave.
1211  * @param obj
1212  * @return pointer behavior.
1213  */
1214 EAPI Evas_Object_Pointer_Mode
1215 evas_object_pointer_mode_get(const Evas_Object *obj)
1216 {
1217    MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
1218    return 0;
1219    MAGIC_CHECK_END();
1220    return obj->pointer_mode;
1221 }