efl

1
#include "edje_private.h"
2

3
static Eina_Bool _edje_var_timer_cb(void *data);
4
static Eina_Bool _edje_var_anim_cb(void *data);
5

6
static Ecore_Animator *_edje_animator = NULL;
7
static Eina_List *_edje_anim_list = NULL;
8

9
static Eina_Bool
10
_edje_var_timer_cb(void *data)
11
{
12
   Edje_Var_Timer *et;
13
   Edje *ed;
14
   Embryo_Function fn;
15

16
   et = data;
17
   if (!et) return ECORE_CALLBACK_CANCEL;
18
   ed = et->edje;
19
//      _edje_embryo_script_reset(ed);
20
   embryo_program_vm_push(ed->collection->script);
21
   _edje_embryo_globals_init(ed);
22
   embryo_parameter_cell_push(ed->collection->script, (Embryo_Cell)et->val);
23
   ed->var_pool->timers = eina_inlist_remove(ed->var_pool->timers,
24
                                             EINA_INLIST_GET(et));
25
   fn = et->func;
26
   free(et);
27
   {
28
      void *pdata;
29
      int ret;
30

31
      pdata = embryo_program_data_get(ed->collection->script);
32
      embryo_program_data_set(ed->collection->script, ed);
33
      embryo_program_max_cycle_run_set(ed->collection->script, 5000000);
34
      ret = embryo_program_run(ed->collection->script, fn);
35
      if (ret == EMBRYO_PROGRAM_FAIL)
36
        {
37
           ERR("ERROR with embryo script (timer callback). "
38
               "OBJECT NAME: '%s', "
39
               "OBJECT FILE: '%s', "
40
               "ERROR: '%s'",
41
               ed->collection->part,
42
               ed->file->path,
43
               embryo_error_string_get(embryo_program_error_get(ed->collection->script)));
44
        }
45
      else if (ret == EMBRYO_PROGRAM_TOOLONG)
46
        {
47
           ERR("ERROR with embryo script (timer callback). "
48
               "OBJECT NAME: '%s', "
49
               "OBJECT FILE: '%s', "
50
               "ERROR: 'Script exceeded maximum allowed cycle count of %i'",
51
               ed->collection->part,
52
               ed->file->path,
53
               embryo_program_max_cycle_run_get(ed->collection->script));
54
        }
55
      embryo_program_data_set(ed->collection->script, pdata);
56
      embryo_program_vm_pop(ed->collection->script);
57
      _edje_recalc(ed);
58
   }
59
   return ECORE_CALLBACK_CANCEL;
60
}
61

62
static Eina_Bool
63
_edje_var_anim_cb(void *data EINA_UNUSED)
64
{
65
   Eina_List *l, *tl = NULL;
66
   double t;
67
   const void *tmp;
68

69
   t = ecore_loop_time_get();
70
   EINA_LIST_FOREACH(_edje_anim_list, l, tmp)
71
     tl = eina_list_append(tl, tmp);
72
   while (tl)
73
     {
74
        Edje *ed;
75
        Eina_List *tl2;
76
        Edje_Var_Animator *ea;
77

78
        ed = eina_list_data_get(tl);
79
        _edje_ref(ed);
80
        _edje_block(ed);
81
        _edje_util_freeze(ed);
82
        tl = eina_list_remove(tl, ed);
83
        if (!ed->var_pool) continue;
84
        tl2 = NULL;
85
        EINA_LIST_FOREACH(ed->var_pool->animators, l, tmp)
86
          tl2 = eina_list_append(tl2, tmp);
87
        ed->var_pool->walking_list++;
88
        while (tl2)
89
          {
90
             ea = eina_list_data_get(tl2);
91
             if ((ed->var_pool) && (!ea->delete_me))
92
               {
93
                  if ((!ed->paused) && (!ed->delete_me))
94
                    {
95
                       Embryo_Function fn;
96
                       float v;
97
                       int ret;
98

99
                       v = (t - ea->start) / ea->len;
100
                       if (v > 1.0) v = 1.0;
101
//		       _edje_embryo_script_reset(ed);
102
                       embryo_program_vm_push(ed->collection->script);
103
                       _edje_embryo_globals_init(ed);
104
                       embryo_parameter_cell_push(ed->collection->script, (Embryo_Cell)ea->val);
105
                       embryo_parameter_cell_push(ed->collection->script, EMBRYO_FLOAT_TO_CELL(v));
106
                       fn = ea->func;
107
                       {
108
                          void *pdata;
109

110
                          pdata = embryo_program_data_get(ed->collection->script);
111
                          embryo_program_data_set(ed->collection->script, ed);
112
                          embryo_program_max_cycle_run_set(ed->collection->script, 5000000);
113
                          ret = embryo_program_run(ed->collection->script, fn);
114
                          if (ret == EMBRYO_PROGRAM_FAIL)
115
                            {
116
                               ERR("ERROR with embryo script (anim callback). "
117
                                   "OBJECT NAME: '%s', "
118
                                   "OBJECT FILE: '%s', "
119
                                   "ERROR: '%s'",
120
                                   ed->collection->part,
121
                                   ed->file->path,
122
                                   embryo_error_string_get(embryo_program_error_get(ed->collection->script)));
123
                            }
124
                          else if (ret == EMBRYO_PROGRAM_TOOLONG)
125
                            {
126
                               ERR("ERROR with embryo script (anim callback). "
127
                                   "OBJECT NAME: '%s', "
128
                                   "OBJECT FILE: '%s', "
129
                                   "ERROR: 'Script exceeded maximum allowed cycle count of %i'",
130
                                   ed->collection->part,
131
                                   ed->file->path,
132
                                   embryo_program_max_cycle_run_get(ed->collection->script));
133
                            }
134
                          embryo_program_data_set(ed->collection->script, pdata);
135
                          embryo_program_vm_pop(ed->collection->script);
136
                          _edje_recalc(ed);
137
                       }
138
                       if (EQ(v, FROM_INT(1))) ea->delete_me = 1;
139
                    }
140
               }
141
             tl2 = eina_list_remove(tl2, ea);
142
             if (ed->block_break)
143
               {
144
                  eina_list_free(tl2);
145
                  break;
146
               }
147
          }
148
        ed->var_pool->walking_list--;
149
        EINA_LIST_FOREACH(ed->var_pool->animators, l, ea)
150
          {
151
             if (ea->delete_me)
152
               {
153
                  l = eina_list_next(l);
154
                  ed->var_pool->animators = eina_list_remove(ed->var_pool->animators, ea);
155
                  free(ea);
156
               }
157
             else
158
               l = eina_list_next(l);
159
          }
160
        if (!ed->var_pool->animators)
161
          _edje_anim_list = eina_list_remove(_edje_anim_list, ed);
162
        _edje_unblock(ed);
163
        _edje_util_thaw(ed);
164
        _edje_unref(ed);
165
     }
166
   if (!_edje_anim_list)
167
     {
168
        if (_edje_animator)
169
          {
170
             ecore_animator_del(_edje_animator);
171
             _edje_animator = NULL;
172
          }
173
     }
174
   return !!_edje_animator;
175
}
176

