static void
vm_action_cb(const char *reply, void *data)
{
xmlNode *r;
Elm_Genlist_Item *gl;
vmitem *item;
zrpc_vm *vm;
if (!reply || !(r = xml_parse_xml(reply)) || (!xml_parse_int(r)))
{
elm_label_label_set(win->main_vm->status, "Job add failed!");
evas_object_show(win->main_vm->notify);
return;
}
elm_label_label_set(win->main_vm->status, "Job add was successful!");
evas_object_show(win->main_vm->notify);
if ((win->view == win->main_vm->view) || (win->view == win->main_user->view))
{
gl = elm_genlist_selected_item_get(win->main_vm->list);
if (gl)
{
item = (vmitem*)elm_genlist_item_data_get(gl);
vm = item->vm;
win->list = eina_list_remove(win->list, vm);
#ifdef DEBUG
printf("Removing %s from all lists...\n", vm->uuid);
#endif
win->elist = eina_list_remove(win->elist, item);
free_vmitem(item);
elm_genlist_item_del(gl);
}
}
}
static void
_e_shell_surface_parent_set(E_Client *ec, struct wl_resource *parent_resource)
{
E_Client *pc;
uint64_t pwin = 0;
if (!parent_resource)
{
ec->icccm.fetch.transient_for = EINA_FALSE;
ec->icccm.transient_for = 0;
if (ec->parent)
{
ec->parent->transients =
eina_list_remove(ec->parent->transients, ec);
if (ec->parent->modal == ec) ec->parent->modal = NULL;
ec->parent = NULL;
}
return;
}
pc = wl_resource_get_user_data(parent_resource);
if (!pc)
{
ERR("Could not get parent resource client");
return;
}
pwin = e_pixmap_window_get(pc->pixmap);
e_pixmap_parent_window_set(ec->pixmap, pwin);
/* If we already have a parent, remove it */
if (ec->parent)
{
if (pc != ec->parent)
{
ec->parent->transients =
eina_list_remove(ec->parent->transients, ec);
if (ec->parent->modal == ec) ec->parent->modal = NULL;
ec->parent = NULL;
}
}
if ((pc != ec) &&
(eina_list_data_find(pc->transients, ec) != ec))
{
pc->transients = eina_list_append(pc->transients, ec);
ec->parent = pc;
}
ec->icccm.fetch.transient_for = EINA_TRUE;
ec->icccm.transient_for = pwin;
}
/*
* etox_line_minimize - reduce the number of bits on a line
*/
void etox_line_minimize(Etox_Line * line)
{
Evas_Object *bit, *last_bit = NULL;
Eina_List *l;
CHECK_PARAM_POINTER("line", line);
l = line->bits;
if (!l)
return;
last_bit = l->data;
l = l->next;
while (l) {
bit = l->data;
/*
* Attempt to merge the bits if possible, remove the second
* one if successful.
*/
if (etox_style_merge(last_bit, bit)) {
line->bits = eina_list_remove(line->bits, bit);
l = eina_list_data_find_list(line->bits, last_bit);
l = l->next;
}
else {
last_bit = bit;
l = l->next;
}
}
}
void
termpty_save_unregister(Termpty *ty)
{
termpty_backlog_lock();
ptys = eina_list_remove(ptys, ty);
termpty_backlog_unlock();
}
/* Gadcon Api Functions */
static E_Gadcon_Client *
_gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style)
{
E_AppMenu_Instance *inst;
E_AppMenu_Context *ctxt;
EINA_SAFETY_ON_NULL_RETURN_VAL(appmenu_module, NULL);
inst = calloc(1, sizeof(E_AppMenu_Instance));
EINA_SAFETY_ON_NULL_RETURN_VAL(inst, NULL);
ctxt = appmenu_module->data;
ctxt->instances = eina_list_append(ctxt->instances, inst);
inst->evas = gc->evas;
inst->ctx = ctxt;
inst->box = evas_object_box_add(inst->evas);
evas_object_show(inst->box);
inst->gcc = e_gadcon_client_new(gc, name, id, style, inst->box);
if (!inst->gcc)
{
evas_object_del(inst->box);
ctxt->instances = eina_list_remove(ctxt->instances, inst);
free(inst);
return NULL;
}
inst->gcc->data = inst;
_gc_orient(inst->gcc, inst->gcc->gadcon->orient);
if (!ctxt->iface)
appmenu_dbus_registrar_server_init(ctxt);
return inst->gcc;
}
static Eina_Bool
_cb_border_remove(void *data, EINA_UNUSED int type, void *event)
{
E_Event_Client *ev = event;
Client_Item *bi;
Eina_List *l;
Plugin *p = data;
EINA_LIST_FOREACH(p->clients, l, bi)
if (bi->client == ev->ec)
break;
if (!bi) return ECORE_CALLBACK_PASS_ON;
EVRY_PLUGIN_ITEMS_CLEAR(p);
p->clients = eina_list_remove(p->clients, bi);
EVRY_ITEM_FREE(bi);
EVRY_PLUGIN_ITEMS_ADD(p, p->clients, p->input, 1, 0);
EVRY_PLUGIN_UPDATE(p, EVRY_UPDATE_ADD);
return ECORE_CALLBACK_PASS_ON;
}
static void
_gc_shutdown(E_Gadcon_Client *gcc)
{
Instance *inst;
if (!(inst = gcc->data)) return;
evas_object_event_callback_del(inst->tclock, EVAS_CALLBACK_MOUSE_DOWN,
_tclock_cb_mouse_down);
evas_object_event_callback_del(inst->tclock, EVAS_CALLBACK_MOUSE_IN,
_tclock_cb_mouse_in);
evas_object_event_callback_del(inst->tclock, EVAS_CALLBACK_MOUSE_OUT,
_tclock_cb_mouse_out);
if (inst->tclock) evas_object_del(inst->tclock);
tclock_config->instances =
eina_list_remove(tclock_config->instances, inst);
if (eina_list_count(tclock_config->instances) <= 0)
{
if (check_timer) ecore_timer_del(check_timer);
check_timer = NULL;
}
E_FREE(inst);
}
//Pop down the menu and its childrend
void eclair_menu_pop_down(Eclair_Menu *menu)
{
Eina_List *l;
Eclair_Menu_Item *item;
if (!menu)
return;
for (l = menu->items; l; l = l->next)
{
if (!(item = l->data))
continue;
eclair_menu_item_deactivate(item);
}
ecore_evas_hide(menu->window);
if (menu == _eclair_menu_root)
{
ecore_x_keyboard_ungrab();
ecore_x_pointer_ungrab();
ecore_x_window_hide(_eclair_menu_input_window);
ecore_event_handler_del(_eclair_menu_mouse_up_handler);
ecore_event_handler_del(_eclair_menu_mouse_move_handler);
_eclair_menu_root = NULL;
}
_eclair_menu_popped_menus = eina_list_remove(_eclair_menu_popped_menus, menu);
}
/*
* etox_line_merge_append - merge lines into the first line, empty the second
* @line1: the destination of the merged lines
* @line2: the line that will be merged with line1
*
* Returns no value. Moves the bits from line2 into line 1.
*/
void etox_line_merge_append(Etox_Line * line1, Etox_Line * line2)
{
Evas_Object *bit;
CHECK_PARAM_POINTER("line1", line1);
CHECK_PARAM_POINTER("line2", line2);
/*
* Move the bits from line2 to line1.
*/
while (line2->bits) {
bit = line2->bits->data;
line1->bits = eina_list_append(line1->bits, bit);
line2->bits = eina_list_remove(line2->bits, bit);
line1->length += etox_style_length(bit);
etox_selections_update(bit, line1);
}
/*
* Adjust the height, width and length of the merged line.
*/
line1->w += line2->w;
if (line2->h > line1->h)
line1->h = line2->h;
}
void
_ex_tab_delete(void)
{
if (!e->cur_tab)
{
D(("No currently selected TAB!!\n"));
return;
}
D(("Number of tabs: %d\n", eina_list_count(e->tabs)));
if (eina_list_count(e->tabs) < 1)
{
D(("Cannot remove the last tab\n"));
return;
}
D(("Delete tab %d\n", e->cur_tab->num));
D(("Remove from list\n"));
e->tabs = eina_list_remove(e->tabs, e->cur_tab);
D(("Free\n"));
etk_notebook_page_remove(ETK_NOTEBOOK(e->notebook), e->cur_tab->num);
/* Set the cur_tab on the new one */
e->cur_tab = eina_list_nth(e->tabs, etk_notebook_current_page_get(ETK_NOTEBOOK(e->notebook)));
// E_FREE(e->cur_tab);
if (eina_list_count(e->tabs) == 1)
etk_notebook_tabs_visible_set(ETK_NOTEBOOK(e->notebook), ETK_FALSE);
}
static Eina_Bool
_edje_var_timer_cb(void *data)
{
Edje_Var_Timer *et;
Edje *ed;
Embryo_Function fn;
et = data;
if (!et) return ECORE_CALLBACK_CANCEL;
ed = et->edje;
// _edje_embryo_script_reset(ed);
embryo_program_vm_push(ed->collection->script);
_edje_embryo_globals_init(ed);
embryo_parameter_cell_push(ed->collection->script, (Embryo_Cell)et->val);
ed->var_pool->timers = eina_list_remove(ed->var_pool->timers, et);
fn = et->func;
free(et);
{
void *pdata;
pdata = embryo_program_data_get(ed->collection->script);
embryo_program_data_set(ed->collection->script, ed);
embryo_program_max_cycle_run_set(ed->collection->script, 5000000);
embryo_program_run(ed->collection->script, fn);
embryo_program_data_set(ed->collection->script, pdata);
embryo_program_vm_pop(ed->collection->script);
_edje_recalc(ed);
}
return ECORE_CALLBACK_CANCEL;
}
static void
_gc_shutdown (E_Gadcon_Client * gcc)
{
Instance *inst;
inst = gcc->data;
if (inst->cb_player_track_change)
e_dbus_signal_handler_del(conn, inst->cb_player_track_change);
if (inst->cb_player_status_change)
e_dbus_signal_handler_del(conn, inst->cb_player_status_change);
empris_config->instances = eina_list_remove (empris_config->instances, inst);
evas_object_event_callback_del (inst->empris, EVAS_CALLBACK_MOUSE_DOWN,
_empris_cb_mouse_down);
evas_object_event_callback_del (inst->empris, EVAS_CALLBACK_MOUSE_IN,
_empris_cb_mouse_in);
evas_object_event_callback_del (inst->empris, EVAS_CALLBACK_MOUSE_OUT,
_empris_cb_mouse_out);
_empris_popup_destroy (inst);
evas_object_del (inst->empris);
free (inst);
inst = NULL;
}
/**
* @brief Sets the group of the radio menu-item
* @param radio_item a radio menu-item
* @param group the group to set
*/
void etk_menu_item_radio_group_set(Etk_Menu_Item_Radio *radio_item, Eina_List **group)
{
Etk_Menu_Item_Check *check_item;
Etk_Bool active;
if (!(check_item = ETK_MENU_ITEM_CHECK(radio_item)) || (group && (radio_item->group == group)))
return;
if (radio_item->group)
{
*radio_item->group = eina_list_remove(*radio_item->group, radio_item);
if (!(*radio_item->group))
{
free(radio_item->group);
radio_item->group = NULL;
}
}
if (!group)
{
group = malloc(sizeof(Eina_List *));
*group = NULL;
active = ETK_TRUE;
}
else
active = ETK_FALSE;
*group = eina_list_append(*group, radio_item);
radio_item->group = group;
etk_object_notify(ETK_OBJECT(radio_item), "group");
radio_item->can_uncheck = ETK_TRUE;
etk_menu_item_check_active_set(check_item, active);
}
/**
* @brief Sets the group of the radio-button
* @param radio_button a radio-button
* @param group the group to use
*/
void etk_radio_button_group_set(Etk_Radio_Button *radio_button, Eina_List **group)
{
Etk_Toggle_Button *toggle_button;
Etk_Bool active;
if (!(toggle_button = ETK_TOGGLE_BUTTON(radio_button)) || (group && (radio_button->group == group)))
return;
if (radio_button->group)
{
*radio_button->group = eina_list_remove(*radio_button->group, radio_button);
if (!(*radio_button->group))
{
free(radio_button->group);
radio_button->group = NULL;
}
}
if (!group)
{
group = malloc(sizeof(Eina_List *));
*group = NULL;
active = ETK_TRUE;
}
else
active = ETK_FALSE;
*group = eina_list_append(*group, radio_button);
radio_button->group = group;
etk_object_notify(ETK_OBJECT(radio_button), "group");
radio_button->can_uncheck = ETK_TRUE;
etk_toggle_button_active_set(toggle_button, active);
}
void
news_config_item_del(News_Config_Item *nic)
{
eina_stringshare_del(nic->id);
while(eina_list_count(nic->feed_refs))
{
News_Feed_Ref *fr;
fr = eina_list_data_get(nic->feed_refs);
eina_stringshare_del(fr->name);
nic->feed_refs = eina_list_remove(nic->feed_refs, fr);
}
news->config->items = eina_list_remove(news->config->items, nic);
free(nic);
}
/**
* @brief Finds an object in the cache according to its filename and its key. If the object is present in the cache,
* it will be removed from the cache and returned. Otherwise NULL is returned
* @param cache the cache system where to find the object
* @param filename the filename of the object to find
* @param key the key associated to the object to find (the group for an Edje object, the key for an image from an
* Eet file, or NULL otherwise)
* @return Returns an object corresponding to the given filename and key, or NULL if no such object is cached
*/
Evas_Object *etk_cache_find(Etk_Cache *cache, const char *filename, const char *key)
{
Etk_Cache_Item *item;
Eina_List *l;
Evas_Object *object;
if (!cache || !filename)
return NULL;
for (l = cache->cached_objects; l; l = l->next)
{
item = l->data;
if (strcmp(item->filename, filename) == 0 && (strcmp(item->key ? item->key : "", key ? key : "") == 0))
{
object = item->object;
evas_object_data_del(object, "_Etk_Cache::Node");
evas_object_event_callback_del(object, EVAS_CALLBACK_FREE, _etk_cache_object_deleted_cb);
free(item->filename);
free(item->key);
free(item);
cache->cached_objects = eina_list_remove(cache->cached_objects, item);
return object;
}
}
return NULL;
}
static void
_ecore_evas_buffer_free(Ecore_Evas *ee)
{
Ecore_Evas_Engine_Buffer_Data *bdata = ee->engine.data;
if (!bdata) return;
if (bdata->image)
{
Ecore_Evas *ee2;
ee2 = evas_object_data_get(bdata->image, "Ecore_Evas_Parent");
evas_object_del(bdata->image);
if (ee2)
ee2->sub_ecore_evas = eina_list_remove(ee2->sub_ecore_evas, ee);
}
else
{
bdata->free_func(bdata->data, bdata->pixels);
}
free(bdata);
ee->engine.data = NULL;
ecore_event_evas_shutdown();
}
static void
_cb_feed_add(void *data, void *data2)
{
E_Config_Dialog_Data *cfdata;
News_Item *ni;
News_Feed *f;
Eina_List *l;
cfdata = data;
ni = cfdata->ni;
for (l=cfdata->ilist_feeds_sel; l; l=eina_list_next(l))
{
f = l->data;
if (f->item) continue;
if (news_feed_attach(f, NULL, ni))
news_feed_obj_refresh(f, 1, 1);
/* dont reselect this feed */
cfdata->ilist_feeds_sel = eina_list_remove(cfdata->ilist_feeds_sel, f);
}
news_item_refresh(ni, 1, 0, 0);
news_feed_list_ui_refresh();
news_viewer_refresh(ni->viewer);
news_config_save();
}
Enlil_IPTC_Job *
enlil_iptc_job_prepend(Enlil_Photo *photo,
Enlil_IPTC_Done_Cb cb,
void *data)
{
ASSERT_RETURN(photo != NULL);
Eina_List *l;
Enlil_IPTC_Job *job;
EINA_LIST_FOREACH(l_jobs, l, job)
if(job->photo == photo)
break;
if(!job)
{
job = calloc(1, sizeof(Enlil_IPTC_Job));
job->photo = photo;
job->cb = cb;
job->data = data;
}
else
l_jobs = eina_list_remove(l_jobs, job);
l_jobs = eina_list_prepend(l_jobs, job);
_job_next();
return job;
}
static void
_job_next(void)
{
char buf[PATH_MAX];
if(running)
return;
if(!l_jobs)
return;
running = 1;
Enlil_IPTC_Job *job = eina_list_data_get(l_jobs);
l_jobs = eina_list_remove(l_jobs, job);
job_current = job;
snprintf(buf, PATH_MAX, "%s/%s", enlil_photo_path_get(job_current->photo),
enlil_photo_file_name_get(job_current->photo));
Enlil_IPTC_Thread_Data *data = calloc(1, sizeof(Enlil_IPTC_Thread_Data));
data->file = eina_stringshare_add(buf);
ecore_thread_run(_iptc_thread, _end_cb, NULL, data);
running = 1;
}
static Eina_Bool
_cb_fd_handler(void *data,
Ecore_Fd_Handler *fd_handler)
{
struct e_mixer_callback_desc *desc;
desc = data;
if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_ERROR))
{
desc->handlers = eina_list_remove(desc->handlers, fd_handler);
if (!desc->handlers)
{
E_Mixer_System *s;
int (*f)(void *,
E_Mixer_System *);
void *d;
s = desc->self;
f = desc->func;
d = desc->data;
_mixer_callback_del(s, desc);
_mixer_callback_add(s, f, d);
}
return ECORE_CALLBACK_CANCEL;
}
if (!desc->idler)
desc->idler = ecore_idler_add(_cb_dispatch, desc);
return ECORE_CALLBACK_RENEW;
}
static void
_e_shell_surface_destroy(struct wl_resource *resource)
{
E_Client *ec;
/* DBG("Shell Surface Destroy: %d", wl_resource_get_id(resource)); */
/* get the client for this resource */
if ((ec = wl_resource_get_user_data(resource)))
{
if (!e_object_unref(E_OBJECT(ec))) return;
if (e_object_is_del(E_OBJECT(ec))) return;
if (ec->comp_data)
{
E_FREE(ec->comp_data->shell.data);
if (ec->comp_data->mapped)
{
if ((ec->comp_data->shell.surface) &&
(ec->comp_data->shell.unmap))
ec->comp_data->shell.unmap(ec->comp_data->shell.surface);
}
if (ec->parent)
{
ec->parent->transients =
eina_list_remove(ec->parent->transients, ec);
}
/* wl_resource_destroy(ec->comp_data->shell.surface); */
ec->comp_data->shell.surface = NULL;
}
}
}
static void
_evas_gl_preload_main_loop_wakeup(void)
{
Evas_GL_Texture_Async_Preload *async;
evas_gl_make_current_cb cb = async_gl_make_current;
void *data = async_engine_data;
Eina_Bool running = async_loader_running;
if (running) evas_gl_preload_render_lock(cb, data);
EINA_LIST_FREE(async_loader_todie, async)
{
Eo *target;
EINA_LIST_FREE(async->tex->targets, target)
eo_do(target, evas_obj_image_pixels_dirty_set(EINA_TRUE));
async->im->cache_entry.flags.preload_done = 0;
async->tex->was_preloaded = EINA_TRUE;
async->tex->ptt->allocations = eina_list_remove(async->tex->ptt->allocations, async->tex->aptt);
pt_unref(async->tex->ptt);
async->tex->ptt = NULL;
free(async->tex->aptt);
async->tex->aptt = NULL;
evas_gl_common_texture_free(async->tex, EINA_FALSE);
evas_cache_image_drop(&async->im->cache_entry);
free(async);
}
static void
toggle_floating(E_Border *bd)
{
if (!bd || !_G.tinfo) return;
if (eina_list_data_find(_G.tinfo->floating_windows, bd) == bd)
{
_G.tinfo->floating_windows = eina_list_remove(_G.tinfo->floating_windows, bd);
if (!tiling_g.config->dont_touch_borders &&
tiling_g.config->tiling_border &&
(!bd->bordername || strcmp(bd->bordername, tiling_g.config->tiling_border)))
change_window_border(bd, tiling_g.config->tiling_border);
e_border_idler_before();
rearrange_windows(bd, 0);
}
else
{
int w = bd->w, h = bd->h;
/* To give the user a bit of feedback we restore the original border */
/* TODO: save the original border, don't just restore the default one */
_G.tinfo->floating_windows = eina_list_prepend(_G.tinfo->floating_windows, bd);
if (!tiling_g.config->dont_touch_borders &&
tiling_g.config->floating_border &&
(!bd->bordername || strcmp(bd->bordername, tiling_g.config->floating_border)))
change_window_border(bd, tiling_g.config->floating_border);
e_border_idler_before();
e_border_resize(bd, w, h);
}
}
static void
_gc_shutdown(E_Gadcon_Client *gcc)
{
Instance *inst;
Forecasts *w;
inst = gcc->data;
w = inst->forecasts;
if (inst->popup) _forecasts_popup_destroy(inst);
if (inst->check_timer)
ecore_timer_del(inst->check_timer);
if (inst->add_handler)
ecore_event_handler_del(inst->add_handler);
if (inst->data_handler)
ecore_event_handler_del(inst->data_handler);
if (inst->del_handler)
ecore_event_handler_del(inst->del_handler);
if (inst->server)
ecore_con_server_del(inst->server);
if (inst->area)
eina_stringshare_del(inst->area);
eina_strbuf_free(inst->buffer);
inst->server = NULL;
forecasts_config->instances =
eina_list_remove(forecasts_config->instances, inst);
evas_object_event_callback_del(w->forecasts_obj, EVAS_CALLBACK_MOUSE_DOWN,
_forecasts_cb_mouse_down);
_forecasts_free(w);
E_FREE(inst);
}
void
etox_line_unwrap(Etox *et, Etox_Line *line)
{
Eina_List *l, *prevline;
Evas_Object *marker;
if (!et->lines)
return;
prevline = eina_list_data_find_list(et->lines, line);
l = prevline->next;
while (l) {
Eina_List *ll;
line = l->data;
if (!(line->flags & ETOX_LINE_WRAPPED))
break;
/* remove any wrap marker bits */
ll = line->bits;
while (ll) {
int t;
marker = ll->data;
ll = ll->next;
t = etox_style_get_type(marker);
if (t == ETOX_BIT_TYPE_WRAP_MARKER) {
line->bits = eina_list_remove(line->bits,
marker);
evas_object_del(marker);
}
}
/* remove the line from the list */
et->lines = eina_list_remove(et->lines, line);
/* merge the two lines */
etox_line_merge_append(prevline->data, line);
etox_line_free(line);
l = prevline->next;
}
// etox_line_minimize(line);
}
void
e_phys_constraint_del(E_Phys_Constraint *con)
{
if (!con) return;
if (con->world)
con->world->constraints = eina_list_remove(con->world->constraints, con);
con->free(con);
}
static void
device_list_device_del(IGD_Device *device)
{
device_list = eina_list_remove(device_list, device);
eupnp_device_info_unref(device->device);
elm_list_item_del(device->item);
free(device);
}
static void
_item_free(Elm_Index_Item *it)
{
ELM_INDEX_DATA_GET(WIDGET(it), sd);
sd->items = eina_list_remove(sd->items, it);
if (it->letter) eina_stringshare_del(it->letter);
}
void
enna_config_section_parser_unregister (Enna_Config_Section_Parser *parser)
{
if (!parser)
return;
cfg_parsers = eina_list_remove(cfg_parsers, parser);
}