EAPI Evas_Object * evas_object_top_get(const Evas *e) { Evas_Object *obj = NULL; Eina_Inlist *list; Evas_Layer *layer; MAGIC_CHECK(e, Evas, MAGIC_EVAS); return NULL; MAGIC_CHECK_END(); list = EINA_INLIST_GET(e->layers); if (!list) return NULL; layer = (Evas_Layer *) list->last; if (!layer) return NULL; list = EINA_INLIST_GET(layer->objects); if (!list) return NULL; obj = (Evas_Object *) list->last; if (!obj) return NULL; while (obj) { if (!obj->delete_me) return obj; obj = evas_object_below_get_internal(obj); } return obj; }
/** * Resumes a frozen (paused) timer. * * @param timer The timer to be resumed. * * The timer will be resumed from its previous relative position in time. That * means, if it had X seconds remaining until expire when it was paused, it will * be started now with those same X seconds remaining to expire again. But * notice that the interval time won't be touched by this call or by * ecore_timer_freeze(). * * @see ecore_timer_freeze() */ EAPI void ecore_timer_thaw(Ecore_Timer *timer) { double now; _ecore_lock(); if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER)) { ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER, "ecore_timer_thaw"); goto unlock; } /* Timer not frozen */ if (!timer->frozen) goto unlock; 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); unlock: _ecore_unlock(); }
/** * Delete the specified timer from the timer list. * @param timer The timer to delete. * @return The data pointer set for the timer when @ref ecore_timer_add was * called. @c NULL is returned if the function is unsuccessful. * * Note: @p timer must be a valid handle. If the timer function has already * returned 0, the handle is no longer valid (and does not need to be delete). */ EAPI void * ecore_timer_del(Ecore_Timer *timer) { if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER)) { ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER, "ecore_timer_del"); return NULL; } if (timer->frozen && !timer->references) { void *data = timer->data; suspended = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer)); if (timer->delete_me) timers_delete_me--; free(timer); return data; } EINA_SAFETY_ON_TRUE_RETURN_VAL(timer->delete_me, NULL); timer->delete_me = 1; timers_delete_me++; return timer->data; }
Ecore_File_Monitor * ecore_file_monitor_backend_add(const char *path, void (*func) (void *data, Ecore_File_Monitor *em, Ecore_File_Event event, const char *path), void *data) { Ecore_File_Monitor *em; size_t len; if (!path) return NULL; if (!func) return NULL; em = calloc(1, sizeof(Ecore_File_Monitor_Poll)); if (!em) return NULL; if (!_timer) _timer = ecore_timer_add(_interval, _ecore_file_monitor_poll_handler, NULL); else ecore_timer_interval_set(_timer, ECORE_FILE_INTERVAL_MIN); em->path = strdup(path); len = strlen(em->path); if (em->path[len - 1] == '/' && strcmp(em->path, "/")) em->path[len - 1] = 0; em->func = func; em->data = data; ECORE_FILE_MONITOR_POLL(em)->mtime = ecore_file_mod_time(em->path); _monitors = ECORE_FILE_MONITOR(eina_inlist_append(EINA_INLIST_GET(_monitors), EINA_INLIST_GET(em))); if (ecore_file_exists(em->path)) { if (ecore_file_is_dir(em->path)) { /* Check for subdirs */ Eina_List *files; char *file; files = ecore_file_ls(em->path); EINA_LIST_FREE(files, file) { Ecore_File *f; char buf[PATH_MAX]; f = calloc(1, sizeof(Ecore_File)); if (!f) { free(file); continue; } snprintf(buf, sizeof(buf), "%s/%s", em->path, file); f->name = file; f->mtime = ecore_file_mod_time(buf); f->is_dir = ecore_file_is_dir(buf); em->files = (Ecore_File *) eina_inlist_append(EINA_INLIST_GET(em->files), EINA_INLIST_GET(f)); } }
EAPI void ecore_timer_freeze(Ecore_Timer *timer) { double now; if (!ECORE_MAGIC_CHECK(timer, ECORE_MAGIC_TIMER)) { ECORE_MAGIC_FAIL(timer, ECORE_MAGIC_TIMER, "ecore_timer_freeze"); return ; } /* Timer already frozen */ if (timer->frozen) return ; timers = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer)); suspended = (Ecore_Timer *) eina_inlist_prepend(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer)); now = ecore_time_get(); timer->pending = timer->at - now; timer->at = 0.0; timer->frozen = 1; }
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); }
/** * Get the exact tile for the given position and zoom. * * If the tile was unused then it's removed from the cache. * * After usage, please give it back using * ewk_tile_matrix_tile_put(). If you just want to check if it exists, * then use ewk_tile_matrix_tile_exact_exists(). * * @param tm the tile matrix to get tile from. * @param col the column number. * @param row the row number. * @param zoom the exact zoom to use. * * @return The tile instance or @c NULL if none is found. If the tile * was in the unused cache it will be @b removed (thus * considered used) and one should give it back with * ewk_tile_matrix_tile_put() afterwards. * * @see ewk_tile_matrix_tile_nearest_get() * @see ewk_tile_matrix_tile_exact_get() */ Ewk_Tile *ewk_tile_matrix_tile_exact_get(Ewk_Tile_Matrix *tm, unsigned long col, unsigned int row, float zoom) { Ewk_Tile *t, *item, *item_found = NULL; Eina_Inlist *inl; t = eina_matrixsparse_data_idx_get(tm->matrix, row, col); if (!t) return NULL; if (t->zoom == zoom) goto end; EINA_INLIST_FOREACH(EINA_INLIST_GET(t), item) { if (item->zoom != zoom) continue; item_found = item; break; } if (!item_found) return NULL; inl = eina_inlist_promote(EINA_INLIST_GET(t), EINA_INLIST_GET(item_found)); eina_matrixsparse_data_idx_replace(tm->matrix, row, col, inl, NULL); end: if (!t->visible) { if (!ewk_tile_unused_cache_tile_get(tm->tuc, t)) WRN("Ewk_Tile was unused but not in cache? bug!"); } return t; }
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; }
static void _evas_cache_engine_image_remove_activ(Evas_Cache_Engine_Image *cache, Engine_Image_Entry *eim) { if (eim->flags.cached) { if (eim->flags.dirty) { cache->dirty = eina_inlist_remove(cache->dirty, EINA_INLIST_GET(eim)); } else if (eim->flags.activ) { eina_hash_del(cache->activ, eim->cache_key, eim); } else { cache->usage -= cache->func.mem_size_get(eim); eina_hash_del(cache->inactiv, eim->cache_key, eim); cache->lru = eina_inlist_remove(cache->lru, EINA_INLIST_GET(eim)); } eim->flags.cached = 0; eim->flags.dirty = 0; eim->flags.activ = 0; } }
static void _ecore_timer_set(Ecore_Timer *timer, double at, double in, Ecore_Task_Cb func, void *data) { Ecore_Timer *t2; timers_added = 1; timer->at = at; timer->in = in; timer->func = func; timer->data = data; timer->just_added = 1; timer->frozen = 0; timer->pending = 0.0; if (timers) { EINA_INLIST_REVERSE_FOREACH(EINA_INLIST_GET(timers), t2) { if (timer->at > t2->at) { timers = (Ecore_Timer *) eina_inlist_append_relative(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer), EINA_INLIST_GET(t2)); return; } } } timers = (Ecore_Timer *) eina_inlist_prepend(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer)); }
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 _ecore_timer_cleanup(void) { Ecore_Timer *l; int in_use = 0, todo = timers_delete_me, done = 0; if (!timers_delete_me) return; for (l = timers; l;) { Ecore_Timer *timer = l; l = (Ecore_Timer *) EINA_INLIST_GET(l)->next; if (timer->delete_me) { if (timer->references) { in_use++; continue; } timers = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(timers), EINA_INLIST_GET(timer)); ECORE_MAGIC_SET(timer, ECORE_MAGIC_NONE); free(timer); timers_delete_me--; done++; if (timers_delete_me == 0) return; } } for (l = suspended; l;) { Ecore_Timer *timer = l; l = (Ecore_Timer *) EINA_INLIST_GET(l)->next; if (timer->delete_me) { if (timer->references) { in_use++; continue; } suspended = (Ecore_Timer *) eina_inlist_remove(EINA_INLIST_GET(suspended), EINA_INLIST_GET(timer)); ECORE_MAGIC_SET(timer, ECORE_MAGIC_NONE); free(timer); timers_delete_me--; done++; if (timers_delete_me == 0) return; } } if ((!in_use) && (timers_delete_me)) { ERR("%d timers to delete, but they were not found!" "Stats: todo=%d, done=%d, pending=%d, in_use=%d. " "reset counter.", timers_delete_me, todo, done, todo - done, in_use); timers_delete_me = 0; } }
int _ecore_timer_call(double when) { if (!timers) return 0; if (last_check > when) { Ecore_Timer *timer; /* User set time backwards */ EINA_INLIST_FOREACH(timers, timer) timer->at -= (last_check - when); } last_check = when; if (!timer_current) { /* regular main loop, start from head */ timer_current = timers; } else { /* recursive main loop, continue from where we were */ Ecore_Timer *timer_old = timer_current; timer_current = (Ecore_Timer *)EINA_INLIST_GET(timer_current)->next; _ecore_timer_reschedule(timer_old, when); } while (timer_current) { Ecore_Timer *timer = timer_current; if (timer->at > when) { timer_current = NULL; /* ended walk, next should restart. */ return 0; } if ((timer->just_added) || (timer->delete_me)) { timer_current = (Ecore_Timer*)EINA_INLIST_GET(timer_current)->next; continue; } timer->references++; if (!timer->func(timer->data)) { if (!timer->delete_me) ecore_timer_del(timer); } timer->references--; if (timer_current) /* may have changed in recursive main loops */ timer_current = (Ecore_Timer *)EINA_INLIST_GET(timer_current)->next; _ecore_timer_reschedule(timer, when); } return 0; }
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); }
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_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 inline Ecore_Timer * _ecore_timer_after_get(Ecore_Timer *base) { Ecore_Timer *timer = (Ecore_Timer *) EINA_INLIST_GET(base)->next; double maxtime = base->at + precision; while ((timer) && ((timer->delete_me) || (timer->just_added)) && (timer->at <= maxtime)) timer = (Ecore_Timer *) EINA_INLIST_GET(timer)->next; if ((!timer) || (timer->at > maxtime)) return NULL; return timer; }
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; }
Comic_Chapter_Item * comic_chapter_item_chapter_add(Comic_Chapter *cc, Comic_Chapter_Item *cci) { Eina_Bool forward = EINA_TRUE; //DBG("(cc=%g, cci=%g)", cc->number, cci ? cci->cc->number : 0); if (!cc->csd->cs->chapters) return _comic_chapter_item_new(cc); if (!cci) { if (cc->number > cc->csd->cs->total / 2) { cci = EINA_INLIST_CONTAINER_GET(cc->csd->cs->chapters->last, Comic_Chapter_Item); forward = EINA_FALSE; } else cci = EINA_INLIST_CONTAINER_GET(cc->csd->cs->chapters, Comic_Chapter_Item); } if (cci->cc->number > cc->number) forward = EINA_FALSE; if (forward) { //DBG("ITER: FORWARD"); for (; cci; cci = comic_chapter_item_next_get(cci)) { if (cci->cc->number < cc->number) continue; cc->csd->chapters = eina_inlist_remove(cc->csd->chapters, EINA_INLIST_GET(cc)); //DBG("INSERT: %g", cci->cc->number); cci->chapters = eina_inlist_sorted_insert(cci->chapters, EINA_INLIST_GET(cc), (Eina_Compare_Cb)_comic_chapter_sort_cb); cci->chapter_count++; _comic_chapter_item_update(cci, cc, EINA_FALSE); return cci; } return _comic_chapter_item_new(cc); } //DBG("ITER: BACKWARD"); for (; cci; cci = comic_chapter_item_prev_get(cci)) { if (cci->cc->number > cc->number) continue; cc->csd->chapters = eina_inlist_remove(cc->csd->chapters, EINA_INLIST_GET(cc)); //DBG("INSERT: %g", cci->cc->number); cci->chapters = eina_inlist_sorted_insert(cci->chapters, EINA_INLIST_GET(cc), (Eina_Compare_Cb)_comic_chapter_sort_cb); cci->chapter_count++; _comic_chapter_item_update(cci, cc, EINA_FALSE); return cci; } return _comic_chapter_item_new(cc); }
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; }
EAPI void evas_object_lower(Evas_Object *obj) { MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); if (evas_object_intercept_call_lower(obj)) return; if (!((EINA_INLIST_GET(obj))->prev)) { evas_object_inform_call_restack(obj); return; } if (obj->smart.parent) evas_object_smart_member_lower(obj); else { if (obj->in_layer) obj->layer->objects = (Evas_Object *)eina_inlist_promote(EINA_INLIST_GET(obj->layer->objects), EINA_INLIST_GET(obj)); } 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); } } } }
static void esql_mysac_res(Esql_Res *res) { MYSAC_ROW *row; MYSAC_RES *re; MYSAC *m; Esql_Row *r; re = res->backend.res = mysac_get_res(res->e->backend.db); if (!re) return; m = res->e->backend.db; res->desc = esql_module_desc_get(re->nb_cols, (Esql_Module_Setup_Cb)esql_module_setup_cb, res); mysac_first_row(re); row = mysac_fetch_row(re); if (!row) /* must be insert/update/etc */ { res->affected = m->affected_rows; res->id = m->insert_id; return; } res->row_count = mysac_num_rows(re); do { r = esql_row_calloc(1); EINA_SAFETY_ON_NULL_RETURN(r); r->res = res; esql_mysac_row_init(r, row); res->rows = eina_inlist_append(res->rows, EINA_INLIST_GET(r)); } while ((row = mysac_fetch_row(re))); }
static Eina_Simple_XML_Node_Data * _eina_simple_xml_node_data_new(Eina_Simple_XML_Node_Tag *parent, Eina_Simple_XML_Node_Type type, const char *content, unsigned length) { Eina_Simple_XML_Node_Data *n; if (!content) return NULL; n = malloc(sizeof(*n) + length + 1); if (!n) { ERR("could not allocate memory for node"); return NULL; } EINA_MAGIC_SET(&n->base, EINA_MAGIC_SIMPLE_XML_DATA); n->base.type = type; n->base.parent = parent; n->length = length; memcpy(n->data, content, length); n->data[length] = '\0'; if (parent) parent->children = eina_inlist_append (parent->children, EINA_INLIST_GET(&n->base)); return n; }
EAPI Eina_Bool eldbus_signal_handler_match_extra_vset(Eldbus_Signal_Handler *sh, va_list ap) { const char *key = NULL, *read; DBusError err; ELDBUS_SIGNAL_HANDLER_CHECK_RETVAL(sh, EINA_FALSE); dbus_error_init(&err); dbus_bus_remove_match(sh->conn->dbus_conn, eina_strbuf_string_get(sh->match), &err); EINA_SAFETY_ON_TRUE_RETURN_VAL(dbus_error_is_set(&err), EINA_FALSE); for (read = va_arg(ap, char *); read; read = va_arg(ap, char *)) { Signal_Argument *arg; if (!key) { key = read; continue; } arg = calloc(1, sizeof(Signal_Argument)); EINA_SAFETY_ON_NULL_GOTO(arg, error); if (!strncmp(key, ARGX, strlen(ARGX))) { int id = atoi(key + strlen(ARGX)); arg->index = (unsigned short) id; arg->value = eina_stringshare_add(read); sh->args = eina_inlist_sorted_state_insert(sh->args, EINA_INLIST_GET(arg), _sort_arg, sh->state_args); _match_append(sh->match, key, read); } else { ERR("%s not supported", key); free(arg); } key = NULL; } dbus_error_init(&err); dbus_bus_add_match(sh->conn->dbus_conn, eina_strbuf_string_get(sh->match), &err); if (!dbus_error_is_set(&err)) return EINA_TRUE; ERR("Error setting new match."); return EINA_FALSE; error: dbus_error_init(&err); dbus_bus_add_match(sh->conn->dbus_conn, eina_strbuf_string_get(sh->match), &err); if (dbus_error_is_set(&err)) ERR("Error setting partial extra arguments."); return EINA_FALSE; }
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 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; }
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; }
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; }
static Ecore_Animator * _ecore_animator_add(Ecore_Task_Cb func, const void *data) { Ecore_Animator *animator = NULL; if (!func) return animator; animator = ecore_animator_calloc(1); if (!animator) return animator; ECORE_MAGIC_SET(animator, ECORE_MAGIC_ANIMATOR); animator->func = func; animator->data = (void *)data; animator->just_added = EINA_TRUE; animators = (Ecore_Animator *)eina_inlist_append(EINA_INLIST_GET(animators), EINA_INLIST_GET(animator)); _begin_tick(); return animator; }