177
Edje_Var *
178
_edje_var_new(void)
179
{
180
   return calloc(1, sizeof(Edje_Var));
181
}
182

183
void
184
_edje_var_free(Edje_Var *var)
185
{
186
   if (var->type == EDJE_VAR_STRING)
187
     {
188
        if (var->data.s.v)
189
          {
190
             free(var->data.s.v);
191
          }
192
     }
193
   free(var);
194
}
195

196
void
197
_edje_var_init(Edje *ed)
198
{
199
   if (!ed) return;
200
   if (!ed->collection) return;
201
   if (!ed->collection->script) return;
202
   if (ed->var_pool) return;
203
   ed->var_pool = calloc(1, sizeof(Edje_Var_Pool));
204
   if (!ed->var_pool) return;
205
   embryo_program_vm_push(ed->collection->script);
206
   ed->var_pool->size = embryo_program_variable_count_get(ed->collection->script);
207
   embryo_program_vm_pop(ed->collection->script);
208
   if (ed->var_pool->size > 0)
209
     ed->var_pool->vars = calloc(1, sizeof(Edje_Var) * ed->var_pool->size);
210
}
211

212
void
213
_edje_var_shutdown(Edje *ed)
214
{
215
   Edje_Var_Timer *et;
216

217
   if (!ed->var_pool) return;
218
   if (ed->var_pool->vars)
219
     {
220
        int i;
221

222
        for (i = 0; i < ed->var_pool->size; i++)
223
          {
224
             if (ed->var_pool->vars[i].type == EDJE_VAR_STRING)
225
               {
226
                  if (ed->var_pool->vars[i].data.s.v)
227
                    {
228
                       free(ed->var_pool->vars[i].data.s.v);
229
                       ed->var_pool->vars[i].data.s.v = NULL;
230
                    }
231
               }
232
             else if (ed->var_pool->vars[i].type == EDJE_VAR_LIST)
233
               {
234
                  while (ed->var_pool->vars[i].data.l.v)
235
                    {
236
                       _edje_var_free(eina_list_data_get(ed->var_pool->vars[i].data.l.v));
237
                       ed->var_pool->vars[i].data.l.v = eina_list_remove_list(ed->var_pool->vars[i].data.l.v, ed->var_pool->vars[i].data.l.v);
238
                    }
239
               }
240
          }
241
        free(ed->var_pool->vars);
242
     }
243
   EINA_INLIST_FREE(ed->var_pool->timers, et)
244
     {
245
        ed->var_pool->timers = eina_inlist_remove(ed->var_pool->timers,
246
                                                  EINA_INLIST_GET(et));
247
        ecore_timer_del(et->timer);
248
        free(et);
249
     }
250
   if (ed->var_pool->animators)
251
     {
252
        _edje_anim_list = eina_list_remove(_edje_anim_list, ed);
253
        if (!_edje_anim_list)
254
          {
255
             if (_edje_animator)
256
               {
257
                  ecore_animator_del(_edje_animator);
258
                  _edje_animator = NULL;
259
               }
260
          }
261
     }
262
   while (ed->var_pool->animators)
263
     {
264
        Edje_Var_Animator *ea;
265

266
        ea = eina_list_data_get(ed->var_pool->animators);
267
        ed->var_pool->animators = eina_list_remove(ed->var_pool->animators, ea);
268
        free(ea);
269
     }
270
   free(ed->var_pool);
271
   ed->var_pool = NULL;
272
}
273

