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;
}
/**
* Move the current xml document pointer to the indicated node
* @param xml The xml document
* @param node The position within the document to move to
* @return The current xml tag name
* @ingroup EXML_Traversal_Group
*/
char *exml_goto_node(EXML *xml, EXML_Node *node)
{
Ecore_List *stack;
EXML_Node *n, *l;
CHECK_PARAM_POINTER_RETURN("xml", xml, NULL);
stack = ecore_list_new();
n = node;
while( n->parent != NULL ) {
ecore_list_prepend(stack, n);
n = n->parent;
}
l = xml->top;
if (n != l)
return NULL;
while( (n = ecore_list_first_remove(stack)) ) {
l = ecore_list_goto(l->children, n);
if (!l)
return NULL;
}
xml->current = node;
return xml->current ? xml->current->tag : NULL;
}
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);
}
static ImageClass *
ImageclassCreate(const char *name)
{
ImageClass *ic;
ic = ECALLOC(ImageClass, 1);
if (!ic)
return NULL;
if (!iclass_list)
iclass_list = ecore_list_new();
ecore_list_prepend(iclass_list, ic);
ic->name = Estrdup(name);
return ic;
}
static MenuStyle *
MenuStyleCreate(const char *name)
{
MenuStyle *ms;
ms = ECALLOC(MenuStyle, 1);
if (!ms)
return NULL;
if (!menu_style_list)
menu_style_list = ecore_list_new();
ecore_list_prepend(menu_style_list, ms);
ms->name = Estrdup(name);
ms->iconpos = ICON_LEFT;
return ms;
}
static ToolTip *
TooltipCreate(const char *name, const char *ic0, const char *ic1,
const char *ic2, const char *ic3, const char *ic4,
const char *tclass, int dist, const char *tooltippic)
{
ToolTip *tt;
ImageClass *ic;
if (!ic0 || !tclass)
return NULL;
ic = ImageclassAlloc(ic0, 0);
if (!ic)
return NULL;
tt = ECALLOC(ToolTip, 1);
if (!tt)
return NULL;
tt->name = Estrdup(name);
tt->iclass[0] = ImageclassAlloc(ic1, 0);
tt->iclass[1] = ImageclassAlloc(ic2, 0);
tt->iclass[2] = ImageclassAlloc(ic3, 0);
tt->iclass[3] = ImageclassAlloc(ic4, 0);
tt->iclass[4] = ic;
tt->tclass = TextclassAlloc(tclass, 1);
tt->tooltippic = ImageclassAlloc(tooltippic, 0);
tt->dist = dist;
if (!tt_list)
tt_list = ecore_list_new();
ecore_list_prepend(tt_list, tt);
return tt;
}
/**
* @param argc: the argc passed into the main function
* @param argv: the argv passed into the main function
* @return Returns 1 or greater on success, 0 otherwise.
* @brief Initialize the internal variables of ewl to begin the program
*
* Sets up necessary internal variables for executing ewl
* functions. This should be called before any other ewl functions are used.
*/
int
ewl_init(int *argc, char **argv)
{
const char *locale;
DENTER_FUNCTION(DLEVEL_STABLE);
/* check if we are already initialized */
if (++ewl_init_count > 1)
DRETURN_INT(ewl_init_count, DLEVEL_STABLE);
/* set the locale for string collation if it isn't already set */
locale = setlocale(LC_COLLATE, NULL);
if (strcmp(locale, "C") || strcmp(locale, "POSIX")) {
setlocale(LC_COLLATE, "");
}
shutdown_queue = ecore_list_new();
if (!shutdown_queue) {
fprintf(stderr, "Could not create Ewl shutdown queue.\n");
goto FAILED;
}
if (!ecore_init()) {
fprintf(stderr, "Could not initialize Ecore.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ecore_shutdown);
#ifdef BUILD_EFREET_SUPPORT
if (!efreet_init()) {
fprintf(stderr, "Could not initialize Efreet.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, efreet_shutdown);
if (!efreet_mime_init()) {
fprintf(stderr, "Could not initialize Efreet_Mime.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, efreet_mime_shutdown);
#endif
if (!ecore_string_init()) {
fprintf(stderr, "Could not initialize Ecore Strings.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ecore_string_shutdown);
reveal_list = ecore_list_new();
obscure_list = ecore_list_new();
configure_active = ecore_list_new();
configure_available = ecore_list_new();
realize_list = ecore_list_new();
destroy_list = ecore_list_new();
free_evas_list = ecore_list_new();
free_evas_object_list = ecore_list_new();
child_add_list = ecore_list_new();
ewl_embed_list = ecore_list_new();
ewl_window_list = ecore_list_new();
shutdown_hooks = ecore_list_new();
if ((!reveal_list) || (!obscure_list) || (!configure_active)
|| (!configure_available)
|| (!realize_list) || (!destroy_list)
|| (!free_evas_list) || (!free_evas_object_list)
|| (!child_add_list) || (!ewl_embed_list)
|| (!ewl_window_list) || (!shutdown_hooks)) {
fprintf(stderr, "Unable to initialize internal configuration."
" Out of memory?\n");
goto FAILED;
}
/*
* Cleanup the queue buffers when the management lists get freed.
*/
ecore_list_free_cb_set(configure_active, free);
ecore_list_free_cb_set(configure_available, free);
if (!ewl_system_directories_init())
{
fprintf(stderr, "Could not initialize the system"
" directories.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_system_directories_shutdown);
/* now that the directories are init we can also set the text domain */
#ifdef ENABLE_NLS
bindtextdomain(PACKAGE, ewl_system_directory_get(EWL_DIRECTORY_LOCALE));
bind_textdomain_codeset(PACKAGE, "UTF-8");
#endif
if (!ewl_config_init()) {
fprintf(stderr, "Could not initialize Ewl Config.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_config_shutdown);
if (!ewl_engines_init()) {
fprintf(stderr, "Could not intialize Ewl Engines.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_engines_shutdown);
/* handle any command line options */
ewl_init_parse_options(argc, argv);
/* initialize this _after_ we've handled the command line options */
ewl_config_cache_init();
/* we create the engine we will be working with here so that it is
* initialized before we start to use it. */
if (!ewl_engine_new(ewl_config_string_get(ewl_config,
EWL_CONFIG_ENGINE_NAME), argc, argv)) {
fprintf(stderr, "Could not initialize Ewl Engine.\n");
goto FAILED;
}
if (!ewl_callbacks_init()) {
fprintf(stderr, "Could not initialize Ewl Callback system.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_callbacks_shutdown);
/* allocate the two window callbacks */
EWL_CALLBACK_EXPOSE = ewl_callback_type_add();
EWL_CALLBACK_DELETE_WINDOW = ewl_callback_type_add();
/* allocate the mvc callback */
EWL_CALLBACK_MVC_CLICKED = ewl_callback_type_add();
if (!ewl_theme_init()) {
fprintf(stderr, "Could not setup Ewl Theme system.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_theme_shutdown);
if (!ewl_icon_theme_init()) {
fprintf(stderr, "Could not initialize Ewl Icon Theme system.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_icon_theme_shutdown);
if (!ewl_dnd_init()) {
fprintf(stderr, "Could not initialize Ewl DND support.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_dnd_shutdown);
if (!ewl_io_manager_init()) {
fprintf(stderr, "Could not initialize Ewl IO Manager.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_io_manager_shutdown);
if (!ewl_text_context_init()) {
fprintf(stderr, "Could not initialize Ewl Text Context system.\n");
goto FAILED;
}
ecore_list_prepend(shutdown_queue, ewl_text_context_shutdown);
if (!(idle_enterer = ecore_idle_enterer_add(ewl_idle_render, NULL))) {
fprintf(stderr, "Could not create Idle Enterer.\n");
goto FAILED;
}
DRETURN_INT(ewl_init_count, DLEVEL_STABLE);
FAILED:
ewl_shutdown();
DRETURN_INT(ewl_init_count, DLEVEL_STABLE);
}
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);
}
evfs_connection *
evfs_connect(void (*callback_func) (EvfsEvent *, void *), void *obj)
{
ecore_init();
ecore_ipc_init();
int connect_attempts = 0;
evfs_connection *connection = NEW(evfs_connection);
connection->id = MAX_CLIENT;
connection->prog_event = NULL;
connection->callback_func = callback_func;
connection->obj = obj;
evfs_io_initialise();
evfs_vfolder_initialise();
if (!_libevfs_init)
{
_libevfs_init = 1;
_libevfs_next_command_id = 1;
evfs_session_servers = ecore_hash_new(ecore_direct_hash, ecore_direct_compare);
/*Register the callback*/
ecore_event_handler_add(ECORE_IPC_EVENT_SERVER_DATA, evfs_server_data,
NULL);
client_list = ecore_list_new();
ecore_list_append(client_list, connection);
}
else
{
ecore_list_prepend(client_list, connection);
}
retry:
if (connect_attempts > MAX_ATTEMPTS)
{
fprintf(stderr, "Could not start server after max attempts\n");
exit(1); /*We shouldn't really kill the libraries parent! */
return NULL;
}
if (!
(connection->server =
ecore_ipc_server_connect(ECORE_IPC_LOCAL_USER, EVFS_IPC_TITLE,0,
connection)))
{
fprintf(stderr,
"Cannot connect to evfs server with '%s', making new server and trying again..\n",
EVFS_IPC_TITLE);
if (!connect_attempts)
{
if (evfs_server_spawn())
{
printf("Failure to start evfs server!\n");
}
}
connect_attempts++;
usleep(100000 * connect_attempts);
goto retry;
} else {
ecore_hash_set(evfs_session_servers, connection->server, (int*)1);
while (connection->id == MAX_CLIENT) {
/*printf("Waiting for connection id..\n");*/
ecore_main_loop_iterate();
}
/*printf("Got connection ID: %d\n", connection->id);*/
}
return connection;
}
