EAPI int efreet_shutdown(void) { if (_efreet_init_count <= 0) { EINA_LOG_ERR("Init count not greater than 0 in shutdown."); return 0; } if (--_efreet_init_count != 0) return _efreet_init_count; efreet_util_shutdown(); efreet_menu_shutdown(); efreet_desktop_shutdown(); efreet_ini_shutdown(); efreet_icon_shutdown(); efreet_xml_shutdown(); efreet_cache_shutdown(); efreet_base_shutdown(); IF_RELEASE(efreet_lang); IF_RELEASE(efreet_lang_country); IF_RELEASE(efreet_lang_modifier); IF_RELEASE(efreet_language); efreet_parsed_locale = 0; /* reset this in case they init efreet again */ ecore_file_shutdown(); ecore_shutdown(); eet_shutdown(); eina_shutdown(); return _efreet_init_count; }
/** * @internal * @returns the number of initializations left for this system * @brief Attempts to shut down the subsystem if nothing else is using it */ void efreet_desktop_shutdown(void) { Efreet_Desktop_Type_Info *info; char *dir; if (efreet_desktop_exe_handler) ecore_event_handler_del(efreet_desktop_exe_handler); IF_RELEASE(desktop_environment); IF_FREE_HASH(efreet_desktop_cache); while (efreet_desktop_types) { info = eina_list_data_get(efreet_desktop_types); efreet_desktop_type_info_free(info); efreet_desktop_types = eina_list_remove_list(efreet_desktop_types, efreet_desktop_types); } EINA_LIST_FREE(efreet_desktop_dirs, dir) eina_stringshare_del(dir); if (cache_monitor) ecore_file_monitor_del(cache_monitor); if (change_monitors) eina_hash_free(change_monitors); if (cache) eet_close(cache); efreet_desktop_edd_shutdown(desktop_edd); ecore_file_shutdown(); eina_log_domain_unregister(_efreet_desktop_log_dom); IF_RELEASE(cache_file); IF_RELEASE(cache_dirs); if (efreet_desktop_job) ecore_job_del(efreet_desktop_job); efreet_desktop_job = NULL; }
EAPI int efreet_mime_shutdown(void) { if (--_efreet_mime_init_count != 0) return _efreet_mime_init_count; efreet_mime_icons_debug(); IF_RELEASE(_mime_inode_symlink); IF_RELEASE(_mime_inode_fifo); IF_RELEASE(_mime_inode_chardevice); IF_RELEASE(_mime_inode_blockdevice); IF_RELEASE(_mime_inode_socket); IF_RELEASE(_mime_inode_mountpoint); IF_RELEASE(_mime_inode_directory); IF_RELEASE(_mime_application_x_executable); IF_RELEASE(_mime_application_octet_stream); IF_RELEASE(_mime_text_plain); IF_FREE_LIST(globs, efreet_mime_glob_free); IF_FREE_LIST(magics, efreet_mime_magic_free); IF_FREE_HASH(monitors); IF_FREE_HASH(wild); IF_FREE_HASH(mime_icons); eina_log_domain_unregister(_efreet_mime_log_dom); _efreet_mime_log_dom = -1; efreet_shutdown(); ecore_file_shutdown(); ecore_shutdown(); return _efreet_mime_init_count; }
/** * @return Returns the number of times the init function as been called * minus the corresponding init call. * @brief Shuts down Efreet if a balanced number of init/shutdown calls have * been made */ EAPI int efreet_shutdown(void) { if (--_efreet_init_count != 0) return _efreet_init_count; efreet_util_shutdown(); efreet_menu_shutdown(); efreet_desktop_shutdown(); efreet_ini_shutdown(); efreet_icon_shutdown(); efreet_xml_shutdown(); efreet_cache_shutdown(); efreet_base_shutdown(); eina_log_domain_unregister(_efreet_log_domain_global); IF_RELEASE(efreet_lang); IF_RELEASE(efreet_lang_country); IF_RELEASE(efreet_lang_modifier); efreet_parsed_locale = 0; /* reset this in case they init efreet again */ ecore_file_shutdown(); ecore_shutdown(); eet_shutdown(); eina_shutdown(); return _efreet_init_count; }
/* externally accessible functions */ int main(int argc, char **argv) { int i; for (i = 1; i < argc; i++) { if ((!strcmp(argv[i], "-h")) || (!strcmp(argv[i], "-help")) || (!strcmp(argv[i], "--help"))) { printf( "This is an internal tool for Enlightenment.\n" "do not use it.\n" ); exit(0); } else if (!strncmp(argv[i], "--nice=", 7)) { const char *val; int ret = 0; val = argv[i] + 7; if (*val) ret = nice(atoi(val)); } } ecore_init(); ecore_app_args_set(argc, (const char **)argv); eet_init(); evas_init(); ecore_evas_init(); edje_init(); ecore_file_init(); ecore_ipc_init(); e_user_dir_concat_static(_thumbdir, "fileman/thumbnails"); ecore_file_mkpath(_thumbdir); if (_e_ipc_init()) ecore_main_loop_begin(); if (_e_ipc_server) { ecore_ipc_server_del(_e_ipc_server); _e_ipc_server = NULL; } ecore_ipc_shutdown(); ecore_file_shutdown(); ecore_evas_shutdown(); edje_shutdown(); evas_shutdown(); eet_shutdown(); ecore_shutdown(); return 0; }
RunLoop::~RunLoop() { if (m_initEfl) { edje_shutdown(); ecore_file_shutdown(); ecore_evas_shutdown(); ecore_shutdown(); } }
/** * Shutdown libraries */ void elicit_libs_shutdown() { edje_shutdown(); ecore_file_shutdown(); ecore_evas_shutdown(); ecore_shutdown(); eina_shutdown(); }
void depose_storage(StorageData *sd) { CALLED(); storage_rewrite_all_items(sd); dump_items(sd); if (sd->ef) eet_close(sd->ef); sd->ef = NULL; eet_shutdown(); ecore_file_shutdown(); }
int main(void) { double start; Eina_Hash *headers; eina_init(); ecore_init(); ecore_file_init(); if (ecore_file_exists(DST)) ecore_file_unlink(DST); start = ecore_time_get(); if (ecore_file_download(URL, DST, completion_cb, progress_cb, NULL, NULL)) { printf("Download started successfully:\n URL: %s\n DEST: %s\n", URL, DST); ecore_main_loop_begin(); printf("\nTime elapsed: %f seconds\n", ecore_time_get() - start); printf("Downloaded %lld bytes\n", ecore_file_size(DST)); } else { printf("Error, can't start download\n"); goto done; } headers = eina_hash_string_small_new(NULL); eina_hash_add(headers, "Content-type", "application/x-gzip"); if (ecore_file_download_full(URL, DST_MIME, completion_cb, progress_cb, NULL, NULL, headers)) { printf("Download started successfully:\n URL: %s\n DEST: %s\n", URL, DST_MIME); ecore_main_loop_begin(); printf("\nTime elapsed: %f seconds\n", ecore_time_get() - start); printf("Downloaded %lld bytes\n", ecore_file_size(DST)); } else { printf("Error, can't start download\n"); goto done; } done: if (headers) eina_hash_free(headers); ecore_file_shutdown(); ecore_shutdown(); eina_shutdown(); return 0; }
/** * Initialize libraries */ int elicit_libs_init(void) { BrInitError error; if (!br_init(&error) && error != BR_INIT_ERROR_DISABLED) fprintf(stderr, "[Elicit] Failed to initialize binreloc (error code: %d)\nFalling back to hardcoded paths.", error); if (!eina_init()) { fprintf(stderr, "[Elicit] Failed to initialize eina.\n"); return 0; } if (!ecore_init()) { fprintf(stderr, "[Elicit] Failed to initialize ecore.\n"); eina_shutdown(); return 0; } if (!ecore_evas_init() || !ecore_evas_engine_type_supported_get(ECORE_EVAS_ENGINE_SOFTWARE_XLIB)) { fprintf(stderr, "[Elicit] Failed to initialize ecore_evas.\n"); fprintf(stderr, "[Elicit] Make sure you have the evas software X11 engine installed.\n"); eina_shutdown(); ecore_shutdown(); return 0; } if (!ecore_file_init()) { fprintf(stderr, "[Elicit] Failed to initialize ecore_file.\n"); eina_shutdown(); ecore_shutdown(); ecore_evas_shutdown(); return 0; } if (!edje_init()) { fprintf(stderr, "[Elicit] Failed to initialize edje.\n"); eina_shutdown(); ecore_shutdown(); ecore_evas_shutdown(); ecore_file_shutdown(); return 0; } return 1; }
int main(int argc, char *argv[]) { Eclair eclair; if (!eclair_init(&eclair, &argc, &argv)) return 1; ecore_main_loop_begin(); edje_shutdown(); ecore_file_shutdown(); ecore_evas_shutdown(); ecore_shutdown(); return 0; }
EAPI int efreet_mime_init(void) { if (++_efreet_mime_init_count != 1) return _efreet_mime_init_count; if (!ecore_init()) return --_efreet_mime_init_count; if (!ecore_file_init()) goto shutdown_ecore; if (!efreet_init()) goto shutdown_ecore_file; _efreet_mime_log_dom = eina_log_domain_register ("efreet_mime", EFREET_DEFAULT_LOG_COLOR); if (_efreet_mime_log_dom < 0) { EINA_LOG_ERR("Efreet: Could not create a log domain for efreet_mime."); goto shutdown_efreet; } efreet_mime_endianess = efreet_mime_endian_check(); monitors = eina_hash_string_superfast_new(EINA_FREE_CB(ecore_file_monitor_del)); efreet_mime_type_cache_clear(); if (!efreet_mime_init_files()) goto unregister_log_domain; return _efreet_mime_init_count; unregister_log_domain: eina_log_domain_unregister(_efreet_mime_log_dom); _efreet_mime_log_dom = -1; shutdown_efreet: efreet_shutdown(); shutdown_ecore_file: ecore_file_shutdown(); shutdown_ecore: ecore_shutdown(); return --_efreet_mime_init_count; }
/* externally accessible functions */ int main(int argc, char **argv) { if (argc > 1) { printf( "This is an internal tool for Enlightenment.\n" "do not use it.\n" ); exit(0); } eina_init(); eet_init(); ecore_init(); ecore_app_args_set(argc, (const char **)argv); ecore_file_init(); ecore_ipc_init(); _e_storage_volume_edd_init(); if (!_e_fm_ipc_init()) return -1; efm_log_dom = eina_log_domain_register("efm", EINA_COLOR_GREEN); _e_fm_init(); ecore_event_handler_add(ECORE_EXE_EVENT_DATA, _e_fm_ipc_slave_data_cb, NULL); ecore_event_handler_add(ECORE_EXE_EVENT_ERROR, _e_fm_ipc_slave_error_cb, NULL); ecore_event_handler_add(ECORE_EXE_EVENT_DEL, _e_fm_ipc_slave_del_cb, NULL); ecore_main_loop_begin(); if (_e_fm_ipc_server) { ecore_ipc_server_del(_e_fm_ipc_server); _e_fm_ipc_server = NULL; } _e_fm_shutdown(); _e_storage_volume_edd_shutdown(); ecore_ipc_shutdown(); ecore_file_shutdown(); ecore_shutdown(); eina_shutdown(); return 0; }
RunLoop::RunLoop() : m_initEfl(false) , m_wakeUpEventRequested(false) { if (!ecore_init()) { LOG_ERROR("could not init ecore."); return; } if (!ecore_evas_init()) { LOG_ERROR("could not init ecore_evas."); goto errorEcoreEvas; } if (!ecore_file_init()) { LOG_ERROR("could not init ecore_file."); goto errorEcoreFile; } if (!edje_init()) { LOG_ERROR("could not init edje."); goto errorEdje; } m_pipe = adoptPtr(ecore_pipe_add(wakeUpEvent, this)); m_initEfl = true; return; errorEdje: ecore_file_shutdown(); errorEcoreFile: ecore_evas_shutdown(); errorEcoreEvas: ecore_shutdown(); }
void bks_model_shutdown(void) { eina_lock_free(&mdl.lock); efreet_shutdown(); ecore_file_shutdown(); }
int main(int argc, char ** argv) { Eli_App * eap; eap = NULL; /* Initialize NLS */ #ifdef ENABLE_NLS setlocale(LC_MESSAGES, ""); setlocale(LC_MONETARY, ""); setlocale(LC_CTYPE, ""); bindtextdomain(PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset(PACKAGE, "UTF-8"); textdomain(PACKAGE); #endif /* Initialize Ecore */ if (!ecore_init()) { fprintf(stderr, _("Elitaire Error: Cannot init Ecore\n")); return 1; } if (!ecore_file_init()) { fprintf(stderr, _("Elitaire Error: Cannot init Ecore File\n")); return 1; } /* Initialize Edje */ if (!edje_init()) { fprintf(stderr, _("Elitaire Error: Cannot init Edje\n")); return 1; } /* Initialize Ecore_Config */ if (ecore_config_init("elitaire") != ECORE_CONFIG_ERR_SUCC) { fprintf(stderr, _("Elitaire Error: Cannot init Ecore Config\n")); return 1; } /* Initialize Ewl */ if (!ewl_init(&argc, argv)) { fprintf(stderr, _("Elitaire Error: Cannot init Ewl\n")); return 1; } /* Init Highscore and Statistics */ eli_highscore_init("elitaire"); eli_statistics_init("elitaire"); help_reader_init(PACKAGE_DATA_DIR"/doc/"); /* Init the main app */ eap = eli_app_new(); eli_app_init(eap, "edje"); eli_app_gui_make(eap); ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, sig_exit_cb, eap); /* ***Main Loop*** */ ecore_main_loop_begin(); eli_app_del(eap); /* shutdown all */ help_reader_shutdown(); eli_statistics_shutdown(); eli_highscore_shutdown(); ewl_shutdown(); //eli_app_gui_del(eap); ecore_config_shutdown(); ecore_file_shutdown(); edje_shutdown(); ecore_evas_shutdown(); ecore_shutdown(); return 0; }
int main(int argc, char *argv[]) { char path[PATH_MAX + 128], buf[PATH_MAX]; FILE *log; int fd; const char *log_file_dir = NULL; const char *hostname_str = NULL; #ifdef HAVE_SYS_RESOURCE_H setpriority(PRIO_PROCESS, 0, 19); #elif _WIN32 SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS); #endif if (!eina_init()) return 1; efreetd_mp_stat = eina_mempool_add("chained_mempool", "struct stat", NULL, sizeof(struct stat), 10); if (!efreetd_mp_stat) return 1; if (!ecore_init()) goto ecore_error; ecore_app_args_set(argc, (const char **)argv); if (!ecore_file_init()) goto ecore_file_error; if (!ipc_init()) goto ipc_error; if (!cache_init()) goto cache_error; log_file_dir = eina_environment_tmp_get(); if (gethostname(buf, sizeof(buf)) < 0) hostname_str = ""; else hostname_str = buf; snprintf(path, sizeof(path), "%s/efreetd_%s_XXXXXX.log", log_file_dir, hostname_str); fd = eina_file_mkstemp(path, NULL); if (fd < 0) { ERR("Can't create log file '%s'\b", path); goto tmp_error; } log = fdopen(fd, "wb"); if (!log) goto tmp_error; eina_log_print_cb_set(eina_log_print_cb_file, log); efreetd_log_dom = eina_log_domain_register("efreetd", EFREETD_DEFAULT_LOG_COLOR); if (efreetd_log_dom < 0) { EINA_LOG_ERR("Efreet: Could not create a log domain for efreetd."); goto tmp_error; } ecore_main_loop_begin(); eina_mempool_del(efreetd_mp_stat); cache_shutdown(); ipc_shutdown(); ecore_file_shutdown(); ecore_shutdown(); eina_log_domain_unregister(efreetd_log_dom); efreetd_log_dom = -1; eina_shutdown(); return 0; tmp_error: cache_shutdown(); cache_error: ipc_shutdown(); ipc_error: ecore_file_shutdown(); ecore_file_error: ecore_shutdown(); ecore_error: if (efreetd_log_dom >= 0) eina_log_domain_unregister(efreetd_log_dom); efreetd_log_dom = -1; eina_shutdown(); return 1; }
/** * @internal * @return Returns > 0 on success or 0 on failure * @brief Initialize the Desktop parser subsystem */ int efreet_desktop_init(void) { char buf[PATH_MAX]; _efreet_desktop_log_dom = eina_log_domain_register("Efreet_desktop", EFREET_DEFAULT_LOG_COLOR); if (_efreet_desktop_log_dom < 0) { ERROR("Efreet: Could not create a log domain for Efreet_desktop"); return 0; } if (!ecore_file_init()) goto ecore_error; desktop_edd = efreet_desktop_edd_init(); if (!desktop_edd) goto edd_error; efreet_desktop_cache = eina_hash_string_superfast_new(NULL); efreet_desktop_types = NULL; EFREET_DESKTOP_TYPE_APPLICATION = efreet_desktop_type_add("Application", efreet_desktop_application_fields_parse, efreet_desktop_application_fields_save, NULL); EFREET_DESKTOP_TYPE_LINK = efreet_desktop_type_add("Link", efreet_desktop_link_fields_parse, efreet_desktop_link_fields_save, NULL); EFREET_DESKTOP_TYPE_DIRECTORY = efreet_desktop_type_add("Directory", NULL, NULL, NULL); EFREET_EVENT_DESKTOP_CACHE_UPDATE = ecore_event_type_new(); snprintf(buf, sizeof(buf), "%s/.efreet", efreet_home_dir_get()); if (!ecore_file_mkpath(buf)) goto cache_error; if (efreet_cache_update) { efreet_desktop_exe_handler = ecore_event_handler_add(ECORE_EXE_EVENT_DEL, efreet_desktop_exe_cb, NULL); if (!efreet_desktop_exe_handler) goto cache_error; cache_monitor = ecore_file_monitor_add(buf, efreet_desktop_cache_update_cb, NULL); if (!cache_monitor) goto handler_error; efreet_desktop_changes_listen(); ecore_exe_run(PACKAGE_LIB_DIR "/efreet/efreet_desktop_cache_create", NULL); } /* TODO: Defer eet open until we actually need it open. */ cache = eet_open(efreet_desktop_cache_file(), EET_FILE_MODE_READ); return 1; handler_error: if (efreet_desktop_exe_handler) ecore_event_handler_del(efreet_desktop_exe_handler); cache_error: if (efreet_desktop_cache) eina_hash_free(efreet_desktop_cache); edd_error: ecore_file_shutdown(); ecore_error: eina_log_domain_unregister(_efreet_desktop_log_dom); return 0; }
EAPI int efreet_init(void) { #ifndef _WIN32 char *tmp; #endif if (++_efreet_init_count != 1) return _efreet_init_count; #ifndef _WIN32 /* Find users real uid and gid */ tmp = getenv("SUDO_UID"); if (tmp) ruid = strtoul(tmp, NULL, 10); else ruid = getuid(); tmp = getenv("SUDO_GID"); if (tmp) rgid = strtoul(tmp, NULL, 10); else rgid = getgid(); #endif if (!eina_init()) return --_efreet_init_count; if (!eet_init()) goto shutdown_eina; if (!ecore_init()) goto shutdown_eet; if (!ecore_file_init()) goto shutdown_ecore; if (!efreet_base_init()) goto shutdown_ecore_file; if (!efreet_cache_init()) goto shutdown_efreet_base; if (!efreet_xml_init()) goto shutdown_efreet_cache; if (!efreet_icon_init()) goto shutdown_efreet_xml; if (!efreet_ini_init()) goto shutdown_efreet_icon; if (!efreet_desktop_init()) goto shutdown_efreet_ini; if (!efreet_menu_init()) goto shutdown_efreet_desktop; if (!efreet_util_init()) goto shutdown_efreet_menu; #ifdef ENABLE_NLS bindtextdomain(PACKAGE, LOCALE_DIR); bind_textdomain_codeset(PACKAGE, "UTF-8"); #endif return _efreet_init_count; shutdown_efreet_menu: efreet_menu_shutdown(); shutdown_efreet_desktop: efreet_desktop_shutdown(); shutdown_efreet_ini: efreet_ini_shutdown(); shutdown_efreet_icon: efreet_icon_shutdown(); shutdown_efreet_xml: efreet_xml_shutdown(); shutdown_efreet_cache: efreet_cache_shutdown(); shutdown_efreet_base: efreet_base_shutdown(); shutdown_ecore_file: ecore_file_shutdown(); shutdown_ecore: ecore_shutdown(); shutdown_eet: eet_shutdown(); shutdown_eina: eina_shutdown(); return --_efreet_init_count; }
int main(int argc, char *argv[]) { char path[PATH_MAX]; FILE *log; strcpy(path, "/tmp/efreetd_XXXXXX"); if (mkstemp(path) < 0) { perror("mkstemp"); return 1; } if (chmod(path, 0700) < 0) { perror("chmod"); return 1; } log = fopen(path, "wb"); if (!log) return 1; if (!eina_init()) return 1; eina_log_print_cb_set(eina_log_print_cb_file, log); efreetd_log_dom = eina_log_domain_register("efreetd", EFREETD_DEFAULT_LOG_COLOR); if (efreetd_log_dom < 0) { EINA_LOG_ERR("Efreet: Could not create a log domain for efreetd."); goto ecore_error; } if (!ecore_init()) goto ecore_error; ecore_app_args_set(argc, (const char **)argv); if (!ecore_file_init()) goto ecore_file_error; if (!dbus_init()) goto dbus_error; if (!cache_init()) goto cache_error; #ifdef HAVE_SYS_RESOURCE_H setpriority(PRIO_PROCESS, 0, 19); #elif _WIN32 SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS); #endif ecore_main_loop_begin(); cache_shutdown(); dbus_shutdown(); ecore_file_shutdown(); ecore_shutdown(); eina_log_domain_unregister(efreetd_log_dom); efreetd_log_dom = -1; eina_shutdown(); return 0; cache_error: dbus_shutdown(); dbus_error: ecore_file_shutdown(); ecore_file_error: ecore_shutdown(); ecore_error: if (efreetd_log_dom >= 0) eina_log_domain_unregister(efreetd_log_dom); efreetd_log_dom = -1; eina_shutdown(); return 1; }
/** * @return Returns > 0 if the initialization was successful, 0 otherwise * @brief Initializes the Efreet system */ EAPI int efreet_init(void) { if (++_efreet_init_count != 1) return _efreet_init_count; if (!eina_init()) return --_efreet_init_count; if (!eet_init()) goto shutdown_eina; if (!ecore_init()) goto shutdown_eet; if (!ecore_file_init()) goto shutdown_ecore; _efreet_log_domain_global = eina_log_domain_register("efreet", EFREET_DEFAULT_LOG_COLOR); if (_efreet_log_domain_global < 0) { EINA_LOG_ERR("Efreet could create a general log domain."); goto shutdown_ecore_file; } if (!efreet_base_init()) goto unregister_log_domain; if (!efreet_cache_init()) goto shutdown_efreet_base; if (!efreet_xml_init()) goto shutdown_efreet_cache; if (!efreet_icon_init()) goto shutdown_efreet_xml; if (!efreet_ini_init()) goto shutdown_efreet_icon; if (!efreet_desktop_init()) goto shutdown_efreet_ini; if (!efreet_menu_init()) goto shutdown_efreet_desktop; if (!efreet_util_init()) goto shutdown_efreet_menu; return _efreet_init_count; shutdown_efreet_menu: efreet_menu_shutdown(); shutdown_efreet_desktop: efreet_desktop_shutdown(); shutdown_efreet_ini: efreet_ini_shutdown(); shutdown_efreet_icon: efreet_icon_shutdown(); shutdown_efreet_xml: efreet_xml_shutdown(); shutdown_efreet_cache: efreet_cache_shutdown(); shutdown_efreet_base: efreet_base_shutdown(); unregister_log_domain: eina_log_domain_unregister(_efreet_log_domain_global); shutdown_ecore_file: ecore_file_shutdown(); shutdown_ecore: ecore_shutdown(); shutdown_eet: eet_shutdown(); shutdown_eina: eina_shutdown(); return --_efreet_init_count; }
int main(int argc, char ** argv) { char *display = NULL; char *theme = NULL; int ret = 1; int i; if (!ecore_init()) { fprintf(stderr, "Error initing Ecore.\n"); goto SHUTDOWN; } ecore_app_args_set(argc, (const char **)argv); ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, entangle_cb_exit, NULL); for (i = 1; i < argc; i++) { if ((!strcmp(argv[i], "-display")) || (!strcmp(argv[i], "-d"))) { if (++i < argc) { IF_FREE(display); display = strdup(argv[i]); } else { fprintf(stderr, "ERROR: Missing argument to -display\n"); goto ECORE_SHUTDOWN; } } else if ((!strcmp(argv[i], "-theme")) || (!strcmp(argv[i], "-t"))) { if (++i < argc) { IF_FREE(theme); theme = strdup(argv[i]); } else { fprintf(stderr, "ERROR: Missing argument to -theme\n"); goto ECORE_SHUTDOWN; } } else if ((!strcmp(argv[i], "-help")) || (!strcmp(argv[i], "-h"))) { entangle_usage(argv); return 0; } } /* make sure the theme is valid */ if (theme) { char *p; p = strstr(theme, ".edj"); if (p && (strlen(theme) - (p - theme) == strlen(".edj"))) { if (!ecore_file_exists(theme)) { char tmp[PATH_MAX]; snprintf(tmp, PATH_MAX, PACKAGE_DATA_DIR"/data/entangle/%s", theme); FREE(theme); if (ecore_file_exists(tmp)) theme = strdup(tmp); } } else { char tmp[PATH_MAX]; snprintf(tmp, PATH_MAX, PACKAGE_DATA_DIR"/data/entangle/%s.edj", theme); FREE(theme); if (ecore_file_exists(tmp)) theme = strdup(tmp); } } if (!theme) theme = strdup(PACKAGE_DATA_DIR"/data/entangle/default.edj"); /* make sure the display is valid */ if (!display) { char *tmp = getenv("DISPLAY"); if (tmp) display = strdup(tmp); } if (display) { char *p; char buf[1024]; p = strrchr(display, ':'); if (!p) { snprintf(buf, sizeof(buf), "%s:0.0", display); FREE(display); display = strdup(buf); } else { p = strrchr(p, '.'); if (!p) { snprintf(buf, sizeof(buf), "%s.0", display); FREE(display); display = strdup(buf); } } } else display = strdup(":0.0"); if (!ecore_file_init()) { fprintf(stderr, "Error initing Ecore_File.\n"); goto ECORE_SHUTDOWN; } if (!ecore_evas_init()) { fprintf(stderr, "Error initing Ecore_Evas.\n"); goto ECORE_FILE_SHUTDOWN; } if (!edje_init()) { fprintf(stderr, "Error initing Edje.\n"); goto ECORE_EVAS_SHUTDOWN; } if (!eet_init()) { fprintf(stderr, "Error initing Eet.\n"); goto EDJE_SHUTDOWN; } if (!entangle_eapps_init()) { fprintf(stderr, "Error initing Entangle_Eapps.\n"); goto EET_SHUTDOWN; } if (!entangle_apps_init()) { fprintf(stderr, "Error initing Entangle_Apps.\n"); goto ENTANGLE_EAPPS_SHUTDOWN; } if (!entangle_ui_init(display, theme)) { fprintf(stderr, "Error initing Entangle_Ui.\n"); goto ENTANGLE_APPS_SHUTDOWN; } ecore_main_loop_begin(); ret = 0; entangle_ui_shutdown(); ENTANGLE_APPS_SHUTDOWN: entangle_apps_shutdown(); ENTANGLE_EAPPS_SHUTDOWN: entangle_eapps_shutdown(); EET_SHUTDOWN: eet_shutdown(); EDJE_SHUTDOWN: edje_shutdown(); ECORE_EVAS_SHUTDOWN: ecore_evas_shutdown(); ECORE_FILE_SHUTDOWN: ecore_file_shutdown(); ECORE_SHUTDOWN: ecore_shutdown(); SHUTDOWN: IF_FREE(display); IF_FREE(theme); return ret; }