274
int
275
_edje_var_string_id_get(Edje *ed, const char *string)
276
{
277
   Embryo_Cell cell, *cptr;
278

279
   if (!ed) return 0;
280
   if (!ed->collection) return 0;
281
   if (!ed->collection->script) return 0;
282
   if (!string) return 0;
283
   cell = embryo_program_variable_find(ed->collection->script, (char *)string);
284
   if (cell == EMBRYO_CELL_NONE) return 0;
285
   cptr = embryo_data_address_get(ed->collection->script, cell);
286
   if (!cptr) return 0;
287
   return (int)(*cptr);
288
}
289

290
int
291
_edje_var_var_int_get(Edje *ed EINA_UNUSED, Edje_Var *var)
292
{
293
   /* auto-cast */
294
   if (var->type == EDJE_VAR_STRING)
295
     {
296
        if (var->data.s.v)
297
          {
298
             double f;
299

300
             f = atof(var->data.s.v);
301
             free(var->data.s.v);
302
             var->data.s.v = NULL;
303
             var->data.i.v = (int)f;
304
          }
305
        var->type = EDJE_VAR_INT;
306
     }
307
   else if (var->type == EDJE_VAR_FLOAT)
308
     {
309
        int tmp = (int)(var->data.f.v);
310
        var->data.i.v = tmp;
311
        var->type = EDJE_VAR_INT;
312
     }
313
   else if (var->type == EDJE_VAR_NONE)
314
     {
315
        var->type = EDJE_VAR_INT;
316
     }
317
   else if (var->type == EDJE_VAR_LIST)
318
     {
319
        return 0;
320
     }
321
   else if (var->type == EDJE_VAR_HASH)
322
     {
323
        return 0;
324
     }
325
   return var->data.i.v;
326
}
327

328
void
329
_edje_var_var_int_set(Edje *ed EINA_UNUSED, Edje_Var *var, int v)
330
{
331
   /* auto-cast */
332
   if (var->type == EDJE_VAR_STRING)
333
     {
334
        if (var->data.s.v)
335
          {
336
             free(var->data.s.v);
337
             var->data.s.v = NULL;
338
          }
339
        var->type = EDJE_VAR_INT;
340
     }
341
   else if (var->type == EDJE_VAR_FLOAT)
342
     {
343
        var->type = EDJE_VAR_INT;
344
     }
345
   else if (var->type == EDJE_VAR_NONE)
346
     {
347
        var->type = EDJE_VAR_INT;
348
     }
349
   else if (var->type == EDJE_VAR_LIST)
350
     {
351
        return;
352
     }
353
   else if (var->type == EDJE_VAR_HASH)
354
     {
355
        return;
356
     }
357
   var->data.i.v = v;
358
}
359

360
double
361
_edje_var_var_float_get(Edje *ed EINA_UNUSED, Edje_Var *var)
362
{
363
   /* auto-cast */
364
   if (var->type == EDJE_VAR_STRING)
365
     {
366
        if (var->data.s.v)
367
          {
368
             double f;
369

370
             f = atof(var->data.s.v);
371
             free(var->data.s.v);
372
             var->data.s.v = NULL;
373
             var->data.f.v = f;
374
          }
375
        var->type = EDJE_VAR_FLOAT;
376
     }
377
   else if (var->type == EDJE_VAR_INT)
378
     {
379
        double tmp = (double)(var->data.i.v);
380
        var->data.f.v = tmp;
381
        var->type = EDJE_VAR_FLOAT;
382
     }
383
   else if (var->type == EDJE_VAR_NONE)
384
     {
385
        var->type = EDJE_VAR_FLOAT;
386
     }
387
   else if (var->type == EDJE_VAR_LIST)
388
     {
389
        return 0.0;
390
     }
391
   else if (var->type == EDJE_VAR_HASH)
392
     {
393
        return 0.0;
394
     }
395
   return var->data.f.v;
396
}
397

