kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "cxx: Fix manual code after efl_app change." 

This reverts commit 135154303b.

Revert "efl: move signal events from efl.loop to efl.app"
This reverts commit 3dbca39f98.

Revert "efl: add test suite for efl_app"
This reverts commit 3e94be5d73.

Revert "efl: create Efl.App class, the parent of Efl.Loop"
This reverts commit 28fe00b94e.

Go back to before efl.app because I think this should be done with
superclassing here not a parent object. reasons?

1. multiple loops per single thread make no sense. so if multilpe loop
objects they wont be contained in a single app object and then deleted
like this.
2. the app object is not really sharable in this design so it cant be
accessed from other threads
3. it makes it harder to get the main loop or app object (well 2 func
calls one calling the other and more typing. it is longer to type and
more work where it is not necessary, and again it can't work from
other threads unless we go duplicating efl.app per thread and then
what is the point of splittyign out the signal events from efl.loop
then?)

etc.
This commit is contained in:
Carsten Haitzler 2018-02-27 14:10:12 +09:00
parent 6f092071ac
commit 1c74aaa7e9
65 changed files with 373 additions and 549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/Makefile_Ecore.am
View File

@ -8,7 +8,6 @@ ecore_eolian_files_legacy = \
lib/ecore/efl_loop_timer.eo
ecore_eolian_files_public = \
lib/ecore/efl_app.eo \
lib/ecore/efl_loop.eo \
lib/ecore/efl_loop_consumer.eo \
lib/ecore/efl_loop_fd.eo \
@ -96,7 +95,6 @@ lib/ecore/ecore_job.c \
lib/ecore/ecore_main.c \
lib/ecore/ecore_event_message.c \
lib/ecore/ecore_event_message_handler.c \
lib/ecore/efl_app.c \
lib/ecore/efl_loop.c \
lib/ecore/efl_loop_consumer.c \
lib/ecore/efl_loop_fd.c \
@ -264,8 +262,8 @@ endif
if EFL_ENABLE_TESTS
check_PROGRAMS += tests/ecore/ecore_suite tests/ecore/efl_app_suite
TESTS += tests/ecore/ecore_suite tests/ecore/efl_app_suite
check_PROGRAMS += tests/ecore/ecore_suite
TESTS += tests/ecore/ecore_suite
tests_ecore_ecore_suite_SOURCES = \
tests/ecore/ecore_suite.c \
@ -324,51 +322,6 @@ tests_ecore_ecore_suite_DEPENDENCIES = \
@USE_ECORE_FB_INTERNAL_LIBS@ \
@USE_ECORE_INPUT_INTERNAL_LIBS@
tests_ecore_efl_app_suite_SOURCES = \
tests/ecore/efl_app_suite.c \
tests/ecore/efl_app_suite.h
tests_ecore_efl_app_suite_CPPFLAGS = -I$(top_builddir)/src/lib/efl \
-DTESTS_SRC_DIR=\"$(top_srcdir)/src/tests/ecore\" \
-DTESTS_BUILD_DIR=\"$(top_builddir)/src/tests/ecore\" \
@CHECK_CFLAGS@ \
@ECORE_CFLAGS@ \
@ECORE_AUDIO_CFLAGS@ \
@ECORE_FILE_CFLAGS@ \
@ECORE_X_CFLAGS@ \
@ECORE_IMF_CFLAGS@ \
@ECORE_EVAS_CFLAGS@ \
@ECORE_WAYLAND_CFLAGS@ \
@ECORE_WAYLAND_SRV_CFLAGS@ \
@ECORE_DRM_CFLAGS@ \
@ECORE_FB_CFLAGS@ \
@ECORE_INPUT_CFLAGS@
tests_ecore_efl_app_suite_LDADD = \
@CHECK_LIBS@ \
@USE_ECORE_LIBS@ \
@USE_ECORE_AUDIO_LIBS@ \
@USE_ECORE_FILE_LIBS@ \
@USE_ECORE_X_LIBS@ \
@USE_ECORE_IMF_LIBS@ \
@USE_ECORE_EVAS_LIBS@ \
@USE_ECORE_WAYLAND_LIBS@ \
@USE_ECORE_FB_LIBS@ \
@ECORE_WAYLAND_SRV_LIBS@ \
@ECORE_DRM_LIBS@ \
@USE_ECORE_INPUT_LIBS@
tests_ecore_efl_app_suite_DEPENDENCIES = \
@USE_ECORE_INTERNAL_LIBS@ \
@USE_ECORE_AUDIO_INTERNAL_LIBS@ \
@USE_ECORE_FILE_INTERNAL_LIBS@ \
@USE_ECORE_X_INTERNAL_LIBS@ \
@USE_ECORE_IMF_INTERNAL_LIBS@ \
@USE_ECORE_EVAS_INTERNAL_LIBS@ \
@USE_ECORE_WAYLAND_INTERNAL_LIBS@ \
@USE_ECORE_DRM_INTERNAL_LIBS@ \
@USE_ECORE_FB_INTERNAL_LIBS@ \
@USE_ECORE_INPUT_INTERNAL_LIBS@
if HAVE_ECORE_X
tests_ecore_ecore_suite_SOURCES += tests/ecore/ecore_test_ecore_x.c
endif

2
src/bin/eeze/eeze_scanner/eeze_scanner.c
View File

