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
widget_clear_ui_hooks( Ewler_Widget *w )
{
Ecore_Hash *elems;
Ecore_List *elems_stack;
Ecore_List *names, *names_stack;
char *name;
names = ecore_hash_keys(w->elems);
elems = w->elems;
elems_stack = ecore_list_new();
names_stack = ecore_list_new();
while( (name = ecore_list_next(names)) ) {
Ewler_Widget_Elem *elem;
elem = ecore_hash_get(elems, name);
elem->entry = NULL;
elem->text = NULL;
if( elem->items )
ecore_hash_destroy(elem->items);
elem->items = NULL;
if( elem->spec->type == EWLER_SPEC_ELEM_STRUCT ) {
ecore_list_prepend(elems_stack, elems);
ecore_list_prepend(names_stack, names);
elems = elem->info.children;
names = ecore_hash_keys(elems);
}
while( !ecore_list_current(names) && elems != w->elems ) {
ecore_list_destroy(names);
elems = ecore_list_first_remove(elems_stack);
names = ecore_list_first_remove(names_stack);
}
}
ecore_list_destroy(names);
ecore_list_destroy(elems_stack);
ecore_list_destroy(names_stack);
}
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
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);
}
int
evfs_client_disconnect(evfs_client * client)
{
Ecore_List *mon_list;
Ecore_List *indiv_list;
evfs_file_monitor *mon;
char *key;
Ecore_List *watched_keys = ecore_list_new();
/*printf("Received disconnect for client at evfs_fs_posix.c for client %lu\n",
client->id);
printf("Scanning monitors for client and removing...\n");*/
mon_list = ecore_hash_keys(posix_monitor_hash);
if (mon_list)
{
while ((key = ecore_list_first_remove(mon_list)))
{
/*printf("Looking for clients for '%s'\n", key);*/
indiv_list = ecore_hash_get(posix_monitor_hash, key);
ecore_list_first_goto(indiv_list);
while ((mon = ecore_list_next(indiv_list)))
{
if (mon->client == client)
{
ecore_list_append(watched_keys, key);
}
}
}
ecore_list_destroy(mon_list);
}
else
{
/*printf("No directories/files monitored by any client\n");*/
}
while ((key = ecore_list_first_remove(watched_keys)))
{
evfs_posix_monitor_remove(client, key);
}
ecore_list_destroy(watched_keys);
return 1;
}
static void *
elem_at_index(Ecore_Hash *elems, int i)
{
Ecore_List *keys;
Ewler_Widget_Elem *elem;
char *name;
keys = ecore_hash_keys(elems);
while( (name = ecore_list_next(keys)) ) {
elem = ecore_hash_get(elems, name);
if( elem->spec->index == i ) {
ecore_list_destroy(keys);
return &elem->info.ivalue;
}
}
ecore_list_destroy(keys);
return NULL;
}
/**
* update the view of this project based on its contents
*/
void
project_update( void )
{
Ewl_Widget *w;
Ecore_List *names;
Ecore_Sheap *snames;
int i, nodes;
char *name;
ewl_tree_selected_clear(EWL_TREE(file_tree));
ewl_container_reset(EWL_CONTAINER(file_tree));
if( !active_project->files->nodes )
return;
names = ecore_hash_keys(active_project->files);
nodes = ecore_list_count(names);
snames = ecore_sheap_new(ecore_str_compare, nodes);
while( (name = ecore_list_remove(names)) )
ecore_sheap_insert(snames, name);
ecore_sheap_sort(snames);
for( i=0;i<nodes;i++ ) {
Ewl_Widget *row;
name = ecore_sheap_item(snames, i);
w = ewl_text_new(name);
row = ewl_tree_row_add(EWL_TREE(file_tree), NULL, &w);
ewl_callback_append(row, EWL_CALLBACK_DOUBLE_CLICKED,
form_open, name);
ewl_callback_append(row, EWL_CALLBACK_CLICKED,
project_file_menu, name);
ewl_widget_show(w);
}
ecore_sheap_destroy(snames);
ecore_list_destroy(names);
}
void
gui_object_destroy_and_free (entropy_gui_component_instance * comp,
Ecore_Hash * gui_hash)
{
Ecore_List *list;
entropy_generic_file *obj;
gui_file *freeobj;
/*Temporarily stop callbacks, we don't want to clobber an in-op process */
entropy_notify_lock_loop (comp->core->notify);
list = ecore_hash_keys (gui_hash);
ecore_list_first_goto (list);
while ((obj = ecore_list_next (list))) {
freeobj = ecore_hash_get (gui_hash, obj);
if (freeobj) {
/*Associate this icon with this file in the core, so DND works */
entropy_core_object_file_disassociate (freeobj->icon);
gui_file_destroy (freeobj);
}
/*Tell the core we no longer need this file - it might free it now */
entropy_core_file_cache_remove_reference (obj->md5);
}
ecore_hash_destroy (gui_hash);
ecore_list_destroy (list);
entropy_notify_unlock_loop (comp->core->notify);
}
void entropy_ewl_mime_dialog_display() {
Ewl_Widget* window = ewl_window_new();
Ewl_Widget* box = ewl_vbox_new();
Ewl_Widget* button = ewl_button_new();
Ewl_Widget* hbox;
entropy_core* core = entropy_core_get_core();
char* entries[3];
char* key;
entropy_mime_action* action;
Ecore_List* keys;
last_select_text = NULL;
/*Init the mime tree*/
mime_tree = ewl_tree_new(2);
ewl_tree_mode_set(EWL_TREE(mime_tree), EWL_SELECTION_MODE_SINGLE);
ewl_object_minimum_size_set(EWL_OBJECT(window), 530, 400);
ewl_window_title_set(EWL_WINDOW(window), "Edit MIME Actions..");
ewl_container_child_append(EWL_CONTAINER(window), box);
ewl_container_child_append(EWL_CONTAINER(box), mime_tree);
ewl_widget_show(box);
keys = ecore_hash_keys(core->mime_action_hint);
while ((key = ecore_list_first_remove(keys))) {
Ewl_Widget* row;
entries[0] = key;
entries[1] = ((entropy_mime_action*)ecore_hash_get(core->mime_action_hint, key))->executable;
entries[2] = NULL;
row = ewl_tree_text_row_add(EWL_TREE(mime_tree), NULL,entries);
ewl_widget_color_set(row,0,0,0,255);
ewl_callback_append(row, EWL_CALLBACK_MOUSE_DOWN,
mime_row_click_cb, key);
}
ecore_list_destroy(keys);
hbox = ewl_hbox_new();
ewl_container_child_append(EWL_CONTAINER(box), hbox);
ewl_object_fill_policy_set(EWL_OBJECT(hbox), EWL_FLAG_FILL_SHRINK);
ewl_widget_show(hbox);
/*Add Button*/
ewl_button_label_set(EWL_BUTTON(button), "Add MIME Action");
ewl_object_maximum_h_set(EWL_OBJECT(button), 15);
ewl_callback_append(button, EWL_CALLBACK_CLICKED, entropy_ewl_mime_add_display_cb, NULL);
ewl_container_child_append(EWL_CONTAINER(hbox), button);
ewl_widget_show(button);
/*OK Button*/
button = ewl_button_new();
ewl_button_label_set(EWL_BUTTON(button), "Close");
ewl_object_maximum_h_set(EWL_OBJECT(button), 15);
ewl_callback_append(button, EWL_CALLBACK_CLICKED, window_dismiss_cb, window);
ewl_container_child_append(EWL_CONTAINER(hbox), button);
ewl_widget_show(button);
ewl_widget_show(window);
ewl_widget_show(mime_tree);
}
void
inspector_update( Ecore_List *selected )
{
Ewl_Widget *prow;
Ecore_Sheap *slist, *sheap;
Ecore_Hash *elems;
Ecore_List *keys;
Ecore_List *prow_stack, *sheap_stack, *elems_stack;
Ewler_Widget *w;
char *key;
ewl_container_reset(EWL_CONTAINER(tree));
if( !selected )
return;
/* add support for multiple selections later */
w = ecore_list_first_goto(selected);
if( !w )
return;
keys = ecore_hash_keys(w->elems);
slist = ecore_sheap_new(ecore_str_compare, ecore_list_count(keys));
while( (key = ecore_list_next(keys)) )
ecore_sheap_insert(slist, key);
ecore_list_destroy(keys);
ecore_sheap_sort(slist);
sheap = slist;
elems = w->elems;
sheap_stack = ecore_list_new();
elems_stack = ecore_list_new();
prow_stack = ecore_list_new();
prow = NULL;
while( (key = ecore_sheap_extract(sheap)) ) {
Ewler_Widget_Elem *elem;
Ewl_Widget *row_items[2], *row;
Ewl_Widget *text, *entry;
int len;
elem = ecore_hash_get(elems, key);
text = ewl_text_new(key);
len = ewl_text_length_get(EWL_TEXT(text));
ewl_text_cursor_position_set(EWL_TEXT(text), 0);
if( elem->changed )
ewl_text_color_apply(EWL_TEXT(text), 255, 0, 0, 255, len);
switch( elem->spec->type ) {
case EWLER_SPEC_ELEM_STRUCT: entry = NULL; break;
case EWLER_SPEC_ELEM_ENUM:
entry = ewl_combo_new(elem_to_s(elem));
if( elem->items )
ecore_hash_destroy(elem->items);
elem->items = ecore_hash_new(ecore_direct_hash, ecore_direct_compare);
keys = ecore_hash_keys(elem->spec->info.edata.map_rev);
while( (key = ecore_list_next(keys)) ) {
Ewl_Widget *combo_item;
int value;
value = (int) ecore_hash_get(elem->spec->info.edata.map_rev, key);
combo_item = ewl_menu_item_new(NULL, key);
ecore_hash_set(elem->items, (void *) value, combo_item);
ewl_container_child_append(EWL_CONTAINER(entry), combo_item);
ewl_widget_show(combo_item);
}
ecore_list_destroy(keys);
ewl_callback_append(entry, EWL_CALLBACK_VALUE_CHANGED,
combo_value_changed, elem);
break;
default:
entry = ewl_entry_new(elem_to_s(elem));
if( !elem->spec->modifiable )
ewl_entry_editable_set(EWL_ENTRY(entry), false);
ewl_callback_append(entry, EWL_CALLBACK_VALUE_CHANGED,
entry_value_changed, elem);
ewl_callback_append(entry, EWL_CALLBACK_DESELECT,
entry_value_changed, elem);
ewl_callback_append(entry, EWL_CALLBACK_FOCUS_OUT,
entry_focus_out, elem);
break;
}
elem->text = text;
elem->entry = entry;
row_items[0] = text;
row_items[1] = entry;
row = ewl_tree_row_add(EWL_TREE(tree), EWL_ROW(prow), row_items);
ewl_widget_show(text);
if( entry )
ewl_widget_show(entry);
if( elem->spec->type == EWLER_SPEC_ELEM_STRUCT ) {
ecore_list_prepend(prow_stack, prow);
ecore_list_prepend(sheap_stack, sheap);
ecore_list_prepend(elems_stack, elems);
prow = row;
elems = elem->info.children;
/* TODO: check for indexed struct */
keys = ecore_hash_keys(elems);
sheap = ecore_sheap_new(ecore_str_compare, ecore_list_count(keys));
while( (key = ecore_list_next(keys)) )
ecore_sheap_insert(sheap, key);
ecore_list_destroy(keys);
ecore_sheap_sort(sheap);
}
if( sheap->size == 0 && ecore_list_count(sheap_stack) ) {
ecore_sheap_destroy(sheap);
prow = ecore_list_first_remove(prow_stack);
sheap = ecore_list_first_remove(sheap_stack);
elems = ecore_list_first_remove(elems_stack);
}
}
ecore_list_destroy(sheap_stack);
ecore_list_destroy(elems_stack);
ecore_sheap_destroy(slist);
}
static EWL_CALLBACK_DEFN(realize)
{
Ewler_Widget *ewler_w = user_data;
Ecore_List *elems;
Ewler_Widget_Elem *elem;
char *name;
void *args[4];
int i, n;
if( ewler_w->selected )
widget_select(ewler_w);
elems = ecore_hash_keys(ewler_w->elems);
while( (name = ecore_list_next(elems)) ) {
elem = ecore_hash_get(ewler_w->elems, name);
if( elem->spec->get_func )
switch( elem->spec->type ) {
case EWLER_SPEC_ELEM_INT:
elem->info.ivalue = (int) elem->spec->get_func(ewler_w->w);
if( elem->entry ) {
ewl_text_text_set(EWL_TEXT(elem->entry), "");
ewl_text_text_append(EWL_TEXT(elem->entry), elem_to_s(elem));
}
break;
case EWLER_SPEC_ELEM_STRING:
IF_FREE(elem->info.svalue);
elem->info.svalue = (char *) elem->spec->get_func(ewler_w->w);
if( elem->entry )
ewl_text_text_set(EWL_TEXT(elem->entry), elem_to_s(elem));
break;
case EWLER_SPEC_ELEM_STRUCT:
n = elem->spec->info.children->nodes;
for( i=0;i<n;i++ )
args[i] = elem_at_index(elem->info.children, i);
switch( n ) {
case 1: elem->spec->get_func(ewler_w->w, args[0]); break;
case 2: elem->spec->get_func(ewler_w->w, args[0], args[1]); break;
case 3:
elem->spec->get_func(ewler_w->w, args[0], args[1], args[2]);
break;
case 4:
elem->spec->get_func(ewler_w->w,
args[0], args[1], args[2], args[3]);
break;
/* haven't seen anything higher just yet */
}
break;
case EWLER_SPEC_ELEM_ENUM:
elem->info.evalue = (int) elem->spec->get_func(ewler_w->w);
if( elem->entry ) {
Ewl_Widget *item;
item = ecore_hash_get(elem->items, (void *) elem->info.evalue);
ewl_combo_selected_set(EWL_COMBO(elem->entry), item);
}
break;
default: break;
}
else if(elem->spec->type == EWLER_SPEC_ELEM_STRUCT)
/* iterate through children, since we don't have a mass get */;
}
ecore_list_destroy(elems);
}