398
void
399
_edje_var_var_float_set(Edje *ed EINA_UNUSED, Edje_Var *var, double v)
400
{
401
   /* auto-cast */
402
   if (var->type == EDJE_VAR_STRING)
403
     {
404
        if (var->data.s.v)
405
          {
406
             free(var->data.s.v);
407
             var->data.s.v = NULL;
408
          }
409
        var->type = EDJE_VAR_FLOAT;
410
     }
411
   else if (var->type == EDJE_VAR_INT)
412
     {
413
        var->data.f.v = 0;
414
        var->type = EDJE_VAR_FLOAT;
415
     }
416
   else if (var->type == EDJE_VAR_NONE)
417
     {
418
        var->type = EDJE_VAR_FLOAT;
419
     }
420
   else if (var->type == EDJE_VAR_LIST)
421
     {
422
        return;
423
     }
424
   else if (var->type == EDJE_VAR_HASH)
425
     {
426
        return;
427
     }
428
   var->data.f.v = v;
429
}
430

431
const char *
432
_edje_var_var_str_get(Edje *ed EINA_UNUSED, Edje_Var *var)
433
{
434
   /* auto-cast */
435
   if (var->type == EDJE_VAR_INT)
436
     {
437
        char buf[64];
438

439
        snprintf(buf, sizeof(buf), "%i", var->data.i.v);
440
        var->data.s.v = strdup(buf);
441
        var->type = EDJE_VAR_STRING;
442
     }
443
   else if (var->type == EDJE_VAR_FLOAT)
444
     {
445
        char buf[64];
446

447
        snprintf(buf, sizeof(buf), "%f", var->data.f.v);
448
        var->data.s.v = strdup(buf);
449
        var->type = EDJE_VAR_STRING;
450
     }
451
   else if (var->type == EDJE_VAR_NONE)
452
     {
453
        var->data.s.v = strdup("");
454
        var->type = EDJE_VAR_STRING;
455
     }
456
   else if (var->type == EDJE_VAR_LIST)
457
     {
458
        return NULL;
459
     }
460
   else if (var->type == EDJE_VAR_HASH)
461
     {
462
        return NULL;
463
     }
464
   return var->data.s.v;
465
}
466

467
void
468
_edje_var_var_str_set(Edje *ed EINA_UNUSED, Edje_Var *var, const char *str)
469
{
470
   /* auto-cast */
471
   if (var->type == EDJE_VAR_STRING)
472
     {
473
        if (var->data.s.v)
474
          {
475
             free(var->data.s.v);
476
             var->data.s.v = NULL;
477
          }
478
     }
479
   else if (var->type == EDJE_VAR_INT)
480
     {
481
        var->type = EDJE_VAR_STRING;
482
     }
483
   else if (var->type == EDJE_VAR_FLOAT)
484
     {
485
        var->type = EDJE_VAR_STRING;
486
     }
487
   else if (var->type == EDJE_VAR_NONE)
488
     {
489
        var->type = EDJE_VAR_STRING;
490
     }
491
   else if (var->type == EDJE_VAR_LIST)
492
     {
493
        return;
494
     }
495
   else if (var->type == EDJE_VAR_HASH)
496
     {
497
        return;
498
     }
499
   var->data.s.v = strdup(str);
500
}
501

502
int
503
_edje_var_int_get(Edje *ed, int id)
504
{
505
   if (!ed) return 0;
506
   if (!ed->var_pool) return 0;
507
   id -= EDJE_VAR_MAGIC_BASE;
508
   if ((id < 0) || (id >= ed->var_pool->size)) return 0;
509
   return _edje_var_var_int_get(ed, &(ed->var_pool->vars[id]));
510
}
511

512
void
513
_edje_var_int_set(Edje *ed, int id, int v)
514
{
515
   if (!ed) return;
516
   if (!ed->var_pool) return;
517
   id -= EDJE_VAR_MAGIC_BASE;
518
   if ((id < 0) || (id >= ed->var_pool->size)) return;
519
   _edje_var_var_int_set(ed, &(ed->var_pool->vars[id]), v);
520
}
521

522
double
523
_edje_var_float_get(Edje *ed, int id)
524
{
525
   if (!ed) return 0;
526
   if (!ed->var_pool) return 0;
527
   id -= EDJE_VAR_MAGIC_BASE;
528
   if ((id < 0) || (id >= ed->var_pool->size)) return 0;
529
   return _edje_var_var_float_get(ed, &(ed->var_pool->vars[id]));
530
}
531

532
void
533
_edje_var_float_set(Edje *ed, int id, double v)
534
{
535
   if (!ed) return;
536
   if (!ed->var_pool) return;
537
   id -= EDJE_VAR_MAGIC_BASE;
538
   if ((id < 0) || (id >= ed->var_pool->size)) return;
539
   _edje_var_var_float_set(ed, &(ed->var_pool->vars[id]), v);
540
}
541

542
const char *
543
_edje_var_str_get(Edje *ed, int id)
544
{
545
   if (!ed) return NULL;
546
   if (!ed->var_pool) return NULL;
547
   id -= EDJE_VAR_MAGIC_BASE;
548
   if ((id < 0) || (id >= ed->var_pool->size)) return NULL;
549
   return _edje_var_var_str_get(ed, &(ed->var_pool->vars[id]));
550
}
551

