efl

1
#include "edje_private.h"
2

3
/*
4
 * ALREADY EXPORTED BY EMBRYO:
5
 *
6
 * enum Float_Round_Method {
7
 *    ROUND, FLOOR, CEIL, TOZERO
8
 * };
9
 * enum Float_Angle_Mode {
10
 *    RADIAN, DEGREES, GRADES
11
 * };
12
 *
13
 * numargs();
14
 * getarg(arg, index=0);
15
 * setarg(arg, index=0, value);
16
 *
17
 * Float:atof(string[]);
18
 * Float:fract(Float:value);
19
 *       round(Float:value, Float_Round_Method:method=ROUND);
20
 * Float:sqrt(Float:value);
21
 * Float:pow(Float:value, Float:exponent);
22
 * Float:log(Float:value, Float:base=10.0);
23
 * Float:sin(Float:value, Float_Angle_Mode:mode=RADIAN);
24
 * Float:cos(Float:value, Float_Angle_Mode:mode=RADIAN);
25
 * Float:tan(Float:value, Float_Angle_Mode:mode=RADIAN);
26
 * Float:abs(Float:value);
27
 *       atoi(str[]);
28
 *       fnmatch(glob[], str[]);
29
 *       strcmp(str1[], str2[]);
30
 *       strncmp(str1[], str2[]);
31
 *       strcpy(dst[], src[]);
32
 *       strncpy(dst[], src[], n);
33
 *       strlen(str[]);
34
 *       strcat(dst[], src[]);
35
 *       strncat(dst[], src[], n);
36
 *       strprep(dst[], src[]);
37
 *       strnprep(dst[], src[], n);
38
 *       strcut(dst[], str[], n, n2);
39
 *       snprintf(dst[], dstn, fmt[], ...);
40
 *       strstr(str[], ndl[]);
41
 *       strchr(str[], ch[]);
42
 *       strrchr(str[], ch[]);
43
 *       rand();
44
 * Float:randf();
45
 * Float:seconds();
46
 *       date(&year, &month, &day, &yearday, &weekday, &hr, &min, &Float:sec);
47
 *
48
 */
49

50
/* EDJE...
51
 *
52
 * implemented so far as examples:
53
 *
54
 * enum Msg_Type {
55
 *    MSG_NONE, MSG_STRING, MSG_INT, MSG_FLOAT, MSG_STRING_SET, MSG_INT_SET,
56
 *    MSG_FLOAT_SET, MSG_STRING_INT, MSG_INT_FLOAT, MSG_STRING_INT_SET,
57
 *    MSG_INT_FLOAT_SET
58
 * };
59
 *
60
 * get_int(id)
61
 * set_int(id, v)
62
 * Float:get_float (id)
63
 * set_float(id, Float:v)
64
 * get_strlen(id)
65
 * get_str(id, dst[], maxlen)
66
 * set_str(id, str[])
67
 * timer(Float:in, fname[], val)
68
 * cancel_timer(id)
69
 * reset_timer(id)
70
 * anim(Float:len, fname[], val)
71
 * cancel_anim(id)
72
 * emit(sig[], src[])
73
 * set_state(part_id, state[], Float:state_val)
74
 * get_state(part_id, dst[], maxlen, &Float:val)
75
 * set_tween_state(part_id, Float:tween, state1[], Float:state1_val, state2[], Float:state2_val)
76
 * play_sample(sample_name, speed, ...)
77
 * play_tone(tone_name, duration, ...)
78
 * play_vibration(sample_name, repeat)
79
 * run_program(program_id)
80
 * Direction:get_drag_dir(part_id)
81
 * get_drag(part_id, &Float:dx, &Float:&dy)
82
 * set_drag(part_id, Float:dx, Float:dy)
83
 * get_drag_size(part_id, &Float:dx, &Float:&dy)
84
 * set_drag_size(part_id, Float:dx, Float:dy)
85
 * set_text(part_id, str[])
86
 * get_text(part_id, dst[], maxlen)
87
 * get_min_size(w, h)
88
 * get_max_size(w, h)
89
 * set_color_class(class[], r, g, b, a)
90
 * get_color_class(class[], &r, &g, &b, &a)
91
 * set_text_class(class[], font[], Float:size)
92
 * get_text_class(class[], font[], &Float:size)
93
 * get_drag_step(part_id, &Float:dx, &Float:&dy)
94
 * set_drag_step(part_id, Float:dx, Float:dy)
95
 * get_drag_page(part_id, &Float:dx, &Float:&dy)
96
 * set_drag_page(part_id, Float:dx, Float:dy)
97
 * get_geometry(part_id, &x, &y, &w, &h)
98
 * get_mouse(&x, &y)
99
 * stop_program(program_id)
100
 * stop_programs_on(part_id)
101
 * set_min_size(w, h)
102
 * set_max_size(w, h)
103
 * send_message(Msg_Type:type, id, ...)
104
 *
105
 * count(id)
106
 * remove(id, n)
107
 *
108
 * append_int(id, v)
109
 * prepend_int(id, v)
110
 * insert_int(id, n, v)
111
 * replace_int(id, n, v)
112
 * fetch_int(id, n)
113
 *
114
 * append_str(id, str[])
115
 * prepend_str(id, str[])
116
 * insert_str(id, n, str[])
117
 * replace_str(id, n, str[])
118
 * fetch_str(id, n, dst[], maxlen)
119
 *
120
 * append_float(id, Float:v)
121
 * prepend_float(id, Float:v)
122
 * insert_float(id, n, Float:v)
123
 * replace_float(id, n, Float:v)
124
 * Float:fetch_float(id, n)
125
 *
126
 * custom_state(part_id, state[], Float:state_val = 0.0)
127
 * set_state_val(part_id, State_Param:param, ...)
128
 * get_state_val(part_id, State_Param:param, ...)
129
 *
130
 * Supported parameters:
131
 * align[Float:x, Float:y]
132
 * min[w, h]
133
 * max[w, h]
134
 * step[x,y]
135
 * aspect[Float:min, Float:max]
136
 * color[r,g,b,a]
137
 * color2[r,g,b,a]
138
 * color3[r,g,b,a]
139
 * aspect_preference
140
 * rel1[relx,rely]
141
 * rel1[part_id,part_id]
142
 * rel1[offx,offy]
143
 * rel2[relx,relyr]
144
 * rel2[part_id,part_id]
145
 * rel2[offx,offy]
146
 * image[image_id] <- all images have an Id not name in the edje
147
 * border[l,r,t,b]
148
 * fill[smooth]
149
 * fill[pos_relx,pos_rely,pos_offx,pos_offy]
150
 * fill[sz_relx,sz_rely,sz_offx,sz_offy]
151
 * color_class
152
 * text[text]
153
 * text[text_class]
154
 * text[font]
155
 * text[size]
156
 * text[style]
157
 * text[fit_x,fit_y]
158
 * text[min_x,min_y]
159
 * text[align_x,align_y]
160
 * visible[on]
161
 * map_on[on]
162
 * map_persp[part_id]
163
 * map_light[part_id]
164
 * map_rot_center[part_id]
165
 * map_rot_x[deg]
166
 * map_rot_y[deg]
167
 * map_rot_z[deg]
168
 * map_back_cull[on]
169
 * map_persp_on[on]
170
 * persp_zplane[z]
171
 * persp_focal[z]
172
 * box[layout]
173
 * box[fallback_layout]
174
 * box[Float:align_x, Float:align_y]
175
 * box[padding_x, padding_y]
176
 * box[min_x, min_y]
177
 *
178
 * ** part_id and program_id need to be able to be "found" from strings
179
 *
180
 * get_drag_count(part_id, &Float:dx, &Float:&dy)
181
 * set_drag_count(part_id, Float:dx, Float:dy)
182
 * set_drag_confine(part_id, confine_part_id)
183
 * get_size(&w, &h);
184
 * resize_request(w, h)
185
 * get_mouse_buttons()
186
 * //set_type(part_id, Type:type)
187
 * //set_effect(part_id, Effect:fx)
188
 * set_mouse_events(part_id, ev)
189
 * get_mouse_events(part_id)
190
 *
191
 * Pointer_Mode {
192
 *   POINTER_MODE_AUTOGRAB = 0,
193
 *   POINTER_MODE_NOGRAB = 1,
194
 *   POINTER_MODE_NOGREP = 2,
195
 * }
196
 *
197
 * set_pointer_mode(part_id, mode)
198
 * set_repeat_events(part_id, rep)
199
 * get_repeat_events(part_id)
200
 * set_ignore_flags(part_id, flags)
201
 * get_ignore_flags(part_id)
202
 * set_mask_flags(part_id, flags)
203
 * get_mask_flags(part_id)
204
 *
205
 * set_focus(part_id, seat_name[])
206
 * unset_focus(seat_name[])
207
 *
208
 * part_swallow(part_id, group_name)
209
 *
210
 * external_param_get_int(id, param_name[])
211
 * external_param_set_int(id, param_name[], value)
212
 * Float:external_param_get_float(id, param_name[])
213
 * external_param_set_float(id, param_name[], Float:value)
214
 * external_param_get_strlen(id, param_name[])
215
 * external_param_get_str(id, param_name[], value[], value_maxlen)
216
 * external_param_set_str(id, param_name[], value[])
217
 * external_param_get_choice_len(id, param_name[])
218
 * external_param_get_choice(id, param_name[], value[], value_maxlen)
219
 * external_param_set_choice(id, param_name[], value[])
220
 * external_param_get_bool(id, param_name[])
221
 * external_param_set_bool(id, param_name[], value)
222
 *
223
 * physics_impulse(part_id, Float:x, Float:y, Float:z)
224
 * physics_torque_impulse(part_id, Float:x, Float:y, Float:z)
225
 * physics_force(part_id, Float:x, Float:y, Float:z)
226
 * physics_torque(part_id, Float:x, Float:y, Float:z)
227
 * physics_clear_forces(part_id)
228
 * physics_get_forces(part_id, &Float:x, &Float:y, &Float:z)
229
 * physics_get_torques(part_id, &Float:x, &Float:y, &Float:z)
230
 * physics_set_velocity(part_id, Float:x, Float:y, Float:z)
231
 * physics_get_velocity(part_id, &Float:x, &Float:y, &Float:z)
232
 * physics_set_ang_velocity(part_id, Float:x, Float:y, Float:z)
233
 * physics_get_ang_velocity(part_id, &Float:x, &Float:y, &Float:z)
234
 * physics_stop(part_id)
235
 * physics_set_rotation(part_id, Float:w, Float:x, Float:y, Float:z)
236
 * physics_get_rotation(part_id, &Float:w, &Float:x, &Float:y, &Float:z)
237
 *
238
 * ADD/DEL CUSTOM OBJECTS UNDER SOLE EMBRYO SCRIPT CONTROL
239
 *
240
 */
241

242
/* get_int(id) */
243
static Embryo_Cell
244
_edje_embryo_fn_get_int(Embryo_Program *ep, Embryo_Cell *params)
245
{
246
   Edje *ed;
247

248
   CHKPARAM(1);
249
   ed = embryo_program_data_get(ep);
250
   return (Embryo_Cell)_edje_var_int_get(ed, (int)params[1]);
251
}
252

253
/* set_int(id, v) */
254
static Embryo_Cell
255
_edje_embryo_fn_set_int(Embryo_Program *ep, Embryo_Cell *params)
256
{
257
   Edje *ed;
258

259
   CHKPARAM(2);
260
   ed = embryo_program_data_get(ep);
261
   _edje_var_int_set(ed, (int)params[1], (int)params[2]);
262
   return 0;
263
}
264

265
/* get_float(id) */
266
static Embryo_Cell
267
_edje_embryo_fn_get_float(Embryo_Program *ep, Embryo_Cell *params)
268
{
269
   Edje *ed;
270
   float v;
271

272
   CHKPARAM(1);
273
   ed = embryo_program_data_get(ep);
274
   v = (float)_edje_var_float_get(ed, params[1]);
275
   return EMBRYO_FLOAT_TO_CELL(v);
276
}
277

278
/* set_float(id, v) */
279
static Embryo_Cell
280
_edje_embryo_fn_set_float(Embryo_Program *ep, Embryo_Cell *params)
281
{
282
   Edje *ed;
283
   float v;
284

285
   CHKPARAM(2);
286
   ed = embryo_program_data_get(ep);
287
   v = EMBRYO_CELL_TO_FLOAT(params[2]);
288
   _edje_var_float_set(ed, (int)params[1], (double)v);
289
   return 0;
290
}
291

292
/* get_str(id, dst[], maxlen) */
293
static Embryo_Cell
294
_edje_embryo_fn_get_str(Embryo_Program *ep, Embryo_Cell *params)
295
{
296
   Edje *ed;
297
   char *s;
298

299
   CHKPARAM(3);
300
   if (params[3] < 1) return 0;
301
   ed = embryo_program_data_get(ep);
302
   s = (char *)_edje_var_str_get(ed, (int)params[1]);
303
   if (s)
304
     {
305
        if ((int)strlen(s) < params[3])
306
          {
307
             SETSTR(s, params[2]);
308
          }
309
        else
310
          {
311
             char *ss;
312

313
             ss = alloca(strlen(s) + 1);
314
             strcpy(ss, s);
315
             ss[params[3] - 1] = 0;
316
             SETSTR(ss, params[2]);
317
          }
318
     }
319
   else
320
     {
321
        SETSTR("", params[2]);
322
     }
323
   return 0;
324
}
325

326
/* get_strlen(id) */
327
static Embryo_Cell
328
_edje_embryo_fn_get_strlen(Embryo_Program *ep, Embryo_Cell *params)
329
{
330
   Edje *ed;
331
   char *s;
332

333
   CHKPARAM(1);
334
   ed = embryo_program_data_get(ep);
335
   s = (char *)_edje_var_str_get(ed, (int)params[1]);
336
   if (s)
337
     {
338
        return strlen(s);
339
     }
340
   return 0;
341
}
342

343
/* set_str(id, str[]) */
344
static Embryo_Cell
345
_edje_embryo_fn_set_str(Embryo_Program *ep, Embryo_Cell *params)
346
{
347
   Edje *ed;
348
   char *s;
349

350
   CHKPARAM(2);
351
   ed = embryo_program_data_get(ep);
352
   GETSTR(s, params[2]);
353
   if (s)
354
     {
355
        _edje_var_str_set(ed, (int)params[1], s);
356
     }
357
   return 0;
358
}
359

360
/* count(id) */
361
static Embryo_Cell
362
_edje_embryo_fn_count(Embryo_Program *ep, Embryo_Cell *params)
363
{
364
   Edje *ed = embryo_program_data_get(ep);
365

366
   CHKPARAM(1);
367

368
   return (Embryo_Cell)_edje_var_list_count_get(ed, (int)params[1]);
369
}
370

371
/* remove(id, n) */
372
static Embryo_Cell
373
_edje_embryo_fn_remove(Embryo_Program *ep, Embryo_Cell *params)
374
{
375
   Edje *ed = embryo_program_data_get(ep);
376

377
   CHKPARAM(2);
378

379
   _edje_var_list_remove_nth(ed, (int)params[1], (int)params[2]);
380

381
   return 0;
382
}
383

384
/* append_int(id, var) */
385
static Embryo_Cell
386
_edje_embryo_fn_append_int(Embryo_Program *ep, Embryo_Cell *params)
387
{
388
   Edje *ed = embryo_program_data_get(ep);
389

390
   CHKPARAM(2);
391

392
   _edje_var_list_int_append(ed, (int)params[1], (int)params[2]);
393

394
   return 0;
395
}
396

397
/* prepend_int(id, var) */
398
static Embryo_Cell
399
_edje_embryo_fn_prepend_int(Embryo_Program *ep, Embryo_Cell *params)
400
{
401
   Edje *ed = embryo_program_data_get(ep);
402

403
   CHKPARAM(2);
404

405
   _edje_var_list_int_prepend(ed, (int)params[1], (int)params[2]);
406

407
   return 0;
408
}
409

410
/* insert_int(id, pos, var) */
411
static Embryo_Cell
412
_edje_embryo_fn_insert_int(Embryo_Program *ep, Embryo_Cell *params)
413
{
414
   Edje *ed = embryo_program_data_get(ep);
415

416
   CHKPARAM(3);
417

418
   _edje_var_list_int_insert(ed, (int)params[1], (int)params[2],
419
                             (int)params[3]);
420

421
   return 0;
422
}
423

424
/* replace_int(id, pos, var) */
425
static Embryo_Cell
426
_edje_embryo_fn_replace_int(Embryo_Program *ep, Embryo_Cell *params)
427
{
428
   Edje *ed = embryo_program_data_get(ep);
429

430
   CHKPARAM(3);
431

432
   _edje_var_list_nth_int_set(ed, (int)params[1], (int)params[2],
433
                              (int)params[3]);
434

435
   return 0;
436
}
437

438
/* fetch_int(id, pos) */
439
static Embryo_Cell
440
_edje_embryo_fn_fetch_int(Embryo_Program *ep, Embryo_Cell *params)
441
{
442
   Edje *ed = embryo_program_data_get(ep);
443

444
   CHKPARAM(2);
445

446
   return _edje_var_list_nth_int_get(ed, (int)params[1],
447
                                     (int)params[2]);
448
}
449

450
/* append_str(id, str[]) */
451
static Embryo_Cell
452
_edje_embryo_fn_append_str(Embryo_Program *ep, Embryo_Cell *params)
453
{
454
   Edje *ed = embryo_program_data_get(ep);
455
   char *s;
456

457
   CHKPARAM(2);
458

459
   GETSTR(s, params[2]);
460
   if (s)
461
     _edje_var_list_str_append(ed, (int)params[1], s);
462

463
   return 0;
464
}
465

466
/* prepend_str(id, str[]) */
467
static Embryo_Cell
468
_edje_embryo_fn_prepend_str(Embryo_Program *ep, Embryo_Cell *params)
469
{
470
   Edje *ed = embryo_program_data_get(ep);
471
   char *s;
472

473
   CHKPARAM(2);
474

475
   GETSTR(s, params[2]);
476
   if (s)
477
     _edje_var_list_str_prepend(ed, (int)params[1], s);
478

479
   return 0;
480
}
481

482
/* insert_str(id, pos, str[]) */
483
static Embryo_Cell
484
_edje_embryo_fn_insert_str(Embryo_Program *ep, Embryo_Cell *params)
485
{
486
   Edje *ed = embryo_program_data_get(ep);
487
   char *s;
488

489
   CHKPARAM(3);
490

491
   GETSTR(s, params[3]);
492
   if (s)
493
     _edje_var_list_str_insert(ed, (int)params[1], (int)params[2], s);
494

495
   return 0;
496
}
497

498
/* replace_str(id, pos, str[]) */
499
static Embryo_Cell
500
_edje_embryo_fn_replace_str(Embryo_Program *ep, Embryo_Cell *params)
501
{
502
   Edje *ed = embryo_program_data_get(ep);
503
   char *s;
504

505
   CHKPARAM(3);
506

507
   GETSTR(s, params[3]);
508
   if (s)
509
     _edje_var_list_nth_str_set(ed, (int)params[1], (int)params[2], s);
510

511
   return 0;
512
}
513

514
/* fetch_str(id, pos, dst[], maxlen) */
515
static Embryo_Cell
516
_edje_embryo_fn_fetch_str(Embryo_Program *ep, Embryo_Cell *params)
517
{
518
   Edje *ed = embryo_program_data_get(ep);
519
   char *s;
520

521
   CHKPARAM(4);
522

523
   s = (char *)_edje_var_list_nth_str_get(ed, (int)params[1],
524
                                          (int)params[2]);
525
   if (s)
526
     {
527
        if ((int)strlen(s) < params[4])
528
          {
529
             SETSTR(s, params[3]);
530
          }
531
        else
532
          {
533
             char *ss;
534

535
             ss = alloca(strlen(s) + 1);
536
             strcpy(ss, s);
537
             ss[params[4] - 1] = 0;
538
             SETSTR(ss, params[3]);
539
          }
540
     }
541
   else
542
     {
543
        SETSTR("", params[3]);
544
     }
545

546
   return 0;
547
}
548

549
/* append_float(id, Float:f) */
550
static Embryo_Cell
551
_edje_embryo_fn_append_float(Embryo_Program *ep, Embryo_Cell *params)
552
{
553
   Edje *ed = embryo_program_data_get(ep);
554
   float f;
555

556
   CHKPARAM(2);
557

558
   f = EMBRYO_CELL_TO_FLOAT(params[2]);
559
   _edje_var_list_float_append(ed, (int)params[1], f);
560

561
   return 0;
562
}
563

564
/* prepend_float(id, Float:f) */
565
static Embryo_Cell
566
_edje_embryo_fn_prepend_float(Embryo_Program *ep, Embryo_Cell *params)
567
{
568
   Edje *ed = embryo_program_data_get(ep);
569
   float f;
570

571
   CHKPARAM(2);
572

573
   f = EMBRYO_CELL_TO_FLOAT(params[2]);
574
   _edje_var_list_float_prepend(ed, (int)params[1], f);
575

576
   return 0;
577
}
578

579
/* insert_float(id, pos, Float:f) */
580
static Embryo_Cell
581
_edje_embryo_fn_insert_float(Embryo_Program *ep, Embryo_Cell *params)
582
{
583
   Edje *ed = embryo_program_data_get(ep);
584
   float f;
585

586
   CHKPARAM(3);
587

588
   f = EMBRYO_CELL_TO_FLOAT(params[3]);
589
   _edje_var_list_float_insert(ed, (int)params[1], (int)params[2], f);
590

591
   return 0;
592
}
593

594
/* replace_float(id, pos, Float:f) */
595
static Embryo_Cell
596
_edje_embryo_fn_replace_float(Embryo_Program *ep, Embryo_Cell *params)
597
{
598
   Edje *ed = embryo_program_data_get(ep);
599

600
   CHKPARAM(3);
601

602
   _edje_var_list_nth_float_set(ed, (int)params[1], (int)params[2],
603
                                EMBRYO_CELL_TO_FLOAT(params[3]));
604

605
   return 0;
606
}
607

608
/* Float:fetch_float(id, pos) */
609
static Embryo_Cell
610
_edje_embryo_fn_fetch_float(Embryo_Program *ep, Embryo_Cell *params)
611
{
612
   Edje *ed = embryo_program_data_get(ep);
613
   float f;
614

615
   CHKPARAM(2);
616

617
   f = _edje_var_list_nth_float_get(ed, (int)params[1], (int)params[2]);
618

619
   return EMBRYO_FLOAT_TO_CELL(f);
620
}
621

622
/* timer(Float:in, fname[], val) */
623
static Embryo_Cell
624
_edje_embryo_fn_timer(Embryo_Program *ep, Embryo_Cell *params)
625
{
626
   Edje *ed;
627
   char *fname = NULL;
628
   float f;
629
   double in;
630
   int val;
631

632
   CHKPARAM(3);
633
   ed = embryo_program_data_get(ep);
634
   GETSTR(fname, params[2]);
635
   if ((!fname)) return 0;
636
   f = EMBRYO_CELL_TO_FLOAT(params[1]);
637
   in = (double)f;
638
   val = params[3];
639
   return _edje_var_timer_add(ed, in, fname, val);
640
}
641

