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;
}