552
void
553
_edje_var_str_set(Edje *ed, int id, const char *str)
554
{
555
   if (!ed) return;
556
   if (!ed->var_pool) return;
557
   if (!str) return;
558
   id -= EDJE_VAR_MAGIC_BASE;
559
   if ((id < 0) || (id >= ed->var_pool->size)) return;
560
   _edje_var_var_str_set(ed, &(ed->var_pool->vars[id]), str);
561
}
562

563
/* list stuff */
564

565
void
566
_edje_var_list_var_append(Edje *ed, int id, Edje_Var *var)
567
{
568
   if (!ed) return;
569
   if (!ed->var_pool) return;
570
   id -= EDJE_VAR_MAGIC_BASE;
571
   if ((id < 0) || (id >= ed->var_pool->size)) return;
572
   if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
573
   ed->var_pool->vars[id].data.l.v = eina_list_append(ed->var_pool->vars[id].data.l.v, var);
574
}
575

576
void
577
_edje_var_list_var_prepend(Edje *ed, int id, Edje_Var *var)
578
{
579
   if (!ed) return;
580
   if (!ed->var_pool) return;
581
   id -= EDJE_VAR_MAGIC_BASE;
582
   if ((id < 0) || (id >= ed->var_pool->size)) return;
583
   if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
584
   ed->var_pool->vars[id].data.l.v = eina_list_prepend(ed->var_pool->vars[id].data.l.v, var);
585
}
586

587
void
588
_edje_var_list_var_append_relative(Edje *ed, int id, Edje_Var *var, Edje_Var *relative)
589
{
590
   if (!ed) return;
591
   if (!ed->var_pool) return;
592
   id -= EDJE_VAR_MAGIC_BASE;
593
   if ((id < 0) || (id >= ed->var_pool->size)) return;
594
   if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
595
   ed->var_pool->vars[id].data.l.v = eina_list_append_relative(ed->var_pool->vars[id].data.l.v, var, relative);
596
}
597

598
void
599
_edje_var_list_var_prepend_relative(Edje *ed, int id, Edje_Var *var, Edje_Var *relative)
600
{
601
   if (!ed) return;
602
   if (!ed->var_pool) return;
603
   id -= EDJE_VAR_MAGIC_BASE;
604
   if ((id < 0) || (id >= ed->var_pool->size)) return;
605
   if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return;
606
   ed->var_pool->vars[id].data.l.v = eina_list_prepend_relative(ed->var_pool->vars[id].data.l.v, var, relative);
607
}
608

609
Edje_Var *
610
_edje_var_list_nth(Edje *ed, int id, int n)
611
{
612
   if (!ed) return NULL;
613
   if (!ed->var_pool) return NULL;
614
   id -= EDJE_VAR_MAGIC_BASE;
615
   if ((id < 0) || (id >= ed->var_pool->size)) return NULL;
616
   if (ed->var_pool->vars[id].type != EDJE_VAR_LIST) return NULL;
617
   return eina_list_nth(ed->var_pool->vars[id].data.l.v, n);
618
}
619

620
int
621
_edje_var_list_count_get(Edje *ed, int id)
622
{
623
   if (!ed) return 0;
624
   if (!ed->var_pool) return 0;
625
   id -= EDJE_VAR_MAGIC_BASE;
626
   if ((id < 0) || (id >= ed->var_pool->size)) return 0;
627
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
628
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
629
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
630
     return 0;
631
   return eina_list_count(ed->var_pool->vars[id].data.l.v);
632
}
633

634
void
635
_edje_var_list_remove_nth(Edje *ed, int id, int n)
636
{
637
   if (!ed) return;
638
   if (!ed->var_pool) return;
639
   id -= EDJE_VAR_MAGIC_BASE;
640
   if ((id < 0) || (id >= ed->var_pool->size)) return;
641
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
642
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
643
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
644
     return;
645
   {
646
      Eina_List *nth;
647

648
      nth = eina_list_nth_list(ed->var_pool->vars[id].data.l.v, n);
649
      if (nth)
650
        {
651
           _edje_var_free(eina_list_data_get(nth));
652
           ed->var_pool->vars[id].data.l.v = eina_list_remove_list(ed->var_pool->vars[id].data.l.v, nth);
653
        }
654
   }
655
}
656

657
int
658
_edje_var_list_nth_int_get(Edje *ed, int id, int n)
659
{
660
   if (!ed) return 0;
661
   if (!ed->var_pool) return 0;
662
   id -= EDJE_VAR_MAGIC_BASE;
663
   if ((id < 0) || (id >= ed->var_pool->size)) return 0;
664
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
665
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
666
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
667
     return 0;
668
   {
669
      Edje_Var *var;
670

671
      id += EDJE_VAR_MAGIC_BASE;
672
      var = _edje_var_list_nth(ed, id, n);
673
      if (!var) return 0;
674
      return _edje_var_var_int_get(ed, var);
675
   }
676
}
677

