setlocale(LC_NUMERIC, "C");
+ eina_init();
+
progname = argv[0];
for (i = 1; i < argc; i++)
{
edje_shutdown();
+ eina_shutdown();
+
return 0;
}
eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
eddc.func.mem_alloc = NULL;
eddc.func.mem_free = NULL;
- eddc.func.str_alloc = evas_stringshare_add;
- eddc.func.str_free = evas_stringshare_del;
+ eddc.func.str_alloc = eina_stringshare_add;
+ eddc.func.str_free = eina_stringshare_del;
eddc.func.list_next = evas_list_next;
eddc.func.list_append = evas_list_append;
eddc.func.list_data = evas_list_data;
free(data);
}
- edc->part = evas_stringshare_add(coll);
+ edc->part = eina_stringshare_add(coll);
edc->references = 1;
edf->collection_hash = evas_hash_add(edf->collection_hash, coll, edc);
return edc;
tmp = alloca(length);
snprintf(tmp, length, "fonts/%s", fnt->entry);
- fnt->path = evas_stringshare_add(tmp);
+ fnt->path = eina_stringshare_add(tmp);
if (edf->free_strings)
- evas_stringshare_del(fnt->entry);
+ eina_stringshare_del(fnt->entry);
fnt->entry = fnt->path + 6;
edf->font_hash = evas_hash_direct_add(edf->font_hash, fnt->entry, fnt);
return NULL;
}
- edf->path = evas_stringshare_add(file);
+ edf->path = eina_stringshare_add(file);
edf->references = 1;
_edje_textblock_style_parse_and_fix(edf);
for (l = edf->data; l; l = l->next)
{
Edje_Data *di = l->data;
- edf->data_cache = evas_hash_add(edf->data_cache, evas_stringshare_add(di->key), di->value);
+ edf->data_cache = evas_hash_add(edf->data_cache, eina_stringshare_add(di->key), di->value);
}
if (coll)
eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
eddc.func.mem_alloc = NULL;
eddc.func.mem_free = NULL;
- eddc.func.str_alloc = (char *(*)(const char *))evas_stringshare_add;
- eddc.func.str_free = evas_stringshare_del;
+ eddc.func.str_alloc = (char *(*)(const char *))eina_stringshare_add;
+ eddc.func.str_free = eina_stringshare_del;
eddc.func.list_next = (void *(*)(void *))evas_list_next;
eddc.func.list_append = (void *(*)(void *, void *))evas_list_append;
eddc.func.list_data = (void *(*)(void *))evas_list_data;
rp->swallowed_object = NULL;
}
- if (rp->text.text) evas_stringshare_del(rp->text.text);
- if (rp->text.font) evas_stringshare_del(rp->text.font);
- if (rp->text.cache.in_str) evas_stringshare_del(rp->text.cache.in_str);
- if (rp->text.cache.out_str) evas_stringshare_del(rp->text.cache.out_str);
+ if (rp->text.text) eina_stringshare_del(rp->text.text);
+ if (rp->text.font) eina_stringshare_del(rp->text.font);
+ if (rp->text.cache.in_str) eina_stringshare_del(rp->text.cache.in_str);
+ if (rp->text.cache.out_str) eina_stringshare_del(rp->text.cache.out_str);
if (rp->custom.description)
_edje_collection_free_part_description_free(rp->custom.description, 0);
dict = eet_dictionary_get(ed->file->ef);
if (eet_dictionary_string_check(dict, str)) return;
- evas_stringshare_del(str);
+ eina_stringshare_del(str);
str = NULL;
}
//printf("FREE LIST: \n");
while (lst)
{
- if (lst->data) evas_stringshare_del(lst->data);
+ if (lst->data) eina_stringshare_del(lst->data);
//printf("FREE: %s\n", lst->data);
lst = evas_list_remove(lst, lst->data);
}
EAPI void
edje_edit_string_free(const char *str)
{
- if (str) evas_stringshare_del(str);
+ if (str) eina_stringshare_del(str);
}
EAPI const char*
edje_edit_compiler_get(Evas_Object *obj)
{
GET_ED_OR_RETURN(0);
- return evas_stringshare_add(ed->file->compiler);
+ return eina_stringshare_add(ed->file->compiler);
}
/****************/
pc->parts = NULL;
pc->data = NULL;
pc->script = NULL;
- pc->part = evas_stringshare_add(name);
+ pc->part = eina_stringshare_add(name);
//cd = mem_alloc(SZ(Code));
//codes = evas_list_append(codes, cd);
printf("Set name of current group: %s [id: %d][new name: %s]\n",
pc->part, pc->id, new_name);
- //if (pc->part && ed->file->free_strings) evas_stringshare_del(pc->part); TODO FIXME
- pc->part = evas_stringshare_add(new_name);
+ //if (pc->part && ed->file->free_strings) eina_stringshare_del(pc->part); TODO FIXME
+ pc->part = eina_stringshare_add(new_name);
for (l = ed->file->collection_dir->entries; l; l = l->next)
{
//if (pce->entry && //TODO Also this cause segv
// !eet_dictionary_string_check(eet_dictionary_get(ed->file->ef), pce->entry))
- // evas_stringshare_del(pce->entry);
- pce->entry = evas_stringshare_add(new_name);
+ // eina_stringshare_del(pce->entry);
+ pce->entry = eina_stringshare_add(new_name);
return 1;
}
for (l = ed->file->data; l; l = l->next)
{
Edje_Data *d = l->data;
- datas = evas_list_append(datas, evas_stringshare_add(d->key));
+ datas = evas_list_append(datas, eina_stringshare_add(d->key));
}
return datas;
d = mem_alloc(sizeof(Edje_Data));
if (!d) return 0;
- d->key = (char*)evas_stringshare_add(itemname);
- if (value) d->value = (char*)evas_stringshare_add(value);
+ d->key = (char*)eina_stringshare_add(itemname);
+ if (value) d->value = (char*)eina_stringshare_add(value);
else d->value = NULL;
ed->file->data = evas_list_append(ed->file->data, d);
{
Edje_Data *d = l->data;
if (strcmp(d->key, itemname) == 0)
- return evas_stringshare_add(d->value);
+ return eina_stringshare_add(d->value);
}
return NULL;
if (strcmp(d->key, itemname) == 0)
{
_edje_if_string_free(ed, d->value);
- d->value = (char*)evas_stringshare_add(value);
+ d->value = (char*)eina_stringshare_add(value);
return 1;
}
}
if (strcmp(d->key, itemname) == 0)
{
_edje_if_string_free(ed, d->key);
- d->key = (char*)evas_stringshare_add(newname);
+ d->key = (char*)eina_stringshare_add(newname);
return 1;
}
}
Edje_Color_Class *cc;
cc = l->data;
- classes = evas_list_append(classes, evas_stringshare_add(cc->name));
+ classes = evas_list_append(classes, eina_stringshare_add(cc->name));
}
return classes;
c = mem_alloc(sizeof(Edje_Color_Class));
if (!c) return 0;
- c->name = (char*)evas_stringshare_add(name);
+ c->name = (char*)eina_stringshare_add(name);
c->r = c->g = c->b = c->a = 255;
c->r2 = c->g2 = c->b2 = c->a2 = 255;
c->r3 = c->g3 = c->b3 = c->a3 = 255;
if (!strcmp(cc->name, name))
{
_edje_if_string_free(ed, cc->name);
- cc->name = (char*)evas_stringshare_add(newname);
+ cc->name = (char*)eina_stringshare_add(newname);
return 1;
}
}
Edje_Real_Part *rp;
rp = ed->table_parts[i];
- parts = evas_list_append(parts, evas_stringshare_add(rp->part->name));
+ parts = evas_list_append(parts, eina_stringshare_add(rp->part->name));
}
return parts;
printf("Set name of part: %s [new name: %s]\n", part, new_name);
_edje_if_string_free(ed, rp->part->name);
- rp->part->name = (char *)evas_stringshare_add(new_name);
+ rp->part->name = (char *)eina_stringshare_add(new_name);
return 1;
}
ep->id = evas_list_count(pc->parts) - 1;
ep->type = type;
- ep->name = evas_stringshare_add(name);
+ ep->name = eina_stringshare_add(name);
ep->mouse_events = 1;
ep->repeat_events = 0;
ep->ignore_flags = EVAS_EVENT_FLAG_NONE;
rp->chosen_description->state.name,
rp->chosen_description->state.value);
- return evas_stringshare_add(name);
+ return eina_stringshare_add(name);
}
EAPI unsigned char
clip = ed->table_parts[rp->part->clip_to_id % ed->table_parts_size];
if (!clip || !clip->part || !clip->part->name) return NULL;
- return evas_stringshare_add(clip->part->name);
+ return eina_stringshare_add(clip->part->name);
}
EAPI unsigned char
printf("Get source for part: %s\n", part);
if (!rp->part->source) return NULL;
- return evas_stringshare_add(rp->part->source);
+ return eina_stringshare_add(rp->part->source);
}
EAPI unsigned char
_edje_if_string_free(ed, rp->part->source);
if (source)
- rp->part->source = evas_stringshare_add(source);
+ rp->part->source = eina_stringshare_add(source);
return 1;
}
return NULL;
confine = ed->table_parts[rp->part->dragable.confine_id];
- return evas_stringshare_add(confine->part->name);
+ return eina_stringshare_add(confine->part->name);
}
EAPI void
return NULL;
events = ed->table_parts[rp->part->dragable.events_id];
- return evas_stringshare_add(events->part->name);
+ return eina_stringshare_add(events->part->name);
}
EAPI void
state = rp->part->default_desc;
snprintf(state_name, PATH_MAX,
"%s %.2f", state->state.name, state->state.value);
- states = evas_list_append(states, evas_stringshare_add(state_name));
+ states = evas_list_append(states, eina_stringshare_add(state_name));
//printf("NEW STATE def: %s\n", state->state.name);
//append other states
state = l->data;
snprintf(state_name, sizeof(state_name),
"%s %.2f", state->state.name, state->state.value);
- states = evas_list_append(states, evas_stringshare_add(state_name));
+ states = evas_list_append(states, eina_stringshare_add(state_name));
//printf("NEW STATE: %s\n", state_name);
}
return states;
pd->state.value == epr->value)
{
_edje_if_string_free(ed, epr->state);
- epr->state = evas_stringshare_add(new_name);
+ epr->state = eina_stringshare_add(new_name);
epr->value = value;
}
}
/* set name */
_edje_if_string_free(ed, pd->state.name);
- pd->state.name = (char *)evas_stringshare_add(new_name);
+ pd->state.name = (char *)eina_stringshare_add(new_name);
/* set value */
pd->state.value = value;
else
rp->part->other_desc = evas_list_append(rp->part->other_desc, pd);
- pd->state.name = evas_stringshare_add(name);
+ pd->state.name = eina_stringshare_add(name);
pd->state.value = 0.0;
pd->visible = 1;
pd->align.x = 0.5;
rel = ed->table_parts[pd->rel1.id_x % ed->table_parts_size];
if (rel->part->name)
- return evas_stringshare_add(rel->part->name);
+ return eina_stringshare_add(rel->part->name);
else
return NULL;
}
rel = ed->table_parts[pd->rel1.id_y % ed->table_parts_size];
if (rel->part->name)
- return evas_stringshare_add(rel->part->name);
+ return eina_stringshare_add(rel->part->name);
else
return NULL;
}
rel = ed->table_parts[pd->rel2.id_x % ed->table_parts_size];
if (rel->part->name)
- return evas_stringshare_add(rel->part->name);
+ return eina_stringshare_add(rel->part->name);
else
return NULL;
}
rel = ed->table_parts[pd->rel2.id_y % ed->table_parts_size];
if (rel->part->name)
- return evas_stringshare_add(rel->part->name);
+ return eina_stringshare_add(rel->part->name);
else
return NULL;
}
{
GET_PD_OR_RETURN(NULL);
printf("Get ColorClass of part: %s state: %s\n", part, state);
- return evas_stringshare_add(pd->color_class);
+ return eina_stringshare_add(pd->color_class);
}
EAPI void
GET_PD_OR_RETURN();
printf("Set ColorClass of part: %s state: %s [to: %s]\n", part, state, color_class);
_edje_if_string_free(ed, pd->color_class);
- pd->color_class = (char*)evas_stringshare_add(color_class);
+ pd->color_class = (char*)eina_stringshare_add(color_class);
}
/**************/
//printf("GET TEXT of state: %s\n", state);
if (pd->text.text)
- return evas_stringshare_add(pd->text.text);
+ return eina_stringshare_add(pd->text.text);
return NULL;
}
if (!text) return;
_edje_if_string_free(ed, pd->text.text);
- pd->text.text = (char *)evas_stringshare_add(text);
+ pd->text.text = (char *)eina_stringshare_add(text);
edje_object_calc_force(obj);
}
for (l = ed->file->font_dir->entries; l; l = l->next)
{
f = l->data;
- fonts = evas_list_append(fonts, evas_stringshare_add(f->entry));
+ fonts = evas_list_append(fonts, eina_stringshare_add(f->entry));
printf(" Font: %s (%s) \n", f->entry, f->path);
}
printf("GET FONT of state: %s [%s]\n", state, pd->text.font);
if (!pd->text.font) return NULL;
- return evas_stringshare_add(pd->text.font);
+ return eina_stringshare_add(pd->text.font);
}
EAPI void
printf("SET FONT of state: %s [%s]\n", state, font);
_edje_if_string_free(ed, pd->text.font);
- pd->text.font = (char *)evas_stringshare_add(font);
+ pd->text.font = (char *)eina_stringshare_add(font);
edje_object_calc_force(obj);
}
for (l = ed->file->image_dir->entries; l; l = l->next)
{
i = l->data;
- images = evas_list_append(images, evas_stringshare_add(i->entry));
+ images = evas_list_append(images, eina_stringshare_add(i->entry));
//printf(" Image: %s (type: %d param: %d id: %d) \n",
// i->entry, i->source_type, i->source_param, i->id);
}
if (!image) return NULL;
//printf("GET IMAGE for %s [%s]\n", state, image);
- return evas_stringshare_add(image);
+ return eina_stringshare_add(image);
}
EAPI void
i = l->data;
name = _edje_image_name_find(obj, i->id);
//printf(" t: %s\n", name);
- tweens = evas_list_append(tweens, evas_stringshare_add(name));
+ tweens = evas_list_append(tweens, eina_stringshare_add(name));
}
return tweens;
{
s = l->data;
//printf("SPECTRUM: %s [id: %d]\n", s->entry, s->id);
- spectrum = evas_list_append(spectrum, evas_stringshare_add(s->entry));
+ spectrum = evas_list_append(spectrum, eina_stringshare_add(s->entry));
}
return spectrum;
s = mem_alloc(SZ(Edje_Spectrum_Directory_Entry));
ed->file->spectrum_dir->entries = evas_list_append(ed->file->spectrum_dir->entries, s);
s->id = evas_list_count(ed->file->spectrum_dir->entries) - 1; //TODO Search for id holes
- s->entry = (char*)evas_stringshare_add(name);
+ s->entry = (char*)eina_stringshare_add(name);
s->filename = NULL;
s->color_list = NULL;
if (!s) return 0;
_edje_if_string_free(ed, s->entry);
- s->entry = (char*)evas_stringshare_add(name);
+ s->entry = (char*)eina_stringshare_add(name);
return 1;
}
// printf("GET GRADIENT TYPE for part: %s state: %s [%s]\n", part, state, pd->gradient.type);
- return evas_stringshare_add(pd->gradient.type);
+ return eina_stringshare_add(pd->gradient.type);
}
EAPI unsigned char
// printf("SET GRADIENT TYPE for part: %s state: %s TO: %s\n", part, state, type);
_edje_if_string_free(ed, pd->gradient.type);
- pd->gradient.type = (char *)evas_stringshare_add(type);
+ pd->gradient.type = (char *)eina_stringshare_add(type);
edje_object_calc_force(obj);
return 1;
}
s = _edje_edit_spectrum_entry_get_by_id(ed, pd->gradient.id);
if (!s) return 0;
- return evas_stringshare_add(s->entry);
+ return eina_stringshare_add(s->entry);
}
EAPI unsigned char
Edje_Program *epr;
epr = ed->table_programs[i];
- progs = evas_list_append(progs, evas_stringshare_add(epr->name));
+ progs = evas_list_append(progs, eina_stringshare_add(epr->name));
}
return progs;
//Init Edje_Program
epr->id = evas_list_count(pc->programs) - 1;
- epr->name = evas_stringshare_add(name);
+ epr->name = eina_stringshare_add(name);
epr->signal = NULL;
epr->source = NULL;
epr->in.from = 0.0;
printf("SET NAME for program: %s [new name: %s]\n", prog, new_name);
_edje_if_string_free(ed, epr->name);
- epr->name = evas_stringshare_add(new_name);
+ epr->name = eina_stringshare_add(new_name);
return 1;
}
if (!epr->source) return NULL;
//printf("GET SOURCE for program: %s [%s]\n", prog, epr->source);
- return evas_stringshare_add(epr->source);
+ return eina_stringshare_add(epr->source);
}
EAPI unsigned char
printf("SET SOURCE for program: %s [%s]\n", prog, source);
_edje_if_string_free(ed, epr->source);
- epr->source = evas_stringshare_add(source);
+ epr->source = eina_stringshare_add(source);
//Update patterns
if (ed->patterns.programs.sources_patterns)
if (!epr->signal) return NULL;
//printf("GET SIGNAL for program: %s [%s]\n", prog, epr->signal);
- return evas_stringshare_add(epr->signal);
+ return eina_stringshare_add(epr->signal);
}
EAPI unsigned char
printf("SET SIGNAL for program: %s [%s]\n", prog, signal);
_edje_if_string_free(ed, epr->signal);
- epr->signal = evas_stringshare_add(signal);
+ epr->signal = eina_stringshare_add(signal);
//Update patterns
if (ed->patterns.programs.signals_patterns)
if (!epr->state) return NULL;
//printf("GET STATE for program: %s [%s %.2f]\n", prog, epr->state, epr->value);
- return evas_stringshare_add(epr->state);
+ return eina_stringshare_add(epr->state);
}
EAPI unsigned char
printf("SET STATE for program: %s\n", prog);
_edje_if_string_free(ed, epr->state);
- epr->state = evas_stringshare_add(state);
+ epr->state = eina_stringshare_add(state);
return 1;
}
if (!epr->state2) return NULL;
//printf("GET STATE2 for program: %s [%s %.2f]\n", prog, epr->state2, epr->value2);
- return evas_stringshare_add(epr->state2);
+ return eina_stringshare_add(epr->state2);
}
EAPI unsigned char
printf("SET STATE2 for program: %s\n", prog);
_edje_if_string_free(ed, epr->state2);
- epr->state2 = evas_stringshare_add(state2);
+ epr->state2 = eina_stringshare_add(state2);
return 1;
}
p = ed->table_parts[t->id % ed->table_parts_size];
if (p && p->part && p->part->name)
targets = evas_list_append(targets,
- evas_stringshare_add(p->part->name));
+ eina_stringshare_add(p->part->name));
}
else if (epr->action == EDJE_ACTION_TYPE_ACTION_STOP)
{
p = ed->table_programs[t->id % ed->table_programs_size];
if (p && p->name)
targets = evas_list_append(targets,
- evas_stringshare_add(p->name));
+ eina_stringshare_add(p->name));
}
}
return targets;
if (p && p->name)
{
printf(" a: %d name: %s\n", a->id, p->name);
- afters = evas_list_append(afters, evas_stringshare_add(p->name));
+ afters = evas_list_append(afters, eina_stringshare_add(p->name));
}
}
return afters;
fclose(f);
- return evas_stringshare_add(tmpn);
+ return eina_stringshare_add(tmpn);
}
eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
eddc.func.mem_alloc = NULL;
eddc.func.mem_free = NULL;
- eddc.func.str_alloc = evas_stringshare_add;
- eddc.func.str_free = evas_stringshare_del;
+ eddc.func.str_alloc = eina_stringshare_add;
+ eddc.func.str_free = eina_stringshare_del;
eddc.func.list_next = evas_list_next;
eddc.func.list_append = evas_list_append;
eddc.func.list_data = evas_list_data;
/* Clear stuff */
unlink(source_file);
- evas_stringshare_del(source_file);
+ eina_stringshare_del(source_file);
eet_close(eetf);
printf("*********** Saving DONE ******************\n");
return 1;
*d = *parent;
- d->state.name = (char *)evas_stringshare_add("custom");
+ d->state.name = (char *)eina_stringshare_add("custom");
d->state.value = 0.0;
/* make sure all the allocated memory is getting copied,
d->image.tween_list = evas_list_append(d->image.tween_list, iid_new);
}
-#define DUP(x) x ? (char *)evas_stringshare_add(x) : NULL
+#define DUP(x) x ? (char *)eina_stringshare_add(x) : NULL
d->color_class = DUP(d->color_class);
d->text.text = DUP(d->text.text);
d->text.text_class = DUP(d->text.text_class);
Edje_Part_Collection_Directory_Entry *ce;
ce = l->data;
- lst = evas_list_append(lst, evas_stringshare_add(ce->entry));
+ lst = evas_list_append(lst, eina_stringshare_add(ce->entry));
}
}
_edje_cache_file_unref(edf);
{
while (lst)
{
- if (lst->data) evas_stringshare_del(lst->data);
+ if (lst->data) eina_stringshare_del(lst->data);
lst = evas_list_remove(lst, lst->data);
}
}
if (_edje_script_only(ed)) _edje_script_only_shutdown(ed);
_edje_file_del(ed);
- if (ed->path) evas_stringshare_del(ed->path);
- if (ed->group) evas_stringshare_del(ed->group);
- ed->path = evas_stringshare_add(file);
- ed->group = evas_stringshare_add(group);
+ if (ed->path) eina_stringshare_del(ed->path);
+ if (ed->group) eina_stringshare_del(ed->group);
+ ed->path = eina_stringshare_add(file);
+ ed->group = eina_stringshare_add(group);
ed->load_error = EDJE_LOAD_ERROR_NONE;
_edje_file_add(ed);
Evas_List *l;
Evas_Object *child_obj;
Edje *child_ed;
- const char *group_path_entry = evas_stringshare_add(rp->part->source);
+ const char *group_path_entry = eina_stringshare_add(rp->part->source);
if (!group_path)
{
- group_path = evas_list_append(NULL, evas_stringshare_add(group));
+ group_path = evas_list_append(NULL, eina_stringshare_add(group));
group_path_started = 1;
}
/* make sure that this group isn't already in the tree of parents */
_edje_unblock(ed);
_edje_unref(ed);
_edje_file_del(ed);
- evas_stringshare_del(group_path_entry);
+ eina_stringshare_del(group_path_entry);
if (group_path_started)
{
- evas_stringshare_del(group_path->data);
+ eina_stringshare_del(group_path->data);
evas_list_free(group_path);
}
ed->load_error = EDJE_LOAD_ERROR_RECURSIVE_REFERENCE;
{
while (group_path)
{
- evas_stringshare_del(group_path->data);
+ eina_stringshare_del(group_path->data);
group_path = evas_list_remove_list(group_path, group_path);
}
}
return 0;
}
child_ed = _edje_fetch(child_obj);
- child_ed->parent = evas_stringshare_add(rp->part->name);
+ child_ed->parent = eina_stringshare_add(rp->part->name);
group_path = evas_list_remove(group_path, group_path_entry);
- evas_stringshare_del(group_path_entry);
+ eina_stringshare_del(group_path_entry);
edje_object_signal_callback_add(child_obj, "*", "*", _cb_signal_repeat, obj);
_edje_real_part_swallow(rp, child_obj);
{
while (group_path)
{
- evas_stringshare_del(group_path->data);
+ eina_stringshare_del(group_path->data);
group_path = evas_list_remove_list(group_path, group_path);
}
}
old_swallows = evas_list_remove_list(old_swallows, old_swallows);
edje_object_part_swallow(obj, name, swallow);
- evas_stringshare_del(name);
+ eina_stringshare_del(name);
}
}
rp = ed->table_parts[i];
if (rp->part->type != EDJE_PART_TYPE_SWALLOW || !rp->swallowed_object) continue;
- swallows = evas_list_append(swallows, evas_stringshare_add(rp->part->name));
+ swallows = evas_list_append(swallows, eina_stringshare_add(rp->part->name));
swallows = evas_list_append(swallows, rp->swallowed_object);
}
return swallows;
rp->swallowed_object = NULL;
}
- if (rp->text.text) evas_stringshare_del(rp->text.text);
- if (rp->text.font) evas_stringshare_del(rp->text.font);
- if (rp->text.cache.in_str) evas_stringshare_del(rp->text.cache.in_str);
- if (rp->text.cache.out_str) evas_stringshare_del(rp->text.cache.out_str);
+ if (rp->text.text) eina_stringshare_del(rp->text.text);
+ if (rp->text.font) eina_stringshare_del(rp->text.font);
+ if (rp->text.cache.in_str) eina_stringshare_del(rp->text.cache.in_str);
+ if (rp->text.cache.out_str) eina_stringshare_del(rp->text.cache.out_str);
if (rp->custom.description)
_edje_collection_free_part_description_free(rp->custom.description, ed->file->free_strings);
Edje_File *edf;
edf = fdata;
- if (edf->free_strings) evas_stringshare_del(data);
+ if (edf->free_strings) eina_stringshare_del(data);
return 1;
}
edf->font_dir->entries =
evas_list_remove_list(edf->font_dir->entries, edf->font_dir->entries);
edf->font_hash = evas_hash_del(edf->font_hash, fe->entry, edf);
- if (edf->free_strings && fe->path) evas_stringshare_del(fe->path);
+ if (edf->free_strings && fe->path) eina_stringshare_del(fe->path);
free(fe);
}
free(edf->font_dir);
ie = edf->image_dir->entries->data;
edf->image_dir->entries =
evas_list_remove_list(edf->image_dir->entries, edf->image_dir->entries);
- if (edf->free_strings && ie->entry) evas_stringshare_del(ie->entry);
+ if (edf->free_strings && ie->entry) eina_stringshare_del(ie->entry);
free(ie);
}
free(edf->image_dir);
ce = edf->collection_dir->entries->data;
edf->collection_dir->entries =
evas_list_remove_list(edf->collection_dir->entries, edf->collection_dir->entries);
- if (edf->free_strings && ce->entry) evas_stringshare_del(ce->entry);
+ if (edf->free_strings && ce->entry) eina_stringshare_del(ce->entry);
free(ce);
}
free(edf->collection_dir);
}
if (edf->free_strings)
{
- if (se->entry) evas_stringshare_del(se->entry);
- if (se->filename) evas_stringshare_del(se->filename);
+ if (se->entry) eina_stringshare_del(se->entry);
+ if (se->filename) eina_stringshare_del(se->filename);
}
free(se);
}
edf->data = evas_list_remove(edf->data, edt);
if (edf->free_strings)
{
- if (edt->key) evas_stringshare_del(edt->key);
- if (edt->value) evas_stringshare_del(edt->value);
+ if (edt->key) eina_stringshare_del(edt->key);
+ if (edt->value) eina_stringshare_del(edt->value);
}
free(edt);
}
ecc = edf->color_classes->data;
edf->color_classes =
evas_list_remove_list(edf->color_classes, edf->color_classes);
- if (edf->free_strings && ecc->name) evas_stringshare_del(ecc->name);
+ if (edf->free_strings && ecc->name) eina_stringshare_del(ecc->name);
free(ecc);
}
_edje_file_collection_hash_foreach, edf);
evas_hash_free(edf->collection_hash);
}
- if (edf->path) evas_stringshare_del(edf->path);
- if (edf->free_strings && edf->compiler) evas_stringshare_del(edf->compiler);
+ if (edf->path) eina_stringshare_del(edf->path);
+ if (edf->free_strings && edf->compiler) eina_stringshare_del(edf->compiler);
if (edf->collection_cache) _edje_cache_coll_flush(edf);
_edje_textblock_style_cleanup(edf);
if (edf->ef) eet_close(edf->ef);
ec->programs = evas_list_remove_list(ec->programs, ec->programs);
if (edf->free_strings)
{
- if (pr->name) evas_stringshare_del(pr->name);
- if (pr->signal) evas_stringshare_del(pr->signal);
- if (pr->source) evas_stringshare_del(pr->source);
- if (pr->state) evas_stringshare_del(pr->state);
- if (pr->state2) evas_stringshare_del(pr->state2);
+ if (pr->name) eina_stringshare_del(pr->name);
+ if (pr->signal) eina_stringshare_del(pr->signal);
+ if (pr->source) eina_stringshare_del(pr->source);
+ if (pr->state) eina_stringshare_del(pr->state);
+ if (pr->state2) eina_stringshare_del(pr->state2);
}
while (pr->targets)
{
ep = ec->parts->data;
ec->parts = evas_list_remove(ec->parts, ep);
- if (edf->free_strings && ep->name) evas_stringshare_del(ep->name);
+ if (edf->free_strings && ep->name) eina_stringshare_del(ep->name);
if (ep->default_desc)
{
_edje_collection_free_part_description_free(ep->default_desc, edf->free_strings);
ec->data = evas_list_remove(ec->data, edt);
if (edf->free_strings)
{
- if (edt->key) evas_stringshare_del(edt->key);
- if (edt->value) evas_stringshare_del(edt->value);
+ if (edt->key) eina_stringshare_del(edt->key);
+ if (edt->value) eina_stringshare_del(edt->value);
}
free(edt);
}
}
- if (edf->free_strings && ec->part) evas_stringshare_del(ec->part);
+ if (edf->free_strings && ec->part) eina_stringshare_del(ec->part);
#ifdef EDJE_PROGRAM_CACHE
if (ec->prog_cache.no_matches) evas_hash_free(ec->prog_cache.no_matches);
if (ec->prog_cache.matches)
}
if (free_strings)
{
- if (desc->color_class) evas_stringshare_del(desc->color_class);
- if (desc->text.text) evas_stringshare_del(desc->text.text);
- if (desc->text.text_class) evas_stringshare_del(desc->text.text_class);
- if (desc->text.style) evas_stringshare_del(desc->text.style);
- if (desc->text.font) evas_stringshare_del(desc->text.font);
- if (desc->gradient.type) evas_stringshare_del(desc->gradient.type);
- if (desc->gradient.params) evas_stringshare_del(desc->gradient.params);
+ if (desc->color_class) eina_stringshare_del(desc->color_class);
+ if (desc->text.text) eina_stringshare_del(desc->text.text);
+ if (desc->text.text_class) eina_stringshare_del(desc->text.text_class);
+ if (desc->text.style) eina_stringshare_del(desc->text.style);
+ if (desc->text.font) eina_stringshare_del(desc->text.font);
+ if (desc->gradient.type) eina_stringshare_del(desc->gradient.type);
+ if (desc->gradient.params) eina_stringshare_del(desc->gradient.params);
}
free(desc);
}
initted++;
if (initted == 1)
{
+ eina_init();
ecore_job_init();
srand(time(NULL));
_edje_edd_setup();
embryo_shutdown();
ecore_job_shutdown();
eet_shutdown();
+ eina_shutdown();
return 0;
}
_edje_message_del(ed);
_edje_callbacks_patterns_clean(ed);
_edje_file_del(ed);
- if (ed->path) evas_stringshare_del(ed->path);
- if (ed->group) evas_stringshare_del(ed->group);
- if (ed->parent) evas_stringshare_del(ed->parent);
+ if (ed->path) eina_stringshare_del(ed->path);
+ if (ed->group) eina_stringshare_del(ed->group);
+ if (ed->parent) eina_stringshare_del(ed->parent);
ed->path = NULL;
ed->group = NULL;
if ((ed->actions) || (ed->pending_actions))
escb = ed->callbacks->data;
ed->callbacks = evas_list_remove(ed->callbacks, escb);
- if (escb->signal) evas_stringshare_del(escb->signal);
- if (escb->source) evas_stringshare_del(escb->source);
+ if (escb->signal) eina_stringshare_del(escb->signal);
+ if (escb->source) eina_stringshare_del(escb->source);
free(escb);
}
while (ed->color_classes)
cc = ed->color_classes->data;
ed->color_classes = evas_list_remove(ed->color_classes, cc);
- if (cc->name) evas_stringshare_del(cc->name);
+ if (cc->name) eina_stringshare_del(cc->name);
free(cc);
}
while (ed->text_classes)
tc = ed->text_classes->data;
ed->text_classes = evas_list_remove(ed->text_classes, tc);
- if (tc->name) evas_stringshare_del(tc->name);
- if (tc->font) evas_stringshare_del(tc->font);
+ if (tc->name) eina_stringshare_del(tc->name);
+ if (tc->font) eina_stringshare_del(tc->font);
free(tc);
}
free(ed);
Edje_Message_Signal *emsg;
emsg = (Edje_Message_Signal *)em->msg;
- if (emsg->sig) evas_stringshare_del(emsg->sig);
- if (emsg->src) evas_stringshare_del(emsg->src);
+ if (emsg->sig) eina_stringshare_del(emsg->sig);
+ if (emsg->src) eina_stringshare_del(emsg->src);
free(emsg);
}
break;
emsg2 = (Edje_Message_Signal *)emsg;
emsg3 = calloc(1, sizeof(Edje_Message_Signal));
- if (emsg2->sig) emsg3->sig = evas_stringshare_add(emsg2->sig);
- if (emsg2->src) emsg3->src = evas_stringshare_add(emsg2->src);
+ if (emsg2->sig) emsg3->sig = eina_stringshare_add(emsg2->sig);
+ if (emsg2->src) emsg3->src = eina_stringshare_add(emsg2->src);
msg = (unsigned char *)emsg3;
}
break;
# include <Evil.h>
#endif
+#include <Eina.h>
#include <Evas.h>
#include <Ecore.h>
#include <Ecore_Str.h>
#include <Ecore_Job.h>
#include <Eet.h>
#include <Embryo.h>
+#include <eina_stringshare.h>
#include "Edje.h"
#include "Edje_Edit.h"
#define GETSTREVAS(str, par) { \
if ((str)) { \
if ((par) && (!strcmp((par), (str)))) return 0; \
- if ((par)) evas_stringshare_del((par)); \
- (par) = (char *)evas_stringshare_add((str)); } \
+ if ((par)) eina_stringshare_del((par)); \
+ (par) = (char *)eina_stringshare_add((str)); } \
else (par) = NULL; }
#define GETFLOAT(val, par) { \
float *___cptr; \
if (ed->delete_me) return;
escb = calloc(1, sizeof(Edje_Signal_Callback));
if ((emission) && (emission[0]))
- escb->signal = evas_stringshare_add(emission);
+ escb->signal = eina_stringshare_add(emission);
if ((source) && (source[0]))
- escb->source = evas_stringshare_add(source);
+ escb->source = eina_stringshare_add(source);
escb->func = func;
escb->data = data;
ed->callbacks = evas_list_append(ed->callbacks, escb);
_edje_callbacks_patterns_clean(ed);
ed->callbacks = evas_list_remove_list(ed->callbacks, l);
- if (escb->signal) evas_stringshare_del(escb->signal);
- if (escb->source) evas_stringshare_del(escb->source);
+ if (escb->signal) eina_stringshare_del(escb->signal);
+ if (escb->source) eina_stringshare_del(escb->source);
free(escb);
}
return data;
if (escb->delete_me)
{
ed->callbacks = evas_list_remove_list(ed->callbacks, l);
- if (escb->signal) evas_stringshare_del(escb->signal);
- if (escb->source) evas_stringshare_del(escb->source);
+ if (escb->signal) eina_stringshare_del(escb->signal);
+ if (escb->source) eina_stringshare_del(escb->source);
free(escb);
}
l = next_l;
goto arrange_text;
}
- if (ep->text.cache.in_str) evas_stringshare_del(ep->text.cache.in_str);
- ep->text.cache.in_str = evas_stringshare_add(text);
+ if (ep->text.cache.in_str) eina_stringshare_del(ep->text.cache.in_str);
+ ep->text.cache.in_str = eina_stringshare_add(text);
ep->text.cache.in_size = size;
if (chosen_desc->text.fit_x)
{
text = _edje_text_fit_x(ed, ep, params, text, font, size, sw, &free_text);
}
- if (ep->text.cache.out_str) evas_stringshare_del(ep->text.cache.out_str);
- ep->text.cache.out_str = evas_stringshare_add(text);
+ if (ep->text.cache.out_str) eina_stringshare_del(ep->text.cache.out_str);
+ ep->text.cache.out_str = eina_stringshare_add(text);
ep->text.cache.in_w = sw;
ep->text.cache.in_h = sh;
ep->text.cache.out_size = size;
else if (!strcmp(key, "text_class"))
{
if (tag_ret)
- (*tag_ret)->text_class = evas_stringshare_add(val);
+ (*tag_ret)->text_class = eina_stringshare_add(val);
}
else if (!strcmp(key, "font_size"))
{
tmpstr = _edje_strbuf_append(tmpstr, "fonts/", &tmplen, &tmpalloc);
tmpstr = _edje_strbuf_append(tmpstr, val, &tmplen, &tmpalloc);
- (*tag_ret)->font = evas_stringshare_add(tmpstr);
+ (*tag_ret)->font = eina_stringshare_add(tmpstr);
free(tmpstr);
}
else
{
- (*tag_ret)->font = evas_stringshare_add(val);
+ (*tag_ret)->font = eina_stringshare_add(val);
}
}
}
if (ts)
{
if (eet_dictionary_string_check(eet_dictionary_get(edf->ef), tag->value) == 0)
- evas_stringshare_del(tag->value);
- tag->value = evas_stringshare_add(ts);
+ eina_stringshare_del(tag->value);
+ tag->value = eina_stringshare_add(ts);
buf = _edje_strbuf_append(buf, tag->value, &buflen, &bufalloc);
free(ts);
}
stl->tags = evas_list_remove_list(stl->tags, stl->tags);
if (edf->free_strings)
{
- if (tag->key) evas_stringshare_del(tag->key);
+ if (tag->key) eina_stringshare_del(tag->key);
/* FIXME: Find a proper way to handle it. */
- if (tag->value) evas_stringshare_del(tag->value);
- if (tag->text_class) evas_stringshare_del(tag->text_class);
- if (tag->font) evas_stringshare_del(tag->font);
+ if (tag->value) eina_stringshare_del(tag->value);
+ if (tag->text_class) eina_stringshare_del(tag->text_class);
+ if (tag->font) eina_stringshare_del(tag->font);
}
free(tag);
}
- if (edf->free_strings && stl->name) evas_stringshare_del(stl->name);
+ if (edf->free_strings && stl->name) eina_stringshare_del(stl->name);
if (stl->style) evas_textblock_style_free(stl->style);
free(stl);
}
{
cc = calloc(1, sizeof(Edje_Color_Class));
if (!cc) return;
- cc->name = evas_stringshare_add(color_class);
+ cc->name = eina_stringshare_add(color_class);
if (!cc->name)
{
free(cc);
evas_hash_add(_edje_color_class_hash, color_class, cc);
if (evas_hash_alloc_error())
{
- evas_stringshare_del(cc->name);
+ eina_stringshare_del(cc->name);
free(cc);
return;
}
_edje_color_class_hash =
evas_hash_del(_edje_color_class_hash, color_class, cc);
- evas_stringshare_del(cc->name);
+ eina_stringshare_del(cc->name);
free(cc);
members = evas_hash_find(_edje_color_class_member_hash, color_class);
}
cc = malloc(sizeof(Edje_Color_Class));
if (!cc) return;
- cc->name = evas_stringshare_add(color_class);
+ cc->name = eina_stringshare_add(color_class);
if (!cc->name)
{
free(cc);
if (!strcmp(cc->name, color_class))
{
ed->color_classes = evas_list_remove(ed->color_classes, cc);
- evas_stringshare_del(cc->name);
+ eina_stringshare_del(cc->name);
free(cc);
return;
}
{
tc = calloc(1, sizeof(Edje_Text_Class));
if (!tc) return;
- tc->name = evas_stringshare_add(text_class);
+ tc->name = eina_stringshare_add(text_class);
if (!tc->name)
{
free(tc);
evas_hash_add(_edje_text_class_hash, text_class, tc);
if (evas_hash_alloc_error())
{
- evas_stringshare_del(tc->name);
+ eina_stringshare_del(tc->name);
free(tc);
return;
}
- tc->font = evas_stringshare_add(font);
+ tc->font = eina_stringshare_add(font);
tc->size = size;
return;
}
return;
/* Update the class found */
- evas_stringshare_del(tc->font);
- tc->font = evas_stringshare_add(font);
+ eina_stringshare_del(tc->font);
+ tc->font = eina_stringshare_add(font);
if (!tc->font)
{
_edje_text_class_hash =
_edje_text_class_hash =
evas_hash_del(_edje_text_class_hash, text_class, tc);
- evas_stringshare_del(tc->name);
- evas_stringshare_del(tc->font);
+ eina_stringshare_del(tc->name);
+ eina_stringshare_del(tc->font);
free(tc);
members = evas_hash_find(_edje_text_class_member_hash, text_class);
Edje_List_Foreach_Data *fd;
fd = fdata;
- fd->list = evas_list_append(fd->list, evas_stringshare_add(key));
+ fd->list = evas_list_append(fd->list, eina_stringshare_add(key));
return 1;
}
if ((!tc->font) && (!font) && (tc->size == size)) return;
/* Update new text class properties */
- if (tc->font) evas_stringshare_del(tc->font);
- if (font) tc->font = evas_stringshare_add(font);
+ if (tc->font) eina_stringshare_del(tc->font);
+ if (font) tc->font = eina_stringshare_add(font);
else tc->font = NULL;
tc->size = size;
/* No matches, create a new text class */
tc = calloc(1, sizeof(Edje_Text_Class));
if (!tc) return;
- tc->name = evas_stringshare_add(text_class);
+ tc->name = eina_stringshare_add(text_class);
if (!tc->name)
{
free(tc);
return;
}
- if (font) tc->font = evas_stringshare_add(font);
+ if (font) tc->font = eina_stringshare_add(font);
else tc->font = NULL;
tc->size = size;
return;
if (rp->text.text)
{
- evas_stringshare_del(rp->text.text);
+ eina_stringshare_del(rp->text.text);
rp->text.text = NULL;
}
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
_edje_entry_text_markup_set(rp, text);
}
else
- if (text) rp->text.text = evas_stringshare_add(text);
+ if (text) rp->text.text = eina_stringshare_add(text);
rp->edje->dirty = 1;
_edje_recalc(rp->edje);
if (rp->edje->text_change.func)
Edje_Color_Class *cc;
cc = data;
- if (cc->name) evas_stringshare_del(cc->name);
+ if (cc->name) eina_stringshare_del(cc->name);
free(cc);
return 1;
}
Edje_Text_Class *tc;
tc = data;
- if (tc->name) evas_stringshare_del(tc->name);
- if (tc->font) evas_stringshare_del(tc->font);
+ if (tc->name) eina_stringshare_del(tc->name);
+ if (tc->font) eina_stringshare_del(tc->font);
free(tc);
return 1;
}
projects / framework / uifw / edje.git / commitdiff