int
main(int argc, char **argv)
{
const char *tmp;
int i = 0;
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 Moksha.\n"
"do not use it.\n");
exit(0);
}
else if (i == 1)
sig = atoi(argv[i]); // signal
else if (i == 2)
pid = atoi(argv[i]); // E's pid
else if (i == 3)
backtrace_str = argv[i];
else if (i == 4)
exit_gdb = atoi(argv[i]);
}
fprintf(stderr, "exit_gdb: %i\n", exit_gdb);
tmp = getenv("E17_TAINTED");
if (tmp && !strcmp(tmp, "NO"))
tainted = EINA_FALSE;
if (!ecore_init()) return EXIT_FAILURE;
ecore_app_args_set(argc, (const char **)argv);
if (!_e_alert_connect())
{
printf("FAILED TO INIT ALERT SYSTEM!!!\n");
ecore_shutdown();
return EXIT_FAILURE;
}
title = "Moksha Error";
str1 = "(F1) Recover";
str2 = "(F12) Logout";
_e_alert_create();
_e_alert_display();
_e_alert_run();
_e_alert_shutdown();
ecore_shutdown();
/* ret == 1 => restart e => exit code 1 */
/* ret == 2 => exit e => any code will do that */
return ret;
}
int
main(int argc, char *argv[])
{
GstElement *pipeline;
char *filename;
Ecore_Pipe *pipe;
gst_init(&argc, &argv);
if (!ecore_init())
{
gst_deinit();
return 0;
}
pipe = ecore_pipe_add(handler);
if (!pipe)
{
ecore_shutdown();
gst_deinit();
return 0;
}
if (argc < 2)
{
g_print("usage: %s file.avi\n", argv[0]);
ecore_pipe_del(pipe);
ecore_shutdown();
gst_deinit();
return 0;
}
filename = argv[1];
pipeline = _buid_pipeline(filename, pipe);
if (!pipeline)
{
g_print("Error during the pipeline building\n");
ecore_pipe_del(pipe);
ecore_shutdown();
gst_deinit();
return -1;
}
gst_element_set_state(pipeline, GST_STATE_PLAYING);
ecore_main_loop_begin();
ecore_pipe_del(pipe);
ecore_shutdown();
gst_deinit();
return 0;
}
bool platformInitialize() override
{
if (!eina_init())
return false;
if (!ecore_init()) {
// Could not init ecore.
eina_shutdown();
return false;
}
#ifdef HAVE_ECORE_X
XSetExtensionErrorHandler(dummyExtensionErrorHandler);
if (!ecore_x_init(0)) {
// Could not init ecore_x.
// PlatformScreenEfl and systemBeep() functions
// depend on ecore_x functionality.
ecore_shutdown();
eina_shutdown();
return false;
}
#endif
if (!ecore_evas_init()) {
#ifdef HAVE_ECORE_X
ecore_x_shutdown();
#endif
ecore_shutdown();
eina_shutdown();
return false;
}
if (!edje_init()) {
ecore_evas_shutdown();
#ifdef HAVE_ECORE_X
ecore_x_shutdown();
#endif
ecore_shutdown();
eina_shutdown();
return false;
}
if (!ecore_main_loop_glib_integrate())
return false;
SoupNetworkSession::defaultSession().setupHTTPProxyFromEnvironment();
return true;
}
/**
* 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;
}
END_TEST
/* Basic testing for address API */
START_TEST(elocation_test_api_address)
{
Eina_Bool ret;
Elocation_Address *address = NULL;
ret = ecore_init();
fail_if(ret != EINA_TRUE);
ret = edbus_init();
fail_if(ret != EINA_TRUE);
ret = elocation_init();
fail_if(ret != EINA_TRUE);
address = elocation_address_new();
fail_if(address == NULL);
ret = elocation_address_get(address);
fail_if(ret != EINA_TRUE);
elocation_address_free(address);
elocation_shutdown();
edbus_shutdown();
ecore_shutdown();
}
END_TEST
/* Basic testing for position API */
START_TEST(elocation_test_api_position)
{
Eina_Bool ret;
Elocation_Position *position = NULL;
ret = ecore_init();
fail_if(ret != EINA_TRUE);
ret = edbus_init();
fail_if(ret != EINA_TRUE);
ret = elocation_init();
fail_if(ret != EINA_TRUE);
position = elocation_position_new();
fail_if(position == NULL);
ret = elocation_position_get(position);
fail_if(ret != EINA_TRUE);
elocation_position_free(position);
elocation_shutdown();
edbus_shutdown();
ecore_shutdown();
}
int
main (int argc, char *argv[])
{
Ecore_Pipe *pipe;
pid_t child_pid;
ecore_init();
pipe = ecore_pipe_add(handler, NULL);
child_pid = fork();
if(!child_pid)
{
ecore_pipe_read_close(pipe);
do_lengthy_task(pipe);
}
else
{
ecore_pipe_write_close(pipe);
ecore_main_loop_begin();
}
ecore_pipe_del(pipe);
ecore_shutdown();
return 0;
}
/**
* @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;
}
/**
* @brief Shuts down Etk. It decrements the init-counter. If the counter reaches 0, it frees all the resources used by Etk
* @return Returns the new value of the init-counter. If 0 is returned, it means that the resources has effectively
* been freed.
*/
int etk_shutdown(void)
{
if (_etk_main_init_count <= 0)
return 0;
_etk_main_init_count--;
if (_etk_main_init_count == 0)
{
ecore_idle_enterer_del(_etk_main_idle_enterer);
_etk_main_idle_enterer = NULL;
/* Shutdown the subsystems of Etk */
etk_object_shutdown();
etk_type_shutdown();
etk_signal_shutdown();
etk_tooltips_shutdown();
etk_event_shutdown();
etk_engine_shutdown();
etk_config_shutdown();
etk_theme_shutdown();
etk_argument_shutdown();
/* Shutdown the EFL*/
edje_shutdown();
ecore_imf_shutdown();
ecore_shutdown();
evas_shutdown();
}
return _etk_main_init_count;
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
int main(int argc, char **argv)
{
Eon_Window *win;
Ender_Element *layout;
Eon_Backend *backend;
Ender_Element *e;
int i;
eon_init();
ecore_init();
//backend = eon_ecore_remote_new();
backend = eon_ecore_sdl_new();
layout = eon_stack_new();
win = eon_window_new(backend, layout, 320, 240);
eon_stack_orientation_set(layout, EON_STACK_ORIENTATION_VERTICAL);
e = eon_color_new();
eon_layout_child_add(layout, e);
e = eon_color_new();
eon_layout_child_add(layout, e);
ecore_main_loop_begin();
ecore_shutdown();
eon_shutdown();
return 0;
}
static void document_delete(void *d)
{
Engine_Remote_Document *rdoc = d;
ecore_ipc_shutdown();
ecore_shutdown();
}
EAPI int
eeze_shutdown(void)
{
if (_eeze_init_count <= 0)
{
EINA_LOG_ERR("Init count not greater than 0 in shutdown.");
return 0;
}
if (--_eeze_init_count != 0)
return _eeze_init_count;
udev_unref(udev);
#ifdef HAVE_EEZE_MOUNT
eeze_disk_shutdown();
#endif
eeze_sensor_shutdown();
eeze_net_shutdown();
ecore_shutdown();
eina_log_domain_unregister(_eeze_udev_log_dom);
_eeze_udev_log_dom = -1;
eina_log_domain_unregister(_eeze_net_log_dom);
_eeze_net_log_dom = -1;
eina_log_domain_unregister(_eeze_sensor_log_dom);
_eeze_sensor_log_dom = -1;
eina_shutdown();
return _eeze_init_count;
}
EAPI int
ecore_audio_shutdown(void)
{
DBG("Ecore_Audio shutdown");
if (--_ecore_audio_init_count != 0)
return _ecore_audio_init_count;
#ifdef HAVE_SNDFILE
ecore_audio_sndfile_lib_unload();
#endif /* HAVE_SNDFILE */
#ifdef HAVE_PULSE
ecore_audio_pulse_lib_unload();
#endif /* HAVE_PULSE */
/* FIXME: Shutdown all the inputs and outputs first */
eina_log_timing(_ecore_audio_log_dom,
EINA_LOG_STATE_START,
EINA_LOG_STATE_SHUTDOWN);
eina_list_free(ecore_audio_modules);
eina_log_domain_unregister(_ecore_audio_log_dom);
_ecore_audio_log_dom = -1;
efl_object_shutdown();
ecore_shutdown();
return _ecore_audio_init_count;
}
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;
}
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;
}
int
main(int argc, char **argv)
{
struct context ctxt = {0};
if (!ecore_init())
{
printf("ERROR: Cannot init Ecore!\n");
return -1;
}
_event_type = ecore_event_type_new();
ctxt.enterer = ecore_idle_enterer_add(_enterer_cb, &ctxt);
ctxt.exiter = ecore_idle_exiter_add(_exiter_cb, &ctxt);
// ctxt.idler = ecore_idler_add(_idler_cb, &ctxt);
ctxt.idler = eo_add_custom(ECORE_IDLER_CLASS, NULL, ecore_idler_constructor(_idler_cb, &ctxt));
ctxt.handler = ecore_event_handler_add(_event_type,
_event_handler_cb,
&ctxt);
ctxt.timer = ecore_timer_add(0.0005, _timer_cb, &ctxt);
ecore_main_loop_begin();
ecore_shutdown();
return 0;
}
// return 0 for normal case
int daemonLoop(void)
{
int return_value = 0;
ecore_init();
if (init_input_events() == -1) {
return_value = -1;
goto END_EVENT;
}
if (!initialize_events()) {
return_value = -1;
goto END_EFD;
}
if (launch_timer_start() < 0) {
LOGE("Launch timer start failed\n");
return_value = -1;
goto END_EFD;
}
init_prof_session(&prof_session);
ecore_main_loop_begin();
ecore_shutdown();
END_EFD:
LOGI("close efd\n");
close(manager.efd);
END_EVENT:
return return_value;
}
int
main(int argc, char **argv)
{
double interval = 0.3; // tick each 0.3 seconds
Ecore_Poller *poller1, *poller2;
char *str1 = "poller1";
char *str2 = "poller2";
if (!ecore_init())
{
printf("ERROR: Cannot init Ecore!\n");
return -1;
}
_initial_time = ecore_time_get();
ecore_poller_poll_interval_set(ECORE_POLLER_CORE, interval);
poller1 = ecore_poller_add(ECORE_POLLER_CORE, 4, _poller_print_cb, str1);
poller2 = ecore_poller_add(ECORE_POLLER_CORE, 8, _poller_print_cb, str2);
ecore_main_loop_begin();
printf("changing poller2 interval to 16\n");
ecore_poller_poller_interval_set(poller2, 16);
ecore_main_loop_begin();
ecore_poller_del(poller1);
ecore_poller_del(poller2);
ecore_shutdown();
}
Main::~Main()
{
// Remove any watchers
for (EcoreFdHandlerList::iterator iterator = m_readWatchersList.begin(); iterator != m_readWatchersList.end(); ++iterator)
ecore_main_fd_handler_del(*iterator);
m_readWatchersList.clear();
for (EcoreFdHandlerList::iterator iterator = m_writeWatchersList.begin(); iterator != m_writeWatchersList.end(); ++iterator)
ecore_main_fd_handler_del(*iterator);
m_writeWatchersList.clear();
// Remove event invoker
ecore_main_fd_handler_del(m_invokerHandler);
m_invokerHandler = NULL;
//set old ecore select function, because after ecore_shutdown() call,
//it is being called once again and it may crash.
ecore_main_loop_select_func_set(m_oldEcoreSelect);
// Decrement ECORE init count
// We do not need ecore routines any more
ecore_shutdown();
// Late EFL event handling
Assert(g_lateMain == this);
g_lateMain = NULL;
}
int
main(void)
{
Esql *e;
struct ctx ctx = {0, 0, 0};
ecore_init();
esql_init();
eina_log_domain_level_set("esskyuehl", EINA_LOG_LEVEL_DBG);
e = esql_new(ESQL_TYPE_SQLITE);
assert(e != NULL);
ecore_event_handler_add(ESQL_EVENT_CONNECT, on_connect, &ctx);
ecore_event_handler_add(ESQL_EVENT_ERROR, on_error, &ctx);
assert(esql_connect(e, ":memory:", NULL, NULL));
ecore_main_loop_begin();
esql_disconnect(e);
esql_shutdown();
ecore_shutdown();
assert(ctx.conns == 1);
assert(ctx.errors == 0);
assert(ctx.res == 2 + INSERTED_ROWS);
return 0;
}
EAPI int
ecore_audio_init(void)
{
if (++_ecore_audio_init_count != 1)
return _ecore_audio_init_count;
if (!ecore_init())
return --_ecore_audio_init_count;
if (!efl_object_init()) {
ecore_shutdown();
return --_ecore_audio_init_count;
}
_ecore_audio_log_dom = eina_log_domain_register("ecore_audio", ECORE_AUDIO_DEFAULT_LOG_COLOR);
if (_ecore_audio_log_dom < 0)
{
EINA_LOG_ERR("Impossible to create a log domain for the ecore audio module.");
return --_ecore_audio_init_count;
}
DBG("Ecore_Audio init");
ecore_audio_modules = NULL;
eina_log_timing(_ecore_audio_log_dom,
EINA_LOG_STATE_STOP,
EINA_LOG_STATE_INIT);
return _ecore_audio_init_count;
}
void sourcedrop_shutdown(void)
{
ecore_event_handler_del(handler);
handler = NULL;
ecore_con_shutdown();
ecore_shutdown();
}
/* 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;
}
/**
* Shutdown libraries
*/
void
elicit_libs_shutdown()
{
edje_shutdown();
ecore_file_shutdown();
ecore_evas_shutdown();
ecore_shutdown();
eina_shutdown();
}
RunLoop::~RunLoop()
{
if (m_initEfl) {
edje_shutdown();
ecore_file_shutdown();
ecore_evas_shutdown();
ecore_shutdown();
}
}
void ui_shutdown(ePlayer *player) {
assert(player);
ui_shutdown_edje(player);
ewl_shutdown();
edje_shutdown();
ecore_evas_shutdown();
ecore_shutdown();
}
/**
* Shuts down the Ecore_IMF library.
* @return Number of times the library has been initialised without being
* shut down.
* @ingroup Ecore_IMF_Lib_Group
*/
EAPI int
ecore_imf_shutdown(void)
{
if (--_ecore_imf_init_count != 0) return _ecore_imf_init_count;
ecore_imf_module_shutdown();
eina_log_domain_unregister(_ecore_imf_log_dom);
_ecore_imf_log_dom = -1;
ecore_shutdown();
return _ecore_imf_init_count;
}
int ewk_init(void)
{
if (_ewkInitCount)
return ++_ewkInitCount;
if (!eina_init())
goto error_eina;
_ewk_log_dom = eina_log_domain_register("ewebkit", EINA_COLOR_ORANGE);
if (_ewk_log_dom < 0) {
EINA_LOG_CRIT("could not register log domain 'ewebkit'");
goto error_log_domain;
}
if (!evas_init()) {
CRITICAL("could not init evas.");
goto error_evas;
}
if (!ecore_init()) {
CRITICAL("could not init ecore.");
goto error_ecore;
}
if (!ecore_evas_init()) {
CRITICAL("could not init ecore_evas.");
goto error_ecore_evas;
}
if (!edje_init()) {
CRITICAL("could not init edje.");
goto error_edje;
}
if (!_ewk_init_body()) {
CRITICAL("could not init body");
goto error_edje;
}
return ++_ewkInitCount;
error_edje:
ecore_evas_shutdown();
error_ecore_evas:
ecore_shutdown();
error_ecore:
evas_shutdown();
error_evas:
eina_log_domain_unregister(_ewk_log_dom);
_ewk_log_dom = -1;
error_log_domain:
eina_shutdown();
error_eina:
return 0;
}
EAPI int
eio_shutdown(void)
{
Eio_File_Direct_Info *info;
Eio_File_Char *cin;
Eio_Progress *pg;
Eio_File_Associate *asso;
if (_eio_init_count <= 0)
{
ERR("Init count not greater than 0 in shutdown.");
return 0;
}
if (--_eio_init_count != 0)
return _eio_init_count;
eina_log_timing(_eio_log_dom_global,
EINA_LOG_STATE_START,
EINA_LOG_STATE_SHUTDOWN);
eio_monitor_shutdown();
eina_condition_free(&(memory_pool_cond));
eina_lock_free(&(memory_pool_mutex));
eina_spinlock_free(&(memory_pool_lock));
eina_lock_free(&(direct_info_pool.lock));
eina_lock_free(&(progress_pool.lock));
eina_lock_free(&(char_pool.lock));
eina_lock_free(&(associate_pool.lock));
/* Cleanup pool */
EINA_TRASH_CLEAN(&progress_pool.trash, pg)
free(pg);
progress_pool.count = 0;
EINA_TRASH_CLEAN(&direct_info_pool.trash, info)
free(info);
direct_info_pool.count = 0;
EINA_TRASH_CLEAN(&char_pool.trash, cin)
free(cin);
char_pool.count = 0;
EINA_TRASH_CLEAN(&associate_pool.trash, asso)
free(asso);
associate_pool.count = 0;
ecore_shutdown();
eina_log_domain_unregister(_eio_log_dom_global);
_eio_log_dom_global = -1;
eina_shutdown();
return _eio_init_count;
}
