efl

1
#include "edje_private.h"
2

3
static void
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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