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 \
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 \
goto end;
}
- loop = efl_main_loop_get();
+ loop = efl_app_main_loop_get(efl_app_get());
#ifdef EFL_NET_SERVER_UNIX_CLASS
server = efl_add(EFL_NET_SERVER_SIMPLE_CLASS, loop,
goto error_path;
}
- loop = efl_main_loop_get();
+ loop = efl_app_main_loop_get(efl_app_get());
#ifdef EFL_NET_DIALER_UNIX_CLASS
dialer = efl_add(EFL_NET_DIALER_SIMPLE_CLASS, loop,
snprintf(path, sizeof(path) - 1, "%s/%s/%s/%i", socket_path,
LOCAL_SERVER_PATH, LOCAL_SERVER_NAME, LOCAL_SERVER_PORT);
- loop = efl_main_loop_get();
+ loop = efl_app_main_loop_get(efl_app_get());
#ifdef EFL_NET_SERVER_UNIX_CLASS
_local_server = efl_add(EFL_NET_SERVER_SIMPLE_CLASS, loop,
Eina_Bool ret = EINA_FALSE;
char address[256];
- loop = efl_main_loop_get();
+ loop = efl_app_main_loop_get(efl_app_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));
void list_files(void *data)
{
- Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
+ Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
const char *path = data;
eina_future_then(efl_io_manager_ls(job, path, NULL, progress_cb, NULL), done_cb, NULL);
{
Efl_Io_Manager *job;
- job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
+ job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
eina_future_chain(efl_io_manager_open(job, path, EINA_FALSE),
{ .cb = _open_cb, .data = job },
eio_init();
ecore_init();
- job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
+ job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
path = getenv("HOME");
path2 = "./";
ELDBUS_CONNECTION_TYPE_SYSTEM :
ELDBUS_CONNECTION_TYPE_SESSION);
- root = efl_add_ref(ELDBUS_MODEL_OBJECT_CLASS, efl_main_loop_get(),
+ root = efl_add_ref(ELDBUS_MODEL_OBJECT_CLASS, efl_app_main_loop_get(efl_app_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));
#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
#include "efl_interpolator_cubic_bezier.eo.h"
/* We ue the factory pattern here, so you shouldn't call eo_add directly. */
-EAPI Eo *efl_main_loop_get(void);
+EAPI Eo *efl_app_get(void);
typedef struct _Efl_Future_Composite_Progress Efl_Future_All_Progress;
sec = ((double) atoi(getenv("WATCHDOG_USEC"))) / 1000 / 1000;
_systemd_watchdog =
- efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
+ efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()),
efl_loop_timer_interval_set(efl_added, sec / 2),
efl_event_callback_add(efl_added,
EFL_LOOP_TIMER_EVENT_TICK,
ecore_system_modules_load();
if (getenv("EFL_FIRST_LOOP"))
- efl_event_callback_add(efl_main_loop_get(),
+ efl_event_callback_add(efl_app_main_loop_get(efl_app_get()),
EFL_LOOP_EVENT_RESUME,
_efl_first_loop_iterate,
getenv("EFL_FIRST_LOOP"));
if (_ecore_init_count-- != _ecore_init_count_threshold)
goto end;
- efl_event_callback_call(efl_main_loop_get(), EFL_LOOP_EVENT_TERMINATE, NULL);
+ efl_event_callback_call(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_TERMINATE, NULL);
ecore_system_modules_unload();
_event_msg_handler =
efl_loop_message_handler_get(EFL_LOOP_CLASS,
- _mainloop_singleton,
+ ML_OBJ,
ECORE_EVENT_MESSAGE_HANDLER_CLASS);
if (!_event_msg_handler)
{
const void *data)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
- Ecore_Exe *ret = efl_add(MY_CLASS, efl_loop_main_get(EFL_LOOP_CLASS),
+ Ecore_Exe *ret = efl_add(MY_CLASS, efl_app_main_loop_get(efl_app_get()),
ecore_obj_exe_command_set(efl_added, exe_cmd,
flags));
if (ret)
// This avoid us duplicating code and should only be slightly slower
// due to a useless cycle of callback registration
- 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);
+ 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);
return ie;
}
return idler->data;
}
- efl_event_callback_array_del(_mainloop_singleton, idler->desc, idler);
+ efl_event_callback_array_del(ML_OBJ, idler->desc, idler);
data = idler->data;
eina_mempool_free(idler_mp, idler);
ret->references = 0;
ret->delete_me = EINA_FALSE;
- efl_event_callback_array_add(_mainloop_singleton, desc, ret);
+ efl_event_callback_array_add(ML_OBJ, desc, ret);
return ret;
}
_ecore_main_loop_init(void)
{
DBG("_ecore_main_loop_init");
- if (!efl_main_loop_get()) ERR("Cannot create main loop object");
+ if (!efl_app_main_loop_get(efl_app_get())) ERR("Cannot create main loop object");
_ecore_main_loop_setup(ML_OBJ, ML_DAT);
}
{
Ecore_Fd_Handler *fdh = NULL;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
- fdh = _ecore_main_fd_handler_add(efl_loop_main_get(EFL_LOOP_CLASS),
+ fdh = _ecore_main_fd_handler_add(efl_app_main_loop_get(efl_app_get()),
ML_DAT, NULL, fd, flags, func, data,
buf_func, buf_data, EINA_FALSE);
if (fdh) fdh->legacy = EINA_TRUE;
const void *buf_data)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
- return _ecore_main_fd_handler_add(efl_loop_main_get(EFL_LOOP_CLASS),
+ return _ecore_main_fd_handler_add(efl_app_main_loop_get(efl_app_get()),
ML_DAT, NULL, fd, flags, func, data,
buf_func, buf_data, EINA_TRUE);
}
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;
#undef GENERIC_ALLOC_FREE_HEADER
-extern Eo *_mainloop_singleton;
-extern Efl_Loop_Data *_mainloop_singleton_data;
-#define ML_OBJ _mainloop_singleton
-#define ML_DAT _mainloop_singleton_data
+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)
//#define ML_DAT efl_data_scope_get(ML_OBJ, EFL_LOOP_CLASS)
extern Efl_Version _app_efl_version;
// access to direct input cb
#define ECORE_EVAS_INTERNAL
-#define EFL_LOOP_DATA efl_data_scope_get(efl_loop_main_get(EFL_LOOP_CLASS), EFL_LOOP_CLASS)
+#define EFL_LOOP_DATA efl_data_scope_get(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_CLASS)
EOAPI Eina_Bool efl_loop_message_process(Eo *obj);
efl_domain_current_push(EFL_ID_DOMAIN_SHARED);
- efl_wref_add(efl_add(EFL_PROMISE_CLASS, efl_main_loop_get()), &p);
+ efl_wref_add(efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get())), &p);
if (!p) goto end;
efl_object_override(p, &thread_safe_call);
}
legacy->func = func;
legacy->data = data;
- timer = efl_add(MY_CLASS, efl_main_loop_get(),
+ timer = efl_add(MY_CLASS, efl_app_main_loop_get(efl_app_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));
}
legacy->func = func;
legacy->data = data;
- timer = efl_add(MY_CLASS, efl_main_loop_get(),
+ timer = efl_add(MY_CLASS, efl_app_main_loop_get(efl_app_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),
--- /dev/null
+#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"
--- /dev/null
+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]]
+ }
+ }
+ }
+ implements {
+ Efl.Object.constructor;
+ Efl.Object.destructor;
+ }
+}
_efl_startup_time = ecore_time_unix_get(); \
_EFL_APP_VERSION_SET(); \
ecore_init(); \
- efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS, efl_main, NULL); \
+ efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS, efl_main, NULL); \
ecore_init_ex(argc, argv); \
__EFL_MAIN_CONSTRUCTOR; \
- ret__ = efl_loop_begin(efl_main_loop_get()); \
+ ret__ = efl_loop_begin(efl_app_main_loop_get(efl_app_get())); \
real__ = efl_loop_exit_code_process(ret__); \
__EFL_MAIN_DESTRUCTOR; \
ecore_shutdown_ex(); \
_efl_startup_time = ecore_time_unix_get(); \
_EFL_APP_VERSION_SET(); \
ecore_init(); \
- efl_event_callback_array_add(efl_main_loop_get(), _efl_main_ex(), NULL); \
+ efl_event_callback_array_add(efl_app_main_loop_get(efl_app_get()), _efl_main_ex(), NULL); \
ecore_init_ex(argc, argv); \
__EFL_MAIN_CONSTRUCTOR; \
- ret__ = efl_loop_begin(efl_main_loop_get()); \
+ ret__ = efl_loop_begin(efl_app_main_loop_get(efl_app_get())); \
real__ = efl_loop_exit_code_process(ret__); \
__EFL_MAIN_DESTRUCTOR; \
ecore_shutdown_ex(); \
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)
{
eina_value_setup(&v, EINA_VALUE_TYPE_INT);
eina_value_set(&v, &exit_code);
- efl_loop_quit(efl_main_loop_get(), v);
+ efl_loop_quit(efl_app_main_loop_get(efl_app_get()), v);
}
EOLIAN static Efl_Object *
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();
pd->env.environ_copy = NULL;
eina_lock_release(&_environ_lock);
- efl_destructor(efl_super(obj, EFL_LOOP_CLASS));
+ efl_parent_set(obj, NULL);
+ if (obj != ML_OBJ)
+ _efl_app_data->loops = eina_list_remove(_efl_app_data->loops, obj);
- if (obj == _mainloop_singleton)
- {
- _mainloop_singleton = NULL;
- _mainloop_singleton_data = NULL;
- }
+ efl_destructor(efl_super(obj, EFL_LOOP_CLASS));
}
static void
arge.initialization = initialization;
initialization = EINA_FALSE;
- efl_event_callback_call(efl_main_loop_get(),
+ efl_event_callback_call(efl_app_main_loop_get(efl_app_get()),
EFL_LOOP_EVENT_ARGUMENTS, &arge);
on_error:
_efl_loop_arguments_cleanup(arga);
Eina_Array *arga;
int i = 0;
- efl_task_arg_reset(efl_main_loop_get());
+ efl_task_arg_reset(efl_app_main_loop_get(efl_app_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_main_loop_get(), argv[i]);
+ efl_task_arg_append(efl_app_main_loop_get(efl_app_get()), argv[i]);
}
- job = eina_future_then(efl_loop_job(efl_main_loop_get()),
+ job = eina_future_then(efl_loop_job(efl_app_main_loop_get(efl_app_get())),
_efl_loop_arguments_send, arga);
- efl_future_Eina_FutureXXX_then(efl_main_loop_get(), job);
+ efl_future_Eina_FutureXXX_then(efl_app_main_loop_get(efl_app_get()), job);
}
// Only one main loop handle for now
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)
{
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.]]
Efl_Loop *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
if (!loop && eina_main_loop_is())
{
- loop = efl_main_loop_get();
+ loop = efl_app_main_loop_get(efl_app_get());
ERR("Failed to get the loop on object %p from the main thread! "
"Returning the main loop: %p", obj, loop);
}
Efl_Model_Hash_Value *hv = eina_hash_find(pd->parent_pd->values, property);
if (hv)
{
- Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
Eina_Value *eina_value = eina_value_new(EINA_VALUE_TYPE_UCHAR);
return efl_model_property_get(pd->composite_child, property);
else
{
- Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
_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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
Efl_Model_Hash_Value *hv = eina_hash_find(pd->parent_pd->values, property);
if (pd->composite_model)
return efl_model_property_get(pd->composite_model, property);
- Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
const char *property, const Eina_Value *value)
{
- Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
if (pd->composite_model)
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
if (pd->composite_model)
return efl_model_children_count_get(pd->composite_model);
else
{
- Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
unsigned int *count = malloc(sizeof(unsigned int));
}
else
{
- Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_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);
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
_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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
Eina_Accessor* accessor = efl_model_list_slice(sd->children, start, count);
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
unsigned int *count = calloc(1, sizeof(unsigned int));
Eina_Stringshare *prop_name;
Child_Property_Data *cpd;
void *data, *new_data;
- Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
if (!sd->parent_data)
Eina_Stringshare *prop_name;
Child_Property_Data *cpd;
Eina_Value *value;
- Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
if (!sd->parent_data)
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
efl_promise_value_set(promise, NULL, NULL);
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
unsigned int *count = calloc(1, sizeof(unsigned int));
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future* future = efl_promise_future_get(promise);
Efl_Model_Property_Event evt;
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
Eina_Stringshare *sshare = eina_stringshare_add(property);
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
Eina_Accessor* accessor = efl_model_list_slice(sd->children, start, count);
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_main_loop_get());
+ Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *rfuture = efl_promise_future_get(promise);
unsigned int *count = calloc(1, sizeof(unsigned int));
const Eina_Future *dead EINA_UNUSED)
{
Ecore_Con_Client *cl = data;
- Eo *loop = efl_main_loop_get();
+ Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *inner_socket;
Eo *socket;
Eo *tcp_socket;
const Eina_Future *dead EINA_UNUSED)
{
Ecore_Con_Server *svr = data;
- Eo *loop = efl_main_loop_get();
+ Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *ssl_ctx;
Eo *inner_server;
Eo *server;
return NULL;
}
- loop = efl_main_loop_get();
+ loop = efl_app_main_loop_get(efl_app_get());
EINA_SAFETY_ON_NULL_RETURN_VAL(loop, NULL);
svr = _ecore_con_server_new(EINA_FALSE, compl_type, name, port, data);
const Eina_Future *dead EINA_UNUSED)
{
Ecore_Con_Server *svr = data;
- Eo *loop = efl_main_loop_get();
+ Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *ssl_ctx;
Eo *inner_dialer;
Eo *dialer;
const Eina_Future *dead EINA_UNUSED)
{
Ecore_Con_Server *svr = data;
- Eo *loop = efl_main_loop_get();
+ Eo *loop = efl_app_main_loop_get(efl_app_get());
Eo *ssl_ctx;
Eo *inner_dialer;
Eo *dialer;
type = compl_type & ECORE_CON_TYPE;
- loop = efl_main_loop_get();
+ loop = efl_app_main_loop_get(efl_app_get());
EINA_SAFETY_ON_NULL_RETURN_VAL(loop, NULL);
svr = _ecore_con_server_new(EINA_TRUE, compl_type, name, port, data);
if (proxy_url)
DBG("proxy_url='%s'", proxy_url);
- url_con->dialer = efl_add(EFL_NET_DIALER_HTTP_CLASS, efl_main_loop_get(),
+ url_con->dialer = efl_add(EFL_NET_DIALER_HTTP_CLASS, efl_app_main_loop_get(efl_app_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),
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_main_loop_get(),
+ ctx->promise = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_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);
return EINA_FALSE;
}
- loop = efl_main_loop_get();
+ loop = efl_app_main_loop_get(efl_app_get());
EINA_SAFETY_ON_NULL_RETURN_VAL(loop, EINA_FALSE);
job = calloc(1, sizeof(Ecore_File_Download_Job));
ecore_ipc_server_with_fd_add(Ecore_Ipc_Type type, const char *name, int port, int fd, const void *data)
{
Ecore_Ipc_Server *svr;
- Eo *loop = efl_main_loop_get();
+ Eo *loop = efl_app_main_loop_get(efl_app_get());
char *address = NULL;
Eina_Error err;
#ifdef EFL_NET_SERVER_UNIX_CLASS
new_mask = S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH;
- svr->server = efl_add(EFL_NET_SERVER_UNIX_CLASS, efl_main_loop_get(),
+ svr->server = efl_add(EFL_NET_SERVER_UNIX_CLASS, efl_app_main_loop_get(efl_app_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);
efl_loop_fd_set(svr->server, fd);// TIZEN ONLY (20180125): smack issue
new_mask = 0;
local_system = EINA_TRUE;
- svr->server = efl_add(EFL_NET_SERVER_UNIX_CLASS, efl_main_loop_get());
+ svr->server = efl_add(EFL_NET_SERVER_UNIX_CLASS, efl_app_main_loop_get(efl_app_get()));
EINA_SAFETY_ON_NULL_GOTO(svr->server, error_server);
efl_loop_fd_set(svr->server, fd);// TIZEN ONLY (20180125): smack issue
}
// 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_main_loop_get());
+ svr->server = efl_add(EFL_NET_SERVER_WINDOWS_CLASS, efl_app_main_loop_get(efl_app_get()));
EINA_SAFETY_ON_NULL_GOTO(svr->server, error_server);
}
else if ((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_SYSTEM)
// 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_main_loop_get());
+ svr->server = efl_add(EFL_NET_SERVER_WINDOWS_CLASS, efl_app_main_loop_get(efl_app_get()));
EINA_SAFETY_ON_NULL_GOTO(svr->server, error_server);
}
#endif /* EFL_NET_SERVER_WINDOWS_CLASS */
ecore_ipc_server_with_fd_connect(Ecore_Ipc_Type type, char *name, int port, int fd, const void *data)
{
Ecore_Ipc_Server *svr;
- Eo *loop = efl_main_loop_get();
+ Eo *loop = efl_app_main_loop_get(efl_app_get());
char *address = NULL;
Eina_Error err;
goto error_dialer;
}
- svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, efl_main_loop_get());
+ svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, efl_app_main_loop_get(efl_app_get()));
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
efl_loop_fd_set(svr->dialer.dialer, fd);// TIZEN ONLY (20180125): smack issue
}
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_main_loop_get());
+ svr->dialer.dialer = efl_add(EFL_NET_DIALER_UNIX_CLASS, efl_app_main_loop_get(efl_app_get()));
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
efl_loop_fd_set(svr->dialer.dialer, fd);// TIZEN ONLY (20180125): smack issue
}
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_main_loop_get());
+ svr->dialer.dialer = efl_add(EFL_NET_DIALER_WINDOWS_CLASS, efl_app_main_loop_get(efl_app_get()));
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
}
else if ((type & ECORE_IPC_TYPE) == ECORE_IPC_LOCAL_SYSTEM)
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_main_loop_get());
+ svr->dialer.dialer = efl_add(EFL_NET_DIALER_WINDOWS_CLASS, efl_app_main_loop_get(efl_app_get()));
EINA_SAFETY_ON_NULL_GOTO(svr->dialer.dialer, error_dialer);
}
#endif /* EFL_NET_DIALER_WINDOWS_CLASS */
_edje_scale = FROM_DOUBLE(1.0);
_edje_global_obj = efl_add(EDJE_GLOBAL_CLASS, NULL);
if (!_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))
+ !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))
goto shutdown_efreet;
_edje_edd_init();
_edje_edd_shutdown();
if (_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_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_del(_edje_global_obj);
_edje_global_obj = NULL;
}
_edje_text_class_hash_free();
_edje_size_class_hash_free();
_edje_edd_shutdown();
- 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_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_del(_edje_global_obj);
_edje_global_obj = NULL;
_edje_global(void)
{
#ifndef NDEBUG
- return efl_provider_find(efl_main_loop_get(), EFL_GFX_COLOR_CLASS_INTERFACE);
+ return efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_GFX_COLOR_CLASS_INTERFACE);
#else
extern Edje_Global *_edje_global_obj;
return _edje_global_obj;
efreet_mime_init();
- 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);
+ 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);
eina_log_timing(_eio_log_dom_global,
EINA_LOG_STATE_STOP,
EINA_LOG_STATE_START,
EINA_LOG_STATE_SHUTDOWN);
- efl_loop_unregister(efl_main_loop_get(), EFL_IO_MANAGER_CLASS, io_manager);
+ efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_IO_MANAGER_CLASS, io_manager);
efl_del(io_manager);
io_manager = NULL;
// 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_main_loop_get();
+ return efl_app_main_loop_get(efl_app_get());
return provider;
}
efl_access_window_created_signal_emit(obj);
// attach config API
- efl_composite_attach(obj, efl_provider_find(efl_main_loop_get(), EFL_CONFIG_GLOBAL_CLASS));
+ efl_composite_attach(obj, efl_provider_find(efl_app_main_loop_get(efl_app_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);
_config_load(void)
{
_efl_config_obj = efl_add(EFL_CONFIG_GLOBAL_CLASS, NULL);
- 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_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_del_intercept_set(_efl_config_obj, _efl_config_obj_del);
_elm_config = _config_user_load();
if (_elm_config)
_elm_config_shutdown(void)
{
efl_del_intercept_set(_efl_config_obj, NULL);
- 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);
+ 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);
ELM_SAFE_FREE(_efl_config_obj, efl_del);
ELM_SAFE_FREE(_elm_config, _config_free);
ELM_SAFE_FREE(_elm_preferred_engine, eina_stringshare_del);
return;
on_error:
- efl_event_callback_del(efl_main_loop_get(),
+ efl_event_callback_del(efl_app_main_loop_get(efl_app_get()),
EFL_LOOP_EVENT_IDLE_ENTER,
_render_cb,
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_main_loop_get(),
+ efl_event_callback_del(efl_app_main_loop_get(efl_app_get()),
EFL_LOOP_EVENT_IDLE_ENTER,
_render_cb,
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_main_loop_get(),
+ sd->render_idle_enterer = efl_event_callback_priority_add(efl_app_main_loop_get(efl_app_get()),
EFL_LOOP_EVENT_IDLE_ENTER,
EFL_CALLBACK_PRIORITY_BEFORE,
_render_cb,
//TODO:will be optimised
efl_event_callback_legacy_call(obj, ELM_GLVIEW_EVENT_DESTROYED, NULL);
- efl_event_callback_del(efl_main_loop_get(),
+ efl_event_callback_del(efl_app_main_loop_get(efl_app_get()),
EFL_LOOP_EVENT_IDLE_ENTER,
_render_cb,
obj);
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_main_loop_get(),
+ sd->render_idle_enterer = efl_event_callback_priority_add(efl_app_main_loop_get(efl_app_get()),
EFL_LOOP_EVENT_IDLE_ENTER,
EFL_CALLBACK_PRIORITY_BEFORE,
_render_cb, obj);
{
if (qre_pause && qre_resume && qre_terminate)
{
- efl_event_callback_array_add(efl_main_loop_get(), _qre_main_ex(), NULL);
+ efl_event_callback_array_add(efl_app_main_loop_get(efl_app_get()), _qre_main_ex(), NULL);
}
else
{
- efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS, qre_main, NULL);
+ efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS, qre_main, NULL);
}
ecore_init_ex(argc, argv);
- ret = efl_loop_exit_code_process(efl_loop_begin(efl_main_loop_get()));
+ ret = efl_loop_exit_code_process(efl_loop_begin(efl_app_main_loop_get(efl_app_get())));
ecore_shutdown_ex();
{
if (value == ELM_POLICY_EXIT_WINDOWS_DEL)
{
- efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_TERMINATE,
+ efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_TERMINATE,
_on_terminate, NULL);
}
else
{
- efl_event_callback_del(efl_main_loop_get(), EFL_LOOP_EVENT_TERMINATE,
+ efl_event_callback_del(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_TERMINATE,
_on_terminate, NULL);
}
}
if (klass == EVAS_CANVAS_CLASS)
return (Eo *)eo_e;
else if (klass == EFL_LOOP_CLASS)
- return efl_main_loop_get();
+ return efl_app_main_loop_get(efl_app_get());
else if (klass == EFL_CANVAS_GESTURE_MANAGER_CLASS)
return e->gesture_manager;
return efl_provider_find(efl_super(eo_e, MY_CLASS), klass);
EOLIAN static Efl_Loop *
_evas_canvas_efl_loop_consumer_loop_get(Eo *eo_e EINA_UNUSED, Evas_Public_Data *e EINA_UNUSED)
{
- return efl_main_loop_get();
+ return efl_app_main_loop_get(efl_app_get());
}
Ector_Surface *
return obj->layer->evas->evas;
}
else if (klass == EFL_LOOP_CLASS)
- return efl_main_loop_get();
+ return efl_app_main_loop_get(efl_app_get());
fallback:
return efl_provider_find(efl_super(eo_obj, MY_CLASS), klass);
}
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_main_loop_get();
+ return efl_app_main_loop_get(efl_app_get());
}
EOLIAN static void
static Eina_Future_Scheduler *
_future_scheduler_get(void)
{
- return efl_loop_future_scheduler_get(efl_main_loop_get());
+ return efl_loop_future_scheduler_get(efl_app_main_loop_get(efl_app_get()));
}
EOLIAN static Eina_Future *
START_TEST(ecore_test_args1)
{
ecore_init();
- efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
+ efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS,
_cb_args1, NULL);
ecore_loop_arguments_send(8, args);
ecore_main_loop_begin();
};
ecore_init();
- efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
+ efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS,
_cb_args2, NULL);
ecore_loop_arguments_send(1, simple_args);
ecore_main_loop_begin();
START_TEST(ecore_test_args3)
{
ecore_init();
- efl_event_callback_add(efl_main_loop_get(), EFL_LOOP_EVENT_ARGUMENTS,
+ efl_event_callback_add(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_EVENT_ARGUMENTS,
_cb_args3, NULL);
ecore_loop_arguments_send(0, NULL);
ecore_main_loop_begin();
ret = pipe(comm);
fail_if(ret != 0);
- fd = efl_add(EFL_LOOP_FD_CLASS, efl_main_loop_get(),
+ fd = efl_add(EFL_LOOP_FD_CLASS, efl_app_main_loop_get(efl_app_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);
ret = pipe(comm);
fail_if(ret != 0);
- fd = efl_add(EFL_LOOP_FD_CLASS, efl_main_loop_get(),
+ fd = efl_add(EFL_LOOP_FD_CLASS, efl_app_main_loop_get(efl_app_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));
ecore_init();
- t = efl_provider_find(efl_main_loop_get(), EFL_LOOP_CLASS);
+ t = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_CLASS);
fail_if(!efl_isa(t, EFL_LOOP_CLASS));
- t = efl_provider_find(efl_main_loop_get(), EFL_LOOP_TIMER_CLASS);
+ 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_main_loop_get());
+ 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_main_loop_get(),
+ 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_main_loop_get(), EFL_LOOP_TIMER_CLASS, n);
+ efl_loop_register(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_TIMER_CLASS, n);
- t = efl_provider_find(efl_main_loop_get(), EFL_LOOP_TIMER_CLASS);
+ 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_main_loop_get(), EFL_LOOP_TIMER_CLASS, n);
+ efl_loop_unregister(efl_app_main_loop_get(efl_app_get()), EFL_LOOP_TIMER_CLASS, n);
- t = efl_provider_find(efl_main_loop_get(), EFL_LOOP_TIMER_CLASS);
+ 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(ecore_test_efl_app_version)
+START_TEST(ecore_test_efl_build_version)
{
const Efl_Version *ver;
- Eo *loop;
+ Eo *app;
ecore_init();
- loop = efl_loop_main_get(EFL_LOOP_CLASS);
- fail_if(!efl_isa(loop, EFL_LOOP_CLASS));
+ 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_loop_app_efl_version_get(loop);
+ 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->flavor);
fail_if(!eina_streq(ver->build_id, EFL_BUILD_ID));
- ver = efl_loop_efl_version_get(loop);
+ ver = efl_app_efl_version_get(app);
fail_if(!ver);
fail_if(ver->major != EFL_VERSION_MAJOR);
fail_if(ver->minor != EFL_VERSION_MINOR);
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);
+ tcase_add_test(tc, ecore_test_efl_build_version);
}
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
f = efl_promise_future_get(p);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
efl_promise_value_set(p, &value, NULL);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
f = efl_promise_future_get(p);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
f1 = efl_promise_future_get(p);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
efl_future_use(&f1, efl_promise_future_get(p));
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
f = efl_promise_future_get(p);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
f = efl_promise_future_get(p);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
f = efl_promise_future_get(p);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
f = efl_promise_future_get(p);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
f = efl_promise_future_get(p);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!p);
efl_future_use(&f, efl_promise_future_get(p));
ecore_init();
- 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());
+ 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()));
fail_if(!p1 || !p2 || !p3);
f1 = efl_ref(efl_promise_future_get(p1));
ecore_init();
- 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());
+ 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()));
fail_if(!p1 || !p2 || !p3);
f1 = efl_promise_future_get(p1);
ecore_init();
- 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());
+ 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()));
fail_if(!p1 || !p2 || !p3);
f1 = efl_ref(efl_promise_future_get(p1));
ecore_init();
- o = efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
+ o = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()),
efl_loop_timer_interval_set(efl_added, 0.0));
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
efl_future_use(&f, efl_promise_future_get(p));
efl_future_link(o, f);
efl_del(o);
fail_if(f);
- o = efl_add(EFL_LOOP_TIMER_CLASS, efl_main_loop_get(),
+ o = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_get()),
efl_loop_timer_interval_set(efl_added, 0.0));
efl_future_use(&f, efl_promise_future_get(p));
efl_future_cancel(f);
ecore_init();
- p = efl_add(EFL_PROMISE_CLASS, efl_main_loop_get());
+ p = efl_add(EFL_PROMISE_CLASS, efl_app_main_loop_get(efl_app_get()));
efl_future_use(&recursive_future, efl_promise_future_get(p));
efl_future_then(recursive_future, _then_cleanup, _cancel, NULL, &done);
static Eina_Future_Scheduler *
_future_scheduler_get(void)
{
- return efl_loop_future_scheduler_get(efl_main_loop_get());
+ return efl_loop_future_scheduler_get(efl_app_main_loop_get(efl_app_get()));
}
static PromiseCtx *
Eina_Bool done = EINA_FALSE;
fail_if(!ecore_init());
- f = eina_future_then(efl_loop_timeout(efl_main_loop_get(), 0.0001),
+ f = eina_future_then(efl_loop_timeout(efl_app_main_loop_get(efl_app_get()), 0.0001),
_promise_empty_done, &done);
fail_if(!f);
ecore_main_loop_begin();
Eina_Bool done = EINA_FALSE;
fail_if(!ecore_init());
- f = eina_future_then(efl_loop_job(efl_main_loop_get()),
+ f = eina_future_then(efl_loop_job(efl_app_main_loop_get(efl_app_get())),
_promise_empty_done, &done);
fail_if(!f);
ecore_main_loop_begin();
Eina_Bool done = EINA_FALSE;
fail_if(!ecore_init());
- f = eina_future_then(efl_loop_idle(efl_main_loop_get()),
+ f = eina_future_then(efl_loop_idle(efl_app_main_loop_get(efl_app_get())),
_promise_empty_done, &done);
fail_if(!f);
ecore_main_loop_begin();
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_main_loop_get(),
+ et = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_loop_get(efl_app_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));
do \
{ \
Eina_Bool _did_timeout = EINA_FALSE; \
- Eina_Future *_timeout_future = efl_loop_timeout(efl_main_loop_get(), t); \
+ Eina_Future *_timeout_future = efl_loop_timeout(efl_app_main_loop_get(efl_app_get()), t); \
eina_future_then(_timeout_future, _timeout, &_did_timeout); \
mark_point(); \
ecore_main_loop_begin(); \
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_main_loop_get(), eio_model_path_set(efl_added, EFL_MODEL_TEST_FILENAME_PATH));
+ 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));
fail_if(!filemodel, "ERROR: Cannot init model!\n");
handler = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, exit_func, NULL);
tmpdir = eina_environment_tmp_get();
- filemodel = efl_add(EIO_MODEL_CLASS, efl_main_loop_get(), eio_model_path_set(efl_added, tmpdir));
+ filemodel = efl_add(EIO_MODEL_CLASS, efl_app_main_loop_get(efl_app_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);
uint64_t expected_test_count,
const char* test_dirname)
{
- Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
+ Efl_Io_Manager *job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
Efl_Future *f = NULL;
uint64_t main_files = 0;
nested_dirname = create_test_dirs(test_dirname);
nested_filename = get_full_path(test_dirname, files[3]);
- job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
+ job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!job);
// Start testing
nested_filename = get_full_path(test_dirname, files[3]);
// Start testing
- job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
+ job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
fail_if(!job);
f = efl_io_manager_ls(job, test_dirname, &main_files, _access_cb, NULL);
nested_dirname = create_test_dirs(test_dirname);
nested_filename = get_full_path(test_dirname, files[3]);
- job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
+ job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
f = efl_io_manager_open(job, nested_filename, EINA_FALSE);
eina_future_then(f, _open_done_cb, &opened_file);
ecore_init();
- fail_if(efl_provider_find(efl_main_loop_get(), EFL_IO_MANAGER_CLASS) != NULL);
+ fail_if(efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_IO_MANAGER_CLASS) != NULL);
eio_init();
- manager = efl_provider_find(efl_main_loop_get(), EFL_IO_MANAGER_CLASS);
+ manager = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_IO_MANAGER_CLASS);
fail_if(manager == NULL);
fail_if(!efl_isa(manager, EFL_IO_MANAGER_CLASS));
eina_init();
eio_init();
- job = efl_add(EFL_IO_MANAGER_CLASS, efl_main_loop_get());
+ job = efl_add(EFL_IO_MANAGER_CLASS, efl_app_main_loop_get(efl_app_get()));
test_file_path = get_full_path(XATTR_TEST_DIR, filename);
fd = open(test_file_path,
Eo *
create_connection(void)
{
- 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));
+ 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));
ck_assert_ptr_ne(NULL, connection);
return connection;
}
Eo *
create_object(void)
{
- 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));
+ 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));
ck_assert_ptr_ne(NULL, object);
return object;
}
fake_server = fake_server_start(&fake_server_data);
- 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));
+ 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));
ck_assert_ptr_ne(NULL, fake_server_object);
fake_server_proxy = eldbus_model_proxy_from_object_get(fake_server_object, FAKE_SERVER_INTERFACE);
fake_server = fake_server_start(&fake_server_data);
- 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));
+ 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));
ck_assert_ptr_ne(NULL, fake_server_object);
fake_server_proxy = eldbus_model_proxy_from_object_get(fake_server_object, FAKE_SERVER_INTERFACE);
};
fake_server = fake_server_start(&fake_server_data);
- 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));
+ 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));
ck_assert_ptr_ne(NULL, fake_server_object);
fake_server_proxy = eldbus_model_proxy_from_object_get(fake_server_object, FAKE_SERVER_INTERFACE);
{
elm_init(1, NULL);
- Eo *cfg = efl_provider_find(efl_main_loop_get(), EFL_CONFIG_INTERFACE);
+ Eo *cfg = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_INTERFACE);
fail_if(!cfg);
#define CONFIG_CHK(opt, typ, val) do { \
{
elm_init(1, NULL);
- Eo *cfg = efl_provider_find(efl_main_loop_get(), EFL_CONFIG_INTERFACE);
+ Eo *cfg = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_INTERFACE);
fail_if(!cfg);
Eo *win = efl_add(EFL_UI_WIN_CLASS, NULL);
// 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_main_loop_get(), EFL_CONFIG_INTERFACE);
+ Eo *cfg = efl_provider_find(efl_app_main_loop_get(efl_app_get()), EFL_CONFIG_INTERFACE);
fail_if(!cfg);
for (int hidden = 0; hidden <= 1; hidden++)
projects / platform / upstream / efl.git / commitdiff