aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/edje/src/lib/edje_embryo.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/edje/src/lib/edje_embryo.c')
-rw-r--r--libraries/edje/src/lib/edje_embryo.c3179
1 files changed, 3179 insertions, 0 deletions
diff --git a/libraries/edje/src/lib/edje_embryo.c b/libraries/edje/src/lib/edje_embryo.c
new file mode 100644
index 0000000..c89a4f4
--- /dev/null
+++ b/libraries/edje/src/lib/edje_embryo.c
@@ -0,0 +1,3179 @@
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 * anim(Float:len, fname[], val)
70 * cancel_anim(id)
71 * emit(sig[], src[])
72 * set_state(part_id, state[], Float:state_val)
73 * get_state(part_id, dst[], maxlen, &Float:val)
74 * set_tween_state(part_id, Float:tween, state1[], Float:state1_val, state2[], Float:state2_val)
75 * play_sample(sample_name, speed)
76 * play_tone(tone_name, duration)
77 * run_program(program_id)
78 * Direction:get_drag_dir(part_id)
79 * get_drag(part_id, &Float:dx, &Float:&dy)
80 * set_drag(part_id, Float:dx, Float:dy)
81 * get_drag_size(part_id, &Float:dx, &Float:&dy)
82 * set_drag_size(part_id, Float:dx, Float:dy)
83 * set_text(part_id, str[])
84 * get_text(part_id, dst[], maxlen)
85 * get_min_size(w, h)
86 * get_max_size(w, h)
87 * set_color_class(class[], r, g, b, a)
88 * get_color_class(class[], &r, &g, &b, &a)
89 * set_text_class(class[], font[], Float:size)
90 * get_text_class(class[], font[], &Float:size)
91 * get_drag_step(part_id, &Float:dx, &Float:&dy)
92 * set_drag_step(part_id, Float:dx, Float:dy)
93 * get_drag_page(part_id, &Float:dx, &Float:&dy)
94 * set_drag_page(part_id, Float:dx, Float:dy)
95 * get_geometry(part_id, &Float:x, &Float:y, &Float:w, &Float:h)
96 * get_mouse(&x, &y)
97 * stop_program(program_id)
98 * stop_programs_on(part_id)
99 * set_min_size(w, h)
100 * set_max_size(w, h)
101 * send_message(Msg_Type:type, id, ...)
102 *
103 * count(id)
104 * remove(id, n)
105 *
106 * append_int(id, v)
107 * prepend_int(id, v)
108 * insert_int(id, n, v)
109 * replace_int(id, n, v)
110 * fetch_int(id, n)
111 *
112 * append_str(id, str[])
113 * prepend_str(id, str[])
114 * insert_str(id, n, str[])
115 * replace_str(id, n, str[])
116 * fetch_str(id, n, dst[], maxlen)
117 *
118 * append_float(id, Float:v)
119 * prepend_float(id, Float:v)
120 * insert_float(id, n, Float:v)
121 * replace_float(id, n, Float:v)
122 * Float:fetch_float(id, n)
123 *
124 * custom_state(part_id, state[], Float:state_val = 0.0)
125 * set_state_val(part_id, State_Param:param, ...)
126 * get_state_val(part_id, State_Param:param, ...)
127 *
128 * Supported parameters:
129 * align[Float:x, Float:y]
130 * min[w, h]
131 * max[w, h]
132 * step[x,y]
133 * aspect[Float:min, Float:max]
134 * color[r,g,b,a]
135 * color2[r,g,b,a]
136 * color3[r,g,b,a]
137 * aspect_preference
138 * rel1[relx,rely]
139 * rel1[part_id,part_id]
140 * rel1[offx,offy]
141 * rel2[relx,relyr]
142 * rel2[part_id,part_id]
143 * rel2[offx,offy]
144 * image[image_id] <- all images have an Id not name in the edje
145 * border[l,r,t,b]
146 * fill[smooth]
147 * fill[pos_relx,pos_rely,pos_offx,pos_offy]
148 * fill[sz_relx,sz_rely,sz_offx,sz_offy]
149 * color_class
150 * text[text]
151 * text[text_class]
152 * text[font]
153 * text[size]
154 * text[style]
155 * text[fit_x,fit_y]
156 * text[min_x,min_y]
157 * text[align_x,align_y]
158 * visible[on]
159 * map_on[on]
160 * map_persp[part_id]
161 * map_light[part_id]
162 * map_rot_center[part_id]
163 * map_rot_x[deg]
164 * map_rot_y[deg]
165 * map_rot_z[deg]
166 * map_back_cull[on]
167 * map_persp_on[on]
168 * persp_zplane[z]
169 * persp_focal[z]
170 *
171 * ** part_id and program_id need to be able to be "found" from strings
172 *
173 * get_drag_count(part_id, &Float:dx, &Float:&dy)
174 * set_drag_count(part_id, Float:dx, Float:dy)
175 * set_drag_confine(part_id, confine_part_id)
176 * get_size(&w, &h);
177 * resize_request(w, h)
178 * get_mouse_buttons()
179 * //set_type(part_id, Type:type)
180 * //set_effect(part_id, Effect:fx)
181 * set_mouse_events(part_id, ev)
182 * get_mouse_events(part_id)
183 * set_repeat_events(part_id, rep)
184 * get_repeat_events(part_id)
185 * set_clip(part_id, clip_part_id)
186 * get_clip(part_id)
187 *
188 * part_swallow(part_id, group_name)
189 *
190 * external_param_get_int(id, param_name[])
191 * external_param_set_int(id, param_name[], value)
192 * Float:external_param_get_float(id, param_name[])
193 * external_param_set_float(id, param_name[], Float:value)
194 * external_param_get_strlen(id, param_name[])
195 * external_param_get_str(id, param_name[], value[], value_maxlen)
196 * external_param_set_str(id, param_name[], value[])
197 * external_param_get_choice_len(id, param_name[])
198 * external_param_get_choice(id, param_name[], value[], value_maxlen)
199 * external_param_set_choice(id, param_name[], value[])
200 * external_param_get_bool(id, param_name[])
201 * external_param_set_bool(id, param_name[], value)
202 *
203 * ADD/DEL CUSTOM OBJECTS UNDER SOLE EMBRYO SCRIPT CONTROL
204 *
205 */
206
207/* get_int(id) */
208static Embryo_Cell
209_edje_embryo_fn_get_int(Embryo_Program *ep, Embryo_Cell *params)
210{
211 Edje *ed;
212
213 CHKPARAM(1);
214 ed = embryo_program_data_get(ep);
215 return (Embryo_Cell)_edje_var_int_get(ed, (int)params[1]);
216}
217
218/* set_int(id, v) */
219static Embryo_Cell
220_edje_embryo_fn_set_int(Embryo_Program *ep, Embryo_Cell *params)
221{
222 Edje *ed;
223
224 CHKPARAM(2);
225 ed = embryo_program_data_get(ep);
226 _edje_var_int_set(ed, (int)params[1], (int)params[2]);
227 return 0;
228}
229
230/* get_float(id) */
231static Embryo_Cell
232_edje_embryo_fn_get_float(Embryo_Program *ep, Embryo_Cell *params)
233{
234 Edje *ed;
235 float v;
236
237 CHKPARAM(1);
238 ed = embryo_program_data_get(ep);
239 v = (float)_edje_var_float_get(ed, params[1]);
240 return EMBRYO_FLOAT_TO_CELL(v);
241}
242
243/* set_float(id, v) */
244static Embryo_Cell
245_edje_embryo_fn_set_float(Embryo_Program *ep, Embryo_Cell *params)
246{
247 Edje *ed;
248 float v;
249
250 CHKPARAM(2);
251 ed = embryo_program_data_get(ep);
252 v = EMBRYO_CELL_TO_FLOAT(params[2]);
253 _edje_var_float_set(ed, (int)params[1], (double)v);
254 return 0;
255}
256
257/* get_str(id, dst[], maxlen) */
258static Embryo_Cell
259_edje_embryo_fn_get_str(Embryo_Program *ep, Embryo_Cell *params)
260{
261 Edje *ed;
262 char *s;
263
264 CHKPARAM(3);
265 if (params[3] < 1) return 0;
266 ed = embryo_program_data_get(ep);
267 s = (char *)_edje_var_str_get(ed, (int)params[1]);
268 if (s)
269 {
270 if ((int) strlen(s) < params[3])
271 {
272 SETSTR(s, params[2]);
273 }
274 else
275 {
276 char *ss;
277
278 ss = alloca(strlen(s) + 1);
279 strcpy(ss, s);
280 ss[params[3] - 1] = 0;
281 SETSTR(ss, params[2]);
282 }
283 }
284 else
285 {
286 SETSTR("", params[2]);
287 }
288 return 0;
289}
290
291/* get_strlen(id) */
292static Embryo_Cell
293_edje_embryo_fn_get_strlen(Embryo_Program *ep, Embryo_Cell *params)
294{
295 Edje *ed;
296 char *s;
297
298 CHKPARAM(1);
299 ed = embryo_program_data_get(ep);
300 s = (char *)_edje_var_str_get(ed, (int)params[1]);
301 if (s)
302 {
303 return strlen(s);
304 }
305 return 0;
306}
307
308/* set_str(id, str[]) */
309static Embryo_Cell
310_edje_embryo_fn_set_str(Embryo_Program *ep, Embryo_Cell *params)
311{
312 Edje *ed;
313 char *s;
314
315 CHKPARAM(2);
316 ed = embryo_program_data_get(ep);
317 GETSTR(s, params[2]);
318 if (s)
319 {
320 _edje_var_str_set(ed, (int)params[1], s);
321 }
322 return 0;
323}
324
325/* count(id) */
326static Embryo_Cell
327_edje_embryo_fn_count(Embryo_Program *ep, Embryo_Cell *params)
328{
329 Edje *ed = embryo_program_data_get(ep);
330
331 CHKPARAM(1);
332
333 return (Embryo_Cell)_edje_var_list_count_get(ed, (int) params[1]);
334}
335
336/* remove(id, n) */
337static Embryo_Cell
338_edje_embryo_fn_remove(Embryo_Program *ep, Embryo_Cell *params)
339{
340 Edje *ed = embryo_program_data_get(ep);
341
342 CHKPARAM(2);
343
344 _edje_var_list_remove_nth(ed, (int) params[1], (int) params[2]);
345
346 return 0;
347}
348
349/* append_int(id, var) */
350static Embryo_Cell
351_edje_embryo_fn_append_int(Embryo_Program *ep, Embryo_Cell *params)
352{
353 Edje *ed = embryo_program_data_get(ep);
354
355 CHKPARAM(2);
356
357 _edje_var_list_int_append(ed, (int) params[1], (int) params[2]);
358
359 return 0;
360}
361
362/* prepend_int(id, var) */
363static Embryo_Cell
364_edje_embryo_fn_prepend_int(Embryo_Program *ep, Embryo_Cell *params)
365{
366 Edje *ed = embryo_program_data_get(ep);
367
368 CHKPARAM(2);
369
370 _edje_var_list_int_prepend(ed, (int) params[1], (int) params[2]);
371
372 return 0;
373}
374
375/* insert_int(id, pos, var) */
376static Embryo_Cell
377_edje_embryo_fn_insert_int(Embryo_Program *ep, Embryo_Cell *params)
378{
379 Edje *ed = embryo_program_data_get(ep);
380
381 CHKPARAM(3);
382
383 _edje_var_list_int_insert(ed, (int) params[1], (int) params[2],
384 (int) params[3]);
385
386 return 0;
387}
388
389/* replace_int(id, pos, var) */
390static Embryo_Cell
391_edje_embryo_fn_replace_int(Embryo_Program *ep, Embryo_Cell *params)
392{
393 Edje *ed = embryo_program_data_get(ep);
394
395 CHKPARAM(3);
396
397 _edje_var_list_nth_int_set(ed, (int) params[1], (int) params[2],
398 (int) params[3]);
399
400 return 0;
401}
402
403/* fetch_int(id, pos) */
404static Embryo_Cell
405_edje_embryo_fn_fetch_int(Embryo_Program *ep, Embryo_Cell *params)
406{
407 Edje *ed = embryo_program_data_get(ep);
408
409 CHKPARAM(2);
410
411 return _edje_var_list_nth_int_get(ed, (int) params[1],
412 (int) params[2]);
413}
414
415/* append_str(id, str[]) */
416static Embryo_Cell
417_edje_embryo_fn_append_str(Embryo_Program *ep, Embryo_Cell *params)
418{
419 Edje *ed = embryo_program_data_get(ep);
420 char *s;
421
422 CHKPARAM(2);
423
424 GETSTR(s, params[2]);
425 if (s)
426 _edje_var_list_str_append(ed, (int) params[1], s);
427
428 return 0;
429}
430
431/* prepend_str(id, str[]) */
432static Embryo_Cell
433_edje_embryo_fn_prepend_str(Embryo_Program *ep, Embryo_Cell *params)
434{
435 Edje *ed = embryo_program_data_get(ep);
436 char *s;
437
438 CHKPARAM(2);
439
440 GETSTR(s, params[2]);
441 if (s)
442 _edje_var_list_str_prepend(ed, (int) params[1], s);
443
444 return 0;
445}
446
447/* insert_str(id, pos, str[]) */
448static Embryo_Cell
449_edje_embryo_fn_insert_str(Embryo_Program *ep, Embryo_Cell *params)
450{
451 Edje *ed = embryo_program_data_get(ep);
452 char *s;
453
454 CHKPARAM(3);
455
456 GETSTR(s, params[3]);
457 if (s)
458 _edje_var_list_str_insert(ed, (int) params[1], (int) params[2], s);
459
460 return 0;
461}
462
463/* replace_str(id, pos, str[]) */
464static Embryo_Cell
465_edje_embryo_fn_replace_str(Embryo_Program *ep, Embryo_Cell *params)
466{
467 Edje *ed = embryo_program_data_get(ep);
468 char *s;
469
470 CHKPARAM(3);
471
472 GETSTR(s, params[3]);
473 if (s)
474 _edje_var_list_nth_str_set(ed, (int) params[1], (int) params[2], s);
475
476 return 0;
477}
478
479
480/* fetch_str(id, pos, dst[], maxlen) */
481static Embryo_Cell
482_edje_embryo_fn_fetch_str(Embryo_Program *ep, Embryo_Cell *params)
483{
484 Edje *ed = embryo_program_data_get(ep);
485 char *s;
486
487 CHKPARAM(4);
488
489 s = (char *) _edje_var_list_nth_str_get(ed, (int) params[1],
490 (int) params[2]);
491 if (s)
492 {
493 if ((int) strlen(s) < params[4])
494 {
495 SETSTR(s, params[3]);
496 }
497 else
498 {
499 char *ss;
500
501 ss = alloca(strlen(s) + 1);
502 strcpy(ss, s);
503 ss[params[4] - 1] = 0;
504 SETSTR(ss, params[3]);
505 }
506 }
507 else
508 {
509 SETSTR("", params[3]);
510 }
511
512 return 0;
513}
514
515/* append_float(id, Float:f) */
516static Embryo_Cell
517_edje_embryo_fn_append_float(Embryo_Program *ep, Embryo_Cell *params)
518{
519 Edje *ed = embryo_program_data_get(ep);
520 float f;
521
522 CHKPARAM(2);
523
524 f = EMBRYO_CELL_TO_FLOAT(params[2]);
525 _edje_var_list_float_append(ed, (int) params[1], f);
526
527 return 0;
528}
529
530/* prepend_float(id, Float:f) */
531static Embryo_Cell
532_edje_embryo_fn_prepend_float(Embryo_Program *ep, Embryo_Cell *params)
533{
534 Edje *ed = embryo_program_data_get(ep);
535 float f;
536
537 CHKPARAM(2);
538
539 f = EMBRYO_CELL_TO_FLOAT(params[2]);
540 _edje_var_list_float_prepend(ed, (int) params[1], f);
541
542 return 0;
543}
544
545/* insert_float(id, pos, Float:f) */
546static Embryo_Cell
547_edje_embryo_fn_insert_float(Embryo_Program *ep, Embryo_Cell *params)
548{
549 Edje *ed = embryo_program_data_get(ep);
550 float f;
551
552 CHKPARAM(3);
553
554 f = EMBRYO_CELL_TO_FLOAT(params[3]);
555 _edje_var_list_float_insert(ed, (int) params[1], (int) params[2], f);
556
557 return 0;
558}
559
560/* replace_float(id, pos, Float:f) */
561static Embryo_Cell
562_edje_embryo_fn_replace_float(Embryo_Program *ep, Embryo_Cell *params)
563{
564 Edje *ed = embryo_program_data_get(ep);
565
566 CHKPARAM(3);
567
568 _edje_var_list_nth_float_set(ed, (int) params[1], (int) params[2],
569 EMBRYO_CELL_TO_FLOAT(params[3]));
570
571 return 0;
572}
573
574/* Float:fetch_float(id, pos) */
575static Embryo_Cell
576_edje_embryo_fn_fetch_float(Embryo_Program *ep, Embryo_Cell *params)
577{
578 Edje *ed = embryo_program_data_get(ep);
579 float f;
580
581 CHKPARAM(2);
582
583 f = _edje_var_list_nth_float_get(ed, (int) params[1], (int) params[2]);
584
585 return EMBRYO_FLOAT_TO_CELL(f);
586}
587
588/* timer(Float:in, fname[], val) */
589static Embryo_Cell
590_edje_embryo_fn_timer(Embryo_Program *ep, Embryo_Cell *params)
591{
592 Edje *ed;
593 char *fname = NULL;
594 float f;
595 double in;
596 int val;
597
598 CHKPARAM(3);
599 ed = embryo_program_data_get(ep);
600 GETSTR(fname, params[2]);
601 if ((!fname)) return 0;
602 f = EMBRYO_CELL_TO_FLOAT(params[1]);
603 in = (double)f;
604 val = params[3];
605 return _edje_var_timer_add(ed, in, fname, val);
606}
607
608/* cancel_timer(id) */
609static Embryo_Cell
610_edje_embryo_fn_cancel_timer(Embryo_Program *ep, Embryo_Cell *params)
611{
612 Edje *ed;
613 int id;
614
615 CHKPARAM(1);
616 ed = embryo_program_data_get(ep);
617 id = params[1];
618 if (id <= 0) return 0;
619 _edje_var_timer_del(ed, id);
620 return 0;
621}
622
623/* anim(Float:len, fname[], val) */
624static Embryo_Cell
625_edje_embryo_fn_anim(Embryo_Program *ep, Embryo_Cell *params)
626{
627 Edje *ed;
628 char *fname = NULL;
629 float f;
630 double len;
631 int val;
632
633 CHKPARAM(3);
634 ed = embryo_program_data_get(ep);
635 GETSTR(fname, params[2]);
636 if ((!fname)) return 0;
637 f = EMBRYO_CELL_TO_FLOAT(params[1]);
638 len = (double)f;
639 val = params[3];
640 return _edje_var_anim_add(ed, len, fname, val);
641}
642
643/* cancel_anim(id) */
644static Embryo_Cell
645_edje_embryo_fn_cancel_anim(Embryo_Program *ep, Embryo_Cell *params)
646{
647 Edje *ed;
648 int id;
649
650 CHKPARAM(1);
651 ed = embryo_program_data_get(ep);
652 id = params[1];
653 if (id <= 0) return 0;
654 _edje_var_anim_del(ed, id);
655 return 0;
656}
657
658/* set_min_size(Float:w, Float:h) */
659static Embryo_Cell
660_edje_embryo_fn_set_min_size(Embryo_Program *ep, Embryo_Cell *params)
661{
662 Edje *ed;
663 float f = 0.0;
664 double w = 0.0, h = 0.0;
665
666 CHKPARAM(2);
667 ed = embryo_program_data_get(ep);
668 f = EMBRYO_CELL_TO_FLOAT(params[1]);
669 w = (double)f;
670 f = EMBRYO_CELL_TO_FLOAT(params[2]);
671 h = (double)f;
672
673 if (w < 0.0) w = 0.0;
674 if (h < 0.0) h = 0.0;
675 ed->collection->prop.min.w = w;
676 ed->collection->prop.min.h = h;
677 ed->dirty = 1;
678#ifdef EDJE_CALC_CACHE
679 ed->all_part_change = 1;
680#endif
681 _edje_recalc(ed);
682 return 0;
683}
684
685/* set_max_size(Float:w, Float:h) */
686static Embryo_Cell
687_edje_embryo_fn_set_max_size(Embryo_Program *ep, Embryo_Cell *params)
688{
689 Edje *ed;
690 float f = 0.0;
691 double w = 0.0, h = 0.0;
692
693 CHKPARAM(2);
694 ed = embryo_program_data_get(ep);
695 f = EMBRYO_CELL_TO_FLOAT(params[1]);
696 w = (double)f;
697 f = EMBRYO_CELL_TO_FLOAT(params[2]);
698 h = (double)f;
699
700 if (w < 0.0) w = 0.0;
701 if (h < 0.0) h = 0.0;
702 ed->collection->prop.max.w = w;
703 ed->collection->prop.max.h = h;
704 ed->dirty = 1;
705#ifdef EDJE_CALC_CACHE
706 ed->all_part_change = 1;
707#endif
708 _edje_recalc(ed);
709
710 return 0;
711}
712
713/* stop_program(program_id) */
714static Embryo_Cell
715_edje_embryo_fn_stop_program(Embryo_Program *ep, Embryo_Cell *params)
716{
717 Edje *ed;
718 int program_id = 0;
719 Edje_Running_Program *runp;
720 Eina_List *l;
721
722 CHKPARAM(1);
723 ed = embryo_program_data_get(ep);
724 program_id = params[1];
725 if (program_id < 0) return 0;
726
727 ed->walking_actions = 1;
728
729 EINA_LIST_FOREACH(ed->actions, l, runp)
730 if (program_id == runp->program->id)
731 _edje_program_end(ed, runp);
732
733 ed->walking_actions = 0;
734
735 return 0;
736}
737
738/* stop_programs_on(part_id) */
739static Embryo_Cell
740_edje_embryo_fn_stop_programs_on(Embryo_Program *ep, Embryo_Cell *params)
741{
742 Edje *ed;
743
744 int part_id = 0;
745 Edje_Real_Part *rp;
746
747 CHKPARAM(1);
748 ed = embryo_program_data_get(ep);
749 part_id = params[1];
750 if (part_id < 0) return 0;
751 rp = ed->table_parts[part_id % ed->table_parts_size];
752 if (rp)
753 {
754 /* there is only ever 1 program acting on a part at any time */
755 if (rp->program) _edje_program_end(ed, rp->program);
756 }
757 return 0;
758}
759
760/* get_mouse(&x, &y) */
761static Embryo_Cell
762_edje_embryo_fn_get_mouse(Embryo_Program *ep, Embryo_Cell *params)
763{
764 Edje *ed;
765 Evas_Coord x = 0, y = 0;
766
767 CHKPARAM(2);
768 ed = embryo_program_data_get(ep);
769 evas_pointer_canvas_xy_get(ed->base.evas, &x, &y);
770 x -= ed->x;
771 y -= ed->y;
772 SETINT((int)x, params[1]);
773 SETINT((int)y, params[2]);
774 return 0;
775}
776
777/* get_mouse_buttons() */
778static Embryo_Cell
779_edje_embryo_fn_get_mouse_buttons(Embryo_Program *ep, Embryo_Cell *params)
780{
781 Edje *ed;
782
783 CHKPARAM(0);
784 ed = embryo_program_data_get(ep);
785 return evas_pointer_button_down_mask_get(ed->base.evas);
786}
787
788/* emit(sig[], src[]) */
789static Embryo_Cell
790_edje_embryo_fn_emit(Embryo_Program *ep, Embryo_Cell *params)
791{
792 Edje *ed;
793 char *sig = NULL, *src = NULL;
794
795 CHKPARAM(2);
796 ed = embryo_program_data_get(ep);
797 GETSTR(sig, params[1]);
798 GETSTR(src, params[2]);
799 if ((!sig) || (!src)) return 0;
800 _edje_emit(ed, sig, src);
801 return 0;
802}
803
804/* get_part_id(part[]) */
805static Embryo_Cell
806_edje_embryo_fn_get_part_id(Embryo_Program *ep, Embryo_Cell *params)
807{
808 Edje *ed;
809 Edje_Part_Collection *col;
810 Edje_Part **part;
811 char *p;
812 unsigned int i;
813
814 CHKPARAM(1);
815 ed = embryo_program_data_get(ep);
816 GETSTR(p, params[1]);
817 if (!p) return -1;
818 col = ed->collection;
819 if (!col) return -1;
820 part = col->parts;
821 for (i = 0; i < col->parts_count; i++, part++)
822 {
823 if (!(*part)->name) continue;
824 if (!strcmp((*part)->name, p)) return (*part)->id;
825 }
826 return -1;
827}
828
829static Embryo_Cell
830_edje_embryo_fn_play_sample(Embryo_Program *ep, Embryo_Cell *params)
831{
832 Edje *ed;
833 char *sample_name = NULL;
834 float speed = 1.0;
835
836 CHKPARAM(1);
837 ed = embryo_program_data_get(ep);
838 GETSTR(sample_name, params[1]);
839 if ((!sample_name)) return 0;
840 speed = EMBRYO_CELL_TO_FLOAT(params[2]);
841 _edje_multisense_internal_sound_sample_play(ed, sample_name, (double)speed);
842 return 0;
843}
844
845static Embryo_Cell
846_edje_embryo_fn_play_tone(Embryo_Program *ep, Embryo_Cell *params)
847{
848 Edje *ed;
849 char *tone_name = NULL;
850 float duration = 0.1;
851
852 CHKPARAM(2);
853 ed = embryo_program_data_get(ep);
854 GETSTR(tone_name, params[1]);
855 if ((!tone_name)) return 0;
856 duration = EMBRYO_CELL_TO_FLOAT(params[2]);
857 _edje_multisense_internal_sound_tone_play(ed, tone_name, (double) duration);
858 return 0;
859}
860
861/* set_state(part_id, state[], Float:state_val) */
862static Embryo_Cell
863_edje_embryo_fn_set_state(Embryo_Program *ep, Embryo_Cell *params)
864{
865 Edje *ed;
866 char *state = NULL;
867 int part_id = 0;
868 float f = 0.0;
869 double value = 0.0;
870 Edje_Real_Part *rp;
871
872 CHKPARAM(3);
873 ed = embryo_program_data_get(ep);
874 GETSTR(state, params[2]);
875 if ((!state)) return 0;
876 part_id = params[1];
877 if (part_id < 0) return 0;
878 f = EMBRYO_CELL_TO_FLOAT(params[3]);
879 value = (double)f;
880 rp = ed->table_parts[part_id % ed->table_parts_size];
881 if (rp)
882 {
883 if (rp->program) _edje_program_end(ed, rp->program);
884 _edje_part_description_apply(ed, rp, state, value, NULL, 0.0);
885 _edje_part_pos_set(ed, rp, EDJE_TWEEN_MODE_LINEAR, ZERO, ZERO, ZERO);
886 _edje_recalc(ed);
887 }
888 return 0;
889}
890
891/* get_state(part_id, dst[], maxlen, &Float:val) */
892static Embryo_Cell
893_edje_embryo_fn_get_state(Embryo_Program *ep, Embryo_Cell *params)
894{
895 Edje *ed;
896 int part_id = 0;
897 Edje_Real_Part *rp;
898 const char *s;
899
900 CHKPARAM(4);
901 ed = embryo_program_data_get(ep);
902 part_id = params[1];
903 if (part_id < 0) return 0;
904 rp = ed->table_parts[part_id % ed->table_parts_size];
905 if (rp->chosen_description)
906 {
907 SETFLOAT(rp->chosen_description->state.value, params[4]);
908 s = rp->chosen_description->state.name;
909 if (s)
910 {
911 if ((int) strlen(s) < params[3])
912 {
913 SETSTR(s, params[2]);
914 }
915 else
916 {
917 char *ss;
918
919 ss = alloca(strlen(s) + 1);
920 strcpy(ss, s);
921 ss[params[3] - 1] = 0;
922 SETSTR(ss, params[2]);
923 }
924 }
925 else
926 {
927 SETSTR("", params[2]);
928 }
929 }
930 else
931 {
932 SETFLOAT(0.0, params[4]);
933 SETSTR("", params[2]);
934 }
935 return 0;
936}
937
938/* set_tween_state(part_id, Float:tween, state1[], Float:state1_val, state2[], Float:state2_val) */
939static Embryo_Cell
940_edje_embryo_fn_set_tween_state(Embryo_Program *ep, Embryo_Cell *params)
941{
942 Edje *ed;
943 char *state1 = NULL, *state2 = NULL;
944 int part_id = 0;
945 float f = 0.0;
946 double tween = 0.0, value1 = 0.0, value2 = 0.0;
947 Edje_Real_Part *rp;
948
949 CHKPARAM(6);
950 ed = embryo_program_data_get(ep);
951 GETSTR(state1, params[3]);
952 GETSTR(state2, params[5]);
953 if ((!state1) || (!state2)) return 0;
954 part_id = params[1];
955 if (part_id < 0) return 0;
956 f = EMBRYO_CELL_TO_FLOAT(params[2]);
957 tween = (double)f;
958 f = EMBRYO_CELL_TO_FLOAT(params[4]);
959 value1 = (double)f;
960 f = EMBRYO_CELL_TO_FLOAT(params[6]);
961 value2 = (double)f;
962 rp = ed->table_parts[part_id % ed->table_parts_size];
963 if (rp)
964 {
965 if (rp->program) _edje_program_end(ed, rp->program);
966 _edje_part_description_apply(ed, rp, state1, value1, state2, value2);
967 _edje_part_pos_set(ed, rp, EDJE_TWEEN_MODE_LINEAR, FROM_DOUBLE(tween), ZERO, ZERO);
968 _edje_recalc(ed);
969 }
970 return 0;
971}
972
973/* run_program(program_id) */
974static Embryo_Cell
975_edje_embryo_fn_run_program(Embryo_Program *ep, Embryo_Cell *params)
976{
977 Edje *ed;
978 int program_id = 0;
979 Edje_Program *pr;
980
981 CHKPARAM(1);
982 ed = embryo_program_data_get(ep);
983 program_id = params[1];
984 if (program_id < 0) return 0;
985 pr = ed->table_programs[program_id % ed->table_programs_size];
986 if (pr)
987 {
988 _edje_program_run(ed, pr, 0, "", "");
989 }
990 return 0;
991}
992
993/* get_drag_dir(part_id) */
994static Embryo_Cell
995_edje_embryo_fn_get_drag_dir(Embryo_Program *ep, Embryo_Cell *params)
996{
997 Edje *ed;
998 int part_id = 0;
999 Edje_Real_Part *rp;
1000
1001 CHKPARAM(1);
1002 ed = embryo_program_data_get(ep);
1003 part_id = params[1];
1004 if (part_id < 0) return 0;
1005 rp = ed->table_parts[part_id % ed->table_parts_size];
1006 return edje_object_part_drag_dir_get(ed->obj, rp->part->name);
1007}
1008
1009/* get_drag(part_id, &Float:dx, &Float:dy) */
1010static Embryo_Cell
1011_edje_embryo_fn_get_drag(Embryo_Program *ep, Embryo_Cell *params)
1012{
1013 Edje *ed;
1014 int part_id = 0;
1015 Edje_Real_Part *rp;
1016 double dx = 0.0, dy = 0.0;
1017
1018 CHKPARAM(3);
1019 ed = embryo_program_data_get(ep);
1020 part_id = params[1];
1021 if (part_id < 0) return 0;
1022 rp = ed->table_parts[part_id % ed->table_parts_size];
1023 edje_object_part_drag_value_get(ed->obj, rp->part->name, &dx, &dy);
1024 SETFLOAT(dx, params[2]);
1025 SETFLOAT(dy, params[3]);
1026
1027 return 0;
1028}
1029
1030/* set_drag(part_id, Float:dx, Float:dy) */
1031static Embryo_Cell
1032_edje_embryo_fn_set_drag(Embryo_Program *ep, Embryo_Cell *params)
1033{
1034 Edje *ed;
1035 int part_id = 0;
1036 Edje_Real_Part *rp;
1037
1038 CHKPARAM(3);
1039 ed = embryo_program_data_get(ep);
1040 part_id = params[1];
1041 if (part_id < 0) return 0;
1042 rp = ed->table_parts[part_id % ed->table_parts_size];
1043 edje_object_part_drag_value_set(ed->obj, rp->part->name,
1044 (double)EMBRYO_CELL_TO_FLOAT(params[2]),
1045 (double)EMBRYO_CELL_TO_FLOAT(params[3]));
1046 return(0);
1047}
1048
1049/* get_drag_size(part_id, &Float:dx, &Float:dy) */
1050static Embryo_Cell
1051_edje_embryo_fn_get_drag_size(Embryo_Program *ep, Embryo_Cell *params)
1052{
1053 Edje *ed;
1054 int part_id = 0;
1055 Edje_Real_Part *rp;
1056 double dx = 0.0, dy = 0.0;
1057
1058 CHKPARAM(3);
1059 ed = embryo_program_data_get(ep);
1060 part_id = params[1];
1061 if (part_id < 0) return 0;
1062 rp = ed->table_parts[part_id % ed->table_parts_size];
1063 edje_object_part_drag_size_get(ed->obj, rp->part->name, &dx, &dy);
1064 SETFLOAT(dx, params[2]);
1065 SETFLOAT(dy, params[3]);
1066
1067 return 0;
1068}
1069
1070/* set_drag_size(part_id, Float:dx, Float:dy) */
1071static Embryo_Cell
1072_edje_embryo_fn_set_drag_size(Embryo_Program *ep, Embryo_Cell *params)
1073{
1074 Edje *ed;
1075 int part_id = 0;
1076 Edje_Real_Part *rp;
1077
1078 CHKPARAM(3);
1079 ed = embryo_program_data_get(ep);
1080 part_id = params[1];
1081 if (part_id < 0) return 0;
1082 rp = ed->table_parts[part_id % ed->table_parts_size];
1083 edje_object_part_drag_size_set(ed->obj, rp->part->name,
1084 (double)EMBRYO_CELL_TO_FLOAT(params[2]),
1085 (double)EMBRYO_CELL_TO_FLOAT(params[3]));
1086 return(0);
1087}
1088
1089/* set_text(part_id, str[]) */
1090static Embryo_Cell
1091_edje_embryo_fn_set_text(Embryo_Program *ep, Embryo_Cell *params)
1092{
1093 Edje *ed;
1094 int part_id = 0;
1095 Edje_Real_Part *rp;
1096 char *s;
1097
1098 CHKPARAM(2);
1099 ed = embryo_program_data_get(ep);
1100 part_id = params[1];
1101 if (part_id < 0) return 0;
1102 rp = ed->table_parts[part_id % ed->table_parts_size];
1103 GETSTR(s, params[2]);
1104 if (s){
1105 edje_object_part_text_set(ed->obj, rp->part->name, s);
1106 }
1107 return(0);
1108}
1109
1110/* get_text(part_id, dst[], maxlen) */
1111static Embryo_Cell
1112_edje_embryo_fn_get_text(Embryo_Program *ep, Embryo_Cell *params)
1113{
1114 Edje *ed;
1115 int part_id = 0;
1116 Edje_Real_Part *rp;
1117 char *s;
1118
1119 CHKPARAM(3);
1120 ed = embryo_program_data_get(ep);
1121 part_id = params[1];
1122 if (part_id < 0) return 0;
1123 rp = ed->table_parts[part_id % ed->table_parts_size];
1124 s = (char *)edje_object_part_text_get(ed->obj, rp->part->name);
1125 if (s)
1126 {
1127 if ((int) strlen(s) < params[3])
1128 {
1129 SETSTR(s, params[2]);
1130 }
1131 else
1132 {
1133 char *ss;
1134
1135 ss = alloca(strlen(s) + 1);
1136 strcpy(ss, s);
1137 ss[params[3] - 1] = 0;
1138 SETSTR(ss, params[2]);
1139 }
1140 }
1141 else
1142 {
1143 SETSTR("", params[2]);
1144 }
1145 return 0;
1146}
1147
1148/* get_min_size(&w, &h) */
1149static Embryo_Cell
1150_edje_embryo_fn_get_min_size(Embryo_Program *ep, Embryo_Cell *params)
1151{
1152 Edje *ed;
1153 Evas_Coord w = 0, h = 0;
1154
1155 CHKPARAM(2);
1156 ed = embryo_program_data_get(ep);
1157 edje_object_size_min_get(ed->obj, &w, &h);
1158 SETINT(w, params[1]);
1159 SETINT(h, params[2]);
1160 return 0;
1161}
1162
1163/* get_max_size(&w, &h) */
1164static Embryo_Cell
1165_edje_embryo_fn_get_max_size(Embryo_Program *ep, Embryo_Cell *params)
1166{
1167 Edje *ed;
1168 Evas_Coord w = 0, h = 0;
1169
1170 CHKPARAM(2);
1171 ed = embryo_program_data_get(ep);
1172 edje_object_size_max_get(ed->obj, &w, &h);
1173 SETINT(w, params[1]);
1174 SETINT(h, params[2]);
1175 return 0;
1176
1177}
1178
1179/* get_color_class(class[], &r, &g, &b, &a) */
1180static Embryo_Cell
1181_edje_embryo_fn_get_color_class(Embryo_Program *ep, Embryo_Cell *params)
1182{
1183 Edje *ed;
1184 Edje_Color_Class *c_class;
1185 char *class;
1186
1187 CHKPARAM(5);
1188 ed = embryo_program_data_get(ep);
1189 GETSTR(class, params[1]);
1190 if (!class) return 0;
1191 c_class = _edje_color_class_find(ed, class);
1192 if (!c_class) return 0;
1193 SETINT(c_class->r, params[2]);
1194 SETINT(c_class->g, params[3]);
1195 SETINT(c_class->b, params[4]);
1196 SETINT(c_class->a, params[5]);
1197 return 0;
1198}
1199
1200/* set_color_class(class[], r, g, b, a) */
1201static Embryo_Cell
1202_edje_embryo_fn_set_color_class(Embryo_Program *ep, Embryo_Cell *params)
1203{
1204 Edje *ed;
1205 char *class;
1206
1207 CHKPARAM(5);
1208 ed = embryo_program_data_get(ep);
1209 GETSTR(class, params[1]);
1210 if (!class) return 0;
1211 edje_object_color_class_set(ed->obj, class, params[2], params[3], params[4], params[5],
1212 params[2], params[3], params[4], params[5],
1213 params[2], params[3], params[4], params[5]);
1214 return 0;
1215}
1216
1217/* set_text_class(class[], font[], Float:size) */
1218static Embryo_Cell
1219_edje_embryo_fn_set_text_class(Embryo_Program *ep, Embryo_Cell *params)
1220{
1221 Edje *ed;
1222 char *class, *font;
1223 Evas_Font_Size fsize;
1224
1225 CHKPARAM(3);
1226 ed = embryo_program_data_get(ep);
1227 GETSTR(class, params[1]);
1228 GETSTR(font, params[2]);
1229 if( !class || !font ) return 0;
1230 fsize = (Evas_Font_Size) EMBRYO_CELL_TO_FLOAT(params[3]);
1231 edje_object_text_class_set(ed->obj, class, font, fsize);
1232 return 0;
1233}
1234
1235/* get_text_class(class[], font[], &Float:size) */
1236static Embryo_Cell
1237_edje_embryo_fn_get_text_class(Embryo_Program *ep, Embryo_Cell *params)
1238{
1239 Edje *ed;
1240 char *class;
1241 Edje_Text_Class *t_class;
1242
1243 CHKPARAM(3);
1244 ed = embryo_program_data_get(ep);
1245 GETSTR(class, params[1]);
1246 if (!class) return 0;
1247 t_class = _edje_text_class_find(ed, class);
1248 if (!t_class) return 0;
1249 SETSTR((char *)t_class->font, params[2]);
1250 SETFLOAT(t_class->size, params[3]);
1251 return 0;
1252}
1253
1254/* get_drag_step(part_id, &Float:dx, &Float:&dy) */
1255static Embryo_Cell
1256_edje_embryo_fn_get_drag_step(Embryo_Program *ep, Embryo_Cell *params)
1257{
1258 Edje *ed;
1259 int part_id = 0;
1260 Edje_Real_Part *rp;
1261 double dx = 0.0, dy = 0.0;
1262
1263 CHKPARAM(3);
1264 ed = embryo_program_data_get(ep);
1265 part_id = params[1];
1266 if (part_id < 0) return 0;
1267 rp = ed->table_parts[part_id % ed->table_parts_size];
1268 edje_object_part_drag_step_get(ed->obj, rp->part->name, &dx, &dy);
1269 SETFLOAT(dx, params[2]);
1270 SETFLOAT(dy, params[3]);
1271
1272 return 0;
1273}
1274
1275/* set_drag_step(part_id, Float:dx, Float:dy) */
1276static Embryo_Cell
1277_edje_embryo_fn_set_drag_step(Embryo_Program *ep, Embryo_Cell *params)
1278{
1279 Edje *ed;
1280 int part_id = 0;
1281 Edje_Real_Part *rp;
1282
1283 CHKPARAM(3);
1284 ed = embryo_program_data_get(ep);
1285 part_id = params[1];
1286 if (part_id < 0) return 0;
1287 rp = ed->table_parts[part_id % ed->table_parts_size];
1288 edje_object_part_drag_step_set(ed->obj, rp->part->name,
1289 (double)EMBRYO_CELL_TO_FLOAT(params[2]),
1290 (double)EMBRYO_CELL_TO_FLOAT(params[3]));
1291 return(0);
1292}
1293
1294/* get_drag_page(part_id, &Float:dx, &Float:&dy) */
1295static Embryo_Cell
1296_edje_embryo_fn_get_drag_page(Embryo_Program *ep, Embryo_Cell *params)
1297{
1298 Edje *ed;
1299 int part_id = 0;
1300 Edje_Real_Part *rp;
1301 double dx = 0.0, dy = 0.0;
1302
1303 CHKPARAM(3);
1304 ed = embryo_program_data_get(ep);
1305 part_id = params[1];
1306 if (part_id < 0) return 0;
1307 rp = ed->table_parts[part_id % ed->table_parts_size];
1308 edje_object_part_drag_page_get(ed->obj, rp->part->name, &dx, &dy);
1309 SETFLOAT(dx, params[2]);
1310 SETFLOAT(dy, params[3]);
1311
1312 return 0;
1313}
1314
1315/* get_geometry(pard_id, &x, &y, &w, &h) */
1316static Embryo_Cell
1317_edje_embryo_fn_get_geometry(Embryo_Program *ep, Embryo_Cell *params)
1318{
1319 Edje *ed;
1320 int part_id = 0;
1321 Edje_Real_Part *rp;
1322 Evas_Coord x = 0.0, y = 0.0, w = 0.0, h = 0.0;
1323
1324 CHKPARAM(5);
1325 ed = embryo_program_data_get(ep);
1326 part_id = params[1];
1327 if (part_id < 0) return 0;
1328 rp = ed->table_parts[part_id % ed->table_parts_size];
1329 edje_object_part_geometry_get(ed->obj, rp->part->name, &x, &y, &w, &h);
1330 SETINT(x, params[2]);
1331 SETINT(y, params[3]);
1332 SETINT(w, params[4]);
1333 SETINT(h, params[5]);
1334
1335 return 0;
1336}
1337
1338/* set_drag_page(part_id, Float:dx, Float:dy) */
1339static Embryo_Cell
1340_edje_embryo_fn_set_drag_page(Embryo_Program *ep, Embryo_Cell *params)
1341{
1342 Edje *ed;
1343 int part_id = 0;
1344 Edje_Real_Part *rp;
1345
1346 CHKPARAM(3);
1347 ed = embryo_program_data_get(ep);
1348 part_id = params[1];
1349 if (part_id < 0) return 0;
1350 rp = ed->table_parts[part_id % ed->table_parts_size];
1351 edje_object_part_drag_page_set(ed->obj, rp->part->name,
1352 (double)EMBRYO_CELL_TO_FLOAT(params[2]),
1353 (double)EMBRYO_CELL_TO_FLOAT(params[3]));
1354 return(0);
1355}
1356
1357/* send_message(Msg_Type:type, id,...); */
1358static Embryo_Cell
1359_edje_embryo_fn_send_message(Embryo_Program *ep, Embryo_Cell *params)
1360{
1361 Edje *ed;
1362 Edje_Message_Type type;
1363 int id, i, n;
1364 Embryo_Cell *ptr;
1365
1366 if (params[0] < (int) (sizeof(Embryo_Cell) * (2))) return 0;
1367 ed = embryo_program_data_get(ep);
1368 type = params[1];
1369 id = params[2];
1370 switch (type)
1371 {
1372 case EDJE_MESSAGE_NONE:
1373 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, NULL);
1374 break;
1375 case EDJE_MESSAGE_SIGNAL:
1376 break;
1377 case EDJE_MESSAGE_STRING:
1378 {
1379 Embryo_Cell *cptr;
1380
1381 cptr = embryo_data_address_get(ep, params[3]);
1382 if (cptr)
1383 {
1384 Edje_Message_String *emsg;
1385 int l;
1386 char *s;
1387
1388 l = embryo_data_string_length_get(ep, cptr);
1389 s = alloca(l + 1);
1390 s[0] = 0;
1391 embryo_data_string_get(ep, cptr, s);
1392 emsg = alloca(sizeof(Edje_Message_String));
1393 emsg->str = s;
1394 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1395 }
1396 }
1397 break;
1398 case EDJE_MESSAGE_INT:
1399 {
1400 Edje_Message_Int *emsg;
1401
1402 emsg = alloca(sizeof(Edje_Message_Int));
1403 ptr = embryo_data_address_get(ep, params[3]);
1404 if (ptr) emsg->val = (int)*ptr;
1405 else emsg->val = 0;
1406 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1407 }
1408 break;
1409 case EDJE_MESSAGE_FLOAT:
1410 {
1411 Edje_Message_Float *emsg;
1412 float f;
1413
1414 emsg = alloca(sizeof(Edje_Message_Float));
1415 ptr = embryo_data_address_get(ep, params[3]);
1416 if (ptr)
1417 {
1418 f = EMBRYO_CELL_TO_FLOAT(*ptr);
1419 emsg->val = (double)f;
1420 }
1421 else
1422 emsg->val = 0.0;
1423 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1424 }
1425 break;
1426 case EDJE_MESSAGE_STRING_SET:
1427 {
1428 Edje_Message_String_Set *emsg;
1429
1430 n = (params[0] / sizeof(Embryo_Cell)) + 1;
1431 emsg = alloca(sizeof(Edje_Message_String_Set) + ((n - 3 - 1) * sizeof(char *)));
1432 emsg->count = n - 3;
1433 for (i = 3; i < n; i++)
1434 {
1435 Embryo_Cell *cptr;
1436
1437 cptr = embryo_data_address_get(ep, params[i]);
1438 if (cptr)
1439 {
1440 int l;
1441 char *s;
1442
1443 l = embryo_data_string_length_get(ep, cptr);
1444 s = alloca(l + 1);
1445 s[0] = 0;
1446 embryo_data_string_get(ep, cptr, s);
1447 emsg->str[i - 3] = s;
1448 }
1449 }
1450 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1451 }
1452 break;
1453 case EDJE_MESSAGE_INT_SET:
1454 {
1455 Edje_Message_Int_Set *emsg;
1456
1457 n = (params[0] / sizeof(Embryo_Cell)) + 1;
1458 emsg = alloca(sizeof(Edje_Message_Int_Set) + ((n - 3 - 1) * sizeof(int)));
1459 emsg->count = n - 3;
1460 for (i = 3; i < n; i++)
1461 {
1462 ptr = embryo_data_address_get(ep, params[i]);
1463 if (ptr) emsg->val[i - 3] = (int)*ptr;
1464 else emsg->val[i - 3] = 0;
1465 }
1466 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1467 }
1468 break;
1469 case EDJE_MESSAGE_FLOAT_SET:
1470 {
1471 Edje_Message_Float_Set *emsg;
1472
1473 n = (params[0] / sizeof(Embryo_Cell)) + 1;
1474 emsg = alloca(sizeof(Edje_Message_Float_Set) + ((n - 3 - 1) * sizeof(double)));
1475 emsg->count = n - 3;
1476 for (i = 3; i < n; i++)
1477 {
1478 float f;
1479
1480 ptr = embryo_data_address_get(ep, params[i]);
1481 if (ptr)
1482 {
1483 f = EMBRYO_CELL_TO_FLOAT(*ptr);
1484 emsg->val[i - 3] = (double)f;
1485 }
1486 else
1487 emsg->val[i - 3] = 0.0;
1488 }
1489 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1490 }
1491 break;
1492 case EDJE_MESSAGE_STRING_INT:
1493 {
1494 Edje_Message_String_Int *emsg;
1495 Embryo_Cell *cptr;
1496
1497 cptr = embryo_data_address_get(ep, params[3]);
1498 if (cptr)
1499 {
1500 int l;
1501 char *s;
1502
1503 l = embryo_data_string_length_get(ep, cptr);
1504 s = alloca(l + 1);
1505 s[0] = 0;
1506 embryo_data_string_get(ep, cptr, s);
1507 emsg = alloca(sizeof(Edje_Message_String_Int));
1508 emsg->str = s;
1509 ptr = embryo_data_address_get(ep, params[4]);
1510 if (ptr) emsg->val = (int)*ptr;
1511 else emsg->val = 0;
1512 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1513 }
1514 }
1515 break;
1516 case EDJE_MESSAGE_STRING_FLOAT:
1517 {
1518 Edje_Message_String_Float *emsg;
1519 Embryo_Cell *cptr;
1520
1521 cptr = embryo_data_address_get(ep, params[3]);
1522 if (cptr)
1523 {
1524 int l;
1525 char *s;
1526 float f;
1527
1528 l = embryo_data_string_length_get(ep, cptr);
1529 s = alloca(l + 1);
1530 s[0] = 0;
1531 embryo_data_string_get(ep, cptr, s);
1532 emsg = alloca(sizeof(Edje_Message_String_Float));
1533 emsg->str = s;
1534 ptr = embryo_data_address_get(ep, params[4]);
1535 if (ptr)
1536 {
1537 f = EMBRYO_CELL_TO_FLOAT(*ptr);
1538 emsg->val = (double)f;
1539 }
1540 else
1541 emsg->val = 0.0;
1542 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1543 }
1544 }
1545 break;
1546 case EDJE_MESSAGE_STRING_INT_SET:
1547 {
1548 Edje_Message_String_Int_Set *emsg;
1549 Embryo_Cell *cptr;
1550
1551 cptr = embryo_data_address_get(ep, params[3]);
1552 if (cptr)
1553 {
1554 int l;
1555 char *s;
1556
1557 l = embryo_data_string_length_get(ep, cptr);
1558 s = alloca(l + 1);
1559 s[0] = 0;
1560 embryo_data_string_get(ep, cptr, s);
1561 n = (params[0] / sizeof(Embryo_Cell)) + 1;
1562 emsg = alloca(sizeof(Edje_Message_String_Int_Set) + ((n - 4 - 1) * sizeof(int)));
1563 emsg->str = s;
1564 emsg->count = n - 4;
1565 for (i = 4; i < n; i++)
1566 {
1567 ptr = embryo_data_address_get(ep, params[i]);
1568 if (ptr) emsg->val[i - 4] = (int)*ptr;
1569 else emsg->val[i - 4] = 0;
1570 }
1571 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1572 }
1573 }
1574 break;
1575 case EDJE_MESSAGE_STRING_FLOAT_SET:
1576 {
1577 Edje_Message_String_Float_Set *emsg;
1578 Embryo_Cell *cptr;
1579
1580 cptr = embryo_data_address_get(ep, params[3]);
1581 if (cptr)
1582 {
1583 int l;
1584 char *s;
1585
1586 l = embryo_data_string_length_get(ep, cptr);
1587 s = alloca(l + 1);
1588 s[0] = 0;
1589 embryo_data_string_get(ep, cptr, s);
1590 n = (params[0] / sizeof(Embryo_Cell)) + 1;
1591 emsg = alloca(sizeof(Edje_Message_String_Float_Set) + ((n - 4 - 1) * sizeof(double)));
1592 emsg->str = s;
1593 emsg->count = n - 4;
1594 for (i = 4; i < n; i++)
1595 {
1596 float f;
1597
1598 ptr = embryo_data_address_get(ep, params[i]);
1599 if (ptr)
1600 {
1601 f = EMBRYO_CELL_TO_FLOAT(*ptr);
1602 emsg->val[i - 4] = (double)f;
1603 }
1604 else
1605 emsg->val[i - 4] = 0.0;
1606 }
1607 _edje_message_send(ed, EDJE_QUEUE_APP, type, id, emsg);
1608 }
1609 }
1610 break;
1611 default:
1612 break;
1613 }
1614 return(0);
1615}
1616
1617/* custom_state(part_id, state[], Float:state_val = 0.0) */
1618static Embryo_Cell
1619_edje_embryo_fn_custom_state(Embryo_Program *ep, Embryo_Cell *params)
1620{
1621 Edje *ed = embryo_program_data_get(ep);
1622 Edje_Real_Part *rp;
1623 Edje_Part_Description_Common *parent, *d = NULL;
1624 char *name;
1625 float val;
1626
1627 CHKPARAM(3);
1628
1629 if (params[1] < 0)
1630 return 0;
1631
1632 if (!(rp = ed->table_parts[params[1] % ed->table_parts_size]))
1633 return 0;
1634
1635 /* check whether this part already has a "custom" state */
1636 if (rp->custom)
1637 return 0;
1638
1639 GETSTR(name, params[2]);
1640 if (!name)
1641 return 0;
1642
1643 val = EMBRYO_CELL_TO_FLOAT(params[3]);
1644
1645 if (!(parent = _edje_part_description_find(ed, rp, name, val)))
1646 return 0;
1647
1648 /* now create the custom state */
1649 switch (rp->part->type)
1650 {
1651#define ALLOC_DESC(Short, Type, To) \
1652 case EDJE_PART_TYPE_##Short: To = calloc(1, sizeof (Edje_Part_Description_##Type)); break;
1653
1654#define ALLOC_COPY_DESC(Short, Type, To, Spec) \
1655 case EDJE_PART_TYPE_##Short: \
1656 { \
1657 Edje_Part_Description_##Type *tmp; \
1658 Edje_Part_Description_##Type *new; \
1659 \
1660 tmp = (Edje_Part_Description_##Type *) parent; \
1661 \
1662 new = calloc(1, sizeof (Edje_Part_Description_##Type)); \
1663 new->Spec = tmp->Spec; \
1664 d = &new->common; \
1665 break; \
1666 }
1667
1668 ALLOC_DESC(RECTANGLE, Common, d);
1669 ALLOC_DESC(SWALLOW, Common, d);
1670 ALLOC_DESC(GROUP, Common, d);
1671
1672 ALLOC_COPY_DESC(IMAGE, Image, d, image);
1673 ALLOC_COPY_DESC(TEXT, Text, d, text);
1674 ALLOC_COPY_DESC(TEXTBLOCK, Text, d, text);
1675 ALLOC_COPY_DESC(BOX, Box, d, box);
1676 ALLOC_COPY_DESC(TABLE, Table, d, table);
1677 ALLOC_COPY_DESC(EXTERNAL, External, d, external_params);
1678 }
1679
1680 if (!d) return 0;
1681
1682 rp->custom = eina_mempool_malloc(_edje_real_part_state_mp, sizeof (Edje_Real_Part_State));
1683 if (!rp->custom)
1684 {
1685 free(d);
1686 return 0;
1687 }
1688
1689 memset(rp->custom, 0, sizeof (Edje_Real_Part_State));
1690
1691 *d = *parent;
1692
1693 d->state.name = (char *)eina_stringshare_add("custom");
1694 d->state.value = 0.0;
1695
1696 /* make sure all the allocated memory is getting copied,
1697 * not just referenced
1698 */
1699 if (rp->part->type == EDJE_PART_TYPE_IMAGE)
1700 {
1701 Edje_Part_Description_Image *img_desc;
1702 Edje_Part_Description_Image *parent_img_desc;
1703
1704 img_desc = (Edje_Part_Description_Image*) d;
1705 parent_img_desc = (Edje_Part_Description_Image*) parent;
1706
1707 img_desc->image.tweens_count = parent_img_desc->image.tweens_count;
1708 img_desc->image.tweens = calloc(img_desc->image.tweens_count,
1709 sizeof(Edje_Part_Image_Id*));
1710 if (img_desc->image.tweens)
1711 {
1712 unsigned int i;
1713
1714 for (i = 0; i < parent_img_desc->image.tweens_count; ++i)
1715 {
1716 Edje_Part_Image_Id *iid_new;
1717
1718 iid_new = calloc(1, sizeof(Edje_Part_Image_Id));
1719 if (!iid_new) continue;
1720
1721 *iid_new = *parent_img_desc->image.tweens[i];
1722
1723 img_desc->image.tweens[i] = iid_new;
1724 }
1725 }
1726 }
1727
1728#define DUP(x) x ? (char *)eina_stringshare_add(x) : NULL
1729 d->color_class = DUP(d->color_class);
1730
1731 if (rp->part->type == EDJE_PART_TYPE_TEXT
1732 || rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
1733 {
1734 Edje_Part_Description_Text *text_desc;
1735
1736 text_desc = (Edje_Part_Description_Text*) d;
1737
1738 text_desc->text.text_class = DUP(text_desc->text.text_class);
1739 text_desc->text.text.str = DUP(edje_string_get(&text_desc->text.text));
1740 text_desc->text.text.id = 0;
1741 text_desc->text.font.str = DUP(edje_string_get(&text_desc->text.font));
1742 text_desc->text.font.id = 0;
1743 text_desc->text.style.str = DUP(edje_string_get(&text_desc->text.style));
1744 text_desc->text.style.id = 0;
1745 }
1746#undef DUP
1747
1748 rp->custom->description = d;
1749
1750 return 0;
1751}
1752
1753/* set_state_val(part_id, State_Param:p, ...) */
1754static Embryo_Cell
1755_edje_embryo_fn_set_state_val(Embryo_Program *ep, Embryo_Cell *params)
1756{
1757 Edje *ed = embryo_program_data_get(ep);
1758 Edje_Real_Part *rp;
1759 char *s;
1760
1761 /* we need at least 3 arguments */
1762 if (params[0] < (int) (sizeof(Embryo_Cell) * 3))
1763 return 0;
1764
1765 if (params[1] < 0)
1766 return 0;
1767
1768 if (!(rp = ed->table_parts[params[1] % ed->table_parts_size]))
1769 return 0;
1770
1771 /* check whether this part has a "custom" state */
1772 if (!rp->custom)
1773 return 0;
1774
1775 switch (params[2])
1776 {
1777 case EDJE_STATE_PARAM_ALIGNMENT:
1778 CHKPARAM(4);
1779
1780 GETFLOAT_T(rp->custom->description->align.x, params[3]);
1781 GETFLOAT_T(rp->custom->description->align.y, params[4]);
1782
1783 break;
1784 case EDJE_STATE_PARAM_MIN:
1785 CHKPARAM(4);
1786
1787 GETINT(rp->custom->description->min.w, params[3]);
1788 GETINT(rp->custom->description->min.h, params[4]);
1789
1790 break;
1791 case EDJE_STATE_PARAM_MAX:
1792 CHKPARAM(4);
1793
1794 GETINT(rp->custom->description->max.w, params[3]);
1795 GETINT(rp->custom->description->max.h, params[4]);
1796
1797 break;
1798 case EDJE_STATE_PARAM_STEP:
1799 CHKPARAM(4);
1800
1801 GETINT(rp->custom->description->step.x, params[3]);
1802 GETINT(rp->custom->description->step.y, params[4]);
1803
1804 break;
1805 case EDJE_STATE_PARAM_ASPECT:
1806 CHKPARAM(4);
1807
1808 GETFLOAT_T(rp->custom->description->aspect.min, params[3]);
1809 GETFLOAT_T(rp->custom->description->aspect.max, params[4]);
1810
1811 break;
1812 case EDJE_STATE_PARAM_ASPECT_PREF:
1813 CHKPARAM(3);
1814
1815 GETINT(rp->custom->description->aspect.prefer, params[3]);
1816
1817 break;
1818 case EDJE_STATE_PARAM_COLOR:
1819 CHKPARAM(6);
1820
1821 GETINT(rp->custom->description->color.r, params[3]);
1822 GETINT(rp->custom->description->color.g, params[4]);
1823 GETINT(rp->custom->description->color.b, params[5]);
1824 GETINT(rp->custom->description->color.a, params[6]);
1825
1826 break;
1827 case EDJE_STATE_PARAM_COLOR2:
1828 CHKPARAM(6);
1829
1830 GETINT(rp->custom->description->color2.r, params[3]);
1831 GETINT(rp->custom->description->color2.g, params[4]);
1832 GETINT(rp->custom->description->color2.b, params[5]);
1833 GETINT(rp->custom->description->color2.a, params[6]);
1834
1835 break;
1836 case EDJE_STATE_PARAM_COLOR3:
1837 {
1838 Edje_Part_Description_Text *text;
1839
1840 if ( (rp->part->type != EDJE_PART_TYPE_TEXT) &&
1841 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
1842 return 0;
1843
1844 CHKPARAM(6);
1845
1846 text = (Edje_Part_Description_Text*) rp->custom->description;
1847
1848 GETINT(text->text.color3.r, params[3]);
1849 GETINT(text->text.color3.g, params[4]);
1850 GETINT(text->text.color3.b, params[5]);
1851 GETINT(text->text.color3.a, params[6]);
1852 break;
1853 }
1854 case EDJE_STATE_PARAM_COLOR_CLASS:
1855 CHKPARAM(3);
1856
1857 GETSTR(s, params[3]);
1858 GETSTREVAS(s, rp->custom->description->color_class);
1859
1860 break;
1861 case EDJE_STATE_PARAM_REL1:
1862 CHKPARAM(4);
1863
1864 GETFLOAT_T(rp->custom->description->rel1.relative_x, params[3]);
1865 GETFLOAT_T(rp->custom->description->rel1.relative_y, params[4]);
1866
1867 break;
1868 case EDJE_STATE_PARAM_REL1_TO:
1869 CHKPARAM(4);
1870
1871 GETINT(rp->custom->description->rel1.id_x, params[3]);
1872 GETINT(rp->custom->description->rel1.id_y, params[4]);
1873
1874 if (rp->param1.description->rel1.id_x >= 0)
1875 rp->param1.rel1_to_x = ed->table_parts[rp->param1.description->rel1.id_x % ed->table_parts_size];
1876 if (rp->param1.description->rel1.id_y >= 0)
1877 rp->param1.rel1_to_y = ed->table_parts[rp->param1.description->rel1.id_y % ed->table_parts_size];
1878
1879 break;
1880 case EDJE_STATE_PARAM_REL1_OFFSET:
1881 CHKPARAM(4);
1882
1883 GETINT(rp->custom->description->rel1.offset_x, params[3]);
1884 GETINT(rp->custom->description->rel1.offset_y, params[4]);
1885
1886 break;
1887 case EDJE_STATE_PARAM_REL2:
1888 CHKPARAM(4);
1889
1890 GETFLOAT_T(rp->custom->description->rel2.relative_x, params[3]);
1891 GETFLOAT_T(rp->custom->description->rel2.relative_y, params[4]);
1892
1893 break;
1894 case EDJE_STATE_PARAM_REL2_TO:
1895 CHKPARAM(4);
1896
1897 GETINT(rp->custom->description->rel2.id_x, params[3]);
1898 GETINT(rp->custom->description->rel2.id_y, params[4]);
1899
1900 if (rp->param1.description->rel2.id_x >= 0)
1901 rp->param1.rel2_to_x = ed->table_parts[rp->param1.description->rel2.id_x % ed->table_parts_size];
1902 if (rp->param1.description->rel2.id_y >= 0)
1903 rp->param1.rel2_to_y = ed->table_parts[rp->param1.description->rel2.id_y % ed->table_parts_size];
1904
1905 break;
1906 case EDJE_STATE_PARAM_REL2_OFFSET:
1907 CHKPARAM(4);
1908
1909 GETINT(rp->custom->description->rel2.offset_x, params[3]);
1910 GETINT(rp->custom->description->rel2.offset_y, params[4]);
1911
1912 break;
1913 case EDJE_STATE_PARAM_IMAGE:
1914 {
1915 Edje_Part_Description_Image *img;
1916
1917 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
1918 CHKPARAM(3);
1919
1920 img = (Edje_Part_Description_Image*) rp->custom->description;
1921 GETINT(img->image.id, params[3]);
1922
1923 break;
1924 }
1925 case EDJE_STATE_PARAM_BORDER:
1926 {
1927 Edje_Part_Description_Image *img;
1928
1929 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
1930 CHKPARAM(6);
1931
1932 img = (Edje_Part_Description_Image*) rp->custom->description;
1933
1934 GETINT(img->image.border.l, params[3]);
1935 GETINT(img->image.border.r, params[4]);
1936 GETINT(img->image.border.t, params[5]);
1937 GETINT(img->image.border.b, params[6]);
1938
1939 break;
1940 }
1941 case EDJE_STATE_PARAM_FILL_SMOOTH:
1942 {
1943 Edje_Part_Description_Image *img;
1944
1945 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
1946 CHKPARAM(3);
1947
1948 img = (Edje_Part_Description_Image*) rp->custom->description;
1949
1950 GETINT(img->image.fill.smooth, params[3]);
1951
1952 break;
1953 }
1954 case EDJE_STATE_PARAM_FILL_POS:
1955 {
1956 Edje_Part_Description_Image *img;
1957
1958 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
1959 CHKPARAM(6);
1960
1961 img = (Edje_Part_Description_Image*) rp->custom->description;
1962
1963 GETFLOAT_T(img->image.fill.pos_rel_x, params[3]);
1964 GETFLOAT_T(img->image.fill.pos_rel_y, params[4]);
1965 GETINT(img->image.fill.pos_abs_x, params[5]);
1966 GETINT(img->image.fill.pos_abs_y, params[6]);
1967
1968 break;
1969 }
1970 case EDJE_STATE_PARAM_FILL_SIZE:
1971 {
1972 Edje_Part_Description_Image *img;
1973
1974 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
1975 CHKPARAM(6);
1976
1977 img = (Edje_Part_Description_Image*) rp->custom->description;
1978
1979 GETFLOAT_T(img->image.fill.rel_x, params[3]);
1980 GETFLOAT_T(img->image.fill.rel_y, params[4]);
1981 GETINT(img->image.fill.abs_x, params[5]);
1982 GETINT(img->image.fill.abs_y, params[6]);
1983
1984 break;
1985 }
1986 case EDJE_STATE_PARAM_TEXT:
1987 {
1988 Edje_Part_Description_Text *text;
1989
1990 if ( (rp->part->type != EDJE_PART_TYPE_TEXT) &&
1991 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
1992 return 0;
1993 CHKPARAM(3);
1994
1995 GETSTR(s, params[3]);
1996
1997 text = (Edje_Part_Description_Text*) rp->custom->description;
1998 GETSTREVAS(s, text->text.text.str);
1999
2000 break;
2001 }
2002 case EDJE_STATE_PARAM_TEXT_CLASS:
2003 {
2004 Edje_Part_Description_Text *text;
2005
2006 if ( (rp->part->type != EDJE_PART_TYPE_TEXT) &&
2007 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2008 return 0;
2009 CHKPARAM(3);
2010
2011 GETSTR(s, params[3]);
2012
2013 text = (Edje_Part_Description_Text*) rp->custom->description;
2014 GETSTREVAS(s, text->text.text_class);
2015
2016 break;
2017 }
2018 case EDJE_STATE_PARAM_TEXT_FONT:
2019 {
2020 Edje_Part_Description_Text *text;
2021
2022 if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2023 CHKPARAM(3);
2024
2025 GETSTR(s, params[3]);
2026
2027 text = (Edje_Part_Description_Text*) rp->custom->description;
2028 GETSTREVAS(s, text->text.font.str);
2029
2030 break;
2031 }
2032 case EDJE_STATE_PARAM_TEXT_STYLE:
2033 {
2034 Edje_Part_Description_Text *text;
2035
2036 if ((rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return 0;
2037 CHKPARAM(3);
2038
2039 GETSTR(s, params[3]);
2040
2041 text = (Edje_Part_Description_Text*) rp->custom->description;
2042 GETSTREVAS(s, text->text.style.str);
2043
2044 break;
2045 }
2046 case EDJE_STATE_PARAM_TEXT_SIZE:
2047 {
2048 Edje_Part_Description_Text *text;
2049
2050 if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2051 CHKPARAM(3);
2052
2053 text = (Edje_Part_Description_Text*) rp->custom->description;
2054 GETINT(text->text.size, params[3]);
2055
2056 break;
2057 }
2058 case EDJE_STATE_PARAM_TEXT_FIT:
2059 {
2060 Edje_Part_Description_Text *text;
2061
2062 if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2063 CHKPARAM(4);
2064
2065 text = (Edje_Part_Description_Text*) rp->custom->description;
2066
2067 GETINT(text->text.fit_x, params[3]);
2068 GETINT(text->text.fit_y, params[4]);
2069
2070 break;
2071 }
2072 case EDJE_STATE_PARAM_TEXT_MIN:
2073 {
2074 Edje_Part_Description_Text *text;
2075
2076 if ( (rp->part->type != EDJE_PART_TYPE_TEXT) &&
2077 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2078 return 0;
2079 CHKPARAM(4);
2080
2081 text = (Edje_Part_Description_Text*) rp->custom->description;
2082
2083 GETINT(text->text.min_x, params[3]);
2084 GETINT(text->text.min_y, params[4]);
2085
2086 break;
2087 }
2088 case EDJE_STATE_PARAM_TEXT_MAX:
2089 {
2090 Edje_Part_Description_Text *text;
2091
2092 if ( (rp->part->type != EDJE_PART_TYPE_TEXT) &&
2093 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2094 return 0;
2095 CHKPARAM(4);
2096
2097 text = (Edje_Part_Description_Text*) rp->custom->description;
2098
2099 GETINT(text->text.max_x, params[3]);
2100 GETINT(text->text.max_y, params[4]);
2101
2102 break;
2103 }
2104 case EDJE_STATE_PARAM_TEXT_ALIGN:
2105 {
2106 Edje_Part_Description_Text *text;
2107
2108 if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2109 CHKPARAM(4);
2110
2111 text = (Edje_Part_Description_Text*) rp->custom->description;
2112
2113 GETFLOAT_T(text->text.align.x, params[3]);
2114 GETFLOAT_T(text->text.align.y, params[4]);
2115
2116 break;
2117 }
2118 case EDJE_STATE_PARAM_VISIBLE:
2119 CHKPARAM(3);
2120
2121 GETINT(rp->custom->description->visible, params[3]);
2122
2123 break;
2124 case EDJE_STATE_PARAM_MAP_OM:
2125 CHKPARAM(3);
2126
2127 GETINT(rp->custom->description->map.on, params[3]);
2128
2129 break;
2130 case EDJE_STATE_PARAM_MAP_PERSP:
2131 CHKPARAM(3);
2132
2133 GETINT(rp->custom->description->map.id_persp, params[3]);
2134
2135 break;
2136 case EDJE_STATE_PARAM_MAP_LIGNT:
2137 CHKPARAM(3);
2138
2139 GETINT(rp->custom->description->map.id_light, params[3]);
2140
2141 break;
2142 case EDJE_STATE_PARAM_MAP_ROT_CENTER:
2143 CHKPARAM(3);
2144
2145 GETINT(rp->custom->description->map.rot.id_center, params[3]);
2146
2147 break;
2148 case EDJE_STATE_PARAM_MAP_ROT_X:
2149 CHKPARAM(3);
2150
2151 GETFLOAT_T(rp->custom->description->map.rot.x, params[3]);
2152
2153 break;
2154 case EDJE_STATE_PARAM_MAP_ROT_Y:
2155 CHKPARAM(3);
2156
2157 GETFLOAT_T(rp->custom->description->map.rot.y, params[3]);
2158
2159 break;
2160 case EDJE_STATE_PARAM_MAP_ROT_Z:
2161 CHKPARAM(3);
2162
2163 GETFLOAT_T(rp->custom->description->map.rot.z, params[3]);
2164
2165 break;
2166 case EDJE_STATE_PARAM_MAP_BACK_CULL:
2167 CHKPARAM(3);
2168
2169 GETINT(rp->custom->description->map.backcull, params[3]);
2170
2171 break;
2172 case EDJE_STATE_PARAM_MAP_PERSP_ON:
2173 CHKPARAM(3);
2174
2175 GETINT(rp->custom->description->map.persp_on, params[3]);
2176
2177 break;
2178 case EDJE_STATE_PARAM_PERSP_ZPLANE:
2179 CHKPARAM(3);
2180
2181 GETINT(rp->custom->description->persp.zplane, params[3]);
2182
2183 break;
2184 case EDJE_STATE_PARAM_PERSP_FOCAL:
2185 CHKPARAM(3);
2186
2187 GETINT(rp->custom->description->persp.focal, params[3]);
2188
2189 break;
2190 default:
2191 break;
2192 }
2193
2194#ifdef EDJE_CALC_CACHE
2195 rp->invalidate = 1;
2196#endif
2197 ed->dirty=1;
2198 return 0;
2199}
2200
2201/* get_state_val(part_id, State_Param:p, ...) */
2202static Embryo_Cell
2203_edje_embryo_fn_get_state_val(Embryo_Program *ep, Embryo_Cell *params)
2204{
2205 Edje *ed = embryo_program_data_get(ep);
2206 Edje_Real_Part *rp;
2207 char *s;
2208
2209 /* we need at least 3 arguments */
2210 if (params[0] < (int) (sizeof(Embryo_Cell) * 3))
2211 return 0;
2212
2213 if (params[1] < 0)
2214 return 0;
2215
2216 if (!(rp = ed->table_parts[params[1] % ed->table_parts_size]))
2217 return 0;
2218
2219 /* check whether this part has a "custom" state */
2220 if (!rp->custom)
2221 return 0;
2222
2223 switch (params[2])
2224 {
2225 case EDJE_STATE_PARAM_ALIGNMENT:
2226 CHKPARAM(4);
2227
2228 SETFLOAT_T(rp->custom->description->align.x, params[3]);
2229 SETFLOAT_T(rp->custom->description->align.y, params[4]);
2230
2231 break;
2232 case EDJE_STATE_PARAM_MIN:
2233 CHKPARAM(4);
2234
2235 SETINT(rp->custom->description->min.w, params[3]);
2236 SETINT(rp->custom->description->min.h, params[4]);
2237
2238 break;
2239 case EDJE_STATE_PARAM_MAX:
2240 CHKPARAM(4);
2241
2242 SETINT(rp->custom->description->max.w, params[3]);
2243 SETINT(rp->custom->description->max.h, params[4]);
2244
2245 break;
2246 case EDJE_STATE_PARAM_STEP:
2247 CHKPARAM(4);
2248
2249 SETINT(rp->custom->description->step.x, params[3]);
2250 SETINT(rp->custom->description->step.y, params[4]);
2251
2252 break;
2253 case EDJE_STATE_PARAM_ASPECT:
2254 CHKPARAM(4);
2255
2256 SETFLOAT_T(rp->custom->description->aspect.min, params[3]);
2257 SETFLOAT_T(rp->custom->description->aspect.max, params[4]);
2258
2259 break;
2260 case EDJE_STATE_PARAM_ASPECT_PREF:
2261 CHKPARAM(3);
2262
2263 SETINT(rp->custom->description->aspect.prefer, params[3]);
2264
2265 break;
2266 case EDJE_STATE_PARAM_COLOR:
2267 CHKPARAM(6);
2268
2269 SETINT(rp->custom->description->color.r, params[3]);
2270 SETINT(rp->custom->description->color.g, params[4]);
2271 SETINT(rp->custom->description->color.b, params[5]);
2272 SETINT(rp->custom->description->color.a, params[6]);
2273
2274 break;
2275 case EDJE_STATE_PARAM_COLOR2:
2276 CHKPARAM(6);
2277
2278 SETINT(rp->custom->description->color2.r, params[3]);
2279 SETINT(rp->custom->description->color2.g, params[4]);
2280 SETINT(rp->custom->description->color2.b, params[5]);
2281 SETINT(rp->custom->description->color2.a, params[6]);
2282
2283 break;
2284 case EDJE_STATE_PARAM_COLOR3:
2285 {
2286 Edje_Part_Description_Text *text;
2287
2288 if (rp->part->type == EDJE_PART_TYPE_TEXT
2289 || rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
2290 return 0;
2291
2292 CHKPARAM(6);
2293
2294 text = (Edje_Part_Description_Text*) rp->custom->description;
2295
2296 SETINT(text->text.color3.r, params[3]);
2297 SETINT(text->text.color3.g, params[4]);
2298 SETINT(text->text.color3.b, params[5]);
2299 SETINT(text->text.color3.a, params[6]);
2300
2301 break;
2302 }
2303 case EDJE_STATE_PARAM_COLOR_CLASS:
2304 CHKPARAM(4);
2305
2306 s = rp->custom->description->color_class;
2307 SETSTRALLOCATE(s);
2308
2309 break;
2310 case EDJE_STATE_PARAM_REL1:
2311 CHKPARAM(4);
2312
2313 SETFLOAT_T(rp->custom->description->rel1.relative_x, params[3]);
2314 SETFLOAT_T(rp->custom->description->rel1.relative_y, params[4]);
2315
2316 break;
2317 case EDJE_STATE_PARAM_REL1_TO:
2318 CHKPARAM(4);
2319
2320 SETINT(rp->custom->description->rel1.id_x, params[3]);
2321 SETINT(rp->custom->description->rel1.id_y, params[4]);
2322
2323 break;
2324 case EDJE_STATE_PARAM_REL1_OFFSET:
2325 CHKPARAM(4);
2326
2327 SETINT(rp->custom->description->rel1.offset_x, params[3]);
2328 SETINT(rp->custom->description->rel1.offset_y, params[4]);
2329
2330 break;
2331 case EDJE_STATE_PARAM_REL2:
2332 CHKPARAM(4);
2333
2334 SETFLOAT_T(rp->custom->description->rel2.relative_x, params[3]);
2335 SETFLOAT_T(rp->custom->description->rel2.relative_y, params[4]);
2336
2337 break;
2338 case EDJE_STATE_PARAM_REL2_TO:
2339 CHKPARAM(4);
2340
2341 SETINT(rp->custom->description->rel2.id_x, params[3]);
2342 SETINT(rp->custom->description->rel2.id_y, params[4]);
2343
2344 break;
2345 case EDJE_STATE_PARAM_REL2_OFFSET:
2346 CHKPARAM(4);
2347
2348 SETINT(rp->custom->description->rel2.offset_x, params[3]);
2349 SETINT(rp->custom->description->rel2.offset_y, params[4]);
2350
2351 break;
2352 case EDJE_STATE_PARAM_IMAGE:
2353 {
2354 Edje_Part_Description_Image *img;
2355
2356 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
2357 CHKPARAM(3);
2358
2359 img = (Edje_Part_Description_Image*) rp->custom->description;
2360
2361 SETINT(img->image.id, params[3]);
2362
2363 break;
2364 }
2365 case EDJE_STATE_PARAM_BORDER:
2366 {
2367 Edje_Part_Description_Image *img;
2368
2369 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
2370 CHKPARAM(6);
2371
2372 img = (Edje_Part_Description_Image*) rp->custom->description;
2373
2374 SETINT(img->image.border.l, params[3]);
2375 SETINT(img->image.border.r, params[4]);
2376 SETINT(img->image.border.t, params[5]);
2377 SETINT(img->image.border.b, params[6]);
2378
2379 break;
2380 }
2381 case EDJE_STATE_PARAM_FILL_SMOOTH:
2382 {
2383 Edje_Part_Description_Image *img;
2384
2385 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
2386 CHKPARAM(3);
2387
2388 img = (Edje_Part_Description_Image*) rp->custom->description;
2389
2390 SETINT(img->image.fill.smooth, params[3]);
2391
2392 break;
2393 }
2394 case EDJE_STATE_PARAM_FILL_POS:
2395 {
2396 Edje_Part_Description_Image *img;
2397
2398 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
2399 CHKPARAM(6);
2400
2401 img = (Edje_Part_Description_Image*) rp->custom->description;
2402
2403 SETFLOAT_T(img->image.fill.pos_rel_x, params[3]);
2404 SETFLOAT_T(img->image.fill.pos_rel_y, params[4]);
2405 SETINT(img->image.fill.pos_abs_x, params[5]);
2406 SETINT(img->image.fill.pos_abs_y, params[6]);
2407
2408 break;
2409 }
2410 case EDJE_STATE_PARAM_FILL_SIZE:
2411 {
2412 Edje_Part_Description_Image *img;
2413
2414 if ( (rp->part->type != EDJE_PART_TYPE_IMAGE) ) return 0;
2415 CHKPARAM(6);
2416
2417 img = (Edje_Part_Description_Image*) rp->custom->description;
2418
2419 SETFLOAT_T(img->image.fill.rel_x, params[3]);
2420 SETFLOAT_T(img->image.fill.rel_y, params[4]);
2421 SETINT(img->image.fill.abs_x, params[5]);
2422 SETINT(img->image.fill.abs_y, params[6]);
2423
2424 break;
2425 }
2426 case EDJE_STATE_PARAM_TEXT:
2427 {
2428 Edje_Part_Description_Text *text;
2429
2430 if (rp->part->type == EDJE_PART_TYPE_TEXT
2431 || rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
2432 return 0;
2433
2434 CHKPARAM(4);
2435
2436 text = (Edje_Part_Description_Text*) rp->custom->description;
2437
2438 s = (char *)text->text.text.str;
2439 SETSTRALLOCATE(s);
2440
2441 break;
2442 }
2443 case EDJE_STATE_PARAM_TEXT_CLASS:
2444 {
2445 Edje_Part_Description_Text *text;
2446
2447 if ( (rp->part->type != EDJE_PART_TYPE_TEXT) &&
2448 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2449 return 0;
2450
2451 CHKPARAM(4);
2452
2453 text = (Edje_Part_Description_Text*) rp->custom->description;
2454
2455 s = text->text.text_class;
2456 SETSTRALLOCATE(s);
2457
2458 break;
2459 }
2460 case EDJE_STATE_PARAM_TEXT_FONT:
2461 {
2462 Edje_Part_Description_Text *text;
2463
2464 if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2465
2466 CHKPARAM(4);
2467
2468 text = (Edje_Part_Description_Text*) rp->custom->description;
2469
2470 s = (char *)text->text.font.str;
2471 SETSTRALLOCATE(s);
2472
2473 break;
2474 }
2475 case EDJE_STATE_PARAM_TEXT_STYLE:
2476 {
2477 Edje_Part_Description_Text *text;
2478
2479 if ((rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return 0;
2480
2481 CHKPARAM(4);
2482
2483 text = (Edje_Part_Description_Text*) rp->custom->description;
2484
2485 s = (char *)text->text.style.str;
2486 SETSTRALLOCATE(s);
2487
2488 break;
2489 }
2490 case EDJE_STATE_PARAM_TEXT_SIZE:
2491 {
2492 Edje_Part_Description_Text *text;
2493
2494 if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2495
2496 CHKPARAM(3);
2497
2498 text = (Edje_Part_Description_Text*) rp->custom->description;
2499
2500 SETINT(text->text.size, params[3]);
2501
2502 break;
2503 }
2504 case EDJE_STATE_PARAM_TEXT_FIT:
2505 {
2506 Edje_Part_Description_Text *text;
2507
2508 if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2509 CHKPARAM(4);
2510
2511 text = (Edje_Part_Description_Text*) rp->custom->description;
2512
2513 SETINT(text->text.fit_x, params[3]);
2514 SETINT(text->text.fit_y, params[4]);
2515
2516 break;
2517 }
2518 case EDJE_STATE_PARAM_TEXT_MIN:
2519 {
2520 Edje_Part_Description_Text *text;
2521
2522 if ( (rp->part->type != EDJE_PART_TYPE_TEXT) &&
2523 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2524 return 0;
2525
2526 CHKPARAM(4);
2527
2528 text = (Edje_Part_Description_Text*) rp->custom->description;
2529
2530 SETINT(text->text.min_x, params[3]);
2531 SETINT(text->text.min_y, params[4]);
2532
2533 break;
2534 }
2535 case EDJE_STATE_PARAM_TEXT_MAX:
2536 {
2537 Edje_Part_Description_Text *text;
2538
2539 if ( (rp->part->type != EDJE_PART_TYPE_TEXT) &&
2540 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK))
2541 return 0;
2542
2543 CHKPARAM(4);
2544
2545 text = (Edje_Part_Description_Text*) rp->custom->description;
2546
2547 SETINT(text->text.max_x, params[3]);
2548 SETINT(text->text.max_y, params[4]);
2549
2550 break;
2551 }
2552 case EDJE_STATE_PARAM_TEXT_ALIGN:
2553 {
2554 Edje_Part_Description_Text *text;
2555
2556 if ((rp->part->type != EDJE_PART_TYPE_TEXT)) return 0;
2557
2558 CHKPARAM(4);
2559
2560 text = (Edje_Part_Description_Text*) rp->custom->description;
2561
2562 SETFLOAT_T(text->text.align.x, params[3]);
2563 SETFLOAT_T(text->text.align.y, params[4]);
2564
2565 break;
2566 }
2567 case EDJE_STATE_PARAM_VISIBLE:
2568 CHKPARAM(3);
2569
2570 SETINT(rp->custom->description->visible, params[3]);
2571
2572 break;
2573 default:
2574 break;
2575 }
2576
2577 return 0;
2578}
2579
2580/* part_swallow(part_id, group_name) */
2581static Embryo_Cell
2582_edje_embryo_fn_part_swallow(Embryo_Program *ep, Embryo_Cell *params)
2583{
2584 int part_id = 0;
2585 char* group_name = 0;
2586 Edje *ed;
2587 Edje_Real_Part *rp;
2588 Evas_Object *new_obj;
2589
2590 CHKPARAM(2);
2591
2592 part_id = params[1];
2593 if (part_id < 0) return 0;
2594
2595 GETSTR(group_name, params[2]);
2596 if (!group_name) return 0;
2597
2598 ed = embryo_program_data_get(ep);
2599
2600 rp = ed->table_parts[part_id % ed->table_parts_size];
2601 if (!rp) return 0;
2602
2603 new_obj = edje_object_add(ed->base.evas);
2604 if (!new_obj) return 0;
2605
2606 if (!edje_object_file_set(new_obj, ed->file->path, group_name))
2607 {
2608 evas_object_del(new_obj);
2609 return 0;
2610 }
2611 edje_object_part_swallow(ed->obj, rp->part->name, new_obj);
2612 _edje_subobj_register(ed, new_obj);
2613
2614 return 0;
2615}
2616
2617/* external_param_get_int(id, param_name[]) */
2618static Embryo_Cell
2619_edje_embryo_fn_external_param_get_int(Embryo_Program *ep, Embryo_Cell *params)
2620{
2621 Edje *ed;
2622 int part_id;
2623 Edje_Real_Part *rp;
2624 Edje_External_Param eep;
2625 char *param_name;
2626
2627 CHKPARAM(2);
2628 ed = embryo_program_data_get(ep);
2629
2630 part_id = params[1];
2631 if (part_id < 0) return 0;
2632 rp = ed->table_parts[part_id % ed->table_parts_size];
2633
2634 GETSTR(param_name, params[2]);
2635 if (!param_name) return 0;
2636 eep.name = param_name;
2637 eep.type = EDJE_EXTERNAL_PARAM_TYPE_INT;
2638 eep.i = 0;
2639 _edje_external_param_get(NULL, rp, &eep);
2640 return eep.i;
2641}
2642
2643/* external_param_set_int(id, param_name[], val) */
2644static Embryo_Cell
2645_edje_embryo_fn_external_param_set_int(Embryo_Program *ep, Embryo_Cell *params)
2646{
2647 Edje *ed;
2648 int part_id;
2649 Edje_Real_Part *rp;
2650 Edje_External_Param eep;
2651 char *param_name;
2652
2653 CHKPARAM(3);
2654 ed = embryo_program_data_get(ep);
2655
2656 part_id = params[1];
2657 if (part_id < 0) return 0;
2658 rp = ed->table_parts[part_id % ed->table_parts_size];
2659
2660 GETSTR(param_name, params[2]);
2661 if (!param_name) return 0;
2662 eep.name = param_name;
2663 eep.type = EDJE_EXTERNAL_PARAM_TYPE_INT;
2664 eep.i = params[3];
2665 return _edje_external_param_set(NULL, rp, &eep);
2666}
2667
2668/* Float:external_param_get_float(id, param_name[]) */
2669static Embryo_Cell
2670_edje_embryo_fn_external_param_get_float(Embryo_Program *ep, Embryo_Cell *params)
2671{
2672 Edje *ed;
2673 int part_id;
2674 Edje_Real_Part *rp;
2675 Edje_External_Param eep;
2676 char *param_name;
2677 float v;
2678
2679 CHKPARAM(2);
2680 ed = embryo_program_data_get(ep);
2681
2682 part_id = params[1];
2683 if (part_id < 0) return 0;
2684 rp = ed->table_parts[part_id % ed->table_parts_size];
2685
2686 GETSTR(param_name, params[2]);
2687 if (!param_name) return 0;
2688 eep.name = param_name;
2689 eep.type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
2690 eep.d = 0.0;
2691 _edje_external_param_get(NULL, rp, &eep);
2692 v = eep.d;
2693 return EMBRYO_FLOAT_TO_CELL(v);
2694}
2695
2696/* external_param_set_float(id, param_name[], Float:val) */
2697static Embryo_Cell
2698_edje_embryo_fn_external_param_set_float(Embryo_Program *ep, Embryo_Cell *params)
2699{
2700 Edje *ed;
2701 int part_id;
2702 Edje_Real_Part *rp;
2703 Edje_External_Param eep;
2704 char *param_name;
2705
2706 CHKPARAM(3);
2707 ed = embryo_program_data_get(ep);
2708
2709 part_id = params[1];
2710 if (part_id < 0) return 0;
2711 rp = ed->table_parts[part_id % ed->table_parts_size];
2712
2713 GETSTR(param_name, params[2]);
2714 if (!param_name) return 0;
2715 eep.name = param_name;
2716 eep.type = EDJE_EXTERNAL_PARAM_TYPE_DOUBLE;
2717 eep.d = EMBRYO_CELL_TO_FLOAT(params[3]);
2718 return _edje_external_param_set(NULL, rp, &eep);
2719}
2720
2721/* external_param_get_strlen(id, param_name[]) */
2722static Embryo_Cell
2723_edje_embryo_fn_external_param_get_strlen(Embryo_Program *ep, Embryo_Cell *params)
2724{
2725 Edje *ed;
2726 int part_id;
2727 Edje_Real_Part *rp;
2728 Edje_External_Param eep;
2729 char *param_name;
2730
2731 CHKPARAM(2);
2732 ed = embryo_program_data_get(ep);
2733
2734 part_id = params[1];
2735 if (part_id < 0) return 0;
2736 rp = ed->table_parts[part_id % ed->table_parts_size];
2737
2738 GETSTR(param_name, params[2]);
2739 if (!param_name) return 0;
2740 eep.name = param_name;
2741 eep.type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
2742 eep.s = NULL;
2743 _edje_external_param_get(NULL, rp, &eep);
2744 if (!eep.s) return 0;
2745 return strlen(eep.s);
2746}
2747
2748/* external_param_get_str(id, param_name[], val[], val_maxlen) */
2749static Embryo_Cell
2750_edje_embryo_fn_external_param_get_str(Embryo_Program *ep, Embryo_Cell *params)
2751{
2752 Edje *ed;
2753 int part_id;
2754 Edje_Real_Part *rp;
2755 Edje_External_Param eep;
2756 char *param_name;
2757 size_t src_len, dst_len;
2758
2759 CHKPARAM(4);
2760 dst_len = params[4];
2761 if (dst_len < 1) goto error;
2762
2763 ed = embryo_program_data_get(ep);
2764
2765 part_id = params[1];
2766 if (part_id < 0) goto error;
2767 rp = ed->table_parts[part_id % ed->table_parts_size];
2768
2769 GETSTR(param_name, params[2]);
2770 if (!param_name) return 0;
2771 eep.name = param_name;
2772 eep.type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
2773 eep.s = NULL;
2774 _edje_external_param_get(NULL, rp, &eep);
2775 if (!eep.s) goto error;
2776 src_len = strlen(eep.s);
2777 if (src_len < dst_len)
2778 {
2779 SETSTR(eep.s, params[3]);
2780 }
2781 else
2782 {
2783 char *tmp = alloca(dst_len);
2784 memcpy(tmp, eep.s, dst_len - 1);
2785 tmp[dst_len] = '\0';
2786 SETSTR(tmp, params[3]);
2787 }
2788 return 1;
2789
2790 error:
2791 SETSTR("", params[3]);
2792 return 0;
2793}
2794
2795/* external_param_set_str(id, param_name[], val[]) */
2796static Embryo_Cell
2797_edje_embryo_fn_external_param_set_str(Embryo_Program *ep, Embryo_Cell *params)
2798{
2799 Edje *ed;
2800 int part_id;
2801 Edje_Real_Part *rp;
2802 Edje_External_Param eep;
2803 char *param_name, *val;
2804
2805 CHKPARAM(3);
2806 ed = embryo_program_data_get(ep);
2807
2808 part_id = params[1];
2809 if (part_id < 0) return 0;
2810 rp = ed->table_parts[part_id % ed->table_parts_size];
2811
2812 GETSTR(param_name, params[2]);
2813 if (!param_name) return 0;
2814 eep.name = param_name;
2815 eep.type = EDJE_EXTERNAL_PARAM_TYPE_STRING;
2816 GETSTR(val, params[3]);
2817 if (!val) return 0;
2818 eep.s = val;
2819 return _edje_external_param_set(NULL, rp, &eep);
2820}
2821
2822/* external_param_get_choice_len(id, param_name[]) */
2823static Embryo_Cell
2824_edje_embryo_fn_external_param_get_choice_len(Embryo_Program *ep, Embryo_Cell *params)
2825{
2826 Edje *ed;
2827 int part_id;
2828 Edje_Real_Part *rp;
2829 Edje_External_Param eep;
2830 char *param_name;
2831
2832 CHKPARAM(2);
2833 ed = embryo_program_data_get(ep);
2834
2835 part_id = params[1];
2836 if (part_id < 0) return 0;
2837 rp = ed->table_parts[part_id % ed->table_parts_size];
2838
2839 GETSTR(param_name, params[2]);
2840 if (!param_name) return 0;
2841 eep.name = param_name;
2842 eep.type = EDJE_EXTERNAL_PARAM_TYPE_CHOICE;
2843 eep.s = NULL;
2844 _edje_external_param_get(NULL, rp, &eep);
2845 if (!eep.s) return 0;
2846 return strlen(eep.s);
2847}
2848
2849/* external_param_get_choice(id, param_name[], val[], val_maxlen) */
2850static Embryo_Cell
2851_edje_embryo_fn_external_param_get_choice(Embryo_Program *ep, Embryo_Cell *params)
2852{
2853 Edje *ed;
2854 int part_id;
2855 Edje_Real_Part *rp;
2856 Edje_External_Param eep;
2857 char *param_name;
2858 size_t src_len, dst_len;
2859
2860 CHKPARAM(4);
2861 dst_len = params[4];
2862 if (dst_len < 1) goto error;
2863
2864 ed = embryo_program_data_get(ep);
2865
2866 part_id = params[1];
2867 if (part_id < 0) goto error;
2868 rp = ed->table_parts[part_id % ed->table_parts_size];
2869
2870 GETSTR(param_name, params[2]);
2871 if (!param_name) return 0;
2872 eep.name = param_name;
2873 eep.type = EDJE_EXTERNAL_PARAM_TYPE_CHOICE;
2874 eep.s = NULL;
2875 _edje_external_param_get(NULL, rp, &eep);
2876 if (!eep.s) goto error;
2877 src_len = strlen(eep.s);
2878 if (src_len < dst_len)
2879 {
2880 SETSTR(eep.s, params[3]);
2881 }
2882 else
2883 {
2884 char *tmp = alloca(dst_len);
2885 memcpy(tmp, eep.s, dst_len - 1);
2886 tmp[dst_len] = '\0';
2887 SETSTR(tmp, params[3]);
2888 }
2889 return 1;
2890
2891 error:
2892 SETSTR("", params[3]);
2893 return 0;
2894}
2895
2896/* external_param_set_choice(id, param_name[], val[]) */
2897static Embryo_Cell
2898_edje_embryo_fn_external_param_set_choice(Embryo_Program *ep, Embryo_Cell *params)
2899{
2900 Edje *ed;
2901 int part_id;
2902 Edje_Real_Part *rp;
2903 Edje_External_Param eep;
2904 char *param_name, *val;
2905
2906 CHKPARAM(3);
2907 ed = embryo_program_data_get(ep);
2908
2909 part_id = params[1];
2910 if (part_id < 0) return 0;
2911 rp = ed->table_parts[part_id % ed->table_parts_size];
2912
2913 GETSTR(param_name, params[2]);
2914 if (!param_name) return 0;
2915 eep.name = param_name;
2916 eep.type = EDJE_EXTERNAL_PARAM_TYPE_CHOICE;
2917 GETSTR(val, params[3]);
2918 if (!val) return 0;
2919 eep.s = val;
2920 return _edje_external_param_set(NULL, rp, &eep);
2921}
2922
2923/* external_param_get_bool(id, param_name[]) */
2924static Embryo_Cell
2925_edje_embryo_fn_external_param_get_bool(Embryo_Program *ep, Embryo_Cell *params)
2926{
2927 Edje *ed;
2928 int part_id;
2929 Edje_Real_Part *rp;
2930 Edje_External_Param eep;
2931 char *param_name;
2932
2933 CHKPARAM(2);
2934 ed = embryo_program_data_get(ep);
2935
2936 part_id = params[1];
2937 if (part_id < 0) return 0;
2938 rp = ed->table_parts[part_id % ed->table_parts_size];
2939
2940 GETSTR(param_name, params[2]);
2941 if (!param_name) return 0;
2942 eep.name = param_name;
2943 eep.type = EDJE_EXTERNAL_PARAM_TYPE_BOOL;
2944 eep.i = 0;
2945 _edje_external_param_get(NULL, rp, &eep);
2946 return eep.i;
2947}
2948
2949/* external_param_set_bool(id, param_name[], val) */
2950static Embryo_Cell
2951_edje_embryo_fn_external_param_set_bool(Embryo_Program *ep, Embryo_Cell *params)
2952{
2953 Edje *ed;
2954 int part_id;
2955 Edje_Real_Part *rp;
2956 Edje_External_Param eep;
2957 char *param_name;
2958
2959 CHKPARAM(3);
2960 ed = embryo_program_data_get(ep);
2961
2962 part_id = params[1];
2963 if (part_id < 0) return 0;
2964 rp = ed->table_parts[part_id % ed->table_parts_size];
2965
2966 GETSTR(param_name, params[2]);
2967 if (!param_name) return 0;
2968 eep.name = param_name;
2969 eep.type = EDJE_EXTERNAL_PARAM_TYPE_BOOL;
2970 eep.i = params[3];
2971 return _edje_external_param_set(NULL, rp, &eep);
2972}
2973
2974void
2975_edje_embryo_script_init(Edje_Part_Collection *edc)
2976{
2977 Embryo_Program *ep;
2978
2979 if (!edc) return;
2980 if (!edc->script) return;
2981
2982 ep = edc->script;
2983 /* first advertise all the edje "script" calls */
2984 embryo_program_native_call_add(ep, "get_int", _edje_embryo_fn_get_int);
2985 embryo_program_native_call_add(ep, "set_int", _edje_embryo_fn_set_int);
2986 embryo_program_native_call_add(ep, "get_float", _edje_embryo_fn_get_float);
2987 embryo_program_native_call_add(ep, "set_float", _edje_embryo_fn_set_float);
2988 embryo_program_native_call_add(ep, "get_str", _edje_embryo_fn_get_str);
2989 embryo_program_native_call_add(ep, "get_strlen", _edje_embryo_fn_get_strlen);
2990 embryo_program_native_call_add(ep, "set_str", _edje_embryo_fn_set_str);
2991 embryo_program_native_call_add(ep, "count", _edje_embryo_fn_count);
2992 embryo_program_native_call_add(ep, "remove", _edje_embryo_fn_remove);
2993 embryo_program_native_call_add(ep, "append_int", _edje_embryo_fn_append_int);
2994 embryo_program_native_call_add(ep, "prepend_int", _edje_embryo_fn_prepend_int);
2995 embryo_program_native_call_add(ep, "insert_int", _edje_embryo_fn_insert_int);
2996 embryo_program_native_call_add(ep, "replace_int", _edje_embryo_fn_replace_int);
2997 embryo_program_native_call_add(ep, "fetch_int", _edje_embryo_fn_fetch_int);
2998 embryo_program_native_call_add(ep, "append_str", _edje_embryo_fn_append_str);
2999 embryo_program_native_call_add(ep, "prepend_str", _edje_embryo_fn_prepend_str);
3000 embryo_program_native_call_add(ep, "insert_str", _edje_embryo_fn_insert_str);
3001 embryo_program_native_call_add(ep, "replace_str", _edje_embryo_fn_replace_str);
3002 embryo_program_native_call_add(ep, "fetch_str", _edje_embryo_fn_fetch_str);
3003 embryo_program_native_call_add(ep, "append_float", _edje_embryo_fn_append_float);
3004 embryo_program_native_call_add(ep, "prepend_float", _edje_embryo_fn_prepend_float);
3005 embryo_program_native_call_add(ep, "insert_float", _edje_embryo_fn_insert_float);
3006 embryo_program_native_call_add(ep, "replace_float", _edje_embryo_fn_replace_float);
3007 embryo_program_native_call_add(ep, "fetch_float", _edje_embryo_fn_fetch_float);
3008
3009 embryo_program_native_call_add(ep, "timer", _edje_embryo_fn_timer);
3010 embryo_program_native_call_add(ep, "cancel_timer", _edje_embryo_fn_cancel_timer);
3011
3012 embryo_program_native_call_add(ep, "anim", _edje_embryo_fn_anim);
3013 embryo_program_native_call_add(ep, "cancel_anim", _edje_embryo_fn_cancel_anim);
3014
3015 embryo_program_native_call_add(ep, "emit", _edje_embryo_fn_emit);
3016 embryo_program_native_call_add(ep, "get_part_id", _edje_embryo_fn_get_part_id);
3017 embryo_program_native_call_add(ep, "set_state", _edje_embryo_fn_set_state);
3018 embryo_program_native_call_add(ep, "get_state", _edje_embryo_fn_get_state);
3019 embryo_program_native_call_add(ep, "set_tween_state", _edje_embryo_fn_set_tween_state);
3020 embryo_program_native_call_add(ep, "run_program", _edje_embryo_fn_run_program);
3021 embryo_program_native_call_add(ep, "get_drag_dir", _edje_embryo_fn_get_drag_dir);
3022 embryo_program_native_call_add(ep, "get_drag", _edje_embryo_fn_get_drag);
3023 embryo_program_native_call_add(ep, "set_drag", _edje_embryo_fn_set_drag);
3024 embryo_program_native_call_add(ep, "get_drag_size", _edje_embryo_fn_get_drag_size);
3025 embryo_program_native_call_add(ep, "set_drag_size", _edje_embryo_fn_set_drag_size);
3026 embryo_program_native_call_add(ep, "set_text", _edje_embryo_fn_set_text);
3027 embryo_program_native_call_add(ep, "get_text", _edje_embryo_fn_get_text);
3028 embryo_program_native_call_add(ep, "get_min_size", _edje_embryo_fn_get_min_size);
3029 embryo_program_native_call_add(ep, "get_max_size", _edje_embryo_fn_get_max_size);
3030 embryo_program_native_call_add(ep, "get_color_class", _edje_embryo_fn_get_color_class);
3031 embryo_program_native_call_add(ep, "set_color_class", _edje_embryo_fn_set_color_class);
3032 embryo_program_native_call_add(ep, "set_text_class", _edje_embryo_fn_set_text_class);
3033 embryo_program_native_call_add(ep, "get_text_class", _edje_embryo_fn_get_text_class);
3034 embryo_program_native_call_add(ep, "get_drag_step", _edje_embryo_fn_get_drag_step);
3035 embryo_program_native_call_add(ep, "set_drag_step", _edje_embryo_fn_set_drag_step);
3036 embryo_program_native_call_add(ep, "get_drag_page", _edje_embryo_fn_get_drag_page);
3037 embryo_program_native_call_add(ep, "set_drag_page", _edje_embryo_fn_set_drag_page);
3038 embryo_program_native_call_add(ep, "get_mouse", _edje_embryo_fn_get_mouse);
3039 embryo_program_native_call_add(ep, "get_mouse_buttons", _edje_embryo_fn_get_mouse_buttons);
3040 embryo_program_native_call_add(ep, "stop_program", _edje_embryo_fn_stop_program);
3041 embryo_program_native_call_add(ep, "stop_programs_on", _edje_embryo_fn_stop_programs_on);
3042 embryo_program_native_call_add(ep, "set_min_size", _edje_embryo_fn_set_min_size);
3043 embryo_program_native_call_add(ep, "set_max_size", _edje_embryo_fn_set_max_size);
3044 embryo_program_native_call_add(ep, "play_sample", _edje_embryo_fn_play_sample);
3045 embryo_program_native_call_add(ep, "play_tone", _edje_embryo_fn_play_tone);
3046 embryo_program_native_call_add(ep, "send_message", _edje_embryo_fn_send_message);
3047 embryo_program_native_call_add(ep, "get_geometry", _edje_embryo_fn_get_geometry);
3048 embryo_program_native_call_add(ep, "custom_state", _edje_embryo_fn_custom_state);
3049 embryo_program_native_call_add(ep, "set_state_val", _edje_embryo_fn_set_state_val);
3050 embryo_program_native_call_add(ep, "get_state_val", _edje_embryo_fn_get_state_val);
3051
3052 embryo_program_native_call_add(ep, "part_swallow", _edje_embryo_fn_part_swallow);
3053
3054 embryo_program_native_call_add(ep, "external_param_get_int", _edje_embryo_fn_external_param_get_int);
3055 embryo_program_native_call_add(ep, "external_param_set_int", _edje_embryo_fn_external_param_set_int);
3056 embryo_program_native_call_add(ep, "external_param_get_float", _edje_embryo_fn_external_param_get_float);
3057 embryo_program_native_call_add(ep, "external_param_set_float", _edje_embryo_fn_external_param_set_float);
3058 embryo_program_native_call_add(ep, "external_param_get_strlen", _edje_embryo_fn_external_param_get_strlen);
3059 embryo_program_native_call_add(ep, "external_param_get_str", _edje_embryo_fn_external_param_get_str);
3060 embryo_program_native_call_add(ep, "external_param_set_str", _edje_embryo_fn_external_param_set_str);
3061 embryo_program_native_call_add(ep, "external_param_get_choice_len", _edje_embryo_fn_external_param_get_choice_len);
3062 embryo_program_native_call_add(ep, "external_param_get_choice", _edje_embryo_fn_external_param_get_choice);
3063 embryo_program_native_call_add(ep, "external_param_set_choice", _edje_embryo_fn_external_param_set_choice);
3064 embryo_program_native_call_add(ep, "external_param_get_bool", _edje_embryo_fn_external_param_get_bool);
3065 embryo_program_native_call_add(ep, "external_param_set_bool", _edje_embryo_fn_external_param_set_bool);
3066}
3067
3068void
3069_edje_embryo_script_shutdown(Edje_Part_Collection *edc)
3070{
3071 if (!edc) return;
3072 if (!edc->script) return;
3073 if (embryo_program_recursion_get(edc->script) > 0) return;
3074 embryo_program_free(edc->script);
3075 edc->script = NULL;
3076}
3077
3078void
3079_edje_embryo_script_reset(Edje *ed)
3080{
3081 if (!ed) return;
3082 if (!ed->collection) return;
3083 if (!ed->collection->script) return;
3084 if (embryo_program_recursion_get(ed->collection->script) > 0) return;
3085 embryo_program_vm_reset(ed->collection->script);
3086 _edje_embryo_globals_init(ed);
3087}
3088
3089/* this may change in future - thus "test_run" is its name */
3090void
3091_edje_embryo_test_run(Edje *ed, const char *fname, const char *sig, const char *src)
3092{
3093 Embryo_Function fn;
3094
3095 if (!ed) return;
3096 if (!ed->collection) return;
3097 if (!ed->collection->script) return;
3098 embryo_program_vm_push(ed->collection->script);
3099 _edje_embryo_globals_init(ed);
3100
3101 // _edje_embryo_script_reset(ed);
3102 fn = embryo_program_function_find(ed->collection->script, (char *)fname);
3103 if (fn != EMBRYO_FUNCTION_NONE)
3104 {
3105 void *pdata;
3106 int ret;
3107
3108 embryo_parameter_string_push(ed->collection->script, (char *)sig);
3109 embryo_parameter_string_push(ed->collection->script, (char *)src);
3110 pdata = embryo_program_data_get(ed->collection->script);
3111 embryo_program_data_set(ed->collection->script, ed);
3112 /* 5 million instructions is an arbitrary number. on my p4-2.6 here */
3113 /* IF embryo is ONLY running embryo stuff and NO native calls thats */
3114 /* about 0.016 seconds, and longer on slower cpu's. if a simple */
3115 /* embryo script snippet hasn't managed to do its work in 5 MILLION */
3116 /* embryo virtual machine instructions - something is wrong, or */
3117 /* embryo is simply being mis-used. Embryo is meant to be minimal */
3118 /* logic enhancment - not entire applications. this cycle count */
3119 /* does NOT include time spent in native function calls, that the */
3120 /* script may call to do the REAL work, so in terms of time this */
3121 /* will likely end up being much longer than 0.016 seconds - more */
3122 /* like 0.03 - 0.05 seconds or even more */
3123 embryo_program_max_cycle_run_set(ed->collection->script, 5000000);
3124 ret = embryo_program_run(ed->collection->script, fn);
3125 if (ret == EMBRYO_PROGRAM_FAIL)
3126 {
3127 ERR("ERROR with embryo script. "
3128 "OBJECT NAME: '%s', "
3129 "OBJECT FILE: '%s', "
3130 "ENTRY POINT: '%s', "
3131 "SIGNAL: '%s', "
3132 "SOURCE: '%s', "
3133 "ERROR: '%s'",
3134 ed->collection->part,
3135 ed->file->path,
3136 fname,
3137 sig, src,
3138 embryo_error_string_get(embryo_program_error_get(ed->collection->script)));
3139 }
3140 else if (ret == EMBRYO_PROGRAM_TOOLONG)
3141 {
3142 ERR("ERROR with embryo script. "
3143 "OBJECT NAME: '%s', "
3144 "OBJECT FILE: '%s', "
3145 "ENTRY POINT: '%s', "
3146 "SIGNAL: '%s', "
3147 "SOURCE: '%s', "
3148 "ERROR: 'Script exceeded maximum allowed cycle count of %i'",
3149 ed->collection->part,
3150 ed->file->path,
3151 fname,
3152 sig, src,
3153 embryo_program_max_cycle_run_get(ed->collection->script));
3154 }
3155 embryo_program_data_set(ed->collection->script, pdata);
3156 }
3157 embryo_program_vm_pop(ed->collection->script);
3158}
3159
3160void
3161_edje_embryo_globals_init(Edje *ed)
3162{
3163 int n, i;
3164 Embryo_Program *ep;
3165
3166 ep = ed->collection->script;
3167 n = embryo_program_variable_count_get(ep);
3168 for (i = 0; i < n; i++)
3169 {
3170 Embryo_Cell cell, *cptr;
3171
3172 cell = embryo_program_variable_get(ep, i);
3173 if (cell != EMBRYO_CELL_NONE)
3174 {
3175 cptr = embryo_data_address_get(ep, cell);
3176 if (cptr) *cptr = EDJE_VAR_MAGIC_BASE + i;
3177 }
3178 }
3179}
generated by cgit v1.1 at 2024-07-12 02:59:48 +0000