@ -494,7 +494,7 @@ main(void)
goto end;
}
loop = efl_app_main_loop_get(efl_app_get());
loop = efl_main_loop_get();
#ifdef EFL_NET_SERVER_UNIX_CLASS
server = efl_add(EFL_NET_SERVER_SIMPLE_CLASS, loop,

2
src/bin/eeze/eeze_scanner_monitor/eeze_scanner_monitor.c
View File

@ -151,7 +151,7 @@ main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
goto error_path;
}
loop = efl_app_main_loop_get(efl_app_get());
loop = efl_main_loop_get();
#ifdef EFL_NET_DIALER_UNIX_CLASS
dialer = efl_add(EFL_NET_DIALER_SIMPLE_CLASS, loop,

4
src/bin/efl/efl_debugd.c
View File

@ -569,7 +569,7 @@ _local_server_create(void)
snprintf(path, sizeof(path) - 1, "%s/%s/%s/%i", socket_path,
LOCAL_SERVER_PATH, LOCAL_SERVER_NAME, LOCAL_SERVER_PORT);
loop = efl_app_main_loop_get(efl_app_get());
loop = efl_main_loop_get();
#ifdef EFL_NET_SERVER_UNIX_CLASS
_local_server = efl_add(EFL_NET_SERVER_SIMPLE_CLASS, loop,
@ -624,7 +624,7 @@ _remote_server_create(void)
Eina_Bool ret = EINA_FALSE;
char address[256];
loop = efl_app_main_loop_get(efl_app_get());
loop = efl_main_loop_get();
_remote_server = efl_add(EFL_NET_SERVER_SIMPLE_CLASS, loop,
efl_net_server_simple_inner_class_set(efl_added, EFL_NET_SERVER_TCP_CLASS));

2
src/bindings/cxx/eo_cxx/eo_promise.hh
View File

@ -30,7 +30,7 @@ struct promise_common
explicit promise_common(std::nullptr_t) : _promise(nullptr) {}
promise_common()
{
_promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
_promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
}
~promise_common()
{

2
src/examples/eio/efl_io_manager_ls.c
View File

@ -50,7 +50,7 @@ progress_cb(void *data EINA_UNUSED, Eina_Accessor *access)
void list_files(void *data)
{
Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
const char *path = data;
eina_future_then(efl_io_manager_ls(job, path, NULL, progress_cb, NULL), done_cb, NULL);

2
src/examples/eio/efl_io_manager_open.c
View File

@ -65,7 +65,7 @@ void open_file(const char *path)
{
Efl_Io_Manager *job;
job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
eina_future_chain(efl_io_manager_open(job, path, EINA_FALSE),
{ .cb = _open_cb, .data = job },

2
src/examples/eio/efl_io_manager_open_multi.c
View File

@ -83,7 +83,7 @@ int main(int argc, char const *argv[])
eio_init();
ecore_init();
job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
path = getenv("HOME");
path2 = "./";

2
src/examples/eldbus/dbusmodel.c
View File

@ -249,7 +249,7 @@ main(int argc, char **argv EINA_UNUSED)
ELDBUS_CONNECTION_TYPE_SYSTEM :
ELDBUS_CONNECTION_TYPE_SESSION);
root = efl_add_ref(ELDBUS_MODEL_OBJECT_CLASS, efl_app_main_loop_get(efl_app_get()),
root = efl_add_ref(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(),
eldbus_model_object_custom_constructor(efl_added, conn_type, NULL, EINA_FALSE, bus_name, path),
efl_event_callback_array_add(efl_added, event_cbs(), NULL));

3
src/lib/ecore/Ecore_Eo.h
View File

@ -48,7 +48,6 @@
#include "efl_exe.eo.h"
#include "efl_loop.eo.h"
#include "efl_app.eo.h"
/**
* @brief Quits the main loop once all the events currently on the queue have
@ -103,7 +102,7 @@ EAPI Eina_Promise *efl_loop_promise_new(const Eo *obj, Eina_Promise_Cancel_Cb ca
#include "efl_interpolator_cubic_bezier.eo.h"
/* We ue the factory pattern here, so you shouldn't call eo_add directly. */
EAPI Eo *efl_app_get(void);
EAPI Eo *efl_main_loop_get(void);
typedef struct _Efl_Future_Composite_Progress Efl_Future_All_Progress;

6
src/lib/ecore/ecore.c
View File

@ -323,7 +323,7 @@ ecore_init(void)
sec = ((double) atoi(getenv("WATCHDOG_USEC"))) / 1000 / 1000;
_systemd_watchdog =
efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()),
efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
efl_loop_timer_interval_set(efl_added, sec / 2),
efl_event_callback_add(efl_added,
EFL_LOOP_TIMER_EVENT_TICK,
@ -347,7 +347,7 @@ ecore_init(void)
ecore_system_modules_load();
if (getenv("EFL_FIRST_LOOP"))
efl_event_callback_add(efl_app_main_loop_get(efl_app_get()),
efl_event_callback_add(efl_main_loop_get(),
EFL_LOOP_EVENT_RESUME,
_efl_first_loop_iterate,
getenv("EFL_FIRST_LOOP"));
@ -391,7 +391,7 @@ ecore_shutdown(void)
if (_ecore_init_count-- != _ecore_init_count_threshold)
goto end;
efl_event_callback_call(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_TERMINATE, NULL);
efl_event_callback_call(efl_main_loop_get(), EFL_LOOP_EVENT_TERMINATE, NULL);
ecore_system_modules_unload();

2
src/lib/ecore/ecore_events.c
View File

@ -247,7 +247,7 @@ _ecore_event_init(void)
_event_msg_handler =
efl_loop_message_handler_get(EFL_LOOP_CLASS,
ML_OBJ,
_mainloop_singleton,
ECORE_EVENT_MESSAGE_HANDLER_CLASS);
if (!_event_msg_handler)
{

2
src/lib/ecore/ecore_exe.c
View File

@ -66,7 +66,7 @@ ecore_exe_pipe_run(const char *exe_cmd,
const void *data)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
Ecore_Exe *ret = efl_add(MY_CLASS, efl_app_main_loop_get(efl_app_get()),
Ecore_Exe *ret = efl_add(MY_CLASS, efl_loop_main_get(EFL_LOOP_CLASS),
ecore_obj_exe_command_set(efl_added, exe_cmd,
flags));
if (ret)

4
src/lib/ecore/ecore_idle_enterer.c
View File

@ -30,8 +30,8 @@ ecore_idle_enterer_before_add(Ecore_Task_Cb func,
// This avoid us duplicating code and should only be slightly slower
// due to a useless cycle of callback registration
efl_event_callback_array_del(ML_OBJ, ecore_idle_enterer_callbacks(), ie);
efl_event_callback_array_priority_add(ML_OBJ, ecore_idle_enterer_callbacks(), EFL_CALLBACK_PRIORITY_BEFORE, ie);
efl_event_callback_array_del(_mainloop_singleton, ecore_idle_enterer_callbacks(), ie);
efl_event_callback_array_priority_add(_mainloop_singleton, ecore_idle_enterer_callbacks(), EFL_CALLBACK_PRIORITY_BEFORE, ie);
return ie;
}

4
src/lib/ecore/ecore_idler.c
View File

@ -57,7 +57,7 @@ _ecore_factorized_idle_del(Ecore_Idler *idler)
return idler->data;
}
efl_event_callback_array_del(ML_OBJ, idler->desc, idler);
efl_event_callback_array_del(_mainloop_singleton, idler->desc, idler);
data = idler->data;
eina_mempool_free(idler_mp, idler);
@ -94,7 +94,7 @@ _ecore_factorized_idle_add(const Efl_Callback_Array_Item *desc,
ret->references = 0;
ret->delete_me = EINA_FALSE;
efl_event_callback_array_add(ML_OBJ, desc, ret);
efl_event_callback_array_add(_mainloop_singleton, desc, ret);
return ret;
}

6
src/lib/ecore/ecore_main.c
View File

@ -1069,7 +1069,7 @@ void
_ecore_main_loop_init(void)
{
DBG("_ecore_main_loop_init");
if (!efl_app_main_loop_get(efl_app_get())) ERR("Cannot create main loop object");
if (!efl_main_loop_get()) ERR("Cannot create main loop object");
_ecore_main_loop_setup(ML_OBJ, ML_DAT);
}
@ -1372,7 +1372,7 @@ ecore_main_fd_handler_add(int fd,
{
Ecore_Fd_Handler *fdh = NULL;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
fdh = _ecore_main_fd_handler_add(efl_app_main_loop_get(efl_app_get()),
fdh = _ecore_main_fd_handler_add(efl_loop_main_get(EFL_LOOP_CLASS),
ML_DAT, NULL, fd, flags, func, data,
buf_func, buf_data, EINA_FALSE);
if (fdh) fdh->legacy = EINA_TRUE;
@ -1388,7 +1388,7 @@ ecore_main_fd_handler_file_add(int fd,
const void *buf_data)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
return _ecore_main_fd_handler_add(efl_app_main_loop_get(efl_app_get()),
return _ecore_main_fd_handler_add(efl_loop_main_get(EFL_LOOP_CLASS),
ML_DAT, NULL, fd, flags, func, data,
buf_func, buf_data, EINA_TRUE);
}

17
src/lib/ecore/ecore_private.h
View File

@ -113,13 +113,6 @@ struct _Efl_Loop_Future_Scheduler
Efl_Loop_Data *loop_data;
};
typedef struct _Efl_App_Data
{
Eo *main_loop;
Efl_Loop_Data *main_loop_data;
Eina_List *loops; // contains non-main_loop objects
} Efl_App_Data;
struct _Efl_Loop_Data
{
double loop_time;
@ -515,10 +508,10 @@ GENERIC_ALLOC_FREE_HEADER(Ecore_Win32_Handler, ecore_win32_handler);
#undef GENERIC_ALLOC_FREE_HEADER
Eo *_efl_app;
Efl_App_Data *_efl_app_data;
#define ML_OBJ (_efl_app_data->main_loop)
#define ML_DAT (_efl_app_data->main_loop_data)
extern Eo *_mainloop_singleton;
extern Efl_Loop_Data *_mainloop_singleton_data;
#define ML_OBJ _mainloop_singleton
#define ML_DAT _mainloop_singleton_data
//#define ML_DAT efl_data_scope_get(ML_OBJ, EFL_LOOP_CLASS)
extern Efl_Version _app_efl_version;
@ -532,7 +525,7 @@ void ecore_loop_promise_fulfill(Efl_Promise *p);
// access to direct input cb
#define ECORE_EVAS_INTERNAL
#define EFL_LOOP_DATA efl_data_scope_get(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_CLASS)
#define EFL_LOOP_DATA efl_data_scope_get(efl_loop_main_get(EFL_LOOP_CLASS), EFL_LOOP_CLASS)
EOAPI Eina_Bool efl_loop_message_process(Eo *obj);

18
src/lib/ecore/ecore_signal.c
View File

@ -46,7 +46,7 @@ typedef struct _Signal_Data
} Signal_Data;
static Eina_Bool
_ecore_signal_pipe_read(Eo *obj EINA_UNUSED)
_ecore_signal_pipe_read(Eo *obj)
{
Signal_Data sdata;
int ret;
@ -74,10 +74,14 @@ _ecore_signal_pipe_read(Eo *obj EINA_UNUSED)
ecore_event_add(ECORE_EVENT_SIGNAL_USER, e,
_ecore_signal_generic_free, NULL);
}
if (sdata.sig == SIGUSR1)
efl_event_callback_call(_efl_app, EFL_APP_EVENT_SIGNAL_USR1, NULL);
else
efl_event_callback_call(_efl_app, EFL_APP_EVENT_SIGNAL_USR2, NULL);
Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
if (loop)
{
if (sdata.sig == SIGUSR1)
efl_event_callback_call(loop, EFL_LOOP_EVENT_SIGNAL_USR1, NULL);
else
efl_event_callback_call(loop, EFL_LOOP_EVENT_SIGNAL_USR2, NULL);
}
}
break;
case SIGHUP:
@ -89,7 +93,9 @@ _ecore_signal_pipe_read(Eo *obj EINA_UNUSED)
ecore_event_add(ECORE_EVENT_SIGNAL_HUP, e,
_ecore_signal_generic_free, NULL);
}
efl_event_callback_call(_efl_app, EFL_APP_EVENT_SIGNAL_HUP, NULL);
Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
if (loop)
efl_event_callback_call(loop, EFL_LOOP_EVENT_SIGNAL_HUP, NULL);
}
break;
case SIGQUIT:

2
src/lib/ecore/ecore_thread.c
View File

@ -1635,7 +1635,7 @@ ecore_thread_future_run(Ecore_Thread_Future_Cb heavy, const void *data, Eina_Fre
efl_domain_current_push(EFL_ID_DOMAIN_SHARED);
efl_wref_add(efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get())), &p);
efl_wref_add(efl_add(EFL_PROMISE_CLASS, efl_main_loop_get()), &p);
if (!p) goto end;
efl_object_override(p, &thread_safe_call);

4
src/lib/ecore/ecore_timer.c
View File

@ -183,7 +183,7 @@ ecore_timer_add(double in, Ecore_Task_Cb func, const void *data)
}
legacy->func = func;
legacy->data = data;
timer = efl_add(MY_CLASS, efl_app_main_loop_get(efl_app_get()),
timer = efl_add(MY_CLASS, efl_main_loop_get(),
efl_event_callback_array_add(efl_added, legacy_timer(), legacy),
efl_key_data_set(efl_added, "_legacy", legacy),
efl_loop_timer_interval_set(efl_added, in));
@ -206,7 +206,7 @@ ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data)
}
legacy->func = func;
legacy->data = data;
timer = efl_add(MY_CLASS, efl_app_main_loop_get(efl_app_get()),
timer = efl_add(MY_CLASS, efl_main_loop_get(),
efl_event_callback_array_add(efl_added, legacy_timer(), legacy),
efl_key_data_set(efl_added, "_legacy", legacy),
efl_loop_timer_loop_reset(efl_added),

110
src/lib/ecore/efl_app.c
View File

@ -1,110 +0,0 @@
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
#include <sys/time.h>
#ifndef _WIN32
# include <sys/resource.h>
#endif
#include <errno.h>
#include "Ecore.h"
#include "ecore_private.h"
#include "ecore_main_common.h"
Eo *_efl_app;
Efl_App_Data *_efl_app_data;
EOLIAN static Efl_Object *
_efl_app_efl_object_constructor(Eo *obj, Efl_App_Data *pd)
{
if (_efl_app)
{
CRI("Efl.App object already exists!");
return NULL;
}
obj = efl_constructor(efl_super(obj, EFL_APP_CLASS));
if (!obj) return NULL;
_efl_app = obj;
_efl_app_data = pd;
pd->main_loop = efl_add(EFL_LOOP_CLASS, NULL);
pd->main_loop_data = efl_data_scope_get(pd->main_loop, EFL_LOOP_CLASS);
return obj;
}
EOLIAN static void
_efl_app_efl_object_destructor(Eo *obj, Efl_App_Data *pd)
{
Eo *loop;
Eina_List *l, *ll;
EINA_LIST_FOREACH_SAFE(pd->loops, l, ll, loop)
efl_del(loop);
efl_del(pd->main_loop);
pd->main_loop = NULL;
pd->main_loop_data = NULL;
efl_destructor(efl_super(obj, EFL_APP_CLASS));
if (obj != _efl_app) return;
_efl_app = NULL;
_efl_app_data = NULL;
}
Efl_Version _build_efl_version = { 0, 0, 0, 0, NULL, NULL };
EWAPI void
efl_build_version_set(int vmaj, int vmin, int vmic, int revision,
const char *flavor, const char *build_id)
{
// note: EFL has not been initialized yet at this point (ie. no eina call)
_build_efl_version.major = vmaj;
_build_efl_version.minor = vmin;
_build_efl_version.micro = vmic;
_build_efl_version.revision = revision;
free((char *)_build_efl_version.flavor);
free((char *)_build_efl_version.build_id);
_build_efl_version.flavor = eina_strdup(flavor);
_build_efl_version.build_id = eina_strdup(build_id);
}
EOLIAN static const Efl_Version *
_efl_app_build_efl_version_get(Eo *obj EINA_UNUSED, Efl_App_Data *pd EINA_UNUSED)
{
return &_build_efl_version;
}
EOLIAN static const Efl_Version *
_efl_app_efl_version_get(Eo *obj EINA_UNUSED, Efl_App_Data *pd EINA_UNUSED)
{
/* vanilla EFL: flavor = NULL */
static const Efl_Version version = {
.major = VMAJ,
.minor = VMIN,
.micro = VMIC,
.revision = VREV,
.build_id = EFL_BUILD_ID,
.flavor = NULL
};
return &version;
}
EOLIAN static Eo *
_efl_app_main_loop_get(Eo *obj EINA_UNUSED, Efl_App_Data *pd)
{
return pd->main_loop;
}
EAPI Eo *
efl_app_get(void)
{
if (_efl_app) return _efl_app;
return efl_add(EFL_APP_CLASS, NULL);
}
#include "efl_app.eo.c"

50
src/lib/ecore/efl_app.eo
View File

@ -1,50 +0,0 @@
import efl_types;
class Efl.App (Efl.Object)
{
[[ The EFL application
Efl.App provides an abstraction to represent the overall application. It is
the parent of all main loops and contains various properties for the
environment and current process.
]]
methods {
@property main_loop {
[[Points to the main loop instance of the application.]]
get {}
values {
main_loop: Efl.Loop; [[Application main loop]]
}
}
@property build_efl_version {
[[Indicates the version of EFL with which this application was compiled.
This might differ from @.efl_version.
]]
get {}
values {
@cref version: Efl.Version; [[Efl version]]
}
}
@property efl_version {
[[Indicates the currently running version of EFL.
This might differ from @.build_efl_version.
]]
get {}
values {
@cref version: Efl.Version; [[Efl version]]
}
}
}
events {
signal,usr1; [[System specific, but on unix maps to SIGUSR1 signal to the process - only called on main loop object]]
signal,usr2; [[System specific, but on unix maps to SIGUSR2 signal to the process - only called on main loop object]]
signal,hup; [[System specific, but on unix maps to SIGHUP signal to the process - only called on main loop object]]
}
implements {
Efl.Object.constructor;
Efl.Object.destructor;
}
}

8
src/lib/ecore/efl_general.h
View File

@ -93,10 +93,10 @@
_efl_startup_time = ecore_time_unix_get(); \
_EFL_APP_VERSION_SET(); \
ecore_init(); \
efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS, efl_main, NULL); \
efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS, efl_main, NULL); \
ecore_init_ex(argc, argv); \
__EFL_MAIN_CONSTRUCTOR; \
ret__ = efl_loop_begin(efl_app_main_loop_get(efl_app_get())); \
ret__ = efl_loop_begin(efl_main_loop_get()); \
real__ = efl_loop_exit_code_process(ret__); \
__EFL_MAIN_DESTRUCTOR; \
ecore_shutdown_ex(); \
@ -117,10 +117,10 @@
_efl_startup_time = ecore_time_unix_get(); \
_EFL_APP_VERSION_SET(); \
ecore_init(); \
efl_event_callback_array_add(efl_app_main_loop_get(efl_app_get()), _efl_main_ex(), NULL); \
efl_event_callback_array_add(efl_main_loop_get(), _efl_main_ex(), NULL); \
ecore_init_ex(argc, argv); \
__EFL_MAIN_CONSTRUCTOR; \
ret__ = efl_loop_begin(efl_app_main_loop_get(efl_app_get())); \
ret__ = efl_loop_begin(efl_main_loop_get()); \
real__ = efl_loop_exit_code_process(ret__); \
__EFL_MAIN_DESTRUCTOR; \
ecore_shutdown_ex(); \

82
src/lib/ecore/efl_loop.c
View File

@ -53,11 +53,31 @@ _efl_loop_message_handler_get(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, Efl_Loo
return mh.handler;
}
Efl_Version _app_efl_version = { 0, 0, 0, 0, NULL, NULL };
Eo *_mainloop_singleton = NULL;
Efl_Loop_Data *_mainloop_singleton_data = NULL;
extern Eina_Lock _environ_lock;
static Eina_List *_environ_strings_set = NULL;
static void _clean_old_environ(void);
EOLIAN static Efl_Loop *
_efl_loop_main_get(Efl_Class *klass EINA_UNUSED, void *_pd EINA_UNUSED)
{
if (_mainloop_singleton) return _mainloop_singleton;
_mainloop_singleton = efl_add(EFL_LOOP_CLASS, NULL);
_mainloop_singleton_data = efl_data_scope_get(_mainloop_singleton, EFL_LOOP_CLASS);
return _mainloop_singleton;
}
EAPI Eo *
efl_main_loop_get(void)
{
return efl_loop_main_get(EFL_LOOP_CLASS);
}
EOLIAN static void
_efl_loop_iterate(Eo *obj, Efl_Loop_Data *pd)
{
@ -104,7 +124,7 @@ efl_exit(int exit_code)
eina_value_setup(&v, EINA_VALUE_TYPE_INT);
eina_value_set(&v, &exit_code);
efl_loop_quit(efl_app_main_loop_get(efl_app_get()), v);
efl_loop_quit(efl_main_loop_get(), v);
}
EOLIAN static Efl_Object *
@ -302,10 +322,6 @@ _efl_loop_efl_object_constructor(Eo *obj, Efl_Loop_Data *pd)
obj = efl_constructor(efl_super(obj, EFL_LOOP_CLASS));
if (!obj) return NULL;
efl_parent_set(obj, _efl_app);
if (ML_OBJ)
_efl_app_data->loops = eina_list_append(_efl_app_data->loops, obj);
efl_event_callback_array_add(obj, event_catcher_watch(), pd);
pd->loop_time = ecore_time_get();
@ -349,11 +365,13 @@ _efl_loop_efl_object_destructor(Eo *obj, Efl_Loop_Data *pd)
pd->env.environ_copy = NULL;
eina_lock_release(&_environ_lock);
efl_parent_set(obj, NULL);
if (obj != ML_OBJ)
_efl_app_data->loops = eina_list_remove(_efl_app_data->loops, obj);
efl_destructor(efl_super(obj, EFL_LOOP_CLASS));
if (obj == _mainloop_singleton)
{
_mainloop_singleton = NULL;
_mainloop_singleton_data = NULL;
}
}
static void
@ -380,7 +398,7 @@ _efl_loop_arguments_send(void *data, const Eina_Value v,
arge.initialization = initialization;
initialization = EINA_FALSE;
efl_event_callback_call(efl_app_main_loop_get(efl_app_get()),
efl_event_callback_call(efl_main_loop_get(),
EFL_LOOP_EVENT_ARGUMENTS, &arge);
on_error:
_efl_loop_arguments_cleanup(arga);
@ -397,17 +415,17 @@ ecore_loop_arguments_send(int argc, const char **argv)
Eina_Array *arga;
int i = 0;
efl_task_arg_reset(efl_app_main_loop_get(efl_app_get()));
efl_task_arg_reset(efl_main_loop_get());
arga = eina_array_new(argc);
for (i = 0; i < argc; i++)
{
eina_array_push(arga, eina_stringshare_add(argv[i]));
efl_task_arg_append(efl_app_main_loop_get(efl_app_get()), argv[i]);
efl_task_arg_append(efl_main_loop_get(), argv[i]);
}
job = eina_future_then(efl_loop_job(efl_app_main_loop_get(efl_app_get())),
job = eina_future_then(efl_loop_job(efl_main_loop_get()),
_efl_loop_arguments_send, arga);
efl_future_Eina_FutureXXX_then(efl_app_main_loop_get(efl_app_get()), job);
efl_future_Eina_FutureXXX_then(efl_main_loop_get(), job);
}
// Only one main loop handle for now
@ -692,6 +710,42 @@ _efl_loop_message_process(Eo *obj, Efl_Loop_Data *pd)
EOAPI EFL_FUNC_BODY(efl_loop_message_process, Eina_Bool, 0);
EWAPI void
efl_build_version_set(int vmaj, int vmin, int vmic, int revision,
const char *flavor, const char *build_id)
{
// note: EFL has not been initialized yet at this point (ie. no eina call)
_app_efl_version.major = vmaj;
_app_efl_version.minor = vmin;
_app_efl_version.micro = vmic;
_app_efl_version.revision = revision;
free((char *)_app_efl_version.flavor);
free((char *)_app_efl_version.build_id);
_app_efl_version.flavor = flavor ? strdup(flavor) : NULL;
_app_efl_version.build_id = build_id ? strdup(build_id) : NULL;
}
EOLIAN static const Efl_Version *
_efl_loop_app_efl_version_get(Eo *obj EINA_UNUSED, Efl_Loop_Data *pd EINA_UNUSED)
{
return &_app_efl_version;
}
EOLIAN static const Efl_Version *
_efl_loop_efl_version_get(Eo *obj EINA_UNUSED, Efl_Loop_Data *pd EINA_UNUSED)
{
/* vanilla EFL: flavor = NULL */
static const Efl_Version version = {
.major = VMAJ,
.minor = VMIN,
.micro = VMIC,
.revision = VREV,
.build_id = EFL_BUILD_ID,
.flavor = NULL
};
return &version;
}
static void
_env_sync(Efl_Loop_Data *pd, Efl_Task_Data *td)
{

30
src/lib/ecore/efl_loop.eo
View File

@ -20,6 +20,33 @@ class Efl.Loop (Efl.Task)
you can provide these if you need to.
]]
methods {
@property main @class {
[[Points to the main loop instance of the application.]]
get {}
values {
main_loop: Efl.Loop; [[Application main loop]]
}
}
@property app_efl_version {
[[Indicates the version of EFL with which this application was compiled.
This might differ from @.efl_version.
]]
get {}
values {
@cref version: Efl.Version; [[Efl version]]
}
}
@property efl_version {
[[Indicates the currently running version of EFL.
This might differ from @.app_efl_version.
]]
get {}
values {
@cref version: Efl.Version; [[Efl version]]
}
}
iterate {
[[Runs a single iteration of the main loop to process everything on the
queue.]]
@ -124,6 +151,9 @@ class Efl.Loop (Efl.Task)
pause; [[Called when the window is not going be displayed for some time]]
resume; [[Called before a window is rendered after a pause event]]
terminate; [[Called before starting the shutdown of Elementary]]
signal,usr1; [[System specific, but on unix maps to SIGUSR1 signal to the process - only called on main loop object]]
signal,usr2; [[System specific, but on unix maps to SIGUSR2 signal to the process - only called on main loop object]]
signal,hup; [[System specific, but on unix maps to SIGHUP signal to the process - only called on main loop object]]
}
implements {
Efl.Object.constructor;

2
src/lib/ecore/efl_loop_consumer.c
View File

@ -17,7 +17,7 @@ _efl_loop_consumer_loop_get(Eo *obj, Efl_Loop_Consumer_Data *pd EINA_UNUSED)
Efl_Loop *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
if (!loop && eina_main_loop_is())
{
loop = efl_app_main_loop_get(efl_app_get());
loop = efl_main_loop_get();
ERR("Failed to get the loop on object %p from the main thread! "
"Returning the main loop: %p", obj, loop);
}

14
src/lib/ecore/efl_model_composite_boolean.c
View File

@ -160,7 +160,7 @@ _efl_model_composite_boolean_children_efl_model_property_get(Eo *obj EINA_UNUSED
Efl_Model_Hash_Value *hv = eina_hash_find(pd->parent_pd->values, property);
if (hv)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
Eina_Value *eina_value = eina_value_new(EINA_VALUE_TYPE_UCHAR);
@ -180,7 +180,7 @@ _efl_model_composite_boolean_children_efl_model_property_get(Eo *obj EINA_UNUSED
return efl_model_property_get(pd->composite_child, property);
else
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
@ -192,7 +192,7 @@ static Efl_Future *
_efl_model_composite_boolean_children_efl_model_property_set(Eo *obj EINA_UNUSED,
Efl_Model_Composite_Boolean_Children_Data *pd, const char *property, const Eina_Value *value)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
Efl_Model_Hash_Value *hv = eina_hash_find(pd->parent_pd->values, property);
@ -567,7 +567,7 @@ _efl_model_composite_boolean_efl_model_property_get(Eo *obj EINA_UNUSED,
if (pd->composite_model)
return efl_model_property_get(pd->composite_model, property);
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
@ -579,7 +579,7 @@ _efl_model_composite_boolean_efl_model_property_set(Eo *obj EINA_UNUSED, Efl_Mod
const char *property, const Eina_Value *value)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
if (pd->composite_model)
@ -598,7 +598,7 @@ _efl_model_composite_boolean_efl_model_property_set(Eo *obj EINA_UNUSED, Efl_Mod
static Efl_Future *
_efl_model_composite_boolean_efl_model_children_slice_get(Eo *obj, Efl_Model_Composite_Boolean_Data *pd, unsigned int start, unsigned int count)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
if (pd->composite_model)
@ -632,7 +632,7 @@ _efl_model_composite_boolean_efl_model_children_count_get(Eo *obj EINA_UNUSED, E
return efl_model_children_count_get(pd->composite_model);
else
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
unsigned int *count = malloc(sizeof(unsigned int));

2
src/lib/ecore/efl_model_composite_selection.c
View File

@ -176,7 +176,7 @@ _efl_model_composite_selection_children_efl_model_property_set(Eo *obj EINA_UNUS
}
else
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
Eina_Value* true_value = eina_value_new(EINA_VALUE_TYPE_UCHAR);
eina_value_set(true_value, EINA_TRUE);

8
src/lib/ecore/efl_model_container.c
View File

@ -236,7 +236,7 @@ _efl_model_container_efl_model_properties_get(Eo *obj EINA_UNUSED, Efl_Model_Con
Efl_Future *
_efl_model_container_efl_model_property_set(Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd EINA_UNUSED, const char *property EINA_UNUSED, const Eina_Value *value EINA_UNUSED)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
@ -247,7 +247,7 @@ Efl_Future *
_efl_model_container_efl_model_property_get(Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd EINA_UNUSED, const char *property EINA_UNUSED)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
@ -257,7 +257,7 @@ _efl_model_container_efl_model_property_get(Eo *obj EINA_UNUSED, Efl_Model_Conta
static Efl_Future *
_efl_model_container_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd, unsigned int start, unsigned int count)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
Eina_Accessor* accessor = efl_model_list_slice(sd->children, start, count);
@ -269,7 +269,7 @@ _efl_model_container_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Efl_Model
static Efl_Future *
_efl_model_container_efl_model_children_count_get(Eo *obj EINA_UNUSED, Efl_Model_Container_Data *sd)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
unsigned int *count = calloc(1, sizeof(unsigned int));

8
src/lib/ecore/efl_model_container_item.c
View File

@ -44,7 +44,7 @@ _efl_model_container_item_efl_model_property_set(Eo *obj EINA_UNUSED, Efl_Model_
Eina_Stringshare *prop_name;
Child_Property_Data *cpd;
void *data, *new_data;
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
if (!sd->parent_data)
@ -105,7 +105,7 @@ _efl_model_container_item_efl_model_property_get(Eo *obj EINA_UNUSED, Efl_Model_
Eina_Stringshare *prop_name;
Child_Property_Data *cpd;
Eina_Value *value;
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
if (!sd->parent_data)
@ -152,7 +152,7 @@ _efl_model_container_item_efl_model_property_get(Eo *obj EINA_UNUSED, Efl_Model_
EOLIAN static Efl_Future *
_efl_model_container_item_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Efl_Model_Container_Item_Data *sd EINA_UNUSED, unsigned int start EINA_UNUSED, unsigned int count EINA_UNUSED)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
efl_promise_value_set(promise, NULL, NULL);
@ -163,7 +163,7 @@ _efl_model_container_item_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Efl_
EOLIAN static Efl_Future *
_efl_model_container_item_efl_model_children_count_get(Eo *obj EINA_UNUSED, Efl_Model_Container_Item_Data *sd EINA_UNUSED)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
unsigned int *count = calloc(1, sizeof(unsigned int));

8
src/lib/ecore/efl_model_item.c
View File

@ -70,7 +70,7 @@ _efl_model_item_efl_model_properties_get(Eo *obj EINA_UNUSED, Efl_Model_Item_Dat
static Efl_Future*
_efl_model_item_efl_model_property_set(Eo *obj EINA_UNUSED, Efl_Model_Item_Data *sd, const char *property, const Eina_Value *value)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future* future = efl_promise_future_get(promise);
Efl_Model_Property_Event evt;
@ -119,7 +119,7 @@ err1:
static Efl_Future *
_efl_model_item_efl_model_property_get(Eo *obj EINA_UNUSED, Efl_Model_Item_Data *sd, const char *property)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
Eina_Stringshare *sshare = eina_stringshare_add(property);
@ -136,7 +136,7 @@ _efl_model_item_efl_model_property_get(Eo *obj EINA_UNUSED, Efl_Model_Item_Data
static Efl_Future *
_efl_model_item_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Efl_Model_Item_Data *sd, unsigned int start, unsigned int count)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
Eina_Accessor* accessor = efl_model_list_slice(sd->children, start, count);
@ -148,7 +148,7 @@ _efl_model_item_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Efl_Model_Item
static Efl_Future *
_efl_model_item_efl_model_children_count_get(Eo *obj EINA_UNUSED, Efl_Model_Item_Data *sd)
{
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
Efl_Future *rfuture = efl_promise_future_get(promise);
unsigned int *count = calloc(1, sizeof(unsigned int));

12
src/lib/ecore_con/ecore_con_legacy.c
View File

@ -818,7 +818,7 @@ _ecore_con_client_ssl_upgrade_job(void *data, const Eina_Value v,
const Eina_Future *dead EINA_UNUSED)
{
Ecore_Con_Client *cl = data;
Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *loop = efl_main_loop_get();
Eo *inner_socket;
Eo *socket;
Eo *tcp_socket;
@ -1604,7 +1604,7 @@ _ecore_con_server_server_ssl_job(void *data, const Eina_Value v,
const Eina_Future *dead EINA_UNUSED)
{
Ecore_Con_Server *svr = data;
Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *loop = efl_main_loop_get();
Eo *ssl_ctx;
Eo *inner_server;
Eo *server;
@ -1683,7 +1683,7 @@ ecore_con_server_add(Ecore_Con_Type compl_type,
return NULL;
}
loop = efl_app_main_loop_get(efl_app_get());
loop = efl_main_loop_get();
EINA_SAFETY_ON_NULL_RETURN_VAL(loop, NULL);
svr = _ecore_con_server_new(EINA_FALSE, compl_type, name, port, data);
@ -1946,7 +1946,7 @@ _ecore_con_server_dialer_ssl_job(void *data, const Eina_Value v,
const Eina_Future *dead EINA_UNUSED)
{
Ecore_Con_Server *svr = data;
Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *loop = efl_main_loop_get();
Eo *ssl_ctx;
Eo *inner_dialer;
Eo *dialer;
@ -2036,7 +2036,7 @@ _ecore_con_server_dialer_ssl_upgrade_job(void *data, const Eina_Value v,
const Eina_Future *dead EINA_UNUSED)
{
Ecore_Con_Server *svr = data;
Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *loop = efl_main_loop_get();
Eo *ssl_ctx;
Eo *inner_dialer;
Eo *dialer;
@ -2140,7 +2140,7 @@ ecore_con_server_connect(Ecore_Con_Type compl_type,
type = compl_type & ECORE_CON_TYPE;
loop = efl_app_main_loop_get(efl_app_get());
loop = efl_main_loop_get();
EINA_SAFETY_ON_NULL_RETURN_VAL(loop, NULL);
svr = _ecore_con_server_new(EINA_TRUE, compl_type, name, port, data);

2
src/lib/ecore_con/ecore_con_url.c
View File

@ -704,7 +704,7 @@ _ecore_con_url_request_prepare(Ecore_Con_Url *url_con, const char *method)
if (proxy_url)
DBG("proxy_url='%s'", proxy_url);
url_con->dialer = efl_add(EFL_NET_DIALER_HTTP_CLASS, efl_app_main_loop_get(efl_app_get()),
url_con->dialer = efl_add(EFL_NET_DIALER_HTTP_CLASS, efl_main_loop_get(),
efl_net_dialer_http_method_set(efl_added, url_con->custom_request ? url_con->custom_request : method),
efl_net_dialer_http_primary_mode_set(efl_added, (strcmp(method, "PUT") == 0) ? EFL_NET_DIALER_HTTP_PRIMARY_MODE_UPLOAD : EFL_NET_DIALER_HTTP_PRIMARY_MODE_DOWNLOAD),
efl_net_dialer_proxy_set(efl_added, proxy_url),

2
src/lib/ecore_con/efl_net_ip_address.c
View File

@ -547,7 +547,7 @@ _efl_net_ip_address_resolve(Eo *cls EINA_UNUSED, void *pd EINA_UNUSED, const cha
ctx->thread = efl_net_ip_resolve_async_new(host, port, &hints, _efl_net_ip_address_resolve_done, ctx);
EINA_SAFETY_ON_NULL_GOTO(ctx->thread, error_thread);
ctx->promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()),
ctx->promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get(),
efl_event_callback_add(efl_added, EFL_EVENT_DEL, _efl_net_ip_address_resolve_del, ctx));
EINA_SAFETY_ON_NULL_GOTO(ctx->promise, error_promise);

2
src/lib/ecore_file/ecore_file_download.c
View File

@ -215,7 +215,7 @@ ecore_file_download_full(const char *url,
return EINA_FALSE;
}
loop = efl_app_main_loop_get(efl_app_get());
loop = efl_main_loop_get();
EINA_SAFETY_ON_NULL_RETURN_VAL(loop, EINA_FALSE);
job = calloc(1, sizeof(Ecore_File_Download_Job));

20
src/lib/ecore_ipc/ecore_ipc.c
View File

@ -382,7 +382,7 @@ EAPI Ecore_Ipc_Server *
ecore_ipc_server_add(Ecore_Ipc_Type type, const char *name, int port, const void *data)
{
Ecore_Ipc_Server *svr;
Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *loop = efl_main_loop_get();
char *address = NULL;
Eina_Error err;
#ifdef EFL_NET_SERVER_UNIX_CLASS
@ -404,7 +404,7 @@ ecore_ipc_server_add(Ecore_Ipc_Type type, const char *name, int port, const void
new_mask = S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH;
svr->server = efl_add(EFL_NET_SERVER_UNIX_CLASS, efl_app_main_loop_get(efl_app_get()),
svr->server = efl_add(EFL_NET_SERVER_UNIX_CLASS, efl_main_loop_get(),
efl_net_server_unix_leading_directories_create_set(efl_added, EINA_TRUE, S_IRUSR | S_IWUSR | S_IXUSR));
EINA_SAFETY_ON_NULL_GOTO(svr->server, error_server);
}
@ -418,7 +418,7 @@ ecore_ipc_server_add(Ecore_Ipc_Type type, const char *name, int port, const void
new_mask = 0;
local_system = EINA_TRUE;
svr->server = efl_add(EFL_NET_SERVER_UNIX_CLASS, efl_app_main_loop_get(efl_app_get()));
svr->server = efl_add(EFL_NET_SERVER_UNIX_CLASS, efl_main_loop_get());
EINA_SAFETY_ON_NULL_GOTO(svr->server, error_server);
}
#endif /* EFL_NET_SERVER_UNIX_CLASS */
@ -431,7 +431,7 @@ ecore_ipc_server_add(Ecore_Ipc_Type type, const char *name, int port, const void
// TODO: specify SECURITY_ATTRIBUTES to use or some
// Efl_Net_Server_Windows API to limit access
svr->server = efl_add(EFL_NET_SERVER_WINDOWS_CLASS, efl_app_main_loop_get(efl_app_get()));
svr->server = efl_add(EFL_NET_SERVER_WINDOWS_CLASS, efl_main_loop_get());
EINA_SAFETY_ON_NULL_GOTO(svr->server, error_server);
}
else if ((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_SYSTEM)
@ -442,7 +442,7 @@ ecore_ipc_server_add(Ecore_Ipc_Type type, const char *name, int port, const void
// TODO: specify SECURITY_ATTRIBUTES to use or some
// Efl_Net_Server_Windows API to limit access
svr->server = efl_add(EFL_NET_SERVER_WINDOWS_CLASS, efl_app_main_loop_get(efl_app_get()));
svr->server = efl_add(EFL_NET_SERVER_WINDOWS_CLASS, efl_main_loop_get());
EINA_SAFETY_ON_NULL_GOTO(svr->server, error_server);
}
#endif /* EFL_NET_SERVER_WINDOWS_CLASS */
@ -653,7 +653,7 @@ EAPI Ecore_Ipc_Server *
ecore_ipc_server_connect(Ecore_Ipc_Type type, char *name, int port, const void *data)
{
Ecore_Ipc_Server *svr;
Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *loop = efl_main_loop_get();
char *address = NULL;
Eina_Error err;
@ -681,7 +681,7 @@ ecore_ipc_server_connect(Ecore_Ipc_Type type, char *name, int port, const void *
goto error_dialer;
}
svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, efl_app_main_loop_get(efl_app_get()));
svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, efl_main_loop_get());
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
}
else if ((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_SYSTEM)
@ -689,7 +689,7 @@ ecore_ipc_server_connect(Ecore_Ipc_Type type, char *name, int port, const void *
address = ecore_con_local_path_new(EINA_TRUE, name, port);
EINA_SAFETY_ON_NULL_GOTO(address, error_dialer);
svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, efl_app_main_loop_get(efl_app_get()));
svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, efl_main_loop_get());
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
}
#endif /* EFL_NET_DIALER_UNIX_CLASS */
@ -699,7 +699,7 @@ ecore_ipc_server_connect(Ecore_Ipc_Type type, char *name, int port, const void *
address = ecore_con_local_path_new(EINA_FALSE, name, port);
EINA_SAFETY_ON_NULL_GOTO(address, error_dialer);
svr->dialer.dialer = efl_add(EFL_NET_DIALER_WINDOWS_CLASS, efl_app_main_loop_get(efl_app_get()));
svr->dialer.dialer = efl_add(EFL_NET_DIALER_WINDOWS_CLASS, efl_main_loop_get());
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
}
else if ((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_SYSTEM)
@ -707,7 +707,7 @@ ecore_ipc_server_connect(Ecore_Ipc_Type type, char *name, int port, const void *
address = ecore_con_local_path_new(EINA_TRUE, name, port);
EINA_SAFETY_ON_NULL_GOTO(address, error_dialer);
svr->dialer.dialer = efl_add(EFL_NET_DIALER_WINDOWS_CLASS, efl_app_main_loop_get(efl_app_get()));
svr->dialer.dialer = efl_add(EFL_NET_DIALER_WINDOWS_CLASS, efl_main_loop_get());
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
}
#endif /* EFL_NET_DIALER_WINDOWS_CLASS */

18
src/lib/edje/edje_main.c
View File

@ -85,9 +85,9 @@ edje_init(void)
_edje_scale = FROM_DOUBLE(1.0);
_edje_global_obj = efl_add(EDJE_GLOBAL_CLASS, NULL);
if (!_edje_global_obj ||
!efl_loop_register(efl_app_main_loop_get(efl_app_get()), EFL_GFX_COLOR_CLASS_INTERFACE, _edje_global_obj) ||
!efl_loop_register(efl_app_main_loop_get(efl_app_get()), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj) ||
!efl_loop_register(efl_app_main_loop_get(efl_app_get()), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj))
!efl_loop_register(efl_main_loop_get(), EFL_GFX_COLOR_CLASS_INTERFACE, _edje_global_obj) ||
!efl_loop_register(efl_main_loop_get(), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj) ||
!efl_loop_register(efl_main_loop_get(), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj))
goto shutdown_efreet;
_edje_edd_init();
@ -150,9 +150,9 @@ shutdown_all:
_edje_edd_shutdown();
if (_edje_global_obj)
{
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_GFX_COLOR_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_main_loop_get(), EFL_GFX_COLOR_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_main_loop_get(), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_main_loop_get(), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj);
efl_del(_edje_global_obj);
_edje_global_obj = NULL;
}
@ -209,9 +209,9 @@ _edje_shutdown_core(void)
_edje_text_class_hash_free();
_edje_size_class_hash_free();
_edje_edd_shutdown();
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_GFX_COLOR_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_main_loop_get(), EFL_GFX_COLOR_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_main_loop_get(), EFL_GFX_TEXT_CLASS_INTERFACE, _edje_global_obj);
efl_loop_unregister(efl_main_loop_get(), EFL_GFX_SIZE_CLASS_INTERFACE, _edje_global_obj);
efl_del(_edje_global_obj);
_edje_global_obj = NULL;

2
src/lib/edje/edje_private.h
View File

@ -2415,7 +2415,7 @@ static inline Edje_Global *
_edje_global(void)
{
#ifndef NDEBUG
return efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_GFX_COLOR_CLASS_INTERFACE);
return efl_provider_find(efl_main_loop_get(), EFL_GFX_COLOR_CLASS_INTERFACE);
#else
extern Edje_Global *_edje_global_obj;
return _edje_global_obj;

6
src/lib/eio/eio_main.c
View File

@ -319,8 +319,8 @@ eio_init(void)
efreet_mime_init();
io_manager = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
efl_loop_register(efl_app_main_loop_get(efl_app_get()), EFL_IO_MANAGER_CLASS, io_manager);
io_manager = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
efl_loop_register(efl_main_loop_get(), EFL_IO_MANAGER_CLASS, io_manager);
eina_log_timing(_eio_log_dom_global,
EINA_LOG_STATE_STOP,
@ -358,7 +358,7 @@ eio_shutdown(void)
EINA_LOG_STATE_START,
EINA_LOG_STATE_SHUTDOWN);
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_IO_MANAGER_CLASS, io_manager);
efl_loop_unregister(efl_main_loop_get(), EFL_IO_MANAGER_CLASS, io_manager);
efl_del(io_manager);
io_manager = NULL;

2
src/lib/eio/eio_model.c
View File

@ -824,7 +824,7 @@ _eio_model_efl_object_provider_find(const Eo *obj, Eio_Model_Data *priv EINA_UNU
// Provide main loop even if we don't have a loop user parent
if (!provider && (klass == EFL_LOOP_CLASS) && eina_main_loop_is())
return efl_app_main_loop_get(efl_app_get());
return efl_main_loop_get();
return provider;
}

2
src/lib/elementary/efl_ui_win.c
View File

@ -5431,7 +5431,7 @@ _elm_win_finalize_internal(Eo *obj, Efl_Ui_Win_Data *sd, const char *name, Efl_U
efl_access_window_created_signal_emit(obj);
// attach config API
efl_composite_attach(obj, efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_GLOBAL_CLASS));
efl_composite_attach(obj, efl_provider_find(efl_main_loop_get(), EFL_CONFIG_GLOBAL_CLASS));
efl_event_callback_array_add(sd->evas, _elm_evas_tracking(), sd);
efl_event_callback_array_add(obj, _elm_win_evas_feed_fake_callbacks(), sd->evas);

8
src/lib/elementary/elm_config.c
View File

@ -1666,8 +1666,8 @@ static void
_config_load(void)
{
_efl_config_obj = efl_add(EFL_CONFIG_GLOBAL_CLASS, NULL);
efl_loop_register(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_INTERFACE, _efl_config_obj);
efl_loop_register(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_GLOBAL_CLASS, _efl_config_obj);
efl_loop_register(efl_main_loop_get(), EFL_CONFIG_INTERFACE, _efl_config_obj);
efl_loop_register(efl_main_loop_get(), EFL_CONFIG_GLOBAL_CLASS, _efl_config_obj);
efl_del_intercept_set(_efl_config_obj, _efl_config_obj_del);
_elm_config = _config_user_load();
if (_elm_config)
@ -4620,8 +4620,8 @@ void
_elm_config_shutdown(void)
{
efl_del_intercept_set(_efl_config_obj, NULL);
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_INTERFACE, _efl_config_obj);
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_GLOBAL_CLASS, _efl_config_obj);
efl_loop_unregister(efl_main_loop_get(), EFL_CONFIG_INTERFACE, _efl_config_obj);
efl_loop_unregister(efl_main_loop_get(), EFL_CONFIG_GLOBAL_CLASS, _efl_config_obj);
ELM_SAFE_FREE(_efl_config_obj, efl_del);
ELM_SAFE_FREE(_elm_config, _config_free);
ELM_SAFE_FREE(_elm_preferred_engine, eina_stringshare_del);

10
src/lib/elementary/elm_glview.c
View File

@ -165,7 +165,7 @@ _render_cb(void *obj, const Efl_Event *event EINA_UNUSED)
return;
on_error:
efl_event_callback_del(efl_app_main_loop_get(efl_app_get()),
efl_event_callback_del(efl_main_loop_get(),
EFL_LOOP_EVENT_IDLE_ENTER,
_render_cb,
obj);
@ -187,7 +187,7 @@ _set_render_policy_callback(Evas_Object *obj)
evas_object_image_data_update_add(wd->resize_obj, 0, 0, sd->w, sd->h);
}
// Delete idle_enterer if it for some reason is around
efl_event_callback_del(efl_app_main_loop_get(efl_app_get()),
efl_event_callback_del(efl_main_loop_get(),
EFL_LOOP_EVENT_IDLE_ENTER,
_render_cb,
obj);
@ -202,7 +202,7 @@ _set_render_policy_callback(Evas_Object *obj)
case ELM_GLVIEW_RENDER_POLICY_ALWAYS:
if (evas_object_image_pixels_dirty_get(wd->resize_obj) && !sd->render_idle_enterer)
sd->render_idle_enterer = efl_event_callback_priority_add(efl_app_main_loop_get(efl_app_get()),
sd->render_idle_enterer = efl_event_callback_priority_add(efl_main_loop_get(),
EFL_LOOP_EVENT_IDLE_ENTER,
EFL_CALLBACK_PRIORITY_BEFORE,
_render_cb,
@ -297,7 +297,7 @@ _elm_glview_efl_canvas_group_group_del(Eo *obj, Elm_Glview_Data *sd)
//TODO:will be optimised
efl_event_callback_legacy_call(obj, ELM_GLVIEW_EVENT_DESTROYED, NULL);
efl_event_callback_del(efl_app_main_loop_get(efl_app_get()),
efl_event_callback_del(efl_main_loop_get(),
EFL_LOOP_EVENT_IDLE_ENTER,
_render_cb,
obj);
@ -529,7 +529,7 @@ _elm_glview_draw_request(Eo *obj, Elm_Glview_Data *sd)
evas_object_image_data_update_add(wd->resize_obj, 0, 0, sd->w, sd->h);
if (sd->render_policy == ELM_GLVIEW_RENDER_POLICY_ALWAYS &&
!sd->render_idle_enterer)
sd->render_idle_enterer = efl_event_callback_priority_add(efl_app_main_loop_get(efl_app_get()),
sd->render_idle_enterer = efl_event_callback_priority_add(efl_main_loop_get(),
EFL_LOOP_EVENT_IDLE_ENTER,
EFL_CALLBACK_PRIORITY_BEFORE,
_render_cb, obj);

10
src/lib/elementary/elm_main.c
View File

@ -1148,16 +1148,16 @@ elm_quicklaunch_fork(int argc,
{
if (qre_pause && qre_resume && qre_terminate)
{
efl_event_callback_array_add(efl_app_main_loop_get(efl_app_get()), _qre_main_ex(), NULL);
efl_event_callback_array_add(efl_main_loop_get(), _qre_main_ex(), NULL);
}
else
{
efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS, qre_main, NULL);
efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS, qre_main, NULL);
}
ecore_init_ex(argc, argv);
ret = efl_loop_exit_code_process(efl_loop_begin(efl_app_main_loop_get(efl_app_get())));
ret = efl_loop_exit_code_process(efl_loop_begin(efl_main_loop_get()));
ecore_shutdown_ex();
@ -1304,12 +1304,12 @@ elm_policy_set(unsigned int policy,
{
if (value == ELM_POLICY_EXIT_WINDOWS_DEL)
{
efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_TERMINATE,
efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_TERMINATE,
_on_terminate, NULL);
}
else
{
efl_event_callback_del(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_TERMINATE,
efl_event_callback_del(efl_main_loop_get(), EFL_LOOP_EVENT_TERMINATE,
_on_terminate, NULL);
}
}

4
src/lib/evas/canvas/evas_main.c
View File

@ -842,7 +842,7 @@ _evas_canvas_efl_object_provider_find(const Eo *eo_e,
if (klass == EVAS_CANVAS_CLASS)
return (Eo *)eo_e;
else if (klass == EFL_LOOP_CLASS)
return efl_app_main_loop_get(efl_app_get());
return efl_main_loop_get();
else if (klass == EFL_CANVAS_GESTURE_MANAGER_CLASS)
return e->gesture_manager;
return efl_provider_find(efl_super(eo_e, MY_CLASS), klass);
@ -851,7 +851,7 @@ _evas_canvas_efl_object_provider_find(const Eo *eo_e,
EOLIAN static Efl_Loop *
_evas_canvas_efl_loop_consumer_loop_get(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e EINA_UNUSED)
{
return efl_app_main_loop_get(efl_app_get());
return efl_main_loop_get();
}
Ector_Surface *

4
src/lib/evas/canvas/evas_object_main.c
View File

@ -2330,7 +2330,7 @@ _efl_canvas_object_efl_object_provider_find(const Eo *eo_obj EINA_UNUSED, Evas_O
return obj->layer->evas->evas;
}
else if (klass == EFL_LOOP_CLASS)
return efl_app_main_loop_get(efl_app_get());
return efl_main_loop_get();
fallback:
return efl_provider_find(efl_super(eo_obj, MY_CLASS), klass);
}
@ -2338,7 +2338,7 @@ fallback:
EOLIAN static Efl_Loop *
_efl_canvas_object_efl_loop_consumer_loop_get(Eo *eo_obj EINA_UNUSED, Evas_Object_Protected_Data *obj EINA_UNUSED)
{
return efl_app_main_loop_get(efl_app_get());
return efl_main_loop_get();
}
EOLIAN static void

2
src/lib/evas/canvas/evas_object_textblock.c
View File

@ -16251,7 +16251,7 @@ _dummy_cancel(void *data EINA_UNUSED, const Eina_Promise *dead EINA_UNUSED)
static Eina_Future_Scheduler *
_future_scheduler_get(void)
{
return efl_loop_future_scheduler_get(efl_app_main_loop_get(efl_app_get()));
return efl_loop_future_scheduler_get(efl_main_loop_get());
}
EOLIAN static Eina_Future *

6
src/tests/ecore/ecore_test_args.c
View File

@ -27,7 +27,7 @@ _cb_args1(void *data EINA_UNUSED, const Efl_Event *event)
START_TEST(ecore_test_args1)
{
ecore_init();
efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS,
efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
_cb_args1, NULL);
ecore_loop_arguments_send(8, args);
ecore_main_loop_begin();
@ -52,7 +52,7 @@ START_TEST(ecore_test_args2)
};
ecore_init();
efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS,
efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
_cb_args2, NULL);
ecore_loop_arguments_send(1, simple_args);
ecore_main_loop_begin();
@ -72,7 +72,7 @@ _cb_args3(void *data EINA_UNUSED, const Efl_Event *event)
START_TEST(ecore_test_args3)
{
ecore_init();
efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS,
efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
_cb_args3, NULL);
ecore_loop_arguments_send(0, NULL);
ecore_main_loop_begin();

67
src/tests/ecore/ecore_test_ecore.c
View File

@ -317,7 +317,7 @@ START_TEST(ecore_test_efl_loop_fd)
ret = pipe(comm);
fail_if(ret != 0);
fd = efl_add(EFL_LOOP_FD_CLASS, efl_app_main_loop_get(efl_app_get()),
fd = efl_add(EFL_LOOP_FD_CLASS, efl_main_loop_get(),
efl_loop_fd_set(efl_added, comm[0]),
efl_event_callback_add(efl_added, EFL_LOOP_FD_EVENT_READ, _eo_read_cb, &did));
fail_if(fd == NULL);
@ -360,7 +360,7 @@ START_TEST(ecore_test_efl_loop_fd_lifecycle)
ret = pipe(comm);
fail_if(ret != 0);
fd = efl_add(EFL_LOOP_FD_CLASS, efl_app_main_loop_get(efl_app_get()),
fd = efl_add(EFL_LOOP_FD_CLASS, efl_main_loop_get(),
efl_loop_fd_set(efl_added, comm[0]),
efl_event_callback_add(efl_added, EFL_LOOP_FD_EVENT_READ, _eo_read_cb, &did),
efl_event_callback_add(efl_added, EFL_EVENT_DEL, _efl_del_cb, &dead));
@ -857,6 +857,67 @@ START_TEST(ecore_test_ecore_main_loop_poller_add_del)
}
END_TEST
START_TEST(ecore_test_efl_loop_register)
{
Efl_Object *t, *n;
ecore_init();
t = efl_provider_find(efl_main_loop_get(), EFL_LOOP_CLASS);
fail_if(!efl_isa(t, EFL_LOOP_CLASS));
t = efl_provider_find(efl_main_loop_get(), EFL_LOOP_TIMER_CLASS);
fail_if(t != NULL);
n = efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get());
fail_if(n != NULL);
n = efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
efl_loop_timer_interval_set(efl_added, 1.0));
efl_loop_register(efl_main_loop_get(), EFL_LOOP_TIMER_CLASS, n);
t = efl_provider_find(efl_main_loop_get(), EFL_LOOP_TIMER_CLASS);
fail_if(!efl_isa(t, EFL_LOOP_TIMER_CLASS));
fail_if(t != n);
efl_loop_unregister(efl_main_loop_get(), EFL_LOOP_TIMER_CLASS, n);
t = efl_provider_find(efl_main_loop_get(), EFL_LOOP_TIMER_CLASS);
fail_if(t != NULL);
ecore_shutdown();
}
END_TEST
START_TEST(ecore_test_efl_app_version)
{
const Efl_Version *ver;
Eo *loop;
ecore_init();
loop = efl_loop_main_get(EFL_LOOP_CLASS);
fail_if(!efl_isa(loop, EFL_LOOP_CLASS));
efl_build_version_set(EFL_VERSION_MAJOR, EFL_VERSION_MINOR, 0, 0, NULL, EFL_BUILD_ID);
ver = efl_loop_app_efl_version_get(loop);
fail_if(!ver);
fail_if(ver->major != EFL_VERSION_MAJOR);
fail_if(ver->minor != EFL_VERSION_MINOR);
fail_if(ver->micro != 0);
fail_if(ver->revision != 0);
fail_if(ver->flavor);
fail_if(!eina_streq(ver->build_id, EFL_BUILD_ID));
ver = efl_loop_efl_version_get(loop);
fail_if(!ver);
fail_if(ver->major != EFL_VERSION_MAJOR);
fail_if(ver->minor != EFL_VERSION_MINOR);
ecore_shutdown();
}
END_TEST
void ecore_test_ecore(TCase *tc)
{
tcase_add_test(tc, ecore_test_ecore_init);
@ -879,4 +940,6 @@ void ecore_test_ecore(TCase *tc)
tcase_add_test(tc, ecore_test_ecore_main_loop_poller_add_del);
tcase_add_test(tc, ecore_test_efl_loop_fd);
tcase_add_test(tc, ecore_test_efl_loop_fd_lifecycle);
tcase_add_test(tc, ecore_test_efl_loop_register);
tcase_add_test(tc, ecore_test_efl_app_version);
}

58
src/tests/ecore/ecore_test_promise.c
View File

@ -66,7 +66,7 @@ START_TEST(efl_test_promise_future_success)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -106,7 +106,7 @@ START_TEST(efl_test_promise_future_success_before_get)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
efl_promise_value_set(p, &value, NULL);
@ -146,7 +146,7 @@ START_TEST(efl_test_promise_future_cancel)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
@ -191,7 +191,7 @@ START_TEST(efl_test_promise_before_future_success)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -229,7 +229,7 @@ START_TEST(efl_test_promise_before_future_cancel)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
@ -310,7 +310,7 @@ START_TEST(efl_test_promise_future_chain_success)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f1 = efl_promise_future_get(p);
@ -357,7 +357,7 @@ START_TEST(efl_test_promise_future_chain_cancel)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
efl_future_use(&f1, efl_promise_future_get(p));
@ -409,7 +409,7 @@ START_TEST(efl_test_promise_future_multi_success)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -454,7 +454,7 @@ START_TEST(efl_test_promise_future_multi_success_noref)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -497,7 +497,7 @@ START_TEST(efl_test_promise_future_multi_cancel)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
@ -545,7 +545,7 @@ START_TEST(efl_test_promise_before_future_multi_success)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -588,7 +588,7 @@ START_TEST(efl_test_promise_before_future_multi_success_noref)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -630,7 +630,7 @@ START_TEST(efl_test_promise_before_future_multi_cancel)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
@ -682,7 +682,7 @@ START_TEST(efl_test_promise_before_future_multi_cancel_noref)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
@ -742,7 +742,7 @@ START_TEST(efl_test_promise_future_optional_success)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -782,7 +782,7 @@ START_TEST(efl_test_promise_future_optional_cancel)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
@ -843,9 +843,9 @@ START_TEST(efl_test_promise_all)
ecore_init();
p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p3 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
p3 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1 || !p2 || !p3);
f1 = efl_ref(efl_promise_future_get(p1));
@ -893,9 +893,9 @@ START_TEST(efl_test_promise_all_after_value_set)
ecore_init();
p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p3 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
p3 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1 || !p2 || !p3);
f1 = efl_promise_future_get(p1);
@ -951,9 +951,9 @@ START_TEST(efl_test_promise_race)
ecore_init();
p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p3 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
p3 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1 || !p2 || !p3);
f1 = efl_ref(efl_promise_future_get(p1));
@ -989,9 +989,9 @@ START_TEST(efl_test_future_link)
ecore_init();
o = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()),
o = efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
efl_loop_timer_interval_set(efl_added, 0.0));
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
efl_future_use(&f, efl_promise_future_get(p));
efl_future_link(o, f);
@ -999,7 +999,7 @@ START_TEST(efl_test_future_link)
efl_del(o);
fail_if(f);
o = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()),
o = efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
efl_loop_timer_interval_set(efl_added, 0.0));
efl_future_use(&f, efl_promise_future_get(p));
efl_future_cancel(f);
@ -1026,7 +1026,7 @@ START_TEST(efl_test_recursive_mess)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
efl_future_use(&recursive_future, efl_promise_future_get(p));
efl_future_then(recursive_future, _then_cleanup, _cancel, NULL, &done);

8
src/tests/ecore/ecore_test_promise2.c
View File

@ -156,7 +156,7 @@ _simple_timeout(void *data)
static Eina_Future_Scheduler *
_future_scheduler_get(void)
{
return efl_loop_future_scheduler_get(efl_app_main_loop_get(efl_app_get()));
return efl_loop_future_scheduler_get(efl_main_loop_get());
}
static PromiseCtx *
@ -490,7 +490,7 @@ START_TEST(efl_test_timeout)
Eina_Bool done = EINA_FALSE;
fail_if(!ecore_init());
f = eina_future_then(efl_loop_timeout(efl_app_main_loop_get(efl_app_get()), 0.0001),
f = eina_future_then(efl_loop_timeout(efl_main_loop_get(), 0.0001),
_promise_empty_done, &done);
fail_if(!f);
ecore_main_loop_begin();
@ -506,7 +506,7 @@ START_TEST(efl_test_job)
Eina_Bool done = EINA_FALSE;
fail_if(!ecore_init());
f = eina_future_then(efl_loop_job(efl_app_main_loop_get(efl_app_get())),
f = eina_future_then(efl_loop_job(efl_main_loop_get()),
_promise_empty_done, &done);
fail_if(!f);
ecore_main_loop_begin();
@ -522,7 +522,7 @@ START_TEST(efl_test_idle)
Eina_Bool done = EINA_FALSE;
fail_if(!ecore_init());
f = eina_future_then(efl_loop_idle(efl_app_main_loop_get(efl_app_get())),
f = eina_future_then(efl_loop_idle(efl_main_loop_get()),
_promise_empty_done, &done);
fail_if(!f);
ecore_main_loop_begin();

2
src/tests/ecore/ecore_test_timer.c
View File

@ -267,7 +267,7 @@ START_TEST(ecore_test_timer_lifecycle)
t = ecore_timer_add(1.0, _test_time_cb, &rl);
efl_event_callback_add((Eo*) t, EFL_EVENT_DEL, _test_death_cb, &dl);
et = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()),
et = efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
efl_event_callback_add(efl_added, EFL_LOOP_TIMER_EVENT_TICK, _test_run_cb, &re),
efl_event_callback_add(efl_added, EFL_EVENT_DEL, _test_death_cb, &de),
efl_loop_timer_interval_set(efl_added, 1.0));

106
src/tests/ecore/efl_app_suite.c
View File

@ -1,106 +0,0 @@
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdio.h>
#include <unistd.h>
#define EFL_NOLEGACY_API_SUPPORT
#include <Efl_Core.h>
#include <Efl_Net.h>
#include "efl_app_suite.h"
#include "../efl_check.h"
START_TEST(efl_app_test_efl_loop_register)
{
Efl_Object *t, *n, *parent;
ecore_init();
t = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_CLASS);
fail_if(!efl_isa(t, EFL_LOOP_CLASS));
parent = efl_parent_get(t);
fail_if(!efl_isa(parent, EFL_APP_CLASS));
fail_if(parent != efl_app_get());
t = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_TIMER_CLASS);
fail_if(t != NULL);
n = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(n != NULL);
n = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()),
efl_loop_timer_interval_set(efl_added, 1.0));
efl_loop_register(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_TIMER_CLASS, n);
t = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_TIMER_CLASS);
fail_if(!efl_isa(t, EFL_LOOP_TIMER_CLASS));
fail_if(t != n);
efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_TIMER_CLASS, n);
t = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_TIMER_CLASS);
fail_if(t != NULL);
ecore_shutdown();
}
END_TEST
START_TEST(efl_app_test_efl_build_version)
{
const Efl_Version *ver;
Eo *app;
ecore_init();
app = efl_app_get();
fail_if(!efl_isa(app, EFL_APP_CLASS));
efl_build_version_set(EFL_VERSION_MAJOR, EFL_VERSION_MINOR, 0, 0, NULL, EFL_BUILD_ID);
ver = efl_app_build_efl_version_get(app);
fail_if(!ver);
fail_if(ver->major != EFL_VERSION_MAJOR);
fail_if(ver->minor != EFL_VERSION_MINOR);
fail_if(ver->micro != 0);
fail_if(ver->revision != 0);
fail_if(ver->flavor);
fail_if(!eina_streq(ver->build_id, EFL_BUILD_ID));
ver = efl_app_efl_version_get(app);
fail_if(!ver);
fail_if(ver->major != EFL_VERSION_MAJOR);
fail_if(ver->minor != EFL_VERSION_MINOR);
ecore_shutdown();
}
END_TEST
void efl_test_efl_app(TCase *tc)
{
tcase_add_test(tc, efl_app_test_efl_loop_register);
tcase_add_test(tc, efl_app_test_efl_build_version);
}
static const Efl_Test_Case etc[] = {
{ "Efl_App", efl_test_efl_app },
{ NULL, NULL }
};
int
main(int argc, char **argv)
{
int failed_count;
if (!_efl_test_option_disp(argc, argv, etc))
return 0;
#ifdef NEED_RUN_IN_TREE
putenv("EFL_RUN_IN_TREE=1");
#endif
failed_count = _efl_suite_build_and_run(argc - 1, (const char **)argv + 1,
"Efl_App", etc);
return (failed_count == 0) ? 0 : 255;
}

8
src/tests/ecore/efl_app_suite.h
View File

@ -1,8 +0,0 @@
#ifndef _EFL_APP_SUITE_H
#define _EFL_APP_SUITE_H
#include <check.h>
void efl_app_test_efl_app(TCase *tc);
#endif /* _EFL_APP_SUITE_H */

2
src/tests/ecore_con/ecore_con_test_efl_net_ip_address.c
View File

@ -117,7 +117,7 @@ _timeout(void *data,
do \
{ \
Eina_Bool _did_timeout = EINA_FALSE; \
Eina_Future *_timeout_future = efl_loop_timeout(efl_app_main_loop_get(efl_app_get()), t); \
Eina_Future *_timeout_future = efl_loop_timeout(efl_main_loop_get(), t); \
eina_future_then(_timeout_future, _timeout, &_did_timeout); \
mark_point(); \
ecore_main_loop_begin(); \

2
src/tests/eio/eio_model_test_file.c
View File

@ -114,7 +114,7 @@ START_TEST(eio_model_test_test_file)
fail_if(!efl_object_init(), "ERROR: Cannot init EO!\n");
fail_if(!eio_init(), "ERROR: Cannot init EIO!\n");
filemodel = efl_add(EIO_MODEL_CLASS, efl_app_main_loop_get(efl_app_get()), eio_model_path_set(efl_added, EFL_MODEL_TEST_FILENAME_PATH));
filemodel = efl_add(EIO_MODEL_CLASS, efl_main_loop_get(), eio_model_path_set(efl_added, EFL_MODEL_TEST_FILENAME_PATH));
fail_if(!filemodel, "ERROR: Cannot init model!\n");
handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL);

2
src/tests/eio/eio_model_test_monitor_add.c
View File

@ -112,7 +112,7 @@ START_TEST(eio_model_test_test_monitor_add)
tmpdir = eina_environment_tmp_get();
filemodel = efl_add(EIO_MODEL_CLASS, efl_app_main_loop_get(efl_app_get()), eio_model_path_set(efl_added, tmpdir));
filemodel = efl_add(EIO_MODEL_CLASS, efl_main_loop_get(), eio_model_path_set(efl_added, tmpdir));
fail_if(!filemodel, "ERROR: Cannot init model!\n");
efl_event_callback_add(filemodel, EFL_MODEL_EVENT_CHILD_ADDED, &_children_added_cb, filemodel);

12
src/tests/eio/eio_test_manager.c
View File

@ -156,7 +156,7 @@ _test_ls(Efl_Future *(*func)(Eo *obj, const char *path, Eina_Bool recursive),
uint64_t expected_test_count,
const char* test_dirname)
{
Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
Efl_Future *f = NULL;
uint64_t main_files = 0;
@ -206,7 +206,7 @@ START_TEST(efl_io_manager_test_stat)
nested_dirname = create_test_dirs(test_dirname);
nested_filename = get_full_path(test_dirname, files[3]);
job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
fail_if(!job);
// Start testing
@ -257,7 +257,7 @@ START_TEST(efl_io_manager_test_ls)
nested_filename = get_full_path(test_dirname, files[3]);
// Start testing
job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
fail_if(!job);
f = efl_io_manager_ls(job, test_dirname, &main_files, _access_cb, NULL);
@ -311,7 +311,7 @@ START_TEST(efl_io_manager_test_open)
nested_dirname = create_test_dirs(test_dirname);
nested_filename = get_full_path(test_dirname, files[3]);
job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
f = efl_io_manager_open(job, nested_filename, EINA_FALSE);
eina_future_then(f, _open_done_cb, &opened_file);
@ -340,11 +340,11 @@ START_TEST(efl_io_instantiated)
ecore_init();
fail_if(efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_IO_MANAGER_CLASS) != NULL);
fail_if(efl_provider_find(efl_main_loop_get(), EFL_IO_MANAGER_CLASS) != NULL);
eio_init();
manager = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_IO_MANAGER_CLASS);
manager = efl_provider_find(efl_main_loop_get(), EFL_IO_MANAGER_CLASS);
fail_if(manager == NULL);
fail_if(!efl_isa(manager, EFL_IO_MANAGER_CLASS));

2
src/tests/eio/eio_test_manager_xattr.c
View File

@ -130,7 +130,7 @@ START_TEST(eio_test_job_xattr_set)
eina_init();
eio_init();
job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
test_file_path = get_full_path(XATTR_TEST_DIR, filename);
fd = open(test_file_path,

4
src/tests/eldbus/eldbus_test_eldbus_model.c
View File

@ -172,7 +172,7 @@ check_property(Eo *object, const char *property_name, const char *expected_value
Eo *
create_connection(void)
{
Eo *connection = efl_add_ref(ELDBUS_MODEL_CONNECTION_CLASS, efl_app_main_loop_get(efl_app_get()), eldbus_model_connection_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE));
Eo *connection = efl_add_ref(ELDBUS_MODEL_CONNECTION_CLASS, efl_main_loop_get(), eldbus_model_connection_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE));
ck_assert_ptr_ne(NULL, connection);
return connection;
}
@ -180,7 +180,7 @@ create_connection(void)
Eo *
create_object(void)
{
Eo *object = efl_add_ref(ELDBUS_MODEL_OBJECT_CLASS, efl_app_main_loop_get(efl_app_get()), eldbus_model_object_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, ELDBUS_FDO_BUS, ELDBUS_FDO_PATH));
Eo *object = efl_add_ref(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(), eldbus_model_object_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, ELDBUS_FDO_BUS, ELDBUS_FDO_PATH));
ck_assert_ptr_ne(NULL, object);
return object;
}

2
src/tests/eldbus/eldbus_test_eldbus_model_method.c
View File

@ -29,7 +29,7 @@ _setup(void)
fake_server = fake_server_start(&fake_server_data);
fake_server_object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_app_main_loop_get(efl_app_get()), eldbus_model_object_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
fake_server_object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(), eldbus_model_object_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
ck_assert_ptr_ne(NULL, fake_server_object);
fake_server_proxy = eldbus_model_proxy_from_object_get(fake_server_object, FAKE_SERVER_INTERFACE);

2
src/tests/eldbus/eldbus_test_eldbus_model_signal.c
View File

@ -27,7 +27,7 @@ _setup(void)
fake_server = fake_server_start(&fake_server_data);
fake_server_object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_app_main_loop_get(efl_app_get()), eldbus_model_object_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
fake_server_object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(), eldbus_model_object_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
ck_assert_ptr_ne(NULL, fake_server_object);
fake_server_proxy = eldbus_model_proxy_from_object_get(fake_server_object, FAKE_SERVER_INTERFACE);

2
src/tests/eldbus/eldbus_test_fake_server_eldbus_model_proxy.c
View File

@ -33,7 +33,7 @@ _setup(void)
};
fake_server = fake_server_start(&fake_server_data);
fake_server_object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_app_main_loop_get(efl_app_get()), eldbus_model_object_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
fake_server_object = efl_add(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(), eldbus_model_object_custom_constructor(efl_added, ELDBUS_CONNECTION_TYPE_SESSION, NULL, EINA_FALSE, FAKE_SERVER_BUS, FAKE_SERVER_PATH));
ck_assert_ptr_ne(NULL, fake_server_object);
fake_server_proxy = eldbus_model_proxy_from_object_get(fake_server_object, FAKE_SERVER_INTERFACE);

6
src/tests/elementary/elm_test_config.c
View File

@ -13,7 +13,7 @@ START_TEST (elm_config_eoapi)
{
elm_init(1, NULL);
Eo *cfg = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_INTERFACE);
Eo *cfg = efl_provider_find(efl_main_loop_get(), EFL_CONFIG_INTERFACE);
fail_if(!cfg);
#define CONFIG_CHK(opt, typ, val) do { \
@ -150,7 +150,7 @@ START_TEST (elm_config_win)
{
elm_init(1, NULL);
Eo *cfg = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_INTERFACE);
Eo *cfg = efl_provider_find(efl_main_loop_get(), EFL_CONFIG_INTERFACE);
fail_if(!cfg);
Eo *win = efl_add(EFL_UI_WIN_CLASS, NULL);
@ -185,7 +185,7 @@ START_TEST (elm_config_profiles)
// this only tests some of the profile APIs. we're not going to mess with
// the global config during make check :)
Eo *cfg = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_INTERFACE);
Eo *cfg = efl_provider_find(efl_main_loop_get(), EFL_CONFIG_INTERFACE);
fail_if(!cfg);
for (int hidden = 0; hidden <= 1; hidden++)

66
src/tests/eo_cxx/eo_cxx_test_promise.cc
View File

@ -16,7 +16,7 @@ START_TEST(eo_cxx_future_construct_and_destroy)
ecore_init();
{
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -35,7 +35,7 @@ START_TEST(eo_cxx_future_wait)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -74,7 +74,7 @@ START_TEST(eo_cxx_future_get)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -114,7 +114,7 @@ START_TEST(eo_cxx_future_get_error)
ecore_init();
p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p);
f = efl_promise_future_get(p);
@ -157,7 +157,7 @@ START_TEST(eo_cxx_future_then_value)
ecore_init();
promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!promise);
f = efl_promise_future_get(promise);
@ -208,13 +208,13 @@ START_TEST(eo_cxx_future_composite_construct_and_destroy)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -236,13 +236,13 @@ START_TEST(eo_cxx_future_composite_wait)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future* f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future* f2 = efl_promise_future_get(p2);
@ -286,13 +286,13 @@ START_TEST(eo_cxx_future_composite_get)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -339,13 +339,13 @@ START_TEST(eo_cxx_future_composite_then_value)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -403,13 +403,13 @@ START_TEST(eo_cxx_future_all_construct_and_destroy)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -431,13 +431,13 @@ START_TEST(eo_cxx_future_all_wait)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future* f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future* f2 = efl_promise_future_get(p2);
@ -478,13 +478,13 @@ START_TEST(eo_cxx_future_all_get)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -528,13 +528,13 @@ START_TEST(eo_cxx_future_all_then_value)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -591,13 +591,13 @@ START_TEST(eo_cxx_future_race_construct_and_destroy)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -617,13 +617,13 @@ START_TEST(eo_cxx_future_race_wait)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future* f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future* f2 = efl_promise_future_get(p2);
@ -661,13 +661,13 @@ START_TEST(eo_cxx_future_race_get)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -707,13 +707,13 @@ START_TEST(eo_cxx_future_race_then_value)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -765,13 +765,13 @@ START_TEST(eo_cxx_future_race_variant_get)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future *f2 = efl_promise_future_get(p2);
@ -812,13 +812,13 @@ START_TEST(eo_cxx_future_race_variant_then_value)
ecore_init();
{
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p1 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p1);
Efl_Future *f1 = efl_promise_future_get(p1);
fail_if(!f1);
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Promise *p2 = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
fail_if(!p2);
Efl_Future *f2 = efl_promise_future_get(p2);