void
_eina_simple_xml_node_tag_free(Eina_Simple_XML_Node_Tag *tag)
{
while (tag->children)
{
Eina_Simple_XML_Node *n = EINA_INLIST_CONTAINER_GET
(tag->children, Eina_Simple_XML_Node);
if (n->type == EINA_SIMPLE_XML_NODE_TAG)
_eina_simple_xml_node_tag_free((Eina_Simple_XML_Node_Tag *)n);
else
_eina_simple_xml_node_data_free((Eina_Simple_XML_Node_Data *)n);
}
while (tag->attributes)
{
Eina_Simple_XML_Attribute *a = EINA_INLIST_CONTAINER_GET
(tag->attributes, Eina_Simple_XML_Attribute);
eina_simple_xml_attribute_free(a);
}
if (tag->base.parent)
tag->base.parent->children = eina_inlist_remove
(tag->base.parent->children, EINA_INLIST_GET(&tag->base));
eina_stringshare_del(tag->name);
EINA_MAGIC_SET(&tag->base, EINA_MAGIC_NONE);
eina_mempool_free(_eina_simple_xml_tag_mp, tag);
}
EAPI void *
ecore_exe_free(Ecore_Exe *exe)
{
void *data;
if (!ECORE_MAGIC_CHECK(exe, ECORE_MAGIC_EXE))
{
ECORE_MAGIC_FAIL(exe, ECORE_MAGIC_EXE, "ecore_exe_free");
return NULL;
}
data = exe->data;
if (exe->pre_free_cb)
exe->pre_free_cb(data, exe);
CloseHandle(exe->process2);
CloseHandle(exe->process_thread);
CloseHandle(exe->process);
free(exe->cmd);
_ecore_exe_win32_pipes_close(exe);
exes = (Ecore_Exe *)eina_inlist_remove(EINA_INLIST_GET(exes), EINA_INLIST_GET(exe));
ECORE_MAGIC_SET(exe, ECORE_MAGIC_NONE);
if (exe->tag) free(exe->tag);
free(exe);
return data;
}
void
_ecore_idle_exiter_call(void)
{
if (!idle_exiter_current)
{
/* regular main loop, start from head */
idle_exiter_current = idle_exiters;
}
else
{
/* recursive main loop, continue from where we were */
idle_exiter_current =
(Ecore_Idle_Exiter *)EINA_INLIST_GET(idle_exiter_current)->next;
}
while (idle_exiter_current)
{
Ecore_Idle_Exiter *ie = (Ecore_Idle_Exiter *)idle_exiter_current;
if (!ie->delete_me)
{
ie->references++;
if (!_ecore_call_task_cb(ie->func, ie->data))
{
if (!ie->delete_me) _ecore_idle_exiter_del(ie);
}
ie->references--;
}
if (idle_exiter_current) /* may have changed in recursive main loops */
idle_exiter_current =
(Ecore_Idle_Exiter *)EINA_INLIST_GET(idle_exiter_current)->next;
}
if (idle_exiters_delete_me)
{
Ecore_Idle_Exiter *l;
int deleted_idler_exiters_in_use = 0;
for (l = idle_exiters; l; )
{
Ecore_Idle_Exiter *ie = l;
l = (Ecore_Idle_Exiter *)EINA_INLIST_GET(l)->next;
if (ie->delete_me)
{
if (ie->references)
{
deleted_idler_exiters_in_use++;
continue;
}
idle_exiters = (Ecore_Idle_Exiter *)eina_inlist_remove(EINA_INLIST_GET(idle_exiters), EINA_INLIST_GET(ie));
ECORE_MAGIC_SET(ie, ECORE_MAGIC_NONE);
ecore_idle_exiter_mp_free(ie);
}
}
if (!deleted_idler_exiters_in_use)
idle_exiters_delete_me = 0;
}
}
void
database_type_del(Eolian_Type type)
{
while (type)
{
_Parameter_Type *ptype = (_Parameter_Type *) type;
eina_stringshare_del(ptype->name);
type = eina_inlist_remove(type, EINA_INLIST_GET(ptype));
}
}
static void
_eina_simple_xml_node_data_free(Eina_Simple_XML_Node_Data *node)
{
if (node->base.parent)
node->base.parent->children = eina_inlist_remove
(node->base.parent->children, EINA_INLIST_GET(&node->base));
EINA_MAGIC_SET(&node->base, EINA_MAGIC_NONE);
free(node);
}
void
comic_chapter_item_chapter_del(Comic_Chapter *cc)
{
Comic_Chapter_Item *cci = cc->cci;
cci->chapters = eina_inlist_remove(cci->chapters, EINA_INLIST_GET(cc));
cci->chapter_count--;
if (cc != cci->cc) return;
if (cci->chapters)
{
cci->cc = EINA_INLIST_CONTAINER_GET(cci->chapters, Comic_Chapter);
_comic_chapter_item_update(cci, cci->cc, EINA_TRUE);
return;
}
cc->csd->cs->chapters = eina_inlist_remove(cc->csd->cs->chapters, EINA_INLIST_GET(cci));
free(cci);
}
static void
_ecore_con_info_slave_free(CB_Data *cbdata)
{
info_slaves = (CB_Data *)eina_inlist_remove(EINA_INLIST_GET(info_slaves),
EINA_INLIST_GET(cbdata));
ecore_main_fd_handler_del(cbdata->fdh);
ecore_event_handler_del(cbdata->handler);
close(ecore_main_fd_handler_fd_get(cbdata->fdh));
if (cbdata->data) ecore_con_server_infos_del(cbdata->data, cbdata);
free(cbdata);
}
void
_ecore_timer_shutdown(void)
{
Ecore_Timer *timer;
while ((timer = timers))
{
timers = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timers));
ECORE_MAGIC_SET(timer, ECORE_MAGIC_NONE);
free(timer);
}
while ((timer = suspended))
{
suspended = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(suspended));
ECORE_MAGIC_SET(timer, ECORE_MAGIC_NONE);
free(timer);
}
timer_current = NULL;
}
EAPI void
evas_common_tilebuf_free_render_rects(Tilebuf_Rect *rects)
{
while (rects)
{
Tilebuf_Rect *r;
r = rects;
rects = (Tilebuf_Rect *)eina_inlist_remove(EINA_INLIST_GET(rects), EINA_INLIST_GET(r));
free(r);
}
}
void
ecore_file_monitor_inotify_del(Ecore_File_Monitor *em)
{
int fd;
_monitors = ECORE_FILE_MONITOR(eina_inlist_remove(EINA_INLIST_GET(_monitors), EINA_INLIST_GET(em)));
fd = ecore_main_fd_handler_fd_get(_fdh);
if (ECORE_FILE_MONITOR_INOTIFY(em)->wd)
inotify_rm_watch(fd, ECORE_FILE_MONITOR_INOTIFY(em)->wd);
free(em->path);
free(em);
}
void
_ecore_idle_enterer_shutdown(void)
{
Ecore_Idle_Enterer *ie;
while ((ie = idle_enterers))
{
idle_enterers = (Ecore_Idle_Enterer *) eina_inlist_remove(EINA_INLIST_GET(idle_enterers), EINA_INLIST_GET(idle_enterers));
ECORE_MAGIC_SET(ie, ECORE_MAGIC_NONE);
free(ie);
}
idle_enterers_delete_me = 0;
idle_enterer_current = NULL;
}
void
_ecore_animator_shutdown(void)
{
_end_tick();
while (animators)
{
Ecore_Animator *animator;
animator = animators;
animators = (Ecore_Animator *)eina_inlist_remove(EINA_INLIST_GET(animators), EINA_INLIST_GET(animators));
ECORE_MAGIC_SET(animator, ECORE_MAGIC_NONE);
ecore_animator_mp_free(animator);
}
}
static Comic_Chapter_Item *
_comic_chapter_item_new(Comic_Chapter *cc)
{
Comic_Chapter_Item *cci;
cci = calloc(1, sizeof(Comic_Chapter_Item));
//DBG("new item: cc %g", cc->number);
_comic_chapter_item_update(cci, cc, EINA_FALSE);
cc->csd->chapters = eina_inlist_remove(cc->csd->chapters, EINA_INLIST_GET(cc));
cc->csd->cs->chapters = eina_inlist_sorted_insert(cc->csd->cs->chapters, EINA_INLIST_GET(cci), (Eina_Compare_Cb)_comic_chapter_item_sort_cb);
cci->chapters = eina_inlist_append(cci->chapters, EINA_INLIST_GET(cc));
cci->chapter_count++;
return cci;
}
EAPI void
eina_simple_xml_attribute_free(Eina_Simple_XML_Attribute *attr)
{
EINA_MAGIC_CHECK_ATTRIBUTE(attr);
if (attr->parent)
attr->parent->attributes = eina_inlist_remove
(attr->parent->attributes, EINA_INLIST_GET(attr));
eina_stringshare_del(attr->key);
eina_stringshare_del(attr->value);
EINA_MAGIC_SET(attr, EINA_MAGIC_NONE);
eina_mempool_free(_eina_simple_xml_attribute_mp, attr);
}
static void
eina_one_big_free(void *data, void *ptr)
{
One_Big *pool = data;
if (!eina_lock_take(&pool->mutex))
{
#ifdef EINA_HAVE_DEBUG_THREADS
assert(eina_thread_equal(pool->self, eina_thread_self()));
#endif
}
if ((void *)pool->base <= ptr
&& ptr < (void *)(pool->base + (pool->max * pool->item_size)))
{
eina_trash_push(&pool->empty, ptr);
pool->usage--;
#ifndef NVALGRIND
VALGRIND_MEMPOOL_FREE(pool, ptr);
#endif
}
else
{
#ifndef NDEBUG
Eina_Inlist *it;
#endif
Eina_Inlist *il;
il = OVER_MEM_TO_LIST(pool, ptr);
#ifndef NDEBUG
for (it = pool->over_list; it != NULL; it = it->next)
if (it == il) break;
assert(it != NULL);
#endif
pool->over_list = eina_inlist_remove(pool->over_list, il);
#ifndef NVALGRIND
VALGRIND_MEMPOOL_FREE(pool, ptr);
#endif
free(ptr);
pool->over--;
}
eina_lock_release(&pool->mutex);
}
static Eina_Bool
_do_tick(void)
{
Ecore_Animator *animator;
EINA_INLIST_FOREACH(animators, animator)
{
animator->just_added = EINA_FALSE;
}
EINA_INLIST_FOREACH(animators, animator)
{
if ((!animator->delete_me) &&
(!animator->suspended) &&
(!animator->just_added))
{
if (!_ecore_call_task_cb(animator->func, animator->data))
{
animator->delete_me = EINA_TRUE;
animators_delete_me++;
}
}
else animator->just_added = EINA_FALSE;
}
if (animators_delete_me)
{
Ecore_Animator *l;
for (l = animators; l; )
{
animator = l;
l = (Ecore_Animator *)EINA_INLIST_GET(l)->next;
if (animator->delete_me)
{
animators = (Ecore_Animator *)
eina_inlist_remove(EINA_INLIST_GET(animators),
EINA_INLIST_GET(animator));
ECORE_MAGIC_SET(animator, ECORE_MAGIC_NONE);
ecore_animator_mp_free(animator);
animators_delete_me--;
if (animators_delete_me == 0) break;
}
}
}
if (!animators)
{
_end_tick();
return ECORE_CALLBACK_CANCEL;
}
return ECORE_CALLBACK_RENEW;
}
static void
_ecore_x_input_touch_info_clear(void)
{
Eina_Inlist *l = _ecore_x_xi2_touch_info_list;
Ecore_X_Touch_Device_Info *info = NULL;
while (l)
{
info = EINA_INLIST_CONTAINER_GET(l, Ecore_X_Touch_Device_Info);
l = eina_inlist_remove(l, l);
if (info->slot) free(info->slot);
free(info);
}
_ecore_x_xi2_touch_info_list = NULL;
}
static void
eina_one_big_shutdown(void *data)
{
One_Big *pool = data;
if (!pool) return;
if (!eina_lock_take(&pool->mutex))
{
#ifdef EINA_HAVE_DEBUG_THREADS
assert(eina_thread_equal(pool->self, eina_thread_self()));
#endif
}
if (pool->over > 0)
{
// FIXME: should we warn here? one_big mempool exceeded its alloc and now
// mempool is cleaning up the mess created. be quiet for now as we were before
// but edje seems to be a big offender at the moment! bad cedric! :)
// WRN(
// "Pool [%s] over by %i. cleaning up for you",
// pool->name, pool->over);
while (pool->over_list)
{
Eina_Inlist *il = pool->over_list;
void *ptr = OVER_MEM_FROM_LIST(pool, il);
pool->over_list = eina_inlist_remove(pool->over_list, il);
free(ptr);
pool->over--;
}
}
if (pool->over > 0)
{
WRN(
"Pool [%s] still over by %i\n",
pool->name, pool->over);
}
#ifndef NVALGRIND
VALGRIND_DESTROY_MEMPOOL(pool);
#endif
if (pool->base) free(pool->base);
eina_lock_release(&pool->mutex);
eina_lock_free(&pool->mutex);
free(pool);
}
void
_ecore_idler_shutdown(void)
{
Ecore_Idler_Data *ie;
while ((ie = idlers))
{
idlers = (Ecore_Idler_Data *)eina_inlist_remove(EINA_INLIST_GET(idlers), EINA_INLIST_GET(idlers));
eo_do(ie->obj, eo_parent_set(NULL));
if (eo_destructed_is(ie->obj))
eo_manual_free(ie->obj);
else
eo_manual_free_set(ie->obj, EINA_FALSE);
}
idlers_delete_me = 0;
idler_current = NULL;
}
void
_ecore_animator_shutdown(void)
{
if (timer)
{
ecore_timer_del(timer);
timer = NULL;
}
while (animators)
{
Ecore_Animator *animator;
animator = animators;
animators = (Ecore_Animator *) eina_inlist_remove(EINA_INLIST_GET(animators), EINA_INLIST_GET(animators));
ECORE_MAGIC_SET(animator, ECORE_MAGIC_NONE);
free(animator);
}
}
void
cserve2_shm_unref(Shm_Handle *shm)
{
Shm_Mapping *map = shm->mapping;
map->segments = eina_inlist_remove(map->segments, EINA_INLIST_GET(shm));
if (shm->data)
munmap(shm->data, shm->image_size);
free(shm);
if (map->segments)
return;
shm_unlink(map->name);
eina_stringshare_del(map->name);
free(map);
}
/**
* Add some delay for the next occurrence of a timer.
* This doesn't affect the interval of a timer.
*
* @param timer The timer to change.
* @param add The dalay to add to the next iteration.
* @ingroup Ecore_Time_Group
*/
EAPI void ecore_timer_delay(Ecore_Timer * timer, double add)
{
if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER)) {
ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
"ecore_timer_delay");
return;
}
if (timer->frozen) {
timer->pending += add;
} else {
timers =
(Ecore_Timer *)
eina_inlist_remove(EINA_INLIST_GET(timers),
EINA_INLIST_GET(timer));
_ecore_timer_set(timer, timer->at + add, timer->in,
timer->func, timer->data);
}
}
void
eupnp_service_action_free(Eupnp_Service_Action *a)
{
if (!a) return;
free((char *)a->name);
if (a->arguments)
{
Eupnp_Service_Action_Argument *item;
while (item = (void *)a->arguments)
{
a->arguments = eina_inlist_remove(a->arguments, a->arguments);
eupnp_service_action_argument_free(item);
}
}
free(a);
}
EAPI void
ecore_timer_thaw(Ecore_Timer *timer)
{
double now;
if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER))
{
ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER,
"ecore_timer_thaw");
return ;
}
/* Timer not frozen */
if (!timer->frozen)
return ;
suspended = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer));
now = ecore_time_get();
_ecore_timer_set(timer, timer->pending + now, timer->in, timer->func, timer->data);
}
static inline void
_ecore_timer_reschedule(Ecore_Timer *timer, double when)
{
if ((timer->delete_me) || (timer->frozen)) return;
timers = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer));
/* if the timer would have gone off more than 15 seconds ago,
* assume that the system hung and set the timer to go off
* timer->in from now. this handles system hangs, suspends
* and more, so ecore will only "replay" the timers while
* the system is suspended if it is suspended for less than
* 15 seconds (basically). this also handles if the process
* is stopped in a debugger or IO and other handling gets
* really slow within the main loop.
*/
if ((timer->at + timer->in) < (when - 15.0))
_ecore_timer_set(timer, when + timer->in, timer->in, timer->func, timer->data);
else
_ecore_timer_set(timer, timer->at + timer->in, timer->in, timer->func, timer->data);
}
/* called when cache of unused tile is flushed */
static void _ewk_tile_matrix_tile_free(void *data, Ewk_Tile *t)
{
Ewk_Tile_Matrix *tm = data;
Eina_Matrixsparse_Cell *cell;
Eina_Inlist *l, *old;
if (!eina_matrixsparse_cell_idx_get(tm->matrix, t->row, t->col, &cell)) {
ERR("removing tile %p that was not in the matrix? Leaking...", t);
return;
}
if (t->updates || t->stats.full_update)
tm->updates = eina_list_remove(tm->updates, t);
old = eina_matrixsparse_cell_data_get(cell);
l = eina_inlist_remove(old, EINA_INLIST_GET(t));
if (!l) {
/* set to null to avoid double free */
eina_matrixsparse_cell_data_replace(cell, NULL, NULL);
eina_matrixsparse_cell_clear(cell);
} else if (old != l)
eina_matrixsparse_cell_data_replace(cell, l, NULL);
if (EINA_UNLIKELY(!!t->visible)) {
ERR("cache of unused tiles requesting deletion of used tile %p? "
"Leaking...", t);
return;
}
#ifdef DEBUG_MEM_LEAKS
tm->stats.bytes.freed += t->bytes;
tm->stats.tiles.freed++;
#endif
ewk_tile_free(t);
}
void
_ecore_wl_input_del(Ecore_Wl_Input *input)
{
if (!input) return;
_pointer_update_stop(input);
if (input->cursor_name) eina_stringshare_del(input->cursor_name);
input->cursor_name = NULL;
if (input->touch_focus)
{
input->touch_focus = NULL;
}
if (input->pointer_focus)
{
Ecore_Wl_Window *win = NULL;
if ((win = input->pointer_focus))
win->pointer_device = NULL;
input->pointer_focus = NULL;
}
if (input->keyboard_focus)
{
Ecore_Wl_Window *win = NULL;
if ((win = input->keyboard_focus))
win->keyboard_device = NULL;
input->keyboard_focus = NULL;
}
if (input->data_types.data)
{
char **t;
wl_array_for_each(t, &input->data_types)
free(*t);
wl_array_release(&input->data_types);
}
if (input->data_source) wl_data_source_destroy(input->data_source);
input->data_source = NULL;
if (input->drag_source) _ecore_wl_dnd_del(input->drag_source);
input->drag_source = NULL;
if (input->selection_source) _ecore_wl_dnd_del(input->selection_source);
input->selection_source = NULL;
if (input->data_device) wl_data_device_destroy(input->data_device);
if (input->xkb.state)
xkb_state_unref(input->xkb.state);
if (input->xkb.keymap)
xkb_map_unref(input->xkb.keymap);
if (input->cursor_surface)
wl_surface_destroy(input->cursor_surface);
_ecore_wl_disp->inputs = eina_inlist_remove
(_ecore_wl_disp->inputs, EINA_INLIST_GET(input));
if (input->seat) wl_seat_destroy(input->seat);
if (input->repeat.tmr) ecore_timer_del(input->repeat.tmr);
input->repeat.tmr = NULL;
free(input);
}
int
_ecore_idler_all_call(void)
{
if (!idler_current)
{
/* regular main loop, start from head */
idler_current = idlers;
}
else
{
/* recursive main loop, continue from where we were */
idler_current = (Ecore_Idler_Data *)EINA_INLIST_GET(idler_current)->next;
}
while (idler_current)
{
Ecore_Idler_Data *ie = (Ecore_Idler_Data *)idler_current;
if (!ie->delete_me)
{
ie->references++;
eina_evlog("+idler", ie, 0.0, NULL);
if (!_ecore_call_task_cb(ie->func, ie->data))
{
if (!ie->delete_me) _ecore_idler_del(ie->obj);
}
eina_evlog("-idler", ie, 0.0, NULL);
ie->references--;
}
if (idler_current) /* may have changed in recursive main loops */
idler_current = (Ecore_Idler_Data *)EINA_INLIST_GET(idler_current)->next;
}
if (idlers_delete_me)
{
Ecore_Idler_Data *l;
int deleted_idlers_in_use = 0;
for (l = idlers; l; )
{
Ecore_Idler_Data *ie = l;
l = (Ecore_Idler_Data *)EINA_INLIST_GET(l)->next;
if (ie->delete_me)
{
if (ie->references)
{
deleted_idlers_in_use++;
continue;
}
idlers = (Ecore_Idler_Data *)eina_inlist_remove(EINA_INLIST_GET(idlers), EINA_INLIST_GET(ie));
eo_do(ie->obj, eo_parent_set(NULL));
if (eo_destructed_is(ie->obj))
eo_manual_free(ie->obj);
else
eo_manual_free_set(ie->obj, EINA_FALSE);
}
}
if (!deleted_idlers_in_use)
idlers_delete_me = 0;
}
if (idlers) return 1;
return 0;
}
EAPI void
evas_object_stack_below(Evas_Object *obj, Evas_Object *below)
{
MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ);
return;
MAGIC_CHECK_END();
MAGIC_CHECK(below, Evas_Object, MAGIC_OBJ);
return;
MAGIC_CHECK_END();
if (obj == below) return;
if (evas_object_intercept_call_stack_below(obj, below)) return;
if (!below)
{
evas_object_lower(obj);
return;
}
if ((EINA_INLIST_GET(obj))->next == EINA_INLIST_GET(below))
{
evas_object_inform_call_restack(obj);
return;
}
if (obj->smart.parent)
{
if (obj->smart.parent != below->smart.parent)
{
ERR("BITCH! evas_object_stack_below(), %p not inside same smart as %p!", obj, below);
return;
}
evas_object_smart_member_stack_below(obj, below);
}
else
{
if (below->smart.parent)
{
ERR("BITCH! evas_object_stack_below(), %p stack below %p, but below has smart parent, obj does not", obj, below);
return;
}
if (obj->layer != below->layer)
{
ERR("BITCH! evas_object_stack_below(), %p stack below %p, not matching layers", obj, below);
return;
}
if (obj->in_layer)
{
obj->layer->objects = (Evas_Object *)eina_inlist_remove(EINA_INLIST_GET(obj->layer->objects),
EINA_INLIST_GET(obj));
obj->layer->objects = (Evas_Object *)eina_inlist_prepend_relative(EINA_INLIST_GET(obj->layer->objects),
EINA_INLIST_GET(obj),
EINA_INLIST_GET(below));
}
}
if (obj->clip.clipees)
{
evas_object_inform_call_restack(obj);
return;
}
if (obj->layer) evas_render_invalidate(obj->layer->evas);
obj->restack = 1;
evas_object_change(obj);
evas_object_inform_call_restack(obj);
if (obj->layer->evas->events_frozen <= 0)
{
if (!evas_event_passes_through(obj))
{
if (!obj->smart.smart)
{
if (evas_object_is_in_output_rect(obj,
obj->layer->evas->pointer.x,
obj->layer->evas->pointer.y, 1, 1) &&
obj->cur.visible)
evas_event_feed_mouse_move(obj->layer->evas,
obj->layer->evas->pointer.x,
obj->layer->evas->pointer.y,
obj->layer->evas->last_timestamp,
NULL);
}
}
}
}