1 #include "edje_private.h"
2 
3 static void
_edje_hold_signal_cb(void * data,const Efl_Event * event)4 _edje_hold_signal_cb(void *data, const Efl_Event *event)
5 {
6    Efl_Input_Hold *ev;
7    Edje *ed;
8    Edje_Real_Part *rp;
9 
10    ev = event->info;
11    ed = data;
12    rp = evas_object_data_get(event->object, "real_part");
13    if (!rp) return;
14    if (efl_input_hold_get(ev))
15      _edje_seat_emit(ed, efl_input_device_get(ev),
16                      "hold,on", rp->part->name);
17    else
18      _edje_seat_emit(ed, efl_input_device_get(ev),
19                      "hold,off", rp->part->name);
20 }
21 
22 static void
_edje_focus_in_signal_cb(void * data,const Efl_Event * event)23 _edje_focus_in_signal_cb(void *data, const Efl_Event *event)
24 {
25    Efl_Input_Focus *ev;
26    Edje *ed;
27    Edje_Real_Part *rp;
28 
29    ev = event->info;
30    ed = data;
31    rp = evas_object_data_get(event->object, "real_part");
32    if ((!rp) || (!ed))
33      return;
34 
35    _edje_seat_emit(ed, efl_input_device_get(ev),
36                    "focus,part,in", rp->part->name);
37 }
38 
39 static void
_edje_focus_out_signal_cb(void * data,const Efl_Event * event)40 _edje_focus_out_signal_cb(void *data, const Efl_Event *event)
41 {
42    Efl_Input_Focus *ev;
43    Edje *ed;
44    Edje_Real_Part *rp;
45 
46    ev = event->info;
47    ed = data;
48    rp = evas_object_data_get(event->object, "real_part");
49    if ((!rp) || (!ed))
50      return;
51 
52    _edje_seat_emit(ed, efl_input_device_get(ev),
53                    "focus,part,out", rp->part->name);
54 }
55 
56 static void
_edje_mouse_in_signal_cb(void * data,const Efl_Event * event)57 _edje_mouse_in_signal_cb(void *data, const Efl_Event *event)
58 {
59    Efl_Input_Pointer_Data *ev;
60    Edje *ed;
61    Edje_Real_Part *rp;
62 
63    ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
64    ed = data;
65    rp = evas_object_data_get(event->object, "real_part");
66    if (rp)
67      {
68         if (!(ev->event_flags) || !(rp->ignore_flags & ev->event_flags))
69           _edje_seat_emit(ed, ev->device, "mouse,in", rp->part->name);
70 
71         ev->event_flags |= rp->mask_flags;
72      }
73 }
74 
75 static void
_edje_mouse_out_signal_cb(void * data,const Efl_Event * event)76 _edje_mouse_out_signal_cb(void *data, const Efl_Event *event)
77 {
78    Efl_Input_Pointer_Data *ev;
79    Edje *ed;
80    Edje_Real_Part *rp;
81 
82    ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
83    ed = data;
84    rp = evas_object_data_get(event->object, "real_part");
85    if (rp)
86      {
87         if (!(ev->event_flags) || !(rp->ignore_flags & ev->event_flags))
88           _edje_seat_emit(ed, ev->device, "mouse,out", rp->part->name);
89 
90         ev->event_flags |= rp->mask_flags;
91      }
92 }
93 
94 static void
_edje_mouse_down_signal_cb(void * data,const Efl_Event * event)95 _edje_mouse_down_signal_cb(void *data, const Efl_Event *event)
96 {
97    Efl_Input_Pointer_Data *ev;
98    Edje *ed;
99    Edje_Real_Part *rp;
100    char buf[256];
101    int ignored;
102 
103    ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
104    ed = data;
105    rp = evas_object_data_get(event->object, "real_part");
106    if (!rp) return;
107 
108    ignored = rp->ignore_flags & ev->event_flags;
109 
110    _edje_ref(ed);
111    _edje_util_freeze(ed);
112 
113    if ((!ev->event_flags) || (!ignored))
114      {
115         if (ev->button_flags & EVAS_BUTTON_TRIPLE_CLICK)
116           snprintf(buf, sizeof(buf), "mouse,down,%i,triple", ev->button);
117         else if (ev->button_flags & EVAS_BUTTON_DOUBLE_CLICK)
118           snprintf(buf, sizeof(buf), "mouse,down,%i,double", ev->button);
119         else
120           snprintf(buf, sizeof(buf), "mouse,down,%i", ev->button);
121         _edje_seat_emit(ed, ev->device, buf, rp->part->name);
122      }
123 
124    if (rp->part->dragable.event_id >= 0)
125      {
126         rp = ed->table_parts[rp->part->dragable.event_id % ed->table_parts_size];
127         if (!ignored)
128           {
129              snprintf(buf, sizeof(buf), "mouse,down,%i", ev->button);
130              _edje_seat_emit(ed, ev->device, buf, rp->part->name);
131           }
132      }
133 
134    if (rp->drag)
135      {
136         if (rp->drag->down.count == 0)
137           {
138              if (rp->part->dragable.x)
139                rp->drag->down.x = ev->cur.x;
140              if (rp->part->dragable.y)
141                rp->drag->down.y = ev->cur.y;
142              rp->drag->threshold_x = EINA_FALSE;
143              rp->drag->threshold_y = EINA_FALSE;
144              rp->drag->threshold_started_x = EINA_TRUE;
145              rp->drag->threshold_started_y = EINA_TRUE;
146           }
147         rp->drag->down.count++;
148      }
149 
150    if (rp->clicked_button == 0)
151      {
152         rp->clicked_button = ev->button;
153         if (!(ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD))
154           rp->still_in = EINA_TRUE;
155      }
156 //   _edje_recalc_do(ed);
157    _edje_util_thaw(ed);
158    _edje_unref(ed);
159 
160    ev->event_flags |= rp->mask_flags;
161 }
162 
163 static void
_edje_mouse_up_signal_cb(void * data,const Efl_Event * event)164 _edje_mouse_up_signal_cb(void *data, const Efl_Event *event)
165 {
166    Efl_Input_Pointer_Data *ev;
167    Edje *ed;
168    Edje_Real_Part *rp;
169    char buf[256];
170    int ignored;
171 
172    ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
173    ed = data;
174    rp = evas_object_data_get(event->object, "real_part");
175    if (!rp) return;
176 
177    ignored = rp->ignore_flags & ev->event_flags;
178 
179    _edje_ref(ed);
180    _edje_util_freeze(ed);
181 
182    if ((!ev->event_flags) || (!ignored))
183      {
184         snprintf(buf, sizeof(buf), "mouse,up,%i", ev->button);
185         _edje_seat_emit(ed, ev->device, buf, rp->part->name);
186      }
187 
188    if (rp->part->dragable.event_id >= 0)
189      {
190         rp = ed->table_parts[rp->part->dragable.event_id % ed->table_parts_size];
191         if (!ignored)
192           {
193              snprintf(buf, sizeof(buf), "mouse,up,%i", ev->button);
194              _edje_seat_emit(ed, ev->device, buf, rp->part->name);
195           }
196      }
197 
198    if (rp->drag)
199      {
200         if (rp->drag->down.count > 0)
201           {
202              rp->drag->down.count--;
203              if (rp->drag->down.count == 0)
204                {
205                   rp->drag->threshold_started_x = EINA_FALSE;
206                   rp->drag->threshold_started_y = EINA_FALSE;
207                   rp->drag->need_reset = 1;
208                   ed->recalc_call = EINA_TRUE;
209                   ed->dirty = EINA_TRUE;
210 #ifdef EDJE_CALC_CACHE
211                   rp->invalidate = EINA_TRUE;
212 #endif
213                   if (!ignored && rp->drag->started)
214                     _edje_seat_emit(ed, ev->device, "drag,stop",
215                                     rp->part->name);
216                   rp->drag->started = EINA_FALSE;
217                   _edje_recalc_do(ed);
218                }
219           }
220      }
221 
222    if ((rp->still_in) && (rp->clicked_button == ev->button) && (!ev->event_flags))
223      {
224         snprintf(buf, sizeof(buf), "mouse,clicked,%i", ev->button);
225         _edje_seat_emit(ed, ev->device, buf, rp->part->name);
226      }
227    rp->clicked_button = 0;
228    rp->still_in = EINA_FALSE;
229 
230 //   _edje_recalc_do(ed);
231    _edje_util_thaw(ed);
232    _edje_unref(ed);
233 
234    ev->event_flags |= rp->mask_flags;
235 }
236 
237 static void
_edje_mouse_move_signal_cb(void * data,const Efl_Event * event)238 _edje_mouse_move_signal_cb(void *data, const Efl_Event *event)
239 {
240    Efl_Input_Pointer_Data *ev;
241    Edje *ed;
242    Edje_Real_Part *rp;
243    int ignored;
244 
245    ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
246    ed = data;
247    rp = evas_object_data_get(event->object, "real_part");
248    if (!rp) return;
249    if (rp->part->dragable.event_id >= 0)
250      {
251         rp = ed->table_parts[rp->part->dragable.event_id % ed->table_parts_size];
252      }
253 
254    ignored = rp->ignore_flags & ev->event_flags;
255 
256    _edje_ref(ed);
257    if ((!ev->event_flags) || (!ignored))
258      _edje_seat_emit(ed, ev->device, "mouse,move", rp->part->name);
259 
260    if (rp->still_in)
261      {
262         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
263           rp->still_in = EINA_FALSE;
264         else
265           {
266              Evas_Coord x, y, w, h;
267 
268              evas_object_geometry_get(event->object, &x, &y, &w, &h);
269              if ((ev->cur.x < x) || (ev->cur.y < y) ||
270                  (ev->cur.x >= (x + w)) || (ev->cur.y >= (y + h)))
271                {
272                   if ((ev->pressed_buttons) && ((!ev->event_flags) || (!ignored)))
273                     _edje_seat_emit(ed, ev->device, "mouse,pressed,out",
274                                     rp->part->name);
275 
276                   rp->still_in = EINA_FALSE;
277                }
278           }
279      }
280    else
281      {
282         if (!(ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD))
283           {
284              Evas_Coord x, y, w, h;
285 
286              evas_object_geometry_get(event->object, &x, &y, &w, &h);
287              if ((ev->cur.x >= x) && (ev->cur.y >= y) &&
288                  (ev->cur.x < (x + w)) && (ev->cur.y < (y + h)))
289                {
290                   if ((ev->pressed_buttons) && ((!ev->event_flags) || (!ignored)))
291                     _edje_seat_emit(ed, ev->device, "mouse,pressed,in",
292                                     rp->part->name);
293 
294                   rp->still_in = EINA_TRUE;
295                }
296           }
297      }
298    _edje_util_freeze(ed);
299    if (rp->drag)
300      {
301         if (rp->drag->down.count > 0)
302           {
303              if (rp->part->dragable.x)
304                rp->drag->tmp.x = ev->cur.x - rp->drag->down.x;
305              if (rp->part->dragable.y)
306                rp->drag->tmp.y = ev->cur.y - rp->drag->down.y;
307              ed->recalc_call = EINA_TRUE;
308              ed->dirty = EINA_TRUE;
309 #ifdef EDJE_CALC_CACHE
310              rp->invalidate = EINA_TRUE;
311 #endif
312           }
313         _edje_recalc_do(ed);
314 
315         if (rp->drag->down.count > 0)
316           {
317              FLOAT_T dx, dy;
318 
319              _edje_part_dragable_calc(ed, rp, &dx, &dy);
320              if ((NEQ(dx, rp->drag->val.x)) || (NEQ(dy, rp->drag->val.y)))
321                {
322                   rp->drag->val.x = dx;
323                   rp->drag->val.y = dy;
324                   if (!ignored)
325                     {
326                        if (!rp->drag->started)
327                          _edje_seat_emit(ed, ev->device, "drag,start",
328                                          rp->part->name);
329                        _edje_seat_emit(ed, ev->device, "drag", rp->part->name);
330                        rp->drag->started = EINA_TRUE;
331                     }
332                   ed->recalc_call = EINA_TRUE;
333                   ed->dirty = EINA_TRUE;
334 #ifdef EDJE_CALC_CACHE
335                   rp->invalidate = EINA_TRUE;
336 #endif
337                   _edje_recalc_do(ed);
338                }
339           }
340      }
341    _edje_unref(ed);
342    _edje_util_thaw(ed);
343 
344    ev->event_flags |= rp->mask_flags;
345 }
346 
347 static void
_edje_mouse_wheel_signal_cb(void * data,const Efl_Event * event)348 _edje_mouse_wheel_signal_cb(void *data, const Efl_Event *event)
349 {
350    Efl_Input_Pointer_Data *ev;
351    Edje *ed;
352    Edje_Real_Part *rp;
353    char buf[256];
354 
355    ev = efl_data_scope_get(event->info, EFL_INPUT_POINTER_CLASS);
356    ed = data;
357    rp = evas_object_data_get(event->object, "real_part");
358    if (rp)
359      {
360         if (!(ev->event_flags) || !(rp->ignore_flags & ev->event_flags))
361           {
362              snprintf(buf, sizeof(buf), "mouse,wheel,%i,%i",
363                       ev->wheel.horizontal,
364                       (ev->wheel.z < 0) ? (-1) : (1));
365              _edje_seat_emit(ed, ev->device, buf, rp->part->name);
366           }
367 
368         ev->event_flags |= rp->mask_flags;
369      }
370 }
371 
372 void
_edje_timer_cb(void * data,const Efl_Event * event EINA_UNUSED)373 _edje_timer_cb(void *data, const Efl_Event *event EINA_UNUSED)
374 {
375    double t;
376    Eina_List *l;
377    Eina_List *newl = NULL;
378    Edje *ed = data;
379 
380    t = ecore_loop_time_get();
381    _edje_ref(ed);
382 
383    _edje_block(ed);
384    _edje_util_freeze(ed);
385    if ((!ed->paused) && (!ed->delete_me))
386      {
387         Edje_Running_Program *tmp;
388 
389         ed->walking_actions = EINA_TRUE;
390         EINA_LIST_FOREACH(ed->actions, l, tmp)
391           {
392              tmp->ref++;
393              newl = eina_list_append(newl, tmp);
394           }
395         while (newl)
396           {
397              Edje_Running_Program *runp;
398 
399              runp = eina_list_data_get(newl);
400              newl = eina_list_remove(newl, eina_list_data_get(newl));
401              runp->ref--;
402              if (!runp->delete_me)
403                _edje_program_run_iterate(runp, t);
404              if (_edje_block_break(ed))
405                {
406                   EINA_LIST_FREE(newl, tmp)
407                     {
408                        tmp->ref--;
409                        if ((tmp->delete_me) && (tmp->ref == 0))
410                          {
411                             _edje_program_run_cleanup(ed, tmp);
412                             free(tmp);
413                          }
414                     }
415                   newl = NULL;
416                   goto break_prog;
417                }
418           }
419         EINA_LIST_FOREACH(ed->actions, l, tmp)
420           {
421              tmp->ref++;
422              newl = eina_list_append(newl, tmp);
423           }
424         while (newl)
425           {
426              Edje_Running_Program *runp;
427 
428              runp = eina_list_data_get(newl);
429              newl = eina_list_remove(newl, eina_list_data_get(newl));
430              runp->ref--;
431              if ((runp->delete_me) && (runp->ref == 0))
432                {
433                   _edje_program_run_cleanup(ed, runp);
434                   free(runp);
435                }
436           }
437         ed->walking_actions = EINA_FALSE;
438      }
439 break_prog:
440    _edje_unblock(ed);
441    _edje_util_thaw(ed);
442    _edje_unref(ed);
443 }
444 
445 Eina_Bool
_edje_pending_timer_cb(void * data)446 _edje_pending_timer_cb(void *data)
447 {
448    Edje_Pending_Program *pp;
449 
450    pp = data;
451    pp->edje->pending_actions = eina_list_remove(pp->edje->pending_actions, pp);
452    _edje_program_run(pp->edje, pp->program, 1, "", "", NULL);
453    pp->timer = NULL;
454    free(pp);
455    return ECORE_CALLBACK_CANCEL;
456 }
457 
458 EFL_CALLBACKS_ARRAY_DEFINE(edje_callbacks,
459                           { EFL_EVENT_HOLD, _edje_hold_signal_cb },
460                           { EFL_EVENT_POINTER_IN, _edje_mouse_in_signal_cb },
461                           { EFL_EVENT_POINTER_OUT, _edje_mouse_out_signal_cb },
462                           { EFL_EVENT_POINTER_DOWN, _edje_mouse_down_signal_cb },
463                           { EFL_EVENT_POINTER_UP, _edje_mouse_up_signal_cb },
464                           { EFL_EVENT_POINTER_MOVE, _edje_mouse_move_signal_cb },
465                           { EFL_EVENT_POINTER_WHEEL, _edje_mouse_wheel_signal_cb });
466 
467 EFL_CALLBACKS_ARRAY_DEFINE(edje_focus_callbacks,
468                           { EFL_EVENT_FOCUS_IN, _edje_focus_in_signal_cb },
469                           { EFL_EVENT_FOCUS_OUT, _edje_focus_out_signal_cb });
470 
471 void
_edje_callbacks_add(Evas_Object * obj,Edje * ed,Edje_Real_Part * rp)472 _edje_callbacks_add(Evas_Object *obj, Edje *ed, Edje_Real_Part *rp)
473 {
474    efl_event_callback_array_add(obj, edje_callbacks(), ed);
475    evas_object_data_set(obj, "real_part", rp);
476 }
477 
478 void
_edje_callbacks_del(Evas_Object * obj,Edje * ed)479 _edje_callbacks_del(Evas_Object *obj, Edje *ed)
480 {
481    efl_event_callback_array_del(obj, edje_callbacks(), ed);
482    evas_object_data_del(obj, "real_part");
483 }
484 
485 void
_edje_callbacks_focus_add(Evas_Object * obj,Edje * ed,Edje_Real_Part * rp)486 _edje_callbacks_focus_add(Evas_Object *obj, Edje *ed, Edje_Real_Part *rp)
487 {
488    efl_event_callback_array_add(obj, edje_focus_callbacks(), ed);
489    evas_object_data_set(obj, "real_part", rp);
490 }
491 
492 void
_edje_callbacks_focus_del(Evas_Object * obj,Edje * ed)493 _edje_callbacks_focus_del(Evas_Object *obj, Edje *ed)
494 {
495    efl_event_callback_array_del(obj, edje_focus_callbacks(), ed);
496    evas_object_data_del(obj, "real_part");
497 }
498 
499