EAPI Eina_Simple_XML_Attribute *
eina_simple_xml_attribute_new(Eina_Simple_XML_Node_Tag *parent, const char *key, const char *value)
{
Eina_Simple_XML_Attribute *attr;
if (!key) return NULL;
attr = eina_mempool_malloc(_eina_simple_xml_attribute_mp, sizeof(*attr));
if (!attr)
{
ERR("could not allocate memory for attribute from mempool");
return NULL;
}
EINA_MAGIC_SET(attr, EINA_MAGIC_SIMPLE_XML_ATTRIBUTE);
attr->parent = parent;
attr->key = eina_stringshare_add(key);
attr->value = eina_stringshare_add(value ? value : "");
if (parent)
parent->attributes = eina_inlist_append
(parent->attributes, EINA_INLIST_GET(attr));
return attr;
}
EAPI Eina_Simple_XML_Node_Tag *
eina_simple_xml_node_tag_new(Eina_Simple_XML_Node_Tag *parent, const char *name)
{
Eina_Simple_XML_Node_Tag *n;
if (!name) return NULL;
n = eina_mempool_malloc(_eina_simple_xml_tag_mp, sizeof(*n));
if (!n)
{
ERR("could not allocate memory for node from mempool");
return NULL;
}
memset(n, 0, sizeof(*n));
EINA_MAGIC_SET(&n->base, EINA_MAGIC_SIMPLE_XML_TAG);
n->base.type = EINA_SIMPLE_XML_NODE_TAG;
n->base.parent = parent;
n->name = eina_stringshare_add(name);
if (parent)
parent->children = eina_inlist_append
(parent->children, EINA_INLIST_GET(&n->base));
return n;
}
Eet_Node *
eet_node_new(void)
{
Eet_Node *result;
result = eina_mempool_malloc(_eet_node_mp, sizeof (Eet_Node));
if (!result)
return NULL;
memset(result, 0, sizeof (Eet_Node));
return result;
}
static inline Eina_List *
_eina_list_mempool_list_new(EINA_UNUSED Eina_List *list)
{
Eina_List *tmp;
tmp = eina_mempool_malloc(_eina_list_mp, sizeof (Eina_List));
if (!tmp)
return NULL;
EINA_MAGIC_SET(tmp, EINA_MAGIC_LIST);
return tmp;
}
static inline Eina_Matrixsparse_Row *
_eina_matrixsparse_row_idx_add(Eina_Matrixsparse *m, unsigned long row)
{
Eina_Matrixsparse_Row *r = eina_mempool_malloc
(_eina_matrixsparse_row_mp, sizeof(Eina_Matrixsparse_Row));
if (!r) return NULL;
if (!m->rows)
{
r->prev = NULL;
r->next = NULL;
m->rows = r;
m->last_row = r;
}
else if (row < m->rows->row)
{
r->prev = NULL;
r->next = m->rows;
m->rows->prev = r;
m->rows = r;
}
else if (row > m->last_row->row)
{
r->prev = m->last_row;
m->last_row->next = r;
r->next = NULL;
m->last_row = r;
}
else
{
Eina_Matrixsparse_Row *prev = NULL, *next = NULL;
_eina_matrixsparse_row_idx_siblings_find(m, row, &prev, &next);
assert(prev != NULL);
assert(next != NULL);
r->prev = prev;
r->next = next;
prev->next = r;
next->prev = r;
}
r->cols = NULL;
r->last_col = NULL;
r->last_used = NULL;
r->row = row;
r->parent = m;
EINA_MAGIC_SET(r, EINA_MAGIC_MATRIXSPARSE_ROW);
m->last_used = r;
return r;
}
static inline Eina_List_Accounting *
_eina_list_mempool_accounting_new(EINA_UNUSED Eina_List *list)
{
Eina_List_Accounting *tmp;
tmp =
eina_mempool_malloc(_eina_list_accounting_mp,
sizeof (Eina_List_Accounting));
if (!tmp)
return NULL;
EINA_MAGIC_SET(tmp, EINA_MAGIC_LIST_ACCOUNTING);
return tmp;
}
static inline Eina_Matrixsparse_Cell *
_eina_matrixsparse_row_cell_idx_add(Eina_Matrixsparse_Row *r, unsigned long col, const void *data)
{
Eina_Matrixsparse_Cell *c = eina_mempool_malloc
(_eina_matrixsparse_cell_mp, sizeof(Eina_Matrixsparse_Cell));
if (!c) return NULL;
if (!r->cols)
{
c->prev = NULL;
c->next = NULL;
r->cols = c;
r->last_col = c;
}
else if (col < r->cols->col)
{
c->prev = NULL;
c->next = r->cols;
r->cols->prev = c;
r->cols = c;
}
else if (col > r->last_col->col)
{
c->prev = r->last_col;
r->last_col->next = c;
c->next = NULL;
r->last_col = c;
}
else
{
Eina_Matrixsparse_Cell *prev = NULL, *next = NULL;
_eina_matrixsparse_row_cell_idx_siblings_find(r, col, &prev, &next);
assert(prev != NULL);
assert(next != NULL);
c->prev = prev;
c->next = next;
prev->next = c;
next->prev = c;
}
c->data = (void *)data;
c->col = col;
c->parent = r;
EINA_MAGIC_SET(c, EINA_MAGIC_MATRIXSPARSE_CELL);
r->last_used = c;
return c;
}
EAPI Eina_Rectangle *
eina_rectangle_new(int x, int y, int w, int h)
{
Eina_Rectangle *rect;
if (_eina_rectangles)
{
rect = eina_trash_pop(&_eina_rectangles);
_eina_rectangles_count--;
}
else
rect = eina_mempool_malloc(_eina_rectangle_mp, sizeof (Eina_Rectangle));
if (!rect)
return NULL;
EINA_RECTANGLE_SET(rect, x, y, w, h);
return rect;
}
EAPI Eina_Simple_XML_Node_Root *
eina_simple_xml_node_load(const char *buf, unsigned buflen, Eina_Bool strip)
{
Eina_Simple_XML_Node_Root *root;
struct eina_simple_xml_node_load_ctxt ctx;
if (!buf) return NULL;
root = eina_mempool_malloc(_eina_simple_xml_tag_mp, sizeof(*root));
if (!root) return NULL;
memset(root, 0, sizeof(*root));
EINA_MAGIC_SET(&root->base, EINA_MAGIC_SIMPLE_XML_TAG);
root->base.type = EINA_SIMPLE_XML_NODE_ROOT;
ctx.root = root;
ctx.current = root;
eina_simple_xml_parse(buf, buflen, strip, _eina_simple_xml_node_parse, &ctx);
return root;
}
/*----------------------------------------------------------------------------*
* The Enesim's pool interface *
*----------------------------------------------------------------------------*/
static Eina_Bool _data_alloc(void *prv,
Enesim_Backend *backend,
void **backend_data,
Enesim_Buffer_Format fmt, uint32_t w, uint32_t h)
{
Enesim_Buffer_Sw_Data *data;
Enesim_Eina_Pool *thiz = prv;
size_t bytes;
int stride;
void *alloc_data;
data = malloc(sizeof(Enesim_Buffer_Sw_Data));
*backend = ENESIM_BACKEND_SOFTWARE;
*backend_data = data;
bytes = enesim_buffer_format_size_get(fmt, w, h);
stride = enesim_buffer_format_size_get(fmt, w, 1);
alloc_data = eina_mempool_malloc(thiz->mp, bytes);
enesim_buffer_sw_data_set(data, fmt, alloc_data, stride);
return EINA_TRUE;
}
int
_edje_object_file_set_internal(Evas_Object *obj, const char *file, const char *group, const char *parent, Eina_List *group_path)
{
Edje *ed;
Evas *tev;
Edje_Real_Part *rp;
Eina_List *textblocks = NULL;
Eina_List *sources = NULL;
Eina_List *externals = NULL;
Eina_List *old_swallows;
unsigned int n;
Eina_List *parts = NULL;
int group_path_started = 0;
ed = _edje_fetch(obj);
if (!ed) return 0;
if (!file) file = "";
if (!group) group = "";
if (((ed->path) && (!strcmp(file, ed->path))) &&
(ed->group) && (!strcmp(group, ed->group)))
return 1;
tev = evas_object_evas_get(obj);
evas_event_freeze(tev);
old_swallows = _edje_swallows_collect(ed);
if (_edje_script_only(ed)) _edje_script_only_shutdown(ed);
if (_edje_lua_script_only(ed)) _edje_lua_script_only_shutdown(ed);
_edje_file_del(ed);
eina_stringshare_replace(&ed->path, file);
eina_stringshare_replace(&ed->group, group);
ed->parent = eina_stringshare_add(parent);
ed->load_error = EDJE_LOAD_ERROR_NONE;
_edje_file_add(ed);
ed->block_break = 0;
if (ed->file && ed->file->external_dir)
{
unsigned int i;
for (i = 0; i < ed->file->external_dir->entries_count; ++i)
edje_module_load(ed->file->external_dir->entries[i].entry);
}
_edje_textblock_styles_add(ed);
_edje_textblock_style_all_update(ed);
ed->has_entries = EINA_FALSE;
if (ed->collection)
{
if (ed->collection->prop.orientation != EDJE_ORIENTATION_AUTO)
ed->is_rtl = (ed->collection->prop.orientation ==
EDJE_ORIENTATION_RTL);
if (ed->collection->script_only)
{
ed->load_error = EDJE_LOAD_ERROR_NONE;
_edje_script_only_init(ed);
}
else if (ed->collection->lua_script_only)
{
ed->load_error = EDJE_LOAD_ERROR_NONE;
_edje_lua_script_only_init(ed);
}
else
{
unsigned int i;
/* colorclass stuff */
for (i = 0; i < ed->collection->parts_count; ++i)
{
Edje_Part *ep;
unsigned int k;
ep = ed->collection->parts[i];
/* Register any color classes in this parts descriptions. */
if ((ep->default_desc) && (ep->default_desc->color_class))
_edje_color_class_member_add(ed, ep->default_desc->color_class);
for (k = 0; k < ep->other.desc_count; k++)
{
Edje_Part_Description_Common *desc;
desc = ep->other.desc[k];
if (desc->color_class)
_edje_color_class_member_add(ed, desc->color_class);
}
}
/* build real parts */
for (n = 0; n < ed->collection->parts_count; n++)
{
Edje_Part *ep;
ep = ed->collection->parts[n];
rp = eina_mempool_malloc(_edje_real_part_mp, sizeof(Edje_Real_Part));
if (!rp)
{
/* FIXME: destroy all allocated ressource, need to have a common exit point */
ed->load_error = EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
evas_event_thaw(tev);
evas_event_thaw_eval(tev);
return 0;
}
memset(rp, 0, sizeof (Edje_Real_Part));
if ((ep->dragable.x != 0) || (ep->dragable.y != 0))
{
rp->drag = calloc(1, sizeof (Edje_Real_Part_Drag));
if (!rp->drag)
{
ed->load_error = EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
eina_mempool_free(_edje_real_part_mp, rp);
evas_event_thaw(tev);
evas_event_thaw_eval(tev);
return 0;
}
rp->drag->step.x = FROM_INT(ep->dragable.step_x);
rp->drag->step.y = FROM_INT(ep->dragable.step_y);
}
rp->edje = ed;
_edje_ref(rp->edje);
rp->part = ep;
parts = eina_list_append(parts, rp);
rp->param1.description =
_edje_part_description_find(ed, rp, "default", 0.0);
rp->chosen_description = rp->param1.description;
if (!rp->param1.description)
ERR("no default part description!");
switch (ep->type)
{
case EDJE_PART_TYPE_RECTANGLE:
rp->object = evas_object_rectangle_add(ed->base.evas);
break;
case EDJE_PART_TYPE_PROXY:
case EDJE_PART_TYPE_IMAGE:
rp->object = evas_object_image_add(ed->base.evas);
break;
case EDJE_PART_TYPE_TEXT:
_edje_text_part_on_add(ed, rp);
rp->object = evas_object_text_add(ed->base.evas);
evas_object_text_font_source_set(rp->object, ed->path);
break;
case EDJE_PART_TYPE_GROUP:
sources = eina_list_append(sources, rp);
case EDJE_PART_TYPE_SWALLOW:
case EDJE_PART_TYPE_EXTERNAL:
if (ep->type == EDJE_PART_TYPE_EXTERNAL)
externals = eina_list_append(externals, rp);
rp->object = evas_object_rectangle_add(ed->base.evas);
evas_object_color_set(rp->object, 0, 0, 0, 0);
evas_object_pass_events_set(rp->object, 1);
evas_object_pointer_mode_set(rp->object, EVAS_OBJECT_POINTER_MODE_NOGRAB);
_edje_callbacks_focus_add(rp->object, ed, rp);
break;
case EDJE_PART_TYPE_TEXTBLOCK:
textblocks = eina_list_append(textblocks, rp);
rp->object = evas_object_textblock_add(ed->base.evas);
break;
case EDJE_PART_TYPE_BOX:
sources = eina_list_append(sources, rp);
rp->object = evas_object_box_add(ed->base.evas);
rp->anim = _edje_box_layout_anim_new(rp->object);
break;
case EDJE_PART_TYPE_TABLE:
sources = eina_list_append(sources, rp);
rp->object = evas_object_table_add(ed->base.evas);
break;
case EDJE_PART_TYPE_GRADIENT:
ERR("SPANK ! SPANK ! SPANK ! YOU ARE USING GRADIENT IN PART %s FROM GROUP %s INSIDE FILE %s !! THEY ARE NOW REMOVED !",
ep->name, group, file);
default:
ERR("wrong part type %i!", ep->type);
break;
}
if (rp->object)
{
evas_object_smart_member_add(rp->object, ed->obj);
// evas_object_layer_set(rp->object, evas_object_layer_get(ed->obj));
if (ep->type != EDJE_PART_TYPE_SWALLOW && ep->type != EDJE_PART_TYPE_GROUP && ep->type != EDJE_PART_TYPE_EXTERNAL)
{
if (ep->mouse_events)
{
_edje_callbacks_add(rp->object, ed, rp);
if (ep->repeat_events)
evas_object_repeat_events_set(rp->object, 1);
if (ep->pointer_mode != EVAS_OBJECT_POINTER_MODE_AUTOGRAB)
evas_object_pointer_mode_set(rp->object, ep->pointer_mode);
}
else
{
evas_object_pass_events_set(rp->object, 1);
evas_object_pointer_mode_set(rp->object, EVAS_OBJECT_POINTER_MODE_NOGRAB);
}
if (ep->precise_is_inside)
evas_object_precise_is_inside_set(rp->object, 1);
}
if (rp->part->clip_to_id < 0)
evas_object_clip_set(rp->object, ed->base.clipper);
}
}
if (n > 0)
{
Eina_List *l;
ed->table_parts = malloc(sizeof(Edje_Real_Part *) * n);
ed->table_parts_size = n;
/* FIXME: check malloc return */
n = 0;
EINA_LIST_FOREACH(parts, l, rp)
{
ed->table_parts[n] = rp;
n++;
}
eina_list_free(parts);
for (i = 0; i < ed->table_parts_size; i++)
{
rp = ed->table_parts[i];
if (rp->param1.description) /* FIXME: prevent rel to gone radient part to go wrong. You may
be able to remove this when all theme are correctly rewritten. */
{
if (rp->param1.description->rel1.id_x >= 0)
rp->param1.rel1_to_x = ed->table_parts[rp->param1.description->rel1.id_x % ed->table_parts_size];
if (rp->param1.description->rel1.id_y >= 0)
rp->param1.rel1_to_y = ed->table_parts[rp->param1.description->rel1.id_y % ed->table_parts_size];
if (rp->param1.description->rel2.id_x >= 0)
rp->param1.rel2_to_x = ed->table_parts[rp->param1.description->rel2.id_x % ed->table_parts_size];
if (rp->param1.description->rel2.id_y >= 0)
rp->param1.rel2_to_y = ed->table_parts[rp->param1.description->rel2.id_y % ed->table_parts_size];
}
if (rp->part->clip_to_id >= 0)
{
rp->clip_to = ed->table_parts[rp->part->clip_to_id % ed->table_parts_size];
if (rp->clip_to)
{
evas_object_pass_events_set(rp->clip_to->object, 1);
evas_object_pointer_mode_set(rp->clip_to->object, EVAS_OBJECT_POINTER_MODE_NOGRAB);
evas_object_clip_set(rp->object, rp->clip_to->object);
}
}
if (rp->drag)
{
if (rp->part->dragable.confine_id >= 0)
rp->drag->confine_to = ed->table_parts[rp->part->dragable.confine_id % ed->table_parts_size];
}
/* replay events for dragable */
if (rp->part->dragable.event_id >= 0)
{
rp->events_to =
ed->table_parts[rp->part->dragable.event_id % ed->table_parts_size];
/* events_to may be used only with dragable */
if (!rp->events_to->part->dragable.x &&
!rp->events_to->part->dragable.y)
rp->events_to = NULL;
}
rp->swallow_params.min.w = 0;
rp->swallow_params.min.h = 0;
rp->swallow_params.max.w = -1;
rp->swallow_params.max.h = -1;
if (rp->part->type == EDJE_PART_TYPE_TEXT
|| rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
{
Edje_Part_Description_Text *text;
text = (Edje_Part_Description_Text *) rp->param1.description;
if (ed->file->feature_ver < 1)
{
text->text.id_source = -1;
text->text.id_text_source = -1;
}
if (text->text.id_source >= 0)
rp->text.source = ed->table_parts[text->text.id_source % ed->table_parts_size];
if (text->text.id_text_source >= 0)
rp->text.text_source = ed->table_parts[text->text.id_text_source % ed->table_parts_size];
if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
{
_edje_entry_real_part_init(rp);
if (!ed->has_entries)
ed->has_entries = EINA_TRUE;
}
}
}
}
_edje_programs_patterns_init(ed);
n = ed->collection->programs.fnmatch_count +
ed->collection->programs.strcmp_count +
ed->collection->programs.strncmp_count +
ed->collection->programs.strrncmp_count +
ed->collection->programs.nocmp_count;
if (n > 0)
{
Edje_Program *pr;
ed->table_programs = malloc(sizeof(Edje_Program *) * n);
if (ed->table_programs)
{
ed->table_programs_size = n;
#define EDJE_LOAD_BUILD_TABLE(Array, Ed, It, Tmp) \
for (It = 0; It < Ed->collection->programs.Array##_count; ++It) \
{ \
Tmp = Ed->collection->programs.Array[It]; \
Ed->table_programs[Tmp->id] = Tmp; \
}
EDJE_LOAD_BUILD_TABLE(fnmatch, ed, i, pr);
EDJE_LOAD_BUILD_TABLE(strcmp, ed, i, pr);
EDJE_LOAD_BUILD_TABLE(strncmp, ed, i, pr);
EDJE_LOAD_BUILD_TABLE(strrncmp, ed, i, pr);
EDJE_LOAD_BUILD_TABLE(nocmp, ed, i, pr);
}
}
_edje_ref(ed);
_edje_block(ed);
_edje_freeze(ed);
// if (ed->collection->script) _edje_embryo_script_init(ed);
_edje_var_init(ed);
for (i = 0; i < ed->table_parts_size; i++)
{
rp = ed->table_parts[i];
evas_object_show(rp->object);
if (_edje_block_break(ed)) break;
if (rp->drag)
{
if (rp->part->dragable.x < 0) rp->drag->val.x = FROM_DOUBLE(1.0);
if (rp->part->dragable.y < 0) rp->drag->val.x = FROM_DOUBLE(1.0);
_edje_dragable_pos_set(ed, rp, rp->drag->val.x, rp->drag->val.y);
}
}
ed->recalc_call = 1;
ed->dirty = 1;
#ifdef EDJE_CALC_CACHE
ed->all_part_change = 1;
#endif
if ((evas_object_clipees_get(ed->base.clipper)) &&
(evas_object_visible_get(obj)))
evas_object_show(ed->base.clipper);
/* instantiate 'internal swallows' */
EINA_LIST_FREE(externals, rp)
{
Edje_Part_Description_External *external;
Evas_Object *child_obj;
external = (Edje_Part_Description_External *) rp->part->default_desc;
child_obj = _edje_external_type_add(rp->part->source,
evas_object_evas_get(ed->obj), ed->obj,
external->external_params, rp->part->name);
if (child_obj)
{
_edje_real_part_swallow(rp, child_obj, EINA_TRUE);
rp->param1.external_params = _edje_external_params_parse(child_obj,
external->external_params);
_edje_external_recalc_apply(ed, rp, NULL, rp->chosen_description);
}
}
