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
_edje_embryo_fn_get_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_strlen(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_count(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_remove(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_append_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_prepend_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_insert_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_replace_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_fetch_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_append_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_prepend_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_insert_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_replace_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_fetch_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_append_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_prepend_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_insert_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_replace_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_fetch_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_timer(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_cancel_timer(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_reset_timer(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_anim(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_cancel_anim(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_anim_pos_map(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_min_size(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_max_size(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_stop_program(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_stop_programs_on(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_mouse(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_mouse_buttons(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_emit(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_part_id(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_image_id(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_program_id(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_play_sample(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_play_tone(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_play_vibration(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_state(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_state_anim(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_state(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_tween_state(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_tween_state_anim(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_run_program(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_drag_dir(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_drag(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_drag(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_drag_size(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_drag_size(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_text(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_text(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_min_size(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_max_size(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_color_class(Embryo_Program * ep,Embryo_Cell * params)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_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
_edje_embryo_fn_set_color_class(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_text_class(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_text_class(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_drag_step(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_drag_step(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_drag_page(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_geometry(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_drag_page(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_send_message(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_custom_state(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_state_val(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_state_val(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_mouse_events(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_mouse_events(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_pointer_mode(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_repeat_events(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_repeat_events(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_ignore_flags(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_ignore_flags(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_mask_flags(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_get_mask_flags(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_part_swallow(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_set_focus(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_unset_focus(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_get_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_set_int(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_get_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_set_float(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_get_strlen(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_get_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_set_str(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_get_choice_len(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_get_choice(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_set_choice(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_get_bool(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_external_param_set_bool(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_components_set(Embryo_Program * ep,Embryo_Cell * params,void (* func)(EPhysics_Body * body,double x,double y,double z))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
_edje_embryo_fn_physics_components_get(Embryo_Program * ep,Embryo_Cell * params,void (* func)(const EPhysics_Body * body,double * x,double * y,double * z))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
_edje_embryo_fn_physics_impulse(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_torque_impulse(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_force(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_torque(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_clear_forces(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_get_forces(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_get_torques(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_set_velocity(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_get_velocity(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_set_ang_velocity(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_get_ang_velocity(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_stop(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_set_rotation(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_physics_get_rotation(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_swallow_has_content(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_fn_echo(Embryo_Program * ep,Embryo_Cell * params)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
_edje_embryo_script_init(Edje_Part_Collection * edc)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
_edje_embryo_script_shutdown(Edje_Part_Collection * edc)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
_edje_embryo_script_reset(Edje * ed)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
_edje_embryo_test_run(Edje * ed,Edje_Program * pr,const char * sig,const char * src)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
_edje_embryo_globals_init(Edje * ed)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