642
/* cancel_timer(id) */
643
static Embryo_Cell
644
_edje_embryo_fn_cancel_timer(Embryo_Program *ep, Embryo_Cell *params)
645
{
646
   Edje *ed;
647
   int id;
648

649
   CHKPARAM(1);
650
   ed = embryo_program_data_get(ep);
651
   id = params[1];
652
   if (id <= 0) return 0;
653
   _edje_var_timer_del(ed, id);
654
   return 0;
655
}
656

657
/* reset_timer(id) */
658
static Embryo_Cell
659
_edje_embryo_fn_reset_timer(Embryo_Program *ep, Embryo_Cell *params)
660
{
661
   Edje *ed;
662
   int id;
663

664
   CHKPARAM(1);
665
   ed = embryo_program_data_get(ep);
666
   id = params[1];
667
   if (id <= 0) return 0;
668
   _edje_var_timer_reset(ed, id);
669
   return 0;
670
}
671

672
/* anim(Float:len, fname[], val) */
673
static Embryo_Cell
674
_edje_embryo_fn_anim(Embryo_Program *ep, Embryo_Cell *params)
675
{
676
   Edje *ed;
677
   char *fname = NULL;
678
   float f;
679
   double len;
680
   int val;
681

682
   CHKPARAM(3);
683
   ed = embryo_program_data_get(ep);
684
   GETSTR(fname, params[2]);
685
   if ((!fname)) return 0;
686
   f = EMBRYO_CELL_TO_FLOAT(params[1]);
687
   len = (double)f;
688
   val = params[3];
689
   return _edje_var_anim_add(ed, len, fname, val);
690
}
691

692
/* cancel_anim(id) */
693
static Embryo_Cell
694
_edje_embryo_fn_cancel_anim(Embryo_Program *ep, Embryo_Cell *params)
695
{
696
   Edje *ed;
697
   int id;
698

699
   CHKPARAM(1);
700
   ed = embryo_program_data_get(ep);
701
   id = params[1];
702
   if (id <= 0) return 0;
703
   _edje_var_anim_del(ed, id);
704
   return 0;
705
}
706

707
/* get_anim_pos_map(Float:pos, Tween_Mode_Type:tween, Float:v1, Float:v2, &Float:ret) */
708
static Embryo_Cell
709
_edje_embryo_fn_get_anim_pos_map(Embryo_Program *ep, Embryo_Cell *params)
710
{
711
   double pos;
712
   Ecore_Pos_Map tween;
713
   double v1, v2;
714

715
   CHKPARAM(5);
716
   pos = EMBRYO_CELL_TO_FLOAT(params[1]);
717
   tween = params[2];
718
   v1 = EMBRYO_CELL_TO_FLOAT(params[3]);
719
   v2 = EMBRYO_CELL_TO_FLOAT(params[4]);
720

721
   switch (tween)
722
     {
723
      case ECORE_POS_MAP_LINEAR:
724
      case ECORE_POS_MAP_ACCELERATE:
725
      case ECORE_POS_MAP_DECELERATE:
726
      case ECORE_POS_MAP_SINUSOIDAL:
727
        pos = ecore_animator_pos_map(pos, tween, 0, 0);
728
        break;
729

730
      case ECORE_POS_MAP_ACCELERATE_FACTOR:
731
        pos = ecore_animator_pos_map(pos, ECORE_POS_MAP_ACCELERATE_FACTOR,
732
                                     v1, 0);
733
        break;
734

735
      case ECORE_POS_MAP_DECELERATE_FACTOR:
736
        pos = ecore_animator_pos_map(pos, ECORE_POS_MAP_DECELERATE_FACTOR,
737
                                     v1, 0);
738
        break;
739

740
      case ECORE_POS_MAP_SINUSOIDAL_FACTOR:
741
        pos = ecore_animator_pos_map(pos, ECORE_POS_MAP_SINUSOIDAL_FACTOR,
742
                                     v1, 0);
743
        break;
744

745
      case ECORE_POS_MAP_DIVISOR_INTERP:
746
      case ECORE_POS_MAP_BOUNCE:
747
      case ECORE_POS_MAP_SPRING:
748
        pos = ecore_animator_pos_map(pos, tween, v1, v2);
749
        break;
750

751
      default:
752
        break;
753
     }
754

755
   SETFLOAT(pos, params[5]);
756

757
   return 0;
758
}
759

760
/* set_min_size(Float:w, Float:h) */
761
static Embryo_Cell
762
_edje_embryo_fn_set_min_size(Embryo_Program *ep, Embryo_Cell *params)
763
{
764
   Edje *ed;
765
   float f = 0.0;
766
   double w = 0.0, h = 0.0;
767

768
   CHKPARAM(2);
769
   ed = embryo_program_data_get(ep);
770
   f = EMBRYO_CELL_TO_FLOAT(params[1]);
771
   w = (double)f;
772
   f = EMBRYO_CELL_TO_FLOAT(params[2]);
773
   h = (double)f;
774

775
   if (w < 0.0) w = 0.0;
776
   if (h < 0.0) h = 0.0;
777
   ed->collection->prop.min.w = w;
778
   ed->collection->prop.min.h = h;
779
   ed->recalc_call = EINA_TRUE;
780
   ed->dirty = EINA_TRUE;
781
#ifdef EDJE_CALC_CACHE
782
   ed->all_part_change = EINA_TRUE;
783
#endif
784
   _edje_recalc(ed);
785
   return 0;
786
}
787

788
/* set_max_size(Float:w, Float:h) */
789
static Embryo_Cell
790
_edje_embryo_fn_set_max_size(Embryo_Program *ep, Embryo_Cell *params)
791
{
792
   Edje *ed;
793
   float f = 0.0;
794
   double w = 0.0, h = 0.0;
795

796
   CHKPARAM(2);
797
   ed = embryo_program_data_get(ep);
798
   f = EMBRYO_CELL_TO_FLOAT(params[1]);
799
   w = (double)f;
800
   f = EMBRYO_CELL_TO_FLOAT(params[2]);
801
   h = (double)f;
802

803
   if (w < 0.0) w = 0.0;
804
   if (h < 0.0) h = 0.0;
805
   ed->collection->prop.max.w = w;
806
   ed->collection->prop.max.h = h;
807
   ed->recalc_call = EINA_TRUE;
808
   ed->dirty = EINA_TRUE;
809
#ifdef EDJE_CALC_CACHE
810
   ed->all_part_change = EINA_TRUE;
811
#endif
812
   _edje_recalc(ed);
813

814
   return 0;
815
}
816

817
/* stop_program(program_id) */
818
static Embryo_Cell
819
_edje_embryo_fn_stop_program(Embryo_Program *ep, Embryo_Cell *params)
820
{
821
   Edje *ed;
822
   int program_id = 0;
823
   Edje_Running_Program *runp;
824
   Edje_Pending_Program *pp;
825
   Eina_List *l, *ll;
826

827
   CHKPARAM(1);
828
   ed = embryo_program_data_get(ep);
829
   program_id = params[1];
830
   if (program_id < 0) return 0;
831

832
   ed->walking_actions = EINA_TRUE;
833

834
   EINA_LIST_FOREACH(ed->actions, l, runp)
835
     if (program_id == runp->program->id)
836
       _edje_program_end(ed, runp);
837
   EINA_LIST_FOREACH_SAFE(ed->pending_actions, l, ll, pp)
838
     if (program_id == pp->program->id)
839
       {
840
          ed->pending_actions = eina_list_remove_list(ed->pending_actions, l);
841
          ecore_timer_del(pp->timer);
842
          free(pp);
843
       }
844

845
   ed->walking_actions = EINA_FALSE;
846

847
   return 0;
848
}
849

850
/* stop_programs_on(part_id) */
851
static Embryo_Cell
852
_edje_embryo_fn_stop_programs_on(Embryo_Program *ep, Embryo_Cell *params)
853
{
854
   Edje *ed;
855

856
   int part_id = 0;
857
   Edje_Real_Part *rp;
858

859
   CHKPARAM(1);
860
   ed = embryo_program_data_get(ep);
861
   part_id = params[1];
862
   if (part_id < 0) return 0;
863
   rp = ed->table_parts[part_id % ed->table_parts_size];
864
   if (rp)
865
     {
866
        Eina_List *l, *ll, *lll;
867
        Edje_Pending_Program *pp;
868
        Edje_Program_Target *pt;
869
        /* there is only ever 1 program acting on a part at any time */
870
        if (rp->program) _edje_program_end(ed, rp->program);
871
        EINA_LIST_FOREACH_SAFE(ed->pending_actions, l, ll, pp)
872
          {
873
             EINA_LIST_FOREACH(pp->program->targets, lll, pt)
874
               if (pt->id == part_id)
875
                 {
876
                    ed->pending_actions = eina_list_remove_list(ed->pending_actions, l);
877
                    ecore_timer_del(pp->timer);
878
                    free(pp);
879
                    break;
880
                 }
881
          }
882
     }
883
   return 0;
884
}
885

886
/* get_mouse(&x, &y) */
887
static Embryo_Cell
888
_edje_embryo_fn_get_mouse(Embryo_Program *ep, Embryo_Cell *params)
889
{
890
   Edje *ed;
891
   Evas_Coord x = 0, y = 0;
892

893
   CHKPARAM(2);
894
   ed = embryo_program_data_get(ep);
895
   evas_pointer_canvas_xy_get(ed->base.evas, &x, &y);
896
   x -= ed->x;
897
   y -= ed->y;
898
   SETINT((int)x, params[1]);
899
   SETINT((int)y, params[2]);
900
   return 0;
901
}
902

903
/* get_mouse_buttons() */
904
static Embryo_Cell
905
_edje_embryo_fn_get_mouse_buttons(Embryo_Program *ep, Embryo_Cell *params)
906
{
907
   Edje *ed;
908

909
   CHKPARAM(0);
910
   ed = embryo_program_data_get(ep);
911
   return evas_pointer_button_down_mask_get(ed->base.evas);
912
}
913

914
/* emit(sig[], src[]) */
915
static Embryo_Cell
916
_edje_embryo_fn_emit(Embryo_Program *ep, Embryo_Cell *params)
917
{
918
   Edje *ed;
919
   char *sig = NULL, *src = NULL;
920

921
   CHKPARAM(2);
922
   ed = embryo_program_data_get(ep);
923
   GETSTR(sig, params[1]);
924
   GETSTR(src, params[2]);
925
   if ((!sig) || (!src)) return 0;
926
   _edje_emit(ed, sig, src);
927
   return 0;
928
}
929

930
/* get_part_id(part[]) */
931
static Embryo_Cell
932
_edje_embryo_fn_get_part_id(Embryo_Program *ep, Embryo_Cell *params)
933
{
934
   Edje *ed;
935
   Edje_Part_Collection *col;
936
   Edje_Part **part;
937
   char *p;
938
   unsigned int i;
939

940
   CHKPARAM(1);
941
   ed = embryo_program_data_get(ep);
942
   GETSTR(p, params[1]);
943
   if (!p) return -1;
944
   col = ed->collection;
945
   if (!col) return -1;
946
   part = col->parts;
947
   for (i = 0; i < col->parts_count; i++, part++)
948
     {
949
        if (!(*part)->name) continue;
950
        if (!strcmp((*part)->name, p)) return (*part)->id;
951
     }
952
   return -1;
953
}
954

955
/* get_image_id(img[]) */
956
static Embryo_Cell
957
_edje_embryo_fn_get_image_id(Embryo_Program *ep, Embryo_Cell *params)
958
{
959
   Edje *ed;
960
   Edje_File *file;
961
   Edje_Image_Directory *dir;
962
   Edje_Image_Directory_Entry *dirent;
963
   char *p;
964
   unsigned int i;
965

966
   CHKPARAM(1);
967
   ed = embryo_program_data_get(ep);
968
   GETSTR(p, params[1]);
969
   if (!p) return -1;
970
   file = ed->file;
971
   if (!file) return -1;
972
   dir = file->image_dir;
973
   dirent = dir->entries;
974
   for (i = 0; i < dir->entries_count; i++, dirent++)
975
     {
976
        if (!dirent->entry) continue;
977
        if (!strcmp(dirent->entry, p)) return dirent->id;
978
     }
979
   return -1;
980
}
981

982
/* get_program_id(program[]) */
983
static Embryo_Cell
984
_edje_embryo_fn_get_program_id(Embryo_Program *ep, Embryo_Cell *params)
985
{
986
   Edje *ed;
987
   Edje_Program **prog;
988
   char *p;
989
   int i;
990

991
   CHKPARAM(1);
992
   ed = embryo_program_data_get(ep);
993
   GETSTR(p, params[1]);
994
   if (!p) return -1;
995
   prog = ed->collection->patterns.table_programs;
996
   if (!prog) return -1;
997
   for (i = 0; i < ed->collection->patterns.table_programs_size; i++, prog++)
998
     {
999
        if (!(*prog)->name) continue;
1000
        if (!strcmp((*prog)->name, p)) return (*prog)->id;
1001
     }
1002
   return -1;
1003
}
1004

1005
static Embryo_Cell
1006
_edje_embryo_fn_play_sample(Embryo_Program *ep, Embryo_Cell *params)
1007
{
1008
   Edje *ed;
1009
   char *sample_name = NULL;
1010
   float speed = 1.0;
1011
   int channel = 0;
1012

1013
   if (params[0] < (int)(sizeof(Embryo_Cell) * 2))
1014
     return 0;
1015
   ed = embryo_program_data_get(ep);
1016
   GETSTR(sample_name, params[1]);
1017
   if ((!sample_name)) return 0;
1018
   speed = EMBRYO_CELL_TO_FLOAT(params[2]);
1019
   if (params[0] == (int)(sizeof(Embryo_Cell) * 3))
1020
     GETINT(channel, params[3]);
1021
   _edje_multisense_internal_sound_sample_play(ed, sample_name,
1022
                                               (double)speed, channel);
1023
   return 0;
1024
}
1025

1026
static Embryo_Cell
1027
_edje_embryo_fn_play_tone(Embryo_Program *ep, Embryo_Cell *params)
1028
{
1029
   Edje *ed;
1030
   char *tone_name = NULL;
1031
   float duration = 0.1;
1032
   int channel = 0;
1033

1034
   if (params[0] < (int)(sizeof(Embryo_Cell) * 2))
1035
     return 0;
1036
   ed = embryo_program_data_get(ep);
1037
   GETSTR(tone_name, params[1]);
1038
   if ((!tone_name)) return 0;
1039
   duration = EMBRYO_CELL_TO_FLOAT(params[2]);
1040
   if (params[0] == (int)(sizeof(Embryo_Cell) * 3))
1041
     GETINT(channel, params[3]);
1042
   _edje_multisense_internal_sound_tone_play(ed, tone_name,
1043
                                             (double)duration, channel);
1044
   return 0;
1045
}
1046

1047
static Embryo_Cell
1048
_edje_embryo_fn_play_vibration(Embryo_Program *ep, Embryo_Cell *params)
1049
{
1050
   Edje *ed;
1051
   char *sample_name = NULL;
1052
   int repeat = 10;
1053

1054
   if (params[0] < (int)(sizeof(Embryo_Cell) * 2)) return 0;
1055
   ed = embryo_program_data_get(ep);
1056
   GETSTR(sample_name, params[1]);
1057
   if ((!sample_name)) return 0;
1058

1059
   if (params[0] == (int)(sizeof(Embryo_Cell) * 2))
1060
     GETINT(repeat, params[2]);
1061

1062
   _edje_multisense_internal_vibration_sample_play(ed, sample_name,
1063
                                                   repeat);
1064
   return 0;
1065
}
1066

1067
/* set_state(part_id, state[], Float:state_val) */
1068
static Embryo_Cell
1069
_edje_embryo_fn_set_state(Embryo_Program *ep, Embryo_Cell *params)
1070
{
1071
   Edje *ed;
1072
   char *state = NULL;
1073
   int part_id = 0;
1074
   float f = 0.0;
1075
   double value = 0.0;
1076
   Edje_Real_Part *rp;
1077

1078
   if (!(HASNPARAMS(2) || HASNPARAMS(3))) return -1;
1079

1080
   ed = embryo_program_data_get(ep);
1081
   GETSTR(state, params[2]);
1082
   if ((!state)) return 0;
1083
   part_id = params[1];
1084
   if (part_id < 0) return 0;
1085
   if (HASNPARAMS(3))
1086
     {
1087
        f = EMBRYO_CELL_TO_FLOAT(params[3]);
1088
        value = (double)f;
1089
     }
1090
   else
1091
     value = 0.0;
1092
   rp = ed->table_parts[part_id % ed->table_parts_size];
1093
   if (rp)
1094
     {
1095
        if (rp->program) _edje_program_end(ed, rp->program);
1096
        _edje_part_description_apply(ed, rp, state, value, NULL, 0.0);
1097
        _edje_part_pos_set(ed, rp, EDJE_TWEEN_MODE_LINEAR, ZERO, ZERO, ZERO,
1098
                           ZERO, ZERO);
1099
        _edje_recalc(ed);
1100
     }
1101
   return 0;
1102
}
1103

1104
static Embryo_Cell
1105
_edje_embryo_fn_set_state_anim(Embryo_Program *ep, Embryo_Cell *params)
1106
{
1107
   Edje *ed;
1108
   char *state = NULL;
1109
   int part_id = 0;
1110
   float f = 0.0;
1111
   double value = 0.0;
1112
   char *tmp = NULL;
1113
   Edje_Real_Part *rp;
1114
   int anim_type = 0;
1115
   double tween = 0.0, v1 = 0.0, v2 = 0.0, v3 = 0.0, v4 = 0.0;
1116

1117
   if (HASNPARAMS(4)) return -1;
1118

1119
   ed = embryo_program_data_get(ep);
1120
   GETSTR(state, params[2]);
1121
   if ((!state)) return 0;
1122
   part_id = params[1];
1123
   if (part_id < 0) return 0;
1124
   f = EMBRYO_CELL_TO_FLOAT(params[3]);
1125
   value = (double)f;
1126
   anim_type = params[4];
1127
   f = EMBRYO_CELL_TO_FLOAT(params[5]);
1128
   tween = (double)f;
1129
   if ((anim_type >= EDJE_TWEEN_MODE_LINEAR) &&
1130
       (anim_type <= EDJE_TWEEN_MODE_DECELERATE))
1131
     {
1132
        if (HASNPARAMS(6))
1133
          {
1134
             GETSTR(tmp, params[6]);
1135
             if ((tmp) && (!strcmp(tmp, "CURRENT")))
1136
               anim_type |= EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
1137
          }
1138
     }
1139
   else if ((anim_type >= EDJE_TWEEN_MODE_ACCELERATE_FACTOR) &&
1140
            (anim_type <= EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR))
1141
     {
1142
        if (HASNPARAMS(7))
1143
          {
1144
             GETSTR(tmp, params[7]);
1145
             if ((tmp) && (!strcmp(tmp, "CURRENT")))
1146
               anim_type |= EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
1147
          }
1148
        else if (HASNPARAMS(5))
1149
          {
1150
             ERR("parse error. Need 6th parameter to set factor");
1151
             return -1;
1152
          }
1153
        GETFLOAT_T(v1, params[6]);
1154
     }
1155
   else if ((anim_type >= EDJE_TWEEN_MODE_DIVISOR_INTERP) &&
1156
            (anim_type <= EDJE_TWEEN_MODE_SPRING))
1157
     {
1158
        if (HASNPARAMS(8))
1159
          {
1160
             GETSTR(tmp, params[8]);
1161
             if ((tmp) && (!strcmp(tmp, "CURRENT")))
1162
               anim_type |= EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
1163
          }
1164
        else if (HASNPARAMS(5))
1165
          {
1166
             ERR("parse error.Need 6th and 7th parameters to set factor and counts");
1167
             return -1;
1168
          }
1169
        GETFLOAT_T(v1, params[6]);
1170
        GETFLOAT_T(v2, params[7]);
1171
     }
1172
   else if (anim_type == EDJE_TWEEN_MODE_CUBIC_BEZIER)
1173
     {
1174
        if (HASNPARAMS(12))
1175
          {
1176
             GETSTR(tmp, params[8]);
1177
             if ((tmp) && (!strcmp(tmp, "CURRENT")))
1178
               anim_type |= EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
1179
          }
1180
        else if (HASNPARAMS(5))
1181
          {
1182
             ERR("parse error.Need 6th, 7th, 9th and 10th parameters to set x1, y1, x2 and y2");
1183
             return -1;
1184
          }
1185
        if (HASNPARAMS(10))
1186
          {
1187
             GETFLOAT_T(v1, params[6]);
1188
             GETFLOAT_T(v2, params[7]);
1189
             GETFLOAT_T(v3, params[9]);
1190
             GETFLOAT_T(v4, params[10]);
1191
          }
1192
        else
1193
          {
1194
             GETFLOAT_T(v1, params[6]);
1195
             GETFLOAT_T(v2, params[7]);
1196
             GETFLOAT_T(v3, params[8]);
1197
             GETFLOAT_T(v4, params[9]);
1198
          }
1199
     }
1200
   rp = ed->table_parts[part_id % ed->table_parts_size];
1201
   if (!rp) return 0;
1202
   _edje_part_description_apply(ed, rp, NULL, 0.0, state, value);
1203
   _edje_part_pos_set(ed, rp, anim_type, FROM_DOUBLE(tween), v1, v2,
1204
                      v3, v4);
1205
   _edje_recalc(ed);
1206
   return 0;
1207
}
1208

1209
/* get_state(part_id, dst[], maxlen, &Float:val) */
1210
static Embryo_Cell
1211
_edje_embryo_fn_get_state(Embryo_Program *ep, Embryo_Cell *params)
1212
{
1213
   Edje *ed;
1214
   int part_id = 0;
1215
   Edje_Real_Part *rp;
1216
   const char *s;
1217

1218
   CHKPARAM(4);
1219
   ed = embryo_program_data_get(ep);
1220
   part_id = params[1];
1221
   if (part_id < 0) return 0;
1222
   rp = ed->table_parts[part_id % ed->table_parts_size];
1223
   if (rp->chosen_description)
1224
     {
1225
        SETFLOAT(rp->chosen_description->state.value, params[4]);
1226
        s = rp->chosen_description->state.name;
1227
        if (s)
1228
          {
1229
             if ((int)strlen(s) < params[3])
1230
               {
1231
                  SETSTR(s, params[2]);
1232
               }
1233
             else
1234
               {
1235
                  char *ss;
1236

1237
                  ss = alloca(strlen(s) + 1);
1238
                  strcpy(ss, s);
1239
                  ss[params[3] - 1] = 0;
1240
                  SETSTR(ss, params[2]);
1241
               }
1242
          }
1243
        else
1244
          {
1245
             SETSTR("", params[2]);
1246
          }
1247
     }
1248
   else
1249
     {
1250
        SETFLOAT(0.0, params[4]);
1251
        SETSTR("", params[2]);
1252
     }
1253
   return 0;
1254
}
1255

