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; }
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 ); }
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_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); }
void ewl_iconbox_background_set_file_cb (Ewl_Widget * w, void *ev, void *user_data) { Ewl_Dialog_Event *e; entropy_gui_component_instance *instance = user_data; entropy_icon_viewer *viewer = instance->data; char* file = NULL; e = ev; if (e->response == EWL_STOCK_OPEN) { Ecore_List* l; l = ewl_filedialog_selected_files_get(EWL_FILEDIALOG(viewer->file_dialog)); ecore_list_first_goto(l); file = ecore_list_current(l); printf ("Curent directory is '%s'\n", viewer->current_dir); entropy_config_str_set ("iconbox_viewer", viewer->current_dir, file); ewl_widget_destroy (viewer->file_dialog); } else if (e->response == EWL_STOCK_CANCEL) { ewl_widget_destroy (viewer->file_dialog); } }
/** * Retrieves an ecore_list of all keys in the given hash. * @param hash The given hash. * @return new ecore_list on success, NULL otherwise * @ingroup Ecore_Data_Hash_ADT_Traverse_Group */ EAPI Ecore_List * ecore_hash_keys(Ecore_Hash *hash) { unsigned int i = 0; Ecore_List *keys; CHECK_PARAM_POINTER_RETURN("hash", hash, NULL); keys = ecore_list_new(); while (i < ecore_prime_table[hash->size]) { if (hash->buckets[i]) { Ecore_Hash_Node *node; for (node = hash->buckets[i]; node; node = node->next) { ecore_list_append(keys, node->key); } } i++; } ecore_list_first_goto(keys); return keys; }
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"); }
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 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); } } }
void TOCDialog(Evas *e, Evas_Object *obj,Ecore_List *list) { int numchoices=ecore_list_count(list); char **initchoices; //char **values; initchoices=(char **)malloc(sizeof(char*)*numchoices); //values=(char **)malloc(sizeof(char*)*numchoices); ecore_list_first_goto(list); int i; for(i=0;i<numchoices;i++) { asprintf(&(initchoices[i]),"%d. %s",(i%8+1),epdf_index_item_title_get((Epdf_Index_Item *)ecore_list_next(list))); } Evas_Object *tocchoicebox=init_choicebox(e,(const char**)initchoices,NULL, numchoices, toc_choicehandler, "Table of Contents",obj,(void *)list, true); for(i=0;i<numchoices;i++) { free(initchoices[i]); } //free(values); free(initchoices); int x,y,w,h; evas_object_geometry_get(tocchoicebox,&x,&y,&w,&h); evas_object_move(tocchoicebox,(int)(((double)get_win_width()-w)/2.0),(int)(((double)get_win_height()-h)/2.0)); }
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:
/** * 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(); } } }
void etk_entropy_delete_dialog_cb(Etk_Object* w, void* user_data) { Etk_Widget* window = NULL; int result = (int)user_data; entropy_generic_file* file; Ecore_List* files; entropy_gui_component_instance* instance; window = etk_object_data_get(ETK_OBJECT(w), "window"); files= etk_object_data_get(ETK_OBJECT(window), "files"); instance = etk_object_data_get(ETK_OBJECT(window), "instance"); switch (result) { case ENTROPY_USER_INTERACTION_RESPONSE_YES: { ecore_list_first_goto(files); while ((file = ecore_list_first_remove(files))) { entropy_plugin_filesystem_file_remove(file, instance); } } break; case ENTROPY_USER_INTERACTION_RESPONSE_NO: { } break; default: break; } ecore_list_destroy(files); etk_object_destroy(ETK_OBJECT(window)); }
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); }
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; }
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; }
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 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; }
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; }
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; } } }
int posix_monitor_add(evfs_client * client, evfs_command * command) { Ecore_List *mon_list = ecore_hash_get(posix_monitor_hash, evfs_command_first_file_get(command)->path); evfs_file_monitor *mon; evfs_file_monitor *old; mon = calloc(1, sizeof(evfs_file_monitor)); mon->client = client; mon->monitor_path = strdup(evfs_command_first_file_get(command)->path); /*Check if we are already monitoring, if not, make a new list of monitors.. */ if (!mon_list) { /*printf("No previous instance, making a new list, monitoring..\n"); */ mon_list = ecore_list_new(); ecore_hash_set(posix_monitor_hash, mon->monitor_path, mon_list); printf("Adding monitor on path '%s'\n", mon->monitor_path); if (! (mon->em = ecore_file_monitor_add(mon->monitor_path, &evfs_file_monitor_fam_handler, mon->monitor_path))) { fprintf(stderr, "EVFS: Error monitoring '%s'\n", mon->monitor_path); } ecore_list_append(mon_list, mon); } else { if (!client_already_monitoring(client, mon_list)) { /*We assume there is something already in the list. This is probably bad a bad assumption */ ecore_list_first_goto(mon_list); old = ecore_list_current(mon_list); /*Make sure we have the ecore ref, so the last monitor can nuke it */ mon->em = old->em; ecore_list_append(mon_list, mon); } else { printf("Oi, dufus, you're already monitoring this object\n"); } } return 0; }
/** * Move the current xml to its first child if there are children * @param xml The xml document * @return The current xml tag name * @ingroup EXML_Traversal_Group */ char *exml_down(EXML *xml) { CHECK_PARAM_POINTER_RETURN("xml", xml, NULL); if (exml_has_children(xml)) xml->current = ecore_list_first_goto( xml->current->children ); else return NULL; return xml->current ? xml->current->tag : NULL; }
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); } }
/** * @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 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 */ } } }
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); }
static EWL_CALLBACK_DEFN(fg_mouse_down) { Ewler_Widget *ewler_w = user_data; Ewl_Embed *embed; Ewl_Event_Mouse_Down *ev = ev_data; bool multi; if( !ewler_w->selectable || widget_under_cursor ) return; widget_under_cursor = true; ewler_w->mouse.state |= EWLER_WIDGET_MOUSE_DOWN; ewler_w->mouse.button = ev->button; ewler_w->mouse.state_x = ev->x; ewler_w->mouse.state_y = ev->y; ewler_w->corners.x = CURRENT_X(w); ewler_w->corners.y = CURRENT_Y(w); ewler_w->corners.u = CURRENT_X(w) + CURRENT_W(w); ewler_w->corners.v = CURRENT_Y(w) + CURRENT_H(w); if( ev->modifiers & (EWL_KEY_MODIFIER_CTRL | EWL_KEY_MODIFIER_SHIFT) ) multi = true; else multi = false; if( ev->button == 1 && multi ) { form_toggle(ewler_w); } else if( ev->button == 1 || (!multi && !ecore_list_count(form_selected())) ) { Ecore_List *selected; selected = form_selected(); if( selected && (ecore_list_count(selected) != 1 || ecore_list_first_goto(selected) != ewler_w) ) { form_deselect_all(); form_select(ewler_w); } } IF_FREE(ewler_w->source); embed = ewl_embed_widget_find(w); evas_event_feed_mouse_down(embed->evas, ev->button, EVAS_BUTTON_NONE, 0, NULL); }
/** * @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); }