1 #define EFL_INPUT_EVENT_PROTECTED
2
3 #include "evas_common_private.h"
4 #include "evas_private.h"
5
6 int _evas_event_counter = 0;
7
8 static Eina_List *
9 _evas_event_object_list_in_get(Evas *eo_e, Eina_List *in,
10 const Eina_Inlist *ilist,
11 const Eina_List *list,
12 Evas_Object *stop,
13 int x, int y, int *no_rep, Eina_Bool source);
14
15 /* FIXME: use eina_list_clone */
16 static Eina_List *
17 evas_event_list_copy(Eina_List *list);
18
19 static void
20 _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev);
21
22 static void
23 _canvas_event_feed_multi_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev);
24
25 static void
26 _canvas_event_feed_multi_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev);
27
28 static void
29 _canvas_event_feed_mouse_move_legacy(Evas *eo_e, Evas_Public_Data *e, int x, int y,
30 unsigned int timestamp, const void *data);
31
32 static inline void
_evas_event_feed_check(Evas_Public_Data * e)33 _evas_event_feed_check(Evas_Public_Data *e)
34 {
35 if (EINA_LIKELY(!e->running_post_events)) return;
36 CRI("Feeding new input events from a post-event callback is risky!");
37 }
38
39 static inline Eina_Bool
_evas_event_object_pointer_allow(Eo * eo_obj,Evas_Object_Protected_Data * obj,Evas_Object_Pointer_Data * obj_pdata)40 _evas_event_object_pointer_allow(Eo *eo_obj, Evas_Object_Protected_Data *obj, Evas_Object_Pointer_Data *obj_pdata)
41 {
42 return (obj->is_event_parent || evas_object_clippers_is_visible(eo_obj, obj) || obj_pdata->mouse_grabbed) &&
43 (!evas_event_passes_through(eo_obj, obj)) &&
44 (!evas_event_freezes_through(eo_obj, obj)) &&
45 (!obj->clip.clipees);
46 }
47
48 static inline Eina_Bool
_evas_event_object_pointer_allow_precise(Eo * eo_obj,Evas_Object_Protected_Data * obj,int x,int y,const Eina_List * ins)49 _evas_event_object_pointer_allow_precise(Eo *eo_obj, Evas_Object_Protected_Data *obj, int x, int y, const Eina_List *ins)
50 {
51 return eina_list_data_find(ins, eo_obj) &&
52 ((!obj->precise_is_inside) || evas_object_is_inside(eo_obj, obj, x, y));
53 }
54
55 #define EVAS_EVENT_FEED_SAFETY_CHECK(evas) _evas_event_feed_check(evas)
56
57 static Eina_Bool
_evas_event_havemap_adjust_f_inline(Evas_Object_Protected_Data * obj,Eina_Vector2 * point,Eina_Bool mouse_grabbed)58 _evas_event_havemap_adjust_f_inline(Evas_Object_Protected_Data *obj, Eina_Vector2 *point, Eina_Bool mouse_grabbed)
59 {
60 Eina_Bool ret = EINA_FALSE;
61
62 if (obj->smart.parent)
63 {
64 Evas_Object_Protected_Data *smart_parent_obj = efl_data_scope_get(obj->smart.parent, EFL_CANVAS_OBJECT_CLASS);
65 ret |= _evas_event_havemap_adjust_f_inline(smart_parent_obj, point, mouse_grabbed);
66 }
67
68 if ((!obj->map->cur.usemap) || (!obj->map->cur.map)) return ret;
69
70 //FIXME: Unless map_coords_get() supports grab mode and extrapolate coords
71 //outside map, this should check the return value for outside case.
72
73 //FIXME: When Mouse Out, it fails. but the coordiates might be transformed as well.
74 if (evas_map_coords_get(obj->map->cur.map, point->x, point->y, &point->x, &point->y, mouse_grabbed))
75 {
76 point->x += obj->cur->geometry.x;
77 point->y += obj->cur->geometry.y;
78 return EINA_TRUE;
79 }
80 return ret;
81 }
82
83 static void
_evas_event_havemap_adjust_f(Evas_Object_Protected_Data * obj,Eina_Vector2 * cur_pt,Eina_Vector2 * prev_pt,Eina_Bool mouse_grabbed)84 _evas_event_havemap_adjust_f(Evas_Object_Protected_Data *obj, Eina_Vector2 *cur_pt, Eina_Vector2 *prev_pt, Eina_Bool mouse_grabbed)
85 {
86 Eina_Vector2 tmp_pt = *cur_pt;
87 if (!_evas_event_havemap_adjust_f_inline(obj, &tmp_pt, mouse_grabbed)) return;
88
89 prev_pt->x += (tmp_pt.x - cur_pt->x);
90 prev_pt->y += (tmp_pt.y - cur_pt->y);
91 *cur_pt = tmp_pt;
92 }
93
94 #if 0
95 # define DDD_DO 1
96 # define DDD(...) do { for (int _i = 0; _i < spaces; _i++) printf(" "); printf(__VA_ARGS__); } while (0)
97 # define D(...) do { printf(__VA_ARGS__); } while (0)
98 # define DDD_STATIC static
99 #else
100 # define DDD(...) do { } while (0)
101 # define D(...) do { } while (0)
102 # define DDD_STATIC
103 #endif
104
105 #ifdef DDD_DO
106 static void
walk_clippers_print(int spaces,Evas_Object_Protected_Data * obj)107 walk_clippers_print(int spaces, Evas_Object_Protected_Data *obj)
108 {
109 DDD("<<< CLIP %p c[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i]\n",
110 obj->object,
111 obj->cur->geometry.x, obj->cur->geometry.y,
112 obj->cur->geometry.w, obj->cur->geometry.h,
113 obj->cur->cache.clip.x, obj->cur->cache.clip.y,
114 obj->cur->cache.clip.w, obj->cur->cache.clip.h
115 );
116 if (obj->cur->clipper) walk_clippers_print(spaces + 1, obj->cur->clipper);
117 }
118 #endif
119
120 static void
clip_calc(Evas_Object_Protected_Data * obj,Eina_Rectangle * c)121 clip_calc(Evas_Object_Protected_Data *obj, Eina_Rectangle *c)
122 {
123 if (!obj) return;
124 RECTS_CLIP_TO_RECT(c->x, c->y, c->w, c->h,
125 obj->cur->geometry.x, obj->cur->geometry.y,
126 obj->cur->geometry.w, obj->cur->geometry.h);
127 clip_calc(obj->cur->clipper, c);
128 }
129
130 static Eina_List *
_evas_event_object_list_raw_in_get_single(Evas * eo_e,Evas_Object_Protected_Data * obj,Eina_List * in,Evas_Object * stop,int x,int y,int * no_rep,Eina_Bool source,int spaces EINA_UNUSED)131 _evas_event_object_list_raw_in_get_single(Evas *eo_e, Evas_Object_Protected_Data *obj, Eina_List *in, Evas_Object *stop,
132 int x, int y, int *no_rep, Eina_Bool source, int spaces EINA_UNUSED)
133 {
134 Eina_Rectangle c;
135 int inside;
136 Evas_Object *eo_obj = obj->object;
137 if (eo_obj == stop)
138 {
139 *no_rep = 1;
140 DDD("***** NO REP - STOP *****\n");
141 return in;
142 }
143 if ((!obj->cur->visible) && (!obj->is_event_parent)) return in;
144 // XXX: this below DYNAMICALLY calculates the current clip rect
145 // by walking clippers to each parent clipper until there are
146 // no more of them. this is a necessary hack because cache.clip
147 // cooreds are broken. somewhere along the way in the past few years
148 // someone has forgotten to flag them as dirty and update them
149 // so a clicp recalce caqn work... somewhere. maybe a prexy or map fix
150 // or an optimization. finding this is really hard, so i'm going
151 // for plan b and doing this on the fly. it's only for event or
152 // callback handling so its a small percentage of the time, but
153 // it's better that we get this right
154
155 if (EINA_UNLIKELY((!!obj->map) && (obj->map->cur.map)
156 && (obj->map->cur.usemap)))
157 c = obj->map->cur.map->normal_geometry;
158 else
159 {
160 if (obj->is_smart)
161 {
162 Eina_Rectangle bounding_box = { 0, };
163
164 evas_object_smart_bounding_box_update(obj);
165 evas_object_smart_bounding_box_get(obj, &bounding_box, NULL);
166 c = bounding_box;
167 }
168 else
169 {
170 if (obj->clip.clipees) return in;
171 c = obj->cur->geometry;
172 }
173 }
174 clip_calc(obj->cur->clipper, &c);
175 // only worry about objects that intersect INCLUDING clippint
176 if ((!RECTS_INTERSECT(x, y, 1, 1, c.x, c.y, c.w, c.h)) && (!obj->child_has_map))
177 {
178 #ifdef DDD_DO
179 if (obj->is_smart)
180 {
181 Eina_Rectangle bounding_box = { 0, 0, 0, 0 };
182
183 evas_object_smart_bounding_box_get(obj, &bounding_box, NULL);
184 DDD("___ %p g[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i] b[%6i %6i %6ix%6i] %s\n",
185 obj->object,
186 obj->cur->geometry.x, obj->cur->geometry.y,
187 obj->cur->geometry.w, obj->cur->geometry.h,
188 obj->cur->cache.clip.x, obj->cur->cache.clip.y,
189 obj->cur->cache.clip.w, obj->cur->cache.clip.h,
190 bounding_box.x, bounding_box.y,
191 bounding_box.w, bounding_box.h,
192 obj->type);
193 }
194 else
195 {
196 DDD("___ %p g[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i] %s\n",
197 obj->object,
198 obj->cur->geometry.x, obj->cur->geometry.y,
199 obj->cur->geometry.w, obj->cur->geometry.h,
200 obj->cur->cache.clip.x, obj->cur->cache.clip.y,
201 obj->cur->cache.clip.w, obj->cur->cache.clip.h,
202 obj->type);
203 }
204 if (!strcmp(obj->type, "e_layout"))
205 {
206 if (obj->cur->clipper)
207 walk_clippers_print(spaces + 1, obj->cur->clipper);
208 }
209 #endif
210 return in;
211 }
212 #ifdef DDD_DO
213 else
214 {
215 if (obj->is_smart)
216 {
217 Eina_Rectangle bounding_box = { 0, 0, 0, 0 };
218
219 evas_object_smart_bounding_box_get(obj, &bounding_box, NULL);
220 DDD("OBJ %p g[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i] b[%6i %6i %6ix%6i] %s\n",
221 obj->object,
222 obj->cur->geometry.x, obj->cur->geometry.y,
223 obj->cur->geometry.w, obj->cur->geometry.h,
224 obj->cur->cache.clip.x, obj->cur->cache.clip.y,
225 obj->cur->cache.clip.w, obj->cur->cache.clip.h,
226 bounding_box.x, bounding_box.y,
227 bounding_box.w, bounding_box.h,
228 obj->type);
229 }
230 else
231 {
232 DDD("OBJ %p g[%6i %6i %6ix%6i] c[%6i %6i %6ix%6i] %s\n",
233 obj->object,
234 obj->cur->geometry.x, obj->cur->geometry.y,
235 obj->cur->geometry.w, obj->cur->geometry.h,
236 obj->cur->cache.clip.x, obj->cur->cache.clip.y,
237 obj->cur->cache.clip.w, obj->cur->cache.clip.h,
238 obj->type);
239 }
240 // if (!strcmp(obj->type, "e_layout"))
241 {
242 if (obj->cur->clipper)
243 walk_clippers_print(spaces + 1, obj->cur->clipper);
244 }
245 }
246 #endif
247
248 if (!source)
249 {
250 if (evas_event_passes_through(eo_obj, obj)) return in;
251 if (evas_object_is_source_invisible(eo_obj, obj)) return in;
252 }
253 if ((obj->delete_me == 0) &&
254 ((source) || ((obj->cur->visible || obj->is_event_parent) && (!obj->clip.clipees) &&
255 (obj->is_event_parent || evas_object_clippers_is_visible(eo_obj, obj)))))
256 {
257 if (obj->is_smart)
258 {
259 DDD("CHILDREN ->\n");
260 Evas_Object_Protected_Data *clip = obj->cur->clipper;
261 int norep = 0;
262
263 if (clip && clip->mask->is_mask && clip->precise_is_inside)
264 if (!evas_object_is_inside(clip->object, clip, x, y))
265 return in;
266
267 if ((obj->map->cur.usemap) && (obj->map->cur.map))
268 {
269 inside = evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1);
270 if (inside)
271 {
272 if (!evas_map_coords_get(obj->map->cur.map, x, y,
273 &(obj->map->cur.map->mx),
274 &(obj->map->cur.map->my), 0))
275 {
276 inside = 0;
277 }
278 else
279 {
280 in = _evas_event_object_list_in_get
281 (eo_e, in,
282 evas_object_smart_members_get_direct(eo_obj),
283 NULL,
284 stop,
285 obj->cur->geometry.x + obj->map->cur.map->mx,
286 obj->cur->geometry.y + obj->map->cur.map->my,
287 &norep, source);
288 }
289 }
290 }
291 else
292 {
293 Eina_Rectangle bounding_box = { 0, };
294
295 if (!obj->child_has_map)
296 evas_object_smart_bounding_box_update(obj);
297
298 evas_object_smart_bounding_box_get(obj, &bounding_box, NULL);
299
300 if (obj->child_has_map ||
301 (bounding_box.x <= x &&
302 bounding_box.x + bounding_box.w >= x &&
303 bounding_box.y <= y &&
304 bounding_box.y + bounding_box.h >= y) ||
305 (obj->cur->geometry.x <= x &&
306 obj->cur->geometry.x + obj->cur->geometry.w >= x &&
307 obj->cur->geometry.y <= y &&
308 obj->cur->geometry.y + obj->cur->geometry.h >= y))
309 in = _evas_event_object_list_in_get
310 (eo_e, in, evas_object_smart_members_get_direct(eo_obj), NULL,
311 stop, x, y, &norep, source);
312 }
313 if (norep)
314 {
315 if (!obj->repeat_events)
316 {
317 *no_rep = 1;
318 DDD("***** NO REP1 *****\n");
319 return in;
320 }
321 }
322 }
323 else if (obj->is_event_parent)
324 {
325 int norep = 0;
326 in = _evas_event_object_list_in_get(eo_e, in,
327 NULL, evas_object_event_grabber_members_list(eo_obj),
328 stop, x, y, &norep, source);
329 if (norep)
330 {
331 if (!obj->repeat_events)
332 {
333 *no_rep = 1;
334 DDD("***** NO REP1 *****\n");
335 return in;
336 }
337 }
338 }
339 else
340 {
341 Evas_Object_Protected_Data *clip = obj->cur->clipper;
342 if (clip && clip->mask->is_mask && clip->precise_is_inside)
343 inside = evas_object_is_inside(clip->object, clip, x, y);
344 else
345 inside = evas_object_is_in_output_rect(eo_obj, obj, x, y, 1, 1);
346
347 if (inside)
348 {
349 if ((obj->map->cur.usemap) && (obj->map->cur.map))
350 {
351 if (!evas_map_coords_get(obj->map->cur.map, x, y,
352 &(obj->map->cur.map->mx),
353 &(obj->map->cur.map->my), 0))
354 {
355 inside = 0;
356 }
357 }
358 }
359 if (inside && ((!obj->precise_is_inside) ||
360 (evas_object_is_inside(eo_obj, obj, x, y))))
361 {
362 if (!evas_event_freezes_through(eo_obj, obj))
363 {
364 DDD("----------------> ADD obj %p\n", obj->object);
365 in = eina_list_append(in, eo_obj);
366 }
367 if (!obj->repeat_events)
368 {
369 *no_rep = 1;
370 DDD("***** NO REP2 *****\n");
371 return in;
372 }
373 }
374 }
375 }
376 return in;
377 }
378
379 static Eina_List *
_evas_event_object_list_raw_in_get(Evas * eo_e,Eina_List * in,const Eina_Inlist * ilist,const Eina_List * list,Evas_Object * stop,int x,int y,int * no_rep,Eina_Bool source,Eina_Bool must_walk_last)380 _evas_event_object_list_raw_in_get(Evas *eo_e, Eina_List *in,
381 const Eina_Inlist *ilist,
382 const Eina_List *list,
383 Evas_Object *stop,
384 int x, int y, int *no_rep, Eina_Bool source,
385 Eina_Bool must_walk_last)
386 {
387 Evas_Object_Protected_Data *obj = NULL;
388 DDD_STATIC int spaces = 0;
389
390 if ((!ilist) && (!list)) return in;
391
392 spaces++;
393 if (ilist)
394 {
395 Eina_Inlist *last;
396
397 if (must_walk_last) last = eina_inlist_last(ilist);
398 else last = ilist->last;
399 for (obj = _EINA_INLIST_CONTAINER(obj, last);
400 obj;
401 obj = _EINA_INLIST_CONTAINER(obj, EINA_INLIST_GET(obj)->prev))
402 {
403 if (obj->events->parent) continue;
404 in = _evas_event_object_list_raw_in_get_single(eo_e, obj, in, stop, x, y, no_rep, source, spaces);
405 if (*no_rep) goto end;
406 }
407 }
408 else
409 {
410 Eina_List *l;
411
412 EINA_LIST_REVERSE_FOREACH(list, l, obj)
413 {
414 in = _evas_event_object_list_raw_in_get_single(eo_e, obj, in, stop, x, y, no_rep, source, spaces);
415 if (*no_rep) goto end;
416 }
417 }
418 *no_rep = 0;
419
420 end:
421 spaces--;
422 return in;
423 }
424
425 static void
_transform_to_src_space_f(Evas_Object_Protected_Data * obj,Evas_Object_Protected_Data * src,Eina_Vector2 * cur_pt,Eina_Vector2 * prev_pt)426 _transform_to_src_space_f(Evas_Object_Protected_Data *obj, Evas_Object_Protected_Data *src,
427 Eina_Vector2 *cur_pt, Eina_Vector2 *prev_pt)
428 {
429 double obj_w = obj->cur->geometry.w, obj_h = obj->cur->geometry.h;
430 double src_w = src->cur->geometry.w, src_h = src->cur->geometry.h;
431
432 //Current Point
433 cur_pt->x -= obj->cur->geometry.x;
434 cur_pt->y -= obj->cur->geometry.y;
435
436 if (!EINA_DBL_EQ(obj_w, src_w)) cur_pt->x *= (src_w / obj_w);
437 if (!EINA_DBL_EQ(obj_h, src_h)) cur_pt->y *= (src_h / obj_h);
438
439 cur_pt->x += src->cur->geometry.x;
440 cur_pt->y += src->cur->geometry.y;
441
442 //Prev Point
443 prev_pt->x -= obj->cur->geometry.x;
444 prev_pt->y -= obj->cur->geometry.y;
445
446 if (!EINA_DBL_EQ(obj_w, src_w)) prev_pt->x *= (src_w / obj_w);
447 if (!EINA_DBL_EQ(obj_h, src_h)) prev_pt->y *= (src_h / obj_h);
448
449 prev_pt->x += src->cur->geometry.x;
450 prev_pt->y += src->cur->geometry.y;
451 }
452
453 static Efl_Input_Device *
_evas_event_legacy_device_get(Eo * evas,Eina_Bool mouse)454 _evas_event_legacy_device_get(Eo *evas, Eina_Bool mouse)
455 {
456 Efl_Input_Device *dev = _evas_device_top_get(evas);
457 //The user did not push a device, use the default mouse/keyboard instead.
458 if (!dev)
459 {
460 Evas_Public_Data *e = efl_data_scope_get(evas, EVAS_CANVAS_CLASS);
461 if (mouse)
462 return e->default_mouse;
463 return e->default_keyboard;
464 }
465 return dev;
466 }
467
468 static void
_evas_event_source_mouse_down_events(Evas_Object * eo_obj,Evas * eo_e,Efl_Input_Pointer * parent_ev,Evas_Pointer_Data * pdata,int event_id)469 _evas_event_source_mouse_down_events(Evas_Object *eo_obj, Evas *eo_e,
470 Efl_Input_Pointer *parent_ev,
471 Evas_Pointer_Data *pdata,
472 int event_id)
473 {
474 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
475 Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
476 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
477 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
478 Evas_Object_Protected_Data *child;
479 Evas_Object *eo_child;
480 Eina_List *copy, *l;
481 Efl_Input_Pointer_Data *ev;
482 Efl_Input_Pointer *evt;
483 Eina_Vector2 cur_pt, prev_pt;
484 int addgrab = 0;
485 int no_rep = 0;
486 int srcgrab = 0;
487
488 if (obj->delete_me || src->delete_me || e->is_frozen) return;
489
490 evt = efl_duplicate(parent_ev);
491 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
492 if (!ev) return;
493
494 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
495
496 cur_pt = ev->cur;
497 prev_pt = ev->prev;
498 ev->source = eo_obj;
499 ev->touch_id = 0;
500
501 EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
502 {
503 Evas_Object_Pointer_Data *obj_pdata;
504
505 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
506 obj_pdata = _evas_object_pointer_data_get(pdata, child);
507 if (!obj_pdata)
508 {
509 ERR("Could not find the object pointer data for device %p",
510 ev->device);
511 continue;
512 }
513 srcgrab += obj_pdata->mouse_grabbed;
514 }
515
516 if (srcgrab == 0)
517 {
518 EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
519 {
520 if (proxy_write->src_event_in)
521 proxy_write->src_event_in = eina_list_free(proxy_write->src_event_in);
522
523 if (src->is_smart)
524 {
525 proxy_write->src_event_in = _evas_event_object_list_raw_in_get
526 (eo_e, proxy_write->src_event_in,
527 evas_object_smart_members_get_direct(eo_src), NULL,
528 NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
529 }
530 else if (src->is_event_parent)
531 {
532 proxy_write->src_event_in = _evas_event_object_list_raw_in_get
533 (eo_e, proxy_write->src_event_in,
534 NULL, evas_object_event_grabber_members_list(eo_src),
535 NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
536 }
537 else
538 proxy_write->src_event_in = eina_list_append(proxy_write->src_event_in, eo_src);
539 }
540 EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
541 }
542
543 if (pdata->seat->mouse_grabbed == 0)
544 {
545 if (pdata->seat->downs > 1) addgrab = pdata->seat->downs - 1;
546 }
547
548 EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
549 {
550 Evas_Object_Pointer_Data *obj_pdata;
551
552 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
553 obj_pdata = _evas_object_pointer_data_get(pdata, child);
554 if (!obj_pdata)
555 {
556 ERR("Could not find the object pointer data for device %p",
557 ev->device);
558 continue;
559 }
560 if ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
561 (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN))
562 {
563 obj_pdata->mouse_grabbed += (addgrab + 1);
564 pdata->seat->mouse_grabbed += (addgrab + 1);
565 if (obj_pdata->pointer_mode ==
566 EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
567 {
568 pdata->seat->nogrep++;
569 break;
570 }
571 }
572 }
573
574 copy = evas_event_list_copy(src->proxy->src_event_in);
575 EINA_LIST_FOREACH(copy, l, eo_child)
576 {
577 Evas_Object_Pointer_Data *obj_pdata;
578 Evas_Object_Pointer_Mode pointer_mode;
579
580 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
581 obj_pdata = _evas_object_pointer_data_get(pdata, child);
582 if (!obj_pdata)
583 {
584 ERR("Could not find the object pointer data for device %p",
585 ev->device);
586 continue;
587 }
588 pointer_mode = obj_pdata->pointer_mode;
589
590 ev->cur = cur_pt;
591 ev->prev = prev_pt;
592
593 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
594
595 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_DOWN, evt,
596 event_id, EFL_EVENT_POINTER_DOWN);
597 if (e->delete_me) break;
598 if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
599 break;
600 }
601 eina_list_free(copy);
602
603 efl_unref(evt);
604 }
605
606 static void
_evas_event_mouse_in_set(Evas_Pointer_Seat * pseat,Evas_Object_Protected_Data * obj,Eina_Bool mouse_in)607 _evas_event_mouse_in_set(Evas_Pointer_Seat *pseat,
608 Evas_Object_Protected_Data *obj, Eina_Bool mouse_in)
609 {
610 Evas_Pointer_Data *pdata;
611 Evas_Object_Pointer_Data *obj_pdata;
612
613 if ((!pseat) || (!obj)) return;
614
615 EINA_INLIST_FOREACH(pseat->pointers, pdata)
616 {
617 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
618 if (obj_pdata)
619 obj_pdata->mouse_in = mouse_in;
620 }
621 }
622
623 static void
_evas_event_source_mouse_move_events(Evas_Object * eo_obj,Evas * eo_e,Efl_Input_Pointer * parent_ev,Evas_Pointer_Data * pdata,int event_id)624 _evas_event_source_mouse_move_events(Evas_Object *eo_obj, Evas *eo_e,
625 Efl_Input_Pointer *parent_ev,
626 Evas_Pointer_Data *pdata,
627 int event_id)
628 {
629 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
630 Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
631 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
632 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
633 Evas_Object_Protected_Data *child;
634 Evas_Object *eo_child;
635 Eina_List *l;
636 Efl_Input_Pointer_Data *ev;
637 Efl_Input_Pointer *evt;
638 Eina_Vector2 cur_pt_real, prev_pt_real, cur_pt, prev_pt;
639 Evas_Object_Pointer_Data *obj_pdata;
640
641 if (obj->delete_me || src->delete_me || e->is_frozen) return;
642
643 evt = efl_duplicate(parent_ev);
644 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
645 if (!ev) return;
646
647 cur_pt_real = ev->cur;
648 prev_pt_real = ev->prev;
649
650 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
651
652 cur_pt = ev->cur;
653 prev_pt = ev->prev;
654 ev->source = eo_obj;
655 ev->touch_id = 0;
656
657 if (pdata->seat->mouse_grabbed)
658 {
659 Eina_List *outs = NULL;
660 Eina_List *copy = evas_event_list_copy(src->proxy->src_event_in);
661
662 EINA_LIST_FOREACH(copy, l, eo_child)
663 {
664 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
665 //FIXME: When object is deleted in the src_event_in list,
666 //the src_event_in list should be updated. But now there is no way.
667 //So add checking NULL logic, please delete it if you make a better way.
668 if (!child) continue;
669
670 obj_pdata = _evas_object_pointer_data_get(pdata, child);
671 if (!obj_pdata)
672 {
673 ERR("Could not find the object pointer data for device %p",
674 ev->device);
675 continue;
676 }
677
678 if (_evas_event_object_pointer_allow(eo_child, child, obj_pdata))
679 {
680 ev->cur = cur_pt;
681 ev->prev = prev_pt;
682
683 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
684
685 ev->action = EFL_POINTER_ACTION_MOVE;
686 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
687 event_id, EFL_EVENT_POINTER_MOVE);
688 }
689 else
690 outs = eina_list_append(outs, eo_child);
691 if (e->delete_me || e->is_frozen) break;
692 //FIXME: take care nograb object
693 }
694 eina_list_free(copy);
695
696 EINA_LIST_FREE(outs, eo_child)
697 {
698 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
699 if (child->delete_me) continue;
700 obj_pdata = _evas_object_pointer_data_get(pdata, child);
701 if (!obj_pdata)
702 {
703 ERR("Could not find the object pointer data for device %p",
704 ev->device);
705 continue;
706 }
707 if ((obj_pdata->mouse_grabbed == 0) && (!e->delete_me))
708 {
709 if (obj_pdata->mouse_in) continue; /* FIXME: dubious logic! */
710 _evas_event_mouse_in_set(pdata->seat, child, 0);
711 if (e->is_frozen) continue;
712
713 ev->cur = cur_pt_real;
714 ev->prev = prev_pt_real;
715
716 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
717
718 EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
719 proxy_write->src_event_in = eina_list_remove(proxy_write->src_event_in, eo_child);
720 EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
721
722 ev->action = EFL_POINTER_ACTION_OUT;
723 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_OUT, evt,
724 event_id, EFL_EVENT_POINTER_OUT);
725 }
726 }
727 }
728 else
729 {
730 Eina_List *ins = NULL;
731 Eina_List *copy = evas_event_list_copy(src->proxy->src_event_in);
732
733 if (src->is_smart)
734 {
735 int no_rep = 0;
736 ins = _evas_event_object_list_raw_in_get(eo_e, ins, evas_object_smart_members_get_direct(eo_src),
737 NULL, NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
738 }
739 else if (src->is_event_parent)
740 {
741 int no_rep = 0;
742 ins = _evas_event_object_list_raw_in_get(eo_e, ins, NULL,
743 evas_object_event_grabber_members_list(eo_src),
744 NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
745 }
746 else
747 ins = eina_list_append(ins, eo_src);
748
749 EINA_LIST_FOREACH(copy, l, eo_child)
750 {
751 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
752 //FIXME: When object is deleted in the src_event_in list,
753 //the src_event_in list should be updated. But now there is no way.
754 //So add checking NULL logic, please delete it if you make a better way.
755 if (!child) continue;
756
757 obj_pdata = _evas_object_pointer_data_get(pdata, child);
758 if (!obj_pdata)
759 {
760 ERR("Could not find the object pointer data for device %p",
761 ev->device);
762 continue;
763 }
764 ev->cur = cur_pt;
765 ev->prev = prev_pt;
766
767 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
768
769 if (evas_object_is_in_output_rect(eo_child, child,
770 ev->cur.x, ev->cur.y, 1, 1) &&
771 _evas_event_object_pointer_allow(eo_child, child, obj_pdata) &&
772 _evas_event_object_pointer_allow_precise(eo_child, child, ev->cur.x, ev->cur.y, ins))
773 {
774 ev->action = EFL_POINTER_ACTION_MOVE;
775 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
776 event_id, EFL_EVENT_POINTER_MOVE);
777 }
778 else if (obj_pdata->mouse_in)
779 {
780 _evas_event_mouse_in_set(pdata->seat, child, 0);
781 if (e->is_frozen) continue;
782 ev->action = EFL_POINTER_ACTION_OUT;
783 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_OUT, evt,
784 event_id, EFL_EVENT_POINTER_OUT);
785 if (e->delete_me) break;
786
787 }
788 if (e->delete_me || e->is_frozen) break;
789 }
790 eina_list_free(copy);
791
792 int event_id2 = _evas_object_event_new();
793 EINA_LIST_FOREACH(ins, l, eo_child)
794 {
795 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
796 obj_pdata = _evas_object_pointer_data_get(pdata, child);
797 if (!obj_pdata)
798 {
799 ERR("Could not find the object pointer data for device %p",
800 ev->device);
801 continue;
802 }
803 if (!eina_list_data_find(src->proxy->src_event_in, eo_child))
804 {
805 if (!obj_pdata->mouse_in)
806 {
807 _evas_event_mouse_in_set(pdata->seat, child, 1);
808 if (e->is_frozen) continue;
809
810 ev->cur = cur_pt;
811 ev->prev = prev_pt;
812
813 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
814
815 ev->action = EFL_POINTER_ACTION_IN;
816 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_IN, evt,
817 event_id2, EFL_EVENT_POINTER_IN);
818 if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
819 {
820 ev->action = EFL_POINTER_ACTION_MOVE;
821 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
822 event_id2, EFL_EVENT_POINTER_MOVE);
823 }
824 if (e->delete_me) break;
825 }
826 }
827 }
828
829 if (pdata->seat->mouse_grabbed == 0)
830 {
831 EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
832 {
833 eina_list_free(proxy_write->src_event_in);
834 proxy_write->src_event_in = ins;
835 }
836 EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
837 }
838 else
839 {
840 if (ins) eina_list_free(ins);
841 }
842 }
843
844 efl_unref(evt);
845 }
846
847 static void
_evas_event_source_mouse_up_events(Evas_Object * eo_obj,Evas * eo_e,Efl_Input_Pointer * parent_ev,Evas_Pointer_Data * pdata,int event_id,Eina_Bool cancel)848 _evas_event_source_mouse_up_events(Evas_Object *eo_obj, Evas *eo_e,
849 Efl_Input_Pointer *parent_ev,
850 Evas_Pointer_Data *pdata,
851 int event_id, Eina_Bool cancel)
852 {
853 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
854 Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
855 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
856 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
857 Evas_Object_Protected_Data *child;
858 Evas_Object *eo_child;
859 Eina_List *copy, *l;
860 Efl_Input_Pointer_Data *ev;
861 Efl_Input_Pointer *evt;
862 Eina_Vector2 cur_pt, prev_pt;
863
864 if (obj->delete_me || src->delete_me || e->is_frozen) return;
865
866 evt = efl_duplicate(parent_ev);
867 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
868 if (!ev) return;
869
870 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
871
872 cur_pt = ev->cur;
873 prev_pt = ev->prev;
874 ev->source = eo_obj;
875 ev->touch_id = 0;
876
877 copy = evas_event_list_copy(src->proxy->src_event_in);
878 EINA_LIST_FOREACH(copy, l, eo_child)
879 {
880 Evas_Object_Pointer_Data *obj_pdata;
881 Evas_Object_Pointer_Mode pointer_mode;
882
883 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
884 obj_pdata = _evas_object_pointer_data_get(pdata, child);
885 if (!obj_pdata)
886 {
887 ERR("Could not find the object pointer data for device %p",
888 ev->device);
889 continue;
890 }
891 if ((!cancel) && ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
892 (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
893 (obj_pdata->mouse_grabbed > 0))
894 {
895 obj_pdata->mouse_grabbed--;
896 pdata->seat->mouse_grabbed--;
897 }
898
899 pointer_mode = obj_pdata->pointer_mode;
900
901 ev->cur = cur_pt;
902 ev->prev = prev_pt;
903
904 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
905
906 if (cancel)
907 efl_event_callback_call(eo_child, EFL_EVENT_POINTER_CANCEL, evt);
908 else
909 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_UP, evt,
910 event_id, EFL_EVENT_POINTER_UP);
911 if (e->delete_me) break;
912 if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
913 {
914 if ((!cancel) && (pdata->seat->nogrep > 0)) pdata->seat->nogrep--;
915 break;
916 }
917 }
918 eina_list_free(copy);
919
920 efl_unref(evt);
921 }
922
923 static void
_evas_event_source_hold_events(Evas_Object * eo_obj,int event_id,Efl_Input_Hold * evt)924 _evas_event_source_hold_events(Evas_Object *eo_obj, int event_id, Efl_Input_Hold *evt)
925 {
926 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
927 Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
928 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
929 Evas_Object_Protected_Data *child;
930 Evas_Object *eo_child;
931 Eina_List *l;
932
933 if (obj->layer->evas->is_frozen) return;
934
935 EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
936 {
937 if (src->delete_me) return;
938 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
939 evas_object_event_callback_call(eo_child, child,
940 EVAS_CALLBACK_HOLD, evt,
941 event_id, EFL_EVENT_HOLD);
942 if (src->layer->evas->delete_me) break;
943 }
944 }
945
946 static void
_evas_event_source_wheel_events(Evas_Object * eo_obj,Evas * eo_e,Efl_Input_Pointer * parent_ev,int event_id)947 _evas_event_source_wheel_events(Evas_Object *eo_obj, Evas *eo_e,
948 Efl_Input_Pointer *parent_ev, int event_id)
949 {
950 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
951 Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
952 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
953 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
954 Evas_Object_Protected_Data *child;
955 Evas_Object *eo_child;
956 Eina_List *copy, *l;
957 Efl_Input_Pointer_Data *ev;
958 Efl_Input_Pointer *evt;
959 Eina_Vector2 cur_pt, prev_pt;
960 Evas_Pointer_Data *pdata;
961
962 if (obj->delete_me || src->delete_me || obj->layer->evas->is_frozen) return;
963
964 evt = efl_duplicate(parent_ev);
965 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
966 if (!ev) return;
967
968 pdata = _evas_pointer_data_by_device_get(e, ev->device);
969 if (!pdata) return;
970
971 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
972
973 cur_pt = ev->cur;
974 prev_pt = ev->prev;
975 ev->source = eo_obj;
976
977 copy = evas_event_list_copy(src->proxy->src_event_in);
978 EINA_LIST_FOREACH(copy, l, eo_child)
979 {
980 Evas_Object_Pointer_Data *obj_pdata;
981
982 if (src->delete_me) return;
983 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
984 //FIXME: When object is deleted in the src_event_in list,
985 //the src_event_in list should be updated. But now there is no way.
986 //So add checking NULL logic, please delete it if you make a better way.
987 if (!child) continue;
988
989 obj_pdata = _evas_object_pointer_data_get(pdata, child);
990 if (!obj_pdata)
991 {
992 ERR("Could not find the object pointer data for device %p",
993 ev->device);
994 continue;
995 }
996 ev->cur = cur_pt;
997 ev->prev = prev_pt;
998 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
999
1000 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_WHEEL, evt,
1001 event_id, EFL_EVENT_POINTER_WHEEL);
1002 if (e->delete_me) break;
1003 }
1004 eina_list_free(copy);
1005
1006 efl_unref(evt);
1007 }
1008
1009 static void
_evas_event_source_multi_down_events(Evas_Object_Protected_Data * obj,Evas_Public_Data * e,Efl_Input_Pointer * parent_ev,Evas_Pointer_Data * pdata,int event_id)1010 _evas_event_source_multi_down_events(Evas_Object_Protected_Data *obj, Evas_Public_Data *e,
1011 Efl_Input_Pointer *parent_ev, Evas_Pointer_Data *pdata,
1012 int event_id)
1013 {
1014 Evas_Object *eo_src = _evas_object_image_source_get(obj->object);
1015 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1016 Evas_Object_Protected_Data *child;
1017 Evas_Object *eo_child;
1018 Eina_List *copy, *l;
1019 Efl_Input_Pointer_Data *ev;
1020 Efl_Input_Pointer *evt;
1021 Eina_Vector2 cur_pt, prev_pt;
1022 Evas_Object_Pointer_Data *obj_pdata;
1023 int addgrab = 0;
1024
1025 if (obj->delete_me || src->delete_me || obj->layer->evas->is_frozen) return;
1026
1027 evt = efl_duplicate(parent_ev);
1028 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1029 if (!ev) return;
1030
1031 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1032
1033 cur_pt = ev->cur;
1034 prev_pt = ev->prev;
1035 ev->source = obj->object;
1036 ev->action = EFL_POINTER_ACTION_DOWN;
1037
1038 if (pdata->seat->mouse_grabbed == 0)
1039 {
1040 if (pdata->seat->downs > 1)
1041 addgrab = pdata->seat->downs - 1;
1042 else /* this is the first touch, which means it's also a move event, which means we need to redo this */
1043 {
1044 Eina_List *ins = NULL;
1045
1046 if (src->is_smart)
1047 {
1048 int no_rep = 0;
1049 ins = _evas_event_object_list_raw_in_get
1050 (e->evas, ins, evas_object_smart_members_get_direct(eo_src), NULL, NULL,
1051 ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1052 }
1053 if (src->is_event_parent)
1054 {
1055 int no_rep = 0;
1056 ins = _evas_event_object_list_raw_in_get
1057 (e->evas, ins, NULL, evas_object_event_grabber_members_list(eo_src), NULL,
1058 ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1059 }
1060 else
1061 ins = eina_list_append(ins, eo_src);
1062 EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
1063 {
1064 eina_list_free(proxy_write->src_event_in);
1065 proxy_write->src_event_in = ins;
1066 }
1067 EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
1068 }
1069 }
1070
1071 EINA_LIST_FOREACH(src->proxy->src_event_in, l, eo_child)
1072 {
1073 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1074 obj_pdata = _evas_object_pointer_data_get(pdata, child);
1075 if (!obj_pdata)
1076 {
1077 ERR("Could not find the object pointer data for device %p",
1078 ev->device);
1079 continue;
1080 }
1081 if (obj_pdata->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB)
1082 {
1083 obj_pdata->mouse_grabbed += (addgrab + 1);
1084 pdata->seat->mouse_grabbed += (addgrab + 1);
1085 }
1086 }
1087
1088 copy = evas_event_list_copy(src->proxy->src_event_in);
1089 EINA_LIST_FOREACH(copy, l, eo_child)
1090 {
1091 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1092 obj_pdata = _evas_object_pointer_data_get(pdata, child);
1093 if (!obj_pdata)
1094 {
1095 ERR("Could not find the object pointer data for device %p",
1096 ev->device);
1097 continue;
1098 }
1099 ev->cur = cur_pt;
1100 ev->prev = prev_pt;
1101
1102 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1103
1104 evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_DOWN, evt,
1105 event_id, EFL_EVENT_FINGER_DOWN);
1106 if (e->delete_me) break;
1107 }
1108 eina_list_free(copy);
1109
1110 efl_unref(evt);
1111 }
1112
1113 static void
_evas_event_source_multi_up_events(Evas_Object_Protected_Data * obj,Evas_Public_Data * e,Efl_Input_Pointer * parent_ev,Evas_Pointer_Data * pdata,int event_id)1114 _evas_event_source_multi_up_events(Evas_Object_Protected_Data *obj, Evas_Public_Data *e,
1115 Efl_Input_Pointer *parent_ev, Evas_Pointer_Data *pdata,
1116 int event_id)
1117 {
1118 Evas_Object *eo_src = _evas_object_image_source_get(obj->object);
1119 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1120 Evas_Object_Protected_Data *child;
1121 Evas_Object *eo_child;
1122 Eina_List *copy, *l;
1123 Efl_Input_Pointer_Data *ev;
1124 Efl_Input_Pointer *evt;
1125 Eina_Vector2 cur_pt, prev_pt;
1126
1127 if (obj->delete_me || src->delete_me || obj->layer->evas->is_frozen) return;
1128
1129 evt = efl_duplicate(parent_ev);
1130 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1131 if (!ev) return;
1132
1133 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1134
1135 cur_pt = ev->cur;
1136 prev_pt = ev->prev;
1137
1138 ev->source = obj->object;
1139 ev->action = EFL_POINTER_ACTION_UP;
1140
1141 copy = evas_event_list_copy(src->proxy->src_event_in);
1142 EINA_LIST_FOREACH(copy, l, eo_child)
1143 {
1144 Evas_Object_Pointer_Data *obj_pdata;
1145
1146 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1147
1148 obj_pdata = _evas_object_pointer_data_get(pdata, child);
1149 if (!obj_pdata)
1150 {
1151 ERR("Could not find the object pointer data for device %p",
1152 ev->device);
1153 continue;
1154 }
1155
1156 if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
1157 (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
1158 (obj_pdata->mouse_grabbed > 0))
1159 {
1160 obj_pdata->mouse_grabbed--;
1161 pdata->seat->mouse_grabbed--;
1162 }
1163 ev->cur = cur_pt;
1164 ev->prev = prev_pt;
1165 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1166
1167 evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_UP, evt,
1168 event_id, EFL_EVENT_FINGER_UP);
1169 if (e->delete_me || e->is_frozen) break;
1170 }
1171 eina_list_free(copy);
1172
1173 efl_unref(evt);
1174 }
1175
1176 static void
_evas_event_source_multi_move_events(Evas_Object_Protected_Data * obj,Evas_Public_Data * e,Efl_Input_Pointer * parent_ev,Evas_Pointer_Data * pdata,int event_id)1177 _evas_event_source_multi_move_events(Evas_Object_Protected_Data *obj, Evas_Public_Data *e,
1178 Efl_Input_Pointer *parent_ev, Evas_Pointer_Data *pdata,
1179 int event_id)
1180 {
1181 Evas_Object *eo_src = _evas_object_image_source_get(obj->object);
1182 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1183 Evas_Object_Protected_Data *child;
1184 Evas_Object *eo_child;
1185 Eina_List *copy, *l;
1186 Efl_Input_Pointer_Data *ev;
1187 Efl_Input_Pointer *evt;
1188 Eina_Vector2 cur_pt, prev_pt;
1189 Evas_Object_Pointer_Data *obj_pdata;
1190 Evas *eo_e = e->evas;
1191
1192 if (obj->delete_me || src->delete_me || e->is_frozen) return;
1193
1194 evt = efl_duplicate(parent_ev);
1195 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1196 if (!ev) return;
1197
1198 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1199
1200 cur_pt = ev->cur;
1201 prev_pt = ev->prev;
1202 ev->source = obj->object;
1203 ev->action = EFL_POINTER_ACTION_UP;
1204
1205 /* Why a new event id here? Other 'source' events keep the same id. */
1206 event_id = _evas_object_event_new();
1207
1208 if (pdata->seat->mouse_grabbed > 0)
1209 {
1210 copy = evas_event_list_copy(src->proxy->src_event_in);
1211 EINA_LIST_FOREACH(copy, l, eo_child)
1212 {
1213 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1214 obj_pdata = _evas_object_pointer_data_get(pdata, child);
1215 if (!obj_pdata)
1216 {
1217 ERR("Could not find the object pointer data for device %p",
1218 ev->device);
1219 continue;
1220 }
1221 if (_evas_event_object_pointer_allow(eo_child, child, obj_pdata))
1222 {
1223 ev->cur = cur_pt;
1224 ev->prev = prev_pt;
1225 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1226
1227 evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
1228 event_id, EFL_EVENT_FINGER_MOVE);
1229 if (e->delete_me || e->is_frozen) break;
1230 }
1231 }
1232 eina_list_free(copy);
1233 }
1234 else
1235 {
1236 Eina_List *ins = NULL;
1237
1238 if (src->is_smart)
1239 {
1240 int no_rep = 0;
1241 ins = _evas_event_object_list_raw_in_get
1242 (eo_e, ins, evas_object_smart_members_get_direct(eo_src), NULL, NULL,
1243 ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1244 }
1245 if (src->is_event_parent)
1246 {
1247 int no_rep = 0;
1248 ins = _evas_event_object_list_raw_in_get
1249 (eo_e, ins, NULL, evas_object_event_grabber_members_list(eo_src), NULL,
1250 ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1251 }
1252 else
1253 ins = eina_list_append(ins, eo_src);
1254
1255 copy = evas_event_list_copy(src->proxy->src_event_in);
1256 EINA_LIST_FOREACH(copy, l, eo_child)
1257 {
1258 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1259 obj_pdata = _evas_object_pointer_data_get(pdata, child);
1260 if (!obj_pdata)
1261 {
1262 ERR("Could not find the object pointer data for device %p",
1263 ev->device);
1264 continue;
1265 }
1266
1267 ev->cur = cur_pt;
1268 ev->prev = prev_pt;
1269 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1270
1271 if (evas_object_is_in_output_rect(eo_child, child, ev->cur.x, ev->cur.y, 1, 1) &&
1272 _evas_event_object_pointer_allow(eo_child, child, obj_pdata) &&
1273 _evas_event_object_pointer_allow_precise(eo_child, child, ev->cur.x, ev->cur.y, ins))
1274 {
1275 evas_object_event_callback_call(obj->object, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
1276 event_id, EFL_EVENT_FINGER_MOVE);
1277 if (e->delete_me || e->is_frozen) break;
1278 }
1279 }
1280 eina_list_free(copy);
1281 if (pdata->seat->mouse_grabbed == 0)
1282 {
1283 EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
1284 {
1285 eina_list_free(proxy_write->src_event_in);
1286 proxy_write->src_event_in = ins;
1287 }
1288 EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
1289 }
1290 else
1291 eina_list_free(ins);
1292 }
1293
1294 efl_unref(evt);
1295 }
1296
1297 static void
_evas_event_source_mouse_in_events(Evas_Object * eo_obj,Evas * eo_e,Efl_Input_Pointer * parent_ev,int event_id)1298 _evas_event_source_mouse_in_events(Evas_Object *eo_obj, Evas *eo_e,
1299 Efl_Input_Pointer *parent_ev, int event_id)
1300 {
1301 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1302 Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
1303 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1304 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1305 Evas_Object_Protected_Data *child;
1306 Evas_Object *eo_child;
1307 Eina_List *ins = NULL, *l;
1308 Efl_Input_Pointer_Data *ev;
1309 Efl_Input_Pointer *evt;
1310 Eina_Vector2 cur_pt, prev_pt;
1311 Evas_Pointer_Data *pdata;
1312
1313 if (obj->delete_me || src->delete_me || e->is_frozen) return;
1314 evt = efl_duplicate(parent_ev);
1315
1316 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1317 if (!ev) return;
1318
1319 pdata = _evas_pointer_data_by_device_get(e, ev->device);
1320 if (!pdata) return;
1321
1322 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1323
1324 cur_pt = ev->cur;
1325 prev_pt = ev->prev;
1326 ev->source = eo_obj;
1327 ev->action = EFL_POINTER_ACTION_IN;
1328
1329 if (src->is_smart)
1330 {
1331 int no_rep = 0;
1332 ins = _evas_event_object_list_raw_in_get(eo_e, ins, evas_object_smart_members_get_direct(eo_src),
1333 NULL, NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1334
1335 }
1336 else if (src->is_event_parent)
1337 {
1338 int no_rep = 0;
1339 ins = _evas_event_object_list_raw_in_get(eo_e, ins, NULL, evas_object_event_grabber_members_list(eo_src),
1340 NULL, ev->cur.x, ev->cur.y, &no_rep, EINA_TRUE, EINA_FALSE);
1341
1342 }
1343 else
1344 ins = eina_list_append(ins, eo_src);
1345
1346 EINA_LIST_FOREACH(ins, l, eo_child)
1347 {
1348 Evas_Object_Pointer_Data *obj_pdata;
1349
1350 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1351 obj_pdata = _evas_object_pointer_data_get(pdata, child);
1352 if (!obj_pdata)
1353 {
1354 ERR("Could not find the object pointer data for device %p",
1355 ev->device);
1356 continue;
1357 }
1358
1359 if (!eina_list_data_find(src->proxy->src_event_in, eo_child))
1360 {
1361 if (obj_pdata->mouse_in) continue;
1362 _evas_event_mouse_in_set(pdata->seat, child, 1);
1363
1364 ev->cur = cur_pt;
1365 ev->prev = prev_pt;
1366 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1367
1368 ev->action = EFL_POINTER_ACTION_IN;
1369 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_IN, evt,
1370 event_id, EFL_EVENT_POINTER_IN);
1371 if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
1372 {
1373 ev->action = EFL_POINTER_ACTION_MOVE;
1374 evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_MOVE, evt,
1375 event_id, EFL_EVENT_POINTER_MOVE);
1376 }
1377 if (e->delete_me || e->is_frozen) break;
1378 }
1379 }
1380
1381 EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
1382 {
1383 eina_list_free(proxy_write->src_event_in);
1384 proxy_write->src_event_in = ins;
1385 }
1386 EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
1387
1388 efl_unref(evt);
1389 }
1390
1391 static void
_evas_event_source_mouse_out_events(Evas_Object * eo_obj,Evas * eo_e,Efl_Input_Pointer * parent_ev,int event_id)1392 _evas_event_source_mouse_out_events(Evas_Object *eo_obj, Evas *eo_e,
1393 Efl_Input_Pointer *parent_ev, int event_id)
1394 {
1395 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1396 Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
1397 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1398 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1399 Evas_Object_Protected_Data *child;
1400 Evas_Object *eo_child;
1401 Eina_List *copy, *l;
1402 Efl_Input_Pointer_Data *ev;
1403 Efl_Input_Pointer *evt;
1404 Eina_Vector2 cur_pt, prev_pt;
1405 Evas_Pointer_Data *pdata;
1406
1407 if (obj->delete_me || src->delete_me || e->is_frozen) return;
1408
1409 evt = efl_duplicate(parent_ev);
1410 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1411 if (!ev) return;
1412
1413 pdata = _evas_pointer_data_by_device_get(e, ev->device);
1414 if (!pdata) return;
1415
1416 _transform_to_src_space_f(obj, src, &ev->cur, &ev->prev);
1417
1418 cur_pt = ev->cur;
1419 prev_pt = ev->prev;
1420 ev->source = eo_obj;
1421 ev->action = EFL_POINTER_ACTION_OUT;
1422
1423 copy = evas_event_list_copy(src->proxy->src_event_in);
1424 EINA_LIST_FOREACH(copy, l, eo_child)
1425 {
1426 Evas_Object_Pointer_Data *obj_pdata;
1427 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1428 obj_pdata = _evas_object_pointer_data_get(pdata, child);
1429 if (!obj_pdata)
1430 {
1431 ERR("Could not find the object pointer data for device %p",
1432 ev->device);
1433 continue;
1434 }
1435
1436 if (!obj_pdata->mouse_in) continue;
1437 _evas_event_mouse_in_set(pdata->seat, child, 0);
1438 if (child->delete_me) continue;
1439
1440 ev->cur = cur_pt;
1441 ev->prev = prev_pt;
1442 _evas_event_havemap_adjust_f(child, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1443
1444 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
1445 event_id, EFL_EVENT_POINTER_OUT);
1446 if (e->is_frozen) continue;
1447 }
1448 eina_list_free(copy);
1449
1450 EINA_COW_WRITE_BEGIN(evas_object_proxy_cow, src->proxy, Evas_Object_Proxy_Data, proxy_write)
1451 proxy_write->src_event_in = eina_list_free(proxy_write->src_event_in);
1452 EINA_COW_WRITE_END(evas_object_proxy_cow, src->proxy, proxy_write);
1453
1454 efl_unref(evt);
1455 }
1456
1457 static Eina_List *
_evas_event_object_list_in_get(Evas * eo_e,Eina_List * in,const Eina_Inlist * ilist,const Eina_List * list,Evas_Object * stop,int x,int y,int * no_rep,Eina_Bool source)1458 _evas_event_object_list_in_get(Evas *eo_e, Eina_List *in,
1459 const Eina_Inlist *ilist,
1460 const Eina_List *list,
1461 Evas_Object *stop,
1462 int x, int y, int *no_rep, Eina_Bool source)
1463 {
1464 return _evas_event_object_list_raw_in_get(eo_e, in, ilist, list, stop, x, y,
1465 no_rep, source, EINA_FALSE);
1466 }
1467
1468 static Eina_List *
_evas_event_objects_event_list_no_frozen_check(Evas * eo_e,Evas_Object * stop,int x,int y)1469 _evas_event_objects_event_list_no_frozen_check(Evas *eo_e, Evas_Object *stop, int x, int y)
1470 {
1471 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1472 Evas_Layer *lay;
1473 Eina_List *in = NULL;
1474
1475 if (!e->layers) return NULL;
1476
1477 D("@@@@@ layer count = %i\n", eina_inlist_count(EINA_INLIST_GET(e->layers)));
1478 EINA_INLIST_REVERSE_FOREACH((EINA_INLIST_GET(e->layers)), lay)
1479 {
1480 int no_rep = 0;
1481 D("############################# check layer %i\n", lay->layer);
1482 in = _evas_event_object_list_in_get(eo_e, in,
1483 EINA_INLIST_GET(lay->objects), NULL,
1484 stop, x, y, &no_rep, EINA_FALSE);
1485 if (no_rep) return in;
1486 }
1487 return in;
1488 }
1489
1490 EOLIAN Eina_List*
_evas_canvas_tree_objects_at_xy_get(Eo * eo_e,Evas_Public_Data * e EINA_UNUSED,Evas_Object * stop,int x,int y)1491 _evas_canvas_tree_objects_at_xy_get(Eo *eo_e, Evas_Public_Data *e EINA_UNUSED, Evas_Object *stop, int x, int y)
1492 {
1493 return _evas_event_objects_event_list_no_frozen_check(eo_e, stop, x, y);
1494 }
1495
1496 Eina_List *
evas_event_objects_event_list(Evas * eo_e,Evas_Object * stop,int x,int y)1497 evas_event_objects_event_list(Evas *eo_e, Evas_Object *stop, int x, int y)
1498 {
1499 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1500
1501 if ((!e->layers) || (e->is_frozen)) return NULL;
1502 D("------------------------------GET EVETNS AT ............... %i %i\n", x, y);
1503 return _evas_event_objects_event_list_no_frozen_check(eo_e, stop, x, y);
1504 }
1505
1506 static Eina_List *
evas_event_list_copy(Eina_List * list)1507 evas_event_list_copy(Eina_List *list)
1508 {
1509 Eina_List *l, *new_l = NULL;
1510 const void *data;
1511
1512 EINA_LIST_FOREACH(list, l, data)
1513 new_l = eina_list_append(new_l, data);
1514 return new_l;
1515 }
1516 /* public functions */
1517
1518 EOLIAN void
_evas_canvas_event_default_flags_set(Eo * eo_e EINA_UNUSED,Evas_Public_Data * e,Evas_Event_Flags flags)1519 _evas_canvas_event_default_flags_set(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e, Evas_Event_Flags flags)
1520 {
1521 e->default_event_flags = flags;
1522 }
1523
1524 EOLIAN Evas_Event_Flags
_evas_canvas_event_default_flags_get(const Eo * eo_e EINA_UNUSED,Evas_Public_Data * e)1525 _evas_canvas_event_default_flags_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e)
1526 {
1527 return e->default_event_flags;
1528 }
1529
1530 static inline void
_canvas_event_thaw_eval_internal(Eo * eo_e,Evas_Public_Data * e)1531 _canvas_event_thaw_eval_internal(Eo *eo_e, Evas_Public_Data *e)
1532 {
1533 Evas_Pointer_Data *pdata = _evas_pointer_data_by_device_get(e, NULL);
1534 if (!pdata) return;
1535 _canvas_event_feed_mouse_move_legacy(eo_e, e, pdata->seat->x, pdata->seat->y,
1536 e->last_timestamp, NULL);
1537 }
1538
1539 EAPI void
evas_event_freeze(Evas * eo_e)1540 evas_event_freeze(Evas *eo_e)
1541 {
1542 efl_event_freeze(eo_e);
1543 }
1544
1545 EAPI void
evas_event_thaw(Evas * eo_e)1546 evas_event_thaw(Evas *eo_e)
1547 {
1548 efl_event_thaw(eo_e);
1549 }
1550
1551 EOLIAN void
_evas_canvas_efl_object_event_freeze(Eo * eo_e,Evas_Public_Data * e)1552 _evas_canvas_efl_object_event_freeze(Eo *eo_e, Evas_Public_Data *e)
1553 {
1554 efl_event_freeze(efl_super(eo_e, EVAS_CANVAS_CLASS));
1555 e->is_frozen = EINA_TRUE;
1556 }
1557
1558 EOLIAN void
_evas_canvas_efl_object_event_thaw(Eo * eo_e,Evas_Public_Data * e)1559 _evas_canvas_efl_object_event_thaw(Eo *eo_e, Evas_Public_Data *e)
1560 {
1561 int fcount = -1;
1562 efl_event_thaw(efl_super(eo_e, EVAS_CANVAS_CLASS));
1563 fcount = efl_event_freeze_count_get(efl_super(eo_e, EVAS_CANVAS_CLASS));
1564 if (0 == fcount)
1565 {
1566 Evas_Layer *lay;
1567
1568 e->is_frozen = EINA_FALSE;
1569 EINA_INLIST_FOREACH((EINA_INLIST_GET(e->layers)), lay)
1570 {
1571 Evas_Object_Protected_Data *obj;
1572
1573 EINA_INLIST_FOREACH(lay->objects, obj)
1574 {
1575 evas_object_clip_recalc(obj);
1576 evas_object_recalc_clippees(obj);
1577 }
1578 }
1579
1580 _canvas_event_thaw_eval_internal(eo_e, e);
1581 }
1582 }
1583
1584 EAPI int
evas_event_freeze_get(const Evas * eo_e)1585 evas_event_freeze_get(const Evas *eo_e)
1586 {
1587 return efl_event_freeze_count_get(eo_e);
1588 }
1589
1590 EAPI void
evas_event_thaw_eval(Evas * eo_e)1591 evas_event_thaw_eval(Evas *eo_e)
1592 {
1593 if (!evas_event_freeze_get(eo_e))
1594 {
1595 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
1596 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
1597 _canvas_event_thaw_eval_internal(eo_e, e);
1598 }
1599 }
1600
1601 static void
_canvas_event_feed_mouse_down_internal(Evas_Public_Data * e,Efl_Input_Pointer_Data * ev)1602 _canvas_event_feed_mouse_down_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
1603 {
1604 Efl_Input_Pointer *evt;
1605 Eina_List *l, *copy;
1606 Evas_Object *eo_obj;
1607 int event_id, b;
1608 Evas *eo_e;
1609 int addgrab = 0;
1610 Evas_Pointer_Data *pdata;
1611 Evas_Object_Pointer_Data *obj_pdata;
1612
1613 static const int value_flags =
1614 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
1615 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
1616 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
1617 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID) |
1618 _efl_input_value_mask(EFL_INPUT_VALUE_BUTTON);
1619
1620 if (!e || !ev) return;
1621 EVAS_EVENT_FEED_SAFETY_CHECK(e);
1622
1623 pdata = _evas_pointer_data_by_device_get(e, ev->device);
1624 if (!pdata) return;
1625
1626 b = ev->button;
1627 DBG("ButtonEvent:down time=%u x=%d y=%d button=%d downs=%d",
1628 ev->timestamp, pdata->seat->x, pdata->seat->y, b, pdata->seat->downs);
1629 if ((b < 1) || (b > 32)) return;
1630
1631 pdata->button |= (1u << (b - 1));
1632 pdata->seat->downs++;
1633
1634 if (e->is_frozen) return;
1635 e->last_timestamp = ev->timestamp;
1636 eo_e = e->evas;
1637 evt = ev->eo;
1638
1639 event_id = _evas_object_event_new();
1640
1641 ev->cur.x = pdata->seat->x;
1642 ev->cur.y = pdata->seat->y;
1643 ev->modifiers = &(e->modifiers);
1644 ev->locks = &(e->locks);
1645 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
1646 ev->touch_id = 0;
1647 ev->action = EFL_POINTER_ACTION_DOWN;
1648 ev->value_flags |= value_flags;
1649 if (ev->device) efl_ref(ev->device);
1650
1651 _evas_walk(e);
1652 /* append new touch point to the touch point list */
1653 _evas_touch_point_append(e->evas, 0, pdata->seat->x, pdata->seat->y);
1654 /* If this is the first finger down, i.e no other fingers pressed,
1655 * get a new event list, otherwise, keep the current grabbed list. */
1656 if (pdata->seat->mouse_grabbed == 0)
1657 {
1658 Eina_List *ins = evas_event_objects_event_list(eo_e,
1659 NULL,
1660 pdata->seat->x,
1661 pdata->seat->y);
1662 /* free our old list of ins */
1663 eina_list_free(pdata->seat->object.in);
1664 /* and set up the new one */
1665 pdata->seat->object.in = ins;
1666 /* adjust grabbed count by the nuymber of currently held down
1667 * fingers/buttons */
1668 if (pdata->seat->downs > 1) addgrab = pdata->seat->downs - 1;
1669 }
1670 copy = evas_event_list_copy(pdata->seat->object.in);
1671 EINA_LIST_FOREACH(copy, l, eo_obj)
1672 {
1673 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1674 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
1675 if (!obj_pdata)
1676 {
1677 ERR("Could not find the object pointer data for device %p",
1678 ev->device);
1679 continue;
1680 }
1681
1682 if ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
1683 (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN))
1684 {
1685 obj_pdata->mouse_grabbed += addgrab + 1;
1686 pdata->seat->mouse_grabbed += addgrab + 1;
1687 if (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
1688 {
1689 pdata->seat->nogrep++;
1690 break;
1691 }
1692 }
1693 }
1694 EINA_LIST_FOREACH(copy, l, eo_obj)
1695 {
1696 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1697 Evas_Object_Pointer_Mode pointer_mode;
1698 if (obj->delete_me) continue;
1699 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
1700 if (!obj_pdata)
1701 {
1702 ERR("Could not find the object pointer data for device %p",
1703 ev->device);
1704 continue;
1705 }
1706 pointer_mode = obj_pdata->pointer_mode;
1707
1708 ev->cur.x = pdata->seat->x;
1709 ev->cur.y = pdata->seat->y;
1710 ev->prev.x = pdata->seat->prev.x;
1711 ev->prev.y = pdata->seat->prev.y;
1712 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1713
1714 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_DOWN, evt,
1715 event_id, EFL_EVENT_POINTER_DOWN);
1716 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
1717 _evas_event_source_mouse_down_events(eo_obj, eo_e, evt, pdata, event_id);
1718 if (e->is_frozen || e->delete_me) break;
1719 if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
1720 break;
1721 }
1722 if (copy) eina_list_free(copy);
1723 e->last_mouse_down_counter++;
1724 _evas_post_event_callback_call(eo_e, e, event_id);
1725 /* update touch point's state to EVAS_TOUCH_POINT_STILL */
1726 _evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_STILL);
1727 _evas_unwalk(e);
1728
1729 if (ev->device) efl_unref(ev->device);
1730 }
1731
1732 static void
_post_up_handle(Evas_Public_Data * e,Efl_Input_Pointer * parent_ev,Evas_Pointer_Data * pdata)1733 _post_up_handle(Evas_Public_Data *e, Efl_Input_Pointer *parent_ev,
1734 Evas_Pointer_Data *pdata)
1735 {
1736 Eina_List *l, *copy, *ins, *ll;
1737 Efl_Input_Pointer_Data *ev;
1738 Efl_Input_Pointer *evt;
1739 Evas_Object *eo_obj;
1740 Evas *eo_e = e->evas;
1741 Evas_Object_Pointer_Data *obj_pdata;
1742 int event_id;
1743
1744 /* Duplicating UP event */
1745 evt = efl_duplicate(parent_ev);
1746 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
1747 if (!ev) return;
1748
1749 event_id = _evas_object_event_new();
1750
1751 /* Actually we want an OUT */
1752 ev->action = EFL_POINTER_ACTION_OUT;
1753
1754 /* get new list of ins */
1755 ins = evas_event_objects_event_list(eo_e, NULL, pdata->seat->x, pdata->seat->y);
1756 /* go thru old list of in objects */
1757 copy = evas_event_list_copy(pdata->seat->object.in);
1758 EINA_LIST_FOREACH(copy, ll, eo_obj)
1759 {
1760 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1761 if ((!eina_list_data_find(ins, eo_obj)) || (!pdata->seat->inside))
1762 {
1763 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
1764 if (!obj_pdata)
1765 {
1766 ERR("Could not find the object pointer data for device %p",
1767 ev->device);
1768 continue;
1769 }
1770 if (!obj_pdata->mouse_in) continue;
1771 _evas_event_mouse_in_set(pdata->seat, obj, 0);
1772 if (!e->is_frozen)
1773 {
1774 ev->cur.x = pdata->seat->x;
1775 ev->cur.y = pdata->seat->y;
1776 ev->prev.x = pdata->seat->prev.x;
1777 ev->prev.y = pdata->seat->prev.y;
1778
1779 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1780
1781 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
1782 event_id, EFL_EVENT_POINTER_OUT);
1783 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
1784 _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
1785 if (e->delete_me) break;
1786 }
1787 }
1788 }
1789 _evas_post_event_callback_call(eo_e, e, event_id);
1790
1791 eina_list_free(copy);
1792
1793 if (pdata->seat->inside)
1794 {
1795 Evas_Object *eo_obj_itr;
1796
1797 event_id = _evas_object_event_new();
1798 ev->action = EFL_POINTER_ACTION_IN;
1799
1800 EINA_LIST_FOREACH(ins, l, eo_obj_itr)
1801 {
1802 Evas_Object_Protected_Data *obj_itr = efl_data_scope_get(eo_obj_itr, EFL_CANVAS_OBJECT_CLASS);
1803 if (!eina_list_data_find(pdata->seat->object.in, eo_obj_itr))
1804 {
1805 obj_pdata = _evas_object_pointer_data_get(pdata, obj_itr);
1806 if (!obj_pdata)
1807 {
1808 ERR("Could not find the object pointer data for device %p",
1809 ev->device);
1810 continue;
1811 }
1812 if (obj_pdata->mouse_in) continue;
1813 _evas_event_mouse_in_set(pdata->seat, obj_itr, 1);
1814 if (e->is_frozen) continue;
1815
1816 ev->cur.x = pdata->seat->x;
1817 ev->cur.y = pdata->seat->y;
1818 ev->prev.x = pdata->seat->prev.x;
1819 ev->prev.y = pdata->seat->prev.y;
1820
1821 _evas_event_havemap_adjust_f(obj_itr, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1822
1823 ev->action = EFL_POINTER_ACTION_IN;
1824 evas_object_event_callback_call(eo_obj_itr, obj_itr, EVAS_CALLBACK_MOUSE_IN, evt,
1825 event_id, EFL_EVENT_POINTER_IN);
1826 if ((pdata->seat->x != pdata->seat->prev.x) && (pdata->seat->y != pdata->seat->prev.y))
1827 {
1828 ev->action = EFL_POINTER_ACTION_MOVE;
1829 evas_object_event_callback_call(eo_obj_itr, obj_itr, EVAS_CALLBACK_MOUSE_MOVE, evt,
1830 event_id, EFL_EVENT_POINTER_MOVE);
1831 }
1832 if ((obj_itr->proxy->is_proxy) &&
1833 (obj_itr->proxy->src_events))
1834 _evas_event_source_mouse_in_events(eo_obj_itr, eo_e, evt, event_id);
1835 if (e->delete_me) break;
1836 }
1837 }
1838 _evas_post_event_callback_call(eo_e, e, event_id);
1839 }
1840 else
1841 {
1842 ins = eina_list_free(ins);
1843 }
1844
1845 if (pdata->seat->mouse_grabbed == 0)
1846 {
1847 /* free our old list of ins */
1848 eina_list_free(pdata->seat->object.in);
1849 /* and set up the new one */
1850 pdata->seat->object.in = ins;
1851 }
1852 else
1853 {
1854 /* free our cur ins */
1855 eina_list_free(ins);
1856 }
1857 if (pdata->seat->inside)
1858 _evas_canvas_event_pointer_move_event_dispatch(e, pdata, ev->data);
1859
1860 efl_unref(evt);
1861 }
1862
1863 static void
_canvas_event_feed_mouse_up_internal(Evas_Public_Data * e,Efl_Input_Pointer_Data * ev)1864 _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
1865 {
1866 Efl_Input_Pointer *evt;
1867 Eina_List *l, *copy;
1868 Evas_Object *eo_obj;
1869 int event_id = 0, b;
1870 Evas *eo_e;
1871 Evas_Pointer_Data *pdata;
1872 Eina_Bool cancel;
1873
1874 static const int value_flags =
1875 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
1876 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
1877 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
1878 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID) |
1879 _efl_input_value_mask(EFL_INPUT_VALUE_BUTTON);
1880
1881 if (!e || !ev) return;
1882 EVAS_EVENT_FEED_SAFETY_CHECK(e);
1883
1884 pdata = _evas_pointer_data_by_device_get(e, ev->device);
1885 if (!pdata) return;
1886
1887 b = ev->button;
1888 cancel = ev->action == EFL_POINTER_ACTION_CANCEL;
1889 if (cancel)
1890 DBG("ButtonEvent:cancel time=%u x=%d y=%d button=%d downs=%d",
1891 ev->timestamp, pdata->seat->x, pdata->seat->y, b, pdata->seat->downs);
1892 else
1893 DBG("ButtonEvent:up time=%u x=%d y=%d button=%d downs=%d",
1894 ev->timestamp, pdata->seat->x, pdata->seat->y, b, pdata->seat->downs);
1895 if ((b < 1) || (b > 32)) return;
1896 if (pdata->seat->downs <= 0) return;
1897
1898 if (!cancel)
1899 {
1900 pdata->button &= ~(1u << (b - 1));
1901 pdata->seat->downs--;
1902 }
1903
1904 if (e->is_frozen) return;
1905 e->last_timestamp = ev->timestamp;
1906 eo_e = e->evas;
1907 evt = ev->eo;
1908
1909 if (!cancel)
1910 event_id = _evas_object_event_new();
1911
1912 ev->cur.x = pdata->seat->x;
1913 ev->cur.y = pdata->seat->y;
1914 ev->modifiers = &(e->modifiers);
1915 ev->locks = &(e->locks);
1916 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
1917 ev->touch_id = 0;
1918 ev->value_flags |= value_flags;
1919 if (ev->device) efl_ref(ev->device);
1920
1921 _evas_walk(e);
1922 if (!cancel)
1923 /* update released touch point */
1924 _evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_UP);
1925 copy = evas_event_list_copy(pdata->seat->object.in);
1926 EINA_LIST_FOREACH(copy, l, eo_obj)
1927 {
1928 Evas_Object_Pointer_Mode pointer_mode;
1929 Evas_Object_Pointer_Data *obj_pdata;
1930 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
1931
1932 if (obj->delete_me) continue;
1933 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
1934 if (!obj_pdata)
1935 {
1936 ERR("Could not find the object pointer data for device %p",
1937 ev->device);
1938 continue;
1939 }
1940 if ((!cancel) && ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
1941 (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
1942 (obj_pdata->mouse_grabbed > 0))
1943 {
1944 obj_pdata->mouse_grabbed--;
1945 pdata->seat->mouse_grabbed--;
1946 }
1947 pointer_mode = obj_pdata->pointer_mode;
1948 if ((!e->is_frozen) &&
1949 (!evas_event_freezes_through(eo_obj, obj)))
1950 {
1951 ev->cur.x = pdata->seat->x;
1952 ev->cur.y = pdata->seat->y;
1953 ev->prev.x = pdata->seat->prev.x;
1954 ev->prev.y = pdata->seat->prev.y;
1955
1956 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
1957
1958 if (cancel)
1959 efl_event_callback_call(eo_obj, EFL_EVENT_POINTER_CANCEL, evt);
1960 else
1961 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_UP, evt,
1962 event_id, EFL_EVENT_POINTER_UP);
1963 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
1964 _evas_event_source_mouse_up_events(eo_obj, eo_e, evt, pdata, event_id, cancel);
1965 if (e->delete_me) break;
1966 }
1967 else if (evas_event_freezes_through(eo_obj, obj) &&
1968 (obj->proxy->is_proxy) && (obj->proxy->src_events))
1969 {
1970 Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
1971 Evas_Object_Protected_Data *src = efl_data_scope_get(eo_src, EFL_CANVAS_OBJECT_CLASS);
1972 Evas_Object_Protected_Data *child;
1973 Evas_Object *eo_child;
1974 Eina_List *copy_events;
1975
1976 if (src->delete_me) continue;
1977 copy_events = evas_event_list_copy(src->proxy->src_event_in);
1978 EINA_LIST_FREE(copy_events, eo_child)
1979 {
1980 Evas_Object_Pointer_Data *obj_pdata;
1981
1982 child = efl_data_scope_get(eo_child, EFL_CANVAS_OBJECT_CLASS);
1983 obj_pdata = _evas_object_pointer_data_get(pdata, child);
1984 if (!obj_pdata)
1985 {
1986 ERR("Could not find the object pointer data for device %p",
1987 ev->device);
1988 continue;
1989 }
1990 if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
1991 (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
1992 (obj_pdata->mouse_grabbed > 0))
1993 {
1994 obj_pdata->mouse_grabbed--;
1995 pdata->seat->mouse_grabbed--;
1996 }
1997 }
1998 }
1999 if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
2000 {
2001 if ((!cancel) && (pdata->seat->nogrep > 0)) pdata->seat->nogrep--;
2002 break;
2003 }
2004 }
2005 eina_list_free(copy);
2006 if (!cancel)
2007 {
2008 e->last_mouse_up_counter++;
2009 _evas_post_event_callback_call(eo_e, e, event_id);
2010
2011 if (pdata->seat->mouse_grabbed == 0)
2012 _post_up_handle(e, evt, pdata);
2013
2014 if (pdata->seat->mouse_grabbed < 0)
2015 {
2016 ERR("BUG? pdata->seat->mouse_grabbed (=%d) < 0!",
2017 pdata->seat->mouse_grabbed);
2018 }
2019 }
2020 /* remove released touch point from the touch point list */
2021 _evas_touch_point_remove(eo_e, 0);
2022 _evas_unwalk(e);
2023
2024 if (ev->device) efl_unref(ev->device);
2025 }
2026
2027 static void
_canvas_event_feed_mouse_updown(Eo * eo_e,int b,Evas_Button_Flags flags,unsigned int timestamp,const void * data,Eina_Bool down,Efl_Input_Device * device,Eina_Bool cancel)2028 _canvas_event_feed_mouse_updown(Eo *eo_e, int b, Evas_Button_Flags flags,
2029 unsigned int timestamp, const void *data,
2030 Eina_Bool down, Efl_Input_Device *device, Eina_Bool cancel)
2031 {
2032 Efl_Input_Pointer_Data *ev = NULL;
2033 Efl_Input_Pointer *evt;
2034 Evas_Public_Data *e;
2035
2036 e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2037 if (!e) return;
2038 EVAS_EVENT_FEED_SAFETY_CHECK(e);
2039
2040 evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
2041 if (!ev) return;
2042
2043 ev->data = (void *) data;
2044 ev->timestamp = timestamp;
2045 ev->device = efl_ref(device ? device : _evas_event_legacy_device_get(eo_e, EINA_TRUE));
2046 if (cancel)
2047 ev->action = EFL_POINTER_ACTION_CANCEL;
2048 else
2049 ev->action = down ? EFL_POINTER_ACTION_DOWN : EFL_POINTER_ACTION_UP;
2050 ev->button = b;
2051 ev->button_flags = (Efl_Pointer_Flags)flags;
2052 ev->radius = 1;
2053 ev->radius_x = 1;
2054 ev->radius_y = 1;
2055 ev->pressure = 1;
2056 ev->angle = 0;
2057 //ev->window_pos = ?;
2058 //ev->fake = 1;
2059
2060 /* first, send the cancel action through to trigger POINTER_CANCEL on all
2061 * relevant objects.
2062 * this does not change canvas state in any way.
2063 * note that the 'down' branch can only occur if 'cancel' is not true
2064 */
2065 if (down)
2066 _canvas_event_feed_mouse_down_internal(e, ev);
2067 else
2068 _canvas_event_feed_mouse_up_internal(e, ev);
2069
2070 efl_unref(evt);
2071
2072 /* next, emit actual up event and perform state changes */
2073 if (cancel)
2074 _canvas_event_feed_mouse_updown(eo_e, b, flags, timestamp, data, down, device, EINA_FALSE);
2075 }
2076
2077 static void
_canvas_event_feed_mouse_updown_legacy(Eo * eo_e,int b,Evas_Button_Flags flags,unsigned int timestamp,const void * data,Eina_Bool down)2078 _canvas_event_feed_mouse_updown_legacy(Eo *eo_e, int b, Evas_Button_Flags flags,
2079 unsigned int timestamp, const void *data,
2080 Eina_Bool down)
2081 {
2082 _canvas_event_feed_mouse_updown(eo_e, b, flags, timestamp, data, down, NULL, EINA_FALSE);
2083 }
2084
2085 EAPI void
evas_event_feed_mouse_down(Eo * eo_e,int b,Evas_Button_Flags flags,unsigned int timestamp,const void * data)2086 evas_event_feed_mouse_down(Eo *eo_e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
2087 {
2088 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2089 _canvas_event_feed_mouse_updown_legacy(eo_e, b, flags, timestamp, data, 1);
2090 }
2091
2092 EAPI void
evas_event_feed_mouse_up(Eo * eo_e,int b,Evas_Button_Flags flags,unsigned int timestamp,const void * data)2093 evas_event_feed_mouse_up(Eo *eo_e, int b, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
2094 {
2095 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2096 _canvas_event_feed_mouse_updown_legacy(eo_e, b, flags, timestamp, data, 0);
2097 }
2098
2099 static void
_canvas_event_feed_mouse_cancel_internal(Evas_Public_Data * e,Efl_Input_Pointer_Data * ev)2100 _canvas_event_feed_mouse_cancel_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
2101 {
2102 Evas_Coord_Touch_Point *point;
2103 Efl_Input_Pointer_Data save;
2104 Eina_List *l, *ll;
2105 Evas_Event_Flags flags;
2106 Evas *eo_e;
2107 int i;
2108 Evas_Pointer_Data *pdata;
2109
2110 static const int value_flags =
2111 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
2112 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
2113 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
2114 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
2115
2116 if (!e || !ev) return;
2117 if (e->is_frozen) return;
2118 EVAS_EVENT_FEED_SAFETY_CHECK(e);
2119
2120 pdata = _evas_pointer_data_by_device_get(e, ev->device);
2121 if (!pdata) return;
2122
2123 save = *ev;
2124 eo_e = e->evas;
2125 _evas_walk(e);
2126
2127 flags = evas_event_default_flags_get(eo_e);
2128 evas_event_default_flags_set(eo_e, (flags | EVAS_EVENT_FLAG_ON_HOLD));
2129
2130 for (i = 0; i < 32; i++)
2131 {
2132 if ((pdata->button & (1u << i)))
2133 _canvas_event_feed_mouse_updown(eo_e, i + 1, 0, ev->timestamp, ev->data, 0, ev->device, EINA_TRUE);
2134 }
2135
2136 ev->action = EFL_POINTER_ACTION_CANCEL;
2137 ev->value_flags |= value_flags;
2138 ev->event_flags = (Efl_Input_Flags)flags;
2139 EINA_LIST_FOREACH_SAFE(e->touch_points, l, ll, point)
2140 {
2141 if ((point->state == EVAS_TOUCH_POINT_DOWN) ||
2142 (point->state == EVAS_TOUCH_POINT_MOVE) ||
2143 (point->state == EVAS_TOUCH_POINT_STILL))
2144 {
2145 ev->touch_id = point->id;
2146 ev->cur.x = point->x;
2147 ev->cur.y = point->y;
2148 ev->prev = ev->cur;
2149 _canvas_event_feed_multi_up_internal(e, ev);
2150 }
2151 }
2152 evas_event_default_flags_set(eo_e, flags);
2153 _evas_unwalk(e);
2154
2155 *ev = save;
2156 }
2157
2158 EAPI void
evas_event_feed_mouse_cancel(Eo * eo_e,unsigned int timestamp,const void * data)2159 evas_event_feed_mouse_cancel(Eo *eo_e, unsigned int timestamp, const void *data)
2160 {
2161 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2162 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2163 Efl_Input_Pointer_Data *ev = NULL;
2164 Efl_Input_Pointer *evt;
2165
2166 evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
2167 if (!ev) return;
2168 EVAS_EVENT_FEED_SAFETY_CHECK(e);
2169
2170 ev->timestamp = timestamp;
2171 ev->data = (void *) data;
2172 ev->device = efl_ref(_evas_event_legacy_device_get(e->evas, EINA_TRUE));
2173
2174 _canvas_event_feed_mouse_cancel_internal(e, ev);
2175
2176 efl_unref(evt);
2177 }
2178
2179 static void
_canvas_event_feed_mouse_wheel_internal(Eo * eo_e,Efl_Input_Pointer_Data * pe)2180 _canvas_event_feed_mouse_wheel_internal(Eo *eo_e, Efl_Input_Pointer_Data *pe)
2181 {
2182 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2183 Efl_Input_Pointer_Data *ev = NULL;
2184 Efl_Input_Pointer *evt;
2185 Eina_List *l, *copy;
2186 Evas_Object *eo_obj;
2187 int event_id = 0;
2188 Evas_Pointer_Data *pdata;
2189
2190 static const int value_flags =
2191 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
2192 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
2193 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
2194 _efl_input_value_mask(EFL_INPUT_VALUE_WHEEL_DELTA) |
2195 _efl_input_value_mask(EFL_INPUT_VALUE_WHEEL_HORIZONTAL);
2196
2197 if (e->is_frozen) return;
2198 EVAS_EVENT_FEED_SAFETY_CHECK(e);
2199
2200 pdata = _evas_pointer_data_by_device_get(e, pe->device);
2201 if (!pdata) return;
2202 e->last_timestamp = pe->timestamp;
2203
2204 event_id = _evas_object_event_new();
2205
2206 evt = efl_duplicate(pe->eo);
2207 ev = efl_data_scope_get(evt, EFL_INPUT_POINTER_CLASS);
2208 if (!ev) return;
2209
2210 // adjust missing data based on evas state
2211 ev->cur.x = pdata->seat->x;
2212 ev->cur.y = pdata->seat->y;
2213 ev->modifiers = &(e->modifiers);
2214 ev->locks = &(e->locks);
2215 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
2216 ev->action = EFL_POINTER_ACTION_WHEEL;
2217 ev->value_flags |= value_flags;
2218
2219 _evas_walk(e);
2220 copy = evas_event_list_copy(pdata->seat->object.in);
2221
2222 EINA_LIST_FOREACH(copy, l, eo_obj)
2223 {
2224 Evas_Object_Pointer_Data *obj_pdata;
2225 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2226 if (!evas_event_freezes_through(eo_obj, obj))
2227 {
2228 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2229 if (!obj_pdata)
2230 {
2231 ERR("Could not find the object pointer data for device %p",
2232 ev->device);
2233 continue;
2234 }
2235 ev->cur.x = pdata->seat->x;
2236 ev->cur.y = pdata->seat->y;
2237 ev->prev.x = pdata->seat->prev.x;
2238 ev->prev.y = pdata->seat->prev.y;
2239
2240 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2241
2242 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_WHEEL, evt,
2243 event_id, EFL_EVENT_POINTER_WHEEL);
2244 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2245 _evas_event_source_wheel_events(eo_obj, eo_e, evt, event_id);
2246 if (e->delete_me || e->is_frozen) break;
2247 }
2248 }
2249 eina_list_free(copy);
2250 _evas_post_event_callback_call(eo_e, e, event_id);
2251
2252 efl_unref(evt);
2253 _evas_unwalk(e);
2254 }
2255
2256 EAPI void
evas_event_feed_mouse_wheel(Eo * eo_e,int direction,int z,unsigned int timestamp,const void * data)2257 evas_event_feed_mouse_wheel(Eo *eo_e, int direction, int z, unsigned int timestamp, const void *data)
2258 {
2259 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2260 Efl_Input_Pointer_Data *ev = NULL;
2261 Efl_Input_Pointer *evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
2262
2263 if (!ev) return;
2264
2265 ev->wheel.horizontal = !!direction;
2266 ev->wheel.z = z;
2267 ev->timestamp = timestamp;
2268 ev->data = (void *) data;
2269 ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
2270
2271 _canvas_event_feed_mouse_wheel_internal(eo_e, ev);
2272 efl_unref(evt);
2273 }
2274
2275 static void
_canvas_event_feed_mouse_move_internal(Evas_Public_Data * e,Efl_Input_Pointer_Data * ev)2276 _canvas_event_feed_mouse_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
2277 {
2278 Evas_Object *nogrep_obj = NULL;
2279 Evas_Object_Protected_Data *obj;
2280 Efl_Input_Pointer *evt;
2281 Eina_List *l, *copy;
2282 Evas_Object *eo_obj;
2283 Eina_Vector2 cur_pt, prev_pt;
2284 Evas *eo_e;
2285 int event_id;
2286 Evas_Pointer_Data *pdata;
2287 Evas_Object_Pointer_Data *obj_pdata;
2288
2289 // inform which values are valid
2290 static const int value_flags =
2291 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
2292 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
2293 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
2294 _efl_input_value_mask(EFL_INPUT_VALUE_PREVIOUS_X) |
2295 _efl_input_value_mask(EFL_INPUT_VALUE_PREVIOUS_Y) |
2296 _efl_input_value_mask(EFL_INPUT_VALUE_DX) |
2297 _efl_input_value_mask(EFL_INPUT_VALUE_DY) |
2298 _efl_input_value_mask(EFL_INPUT_VALUE_BUTTONS_PRESSED) |
2299 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
2300
2301 if (!e || !ev) return;
2302 if (e->is_frozen) return;
2303 EVAS_EVENT_FEED_SAFETY_CHECK(e);
2304
2305 if (ev->device)
2306 {
2307 pdata = _evas_pointer_data_by_device_get(e, ev->device);
2308 if (!pdata) return;
2309 }
2310 else
2311 {
2312 Evas_Pointer_Seat *pseat;
2313 if (!e->seats) return;
2314 pseat = EINA_INLIST_CONTAINER_GET(e->seats, Evas_Pointer_Seat);
2315 pseat->inside = 1;
2316 e->last_timestamp = ev->timestamp;
2317 pseat->prev.x = pseat->x;
2318 pseat->prev.y = pseat->y;
2319
2320 // new pos
2321 pseat->x = ev->cur.x;
2322 pseat->y = ev->cur.y;
2323 return;
2324 }
2325
2326 eo_e = e->evas;
2327 e->last_timestamp = ev->timestamp;
2328
2329 ev->prev.x = pdata->seat->x;
2330 ev->prev.y = pdata->seat->y;
2331
2332 // prev pos
2333 prev_pt.x = pdata->seat->prev.x = ev->prev.x;
2334 prev_pt.y = pdata->seat->prev.y = ev->prev.y;
2335
2336 // new pos
2337 cur_pt.x = pdata->seat->x = ev->cur.x;
2338 cur_pt.y = pdata->seat->y = ev->cur.y;
2339
2340 if ((!pdata->seat->inside) && (pdata->seat->mouse_grabbed == 0)) return;
2341
2342 evt = ev->eo;
2343 ev->modifiers = &(e->modifiers);
2344 ev->locks = &(e->locks);
2345 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
2346 ev->pressed_buttons = pdata->button;
2347 ev->touch_id = 0;
2348 ev->value_flags |= value_flags;
2349 if (ev->device) efl_ref(ev->device);
2350
2351 _evas_walk(e);
2352 /* update moved touch point */
2353 if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2354 _evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_MOVE);
2355 /* if our mouse button is grabbed to any objects */
2356 if (pdata->seat->mouse_grabbed > 0)
2357 {
2358 Eina_List *outs = NULL;
2359
2360 /* Send normal mouse move events */
2361 ev->action = EFL_POINTER_ACTION_MOVE;
2362
2363 event_id = _evas_object_event_new();
2364
2365 /* go thru old list of in objects */
2366 copy = evas_event_list_copy(pdata->seat->object.in);
2367 EINA_LIST_FOREACH(copy, l, eo_obj)
2368 {
2369 Eina_Bool check_nogrep = EINA_FALSE;
2370
2371 obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2372 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2373 if (!obj_pdata)
2374 {
2375 ERR("Could not find the object pointer data for device %p",
2376 ev->device);
2377 continue;
2378 }
2379 if ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN) &&
2380 (pdata->seat->nogrep > 0))
2381 check_nogrep = EINA_TRUE;
2382 if ((!e->is_frozen) &&
2383 _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
2384 (!evas_object_is_source_invisible(eo_obj, obj) ||
2385 obj_pdata->mouse_grabbed))
2386 {
2387 ev->cur = cur_pt;
2388 ev->prev = prev_pt;
2389
2390 if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2391 {
2392 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2393
2394 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2395 event_id, EFL_EVENT_POINTER_MOVE);
2396 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2397 _evas_event_source_mouse_move_events(eo_obj, eo_e, evt, pdata, event_id);
2398 }
2399 }
2400 else
2401 outs = eina_list_append(outs, eo_obj);
2402 if (check_nogrep)
2403 {
2404 eina_list_free(copy);
2405 eina_list_free(outs);
2406 nogrep_obj = eo_obj;
2407 goto nogrep;
2408 }
2409 if (e->delete_me) break;
2410 }
2411 eina_list_free(copy);
2412 _evas_post_event_callback_call(eo_e, e, event_id);
2413
2414
2415 /* Send mouse out events */
2416 ev->action = EFL_POINTER_ACTION_OUT;
2417
2418 event_id = _evas_object_event_new();
2419
2420 EINA_LIST_FREE(outs, eo_obj)
2421 {
2422 obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2423 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2424 if (!obj_pdata)
2425 {
2426 ERR("Could not find the object pointer data for device %p",
2427 ev->device);
2428 continue;
2429 }
2430 if ((obj_pdata->mouse_grabbed == 0) && (!e->delete_me))
2431 {
2432 if (!obj_pdata->mouse_in) continue;
2433 _evas_event_mouse_in_set(pdata->seat, obj, 0);
2434 if (obj->delete_me || e->is_frozen) continue;
2435 pdata->seat->object.in = eina_list_remove(pdata->seat->object.in, eo_obj);
2436
2437 ev->cur = cur_pt;
2438 ev->prev = prev_pt;
2439
2440 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2441
2442 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
2443 event_id, EFL_EVENT_POINTER_OUT);
2444 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2445 _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
2446 }
2447 }
2448 _evas_post_event_callback_call(eo_e, e, event_id);
2449 }
2450 else
2451 {
2452 Eina_List *ins;
2453
2454 event_id = _evas_object_event_new();
2455
2456 /* get all new in objects */
2457 ins = evas_event_objects_event_list(eo_e, NULL, cur_pt.x, cur_pt.y);
2458 /* go thru old list of in objects */
2459 copy = evas_event_list_copy(pdata->seat->object.in);
2460 EINA_LIST_FOREACH(copy, l, eo_obj)
2461 {
2462 obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2463 if (!obj) continue;
2464 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2465 if (!obj_pdata)
2466 {
2467 ERR("Could not find the object pointer data for device %p",
2468 ev->device);
2469 continue;
2470 }
2471
2472 /* if its under the pointer and its visible and its in the new */
2473 /* in list */
2474 // FIXME: i don't think we need this
2475 // evas_object_clip_recalc(eo_obj);
2476
2477 ev->cur = cur_pt;
2478 ev->prev = prev_pt;
2479
2480 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2481
2482 if ((!e->is_frozen) &&
2483 (evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1)) &&
2484 _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
2485 _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, ins) &&
2486 (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
2487 {
2488 if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2489 {
2490 ev->action = EFL_POINTER_ACTION_MOVE;
2491 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2492 event_id, EFL_EVENT_POINTER_MOVE);
2493 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2494 _evas_event_source_mouse_move_events(eo_obj, eo_e, evt, pdata, event_id);
2495 }
2496 }
2497 /* otherwise it has left the object */
2498 else if (obj_pdata->mouse_in)
2499 {
2500 _evas_event_mouse_in_set(pdata->seat, obj, 0);
2501 if (e->is_frozen) continue;
2502 ev->action = EFL_POINTER_ACTION_OUT;
2503 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
2504 event_id, EFL_EVENT_POINTER_OUT);
2505 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2506 _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
2507 if (e->delete_me) break;
2508 }
2509 }
2510 eina_list_free(copy);
2511 _evas_post_event_callback_call(eo_e, e, event_id);
2512
2513 /* new event id for mouse in */
2514 event_id = _evas_object_event_new();
2515
2516 /* go thru our current list of ins */
2517 EINA_LIST_FOREACH(ins, l, eo_obj)
2518 {
2519 obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2520 /* if its not in the old list of ins send an enter event */
2521 if (!eina_list_data_find(pdata->seat->object.in, eo_obj))
2522 {
2523 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2524 if (!obj_pdata)
2525 {
2526 ERR("Could not find the object pointer data for device %p",
2527 ev->device);
2528 continue;
2529 }
2530 if (!obj_pdata->mouse_in)
2531 {
2532 _evas_event_mouse_in_set(pdata->seat, obj, 1);
2533 if (e->is_frozen) continue;
2534
2535 ev->cur = cur_pt;
2536 ev->prev = prev_pt;
2537
2538 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2539
2540 ev->action = EFL_POINTER_ACTION_IN;
2541 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
2542 event_id, EFL_EVENT_POINTER_IN);
2543 if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2544 {
2545 ev->action = EFL_POINTER_ACTION_MOVE;
2546 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2547 event_id, EFL_EVENT_POINTER_MOVE);
2548 }
2549 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2550 _evas_event_source_mouse_in_events(eo_obj, eo_e, evt, event_id);
2551
2552 if (e->delete_me) break;
2553 }
2554 }
2555 }
2556 if (pdata->seat->mouse_grabbed == 0)
2557 {
2558 /* free our old list of ins */
2559 eina_list_free(pdata->seat->object.in);
2560 /* and set up the new one */
2561 pdata->seat->object.in = ins;
2562 }
2563 else
2564 {
2565 /* free our cur ins */
2566 eina_list_free(ins);
2567 }
2568 _evas_post_event_callback_call(eo_e, e, event_id);
2569 }
2570
2571 nogrep:
2572 if (nogrep_obj)
2573 {
2574 Eina_List *ins = NULL, *newin = NULL, *lst = NULL;
2575 Evas_Object *eo_below_obj;
2576
2577 event_id = _evas_object_event_new();
2578
2579 /* go thru old list of in objects */
2580 copy = evas_event_list_copy(pdata->seat->object.in);
2581 EINA_LIST_FOREACH(copy, l, eo_obj)
2582 {
2583 if (eo_obj == nogrep_obj)
2584 {
2585 lst = l->next;
2586 break;
2587 }
2588 }
2589
2590 /* get all new in objects */
2591 eo_below_obj = evas_object_below_get(nogrep_obj);
2592 if (eo_below_obj)
2593 {
2594 Evas_Object_Protected_Data *below_obj = efl_data_scope_get(eo_below_obj, EFL_CANVAS_OBJECT_CLASS);
2595 int norep = 0;
2596 ins = _evas_event_object_list_raw_in_get(eo_e, NULL,
2597 EINA_INLIST_GET(below_obj), NULL, NULL,
2598 pdata->seat->x, pdata->seat->y,
2599 &norep, EINA_FALSE, EINA_TRUE);
2600 }
2601
2602 EINA_LIST_FOREACH(copy, l, eo_obj)
2603 {
2604 newin = eina_list_append(newin, eo_obj);
2605 if (eo_obj == nogrep_obj) break;
2606 }
2607
2608 // NOTE: was foreach + append without free (smelled bad)
2609 newin = eina_list_merge(newin, ins);
2610 EINA_LIST_FOREACH(lst, l, eo_obj)
2611 {
2612 obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2613 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2614 if (!obj_pdata)
2615 {
2616 ERR("Could not find the object pointer data for device %p",
2617 ev->device);
2618 continue;
2619 }
2620 /* if its under the pointer and its visible and its in the new */
2621 /* in list */
2622 // FIXME: i don't think we need this
2623 // evas_object_clip_recalc(eo_obj);
2624
2625 ev->cur = cur_pt;
2626 ev->prev = prev_pt;
2627
2628 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2629
2630 if ((!e->is_frozen) &&
2631 evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1) &&
2632 _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
2633 _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, newin) &&
2634 (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
2635 {
2636 if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2637 {
2638 ev->action = EFL_POINTER_ACTION_MOVE;
2639 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2640 event_id, EFL_EVENT_POINTER_MOVE);
2641 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2642 _evas_event_source_mouse_move_events(eo_obj, eo_e, evt, pdata, event_id);
2643 }
2644 }
2645 else
2646 {
2647 /* otherwise it has left the object */
2648 if (!obj_pdata->mouse_in) continue;
2649 _evas_event_mouse_in_set(pdata->seat, obj, 0);
2650 if (e->is_frozen) continue;
2651 ev->action = EFL_POINTER_ACTION_OUT;
2652 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
2653 event_id, EFL_EVENT_POINTER_OUT);
2654 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2655 _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
2656 }
2657 if (e->delete_me) break;
2658 }
2659 eina_list_free(copy);
2660 _evas_post_event_callback_call(eo_e, e, event_id);
2661
2662 event_id = _evas_object_event_new();
2663
2664 /* go thru our current list of ins */
2665 EINA_LIST_FOREACH(newin, l, eo_obj)
2666 {
2667 obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2668 /* if its not in the old list of ins send an enter event */
2669 if (!eina_list_data_find(pdata->seat->object.in, eo_obj))
2670 {
2671 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2672 if (!obj_pdata)
2673 {
2674 ERR("Could not find the object pointer data for device %p",
2675 ev->device);
2676 continue;
2677 }
2678 if (obj_pdata->mouse_in) continue;
2679 _evas_event_mouse_in_set(pdata->seat, obj, 1);
2680 if (e->is_frozen) continue;
2681
2682 ev->cur = cur_pt;
2683 ev->prev = prev_pt;
2684
2685 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2686
2687 ev->action = EFL_POINTER_ACTION_IN;
2688 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
2689 event_id, EFL_EVENT_POINTER_IN);
2690 if (!EINA_DBL_EQ(cur_pt.x, prev_pt.x) || !EINA_DBL_EQ(cur_pt.y, prev_pt.y))
2691 {
2692 ev->action = EFL_POINTER_ACTION_MOVE;
2693 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2694 event_id, EFL_EVENT_POINTER_MOVE);
2695 }
2696 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2697 _evas_event_source_mouse_in_events(eo_obj, eo_e, evt, event_id);
2698 if (e->delete_me) break;
2699 }
2700 }
2701 /* free our old list of ins */
2702 eina_list_free(pdata->seat->object.in);
2703 /* and set up the new one */
2704 pdata->seat->object.in = newin;
2705
2706 _evas_post_event_callback_call(eo_e, e, event_id);
2707 }
2708
2709 _evas_unwalk(e);
2710 if (ev->device) efl_unref(ev->device);
2711 }
2712
2713 static void
_canvas_event_feed_mouse_move_legacy(Evas * eo_e,Evas_Public_Data * e,int x,int y,unsigned int timestamp,const void * data)2714 _canvas_event_feed_mouse_move_legacy(Evas *eo_e, Evas_Public_Data *e, int x, int y,
2715 unsigned int timestamp, const void *data)
2716 {
2717 Efl_Input_Pointer_Data *ev = NULL;
2718 Efl_Input_Pointer *evt;
2719
2720 evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
2721 if (!ev) return;
2722
2723 ev->data = (void *) data;
2724 ev->timestamp = timestamp;
2725 ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
2726 ev->cur.x = x;
2727 ev->cur.y = y;
2728
2729 _canvas_event_feed_mouse_move_internal(e, ev);
2730
2731 efl_unref(evt);
2732 }
2733
2734 EAPI void
evas_event_input_mouse_move(Eo * eo_e,int x,int y,unsigned int timestamp,const void * data)2735 evas_event_input_mouse_move(Eo *eo_e, int x, int y, unsigned int timestamp, const void *data)
2736 {
2737 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2738 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2739 _canvas_event_feed_mouse_move_legacy(eo_e, e, x - e->framespace.x, y - e->framespace.y, timestamp, data);
2740 }
2741
2742 EAPI void
evas_event_feed_mouse_move(Eo * eo_e,int x,int y,unsigned int timestamp,const void * data)2743 evas_event_feed_mouse_move(Eo *eo_e, int x, int y, unsigned int timestamp, const void *data)
2744 {
2745 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2746 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2747 _canvas_event_feed_mouse_move_legacy(eo_e, e, x, y, timestamp, data);
2748 }
2749
2750 static void
_canvas_event_feed_mouse_in_internal(Evas * eo_e,Efl_Input_Pointer_Data * ev)2751 _canvas_event_feed_mouse_in_internal(Evas *eo_e, Efl_Input_Pointer_Data *ev)
2752 {
2753 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2754 Efl_Input_Pointer *evt;
2755 Eina_List *ins;
2756 Eina_List *l;
2757 Evas_Object *eo_obj;
2758 int event_id;
2759 Evas_Pointer_Data *pdata;
2760
2761 static const int value_flags =
2762 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
2763 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
2764 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
2765 _efl_input_value_mask(EFL_INPUT_VALUE_BUTTONS_PRESSED) |
2766 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
2767
2768 if (!e || !ev) return;
2769 EVAS_EVENT_FEED_SAFETY_CHECK(e);
2770
2771 if (ev->device)
2772 {
2773 pdata = _evas_pointer_data_by_device_get(e, ev->device);
2774 if (!pdata) return;
2775 }
2776 else
2777 {
2778 Evas_Pointer_Seat *pseat;
2779 if (!e->seats) return;
2780 pseat = EINA_INLIST_CONTAINER_GET(e->seats, Evas_Pointer_Seat);
2781 pseat->inside = 1;
2782 return;
2783 }
2784
2785 pdata->seat->inside = 1;
2786 if (e->is_frozen) return;
2787
2788 e->last_timestamp = ev->timestamp;
2789 if (pdata->seat->mouse_grabbed != 0) return;
2790
2791 evt = ev->eo;
2792 ev->action = EFL_POINTER_ACTION_IN;
2793 ev->pressed_buttons = pdata->button;
2794 ev->cur.x = pdata->seat->x;
2795 ev->cur.y = pdata->seat->y;
2796 ev->modifiers = &(e->modifiers);
2797 ev->locks = &(e->locks);
2798 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
2799 ev->value_flags |= value_flags;
2800 if (ev->device) efl_ref(ev->device);
2801
2802 event_id = _evas_object_event_new();
2803
2804 _evas_walk(e);
2805 /* get new list of ins */
2806 ins = evas_event_objects_event_list(eo_e, NULL, pdata->seat->x, pdata->seat->y);
2807 EINA_LIST_FOREACH(ins, l, eo_obj)
2808 {
2809 Evas_Object_Pointer_Data *obj_pdata;
2810 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2811 if ((!obj) || (obj->delete_me)) continue;
2812 if (!eina_list_data_find(pdata->seat->object.in, eo_obj))
2813 {
2814 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2815 if (!obj_pdata)
2816 {
2817 ERR("Could not find the object pointer data for device %p",
2818 ev->device);
2819 continue;
2820 }
2821 if (obj_pdata->mouse_in) continue;
2822 _evas_event_mouse_in_set(pdata->seat, obj, 1);
2823
2824 ev->cur.x = pdata->seat->x;
2825 ev->cur.y = pdata->seat->y;
2826 ev->prev.x = pdata->seat->prev.x;
2827 ev->prev.y = pdata->seat->prev.y;
2828 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2829
2830 ev->action = EFL_POINTER_ACTION_IN;
2831 efl_ref(eo_obj);
2832 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_IN, evt,
2833 event_id, EFL_EVENT_POINTER_IN);
2834 if (!EINA_DBL_EQ(pdata->seat->x, ev->prev.x) &&
2835 !EINA_DBL_EQ(pdata->seat->y, ev->prev.y))
2836 {
2837 ev->action = EFL_POINTER_ACTION_MOVE;
2838 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_MOVE, evt,
2839 event_id, EFL_EVENT_POINTER_MOVE);
2840 }
2841 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2842 _evas_event_source_mouse_in_events(eo_obj, eo_e, evt, event_id);
2843 efl_unref(eo_obj);
2844 if (e->delete_me || e->is_frozen) break;
2845 }
2846 }
2847 /* free our old list of ins */
2848 eina_list_free(pdata->seat->object.in);
2849 /* and set up the new one */
2850 pdata->seat->object.in = ins;
2851 _evas_post_event_callback_call(eo_e, e, event_id);
2852 _canvas_event_feed_mouse_move_internal(e, ev);
2853 _evas_unwalk(e);
2854
2855 if (ev->device) efl_unref(ev->device);
2856 }
2857
2858 static void
_canvas_event_feed_mouse_out_internal(Evas * eo_e,Efl_Input_Pointer_Data * ev)2859 _canvas_event_feed_mouse_out_internal(Evas *eo_e, Efl_Input_Pointer_Data *ev)
2860 {
2861 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
2862 Efl_Input_Pointer *evt;
2863 Eina_List *l, *copy;
2864 Evas_Object *eo_obj;
2865 int event_id;
2866 Evas_Pointer_Data *pdata;
2867
2868 static const int value_flags =
2869 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
2870 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
2871 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
2872 _efl_input_value_mask(EFL_INPUT_VALUE_BUTTONS_PRESSED) |
2873 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
2874
2875 if (!e || !ev) return;
2876 EVAS_EVENT_FEED_SAFETY_CHECK(e);
2877 if (ev->device)
2878 {
2879 pdata = _evas_pointer_data_by_device_get(e, ev->device);
2880 if (!pdata) return;
2881 }
2882 else
2883 {
2884 Evas_Pointer_Seat *pseat;
2885 if (!e->seats) return;
2886 pseat = EINA_INLIST_CONTAINER_GET(e->seats, Evas_Pointer_Seat);
2887 pseat->inside = 0;
2888 return;
2889 }
2890 pdata->seat->inside = 0;
2891
2892 if (e->is_frozen) return;
2893 e->last_timestamp = ev->timestamp;
2894
2895 event_id = _evas_object_event_new();
2896
2897 evt = ev->eo;
2898 ev->action = EFL_POINTER_ACTION_OUT;
2899 ev->pressed_buttons = pdata->button;
2900 ev->cur.x = pdata->seat->x;
2901 ev->cur.y = pdata->seat->y;
2902 ev->modifiers = &(e->modifiers);
2903 ev->locks = &(e->locks);
2904 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
2905 ev->value_flags |= value_flags;
2906 if (ev->device) efl_ref(ev->device);
2907
2908 _evas_walk(e);
2909 /* if our mouse button is inside any objects */
2910 /* go thru old list of in objects */
2911 copy = evas_event_list_copy(pdata->seat->object.in);
2912 EINA_LIST_FOREACH(copy, l, eo_obj)
2913 {
2914 Evas_Object_Pointer_Data *obj_pdata;
2915 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
2916 if ((!obj) || (obj->delete_me)) continue;
2917 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
2918 if (!obj_pdata)
2919 {
2920 ERR("Could not find the object pointer data for device %p",
2921 ev->device);
2922 continue;
2923 }
2924 if (!obj_pdata->mouse_in) continue;
2925 _evas_event_mouse_in_set(pdata->seat, obj, 0);
2926 efl_ref(eo_obj);
2927
2928 ev->cur.x = pdata->seat->x;
2929 ev->cur.y = pdata->seat->y;
2930 ev->prev.x = pdata->seat->prev.x;
2931 ev->prev.y = pdata->seat->prev.y;
2932 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
2933
2934 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_OUT, evt,
2935 event_id, EFL_EVENT_POINTER_OUT);
2936 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
2937 _evas_event_source_mouse_out_events(eo_obj, eo_e, evt, event_id);
2938 efl_unref(eo_obj);
2939 if (e->delete_me || e->is_frozen) break;
2940 obj_pdata->mouse_grabbed = 0;
2941 }
2942 eina_list_free(copy);
2943
2944 /* free our old list of ins */
2945 pdata->seat->object.in = eina_list_free(pdata->seat->object.in);
2946 pdata->seat->mouse_grabbed = 0;
2947 _evas_post_event_callback_call(eo_e, e, event_id);
2948 _evas_unwalk(e);
2949
2950 if (ev->device) efl_unref(ev->device);
2951 }
2952
2953 static void
_canvas_event_feed_mouse_inout_legacy(Eo * eo_e,unsigned int timestamp,const void * data,Eina_Bool in)2954 _canvas_event_feed_mouse_inout_legacy(Eo *eo_e, unsigned int timestamp,
2955 const void *data, Eina_Bool in)
2956 {
2957 Efl_Input_Pointer_Data *ev = NULL;
2958 Efl_Input_Pointer *evt;
2959
2960 evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
2961 if (!ev) return;
2962
2963 ev->timestamp = timestamp;
2964 ev->data = (void *) data;
2965 ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
2966
2967 if (in)
2968 _canvas_event_feed_mouse_in_internal(eo_e, ev);
2969 else
2970 _canvas_event_feed_mouse_out_internal(eo_e, ev);
2971
2972 efl_unref(evt);
2973 }
2974
2975 EAPI void
evas_event_feed_mouse_in(Eo * eo_e,unsigned int timestamp,const void * data)2976 evas_event_feed_mouse_in(Eo *eo_e, unsigned int timestamp, const void *data)
2977 {
2978 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2979 _canvas_event_feed_mouse_inout_legacy(eo_e, timestamp, data, EINA_TRUE);
2980 }
2981
2982 EAPI void
evas_event_feed_mouse_out(Eo * eo_e,unsigned int timestamp,const void * data)2983 evas_event_feed_mouse_out(Eo *eo_e, unsigned int timestamp, const void *data)
2984 {
2985 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
2986 _canvas_event_feed_mouse_inout_legacy(eo_e, timestamp, data, EINA_FALSE);
2987 }
2988
2989 static void
_canvas_event_feed_multi_down_internal(Evas_Public_Data * e,Efl_Input_Pointer_Data * ev)2990 _canvas_event_feed_multi_down_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
2991 {
2992 Efl_Input_Pointer *evt;
2993 Eina_List *l, *copy;
2994 Evas_Object *eo_obj;
2995 Eina_Vector2 point;
2996 Evas *eo_e;
2997 int event_id;
2998 int addgrab = 0;
2999 Evas_Pointer_Data *pdata;
3000 Evas_Object_Pointer_Data *obj_pdata;
3001
3002 static const int value_flags =
3003 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
3004 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
3005 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
3006 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID) |
3007 _efl_input_value_mask(EFL_INPUT_VALUE_BUTTON);
3008
3009 if (!e || !ev) return;
3010 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3011
3012 pdata = _evas_pointer_data_by_device_get(e, ev->device);
3013 if (!pdata) return;
3014 eo_e = e->evas;
3015 DBG("ButtonEvent:multi down time=%u x=%.1f y=%.1f button=%d downs=%d",
3016 ev->timestamp, ev->cur.x, ev->cur.y, ev->touch_id, pdata->seat->downs);
3017 pdata->seat->downs++;
3018 if (e->is_frozen) return;
3019 e->last_timestamp = ev->timestamp;
3020
3021 event_id = _evas_object_event_new();
3022
3023 point = ev->cur;
3024 evt = ev->eo;
3025 ev->action = EFL_POINTER_ACTION_DOWN;
3026 ev->modifiers = &(e->modifiers);
3027 ev->locks = &(e->locks);
3028 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3029 ev->value_flags |= value_flags;
3030 if (ev->device) efl_ref(ev->device);
3031
3032 _evas_walk(e);
3033 /* append new touch point to the touch point list */
3034 _evas_touch_point_append(eo_e, ev->touch_id, ev->cur.x, ev->cur.y);
3035 if (pdata->seat->mouse_grabbed == 0)
3036 {
3037 if (pdata->seat->downs > 1)
3038 addgrab = pdata->seat->downs - 1;
3039 else /* this is the first touch, which means it's also a move event, which means we need to redo this */
3040 {
3041 /* get all new in objects */
3042 Eina_List *ins = evas_event_objects_event_list(eo_e, NULL, ev->cur.x, ev->cur.y);
3043 /* free our old list of ins */
3044 eina_list_free(pdata->seat->object.in);
3045 /* and set up the new one */
3046 pdata->seat->object.in = ins;
3047 }
3048 }
3049 copy = evas_event_list_copy(pdata->seat->object.in);
3050 EINA_LIST_FOREACH(copy, l, eo_obj)
3051 {
3052 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3053 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3054 if (!obj_pdata)
3055 {
3056 ERR("Could not find the object pointer data for device %p",
3057 ev->device);
3058 continue;
3059 }
3060 if (obj_pdata->pointer_mode != EVAS_OBJECT_POINTER_MODE_NOGRAB)
3061 {
3062 obj_pdata->mouse_grabbed += addgrab + 1;
3063 pdata->seat->mouse_grabbed += addgrab + 1;
3064 }
3065 }
3066 EINA_LIST_FOREACH(copy, l, eo_obj)
3067 {
3068 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3069 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3070 if (!obj_pdata)
3071 {
3072 ERR("Could not find the object pointer data for device %p",
3073 ev->device);
3074 continue;
3075 }
3076 ev->cur = point;
3077 ev->prev.x = pdata->seat->prev.x;
3078 ev->prev.y = pdata->seat->prev.y;
3079 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3080
3081 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_DOWN, evt,
3082 event_id, EFL_EVENT_FINGER_DOWN);
3083 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3084 _evas_event_source_multi_down_events(obj, e, evt, pdata, event_id);
3085 if (e->delete_me || e->is_frozen) break;
3086 }
3087 eina_list_free(copy);
3088
3089 _evas_post_event_callback_call(eo_e, e, event_id);
3090 /* update touch point's state to EVAS_TOUCH_POINT_STILL */
3091 _evas_touch_point_update(eo_e, ev->touch_id, ev->cur.x, ev->cur.y, EVAS_TOUCH_POINT_STILL);
3092 _evas_unwalk(e);
3093
3094 if (ev->device) efl_unref(ev->device);
3095 }
3096
3097 static void
_canvas_event_feed_multi_up_internal(Evas_Public_Data * e,Efl_Input_Pointer_Data * ev)3098 _canvas_event_feed_multi_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
3099 {
3100 Efl_Input_Pointer *evt;
3101 Eina_List *l, *copy;
3102 Evas_Object *eo_obj;
3103 Eina_Vector2 point;
3104 Evas *eo_e;
3105 int event_id;
3106 Evas_Pointer_Data *pdata;
3107
3108 static const int value_flags =
3109 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
3110 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
3111 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
3112 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
3113
3114 if (!e || !ev) return;
3115 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3116
3117 pdata = _evas_pointer_data_by_device_get(e, ev->device);
3118 if (!pdata) return;
3119 eo_e = e->evas;
3120 DBG("ButtonEvent:multi up time=%u x=%.1f y=%.1f device=%d downs=%d",
3121 ev->timestamp, ev->cur.x, ev->cur.y, ev->touch_id, pdata->seat->downs);
3122 if (pdata->seat->downs <= 0) return;
3123 pdata->seat->downs--;
3124 if (e->is_frozen) return;
3125 e->last_timestamp = ev->timestamp;
3126
3127 event_id = _evas_object_event_new();
3128
3129 point = ev->cur;
3130 evt = ev->eo;
3131 ev->action = EFL_POINTER_ACTION_UP;
3132 ev->modifiers = &(e->modifiers);
3133 ev->locks = &(e->locks);
3134 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3135 ev->value_flags |= value_flags;
3136 if (ev->device) efl_ref(ev->device);
3137
3138 _evas_walk(e);
3139 /* update released touch point */
3140 _evas_touch_point_update(eo_e, ev->touch_id, ev->cur.x, ev->cur.y, EVAS_TOUCH_POINT_UP);
3141 copy = evas_event_list_copy(pdata->seat->object.in);
3142 EINA_LIST_FOREACH(copy, l, eo_obj)
3143 {
3144 Evas_Object_Pointer_Data *obj_pdata;
3145 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3146 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3147 if (!obj_pdata)
3148 {
3149 ERR("Could not find the object pointer data for device %p",
3150 ev->device);
3151 continue;
3152 }
3153 ev->cur = point;
3154 ev->prev.x = pdata->seat->prev.x;
3155 ev->prev.y = pdata->seat->prev.y;
3156
3157 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3158 if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
3159 (obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
3160 (obj_pdata->mouse_grabbed > 0))
3161 {
3162 obj_pdata->mouse_grabbed--;
3163 pdata->seat->mouse_grabbed--;
3164 }
3165 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_UP, evt,
3166 event_id, EFL_EVENT_FINGER_UP);
3167 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3168 _evas_event_source_multi_up_events(obj, e, evt, pdata, event_id);
3169 if (e->delete_me || e->is_frozen) break;
3170 }
3171 eina_list_free(copy);
3172 if (pdata->seat->mouse_grabbed == 0)
3173 {
3174 _post_up_handle(e, evt, pdata);
3175 _evas_post_event_callback_call(eo_e, e, event_id);
3176 }
3177
3178 /* remove released touch point from the touch point list */
3179 _evas_touch_point_remove(eo_e, ev->touch_id);
3180 _evas_unwalk(e);
3181
3182 if (ev->device) efl_unref(ev->device);
3183 }
3184
3185 static inline void
_canvas_event_feed_multi_internal(Evas * eo_e,Evas_Public_Data * e,int d,int x,int y,double rad,double radx,double rady,double pres,double ang,double fx,double fy,Evas_Button_Flags flags,unsigned int timestamp,const void * data,Efl_Pointer_Action action)3186 _canvas_event_feed_multi_internal(Evas *eo_e, Evas_Public_Data *e,
3187 int d, int x, int y,
3188 double rad, double radx, double rady,
3189 double pres, double ang,
3190 double fx, double fy,
3191 Evas_Button_Flags flags,
3192 unsigned int timestamp,
3193 const void *data, Efl_Pointer_Action action)
3194 {
3195 Efl_Input_Pointer_Data *ev = NULL;
3196 Efl_Input_Pointer *evt;
3197
3198 evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
3199 if (!e || !ev) return;
3200 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3201
3202 if (EINA_DBL_EQ(fx, 0.0)) fx = x;
3203 if (EINA_DBL_EQ(fy, 0.0)) fy = y;
3204
3205 ev->action = action;
3206 ev->touch_id = d;
3207 ev->cur.x = fx;
3208 ev->cur.y = fy;
3209 ev->pressure = pres;
3210 ev->angle = ang;
3211 ev->radius = rad;
3212 ev->radius_x = radx;
3213 ev->radius_y = rady;
3214 ev->button_flags = (Efl_Pointer_Flags)flags;
3215 ev->timestamp = timestamp;
3216 ev->data = (void *) data;
3217 ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
3218
3219 switch (action)
3220 {
3221 case EFL_POINTER_ACTION_DOWN:
3222 _canvas_event_feed_multi_down_internal(e, ev);
3223 break;
3224
3225 case EFL_POINTER_ACTION_UP:
3226 _canvas_event_feed_multi_up_internal(e, ev);
3227 break;
3228
3229 case EFL_POINTER_ACTION_MOVE:
3230 _canvas_event_feed_multi_move_internal(e, ev);
3231 break;
3232
3233 default: break;
3234 }
3235
3236 efl_unref(evt);
3237 }
3238
3239 EAPI void
evas_event_input_multi_down(Eo * eo_e,int d,int x,int y,double rad,double radx,double rady,double pres,double ang,double fx,double fy,Evas_Button_Flags flags,unsigned int timestamp,const void * data)3240 evas_event_input_multi_down(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
3241 {
3242 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3243 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3244 _canvas_event_feed_multi_internal(eo_e, e, d,
3245 x - e->framespace.x, y - e->framespace.y,
3246 rad, radx, rady, pres, ang,
3247 fx, fy, flags, timestamp, data, EFL_POINTER_ACTION_DOWN);
3248 }
3249
3250 EAPI void
evas_event_feed_multi_down(Eo * eo_e,int d,int x,int y,double rad,double radx,double rady,double pres,double ang,double fx,double fy,Evas_Button_Flags flags,unsigned int timestamp,const void * data)3251 evas_event_feed_multi_down(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
3252 {
3253 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3254 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3255 _canvas_event_feed_multi_internal(eo_e, e, d, x, y, rad, radx, rady, pres, ang,
3256 fx, fy, flags, timestamp, data, EFL_POINTER_ACTION_DOWN);
3257 }
3258
3259 EAPI void
evas_event_input_multi_up(Eo * eo_e,int d,int x,int y,double rad,double radx,double rady,double pres,double ang,double fx,double fy,Evas_Button_Flags flags,unsigned int timestamp,const void * data)3260 evas_event_input_multi_up(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
3261 {
3262 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3263 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3264 _canvas_event_feed_multi_internal(eo_e, e, d,
3265 x - e->framespace.x, y - e->framespace.y,
3266 rad, radx, rady, pres, ang,
3267 fx, fy, flags, timestamp, data, EFL_POINTER_ACTION_UP);
3268 }
3269
3270 EAPI void
evas_event_feed_multi_up(Eo * eo_e,int d,int x,int y,double rad,double radx,double rady,double pres,double ang,double fx,double fy,Evas_Button_Flags flags,unsigned int timestamp,const void * data)3271 evas_event_feed_multi_up(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, Evas_Button_Flags flags, unsigned int timestamp, const void *data)
3272 {
3273 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3274 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3275 _canvas_event_feed_multi_internal(eo_e, e, d, x, y, rad, radx, rady, pres, ang,
3276 fx, fy, flags, timestamp, data, EFL_POINTER_ACTION_UP);
3277 }
3278
3279 static void
_canvas_event_feed_multi_move_internal(Evas_Public_Data * e,Efl_Input_Pointer_Data * ev)3280 _canvas_event_feed_multi_move_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
3281 {
3282 Efl_Input_Pointer *evt;
3283 Eina_List *l, *copy;
3284 Evas_Object *eo_obj;
3285 Eina_Vector2 cur_pt, prev_pt;
3286 Evas *eo_e;
3287 int event_id;
3288 Evas_Pointer_Data *pdata;
3289 Evas_Object_Pointer_Data *obj_pdata;
3290
3291 /* FIXME: Add previous x,y information (from evas touch point list) */
3292 static const int value_flags =
3293 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
3294 _efl_input_value_mask(EFL_INPUT_VALUE_X) |
3295 _efl_input_value_mask(EFL_INPUT_VALUE_Y) |
3296 _efl_input_value_mask(EFL_INPUT_VALUE_TOUCH_ID);
3297
3298 if (!e || !ev) return;
3299 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3300
3301 pdata = _evas_pointer_data_by_device_get(e, ev->device);
3302 if (!pdata) return;
3303 eo_e = e->evas;
3304 event_id = _evas_object_event_new();
3305
3306 if (e->is_frozen) return;
3307 e->last_timestamp = ev->timestamp;
3308
3309 if ((!pdata->seat->inside) && (pdata->seat->mouse_grabbed == 0)) return;
3310
3311 evt = ev->eo;
3312 ev->modifiers = &(e->modifiers);
3313 ev->locks = &(e->locks);
3314 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3315 ev->action = EFL_POINTER_ACTION_MOVE;
3316 ev->value_flags |= value_flags;
3317 if (ev->device) efl_ref(ev->device);
3318
3319 cur_pt = ev->cur;
3320 prev_pt = ev->prev;
3321
3322 _evas_walk(e);
3323 /* update moved touch point */
3324 _evas_touch_point_update(eo_e, ev->touch_id, ev->cur.x, ev->cur.y, EVAS_TOUCH_POINT_MOVE);
3325 /* if our mouse button is grabbed to any objects */
3326 if (pdata->seat->mouse_grabbed > 0)
3327 {
3328 /* go thru old list of in objects */
3329 copy = evas_event_list_copy(pdata->seat->object.in);
3330 EINA_LIST_FOREACH(copy, l, eo_obj)
3331 {
3332 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3333 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3334 if (!obj_pdata)
3335 {
3336 ERR("Could not find the object pointer data for device %p",
3337 ev->device);
3338 continue;
3339 }
3340 if (_evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
3341 (!evas_object_is_source_invisible(eo_obj, obj) ||
3342 obj_pdata->mouse_grabbed))
3343 {
3344 ev->cur = cur_pt;
3345 ev->prev = prev_pt;
3346 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3347 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
3348 event_id, EFL_EVENT_FINGER_MOVE);
3349 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3350 _evas_event_source_multi_move_events(obj, e, evt, pdata, event_id);
3351
3352 if (e->delete_me || e->is_frozen) break;
3353 }
3354 }
3355 eina_list_free(copy);
3356 _evas_post_event_callback_call(eo_e, e, event_id);
3357 }
3358 else
3359 {
3360 Eina_List *ins;
3361
3362 /* get all new in objects */
3363 ins = evas_event_objects_event_list(eo_e, NULL, ev->cur.x, ev->cur.y);
3364 /* go thru old list of in objects */
3365 copy = evas_event_list_copy(pdata->seat->object.in);
3366 EINA_LIST_FOREACH(copy, l, eo_obj)
3367 {
3368 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3369 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
3370 if (!obj_pdata)
3371 {
3372 ERR("Could not find the object pointer data for device %p",
3373 ev->device);
3374 continue;
3375 }
3376 /* if its under the pointer and its visible and its in the new */
3377 /* in list */
3378 // FIXME: i don't think we need this
3379 // evas_object_clip_recalc(eo_obj);
3380
3381 ev->cur = cur_pt;
3382 ev->prev = prev_pt;
3383
3384 _evas_event_havemap_adjust_f(obj, &ev->cur, &ev->prev, obj_pdata->mouse_grabbed);
3385
3386 if (evas_object_is_in_output_rect(eo_obj, obj, ev->cur.x, ev->cur.y, 1, 1) &&
3387 _evas_event_object_pointer_allow(eo_obj, obj, obj_pdata) &&
3388 _evas_event_object_pointer_allow_precise(eo_obj, obj, ev->cur.x, ev->cur.y, ins) &&
3389 (obj_pdata->mouse_grabbed || !evas_object_is_source_invisible(eo_obj, obj)))
3390 {
3391 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MULTI_MOVE, evt,
3392 event_id, EFL_EVENT_FINGER_MOVE);
3393 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3394 _evas_event_source_multi_move_events(obj, e, evt, pdata, event_id);
3395 }
3396 if (e->delete_me || e->is_frozen) break;
3397 }
3398 eina_list_free(copy);
3399 if (pdata->seat->mouse_grabbed == 0)
3400 {
3401 /* free our old list of ins */
3402 eina_list_free(pdata->seat->object.in);
3403 /* and set up the new one */
3404 pdata->seat->object.in = ins;
3405 }
3406 else
3407 {
3408 /* free our cur ins */
3409 eina_list_free(ins);
3410 }
3411 _evas_post_event_callback_call(eo_e, e, event_id);
3412 }
3413 _evas_unwalk(e);
3414
3415 if (ev->device) efl_unref(ev->device);
3416 }
3417
3418 EAPI void
evas_event_input_multi_move(Eo * eo_e,int d,int x,int y,double rad,double radx,double rady,double pres,double ang,double fx,double fy,unsigned int timestamp,const void * data)3419 evas_event_input_multi_move(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, unsigned int timestamp, const void *data)
3420 {
3421 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3422 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3423 _canvas_event_feed_multi_internal(eo_e, e, d, x - e->framespace.x, y - e->framespace.y,
3424 rad, radx, rady,
3425 pres, ang, fx, fy, EVAS_BUTTON_NONE, timestamp, data,
3426 EFL_POINTER_ACTION_MOVE);
3427 }
3428
3429 EAPI void
evas_event_feed_multi_move(Eo * eo_e,int d,int x,int y,double rad,double radx,double rady,double pres,double ang,double fx,double fy,unsigned int timestamp,const void * data)3430 evas_event_feed_multi_move(Eo *eo_e, int d, int x, int y, double rad, double radx, double rady, double pres, double ang, double fx, double fy, unsigned int timestamp, const void *data)
3431 {
3432 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3433 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3434 _canvas_event_feed_multi_internal(eo_e, e, d, x, y, rad, radx, rady,
3435 pres, ang, fx, fy, EVAS_BUTTON_NONE, timestamp, data,
3436 EFL_POINTER_ACTION_MOVE);
3437 }
3438
3439 static void
_key_event_dispatch(Evas_Public_Data * e,void * event_info,Efl_Input_Device * device,const Efl_Event_Description * efl_event_desc,Evas_Callback_Type evas_event_type,int event_id)3440 _key_event_dispatch(Evas_Public_Data *e, void *event_info,
3441 Efl_Input_Device *device,
3442 const Efl_Event_Description *efl_event_desc,
3443 Evas_Callback_Type evas_event_type, int event_id)
3444 {
3445 Eo *focused;
3446
3447 if (!device)
3448 device = e->default_seat;
3449 else
3450 {
3451 const char *name = efl_name_get(device);
3452
3453 device = efl_input_device_seat_get(device);
3454 if (!device)
3455 {
3456 ERR("Could not find the parent seat from device name '%s'. Using default seat instead", name);
3457 device = e->default_seat;
3458 }
3459 }
3460
3461 focused = eina_hash_find(e->focused_objects, &device);
3462
3463 if (!focused)
3464 return;
3465
3466 Evas_Object_Protected_Data *focused_obj =
3467 efl_data_scope_get(focused, EFL_CANVAS_OBJECT_CLASS);
3468
3469 if (!focused_obj)
3470 {
3471 WRN("No element focused");
3472 return;
3473 }
3474
3475 if (!e->is_frozen && !evas_event_freezes_through(focused, focused_obj))
3476 {
3477 evas_object_event_callback_call(focused, focused_obj,
3478 evas_event_type, event_info,
3479 event_id, efl_event_desc);
3480 }
3481 }
3482
3483 static void
_canvas_event_feed_key_down_internal(Evas_Public_Data * e,Efl_Input_Key_Data * ev)3484 _canvas_event_feed_key_down_internal(Evas_Public_Data *e, Efl_Input_Key_Data *ev)
3485 {
3486 Eina_Bool exclusive = EINA_FALSE;
3487 Efl_Input_Pointer *evt;
3488 int event_id = 0;
3489 Eo *eo_e;
3490
3491 if (!e || !ev) return;
3492 if (e->is_frozen) return;
3493 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3494
3495 eo_e = e->evas;
3496 e->last_timestamp = ev->timestamp;
3497 _evas_walk(e);
3498
3499 event_id = _evas_object_event_new();
3500
3501 evt = ev->eo;
3502 ev->modifiers = &(e->modifiers);
3503 ev->locks = &(e->locks);
3504 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3505 if (ev->device) efl_ref(ev->device);
3506
3507 if (e->grabs)
3508 {
3509 Eina_List *l;
3510 Evas_Key_Grab *g;
3511 Evas_Modifier_Mask *seat_mask, modifier_mask;
3512 Efl_Input_Device *seat = NULL;
3513
3514 e->walking_grabs++;
3515 if (ev->device)
3516 seat = efl_input_device_seat_get(ev->device);
3517 seat_mask = eina_hash_find(e->modifiers.masks, &seat);
3518 modifier_mask = seat_mask ? *seat_mask : 0;
3519 EINA_LIST_FOREACH(e->grabs, l, g)
3520 {
3521 if (g->just_added)
3522 {
3523 g->just_added = EINA_FALSE;
3524 continue;
3525 }
3526 if (g->delete_me) continue;
3527 if (!g->object) continue;
3528 if (!g->is_active) continue;
3529 if (((modifier_mask & g->modifiers) ||
3530 (g->modifiers == modifier_mask)) &&
3531 (!strcmp(ev->keyname, g->keyname)))
3532 {
3533 if (!(modifier_mask & g->not_modifiers))
3534 {
3535 Evas_Object_Protected_Data *object_obj = efl_data_scope_get(g->object, EFL_CANVAS_OBJECT_CLASS);
3536 if (!e->is_frozen &&
3537 !evas_event_freezes_through(g->object, object_obj))
3538 {
3539 evas_object_event_callback_call(g->object, object_obj, EVAS_CALLBACK_KEY_DOWN, evt,
3540 event_id, EFL_EVENT_KEY_DOWN);
3541 }
3542 if (g->exclusive) exclusive = EINA_TRUE;
3543 }
3544 }
3545 if (e->delete_me) break;
3546 }
3547 e->walking_grabs--;
3548 if (e->walking_grabs <= 0)
3549 {
3550 while (e->delete_grabs > 0)
3551 {
3552 e->delete_grabs--;
3553 for (l = e->grabs; l;)
3554 {
3555 g = eina_list_data_get(l);
3556 l = eina_list_next(l);
3557 if (g->delete_me)
3558 {
3559 Evas_Object_Protected_Data *g_object_obj = efl_data_scope_get(g->object, EFL_CANVAS_OBJECT_CLASS);
3560 evas_key_grab_free(g->object, g_object_obj, g->keyname,
3561 g->modifiers, g->not_modifiers);
3562 }
3563 }
3564 }
3565 }
3566 }
3567 if (!exclusive)
3568 _key_event_dispatch(e, evt, ev->device, EFL_EVENT_KEY_DOWN,
3569 EVAS_CALLBACK_KEY_DOWN, event_id);
3570 _evas_post_event_callback_call(eo_e, e, event_id);
3571 _evas_unwalk(e);
3572
3573 if (ev->device) efl_unref(ev->device);
3574 }
3575
3576 static void
_canvas_event_feed_key_up_internal(Evas_Public_Data * e,Efl_Input_Key_Data * ev)3577 _canvas_event_feed_key_up_internal(Evas_Public_Data *e, Efl_Input_Key_Data *ev)
3578 {
3579 Eina_Bool exclusive = EINA_FALSE;
3580 Efl_Input_Pointer *evt;
3581 int event_id = 0;
3582 Eo *eo_e;
3583
3584 if (!e || !ev) return;
3585 if (e->is_frozen) return;
3586 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3587
3588 eo_e = e->evas;
3589 e->last_timestamp = ev->timestamp;
3590 _evas_walk(e);
3591
3592 event_id = _evas_object_event_new();
3593
3594 evt = ev->eo;
3595 ev->modifiers = &(e->modifiers);
3596 ev->locks = &(e->locks);
3597 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3598 if (ev->device) efl_ref(ev->device);
3599
3600 if (e->grabs)
3601 {
3602 Eina_List *l;
3603 Evas_Key_Grab *g;
3604 Evas_Modifier_Mask *seat_mask, modifier_mask;
3605 Efl_Input_Device *seat = NULL;
3606
3607 e->walking_grabs++;
3608 if (ev->device)
3609 seat = efl_input_device_seat_get(ev->device);
3610 seat_mask = eina_hash_find(e->modifiers.masks, &seat);
3611 modifier_mask = seat_mask ? *seat_mask : 0;
3612 EINA_LIST_FOREACH(e->grabs, l, g)
3613 {
3614 if (g->just_added)
3615 {
3616 g->just_added = EINA_FALSE;
3617 continue;
3618 }
3619 if (g->delete_me) continue;
3620 if (!g->object) continue;
3621 if (!g->is_active) continue;
3622 if (((modifier_mask & g->modifiers) ||
3623 (g->modifiers == modifier_mask)) &&
3624 (!(modifier_mask & g->not_modifiers)) &&
3625 (!strcmp(ev->keyname, g->keyname)))
3626 {
3627 Evas_Object_Protected_Data *object_obj = efl_data_scope_get(g->object, EFL_CANVAS_OBJECT_CLASS);
3628 if (!e->is_frozen &&
3629 !evas_event_freezes_through(g->object, object_obj))
3630 {
3631 evas_object_event_callback_call
3632 (g->object, object_obj, EVAS_CALLBACK_KEY_UP, evt,
3633 event_id, EFL_EVENT_KEY_UP);
3634 }
3635 if (g->exclusive) exclusive = EINA_TRUE;
3636 }
3637 if (e->delete_me) break;
3638 }
3639 e->walking_grabs--;
3640 if (e->walking_grabs <= 0)
3641 {
3642 while (e->delete_grabs > 0)
3643 {
3644 Eina_List *ll, *l_next;
3645 Evas_Key_Grab *gr;
3646
3647 e->delete_grabs--;
3648 EINA_LIST_FOREACH_SAFE(e->grabs, ll, l_next, gr)
3649 {
3650 if (gr->delete_me)
3651 {
3652 Evas_Object_Protected_Data *gr_object_obj =
3653 efl_data_scope_get(gr->object, EFL_CANVAS_OBJECT_CLASS);
3654 evas_key_grab_free(gr->object, gr_object_obj, gr->keyname,
3655 gr->modifiers, gr->not_modifiers);
3656 }
3657 }
3658 }
3659 }
3660 }
3661 if (!exclusive)
3662 _key_event_dispatch(e, evt, ev->device, EFL_EVENT_KEY_UP,
3663 EVAS_CALLBACK_KEY_UP, event_id);
3664 _evas_post_event_callback_call(eo_e, e, event_id);
3665 _evas_unwalk(e);
3666
3667 if (ev->device) efl_unref(ev->device);
3668 }
3669
3670 static void
_canvas_event_feed_key_legacy(Eo * eo_e,Evas_Public_Data * e,const char * keyname,const char * key,const char * string,const char * compose,unsigned int timestamp,const void * data,unsigned int keycode,Eina_Bool down)3671 _canvas_event_feed_key_legacy(Eo *eo_e, Evas_Public_Data *e,
3672 const char *keyname, const char *key,
3673 const char *string, const char *compose,
3674 unsigned int timestamp, const void *data,
3675 unsigned int keycode, Eina_Bool down)
3676 {
3677 Efl_Input_Key_Data *ev = NULL;
3678 Efl_Input_Key *evt;
3679
3680 if (!keyname) return;
3681
3682 evt = efl_input_key_instance_get( eo_e, (void **) &ev);
3683 if (!ev) return;
3684
3685 ev->keyname = (char *) keyname;
3686 ev->data = (void *) data;
3687 ev->key = key;
3688 ev->string = string;
3689 ev->compose = compose;
3690 ev->timestamp = timestamp;
3691 ev->keycode = keycode;
3692 ev->pressed = down;
3693 ev->no_stringshare = EINA_TRUE;
3694 ev->device = efl_ref(_evas_event_legacy_device_get(e->evas, EINA_FALSE));
3695
3696
3697 if (down)
3698 _canvas_event_feed_key_down_internal(e, ev);
3699 else
3700 _canvas_event_feed_key_up_internal(e, ev);
3701
3702 efl_unref(evt);
3703 }
3704
3705 EAPI void
evas_event_feed_key_down(Eo * eo_e,const char * keyname,const char * key,const char * string,const char * compose,unsigned int timestamp,const void * data)3706 evas_event_feed_key_down(Eo *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data)
3707 {
3708 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3709 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3710 _canvas_event_feed_key_legacy(eo_e, e, keyname, key, string,
3711 compose, timestamp, data, 0, 1);
3712 }
3713
3714 EAPI void
evas_event_feed_key_up(Eo * eo_e,const char * keyname,const char * key,const char * string,const char * compose,unsigned int timestamp,const void * data)3715 evas_event_feed_key_up(Eo *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data)
3716 {
3717 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3718 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3719 _canvas_event_feed_key_legacy(eo_e, e, keyname, key, string,
3720 compose, timestamp, data, 0, 0);
3721 }
3722
3723 EAPI void
evas_event_feed_key_down_with_keycode(Eo * eo_e,const char * keyname,const char * key,const char * string,const char * compose,unsigned int timestamp,const void * data,unsigned int keycode)3724 evas_event_feed_key_down_with_keycode(Eo *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data, unsigned int keycode)
3725 {
3726 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3727 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3728 _canvas_event_feed_key_legacy(eo_e, e, keyname, key, string,
3729 compose, timestamp, data, keycode, 1);
3730 }
3731
3732 EAPI void
evas_event_feed_key_up_with_keycode(Eo * eo_e,const char * keyname,const char * key,const char * string,const char * compose,unsigned int timestamp,const void * data,unsigned int keycode)3733 evas_event_feed_key_up_with_keycode(Eo *eo_e, const char *keyname, const char *key, const char *string, const char *compose, unsigned int timestamp, const void *data, unsigned int keycode)
3734 {
3735 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3736 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3737 _canvas_event_feed_key_legacy(eo_e, e, keyname, key, string,
3738 compose, timestamp, data, keycode, 0);
3739 }
3740
3741 EAPI void
evas_event_feed_hold(Eo * eo_e,int hold,unsigned int timestamp,const void * data)3742 evas_event_feed_hold(Eo *eo_e, int hold, unsigned int timestamp, const void *data)
3743 {
3744 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3745 Efl_Input_Hold_Data *ev = NULL;
3746 Efl_Input_Hold *evt;
3747 Eina_List *l, *copy;
3748 Evas_Object *eo_obj;
3749 int event_id = 0;
3750 Evas_Pointer_Data *pdata;
3751
3752 if (e->is_frozen) return;
3753 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3754 e->last_timestamp = timestamp;
3755
3756 event_id = _evas_object_event_new();
3757
3758 evt = efl_input_hold_instance_get(eo_e, (void **) &ev);
3759 if (!ev) return;
3760
3761 ev->hold = !!hold;
3762 ev->data = (void *) data;
3763 ev->timestamp = timestamp;
3764 ev->event_flags = (Efl_Input_Flags)e->default_event_flags;
3765 ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE));
3766
3767 pdata = _evas_pointer_data_by_device_get(e, ev->device);
3768 if (!pdata) return;
3769
3770
3771 _evas_walk(e);
3772 copy = evas_event_list_copy(pdata->seat->object.in);
3773 EINA_LIST_FOREACH(copy, l, eo_obj)
3774 {
3775 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3776 if ( !evas_event_freezes_through(eo_obj, obj))
3777 {
3778 evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_HOLD, evt,
3779 event_id, EFL_EVENT_HOLD);
3780 if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
3781 _evas_event_source_hold_events(eo_obj, event_id, evt);
3782 }
3783 if (e->delete_me || e->is_frozen) break;
3784 }
3785 eina_list_free(copy);
3786 _evas_post_event_callback_call(eo_e, e, event_id);
3787 _evas_unwalk(e);
3788 _evas_object_event_new();
3789
3790 efl_unref(evt);
3791 }
3792
3793 void
_canvas_event_feed_axis_update_internal(Evas_Public_Data * e,Efl_Input_Pointer_Data * ev)3794 _canvas_event_feed_axis_update_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data *ev)
3795 {
3796 Efl_Input_Pointer *evt;
3797 Eina_List *l, *copy;
3798 Evas_Object *eo_obj;
3799 int event_id = 0;
3800 Evas *eo_e;
3801 Evas_Pointer_Data *pdata;
3802
3803 static const int value_flags =
3804 _efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP);
3805
3806 if (!e || !ev) return;
3807 if (e->is_frozen) return;
3808 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3809
3810 pdata = _evas_pointer_data_by_device_get(e, ev->device);
3811 if (!pdata) return;
3812 eo_e = e->evas;
3813 e->last_timestamp = ev->timestamp;
3814
3815 ev->action = EFL_POINTER_ACTION_AXIS;
3816 ev->value_flags |= value_flags;
3817 event_id = _evas_object_event_new();
3818 evt = ev->eo;
3819
3820 if (ev->device) efl_ref(ev->device);
3821
3822 _evas_walk(e);
3823 copy = evas_event_list_copy(pdata->seat->object.in);
3824
3825 EINA_LIST_FOREACH(copy, l, eo_obj)
3826 {
3827 Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
3828 if (!evas_event_freezes_through(eo_obj, obj))
3829 {
3830 evas_object_event_callback_call(eo_obj, obj,
3831 EVAS_CALLBACK_AXIS_UPDATE, evt,
3832 event_id, EFL_EVENT_POINTER_AXIS);
3833 if (e->delete_me || e->is_frozen) break;
3834 }
3835 }
3836 eina_list_free(copy);
3837 _evas_post_event_callback_call(eo_e, e, event_id);
3838
3839 _evas_unwalk(e);
3840 if (ev->device) efl_unref(ev->device);
3841 }
3842
3843 EAPI void
evas_event_feed_axis_update(Evas * eo_e,unsigned int timestamp,int device,int toolid,int naxis,const Evas_Axis * axes,const void * data)3844 evas_event_feed_axis_update(Evas *eo_e, unsigned int timestamp, int device, int toolid, int naxis, const Evas_Axis *axes, const void *data)
3845 {
3846 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
3847 Evas_Public_Data *e = efl_data_scope_get(eo_e, EVAS_CANVAS_CLASS);
3848 Efl_Input_Pointer_Data *ev = NULL;
3849 Eina_Bool haswinx = 0, haswiny = 0;
3850 Efl_Input_Pointer *evt;
3851 double x = 0, y = 0;
3852 int n;
3853
3854 if (!e) return;
3855 EVAS_EVENT_FEED_SAFETY_CHECK(e);
3856
3857 evt = efl_input_pointer_instance_get( eo_e, (void **) &ev);
3858 if (!ev) return;
3859
3860 ev->data = (void *) data;
3861 ev->timestamp = timestamp;
3862 ev->action = EFL_POINTER_ACTION_AXIS;
3863 ev->touch_id = toolid;
3864
3865 // see also ecore_evas.c
3866 for (n = 0; n < naxis; n++)
3867 {
3868 const Evas_Axis *axis = &(axes[n]);
3869 switch (axis->label)
3870 {
3871 case EVAS_AXIS_LABEL_WINDOW_X:
3872 _efl_input_value_mark(ev, EFL_INPUT_VALUE_X);
3873 x = axis->value;
3874 haswinx = EINA_TRUE;
3875 break;
3876
3877 case EVAS_AXIS_LABEL_WINDOW_Y:
3878 _efl_input_value_mark(ev, EFL_INPUT_VALUE_Y);
3879 y = axis->value;
3880 haswiny = EINA_TRUE;
3881 break;
3882
3883 case EVAS_AXIS_LABEL_X:
3884 if (!haswinx)
3885 {
3886 _efl_input_value_mark(ev, EFL_INPUT_VALUE_X);
3887 x = axis->value;
3888 }
3889 ev->raw.x = axis->value;
3890 ev->has_raw = EINA_TRUE;
3891 break;
3892
3893 case EVAS_AXIS_LABEL_Y:
3894 if (!haswiny)
3895 {
3896 _efl_input_value_mark(ev, EFL_INPUT_VALUE_Y);
3897 y = axis->value;
3898 }
3899 ev->raw.y = axis->value;
3900 ev->has_raw = EINA_TRUE;
3901 break;
3902
3903 case EVAS_AXIS_LABEL_NORMAL_X:
3904 ev->norm.x = axis->value;
3905 ev->has_norm = EINA_TRUE;
3906 break;
3907
3908 case EVAS_AXIS_LABEL_NORMAL_Y:
3909 ev->norm.y = axis->value;
3910 ev->has_norm = EINA_TRUE;
3911 break;
3912
3913 case EVAS_AXIS_LABEL_PRESSURE:
3914 _efl_input_value_mark(ev, EFL_INPUT_VALUE_PRESSURE);
3915 ev->pressure = axis->value;
3916 break;
3917
3918 case EVAS_AXIS_LABEL_DISTANCE:
3919 _efl_input_value_mark(ev, EFL_INPUT_VALUE_DISTANCE);
3920 ev->distance = axis->value;
3921 break;
3922
3923 case EVAS_AXIS_LABEL_AZIMUTH:
3924 _efl_input_value_mark(ev, EFL_INPUT_VALUE_AZIMUTH);
3925 ev->azimuth = axis->value;
3926 break;
3927
3928 case EVAS_AXIS_LABEL_TILT:
3929 _efl_input_value_mark(ev, EFL_INPUT_VALUE_TILT);
3930 ev->tilt = axis->value;
3931 break;
3932
3933 case EVAS_AXIS_LABEL_TWIST:
3934 _efl_input_value_mark(ev, EFL_INPUT_VALUE_TWIST);
3935 ev->twist = axis->value;
3936 break;
3937
3938 case EVAS_AXIS_LABEL_UNKNOWN:
3939 case EVAS_AXIS_LABEL_TOUCH_WIDTH_MAJOR:
3940 case EVAS_AXIS_LABEL_TOUCH_WIDTH_MINOR:
3941 case EVAS_AXIS_LABEL_TOOL_WIDTH_MAJOR:
3942 case EVAS_AXIS_LABEL_TOOL_WIDTH_MINOR:
3943 default:
3944 DBG("Unsupported axis label %d, value %f (discarded)",
3945 axis->label, axis->value);
3946 break;
3947 }
3948 }
3949
3950 ev->cur.x = x;
3951 ev->cur.y = y;
3952
3953 /* FIXME: set proper device based on the device id (X or WL specific) */
3954 ev->device = efl_ref(_evas_event_legacy_device_get(eo_e, EINA_TRUE)); // FIXME
3955 (void) device;
3956
3957 _canvas_event_feed_axis_update_internal(e, ev);
3958
3959 efl_unref(evt);
3960 }
3961
3962 static void
_feed_mouse_move_eval_internal(Eo * eo_obj,Evas_Object_Protected_Data * obj)3963 _feed_mouse_move_eval_internal(Eo *eo_obj, Evas_Object_Protected_Data *obj)
3964 {
3965 Evas_Public_Data *evas = obj->layer->evas;
3966 Eina_Bool in_output_rect;
3967 Evas_Pointer_Data *pdata = _evas_pointer_data_by_device_get(evas, NULL);
3968
3969 if (!pdata) return;
3970 in_output_rect = evas_object_is_in_output_rect(eo_obj, obj, pdata->seat->x,
3971 pdata->seat->y, 1, 1);
3972 if ((in_output_rect) &&
3973 ((!obj->precise_is_inside) || (evas_object_is_inside(eo_obj, obj,
3974 pdata->seat->x,
3975 pdata->seat->y))))
3976 {
3977 _canvas_event_feed_mouse_move_legacy(evas->evas, evas,
3978 pdata->seat->x, pdata->seat->y,
3979 evas->last_timestamp, NULL);
3980 }
3981 }
3982 EOLIAN void
_efl_canvas_object_efl_object_event_freeze(Eo * obj,Evas_Object_Protected_Data * pd)3983 _efl_canvas_object_efl_object_event_freeze(Eo *obj, Evas_Object_Protected_Data *pd)
3984 {
3985 efl_event_freeze(efl_super(obj, EFL_CANVAS_OBJECT_CLASS));
3986 if (efl_event_freeze_count_get(obj) == 1)
3987 {
3988 pd->freeze_events = EINA_TRUE;
3989 evas_object_smart_member_cache_invalidate(obj, EINA_FALSE, EINA_TRUE,
3990 EINA_FALSE);
3991 }
3992 }
3993
3994 EOLIAN void
_efl_canvas_object_efl_object_event_thaw(Eo * obj,Evas_Object_Protected_Data * pd)3995 _efl_canvas_object_efl_object_event_thaw(Eo *obj, Evas_Object_Protected_Data *pd)
3996 {
3997 if (efl_event_freeze_count_get(obj) == 1)
3998 {
3999 pd->freeze_events = EINA_FALSE;
4000 evas_object_smart_member_cache_invalidate(obj, EINA_FALSE, EINA_TRUE,
4001 EINA_FALSE);
4002 _feed_mouse_move_eval_internal(obj, pd);
4003 }
4004 efl_event_thaw(efl_super(obj, EFL_CANVAS_OBJECT_CLASS));
4005 }
4006
4007 EAPI void
evas_object_freeze_events_set(Eo * eo_obj,Eina_Bool freeze)4008 evas_object_freeze_events_set(Eo *eo_obj, Eina_Bool freeze)
4009 {
4010 Evas_Object_Protected_Data *pd = EVAS_OBJECT_DATA_SAFE_GET(eo_obj);
4011 EINA_SAFETY_ON_NULL_RETURN(pd);
4012
4013 freeze = !!freeze;
4014 if (pd->freeze_events == freeze) return;
4015
4016 if (freeze)
4017 efl_event_freeze(eo_obj);
4018 else
4019 // The following check is needed, as eo does not accept more thaw calls than freeze calls.
4020 // However, evas legacy stuff accepted multiple flase sets
4021 if (efl_event_freeze_count_get(eo_obj) > 0)
4022 efl_event_thaw(eo_obj);
4023 }
4024
4025 EAPI Eina_Bool
evas_object_freeze_events_get(const Eo * eo_obj EINA_UNUSED)4026 evas_object_freeze_events_get(const Eo *eo_obj EINA_UNUSED)
4027 {
4028 return (efl_event_freeze_count_get(eo_obj) > 0);
4029 }
4030
4031 EOLIAN void
_efl_canvas_object_pass_events_set(Eo * eo_obj,Evas_Object_Protected_Data * obj,Eina_Bool pass)4032 _efl_canvas_object_pass_events_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Eina_Bool pass)
4033 {
4034 pass = !!pass;
4035 if (obj->pass_events == pass) return;
4036 obj->pass_events = pass;
4037 evas_object_smart_member_cache_invalidate(eo_obj, EINA_TRUE, EINA_FALSE, EINA_FALSE);
4038 _feed_mouse_move_eval_internal(eo_obj, obj);
4039 }
4040
4041 EOLIAN Eina_Bool
_efl_canvas_object_pass_events_get(const Eo * eo_obj EINA_UNUSED,Evas_Object_Protected_Data * obj)4042 _efl_canvas_object_pass_events_get(const Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj)
4043 {
4044 return obj->pass_events;
4045 }
4046
4047 EOLIAN void
_efl_canvas_object_repeat_events_set(Eo * eo_obj,Evas_Object_Protected_Data * obj,Eina_Bool repeat)4048 _efl_canvas_object_repeat_events_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Eina_Bool repeat)
4049 {
4050 repeat = !!repeat;
4051 if (obj->repeat_events == repeat) return;
4052 obj->repeat_events = repeat;
4053 _feed_mouse_move_eval_internal(eo_obj, obj);
4054 }
4055
4056 EOLIAN Eina_Bool
_efl_canvas_object_repeat_events_get(const Eo * eo_obj EINA_UNUSED,Evas_Object_Protected_Data * obj)4057 _efl_canvas_object_repeat_events_get(const Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj)
4058 {
4059 return obj->repeat_events;
4060 }
4061
4062 EOLIAN void
_efl_canvas_object_propagate_events_set(Eo * eo_obj EINA_UNUSED,Evas_Object_Protected_Data * obj,Eina_Bool prop)4063 _efl_canvas_object_propagate_events_set(Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj, Eina_Bool prop)
4064 {
4065 obj->no_propagate = !prop;
4066 }
4067
4068 EOLIAN Eina_Bool
_efl_canvas_object_propagate_events_get(const Eo * eo_obj EINA_UNUSED,Evas_Object_Protected_Data * obj)4069 _efl_canvas_object_propagate_events_get(const Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj)
4070 {
4071 return !(obj->no_propagate);
4072 }
4073
4074 EOLIAN Eina_Bool
_efl_canvas_object_pointer_mode_by_device_set(Eo * eo_obj,Evas_Object_Protected_Data * obj,Efl_Input_Device * dev,Evas_Object_Pointer_Mode setting)4075 _efl_canvas_object_pointer_mode_by_device_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Efl_Input_Device *dev, Evas_Object_Pointer_Mode setting)
4076 {
4077 int addgrab;
4078 Evas_Object *cobj;
4079 const Eina_List *l;
4080 Evas_Pointer_Data *pdata;
4081 Evas_Object_Pointer_Data *obj_pdata;
4082
4083 pdata = _evas_pointer_data_by_device_get(obj->layer->evas, dev);
4084 if (!pdata) return EINA_FALSE;
4085
4086 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
4087 EINA_SAFETY_ON_NULL_RETURN_VAL(obj_pdata, EINA_FALSE);
4088
4089 /* ignore no-ops */
4090 if (obj_pdata->pointer_mode == setting) return EINA_FALSE;
4091
4092 /* adjust by number of pointer down events */
4093 addgrab = pdata->seat->downs;
4094 switch (obj_pdata->pointer_mode)
4095 {
4096 /* nothing needed */
4097 case EVAS_OBJECT_POINTER_MODE_NOGRAB: break;
4098 /* decrement canvas nogrep (NO Grab/REPeat) counter */
4099 case EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN:
4100 if (obj_pdata->mouse_grabbed)
4101 pdata->seat->nogrep--;
4102 /* fall through */
4103 /* remove related grabs from canvas and object */
4104 case EVAS_OBJECT_POINTER_MODE_AUTOGRAB:
4105 if (obj_pdata->mouse_grabbed)
4106 {
4107 pdata->seat->mouse_grabbed -= obj_pdata->mouse_grabbed;
4108 obj_pdata->mouse_grabbed = 0;
4109 }
4110 }
4111 /* adjustments for new mode */
4112 switch (setting)
4113 {
4114 /* nothing needed */
4115 case EVAS_OBJECT_POINTER_MODE_NOGRAB: break;
4116 /* increment canvas nogrep (NO Grab/REPeat) counter */
4117 case EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN:
4118 pdata->seat->nogrep++;
4119 /* having nogrep set indicates that any object following it in
4120 * the pointer.object.in list will not be receiving events, meaning
4121 * that they will fail to unset any existing grabs/flags. unset them
4122 * now to avoid breaking the canvas
4123 */
4124 EINA_LIST_FOREACH(pdata->seat->object.in, l, cobj)
4125 {
4126 Evas_Object_Protected_Data *cobj_data;
4127
4128 /* skip to the current object */
4129 if (cobj != eo_obj) continue;
4130 /* only change objects past it */
4131 EINA_LIST_FOREACH(l->next, l, cobj)
4132 {
4133 Evas_Object_Pointer_Data *cobj_pdata;
4134 cobj_data = efl_data_scope_get(cobj, EFL_CANVAS_OBJECT_CLASS);
4135 cobj_pdata = _evas_object_pointer_data_get(pdata, cobj_data);
4136 if (!cobj_pdata) continue;
4137 if (!cobj_pdata->mouse_grabbed) continue;
4138 cobj_pdata->mouse_grabbed -= addgrab;
4139 pdata->seat->mouse_grabbed -= addgrab;
4140 if (cobj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
4141 pdata->seat->nogrep--;
4142 }
4143 break;
4144 }
4145 /* fall through */
4146 /* add all button grabs to this object */
4147 case EVAS_OBJECT_POINTER_MODE_AUTOGRAB:
4148 obj_pdata->mouse_grabbed += addgrab;
4149 pdata->seat->mouse_grabbed += addgrab;
4150 }
4151 obj_pdata->pointer_mode = setting;
4152 return EINA_TRUE;
4153 }
4154
4155 EOLIAN Evas_Object_Pointer_Mode
_efl_canvas_object_pointer_mode_by_device_get(const Eo * eo_obj EINA_UNUSED,Evas_Object_Protected_Data * obj,Efl_Input_Device * dev)4156 _efl_canvas_object_pointer_mode_by_device_get(const Eo *eo_obj EINA_UNUSED,
4157 Evas_Object_Protected_Data *obj,
4158 Efl_Input_Device *dev)
4159 {
4160
4161 Evas_Pointer_Data *pdata;
4162 Evas_Object_Pointer_Data *obj_pdata;
4163
4164 pdata = _evas_pointer_data_by_device_get(obj->layer->evas, dev);
4165 EINA_SAFETY_ON_NULL_RETURN_VAL(pdata, EVAS_OBJECT_POINTER_MODE_AUTOGRAB);
4166
4167 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
4168 EINA_SAFETY_ON_NULL_RETURN_VAL(obj_pdata, EVAS_OBJECT_POINTER_MODE_AUTOGRAB);
4169 return obj_pdata->pointer_mode;
4170 }
4171
4172 EOLIAN Eina_Bool
_efl_canvas_object_pointer_mode_set(Eo * eo_obj,Evas_Object_Protected_Data * obj,Evas_Object_Pointer_Mode setting)4173 _efl_canvas_object_pointer_mode_set(Eo *eo_obj, Evas_Object_Protected_Data *obj,
4174 Evas_Object_Pointer_Mode setting)
4175 {
4176 return _efl_canvas_object_pointer_mode_by_device_set(eo_obj, obj, NULL, setting);
4177 }
4178
4179 EOLIAN Evas_Object_Pointer_Mode
_efl_canvas_object_pointer_mode_get(const Eo * eo_obj,Evas_Object_Protected_Data * obj)4180 _efl_canvas_object_pointer_mode_get(const Eo *eo_obj, Evas_Object_Protected_Data *obj)
4181 {
4182 return _efl_canvas_object_pointer_mode_by_device_get(eo_obj, obj, NULL);
4183 }
4184
4185 EOLIAN Eina_Bool
_efl_canvas_object_efl_canvas_pointer_pointer_inside_get(const Eo * eo_obj,Evas_Object_Protected_Data * obj,Efl_Input_Device * pointer)4186 _efl_canvas_object_efl_canvas_pointer_pointer_inside_get(const Eo *eo_obj,
4187 Evas_Object_Protected_Data *obj,
4188 Efl_Input_Device *pointer)
4189 {
4190 Evas_Object_Protected_Data *in, *parent;
4191 Eo *eo_in, *eo_parent;
4192 Eina_List *l;
4193 Evas_Object_Pointer_Data *obj_pdata;
4194 Evas_Pointer_Data *pdata;
4195
4196 EVAS_OBJECT_DATA_ALIVE_CHECK(obj, EINA_FALSE);
4197
4198 if (!pointer)
4199 pointer = obj->layer->evas->default_mouse;
4200
4201 if (!pointer) return EINA_FALSE;
4202
4203 pdata = _evas_pointer_data_by_device_get(obj->layer->evas, pointer);
4204 if (!pdata) return EINA_FALSE;
4205 obj_pdata = _evas_object_pointer_data_get(pdata, obj);
4206 if (!obj_pdata) return EINA_FALSE;
4207 if (!obj->is_smart)
4208 return obj_pdata->mouse_in;
4209
4210 /* This is to keep the legacy APIs evas_object_pointer_inside_by_device_get() &
4211 * evas_object_pointer_inside_get() old behaviour. */
4212 if (obj->is_pointer_inside_legacy) return EINA_FALSE;
4213
4214 /* For smart objects, this is a bit expensive obj->mouse_in will not be set.
4215 * Alternatively we could count the number of in and out events propagated
4216 * to the smart object, assuming they always match. */
4217 EINA_LIST_FOREACH(pdata->seat->object.in, l, eo_in)
4218 {
4219 if (EINA_UNLIKELY(eo_in == eo_obj))
4220 return EINA_TRUE;
4221
4222 in = EVAS_OBJECT_DATA_GET(eo_in);
4223 if (!EVAS_OBJECT_DATA_ALIVE(in)) continue;
4224 eo_parent = in->smart.parent;
4225 while (eo_parent)
4226 {
4227 if ((eo_parent == eo_obj) && !in->no_propagate)
4228 return EINA_TRUE;
4229 parent = EVAS_OBJECT_DATA_GET(eo_parent);
4230 if (!EVAS_OBJECT_DATA_ALIVE(parent)) break;
4231 eo_parent = parent->smart.parent;
4232 }
4233 }
4234
4235 return EINA_FALSE;
4236 }
4237
4238 EAPI void
evas_event_refeed_event(Eo * eo_e,void * event_copy,Evas_Callback_Type event_type)4239 evas_event_refeed_event(Eo *eo_e, void *event_copy, Evas_Callback_Type event_type)
4240 {
4241 EINA_SAFETY_ON_FALSE_RETURN(efl_isa(eo_e, EVAS_CANVAS_CLASS));
4242 if (!event_copy) return;
4243
4244 switch (event_type)
4245 {
4246 case EVAS_CALLBACK_MOUSE_IN:
4247 {
4248 Evas_Event_Mouse_In *ev = event_copy;
4249 evas_event_feed_mouse_in(eo_e, ev->timestamp, ev->data);
4250 break;
4251 }
4252 case EVAS_CALLBACK_MOUSE_OUT:
4253 {
4254 Evas_Event_Mouse_Out *ev = event_copy;
4255 evas_event_feed_mouse_out(eo_e, ev->timestamp, ev->data);
4256 break;
4257 }
4258 case EVAS_CALLBACK_MOUSE_DOWN:
4259 {
4260 Evas_Event_Mouse_Down *ev = event_copy;
4261 evas_event_feed_mouse_down(eo_e, ev->button, ev->flags, ev-> timestamp, ev->data);
4262 break;
4263 }
4264 case EVAS_CALLBACK_MOUSE_UP:
4265 {
4266 Evas_Event_Mouse_Up *ev = event_copy;
4267 evas_event_feed_mouse_up(eo_e, ev->button, ev->flags, ev-> timestamp, ev->data);
4268 break;
4269 }
4270 case EVAS_CALLBACK_MOUSE_MOVE:
4271 {
4272 Evas_Event_Mouse_Move *ev = event_copy;
4273 evas_event_feed_mouse_move(eo_e, ev->cur.canvas.x, ev->cur.canvas.y, ev->timestamp, ev->data);
4274 break;
4275 }
4276 case EVAS_CALLBACK_MOUSE_WHEEL:
4277 {
4278 Evas_Event_Mouse_Wheel *ev = event_copy;
4279 evas_event_feed_mouse_wheel(eo_e, ev->direction, ev-> z, ev->timestamp, ev->data);
4280 break;
4281 }
4282 case EVAS_CALLBACK_MULTI_DOWN:
4283 {
4284 Evas_Event_Multi_Down *ev = event_copy;
4285 evas_event_feed_multi_down(eo_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);
4286 break;
4287 }
4288 case EVAS_CALLBACK_MULTI_UP:
4289 {
4290 Evas_Event_Multi_Up *ev = event_copy;
4291 evas_event_feed_multi_up(eo_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);
4292 break;
4293 }
4294 case EVAS_CALLBACK_MULTI_MOVE:
4295 {
4296 Evas_Event_Multi_Move *ev = event_copy;
4297 evas_event_feed_multi_move(eo_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);
4298 break;
4299 }
4300 case EVAS_CALLBACK_KEY_DOWN:
4301 {
4302 Evas_Event_Key_Down *ev = event_copy;
4303 evas_event_feed_key_down(eo_e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data);
4304 break;
4305 }
4306 case EVAS_CALLBACK_KEY_UP:
4307 {
4308 Evas_Event_Key_Up *ev = event_copy;
4309 evas_event_feed_key_up(eo_e, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, ev->data);
4310 break;
4311 }
4312 case EVAS_CALLBACK_AXIS_UPDATE:
4313 {
4314 Evas_Event_Axis_Update *ev = event_copy;
4315 evas_event_feed_axis_update(eo_e, ev->timestamp, ev->device, ev->toolid, ev->naxis, ev->axis, ev->data);
4316 break;
4317 }
4318 default: /* All non-input events are not handeled */
4319 break;
4320 }
4321 }
4322
4323
4324 EOLIAN int
_evas_canvas_event_down_count_by_device_get(const Eo * eo_e EINA_UNUSED,Evas_Public_Data * e,Efl_Input_Device * dev)4325 _evas_canvas_event_down_count_by_device_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e,
4326 Efl_Input_Device *dev)
4327 {
4328 Evas_Pointer_Data *pdata = _evas_pointer_data_by_device_get(e, dev);
4329 EINA_SAFETY_ON_NULL_RETURN_VAL(pdata, 0);
4330 return pdata->seat->downs;
4331 }
4332
4333 EOLIAN int
_evas_canvas_event_down_count_get(const Eo * eo_e EINA_UNUSED,Evas_Public_Data * e)4334 _evas_canvas_event_down_count_get(const Eo *eo_e EINA_UNUSED, Evas_Public_Data *e)
4335 {
4336 return _evas_canvas_event_down_count_by_device_get(eo_e, e, NULL);
4337 }
4338
4339 static void
_evas_canvas_event_pointer_cb(void * data,const Efl_Event * event)4340 _evas_canvas_event_pointer_cb(void *data, const Efl_Event *event)
4341 {
4342 Efl_Input_Pointer_Data *ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
4343 Evas_Public_Data *e = data;
4344 Evas *eo_e = event->object;
4345 Eina_Bool nodev = 0;
4346
4347 if (!ev) return;
4348
4349 ev->evas_done = EINA_TRUE;
4350 ev->modifiers = &e->modifiers;
4351 ev->locks = &e->locks;
4352
4353 if (!ev->device)
4354 {
4355 nodev = 1;
4356 ev->device = _evas_event_legacy_device_get(e->evas, EINA_TRUE);
4357 }
4358
4359 switch (ev->action)
4360 {
4361 case EFL_POINTER_ACTION_MOVE:
4362 if (ev->touch_id == 0)
4363 _canvas_event_feed_mouse_move_internal(e, ev);
4364 else
4365 _canvas_event_feed_multi_move_internal(e, ev);
4366 break;
4367
4368 case EFL_POINTER_ACTION_DOWN:
4369 if (ev->touch_id == 0)
4370 _canvas_event_feed_mouse_down_internal(e, ev);
4371 else
4372 _canvas_event_feed_multi_down_internal(e, ev);
4373 break;
4374
4375 case EFL_POINTER_ACTION_UP:
4376 if (ev->touch_id == 0)
4377 _canvas_event_feed_mouse_up_internal(e, ev);
4378 else
4379 _canvas_event_feed_multi_up_internal(e, ev);
4380 break;
4381
4382 case EFL_POINTER_ACTION_CANCEL:
4383 _canvas_event_feed_mouse_cancel_internal(e, ev);
4384 break;
4385
4386 case EFL_POINTER_ACTION_IN:
4387 _canvas_event_feed_mouse_in_internal(eo_e, ev);
4388 break;
4389
4390 case EFL_POINTER_ACTION_OUT:
4391 _canvas_event_feed_mouse_out_internal(eo_e, ev);
4392 break;
4393
4394 case EFL_POINTER_ACTION_WHEEL:
4395 _canvas_event_feed_mouse_wheel_internal(eo_e, ev);
4396 break;
4397
4398 case EFL_POINTER_ACTION_AXIS:
4399 _canvas_event_feed_axis_update_internal(e, ev);
4400 break;
4401
4402 default:
4403 ERR("unsupported event type: %d", ev->action);
4404 ev->evas_done = EINA_FALSE;
4405 break;
4406 }
4407
4408 if (nodev) ev->device = NULL;
4409 }
4410
4411 static void
_evas_canvas_event_key_cb(void * data,const Efl_Event * event)4412 _evas_canvas_event_key_cb(void *data, const Efl_Event *event)
4413 {
4414 Efl_Input_Key *evt = event->info;
4415 Evas_Public_Data *e = data;
4416 Efl_Input_Key_Data *ev;
4417 Eina_Bool nodev = 0;
4418
4419 ev = efl_data_scope_get(evt, EFL_INPUT_KEY_CLASS);
4420 if (!ev) return;
4421
4422 if (!ev->device)
4423 {
4424 nodev = 1;
4425 ev->device = _evas_event_legacy_device_get(e->evas, EINA_FALSE);
4426 }
4427
4428 ev->modifiers = &e->modifiers;
4429 ev->locks = &e->locks;
4430
4431 if (ev->pressed)
4432 _canvas_event_feed_key_down_internal(e, ev);
4433 else
4434 _canvas_event_feed_key_up_internal(e, ev);
4435
4436 if (nodev) ev->device = NULL;
4437 ev->evas_done = EINA_TRUE;
4438 }
4439
4440 static void
_evas_canvas_event_focus_cb(void * data,const Efl_Event * event)4441 _evas_canvas_event_focus_cb(void *data, const Efl_Event *event)
4442 {
4443 Efl_Input_Device *seat = efl_canvas_scene_seat_default_get(event->object);
4444 Evas_Public_Data *e = data;
4445
4446 EINA_SAFETY_ON_NULL_RETURN(seat);
4447
4448 if (event->desc == EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN)
4449 {
4450 if (eina_list_data_find(e->focused_by, seat)) return;
4451 e->focused_by = eina_list_append(e->focused_by, seat);
4452 }
4453 else
4454 {
4455 if (!eina_list_data_find(e->focused_by, seat)) return;
4456 e->focused_by = eina_list_remove(e->focused_by, seat);
4457 }
4458 }
4459
4460 // note: "hold" event comes from above (elm), not below (ecore)
4461 EFL_CALLBACKS_ARRAY_DEFINE(_evas_canvas_event_pointer_callbacks,
4462 { EFL_EVENT_POINTER_MOVE, _evas_canvas_event_pointer_cb },
4463 { EFL_EVENT_POINTER_DOWN, _evas_canvas_event_pointer_cb },
4464 { EFL_EVENT_POINTER_UP, _evas_canvas_event_pointer_cb },
4465 { EFL_EVENT_POINTER_IN, _evas_canvas_event_pointer_cb },
4466 { EFL_EVENT_POINTER_OUT, _evas_canvas_event_pointer_cb },
4467 { EFL_EVENT_POINTER_CANCEL, _evas_canvas_event_pointer_cb },
4468 { EFL_EVENT_POINTER_WHEEL, _evas_canvas_event_pointer_cb },
4469 { EFL_EVENT_POINTER_AXIS, _evas_canvas_event_pointer_cb },
4470 { EFL_EVENT_FINGER_MOVE, _evas_canvas_event_pointer_cb },
4471 { EFL_EVENT_FINGER_DOWN, _evas_canvas_event_pointer_cb },
4472 { EFL_EVENT_FINGER_UP, _evas_canvas_event_pointer_cb },
4473 { EFL_EVENT_KEY_DOWN, _evas_canvas_event_key_cb },
4474 { EFL_EVENT_KEY_UP, _evas_canvas_event_key_cb },
4475 { EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN, _evas_canvas_event_focus_cb },
4476 { EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT, _evas_canvas_event_focus_cb })
4477
4478 void
_evas_canvas_event_init(Evas * eo_e,Evas_Public_Data * e)4479 _evas_canvas_event_init(Evas *eo_e, Evas_Public_Data *e)
4480 {
4481 efl_event_callback_array_add(eo_e, _evas_canvas_event_pointer_callbacks(), e);
4482 }
4483
4484 void
_evas_canvas_event_shutdown(Evas * eo_e,Evas_Public_Data * e)4485 _evas_canvas_event_shutdown(Evas *eo_e, Evas_Public_Data *e)
4486 {
4487 efl_event_callback_array_del(eo_e, _evas_canvas_event_pointer_callbacks(), e);
4488 }
4489
4490 void
_evas_canvas_event_pointer_move_event_dispatch(Evas_Public_Data * edata,Evas_Pointer_Data * pdata,void * data)4491 _evas_canvas_event_pointer_move_event_dispatch(Evas_Public_Data *edata,
4492 Evas_Pointer_Data *pdata,
4493 void *data)
4494 {
4495 Efl_Input_Pointer_Data *ev = NULL;
4496 Efl_Input_Pointer *evt;
4497
4498 evt = efl_input_pointer_instance_get( edata->evas,
4499 (void **) &ev);
4500 if (!evt) return;
4501
4502 ev->data = (void *) data;
4503 ev->timestamp = edata->last_timestamp;
4504 ev->device = efl_ref(pdata->pointer);
4505 ev->cur.x = pdata->seat->x;
4506 ev->cur.y = pdata->seat->y;
4507
4508 _canvas_event_feed_mouse_move_internal(edata, ev);
4509
4510 efl_unref(evt);
4511 }
4512
4513 void
_evas_canvas_event_pointer_in_rect_mouse_move_feed(Evas_Public_Data * edata,Evas_Object * obj,Evas_Object_Protected_Data * obj_data,int w,int h,Eina_Bool in_objects_list,void * data)4514 _evas_canvas_event_pointer_in_rect_mouse_move_feed(Evas_Public_Data *edata,
4515 Evas_Object *obj,
4516 Evas_Object_Protected_Data *obj_data,
4517 int w, int h,
4518 Eina_Bool in_objects_list,
4519 void *data)
4520 {
4521 Evas_Pointer_Seat *pseat;
4522
4523 EINA_INLIST_FOREACH(edata->seats, pseat)
4524 {
4525 if (!pseat->pointers) continue;
4526 if (!evas_object_is_in_output_rect(obj, obj_data, pseat->x,
4527 pseat->y, w, h))
4528 continue;
4529 if ((in_objects_list && eina_list_data_find(pseat->object.in, obj)) || !in_objects_list)
4530 {
4531 Evas_Pointer_Data *pdata = EINA_INLIST_CONTAINER_GET(pseat->pointers, Evas_Pointer_Data);
4532 _evas_canvas_event_pointer_move_event_dispatch(edata, pdata, data);
4533 }
4534 }
4535 }
4536
4537 void
_evas_canvas_event_pointer_in_list_mouse_move_feed(Evas_Public_Data * edata,Eina_List * was,Evas_Object * obj,Evas_Object_Protected_Data * obj_data,int w,int h,Eina_Bool xor_rule,void * data)4538 _evas_canvas_event_pointer_in_list_mouse_move_feed(Evas_Public_Data *edata,
4539 Eina_List *was,
4540 Evas_Object *obj,
4541 Evas_Object_Protected_Data *obj_data,
4542 int w, int h,
4543 Eina_Bool xor_rule,
4544 void *data)
4545 {
4546 Evas_Pointer_Seat *pseat;
4547
4548 EINA_INLIST_FOREACH(edata->seats, pseat)
4549 {
4550 Evas_Pointer_Data *pdata, *found = NULL;
4551 Eina_List *l;
4552 int in;
4553
4554 if (!pseat->pointers) continue;
4555 in = evas_object_is_in_output_rect(obj, obj_data, pseat->x,
4556 pseat->y, w, h);
4557 EINA_LIST_FOREACH(was, l, pdata)
4558 if (pdata->seat == pseat)
4559 {
4560 found = pdata;
4561 break;
4562 }
4563
4564 if ((xor_rule && ((in && !found) || (!in && found))) ||
4565 (!xor_rule && (in || found)))
4566 {
4567 if (!pdata) pdata = EINA_INLIST_CONTAINER_GET(pseat->pointers, Evas_Pointer_Data);
4568 _evas_canvas_event_pointer_move_event_dispatch(edata, pdata, data);
4569 }
4570 }
4571 }
4572