1256
/* set_tween_state(part_id, Float:tween, state1[], Float:state1_val, state2[], Float:state2_val) */
1257
static Embryo_Cell
1258
_edje_embryo_fn_set_tween_state(Embryo_Program *ep, Embryo_Cell *params)
1259
{
1260
   Edje *ed;
1261
   char *state1 = NULL, *state2 = NULL;
1262
   int part_id = 0;
1263
   float f = 0.0;
1264
   double tween = 0.0, value1 = 0.0, value2 = 0.0;
1265
   Edje_Real_Part *rp;
1266

1267
   CHKPARAM(6);
1268
   ed = embryo_program_data_get(ep);
1269
   GETSTR(state1, params[3]);
1270
   GETSTR(state2, params[5]);
1271
   if ((!state1) || (!state2)) return 0;
1272
   part_id = params[1];
1273
   if (part_id < 0) return 0;
1274
   f = EMBRYO_CELL_TO_FLOAT(params[2]);
1275
   tween = (double)f;
1276
   f = EMBRYO_CELL_TO_FLOAT(params[4]);
1277
   value1 = (double)f;
1278
   f = EMBRYO_CELL_TO_FLOAT(params[6]);
1279
   value2 = (double)f;
1280
   rp = ed->table_parts[part_id % ed->table_parts_size];
1281
   if (rp)
1282
     {
1283
        if (rp->program) _edje_program_end(ed, rp->program);
1284
        _edje_part_description_apply(ed, rp, state1, value1, state2, value2);
1285
        _edje_part_pos_set(ed, rp, EDJE_TWEEN_MODE_LINEAR, FROM_DOUBLE(tween),
1286
                           ZERO, ZERO, ZERO, ZERO);
1287
        _edje_recalc(ed);
1288
     }
1289
   return 0;
1290
}
1291

1292
static Embryo_Cell
1293
_edje_embryo_fn_set_tween_state_anim(Embryo_Program *ep, Embryo_Cell *params)
1294
{
1295
   Edje *ed;
1296
   char *tmp = NULL;
1297
   char *state1 = NULL, *state2 = NULL;
1298
   int part_id = 0;
1299
   int anim_type = 0;
1300
   float f = 0.0;
1301
   double tween = 0.0, value1 = 0.0, value2 = 0.0, v1 = 0.0, v2 = 0.0, v3 = 0.0, v4 = 0.0;
1302
   Edje_Real_Part *rp;
1303

1304
   if (HASNPARAMS(6)) return -1;
1305
   ed = embryo_program_data_get(ep);
1306
   GETSTR(state1, params[2]);
1307
   GETSTR(state2, params[4]);
1308
   if ((!state1) || (!state2)) return 0;
1309
   part_id = params[1];
1310
   anim_type = params[6];
1311
   if (part_id < 0) return 0;
1312
   f = EMBRYO_CELL_TO_FLOAT(params[3]);
1313
   value1 = (double)f;
1314
   f = EMBRYO_CELL_TO_FLOAT(params[5]);
1315
   value2 = (double)f;
1316
   f = EMBRYO_CELL_TO_FLOAT(params[7]);
1317
   tween = (double)f;
1318
   if ((anim_type >= EDJE_TWEEN_MODE_LINEAR) &&
1319
       (anim_type <= EDJE_TWEEN_MODE_DECELERATE))
1320
     {
1321
        if (HASNPARAMS(8))
1322
          {
1323
             GETSTR(tmp, params[8]);
1324
             if (!tmp) return 0;
1325
             if (!strcmp(tmp, "CURRENT"))
1326
               anim_type |= EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
1327
          }
1328
     }
1329
   else if ((anim_type >= EDJE_TWEEN_MODE_ACCELERATE_FACTOR) &&
1330
            (anim_type <= EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR))
1331
     {
1332
        if (HASNPARAMS(9))
1333
          {
1334
             GETSTR(tmp, params[9]);
1335
             if (!tmp) return 0;
1336
             if (!strcmp(tmp, "CURRENT"))
1337
               anim_type |= EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
1338
          }
1339
        else if (HASNPARAMS(7))
1340
          {
1341
             ERR("parse error. Need 8th parameter to set factor");
1342
             return -1;
1343
          }
1344
        GETFLOAT_T(v1, params[8]);
1345
     }
1346
   else if ((anim_type >= EDJE_TWEEN_MODE_DIVISOR_INTERP) &&
1347
            (anim_type <= EDJE_TWEEN_MODE_SPRING))
1348
     {
1349
        if (HASNPARAMS(10))
1350
          {
1351
             GETSTR(tmp, params[10]);
1352
             if (!tmp) return 0;
1353
             if (!strcmp(tmp, "CURRENT"))
1354
               anim_type |= EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
1355
          }
1356
        else if (HASNPARAMS(7))
1357
          {
1358
             ERR("parse error.Need 8th and 9th parameters to set factor and counts");
1359
             return -1;
1360
          }
1361
        GETFLOAT_T(v1, params[8]);
1362
        GETFLOAT_T(v2, params[9]);
1363
     }
1364
   else if (anim_type == EDJE_TWEEN_MODE_CUBIC_BEZIER)
1365
     {
1366
        if (HASNPARAMS(12))
1367
          {
1368
             GETSTR(tmp, params[10]);
1369
             if (!tmp) return 0;
1370
             if (!strcmp(tmp, "CURRENT"))
1371
               anim_type |= EDJE_TWEEN_MODE_OPT_FROM_CURRENT;
1372
          }
1373
        else if (HASNPARAMS(7))
1374
          {
1375
             ERR("parse error.Need 8th, 9th, 10th and 11th parameters to set x1, y1, x2 and y2");
1376
             return -1;
1377
          }
1378
        if (HASNPARAMS(12))
1379
          {
1380
             GETFLOAT_T(v1, params[8]);
1381
             GETFLOAT_T(v2, params[9]);
1382
             GETFLOAT_T(v3, params[11]);
1383
             GETFLOAT_T(v4, params[12]);
1384
          }
1385
        else
1386
          {
1387
             GETFLOAT_T(v1, params[8]);
1388
             GETFLOAT_T(v2, params[9]);
1389
             GETFLOAT_T(v3, params[10]);
1390
             GETFLOAT_T(v4, params[11]);
1391
          }
1392
     }
1393
   rp = ed->table_parts[part_id % ed->table_parts_size];
1394
   if (!rp) return 0;
1395

1396
   if (rp->program) _edje_program_end(ed, rp->program);
1397
   _edje_part_description_apply(ed, rp, state1, value1, state2, value2);
1398
   _edje_part_pos_set(ed, rp, anim_type, FROM_DOUBLE(tween),
1399
                      v1, v2, v3, v4);
1400
   _edje_recalc(ed);
1401
   return 0;
1402
}
1403

1404
/* run_program(program_id) */
1405
static Embryo_Cell
1406
_edje_embryo_fn_run_program(Embryo_Program *ep, Embryo_Cell *params)
1407
{
1408
   Edje *ed;
1409
   int program_id = 0;
1410
   Edje_Program *pr;
1411

1412
   CHKPARAM(1);
1413
   ed = embryo_program_data_get(ep);
1414
   program_id = params[1];
1415
   if (program_id < 0) return 0;
1416
   pr = ed->collection->patterns.table_programs[program_id % ed->collection->patterns.table_programs_size];
1417
   if (pr)
1418
     {
1419
        _edje_program_run(ed, pr, 0, "", "", NULL);
1420
     }
1421
   return 0;
1422
}
1423

1424
/* get_drag_dir(part_id) */
1425
static Embryo_Cell
1426
_edje_embryo_fn_get_drag_dir(Embryo_Program *ep, Embryo_Cell *params)
1427
{
1428
   Edje *ed;
1429
   int part_id = 0;
1430
   Edje_Real_Part *rp;
1431

1432
   CHKPARAM(1);
1433
   ed = embryo_program_data_get(ep);
1434
   part_id = params[1];
1435
   if (part_id < 0) return 0;
1436
   rp = ed->table_parts[part_id % ed->table_parts_size];
1437
   return edje_object_part_drag_dir_get(ed->obj, rp->part->name);
1438
}
1439

1440
/* get_drag(part_id, &Float:dx, &Float:dy) */
1441
static Embryo_Cell
1442
_edje_embryo_fn_get_drag(Embryo_Program *ep, Embryo_Cell *params)
1443
{
1444
   Edje *ed;
1445
   int part_id = 0;
1446
   Edje_Real_Part *rp;
1447
   double dx = 0.0, dy = 0.0;
1448

1449
   CHKPARAM(3);
1450
   ed = embryo_program_data_get(ep);
1451
   part_id = params[1];
1452
   if (part_id < 0) return 0;
1453
   rp = ed->table_parts[part_id % ed->table_parts_size];
1454
   edje_object_part_drag_value_get(ed->obj, rp->part->name, &dx, &dy);
1455
   SETFLOAT(dx, params[2]);
1456
   SETFLOAT(dy, params[3]);
1457

1458
   return 0;
1459
}
1460

1461
/* set_drag(part_id, Float:dx, Float:dy) */
1462
static Embryo_Cell
1463
_edje_embryo_fn_set_drag(Embryo_Program *ep, Embryo_Cell *params)
1464
{
1465
   Edje *ed;
1466
   int part_id = 0;
1467
   Edje_Real_Part *rp;
1468

1469
   CHKPARAM(3);
1470
   ed = embryo_program_data_get(ep);
1471
   part_id = params[1];
1472
   if (part_id < 0) return 0;
1473
   rp = ed->table_parts[part_id % ed->table_parts_size];
1474
   edje_object_part_drag_value_set(ed->obj, rp->part->name,
1475
                                   (double)EMBRYO_CELL_TO_FLOAT(params[2]),
1476
                                   (double)EMBRYO_CELL_TO_FLOAT(params[3]));
1477
   return 0;
1478
}
1479

1480
/* get_drag_size(part_id, &Float:dx, &Float:dy) */
1481
static Embryo_Cell
1482
_edje_embryo_fn_get_drag_size(Embryo_Program *ep, Embryo_Cell *params)
1483
{
1484
   Edje *ed;
1485
   int part_id = 0;
1486
   Edje_Real_Part *rp;
1487
   double dx = 0.0, dy = 0.0;
1488

1489
   CHKPARAM(3);
1490
   ed = embryo_program_data_get(ep);
1491
   part_id = params[1];
1492
   if (part_id < 0) return 0;
1493
   rp = ed->table_parts[part_id % ed->table_parts_size];
1494
   edje_object_part_drag_size_get(ed->obj, rp->part->name, &dx, &dy);
1495
   SETFLOAT(dx, params[2]);
1496
   SETFLOAT(dy, params[3]);
1497

1498
   return 0;
1499
}
1500

1501
/* set_drag_size(part_id, Float:dx, Float:dy) */
1502
static Embryo_Cell
1503
_edje_embryo_fn_set_drag_size(Embryo_Program *ep, Embryo_Cell *params)
1504
{
1505
   Edje *ed;
1506
   int part_id = 0;
1507
   Edje_Real_Part *rp;
1508

1509
   CHKPARAM(3);
1510
   ed = embryo_program_data_get(ep);
1511
   part_id = params[1];
1512
   if (part_id < 0) return 0;
1513
   rp = ed->table_parts[part_id % ed->table_parts_size];
1514
   edje_object_part_drag_size_set(ed->obj, rp->part->name,
1515
                                  (double)EMBRYO_CELL_TO_FLOAT(params[2]),
1516
                                  (double)EMBRYO_CELL_TO_FLOAT(params[3]));
1517
   return 0;
1518
}
1519

1520
/* set_text(part_id, str[]) */
1521
static Embryo_Cell
1522
_edje_embryo_fn_set_text(Embryo_Program *ep, Embryo_Cell *params)
1523
{
1524
   Edje *ed;
1525
   int part_id = 0;
1526
   Edje_Real_Part *rp;
1527
   char *s;
1528

1529
   CHKPARAM(2);
1530
   ed = embryo_program_data_get(ep);
1531
   part_id = params[1];
1532
   if (part_id < 0) return 0;
1533
   rp = ed->table_parts[part_id % ed->table_parts_size];
1534
   GETSTR(s, params[2]);
1535
   if (s)
1536
     {
1537
        edje_object_part_text_set(ed->obj, rp->part->name, s);
1538
     }
1539
   return 0;
1540
}
1541

1542
/* get_text(part_id, dst[], maxlen) */
1543
static Embryo_Cell
1544
_edje_embryo_fn_get_text(Embryo_Program *ep, Embryo_Cell *params)
1545
{
1546
   Edje *ed;
1547
   int part_id = 0;
1548
   Edje_Real_Part *rp;
1549
   char *s;
1550

1551
   CHKPARAM(3);
1552
   ed = embryo_program_data_get(ep);
1553
   part_id = params[1];
1554
   if (part_id < 0) return 0;
1555
   rp = ed->table_parts[part_id % ed->table_parts_size];
1556
   s = (char *)edje_object_part_text_get(ed->obj, rp->part->name);
1557
   if (s)
1558
     {
1559
        if ((int)strlen(s) < params[3])
1560
          {
1561
             SETSTR(s, params[2]);
1562
          }
1563
        else
1564
          {
1565
             char *ss;
1566

1567
             ss = alloca(strlen(s) + 1);
1568
             strcpy(ss, s);
1569
             ss[params[3] - 1] = 0;
1570
             SETSTR(ss, params[2]);
1571
          }
1572
     }
1573
   else
1574
     {
1575
        SETSTR("", params[2]);
1576
     }
1577
   return 0;
1578
}
1579

1580
/* get_min_size(&w, &h) */
1581
static Embryo_Cell
1582
_edje_embryo_fn_get_min_size(Embryo_Program *ep, Embryo_Cell *params)
1583
{
1584
   Edje *ed;
1585
   Evas_Coord w = 0, h = 0;
1586

1587
   CHKPARAM(2);
1588
   ed = embryo_program_data_get(ep);
1589
   edje_object_size_min_get(ed->obj, &w, &h);
1590
   SETINT(w, params[1]);
1591
   SETINT(h, params[2]);
1592
   return 0;
1593
}
1594

1595
/* get_max_size(&w, &h) */
1596
static Embryo_Cell
1597
_edje_embryo_fn_get_max_size(Embryo_Program *ep, Embryo_Cell *params)
1598
{
1599
   Edje *ed;
1600
   Evas_Coord w = 0, h = 0;
1601

1602
   CHKPARAM(2);
1603
   ed = embryo_program_data_get(ep);
1604
   edje_object_size_max_get(ed->obj, &w, &h);
1605
   SETINT(w, params[1]);
1606
   SETINT(h, params[2]);
1607
   return 0;
1608
}
1609

1610
/* get_color_class(class[], &r, &g, &b, &a) */
1611
static Embryo_Cell
1612
_edje_embryo_fn_get_color_class(Embryo_Program *ep, Embryo_Cell *params)
1613
{
1614
   Edje *ed;
1615
   Edje_Color_Class *c_class;
1616
   char *class;
1617

1618
   CHKPARAM(5);
1619
   ed = embryo_program_data_get(ep);
1620
   GETSTR(class, params[1]);
1621
   if (!class) return 0;
1622
   c_class = _edje_color_class_recursive_find(ed, class);
1623
   if (!c_class) return 0;
1624
   SETINT(c_class->r, params[2]);
1625
   SETINT(c_class->g, params[3]);
1626
   SETINT(c_class->b, params[4]);
1627
   SETINT(c_class->a, params[5]);
1628
   return 0;
1629
}
1630

1631
/* set_color_class(class[], r, g, b, a) */
1632
static Embryo_Cell
1633
_edje_embryo_fn_set_color_class(Embryo_Program *ep, Embryo_Cell *params)
1634
{
1635
   Edje *ed;
1636
   char *class;
1637

1638
   CHKPARAM(5);
1639
   ed = embryo_program_data_get(ep);
1640
   GETSTR(class, params[1]);
1641
   if (!class) return 0;
1642
   edje_object_color_class_set(ed->obj, class, params[2], params[3], params[4],
1643
                               params[5], params[2], params[3], params[4],
1644
                               params[5], params[2], params[3], params[4],
1645
                               params[5]);
1646
   return 0;
1647
}
1648

1649
/* set_text_class(class[], font[], Float:size) */
1650
static Embryo_Cell
1651
_edje_embryo_fn_set_text_class(Embryo_Program *ep, Embryo_Cell *params)
1652
{
1653
   Edje *ed;
1654
   char *class, *font;
1655
   Evas_Font_Size fsize;
1656

1657
   CHKPARAM(3);
1658
   ed = embryo_program_data_get(ep);
1659
   GETSTR(class, params[1]);
1660
   GETSTR(font, params[2]);
1661
   if ( !class || !font ) return 0;
1662
   fsize = (Evas_Font_Size)EMBRYO_CELL_TO_FLOAT(params[3]);
1663
   edje_object_text_class_set(ed->obj, class, font, fsize);
1664
   return 0;
1665
}
1666

1667
/* get_text_class(class[], font[], &Float:size) */
1668
static Embryo_Cell
1669
_edje_embryo_fn_get_text_class(Embryo_Program *ep, Embryo_Cell *params)
1670
{
1671
   Edje *ed;
1672
   char *class;
1673
   Edje_Text_Class *t_class;
1674

1675
   CHKPARAM(3);
1676
   ed = embryo_program_data_get(ep);
1677
   GETSTR(class, params[1]);
1678
   if (!class) return 0;
1679
   t_class = _edje_text_class_find(ed, class);
1680
   if (!t_class) return 0;
1681
   SETSTR((char *)t_class->font, params[2]);
1682
   SETFLOAT(t_class->size, params[3]);
1683
   return 0;
1684
}
1685

1686
/* get_drag_step(part_id, &Float:dx, &Float:&dy) */
1687
static Embryo_Cell
1688
_edje_embryo_fn_get_drag_step(Embryo_Program *ep, Embryo_Cell *params)
1689
{
1690
   Edje *ed;
1691
   int part_id = 0;
1692
   Edje_Real_Part *rp;
1693
   double dx = 0.0, dy = 0.0;
1694

1695
   CHKPARAM(3);
1696
   ed = embryo_program_data_get(ep);
1697
   part_id = params[1];
1698
   if (part_id < 0) return 0;
1699
   rp = ed->table_parts[part_id % ed->table_parts_size];
1700
   edje_object_part_drag_step_get(ed->obj, rp->part->name, &dx, &dy);
1701
   SETFLOAT(dx, params[2]);
1702
   SETFLOAT(dy, params[3]);
1703

1704
   return 0;
1705
}
1706

1707
/* set_drag_step(part_id, Float:dx, Float:dy) */
1708
static Embryo_Cell
1709
_edje_embryo_fn_set_drag_step(Embryo_Program *ep, Embryo_Cell *params)
1710
{
1711
   Edje *ed;
1712
   int part_id = 0;
1713
   Edje_Real_Part *rp;
1714

1715
   CHKPARAM(3);
1716
   ed = embryo_program_data_get(ep);
1717
   part_id = params[1];
1718
   if (part_id < 0) return 0;
1719
   rp = ed->table_parts[part_id % ed->table_parts_size];
1720
   edje_object_part_drag_step_set(ed->obj, rp->part->name,
1721
                                  (double)EMBRYO_CELL_TO_FLOAT(params[2]),
1722
                                  (double)EMBRYO_CELL_TO_FLOAT(params[3]));
1723
   return 0;
1724
}
1725

1726
/* get_drag_page(part_id, &Float:dx, &Float:&dy) */
1727
static Embryo_Cell
1728
_edje_embryo_fn_get_drag_page(Embryo_Program *ep, Embryo_Cell *params)
1729
{
1730
   Edje *ed;
1731
   int part_id = 0;
1732
   Edje_Real_Part *rp;
1733
   double dx = 0.0, dy = 0.0;
1734

1735
   CHKPARAM(3);
1736
   ed = embryo_program_data_get(ep);
1737
   part_id = params[1];
1738
   if (part_id < 0) return 0;
1739
   rp = ed->table_parts[part_id % ed->table_parts_size];
1740
   edje_object_part_drag_page_get(ed->obj, rp->part->name, &dx, &dy);
1741
   SETFLOAT(dx, params[2]);
1742
   SETFLOAT(dy, params[3]);
1743

1744
   return 0;
1745
}
1746

1747
/* get_geometry(pard_id, &x, &y, &w, &h) */
1748
static Embryo_Cell
1749
_edje_embryo_fn_get_geometry(Embryo_Program *ep, Embryo_Cell *params)
1750
{
1751
   Edje *ed;
1752
   int part_id = 0;
1753
   Edje_Real_Part *rp;
1754
   Evas_Coord x = 0, y = 0, w = 0, h = 0;
1755

1756
   CHKPARAM(5);
1757
   ed = embryo_program_data_get(ep);
1758
   part_id = params[1];
1759
   if (part_id < 0) return 0;
1760
   rp = ed->table_parts[part_id % ed->table_parts_size];
1761
   edje_object_part_geometry_get(ed->obj, rp->part->name, &x, &y, &w, &h);
1762
   SETINT(x, params[2]);
1763
   SETINT(y, params[3]);
1764
   SETINT(w, params[4]);
1765
   SETINT(h, params[5]);
1766

1767
   return 0;
1768
}
1769

1770
/* set_drag_page(part_id, Float:dx, Float:dy) */
1771
static Embryo_Cell
1772
_edje_embryo_fn_set_drag_page(Embryo_Program *ep, Embryo_Cell *params)
1773
{
1774
   Edje *ed;
1775
   int part_id = 0;
1776
   Edje_Real_Part *rp;
1777

1778
   CHKPARAM(3);
1779
   ed = embryo_program_data_get(ep);
1780
   part_id = params[1];
1781
   if (part_id < 0) return 0;
1782
   rp = ed->table_parts[part_id % ed->table_parts_size];
1783
   edje_object_part_drag_page_set(ed->obj, rp->part->name,
1784
                                  (double)EMBRYO_CELL_TO_FLOAT(params[2]),
1785
                                  (double)EMBRYO_CELL_TO_FLOAT(params[3]));
1786
   return 0;
1787
}
1788