678
void
679
_edje_var_list_nth_int_set(Edje *ed, int id, int n, int v)
680
{
681
   if (!ed) return;
682
   if (!ed->var_pool) return;
683
   id -= EDJE_VAR_MAGIC_BASE;
684
   if ((id < 0) || (id >= ed->var_pool->size)) return;
685
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
686
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
687
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
688
     return;
689
   {
690
      Edje_Var *var;
691

692
      id += EDJE_VAR_MAGIC_BASE;
693
      var = _edje_var_list_nth(ed, id, n);
694
      if (!var) return;
695
      _edje_var_var_int_set(ed, var, v);
696
   }
697
}
698

699
void
700
_edje_var_list_int_append(Edje *ed, int id, int v)
701
{
702
   if (!ed) return;
703
   if (!ed->var_pool) return;
704
   id -= EDJE_VAR_MAGIC_BASE;
705
   if ((id < 0) || (id >= ed->var_pool->size)) return;
706
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
707
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
708
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
709
     return;
710
   {
711
      Edje_Var *var;
712

713
      var = _edje_var_new();
714
      if (!var) return;
715
      id += EDJE_VAR_MAGIC_BASE;
716
      _edje_var_var_int_set(ed, var, v);
717
      _edje_var_list_var_append(ed, id, var);
718
   }
719
}
720

721
void
722
_edje_var_list_int_prepend(Edje *ed, int id, int v)
723
{
724
   if (!ed) return;
725
   if (!ed->var_pool) return;
726
   id -= EDJE_VAR_MAGIC_BASE;
727
   if ((id < 0) || (id >= ed->var_pool->size)) return;
728
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
729
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
730
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
731
     return;
732
   {
733
      Edje_Var *var;
734

735
      var = _edje_var_new();
736
      if (!var) return;
737
      id += EDJE_VAR_MAGIC_BASE;
738
      _edje_var_var_int_set(ed, var, v);
739
      _edje_var_list_var_prepend(ed, id, var);
740
   }
741
}
742

743
void
744
_edje_var_list_int_insert(Edje *ed, int id, int n, int v)
745
{
746
   if (!ed) return;
747
   if (!ed->var_pool) return;
748
   id -= EDJE_VAR_MAGIC_BASE;
749
   if ((id < 0) || (id >= ed->var_pool->size)) return;
750
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
751
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
752
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
753
     return;
754
   {
755
      Edje_Var *var, *var_rel;
756

757
      var = _edje_var_new();
758
      if (!var) return;
759
      id += EDJE_VAR_MAGIC_BASE;
760
      _edje_var_var_int_set(ed, var, v);
761
      var_rel = _edje_var_list_nth(ed, id, n);
762
      if (!var_rel)
763
        _edje_var_list_var_append(ed, id, var);
764
      else
765
        _edje_var_list_var_prepend_relative(ed, id, var, var_rel);
766
   }
767
}
768

769
double
770
_edje_var_list_nth_float_get(Edje *ed, int id, int n)
771
{
772
   if (!ed) return 0;
773
   if (!ed->var_pool) return 0;
774
   id -= EDJE_VAR_MAGIC_BASE;
775
   if ((id < 0) || (id >= ed->var_pool->size)) return 0;
776
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
777
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
778
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
779
     return 0;
780
   {
781
      Edje_Var *var;
782

783
      id += EDJE_VAR_MAGIC_BASE;
784
      var = _edje_var_list_nth(ed, id, n);
785
      if (!var) return 0;
786
      return _edje_var_var_float_get(ed, var);
787
   }
788
}
789

790
void
791
_edje_var_list_nth_float_set(Edje *ed, int id, int n, double v)
792
{
793
   if (!ed) return;
794
   if (!ed->var_pool) return;
795
   id -= EDJE_VAR_MAGIC_BASE;
796
   if ((id < 0) || (id >= ed->var_pool->size)) return;
797
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
798
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
799
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
800
     return;
801
   {
802
      Edje_Var *var;
803

804
      id += EDJE_VAR_MAGIC_BASE;
805
      var = _edje_var_list_nth(ed, id, n);
806
      if (!var) return;
807
      _edje_var_var_float_set(ed, var, v);
808
   }
809
}
810

811
void
812
_edje_var_list_float_append(Edje *ed, int id, double v)
813
{
814
   if (!ed) return;
815
   if (!ed->var_pool) return;
816
   id -= EDJE_VAR_MAGIC_BASE;
817
   if ((id < 0) || (id >= ed->var_pool->size)) return;
818
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
819
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
820
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
821
     return;
822
   {
823
      Edje_Var *var;
824

825
      var = _edje_var_new();
826
      if (!var) return;
827
      id += EDJE_VAR_MAGIC_BASE;
828
      _edje_var_var_float_set(ed, var, v);
829
      _edje_var_list_var_append(ed, id, var);
830
   }
831
}
832

