static void _exml_write_element(EXML_Node *node, xmlTextWriterPtr writer) { EXML_Node *child; Ecore_List *keys; xmlChar *name; xmlTextWriterStartElement( writer, (xmlChar *) node->tag ); keys = ecore_hash_keys( node->attributes ); ecore_list_first_goto( keys ); while( (name = ecore_list_next( keys )) ) { xmlChar *value = ecore_hash_get( node->attributes, name ); xmlTextWriterWriteAttribute( writer, name, value ); } ecore_list_destroy( keys ); if (node->value) xmlTextWriterWriteString( writer, (xmlChar *) node->value ); ecore_list_first_goto( node->children ); while( (child = ecore_list_next( node->children )) ) _exml_write_element( child, writer ); xmlTextWriterEndElement( writer ); }
void entropy_notify_event_expire_requestor_layout(void* requestor) { /*HACK - assume the requestor is an entropy_gui_component_instance* - * safe for now - but we commit ourselves here*/ entropy_notification_engine* engine = entropy_core_get_core()->notify; entropy_gui_component_instance* instance = requestor; entropy_gui_component_instance* layout = instance->layout_parent; entropy_notify_event* ev; ecore_list_first_goto(engine->op_queue); ev = ecore_list_current(engine->op_queue); while ( ev) { if ( ((entropy_gui_component_instance*)ev->requestor_data)->layout_parent == layout) { if (!ev->processed) { ecore_list_remove(engine->op_queue); entropy_notify_event_destroy(ev); printf("Removed event, unprocessed: %p\n", ev); ev = ecore_list_current(engine->op_queue); } else { printf("Left event, processed: %p\n", ev); ev = ecore_list_next(engine->op_queue); } } else { printf("Left event, different layout: %p\n", ev); ev = ecore_list_next(engine->op_queue); } } }
static Ecore_List * _list_keys_order (Ecore_List *keys) { Ecore_List *l; char *key; l = ecore_list_new (); ecore_list_first_goto(keys); while ((key = ecore_list_next(keys))) { char *str; ecore_list_first_goto (l); while ((str = ecore_list_next(l)) && (strcasecmp (key, str) >= 0)) { } if (!str) ecore_list_append (l, key); else { ecore_list_index_goto (l, ecore_list_index (l) - 1); ecore_list_insert (l, key); } } ecore_list_destroy (keys); return l; }
char* ewl_entropy_tip_window_tip_next() { char* next = ecore_list_next(tool_tips); if (!next) { ecore_list_first_goto(tool_tips); next = ecore_list_next(tool_tips); } return next; }
static E_Widget * _e_widget_spinner_handle(Enhance *en, EXML_Node *node) { E_Widget *spinner; char *id; Ecore_List *props; EXML_Node *prop; double value; double min = 0; double max = 0; double step_inc = 1; double page_inc = 1; double page_size = 1; id = ecore_hash_get(node->attributes, "id"); if(!id) return NULL; props = node->children; ecore_list_first_goto(props); prop = ecore_list_current(props); while(prop != NULL) { if(!strcmp(prop->tag, "property")) { char *name; name = ecore_hash_get(prop->attributes, "name"); if(!name) { prop = ecore_list_next(props); continue; } if(!strcmp(name, "adjustment")) { if(prop->value) { char *adj; adj = strdup(prop->value); sscanf(adj, "%lf %lf %lf %lf %lf %lf", &value, &min, &max, &step_inc, &page_inc, &page_size); E_FREE(adj); } } } prop = ecore_list_next(props); } ecore_list_first_goto(props); spinner = _e_widget_new(en, node, etk_spinner_new(min, max, value, step_inc, page_inc), id); return spinner; }
void ewl_icon_local_viewer_delete_cb (Ewl_Widget * w, void *ev_data, void *user_data) { Ecore_List *file_list = user_data; const char *text = ewl_button_label_get (EWL_BUTTON (w)); entropy_generic_file *file; entropy_gui_component_instance *instance; if (!strcmp (text, "Yes")) { entropy_plugin *plugin; void (*del_func) (entropy_generic_file * source); ecore_list_first_goto (file_list); /*As mentioned below, this is awkward, * but we avoid a sep. data structure here, * as long as we make sure this is documented * i.e. - this first item on this list is the plugin * reference */ instance = ecore_list_next (file_list); plugin = entropy_plugins_type_get_first (ENTROPY_PLUGIN_BACKEND_FILE, ENTROPY_PLUGIN_SUB_TYPE_ALL); /*Get the func ref */ del_func = dlsym (plugin->dl_ref, "entropy_filesystem_file_remove"); while ((file = ecore_list_next (file_list))) { printf ("Deleting '%s'\n", file->filename); (*del_func) (file); } } else { printf ("Selected cancel..\n"); } /*Um...FIXME bad - we need to save a reference to the dialog somewhere */ ewl_widget_destroy (w->parent->parent->parent); ecore_list_destroy (file_list); }
void ewl_iconbox_file_copy_cb (Ewl_Widget * w, void *ev_data, void *user_data) { Ecore_List *icon_list; gui_file *file; Ewl_Iconbox_Icon *list_item; entropy_gui_component_instance *instance = (entropy_gui_component_instance *) user_data; /*Clear the existing contents */ entropy_core_selected_files_clear (instance->core); icon_list = ewl_iconbox_get_selection (EWL_ICONBOX (((entropy_icon_viewer *) instance->data)-> iconbox)); ecore_list_first_goto (icon_list); while ((list_item = ecore_list_next (icon_list))) { file = ecore_hash_get (((entropy_icon_viewer *) instance->data)->icon_hash, list_item); entropy_core_selected_file_add (file->file); } ecore_list_destroy (icon_list); }
/** * Move the current xml to its next sibling, return NULL and move to parent * at the end of the list * @param xml The xml document * @return The current xml tag name or NULL * @ingroup EXML_Traversal_Group */ char *exml_next_nomove(EXML *xml) { Ecore_List *p_list; EXML_Node *parent, *cur; CHECK_PARAM_POINTER_RETURN("xml", xml, NULL); if (xml->current) { cur = xml->current; parent = cur->parent; if (parent) { p_list = parent->children; ecore_list_goto( p_list, xml->current ); ecore_list_next( p_list ); if ((xml->current = ecore_list_current(p_list)) == NULL) { xml->current = cur; return NULL; } } else xml->current = NULL; } return xml->current ? xml->current->tag : NULL; }
static void _enum_display (Ewl_Widget *w, void *ev_data, void *user_data) { Ecrin_Hash_Data *data; Ecrin_Enum *e; Ecrin_Enum_Item *item; char str[4096]; data = (Ecrin_Hash_Data *)user_data; e = (Ecrin_Enum *)data->data; ewl_text_text_set (EWL_TEXT (text), data->efl_name); ewl_text_text_append (EWL_TEXT (text), "\n"); ewl_text_text_append (EWL_TEXT (text), "\n"); snprintf (str, 4096, "enum %s\n", e->name); ewl_text_text_append (EWL_TEXT (text), str); ewl_text_text_append (EWL_TEXT (text), "{\n"); ecore_list_first_goto (e->items); while ((item = ecore_list_next (e->items))) { snprintf (str, 4096, " %s", item->name); ewl_text_text_append (EWL_TEXT (text), str); if (item->value) snprintf (str, 4096, " = %s", item->value); ewl_text_text_append (EWL_TEXT (text), str); if (ecore_list_index (e->items) != ecore_list_count (e->items)) ewl_text_text_append (EWL_TEXT (text), ","); ewl_text_text_append (EWL_TEXT (text), "\n"); } ewl_text_text_append (EWL_TEXT (text), "};\n"); }
void evfs_posix_monitor_remove(evfs_client * client, char *path) { Ecore_List *mon_list = ecore_hash_get(posix_monitor_hash, path); Ecore_File_Monitor *em = NULL; if (!mon_list) { /*There is no one monitoring this - so this client can't be... */ return; } else { evfs_file_monitor *mon = NULL; evfs_file_monitor *check_last = NULL; ecore_list_first_goto(mon_list); while ((mon = ecore_list_current(mon_list))) { if (mon->client == client) { em = mon->em; ecore_list_remove(mon_list); goto final; } ecore_list_next(mon_list); } goto out; final:
Ecore_List* entropy_plugins_type_get(int type, int subtype) { entropy_plugin* list_item; Ecore_List* plugins = entropy_core_get_core()->plugin_list; if (plugin_list) { ecore_list_destroy(plugin_list); } plugin_list = ecore_list_new(); ecore_list_first_goto(plugins); while ( (list_item = ecore_list_next(plugins)) ) { /*printf("Scanning plugin: %s\n", list_item->filename);*/ if (list_item->type == type && (subtype == ENTROPY_PLUGIN_SUB_TYPE_ALL || subtype == list_item->subtype) && (type != ENTROPY_PLUGIN_GUI_COMPONENT || (type == ENTROPY_PLUGIN_GUI_COMPONENT && !strcmp(list_item->toolkit, entropy_layout_global_toolkit_get())))) { ecore_list_append(plugin_list, list_item); } } return plugin_list; }
static EXML_Node *find_node(EXML_Node *node, char *key, char *value) { Ecore_List *props; EXML_Node *prop; props = node->children; ecore_list_first_goto(props); prop = ecore_list_current(props); while(prop != NULL) { if(ecore_hash_get(prop->attributes, key)) { if(!strcmp(ecore_hash_get(prop->attributes, key), value)) return prop; } if(prop->children) { EXML_Node *ret; if((ret = find_node(prop, key, value))) return ret; } prop = ecore_list_next(props); } return NULL; }
/** * keystroke accelerator for project window */ static EWL_CALLBACK_DEFN(project_key_down) { Ecore_List *selected; Ewl_Event_Key_Down *ev = ev_data; Ewl_Widget *text, *row; char *name; if( !strcmp(ev->keyname, "Delete") ) { selected = ewl_tree_selected_get(EWL_TREE(file_tree)); if( ecore_list_count(selected) > 0 ) { ecore_list_first_goto(selected); while( (row = ecore_list_next(selected)) ) { text = ewl_tree_row_column_get(EWL_ROW(row), 0); name = ewl_text_text_get(EWL_TEXT(text)); ecore_hash_remove(active_project->files, name); FREE(name); active_project->dirty = true; } project_update(); } } }
struct object * ai_util_planet_closest_uncolonised(struct tpe *tpe, struct object *obj){ Ecore_List *all; struct object *dest, *cur; uint32_t oid; uint64_t destdist, curdist; all = tpe_obj_obj_list(tpe->obj); ecore_list_first_goto(all); dest = NULL; destdist = UINT64_MAX; while ((oid = (int)ecore_list_next(all))){ cur = tpe_obj_obj_get_by_id(tpe,oid); if (cur->type != OBJTYPE_PLANET) continue; if (dest == NULL && cur->ai == NULL) { dest = cur; destdist = tpe_util_dist_calc2(dest,obj); continue; } if (cur->ai != NULL) continue; if (cur->owner >= 0) continue; curdist = tpe_util_dist_calc2(cur,obj); if (curdist < destdist){ /* New target */ destdist = curdist; dest = cur; } } return dest; }
void get_theme_list() { char * path; path = malloc(sizeof(char) * PATH_MAX); snprintf(path, PATH_MAX, "%s/.e/e/themes", getenv("HOME")); Ecore_List *list; list = ecore_file_ls(path); ecore_list_first_goto(list); char * data; themes = NULL; while ((data = (char *)ecore_list_next(list))) if (strstr(data, ".edj") != NULL) { char * file = (char *) strdup(data); Etheme_Object * o; o = etheme_new(file); themes = eina_list_append(themes, o); free(file); } ecore_list_destroy(list); free(path); }
int entropy_notify_loop(void* data) { entropy_notification_engine* notify = (entropy_notification_engine*)data; entropy_notify_event* next; void* (*call_func)(void* arg); ecore_list_first_goto (notify->op_queue); if ( (next = ecore_list_next(notify->op_queue)) ) { next->processed = 1; /*printf ("*************************************** Notify loop - Processing event..\n"); */ /*printf("Calling function '%s'\n", next->function);*/ call_func = dlsym(next->plugin->dl_ref, next->function); next->return_struct = (*call_func)(next->data); /*Relock to remove next*/ ecore_list_first_remove(notify->op_queue); ecore_list_append(notify->exe_queue, next); ecore_ipc_server_send(notify->server, ENTROPY_IPC_EVENT_CORE, 6, 0, 0, 0, NULL, 0); } else { } return 1; }
static void _tree_fill (Etk_Pdf *pdf, Etk_Tree *tree, Etk_Tree_Col *col, Etk_Tree_Row *row, Ecore_List *items) { Etk_Tree_Row *prow; Epdf_Index_Item *item; if (!items) return; ecore_list_first_goto (items); while ((item = ecore_list_next (items))) { char *buf; Ecore_List *c; int *num; buf = strdup (epdf_index_item_title_get (item)); prow = etk_tree_row_append (tree, row, col, buf, NULL); num = (int *)malloc (sizeof (int)); *num = epdf_index_item_page_get (etk_pdf_pdf_document_get (pdf), item); etk_tree_row_data_set_full (prow, num, free); free (buf); c = epdf_index_item_children_get (item); if (c) { _tree_fill (pdf, tree, col, prow, c); } } }
char * EvfsFilereference_to_string(EvfsFilereference * ref) { int length = 0; char *uri; Ecore_List *parent_list = ecore_list_new(); EvfsFilereference *parent; ecore_list_prepend(parent_list, ref); length += strlen(ref->plugin_uri) + strlen("://"); if (ref->username) { length += strlen(ref->username) + strlen(ref->password) + strlen(":") + strlen("@"); } length += strlen(ref->path); while ((parent = ref->parent)) { ecore_list_prepend(parent_list, parent); length += strlen(parent->plugin_uri) + strlen("://"); if (parent->username) { length += strlen(parent->username) + strlen(parent->password) + strlen(":") + strlen("@"); } length += strlen(parent->path); length += strlen("#"); } length += 1; uri = calloc(length, sizeof(char)); while ((parent = ecore_list_first_remove(parent_list))) { strcat(uri, parent->plugin_uri); strcat(uri, "://"); if (parent->username) { strcat(uri, parent->username); strcat(uri, ":"); strcat(uri, parent->password); strcat(uri, "@"); } strcat(uri, parent->path); if (ecore_list_next(parent_list)) strcat(uri, "#"); } ecore_list_destroy(parent_list); return uri; }
void entropy_notification_engine_destroy_thread(entropy_notification_engine* engine) { /*Request a terminate*/ engine->terminate = 1; entropy_notify_event* ev; void* clean; entropy_notify_event_cb_data* cb_data; /*Wait for thread to finish*/ printf("Waiting for notify thread to finish..\n"); printf("..Terminated\n"); ecore_list_first_goto(engine->op_queue); while ( (ev = ecore_list_next(engine->op_queue)) ) { //printf("Freeing an event..\n"); if (ev->cb_list) { ecore_list_first_goto(ev->cb_list); while ( (cb_data = ecore_list_next(ev->cb_list)) ) { entropy_free(cb_data); } ecore_list_destroy(ev->cb_list); } if (ev->cleanup_list) { ecore_list_first_goto(ev->cleanup_list); while ( (clean = ecore_list_next(ev->cleanup_list)) ) { entropy_free(clean); } ecore_list_destroy(ev->cleanup_list); } } printf("Terminating op queue...\n"); ecore_list_destroy(engine->op_queue); printf("Terminating exe queue...\n"); ecore_list_destroy(engine->exe_queue); /*Return*/ printf("..Exiting thread\n"); }
void ecrin_ewl_tree_fill_package (void) { Ewl_Widget *row; Ewl_Widget *row_enum; Ewl_Widget *row_define; Ewl_Widget *row_function; char *key; char *label; label = "Eet"; row = ewl_tree_text_row_add (EWL_TREE (tree), NULL, &label); label = "Enum"; row_enum = ewl_tree_text_row_add (EWL_TREE (tree), EWL_ROW (row), &label); label = "Define"; row_define = ewl_tree_text_row_add (EWL_TREE (tree), EWL_ROW (row), &label); label = "Function"; row_function = ewl_tree_text_row_add (EWL_TREE (tree), EWL_ROW (row), &label); ecore_list_first_goto(sorted_keys); while ((key = ecore_list_next(sorted_keys))) { Ewl_Widget *prow; Ecrin_Hash_Data *data; data = ecrin_hash_data_get (key); switch (data->type) { case HASH_DATA_ENUM: prow = ewl_tree_text_row_add (EWL_TREE (tree), EWL_ROW (row_enum), &data->data_name); ewl_callback_append (prow, EWL_CALLBACK_CLICKED, _enum_display, data); break; case HASH_DATA_DEFINE: prow = ewl_tree_text_row_add (EWL_TREE (tree), EWL_ROW (row_define), &data->data_name); ewl_callback_append (prow, EWL_CALLBACK_CLICKED, _define_display, data); break; case HASH_DATA_FUNCTION: prow = ewl_tree_text_row_add (EWL_TREE (tree), EWL_ROW (row_function), &data->data_name); ewl_callback_append (prow, EWL_CALLBACK_CLICKED, _function_display, data); break; default: break; } } }
/** * @brief print the dns list in the standard output */ void exalt_dns_printf() { Ecore_List* l = exalt_dns_get_list(); char *dns; printf("## DNS LIST ##\n"); ecore_list_first_goto(l); while (( dns=ecore_list_next(l))) printf("%s\n",dns); ecore_list_destroy(l); }
void eke_gui_ewl_feed_change(Eke *eke, Eke_Feed *feed) { Eke_Gui_Ewl_Feed *disp; Eke_Feed_Item *item; Ewl_Widget *o; disp = ecore_hash_get(eke->feeds, feed); if (!disp->tab) { Ewl_Widget *o; disp->tab = ewl_text_new(feed->title); ewl_widget_show(disp->tab); o = ewl_vbox_new(); ewl_notebook_page_append(EWL_NOTEBOOK(eke->gui.ewl.notebook), disp->tab, o); ewl_widget_show(o); disp->page = ewl_scrollpane_new(); ewl_container_child_append(EWL_CONTAINER(o), disp->page); ewl_object_insets_set(EWL_OBJECT(disp->page), 5, 5, 5, 5); ewl_widget_show(disp->page); } ewl_container_reset(EWL_CONTAINER(disp->page)); ecore_list_first_goto(feed->items); while ((item = ecore_list_next(feed->items)) != NULL) { o = ewl_text_new(NULL); ewl_text_wrap_set(EWL_TEXT(o), 1); ewl_text_style_set(EWL_TEXT(o), "soft_shadow"); ewl_text_text_set(EWL_TEXT(o), item->title); ewl_container_child_append(EWL_CONTAINER(disp->page), o); ewl_widget_show(o); if (item->link) { o = ewl_text_new(item->link); ewl_text_wrap_set(EWL_TEXT(o), 1); ewl_container_child_append(EWL_CONTAINER(disp->page), o); ewl_widget_show(o); } if (item->desc) { o = ewl_text_new(item->desc); ewl_text_wrap_set(EWL_TEXT(o), 1); ewl_container_child_append(EWL_CONTAINER(disp->page), o); ewl_widget_show(o); } o = ewl_text_new(" "); ewl_container_child_append(EWL_CONTAINER(disp->page), o); ewl_widget_show(o); } }
void entropy_thumbnailer_plugin_print(Ecore_Hash* mime_register) { char* mime_type; Ecore_List* keys = ecore_hash_keys(mime_register); ecore_list_first_goto(keys); while ( (mime_type = ecore_list_next(keys)) ) { printf ("We have a handler for '%s', it is: %s\n", mime_type, ((entropy_plugin*)ecore_hash_get(mime_register, mime_type))->filename ); } ecore_list_destroy(keys); }
void evfs_file_monitor_fam_handler(void *data, Ecore_File_Monitor * em, Ecore_File_Event event, const char *path) { Ecore_List *mon_list; int type; int filetype = EVFS_FILE_NORMAL; /*printf("Got an event for %s..", path); */ switch (event) { case ECORE_FILE_EVENT_MODIFIED: /*printf("A modified event..\n"); */ type = EVFS_FILE_EV_CHANGE; break; case ECORE_FILE_EVENT_CREATED_FILE: type = EVFS_FILE_EV_CREATE; /*printf("File created - '%s'\n", path); */ break; case ECORE_FILE_EVENT_CREATED_DIRECTORY: type = EVFS_FILE_EV_CREATE; filetype = EVFS_FILE_DIRECTORY; break; case ECORE_FILE_EVENT_DELETED_FILE: type = EVFS_FILE_EV_REMOVE; break; case ECORE_FILE_EVENT_DELETED_DIRECTORY: type = EVFS_FILE_EV_REMOVE_DIRECTORY; break; } /*Looking for ppl no notify */ mon_list = ecore_hash_get(posix_monitor_hash, (char *)data); if (mon_list) { evfs_file_monitor *mon; ecore_list_first_goto(mon_list); while ((mon = ecore_list_next(mon_list))) { evfs_file_monitor_event_create(mon->client, type, path, filetype, "file"); /*Find a better way to do the plugin */ /*We should really use an EvfsFilereference here */ } } }
/** * @param window: the X window to search for on the list of ewl window's * @return Returns the found ewl window on success, NULL on failure. * @brief Find an ewl window by it's X window */ Ewl_Window * ewl_window_window_find(void *window) { Ewl_Window *retwin; DENTER_FUNCTION(DLEVEL_STABLE); DCHECK_PARAM_PTR_RET(window, NULL); ecore_list_first_goto(ewl_window_list); while ((retwin = ecore_list_next(ewl_window_list))) if (retwin->window == window) DRETURN_PTR(retwin, DLEVEL_STABLE); DRETURN_PTR(NULL, DLEVEL_STABLE); }
/*It would seem a good idea to convert this to a hash - but we'd need the actual pointer to the int, or make an ecore_int_hash*/ evfs_connection * evfs_get_connection_for_id(int id) { evfs_connection *conn; ecore_list_first_goto(client_list); while ((conn = ecore_list_next(client_list))) { if (conn->id == id) return conn; } return NULL; }
void ewl_iconbox_file_paste_cb (Ewl_Widget * w, void *ev_data, void *user_data) { Ecore_List *selected; entropy_generic_file *file; entropy_gui_component_instance *instance = ((entropy_gui_component_instance *) user_data); selected = entropy_core_selected_files_get (instance->core); ecore_list_first_goto (selected); while ((file = ecore_list_next (selected))) { entropy_plugin_filesystem_file_copy(file, ((entropy_icon_viewer *) instance->data)->current_dir, instance); } }
void file_project_save( Ewler_Project *p ) { EXML *xml; Ecore_List *names; char *name; xml = exml_new(); exml_start(xml); exml_tag_set(xml, "project"); exml_attribute_set(xml, "source", "ewler"); exml_attribute_set(xml, "version", VERSION); exml_start(xml); exml_tag_set(xml, "name"); exml_value_set(xml, p->name); exml_end(xml); exml_start(xml); exml_tag_set(xml, "path"); exml_value_set(xml, p->path); exml_end(xml); exml_start(xml); exml_tag_set(xml, "files"); names = ecore_hash_keys(p->files); while( (name = ecore_list_next(names)) ) { exml_start(xml); exml_tag_set(xml, "file"); exml_attribute_set(xml, "name", name); exml_value_set(xml, ecore_hash_get(p->files, name)); exml_end(xml); } ecore_list_destroy(names); exml_end(xml); exml_end(xml); /* maybe prepend path to this */ exml_file_write(xml, p->filename); exml_destroy(xml); }
entropy_plugin* entropy_plugin_gui_get_by_name_toolkit(char* toolkit, char* name) { entropy_plugin* list_item; Ecore_List* plugins = entropy_core_get_core()->plugin_list; ecore_list_first_goto(plugins); while ( (list_item = ecore_list_next(plugins)) ) { /*printf("Scanning '%s' for first\n", list_item->filename);*/ if (list_item->toolkit && list_item->name) { if (!strcmp(list_item->toolkit, toolkit) && !(strcmp(list_item->name, name))) { return list_item; } } } return NULL; }
void ecrin_ewl_list_fill_package (char *aiguille) { Ewl_Widget *row; char *key; if (list_rows) ecore_list_destroy (list_rows); list_rows = ecore_list_new (); if (!aiguille) aiguille = ""; ecore_list_first_goto(sorted_keys); while ((key = ecore_list_next(sorted_keys))) { Ecrin_Hash_Data *data; data = ecrin_hash_data_get (key); if (strstr (key, aiguille)) { row = ewl_tree_text_row_add (EWL_TREE (list), NULL, &data->data_name); ecore_list_append (list_rows, row); switch (data->type) { case HASH_DATA_ENUM: ewl_callback_append (row, EWL_CALLBACK_CLICKED, _enum_display, data); break; case HASH_DATA_DEFINE: ewl_callback_append (row, EWL_CALLBACK_CLICKED, _define_display, data); break; case HASH_DATA_FUNCTION: ewl_callback_append (row, EWL_CALLBACK_CLICKED, _function_display, data); break; default: break; } } } }