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