833
void
834
_edje_var_list_float_prepend(Edje *ed, int id, double v)
835
{
836
   if (!ed) return;
837
   if (!ed->var_pool) return;
838
   id -= EDJE_VAR_MAGIC_BASE;
839
   if ((id < 0) || (id >= ed->var_pool->size)) return;
840
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
841
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
842
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
843
     return;
844
   {
845
      Edje_Var *var;
846

847
      var = _edje_var_new();
848
      if (!var) return;
849
      id += EDJE_VAR_MAGIC_BASE;
850
      _edje_var_var_float_set(ed, var, v);
851
      _edje_var_list_var_prepend(ed, id, var);
852
   }
853
}
854

855
void
856
_edje_var_list_float_insert(Edje *ed, int id, int n, double v)
857
{
858
   if (!ed) return;
859
   if (!ed->var_pool) return;
860
   id -= EDJE_VAR_MAGIC_BASE;
861
   if ((id < 0) || (id >= ed->var_pool->size)) return;
862
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
863
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
864
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
865
     return;
866
   {
867
      Edje_Var *var, *var_rel;
868

869
      var = _edje_var_new();
870
      if (!var) return;
871
      id += EDJE_VAR_MAGIC_BASE;
872
      _edje_var_var_float_set(ed, var, v);
873
      var_rel = _edje_var_list_nth(ed, id, n);
874
      if (!var_rel)
875
        _edje_var_list_var_append(ed, id, var);
876
      else
877
        _edje_var_list_var_prepend_relative(ed, id, var, var_rel);
878
   }
879
}
880

881
const char *
882
_edje_var_list_nth_str_get(Edje *ed, int id, int n)
883
{
884
   if (!ed) return NULL;
885
   if (!ed->var_pool) return NULL;
886
   id -= EDJE_VAR_MAGIC_BASE;
887
   if ((id < 0) || (id >= ed->var_pool->size)) return NULL;
888
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
889
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
890
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
891
     return NULL;
892
   {
893
      Edje_Var *var;
894

895
      id += EDJE_VAR_MAGIC_BASE;
896
      var = _edje_var_list_nth(ed, id, n);
897
      if (!var) return NULL;
898
      return _edje_var_var_str_get(ed, var);
899
   }
900
}
901

902
void
903
_edje_var_list_nth_str_set(Edje *ed, int id, int n, const char *v)
904
{
905
   if (!ed) return;
906
   if (!ed->var_pool) return;
907
   id -= EDJE_VAR_MAGIC_BASE;
908
   if ((id < 0) || (id >= ed->var_pool->size)) return;
909
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
910
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
911
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
912
     return;
913
   {
914
      Edje_Var *var;
915

916
      id += EDJE_VAR_MAGIC_BASE;
917
      var = _edje_var_list_nth(ed, id, n);
918
      if (!var) return;
919
      _edje_var_var_str_set(ed, var, v);
920
   }
921
}
922

923
void
924
_edje_var_list_str_append(Edje *ed, int id, const char *v)
925
{
926
   if (!ed) return;
927
   if (!ed->var_pool) return;
928
   id -= EDJE_VAR_MAGIC_BASE;
929
   if ((id < 0) || (id >= ed->var_pool->size)) return;
930
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
931
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
932
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
933
     return;
934
   {
935
      Edje_Var *var;
936

937
      var = _edje_var_new();
938
      if (!var) return;
939
      id += EDJE_VAR_MAGIC_BASE;
940
      _edje_var_var_str_set(ed, var, v);
941
      _edje_var_list_var_append(ed, id, var);
942
   }
943
}
944

945
void
946
_edje_var_list_str_prepend(Edje *ed, int id, const char *v)
947
{
948
   if (!ed) return;
949
   if (!ed->var_pool) return;
950
   id -= EDJE_VAR_MAGIC_BASE;
951
   if ((id < 0) || (id >= ed->var_pool->size)) return;
952
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
953
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
954
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
955
     return;
956
   {
957
      Edje_Var *var;
958

959
      var = _edje_var_new();
960
      if (!var) return;
961
      id += EDJE_VAR_MAGIC_BASE;
962
      _edje_var_var_str_set(ed, var, v);
963
      _edje_var_list_var_prepend(ed, id, var);
964
   }
965
}
966

967
void
968
_edje_var_list_str_insert(Edje *ed, int id, int n, const char *v)
969
{
970
   if (!ed) return;
971
   if (!ed->var_pool) return;
972
   id -= EDJE_VAR_MAGIC_BASE;
973
   if ((id < 0) || (id >= ed->var_pool->size)) return;
974
   if (ed->var_pool->vars[id].type == EDJE_VAR_NONE)
975
     ed->var_pool->vars[id].type = EDJE_VAR_LIST;
976
   else if (ed->var_pool->vars[id].type != EDJE_VAR_LIST)
977
     return;
978
   {
979
      Edje_Var *var, *var_rel;
980

981
      var = _edje_var_new();
982
      if (!var) return;
983
      id += EDJE_VAR_MAGIC_BASE;
984
      _edje_var_var_str_set(ed, var, v);
985
      var_rel = _edje_var_list_nth(ed, id, n);
986
      if (!var_rel)
987
        _edje_var_list_var_append(ed, id, var);
988
      else
989
        _edje_var_list_var_prepend_relative(ed, id, var, var_rel);
990
   }
991
}
992

