1 #include "edje_private.h"
3 typedef struct _Edje_Box_Layout Edje_Box_Layout;
4 struct _Edje_Box_Layout
7 Evas_Object_Box_Layout func;
8 void *(*layout_data_get)(void *);
9 void (*layout_data_free)(void *);
11 void (*free_data)(void *);
15 static Eina_Hash *_edje_color_class_hash = NULL;
16 static Eina_Hash *_edje_color_class_member_hash = NULL;
18 static Eina_Hash *_edje_text_class_hash = NULL;
19 static Eina_Hash *_edje_text_class_member_hash = NULL;
21 static Eina_Rbtree *_edje_box_layout_registry = NULL;
23 char *_edje_fontset_append = NULL;
24 FLOAT_T _edje_scale = ZERO;
25 Eina_Bool _edje_password_show_last = EINA_FALSE;
26 FLOAT_T _edje_password_show_last_timeout = ZERO;
27 int _edje_freeze_val = 0;
28 int _edje_freeze_calc_count = 0;
29 Eina_List *_edje_freeze_calc_list = NULL;
31 typedef struct _Edje_List_Foreach_Data Edje_List_Foreach_Data;
32 struct _Edje_List_Foreach_Data
37 typedef struct _Edje_List_Refcount Edje_List_Refcount;
38 struct _Edje_List_Refcount
45 static Eina_Bool _edje_color_class_list_foreach(const Eina_Hash *hash, const void *key, void *data, void *fdata);
46 static Eina_Bool _edje_text_class_list_foreach(const Eina_Hash *hash, const void *key, void *data, void *fdata);
47 static void _edje_object_image_preload_cb(void *data, Evas *e, Evas_Object *obj, void *event_info);
48 static void _edje_object_signal_preload_cb(void *data, Evas_Object *obj, const char *emission, const char *source);
49 static void _edje_user_def_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *child __UNUSED__, void *einfo __UNUSED__);
50 static void _edje_table_child_remove(Edje_Real_Part *rp, Evas_Object *child);
51 static void _edje_box_child_remove(Edje_Real_Part *rp, Evas_Object *child);
53 Edje_Real_Part *_edje_real_part_recursive_get_helper(const Edje *ed, char **path);
55 static Edje_User_Defined *
56 _edje_user_definition_new(Edje_User_Defined_Type type, const char *part, Edje *ed)
58 Edje_User_Defined *eud;
60 eud = malloc(sizeof (Edje_User_Defined));
61 if (!eud) return NULL;
64 eud->part = eina_stringshare_add(part);
66 ed->user_defined = eina_list_append(ed->user_defined, eud);
72 _edje_user_definition_remove(Edje_User_Defined *eud, Evas_Object *child)
74 eud->ed->user_defined = eina_list_remove(eud->ed->user_defined, eud);
76 if (child) evas_object_event_callback_del_full(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
77 eina_stringshare_del(eud->part);
82 _edje_user_definition_free(Edje_User_Defined *eud)
84 Evas_Object *child = NULL;
87 eud->ed->user_defined = eina_list_remove(eud->ed->user_defined, eud);
91 case EDJE_USER_SWALLOW:
92 child = eud->u.swallow.child;
93 rp = _edje_real_part_recursive_get(eud->ed, eud->part);
96 _edje_real_part_swallow_clear(rp);
97 rp->swallowed_object = NULL;
98 rp->swallow_params.min.w = 0;
99 rp->swallow_params.min.h = 0;
100 rp->swallow_params.max.w = 0;
101 rp->swallow_params.max.h = 0;
103 rp->edje->recalc_call = 1;
104 #ifdef EDJE_CALC_CACHE
107 _edje_recalc_do(rp->edje);
110 case EDJE_USER_BOX_PACK:
111 child = eud->u.box.child;
112 rp = _edje_real_part_recursive_get(eud->ed, eud->part);
113 _edje_box_child_remove(rp, child);
115 case EDJE_USER_TABLE_PACK:
116 child = eud->u.table.child;
117 rp = _edje_real_part_recursive_get(eud->ed, eud->part);
118 _edje_table_child_remove(rp, child);
120 case EDJE_USER_STRING:
121 case EDJE_USER_DRAG_STEP:
122 case EDJE_USER_DRAG_PAGE:
123 case EDJE_USER_DRAG_VALUE:
124 case EDJE_USER_DRAG_SIZE:
128 _edje_user_definition_remove(eud, child);
132 _edje_user_def_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *child __UNUSED__, void *einfo __UNUSED__)
134 Edje_User_Defined *eud = data;
136 _edje_user_definition_free(eud);
140 _edje_class_member_direct_del(const char *class, Edje_List_Refcount *lookup, Eina_Hash *hash)
144 members = eina_hash_find(hash, class);
145 members = eina_list_remove_list(members, lookup->lookup);
146 eina_hash_set(hash, class, members);
151 _edje_class_member_add(Edje *ed, Eina_Hash **ehash, Eina_Hash **ghash, const char *class)
153 Edje_List_Refcount *lookup;
156 if ((!ed) || (!ehash) || (!ghash) || (!class)) return;
158 lookup = eina_hash_find(*ehash, class);
161 EINA_REFCOUNT_REF(lookup);
165 lookup = malloc(sizeof (Edje_List_Refcount));
166 if (!lookup) return ;
167 EINA_REFCOUNT_INIT(lookup);
169 /* Get members list */
170 members = eina_hash_find(*ghash, class);
172 /* Update the member list */
173 lookup->lookup = members = eina_list_prepend(members, ed);
175 /* Don't loose track of members list */
177 *ehash = eina_hash_string_small_new(NULL);
178 eina_hash_add(*ehash, class, lookup);
180 /* Reset the member list to the right pointer */
182 *ghash = eina_hash_string_superfast_new(NULL);
183 eina_hash_set(*ghash, class, members);
187 _edje_class_member_del(Eina_Hash **ehash, Eina_Hash **ghash, const char *class)
189 Edje_List_Refcount *lookup;
192 if ((!ehash) || (!ghash) || (!class)) return;
193 members = eina_hash_find(*ghash, class);
194 if (!members) return;
196 lookup = eina_hash_find(*ehash, class);
197 if (!lookup) return ;
199 EINA_REFCOUNT_UNREF(lookup)
201 members = eina_list_remove_list(members, lookup->lookup);
202 eina_hash_set(*ghash, class, members);
204 eina_hash_del(*ehash, class, lookup);
210 member_list_free(const Eina_Hash *hash __UNUSED__, const void *key __UNUSED__, void *data, void *fdata __UNUSED__)
212 eina_list_free(data);
217 _edje_class_members_free(Eina_Hash **ghash)
219 if (!ghash || !*ghash) return;
220 eina_hash_foreach(*ghash, member_list_free, NULL);
221 eina_hash_free(*ghash);
225 /************************** API Routines **************************/
235 // FIXME: could just have a global freeze instead of per object
236 // above i tried.. but this broke some things. notable e17's menus. why?
240 EINA_LIST_FOREACH(_edje_edjes, l, data)
241 edje_object_freeze(data);
247 _edje_thaw_edje(Edje *ed)
251 for (i = 0; i < ed->table_parts_size; i++)
255 rp = ed->table_parts[i];
256 if (rp->part->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object)
260 ed2 = _edje_fetch(rp->swallowed_object);
261 if (ed2) _edje_thaw_edje(ed2);
264 if ((ed->recalc) && (ed->freeze <= 0)) _edje_recalc_do(ed);
273 if ((_edje_freeze_val <= 0) && (_edje_freeze_calc_count > 0))
277 _edje_freeze_calc_count = 0;
278 EINA_LIST_FREE(_edje_freeze_calc_list, ed)
287 // FIXME: could just have a global freeze instead of per object
288 // comment as above.. why?
291 EINA_LIST_FOREACH(_edje_edjes, l, data)
292 edje_object_thaw(data);
297 edje_fontset_append_set(const char *fonts)
299 if (_edje_fontset_append)
300 free(_edje_fontset_append);
301 _edje_fontset_append = fonts ? strdup(fonts) : NULL;
305 edje_fontset_append_get(void)
307 return _edje_fontset_append;
311 edje_scale_set(double scale)
316 if (_edje_scale == FROM_DOUBLE(scale)) return;
317 _edje_scale = FROM_DOUBLE(scale);
318 EINA_LIST_FOREACH(_edje_edjes, l, data)
319 edje_object_calc_force(data);
325 return TO_DOUBLE(_edje_scale);
329 edje_password_show_last_set(Eina_Bool password_show_last)
331 if (_edje_password_show_last == password_show_last) return;
332 _edje_password_show_last = password_show_last;
336 edje_password_show_last_timeout_set(double password_show_last_timeout)
338 if (_edje_password_show_last_timeout == FROM_DOUBLE(password_show_last_timeout)) return;
339 _edje_password_show_last_timeout = FROM_DOUBLE(password_show_last_timeout);
343 edje_object_scale_set(Evas_Object *obj, double scale)
350 ed = _edje_fetch(obj);
351 if (!ed) return EINA_FALSE;
352 if (ed->scale == scale) return EINA_TRUE;
353 ed->scale = FROM_DOUBLE(scale);
354 EINA_LIST_FOREACH(ed->groups, l, ged)
355 ged->scale = ed->scale;
356 EINA_LIST_FOREACH(ed->subobjs, l, o)
357 edje_object_calc_force(o);
358 for(i = 0; i < ed->table_parts_size; ++i)
361 ep = ed->table_parts[i];
362 if ((ep->part->type == EDJE_PART_TYPE_BOX)
363 || (ep->part->type == EDJE_PART_TYPE_TABLE))
365 EINA_LIST_FOREACH(ep->items, l, o)
366 edje_object_scale_set(o, scale);
369 edje_object_calc_force(obj);
374 edje_object_scale_get(const Evas_Object *obj)
378 ed = _edje_fetch(obj);
380 return TO_DOUBLE(ed->scale);
384 edje_object_mirrored_get(const Evas_Object *obj)
388 ed = _edje_fetch(obj);
389 if (!ed) return EINA_FALSE;
395 _edje_object_orientation_inform(Evas_Object *obj)
397 if (edje_object_mirrored_get(obj))
398 edje_object_signal_emit(obj, "edje,state,rtl", "edje");
400 edje_object_signal_emit(obj, "edje,state,ltr", "edje");
404 edje_object_mirrored_set(Evas_Object *obj, Eina_Bool rtl)
409 ed = _edje_fetch(obj);
411 if (ed->is_rtl == rtl) return;
415 for (i = 0 ; i < ed->table_parts_size ; i++)
421 ep = ed->table_parts[i];
422 s = ep->param1.description->state.name,
423 v = ep->param1.description->state.value;
424 _edje_part_description_apply(ed, ep, s, v , NULL, 0.0);
425 ep->chosen_description = ep->param1.description;
429 _edje_object_orientation_inform(obj);
435 edje_object_data_get(const Evas_Object *obj, const char *key)
439 ed = _edje_fetch(obj);
442 if (!ed->collection) return NULL;
443 if (!ed->collection->data) return NULL;
444 return edje_string_get(eina_hash_find(ed->collection->data, key));
448 edje_object_freeze(Evas_Object *obj)
453 ed = _edje_fetch(obj);
455 for (i = 0; i < ed->table_parts_size; i++)
458 rp = ed->table_parts[i];
459 if (rp->part->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object)
460 edje_object_freeze(rp->swallowed_object);
462 return _edje_freeze(ed);
466 edje_object_thaw(Evas_Object *obj)
471 ed = _edje_fetch(obj);
473 for (i = 0; i < ed->table_parts_size; i++)
477 rp = ed->table_parts[i];
478 if (rp->part->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object)
479 edje_object_thaw(rp->swallowed_object);
481 return _edje_thaw(ed);
485 edje_color_class_set(const char *color_class, int r, int g, int b, int a, int r2, int g2, int b2, int a2, int r3, int g3, int b3, int a3)
488 Edje_Color_Class *cc;
490 if (!color_class) return EINA_FALSE;
492 cc = eina_hash_find(_edje_color_class_hash, color_class);
495 cc = calloc(1, sizeof(Edje_Color_Class));
496 if (!cc) return EINA_FALSE;
497 cc->name = eina_stringshare_add(color_class);
503 if (!_edje_color_class_hash)
504 _edje_color_class_hash = eina_hash_string_superfast_new(NULL);
505 eina_hash_add(_edje_color_class_hash, color_class, cc);
509 else if (r > 255) r = 255;
511 else if (g > 255) g = 255;
513 else if (b > 255) b = 255;
515 else if (a > 255) a = 255;
516 if ((cc->r == r) && (cc->g == g) &&
517 (cc->b == b) && (cc->a == a) &&
518 (cc->r2 == r2) && (cc->g2 == g2) &&
519 (cc->b2 == b2) && (cc->a2 == a2) &&
520 (cc->r3 == r3) && (cc->g3 == g3) &&
521 (cc->b3 == b3) && (cc->a3 == a3))
536 members = eina_hash_find(_edje_color_class_member_hash, color_class);
541 ed = eina_list_data_get(members);
544 #ifdef EDJE_CALC_CACHE
545 ed->all_part_change = 1;
548 _edje_emit(ed, "color_class,set", color_class);
549 members = eina_list_next(members);
555 edje_color_class_get(const char *color_class, int *r, int *g, int *b, int *a, int *r2, int *g2, int *b2, int *a2, int *r3, int *g3, int *b3, int *a3)
557 Edje_Color_Class *cc;
562 cc = eina_hash_find(_edje_color_class_hash, color_class);
566 #define X(C) if (C) *C = cc->C
567 #define S(_r, _g, _b, _a) X(_r); X(_g); X(_b); X(_a)
577 #define X(C) if (C) *C = 0
578 #define S(_r, _g, _b, _a) X(_r); X(_g); X(_b); X(_a)
589 edje_color_class_del(const char *color_class)
591 Edje_Color_Class *cc;
594 if (!color_class) return;
596 cc = eina_hash_find(_edje_color_class_hash, color_class);
599 eina_hash_del(_edje_color_class_hash, color_class, cc);
600 eina_stringshare_del(cc->name);
603 members = eina_hash_find(_edje_color_class_member_hash, color_class);
608 ed = eina_list_data_get(members);
611 #ifdef EDJE_CALC_CACHE
612 ed->all_part_change = 1;
615 _edje_emit(ed, "color_class,del", color_class);
616 members = eina_list_next(members);
621 edje_color_class_list(void)
623 Edje_List_Foreach_Data fdata;
625 if (!_edje_color_class_member_hash) return NULL;
627 memset(&fdata, 0, sizeof(Edje_List_Foreach_Data));
628 eina_hash_foreach(_edje_color_class_member_hash,
629 _edje_color_class_list_foreach, &fdata);
635 _edje_color_class_list_foreach(const Eina_Hash *hash __UNUSED__, const void *key, void *data __UNUSED__, void *fdata)
637 Edje_List_Foreach_Data *fd;
640 fd->list = eina_list_append(fd->list, strdup(key));
645 edje_object_color_class_set(Evas_Object *obj, const char *color_class, int r, int g, int b, int a, int r2, int g2, int b2, int a2, int r3, int g3, int b3, int a3)
648 Edje_Color_Class *cc;
651 ed = _edje_fetch(obj);
652 if ((!ed) || (!color_class)) return EINA_FALSE;
654 else if (r > 255) r = 255;
656 else if (g > 255) g = 255;
658 else if (b > 255) b = 255;
660 else if (a > 255) a = 255;
661 cc = eina_hash_find(ed->color_classes, color_class);
664 if ((cc->r == r) && (cc->g == g) &&
665 (cc->b == b) && (cc->a == a) &&
666 (cc->r2 == r2) && (cc->g2 == g2) &&
667 (cc->b2 == b2) && (cc->a2 == a2) &&
668 (cc->r3 == r3) && (cc->g3 == g3) &&
669 (cc->b3 == b3) && (cc->a3 == a3))
685 #ifdef EDJE_CALC_CACHE
686 ed->all_part_change = 1;
692 color_class = eina_stringshare_add(color_class);
693 if (!color_class) return EINA_FALSE;
694 cc = malloc(sizeof(Edje_Color_Class));
697 eina_stringshare_del(color_class);
700 cc->name = color_class;
713 eina_hash_direct_add(ed->color_classes, cc->name, cc);
716 #ifdef EDJE_CALC_CACHE
717 ed->all_part_change = 1;
720 for (i = 0; i < ed->table_parts_size; i++)
724 rp = ed->table_parts[i];
725 if (rp->part->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object)
726 edje_object_color_class_set(rp->swallowed_object, color_class,
727 r, g, b, a, r2, g2, b2, a2, r3, g3, b3,
732 _edje_emit(ed, "color_class,set", color_class);
737 edje_object_color_class_get(const Evas_Object *obj, const char *color_class, int *r, int *g, int *b, int *a, int *r2, int *g2, int *b2, int *a2, int *r3, int *g3, int *b3, int *a3)
739 Edje *ed = _edje_fetch(obj);
740 Edje_Color_Class *cc = _edje_color_class_find(ed, color_class);
744 #define X(C) if (C) *C = cc->C
745 #define S(_r, _g, _b, _a) X(_r); X(_g); X(_b); X(_a)
755 #define X(C) if (C) *C = 0
756 #define S(_r, _g, _b, _a) X(_r); X(_g); X(_b); X(_a)
767 edje_object_color_class_del(Evas_Object *obj, const char *color_class)
770 Edje_Color_Class *cc = NULL;
773 ed = _edje_fetch(obj);
775 if ((!ed) || (!color_class)) return;
777 eina_hash_del(ed->color_classes, color_class, cc);
779 for (i = 0; i < ed->table_parts_size; i++)
783 rp = ed->table_parts[i];
784 if (rp->part->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object)
785 edje_object_color_class_del(rp->swallowed_object, color_class);
790 #ifdef EDJE_CALC_CACHE
791 ed->all_part_change = 1;
794 _edje_emit(ed, "color_class,del", color_class);
798 edje_text_class_set(const char *text_class, const char *font, Evas_Font_Size size)
803 if (!text_class) return EINA_FALSE;
804 if (!font) font = "";
806 tc = eina_hash_find(_edje_text_class_hash, text_class);
807 /* Create new text class */
810 tc = calloc(1, sizeof(Edje_Text_Class));
811 if (!tc) return EINA_FALSE;
812 tc->name = eina_stringshare_add(text_class);
818 if (!_edje_text_class_hash) _edje_text_class_hash = eina_hash_string_superfast_new(NULL);
819 eina_hash_add(_edje_text_class_hash, text_class, tc);
821 tc->font = eina_stringshare_add(font);
826 /* Match and the same, return */
827 if ((tc->size == size) ||
828 (tc->font == font) ||
829 (tc->font && font && !strcmp(tc->font, font)))
832 /* Update the class found */
833 eina_stringshare_replace(&tc->font, font);
837 /* Tell all members of the text class to recalc */
838 members = eina_hash_find(_edje_text_class_member_hash, text_class);
843 ed = eina_list_data_get(members);
846 _edje_textblock_style_all_update(ed);
847 #ifdef EDJE_CALC_CACHE
848 ed->text_part_change = 1;
851 members = eina_list_next(members);
857 edje_text_class_del(const char *text_class)
862 if (!text_class) return;
864 tc = eina_hash_find(_edje_text_class_hash, text_class);
867 eina_hash_del(_edje_text_class_hash, text_class, tc);
868 eina_stringshare_del(tc->name);
869 eina_stringshare_del(tc->font);
872 members = eina_hash_find(_edje_text_class_member_hash, text_class);
877 ed = eina_list_data_get(members);
879 _edje_textblock_style_all_update(ed);
880 #ifdef EDJE_CALC_CACHE
881 ed->text_part_change = 1;
884 members = eina_list_next(members);
889 edje_text_class_list(void)
891 Edje_List_Foreach_Data fdata;
893 memset(&fdata, 0, sizeof(Edje_List_Foreach_Data));
894 eina_hash_foreach(_edje_text_class_member_hash,
895 _edje_text_class_list_foreach, &fdata);
900 _edje_text_class_list_foreach(const Eina_Hash *hash __UNUSED__, const void *key, void *data __UNUSED__, void *fdata)
902 Edje_List_Foreach_Data *fd;
905 fd->list = eina_list_append(fd->list, eina_stringshare_add(key));
910 edje_object_text_class_set(Evas_Object *obj, const char *text_class, const char *font, Evas_Font_Size size)
914 Edje_Text_Class *tc = NULL;
917 ed = _edje_fetch(obj);
918 if ((!ed) || (!text_class)) return EINA_FALSE;
920 /* for each text_class in the edje */
921 EINA_LIST_FOREACH(ed->text_classes, l, tc)
923 if ((tc->name) && (!strcmp(tc->name, text_class)))
925 /* Match and the same, return */
926 if ((tc->size == size) &&
927 ((tc->font == font) ||
928 (tc->font && font && !strcmp(tc->font, font))))
931 /* Update new text class properties */
932 eina_stringshare_replace(&tc->font, font);
940 /* No matches, create a new text class */
941 tc = calloc(1, sizeof(Edje_Text_Class));
942 if (!tc) return EINA_FALSE;
943 tc->name = eina_stringshare_add(text_class);
949 tc->font = eina_stringshare_add(font);
951 /* Add to edje's text class list */
952 ed->text_classes = eina_list_append(ed->text_classes, tc);
955 for (i = 0; i < ed->table_parts_size; i++)
959 rp = ed->table_parts[i];
960 if (rp->part->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object)
961 edje_object_text_class_set(rp->swallowed_object, text_class,
967 #ifdef EDJE_CALC_CACHE
968 ed->text_part_change = 1;
970 _edje_textblock_style_all_update(ed);
976 edje_object_part_exists(const Evas_Object *obj, const char *part)
981 ed = _edje_fetch(obj);
982 if ((!ed) || (!part)) return EINA_FALSE;
983 rp = _edje_real_part_recursive_get(ed, part);
984 if (!rp) return EINA_FALSE;
988 EAPI const Evas_Object *
989 edje_object_part_object_get(const Evas_Object *obj, const char *part)
994 ed = _edje_fetch(obj);
995 if ((!ed) || (!part)) return NULL;
997 /* Need to recalc before providing the object. */
1000 rp = _edje_real_part_recursive_get(ed, part);
1001 if (!rp) return NULL;
1006 edje_object_part_geometry_get(const Evas_Object *obj, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h )
1011 ed = _edje_fetch(obj);
1012 if ((!ed) || (!part))
1021 /* Need to recalc before providing the object. */
1022 _edje_recalc_do(ed);
1024 rp = _edje_real_part_recursive_get(ed, part);
1041 edje_object_item_provider_set(Evas_Object *obj, Edje_Item_Provider_Cb func, void *data)
1045 ed = _edje_fetch(obj);
1047 ed->item_provider.func = func;
1048 ed->item_provider.data = data;
1051 /* FIXDOC: New Function */
1053 edje_object_text_change_cb_set(Evas_Object *obj, Edje_Text_Change_Cb func, void *data)
1058 ed = _edje_fetch(obj);
1060 ed->text_change.func = func;
1061 ed->text_change.data = data;
1063 for (i = 0; i < ed->table_parts_size; i++)
1067 rp = ed->table_parts[i];
1068 if ((rp->part->type == EDJE_PART_TYPE_GROUP) && (rp->swallowed_object))
1069 edje_object_text_change_cb_set(rp->swallowed_object, func, data);
1074 _edje_object_part_text_raw_set(Evas_Object *obj, Edje_Real_Part *rp, const char *part, const char *text)
1076 if ((!rp->text.text) && (!text))
1077 return EINA_TRUE; /* nothing to do, no error */
1078 if ((rp->text.text) && (text) &&
1079 (!strcmp(rp->text.text, text)))
1080 return EINA_TRUE; /* nothing to do, no error */
1083 eina_stringshare_del(rp->text.text);
1084 rp->text.text = NULL;
1086 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1087 _edje_entry_text_markup_set(rp, text);
1089 if (text) rp->text.text = eina_stringshare_add(text);
1090 rp->edje->dirty = 1;
1091 rp->edje->recalc_call = 1;
1092 rp->edje->recalc_hints = 1;
1093 #ifdef EDJE_CALC_CACHE
1096 _edje_recalc(rp->edje);
1097 if (rp->edje->text_change.func)
1098 rp->edje->text_change.func(rp->edje->text_change.data, obj, part);
1103 _edje_object_part_text_raw_append(Evas_Object *obj, Edje_Real_Part *rp, const char *part, const char *text)
1105 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1106 _edje_entry_text_markup_append(rp, text);
1112 int len_added = strlen(text);
1113 int len_old = strlen(rp->text.text);
1114 new = malloc(len_old + len_added + 1);
1115 memcpy(new, rp->text.text, len_old);
1116 memcpy(new + len_old, text, len_added);
1117 new[len_old + len_added] = '\0';
1118 eina_stringshare_replace(&rp->text.text, new);
1123 eina_stringshare_replace(&rp->text.text, text);
1126 rp->edje->dirty = 1;
1127 rp->edje->recalc_call = 1;
1128 #ifdef EDJE_CALC_CACHE
1131 _edje_recalc(rp->edje);
1132 if (rp->edje->text_change.func)
1133 rp->edje->text_change.func(rp->edje->text_change.data, obj, part);
1138 edje_object_part_text_style_user_push(Evas_Object *obj, const char *part,
1143 Evas_Textblock_Style *ts;
1145 ed = _edje_fetch(obj);
1146 if ((!ed) || (!part) || (!style)) return;
1147 rp = _edje_real_part_recursive_get(ed, part);
1149 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
1151 ts = evas_textblock_style_new();
1152 evas_textblock_style_set(ts, style);
1153 evas_object_textblock_style_user_push(rp->object, ts);
1154 evas_textblock_style_free(ts);
1155 ed->recalc_hints = 1;
1156 #ifdef EDJE_CALC_CACHE
1163 edje_object_part_text_style_user_pop(Evas_Object *obj, const char *part)
1168 ed = _edje_fetch(obj);
1169 if ((!ed) || (!part)) return;
1170 rp = _edje_real_part_recursive_get(ed, part);
1172 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
1174 evas_object_textblock_style_user_pop(rp->object);
1175 ed->recalc_hints = 1;
1176 #ifdef EDJE_CALC_CACHE
1183 edje_object_part_text_style_user_peek(const Evas_Object *obj, const char *part)
1187 const Evas_Textblock_Style *ts;
1189 ed = _edje_fetch(obj);
1190 if ((!ed) || (!part)) return NULL;
1191 rp = _edje_real_part_recursive_get(ed, part);
1192 if (!rp) return NULL;
1193 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return NULL;
1195 ts = evas_object_textblock_style_user_peek(rp->object);
1197 return evas_textblock_style_get(ts);
1203 _edje_user_define_string(Edje *ed, const char *part, const char *raw_text)
1205 /* NOTE: This one is tricky, text is referenced in rp->text.text for the life of the
1206 rp. So on edje_object_file_set, we should first ref it, before destroying the old
1208 Edje_User_Defined *eud;
1211 EINA_LIST_FOREACH(ed->user_defined, l, eud)
1212 if (eud->type == EDJE_USER_STRING && !strcmp(eud->part, part))
1216 _edje_user_definition_free(eud);
1219 eud->u.string.text = raw_text;
1223 eud = _edje_user_definition_new(EDJE_USER_STRING, part, ed);
1225 eud->u.string.text = raw_text;
1229 edje_object_part_text_set(Evas_Object *obj, const char *part, const char *text)
1235 ed = _edje_fetch(obj);
1236 if ((!ed) || (!part)) return EINA_FALSE;
1237 rp = _edje_real_part_recursive_get(ed, part);
1238 if (!rp) return EINA_FALSE;
1239 if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
1240 (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return EINA_FALSE;
1241 r = _edje_object_part_text_raw_set(obj, rp, part, text);
1242 _edje_user_define_string(ed, part, rp->text.text);
1247 edje_object_part_text_get(const Evas_Object *obj, const char *part)
1252 ed = _edje_fetch(obj);
1253 if ((!ed) || (!part)) return NULL;
1255 /* Need to recalc before providing the object. */
1256 _edje_recalc_do(ed);
1258 rp = _edje_real_part_recursive_get(ed, part);
1259 if (!rp) return NULL;
1260 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1261 return _edje_entry_text_get(rp);
1264 if (rp->part->type == EDJE_PART_TYPE_TEXT) return rp->text.text;
1265 if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
1266 return evas_object_textblock_text_markup_get(rp->object);
1272 edje_object_part_text_escaped_set(Evas_Object *obj, const char *part, const char *text)
1278 ed = _edje_fetch(obj);
1279 if ((!ed) || (!part)) return EINA_FALSE;
1280 rp = _edje_real_part_recursive_get(ed, part);
1281 if (!rp) return EINA_FALSE;
1282 if ((rp->part->type == EDJE_PART_TYPE_TEXT) && (text))
1285 char *esc_start = NULL, *esc_end = NULL;
1288 sbuf = eina_strbuf_new();
1293 if ((*p == 0) || (esc_end) || (esc_start))
1299 escape = evas_textblock_escape_string_range_get
1300 (esc_start, esc_end + 1);
1301 if (escape) eina_strbuf_append(sbuf, escape);
1302 esc_start = esc_end = NULL;
1306 if (!s) s = esc_start; /* This would happen when there is & that isn't escaped */
1307 eina_strbuf_append_length(sbuf, s, p - s);
1316 if (!s) s = esc_start; /* This would happen when there is & that isn't escaped */
1319 eina_strbuf_append_length(sbuf, s, p - s);
1332 ret = _edje_object_part_text_raw_set
1333 (obj, rp, part, eina_strbuf_string_get(sbuf));
1334 _edje_user_define_string(ed, part, rp->text.text);
1335 eina_strbuf_free(sbuf);
1338 if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return EINA_FALSE;
1339 ret = _edje_object_part_text_raw_set(obj, rp, part, text);
1340 _edje_user_define_string(ed, part, rp->text.text);
1346 _edje_text_escape(const char *text)
1350 const char *text_end;
1353 if (!text) return NULL;
1355 txt = eina_strbuf_new();
1356 text_len = strlen(text);
1358 text_end = text + text_len;
1359 while (text < text_end)
1362 const char *escaped = evas_textblock_string_escape_get(text, &advance);
1365 eina_strbuf_append_char(txt, text[0]);
1369 eina_strbuf_append(txt, escaped);
1374 ret = eina_strbuf_string_steal(txt);
1375 eina_strbuf_free(txt);
1380 _edje_text_unescape(const char *text)
1384 const char *text_end, *last, *escape_start;
1387 if (!text) return NULL;
1389 txt = eina_strbuf_new();
1390 text_len = strlen(text);
1392 text_end = text + text_len;
1394 escape_start = NULL;
1395 for (; text < text_end; text++)
1409 len = text - escape_start;
1414 eina_strbuf_append_n(txt, str, len);
1416 escape_start = text;
1419 else if ((*text == ';') && (escape_start))
1422 const char *str = evas_textblock_escape_string_range_get(escape_start, text);
1429 len = text + 1 - escape_start;
1432 eina_strbuf_append_n(txt, str, len);
1434 escape_start = NULL;
1439 if (!last && escape_start)
1440 last = escape_start;
1442 if (last && (text > last))
1444 size_t len = text - last;
1445 eina_strbuf_append_n(txt, last, len);
1448 ret = eina_strbuf_string_steal(txt);
1449 eina_strbuf_free(txt);
1454 edje_object_part_text_unescaped_set(Evas_Object *obj, const char *part, const char *text_to_escape)
1458 Eina_Bool ret = EINA_FALSE;
1460 ed = _edje_fetch(obj);
1461 if ((!ed) || (!part)) return ret;
1462 rp = _edje_real_part_recursive_get(ed, part);
1463 if (!rp) return ret;
1464 if (rp->part->type == EDJE_PART_TYPE_TEXT)
1465 ret = _edje_object_part_text_raw_set(obj, rp, part, text_to_escape);
1466 else if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
1468 char *text = _edje_text_escape(text_to_escape);
1470 ret = _edje_object_part_text_raw_set(obj, rp, part, text);
1473 _edje_user_define_string(ed, part, rp->text.text);
1478 edje_object_part_text_unescaped_get(const Evas_Object *obj, const char *part)
1483 ed = _edje_fetch(obj);
1484 if ((!ed) || (!part)) return NULL;
1486 /* Need to recalc before providing the object. */
1487 _edje_recalc_do(ed);
1489 rp = _edje_real_part_recursive_get(ed, part);
1490 if (!rp) return NULL;
1491 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1493 const char *t = _edje_entry_text_get(rp);
1494 return _edje_text_unescape(t);
1498 if (rp->part->type == EDJE_PART_TYPE_TEXT) return strdup(rp->text.text);
1499 if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
1501 const char *t = evas_object_textblock_text_markup_get(rp->object);
1502 return _edje_text_unescape(t);
1509 edje_object_part_text_selection_get(const Evas_Object *obj, const char *part)
1514 ed = _edje_fetch(obj);
1515 if ((!ed) || (!part)) return NULL;
1516 rp = _edje_real_part_recursive_get(ed, part);
1517 if (!rp) return NULL;
1518 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1519 return _edje_entry_selection_get(rp);
1524 edje_object_part_text_select_none(const Evas_Object *obj, const char *part)
1529 ed = _edje_fetch(obj);
1530 if ((!ed) || (!part)) return;
1531 rp = _edje_real_part_recursive_get(ed, part);
1533 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1534 _edje_entry_select_none(rp);
1538 edje_object_part_text_select_all(const Evas_Object *obj, const char *part)
1543 ed = _edje_fetch(obj);
1544 if ((!ed) || (!part)) return;
1545 rp = _edje_real_part_recursive_get(ed, part);
1547 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1548 _edje_entry_select_all(rp);
1552 edje_object_part_text_insert(Evas_Object *obj, const char *part, const char *text)
1557 ed = _edje_fetch(obj);
1558 if ((!ed) || (!part)) return;
1559 rp = _edje_real_part_recursive_get(ed, part);
1561 if ((rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return;
1562 if (rp->part->entry_mode <= EDJE_ENTRY_EDIT_MODE_NONE) return;
1563 _edje_entry_text_markup_insert(rp, text);
1564 rp->edje->dirty = 1;
1565 rp->edje->recalc_call = 1;
1566 rp->edje->recalc_hints = 1;
1567 #ifdef EDJE_CALC_CACHE
1570 _edje_recalc(rp->edje);
1571 if (rp->edje->text_change.func)
1572 rp->edje->text_change.func(rp->edje->text_change.data, obj, part);
1576 edje_object_part_text_append(Evas_Object *obj, const char *part, const char *text)
1581 ed = _edje_fetch(obj);
1582 if ((!ed) || (!part)) return;
1583 rp = _edje_real_part_recursive_get(ed, part);
1585 if ((rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return;
1586 _edje_object_part_text_raw_append(obj, rp, part, text);
1587 rp->edje->dirty = 1;
1588 rp->edje->recalc_call = 1;
1589 rp->edje->recalc_hints = 1;
1590 #ifdef EDJE_CALC_CACHE
1593 _edje_recalc(rp->edje);
1594 if (rp->edje->text_change.func)
1595 rp->edje->text_change.func(rp->edje->text_change.data, obj, part);
1598 EAPI const Eina_List *
1599 edje_object_part_text_anchor_list_get(const Evas_Object *obj, const char *part)
1604 ed = _edje_fetch(obj);
1605 if ((!ed) || (!part)) return NULL;
1606 rp = _edje_real_part_recursive_get(ed, part);
1607 if (!rp) return NULL;
1608 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1609 return _edje_entry_anchors_list(rp);
1613 EAPI const Eina_List *
1614 edje_object_part_text_anchor_geometry_get(const Evas_Object *obj, const char *part, const char *anchor)
1619 ed = _edje_fetch(obj);
1620 if ((!ed) || (!part)) return NULL;
1621 rp = _edje_real_part_recursive_get(ed, part);
1622 if (!rp) return NULL;
1623 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1624 return _edje_entry_anchor_geometry_get(rp, anchor);
1628 EAPI const Eina_List *
1629 edje_object_part_text_item_list_get(const Evas_Object *obj, const char *part)
1634 ed = _edje_fetch(obj);
1635 if ((!ed) || (!part)) return NULL;
1636 rp = _edje_real_part_recursive_get(ed, part);
1637 if (!rp) return NULL;
1638 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1639 return _edje_entry_items_list(rp);
1644 edje_object_part_text_item_geometry_get(const Evas_Object *obj, const char *part, const char *item, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch)
1649 ed = _edje_fetch(obj);
1650 if ((!ed) || (!part)) return EINA_FALSE;
1651 rp = _edje_real_part_recursive_get(ed, part);
1652 if (!rp) return EINA_FALSE;
1653 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1654 return _edje_entry_item_geometry_get(rp, item, cx, cy, cw, ch);
1659 edje_object_part_text_cursor_geometry_get(const Evas_Object *obj, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
1664 ed = _edje_fetch(obj);
1669 if ((!ed) || (!part)) return;
1670 rp = _edje_real_part_recursive_get(ed, part);
1672 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1674 _edje_entry_cursor_geometry_get(rp, x, y, w, h);
1675 if (x) *x -= rp->edje->x;
1676 if (y) *y -= rp->edje->y;
1681 edje_object_part_text_user_insert(const Evas_Object *obj, const char *part, const char *text)
1686 ed = _edje_fetch(obj);
1687 if ((!ed) || (!part)) return;
1688 rp = _edje_real_part_recursive_get(ed, part);
1690 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1691 _edje_entry_user_insert(rp, text);
1695 edje_object_part_text_select_allow_set(const Evas_Object *obj, const char *part, Eina_Bool allow)
1700 ed = _edje_fetch(obj);
1701 if ((!ed) || (!part)) return;
1702 rp = _edje_real_part_recursive_get(ed, part);
1704 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1705 _edje_entry_select_allow_set(rp, allow);
1709 edje_object_part_text_select_abort(const Evas_Object *obj, const char *part)
1714 ed = _edje_fetch(obj);
1715 if ((!ed) || (!part)) return;
1716 rp = _edje_real_part_recursive_get(ed, part);
1718 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1719 _edje_entry_select_abort(rp);
1723 edje_object_part_text_select_begin(const Evas_Object *obj, const char *part)
1728 ed = _edje_fetch(obj);
1729 if ((!ed) || (!part)) return;
1730 rp = _edje_real_part_recursive_get(ed, part);
1732 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1733 _edje_entry_select_begin(rp);
1737 edje_object_part_text_select_extend(const Evas_Object *obj, const char *part)
1742 ed = _edje_fetch(obj);
1743 if ((!ed) || (!part)) return;
1744 rp = _edje_real_part_recursive_get(ed, part);
1746 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1747 _edje_entry_select_extend(rp);
1751 edje_object_part_text_imf_context_get(const Evas_Object *obj, const char *part)
1756 ed = _edje_fetch(obj);
1757 if ((!ed) || (!part)) return NULL;
1759 rp = _edje_real_part_recursive_get(ed, (char *)part);
1760 if (!rp) return NULL;
1762 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1763 return _edje_entry_imf_context_get(rp);
1769 edje_object_part_text_cursor_next(Evas_Object *obj, const char *part, Edje_Cursor cur)
1774 ed = _edje_fetch(obj);
1775 if ((!ed) || (!part)) return EINA_FALSE;
1776 rp = _edje_real_part_recursive_get(ed, part);
1777 if (!rp) return EINA_FALSE;
1778 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1780 return _edje_entry_cursor_next(rp, cur);
1786 edje_object_part_text_cursor_prev(Evas_Object *obj, const char *part, Edje_Cursor cur)
1791 ed = _edje_fetch(obj);
1792 if ((!ed) || (!part)) return EINA_FALSE;
1793 rp = _edje_real_part_recursive_get(ed, part);
1794 if (!rp) return EINA_FALSE;
1795 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1797 return _edje_entry_cursor_prev(rp, cur);
1803 edje_object_part_text_cursor_up(Evas_Object *obj, const char *part, Edje_Cursor cur)
1808 ed = _edje_fetch(obj);
1809 if ((!ed) || (!part)) return EINA_FALSE;
1810 rp = _edje_real_part_recursive_get(ed, part);
1811 if (!rp) return EINA_FALSE;
1812 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1814 return _edje_entry_cursor_up(rp, cur);
1820 edje_object_part_text_cursor_down(Evas_Object *obj, const char *part, Edje_Cursor cur)
1825 ed = _edje_fetch(obj);
1826 if ((!ed) || (!part)) return EINA_FALSE;
1827 rp = _edje_real_part_recursive_get(ed, part);
1828 if (!rp) return EINA_FALSE;
1829 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1831 return _edje_entry_cursor_down(rp, cur);
1837 edje_object_part_text_cursor_begin_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
1842 ed = _edje_fetch(obj);
1843 if ((!ed) || (!part)) return;
1844 rp = _edje_real_part_recursive_get(ed, part);
1846 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1848 _edje_entry_cursor_begin(rp, cur);
1853 edje_object_part_text_cursor_end_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
1858 ed = _edje_fetch(obj);
1859 if ((!ed) || (!part)) return;
1860 rp = _edje_real_part_recursive_get(ed, part);
1862 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1864 _edje_entry_cursor_end(rp, cur);
1869 edje_object_part_text_cursor_copy(Evas_Object *obj, const char *part, Edje_Cursor src, Edje_Cursor dst)
1874 ed = _edje_fetch(obj);
1875 if ((!ed) || (!part)) return;
1876 rp = _edje_real_part_recursive_get(ed, part);
1878 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1880 _edje_entry_cursor_copy(rp, src, dst);
1885 edje_object_part_text_cursor_line_begin_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
1890 ed = _edje_fetch(obj);
1891 if ((!ed) || (!part)) return;
1892 rp = _edje_real_part_recursive_get(ed, part);
1894 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1896 _edje_entry_cursor_line_begin(rp, cur);
1901 edje_object_part_text_cursor_line_end_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
1906 ed = _edje_fetch(obj);
1907 if ((!ed) || (!part)) return;
1908 rp = _edje_real_part_recursive_get(ed, part);
1910 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1912 _edje_entry_cursor_line_end(rp, cur);
1917 edje_object_part_text_cursor_coord_set(Evas_Object *obj, const char *part,
1918 Edje_Cursor cur, Evas_Coord x, Evas_Coord y)
1923 ed = _edje_fetch(obj);
1924 if ((!ed) || (!part)) return EINA_FALSE;
1925 rp = _edje_real_part_recursive_get(ed, part);
1926 if (!rp) return EINA_FALSE;
1927 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1929 return _edje_entry_cursor_coord_set(rp, cur, x, y);
1935 edje_object_part_text_cursor_is_format_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
1940 ed = _edje_fetch(obj);
1941 if ((!ed) || (!part)) return EINA_FALSE;
1942 rp = _edje_real_part_recursive_get(ed, part);
1943 if (!rp) return EINA_FALSE;
1944 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1946 return _edje_entry_cursor_is_format_get(rp, cur);
1952 edje_object_part_text_cursor_is_visible_format_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
1957 ed = _edje_fetch(obj);
1958 if ((!ed) || (!part)) return 0;
1959 rp = _edje_real_part_recursive_get(ed, part);
1961 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1963 return _edje_entry_cursor_is_visible_format_get(rp, cur);
1969 edje_object_part_text_cursor_content_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
1974 ed = _edje_fetch(obj);
1975 if ((!ed) || (!part)) return NULL;
1976 rp = _edje_real_part_recursive_get(ed, part);
1977 if (!rp) return NULL;
1978 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1980 return _edje_entry_cursor_content_get(rp, cur);
1986 edje_object_part_text_cursor_pos_set(Evas_Object *obj, const char *part, Edje_Cursor cur, int pos)
1991 ed = _edje_fetch(obj);
1992 if ((!ed) || (!part)) return;
1993 rp = _edje_real_part_recursive_get(ed, part);
1995 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
1997 _edje_entry_cursor_pos_set(rp, cur, pos);
2002 edje_object_part_text_cursor_pos_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
2007 ed = _edje_fetch(obj);
2008 if ((!ed) || (!part)) return 0;
2009 rp = _edje_real_part_recursive_get(ed, part);
2011 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2013 return _edje_entry_cursor_pos_get(rp, cur);
2019 edje_object_part_text_imf_context_reset(const Evas_Object *obj, const char *part)
2024 ed = _edje_fetch(obj);
2025 if ((!ed) || (!part)) return;
2026 rp = _edje_real_part_recursive_get(ed, part);
2028 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2030 _edje_entry_imf_context_reset(rp);
2035 edje_object_part_text_input_panel_layout_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Layout layout)
2040 ed = _edje_fetch(obj);
2041 if ((!ed) || (!part)) return;
2042 rp = _edje_real_part_recursive_get(ed, part);
2044 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2046 _edje_entry_input_panel_layout_set(rp, layout);
2050 EAPI Edje_Input_Panel_Layout
2051 edje_object_part_text_input_panel_layout_get(const Evas_Object *obj, const char *part)
2056 ed = _edje_fetch(obj);
2057 if ((!ed) || (!part)) return EDJE_INPUT_PANEL_LAYOUT_INVALID;
2058 rp = _edje_real_part_recursive_get(ed, part);
2059 if (!rp) return EINA_FALSE;
2060 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2062 return _edje_entry_input_panel_layout_get(rp);
2064 return EDJE_INPUT_PANEL_LAYOUT_INVALID;
2068 edje_object_part_text_autocapital_type_set(Evas_Object *obj, const char *part, Edje_Text_Autocapital_Type autocapital_type)
2073 ed = _edje_fetch(obj);
2074 if ((!ed) || (!part)) return;
2075 rp = _edje_real_part_recursive_get(ed, part);
2077 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2079 _edje_entry_autocapital_type_set(rp, autocapital_type);
2083 EAPI Edje_Text_Autocapital_Type
2084 edje_object_part_text_autocapital_type_get(const Evas_Object *obj, const char *part)
2089 ed = _edje_fetch(obj);
2090 if ((!ed) || (!part)) return EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
2091 rp = _edje_real_part_recursive_get(ed, part);
2092 if (!rp) return EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
2093 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2095 return _edje_entry_autocapital_type_get(rp);
2097 return EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
2101 edje_object_part_text_prediction_allow_set(Evas_Object *obj, const char *part, Eina_Bool prediction)
2106 ed = _edje_fetch(obj);
2107 if ((!ed) || (!part)) return;
2108 rp = _edje_real_part_recursive_get(ed, part);
2110 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2112 _edje_entry_prediction_allow_set(rp, prediction);
2117 edje_object_part_text_prediction_allow_get(const Evas_Object *obj, const char *part)
2122 ed = _edje_fetch(obj);
2123 if ((!ed) || (!part)) return EINA_FALSE;
2124 rp = _edje_real_part_recursive_get(ed, part);
2125 if (!rp) return EINA_FALSE;
2126 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2128 return _edje_entry_prediction_allow_get(rp);
2134 edje_object_part_text_input_panel_enabled_set(Evas_Object *obj, const char *part, Eina_Bool enabled)
2139 ed = _edje_fetch(obj);
2140 if ((!ed) || (!part)) return;
2141 rp = _edje_real_part_recursive_get(ed, part);
2143 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2145 _edje_entry_input_panel_enabled_set(rp, enabled);
2150 edje_object_part_text_input_panel_enabled_get(const Evas_Object *obj, const char *part)
2155 ed = _edje_fetch(obj);
2156 if ((!ed) || (!part)) return EINA_FALSE;
2157 rp = _edje_real_part_recursive_get(ed, part);
2158 if (!rp) return EINA_FALSE;
2159 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2161 return _edje_entry_input_panel_enabled_get(rp);
2167 edje_object_part_text_input_panel_show(const Evas_Object *obj, const char *part)
2172 ed = _edje_fetch(obj);
2173 if ((!ed) || (!part)) return;
2174 rp = _edje_real_part_recursive_get(ed, part);
2176 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2177 _edje_entry_input_panel_show(rp);
2181 edje_object_part_text_input_panel_hide(const Evas_Object *obj, const char *part)
2186 ed = _edje_fetch(obj);
2187 if ((!ed) || (!part)) return;
2188 rp = _edje_real_part_recursive_get(ed, part);
2190 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2191 _edje_entry_input_panel_hide(rp);
2195 edje_object_part_text_input_panel_language_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Lang lang)
2200 ed = _edje_fetch(obj);
2201 if ((!ed) || (!part)) return;
2202 rp = _edje_real_part_recursive_get(ed, part);
2204 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2206 _edje_entry_input_panel_language_set(rp, lang);
2210 EAPI Edje_Input_Panel_Lang
2211 edje_object_part_text_input_panel_language_get(const Evas_Object *obj, const char *part)
2216 ed = _edje_fetch(obj);
2217 if ((!ed) || (!part)) return EDJE_INPUT_PANEL_LANG_AUTOMATIC;
2218 rp = _edje_real_part_recursive_get(ed, part);
2219 if (!rp) return EDJE_INPUT_PANEL_LANG_AUTOMATIC;
2220 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2222 return _edje_entry_input_panel_language_get(rp);
2224 return EDJE_INPUT_PANEL_LANG_AUTOMATIC;
2228 edje_object_part_text_input_panel_imdata_set(Evas_Object *obj, const char *part, const void *data, int len)
2233 ed = _edje_fetch(obj);
2234 if ((!ed) || (!part)) return;
2235 rp = _edje_real_part_recursive_get(ed, part);
2237 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2239 _edje_entry_input_panel_imdata_set(rp, data, len);
2244 edje_object_part_text_input_panel_imdata_get(const Evas_Object *obj, const char *part, void *data, int *len)
2249 ed = _edje_fetch(obj);
2250 if ((!ed) || (!part)) return;
2251 rp = _edje_real_part_recursive_get(ed, part);
2253 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2255 _edje_entry_input_panel_imdata_get(rp, data, len);
2260 edje_object_part_text_input_panel_return_key_type_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Return_Key_Type return_key_type)
2265 ed = _edje_fetch(obj);
2266 if ((!ed) || (!part)) return;
2267 rp = _edje_real_part_recursive_get(ed, part);
2269 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2271 _edje_entry_input_panel_return_key_type_set(rp, return_key_type);
2275 EAPI Edje_Input_Panel_Return_Key_Type
2276 edje_object_part_text_input_panel_return_key_type_get(const Evas_Object *obj, const char *part)
2281 ed = _edje_fetch(obj);
2282 if ((!ed) || (!part)) return EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
2283 rp = _edje_real_part_recursive_get(ed, part);
2284 if (!rp) return EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
2285 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2287 return _edje_entry_input_panel_return_key_type_get(rp);
2289 return EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
2293 edje_object_part_text_input_panel_return_key_disabled_set(Evas_Object *obj, const char *part, Eina_Bool disabled)
2298 ed = _edje_fetch(obj);
2299 if ((!ed) || (!part)) return;
2300 rp = _edje_real_part_recursive_get(ed, part);
2302 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2304 _edje_entry_input_panel_return_key_disabled_set(rp, disabled);
2309 edje_object_part_text_input_panel_return_key_disabled_get(const Evas_Object *obj, const char *part)
2314 ed = _edje_fetch(obj);
2315 if ((!ed) || (!part)) return EINA_FALSE;
2316 rp = _edje_real_part_recursive_get(ed, part);
2317 if (!rp) return EINA_FALSE;
2318 if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
2320 return _edje_entry_input_panel_return_key_disabled_get(rp);
2326 edje_object_text_insert_filter_callback_add(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func, void *data)
2329 Edje_Text_Insert_Filter_Callback *cb;
2331 ed = _edje_fetch(obj);
2332 if ((!ed) || (!part)) return;
2333 cb = calloc(1, sizeof(Edje_Text_Insert_Filter_Callback));
2334 cb->part = eina_stringshare_add(part);
2336 cb->data = (void *)data;
2337 ed->text_insert_filter_callbacks =
2338 eina_list_append(ed->text_insert_filter_callbacks, cb);
2342 edje_object_text_insert_filter_callback_del(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func)
2345 Edje_Text_Insert_Filter_Callback *cb;
2348 ed = _edje_fetch(obj);
2349 if ((!ed) || (!part)) return NULL;
2350 EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
2352 if ((!strcmp(cb->part, part)) && (cb->func == func))
2354 void *data = cb->data;
2355 ed->text_insert_filter_callbacks =
2356 eina_list_remove_list(ed->text_insert_filter_callbacks, l);
2357 eina_stringshare_del(cb->part);
2366 edje_object_text_insert_filter_callback_del_full(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func, void *data)
2369 Edje_Text_Insert_Filter_Callback *cb;
2372 ed = _edje_fetch(obj);
2373 if ((!ed) || (!part)) return NULL;
2374 EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
2376 if ((!strcmp(cb->part, part)) && (cb->func == func) &&
2379 void *tmp = cb->data;
2380 ed->text_insert_filter_callbacks =
2381 eina_list_remove_list(ed->text_insert_filter_callbacks, l);
2382 eina_stringshare_del(cb->part);
2391 edje_object_text_markup_filter_callback_add(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func, void *data)
2394 Edje_Markup_Filter_Callback *cb;
2396 ed = _edje_fetch(obj);
2397 if ((!ed) || (!part)) return;
2398 cb = calloc(1, sizeof(Edje_Markup_Filter_Callback));
2399 cb->part = eina_stringshare_add(part);
2401 cb->data = (void *)data;
2402 ed->markup_filter_callbacks =
2403 eina_list_append(ed->markup_filter_callbacks, cb);
2407 edje_object_text_markup_filter_callback_del(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func)
2410 Edje_Markup_Filter_Callback *cb;
2413 ed = _edje_fetch(obj);
2414 if ((!ed) || (!part)) return NULL;
2415 EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
2417 if ((!strcmp(cb->part, part)) && (cb->func == func))
2419 void *data = cb->data;
2420 ed->markup_filter_callbacks =
2421 eina_list_remove_list(ed->markup_filter_callbacks, l);
2422 eina_stringshare_del(cb->part);
2431 edje_object_text_markup_filter_callback_del_full(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func, void *data)
2434 Edje_Markup_Filter_Callback *cb;
2437 ed = _edje_fetch(obj);
2438 if ((!ed) || (!part)) return NULL;
2439 EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
2441 if ((!strcmp(cb->part, part)) && (cb->func == func) &&
2444 void *tmp = cb->data;
2445 ed->markup_filter_callbacks =
2446 eina_list_remove_list(ed->markup_filter_callbacks, l);
2447 eina_stringshare_del(cb->part);
2456 edje_object_part_swallow(Evas_Object *obj, const char *part, Evas_Object *obj_swallow)
2460 Edje_User_Defined *eud = NULL;
2462 ed = _edje_fetch(obj);
2463 if ((!ed) || (!part)) return EINA_FALSE;
2465 /* Need to recalc before providing the object. */
2466 // XXX: I guess this is not required, removing for testing purposes
2467 // XXX: uncomment if you see glitches in e17 or others.
2468 // XXX: by Gustavo, January 21th 2009.
2469 // XXX: I got a backtrace with over 30000 calls without this,
2470 // XXX: only with 32px shelves. The problem is probably somewhere else,
2471 // XXX: but until it's found, leave this here.
2472 // XXX: by Sachiel, January 21th 2009, 19:30 UTC
2473 _edje_recalc_do(ed);
2475 rp = evas_object_data_get(obj_swallow, "\377 edje.swallowing_part");
2478 /* The object is already swallowed somewhere, unswallow it first */
2479 edje_object_part_unswallow(rp->edje->obj, obj_swallow);
2482 rp = _edje_real_part_recursive_get(ed, part);
2485 DBG("cannot swallow part %s: part not exist!", part);
2488 if (rp->part->type != EDJE_PART_TYPE_SWALLOW)
2490 ERR("cannot swallow part %s: not swallow type!", rp->part->name);
2493 _edje_real_part_swallow(rp, obj_swallow, EINA_TRUE);
2495 if (rp->swallowed_object)
2499 eud = _edje_user_definition_new(EDJE_USER_SWALLOW, part, ed);
2500 evas_object_event_callback_add(obj_swallow, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
2502 else ed->user_defined = eina_list_append(ed->user_defined, eud);
2506 eud->u.swallow.child = obj_swallow;
2514 _recalc_extern_parent(Evas_Object *obj)
2516 Evas_Object *parent;
2519 parent = evas_object_smart_parent_get(obj);
2520 ed = _edje_fetch(parent);
2523 ed->recalc_call = 1; // ZZZ: ???
2528 edje_extern_object_min_size_set(Evas_Object *obj, Evas_Coord minw, Evas_Coord minh)
2532 evas_object_size_hint_min_set(obj, minw, minh);
2533 rp = evas_object_data_get(obj, "\377 edje.swallowing_part");
2536 rp->swallow_params.min.w = minw;
2537 rp->swallow_params.min.h = minh;
2539 _recalc_extern_parent(obj);
2544 edje_extern_object_max_size_set(Evas_Object *obj, Evas_Coord maxw, Evas_Coord maxh)
2548 evas_object_size_hint_max_set(obj, maxw, maxh);
2549 rp = evas_object_data_get(obj, "\377 edje.swallowing_part");
2552 rp->swallow_params.max.w = maxw;
2553 rp->swallow_params.max.h = maxh;
2555 _recalc_extern_parent(obj);
2560 edje_extern_object_aspect_set(Evas_Object *obj, Edje_Aspect_Control aspect, Evas_Coord aw, Evas_Coord ah)
2563 Evas_Aspect_Control asp;
2565 asp = EVAS_ASPECT_CONTROL_NONE;
2568 case EDJE_ASPECT_CONTROL_NONE: asp = EVAS_ASPECT_CONTROL_NONE; break;
2569 case EDJE_ASPECT_CONTROL_NEITHER: asp = EVAS_ASPECT_CONTROL_NEITHER; break;
2570 case EDJE_ASPECT_CONTROL_HORIZONTAL: asp = EVAS_ASPECT_CONTROL_HORIZONTAL; break;
2571 case EDJE_ASPECT_CONTROL_VERTICAL: asp = EVAS_ASPECT_CONTROL_VERTICAL; break;
2572 case EDJE_ASPECT_CONTROL_BOTH: asp = EVAS_ASPECT_CONTROL_BOTH; break;
2577 evas_object_size_hint_aspect_set(obj, asp, aw, ah);
2578 rp = evas_object_data_get(obj, "\377 edje.swallowing_part");
2581 rp->swallow_params.aspect.mode = aspect;
2582 rp->swallow_params.aspect.w = aw;
2583 rp->swallow_params.aspect.h = ah;
2584 _recalc_extern_parent(obj);
2588 struct edje_box_layout_builtin {
2590 Evas_Object_Box_Layout cb;
2593 static Evas_Object_Box_Layout
2594 _edje_box_layout_builtin_find(const char *name)
2596 const struct edje_box_layout_builtin _edje_box_layout_builtin[] = {
2597 {"horizontal", evas_object_box_layout_horizontal},
2598 {"horizontal_flow", evas_object_box_layout_flow_horizontal},
2599 {"horizontal_homogeneous", evas_object_box_layout_homogeneous_horizontal},
2600 {"horizontal_max", evas_object_box_layout_homogeneous_max_size_horizontal},
2601 {"stack", evas_object_box_layout_stack},
2602 {"vertical", evas_object_box_layout_vertical},
2603 {"vertical_flow", evas_object_box_layout_flow_vertical},
2604 {"vertical_homogeneous", evas_object_box_layout_homogeneous_vertical},
2605 {"vertical_max", evas_object_box_layout_homogeneous_max_size_vertical},
2608 const struct edje_box_layout_builtin *base;
2613 base = _edje_box_layout_builtin + 0;
2616 base = _edje_box_layout_builtin + 4;
2619 base = _edje_box_layout_builtin + 5;
2625 for (; (base->name) && (base->name[0] == name[0]); base++)
2626 if (strcmp(base->name, name) == 0)
2632 static Eina_Rbtree_Direction
2633 _edje_box_layout_external_node_cmp(const Eina_Rbtree *left, const Eina_Rbtree *right, __UNUSED__ void *data)
2635 Edje_Box_Layout *l = (Edje_Box_Layout *)left;
2636 Edje_Box_Layout *r = (Edje_Box_Layout *)right;
2638 if (strcmp(l->name, r->name) < 0)
2639 return EINA_RBTREE_RIGHT;
2641 return EINA_RBTREE_LEFT;
2645 _edje_box_layout_external_find_cmp(const Eina_Rbtree *node, const void *key, __UNUSED__ int length, __UNUSED__ void *data)
2647 Edje_Box_Layout *l = (Edje_Box_Layout *)node;
2648 return strcmp(key, l->name);
2651 static Edje_Box_Layout *
2652 _edje_box_layout_external_find(const char *name)
2654 return (Edje_Box_Layout *)eina_rbtree_inline_lookup
2655 (_edje_box_layout_registry, name, 0, _edje_box_layout_external_find_cmp,
2660 _edje_box_layout_find(const char *name, Evas_Object_Box_Layout *cb, void **data, void (**free_data)(void *data))
2662 const Edje_Box_Layout *l;
2664 if (!name) return EINA_FALSE;
2666 *cb = _edje_box_layout_builtin_find(name);
2674 l = _edje_box_layout_external_find(name);
2675 if (!l) return EINA_FALSE;
2678 *free_data = l->layout_data_free;
2679 if (l->layout_data_get)
2680 *data = l->layout_data_get(l->data);
2688 _edje_box_layout_external_free(Eina_Rbtree *node, __UNUSED__ void *data)
2690 Edje_Box_Layout *l = (Edje_Box_Layout *)node;
2692 if (l->data && l->free_data)
2693 l->free_data(l->data);
2697 static Edje_Box_Layout *
2698 _edje_box_layout_external_new(const char *name, Evas_Object_Box_Layout func, void *(*layout_data_get)(void *), void (*layout_data_free)(void *), void (*free_data)(void *), void *data)
2703 name_len = strlen(name) + 1;
2704 l = malloc(sizeof(Edje_Box_Layout) + name_len);
2705 if (!l) return NULL;
2708 l->layout_data_get = layout_data_get;
2709 l->layout_data_free = layout_data_free;
2710 l->free_data = free_data;
2713 memcpy(l->name, name, name_len);
2719 edje_box_layout_register(const char *name, Evas_Object_Box_Layout func, void *(*layout_data_get)(void *), void (*layout_data_free)(void *), void (*free_data)(void *), void *data)
2725 if (_edje_box_layout_builtin_find(name))
2727 ERR("Cannot register layout '%s': would override builtin!",
2730 if (data && free_data) free_data(data);
2734 l = _edje_box_layout_external_find(name);
2739 if (data && free_data) free_data(data);
2743 l = _edje_box_layout_external_new
2744 (name, func, layout_data_get, layout_data_free, free_data, data);
2748 _edje_box_layout_registry = eina_rbtree_inline_insert
2749 (_edje_box_layout_registry, (Eina_Rbtree *)l,
2750 _edje_box_layout_external_node_cmp, NULL);
2756 if (l->data && l->free_data) l->free_data(l->data);
2759 l->layout_data_get = layout_data_get;
2760 l->layout_data_free = layout_data_free;
2761 l->free_data = free_data;
2766 if (data && free_data) free_data(data);
2768 _edje_box_layout_registry = eina_rbtree_inline_remove
2769 (_edje_box_layout_registry, (Eina_Rbtree *)l,
2770 _edje_box_layout_external_node_cmp, NULL);
2771 _edje_box_layout_external_free((Eina_Rbtree *)l, NULL);
2777 edje_object_part_unswallow(Evas_Object *obj, Evas_Object *obj_swallow)
2781 if (!obj_swallow) return;
2783 rp = (Edje_Real_Part *)evas_object_data_get(obj_swallow, "\377 edje.swallowing_part");
2786 if (rp->part->type != EDJE_PART_TYPE_SWALLOW)
2788 ERR("cannot unswallow part %s: not swallow type!", rp->part->name);
2792 if (rp->swallowed_object == obj_swallow)
2794 Edje_User_Defined *eud;
2801 ed = _edje_fetch(obj);
2804 ERR("edje_object_part_unswallow called on a non Edje object ('%s').",
2805 evas_object_type_get(obj));
2809 EINA_LIST_FOREACH(ed->user_defined, l, eud)
2810 if (eud->type == EDJE_USER_SWALLOW && eud->u.swallow.child == obj_swallow)
2812 _edje_user_definition_free(eud);
2818 _edje_real_part_swallow_clear(rp);
2819 rp->swallowed_object = NULL;
2820 rp->swallow_params.min.w = 0;
2821 rp->swallow_params.min.h = 0;
2822 rp->swallow_params.max.w = 0;
2823 rp->swallow_params.max.h = 0;
2824 rp->edje->dirty = 1;
2825 rp->edje->recalc_call = 1;
2826 #ifdef EDJE_CALC_CACHE
2829 _edje_recalc_do(rp->edje);
2835 edje_object_part_swallow_get(const Evas_Object *obj, const char *part)
2840 ed = _edje_fetch(obj);
2841 if ((!ed) || (!part)) return NULL;
2843 /* Need to recalc before providing the object. */
2844 _edje_recalc_do(ed);
2846 rp = _edje_real_part_recursive_get(ed, part);
2847 if (!rp) return NULL;
2848 return rp->swallowed_object;
2852 edje_object_size_min_get(const Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh)
2856 ed = _edje_fetch(obj);
2857 if ((!ed) || (!ed->collection))
2859 if (minw) *minw = 0;
2860 if (minh) *minh = 0;
2863 if (minw) *minw = ed->collection->prop.min.w;
2864 if (minh) *minh = ed->collection->prop.min.h;
2868 edje_object_size_max_get(const Evas_Object *obj, Evas_Coord *maxw, Evas_Coord *maxh)
2872 ed = _edje_fetch(obj);
2873 if ((!ed) || (!ed->collection))
2875 if (maxw) *maxw = 0;
2876 if (maxh) *maxh = 0;
2880 /* Need to recalc before providing the object. */
2881 _edje_recalc_do(ed);
2883 if (ed->collection->prop.max.w == 0)
2885 /* XXX TODO: convert maxw to 0, fix things that break. */
2886 if (maxw) *maxw = EDJE_INF_MAX_W;
2890 if (maxw) *maxw = ed->collection->prop.max.w;
2892 if (ed->collection->prop.max.h == 0)
2894 /* XXX TODO: convert maxh to 0, fix things that break. */
2895 if (maxh) *maxh = EDJE_INF_MAX_H;
2899 if (maxh) *maxh = ed->collection->prop.max.h;
2904 edje_object_calc_force(Evas_Object *obj)
2909 ed = _edje_fetch(obj);
2912 #ifdef EDJE_CALC_CACHE
2913 ed->all_part_change = 1;
2916 pf2 = _edje_freeze_val;
2919 _edje_freeze_val = 0;
2922 _edje_recalc_do(ed);
2925 _edje_freeze_val = pf2;
2929 edje_object_size_min_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh)
2931 edje_object_size_min_restricted_calc(obj, minw, minh, 0, 0);
2935 edje_object_parts_extends_calc(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
2938 Evas_Coord xx1 = INT_MAX, yy1 = INT_MAX;
2939 Evas_Coord xx2 = 0, yy2 = 0;
2942 ed = _edje_fetch(obj);
2954 /* Need to recalc before providing the object. */
2956 _edje_recalc_do(ed);
2958 for (i = 0; i < ed->table_parts_size; i++)
2961 Evas_Coord rpx1, rpy1;
2962 Evas_Coord rpx2, rpy2;
2964 rp = ed->table_parts[i];
2968 rpx2 = rpx1 + rp->w;
2969 rpy2 = rpy1 + rp->h;
2971 if (xx1 > rpx1) xx1 = rpx1;
2972 if (yy1 > rpy1) yy1 = rpy1;
2973 if (xx2 < rpx2) xx2 = rpx2;
2974 if (yy2 < rpy2) yy2 = rpy2;
2981 if (w) *w = xx2 - xx1;
2982 if (h) *h = yy2 - yy1;
2988 edje_object_size_min_restricted_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh, Evas_Coord restrictedw, Evas_Coord restrictedh)
2995 Edje_Real_Part *pep = NULL;
2996 Eina_Bool has_non_fixed_tb = EINA_FALSE;
2998 ed = _edje_fetch(obj);
2999 if ((!ed) || (!ed->collection))
3001 if (minw) *minw = restrictedw;
3002 if (minh) *minh = restrictedh;
3011 ed->w = restrictedw;
3012 ed->h = restrictedh;
3023 #ifdef EDJE_CALC_CACHE
3024 ed->all_part_change = 1;
3026 _edje_recalc_do(ed);
3033 has_non_fixed_tb = EINA_FALSE;
3034 for (i = 0; i < ed->table_parts_size; i++)
3040 ep = ed->table_parts[i];
3041 w = ep->w - ep->req.w;
3042 h = ep->h - ep->req.h;
3044 if (ep->chosen_description)
3046 if (!ep->chosen_description->fixed.w)
3048 if ((ep->part->type == EDJE_PART_TYPE_TEXTBLOCK))
3051 evas_object_textblock_size_formatted_get(ep->object,
3058 has_non_fixed_tb = EINA_TRUE;
3068 if (!ep->chosen_description->fixed.h)
3070 if (!((ep->part->type == EDJE_PART_TYPE_TEXTBLOCK) &&
3071 (!((Edje_Part_Description_Text *)ep->chosen_description)->text.min_x) &&
3082 if (ep->part->type == EDJE_PART_TYPE_TEXTBLOCK)
3084 has_non_fixed_tb = EINA_TRUE;
3092 if (ed->w < restrictedw) ed->w = restrictedw;
3097 if (ed->h < restrictedh) ed->h = restrictedh;
3099 if ((ed->w > 4000) || (ed->h > 4000))
3101 /* Only print it if we have a non-fixed textblock.
3102 * We should possibly avoid all of this if in this case, but in
3103 * the meanwhile, just doing this. */
3104 if (!has_non_fixed_tb)
3107 ERR("file %s, group %s has a non-fixed part '%s'. Adding 'fixed: 1 1;' to source EDC may help. Continuing discarding faulty part.",
3108 ed->path, ed->group, pep->part->name);
3110 ERR("file %s, group %s overflowed 4000x4000 with minimum size of %dx%d. Continuing discarding faulty parts.",
3111 ed->path, ed->group, ed->w, ed->h);
3125 if (minw) *minw = ed->min.w;
3126 if (minh) *minh = ed->min.h;
3131 #ifdef EDJE_CALC_CACHE
3132 ed->all_part_change = 1;
3138 /* FIXME: Correctly return other states */
3140 edje_object_part_state_get(const Evas_Object *obj, const char *part, double *val_ret)
3145 ed = _edje_fetch(obj);
3146 if ((!ed) || (!part))
3148 if (val_ret) *val_ret = 0;
3152 /* Need to recalc before providing the object. */
3153 _edje_recalc_do(ed);
3155 rp = _edje_real_part_recursive_get(ed, part);
3158 if (val_ret) *val_ret = 0;
3159 INF("part not found");
3162 if (rp->chosen_description)
3164 if (val_ret) *val_ret = rp->chosen_description->state.value;
3165 if (rp->chosen_description->state.name)
3166 return rp->chosen_description->state.name;
3171 if (rp->param1.description)
3173 if (val_ret) *val_ret = rp->param1.description->state.value;
3174 if (rp->param1.description->state.name)
3175 return rp->param1.description->state.name;
3179 if (val_ret) *val_ret = 0;
3184 edje_object_part_drag_dir_get(const Evas_Object *obj, const char *part)
3189 ed = _edje_fetch(obj);
3190 if ((!ed) || (!part)) return EDJE_DRAG_DIR_NONE;
3192 /* Need to recalc before providing the object. */
3193 _edje_recalc_do(ed);
3195 rp = _edje_real_part_recursive_get(ed, part);
3196 if (!rp) return EDJE_DRAG_DIR_NONE;
3197 if ((rp->part->dragable.x) && (rp->part->dragable.y)) return EDJE_DRAG_DIR_XY;
3198 else if (rp->part->dragable.x) return EDJE_DRAG_DIR_X;
3199 else if (rp->part->dragable.y) return EDJE_DRAG_DIR_Y;
3200 return EDJE_DRAG_DIR_NONE;
3204 edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, double dy)
3208 Edje_User_Defined *eud;
3211 ed = _edje_fetch(obj);
3212 if ((!ed) || (!part)) return EINA_FALSE;
3213 rp = _edje_real_part_recursive_get(ed, part);
3214 if (!rp) return EINA_FALSE;
3215 if (!rp->drag) return EINA_FALSE;
3216 if (rp->drag->down.count > 0) return EINA_FALSE;
3218 EINA_LIST_FOREACH(ed->user_defined, l, eud)
3219 if (eud->type == EDJE_USER_DRAG_VALUE && !strcmp(part, eud->part))
3221 eud->u.drag_position.x = dx;
3222 eud->u.drag_position.y = dy;
3227 eud = _edje_user_definition_new(EDJE_USER_DRAG_VALUE, part, ed);
3230 eud->u.drag_position.x = dx;
3231 eud->u.drag_position.y = dy;
3235 if (rp->part->dragable.confine_id != -1)
3237 dx = CLAMP(dx, 0.0, 1.0);
3238 dy = CLAMP(dy, 0.0, 1.0);
3240 if (rp->part->dragable.x < 0) dx = 1.0 - dx;
3241 if (rp->part->dragable.y < 0) dy = 1.0 - dy;
3242 if ((rp->drag->val.x == FROM_DOUBLE(dx)) && (rp->drag->val.y == FROM_DOUBLE(dy))) return EINA_TRUE;
3243 rp->drag->val.x = FROM_DOUBLE(dx);
3244 rp->drag->val.y = FROM_DOUBLE(dy);
3245 #ifdef EDJE_CALC_CACHE
3248 _edje_dragable_pos_set(rp->edje, rp, rp->drag->val.x, rp->drag->val.y);
3249 _edje_emit(rp->edje, "drag,set", rp->part->name);
3253 /* FIXME: Should this be x and y instead of dx/dy? */
3255 edje_object_part_drag_value_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
3261 ed = _edje_fetch(obj);
3262 if ((!ed) || (!part))
3269 /* Need to recalc before providing the object. */
3270 _edje_recalc_do(ed);
3272 rp = _edje_real_part_recursive_get(ed, part);
3273 if (!rp || !rp->drag)
3279 ddx = TO_DOUBLE(rp->drag->val.x);
3280 ddy = TO_DOUBLE(rp->drag->val.y);
3281 if (rp->part->dragable.x < 0) ddx = 1.0 - ddx;
3282 if (rp->part->dragable.y < 0) ddy = 1.0 - ddy;
3289 edje_object_part_drag_size_set(Evas_Object *obj, const char *part, double dw, double dh)
3293 Edje_User_Defined *eud;
3296 ed = _edje_fetch(obj);
3297 if ((!ed) || (!part)) return EINA_FALSE;
3298 rp = _edje_real_part_recursive_get(ed, part);
3299 if (!rp) return EINA_FALSE;
3300 if (!rp->drag) return EINA_FALSE;
3302 EINA_LIST_FOREACH(ed->user_defined, l, eud)
3303 if (eud->type == EDJE_USER_DRAG_SIZE && !strcmp(part, eud->part))
3305 eud->u.drag_size.w = dw;
3306 eud->u.drag_size.h = dh;
3311 eud = _edje_user_definition_new(EDJE_USER_DRAG_SIZE, part, ed);
3314 eud->u.drag_size.w = dw;
3315 eud->u.drag_size.h = dh;
3319 if (dw < 0.0) dw = 0.0;
3320 else if (dw > 1.0) dw = 1.0;
3321 if (dh < 0.0) dh = 0.0;
3322 else if (dh > 1.0) dh = 1.0;
3323 if ((rp->drag->size.x == FROM_DOUBLE(dw)) && (rp->drag->size.y == FROM_DOUBLE(dh))) return EINA_TRUE;
3324 rp->drag->size.x = FROM_DOUBLE(dw);
3325 rp->drag->size.y = FROM_DOUBLE(dh);
3326 rp->edje->dirty = 1;
3327 rp->edje->recalc_call = 1;
3328 #ifdef EDJE_CALC_CACHE
3331 _edje_recalc(rp->edje);
3336 edje_object_part_drag_size_get(const Evas_Object *obj, const char *part, double *dw, double *dh)
3341 ed = _edje_fetch(obj);
3342 if ((!ed) || (!part))
3349 /* Need to recalc before providing the object. */
3350 _edje_recalc_do(ed);
3352 rp = _edje_real_part_recursive_get(ed, part);
3353 if (!rp || !rp->drag)
3359 if (dw) *dw = TO_DOUBLE(rp->drag->size.x);
3360 if (dh) *dh = TO_DOUBLE(rp->drag->size.y);
3365 edje_object_part_drag_step_set(Evas_Object *obj, const char *part, double dx, double dy)
3369 Edje_User_Defined *eud;
3372 ed = _edje_fetch(obj);
3373 if ((!ed) || (!part)) return EINA_FALSE;
3374 rp = _edje_real_part_recursive_get(ed, part);
3375 if (!rp) return EINA_FALSE;
3376 if (!rp->drag) return EINA_FALSE;
3378 EINA_LIST_FOREACH(ed->user_defined, l, eud)
3379 if (eud->type == EDJE_USER_DRAG_STEP && !strcmp(part, eud->part))
3381 eud->u.drag_position.x = dx;
3382 eud->u.drag_position.y = dy;
3387 eud = _edje_user_definition_new(EDJE_USER_DRAG_STEP, part, ed);
3390 eud->u.drag_position.x = dx;
3391 eud->u.drag_position.y = dy;
3395 if (dx < 0.0) dx = 0.0;
3396 else if (dx > 1.0) dx = 1.0;
3397 if (dy < 0.0) dy = 0.0;
3398 else if (dy > 1.0) dy = 1.0;
3399 rp->drag->step.x = FROM_DOUBLE(dx);
3400 rp->drag->step.y = FROM_DOUBLE(dy);
3401 #ifdef EDJE_CALC_CACHE
3408 edje_object_part_drag_step_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
3413 ed = _edje_fetch(obj);
3414 if ((!ed) || (!part))
3421 /* Need to recalc before providing the object. */
3422 _edje_recalc_do(ed);
3424 rp = _edje_real_part_recursive_get(ed, part);
3425 if (!rp || !rp->drag)
3431 if (dx) *dx = TO_DOUBLE(rp->drag->step.x);
3432 if (dy) *dy = TO_DOUBLE(rp->drag->step.y);
3437 edje_object_part_drag_page_set(Evas_Object *obj, const char *part, double dx, double dy)
3441 Edje_User_Defined *eud;
3444 ed = _edje_fetch(obj);
3445 if ((!ed) || (!part)) return EINA_FALSE;
3446 rp = _edje_real_part_recursive_get(ed, part);
3447 if (!rp) return EINA_FALSE;
3448 if (!rp->drag) return EINA_FALSE;
3450 EINA_LIST_FOREACH(ed->user_defined, l, eud)
3451 if (eud->type == EDJE_USER_DRAG_PAGE && !strcmp(part, eud->part))
3453 eud->u.drag_position.x = dx;
3454 eud->u.drag_position.y = dy;
3459 eud = _edje_user_definition_new(EDJE_USER_DRAG_PAGE, part, ed);
3462 eud->u.drag_position.x = dx;
3463 eud->u.drag_position.y = dy;
3467 if (dx < 0.0) dx = 0.0;
3468 else if (dx > 1.0) dx = 1.0;
3469 if (dy < 0.0) dy = 0.0;
3470 else if (dy > 1.0) dy = 1.0;
3471 rp->drag->page.x = FROM_DOUBLE(dx);
3472 rp->drag->page.y = FROM_DOUBLE(dy);
3473 #ifdef EDJE_CALC_CACHE
3480 edje_object_part_drag_page_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
3485 ed = _edje_fetch(obj);
3486 if ((!ed) || (!part))
3493 /* Need to recalc before providing the object. */
3494 _edje_recalc_do(ed);
3496 rp = _edje_real_part_recursive_get(ed, part);
3497 if (!rp || !rp->drag)
3503 if (dx) *dx = TO_DOUBLE(rp->drag->page.x);
3504 if (dy) *dy = TO_DOUBLE(rp->drag->page.y);
3509 edje_object_part_drag_step(Evas_Object *obj, const char *part, double dx, double dy)
3514 Edje_User_Defined *eud;
3517 ed = _edje_fetch(obj);
3518 if ((!ed) || (!part)) return EINA_FALSE;
3519 rp = _edje_real_part_recursive_get(ed, part);
3520 if (!rp) return EINA_FALSE;
3521 if (!rp->drag) return EINA_FALSE;
3522 if (rp->drag->down.count > 0) return EINA_FALSE;
3524 EINA_LIST_FOREACH(ed->user_defined, l, eud)
3525 if (eud->type == EDJE_USER_DRAG_STEP && !strcmp(part, eud->part))
3527 eud->u.drag_position.x = dx;
3528 eud->u.drag_position.y = dy;
3533 eud = _edje_user_definition_new(EDJE_USER_DRAG_STEP, part, ed);
3536 eud->u.drag_position.x = dx;
3537 eud->u.drag_position.y = dy;
3541 px = rp->drag->val.x;
3542 py = rp->drag->val.y;
3543 rp->drag->val.x = ADD(px, MUL(FROM_DOUBLE(dx),
3544 MUL(rp->drag->step.x, rp->part->dragable.x)));
3545 rp->drag->val.y = ADD(py, MUL(FROM_DOUBLE(dy),
3546 MUL(rp->drag->step.y, rp->part->dragable.y)));
3547 rp->drag->val.x = CLAMP (rp->drag->val.x, ZERO, FROM_DOUBLE(1.0));
3548 rp->drag->val.y = CLAMP (rp->drag->val.y, ZERO, FROM_DOUBLE(1.0));
3549 if ((px == rp->drag->val.x) && (py == rp->drag->val.y)) return EINA_TRUE;
3550 #ifdef EDJE_CALC_CACHE
3553 _edje_dragable_pos_set(rp->edje, rp, rp->drag->val.x, rp->drag->val.y);
3554 _edje_emit(rp->edje, "drag,step", rp->part->name);
3559 edje_object_part_drag_page(Evas_Object *obj, const char *part, double dx, double dy)
3564 Edje_User_Defined *eud;
3567 ed = _edje_fetch(obj);
3568 if ((!ed) || (!part)) return EINA_FALSE;
3569 rp = _edje_real_part_recursive_get(ed, part);
3570 if (!rp) return EINA_FALSE;
3571 if (!rp->drag) return EINA_FALSE;
3572 if (rp->drag->down.count > 0) return EINA_FALSE;
3574 EINA_LIST_FOREACH(ed->user_defined, l, eud)
3575 if (eud->type == EDJE_USER_DRAG_PAGE && !strcmp(part, eud->part))
3577 eud->u.drag_position.x = dx;
3578 eud->u.drag_position.y = dy;
3583 eud = _edje_user_definition_new(EDJE_USER_DRAG_PAGE, part, ed);
3586 eud->u.drag_position.x = dx;
3587 eud->u.drag_position.y = dy;
3591 px = rp->drag->val.x;
3592 py = rp->drag->val.y;
3593 rp->drag->val.x = ADD(px, MUL(FROM_DOUBLE(dx), MUL(rp->drag->page.x, rp->part->dragable.x)));
3594 rp->drag->val.y = ADD(py, MUL(FROM_DOUBLE(dy), MUL(rp->drag->page.y, rp->part->dragable.y)));
3595 rp->drag->val.x = CLAMP (rp->drag->val.x, ZERO, FROM_DOUBLE(1.0));
3596 rp->drag->val.y = CLAMP (rp->drag->val.y, ZERO, FROM_DOUBLE(1.0));
3597 if ((px == rp->drag->val.x) && (py == rp->drag->val.y)) return EINA_TRUE;
3598 #ifdef EDJE_CALC_CACHE
3601 _edje_dragable_pos_set(rp->edje, rp, rp->drag->val.x, rp->drag->val.y);
3602 _edje_emit(rp->edje, "drag,page", rp->part->name);
3607 _edje_box_init(void)
3613 _edje_box_shutdown(void)
3615 if (!_edje_box_layout_registry)
3619 (_edje_box_layout_registry, _edje_box_layout_external_free, NULL);
3620 _edje_box_layout_registry = NULL;
3624 edje_object_part_box_append(Evas_Object *obj, const char *part, Evas_Object *child)
3630 ed = _edje_fetch(obj);
3631 if ((!ed) || (!part) || (!child)) return EINA_FALSE;
3633 rp = _edje_real_part_recursive_get(ed, part);
3634 if (!rp) return EINA_FALSE;
3635 if (rp->part->type != EDJE_PART_TYPE_BOX) return EINA_FALSE;
3637 r = _edje_real_part_box_append(rp, child);
3641 Edje_User_Defined *eud;
3643 eud = _edje_user_definition_new(EDJE_USER_BOX_PACK, part, ed);
3645 eud->u.box.child = child;
3646 eud->u.box.index = -1;
3648 evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
3654 edje_object_part_box_prepend(Evas_Object *obj, const char *part, Evas_Object *child)
3660 ed = _edje_fetch(obj);
3661 if ((!ed) || (!part)) return EINA_FALSE;
3663 rp = _edje_real_part_recursive_get(ed, part);
3664 if (!rp) return EINA_FALSE;
3665 if (rp->part->type != EDJE_PART_TYPE_BOX) return EINA_FALSE;
3667 r = _edje_real_part_box_prepend(rp, child);
3671 Edje_User_Defined *eud;
3673 eud = _edje_user_definition_new(EDJE_USER_BOX_PACK, part, ed);
3675 eud->u.box.child = child;
3677 evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
3683 edje_object_part_box_insert_before(Evas_Object *obj, const char *part, Evas_Object *child, const Evas_Object *reference)
3689 ed = _edje_fetch(obj);
3690 if ((!ed) || (!part)) return EINA_FALSE;
3692 rp = _edje_real_part_recursive_get(ed, part);
3693 if (!rp) return EINA_FALSE;
3694 if (rp->part->type != EDJE_PART_TYPE_BOX) return EINA_FALSE;
3696 r = _edje_real_part_box_insert_before(rp, child, reference);
3700 Edje_User_Defined *eud;
3702 eud = _edje_user_definition_new(EDJE_USER_BOX_PACK, part, ed);
3704 eud->u.box.child = child;
3706 evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
3712 edje_object_part_box_insert_at(Evas_Object *obj, const char *part, Evas_Object *child, unsigned int pos)
3718 ed = _edje_fetch(obj);
3719 if ((!ed) || (!part)) return EINA_FALSE;
3721 rp = _edje_real_part_recursive_get(ed, part);
3722 if (!rp) return EINA_FALSE;
3723 if (rp->part->type != EDJE_PART_TYPE_BOX) return EINA_FALSE;
3725 r = _edje_real_part_box_insert_at(rp, child, pos);
3729 Edje_User_Defined *eud;
3731 eud = _edje_user_definition_new(EDJE_USER_BOX_PACK, part, ed);
3733 eud->u.box.child = child;
3735 evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
3741 edje_object_part_box_remove(Evas_Object *obj, const char *part, Evas_Object *child)
3747 ed = _edje_fetch(obj);
3748 if ((!ed) || (!part)) return NULL;
3750 rp = _edje_real_part_recursive_get(ed, part);
3751 if (!rp) return NULL;
3752 if (rp->part->type != EDJE_PART_TYPE_BOX) return NULL;
3754 r = _edje_real_part_box_remove(rp, child);
3758 Edje_User_Defined *eud;
3761 EINA_LIST_FOREACH(ed->user_defined, l, eud)
3762 if (eud->type == EDJE_USER_BOX_PACK && eud->u.box.child == child && !strcmp(eud->part, part))
3764 _edje_user_definition_free(eud);
3772 edje_object_part_box_remove_at(Evas_Object *obj, const char *part, unsigned int pos)
3778 ed = _edje_fetch(obj);
3779 if ((!ed) || (!part)) return NULL;
3781 rp = _edje_real_part_recursive_get(ed, part);
3782 if (!rp) return NULL;
3783 if (rp->part->type != EDJE_PART_TYPE_BOX) return NULL;
3785 r = _edje_real_part_box_remove_at(rp, pos);
3789 Edje_User_Defined *eud;
3792 EINA_LIST_FOREACH(ed->user_defined, l, eud)
3793 if (eud->type == EDJE_USER_BOX_PACK && eud->u.box.child == r && !strcmp(eud->part, part))
3795 _edje_user_definition_free(eud);
3803 edje_object_part_box_remove_all(Evas_Object *obj, const char *part, Eina_Bool clear)
3809 ed = _edje_fetch(obj);
3810 if ((!ed) || (!part)) return EINA_FALSE;
3812 rp = _edje_real_part_recursive_get(ed, part);
3813 if (!rp) return EINA_FALSE;
3814 if (rp->part->type != EDJE_PART_TYPE_BOX) return EINA_FALSE;
3816 r = _edje_real_part_box_remove_all(rp, clear);
3819 Edje_User_Defined *eud;
3822 EINA_LIST_FOREACH_SAFE(ed->user_defined, l, ll, eud)
3823 if (eud->type == EDJE_USER_BOX_PACK && !strcmp(eud->part, part))
3825 _edje_user_definition_free(eud);
3833 edje_object_access_part_list_get(const Evas_Object *obj)
3836 Eina_List *access_parts = NULL;
3838 ed = _edje_fetch(obj);
3839 if ((!ed)) return NULL;
3842 for (i = 0; i < ed->table_parts_size; i++)
3845 rp = ed->table_parts[i];
3846 if (rp->part->access)
3847 access_parts = eina_list_append(access_parts, rp->part->name);
3850 return access_parts;
3854 _edje_box_child_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *child __UNUSED__, void *einfo __UNUSED__)
3856 Edje_Real_Part *rp = data;
3858 rp->edje->dirty = 1;
3859 rp->edje->recalc_call = 1;
3860 #ifdef EDJE_CALC_CACHE
3863 _edje_recalc(rp->edje);
3867 _edje_box_child_add(Edje_Real_Part *rp, Evas_Object *child)
3869 evas_object_event_callback_add
3870 (child, EVAS_CALLBACK_DEL, _edje_box_child_del_cb, rp);
3872 rp->edje->dirty = 1;
3873 rp->edje->recalc_call = 1;
3874 #ifdef EDJE_CALC_CACHE
3877 _edje_recalc(rp->edje);
3881 _edje_box_child_remove(Edje_Real_Part *rp, Evas_Object *child)
3883 evas_object_event_callback_del_full
3884 (child, EVAS_CALLBACK_DEL, _edje_box_child_del_cb, rp);
3886 rp->edje->dirty = 1;
3887 rp->edje->recalc_call = 1;
3888 #ifdef EDJE_CALC_CACHE
3891 _edje_recalc(rp->edje);
3895 _edje_real_part_box_append(Edje_Real_Part *rp, Evas_Object *child_obj)
3897 Evas_Object_Box_Option *opt;
3899 opt = evas_object_box_append(rp->object, child_obj);
3900 if (!opt) return EINA_FALSE;
3902 if (!_edje_box_layout_add_child(rp, child_obj))
3904 evas_object_box_remove(rp->object, child_obj);
3908 _edje_box_child_add(rp, child_obj);
3914 _edje_real_part_box_prepend(Edje_Real_Part *rp, Evas_Object *child_obj)
3916 Evas_Object_Box_Option *opt;
3918 opt = evas_object_box_prepend(rp->object, child_obj);
3919 if (!opt) return EINA_FALSE;
3921 if (!_edje_box_layout_add_child(rp, child_obj))
3923 evas_object_box_remove(rp->object, child_obj);
3927 _edje_box_child_add(rp, child_obj);
3933 _edje_real_part_box_insert_before(Edje_Real_Part *rp, Evas_Object *child_obj, const Evas_Object *ref)
3935 Evas_Object_Box_Option *opt;
3937 opt = evas_object_box_insert_before(rp->object, child_obj, ref);
3938 if (!opt) return EINA_FALSE;
3940 if (!_edje_box_layout_add_child(rp, child_obj))
3942 evas_object_box_remove(rp->object, child_obj);
3946 _edje_box_child_add(rp, child_obj);
3952 _edje_real_part_box_insert_at(Edje_Real_Part *rp, Evas_Object *child_obj, unsigned int pos)
3954 Evas_Object_Box_Option *opt;
3956 opt = evas_object_box_insert_at(rp->object, child_obj, pos);
3957 if (!opt) return EINA_FALSE;
3959 if (!_edje_box_layout_add_child(rp, child_obj))
3961 evas_object_box_remove(rp->object, child_obj);
3965 _edje_box_child_add(rp, child_obj);
3971 _edje_real_part_box_remove(Edje_Real_Part *rp, Evas_Object *child_obj)
3973 if (evas_object_data_get(child_obj, "\377 edje.box_item")) return NULL;
3974 if (!evas_object_box_remove(rp->object, child_obj)) return NULL;
3975 _edje_box_layout_remove_child(rp, child_obj);
3976 _edje_box_child_remove(rp, child_obj);
3981 _edje_real_part_box_remove_at(Edje_Real_Part *rp, unsigned int pos)
3983 Evas_Object_Box_Option *opt;
3984 Evas_Object_Box_Data *priv;
3985 Evas_Object *child_obj;
3987 priv = evas_object_smart_data_get(rp->object);
3988 opt = eina_list_nth(priv->children, pos);
3989 if (!opt) return NULL;
3990 child_obj = opt->obj;
3991 if (evas_object_data_get(child_obj, "\377 edje.box_item")) return NULL;
3992 if (!evas_object_box_remove_at(rp->object, pos)) return NULL;
3993 _edje_box_layout_remove_child(rp, child_obj);
3994 _edje_box_child_remove(rp, child_obj);
3999 _edje_real_part_box_remove_all(Edje_Real_Part *rp, Eina_Bool clear)
4001 Eina_List *children;
4004 children = evas_object_box_children_get(rp->object);
4007 Evas_Object *child_obj = children->data;
4008 if (evas_object_data_get(child_obj, "\377 edje.box_item"))
4012 _edje_box_layout_remove_child(rp, child_obj);
4013 _edje_box_child_remove(rp, child_obj);
4014 if (!evas_object_box_remove_at(rp->object, i))
4017 evas_object_del(child_obj);
4019 children = eina_list_remove_list(children, children);
4025 _edje_table_child_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *child, void *einfo __UNUSED__)
4027 Edje_User_Defined *eud;
4029 Edje_Real_Part *rp = data;
4031 EINA_LIST_FOREACH(rp->edje->user_defined, l, eud)
4032 if (rp->part->type == EDJE_PART_TYPE_BOX)
4034 if (eud->type == EDJE_USER_BOX_PACK &&
4035 eud->u.box.child == child &&
4036 !strcmp(rp->part->name, eud->part))
4038 _edje_user_definition_free(eud);
4042 else if (rp->part->type == EDJE_PART_TYPE_TABLE)
4044 if (eud->type == EDJE_USER_TABLE_PACK &&
4045 eud->u.table.child == child &&
4046 !strcmp(rp->part->name, eud->part))
4048 _edje_user_definition_free(eud);
4053 rp->edje->dirty = 1;
4054 rp->edje->recalc_call = 1;
4055 #ifdef EDJE_CALC_CACHE
4058 _edje_recalc(rp->edje);
4062 _edje_table_child_add(Edje_Real_Part *rp, Evas_Object *child)
4064 evas_object_event_callback_add
4065 (child, EVAS_CALLBACK_DEL, _edje_table_child_del_cb, rp);
4067 rp->edje->dirty = 1;
4068 rp->edje->recalc_call = 1;
4069 #ifdef EDJE_CALC_CACHE
4072 _edje_recalc(rp->edje);
4076 _edje_table_child_remove(Edje_Real_Part *rp, Evas_Object *child)
4078 evas_object_event_callback_del_full
4079 (child, EVAS_CALLBACK_DEL, _edje_table_child_del_cb, rp);
4081 rp->edje->dirty = 1;
4082 rp->edje->recalc_call = 1;
4083 #ifdef EDJE_CALC_CACHE
4086 _edje_recalc(rp->edje);
4090 edje_object_part_table_child_get(const Evas_Object *obj, const char *part, unsigned int col, unsigned int row)
4095 ed = _edje_fetch(obj);
4096 if ((!ed) || (!part)) return NULL;
4098 rp = _edje_real_part_recursive_get(ed, part);
4099 if (!rp) return NULL;
4100 if (rp->part->type != EDJE_PART_TYPE_TABLE) return NULL;
4102 return evas_object_table_child_get(rp->object, col, row);
4106 edje_object_part_table_pack(Evas_Object *obj, const char *part, Evas_Object *child_obj, unsigned short col, unsigned short row, unsigned short colspan, unsigned short rowspan)
4110 Edje_User_Defined *eud;
4113 ed = _edje_fetch(obj);
4114 if ((!ed) || (!part)) return EINA_FALSE;
4116 rp = _edje_real_part_recursive_get(ed, part);
4117 if (!rp) return EINA_FALSE;
4118 if (rp->part->type != EDJE_PART_TYPE_TABLE) return EINA_FALSE;
4120 r = _edje_real_part_table_pack(rp, child_obj, col, row, colspan, rowspan);
4123 eud = _edje_user_definition_new(EDJE_USER_TABLE_PACK, part, ed);
4126 eud->u.table.child = child_obj;
4127 eud->u.table.col = col;
4128 eud->u.table.row = row;
4129 eud->u.table.colspan = colspan;
4130 eud->u.table.rowspan = rowspan;
4132 evas_object_event_callback_add(child_obj, EVAS_CALLBACK_DEL, _edje_user_def_del_cb, eud);
4138 edje_object_part_table_unpack(Evas_Object *obj, const char *part, Evas_Object *child_obj)
4144 ed = _edje_fetch(obj);
4145 if ((!ed) || (!part)) return EINA_FALSE;
4147 rp = _edje_real_part_recursive_get(ed, part);
4148 if (!rp) return EINA_FALSE;
4149 if (rp->part->type != EDJE_PART_TYPE_TABLE) return EINA_FALSE;
4151 r = _edje_real_part_table_unpack(rp, child_obj);
4155 Edje_User_Defined *eud;
4158 EINA_LIST_FOREACH(ed->user_defined, l, eud)
4159 if (eud->type == EDJE_USER_TABLE_PACK &&
4160 eud->u.table.child == child_obj &&
4161 !strcmp(part, eud->part))
4163 _edje_user_definition_free(eud);
4172 edje_object_part_table_col_row_size_get(const Evas_Object *obj, const char *part, int *cols, int *rows)
4177 ed = _edje_fetch(obj);
4178 if ((!ed) || (!part)) return EINA_FALSE;
4180 rp = _edje_real_part_recursive_get(ed, part);
4181 if (!rp) return EINA_FALSE;
4182 if (rp->part->type != EDJE_PART_TYPE_TABLE) return EINA_FALSE;
4184 evas_object_table_col_row_size_get(rp->object, cols, rows);
4189 edje_object_part_table_clear(Evas_Object *obj, const char *part, Eina_Bool clear)
4194 ed = _edje_fetch(obj);
4195 if ((!ed) || (!part)) return EINA_FALSE;
4197 rp = _edje_real_part_recursive_get(ed, part);
4198 if (!rp) return EINA_FALSE;
4199 if (rp->part->type != EDJE_PART_TYPE_TABLE) return EINA_FALSE;
4201 _edje_real_part_table_clear(rp, clear);
4206 _edje_perspective_obj_del(void *data, __UNUSED__ Evas *e, __UNUSED__ Evas_Object *obj, __UNUSED__ void *event_info)
4208 Edje_Perspective *ps = data;
4211 EINA_LIST_FREE(ps->users, o)
4215 ed = evas_object_smart_data_get(o);
4219 ed->recalc_call = 1;
4220 _edje_recalc_do(ed);
4225 EAPI Edje_Perspective *
4226 edje_perspective_new(Evas *e)
4228 Edje_Perspective *ps;
4229 Evas_Coord vx, vy, vw, vh;
4231 if (!e) return NULL;
4232 ps = calloc(1, sizeof(Edje_Perspective));
4233 ps->obj = evas_object_rectangle_add(e);
4234 evas_object_data_set(ps->obj, "_edje_perspective", ps);
4235 evas_object_event_callback_add(ps->obj, EVAS_CALLBACK_DEL, _edje_perspective_obj_del, ps);
4236 evas_output_viewport_get(e, &vx, &vy, &vw, &vh);
4238 ps->px = vx + (vw / 2);
4239 ps->py = vy + (vh / 2);
4246 edje_perspective_free(Edje_Perspective *ps)
4249 evas_object_del(ps->obj);
4253 edje_perspective_set(Edje_Perspective *ps, Evas_Coord px, Evas_Coord py, Evas_Coord z0, Evas_Coord foc)
4259 if ((ps->px == px) && (ps->py == py) && (ps->z0 == z0) && (ps->foc == foc)) return;
4264 EINA_LIST_FOREACH(ps->users, l, o)
4268 ed = evas_object_smart_data_get(o);
4273 ed->recalc_call = 1;
4274 _edje_recalc_do(ed);
4279 EINA_LIST_FOREACH(_edje_edjes, l, o)
4283 ed = evas_object_smart_data_get(o);
4288 ed->recalc_call = 1;
4289 _edje_recalc_do(ed);
4296 edje_perspective_global_set(Edje_Perspective *ps, Eina_Bool global)
4302 if (ps->global == global) return;
4305 o = evas_object_name_find(evas_object_evas_get(ps->obj),
4306 "_edje_perspective");
4307 if (o) evas_object_name_set(o, NULL);
4308 evas_object_name_set(ps->obj, "_edje_perspective");
4311 evas_object_name_set(ps->obj, NULL);
4312 ps->global = global;
4313 EINA_LIST_FOREACH(_edje_edjes, l, o)
4317 ed = evas_object_smart_data_get(o);
4322 ed->recalc_call = 1;
4323 _edje_recalc_do(ed);
4329 edje_perspective_global_get(const Edje_Perspective *ps)
4331 if (!ps) return EINA_FALSE;
4335 EAPI const Edje_Perspective *
4336 edje_evas_global_perspective_get(const Evas *e)
4340 if (!e) return NULL;
4341 obj = evas_object_name_find(e, "_edje_perspective");
4342 if (!obj) return NULL;
4343 return evas_object_data_get(obj, "_edje_perspective");
4347 edje_object_perspective_set(Evas_Object *obj, Edje_Perspective *ps)
4351 ed = evas_object_smart_data_get(obj);
4353 if (ed->persp == ps) return;
4354 if (ed->persp != ps)
4357 ed->persp->users = eina_list_remove(ed->persp->users, obj);
4360 if (ps) ps->users = eina_list_append(ps->users, obj);
4362 ed->recalc_call = 1;
4363 _edje_recalc_do(ed);
4366 EAPI const Edje_Perspective *
4367 edje_object_perspective_get(const Evas_Object *obj)
4371 ed = evas_object_smart_data_get(obj);
4372 if (!ed) return NULL;
4376 #define EDJE_PRELOAD_EMISSION "preload,done"
4377 #define EDJE_PRELOAD_SOURCE NULL
4380 edje_object_preload(Evas_Object *obj, Eina_Bool cancel)
4386 ed = _edje_fetch(obj);
4387 if (!ed) return EINA_FALSE;
4389 _edje_recalc_do(ed);
4391 for (i = 0, count = 0; i < ed->table_parts_size; i++)
4396 rp = ed->table_parts[i];
4399 if (ep->type == EDJE_PART_TYPE_IMAGE ||
4400 (ep->type == EDJE_PART_TYPE_GROUP && rp->swallowed_object))
4404 ed->preload_count = count;
4408 for (i = 0; i < ed->table_parts_size; i++)
4413 rp = ed->table_parts[i];
4416 if (ep->type == EDJE_PART_TYPE_IMAGE)
4418 const char *file = NULL;
4419 const char *key = NULL;
4421 evas_object_event_callback_del_full(rp->object, EVAS_CALLBACK_IMAGE_PRELOADED, _edje_object_image_preload_cb, ed);
4423 evas_object_image_file_get(rp->object, &file, &key);
4426 ed->preload_count--;
4430 evas_object_event_callback_add(rp->object, EVAS_CALLBACK_IMAGE_PRELOADED, _edje_object_image_preload_cb, ed);
4431 evas_object_image_preload(rp->object, cancel);
4435 else if (ep->type == EDJE_PART_TYPE_GROUP)
4437 if (rp->swallowed_object) {
4442 tmp = alloca(strlen(rp->part->name) + 2);
4443 sprintf(tmp, "%s:", rp->part->name);
4445 edje_object_signal_callback_del(obj, EDJE_PRELOAD_EMISSION, tmp, _edje_object_signal_preload_cb);
4446 edje_object_signal_callback_add(obj, EDJE_PRELOAD_EMISSION, tmp, _edje_object_signal_preload_cb, ed);
4447 edje_object_preload(rp->swallowed_object, cancel);
4451 ed->preload_count--;
4461 _edje_emit(ed, EDJE_PRELOAD_EMISSION, EDJE_PRELOAD_SOURCE);
4468 edje_object_update_hints_set(Evas_Object *obj, Eina_Bool update)
4472 ed = _edje_fetch(obj);
4474 if (ed->update_hints == !!update) return ;
4476 ed->update_hints = !!update;
4479 ed->recalc_hints = 1;
4485 edje_object_update_hints_get(Evas_Object *obj)
4489 ed = _edje_fetch(obj);
4490 if (!ed) return EINA_FALSE;
4492 return ed->update_hints;
4496 _edje_real_part_table_pack(Edje_Real_Part *rp, Evas_Object *child_obj, unsigned short col, unsigned short row, unsigned short colspan, unsigned short rowspan)
4499 evas_object_table_pack(rp->object, child_obj, col, row, colspan, rowspan);
4501 _edje_table_child_add(rp, child_obj);
4507 _edje_real_part_table_unpack(Edje_Real_Part *rp, Evas_Object *child_obj)
4509 Eina_Bool ret = evas_object_table_unpack(rp->object, child_obj);
4512 _edje_table_child_remove(rp, child_obj);
4518 _edje_real_part_table_clear(Edje_Real_Part *rp, Eina_Bool clear)
4520 Eina_List *children;
4522 children = evas_object_table_children_get(rp->object);
4525 Evas_Object *child_obj = children->data;
4527 _edje_table_child_remove(rp, child_obj);
4528 if (!evas_object_data_get(child_obj, "\377 edje.table_item"))
4530 evas_object_table_unpack(rp->object, child_obj);
4532 evas_object_del(child_obj);
4534 children = eina_list_remove_list(children, children);
4539 _edje_real_part_recursive_get(const Edje *ed, const char *part)
4544 path = eina_str_split(part, EDJE_PART_PATH_SEPARATOR_STRING, 0);
4545 if (!path) return NULL;
4547 rp = _edje_real_part_recursive_get_helper(ed, path);
4555 _edje_children_get(Edje_Real_Part *rp, const char *partid)
4562 if (!partid) return NULL;
4564 switch (rp->part->type)
4566 case EDJE_PART_TYPE_EXTERNAL:
4567 return _edje_external_content_get(rp->swallowed_object, partid);
4568 case EDJE_PART_TYPE_BOX:
4569 l = evas_object_box_children_get(rp->object);
4571 case EDJE_PART_TYPE_TABLE:
4572 l = evas_object_table_children_get(rp->object);
4578 v = strtol(partid, &p, 10);
4579 if ((*p == '\0') && (v >= 0))
4581 child = eina_list_nth(l, v);
4587 EINA_LIST_FREE(l, cur)
4589 const char *name = evas_object_name_get(cur);
4590 if ((name) && (!strcmp(name, partid)))
4602 /* rebuild alternative path */
4604 _edje_merge_path(const char *alias, char * const *path)
4607 unsigned int length = 1;
4608 unsigned int alias_length;
4611 if (!alias) return NULL;
4613 alias_length = strlen(alias);
4615 for (i = 0; path[i]; i++)
4616 length += strlen(path[i]) + 1;
4618 tmp = malloc(sizeof (char) * (length + alias_length + 2));
4619 memcpy(tmp, alias, alias_length);
4620 tmp[alias_length] = '\0';
4622 for (i = 0; path[i]; i++)
4624 strcat(tmp, EDJE_PART_PATH_SEPARATOR_STRING);
4625 strcat(tmp, path[i]);
4633 _edje_real_part_recursive_get_helper(const Edje *ed, char **path)
4642 if (ed->collection && ed->collection->alias)
4646 alias = _edje_merge_path(eina_hash_find(ed->collection->alias, path[0]), path + 1);
4648 rp = _edje_real_part_recursive_get(ed, alias);
4654 //printf(" lookup: %s on %s\n", path[0], ed->parent ? ed->parent : "-");
4655 idx = strchr(path[0], EDJE_PART_PATH_SEPARATOR_INDEXL);
4660 end = strchr(idx + 1, EDJE_PART_PATH_SEPARATOR_INDEXR);
4669 rp = _edje_real_part_get(ed, path[0]);
4670 if (!path[1] && !idx) return rp;
4671 if (!rp) return NULL;
4673 switch (rp->part->type)
4675 case EDJE_PART_TYPE_GROUP:
4676 if (!rp->swallowed_object) return NULL;
4677 ed = _edje_fetch(rp->swallowed_object);
4678 if (!ed) return NULL;
4680 return _edje_real_part_recursive_get_helper(ed, path);
4681 case EDJE_PART_TYPE_BOX:
4682 case EDJE_PART_TYPE_TABLE:
4683 case EDJE_PART_TYPE_EXTERNAL:
4684 if (!idx) return rp;
4687 child = _edje_children_get(rp, idx);
4689 ed = _edje_fetch(child);
4691 if (!ed) return NULL;
4692 return _edje_real_part_recursive_get_helper(ed, path);
4698 /* Private Routines */
4700 _edje_real_part_get(const Edje *ed, const char *part)
4704 if (!part) return NULL;
4706 for (i = 0; i < ed->table_parts_size; i++)
4710 rp = ed->table_parts[i];
4711 if ((rp->part->name) && (!strcmp(rp->part->name, part))) return rp;
4717 _edje_color_class_find(Edje *ed, const char *color_class)
4719 Edje_Color_Class *cc = NULL;
4721 if ((!ed) || (!color_class)) return NULL;
4723 /* first look through the object scope */
4724 cc = eina_hash_find(ed->color_classes, color_class);
4727 /* next look through the global scope */
4728 cc = eina_hash_find(_edje_color_class_hash, color_class);
4731 /* finally, look through the file scope */
4732 cc = eina_hash_find(ed->file->color_hash, color_class);
4739 _edje_color_class_member_add(Edje *ed, const char *color_class)
4741 _edje_class_member_add(ed, &ed->members.color_class, &_edje_color_class_member_hash, color_class);
4745 _edje_color_class_member_direct_del(const char *color_class, void *l)
4747 _edje_class_member_direct_del(color_class, l, _edje_color_class_member_hash);
4751 _edje_color_class_member_del(Edje *ed, const char *color_class)
4753 if ((!ed) || (!color_class)) return;
4755 _edje_class_member_del(&ed->members.color_class, &_edje_color_class_member_hash, color_class);
4759 _edje_color_class_members_free(void)
4761 if (!_edje_color_class_member_hash) return;
4762 eina_hash_foreach(_edje_color_class_member_hash, member_list_free, NULL);
4763 eina_hash_free(_edje_color_class_member_hash);
4764 _edje_color_class_member_hash = NULL;
4768 color_class_hash_list_free(const Eina_Hash *hash __UNUSED__, const void *key __UNUSED__, void *data, void *fdata __UNUSED__)
4770 Edje_Color_Class *cc;
4773 if (cc->name) eina_stringshare_del(cc->name);
4779 _edje_color_class_hash_free(void)
4781 if (!_edje_color_class_hash) return;
4782 eina_hash_foreach(_edje_color_class_hash, color_class_hash_list_free, NULL);
4783 eina_hash_free(_edje_color_class_hash);
4784 _edje_color_class_hash = NULL;
4788 _edje_color_class_on_del(Edje *ed, Edje_Part *ep)
4792 if ((ep->default_desc) && (ep->default_desc->color_class))
4793 _edje_color_class_member_del(ed, ep->default_desc->color_class);
4795 for (i = 0; i < ep->other.desc_count; ++i)
4796 if (ep->other.desc[i]->color_class)
4797 _edje_color_class_member_del(ed, ep->other.desc[i]->color_class);
4801 _edje_text_class_find(Edje *ed, const char *text_class)
4804 Edje_Text_Class *tc;
4806 if ((!ed) || (!text_class)) return NULL;
4807 EINA_LIST_FOREACH(ed->text_classes, l, tc)
4808 if ((tc->name) && (!strcmp(text_class, tc->name))) return tc;
4809 return eina_hash_find(_edje_text_class_hash, text_class);
4813 _edje_text_class_member_direct_del(const char *text_class,
4816 _edje_class_member_direct_del(text_class, l, _edje_text_class_member_hash);
4820 _edje_text_class_member_add(Edje *ed, const char *text_class)
4822 _edje_class_member_add(ed, &ed->members.text_class, &_edje_text_class_member_hash, text_class);
4826 _edje_text_class_member_del(Edje *ed, const char *text_class)
4828 if ((!ed) || (!text_class)) return;
4830 _edje_class_member_del(&ed->members.text_class, &_edje_text_class_member_hash, text_class);
4834 _edje_text_class_members_free(void)
4836 _edje_class_members_free(&_edje_text_class_member_hash);
4840 text_class_hash_list_free(const Eina_Hash *hash __UNUSED__, const void *key __UNUSED__, void *data, void *fdata __UNUSED__)
4842 Edje_Text_Class *tc;
4845 if (tc->name) eina_stringshare_del(tc->name);
4846 if (tc->font) eina_stringshare_del(tc->font);
4852 _edje_text_class_hash_free(void)
4854 if (!_edje_text_class_hash) return;
4855 eina_hash_foreach(_edje_text_class_hash, text_class_hash_list_free, NULL);
4856 eina_hash_free(_edje_text_class_hash);
4857 _edje_text_class_hash = NULL;
4861 _edje_fetch(const Evas_Object *obj)
4865 if (!evas_object_smart_type_check(obj, "edje"))
4867 ed = evas_object_smart_data_get(obj);
4868 if ((ed) && (ed->delete_me)) return NULL;
4873 _edje_freeze(Edje *ed)
4876 // printf("FREEZE %i\n", ed->freeze);
4881 _edje_thaw(Edje *ed)
4886 // printf("-------------########### OVER THAW\n");
4889 if ((ed->freeze == 0) && (ed->recalc))
4891 // printf("thaw recalc\n");
4898 _edje_block(Edje *ed)
4906 _edje_unblock(Edje *ed)
4910 if (!ed) return ret;
4913 if (ed->block == 0) ed->block_break = 0;
4920 _edje_block_break(Edje *ed)
4922 if (ed->block_break) return 1;
4927 _edje_block_violate(Edje *ed)
4929 if (ed->block > 0) ed->block_break = 1;
4933 _edje_object_part_swallow_free_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
4936 Edje_User_Defined *eud;
4941 EINA_LIST_FOREACH(rp->edje->user_defined, l, eud)
4942 if (eud->type == EDJE_USER_SWALLOW && eud->u.swallow.child == obj)
4944 _edje_user_definition_free(eud);
4952 _edje_real_part_swallow_hints_update(Edje_Real_Part *rp)
4956 type = evas_object_type_get(rp->swallowed_object);
4958 rp->swallow_params.min.w = 0;
4959 rp->swallow_params.min.h = 0;
4960 rp->swallow_params.max.w = -1;
4961 rp->swallow_params.max.h = -1;
4962 if ((type) && (!strcmp(type, "edje")))
4967 edje_object_size_min_get(rp->swallowed_object, &w, &h);
4968 rp->swallow_params.min.w = w;
4969 rp->swallow_params.min.h = h;
4971 edje_object_size_max_get(rp->swallowed_object, &w, &h);
4972 rp->swallow_params.max.w = w;
4973 rp->swallow_params.max.h = h;
4975 else if ((type) && ((!strcmp(type, "text")) || (!strcmp(type, "polygon")) ||
4976 (!strcmp(type, "line"))))
4980 evas_object_geometry_get(rp->swallowed_object, NULL, NULL, &w, &h);
4982 rp->swallow_params.min.w = w;
4983 rp->swallow_params.min.h = h;
4985 rp->swallow_params.max.w = w;
4986 rp->swallow_params.max.h = h;
4989 Evas_Coord w1, h1, w2, h2, aw, ah;
4990 Evas_Aspect_Control am;
4992 evas_object_size_hint_min_get(rp->swallowed_object, &w1, &h1);
4993 evas_object_size_hint_max_get(rp->swallowed_object, &w2, &h2);
4994 evas_object_size_hint_aspect_get(rp->swallowed_object, &am, &aw, &ah);
4995 rp->swallow_params.min.w = w1;
4996 rp->swallow_params.min.h = h1;
4997 if (w2 > 0) rp->swallow_params.max.w = w2;
4998 if (h2 > 0) rp->swallow_params.max.h = h2;
5001 case EVAS_ASPECT_CONTROL_NONE:
5002 rp->swallow_params.aspect.mode = EDJE_ASPECT_CONTROL_NONE;
5004 case EVAS_ASPECT_CONTROL_NEITHER:
5005 rp->swallow_params.aspect.mode = EDJE_ASPECT_CONTROL_NEITHER;
5007 case EVAS_ASPECT_CONTROL_HORIZONTAL:
5008 rp->swallow_params.aspect.mode = EDJE_ASPECT_CONTROL_HORIZONTAL;
5010 case EVAS_ASPECT_CONTROL_VERTICAL:
5011 rp->swallow_params.aspect.mode = EDJE_ASPECT_CONTROL_VERTICAL;
5013 case EVAS_ASPECT_CONTROL_BOTH:
5014 rp->swallow_params.aspect.mode = EDJE_ASPECT_CONTROL_BOTH;
5019 rp->swallow_params.aspect.w = aw;
5020 rp->swallow_params.aspect.h = ah;
5021 evas_object_data_set(rp->swallowed_object, "\377 edje.swallowing_part", rp);
5024 #ifdef EDJE_CALC_CACHE
5030 _edje_object_part_swallow_changed_hints_cb(void *data, __UNUSED__ Evas *e, __UNUSED__ Evas_Object *obj, __UNUSED__ void *event_info)
5035 _edje_real_part_swallow_hints_update(rp);
5036 rp->edje->dirty = 1;
5037 rp->edje->recalc_call = 1;
5038 _edje_recalc(rp->edje);
5043 _edje_real_part_swallow(Edje_Real_Part *rp,
5044 Evas_Object *obj_swallow,
5045 Eina_Bool hints_update)
5047 if (rp->swallowed_object)
5049 if (rp->swallowed_object != obj_swallow)
5051 edje_object_part_unswallow(rp->edje->obj, rp->swallowed_object);
5056 _edje_real_part_swallow_hints_update(rp);
5057 rp->edje->dirty = 1;
5058 rp->edje->recalc_call = 1;
5059 rp->edje->recalc_hints = 1;
5060 _edje_recalc(rp->edje);
5064 #ifdef EDJE_CALC_CACHE
5067 if (!obj_swallow) return;
5068 rp->swallowed_object = obj_swallow;
5069 evas_object_smart_member_add(rp->swallowed_object, rp->edje->obj);
5071 evas_object_clip_set(rp->swallowed_object, rp->clip_to->object);
5072 else evas_object_clip_set(rp->swallowed_object, rp->edje->base.clipper);
5073 evas_object_stack_above(rp->swallowed_object, rp->object);
5074 evas_object_event_callback_add(rp->swallowed_object,
5076 _edje_object_part_swallow_free_cb,
5078 evas_object_event_callback_add(rp->swallowed_object,
5079 EVAS_CALLBACK_CHANGED_SIZE_HINTS,
5080 _edje_object_part_swallow_changed_hints_cb,
5084 _edje_real_part_swallow_hints_update(rp);
5086 if (rp->part->mouse_events)
5088 _edje_callbacks_add(obj_swallow, rp->edje, rp);
5089 if (rp->part->repeat_events)
5090 evas_object_repeat_events_set(obj_swallow, 1);
5091 if (rp->part->pointer_mode != EVAS_OBJECT_POINTER_MODE_AUTOGRAB)
5092 evas_object_pointer_mode_set(obj_swallow, rp->part->pointer_mode);
5093 evas_object_pass_events_set(obj_swallow, 0);
5096 evas_object_pass_events_set(obj_swallow, 1);
5097 _edje_callbacks_focus_add(rp->swallowed_object, rp->edje, rp);
5099 if (rp->part->precise_is_inside)
5100 evas_object_precise_is_inside_set(obj_swallow, 1);
5102 rp->edje->dirty = 1;
5103 rp->edje->recalc_call = 1;
5104 rp->edje->recalc_hints = 1;
5105 _edje_recalc(rp->edje);
5109 _edje_real_part_swallow_clear(Edje_Real_Part *rp)
5111 evas_object_smart_member_del(rp->swallowed_object);
5112 evas_object_event_callback_del_full(rp->swallowed_object,
5114 _edje_object_part_swallow_free_cb,
5116 evas_object_event_callback_del_full(rp->swallowed_object,
5117 EVAS_CALLBACK_CHANGED_SIZE_HINTS,
5118 _edje_object_part_swallow_changed_hints_cb,
5120 evas_object_clip_unset(rp->swallowed_object);
5121 evas_object_data_del(rp->swallowed_object, "\377 edje.swallowing_part");
5122 if (rp->part->mouse_events)
5123 _edje_callbacks_del(rp->swallowed_object, rp->edje);
5124 _edje_callbacks_focus_del(rp->swallowed_object, rp->edje);
5125 rp->swallowed_object = NULL;
5129 _edje_object_preload(Edje *ed)
5131 ed->preload_count--;
5132 if (!ed->preload_count)
5133 _edje_emit(ed, EDJE_PRELOAD_EMISSION, EDJE_PRELOAD_SOURCE);
5137 _edje_object_image_preload_cb(void *data, __UNUSED__ Evas *e, Evas_Object *obj, __UNUSED__ void *event_info)
5141 evas_object_event_callback_del_full(obj, EVAS_CALLBACK_IMAGE_PRELOADED, _edje_object_image_preload_cb, ed);
5142 _edje_object_preload(ed);
5146 _edje_object_signal_preload_cb(void *data, Evas_Object *obj, __UNUSED__ const char *emission, __UNUSED__ const char *source)
5150 edje_object_signal_callback_del(obj, EDJE_PRELOAD_EMISSION, EDJE_PRELOAD_SOURCE, _edje_object_signal_preload_cb);
5151 _edje_object_preload(ed);
5160 _edje_program_remove(Edje_Part_Collection *edc, Edje_Program *p)
5162 Edje_Program ***array;
5163 unsigned int *count;
5166 if (!p->signal && !p->source)
5168 array = &edc->programs.nocmp;
5169 count = &edc->programs.nocmp_count;
5171 else if (p->signal && !strpbrk(p->signal, "*?[\\")
5172 && p->source && !strpbrk(p->source, "*?[\\"))
5174 array = &edc->programs.strcmp;
5175 count = &edc->programs.strcmp_count;
5177 else if (p->signal && edje_program_is_strncmp(p->signal)
5178 && p->source && edje_program_is_strncmp(p->source))
5180 array = &edc->programs.strncmp;
5181 count = &edc->programs.strncmp_count;
5183 else if (p->signal && edje_program_is_strrncmp(p->signal)
5184 && p->source && edje_program_is_strrncmp(p->source))
5186 array = &edc->programs.strrncmp;
5187 count = &edc->programs.strrncmp_count;
5191 array = &edc->programs.fnmatch;
5192 count = &edc->programs.fnmatch_count;
5195 for (i = 0; i < *count; ++i)
5196 if ((*array)[i] == p)
5198 memmove(*array + i, *array + i + 1, sizeof (Edje_Program *) * (*count - i -1));
5210 _edje_program_insert(Edje_Part_Collection *edc, Edje_Program *p)
5212 Edje_Program ***array;
5213 unsigned int *count;
5215 if (!p->signal && !p->source)
5217 array = &edc->programs.nocmp;
5218 count = &edc->programs.nocmp_count;
5220 else if (p->signal && !strpbrk(p->signal, "*?[\\")
5221 && p->source && !strpbrk(p->source, "*?[\\"))
5223 array = &edc->programs.strcmp;
5224 count = &edc->programs.strcmp_count;
5226 else if (p->signal && edje_program_is_strncmp(p->signal)
5227 && p->source && edje_program_is_strncmp(p->source))
5229 array = &edc->programs.strncmp;
5230 count = &edc->programs.strncmp_count;
5232 else if (p->signal && edje_program_is_strrncmp(p->signal)
5233 && p->source && edje_program_is_strrncmp(p->source))
5235 array = &edc->programs.strrncmp;
5236 count = &edc->programs.strrncmp_count;
5240 array = &edc->programs.fnmatch;
5241 count = &edc->programs.fnmatch_count;
5244 *array = realloc(*array, sizeof (Edje_Program *) * (*count + 1));
5245 (*array)[(*count)++] = p;
5249 edje_string_get(const Edje_String *es)
5251 /* FIXME: Handle localization here */
5252 if (!es) return NULL;
5257 edje_string_id_get(const Edje_String *es)
5259 /* FIXME: Handle localization here */
5260 if (!es) return NULL;
5265 _cb_subobj_del(void *data, __UNUSED__ Evas *e, Evas_Object *obj, __UNUSED__ void *event_info)
5268 _edje_subobj_unregister(ed, obj);
5272 _edje_subobj_register(Edje *ed, Evas_Object *ob)
5274 ed->subobjs = eina_list_append(ed->subobjs, ob);
5275 evas_object_event_callback_add(ob, EVAS_CALLBACK_DEL,
5276 _cb_subobj_del, ed);
5280 _edje_subobj_unregister(Edje *ed, Evas_Object *obj)
5282 ed->subobjs = eina_list_remove(ed->subobjs, obj);
5283 evas_object_event_callback_del_full(obj, EVAS_CALLBACK_DEL,
5284 _cb_subobj_del, ed);
5287 /* vim:set ts=8 sw=3 sts=3 expandtab cino=>5n-2f0^-2{2(0W1st0 :*/