1789
/* send_message(Msg_Type:type, id,...); */
1790
static Embryo_Cell
1791
_edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
1792
{
1793
   Edje *ed;
1794
   Edje_Message_Type type;
1795
   int id, i, n;
1796
   Embryo_Cell *ptr;
1797

1798
   if (params[0] < (int)(sizeof(Embryo_Cell) * (2))) return 0;
1799
   ed = embryo_program_data_get(ep);
1800
   type = params[1];
1801
   id = params[2];
1802
   switch (type)
1803
     {
1804
      case EDJE_MESSAGE_NONE:
1805
        _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, NULL);
1806
        break;
1807

1808
      case EDJE_MESSAGE_SIGNAL:
1809
        break;
1810

1811
      case EDJE_MESSAGE_STRING:
1812
      {
1813
         Embryo_Cell *cptr;
1814

1815
         cptr = embryo_data_address_get(ep, params[3]);
1816
         if (cptr)
1817
           {
1818
              Edje_Message_String *emsg;
1819
              int l;
1820
              char *s;
1821

1822
              l = embryo_data_string_length_get(ep, cptr);
1823
              s = alloca(l + 1);
1824
              s[0] = 0;
1825
              embryo_data_string_get(ep, cptr, s);
1826
              emsg = alloca(sizeof(Edje_Message_String));
1827
              emsg->str = s;
1828
              _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1829
           }
1830
      }
1831
      break;
1832

1833
      case EDJE_MESSAGE_INT:
1834
      {
1835
         Edje_Message_Int *emsg;
1836

1837
         emsg = alloca(sizeof(Edje_Message_Int));
1838
         ptr = embryo_data_address_get(ep, params[3]);
1839
         if (ptr) emsg->val = (int)*ptr;
1840
         else emsg->val = 0;
1841
         _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1842
      }
1843
      break;
1844

1845
      case EDJE_MESSAGE_FLOAT:
1846
      {
1847
         Edje_Message_Float *emsg;
1848
         float f;
1849

1850
         emsg = alloca(sizeof(Edje_Message_Float));
1851
         ptr = embryo_data_address_get(ep, params[3]);
1852
         if (ptr)
1853
           {
1854
              f = EMBRYO_CELL_TO_FLOAT(*ptr);
1855
              emsg->val = (double)f;
1856
           }
1857
         else
1858
           emsg->val = 0.0;
1859
         _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1860
      }
1861
      break;
1862

1863
      case EDJE_MESSAGE_STRING_SET:
1864
      {
1865
         Edje_Message_String_Set *emsg;
1866

1867
         n = (params[0] / sizeof(Embryo_Cell)) + 1;
1868
         emsg = alloca(sizeof(Edje_Message_String_Set) + ((n - 3 - 1) * sizeof(char *)));
1869
         emsg->count = n - 3;
1870
         for (i = 3; i < n; i++)
1871
           {
1872
              Embryo_Cell *cptr;
1873

1874
              cptr = embryo_data_address_get(ep, params[i]);
1875
              if (cptr)
1876
                {
1877
                   int l;
1878
                   char *s;
1879

1880
                   l = embryo_data_string_length_get(ep, cptr);
1881
                   s = alloca(l + 1);
1882
                   s[0] = 0;
1883
                   embryo_data_string_get(ep, cptr, s);
1884
                   emsg->str[i - 3] = s;
1885
                }
1886
           }
1887
         _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1888
      }
1889
      break;
1890

1891
      case EDJE_MESSAGE_INT_SET:
1892
      {
1893
         Edje_Message_Int_Set *emsg;
1894

1895
         n = (params[0] / sizeof(Embryo_Cell)) + 1;
1896
         emsg = alloca(sizeof(Edje_Message_Int_Set) + ((n - 3 - 1) * sizeof(int)));
1897
         emsg->count = n - 3;
1898
         for (i = 3; i < n; i++)
1899
           {
1900
              ptr = embryo_data_address_get(ep, params[i]);
1901
              if (ptr) emsg->val[i - 3] = (int)*ptr;
1902
              else emsg->val[i - 3] = 0;
1903
           }
1904
         _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1905
      }
1906
      break;
1907

1908
      case EDJE_MESSAGE_FLOAT_SET:
1909
      {
1910
         Edje_Message_Float_Set *emsg;
1911

1912
         n = (params[0] / sizeof(Embryo_Cell)) + 1;
1913
         emsg = alloca(sizeof(Edje_Message_Float_Set) + ((n - 3 - 1) * sizeof(double)));
1914
         emsg->count = n - 3;
1915
         for (i = 3; i < n; i++)
1916
           {
1917
              float f;
1918

1919
              ptr = embryo_data_address_get(ep, params[i]);
1920
              if (ptr)
1921
                {
1922
                   f = EMBRYO_CELL_TO_FLOAT(*ptr);
1923
                   emsg->val[i - 3] = (double)f;
1924
                }
1925
              else
1926
                emsg->val[i - 3] = 0.0;
1927
           }
1928
         _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1929
      }
1930
      break;
1931

1932
      case EDJE_MESSAGE_STRING_INT:
1933
      {
1934
         Edje_Message_String_Int *emsg;
1935
         Embryo_Cell *cptr;
1936

1937
         cptr = embryo_data_address_get(ep, params[3]);
1938
         if (cptr)
1939
           {
1940
              int l;
1941
              char *s;
1942

1943
              l = embryo_data_string_length_get(ep, cptr);
1944
              s = alloca(l + 1);
1945
              s[0] = 0;
1946
              embryo_data_string_get(ep, cptr, s);
1947
              emsg = alloca(sizeof(Edje_Message_String_Int));
1948
              emsg->str = s;
1949
              ptr = embryo_data_address_get(ep, params[4]);
1950
              if (ptr) emsg->val = (int)*ptr;
1951
              else emsg->val = 0;
1952
              _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1953
           }
1954
      }
1955
      break;
1956

1957
      case EDJE_MESSAGE_STRING_FLOAT:
1958
      {
1959
         Edje_Message_String_Float *emsg;
1960
         Embryo_Cell *cptr;
1961

1962
         cptr = embryo_data_address_get(ep, params[3]);
1963
         if (cptr)
1964
           {
1965
              int l;
1966
              char *s;
1967
              float f;
1968

1969
              l = embryo_data_string_length_get(ep, cptr);
1970
              s = alloca(l + 1);
1971
              s[0] = 0;
1972
              embryo_data_string_get(ep, cptr, s);
1973
              emsg = alloca(sizeof(Edje_Message_String_Float));
1974
              emsg->str = s;
1975
              ptr = embryo_data_address_get(ep, params[4]);
1976
              if (ptr)
1977
                {
1978
                   f = EMBRYO_CELL_TO_FLOAT(*ptr);
1979
                   emsg->val = (double)f;
1980
                }
1981
              else
1982
                emsg->val = 0.0;
1983
              _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1984
           }
1985
      }
1986
      break;
1987

1988
      case EDJE_MESSAGE_STRING_INT_SET:
1989
      {
1990
         Edje_Message_String_Int_Set *emsg;
1991
         Embryo_Cell *cptr;
1992

1993
         cptr = embryo_data_address_get(ep, params[3]);
1994
         if (cptr)
1995
           {
1996
              int l;
1997
              char *s;
1998

1999
              l = embryo_data_string_length_get(ep, cptr);
2000
              s = alloca(l + 1);
2001
              s[0] = 0;
2002
              embryo_data_string_get(ep, cptr, s);
2003
              n = (params[0] / sizeof(Embryo_Cell)) + 1;
2004
              emsg = alloca(sizeof(Edje_Message_String_Int_Set) + ((n - 4 - 1) * sizeof(int)));
2005
              emsg->str = s;
2006
              emsg->count = n - 4;
2007
              for (i = 4; i < n; i++)
2008
                {
2009
                   ptr = embryo_data_address_get(ep, params[i]);
2010
                   if (ptr) emsg->val[i - 4] = (int)*ptr;
2011
                   else emsg->val[i - 4] = 0;
2012
                }
2013
              _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
2014
           }
2015
      }
2016
      break;
2017

2018
      case EDJE_MESSAGE_STRING_FLOAT_SET:
2019
      {
2020
         Edje_Message_String_Float_Set *emsg;
2021
         Embryo_Cell *cptr;
2022

2023
         cptr = embryo_data_address_get(ep, params[3]);
2024
         if (cptr)
2025
           {
2026
              int l;
2027
              char *s;
2028

2029
              l = embryo_data_string_length_get(ep, cptr);
2030
              s = alloca(l + 1);
2031
              s[0] = 0;
2032
              embryo_data_string_get(ep, cptr, s);
2033
              n = (params[0] / sizeof(Embryo_Cell)) + 1;
2034
              emsg = alloca(sizeof(Edje_Message_String_Float_Set) + ((n - 4 - 1) * sizeof(double)));
2035
              emsg->str = s;
2036
              emsg->count = n - 4;
2037
              for (i = 4; i < n; i++)
2038
                {
2039
                   float f;
2040

2041
                   ptr = embryo_data_address_get(ep, params[i]);
2042
                   if (ptr)
2043
                     {
2044
                        f = EMBRYO_CELL_TO_FLOAT(*ptr);
2045
                        emsg->val[i - 4] = (double)f;
2046
                     }
2047
                   else
2048
                     emsg->val[i - 4] = 0.0;
2049
                }
2050
              _edje_util_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
2051
           }
2052
      }
2053
      break;
2054

2055
      default:
2056
        break;
2057
     }
2058
   return 0;
2059
}
2060