993
int
994
_edje_var_timer_add(Edje *ed, double in, const char *fname, int val)
995
{
996
   Edje_Var_Timer *et;
997
   Embryo_Function fn;
998

999
   if (!ed->var_pool) return 0;
1000
   fn = embryo_program_function_find(ed->collection->script, (char *)fname);
1001
   if (fn == EMBRYO_FUNCTION_NONE) return 0;
1002
   et = calloc(1, sizeof(Edje_Var_Timer));
1003
   if (!et) return 0;
1004
   et->id = ++ed->var_pool->id_count;
1005
   et->edje = ed;
1006
   et->func = fn;
1007
   et->val = val;
1008
   et->timer = ecore_timer_add(in, _edje_var_timer_cb, et);
1009
   if (!et->timer)
1010
     {
1011
        free(et);
1012
        return 0;
1013
     }
1014
   ed->var_pool->timers = eina_inlist_prepend(ed->var_pool->timers,
1015
                                              EINA_INLIST_GET(et));
1016
   return et->id;
1017
}
1018

1019
static Edje_Var_Timer *
1020
_edje_var_timer_find(Edje *ed, int id)
1021
{
1022
   Edje_Var_Timer *et;
1023

1024
   if (!ed->var_pool) return NULL;
1025

1026
   EINA_INLIST_FOREACH(ed->var_pool->timers, et)
1027
     if (et->id == id) return et;
1028

1029
   return NULL;
1030
}
1031

1032
void
1033
_edje_var_timer_del(Edje *ed, int id)
1034
{
1035
   Edje_Var_Timer *et;
1036

1037
   et = _edje_var_timer_find(ed, id);
1038
   if (!et) return;
1039

1040
   ed->var_pool->timers = eina_inlist_remove(ed->var_pool->timers,
1041
                                              EINA_INLIST_GET(et));
1042
   ecore_timer_del(et->timer);
1043
   free(et);
1044
}
1045

1046
void
1047
_edje_var_timer_reset(Edje *ed, int id)
1048
{
1049
   Edje_Var_Timer *et;
1050

1051
   et = _edje_var_timer_find(ed, id);
1052
   if (et)
1053
     ecore_timer_reset(et->timer);
1054
}
1055

1056
int
1057
_edje_var_anim_add(Edje *ed, double len, const char *fname, int val)
1058
{
1059
   Edje_Var_Animator *ea;
1060
   Embryo_Function fn;
1061

1062
   if (!ed->var_pool) return 0;
1063
   if (len <= 0.0) return 0;
1064
   fn = embryo_program_function_find(ed->collection->script, (char *)fname);
1065
   if (fn == EMBRYO_FUNCTION_NONE) return 0;
1066
   ea = calloc(1, sizeof(Edje_Var_Animator));
1067
   if (!ea) return 0;
1068
   ea->start = ecore_loop_time_get();
1069
   ea->len = len;
1070
   ea->id = ++ed->var_pool->id_count;
1071
   ea->edje = ed;
1072
   ea->func = fn;
1073
   ea->val = val;
1074
   if (!ed->var_pool->animators)
1075
     _edje_anim_list = eina_list_append(_edje_anim_list, ed);
1076
   ed->var_pool->animators = eina_list_prepend(ed->var_pool->animators, ea);
1077
   if (!_edje_animator)
1078
     _edje_animator = ecore_animator_add(_edje_var_anim_cb, NULL);
1079
   return ea->id;
1080
}
1081

1082
static Edje_Var_Animator *
1083
_edje_var_anim_find(Edje *ed, int id)
1084
{
1085
   Eina_List *l;
1086
   Edje_Var_Animator *ea;
1087

1088
   if (!ed->var_pool) return NULL;
1089

1090
   EINA_LIST_FOREACH(ed->var_pool->animators, l, ea)
1091
     if (ea->id == id) return ea;
1092

1093
   return NULL;
1094
}
1095

1096
void
1097
_edje_var_anim_del(Edje *ed, int id)
1098
{
1099
   Edje_Var_Animator *ea;
1100

1101
   ea = _edje_var_anim_find(ed, id);
1102
   if (!ea) return;
1103

1104
   if (ed->var_pool->walking_list)
1105
     {
1106
        ea->delete_me = 1;
1107
        return;
1108
     }
1109

1110
   ed->var_pool->animators = eina_list_remove(ed->var_pool->animators, ea);
1111
   free(ea);
1112

1113
   if (ed->var_pool->animators) return;
1114

1115
   _edje_anim_list = eina_list_remove(_edje_anim_list, ed);
1116
   if (!_edje_anim_list)
1117
     {
1118
        if (_edje_animator)
1119
          {
1120
             ecore_animator_del(_edje_animator);
1121
             _edje_animator = NULL;
1122
          }
1123
     }
1124
}
1125

1126