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);
}
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");
}
/**
* 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 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
ewl_icon_local_viewer_menu_rename_cb (Ewl_Widget * w, void *ev_data,
void *user_data)
{
entropy_gui_component_instance *instance = user_data;
entropy_icon_viewer *viewer = instance->data;
Ecore_List *sel = ewl_iconbox_get_selection (EWL_ICONBOX (viewer->iconbox));
if (ecore_list_count (sel) == 1) {
Ewl_Iconbox_Icon *icon = ecore_list_first_remove (sel);
gui_file *local_file = ecore_hash_get (viewer->icon_hash, icon);
if (icon) {
printf ("Rename dialog..\n");
entropy_ewl_rename_dialog_new (entropy_file_gui_component_new_with_data
(local_file->file, instance));
}
}
else {
printf ("Can't rename more than 1 file\n");
}
ecore_list_destroy (sel);
}
void entropy_etk_delete_dialog_new(entropy_gui_component_instance* instance, Ecore_List* files)
{
char buf[PATH_MAX];
Etk_Widget* window = etk_window_new();
Etk_Widget* vbox= etk_vbox_new(ETK_TRUE,5);
Etk_Widget* hbox = etk_hbox_new(ETK_TRUE,5);
Etk_Widget* button;
Etk_Widget* label;
if (ecore_list_count(files) == 1) {
ecore_list_first_goto(files);
entropy_generic_file* file = ((entropy_generic_file*)ecore_list_current(files));
snprintf(buf, PATH_MAX, "Are you sure you want to delete '%s/%s'? ", file->path,
file->filename);
} else {
snprintf(buf, PATH_MAX, "Are you sure you want to delete these %d files'? ", ecore_list_count(files));
}
etk_window_title_set(ETK_WINDOW(window), buf);
etk_container_add(ETK_CONTAINER(window), vbox);
label = etk_label_new(buf);
etk_box_append(ETK_BOX(vbox), label, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 5);
etk_box_append(ETK_BOX(vbox), hbox, ETK_BOX_START, ETK_BOX_EXPAND_FILL, 5);
button = etk_button_new_with_label("Yes");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_delete_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_YES );
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_widget_show(button);
button = etk_button_new();
etk_button_label_set(ETK_BUTTON(button), "No");
etk_container_add(ETK_CONTAINER(hbox), button);
etk_signal_connect("pressed", ETK_OBJECT(button), ETK_CALLBACK(etk_entropy_delete_dialog_cb),
(int*)ENTROPY_USER_INTERACTION_RESPONSE_NO );
etk_object_data_set(ETK_OBJECT(button), "window", window);
etk_widget_show(button);
etk_object_data_set(ETK_OBJECT(window), "files", files);
etk_object_data_set(ETK_OBJECT(window), "instance", instance);
etk_widget_show_all(window);
}
static void
_function_display (Ewl_Widget *w, void *ev_data, void *user_data)
{
Ecrin_Hash_Data *data;
Ecrin_Function *function;
Ecrin_Function_Param *param;
char str[4096];
char space[4096];
data = (Ecrin_Hash_Data *)user_data;
function = (Ecrin_Function *)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, "%s %s (", function->return_type, function->name);
ewl_text_text_append (EWL_TEXT (text), str);
memset (space, ' ', 4096);
space[strlen (str)] = '\0';
ecore_list_first_goto (function->params);
while ((param = ecore_list_next (function->params)))
{
if (ecore_list_index (function->params) != 1)
ewl_text_text_append (EWL_TEXT (text), space);
snprintf (str, 4096, "%s", param->type);
ewl_text_text_append (EWL_TEXT (text), str);
if (param->name)
{
snprintf (str, 4096, " %s", param->name);
ewl_text_text_append (EWL_TEXT (text), str);
}
if (ecore_list_index (function->params) != ecore_list_count (function->params))
{
snprintf (str, 4096, ",\n");
ewl_text_text_append (EWL_TEXT (text), str);
}
else
{
snprintf (str, 4096, ")\n");
ewl_text_text_append (EWL_TEXT (text), str);
}
}
}
/**
* 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_event_callback (entropy_notify_event * eevent, void *requestor,
void *el, entropy_gui_component_instance * comp)
{
entropy_layout_gui* view = (entropy_layout_gui*)comp->data;
switch (eevent->event_type) {
case ENTROPY_NOTIFY_FILE_PROGRESS:{
entropy_file_progress_window* window;
entropy_file_progress *progress = el;
if (! (window = ecore_hash_get(view->progress_hash, (long*)progress->identifier))) {
window = entropy_etk_progress_window_create();
entropy_etk_progress_dialog_show(window);
entropy_etk_progress_dialog_set_file_from_to(window, progress->file_from, progress->file_to);
entropy_etk_progress_dialog_set_progress_pct(window, &progress->progress);
ecore_hash_set(view->progress_hash, (long*)progress->identifier, window);
} else {
entropy_etk_progress_dialog_set_file_from_to(window, progress->file_from, progress->file_to);
entropy_etk_progress_dialog_set_progress_pct(window, &progress->progress);
}
if (progress->type == TYPE_END) {
window = ecore_hash_get(view->progress_hash, (long*)progress->identifier);
if (window) {
ecore_hash_remove(view->progress_hash, (long*)progress->identifier);
entropy_etk_progress_dialog_destroy(window);
}
}
}
break;
case ENTROPY_NOTIFY_USER_INTERACTION_YES_NO_ABORT: {
/*FIXME: We need to handle different types here*/
entropy_etk_user_interaction_dialog_new((entropy_file_operation*)el);
}
break;
case ENTROPY_NOTIFY_EXTENDED_STAT: {
printf("**** Extended stat at layout\n");
ecore_hash_set(view->properties_request_hash, (entropy_generic_file*)el, (int*)1);
};
break;
case ENTROPY_NOTIFY_FILE_STAT_AVAILABLE:{
entropy_file_stat *file_stat = (entropy_file_stat *) eevent->return_struct;
if (ecore_hash_get(view->properties_request_hash, file_stat->file)) {
ecore_hash_remove(view->properties_request_hash, file_stat->file);
/*Lauch a properties window*/
etk_properties_dialog_new(file_stat->file);
}
}
break;
case ENTROPY_NOTIFY_PASTE_REQUEST: {
printf("Paste request..\n");
Entropy_Selection_Type stype = entropy_core_selection_type_get();
entropy_generic_file* cfolder =
((entropy_gui_component_instance_layout*)comp)->current_folder;
Ecore_List* files = entropy_core_selected_files_get();
if (cfolder) {
char* f_uri = cfolder->uri;
if (f_uri) {
if (stype == ENTROPY_SELECTION_COPY) {
printf("Copy type..: %d:%s\n", ecore_list_count(files), f_uri);
entropy_plugin_filesystem_file_copy_multi(files, f_uri,
comp);
} else if (stype == ENTROPY_SELECTION_CUT) {
printf("Cut type..:%d:%s\n", ecore_list_count(files), f_uri);
entropy_plugin_filesystem_file_move_multi(files, f_uri,
comp);
} else {
printf("Unsupported copy type at context menu paste\n");
}
}
} else {
printf("Current folder is NULL at layout paste\n");
}
}
break;
case ENTROPY_NOTIFY_AUTH_REQUEST: {
printf("Requested auth for: %s\n",(char*)el);
etk_auth_request_dialog_create(strdup((char*)el));
}
break;
case ENTROPY_NOTIFY_METADATA_ALL: {
entropy_etk_efolder_dialog_show((Eina_List*)el);
}
break;
}
}
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);
}