2061
/* custom_state(part_id, state[], Float:state_val = 0.0) */
2062
static Embryo_Cell
2063
_edje_embryo_fn_custom_state(Embryo_Program *ep, Embryo_Cell *params)
2064
{
2065
   Edje *ed = embryo_program_data_get(ep);
2066
   Edje_Real_Part *rp;
2067
   Edje_Part_Description_Common *parent, *d = NULL;
2068
   char *name;
2069
   float val;
2070

2071
   CHKPARAM(3);
2072

2073
   if (params[1] < 0)
2074
     return 0;
2075

2076
   if (!(rp = ed->table_parts[params[1] % ed->table_parts_size]))
2077
     return 0;
2078

2079
   /* check whether this part already has a "custom" state */
2080
   if (rp->custom)
2081
     return 0;
2082

2083
   GETSTR(name, params[2]);
2084
   if (!name)
2085
     return 0;
2086

2087
   val = EMBRYO_CELL_TO_FLOAT(params[3]);
2088

2089
   if (!(parent = _edje_part_description_find(ed, rp, name, val, EINA_TRUE)))
2090
     return 0;
2091

2092
   rp->custom = eina_mempool_malloc(_edje_real_part_state_mp, sizeof (Edje_Real_Part_State));
2093
   if (!rp->custom) return 0;
2094

2095
   memset(rp->custom, 0, sizeof (Edje_Real_Part_State));
2096

2097
   /* now create the custom state */
2098
   switch (rp->part->type)
2099
     {
2100
#define ALLOC_DESC(Short, Type, To) \
2101
case EDJE_PART_TYPE_##Short: To = calloc(1, sizeof (Edje_Part_Description_##Type)); break;
2102

2103
#define ALLOC_COPY_DESC(Short, Type, To, Spec)             \
2104
case EDJE_PART_TYPE_##Short:                               \
2105
{                                                          \
2106
   Edje_Part_Description_##Type * tmp;                     \
2107
   Edje_Part_Description_##Type * new;                     \
2108
   tmp = (Edje_Part_Description_##Type *)parent;           \
2109
   new = calloc(1, sizeof (Edje_Part_Description_##Type)); \
2110
   if (!new) break;                                        \
2111
   new->Spec = tmp->Spec;                                  \
2112
   To = &new->common;                                      \
2113
   break;                                                  \
2114
}
2115

2116
        ALLOC_DESC(RECTANGLE, Common, d);
2117
        ALLOC_DESC(SPACER, Common, d);
2118
        ALLOC_DESC(SWALLOW, Common, d);
2119
        ALLOC_DESC(GROUP, Common, d);
2120

2121
        ALLOC_COPY_DESC(IMAGE, Image, d, image);
2122
        ALLOC_COPY_DESC(PROXY, Proxy, d, proxy);
2123
        ALLOC_COPY_DESC(TEXT, Text, d, text);
2124
        ALLOC_COPY_DESC(TEXTBLOCK, Text, d, text);
2125
        ALLOC_COPY_DESC(BOX, Box, d, box);
2126
        ALLOC_COPY_DESC(TABLE, Table, d, table);
2127
        ALLOC_COPY_DESC(EXTERNAL, External, d, external_params);
2128
        ALLOC_COPY_DESC(VECTOR, Vector, d, vg);
2129
     }
2130

2131
   if (!d)
2132
     {
2133
        eina_mempool_free(_edje_real_part_state_mp, rp->custom);
2134
        rp->custom = NULL;
2135
        return 0;
2136
     }
2137

2138
   *d = *parent;
2139

2140
   d->state.name = (char *)eina_stringshare_add("custom");
2141
   d->state.value = 0.0;
2142

2143
   /* make sure all the allocated memory is getting copied,
2144
    * not just referenced
2145
    */
2146
   if (rp->part->type == EDJE_PART_TYPE_IMAGE)
2147
     {
2148
        Edje_Part_Description_Image *img_desc;
2149
        Edje_Part_Description_Image *parent_img_desc;
2150

2151
        img_desc = (Edje_Part_Description_Image *)d;
2152
        parent_img_desc = (Edje_Part_Description_Image *)parent;
2153

2154
        img_desc->image.tweens_count = parent_img_desc->image.tweens_count;
2155
        img_desc->image.tweens = calloc(img_desc->image.tweens_count,
2156
                                        sizeof(Edje_Part_Image_Id *));
2157
        if (img_desc->image.tweens)
2158
          {
2159
             unsigned int i;
2160

2161
             for (i = 0; i < parent_img_desc->image.tweens_count; ++i)
2162
               {
2163
                  Edje_Part_Image_Id *iid_new;
2164

2165
                  iid_new = calloc(1, sizeof(Edje_Part_Image_Id));
2166
                  if (!iid_new) continue;
2167

2168
                  *iid_new = *parent_img_desc->image.tweens[i];
2169

2170
                  img_desc->image.tweens[i] = iid_new;
2171
               }
2172
          }
2173
     }
2174

2175
#define DUP(x) x ? (char *)eina_stringshare_add(x) : NULL
2176
   d->color_class = DUP(d->color_class);
2177

2178
   if (rp->part->type == EDJE_PART_TYPE_TEXT
2179
       || rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
2180
     {
2181
        Edje_Part_Description_Text *text_desc;
2182

2183
        text_desc = (Edje_Part_Description_Text *)d;
2184

2185
        text_desc->text.text_class = DUP(text_desc->text.text_class);
2186
        text_desc->text.text.str = DUP(edje_string_get(&text_desc->text.text));
2187
        text_desc->text.text.id = 0;
2188
        text_desc->text.text.translated = NULL;
2189
        text_desc->text.domain = DUP(text_desc->text.domain);
2190
        text_desc->text.font.str = DUP(edje_string_get(&text_desc->text.font));
2191
        text_desc->text.font.id = 0;
2192
        text_desc->text.style.str = DUP(edje_string_get(&text_desc->text.style));
2193
        text_desc->text.style.id = 0;
2194
     }
2195
#undef DUP
2196

2197
   rp->custom->description = d;
2198

2199
   return 0;
2200
}
2201

2202
/* set_state_val(part_id, State_Param:p, ...) */
2203
static Embryo_Cell
2204
_edje_embryo_fn_set_state_val(Embryo_Program *ep, Embryo_Cell *params)
2205
{
2206
   Edje *ed = embryo_program_data_get(ep);
2207
   Edje_Real_Part *rp;
2208
   char *s;
2209

2210
   /* we need at least 3 arguments */
2211
   if (params[0] < (int)(sizeof(Embryo_Cell) * 3))
2212
     return 0;
2213

2214
   if (params[1] < 0)
2215
     return 0;
2216

2217
   if (!(rp = ed->table_parts[params[1] % ed->table_parts_size]))
2218
     return 0;
2219

2220
   /* check whether this part has a "custom" state */
2221
   if (!rp->custom)
2222
     return 0;
2223

2224
   switch (params[2])
2225
     {
2226
      case EDJE_STATE_PARAM_ALIGNMENT:
2227
        CHKPARAM(4);
2228

2229
        GETFLOAT_T(rp->custom->description->align.x, params[3]);
2230
        GETFLOAT_T(rp->custom->description->align.y, params[4]);
2231

2232
        break;
2233

2234
      case EDJE_STATE_PARAM_MIN:
2235
        CHKPARAM(4);
2236

2237
        GETINT(rp->custom->description->min.w, params[3]);
2238
        GETINT(rp->custom->description->min.h, params[4]);
2239

2240
        break;
2241

2242
      case EDJE_STATE_PARAM_MAX:
2243
        CHKPARAM(4);
2244

2245
        GETINT(rp->custom->description->max.w, params[3]);
2246
        GETINT(rp->custom->description->max.h, params[4]);
2247

2248
        break;
2249

2250
      case EDJE_STATE_PARAM_STEP:
2251
        CHKPARAM(4);
2252

2253
        GETINT(rp->custom->description->step.x, params[3]);
2254
        GETINT(rp->custom->description->step.y, params[4]);
2255

2256
        break;
2257

2258
      case EDJE_STATE_PARAM_ASPECT:
2259
        CHKPARAM(4);
2260

2261
        GETFLOAT_T(rp->custom->description->aspect.min, params[3]);
2262
        GETFLOAT_T(rp->custom->description->aspect.max, params[4]);
2263

2264
        break;
2265

2266
      case EDJE_STATE_PARAM_ASPECT_PREF:
2267
        CHKPARAM(3);
2268

2269
        GETINT(rp->custom->description->aspect.prefer, params[3]);
2270

2271
        break;
2272

2273
      case EDJE_STATE_PARAM_COLOR:
2274
        CHKPARAM(6);
2275

2276
        GETINT(rp->custom->description->color.r, params[3]);
2277
        GETINT(rp->custom->description->color.g, params[4]);
2278
        GETINT(rp->custom->description->color.b, params[5]);
2279
        GETINT(rp->custom->description->color.a, params[6]);
2280

2281
        break;
2282

2283
      case EDJE_STATE_PARAM_COLOR2:
2284
        CHKPARAM(6);
2285

2286
        GETINT(rp->custom->description->color2.r, params[3]);
2287
        GETINT(rp->custom->description->color2.g, params[4]);
2288
        GETINT(rp->custom->description->color2.b, params[5]);
2289
        GETINT(rp->custom->description->color2.a, params[6]);
2290

2291
        break;
2292

2293
      case EDJE_STATE_PARAM_COLOR3:
2294
      {
2295
         Edje_Part_Description_Text *text;
2296

2297
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
2298
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2299
           return 0;
2300

2301
         CHKPARAM(6);
2302

2303
         text = (Edje_Part_Description_Text *)rp->custom->description;
2304

2305
         GETINT(text->text.color3.r, params[3]);
2306
         GETINT(text->text.color3.g, params[4]);
2307
         GETINT(text->text.color3.b, params[5]);
2308
         GETINT(text->text.color3.a, params[6]);
2309
         break;
2310
      }
2311

2312
      case EDJE_STATE_PARAM_COLOR_CLASS:
2313
        CHKPARAM(3);
2314

2315
        GETSTR(s, params[3]);
2316
        GETSTREVAS(s, rp->custom->description->color_class);
2317

2318
        break;
2319

2320
      case EDJE_STATE_PARAM_REL1:
2321
        CHKPARAM(4);
2322

2323
        GETFLOAT_T(rp->custom->description->rel1.relative_x, params[3]);
2324
        GETFLOAT_T(rp->custom->description->rel1.relative_y, params[4]);
2325

2326
        break;
2327

2328
      case EDJE_STATE_PARAM_REL1_TO:
2329
        CHKPARAM(4);
2330

2331
        GETINT(rp->custom->description->rel1.id_x, params[3]);
2332
        GETINT(rp->custom->description->rel1.id_y, params[4]);
2333

2334
        break;
2335

2336
      case EDJE_STATE_PARAM_REL1_OFFSET:
2337
        CHKPARAM(4);
2338

2339
        GETINT(rp->custom->description->rel1.offset_x, params[3]);
2340
        GETINT(rp->custom->description->rel1.offset_y, params[4]);
2341

2342
        break;
2343

2344
      case EDJE_STATE_PARAM_REL2:
2345
        CHKPARAM(4);
2346

2347
        GETFLOAT_T(rp->custom->description->rel2.relative_x, params[3]);
2348
        GETFLOAT_T(rp->custom->description->rel2.relative_y, params[4]);
2349

2350
        break;
2351

2352
      case EDJE_STATE_PARAM_REL2_TO:
2353
        CHKPARAM(4);
2354

2355
        GETINT(rp->custom->description->rel2.id_x, params[3]);
2356
        GETINT(rp->custom->description->rel2.id_y, params[4]);
2357

2358
        break;
2359

2360
      case EDJE_STATE_PARAM_REL2_OFFSET:
2361
        CHKPARAM(4);
2362

2363
        GETINT(rp->custom->description->rel2.offset_x, params[3]);
2364
        GETINT(rp->custom->description->rel2.offset_y, params[4]);
2365

2366
        break;
2367

2368
      case EDJE_STATE_PARAM_IMAGE:
2369
      {
2370
         Edje_Part_Description_Image *img;
2371

2372
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE)) return 0;
2373
         CHKPARAM(3);
2374

2375
         img = (Edje_Part_Description_Image *)rp->custom->description;
2376
         GETINT(img->image.id, params[3]);
2377

2378
         break;
2379
      }
2380

2381
      case EDJE_STATE_PARAM_BORDER:
2382
      {
2383
         Edje_Part_Description_Image *img;
2384

2385
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE)) return 0;
2386
         CHKPARAM(6);
2387

2388
         img = (Edje_Part_Description_Image *)rp->custom->description;
2389

2390
         GETINT(img->image.border.l, params[3]);
2391
         GETINT(img->image.border.r, params[4]);
2392
         GETINT(img->image.border.t, params[5]);
2393
         GETINT(img->image.border.b, params[6]);
2394

2395
         break;
2396
      }
2397

2398
      case EDJE_STATE_PARAM_FILL_SMOOTH:
2399
      {
2400
         Edje_Part_Description_Image *img;
2401
         Edje_Part_Description_Proxy *proxy;
2402

2403
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE) && (rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
2404
         CHKPARAM(3);
2405

2406
         if (rp->part->type == EDJE_PART_TYPE_IMAGE)
2407
           {
2408
              img = (Edje_Part_Description_Image *)rp->custom->description;
2409
              GETINT(img->image.fill.smooth, params[3]);
2410
           }
2411
         else
2412
           {
2413
              proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
2414
              GETINT(proxy->proxy.fill.smooth, params[3]);
2415
           }
2416

2417
         break;
2418
      }
2419

2420
      case EDJE_STATE_PARAM_FILL_POS:
2421
      {
2422
         Edje_Part_Description_Image *img;
2423
         Edje_Part_Description_Proxy *proxy;
2424

2425
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE) && (rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
2426
         CHKPARAM(6);
2427

2428
         if (rp->part->type == EDJE_PART_TYPE_IMAGE)
2429
           {
2430
              img = (Edje_Part_Description_Image *)rp->custom->description;
2431

2432
              GETFLOAT_T(img->image.fill.pos_rel_x, params[3]);
2433
              GETFLOAT_T(img->image.fill.pos_rel_y, params[4]);
2434
              GETINT(img->image.fill.pos_abs_x, params[5]);
2435
              GETINT(img->image.fill.pos_abs_y, params[6]);
2436
           }
2437
         else
2438
           {
2439
              proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
2440

2441
              GETFLOAT_T(proxy->proxy.fill.pos_rel_x, params[3]);
2442
              GETFLOAT_T(proxy->proxy.fill.pos_rel_y, params[4]);
2443
              GETINT(proxy->proxy.fill.pos_abs_x, params[5]);
2444
              GETINT(proxy->proxy.fill.pos_abs_y, params[6]);
2445
           }
2446

2447
         break;
2448
      }
2449

2450
      case EDJE_STATE_PARAM_FILL_SIZE:
2451
      {
2452
         Edje_Part_Description_Image *img;
2453
         Edje_Part_Description_Proxy *proxy;
2454

2455
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE) && (rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
2456
         CHKPARAM(6);
2457

2458
         if (rp->part->type == EDJE_PART_TYPE_IMAGE)
2459
           {
2460
              img = (Edje_Part_Description_Image *)rp->custom->description;
2461

2462
              GETFLOAT_T(img->image.fill.rel_x, params[3]);
2463
              GETFLOAT_T(img->image.fill.rel_y, params[4]);
2464
              GETINT(img->image.fill.abs_x, params[5]);
2465
              GETINT(img->image.fill.abs_y, params[6]);
2466
           }
2467
         else
2468
           {
2469
              proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
2470

2471
              GETFLOAT_T(proxy->proxy.fill.rel_x, params[3]);
2472
              GETFLOAT_T(proxy->proxy.fill.rel_y, params[4]);
2473
              GETINT(proxy->proxy.fill.abs_x, params[5]);
2474
              GETINT(proxy->proxy.fill.abs_y, params[6]);
2475
           }
2476

2477
         break;
2478
      }
2479

2480
      case EDJE_STATE_PARAM_TEXT:
2481
      {
2482
         Edje_Part_Description_Text *text;
2483

2484
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
2485
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2486
           return 0;
2487
         CHKPARAM(3);
2488

2489
         GETSTR(s, params[3]);
2490

2491
         text = (Edje_Part_Description_Text *)rp->custom->description;
2492
         GETSTREVAS(s, text->text.text.str);
2493

2494
         break;
2495
      }
2496

2497
      case EDJE_STATE_PARAM_TEXT_CLASS:
2498
      {
2499
         Edje_Part_Description_Text *text;
2500

2501
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
2502
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2503
           return 0;
2504
         CHKPARAM(3);
2505

2506
         GETSTR(s, params[3]);
2507

2508
         text = (Edje_Part_Description_Text *)rp->custom->description;
2509
         GETSTREVAS(s, text->text.text_class);
2510

2511
         break;
2512
      }
2513

2514
      case EDJE_STATE_PARAM_TEXT_FONT:
2515
      {
2516
         Edje_Part_Description_Text *text;
2517

2518
         if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2519
         CHKPARAM(3);
2520

2521
         GETSTR(s, params[3]);
2522

2523
         text = (Edje_Part_Description_Text *)rp->custom->description;
2524
         GETSTREVAS(s, text->text.font.str);
2525

2526
         break;
2527
      }
2528

2529
      case EDJE_STATE_PARAM_TEXT_STYLE:
2530
      {
2531
         Edje_Part_Description_Text *text;
2532

2533
         if ((rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return 0;
2534
         CHKPARAM(3);
2535

2536
         GETSTR(s, params[3]);
2537

2538
         text = (Edje_Part_Description_Text *)rp->custom->description;
2539
         GETSTREVAS(s, text->text.style.str);
2540

2541
         break;
2542
      }
2543

2544
      case EDJE_STATE_PARAM_TEXT_SIZE:
2545
      {
2546
         Edje_Part_Description_Text *text;
2547

2548
         if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2549
         CHKPARAM(3);
2550

2551
         text = (Edje_Part_Description_Text *)rp->custom->description;
2552
         GETINT(text->text.size, params[3]);
2553

2554
         break;
2555
      }
2556

2557
      case EDJE_STATE_PARAM_TEXT_FIT:
2558
      {
2559
         Edje_Part_Description_Text *text;
2560

2561
         if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2562
         CHKPARAM(4);
2563

2564
         text = (Edje_Part_Description_Text *)rp->custom->description;
2565

2566
         GETINT(text->text.fit_x, params[3]);
2567
         GETINT(text->text.fit_y, params[4]);
2568

2569
         break;
2570
      }
2571

2572
      case EDJE_STATE_PARAM_TEXT_MIN:
2573
      {
2574
         Edje_Part_Description_Text *text;
2575

2576
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
2577
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2578
           return 0;
2579
         CHKPARAM(4);
2580

2581
         text = (Edje_Part_Description_Text *)rp->custom->description;
2582

2583
         GETINT(text->text.min_x, params[3]);
2584
         GETINT(text->text.min_y, params[4]);
2585

2586
         break;
2587
      }
2588

2589
      case EDJE_STATE_PARAM_TEXT_MAX:
2590
      {
2591
         Edje_Part_Description_Text *text;
2592

2593
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
2594
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2595
           return 0;
2596
         CHKPARAM(4);
2597

2598
         text = (Edje_Part_Description_Text *)rp->custom->description;
2599

2600
         GETINT(text->text.max_x, params[3]);
2601
         GETINT(text->text.max_y, params[4]);
2602

2603
         break;
2604
      }
2605

2606
      case EDJE_STATE_PARAM_TEXT_ALIGN:
2607
      {
2608
         Edje_Part_Description_Text *text;
2609

2610
         if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2611
         CHKPARAM(4);
2612

2613
         text = (Edje_Part_Description_Text *)rp->custom->description;
2614

2615
         GETFLOAT_T(text->text.align.x, params[3]);
2616
         GETFLOAT_T(text->text.align.y, params[4]);
2617

2618
         break;
2619
      }
2620

2621
      case EDJE_STATE_PARAM_VISIBLE:
2622
        CHKPARAM(3);
2623

2624
        GETINT(rp->custom->description->visible, params[3]);
2625

2626
        break;
2627

2628
      case EDJE_STATE_PARAM_MAP_ON:
2629
        CHKPARAM(3);
2630

2631
        GETINT(rp->custom->description->map.on, params[3]);
2632

2633
        break;
2634

2635
      case EDJE_STATE_PARAM_MAP_PERSP:
2636
        CHKPARAM(3);
2637

2638
        GETINT(rp->custom->description->map.id_persp, params[3]);
2639

2640
        break;
2641

2642
      case EDJE_STATE_PARAM_MAP_LIGHT:
2643
        CHKPARAM(3);
2644

2645
        GETINT(rp->custom->description->map.id_light, params[3]);
2646

2647
        break;
2648

2649
      case EDJE_STATE_PARAM_MAP_ROT_CENTER:
2650
        CHKPARAM(3);
2651

2652
        GETINT(rp->custom->description->map.rot.id_center, params[3]);
2653

2654
        break;
2655

2656
      case EDJE_STATE_PARAM_MAP_ROT_X:
2657
        CHKPARAM(3);
2658

2659
        GETFLOAT_T(rp->custom->description->map.rot.x, params[3]);
2660

2661
        break;
2662

2663
      case EDJE_STATE_PARAM_MAP_ROT_Y:
2664
        CHKPARAM(3);
2665

2666
        GETFLOAT_T(rp->custom->description->map.rot.y, params[3]);
2667

2668
        break;
2669

2670
      case EDJE_STATE_PARAM_MAP_ROT_Z:
2671
        CHKPARAM(3);
2672

2673
        GETFLOAT_T(rp->custom->description->map.rot.z, params[3]);
2674

2675
        break;
2676

2677
      case EDJE_STATE_PARAM_MAP_BACK_CULL:
2678
        CHKPARAM(3);
2679

2680
        GETINT(rp->custom->description->map.backcull, params[3]);
2681

2682
        break;
2683

2684
      case EDJE_STATE_PARAM_MAP_PERSP_ON:
2685
        CHKPARAM(3);
2686

2687
        GETINT(rp->custom->description->map.persp_on, params[3]);
2688

2689
        break;
2690

2691
      case EDJE_STATE_PARAM_PERSP_ZPLANE:
2692
        CHKPARAM(3);
2693

2694
        GETINT(rp->custom->description->persp.zplane, params[3]);
2695

2696
        break;
2697

2698
      case EDJE_STATE_PARAM_PERSP_FOCAL:
2699
        CHKPARAM(3);
2700

2701
        GETINT(rp->custom->description->persp.focal, params[3]);
2702

2703
        break;
2704

2705
      case EDJE_STATE_PARAM_PROXY_SRC_CLIP:
2706
      {
2707
         Edje_Part_Description_Proxy *proxy;
2708

2709
         if ((rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
2710
         CHKPARAM(3);
2711

2712
         proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
2713
         GETINT(proxy->proxy.source_clip, params[3]);
2714

2715
         break;
2716
      }
2717

2718
      case EDJE_STATE_PARAM_PROXY_SRC_VISIBLE:
2719
      {
2720
         Edje_Part_Description_Proxy *proxy;
2721

2722
         if ((rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
2723
         CHKPARAM(3);
2724

2725
         proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
2726
         GETINT(proxy->proxy.source_visible, params[3]);
2727

2728
         break;
2729
      }
2730

2731
      case EDJE_STATE_PARAM_BOX_LAYOUT:
2732
      {
2733
         Edje_Part_Description_Box *box;
2734
         if ((rp->part->type != EDJE_PART_TYPE_BOX)) return 0;
2735
         CHKPARAM(3);
2736

2737
         GETSTR(s, params[3]);
2738
         s = strdup(s);
2739

2740
         box = (Edje_Part_Description_Box *)rp->custom->description;
2741
         box->box.layout = s;
2742

2743
         break;
2744
      }
2745

2746
      case EDJE_STATE_PARAM_BOX_FALLBACK_LAYOUT:
2747
      {
2748
         Edje_Part_Description_Box *box;
2749
         if ((rp->part->type != EDJE_PART_TYPE_BOX)) return 0;
2750
         CHKPARAM(3);
2751

2752
         GETSTR(s, params[3]);
2753
         s = strdup(s);
2754

2755
         box = (Edje_Part_Description_Box *)rp->custom->description;
2756
         box->box.alt_layout = s;
2757

2758
         break;
2759
      }
2760

2761
      case EDJE_STATE_PARAM_BOX_ALIGN:
2762
      {
2763
         Edje_Part_Description_Box *box;
2764
         if ((rp->part->type != EDJE_PART_TYPE_BOX)) return 0;
2765
         CHKPARAM(4);
2766

2767
         box = (Edje_Part_Description_Box *)rp->custom->description;
2768
         GETFLOAT_T(box->box.align.x, params[3]);
2769
         GETFLOAT_T(box->box.align.y, params[4]);
2770

2771
         break;
2772
      }
2773

2774
      case EDJE_STATE_PARAM_BOX_PADDING:
2775
      {
2776
         Edje_Part_Description_Box *box;
2777
         if ((rp->part->type != EDJE_PART_TYPE_BOX)) return 0;
2778
         CHKPARAM(4);
2779

2780
         box = (Edje_Part_Description_Box *)rp->custom->description;
2781
         GETINT(box->box.padding.x, params[3]);
2782
         GETINT(box->box.padding.y, params[4]);
2783

2784
         break;
2785
      }
2786

2787
      case EDJE_STATE_PARAM_BOX_MIN:
2788
      {
2789
         Edje_Part_Description_Box *box;
2790
         if ((rp->part->type != EDJE_PART_TYPE_BOX)) return 0;
2791
         CHKPARAM(4);
2792

2793
         box = (Edje_Part_Description_Box *)rp->custom->description;
2794
         GETINT(box->box.min.h, params[3]);
2795
         GETINT(box->box.min.v, params[4]);
2796

2797
         break;
2798
      }
2799

2800
#ifdef HAVE_EPHYSICS
2801
      case EDJE_STATE_PARAM_PHYSICS_MASS:
2802
        CHKPARAM(3);
2803

2804
        GETFLOAT_T(rp->custom->description->physics.mass, params[3]);
2805

2806
        break;
2807

2808
      case EDJE_STATE_PARAM_PHYSICS_RESTITUTION:
2809
        CHKPARAM(3);
2810

2811
        GETFLOAT_T(rp->custom->description->physics.restitution, params[3]);
2812

2813
        break;
2814

2815
      case EDJE_STATE_PARAM_PHYSICS_FRICTION:
2816
        CHKPARAM(3);
2817

2818
        GETFLOAT_T(rp->custom->description->physics.friction, params[3]);
2819

2820
        break;
2821

2822
      case EDJE_STATE_PARAM_PHYSICS_DAMPING:
2823
        CHKPARAM(4);
2824

2825
        GETFLOAT_T(rp->custom->description->physics.damping.linear, params[3]);
2826
        GETFLOAT_T(rp->custom->description->physics.damping.angular,
2827
                   params[4]);
2828

2829
        break;
2830

2831
      case EDJE_STATE_PARAM_PHYSICS_SLEEP:
2832
        CHKPARAM(4);
2833

2834
        GETFLOAT_T(rp->custom->description->physics.sleep.linear, params[3]);
2835
        GETFLOAT_T(rp->custom->description->physics.sleep.angular, params[4]);
2836

2837
        break;
2838

2839
      case EDJE_STATE_PARAM_PHYSICS_MATERIAL:
2840
        CHKPARAM(3);
2841

2842
        GETINT(rp->custom->description->physics.material, params[3]);
2843
        break;
2844

2845
      case EDJE_STATE_PARAM_PHYSICS_DENSITY:
2846
        CHKPARAM(3);
2847

2848
        GETFLOAT_T(rp->custom->description->physics.density, params[3]);
2849
        break;
2850

2851
      case EDJE_STATE_PARAM_PHYSICS_HARDNESS:
2852
        CHKPARAM(3);
2853

2854
        GETFLOAT_T(rp->custom->description->physics.hardness, params[3]);
2855
        break;
2856

2857
      case EDJE_STATE_PARAM_PHYSICS_IGNORE_PART_POS:
2858
        CHKPARAM(3);
2859

2860
        GETINT(rp->custom->description->physics.ignore_part_pos, params[3]);
2861
        break;
2862

2863
      case EDJE_STATE_PARAM_PHYSICS_LIGHT_ON:
2864
        CHKPARAM(3);
2865

2866
        GETINT(rp->custom->description->physics.light_on, params[3]);
2867
        break;
2868

2869
      case EDJE_STATE_PARAM_PHYSICS_MOV_FREEDOM_LIN:
2870
        CHKPARAM(5);
2871

2872
        GETINT(rp->custom->description->physics.mov_freedom.lin.x, params[3]);
2873
        GETINT(rp->custom->description->physics.mov_freedom.lin.y, params[4]);
2874
        GETINT(rp->custom->description->physics.mov_freedom.lin.z, params[5]);
2875
        break;
2876

2877
      case EDJE_STATE_PARAM_PHYSICS_MOV_FREEDOM_ANG:
2878
        CHKPARAM(5);
2879

2880
        GETINT(rp->custom->description->physics.mov_freedom.ang.x, params[3]);
2881
        GETINT(rp->custom->description->physics.mov_freedom.ang.y, params[4]);
2882
        GETINT(rp->custom->description->physics.mov_freedom.ang.z, params[5]);
2883
        break;
2884

2885
      case EDJE_STATE_PARAM_PHYSICS_BACK_CULL:
2886
        CHKPARAM(3);
2887

2888
        GETINT(rp->custom->description->physics.backcull, params[3]);
2889
        break;
2890

2891
      case EDJE_STATE_PARAM_PHYSICS_Z:
2892
        CHKPARAM(3);
2893

2894
        GETINT(rp->custom->description->physics.z, params[3]);
2895
        break;
2896

2897
      case EDJE_STATE_PARAM_PHYSICS_DEPTH:
2898
        CHKPARAM(3);
2899

2900
        GETINT(rp->custom->description->physics.depth, params[3]);
2901
        break;
2902

2903
#endif
2904
      default:
2905
        break;
2906
     }
2907

2908
#ifdef EDJE_CALC_CACHE
2909
   rp->invalidate = EINA_TRUE;
2910
#endif
2911
   ed->dirty = EINA_TRUE;
2912
   return 0;
2913
}
2914

2915
/* get_state_val(part_id, State_Param:p, ...) */
2916
static Embryo_Cell
2917
_edje_embryo_fn_get_state_val(Embryo_Program *ep, Embryo_Cell *params)
2918
{
2919
   Edje *ed = embryo_program_data_get(ep);
2920
   Edje_Real_Part *rp;
2921
   const char *s;
2922

2923
   /* we need at least 3 arguments */
2924
   if (params[0] < (int)(sizeof(Embryo_Cell) * 3))
2925
     return 0;
2926

2927
   if (params[1] < 0)
2928
     return 0;
2929

2930
   if (!(rp = ed->table_parts[params[1] % ed->table_parts_size]))
2931
     return 0;
2932

2933
   /* check whether this part has a "custom" state */
2934
   if (!rp->custom)
2935
     return 0;
2936

2937
   switch (params[2])
2938
     {
2939
      case EDJE_STATE_PARAM_ALIGNMENT:
2940
        CHKPARAM(4);
2941

2942
        SETFLOAT_T(rp->custom->description->align.x, params[3]);
2943
        SETFLOAT_T(rp->custom->description->align.y, params[4]);
2944

2945
        break;
2946

2947
      case EDJE_STATE_PARAM_MIN:
2948
        CHKPARAM(4);
2949

2950
        SETINT(rp->custom->description->min.w, params[3]);
2951
        SETINT(rp->custom->description->min.h, params[4]);
2952

2953
        break;
2954

2955
      case EDJE_STATE_PARAM_MAX:
2956
        CHKPARAM(4);
2957

2958
        SETINT(rp->custom->description->max.w, params[3]);
2959
        SETINT(rp->custom->description->max.h, params[4]);
2960

2961
        break;
2962

2963
      case EDJE_STATE_PARAM_STEP:
2964
        CHKPARAM(4);
2965

2966
        SETINT(rp->custom->description->step.x, params[3]);
2967
        SETINT(rp->custom->description->step.y, params[4]);
2968

2969
        break;
2970

2971
      case EDJE_STATE_PARAM_ASPECT:
2972
        CHKPARAM(4);
2973

2974
        SETFLOAT_T(rp->custom->description->aspect.min, params[3]);
2975
        SETFLOAT_T(rp->custom->description->aspect.max, params[4]);
2976

2977
        break;
2978

2979
      case EDJE_STATE_PARAM_ASPECT_PREF:
2980
        CHKPARAM(3);
2981

2982
        SETINT(rp->custom->description->aspect.prefer, params[3]);
2983

2984
        break;
2985

2986
      case EDJE_STATE_PARAM_COLOR:
2987
        CHKPARAM(6);
2988

2989
        SETINT(rp->custom->description->color.r, params[3]);
2990
        SETINT(rp->custom->description->color.g, params[4]);
2991
        SETINT(rp->custom->description->color.b, params[5]);
2992
        SETINT(rp->custom->description->color.a, params[6]);
2993

2994
        break;
2995

2996
      case EDJE_STATE_PARAM_COLOR2:
2997
        CHKPARAM(6);
2998

2999
        SETINT(rp->custom->description->color2.r, params[3]);
3000
        SETINT(rp->custom->description->color2.g, params[4]);
3001
        SETINT(rp->custom->description->color2.b, params[5]);
3002
        SETINT(rp->custom->description->color2.a, params[6]);
3003

3004
        break;
3005

3006
      case EDJE_STATE_PARAM_COLOR3:
3007
      {
3008
         Edje_Part_Description_Text *text;
3009

3010
         if (rp->part->type == EDJE_PART_TYPE_TEXT
3011
             || rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
3012
           return 0;
3013

3014
         CHKPARAM(6);
3015

3016
         text = (Edje_Part_Description_Text *)rp->custom->description;
3017

3018
         SETINT(text->text.color3.r, params[3]);
3019
         SETINT(text->text.color3.g, params[4]);
3020
         SETINT(text->text.color3.b, params[5]);
3021
         SETINT(text->text.color3.a, params[6]);
3022

3023
         break;
3024
      }
3025

3026
      case EDJE_STATE_PARAM_COLOR_CLASS:
3027
        CHKPARAM(4);
3028

3029
        s = rp->custom->description->color_class;
3030
        SETSTRALLOCATE(s);
3031

3032
        break;
3033

3034
      case EDJE_STATE_PARAM_REL1:
3035
        CHKPARAM(4);
3036

3037
        SETFLOAT_T(rp->custom->description->rel1.relative_x, params[3]);
3038
        SETFLOAT_T(rp->custom->description->rel1.relative_y, params[4]);
3039

3040
        break;
3041

3042
      case EDJE_STATE_PARAM_REL1_TO:
3043
        CHKPARAM(4);
3044

3045
        SETINT(rp->custom->description->rel1.id_x, params[3]);
3046
        SETINT(rp->custom->description->rel1.id_y, params[4]);
3047

3048
        break;
3049

3050
      case EDJE_STATE_PARAM_REL1_OFFSET:
3051
        CHKPARAM(4);
3052

3053
        SETINT(rp->custom->description->rel1.offset_x, params[3]);
3054
        SETINT(rp->custom->description->rel1.offset_y, params[4]);
3055

3056
        break;
3057

3058
      case EDJE_STATE_PARAM_REL2:
3059
        CHKPARAM(4);
3060

3061
        SETFLOAT_T(rp->custom->description->rel2.relative_x, params[3]);
3062
        SETFLOAT_T(rp->custom->description->rel2.relative_y, params[4]);
3063

3064
        break;
3065

3066
      case EDJE_STATE_PARAM_REL2_TO:
3067
        CHKPARAM(4);
3068

3069
        SETINT(rp->custom->description->rel2.id_x, params[3]);
3070
        SETINT(rp->custom->description->rel2.id_y, params[4]);
3071

3072
        break;
3073

3074
      case EDJE_STATE_PARAM_REL2_OFFSET:
3075
        CHKPARAM(4);
3076

3077
        SETINT(rp->custom->description->rel2.offset_x, params[3]);
3078
        SETINT(rp->custom->description->rel2.offset_y, params[4]);
3079

3080
        break;
3081

3082
      case EDJE_STATE_PARAM_IMAGE:
3083
      {
3084
         Edje_Part_Description_Image *img;
3085

3086
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE)) return 0;
3087
         CHKPARAM(3);
3088

3089
         img = (Edje_Part_Description_Image *)rp->custom->description;
3090

3091
         SETINT(img->image.id, params[3]);
3092

3093
         break;
3094
      }
3095

3096
      case EDJE_STATE_PARAM_BORDER:
3097
      {
3098
         Edje_Part_Description_Image *img;
3099

3100
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE)) return 0;
3101
         CHKPARAM(6);
3102

3103
         img = (Edje_Part_Description_Image *)rp->custom->description;
3104

3105
         SETINT(img->image.border.l, params[3]);
3106
         SETINT(img->image.border.r, params[4]);
3107
         SETINT(img->image.border.t, params[5]);
3108
         SETINT(img->image.border.b, params[6]);
3109

3110
         break;
3111
      }
3112

3113
      case EDJE_STATE_PARAM_FILL_SMOOTH:
3114
      {
3115
         Edje_Part_Description_Image *img;
3116
         Edje_Part_Description_Proxy *proxy;
3117

3118
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE) && (rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
3119
         CHKPARAM(3);
3120

3121
         if (rp->part->type == EDJE_PART_TYPE_IMAGE)
3122
           {
3123
              img = (Edje_Part_Description_Image *)rp->custom->description;
3124

3125
              SETINT(img->image.fill.smooth, params[3]);
3126
           }
3127
         else
3128
           {
3129
              proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
3130

3131
              SETINT(proxy->proxy.fill.smooth, params[3]);
3132
           }
3133

3134
         break;
3135
      }
3136

3137
      case EDJE_STATE_PARAM_FILL_POS:
3138
      {
3139
         Edje_Part_Description_Image *img;
3140
         Edje_Part_Description_Proxy *proxy;
3141

3142
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE) && (rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
3143
         CHKPARAM(6);
3144

3145
         if (rp->part->type == EDJE_PART_TYPE_IMAGE)
3146
           {
3147
              img = (Edje_Part_Description_Image *)rp->custom->description;
3148

3149
              SETFLOAT_T(img->image.fill.pos_rel_x, params[3]);
3150
              SETFLOAT_T(img->image.fill.pos_rel_y, params[4]);
3151
              SETINT(img->image.fill.pos_abs_x, params[5]);
3152
              SETINT(img->image.fill.pos_abs_y, params[6]);
3153
           }
3154
         else
3155
           {
3156
              proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
3157

3158
              SETFLOAT_T(proxy->proxy.fill.pos_rel_x, params[3]);
3159
              SETFLOAT_T(proxy->proxy.fill.pos_rel_y, params[4]);
3160
              SETINT(proxy->proxy.fill.pos_abs_x, params[5]);
3161
              SETINT(proxy->proxy.fill.pos_abs_y, params[6]);
3162
           }
3163

3164
         break;
3165
      }
3166

3167
      case EDJE_STATE_PARAM_FILL_SIZE:
3168
      {
3169
         Edje_Part_Description_Image *img;
3170
         Edje_Part_Description_Proxy *proxy;
3171

3172
         if ((rp->part->type != EDJE_PART_TYPE_IMAGE) && (rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
3173
         CHKPARAM(6);
3174

3175
         if (rp->part->type == EDJE_PART_TYPE_IMAGE)
3176
           {
3177
              img = (Edje_Part_Description_Image *)rp->custom->description;
3178

3179
              SETFLOAT_T(img->image.fill.rel_x, params[3]);
3180
              SETFLOAT_T(img->image.fill.rel_y, params[4]);
3181
              SETINT(img->image.fill.abs_x, params[5]);
3182
              SETINT(img->image.fill.abs_y, params[6]);
3183
           }
3184
         else
3185
           {
3186
              proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
3187

3188
              SETFLOAT_T(proxy->proxy.fill.rel_x, params[3]);
3189
              SETFLOAT_T(proxy->proxy.fill.rel_y, params[4]);
3190
              SETINT(proxy->proxy.fill.abs_x, params[5]);
3191
              SETINT(proxy->proxy.fill.abs_y, params[6]);
3192
           }
3193

3194
         break;
3195
      }
3196

3197
      case EDJE_STATE_PARAM_TEXT:
3198
      {
3199
         Edje_Part_Description_Text *text;
3200

3201
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
3202
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
3203
           return 0;
3204

3205
         CHKPARAM(4);
3206

3207
         text = (Edje_Part_Description_Text *)rp->custom->description;
3208

3209
         s = (char *)text->text.text.str;
3210
         SETSTRALLOCATE(s);
3211

3212
         break;
3213
      }
3214

3215
      case EDJE_STATE_PARAM_TEXT_CLASS:
3216
      {
3217
         Edje_Part_Description_Text *text;
3218

3219
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
3220
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
3221
           return 0;
3222

3223
         CHKPARAM(4);
3224

3225
         text = (Edje_Part_Description_Text *)rp->custom->description;
3226

3227
         s = text->text.text_class;
3228
         SETSTRALLOCATE(s);
3229

3230
         break;
3231
      }
3232

3233
      case EDJE_STATE_PARAM_TEXT_FONT:
3234
      {
3235
         Edje_Part_Description_Text *text;
3236

3237
         if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
3238

3239
         CHKPARAM(4);
3240

3241
         text = (Edje_Part_Description_Text *)rp->custom->description;
3242

3243
         s = (char *)text->text.font.str;
3244
         SETSTRALLOCATE(s);
3245

3246
         break;
3247
      }
3248

3249
      case EDJE_STATE_PARAM_TEXT_STYLE:
3250
      {
3251
         Edje_Part_Description_Text *text;
3252

3253
         if ((rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return 0;
3254

3255
         CHKPARAM(4);
3256

3257
         text = (Edje_Part_Description_Text *)rp->custom->description;
3258

3259
         s = (char *)text->text.style.str;
3260
         SETSTRALLOCATE(s);
3261

3262
         break;
3263
      }
3264

3265
      case EDJE_STATE_PARAM_TEXT_SIZE:
3266
      {
3267
         Edje_Part_Description_Text *text;
3268

3269
         if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
3270

3271
         CHKPARAM(3);
3272

3273
         text = (Edje_Part_Description_Text *)rp->custom->description;
3274

3275
         SETINT(text->text.size, params[3]);
3276

3277
         break;
3278
      }
3279

3280
      case EDJE_STATE_PARAM_TEXT_FIT:
3281
      {
3282
         Edje_Part_Description_Text *text;
3283

3284
         if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
3285
         CHKPARAM(4);
3286

3287
         text = (Edje_Part_Description_Text *)rp->custom->description;
3288

3289
         SETINT(text->text.fit_x, params[3]);
3290
         SETINT(text->text.fit_y, params[4]);
3291

3292
         break;
3293
      }
3294

3295
      case EDJE_STATE_PARAM_TEXT_MIN:
3296
      {
3297
         Edje_Part_Description_Text *text;
3298

3299
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
3300
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
3301
           return 0;
3302

3303
         CHKPARAM(4);
3304

3305
         text = (Edje_Part_Description_Text *)rp->custom->description;
3306

3307
         SETINT(text->text.min_x, params[3]);
3308
         SETINT(text->text.min_y, params[4]);
3309

3310
         break;
3311
      }
3312

3313
      case EDJE_STATE_PARAM_TEXT_MAX:
3314
      {
3315
         Edje_Part_Description_Text *text;
3316

3317
         if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
3318
             (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
3319
           return 0;
3320

3321
         CHKPARAM(4);
3322

3323
         text = (Edje_Part_Description_Text *)rp->custom->description;
3324

3325
         SETINT(text->text.max_x, params[3]);
3326
         SETINT(text->text.max_y, params[4]);
3327

3328
         break;
3329
      }
3330

3331
      case EDJE_STATE_PARAM_TEXT_ALIGN:
3332
      {
3333
         Edje_Part_Description_Text *text;
3334

3335
         if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
3336

3337
         CHKPARAM(4);
3338

3339
         text = (Edje_Part_Description_Text *)rp->custom->description;
3340

3341
         SETFLOAT_T(text->text.align.x, params[3]);
3342
         SETFLOAT_T(text->text.align.y, params[4]);
3343

3344
         break;
3345
      }
3346

3347
      case EDJE_STATE_PARAM_VISIBLE:
3348
        CHKPARAM(3);
3349

3350
        SETINT(rp->custom->description->visible, params[3]);
3351

3352
        break;
3353

3354
      case EDJE_STATE_PARAM_MAP_ON:
3355
        CHKPARAM(3);
3356

3357
        SETINT(rp->custom->description->map.on, params[3]);
3358

3359
        break;
3360

3361
      case EDJE_STATE_PARAM_MAP_PERSP:
3362
        CHKPARAM(3);
3363

3364
        SETINT(rp->custom->description->map.id_persp, params[3]);
3365

3366
        break;
3367

3368
      case EDJE_STATE_PARAM_MAP_LIGHT:
3369
        CHKPARAM(3);
3370

3371
        SETINT(rp->custom->description->map.id_light, params[3]);
3372

3373
        break;
3374

3375
      case EDJE_STATE_PARAM_MAP_ROT_CENTER:
3376
        CHKPARAM(3);
3377

3378
        SETINT(rp->custom->description->map.rot.id_center, params[3]);
3379

3380
        break;
3381

3382
      case EDJE_STATE_PARAM_MAP_ROT_X:
3383
        CHKPARAM(3);
3384

3385
        SETFLOAT_T(rp->custom->description->map.rot.x, params[3]);
3386

3387
        break;
3388

3389
      case EDJE_STATE_PARAM_MAP_ROT_Y:
3390
        CHKPARAM(3);
3391

3392
        SETFLOAT_T(rp->custom->description->map.rot.y, params[3]);
3393

3394
        break;
3395

3396
      case EDJE_STATE_PARAM_MAP_ROT_Z:
3397
        CHKPARAM(3);
3398

3399
        SETFLOAT_T(rp->custom->description->map.rot.z, params[3]);
3400

3401
        break;
3402

3403
      case EDJE_STATE_PARAM_MAP_BACK_CULL:
3404
        CHKPARAM(3);
3405

3406
        SETINT(rp->custom->description->map.backcull, params[3]);
3407

3408
        break;
3409

3410
      case EDJE_STATE_PARAM_MAP_PERSP_ON:
3411
        CHKPARAM(3);
3412

3413
        SETINT(rp->custom->description->map.persp_on, params[3]);
3414

3415
        break;
3416

3417
      case EDJE_STATE_PARAM_PERSP_ZPLANE:
3418
        CHKPARAM(3);
3419

3420
        SETINT(rp->custom->description->persp.zplane, params[3]);
3421

3422
        break;
3423

3424
      case EDJE_STATE_PARAM_PERSP_FOCAL:
3425
        CHKPARAM(3);
3426

3427
        SETINT(rp->custom->description->persp.focal, params[3]);
3428

3429
        break;
3430

3431
      case EDJE_STATE_PARAM_PROXY_SRC_CLIP:
3432
      {
3433
         Edje_Part_Description_Proxy *proxy;
3434

3435
         if ((rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
3436
         CHKPARAM(3);
3437

3438
         proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
3439
         SETINT(proxy->proxy.source_clip, params[3]);
3440

3441
         break;
3442
      }
3443

3444
      case EDJE_STATE_PARAM_PROXY_SRC_VISIBLE:
3445
      {
3446
         Edje_Part_Description_Proxy *proxy;
3447

3448
         if ((rp->part->type != EDJE_PART_TYPE_PROXY)) return 0;
3449
         CHKPARAM(3);
3450

3451
         proxy = (Edje_Part_Description_Proxy *)rp->custom->description;
3452
         SETINT(proxy->proxy.source_visible, params[3]);
3453

3454
         break;
3455
      }
3456

3457
#ifdef HAVE_EPHYSICS
3458
      case EDJE_STATE_PARAM_PHYSICS_MASS:
3459
        CHKPARAM(3);
3460

3461
        SETFLOAT_T(rp->custom->description->physics.mass, params[3]);
3462

3463
        break;
3464

3465
      case EDJE_STATE_PARAM_PHYSICS_RESTITUTION:
3466
        CHKPARAM(3);
3467

3468
        SETFLOAT_T(rp->custom->description->physics.restitution, params[3]);
3469

3470
        break;
3471

3472
      case EDJE_STATE_PARAM_PHYSICS_FRICTION:
3473
        CHKPARAM(3);
3474

3475
        SETFLOAT_T(rp->custom->description->physics.friction, params[3]);
3476

3477
        break;
3478

3479
      case EDJE_STATE_PARAM_PHYSICS_DAMPING:
3480
        CHKPARAM(4);
3481

3482
        SETFLOAT_T(rp->custom->description->physics.damping.linear, params[3]);
3483
        SETFLOAT_T(rp->custom->description->physics.damping.angular,
3484
                   params[4]);
3485

3486
        break;
3487

3488
      case EDJE_STATE_PARAM_PHYSICS_SLEEP:
3489
        CHKPARAM(4);
3490

3491
        SETFLOAT_T(rp->custom->description->physics.sleep.linear, params[3]);
3492
        SETFLOAT_T(rp->custom->description->physics.sleep.angular, params[4]);
3493

3494
        break;
3495

3496
      case EDJE_STATE_PARAM_PHYSICS_MATERIAL:
3497
        CHKPARAM(3);
3498

3499
        SETINT(rp->custom->description->physics.material, params[3]);
3500
        break;
3501

3502
      case EDJE_STATE_PARAM_PHYSICS_DENSITY:
3503
        CHKPARAM(3);
3504

3505
        SETFLOAT_T(rp->custom->description->physics.density, params[3]);
3506
        break;
3507

3508
      case EDJE_STATE_PARAM_PHYSICS_HARDNESS:
3509
        CHKPARAM(3);
3510

3511
        SETFLOAT_T(rp->custom->description->physics.hardness, params[3]);
3512
        break;
3513

3514
      case EDJE_STATE_PARAM_PHYSICS_IGNORE_PART_POS:
3515
        CHKPARAM(3);
3516

3517
        SETINT(rp->custom->description->physics.ignore_part_pos, params[3]);
3518
        break;
3519

3520
      case EDJE_STATE_PARAM_PHYSICS_LIGHT_ON:
3521
        CHKPARAM(3);
3522

3523
        SETINT(rp->custom->description->physics.light_on, params[3]);
3524
        break;
3525

3526
      case EDJE_STATE_PARAM_PHYSICS_MOV_FREEDOM_LIN:
3527
        CHKPARAM(5);
3528

3529
        SETINT(rp->custom->description->physics.mov_freedom.lin.x, params[3]);
3530
        SETINT(rp->custom->description->physics.mov_freedom.lin.y, params[4]);
3531
        SETINT(rp->custom->description->physics.mov_freedom.lin.z, params[5]);
3532
        break;
3533

3534
      case EDJE_STATE_PARAM_PHYSICS_MOV_FREEDOM_ANG:
3535
        CHKPARAM(5);
3536

3537
        SETINT(rp->custom->description->physics.mov_freedom.ang.x, params[3]);
3538
        SETINT(rp->custom->description->physics.mov_freedom.ang.y, params[4]);
3539
        SETINT(rp->custom->description->physics.mov_freedom.ang.z, params[5]);
3540
        break;
3541

3542
      case EDJE_STATE_PARAM_PHYSICS_BACK_CULL:
3543
        CHKPARAM(3);
3544

3545
        SETINT(rp->custom->description->physics.backcull, params[3]);
3546
        break;
3547

3548
      case EDJE_STATE_PARAM_PHYSICS_Z:
3549
        CHKPARAM(3);
3550

3551
        SETINT(rp->custom->description->physics.z, params[3]);
3552
        break;
3553

3554
      case EDJE_STATE_PARAM_PHYSICS_DEPTH:
3555
        CHKPARAM(3);
3556

3557
        SETINT(rp->custom->description->physics.depth, params[3]);
3558
        break;
3559

3560
#endif
3561
      default:
3562
        break;
3563
     }
3564

3565
   return 0;
3566
}
3567

3568
/* set_mouse_events(part_id, ev) */
3569
static Embryo_Cell
3570
_edje_embryo_fn_set_mouse_events(Embryo_Program *ep, Embryo_Cell *params)
3571
{
3572
   int part_id = 0;
3573
   Edje *ed;
3574
   Edje_Real_Part *rp;
3575

3576
   CHKPARAM(2);
3577

3578
   part_id = params[1];
3579
   if (part_id < 0) return 0;
3580

3581
   ed = embryo_program_data_get(ep);
3582
   rp = ed->table_parts[part_id % ed->table_parts_size];
3583

3584
   if (rp)
3585
     _edje_real_part_mouse_events_set(ed, rp, params[2]);
3586

3587
   return 0;
3588
}
3589

3590
/* get_mouse_events(part_id) */
3591
static Embryo_Cell
3592
_edje_embryo_fn_get_mouse_events(Embryo_Program *ep, Embryo_Cell *params)
3593
{
3594
   int part_id = 0;
3595
   Edje *ed;
3596
   Edje_Real_Part *rp;
3597

3598
   CHKPARAM(1);
3599

3600
   part_id = params[1];
3601
   if (part_id < 0) return 0;
3602

3603
   ed = embryo_program_data_get(ep);
3604
   rp = ed->table_parts[part_id % ed->table_parts_size];
3605

3606
   if (rp)
3607
     return (Embryo_Cell)_edje_var_int_get(ed, (int)_edje_real_part_mouse_events_get(ed, rp));
3608

3609
   return 0;
3610

3611
}
3612

3613
/* set_pointer_mode(part_id, mode) */
3614
static Embryo_Cell
3615
_edje_embryo_fn_set_pointer_mode(Embryo_Program *ep, Embryo_Cell *params)
3616
{
3617
   int part_id = 0;
3618
   Edje *ed;
3619
   Edje_Real_Part *rp;
3620

3621
   CHKPARAM(2);
3622

3623
   part_id = params[1];
3624
   if (part_id < 0) return 0;
3625

3626
   ed = embryo_program_data_get(ep);
3627
   rp = ed->table_parts[part_id % ed->table_parts_size];
3628

3629
   if (rp)
3630
     _edje_real_part_pointer_mode_set(ed, rp, params[2]);
3631

3632
   return 0;
3633
}
3634

3635
/* set_repeat_events(part_id, rep) */
3636
static Embryo_Cell
3637
_edje_embryo_fn_set_repeat_events(Embryo_Program *ep, Embryo_Cell *params)
3638
{
3639
   int part_id = 0;
3640
   Edje *ed;
3641
   Edje_Real_Part *rp;
3642

3643
   CHKPARAM(2);
3644

3645
   part_id = params[1];
3646
   if (part_id < 0) return 0;
3647

3648
   ed = embryo_program_data_get(ep);
3649
   rp = ed->table_parts[part_id % ed->table_parts_size];
3650

3651
   if (rp)
3652
     _edje_real_part_repeat_events_set(ed, rp, params[2]);
3653

3654
   return 0;
3655
}
3656

3657
/* get_repeat_events(part_id) */
3658
static Embryo_Cell
3659
_edje_embryo_fn_get_repeat_events(Embryo_Program *ep, Embryo_Cell *params)
3660
{
3661
   int part_id = 0;
3662
   Edje *ed;
3663
   Edje_Real_Part *rp;
3664

3665
   CHKPARAM(1);
3666

3667
   part_id = params[1];
3668
   if (part_id < 0) return 0;
3669

3670
   ed = embryo_program_data_get(ep);
3671
   rp = ed->table_parts[part_id % ed->table_parts_size];
3672

3673
   if (rp)
3674
     return (Embryo_Cell)_edje_var_int_get(ed, (int)_edje_real_part_repeat_events_get(ed, rp));
3675

3676
   return 0;
3677

3678
}
3679

3680
/* set_ignore_flags(part_id, flags) */
3681
static Embryo_Cell
3682
_edje_embryo_fn_set_ignore_flags(Embryo_Program *ep, Embryo_Cell *params)
3683
{
3684
   int part_id = 0;
3685
   Edje *ed;
3686
   Edje_Real_Part *rp;
3687

3688
   CHKPARAM(2);
3689

3690
   part_id = params[1];
3691
   if (part_id < 0) return 0;
3692

3693
   ed = embryo_program_data_get(ep);
3694
   rp = ed->table_parts[part_id % ed->table_parts_size];
3695

3696
   if (rp)
3697
     _edje_real_part_ignore_flags_set(ed, rp, params[2]);
3698

3699
   return 0;
3700
}
3701

3702
/* get_ignore_flags(part_id) */
3703
static Embryo_Cell
3704
_edje_embryo_fn_get_ignore_flags(Embryo_Program *ep, Embryo_Cell *params)
3705
{
3706
   int part_id = 0;
3707
   Edje *ed;
3708
   Edje_Real_Part *rp;
3709

3710
   CHKPARAM(1);
3711

3712
   part_id = params[1];
3713
   if (part_id < 0) return 0;
3714

3715
   ed = embryo_program_data_get(ep);
3716
   rp = ed->table_parts[part_id % ed->table_parts_size];
3717

3718
   if (rp)
3719
     return (Embryo_Cell)_edje_var_int_get(ed, (int)_edje_real_part_ignore_flags_get(ed, rp));
3720

3721
   return 0;
3722

3723
}
3724

3725
/* set_mask_flags(part_id, flags) */
3726
static Embryo_Cell
3727
_edje_embryo_fn_set_mask_flags(Embryo_Program *ep, Embryo_Cell *params)
3728
{
3729
   int part_id = 0;
3730
   Edje *ed;
3731
   Edje_Real_Part *rp;
3732

3733
   CHKPARAM(2);
3734

3735
   part_id = params[1];
3736
   if (part_id < 0) return 0;
3737

3738
   ed = embryo_program_data_get(ep);
3739
   rp = ed->table_parts[part_id % ed->table_parts_size];
3740

3741
   if (rp)
3742
     _edje_real_part_mask_flags_set(ed, rp, params[2]);
3743

3744
   return 0;
3745
}
3746

3747
/* get_mask_flags(part_id) */
3748
static Embryo_Cell
3749
_edje_embryo_fn_get_mask_flags(Embryo_Program *ep, Embryo_Cell *params)
3750
{
3751
   int part_id = 0;
3752
   Edje *ed;
3753
   Edje_Real_Part *rp;
3754

3755
   CHKPARAM(1);
3756

3757
   part_id = params[1];
3758
   if (part_id < 0) return 0;
3759

3760
   ed = embryo_program_data_get(ep);
3761
   rp = ed->table_parts[part_id % ed->table_parts_size];
3762

3763
   if (rp)
3764
     return (Embryo_Cell)_edje_var_int_get(ed, (int)_edje_real_part_mask_flags_get(ed, rp));
3765

3766
   return 0;
3767

3768
}
3769

3770
/* part_swallow(part_id, group_name) */
3771
static Embryo_Cell
3772
_edje_embryo_fn_part_swallow(Embryo_Program *ep, Embryo_Cell *params)
3773
{
3774
   int part_id = 0;
3775
   char *group_name = 0;
3776
   Edje *ed;
3777
   Edje_Real_Part *rp;
3778
   Evas_Object *new_obj;
3779

3780
   CHKPARAM(2);
3781

3782
   part_id = params[1];
3783
   if (part_id < 0) return 0;
3784

3785
   GETSTR(group_name, params[2]);
3786
   if (!group_name) return 0;
3787

3788
   ed = embryo_program_data_get(ep);
3789

3790
   rp = ed->table_parts[part_id % ed->table_parts_size];
3791
   if (!rp) return 0;
3792

3793
   new_obj = edje_object_add(ed->base.evas);
3794
   if (!new_obj) return 0;
3795

3796
   if (!edje_object_file_set(new_obj, ed->file->path, group_name))
3797
     {
3798
        evas_object_del(new_obj);
3799
        return 0;
3800
     }
3801
   edje_object_part_swallow(ed->obj, rp->part->name, new_obj);
3802
   _edje_subobj_register(ed, new_obj);
3803

3804
   return 0;
3805
}
3806

3807
/* set_focus(part_id, seat_name[]) */
3808
static Embryo_Cell
3809
_edje_embryo_fn_set_focus(Embryo_Program *ep, Embryo_Cell *params)
3810
{
3811
   Edje *ed;
3812
   int part_id;
3813
   Edje_Real_Part *rp;
3814
   char *seat_name = NULL;
3815

3816
   if (!(HASNPARAMS(1) || HASNPARAMS(2))) return -1;
3817
   ed = embryo_program_data_get(ep);
3818

3819
   part_id = params[1];
3820
   if (part_id < 0) return 0;
3821
   rp = ed->table_parts[part_id % ed->table_parts_size];
3822
   if (!rp) return 0;
3823

3824
   /* if no seat name is passed, that's fine. it means
3825
      it should be applied to default seat */
3826
   if (HASNPARAMS(2))
3827
     {
3828
        GETSTR(seat_name, params[2]);
3829
        if (!seat_name) return 0;
3830
     }
3831

3832
   _edje_part_focus_set(ed, seat_name, rp);
3833

3834
   return 0;
3835
}
3836

3837
/* unset_focus(seat_name[]) */
3838
static Embryo_Cell
3839
_edje_embryo_fn_unset_focus(Embryo_Program *ep, Embryo_Cell *params)
3840
{
3841
   Edje *ed;
3842
   char *seat_name = NULL;
3843

3844
   if (!(HASNPARAMS(0) || HASNPARAMS(1))) return -1;
3845
   ed = embryo_program_data_get(ep);
3846

3847
   /* seat name is optional. no seat means
3848
      it should be applied to default seat */
3849
   if (HASNPARAMS(1))
3850
     {
3851
        GETSTR(seat_name, params[1]);
3852
        if (!seat_name) return 0;
3853
     }
3854

3855
   _edje_part_focus_set(ed, seat_name, NULL);
3856

3857
   return 0;
3858
}
3859

3860
/* external_param_get_int(id, param_name[]) */
3861
static Embryo_Cell
3862
_edje_embryo_fn_external_param_get_int(Embryo_Program *ep, Embryo_Cell *params)
3863
{
3864
   Edje *ed;
3865
   int part_id;
3866
   Edje_Real_Part *rp;
3867
   Edje_External_Param eep;
3868
   char *param_name;
3869

3870
   CHKPARAM(2);
3871
   ed = embryo_program_data_get(ep);
3872

3873
   part_id = params[1];
3874
   if (part_id < 0) return 0;
3875
   rp = ed->table_parts[part_id % ed->table_parts_size];
3876

3877
   GETSTR(param_name, params[2]);
3878
   if (!param_name) return 0;
3879
   eep.name = param_name;
3880
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_INT;
3881
   eep.i = 0;
3882
   _edje_external_param_get(NULL, rp, &eep);
3883
   return eep.i;
3884
}
3885

3886
/* external_param_set_int(id, param_name[], val) */
3887
static Embryo_Cell
3888
_edje_embryo_fn_external_param_set_int(Embryo_Program *ep, Embryo_Cell *params)
3889
{
3890
   Edje *ed;
3891
   int part_id;
3892
   Edje_Real_Part *rp;
3893
   Edje_External_Param eep;
3894
   char *param_name;
3895

3896
   CHKPARAM(3);
3897
   ed = embryo_program_data_get(ep);
3898

3899
   part_id = params[1];
3900
   if (part_id < 0) return 0;
3901
   rp = ed->table_parts[part_id % ed->table_parts_size];
3902

3903
   GETSTR(param_name, params[2]);
3904
   if (!param_name) return 0;
3905
   eep.name = param_name;
3906
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_INT;
3907
   eep.i = params[3];
3908
   return _edje_external_param_set(NULL, rp, &eep);
3909
}
3910

3911
/* Float:external_param_get_float(id, param_name[]) */
3912
static Embryo_Cell
3913
_edje_embryo_fn_external_param_get_float(Embryo_Program *ep, Embryo_Cell *params)
3914
{
3915
   Edje *ed;
3916
   int part_id;
3917
   Edje_Real_Part *rp;
3918
   Edje_External_Param eep;
3919
   char *param_name;
3920
   float v;
3921

3922
   CHKPARAM(2);
3923
   ed = embryo_program_data_get(ep);
3924

3925
   part_id = params[1];
3926
   if (part_id < 0) return 0;
3927
   rp = ed->table_parts[part_id % ed->table_parts_size];
3928

3929
   GETSTR(param_name, params[2]);
3930
   if (!param_name) return 0;
3931
   eep.name = param_name;
3932
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
3933
   eep.d = 0.0;
3934
   _edje_external_param_get(NULL, rp, &eep);
3935
   v = eep.d;
3936
   return EMBRYO_FLOAT_TO_CELL(v);
3937
}
3938

3939
/* external_param_set_float(id, param_name[], Float:val) */
3940
static Embryo_Cell
3941
_edje_embryo_fn_external_param_set_float(Embryo_Program *ep, Embryo_Cell *params)
3942
{
3943
   Edje *ed;
3944
   int part_id;
3945
   Edje_Real_Part *rp;
3946
   Edje_External_Param eep;
3947
   char *param_name;
3948

3949
   CHKPARAM(3);
3950
   ed = embryo_program_data_get(ep);
3951

3952
   part_id = params[1];
3953
   if (part_id < 0) return 0;
3954
   rp = ed->table_parts[part_id % ed->table_parts_size];
3955

3956
   GETSTR(param_name, params[2]);
3957
   if (!param_name) return 0;
3958
   eep.name = param_name;
3959
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
3960
   eep.d = EMBRYO_CELL_TO_FLOAT(params[3]);
3961
   return _edje_external_param_set(NULL, rp, &eep);
3962
}
3963

3964
/* external_param_get_strlen(id, param_name[]) */
3965
static Embryo_Cell
3966
_edje_embryo_fn_external_param_get_strlen(Embryo_Program *ep, Embryo_Cell *params)
3967
{
3968
   Edje *ed;
3969
   int part_id;
3970
   Edje_Real_Part *rp;
3971
   Edje_External_Param eep;
3972
   char *param_name;
3973

3974
   CHKPARAM(2);
3975
   ed = embryo_program_data_get(ep);
3976

3977
   part_id = params[1];
3978
   if (part_id < 0) return 0;
3979
   rp = ed->table_parts[part_id % ed->table_parts_size];
3980

3981
   GETSTR(param_name, params[2]);
3982
   if (!param_name) return 0;
3983
   eep.name = param_name;
3984
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
3985
   eep.s = NULL;
3986
   _edje_external_param_get(NULL, rp, &eep);
3987
   if (!eep.s) return 0;
3988
   return strlen(eep.s);
3989
}
3990

3991
/* external_param_get_str(id, param_name[], val[], val_maxlen) */
3992
static Embryo_Cell
3993
_edje_embryo_fn_external_param_get_str(Embryo_Program *ep, Embryo_Cell *params)
3994
{
3995
   Edje *ed;
3996
   int part_id;
3997
   Edje_Real_Part *rp;
3998
   Edje_External_Param eep;
3999
   char *param_name;
4000
   size_t src_len, dst_len;
4001

4002
   CHKPARAM(4);
4003
   dst_len = params[4];
4004
   if (dst_len < 1) goto error;
4005

4006
   ed = embryo_program_data_get(ep);
4007

4008
   part_id = params[1];
4009
   if (part_id < 0) goto error;
4010
   rp = ed->table_parts[part_id % ed->table_parts_size];
4011

4012
   GETSTR(param_name, params[2]);
4013
   if (!param_name) return 0;
4014
   eep.name = param_name;
4015
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
4016
   eep.s = NULL;
4017
   _edje_external_param_get(NULL, rp, &eep);
4018
   if (!eep.s) goto error;
4019
   src_len = strlen(eep.s);
4020
   if (src_len < dst_len)
4021
     {
4022
        SETSTR(eep.s, params[3]);
4023
     }
4024
   else
4025
     {
4026
        char *tmp = alloca(dst_len);
4027
        memcpy(tmp, eep.s, dst_len - 1);
4028
        tmp[dst_len - 1] = '\0';
4029
        SETSTR(tmp, params[3]);
4030
     }
4031
   return 1;
4032

4033
error:
4034
   SETSTR("", params[3]);
4035
   return 0;
4036
}
4037

4038
/* external_param_set_str(id, param_name[], val[]) */
4039
static Embryo_Cell
4040
_edje_embryo_fn_external_param_set_str(Embryo_Program *ep, Embryo_Cell *params)
4041
{
4042
   Edje *ed;
4043
   int part_id;
4044
   Edje_Real_Part *rp;
4045
   Edje_External_Param eep;
4046
   char *param_name, *val;
4047

4048
   CHKPARAM(3);
4049
   ed = embryo_program_data_get(ep);
4050

4051
   part_id = params[1];
4052
   if (part_id < 0) return 0;
4053
   rp = ed->table_parts[part_id % ed->table_parts_size];
4054

4055
   GETSTR(param_name, params[2]);
4056
   if (!param_name) return 0;
4057
   eep.name = param_name;
4058
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
4059
   GETSTR(val, params[3]);
4060
   if (!val) return 0;
4061
   eep.s = val;
4062
   return _edje_external_param_set(NULL, rp, &eep);
4063
}
4064

4065
/* external_param_get_choice_len(id, param_name[]) */
4066
static Embryo_Cell
4067
_edje_embryo_fn_external_param_get_choice_len(Embryo_Program *ep, Embryo_Cell *params)
4068
{
4069
   Edje *ed;
4070
   int part_id;
4071
   Edje_Real_Part *rp;
4072
   Edje_External_Param eep;
4073
   char *param_name;
4074

4075
   CHKPARAM(2);
4076
   ed = embryo_program_data_get(ep);
4077

4078
   part_id = params[1];
4079
   if (part_id < 0) return 0;
4080
   rp = ed->table_parts[part_id % ed->table_parts_size];
4081

4082
   GETSTR(param_name, params[2]);
4083
   if (!param_name) return 0;
4084
   eep.name = param_name;
4085
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_CHOICE;
4086
   eep.s = NULL;
4087
   _edje_external_param_get(NULL, rp, &eep);
4088
   if (!eep.s) return 0;
4089
   return strlen(eep.s);
4090
}
4091

4092
/* external_param_get_choice(id, param_name[], val[], val_maxlen) */
4093
static Embryo_Cell
4094
_edje_embryo_fn_external_param_get_choice(Embryo_Program *ep, Embryo_Cell *params)
4095
{
4096
   Edje *ed;
4097
   int part_id;
4098
   Edje_Real_Part *rp;
4099
   Edje_External_Param eep;
4100
   char *param_name;
4101
   size_t src_len, dst_len;
4102

4103
   CHKPARAM(4);
4104
   dst_len = params[4];
4105
   if (dst_len < 1) goto error;
4106

4107
   ed = embryo_program_data_get(ep);
4108

4109
   part_id = params[1];
4110
   if (part_id < 0) goto error;
4111
   rp = ed->table_parts[part_id % ed->table_parts_size];
4112

4113
   GETSTR(param_name, params[2]);
4114
   if (!param_name) return 0;
4115
   eep.name = param_name;
4116
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_CHOICE;
4117
   eep.s = NULL;
4118
   _edje_external_param_get(NULL, rp, &eep);
4119
   if (!eep.s) goto error;
4120
   src_len = strlen(eep.s);
4121
   if (src_len < dst_len)
4122
     {
4123
        SETSTR(eep.s, params[3]);
4124
     }
4125
   else
4126
     {
4127
        char *tmp = alloca(dst_len);
4128
        memcpy(tmp, eep.s, dst_len - 1);
4129
        tmp[dst_len - 1] = '\0';
4130
        SETSTR(tmp, params[3]);
4131
     }
4132
   return 1;
4133

4134
error:
4135
   SETSTR("", params[3]);
4136
   return 0;
4137
}
4138

4139
/* external_param_set_choice(id, param_name[], val[]) */
4140
static Embryo_Cell
4141
_edje_embryo_fn_external_param_set_choice(Embryo_Program *ep, Embryo_Cell *params)
4142
{
4143
   Edje *ed;
4144
   int part_id;
4145
   Edje_Real_Part *rp;
4146
   Edje_External_Param eep;
4147
   char *param_name, *val;
4148

4149
   CHKPARAM(3);
4150
   ed = embryo_program_data_get(ep);
4151

4152
   part_id = params[1];
4153
   if (part_id < 0) return 0;
4154
   rp = ed->table_parts[part_id % ed->table_parts_size];
4155

4156
   GETSTR(param_name, params[2]);
4157
   if (!param_name) return 0;
4158
   eep.name = param_name;
4159
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_CHOICE;
4160
   GETSTR(val, params[3]);
4161
   if (!val) return 0;
4162
   eep.s = val;
4163
   return _edje_external_param_set(NULL, rp, &eep);
4164
}
4165

4166
/* external_param_get_bool(id, param_name[]) */
4167
static Embryo_Cell
4168
_edje_embryo_fn_external_param_get_bool(Embryo_Program *ep, Embryo_Cell *params)
4169
{
4170
   Edje *ed;
4171
   int part_id;
4172
   Edje_Real_Part *rp;
4173
   Edje_External_Param eep;
4174
   char *param_name;
4175

4176
   CHKPARAM(2);
4177
   ed = embryo_program_data_get(ep);
4178

4179
   part_id = params[1];
4180
   if (part_id < 0) return 0;
4181
   rp = ed->table_parts[part_id % ed->table_parts_size];
4182

4183
   GETSTR(param_name, params[2]);
4184
   if (!param_name) return 0;
4185
   eep.name = param_name;
4186
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_BOOL;
4187
   eep.i = 0;
4188
   _edje_external_param_get(NULL, rp, &eep);
4189
   return eep.i;
4190
}
4191

4192
/* external_param_set_bool(id, param_name[], val) */
4193
static Embryo_Cell
4194
_edje_embryo_fn_external_param_set_bool(Embryo_Program *ep, Embryo_Cell *params)
4195
{
4196
   Edje *ed;
4197
   int part_id;
4198
   Edje_Real_Part *rp;
4199
   Edje_External_Param eep;
4200
   char *param_name;
4201

4202
   CHKPARAM(3);
4203
   ed = embryo_program_data_get(ep);
4204

4205
   part_id = params[1];
4206
   if (part_id < 0) return 0;
4207
   rp = ed->table_parts[part_id % ed->table_parts_size];
4208

4209
   GETSTR(param_name, params[2]);
4210
   if (!param_name) return 0;
4211
   eep.name = param_name;
4212
   eep.type = EDJE_EXTERNAL_PARAM_TYPE_BOOL;
4213
   eep.i = params[3];
4214
   return _edje_external_param_set(NULL, rp, &eep);
4215
}
4216

4217
#ifdef HAVE_EPHYSICS
4218
/* Generic function to call ephysics functions that apply an action to
4219
* a body using 3 double values.
4220
* To be used by the other functions only avoiding code duplication. */
4221
static Embryo_Cell
4222
_edje_embryo_fn_physics_components_set(Embryo_Program *ep, Embryo_Cell *params, void (*func)(EPhysics_Body *body, double x, double y, double z))
4223
{
4224
   Edje_Real_Part *rp;
4225
   int part_id = 0;
4226
   Edje *ed;
4227

4228
   CHKPARAM(4);
4229

4230
   ed = embryo_program_data_get(ep);
4231
   part_id = params[1];
4232
   if (part_id < 0) return 0;
4233

4234
   rp = ed->table_parts[part_id % ed->table_parts_size];
4235
   if ((rp) && (rp->body))
4236
     {
4237
        double x, y, z;
4238

4239
        x = (double)EMBRYO_CELL_TO_FLOAT(params[2]);
4240
        y = (double)EMBRYO_CELL_TO_FLOAT(params[3]);
4241
        z = (double)EMBRYO_CELL_TO_FLOAT(params[4]);
4242

4243
        func(rp->body, x, y, z);
4244
     }
4245

4246
   return 0;
4247
}
4248

4249
/* Generic function to call ephysics functions that get components related
4250
 * to actions from a body using 3 double values.
4251
 * To be used by the other functions only avoiding code duplication. */
4252
static Embryo_Cell
4253
_edje_embryo_fn_physics_components_get(Embryo_Program *ep, Embryo_Cell *params, void (*func)(const EPhysics_Body *body, double *x, double *y, double *z))
4254
{
4255
   Edje_Real_Part *rp;
4256
   int part_id = 0;
4257
   Edje *ed;
4258

4259
   CHKPARAM(4);
4260

4261
   ed = embryo_program_data_get(ep);
4262
   part_id = params[1];
4263
   if (part_id < 0) return 0;
4264

4265
   rp = ed->table_parts[part_id % ed->table_parts_size];
4266
   if ((rp) && (rp->body))
4267
     {
4268
        double x, y, z;
4269
        func(rp->body, &x, &y, &z);
4270
        SETFLOAT(x, params[2]);
4271
        SETFLOAT(y, params[3]);
4272
        SETFLOAT(z, params[4]);
4273
     }
4274

4275
   return 0;
4276
}
4277

4278
/* physics_impulse(part_id, Float:x, Float:y, Float:z) */
4279
static Embryo_Cell
4280
_edje_embryo_fn_physics_impulse(Embryo_Program *ep, Embryo_Cell *params)
4281
{
4282
   if (!EPH_LOAD()) return 0;
4283
   return _edje_embryo_fn_physics_components_set(
4284
            ep, params, EPH_CALL(ephysics_body_central_impulse_apply));
4285
}
4286

4287
/* physics_torque_impulse(part_id, Float:x, Float:y, Float:z) */
4288
static Embryo_Cell
4289
_edje_embryo_fn_physics_torque_impulse(Embryo_Program *ep, Embryo_Cell *params)
4290
{
4291
   if (!EPH_LOAD()) return 0;
4292
   return _edje_embryo_fn_physics_components_set(
4293
            ep, params, EPH_CALL(ephysics_body_torque_impulse_apply));
4294
}
4295

4296
/* physics_force(part_id, Float:x, Float:y, Float:z) */
4297
static Embryo_Cell
4298
_edje_embryo_fn_physics_force(Embryo_Program *ep, Embryo_Cell *params)
4299
{
4300
   if (!EPH_LOAD()) return 0;
4301
   return _edje_embryo_fn_physics_components_set(
4302
            ep, params, EPH_CALL(ephysics_body_central_force_apply));
4303
}
4304

4305
/* physics_torque(part_id, Float:x, Float:y, Float:z) */
4306
static Embryo_Cell
4307
_edje_embryo_fn_physics_torque(Embryo_Program *ep, Embryo_Cell *params)
4308
{
4309
   if (!EPH_LOAD()) return 0;
4310
   return _edje_embryo_fn_physics_components_set(
4311
            ep, params, EPH_CALL(ephysics_body_torque_apply));
4312
}
4313

4314
/* physics_clear_forces(part_id) */
4315
static Embryo_Cell
4316
_edje_embryo_fn_physics_clear_forces(Embryo_Program *ep, Embryo_Cell *params)
4317
{
4318
   Edje_Real_Part *rp;
4319
   int part_id = 0;
4320
   Edje *ed;
4321

4322
   CHKPARAM(1);
4323

4324
   if (!EPH_LOAD()) return 0;
4325
   ed = embryo_program_data_get(ep);
4326
   part_id = params[1];
4327
   if (part_id < 0) return 0;
4328

4329
   rp = ed->table_parts[part_id % ed->table_parts_size];
4330
   if ((rp) && (rp->body))
4331
     EPH_CALL(ephysics_body_forces_clear)(rp->body);
4332

4333
   return 0;
4334
}
4335

4336
/* physics_get_forces(part_id, &Float:x, &Float:y, &Float:z) */
4337
static Embryo_Cell
4338
_edje_embryo_fn_physics_get_forces(Embryo_Program *ep, Embryo_Cell *params)
4339
{
4340
   if (!EPH_LOAD()) return 0;
4341
   return _edje_embryo_fn_physics_components_get(
4342
            ep, params, EPH_CALL(ephysics_body_forces_get));
4343
}
4344

4345
/* physics_get_torques(part_id, &Float:x, &Float:y, &Float:z) */
4346
static Embryo_Cell
4347
_edje_embryo_fn_physics_get_torques(Embryo_Program *ep, Embryo_Cell *params)
4348
{
4349
   if (!EPH_LOAD()) return 0;
4350
   return _edje_embryo_fn_physics_components_get(
4351
            ep, params, EPH_CALL(ephysics_body_torques_get));
4352
}
4353

4354
/* physics_set_velocity(part_id, Float:x, Float:y, Float:z) */
4355
static Embryo_Cell
4356
_edje_embryo_fn_physics_set_velocity(Embryo_Program *ep, Embryo_Cell *params)
4357
{
4358
   if (!EPH_LOAD()) return 0;
4359
   return _edje_embryo_fn_physics_components_set(
4360
            ep, params, EPH_CALL(ephysics_body_linear_velocity_set));
4361
}
4362

4363
/* physics_get_velocity(part_id, &Float:x, &Float:y, &Float:z) */
4364
static Embryo_Cell
4365
_edje_embryo_fn_physics_get_velocity(Embryo_Program *ep, Embryo_Cell *params)
4366
{
4367
   if (!EPH_LOAD()) return 0;
4368
   return _edje_embryo_fn_physics_components_get(
4369
            ep, params, EPH_CALL(ephysics_body_linear_velocity_get));
4370
}
4371

4372
/* physics_set_ang_velocity(part_id, Float:x, Float:y, Float:z) */
4373
static Embryo_Cell
4374
_edje_embryo_fn_physics_set_ang_velocity(Embryo_Program *ep, Embryo_Cell *params)
4375
{
4376
   if (!EPH_LOAD()) return 0;
4377
   return _edje_embryo_fn_physics_components_set(
4378
            ep, params, EPH_CALL(ephysics_body_angular_velocity_set));
4379
}
4380

4381
/* physics_get_ang_velocity(part_id, &Float:x, &Float:y, &Float:z) */
4382
static Embryo_Cell
4383
_edje_embryo_fn_physics_get_ang_velocity(Embryo_Program *ep, Embryo_Cell *params)
4384
{
4385
   if (!EPH_LOAD()) return 0;
4386
   return _edje_embryo_fn_physics_components_get(
4387
            ep, params, EPH_CALL(ephysics_body_angular_velocity_get));
4388
}
4389

4390
/* physics_stop(part_id) */
4391
static Embryo_Cell
4392
_edje_embryo_fn_physics_stop(Embryo_Program *ep, Embryo_Cell *params)
4393
{
4394
   Edje_Real_Part *rp;
4395
   int part_id = 0;
4396
   Edje *ed;
4397

4398
   CHKPARAM(1);
4399

4400
   if (!EPH_LOAD()) return 0;
4401
   ed = embryo_program_data_get(ep);
4402
   part_id = params[1];
4403
   if (part_id < 0) return 0;
4404

4405
   rp = ed->table_parts[part_id % ed->table_parts_size];
4406
   if ((rp) && (rp->body))
4407
     EPH_CALL(ephysics_body_stop)(rp->body);
4408

4409
   return 0;
4410
}
4411

4412
/* physics_set_rotation(part_id, Float:w, Float:x, Float:y, Float:z) */
4413
static Embryo_Cell
4414
_edje_embryo_fn_physics_set_rotation(Embryo_Program *ep, Embryo_Cell *params)
4415
{
4416
   Edje_Real_Part *rp;
4417
   int part_id = 0;
4418
   Edje *ed;
4419

4420
   CHKPARAM(5);
4421

4422
   if (!EPH_LOAD()) return 0;
4423
   ed = embryo_program_data_get(ep);
4424
   part_id = params[1];
4425
   if (part_id < 0) return 0;
4426

4427
   rp = ed->table_parts[part_id % ed->table_parts_size];
4428
   if ((rp) && (rp->body))
4429
     {
4430
        EPhysics_Quaternion quat;
4431
        double w, x, y, z;
4432

4433
        w = (double)EMBRYO_CELL_TO_FLOAT(params[2]);
4434
        x = (double)EMBRYO_CELL_TO_FLOAT(params[3]);
4435
        y = (double)EMBRYO_CELL_TO_FLOAT(params[4]);
4436
        z = (double)EMBRYO_CELL_TO_FLOAT(params[5]);
4437

4438
        EPH_CALL(ephysics_quaternion_set)(&quat, x, y, z, w);
4439
        EPH_CALL(ephysics_quaternion_normalize)(&quat);
4440
        EPH_CALL(ephysics_body_rotation_set)(rp->body, &quat);
4441
     }
4442

4443
   return 0;
4444
}
4445

4446
/* physics_get_rotation(part_id, &Float:w, &Float:x, &Float:y, &Float:z) */
4447
static Embryo_Cell
4448
_edje_embryo_fn_physics_get_rotation(Embryo_Program *ep, Embryo_Cell *params)
4449
{
4450
   Edje_Real_Part *rp;
4451
   int part_id = 0;
4452
   Edje *ed;
4453

4454
   CHKPARAM(5);
4455

4456
   if (!EPH_LOAD()) return 0;
4457
   ed = embryo_program_data_get(ep);
4458
   part_id = params[1];
4459
   if (part_id < 0) return 0;
4460

4461
   rp = ed->table_parts[part_id % ed->table_parts_size];
4462
   if ((rp) && (rp->body))
4463
     {
4464
        EPhysics_Quaternion quat;
4465
        double w, x, y, z;
4466

4467
        EPH_CALL(ephysics_body_rotation_get)(rp->body, &quat);
4468
        EPH_CALL(ephysics_quaternion_get)(&quat, &x, &y, &z, &w);
4469

4470
        SETFLOAT(w, params[2]);
4471
        SETFLOAT(x, params[3]);
4472
        SETFLOAT(y, params[4]);
4473
        SETFLOAT(z, params[5]);
4474
     }
4475

4476
   return 0;
4477
}
4478

4479
#endif
4480

4481
/* swallow_has_content(part_id) */
4482
static Embryo_Cell
4483
_edje_embryo_fn_swallow_has_content(Embryo_Program *ep, Embryo_Cell *params)
4484
{
4485
   Edje *ed;
4486
   int part_id = 0;
4487
   Edje_Real_Part *rp;
4488

4489
   CHKPARAM(1);
4490
   ed = embryo_program_data_get(ep);
4491
   part_id = params[1];
4492
   if (part_id < 0) return 0;
4493
   rp = ed->table_parts[part_id % ed->table_parts_size];
4494

4495
   if ((!rp) ||
4496
       (!rp->part) ||
4497
       (rp->part->type != EDJE_PART_TYPE_SWALLOW) ||
4498
       (!rp->typedata.swallow) ||
4499
       (!rp->typedata.swallow->swallowed_object))
4500
      return 0;
4501

4502
   return 1;
4503
}
4504

4505
/* get_part_id(part[]) */
4506
static Embryo_Cell
4507
_edje_embryo_fn_echo(Embryo_Program *ep, Embryo_Cell *params)
4508
{
4509
   Edje *ed;
4510
   char *p;
4511

4512
   CHKPARAM(1);
4513
   ed = embryo_program_data_get(ep);
4514
   GETSTR(p, params[1]);
4515
   if (!p) return -1;
4516
   fprintf(stderr,
4517
           "<EDJE ECHO> [%llx | %s:%s]: %s\n",
4518
           (unsigned long long)((uintptr_t)ed),
4519
           ed->path,
4520
           ed->group,
4521
           p);
4522
   return 0;
4523
}
4524

4525
void
4526
_edje_embryo_script_init(Edje_Part_Collection *edc)
4527
{
4528
   Embryo_Program *ep;
4529

4530
   if (!edc) return;
4531
   if (!edc->script) return;
4532

4533
   ep = edc->script;
4534
   /* first advertise all the edje "script" calls */
4535
   embryo_program_native_call_add(ep, "get_int", _edje_embryo_fn_get_int);
4536
   embryo_program_native_call_add(ep, "set_int", _edje_embryo_fn_set_int);
4537
   embryo_program_native_call_add(ep, "get_float", _edje_embryo_fn_get_float);
4538
   embryo_program_native_call_add(ep, "set_float", _edje_embryo_fn_set_float);
4539
   embryo_program_native_call_add(ep, "get_str", _edje_embryo_fn_get_str);
4540
   embryo_program_native_call_add(ep, "get_strlen", _edje_embryo_fn_get_strlen);
4541
   embryo_program_native_call_add(ep, "set_str", _edje_embryo_fn_set_str);
4542
   embryo_program_native_call_add(ep, "count", _edje_embryo_fn_count);
4543
   embryo_program_native_call_add(ep, "remove", _edje_embryo_fn_remove);
4544
   embryo_program_native_call_add(ep, "append_int", _edje_embryo_fn_append_int);
4545
   embryo_program_native_call_add(ep, "prepend_int", _edje_embryo_fn_prepend_int);
4546
   embryo_program_native_call_add(ep, "insert_int", _edje_embryo_fn_insert_int);
4547
   embryo_program_native_call_add(ep, "replace_int", _edje_embryo_fn_replace_int);
4548
   embryo_program_native_call_add(ep, "fetch_int", _edje_embryo_fn_fetch_int);
4549
   embryo_program_native_call_add(ep, "append_str", _edje_embryo_fn_append_str);
4550
   embryo_program_native_call_add(ep, "prepend_str", _edje_embryo_fn_prepend_str);
4551
   embryo_program_native_call_add(ep, "insert_str", _edje_embryo_fn_insert_str);
4552
   embryo_program_native_call_add(ep, "replace_str", _edje_embryo_fn_replace_str);
4553
   embryo_program_native_call_add(ep, "fetch_str", _edje_embryo_fn_fetch_str);
4554
   embryo_program_native_call_add(ep, "append_float", _edje_embryo_fn_append_float);
4555
   embryo_program_native_call_add(ep, "prepend_float", _edje_embryo_fn_prepend_float);
4556
   embryo_program_native_call_add(ep, "insert_float", _edje_embryo_fn_insert_float);
4557
   embryo_program_native_call_add(ep, "replace_float", _edje_embryo_fn_replace_float);
4558
   embryo_program_native_call_add(ep, "fetch_float", _edje_embryo_fn_fetch_float);
4559

4560
   embryo_program_native_call_add(ep, "timer", _edje_embryo_fn_timer);
4561
   embryo_program_native_call_add(ep, "cancel_timer", _edje_embryo_fn_cancel_timer);
4562
   embryo_program_native_call_add(ep, "reset_timer", _edje_embryo_fn_reset_timer);
4563

4564
   embryo_program_native_call_add(ep, "anim", _edje_embryo_fn_anim);
4565
   embryo_program_native_call_add(ep, "cancel_anim", _edje_embryo_fn_cancel_anim);
4566
   embryo_program_native_call_add(ep, "get_anim_pos_map", _edje_embryo_fn_get_anim_pos_map);
4567

4568
   embryo_program_native_call_add(ep, "emit", _edje_embryo_fn_emit);
4569
   embryo_program_native_call_add(ep, "get_part_id", _edje_embryo_fn_get_part_id);
4570
   embryo_program_native_call_add(ep, "get_image_id", _edje_embryo_fn_get_image_id);
4571
   embryo_program_native_call_add(ep, "get_program_id", _edje_embryo_fn_get_program_id);
4572
   embryo_program_native_call_add(ep, "set_state", _edje_embryo_fn_set_state);
4573
   embryo_program_native_call_add(ep, "get_state", _edje_embryo_fn_get_state);
4574
   embryo_program_native_call_add(ep, "set_tween_state", _edje_embryo_fn_set_tween_state);
4575
   embryo_program_native_call_add(ep, "set_tween_state_anim", _edje_embryo_fn_set_tween_state_anim);
4576
   embryo_program_native_call_add(ep, "run_program", _edje_embryo_fn_run_program);
4577
   embryo_program_native_call_add(ep, "get_drag_dir", _edje_embryo_fn_get_drag_dir);
4578
   embryo_program_native_call_add(ep, "get_drag", _edje_embryo_fn_get_drag);
4579
   embryo_program_native_call_add(ep, "set_drag", _edje_embryo_fn_set_drag);
4580
   embryo_program_native_call_add(ep, "get_drag_size", _edje_embryo_fn_get_drag_size);
4581
   embryo_program_native_call_add(ep, "set_drag_size", _edje_embryo_fn_set_drag_size);
4582
   embryo_program_native_call_add(ep, "set_text", _edje_embryo_fn_set_text);
4583
   embryo_program_native_call_add(ep, "get_text", _edje_embryo_fn_get_text);
4584
   embryo_program_native_call_add(ep, "get_min_size", _edje_embryo_fn_get_min_size);
4585
   embryo_program_native_call_add(ep, "get_max_size", _edje_embryo_fn_get_max_size);
4586
   embryo_program_native_call_add(ep, "get_color_class", _edje_embryo_fn_get_color_class);
4587
   embryo_program_native_call_add(ep, "set_color_class", _edje_embryo_fn_set_color_class);
4588
   embryo_program_native_call_add(ep, "set_text_class", _edje_embryo_fn_set_text_class);
4589
   embryo_program_native_call_add(ep, "get_text_class", _edje_embryo_fn_get_text_class);
4590
   embryo_program_native_call_add(ep, "get_drag_step", _edje_embryo_fn_get_drag_step);
4591
   embryo_program_native_call_add(ep, "set_drag_step", _edje_embryo_fn_set_drag_step);
4592
   embryo_program_native_call_add(ep, "get_drag_page", _edje_embryo_fn_get_drag_page);
4593
   embryo_program_native_call_add(ep, "set_drag_page", _edje_embryo_fn_set_drag_page);
4594
   embryo_program_native_call_add(ep, "get_mouse", _edje_embryo_fn_get_mouse);
4595
   embryo_program_native_call_add(ep, "get_mouse_buttons", _edje_embryo_fn_get_mouse_buttons);
4596
   embryo_program_native_call_add(ep, "stop_program", _edje_embryo_fn_stop_program);
4597
   embryo_program_native_call_add(ep, "stop_programs_on", _edje_embryo_fn_stop_programs_on);
4598
   embryo_program_native_call_add(ep, "set_min_size", _edje_embryo_fn_set_min_size);
4599
   embryo_program_native_call_add(ep, "set_max_size", _edje_embryo_fn_set_max_size);
4600
   embryo_program_native_call_add(ep, "play_sample", _edje_embryo_fn_play_sample);
4601
   embryo_program_native_call_add(ep, "play_tone", _edje_embryo_fn_play_tone);
4602
   embryo_program_native_call_add(ep, "play_vibration", _edje_embryo_fn_play_vibration);
4603
   embryo_program_native_call_add(ep, "send_message", _edje_embryo_fn_send_message);
4604
   embryo_program_native_call_add(ep, "get_geometry", _edje_embryo_fn_get_geometry);
4605
   embryo_program_native_call_add(ep, "custom_state", _edje_embryo_fn_custom_state);
4606
   embryo_program_native_call_add(ep, "set_state_val", _edje_embryo_fn_set_state_val);
4607
   embryo_program_native_call_add(ep, "get_state_val", _edje_embryo_fn_get_state_val);
4608
   embryo_program_native_call_add(ep, "set_state_anim", _edje_embryo_fn_set_state_anim);
4609

4610
   embryo_program_native_call_add(ep, "set_mouse_events", _edje_embryo_fn_set_mouse_events);
4611
   embryo_program_native_call_add(ep, "get_mouse_events", _edje_embryo_fn_get_mouse_events);
4612
   embryo_program_native_call_add(ep, "set_pointer_mode", _edje_embryo_fn_set_pointer_mode);
4613
   embryo_program_native_call_add(ep, "set_repeat_events", _edje_embryo_fn_set_repeat_events);
4614
   embryo_program_native_call_add(ep, "get_repeat_events", _edje_embryo_fn_get_repeat_events);
4615
   embryo_program_native_call_add(ep, "set_ignore_flags", _edje_embryo_fn_set_ignore_flags);
4616
   embryo_program_native_call_add(ep, "get_ignore_flags", _edje_embryo_fn_get_ignore_flags);
4617
   embryo_program_native_call_add(ep, "set_mask_flags", _edje_embryo_fn_set_mask_flags);
4618
   embryo_program_native_call_add(ep, "get_mask_flags", _edje_embryo_fn_get_mask_flags);
4619

4620
   embryo_program_native_call_add(ep, "set_focus", _edje_embryo_fn_set_focus);
4621
   embryo_program_native_call_add(ep, "unset_focus", _edje_embryo_fn_unset_focus);
4622

4623
   embryo_program_native_call_add(ep, "part_swallow", _edje_embryo_fn_part_swallow);
4624

4625
   embryo_program_native_call_add(ep, "external_param_get_int", _edje_embryo_fn_external_param_get_int);
4626
   embryo_program_native_call_add(ep, "external_param_set_int", _edje_embryo_fn_external_param_set_int);
4627
   embryo_program_native_call_add(ep, "external_param_get_float", _edje_embryo_fn_external_param_get_float);
4628
   embryo_program_native_call_add(ep, "external_param_set_float", _edje_embryo_fn_external_param_set_float);
4629
   embryo_program_native_call_add(ep, "external_param_get_strlen", _edje_embryo_fn_external_param_get_strlen);
4630
   embryo_program_native_call_add(ep, "external_param_get_str", _edje_embryo_fn_external_param_get_str);
4631
   embryo_program_native_call_add(ep, "external_param_set_str", _edje_embryo_fn_external_param_set_str);
4632
   embryo_program_native_call_add(ep, "external_param_get_choice_len", _edje_embryo_fn_external_param_get_choice_len);
4633
   embryo_program_native_call_add(ep, "external_param_get_choice", _edje_embryo_fn_external_param_get_choice);
4634
   embryo_program_native_call_add(ep, "external_param_set_choice", _edje_embryo_fn_external_param_set_choice);
4635
   embryo_program_native_call_add(ep, "external_param_get_bool", _edje_embryo_fn_external_param_get_bool);
4636
   embryo_program_native_call_add(ep, "external_param_set_bool", _edje_embryo_fn_external_param_set_bool);
4637

4638
#ifdef HAVE_EPHYSICS
4639
   embryo_program_native_call_add(ep, "physics_impulse", _edje_embryo_fn_physics_impulse);
4640
   embryo_program_native_call_add(ep, "physics_torque_impulse", _edje_embryo_fn_physics_torque_impulse);
4641
   embryo_program_native_call_add(ep, "physics_force", _edje_embryo_fn_physics_force);
4642
   embryo_program_native_call_add(ep, "physics_torque", _edje_embryo_fn_physics_torque);
4643
   embryo_program_native_call_add(ep, "physics_clear_forces", _edje_embryo_fn_physics_clear_forces);
4644
   embryo_program_native_call_add(ep, "physics_get_forces", _edje_embryo_fn_physics_get_forces);
4645
   embryo_program_native_call_add(ep, "physics_get_torques", _edje_embryo_fn_physics_get_torques);
4646
   embryo_program_native_call_add(ep, "physics_set_velocity", _edje_embryo_fn_physics_set_velocity);
4647
   embryo_program_native_call_add(ep, "physics_get_velocity", _edje_embryo_fn_physics_get_velocity);
4648
   embryo_program_native_call_add(ep, "physics_set_ang_velocity", _edje_embryo_fn_physics_set_ang_velocity);
4649
   embryo_program_native_call_add(ep, "physics_get_ang_velocity", _edje_embryo_fn_physics_get_ang_velocity);
4650
   embryo_program_native_call_add(ep, "physics_stop", _edje_embryo_fn_physics_stop);
4651
   embryo_program_native_call_add(ep, "physics_set_rotation", _edje_embryo_fn_physics_set_rotation);
4652
   embryo_program_native_call_add(ep, "physics_get_rotation", _edje_embryo_fn_physics_get_rotation);
4653
#endif
4654

4655
   embryo_program_native_call_add(ep, "swallow_has_content", _edje_embryo_fn_swallow_has_content);
4656
   embryo_program_native_call_add(ep, "echo", _edje_embryo_fn_echo);
4657
}
4658

4659
void
4660
_edje_embryo_script_shutdown(Edje_Part_Collection *edc)
4661
{
4662
   if (!edc) return;
4663
   if (!edc->script) return;
4664
   if (embryo_program_recursion_get(edc->script) > 0) return;
4665
   embryo_program_free(edc->script);
4666
   edc->script = NULL;
4667
}
4668

4669
void
4670
_edje_embryo_script_reset(Edje *ed)
4671
{
4672
   if (!ed) return;
4673
   if (!ed->collection) return;
4674
   if (!ed->collection->script) return;
4675
   if (embryo_program_recursion_get(ed->collection->script) > 0) return;
4676
   embryo_program_vm_reset(ed->collection->script);
4677
   _edje_embryo_globals_init(ed);
4678
}
4679

4680
/* this may change in future - thus "test_run" is its name */
4681
void
4682
_edje_embryo_test_run(Edje *ed, Edje_Program *pr, const char *sig, const char *src)
4683
{
4684
   char fname[128];
4685
   Embryo_Function fn;
4686

4687
   if (!ed) return;
4688
   if (!ed->collection) return;
4689
   if (!ed->collection->script) return;
4690
   embryo_program_vm_push(ed->collection->script);
4691
   _edje_embryo_globals_init(ed);
4692

4693
   //   _edje_embryo_script_reset(ed);
4694
   snprintf(fname, sizeof(fname), "_p%i", pr->id);
4695
   fn = embryo_program_function_find(ed->collection->script, (char *)fname);
4696
   if (fn != EMBRYO_FUNCTION_NONE)
4697
     {
4698
        void *pdata;
4699
        int ret;
4700

4701
        embryo_parameter_string_push(ed->collection->script, (char *)sig);
4702
        embryo_parameter_string_push(ed->collection->script, (char *)src);
4703
        pdata = embryo_program_data_get(ed->collection->script);
4704
        embryo_program_data_set(ed->collection->script, ed);
4705
        /* 5 million instructions is an arbitrary number. on my p4-2.6 here */
4706
        /* IF embryo is ONLY running embryo stuff and NO native calls that's */
4707
        /* about 0.016 seconds, and longer on slower cpu's. if a simple */
4708
        /* embryo script snippet hasn't managed to do its work in 5 MILLION */
4709
        /* embryo virtual machine instructions - something is wrong, or */
4710
        /* embryo is simply being mis-used. Embryo is meant to be minimal */
4711
        /* logic enhancment - not entire applications. this cycle count */
4712
        /* does NOT include time spent in native function calls, that the */
4713
        /* script may call to do the REAL work, so in terms of time this */
4714
        /* will likely end up being much longer than 0.016 seconds - more */
4715
        /* like 0.03 - 0.05 seconds or even more */
4716
        embryo_program_max_cycle_run_set(ed->collection->script, 5000000);
4717
        if (embryo_program_recursion_get(ed->collection->script) && (!ed->collection->script_recursion))
4718
          ERR("You are running Embryo->EDC->Embryo with script program '%s';\n"
4719
              "A run_program runs the '%d'th program '%s' in the group '%s' of file %s;\n"
4720
              "By the power of Grayskull, your previous Embryo stack is now broken!",
4721
              fname, (fn + 1), pr->name, ed->group, ed->path);
4722

4723
        ret = embryo_program_run(ed->collection->script, fn);
4724
        if (ret == EMBRYO_PROGRAM_FAIL)
4725
          {
4726
             ERR("ERROR with embryo script. "
4727
                 "OBJECT NAME: '%s', "
4728
                 "OBJECT FILE: '%s', "
4729
                 "ENTRY POINT: '%s (%s)', "
4730
                 "SIGNAL: '%s', "
4731
                 "SOURCE: '%s', "
4732
                 "ERROR: '%s'",
4733
                 ed->collection->part,
4734
                 ed->file->path,
4735
                 fname, pr->name,
4736
                 sig, src,
4737
                 embryo_error_string_get(embryo_program_error_get(ed->collection->script)));
4738
          }
4739
        else if (ret == EMBRYO_PROGRAM_TOOLONG)
4740
          {
4741
             ERR("ERROR with embryo script. "
4742
                 "OBJECT NAME: '%s', "
4743
                 "OBJECT FILE: '%s', "
4744
                 "ENTRY POINT: '%s (%s)', "
4745
                 "SIGNAL: '%s', "
4746
                 "SOURCE: '%s', "
4747
                 "ERROR: 'Script exceeded maximum allowed cycle count of %i'",
4748
                 ed->collection->part,
4749
                 ed->file->path,
4750
                 fname, pr->name,
4751
                 sig, src,
4752
                 embryo_program_max_cycle_run_get(ed->collection->script));
4753
          }
4754
        embryo_program_data_set(ed->collection->script, pdata);
4755
     }
4756
   embryo_program_vm_pop(ed->collection->script);
4757
}
4758

4759
void
4760
_edje_embryo_globals_init(Edje *ed)
4761
{
4762
   int n, i;
4763
   Embryo_Program *ep;
4764

4765
   ep = ed->collection->script;
4766
   n = embryo_program_variable_count_get(ep);
4767
   for (i = 0; i < n; i++)
4768
     {
4769
        Embryo_Cell cell, *cptr;
4770

4771
        cell = embryo_program_variable_get(ep, i);
4772
        if (cell != EMBRYO_CELL_NONE)
4773
          {
4774
             cptr = embryo_data_address_get(ep, cell);
4775
             if (cptr) *cptr = EDJE_VAR_MAGIC_BASE + i;
4776
          }
4777
     }
4778
}
4779

4780