2013-01-10 14:11:07 -08:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2019-05-22 04:59:05 -07:00
|
|
|
#ifdef _WIN32
|
|
|
|
/* normally, they will never be called as it's for Wayland */
|
|
|
|
# include <evil_private.h> /* setenv unsetenv */
|
|
|
|
#endif
|
|
|
|
|
2013-01-10 14:11:07 -08:00
|
|
|
#include "emotion_private.h"
|
2018-02-12 09:38:34 -08:00
|
|
|
#include "../../static_libs/buildsystem/buildsystem.h"
|
2014-01-08 02:46:23 -08:00
|
|
|
#include <unistd.h>
|
2013-01-10 14:11:07 -08:00
|
|
|
|
2020-04-24 00:35:31 -07:00
|
|
|
#if defined(EMOTION_STATIC_BUILD_GSTREAMER1)
|
2013-01-10 14:11:07 -08:00
|
|
|
Eina_Bool gstreamer_module_init(void);
|
|
|
|
void gstreamer_module_shutdown(void);
|
|
|
|
#endif
|
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
typedef struct _Emotion_Engine_Registry_Entry
|
|
|
|
{
|
|
|
|
const Emotion_Engine *engine;
|
|
|
|
int priority;
|
|
|
|
} Emotion_Engine_Registry_Entry;
|
|
|
|
|
|
|
|
static Eina_List *_emotion_engine_registry = NULL;
|
2013-01-10 16:27:35 -08:00
|
|
|
static Eina_Array *_emotion_modules = NULL;
|
2013-01-11 09:41:53 -08:00
|
|
|
static Eina_Bool _emotion_modules_loaded = EINA_FALSE;
|
2013-01-10 14:11:07 -08:00
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
static void
|
|
|
|
_emotion_engine_registry_entry_free(Emotion_Engine_Registry_Entry *re)
|
|
|
|
{
|
|
|
|
free(re);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
_emotion_engine_registry_entry_cmp(const void *pa, const void *pb)
|
|
|
|
{
|
|
|
|
const Emotion_Engine_Registry_Entry *a = pa, *b = pb;
|
2013-07-31 02:42:13 -07:00
|
|
|
int r = b->priority - a->priority;
|
2013-01-10 19:06:42 -08:00
|
|
|
|
|
|
|
if (r == 0)
|
2013-07-31 02:42:13 -07:00
|
|
|
r = b->engine->priority - a->engine->priority;
|
2013-01-10 19:06:42 -08:00
|
|
|
|
|
|
|
if (r == 0)
|
|
|
|
/* guarantee some order to ease debug */
|
2013-07-31 02:42:13 -07:00
|
|
|
r = strcmp(b->engine->name, a->engine->name);
|
2013-01-10 19:06:42 -08:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-01-10 14:11:07 -08:00
|
|
|
static void
|
2013-01-11 21:19:46 -08:00
|
|
|
_emotion_modules_load(void)
|
2013-01-10 14:11:07 -08:00
|
|
|
{
|
|
|
|
char buf[PATH_MAX];
|
|
|
|
|
2013-01-11 21:19:46 -08:00
|
|
|
if (_emotion_modules_loaded) return;
|
|
|
|
_emotion_modules_loaded = EINA_TRUE;
|
|
|
|
|
2017-02-03 05:49:38 -08:00
|
|
|
#ifdef NEED_RUN_IN_TREE
|
2014-01-08 05:06:41 -08:00
|
|
|
#if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
|
|
|
|
if (getuid() == geteuid())
|
|
|
|
#endif
|
2013-01-10 14:11:07 -08:00
|
|
|
{
|
2014-01-08 02:46:23 -08:00
|
|
|
if (getenv("EFL_RUN_IN_TREE"))
|
2013-01-10 14:11:07 -08:00
|
|
|
{
|
2014-01-08 02:46:23 -08:00
|
|
|
struct stat st;
|
|
|
|
snprintf(buf, sizeof(buf), "%s/src/modules/emotion",
|
|
|
|
PACKAGE_BUILD_DIR);
|
|
|
|
if (stat(buf, &st) == 0)
|
|
|
|
{
|
|
|
|
const char *built_modules[] = {
|
2014-08-21 08:00:21 -07:00
|
|
|
"gstreamer1",
|
2014-01-08 02:46:23 -08:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
const char **itr;
|
|
|
|
for (itr = built_modules; *itr != NULL; itr++)
|
|
|
|
{
|
2018-08-13 06:57:47 -07:00
|
|
|
Eina_Module *m;
|
2018-02-12 09:38:34 -08:00
|
|
|
bs_mod_get(buf, sizeof(buf), "emotion", *itr);
|
2018-08-13 06:57:47 -07:00
|
|
|
m = eina_module_new(buf);
|
|
|
|
|
|
|
|
if (!m) continue;
|
|
|
|
|
|
|
|
if (!_emotion_modules)
|
|
|
|
_emotion_modules = eina_array_new(4);
|
|
|
|
eina_array_push(_emotion_modules, m);
|
2014-01-08 02:46:23 -08:00
|
|
|
}
|
|
|
|
return;
|
2013-01-10 14:11:07 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-02-03 05:49:38 -08:00
|
|
|
#endif
|
2013-01-10 14:11:07 -08:00
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "%s/emotion/modules", eina_prefix_lib_get(_emotion_pfx));
|
|
|
|
_emotion_modules = eina_module_arch_list_get(_emotion_modules, buf, MODULE_ARCH);
|
2013-12-27 00:14:02 -08:00
|
|
|
// no - this is dumb. load ALL modules we find - force ALL the code pages of
|
|
|
|
// every lib a module MAY depend on and need to execute some init code into
|
|
|
|
// memory even if we never use it? not a good idea! the point of modules was
|
|
|
|
// to avoid such cost until a module is EXPLICITLY asked for.
|
|
|
|
//load:
|
|
|
|
// if (_emotion_modules)
|
|
|
|
// eina_module_list_load(_emotion_modules);
|
|
|
|
//
|
|
|
|
// if (!_emotion_engine_registry)
|
|
|
|
// ERR("Couldn't find any emotion engine.");
|
2013-01-11 09:41:53 -08:00
|
|
|
}
|
|
|
|
|
2013-01-10 14:11:07 -08:00
|
|
|
Eina_Bool
|
|
|
|
emotion_modules_init(void)
|
|
|
|
{
|
2020-04-24 00:35:31 -07:00
|
|
|
#if defined(EMOTION_STATIC_BUILD_GSTREAMER1)
|
2013-01-11 21:19:46 -08:00
|
|
|
gstreamer_module_init();
|
2013-01-10 14:11:07 -08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_modules_shutdown(void)
|
|
|
|
{
|
2013-01-10 19:06:42 -08:00
|
|
|
Emotion_Engine_Registry_Entry *re;
|
|
|
|
|
2020-04-24 00:35:31 -07:00
|
|
|
#if defined(EMOTION_STATIC_BUILD_GSTREAMER1)
|
2013-01-10 14:11:07 -08:00
|
|
|
gstreamer_module_shutdown();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (_emotion_modules)
|
|
|
|
{
|
|
|
|
eina_module_list_free(_emotion_modules);
|
|
|
|
eina_array_free(_emotion_modules);
|
|
|
|
_emotion_modules = NULL;
|
|
|
|
}
|
2013-01-11 09:41:53 -08:00
|
|
|
|
2013-01-11 17:08:14 -08:00
|
|
|
EINA_LIST_FREE(_emotion_engine_registry, re)
|
|
|
|
{
|
|
|
|
WRN("Engine was not unregistered: %p", re->engine);
|
|
|
|
_emotion_engine_registry_entry_free(re);
|
|
|
|
}
|
|
|
|
|
2013-01-11 09:41:53 -08:00
|
|
|
_emotion_modules_loaded = EINA_FALSE;
|
2013-01-10 14:11:07 -08:00
|
|
|
}
|
2013-01-10 14:17:32 -08:00
|
|
|
|
emotion: emotion EAPI macro to EMOTION_API in Emotion library
Summary:
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.
= The Rationale =
EAPI was designed to be able to pass
`__attribute__ ((visibility ("default")))` for symbols with
GCC, which would mean that even if -fvisibility=hidden was used
when compiling the library, the needed symbols would get exported.
MSVC __almost__ works like GCC (or mingw) in which you can
declare everything as export and it will just work (slower, but
it will work). But there's a caveat: global variables will not
work the same way for MSVC, but works for mingw and GCC.
For global variables (as opposed to functions), MSVC requires
correct DSO visibility for MSVC: instead of declaring a symbol as
export for everything, you need to declare it as import when
importing from another DSO and export when defining it locally.
With current EAPI definitions, we get the following example
working in mingw and MSVC (observe it doesn't define any global
variables as exported symbols).
Example 1:
dll1:
```
EAPI void foo(void);
EAPI void bar()
{
foo();
}
```
dll2:
```
EAPI void foo()
{
printf ("foo\n");
}
```
This works fine with API defined as __declspec(dllexport) in both
cases and for gcc defining as
`__atttribute__((visibility("default")))`.
However, the following:
Example 2:
dll1:
```
EAPI extern int foo;
EAPI void foobar(void);
EAPI void bar()
{
foo = 5;
foobar();
}
```
dll2:
```
EAPI int foo = 0;
EAPI void foobar()
{
printf ("foo %d\n", foo);
}
```
This will work on mingw but will not work for MSVC. And that's why
EAPI is the only solution that worked for MSVC.
Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Reviewers: vtorri, woohyun, jptiz, lucas
Reviewed By: vtorri, lucas
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D12227
2021-01-11 02:31:30 -08:00
|
|
|
EMOTION_API Eina_Bool
|
2013-01-10 19:06:42 -08:00
|
|
|
_emotion_module_register(const Emotion_Engine *api)
|
2013-01-10 14:17:32 -08:00
|
|
|
{
|
2013-01-10 19:06:42 -08:00
|
|
|
Emotion_Engine_Registry_Entry *re;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(api, EINA_FALSE);
|
|
|
|
|
|
|
|
if (api->version != EMOTION_ENGINE_API_VERSION)
|
|
|
|
{
|
|
|
|
ERR("Module '%p' uses api version=%u while %u was expected",
|
|
|
|
api, api->version, EMOTION_ENGINE_API_VERSION);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(api->name, EINA_FALSE);
|
|
|
|
|
|
|
|
INF("register name=%s, version=%u, priority=%d, api=%p",
|
|
|
|
api->name, api->version, api->priority, api);
|
2013-01-10 14:17:32 -08:00
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
re = calloc(1, sizeof(Emotion_Engine_Registry_Entry));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(re, EINA_FALSE);
|
2013-01-10 14:17:32 -08:00
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
re->engine = api;
|
|
|
|
re->priority = api->priority; // TODO: use user-priority from file as weel.
|
2013-01-10 14:17:32 -08:00
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
_emotion_engine_registry = eina_list_sorted_insert
|
|
|
|
(_emotion_engine_registry, _emotion_engine_registry_entry_cmp, re);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
2013-01-10 14:17:32 -08:00
|
|
|
}
|
|
|
|
|
emotion: emotion EAPI macro to EMOTION_API in Emotion library
Summary:
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.
= The Rationale =
EAPI was designed to be able to pass
`__attribute__ ((visibility ("default")))` for symbols with
GCC, which would mean that even if -fvisibility=hidden was used
when compiling the library, the needed symbols would get exported.
MSVC __almost__ works like GCC (or mingw) in which you can
declare everything as export and it will just work (slower, but
it will work). But there's a caveat: global variables will not
work the same way for MSVC, but works for mingw and GCC.
For global variables (as opposed to functions), MSVC requires
correct DSO visibility for MSVC: instead of declaring a symbol as
export for everything, you need to declare it as import when
importing from another DSO and export when defining it locally.
With current EAPI definitions, we get the following example
working in mingw and MSVC (observe it doesn't define any global
variables as exported symbols).
Example 1:
dll1:
```
EAPI void foo(void);
EAPI void bar()
{
foo();
}
```
dll2:
```
EAPI void foo()
{
printf ("foo\n");
}
```
This works fine with API defined as __declspec(dllexport) in both
cases and for gcc defining as
`__atttribute__((visibility("default")))`.
However, the following:
Example 2:
dll1:
```
EAPI extern int foo;
EAPI void foobar(void);
EAPI void bar()
{
foo = 5;
foobar();
}
```
dll2:
```
EAPI int foo = 0;
EAPI void foobar()
{
printf ("foo %d\n", foo);
}
```
This will work on mingw but will not work for MSVC. And that's why
EAPI is the only solution that worked for MSVC.
Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Reviewers: vtorri, woohyun, jptiz, lucas
Reviewed By: vtorri, lucas
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D12227
2021-01-11 02:31:30 -08:00
|
|
|
EMOTION_API Eina_Bool
|
2013-01-10 19:06:42 -08:00
|
|
|
_emotion_module_unregister(const Emotion_Engine *api)
|
2013-01-10 14:17:32 -08:00
|
|
|
{
|
2013-01-10 19:06:42 -08:00
|
|
|
Eina_List *n;
|
|
|
|
Emotion_Engine_Registry_Entry *re;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(api, EINA_FALSE);
|
|
|
|
if (api->version != EMOTION_ENGINE_API_VERSION)
|
|
|
|
{
|
|
|
|
ERR("Module '%p' uses api version=%u while %u was expected",
|
|
|
|
api, api->version, EMOTION_ENGINE_API_VERSION);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
INF("unregister name=%s, api=%p", api->name, api);
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(_emotion_engine_registry, n, re)
|
|
|
|
{
|
|
|
|
if (re->engine == api)
|
|
|
|
{
|
|
|
|
_emotion_engine_registry_entry_free(re);
|
|
|
|
_emotion_engine_registry = eina_list_remove_list
|
|
|
|
(_emotion_engine_registry, n);
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ERR("module not registered name=%s, api=%p", api->name, api);
|
|
|
|
return EINA_FALSE;
|
2013-01-10 14:17:32 -08:00
|
|
|
}
|
2013-01-10 16:27:35 -08:00
|
|
|
|
|
|
|
struct _Emotion_Engine_Instance
|
|
|
|
{
|
2013-01-10 19:06:42 -08:00
|
|
|
const Emotion_Engine *api;
|
2013-01-10 16:27:35 -08:00
|
|
|
Evas_Object *obj;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define EMOTION_ENGINE_INSTANCE_CHECK(inst, meth, ...) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
if (!inst) \
|
|
|
|
{ \
|
|
|
|
DBG("no instance to call "#meth); \
|
|
|
|
return __VA_ARGS__; \
|
|
|
|
} \
|
|
|
|
if (!inst->api->meth) \
|
|
|
|
{ \
|
|
|
|
DBG("no "#meth" in instance=%p", inst); \
|
|
|
|
return __VA_ARGS__; \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
while (0)
|
|
|
|
|
|
|
|
#define EMOTION_ENGINE_INSTANCE_CALL(inst, meth, ...) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
EMOTION_ENGINE_INSTANCE_CHECK(inst, meth); \
|
|
|
|
inst->api->meth(inst->data, ## __VA_ARGS__); \
|
|
|
|
} \
|
|
|
|
while (0)
|
|
|
|
|
|
|
|
#define EMOTION_ENGINE_INSTANCE_CALL_RET(inst, meth, retval, ...) \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
EMOTION_ENGINE_INSTANCE_CHECK(inst, meth, retval); \
|
|
|
|
return inst->api->meth(inst->data, ## __VA_ARGS__); \
|
|
|
|
} \
|
|
|
|
while (0)
|
|
|
|
|
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
static const Emotion_Engine *
|
|
|
|
_emotion_engine_registry_find(const char *name)
|
|
|
|
{
|
|
|
|
const Eina_List *n;
|
|
|
|
const Emotion_Engine_Registry_Entry *re;
|
|
|
|
EINA_LIST_FOREACH(_emotion_engine_registry, n, re)
|
|
|
|
{
|
|
|
|
if (strcmp(re->engine->name, name) == 0)
|
|
|
|
return re->engine;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Emotion_Engine_Instance *
|
|
|
|
_emotion_engine_instance_new(const Emotion_Engine *engine, Evas_Object *obj, void *data)
|
|
|
|
{
|
|
|
|
Emotion_Engine_Instance *inst = calloc(1, sizeof(Emotion_Engine_Instance));
|
|
|
|
EINA_SAFETY_ON_NULL_GOTO(inst, error);
|
|
|
|
inst->api = engine;
|
|
|
|
inst->obj = obj;
|
|
|
|
inst->data = data;
|
|
|
|
return inst;
|
|
|
|
|
|
|
|
error:
|
|
|
|
engine->del(data);
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-01-10 16:27:35 -08:00
|
|
|
|
2013-12-27 00:14:02 -08:00
|
|
|
static Eina_Module *
|
|
|
|
_find_mod(const char *name)
|
|
|
|
{
|
|
|
|
Eina_Array_Iterator iterator;
|
|
|
|
Eina_Module *m;
|
|
|
|
unsigned int i;
|
|
|
|
int inlen;
|
|
|
|
|
2014-04-01 23:18:46 -07:00
|
|
|
if (!name || !_emotion_modules) return NULL;
|
2013-12-27 00:14:02 -08:00
|
|
|
inlen = strlen(name);
|
|
|
|
EINA_ARRAY_ITER_NEXT(_emotion_modules, i, m, iterator)
|
|
|
|
{
|
|
|
|
const char *path = eina_module_file_get(m);
|
2018-08-13 06:57:47 -07:00
|
|
|
const char *p, *p1, *p2, *p3;
|
|
|
|
int found, len, len2;
|
2013-12-27 00:14:02 -08:00
|
|
|
|
|
|
|
if ((!path) || (!path[0])) continue;
|
|
|
|
// path is /*/modulename/ARCH/module.* - we want "modulename"
|
|
|
|
found = 0;
|
2018-11-08 07:14:01 -08:00
|
|
|
p1 = p2 = p3 = NULL;
|
2013-12-27 00:14:02 -08:00
|
|
|
for (p = path + strlen(path) - 1;
|
|
|
|
p > path;
|
|
|
|
p--)
|
|
|
|
{
|
2019-09-04 08:39:02 -07:00
|
|
|
if ((*p == '/')
|
|
|
|
/* FIXME : find a better way to handle Windows path in all the EFL */
|
|
|
|
#ifdef _WIN32
|
|
|
|
|| (*p == '\\')
|
|
|
|
#endif
|
|
|
|
)
|
2013-12-27 00:14:02 -08:00
|
|
|
{
|
|
|
|
found++;
|
|
|
|
// found == 1 -> p = /module.*
|
|
|
|
// found == 2 -> p = /ARCH/module.*
|
|
|
|
// found == 3 -> p = /modulename/ARCH/module.*
|
2018-08-13 06:57:47 -07:00
|
|
|
if (found == 1) p3 = p;
|
2013-12-27 00:14:02 -08:00
|
|
|
if (found == 2) p2 = p;
|
|
|
|
if (found == 3)
|
|
|
|
{
|
|
|
|
p1 = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (p1)
|
|
|
|
{
|
|
|
|
p1++;
|
|
|
|
len = p2 - p1;
|
2018-08-13 06:57:47 -07:00
|
|
|
len2 = p3 - (p2 + 1);
|
|
|
|
if (len == inlen || len2 == inlen)
|
2013-12-27 00:14:02 -08:00
|
|
|
{
|
2018-08-13 06:57:47 -07:00
|
|
|
if (!strncmp(p1, name, len) || !strncmp(p2 + 1, name, len2)) return m;
|
2013-12-27 00:14:02 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-01-10 16:27:35 -08:00
|
|
|
Emotion_Engine_Instance *
|
|
|
|
emotion_engine_instance_new(const char *name, Evas_Object *obj, Emotion_Module_Options *opts)
|
|
|
|
{
|
2013-01-10 19:06:42 -08:00
|
|
|
const Eina_List *n;
|
|
|
|
const Emotion_Engine_Registry_Entry *re;
|
|
|
|
const Emotion_Engine *engine;
|
|
|
|
void *data;
|
2013-12-27 00:14:02 -08:00
|
|
|
Eina_Module *m;
|
2018-01-04 07:10:38 -08:00
|
|
|
char *disp = NULL;
|
2013-01-10 16:27:35 -08:00
|
|
|
|
2013-01-11 09:41:53 -08:00
|
|
|
_emotion_modules_load();
|
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
if ((!name) && getenv("EMOTION_ENGINE"))
|
2013-01-10 16:27:35 -08:00
|
|
|
{
|
|
|
|
name = getenv("EMOTION_ENGINE");
|
|
|
|
DBG("using EMOTION_ENGINE=%s", name);
|
|
|
|
}
|
|
|
|
|
2018-01-04 07:10:38 -08:00
|
|
|
if (getenv("WAYLAND_DISPLAY"))
|
|
|
|
{
|
|
|
|
disp = eina_strdup(getenv("DISPLAY"));
|
|
|
|
unsetenv("DISPLAY");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-27 00:14:02 -08:00
|
|
|
if (name)
|
|
|
|
{
|
|
|
|
m = _find_mod(name);
|
2016-08-07 22:49:35 -07:00
|
|
|
if (m)
|
|
|
|
{
|
|
|
|
if (!eina_module_load(m))
|
|
|
|
ERR("Cannot load module %s", eina_module_file_get(m));
|
|
|
|
}
|
2013-12-27 00:14:02 -08:00
|
|
|
}
|
2014-04-20 06:58:47 -07:00
|
|
|
|
|
|
|
if (!_emotion_engine_registry)
|
2013-12-27 00:14:02 -08:00
|
|
|
{
|
2020-04-24 00:35:31 -07:00
|
|
|
m = _find_mod("gstreamer1");
|
2016-08-07 22:49:35 -07:00
|
|
|
if (!eina_module_load(m))
|
|
|
|
ERR("Cannot load module %s", eina_module_file_get(m));
|
2013-12-27 00:14:02 -08:00
|
|
|
}
|
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
if (name)
|
2013-01-10 16:27:35 -08:00
|
|
|
{
|
2013-01-10 19:06:42 -08:00
|
|
|
engine = _emotion_engine_registry_find(name);
|
|
|
|
if (!engine)
|
|
|
|
ERR("Couldn't find requested engine: %s. Try fallback", name);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data = engine->add(engine, obj, opts);
|
|
|
|
if (data)
|
|
|
|
{
|
|
|
|
INF("Using requested engine %s, data=%p", name, data);
|
2018-01-04 07:10:38 -08:00
|
|
|
if (disp) setenv("DISPLAY", disp, 1);
|
|
|
|
free(disp);
|
2013-01-10 19:06:42 -08:00
|
|
|
return _emotion_engine_instance_new(engine, obj, data);
|
|
|
|
}
|
2013-01-10 16:27:35 -08:00
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
ERR("Requested engine '%s' could not be used. Try fallback", name);
|
|
|
|
}
|
2013-01-10 16:27:35 -08:00
|
|
|
}
|
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
EINA_LIST_FOREACH(_emotion_engine_registry, n, re)
|
2013-01-10 16:27:35 -08:00
|
|
|
{
|
2013-01-10 19:06:42 -08:00
|
|
|
engine = re->engine;
|
|
|
|
DBG("Trying engine %s, priority=%d (%d)",
|
|
|
|
engine->name, re->priority, engine->priority);
|
2013-01-10 16:27:35 -08:00
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
data = engine->add(engine, obj, opts);
|
|
|
|
if (data)
|
|
|
|
{
|
|
|
|
INF("Using fallback engine %s, data=%p", engine->name, data);
|
2018-01-04 07:10:38 -08:00
|
|
|
if (disp) setenv("DISPLAY", disp, 1);
|
|
|
|
free(disp);
|
2013-01-10 19:06:42 -08:00
|
|
|
return _emotion_engine_instance_new(engine, obj, data);
|
|
|
|
}
|
|
|
|
}
|
2013-01-10 16:27:35 -08:00
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
ERR("No engine worked");
|
2018-01-04 07:10:38 -08:00
|
|
|
if (disp) setenv("DISPLAY", disp, 1);
|
|
|
|
free(disp);
|
2013-01-10 16:27:35 -08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_del(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN(inst);
|
2013-01-10 19:06:42 -08:00
|
|
|
inst->api->del(inst->data);
|
2014-04-01 02:59:16 -07:00
|
|
|
free(inst);
|
2013-01-10 16:27:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_name_equal(const Emotion_Engine_Instance *inst, const char *name)
|
|
|
|
{
|
|
|
|
/* these are valid, no safety macros here */
|
|
|
|
if (!name) return EINA_FALSE;
|
|
|
|
if (!inst) return EINA_FALSE;
|
2013-01-10 19:06:42 -08:00
|
|
|
return strcmp(name, inst->api->name) == 0;
|
2013-01-10 16:27:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void *
|
|
|
|
emotion_engine_instance_data_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(inst, NULL);
|
|
|
|
return inst->data;
|
|
|
|
}
|
|
|
|
|
2013-01-10 19:06:42 -08:00
|
|
|
Eina_Bool
|
2013-01-10 16:27:35 -08:00
|
|
|
emotion_engine_instance_file_open(Emotion_Engine_Instance *inst, const char *file)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CHECK(inst, file_open, EINA_FALSE);
|
2013-01-10 19:06:42 -08:00
|
|
|
return inst->api->file_open(inst->data, file);
|
2013-01-10 16:27:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_file_close(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, file_close);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_play(Emotion_Engine_Instance *inst, double pos)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, play, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_stop(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, stop);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_size_get(const Emotion_Engine_Instance *inst, int *w, int *h)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, size_get, w, h);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_pos_set(Emotion_Engine_Instance *inst, double pos)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, pos_set, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
emotion_engine_instance_len_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, len_get, 0.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
emotion_engine_instance_buffer_size_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, buffer_size_get, 1.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_fps_num_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, fps_num_get, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_fps_den_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, fps_den_get, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
emotion_engine_instance_fps_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, fps_get, 1.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
emotion_engine_instance_pos_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, pos_get, 0.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_vis_set(Emotion_Engine_Instance *inst, Emotion_Vis vis)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, vis_set, vis);
|
|
|
|
}
|
|
|
|
|
|
|
|
Emotion_Vis
|
|
|
|
emotion_engine_instance_vis_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, vis_get, EMOTION_VIS_NONE);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_vis_supported(Emotion_Engine_Instance *inst, Emotion_Vis vis)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, vis_supported, EINA_FALSE, vis);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
emotion_engine_instance_ratio_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, ratio_get, 0.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_video_handled(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, video_handled, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_audio_handled(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, audio_handled, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_seekable(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, seekable, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_frame_done(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, frame_done);
|
|
|
|
}
|
|
|
|
|
|
|
|
Emotion_Format
|
|
|
|
emotion_engine_instance_format_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, format_get, EMOTION_FORMAT_NONE);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-04-17 15:06:28 -07:00
|
|
|
emotion_engine_instance_video_data_size_get(const Emotion_Engine_Instance *inst, int *w, int *h)
|
2013-01-10 16:27:35 -08:00
|
|
|
{
|
2017-04-17 15:06:28 -07:00
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, video_data_size_get, w, h);
|
2013-01-10 16:27:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_yuv_rows_get(const Emotion_Engine_Instance *inst, int w, int h, unsigned char **yrows, unsigned char **urows, unsigned char **vrows)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, yuv_rows_get, EINA_FALSE, w, h, yrows, urows, vrows);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_bgra_data_get(const Emotion_Engine_Instance *inst, unsigned char **bgra_data)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, bgra_data_get, EINA_FALSE, bgra_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_event_feed(Emotion_Engine_Instance *inst, int event)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, event_feed, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_event_mouse_button_feed(Emotion_Engine_Instance *inst, int button, int x, int y)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, event_mouse_button_feed, button, x, y);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_event_mouse_move_feed(Emotion_Engine_Instance *inst, int x, int y)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, event_mouse_move_feed, x, y);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_video_channel_count(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, video_channel_count, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_video_channel_set(Emotion_Engine_Instance *inst, int channel)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, video_channel_set, channel);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_video_channel_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, video_channel_get, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_video_subtitle_file_set(Emotion_Engine_Instance *inst, const char *filepath)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, video_subtitle_file_set, filepath);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
emotion_engine_instance_video_subtitle_file_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, video_subtitle_file_get, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
emotion_engine_instance_video_channel_name_get(const Emotion_Engine_Instance *inst, int channel)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, video_channel_name_get, NULL, channel);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_video_channel_mute_set(Emotion_Engine_Instance *inst, Eina_Bool mute)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, video_channel_mute_set, mute);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_video_channel_mute_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, video_channel_mute_get, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_audio_channel_count(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, audio_channel_count, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_audio_channel_set(Emotion_Engine_Instance *inst, int channel)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, audio_channel_set, channel);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_audio_channel_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, audio_channel_get, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
emotion_engine_instance_audio_channel_name_get(const Emotion_Engine_Instance *inst, int channel)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, audio_channel_name_get, NULL, channel);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_audio_channel_mute_set(Emotion_Engine_Instance *inst, Eina_Bool mute)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, audio_channel_mute_set, mute);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_audio_channel_mute_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, audio_channel_mute_get, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_audio_channel_volume_set(Emotion_Engine_Instance *inst, double vol)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, audio_channel_volume_set, vol);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
emotion_engine_instance_audio_channel_volume_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, audio_channel_volume_get, 0.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_spu_channel_count(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, spu_channel_count, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_spu_channel_set(Emotion_Engine_Instance *inst, int channel)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, spu_channel_set, channel);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_spu_channel_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, spu_channel_get, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
emotion_engine_instance_spu_channel_name_get(const Emotion_Engine_Instance *inst, int channel)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, spu_channel_name_get, NULL, channel);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_spu_channel_mute_set(Emotion_Engine_Instance *inst, Eina_Bool mute)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, spu_channel_mute_set, mute);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_spu_channel_mute_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, spu_channel_mute_get, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_chapter_count(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, chapter_count, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_chapter_set(Emotion_Engine_Instance *inst, int chapter)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, chapter_set, chapter);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
emotion_engine_instance_chapter_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, chapter_get, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
emotion_engine_instance_chapter_name_get(const Emotion_Engine_Instance *inst, int chapter)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, chapter_name_get, NULL, chapter);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
emotion_engine_instance_speed_set(Emotion_Engine_Instance *inst, double speed)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, speed_set, speed);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
emotion_engine_instance_speed_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, speed_get, 0.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_eject(Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, eject, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
emotion_engine_instance_meta_get(const Emotion_Engine_Instance *inst, int meta)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, meta_get, NULL, meta);
|
|
|
|
}
|
|
|
|
|
2017-01-12 14:09:49 -08:00
|
|
|
void *
|
|
|
|
emotion_engine_instance_meta_artwork_get(const Emotion_Engine_Instance *inst, Evas_Object *img, const char *path, Emotion_Artwork_Info type)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, meta_artwork_get, NULL, img, path, type);
|
|
|
|
}
|
|
|
|
|
2013-01-10 16:27:35 -08:00
|
|
|
void
|
|
|
|
emotion_engine_instance_priority_set(Emotion_Engine_Instance *inst, Eina_Bool priority)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL(inst, priority_set, priority);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
emotion_engine_instance_priority_get(const Emotion_Engine_Instance *inst)
|
|
|
|
{
|
|
|
|
EMOTION_ENGINE_INSTANCE_CALL_RET(inst, priority_get, EINA_FALSE);
|
|
|
|
}
|