Compare commits

...

88 Commits

Author SHA1 Message Date
João Paulo Taylor Ienczak Zanette 9031750e62 efl: Make lua support optional 2021-01-31 11:40:45 -03:00
João Paulo Taylor Ienczak Zanette e92f822fc8 emile: make emile optional 2021-01-06 14:20:16 -03:00
João Paulo Taylor Ienczak Zanette dd7fd87acc efreet: make efreet optional
Summary:
Not everyone has a system or libraries that need to conform with
Freedesktop standards, making efreet not necessary on them.

This patch solves this by making efreet an optional library.

Test Plan:
`meson test -C build` + run edje, evas and elementary examples to
see if nothing got weird.

Ref T8814

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Maniphest Tasks: T8814

Differential Revision: https://phab.enlightenment.org/D12151
2021-01-06 13:49:50 -03:00
Lucas f7c9d19d34 ethumb: Make ethumb optional
This commit is based on 748e89e703 with a small change to compile in
Linux.

Original changes:
- ethumb(_client) depend on `ethumb` option
- Remove ethumb(_client) from ignored subprojects
- Remove ethumb_client from default elementary dependencies
Additional changes:
- Surround `_elm_unneed_ethumb();` call in
  `src/lib/elementary/elm_main.c` with `#ifdef HAVE_ETHUMB`.

Co-authored-by: Felipe Magno de Almeida <felipe@expertise.dev>
2021-01-06 13:49:44 -03:00
Wander Lairson Costa 6bc4748657 eina: Implement Eina_Thread for native windows
The implementation design respects the fact that Eina_Thread is an
uintptr_t. Thus we allocate the thread struct in the heap and return a
pointer to it.

As such, we store the created thread structure in the target thread
TLS slot. For threads that were not created through eina API, in
eina_thread_self we allocate a new structure, push it to the TLS slot
and mark it to be freed on thread exit.

Reviewers: jptiz, walac, vtorri, woohyun, lucas

Reviewed By: jptiz, cedric

Subscribers: raster, cedric, #reviewers, #committers, lucas

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12037
2020-12-15 17:20:24 -03:00
Felipe Magno de Almeida 886723d47b eina: Add eina_fnmatch win32 implementation 2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida 1bd1c85a67 windows: Fix use of S_ISREG and S_ISDIR in windows code 2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida 7799e18953 windows: Do not use S_ISREG in windows platform 2020-12-15 16:10:26 -03:00
João Antônio Cardoso 6237e6f9bf win32: Fix IF_S* macros
Since S_IFBLK, S_IFSOCK and S_IFLNK are not defined by ucrt because
they make no sense for windows, we can just remove those definitions
from efl sources when compiling for windows.
2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida 39c77ec590 evil: Add stat constants not defined in MSVC's runtime 2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida d0d660ec29 evil: Add ssize_t typedef for MSVC compatibility 2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida d241b225c1 evil: Add mode_t typedef for MSVC compatibility 2020-12-15 16:10:26 -03:00
Lucas b0fbb10208 evil: Define file creation flags and file status flags for fcntl
UCRT `fcntl.h` already define those as `_<FLAG>` and by defining
`_CRT_DECLARE_NONSTDC_NAMES` it does a `#define _<FLAG> <FLAG>` making
them available the way a POSIX system expects.
2020-12-15 16:10:26 -03:00
Cauê Baasch de Souza edb195cfd2 evil: Implement ftruncate
Create POSIX-compliant ftruncate with tests.
2020-12-15 16:10:26 -03:00
Lucas 38a94040a2 evil: Implement evil_localtime_r using localtime
Implements `evil_localtime_r` using win32 [localtime
function](https://docs.microsoft.com/pt-br/cpp/c-runtime-library/reference/localtime-localtime32-localtime64?view=vs-2019).
If `HAVE_lOCALTIME_R` is not defined, define `localtime_r`
as `evil_localtime_r`

Co-authored-by: Felipe Magno de Almeida <felipe@expertise.dev>
2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida 9407a5fe76 evil: Add STDIO FILENO macros for compatibility with MSVC 2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida 191cb43c81 evil: Add mkstemp macro for MSVC compatibility 2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida 733420f799 evil: Fix adding EVIL_API macro to mkstemps 2020-12-15 16:10:26 -03:00
Felipe Magno de Almeida 81a1b4eac3 evil: Add execvp based on UCRT's _execvp 2020-12-15 16:10:26 -03:00
João Paulo Taylor Ienczak Zanette 04a25307c5 eina: Fix evil and Windows #include's 2020-12-15 16:10:26 -03:00
Lucas c6c7f7153e eina: Create eina_pipe abstraction for Windows compatibility 2020-12-15 16:10:21 -03:00
Felipe Magno de Almeida d07296f618 eina: Add EINA_HOT and EINA_COLD macros for visual studio 2020-12-14 13:59:16 -03:00
Lucas Cavalcante de Sousa c5f80ad384 eina: Fixed undefined behavior usage of bitfields and enumerations
On Microsoft Visual Studio, enumerations are signed and consequently get sign-extended when used with bit-fields, which causes the number to become inadvertently negative.

I removed the undefined behavior use by defining explictly as a unsigned int, so it works on all platforms.
2020-12-14 13:52:59 -03:00
Lucas Cavalcante de Sousa 1e22a1b90b eina: Resolve string comparison from strerror_s when no code is returned
On Windows, `strerror_s` doesn't return the error code with the error
message string as `strerror_r` on Linux does. So we do not compare the
last space before the error code, comparing 13 characters instead of
14. Thus comparing for "Unknown error" correctly for all platforms.
2020-12-14 13:45:38 -03:00
João Antônio Cardoso abcb324c2d evil: Reimplement basename for windows considering possible reentrancy
Use thread local storage (TLS) to enable the usage with multiples threads
2020-12-14 13:41:04 -03:00
Felipe Magno de Almeida 7c74fc9b5f exactness: Use EXPORTAPI for symbols that will replace in library
We can export always because our declaration is always a definition in
exactness programs. So it doesn't make sense to condition on building
one library or another.

Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>
2020-12-14 13:29:16 -03:00
Felipe Magno de Almeida 2368d27089 eina: Use EXPORTAPI for macro EINA_MODINFO
The EINA_MODINFO must export the symbols in the current module, and it
is not used for importing symbols so we can use EXPORTAPI to export
without needing to know what is being built.

Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>
2020-12-14 13:27:53 -03:00
Felipe Magno de Almeida 300686e153 ecore_imf_evas: Rename EAPI macro to ECORE_IMF_EVAS_API in Ecore IMF Evas library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida 0dfc72d427 ecore_sdl: Rename EAPI macro to ECORE_SDL_API in Ecore SDL library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida 697724cd41 ecore_wayland: Rename EAPI macro to ECORE_WAYLAND_API in Ecore Wayland library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida 828474351a ecore_wl2: Rename EAPI macro to ECORE_WL2_API in Ecore WL2 library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida e0f550acb8 ethumb_client: Rename EAPI macro to ETHUMB_CLIENT_API in Ethumb Client library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida e294678ed5 ephysics: Rename EAPI macro to EPHYSICS_API in Ephysics library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida 8ba326b443 efl_canvas_wl: Rename EAPI macro to EFL_CANVAS_WL_API in Efl Canvas WL library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida d924100b42 ecore_input: Rename EAPI macro to ECORE_INPUT_API in Ecore Input library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida ff840ba26c ecore_buffer: Rename EAPI macro to ECORE_BUFFER_API in Ecore Buffer library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida d37234b2a4 ecore_cocoa: Rename EAPI macro to ECORE_COCOA_API in Ecore Cocoa library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:42 -03:00
Felipe Magno de Almeida caffa66952 ecore_evas: Rename EAPI macro to ECORE_EVAS_API in Ecore Evas library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.de>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 41cefb11a9 ecore_fb: Rename EAPI macro to ECORE_FB_API in Ecore FB library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida c3afa1cffe ecore_file: Rename EAPI macro to ECORE_FILE_API in Ecore File library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 150a00f92e ecore_imf: Rename EAPI macro to ECORE_IMF_API in Ecore IMF library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida cee432a2a3 ecore_input_evas: Rename EAPI macro to ECORE_INPUT_EVAS_API in Ecore Input Evas library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida b83e9567d9 ecore_ipc: Rename EAPI macro to ECORE_IPC_API in Ecore IPC library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida aec4e4c2cd eet: Rename EAPI macro to EET_API in Eet library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 9818a8105e efreet: Rename EAPI macro to EFREET_API in Efreet library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 21674baf68 ecore_win32: Rename EAPI macro to ECORE_WIN32_API in Ecore Win32 library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 1dba2f717a emile: Rename EAPI macro to EMILE_API in Emile library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 8306808aee eeze_api: Rename EAPI macro to EEZE_API in Eeze library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida d3c091366c elput: Rename EAPI macro to ELPUT_API in Elput library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida f1cf6466a5 elua: Rename EAPI macro to ELUA_API in Elua library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 371187cab1 embryo: Rename EAPI macro to EMBRYO_API in Embryo library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 9b3acd4209 ethumb: Rename EAPI macro to ETHUMB_API in Ethumb library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 55a1c1772f ecore_drm2: Rename EAPI macro to ECORE_DRM2_API in Ecore DRM2 library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 61da769307 ecore_avahi: Rename EAPI macro to ECORE_AVAHI_API in Ecore Avahi library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 9eff6d7cfa ecore_drm: Rename EAPI macro to ECORE_DRM_API in Ecore DRM library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 9acf600850 ecore_x: Rename EAPI macro to ECORE_X_API in Ecore X library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida 07240e0d41 edje_cxx: Remove useless EAPI definition
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida b8dccb3154 edje: Rename EAPI macro to EDJE_API in Edje library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:33 -03:00
Felipe Magno de Almeida dca12dc6b3 elementary: Rename EAPI macro to ELM_API in Elementary library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>
2020-12-14 13:22:22 -03:00
Felipe Magno de Almeida 08ba516b64 eina_cxx: Rename EAPI macro to EINA_CXX_TEST_API in Einna C++ tests
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:22 -03:00
Felipe Magno de Almeida e36de1c37c edje_cxx: Edje.hh depends on already set EAPI, explicitly define
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

So we can remove EAPI from other libraries, we need to make this
library non-dependent on this symbol being already defined.

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>
2020-12-14 13:22:22 -03:00
Felipe Magno de Almeida bb895cde36 modules: Rename EAPI macro to MODAPI for modules
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida bbd817c9a1 efl_mono: Rename EAPI macro to EFL_MONO_API in efl mono binding
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida 7df163582e edje: Add weak symbol
The symbols will be needed when we change how Eolian generates
import/export symbols in Eio
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida cc5bf64e66 elementary: Remove use of EOAPI that will get its definition removed
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida e00417edf4 efl: Rename EAPI macro to EFL_API in Efl sub-library
evil: Rename EAPI macro to EVIL_API in Evil library

Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida ea6f250683 ecore: Rename EAPI macro to ECORE_API in Ecore library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida 4bca3f7555 eldbus: Rename EAPI macro to ELDBUS_API in Eldbus library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida 05dba646ae emotion: emotion EAPI macro to EMOTION_API in Emotion library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida 6fbb5595ff ector: Rename EAPI macro to ECTOR_API in Ector library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida 98dcee2dd1 ecore_con: Rename EAPI macro to ECORE_CON_API in Ecore Con library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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>
2020-12-14 13:22:21 -03:00
Felipe Magno de Almeida 89b839600e evas: Rename EAPI macro to EVAS_API in Evas library
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>
2020-12-14 13:22:00 -03:00
Felipe Magno de Almeida 7ad0a1447f ecore_audio: Rename EAPI macro to ECORE_AUDIO_API in Ecore Audio library
Summary:
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12212
2020-12-14 12:34:23 -03:00
Felipe Magno de Almeida b495328a30 evil: Fix fcntl for F_SETLK and F_SETLKW wrong length calculation
Summary:
If length and start are both 0, size is wrongfully negative. Besides,
using length as a delimitator in a range means that [0, length) is a
half-closed interval, so we don't need to subtract by 1.

Reviewers: vtorri, woohyun, lucas, jptiz

Reviewed By: vtorri, lucas

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12208
2020-12-14 12:33:32 -03:00
Felipe Magno de Almeida f563b99917 eio: Rename EAPI macro to EIO_API in Eio library
Summary:
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>

Reviewers: vtorri, woohyun, lucas, jptiz

Reviewed By: vtorri, lucas

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12210
2020-12-14 12:33:32 -03:00
João Antônio Cardoso baa40d623a Fixing conversion from size_t to high-low dwords for _WIN64.
Reviewers: vtorri, woohyun, lucas, jptiz

Reviewed By: vtorri, jptiz

Subscribers: joaoantoniocardoso, cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12207
2020-12-14 12:33:32 -03:00
João Antônio Cardoso ccbce36d91 evil: Define environ macro when using VS based on UCRT definition
Summary:
Microsoft Visual Studio defines _environ, but not environ. Create
a macro #define environ _environ like other analogous solutions

Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>

Reviewers: vtorri, woohyun, joaoantoniocardoso, lucas, jptiz

Reviewed By: jptiz

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12209
2020-12-14 12:33:32 -03:00
Felipe Magno de Almeida eec1680b56 eo: Rename EAPI macro to EO_API in Eo library
Summary:
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>

Reviewers: jptiz, lucas, vtorri, woohyun

Reviewed By: jptiz, lucas, vtorri

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12203
2020-12-14 12:33:32 -03:00
Felipe Magno de Almeida d05157e96a eldbus: Add Eldbus.h include entry point header to eldbus_instrospection.h
Summary:
Add #include Eldbus.h so we can have EAPI definition for
eldbus_instrospection.h header

Reviewers: jptiz, lucas, vtorri, woohyun

Reviewed By: vtorri

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12202
2020-12-14 12:33:32 -03:00
Felipe Magno de Almeida d9dd85fec3 eio: Add weak symbol
Summary:
Add definition for EAPI_WEAK because this macro will be needed when we
change how Eolian generates import/export symbols for the Eio library.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>

Reviewers: jptiz, lucas, vtorri, woohyun

Reviewed By: vtorri

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12201
2020-12-14 12:33:32 -03:00
Felipe Magno de Almeida dfa446873e benchmark: Remove unnecessary import and export macros from benchmark executables
Summary:
Benchmark executables do not need to export and import symbols because
they are not loaded by other executables. Removing is important because
EAPI will be removed in some later commit and would break benchmark
executables.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>

Reviewers: vtorri, woohyun, jptiz, lucas

Reviewed By: vtorri

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12200
2020-12-14 12:33:32 -03:00
Felipe Magno de Almeida 25a1142493 eolian: Add -e parameter to pass export symbol to eolian generator
Summary:
Eolian generator must have a parameter so it can generate the correct
symbol export/import macro for the API generated.

This makes it possible to define the symbols as being local to a
single DSO without the need to guard the generated headers or
generated source files with #define and #undef preprocessor
statements.

=  The Rationale =

This patch is from a series of patches to rename EAPI symbols to
specific library DSOs.

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
LIBAPI is the only solution that works for MSVC.

Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com>
Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com>
Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev>

Reviewers: q66, vtorri, woohyun, jptiz, lucas

Reviewed By: vtorri, lucas

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12197
2020-12-14 12:33:32 -03:00
Felipe Magno de Almeida 35b7458832 eolian: Rename EAPI macro to EOLIAN_API in Eolian library
Summary:
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12196
2020-12-14 12:33:32 -03:00
Lucas Cavalcante de Sousa 567387aab0 efl_mono: Use architecture independent ECANCELED
Summary:
`efl_mono` was assuming ECANCELED as in Linux, which made some tests
fail.

`test_simple_futere_cancel` and `test_cancel_after_resolve` checks if
the returned error code is `ECANCELED` but `Eina.Error.ECANCELED` was
base on Linux `ECANCELED` which is diferent from OSX causing:
```
[ ERROR       ] AssertionException: /Users/lucas/expertise/efl1/src/tests/efl_mono/Promises.cs:138 (test_simple_future_cancel) Left hand side "Eina.Error(89)", right hand side "Eina.Error(125)"
at Test.AssertEquals[T](T lhs, T rhs, String msg, Int32 line, String file, String member) in /Users/lucas/expertise/efl1/src/tests/efl_mono/TestUtils.cs:line 73
at TestSuite.TestPromises.test_simple_future_cancel() in /Users/lucas/expertise/efl1/src/tests/efl_mono/Promises.cs:line 138
[        FAIL ] TestPromises.test_simple_future_cancel
```
```
[ ERROR       ] AssertionException: /Users/lucas/expertise/efl1/src/tests/efl_mono/Promises.cs:256 (test_cancel_after_resolve) Left hand side "Eina.Error(89)", right hand side "Eina.Error(125)"
at Test.AssertEquals[T](T lhs, T rhs, String msg, Int32 line, String file, String member) in /Users/lucas/expertise/efl1/src/tests/efl_mono/TestUtils.cs:line 73
at TestSuite.TestPromises.test_cancel_after_resolve() in /Users/lucas/expertise/efl1/src/tests/efl_mono/Promises.cs:line 256
[        FAIL ] TestPromises.test_cancel_after_resolve
```

And `iwraper.cs:WrapAssync` was only considering Linux `ECANCELED` thus causing
a rise of an `Efl.FutureException: Future failed` instead of the expected
`TaskCanceledException` making fail at `TestEoAsyncMethods.test_async_cancel`:
```
[ RUN         ] TestEoAsyncMethods.test_async_cancel
[ ERROR       ] AssertionException: Assertion failed: /Users/lucas/expertise/efl1/src/tests/efl_mono/EoPromises.cs:175 (test_async_cancel) AggregateException must have been TaskCanceledException
   at Test.Assert(Boolean res, String msg, Int32 line, String file, String member) in /Users/lucas/expertise/efl1/src/tests/efl_mono/TestUtils.cs:line 53
   at TestSuite.TestEoAsyncMethods.<>c.<test_async_cancel>b__1_0(Exception x) in /Users/lucas/expertise/efl1/src/tests/efl_mono/EoPromises.cs:line 175
   at System.AggregateException.Handle(Func`2 predicate)
   at TestSuite.TestEoAsyncMethods.test_async_cancel() in /Users/lucas/expertise/efl1/src/tests/efl_mono/EoPromises.cs:line 171
[        FAIL ] TestEoAsyncMethods.test_async_cancel
```

Depends on D12156

Test Plan:
Compare with master and note that with this diff all tests pass.
- Configure as especified by Enlightenment man page + `-Dbindigns=mono -Ddotnet=true`:
```
meson -Dsystemd=false -Dv4l2=false -Davahi=false -Deeze=false -Dx11=false -Dopengl=full -Dcocoa=true -Dnls=false -Demotion-loaders-disabler=gstreamer1,libvlc,xine -Decore-imf-loaders-disabler=scim,ibus -Dbindigns=cxx,mono -Ddotnet=true build
```
- Build normally
- Test `efl-mono-suite`

Reviewers: felipealmeida

Reviewed By: felipealmeida

Subscribers: ProhtMeyhet, cedric, #reviewers, #committers, woohyun

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12157
2020-12-14 12:33:32 -03:00
Lucas Cavalcante de Sousa cf5884de1b efl-mono: Correctly load dynamic libs for OSX
Summary:
OSX libs end with `.dylib`, so it made failed to load libs, for instance
dl name is `dl.dylib` making it unable to load as it was before
(`libdl.so`).

Test Plan:
Compare with master and note that this diff is able to fail on tests, and
not about importing libs.
- Configure as especified by Enlightenment man page + `-Dbindigns=mono -Ddotnet=true`:
```
meson -Dsystemd=false -Dv4l2=false -Davahi=false -Deeze=false -Dx11=false -Dopengl=full -Dcocoa=true -Dnls=false -Demotion-loaders-disabler=gstreamer1,libvlc,xine -Decore-imf-loaders-disabler=scim,ibus -Dbindigns=cxx,mono -Ddotnet=true --prefix=$PWD/prefix build
```
- Build normally
- Test `efl-mono-suite`

Reviewers: felipealmeida

Reviewed By: felipealmeida

Subscribers: stefan_schmidt, cedric, #reviewers, #committers, woohyun

Tags: #efl, #expertise_solutions

Differential Revision: https://phab.enlightenment.org/D12156
2020-12-14 12:33:32 -03:00
Felipe Magno de Almeida c4741a6f34 eina: Rename EAPI macro to EINA_API in Eina library
Summary:
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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: jptiz, lucas, woohyun, vtorri, raster

Reviewed By: jptiz, lucas, vtorri

Subscribers: ProhtMeyhet, cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12188
2020-12-14 12:33:27 -03:00
Felipe Magno de Almeida 7e5e14ed1e evil: Rename EAPI macro to EVIL_API in Evil library
Summary:
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

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: raster, vtorri, jptiz, lucas, woohyun

Reviewed By: vtorri, jptiz

Subscribers: ProhtMeyhet, cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12182
2020-12-14 12:33:22 -03:00
Felipe Magno de Almeida 1a7dccfcae evil: undef setlocale to avoid recursion
Summary:
evil_setlocale implementation must not call itself, so it must #undef
setlocale to avoid replacing with evil_setlocale.

Reviewers: vtorri, jptiz, lucas

Reviewed By: vtorri, jptiz

Subscribers: cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D12184
2020-12-14 11:39:25 -03:00
1561 changed files with 28158 additions and 26525 deletions

View File

@ -53,7 +53,8 @@ header_checks = [
'features.h',
'langinfo.h',
'locale.h',
'crt_externs.h'
'crt_externs.h',
'pthread.h',
]
#### The below is logically broken
@ -88,6 +89,7 @@ function_checks = [
['getxattr', ['sys/types.h', 'sys/xattr.h']],
['iconv', ['iconv.h']],
['listxattr', ['sys/types.h', 'sys/xattr.h']],
['localtime_r', ['time.h']],
['malloc_info', ['malloc.h']],
['malloc_usable_size', ['malloc.h']],
['mkdirat', ['sys/stat.h']],

View File

@ -261,47 +261,53 @@ ecore_evas_wayland_engine_include_dir = []
evas_static_list = []
luaold_interpreters = [
['lua', ['>=5.1.0', '<5.3.0']],
['lua51', ['>=5.1.0', '<5.2.0']],
['lua-5.1', ['>=5.1.0', '<5.2.0']],
['lua5.1', ['>=5.1.0', '<5.2.0']],
['lua52', ['>=5.2.0', '<5.3.0']],
['lua-5.2', ['>=5.2.0', '<5.3.0']],
['lua5.2', ['>=5.2.0', '<5.3.0']],
]
lua_pc_name = ''
have_elua = get_option('elua')
if get_option('lua-interpreter') == 'lua'
config_h.set('ENABLE_LUA_OLD', '1')
foreach l : luaold_interpreters
lua = dependency(l[0], version: l[1], required:false)
lua_pc_name = l[0]
if lua.found()
break
endif
endforeach
if not lua.found()
error('Lua not found')
endif
if have_elua
message('Using experimental Elua with interpreter support...')
endif
if get_option('lua-interpreter') == 'none'
lua_pc_name = []
lua = declare_dependency()
else
lua = dependency(get_option('lua-interpreter'))
lua_pc_name = 'luajit'
endif
config_h.set('HAVE_LUA', 1)
luaold_interpreters = [
['lua', ['>=5.1.0', '<5.3.0']],
['lua51', ['>=5.1.0', '<5.2.0']],
['lua-5.1', ['>=5.1.0', '<5.2.0']],
['lua5.1', ['>=5.1.0', '<5.2.0']],
['lua52', ['>=5.2.0', '<5.3.0']],
['lua-5.2', ['>=5.2.0', '<5.3.0']],
['lua5.2', ['>=5.2.0', '<5.3.0']],
]
if sys_osx and get_option('lua-interpreter') == 'luajit'
# luajit on macro is broken, this means we need to generate our own
# dependency with our arguments, a library later still needs to link to
# luajit for the pagesize argument thingy
lua = declare_dependency(
include_directories: include_directories(lua.get_pkgconfig_variable('includedir')),
link_args: ['-L' + lua.get_pkgconfig_variable('libdir'), '-l' + lua.get_pkgconfig_variable('libname')]
)
lua_pc_name = ''
if get_option('lua-interpreter') == 'lua'
config_h.set('ENABLE_LUA_OLD', '1')
foreach l : luaold_interpreters
lua = dependency(l[0], version: l[1], required:false)
lua_pc_name = l[0]
if lua.found()
break
endif
endforeach
if not lua.found()
error('Lua not found')
endif
if have_elua
message('Using experimental Elua with interpreter support...')
endif
else
lua = dependency(get_option('lua-interpreter'))
lua_pc_name = 'luajit'
endif
if sys_osx and get_option('lua-interpreter') == 'luajit'
# luajit on macro is broken, this means we need to generate our own
# dependency with our arguments, a library later still needs to link to
# luajit for the pagesize argument thingy
lua = declare_dependency(
include_directories: include_directories(lua.get_pkgconfig_variable('includedir')),
link_args: ['-L' + lua.get_pkgconfig_variable('libdir'), '-l' + lua.get_pkgconfig_variable('libname')]
)
endif
endif
subprojects = [
@ -311,8 +317,8 @@ subprojects = [
['eolian' ,[] , false, true, true, false, true, false, false, ['eina'], []],
['eo' ,[] , false, true, false, true, true, false, true, ['eina'], []],
['efl' ,[] , false, true, false, false, true, false, true, ['eo'], []],
['emile' ,[] , false, true, false, false, true, true, true, ['eina', 'efl'], ['lz4', 'rg_etc']],
['eet' ,[] , false, true, true, false, true, true, true, ['eina', 'emile', 'efl'], []],
['emile' ,['emile'] , false, true, false, false, true, true, true, ['eina', 'efl'], ['lz4', 'rg_etc']],
['eet' ,[] , false, true, true, false, true, true, true, ['eina', 'efl'], ['rg_etc']],
['ecore' ,[] , false, true, false, false, false, false, true, ['eina', 'eo', 'efl'], ['buildsystem']],
['eldbus' ,[] , false, true, true, false, true, true, true, ['eina', 'eo', 'efl'], []],
['ecore' ,[] , true, false, false, false, true, true, true, ['eina', 'eo', 'efl'], []], #ecores modules depend on eldbus
@ -334,20 +340,20 @@ subprojects = [
['ecore_drm2' ,['drm'] , false, true, false, false, false, false, true, ['ecore'], ['libdrm']],
['ecore_cocoa' ,['cocoa'] , false, true, false, false, false, false, true, ['eina'], []],
['evas' ,[] , true, true, false, false, true, true, true, ['eina', 'efl', 'eo'], ['vg_common', 'libunibreak']],
['efreet' ,[] , false, true, false, false, true, false, true, ['eina', 'efl', 'eo'], []],
['efreet' ,['efreet'] , false, true, false, false, true, false, true, ['eina', 'efl', 'eo'], []],
['ecore_input_evas' ,[] , false, true, false, false, false, false, true, ['eina', 'evas'], []],
['ecore_evas' ,[] , true, true, true, false, false, false, true, ['evas', 'ector'], []],
['ecore_imf' ,[] , true, true, false, false, false, false, true, ['eina'], []],
['embryo' ,[] , false, true, true, false, false, false, true, ['eina', 'efl', 'eo'], []],
['eio' ,[] , false, true, false, false, true, true, true, ['eina', 'eet'], []],
['efreet' ,[] , false, false, true, false, false, false, true, ['eina', 'efl', 'eo'], []],
['efreet' ,['efreet'] , false, false, true, false, false, false, true, ['eina', 'efl', 'eo'], []],
['ecore_imf_evas' ,[] , false, true, false, false, false, false, true, ['eina', 'efl', 'eo'], []],
['ephysics' ,['physics'] , false, true, false, false, false, false, true, ['eina', 'efl', 'eo'], []],
['edje' ,[] , false, true, true, false, true, true, true, ['evas', 'eo', 'efl', lua_pc_name], []],
['emotion' ,[] , true, true, false, false, true, true, true, ['eina', 'efl', 'eo'], []],
['ethumb' ,[] , true, true, true, false, false, false, true, ['eina', 'efl', 'eo'], []],
['ethumb_client' ,[] , false, true, true, false, false, true, true, ['eina', 'efl', 'eo', 'ethumb'], []],
['elementary' ,[] , true, true, true, true, true, true, true, ['eina', 'efl', 'eo', 'eet', 'evas', 'ecore', 'ecore-evas', 'ecore-file', 'ecore-input', 'edje', 'ethumb-client', 'emotion', 'ecore-imf', 'ecore-con', 'eldbus', 'efreet', 'efreet-mime', 'efreet-trash', 'eio'], ['atspi']],
['ethumb' ,['ethumb'] , true, true, true, false, false, false, true, ['eina', 'efl', 'eo'], []],
['ethumb_client' ,['ethumb'] , false, true, true, false, false, true, true, ['eina', 'efl', 'eo', 'ethumb'], []],
['elementary' ,[] , true, true, true, true, true, true, true, ['eina', 'efl', 'eo', 'eet', 'evas', 'ecore', 'ecore-evas', 'ecore-file', 'ecore-input', 'edje', 'emotion', 'ecore-imf', 'ecore-con', 'eldbus', 'eio'], ['atspi']],
['efl_canvas_wl' ,['wl'] , false, true, true, false, false, false, true, ['eina', 'efl', 'eo', 'evas', 'ecore'], []],
['elua' ,['elua'] , false, true, true, false, true, false, false, ['eina', lua_pc_name], []],
['ecore_wayland' ,['wl-deprecated'] , false, true, false, false, false, false, false, ['eina'], []],
@ -355,6 +361,10 @@ subprojects = [
['exactness' ,[] , false, false, true, false, false, false, false, ['eina, evas, eet'], []],
]
if not get_option('emile')
config_h.set('EMILE_HEADER_ONLY', 1)
endif
# We generate Efl_Config.h and config.h later, they will be available here
config_dir += include_directories('.')
@ -365,6 +375,7 @@ subdir(join_paths(local_module, 'eina'))
# List of dependency objects that might be disabled due to configurations
# If they are enabled, the object gets overwritten by the library file.
ecore_audio = declare_dependency()
emile = declare_dependency(include_directories : include_directories('src/lib/emile'))
test_dirs = []
example_dirs = []
@ -374,6 +385,9 @@ efl_one_eo_deps = []
efl_one_include_dirs = []
efl_one_sub_dirs = []
tmp_empty = declare_dependency()
lz4 = tmp_empty
efl_config_h = configuration_data()
foreach package : subprojects
package_name = package[0]
@ -381,6 +395,7 @@ foreach package : subprojects
automatic_pkgfile = true
if package[1].length() == 0 or get_option(package[1][0])
config_h.set('HAVE_' + package_name.to_upper().underscorify(), '1')
efl_config_h.set('HAVE_' + package_name.to_upper().underscorify(), '1')
dir_package_include = join_paths(dir_include, package_version_name)
dir_package_modules = join_paths(dir_lib, package_name, 'modules')
@ -628,7 +643,6 @@ endif
# Configure files
#
efl_config_h = configuration_data()
efl_config_h.set('EFL_VERSION_MAJOR', version_major)
efl_config_h.set('EFL_VERSION_MINOR', version_minor)
efl_config_h.set('EFL_VERSION_MICRO', version_micro)

View File

@ -58,6 +58,12 @@ option('physics',
description : 'Physics engine (bullet) in efl'
)
option('ethumb',
type : 'boolean',
value : true,
description : 'Library and service for thumbnail generation and caching'
)
option('eeze',
type : 'boolean',
value : true,
@ -100,6 +106,18 @@ option('build-tests',
description : 'Compile tests'
)
option('efreet',
type : 'boolean',
value : true,
description : 'Enable efreet library',
)
option('emile',
type : 'boolean',
value : true,
description : 'Enable Emile'
)
option('crypto',
type : 'combo',
choices : ['gnutls', 'openssl'],
@ -323,7 +341,7 @@ option('dotnet',
option('lua-interpreter',
type: 'combo',
choices: ['luajit', 'lua'],
choices: ['luajit', 'lua', 'none'],
value: 'luajit',
description: 'Which Lua back-end library to use in efl'
)

View File

@ -7,8 +7,8 @@
#define MY_CLASS SIMPLE_CLASS
EOAPI const Efl_Event_Description _SIMPLE_FOO = EFL_EVENT_DESCRIPTION("foo");
EOAPI const Efl_Event_Description _SIMPLE_BAR = EFL_EVENT_DESCRIPTION("bar");
const Efl_Event_Description _SIMPLE_FOO = EFL_EVENT_DESCRIPTION("foo");
const Efl_Event_Description _SIMPLE_BAR = EFL_EVENT_DESCRIPTION("bar");
static void
_other_call(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, Eo *other, int times)
@ -19,7 +19,7 @@ _other_call(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, Eo *other, int ti
}
}
EAPI EFL_VOID_FUNC_BODYV(simple_other_call, EFL_FUNC_CALL(other, times), Eo *other, int times);
EFL_VOID_FUNC_BODYV(simple_other_call, EFL_FUNC_CALL(other, times), Eo *other, int times);
static void
_a_set(Eo *obj EINA_UNUSED, void *class_data, int a)
@ -28,7 +28,7 @@ _a_set(Eo *obj EINA_UNUSED, void *class_data, int a)
pd->a = a;
}
EAPI EFL_VOID_FUNC_BODYV(simple_a_set, EFL_FUNC_CALL(a), int a);
EFL_VOID_FUNC_BODYV(simple_a_set, EFL_FUNC_CALL(a), int a);
static Eina_Bool
_class_initializer(Efl_Class *klass)

View File

@ -6,16 +6,16 @@ typedef struct
int a;
} Simple_Public_Data;
EAPI void simple_a_set(Eo *self, int a);
void simple_a_set(Eo *self, int a);
/* Calls simple_other_call(other, obj) and then simple_other_call(obj, other)
* for 'times' times in order to grow the call stack on other objects. */
EAPI void simple_other_call(Eo*self, Eo *other, int times);
void simple_other_call(Eo*self, Eo *other, int times);
#define SIMPLE_CLASS simple_class_get()
const Efl_Class *simple_class_get(void);
EOAPI extern const Efl_Event_Description _SIMPLE_FOO;
EOAPI extern const Efl_Event_Description _SIMPLE_BAR;
extern const Efl_Event_Description _SIMPLE_FOO;
extern const Efl_Event_Description _SIMPLE_BAR;
#define SIMPLE_FOO (&(_SIMPLE_FOO))
#define SIMPLE_BAR (&(_SIMPLE_BAR))

View File

@ -151,7 +151,9 @@ main(int argc, char **argv)
setlocale(LC_NUMERIC, "C");
ecore_app_no_system_modules();
#ifdef HAVE_EFREET
efreet_cache_disable();
#endif
if (!eina_init())
return -1;

View File

@ -265,7 +265,9 @@ static void st_collections_group_inherit(void);
static void st_collections_group_program_source(void);
static void st_collections_group_part_remove(void);
static void st_collections_group_program_remove(void);
#ifdef HAVE_LUA
static void st_collections_group_lua_script_only(void);
#endif
static void st_collections_group_script_recursion(void);
static void st_collections_group_alias(void);
static void st_collections_group_min(void);
@ -281,7 +283,9 @@ static void st_collections_group_limits_vertical(void);
static void st_collections_group_limits_horizontal(void);
static void ob_collections_group_script(void);
#ifdef HAVE_LUA
static void ob_collections_group_lua_script(void);
#endif
static void st_collections_group_parts_alias(void);
@ -674,7 +678,9 @@ New_Statement_Handler statement_handlers[] =
{"collections.group.target_group", st_collections_group_target_group}, /* dup */
{"collections.group.part_remove", st_collections_group_part_remove},
{"collections.group.program_remove", st_collections_group_program_remove},
#ifdef HAVE_LUA
{"collections.group.lua_script_only", st_collections_group_lua_script_only},
#endif
{"collections.group.script_recursion", st_collections_group_script_recursion},
{"collections.group.alias", st_collections_group_alias},
{"collections.group.min", st_collections_group_min},
@ -1371,7 +1377,9 @@ New_Object_Handler object_handlers[] =
{"collections.group.data", NULL},
{"collections.group.limits", NULL},
{"collections.group.script", ob_collections_group_script},
#ifdef HAVE_LUA
{"collections.group.lua_script", ob_collections_group_lua_script},
#endif
{"collections.group.externals", NULL}, /* dup */
{"collections.group.set", ob_images_set}, /* dup */
{"collections.group.set.image", ob_images_set_image}, /* dup */
@ -4851,7 +4859,9 @@ st_collections_group_inherit(void)
pc->prop.min.h = pc2->prop.min.h;
pc->prop.orientation = pc2->prop.orientation;
#ifdef HAVE_LUA
pc->lua_script_only = pc2->lua_script_only;
#endif
pc->use_custom_seat_names = pc2->use_custom_seat_names;
pcp = (Edje_Part_Collection_Parser *)pc;
@ -5034,6 +5044,7 @@ st_collections_group_inherit(void)
Defaults: off
@endproperty
*/
#ifdef HAVE_LUA
static void
st_collections_group_lua_script_only(void)
{
@ -5044,6 +5055,7 @@ st_collections_group_lua_script_only(void)
pc = eina_list_data_get(eina_list_last(edje_collections));
pc->lua_script_only = parse_bool(0);
}
#endif
/**
@page edcref

View File

@ -23,8 +23,10 @@
#include "edje_convert.h"
#include "edje_multisense_convert.h"
#ifdef HAVE_LUA
#include <lua.h>
#include <lauxlib.h>
#endif
typedef struct _External_Lookup External_Lookup;
typedef struct _Part_Lookup Part_Lookup;
@ -105,6 +107,7 @@ struct _Code_Lookup
Eina_Bool set;
};
#ifdef HAVE_LUA
typedef struct _Script_Lua_Writer Script_Lua_Writer;
struct _Script_Lua_Writer
@ -112,11 +115,14 @@ struct _Script_Lua_Writer
char *buf;
int size;
};
#endif
typedef struct _Script_Write Script_Write;
typedef struct _Head_Write Head_Write;
typedef struct _Fonts_Write Fonts_Write;
#ifndef EMILE_HEADER_ONLY
typedef struct _Image_Write Image_Write;
#endif
typedef struct _Sound_Write Sound_Write;
typedef struct _Mo_Write Mo_Write;
typedef struct _Vibration_Write Vibration_Write;
@ -148,20 +154,26 @@ struct _Fonts_Write
char *errstr;
};
#ifndef EMILE_HEADER_ONLY
struct _Image_Write
{
Eet_File *ef;
Edje_Image_Directory_Entry *img;
Evas_Object *im;
#ifndef EMILE_HEADER_ONLY
Emile_Image_Property prop;
#endif
Eina_File *f;
#ifndef EMILE_HEADER_ONLY
Emile_Image *emi;
#endif
int w, h;
int alpha;
unsigned int *data;
char *path;
char *errstr;
};
#endif
struct _Sound_Write
{
@ -242,7 +254,9 @@ static int image_num;
static Ecore_Evas *buffer_ee;
static int cur_image_entry;
#ifndef EMILE_HEADER_ONLY
static void data_write_images(void);
#endif
void
error_and_abort(Eet_File *ef EINA_UNUSED, const char *fmt, ...)
@ -268,7 +282,11 @@ thread_end(Eina_Bool img)
if (threads)
{
if ((pending_image_threads + pending_threads) < (int)max_open_files - 2)
#ifndef EMILE_HEADER_ONLY
data_write_images();
#else
{}
#endif
}
if (pending_threads + pending_image_threads <= 0) ecore_main_loop_quit();
}
@ -1080,6 +1098,7 @@ show_err:
file, file_out, errmsg, hint);
}
#ifndef EMILE_HEADER_ONLY
static void
data_thread_image(void *data, Ecore_Thread *thread EINA_UNUSED)
{
@ -1215,7 +1234,9 @@ data_thread_image(void *data, Ecore_Thread *thread EINA_UNUSED)
}
}
}
#endif
#ifndef EMILE_HEADER_ONLY
static void
data_thread_image_end(void *data, Ecore_Thread *thread EINA_UNUSED)
{
@ -1231,7 +1252,9 @@ data_thread_image_end(void *data, Ecore_Thread *thread EINA_UNUSED)
free(iw);
thread_end(1);
}
#endif
#ifndef EMILE_HEADER_ONLY
static void
data_image_preload_done(void *data, Evas *e EINA_UNUSED, Evas_Object *o, void *event_info EINA_UNUSED)
{
@ -1248,7 +1271,9 @@ data_image_preload_done(void *data, Evas *e EINA_UNUSED, Evas_Object *o, void *e
data_thread_image_end(iw, NULL);
}
}
#endif
#ifndef EMILE_HEADER_ONLY
static void
tgv_file_thread(void *data, Ecore_Thread *thread EINA_UNUSED)
{
@ -1261,7 +1286,9 @@ tgv_file_thread(void *data, Ecore_Thread *thread EINA_UNUSED)
len = eina_file_size_get(iw->f);
eet_write_cipher(iw->ef, buf, iw->data, len, EINA_FALSE /*!no_comp*/, NULL);
}
#endif
#ifndef EMILE_HEADER_ONLY
static void
tgv_file_thread_end(void *data, Ecore_Thread *thread EINA_UNUSED)
{
@ -1273,13 +1300,17 @@ tgv_file_thread_end(void *data, Ecore_Thread *thread EINA_UNUSED)
free(iw->errstr);
}
free(iw->path);
#ifndef EMILE_HEADER_ONLY
emile_image_close(iw->emi);
#endif
eina_file_map_free(iw->f, iw->data);
eina_file_close(iw->f);
free(iw);
thread_end(1);
}
#endif
#ifndef EMILE_HEADER_ONLY
static Eina_Bool
tgv_file_check_and_add(Eet_File *ef, Edje_Image_Directory_Entry *img)
{
@ -1368,6 +1399,7 @@ on_error:
eina_file_close(f);
return EINA_FALSE;
}
#endif
static void
data_write_vectors(Eet_File *ef, int *vector_num)
@ -1475,6 +1507,7 @@ data_image_sets_init(void)
}
}
#ifndef EMILE_HEADER_ONLY
static void
data_write_images(void)
{
@ -1496,7 +1529,7 @@ data_write_images(void)
Eina_List *ll;
char *s;
int load_err = EVAS_LOAD_ERROR_NONE;
Image_Write *iw;
Image_Write *iw = NULL;
img = &edje_file->image_dir->entries[cur_image_entry];
if ((img->source_type >= EDJE_IMAGE_SOURCE_TYPE_USER) || !img->entry)
@ -1508,6 +1541,7 @@ data_write_images(void)
ext = strrchr(img->entry, '.');
if (ext && !strcasecmp(ext, ".tgv"))
{
#ifndef EMILE_HEADER_ONLY
if (tgv_file_check_and_add(cur_ef, img))
{
DBG("Directly copying data from TGV file into EDJ");
@ -1515,13 +1549,17 @@ data_write_images(void)
}
else
ERR("Source '%s' has incompatible ETC format.", img->entry);
#endif
}
}
im = evas_object_image_add(evas);
#ifndef EMILE_HEADER_ONLY
iw = calloc(1, sizeof(Image_Write));
iw->ef = cur_ef;
iw->img = img;
iw->im = im = evas_object_image_add(evas);
iw->im = im;
#endif
if (threads)
evas_object_event_callback_add(im,
EVAS_CALLBACK_IMAGE_PRELOADED,
@ -1589,6 +1627,7 @@ data_write_images(void)
}
}
}
#endif
static void
data_thread_sounds(void *data, Ecore_Thread *thread EINA_UNUSED)
@ -2403,6 +2442,7 @@ data_write_scripts(Eet_File *ef)
}
}
#ifdef HAVE_LUA
#ifdef LUA_BINARY
static int
_edje_lua_script_writer(lua_State *L EINA_UNUSED, const void *chunk_buf, size_t chunk_size, void *_data)
@ -2602,6 +2642,7 @@ data_write_lua_scripts(Eet_File *ef)
}
}
}
#endif
static void
data_thread_source(void *data, Ecore_Thread *thread EINA_UNUSED)
@ -2836,8 +2877,10 @@ data_write(void)
INF("groups: %3.5f", ecore_time_get() - t); t = ecore_time_get();
data_write_scripts(ef);
INF("scripts: %3.5f", ecore_time_get() - t); t = ecore_time_get();
#ifdef HAVE_LUA
data_write_lua_scripts(ef);
INF("lua scripts: %3.5f", ecore_time_get() - t); t = ecore_time_get();
#endif
if (!no_save)
{
@ -2883,7 +2926,9 @@ data_write(void)
data_thread_authors_end(ef, NULL);
}
}
#ifndef EMILE_HEADER_ONLY
data_write_images();
#endif
data_image_sets_init();
INF("images: %3.5f", ecore_time_get() - t); t = ecore_time_get();
pending_threads--;
@ -3758,8 +3803,10 @@ data_process_lookups(void)
unsigned int count = 0;
unsigned int i;
#ifdef HAVE_LUA
if (pc->lua_script_only)
is_lua = EINA_TRUE;
#endif
#define PROGRAM_ID_SET(Type, Pc, It, Count) \
for (It = 0; It < Pc->programs.Type ## _count; ++It) \
{ \

View File

@ -3,7 +3,7 @@
#endif
#include <locale.h>
#include <fnmatch.h>
#include <Eina.h>
#include <Ecore.h>
#include <Ecore_Getopt.h>
@ -56,7 +56,7 @@ module_matches(const char *name)
if (!module_patterns) return EINA_TRUE;
for (itr = module_patterns; *itr != NULL; itr++)
if (fnmatch(*itr, name, 0) == 0) return EINA_TRUE;
if (eina_fnmatch(*itr, name, 0) == 0) return EINA_TRUE;
return EINA_FALSE;
}
@ -65,7 +65,7 @@ static inline Eina_Bool
type_matches(const char *name)
{
if (!type_glob) return EINA_TRUE;
return fnmatch(type_glob, name, 0) == 0;
return eina_fnmatch(type_glob, name, 0) == 0;
}
static int

View File

@ -3,7 +3,7 @@
#endif
#include <locale.h>
#include <fnmatch.h>
#include <Eina.h>
#include <unistd.h>
#include <errno.h>
@ -101,7 +101,7 @@ static inline Eina_Bool
matches(const char *name, const char *pattern)
{
if (!pattern) return EINA_TRUE;
return fnmatch(pattern, name, 0) == 0;
return eina_fnmatch(pattern, name, 0) == 0;
}
static void

View File

@ -5,11 +5,15 @@ edje_bin_deps = [
lua, eet, evas,
ecore_file, ecore_input,
ecore_imf, ecore_imf_evas,
embryo, efreet, eio,
embryo, eio,
edje, ecore_evas,
intl,
]
if get_option('efreet')
edje_bin_deps += efreet
endif
edje_cc_src = [
'edje_multisense_convert.h',
'edje_cc.h',

View File

@ -1577,6 +1577,7 @@ _theme_sel(void *data EINA_UNUSED,
printf("not implemented\n");
}*/
#ifdef ELM_EFREET
static void
_icon_preview_icon_add(const char *icon, const char *theme)
{
@ -1594,6 +1595,7 @@ _icon_preview_icon_add(const char *icon, const char *theme)
if (strcmp(theme, ELM_CONFIG_ICON_THEME_ELEMENTARY))
elm_image_file_set(ic, efreet_icon_path_find(theme, icon, 48), NULL);
}
#endif
static void
@ -1611,8 +1613,10 @@ _icon_preview_update(Evas_Object *win)
const char *theme = evas_object_data_get(win, "icon_theme");
elm_box_clear(icon_preview_frame);
#ifdef ELM_EFREET
for (example_icon = example_icons; !!*example_icon; example_icon++)
_icon_preview_icon_add(*example_icon, theme);
#endif
}
static void
@ -1672,15 +1676,18 @@ _icon_theme_sel(void *data, Evas_Object *obj,
static Eina_Bool
_icon_theme_valid(const char *theme)
{
const char *icon_path;
const char *icon_path = NULL;
#ifdef ELM_EFREET
icon_path = efreet_icon_path_find(theme, "folder", 48);
#endif
return !!icon_path;
}
static int
_icon_theme_list_sort(const void *data1, const void *data2)
{
#ifdef ELM_EFREET
const Efreet_Icon_Theme *t1, *t2;
t1 = data1;
@ -1690,6 +1697,9 @@ _icon_theme_list_sort(const void *data1, const void *data2)
if (!t2->name.name) return -1;
return strcmp(t1->name.name, t2->name.name);
#else
return 0;
#endif
}
static void
@ -2391,7 +2401,9 @@ _status_config_icons(Evas_Object *win,
{
Evas_Object *tb, *rc, *sp, *ck, *li, *bx, *ic, *pd, *fr, *bt;
Eina_List *list, *l;
#ifdef ELM_EFREET
const Efreet_Icon_Theme *th;
#endif
Elm_Object_Item *list_it, *def_it = NULL;
tb = elm_table_add(win);
@ -2435,6 +2447,7 @@ _status_config_icons(Evas_Object *win,
evas_object_data_set(win, "icon_theme", elm_config_icon_theme_get());
#ifdef ELM_EFREET
list = efreet_icon_theme_list_get();
list = eina_list_sort(list, eina_list_count(list), _icon_theme_list_sort);
EINA_LIST_FOREACH(list, l, th)
@ -2452,6 +2465,8 @@ _status_config_icons(Evas_Object *win,
if (!strcmp(elm_config_icon_theme_get(), th->name.internal))
elm_list_item_selected_set(list_it, EINA_TRUE);
}
#endif
if (!elm_list_selected_items_get(li))
elm_list_item_selected_set(def_it, EINA_TRUE);

View File

@ -128,7 +128,6 @@ elementary_test_src = [
'test_sys_notify.c',
'test_systray.c',
'test_table.c',
'test_thumb.c',
'test_toolbar.c',
'test_tooltip.c',
'test_transit.c',
@ -172,10 +171,15 @@ if sys_windows == false
link_args += ['-rdynamic', '-fPIC']
package_c_args = package_c_args + ['-fPIC']
endif
if sys_windows == false and sys_sun == false
link_args += ['-pie']
endif
if get_option('ethumb')
elementary_test_src += ['test_thumb.c']
endif
elementary_test = executable('elementary_test',
elementary_test_src,
dependencies: [elementary, intl] + elementary_deps + elementary_pub_deps,

View File

@ -203,7 +203,7 @@ _spincpu_up_idler(void *data EINA_UNUSED)
}
///////////////////////////////////////////////////////////////////////////////
EAPI int
EXPORTAPI int
elm_main(int argc, char **argv)
{
int i, j;

View File

@ -118,6 +118,7 @@ main(int argc, char **argv)
}
}
}
#ifndef _MSC_VER
if (exe)
{
if (!lstat(exe, &st))
@ -140,6 +141,7 @@ main(int argc, char **argv)
}
}
}
#endif
if (we_are_elementary_run)
{
sargc = argc;

View File

@ -877,7 +877,9 @@ add_tests:
ADD_TEST(NULL, "Images", "Photocam Icon", test_photocam_icon);
ADD_TEST_EO(NULL, "Images", "Image Zoomable animation", test_image_zoomable_animated);
ADD_TEST(NULL, "Images", "Photo", test_photo);
#ifdef HAVE_ETHUMB
ADD_TEST(NULL, "Images", "Thumb", test_thumb);
#endif
ADD_TEST(NULL, "Images", "Image", test_image);
ADD_TEST(NULL, "Images", "Image Scale Type", test_image_scale_type);
ADD_TEST(NULL, "Images", "Image Align", test_image_swallow_align);

View File

@ -549,7 +549,9 @@ test_fileselector(void *data EINA_UNUSED,
*/
setlocale(LC_ALL, "");
#ifdef HAVE_ETHUMB
elm_need_ethumb();
#endif
elm_need_efreet();
win = elm_win_util_standard_add("fileselector", "File Selector");

View File

@ -42,7 +42,9 @@ test_photo(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_inf
"wood_01.jpg"
};
#ifdef HAVE_ETHUMB
elm_need_ethumb();
#endif
win = elm_win_util_standard_add("photo", "Photo");
elm_win_autodel_set(win, EINA_TRUE);

View File

@ -1,6 +1,8 @@
#include "main.h"
#include "docs.h"
extern char* _eolian_api_symbol;
static const char *
_get_add_star(Eolian_Function_Type ftype, Eolian_Parameter_Direction pdir)
{
@ -118,7 +120,7 @@ _gen_func(const Eolian_State *state, const Eolian_Function *fid,
eina_strbuf_append_char(buf, '\n');
eina_strbuf_free(dbuf);
}
eina_strbuf_append(buf, "EOAPI ");
eina_strbuf_append_printf(buf, "%s %s_WEAK ", _eolian_api_symbol, _eolian_api_symbol);
if (rtp)
{
if (!rtps)
@ -225,7 +227,8 @@ eo_gen_header_gen(const Eolian_State *state, const Eolian_Class *cl,
eina_strbuf_append_printf(buf, "#define %s %s()\n\n", mname, gname);
eina_stringshare_del(mname);
eina_strbuf_append_printf(buf, "EWAPI const Efl_Class *%s(void) EINA_CONST;\n", gname);
eina_strbuf_append_printf(buf, "%s %s_WEAK const Efl_Class *%s(void) EINA_CONST;\n",
_eolian_api_symbol, _eolian_api_symbol, gname);
eina_stringshare_del(gname);
/* method section */
@ -283,8 +286,9 @@ events:
if (!eolian_event_is_beta(ev) && evs == EOLIAN_SCOPE_PUBLIC)
eina_strbuf_append_char(buf, '\n');
eina_strbuf_append_printf(buf, "EWAPI extern const "
"Efl_Event_Description _%s;\n\n", evn);
eina_strbuf_append_printf(buf, "%s %s_WEAK extern const "
"Efl_Event_Description _%s;\n\n",
_eolian_api_symbol, _eolian_api_symbol, evn);
Eina_Strbuf *evdbuf = eo_gen_docs_event_gen(state, ev,
eolian_class_c_name_get(cl));

View File

@ -7,6 +7,7 @@
#include "sources.h"
int _eolian_gen_log_dom = -1;
char* _eolian_api_symbol;
enum
{
@ -44,6 +45,7 @@ _print_usage(const char *progn, FILE *outf)
" -o type:name specify a particular output filename\n"
" -h print this message and exit\n"
" -v print version and exit\n"
" -e api symbol string to be used for import/export symbol"
"\n"
"Available types:\n"
" h: C header file (.eo.h/.eot.h)\n"
@ -494,6 +496,7 @@ main(int argc, char **argv)
NULL, NULL, NULL, NULL, NULL, NULL
};
char *basen = NULL;
_eolian_api_symbol = strdup("EAPI");
Eina_List *includes = NULL;
eina_init();
@ -514,7 +517,7 @@ main(int argc, char **argv)
int gen_what = 0;
Eina_Bool scan_system = EINA_TRUE;
for (int opt; (opt = getopt(argc, argv, "SI:g:o:hv")) != -1;)
for (int opt; (opt = getopt(argc, argv, "SI:g:o:hve:")) != -1;)
switch (opt)
{
case 0:
@ -526,6 +529,10 @@ main(int argc, char **argv)
/* just a pointer to argv contents, so it persists */
includes = eina_list_append(includes, optarg);
break;
case 'e':
free(_eolian_api_symbol);
_eolian_api_symbol = strdup(optarg);
break;
case 'g':
for (const char *wstr = optarg; *wstr; ++wstr)
switch (*wstr)
@ -665,6 +672,8 @@ end:
free(outs[i]);
free(basen);
free(_eolian_api_symbol);
eolian_state_free(eos);
eolian_shutdown();
eina_shutdown();

View File

@ -7,6 +7,7 @@
*/
static Eina_Hash *_funcs_params_init_get = NULL;
static Eina_Hash *_funcs_params_init_set = NULL;
extern char* _eolian_api_symbol;
static const char *
_get_add_star(Eolian_Function_Type ftype, Eolian_Parameter_Direction pdir)
@ -475,7 +476,8 @@ static void
_emit_class_function(Eina_Strbuf *buf, const Eolian_Function *fid, const Eolian_Function_Type ftype, const Eolian_Type *rtp, const char *rtpn, Eina_Strbuf *params_full,
const char *ocnamel, const char *func_suffix, Eina_Strbuf *params, const char *function_name)
{
eina_strbuf_append(buf, "EOAPI ");
eina_strbuf_append_printf(buf, "%s %s_WEAK", _eolian_api_symbol, _eolian_api_symbol);
eina_strbuf_append(buf, " ");
eina_strbuf_append(buf, rtpn);
eina_strbuf_append(buf, " ");
eina_strbuf_append(buf, function_name);
@ -894,7 +896,8 @@ _gen_func(const Eolian_Class *cl, const Eolian_Function *fid,
eina_strbuf_append_printf(buf, "}\n\n");
}
eina_strbuf_append(buf, "EOAPI EFL_");
eina_strbuf_append_printf(buf, "%s %s_WEAK", _eolian_api_symbol, _eolian_api_symbol);
eina_strbuf_append(buf, " EFL_");
if (!strcmp(rtpn, "void"))
eina_strbuf_append(buf, "VOID_");
eina_strbuf_append(buf, "FUNC_BODY");
@ -1125,7 +1128,8 @@ eo_gen_source_gen(const Eolian_Class *cl, Eina_Strbuf *buf)
EINA_ITERATOR_FOREACH(itr, ev)
{
Eina_Stringshare *evn = eolian_event_c_macro_get(ev);
eina_strbuf_append(buf, "EWAPI const Efl_Event_Description _");
eina_strbuf_append_printf(buf, "%s %s_WEAK", _eolian_api_symbol, _eolian_api_symbol);
eina_strbuf_append(buf, " const Efl_Event_Description _");
eina_strbuf_append(buf, evn);
eina_strbuf_append(buf, " =\n EFL_EVENT_DESCRIPTION");
if (eolian_event_is_hot(ev))

View File

@ -4,6 +4,8 @@
#include "headers.h"
#include "docs.h"
extern char* _eolian_api_symbol;
static Eina_Strbuf *
_type_generate(const Eolian_State *state, const Eolian_Typedecl *tp,
Eina_Bool full)
@ -226,7 +228,8 @@ _err_generate(const Eolian_State *state, const Eolian_Error *err)
if (!buf) buf = eina_strbuf_new();
else eina_strbuf_append_char(buf, '\n');
eina_strbuf_prepend_printf(buf, "EWAPI Eina_Error %s_get(void);\n\n", fn);
eina_strbuf_prepend_printf(buf, "%s %s_WEAK Eina_Error %s_get(void);\n\n",
_eolian_api_symbol, _eolian_api_symbol, fn);
char *ufn = strdup(fn);
eina_str_toupper(&ufn);
@ -324,7 +327,8 @@ _source_gen_error(Eina_Strbuf *buf, const Eolian_Error *err)
*p = '_';
eina_str_tolower(&fn);
eina_strbuf_append_printf(buf, "EWAPI Eina_Error %s_get(void)\n{\n", fn);
eina_strbuf_append_printf(buf, "%s %s_WEAK Eina_Error %s_get(void)\n{\n",
_eolian_api_symbol, _eolian_api_symbol, fn);
free(fn);
const char *msg = eolian_error_message_get(err);

View File

@ -1042,7 +1042,7 @@ _write_unit_file(void)
#define ORIGINAL_CALL(name, ...) \
ORIGINAL_CALL_T(int, name, __VA_ARGS__)
EAPI int
EXPORTAPI int
eina_init(void)
{
int original_return;
@ -1085,7 +1085,7 @@ eina_init(void)
return original_return;
}
EAPI int
EXPORTAPI int
ecore_evas_init(void)
{
int original_return;
@ -1101,7 +1101,7 @@ ecore_evas_init(void)
}
//hook, to hook in our theme
EAPI int
EXPORTAPI int
elm_init(int argc, char **argv)
{
int original_return;
@ -1113,7 +1113,7 @@ elm_init(int argc, char **argv)
return original_return;
}
EAPI void
EXPORTAPI void
ecore_main_loop_begin(void)
{
int original_return;
@ -1123,7 +1123,7 @@ ecore_main_loop_begin(void)
(void)original_return;
}
EAPI Eina_Value*
EXPORTAPI Eina_Value*
efl_loop_begin(Eo *obj)
{
Eina_Value *original_return;
@ -1133,7 +1133,7 @@ efl_loop_begin(Eo *obj)
return original_return;
}
EAPI int
EXPORTAPI int
eina_shutdown(void)
{
int original_return;

View File

@ -308,7 +308,7 @@ _setup_ee_creation(void)
#define ORIGINAL_CALL(name, ...) \
ORIGINAL_CALL_T(int, name, __VA_ARGS__)
EAPI int
EXPORTAPI int
eina_init(void)
{
int original_return;
@ -332,7 +332,7 @@ eina_init(void)
return original_return;
}
EAPI int
EXPORTAPI int
ecore_evas_init(void)
{
int original_return;
@ -349,7 +349,7 @@ ecore_evas_init(void)
}
//hook, to hook in our theme
EAPI int
EXPORTAPI int
elm_init(int argc, char **argv)
{
int original_return;
@ -361,7 +361,7 @@ elm_init(int argc, char **argv)
return original_return;
}
EAPI void
EXPORTAPI void
ecore_main_loop_begin(void)
{
int original_return;
@ -371,7 +371,7 @@ ecore_main_loop_begin(void)
(void)original_return;
}
EAPI Eina_Value*
EXPORTAPI Eina_Value*
efl_loop_begin(Eo *obj)
{
Eina_Value *original_return;
@ -381,7 +381,7 @@ efl_loop_begin(Eo *obj)
return original_return;
}
EAPI int
EXPORTAPI int
eina_shutdown(void)
{
int original_return;

View File

@ -33,7 +33,7 @@ internal class Libs {
internal const string CustomExports = "@CUSTOM_EXPORTS_MONO_DL_MONO@";
internal const string Libdl = "libdl.so";
internal const string Libdl = "@LIBDL_DL_MONO@";
internal const string Kernel32 = "kernel32.dll";
internal static readonly Efl.Eo.NativeModule EflModule = new Efl.Eo.NativeModule(Efl);

View File

@ -16,6 +16,11 @@ efl_libs = configuration_data()
efl_libs.set('EFL_MONO_LIBRARY_MAP', map)
efl_libs.set('CUSTOM_EXPORTS_MONO_DL_MONO', 'eflcustomexportsmono')
efl_libs.set('EVIL_DL_MONO', 'dl')
if sys_osx
efl_libs.set('LIBDL_DL_MONO', 'dl.dylib')
else
efl_libs.set('LIBDL_DL_MONO', 'libdl.so')
endif
foreach mono_libs : mono_sublibs
key = mono_libs[0].to_upper()+'_DL_MONO'
@ -76,6 +81,7 @@ foreach eo_file : mono_eo_files
'-o', 'h:' + join_paths(meson.current_build_dir(), eo_file + '.h'),
'-o', 'c:' + join_paths(meson.current_build_dir(), eo_file + '.c'),
'-o', 'd:' + join_paths(meson.current_build_dir(), eo_file + '.d'),
'-e', 'EFL_MONO_API',
'-gchd', '@INPUT@'])
# mono_eo_c_files += join_paths(meson.current_build_dir(), eo_file + '.c')
endforeach
@ -90,6 +96,7 @@ efl_mono_lib = library('eflcustomexportsmono',
install : true,
include_directories : config_dir + [include_directories(join_paths('.'))],
dependencies : [eo, eina, ecore],
c_args : ['-DEFL_MONO_BUILD'],
version : meson.project_version()
)

View File

@ -59,11 +59,27 @@ public struct Error : IComparable<Error>, IEquatable<Error>
/// <para>Since EFL 1.23.</para>
/// </summary>
public static readonly Error ENOENT = new Error(2);
/// <summary>
/// Return architecture independent ECANCELED error code.
/// Returns 125 for Linux, 89 for OSX and 105 for Windows.
/// <para>Since EFL 1.25.</para>
/// </summary>
private static int IndependentECANCELED()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
return new Error(125);
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
return new Error(89);
else // Windows
return new Error(105);
}
/// <summary>
/// Cancelled error identifier.
/// <para>Since EFL 1.23.</para>
/// </summary>
public static readonly Error ECANCELED = new Error(125);
public static readonly Error ECANCELED = IndependentECANCELED();
/// <summary>
/// Constructor.

View File

@ -56,6 +56,12 @@ internal partial class NativeModule
///<item>
///<description><c>libfilename.so</c></description>
///</item>
///<item>
///<description><c>filename.dylib</c></description>
///</item>
///<item>
///<description><c>libfilename.dylib</c></description>
///</item>
///</list>
///</summary>
///<param name="filename">The name to search for.</param>
@ -73,6 +79,16 @@ internal partial class NativeModule
if (r == IntPtr.Zero)
{
r = dlopen("lib" + filename + ".so", RTLD_NOW | RTLD_GLOBAL);
if (r == IntPtr.Zero)
{
r = dlopen(filename + ".dylib", RTLD_NOW | RTLD_GLOBAL);
if (r == IntPtr.Zero)
{
r = dlopen("lib" + filename + ".dylib", RTLD_NOW | RTLD_GLOBAL);
}
}
}
}
}

View File

@ -34,12 +34,15 @@ edje_external_elementary = [
'elm_slider.c',
'elm_slideshow.c',
'elm_spinner.c',
'elm_thumb.c',
'elm_toolbar.c',
'elm_video.c',
'elm_web.c'
]
if get_option('ethumb')
edje_external_elementary += ['elm_thumb.c']
endif
ecore_systemd_mod = shared_module('elementary',
edje_external_elementary,
dependencies: [edje, elementary, elementary_deps],

View File

@ -31,7 +31,9 @@ DEFINE_TYPE(segment_control)
DEFINE_TYPE(slider)
DEFINE_TYPE(slideshow)
DEFINE_TYPE(spinner)
#ifdef HAVE_ETHUMB
DEFINE_TYPE(thumb)
#endif
DEFINE_TYPE(toolbar)
DEFINE_TYPE(video)
DEFINE_TYPE(web)

View File

@ -28,7 +28,6 @@ edc_files = [
'external_elm_panes.edc',
'external_emotion_elm.edc',
'focus.edc',
'lua_script.edc',
'messages_echo.edc',
'multiseat.edc',
'multiseat_custom_names.edc',
@ -36,7 +35,6 @@ edc_files = [
'perspective.edc',
'signals-messages.edc',
'signalsBubble.edc',
'sigtest.edc',
'svg.edc',
'swallow.edc',
'table.edc',
@ -47,6 +45,13 @@ edc_files = [
'center_zoom.edc',
]
if get_option('lua-interpreter') != 'none'
edc_files += [
'lua_script.edc',
'sigtest.edc',
]
endif
if (get_option('physics'))
edc_files += [
'physics_3d.edc',

View File

@ -20,32 +20,6 @@
#include <Eo.h>
#undef EOAPI
#undef EAPI
#define EOAPI EAPI EAPI_WEAK
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include "example_numberwrapper.eo.h"

View File

@ -22,7 +22,9 @@ struct _Efl_Model_Test_Filemvc_Data
Eo *treeview;
Eo *formview;
Eo *treemodel;
#ifdef HAVE_ETHUMB
Evas_Object *thumb;
#endif
char imagedefault_path[256];
};
typedef struct _Efl_Model_Test_Filemvc_Data Efl_Model_Test_Filemvc_Data;
@ -49,7 +51,9 @@ _list_selected_cb(void *data EINA_UNUSED, const Efl_Event *event)
{
Efl_Model_Test_Filemvc_Data *priv = data;
Eo *child = event->info;
#ifdef HAVE_ETHUMB
ethumb_client_file_free(elm_thumb_ethumb_client_get());
#endif
printf("LIST selected model\n");
elm_view_form_model_set(priv->formview, child);
@ -89,6 +93,7 @@ _label_init(Evas_Object *win, Evas_Object *box, const char *text)
}
#ifdef HAVE_ETHUMB
static void
_thumb_error_cb(void *data, Evas_Object *o EINA_UNUSED, void *event_info EINA_UNUSED)
{
@ -97,6 +102,7 @@ _thumb_error_cb(void *data, Evas_Object *o EINA_UNUSED, void *event_info EINA_UN
elm_thumb_file_set(priv->thumb, priv->imagedefault_path, NULL);
elm_thumb_reload(priv->thumb);
}
#endif
EAPI_MAIN int
elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
@ -177,6 +183,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
elm_view_form_widget_add(priv.formview, "path", entry);
/* Thumb widget */
#ifdef HAVE_ETHUMB
elm_need_ethumb();
priv.thumb = elm_thumb_add(win);
_widget_init(priv.thumb);
@ -185,6 +192,7 @@ elm_main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
elm_view_form_widget_add(priv.formview, "path", priv.thumb);
evas_object_smart_callback_add(priv.thumb, "generate,error", _thumb_error_cb, &priv);
evas_object_smart_callback_add(priv.thumb, "load,error", _thumb_error_cb, &priv);
#endif
//showall
evas_object_resize(win, 800, 400);

View File

@ -113,7 +113,9 @@ elm_main(int argc EINA_UNUSED,
*/
setlocale(LC_ALL, "");
#ifdef HAVE_ETHUMB
elm_need_ethumb(); /* let's have thumbnails of images on grid view */
#endif
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
win = elm_win_util_standard_add("fileselector", "File Selector Example");

View File

@ -90,7 +90,6 @@ examples = [
'table_example_02',
'theme_example_01',
'theme_example_02',
'thumb_example_01',
'toolbar_example_01',
'toolbar_example_02',
'toolbar_example_03',
@ -123,6 +122,10 @@ examples = [
'efl_canvas_textblock_obstacles_example'
]
if get_option('ethumb')
examples += ['thumb_example_01']
endif
foreach example : examples
executable(example, example + '.c', dependencies: [elementary, ecore, eio, m])
endforeach

View File

@ -25,7 +25,7 @@
#endif
#include <Efl_Ui.hh>
EAPI int
EAPI_MAIN int
elm_main(int argc EINA_UNUSED, char* argv[] EINA_UNUSED)
{
elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_HIDDEN);

View File

@ -276,32 +276,7 @@
#include <Eina.h>
#include <Eo.h>
#include <Efl.h>
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_api.h>
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
@ -331,13 +306,10 @@ extern "C" {
#endif
#include "Ecore_Eo.h"
EAPI double _ecore_main_loop_wakeup_time_get(void);
ECORE_API double _ecore_main_loop_wakeup_time_get(void);
#ifdef __cplusplus
}
#endif
#undef EAPI
#define EAPI
#endif

File diff suppressed because it is too large Load Diff

View File

@ -45,9 +45,9 @@
/* To be deprecated at some point */
/** Please use efl_provider_register instead. */
EAPI Eina_Bool efl_loop_register(Efl_Loop *obj, const Efl_Class *klass, const Efl_Object *provider);
ECORE_API Eina_Bool efl_loop_register(Efl_Loop *obj, const Efl_Class *klass, const Efl_Object *provider);
/** Please use efl_provider_unregister instead. */
EAPI Eina_Bool efl_loop_unregister(Efl_Loop *obj, const Efl_Class *klass, const Efl_Object *provider);
ECORE_API Eina_Bool efl_loop_unregister(Efl_Loop *obj, const Efl_Class *klass, const Efl_Object *provider);
/**
* @brief Quits the main loop once all the events currently on the queue have
@ -59,9 +59,9 @@ EAPI Eina_Bool efl_loop_unregister(Efl_Loop *obj, const Efl_Class *klass, const
*
* @ingroup Efl_Loop
*/
EAPI void efl_exit(int exit_code);
ECORE_API void efl_exit(int exit_code);
EAPI int efl_loop_exit_code_process(Eina_Value *value);
ECORE_API int efl_loop_exit_code_process(Eina_Value *value);
#include "efl_loop_consumer.eo.h"
@ -71,7 +71,7 @@ EAPI int efl_loop_exit_code_process(Eina_Value *value);
* @param[in] obj An object which is either a loop or a loop consumer
* @return The current loop's future scheduler.
*/
EAPI Eina_Future_Scheduler *efl_loop_future_scheduler_get(const Eo *obj);
ECORE_API Eina_Future_Scheduler *efl_loop_future_scheduler_get(const Eo *obj);
#include "efl_loop_fd.eo.h"
#include "efl_loop_handler.eo.h"
@ -86,7 +86,7 @@ EAPI Eina_Future_Scheduler *efl_loop_future_scheduler_get(const Eo *obj);
#include "efl_cubic_bezier_interpolator.eo.h"
/* We ue the factory pattern here, so you shouldn't call eo_add directly. */
EAPI Eo *efl_main_loop_get(void);
ECORE_API Eo *efl_main_loop_get(void);
/**
* @}

View File

@ -3,32 +3,7 @@
#include <stdio.h>
#include <Eina.h>
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_api.h>
/**
* @ingroup Ecore
@ -1025,7 +1000,7 @@ struct _Ecore_Getopt
*
* @see ecore_getopt_help_category()
*/
EAPI void ecore_getopt_help(FILE *fp, const Ecore_Getopt *info);
ECORE_API void ecore_getopt_help(FILE *fp, const Ecore_Getopt *info);
/**
* Shows help for a single category (along with program usage and description).
@ -1038,7 +1013,7 @@ EAPI void ecore_getopt_help(FILE *fp, const Ecore_Getopt *info);
*
* @see ecore_getopt_help()
*/
EAPI Eina_Bool ecore_getopt_help_category(FILE *fp, const Ecore_Getopt *info, const char *category);
ECORE_API Eina_Bool ecore_getopt_help_category(FILE *fp, const Ecore_Getopt *info, const char *category);
/**
* Checks parser for duplicate entries, print them out.
@ -1046,7 +1021,7 @@ EAPI Eina_Bool ecore_getopt_help_category(FILE *fp, const Ecore_Getopt *info, c
* @return @c EINA_TRUE if there are duplicates, @c EINA_FALSE otherwise.
* @param parser The parser to be checked.
*/
EAPI Eina_Bool ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser);
ECORE_API Eina_Bool ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser);
/**
* Parses command line parameters.
@ -1110,7 +1085,7 @@ EAPI Eina_Bool ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser);
*
* @see ecore_getopt_parse_positional()
*/
EAPI int ecore_getopt_parse(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv);
ECORE_API int ecore_getopt_parse(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv);
/**
* Parses command line positional parameters.
@ -1163,7 +1138,7 @@ EAPI int ecore_getopt_parse(const Ecore_Getopt *parser, Ecore_Getopt_Valu
* last positional argument is of action @c
* ECORE_GETOPT_ACTION_APPEND then it will be the same as @a argc.
*/
EAPI int ecore_getopt_parse_positional(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv, int start);
ECORE_API int ecore_getopt_parse_positional(const Ecore_Getopt *parser, Ecore_Getopt_Value *values, int argc, char **argv, int start);
/**
@ -1172,7 +1147,7 @@ EAPI int ecore_getopt_parse_positional(const Ecore_Getopt *parser, Ecore_
* @param list Pointer to list to be freed.
* @return always @c NULL, so you can easily make your list head @c NULL.
*/
EAPI Eina_List *ecore_getopt_list_free(Eina_List *list);
ECORE_API Eina_List *ecore_getopt_list_free(Eina_List *list);
/**
* Helper ecore_getopt callback to parse geometry (x:y:w:h).
@ -1189,7 +1164,7 @@ EAPI Eina_List *ecore_getopt_list_free(Eina_List *list);
*
* @c callback_data value is ignored, you can safely use @c NULL.
*/
EAPI Eina_Bool ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
ECORE_API Eina_Bool ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
/**
* Helper ecore_getopt callback to parse geometry size (WxH).
@ -1205,7 +1180,7 @@ EAPI Eina_Bool ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser,
*
* @c callback_data value is ignored, you can safely use @c NULL.
*/
EAPI Eina_Bool ecore_getopt_callback_size_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
ECORE_API Eina_Bool ecore_getopt_callback_size_parse(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
#ifdef __cplusplus
}
@ -1215,7 +1190,4 @@ EAPI Eina_Bool ecore_getopt_callback_size_parse(const Ecore_Getopt *parser, con
* @}
*/
#undef EAPI
#define EAPI
#endif /* _ECORE_GETOPT_H */

View File

@ -38,7 +38,7 @@ typedef struct _Ecore_Poller Ecore_Poller;
* @c 0 it will be deleted automatically making any references/handles for it
* invalid.
*/
EAPI Ecore_Poller *ecore_poller_add(Ecore_Poller_Type type, int interval, Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Poller *ecore_poller_add(Ecore_Poller_Type type, int interval, Ecore_Task_Cb func, const void *data);
/**
* @brief Deletes the specified poller from the timer list.
@ -49,7 +49,7 @@ EAPI Ecore_Poller *ecore_poller_add(Ecore_Poller_Type type, int interval, Ecore_
* @note @a poller must be a valid handle. If the poller function has already
* returned @c 0, the handle is no longer valid (and does not need to be deleted).
*/
EAPI void *ecore_poller_del(Ecore_Poller *poller);
ECORE_API void *ecore_poller_del(Ecore_Poller *poller);
/**
* @brief Sets the time(in seconds) between ticks for the given poller type.
@ -59,7 +59,7 @@ EAPI void *ecore_poller_del(Ecore_Poller *poller);
* This will adjust the time between ticks of the given timer type defined by
* @p type to the time period defined by @p poll_time.
*/
EAPI void ecore_poller_poll_interval_set(Ecore_Poller_Type type, double poll_time);
ECORE_API void ecore_poller_poll_interval_set(Ecore_Poller_Type type, double poll_time);
/**
* @brief Gets the time(in seconds) between ticks for the given poller type.
@ -68,7 +68,7 @@ EAPI void ecore_poller_poll_interval_set(Ecore_Poller_Type type, double poll_tim
*
* This will get the time between ticks of the specified poller timer.
*/
EAPI double ecore_poller_poll_interval_get(Ecore_Poller_Type type);
ECORE_API double ecore_poller_poll_interval_get(Ecore_Poller_Type type);
/**
* @brief Polling interval rate of the poller.
@ -77,14 +77,14 @@ EAPI double ecore_poller_poll_interval_get(Ecore_Poller_Type type);
*
* @return @c true on success, @c false on failure.
*/
EAPI Eina_Bool ecore_poller_poller_interval_set(Ecore_Poller *obj, int interval);
ECORE_API Eina_Bool ecore_poller_poller_interval_set(Ecore_Poller *obj, int interval);
/**
* @brief Polling interval rate of the poller.
*
* @return The tick interval; must be a power of 2 and <= 32768.
*/
EAPI int ecore_poller_poller_interval_get(const Ecore_Poller *obj);
ECORE_API int ecore_poller_poller_interval_get(const Ecore_Poller *obj);
/**
* @}
@ -125,7 +125,7 @@ typedef struct _Ecore_Animator Ecore_Animator;
* @note The default @p frametime value is 1/30th of a second.
*
*/
EAPI Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func, const void *data);
/**
* @brief Adds an animator that runs for a limited time.
@ -157,7 +157,7 @@ EAPI Ecore_Animator *ecore_animator_add(Ecore_Task_Cb func, const void *data);
*
* @since 1.1.0
*/
EAPI Ecore_Animator *ecore_animator_timeline_add(double runtime, Ecore_Timeline_Cb func, const void *data);
ECORE_API Ecore_Animator *ecore_animator_timeline_add(double runtime, Ecore_Timeline_Cb func, const void *data);
/**
* @brief Deletes the specified animator from the animator list.
@ -172,7 +172,7 @@ EAPI Ecore_Animator *ecore_animator_timeline_add(double runtime, Ecore_Timeline_
* is invalid and should not be used again. It will not get called again after
* deletion.
*/
EAPI void *ecore_animator_del(Ecore_Animator *animator);
ECORE_API void *ecore_animator_del(Ecore_Animator *animator);
/**
* @brief Suspends the specified animator.
@ -188,7 +188,7 @@ EAPI void *ecore_animator_del(Ecore_Animator *animator);
* will increase as if the animator hadn't been frozen and the animator may
* have it's execution halted if @p runtime elapsed.
*/
EAPI void ecore_animator_freeze(Ecore_Animator *animator);
ECORE_API void ecore_animator_freeze(Ecore_Animator *animator);
/**
* @brief Restores execution of the specified animator.
@ -198,7 +198,7 @@ EAPI void ecore_animator_freeze(Ecore_Animator *animator);
* The specified @p animator will be put back in the set of animators that are
* executed during main loop.
*/
EAPI void ecore_animator_thaw(Ecore_Animator *animator);
ECORE_API void ecore_animator_thaw(Ecore_Animator *animator);
/**
* @}
@ -228,7 +228,7 @@ EAPI void ecore_animator_thaw(Ecore_Animator *animator);
* @c 0 it will be deleted automatically making any references/handles for it
* invalid.
*/
EAPI Ecore_Timer *ecore_timer_add(double in, Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Timer *ecore_timer_add(double in, Ecore_Task_Cb func, const void *data);
/**
* Creates a timer to call the given function in the given period of time.
@ -242,7 +242,7 @@ EAPI Ecore_Timer *ecore_timer_add(double in, Ecore_Task_Cb func, const void *dat
* ecore_loop_time_get() not ecore_time_get() as ecore_timer_add() uses. See
* ecore_timer_add() for more details.
*/
EAPI Ecore_Timer *ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Timer *ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data);
/**
* Deletes the specified timer from the timer list.
@ -253,7 +253,7 @@ EAPI Ecore_Timer *ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void
* Note: @p timer must be a valid handle. If the timer function has already
* returned @c 0, the handle is no longer valid (and does not need to be delete).
*/
EAPI void *ecore_timer_del(Ecore_Timer *timer);
ECORE_API void *ecore_timer_del(Ecore_Timer *timer);
/**
* Pauses a running timer.
@ -269,7 +269,7 @@ EAPI void *ecore_timer_del(Ecore_Timer *timer);
*
* @see ecore_timer_thaw()
*/
EAPI void ecore_timer_freeze(Ecore_Timer *timer);
ECORE_API void ecore_timer_freeze(Ecore_Timer *timer);
/**
* @brief Return whether the timer is freezing.
@ -278,7 +278,7 @@ EAPI void ecore_timer_freeze(Ecore_Timer *timer);
*
* @see ecore_timer_freeze(), ecore_timer_thaw()
*/
EAPI Eina_Bool ecore_timer_freeze_get(Ecore_Timer *timer);
ECORE_API Eina_Bool ecore_timer_freeze_get(Ecore_Timer *timer);
/**
* @brief Resumes a frozen (paused) timer.
@ -293,7 +293,7 @@ EAPI Eina_Bool ecore_timer_freeze_get(Ecore_Timer *timer);
*
* @see ecore_timer_freeze()
*/
EAPI void ecore_timer_thaw(Ecore_Timer *timer);
ECORE_API void ecore_timer_thaw(Ecore_Timer *timer);
#include "efl_loop_timer_eo.legacy.h"
@ -321,7 +321,7 @@ EAPI void ecore_timer_thaw(Ecore_Timer *timer);
*
* Idlers are useful for progressively processing data without blocking.
*/
EAPI Ecore_Idler *ecore_idler_add(Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Idler *ecore_idler_add(Ecore_Task_Cb func, const void *data);
/**
* Deletes an idler callback from the list to be executed.
@ -329,7 +329,7 @@ EAPI Ecore_Idler *ecore_idler_add(Ecore_Task_Cb func, const void *data);
* @return The data pointer passed to the idler callback on success, @c NULL
* otherwise.
*/
EAPI void *ecore_idler_del(Ecore_Idler *idler);
ECORE_API void *ecore_idler_del(Ecore_Idler *idler);
/**
* Adds an idle enterer handler.
@ -341,7 +341,7 @@ EAPI void *ecore_idler_del(Ecore_Idler *idler);
* idle state, as long as it returns @c 1 (or @c ECORE_CALLBACK_RENEW). A return of @c 0
* (or @c ECORE_CALLBACK_CANCEL) deletes the idle enterer.
*/
EAPI Ecore_Idle_Enterer *ecore_idle_enterer_add(Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Idle_Enterer *ecore_idle_enterer_add(Ecore_Task_Cb func, const void *data);
/**
* Adds an idle enterer handler at the start of the list so it gets called earlier than others.
@ -353,7 +353,7 @@ EAPI Ecore_Idle_Enterer *ecore_idle_enterer_add(Ecore_Task_Cb func, const void *
* idle state, as long as it returns @c 1 (or @c ECORE_CALLBACK_RENEW). A return of @c 0
* (or @c ECORE_CALLBACK_CANCEL) deletes the idle enterer.
*/
EAPI Ecore_Idle_Enterer *ecore_idle_enterer_before_add(Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Idle_Enterer *ecore_idle_enterer_before_add(Ecore_Task_Cb func, const void *data);
/**
* Deletes an idle enterer callback.
@ -361,7 +361,7 @@ EAPI Ecore_Idle_Enterer *ecore_idle_enterer_before_add(Ecore_Task_Cb func, const
* @return The data pointer passed to the idler enterer callback on success.
* @c NULL otherwise.
*/
EAPI void *ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer);
ECORE_API void *ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer);
/**
* Adds an idle exiter handler.
@ -372,7 +372,7 @@ EAPI void *ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer);
* idle state, as long as it returns @c 1 (or @c ECORE_CALLBACK_RENEW). A return of @c 0
* (or @c ECORE_CALLBACK_CANCEL) deletes the idle exiter.
*/
EAPI Ecore_Idle_Exiter *ecore_idle_exiter_add(Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Idle_Exiter *ecore_idle_exiter_add(Ecore_Task_Cb func, const void *data);
/**
* Deletes an idle exiter handler from the list to be run on exiting idle state.
@ -380,7 +380,7 @@ EAPI Ecore_Idle_Exiter *ecore_idle_exiter_add(Ecore_Task_Cb func, const void *da
* @return The data pointer that was being being passed to the handler if
* successful. @c NULL otherwise.
*/
EAPI void *ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter);
ECORE_API void *ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter);
/**
* @}
@ -412,22 +412,22 @@ EAPI void *ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter);
* added to the queue.
* @note Once the job has been executed, the job handle is invalid.
*/
EAPI Ecore_Job *ecore_job_add(Ecore_Cb func, const void *data);
ECORE_API Ecore_Job *ecore_job_add(Ecore_Cb func, const void *data);
/**
* Deletes a queued job that has not yet been executed.
* @param obj Handle of the job to delete.
* @return The data pointer that was to be passed to the job.
*/
EAPI void *ecore_job_del(Ecore_Job *obj);
ECORE_API void *ecore_job_del(Ecore_Job *obj);
/**
* @}
*/
#ifdef EFL_BETA_API_SUPPORT
EAPI Ecore_Animator *ecore_evas_animator_timeline_add(void *evo, double runtime, Ecore_Timeline_Cb func, const void *data);
EAPI Ecore_Animator *ecore_evas_animator_add(void *evo, Ecore_Task_Cb func, const void *data);
ECORE_API Ecore_Animator *ecore_evas_animator_timeline_add(void *evo, double runtime, Ecore_Timeline_Cb func, const void *data);
ECORE_API Ecore_Animator *ecore_evas_animator_add(void *evo, Ecore_Task_Cb func, const void *data);
#endif /* EFL_BETA_API_SUPPORT */
#endif

View File

@ -6,31 +6,8 @@
#include <Eina.h>
#include <Eo.h>
#include <Efl.h>
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_api.h>
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
@ -54,7 +31,7 @@
extern "C" {
#endif
EAPI extern double _efl_startup_time;
ECORE_API extern double _efl_startup_time;
#include "Ecore_Common.h"
#include "Ecore_Eo.h"
@ -63,9 +40,6 @@ EAPI extern double _efl_startup_time;
}
#endif
#undef EAPI
#define EAPI
#endif
// We are including efl_general.h again, just in case Efl_Core.h was already included before this

View File

@ -41,9 +41,9 @@
#endif
static Ecore_Version _version = { VMAJ, VMIN, VMIC, VREV };
EAPI Ecore_Version *ecore_version = &_version;
ECORE_API Ecore_Version *ecore_version = &_version;
EAPI double _efl_startup_time = 0;
ECORE_API double _efl_startup_time = 0;
#if defined(HAVE_MALLINFO) || defined(HAVE_MALLOC_INFO)
#define KEEP_MAX(Global, Local) \
@ -215,13 +215,13 @@ _efl_first_loop_iterate(void *data, const Efl_Event *event)
_efl_first_loop_iterate, data);
}
EAPI void
ECORE_API void
ecore_app_no_system_modules(void)
{
_no_system_modules = EINA_TRUE;
}
EAPI int
ECORE_API int
ecore_init(void)
{
if (++_ecore_init_count != 1)
@ -362,7 +362,7 @@ shutdown_evil:
return --_ecore_init_count;
}
EAPI int
ECORE_API int
ecore_shutdown(void)
{
Ecore_Pipe *p;
@ -470,7 +470,7 @@ ecore_shutdown(void)
static unsigned int _ecore_init_ex = 0;
EAPI unsigned int
ECORE_API unsigned int
ecore_init_ex(int argc, char **argv)
{
if (_ecore_init_ex++ != 0) return _ecore_init_ex;
@ -483,7 +483,7 @@ ecore_init_ex(int argc, char **argv)
return _ecore_init_ex;
}
EAPI unsigned int
ECORE_API unsigned int
ecore_shutdown_ex(void)
{
if (--_ecore_init_ex != 0) return _ecore_init_ex;
@ -505,7 +505,7 @@ typedef struct _Ecore_Fork_Cb Ecore_Fork_Cb;
static int fork_cbs_walking = 0;
static Eina_List *fork_cbs = NULL;
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_fork_reset_callback_add(Ecore_Cb func, const void *data)
{
Ecore_Fork_Cb *fcb;
@ -519,7 +519,7 @@ ecore_fork_reset_callback_add(Ecore_Cb func, const void *data)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_fork_reset_callback_del(Ecore_Cb func, const void *data)
{
Eina_List *l;
@ -542,7 +542,7 @@ ecore_fork_reset_callback_del(Ecore_Cb func, const void *data)
return EINA_FALSE;
}
EAPI void
ECORE_API void
ecore_fork_reset(void)
{
Eina_List *l, *ln;
@ -597,7 +597,7 @@ ecore_fork_reset(void)
#endif
}
EAPI void
ECORE_API void
ecore_main_loop_thread_safe_call_async(Ecore_Cb callback,
void *data)
{
@ -622,7 +622,7 @@ ecore_main_loop_thread_safe_call_async(Ecore_Cb callback,
_ecore_main_loop_thread_safe_call(order);
}
EAPI void *
ECORE_API void *
ecore_main_loop_thread_safe_call_sync(Ecore_Data_Cb callback,
void *data)
{
@ -662,7 +662,7 @@ ecore_main_loop_thread_safe_call_sync(Ecore_Data_Cb callback,
return ret;
}
EAPI void
ECORE_API void
ecore_main_loop_thread_safe_call_wait(double wait)
{
ecore_pipe_wait(_thread_call, 1, wait);
@ -670,7 +670,7 @@ ecore_main_loop_thread_safe_call_wait(double wait)
static Efl_Id_Domain _ecore_main_domain = EFL_ID_DOMAIN_INVALID;
EAPI int
ECORE_API int
ecore_thread_main_loop_begin(void)
{
Ecore_Safe_Call *order;
@ -720,7 +720,7 @@ ecore_thread_main_loop_begin(void)
return _thread_loop;
}
EAPI int
ECORE_API int
ecore_thread_main_loop_end(void)
{
int current_id;
@ -763,7 +763,7 @@ ecore_thread_main_loop_end(void)
return 0;
}
EAPI void
ECORE_API void
ecore_print_warning(const char *function EINA_UNUSED,
const char *sparam EINA_UNUSED)
{
@ -776,7 +776,7 @@ ecore_print_warning(const char *function EINA_UNUSED,
if (getenv("ECORE_ERROR_ABORT")) abort();
}
EAPI void
ECORE_API void
_ecore_magic_fail(const void *d,
Ecore_Magic m,
Ecore_Magic req_m,
@ -1092,13 +1092,13 @@ _thread_callback(void *data EINA_UNUSED,
_ecore_main_call_flush();
}
EAPI Ecore_Power_State
ECORE_API Ecore_Power_State
ecore_power_state_get(void)
{
return _ecore_power_state;
}
EAPI void
ECORE_API void
ecore_power_state_set(Ecore_Power_State state)
{
if (_ecore_power_state == state) return;
@ -1106,13 +1106,13 @@ ecore_power_state_set(Ecore_Power_State state)
ecore_event_add(ECORE_EVENT_POWER_STATE, NULL, NULL, NULL);
}
EAPI Ecore_Memory_State
ECORE_API Ecore_Memory_State
ecore_memory_state_get(void)
{
return _ecore_memory_state;
}
EAPI void
ECORE_API void
ecore_memory_state_set(Ecore_Memory_State state)
{
if (_ecore_memory_state == state) return;

View File

@ -15,28 +15,6 @@
# include <sys/timerfd.h>
#endif
#ifdef _WIN32
# include <winsock2.h>
# include <evil_private.h> /* pipe */
# define pipe_write(fd, buffer, size) send((fd), (char *)(buffer), size, 0)
# define pipe_read(fd, buffer, size) recv((fd), (char *)(buffer), size, 0)
# define pipe_close(fd) closesocket(fd)
# define PIPE_FD_ERROR SOCKET_ERROR
#else
# include <sys/select.h>
# include <fcntl.h>
# define pipe_write(fd, buffer, size) write((fd), buffer, size)
# define pipe_read(fd, buffer, size) read((fd), buffer, size)
# define pipe_close(fd) close(fd)
# define PIPE_FD_ERROR -1
#endif /* ! _WIN32 */
#ifdef HAVE_PRCTL
# include <sys/prctl.h>
#endif
@ -106,7 +84,7 @@ static void
_tick_send(signed char val)
{
DBG("_tick_send(%i)", val);
if (pipe_write(timer_fd_write, &val, 1) != 1)
if (eina_pipe_write(timer_fd_write, &val, 1) != 1)
{
ERR("Cannot write to animator control fd");
}
@ -259,7 +237,7 @@ _timer_tick_core(void *data EINA_UNUSED, Ecore_Thread *thread)
}
if (data_control)
{
if (pipe_read(timer_fd_read, &tick, sizeof(tick)) != 1)
if (eina_pipe_read(timer_fd_read, &tick, sizeof(tick)) != 1)
{
ERR("Cannot read from animator control fd");
}
@ -308,7 +286,7 @@ _timer_tick_core(void *data EINA_UNUSED, Ecore_Thread *thread)
data_timeout = EINA_TRUE;
if (data_control)
{
if (pipe_read(timer_fd_read, &tick, sizeof(tick)) != 1)
if (eina_pipe_read(timer_fd_read, &tick, sizeof(tick)) != 1)
{
ERR("Cannot read from animator control fd");
}
@ -334,9 +312,9 @@ done:
timerfd = -1;
}
#endif
pipe_close(timer_fd_read);
eina_pipe_free(timer_fd_read);
timer_fd_read = -1;
pipe_close(timer_fd_write);
eina_pipe_free(timer_fd_write);
timer_fd_write = -1;
}
@ -378,12 +356,12 @@ _timer_tick_finished(void *data EINA_UNUSED, Ecore_Thread *thread EINA_UNUSED)
tick_queue_count = 0;
if (timer_fd_read >= 0)
{
pipe_close(timer_fd_read);
eina_pipe_free(timer_fd_read);
timer_fd_read = -1;
}
if (timer_fd_write >= 0)
{
pipe_close(timer_fd_write);
eina_pipe_free(timer_fd_write);
timer_fd_write = -1;
}
}
@ -395,7 +373,7 @@ _timer_tick_begin(void)
{
int fds[2];
if (pipe(fds) != 0) return;
if (eina_pipe_new(fds) != 0) return;
eina_file_close_on_exec(fds[0], EINA_TRUE);
eina_file_close_on_exec(fds[1], EINA_TRUE);
timer_fd_read = fds[0];
@ -534,14 +512,14 @@ _ecore_animator_add(Ecore_Task_Cb func,
return animator;
}
EAPI Ecore_Animator *
ECORE_API Ecore_Animator *
ecore_animator_add(Ecore_Task_Cb func,
const void *data)
{
return _ecore_animator_add(func, data);
}
EAPI Ecore_Animator *
ECORE_API Ecore_Animator *
ecore_animator_timeline_add(double runtime,
Ecore_Timeline_Cb func,
const void *data)
@ -747,7 +725,7 @@ _pos_map_cubic_bezier(double pos,
#define SUB(A, B) eina_f32p32_sub(A, B)
#define MUL(A, B) eina_f32p32_mul(A, B)
EAPI double
ECORE_API double
ecore_animator_pos_map_n(double pos,
Ecore_Pos_Map map,
int v_size,
@ -830,7 +808,7 @@ ecore_animator_pos_map_n(double pos,
return pos;
}
EAPI double
ECORE_API double
ecore_animator_pos_map(double pos,
Ecore_Pos_Map map,
double v1,
@ -843,7 +821,7 @@ ecore_animator_pos_map(double pos,
return ecore_animator_pos_map_n(pos, map, 2, v);
}
EAPI void *
ECORE_API void *
ecore_animator_del(Ecore_Animator *animator)
{
void *data = NULL;
@ -871,7 +849,7 @@ ecore_animator_del(Ecore_Animator *animator)
return data;
}
EAPI void
ECORE_API void
ecore_animator_frametime_set(double frametime)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -882,14 +860,14 @@ ecore_animator_frametime_set(double frametime)
if (_have_animators()) _begin_tick();
}
EAPI double
ECORE_API double
ecore_animator_frametime_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
return animators_frametime;
}
EAPI void
ECORE_API void
ecore_animator_freeze(Ecore_Animator *animator)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -907,7 +885,7 @@ ecore_animator_freeze(Ecore_Animator *animator)
if (!_have_animators()) _end_tick();
}
EAPI void
ECORE_API void
ecore_animator_thaw(Ecore_Animator *animator)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -925,7 +903,7 @@ ecore_animator_thaw(Ecore_Animator *animator)
if (_have_animators()) _begin_tick();
}
EAPI void
ECORE_API void
ecore_animator_source_set(Ecore_Animator_Source source)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -938,14 +916,14 @@ ecore_animator_source_set(Ecore_Animator_Source source)
if (_have_animators()) _begin_tick();
}
EAPI Ecore_Animator_Source
ECORE_API Ecore_Animator_Source
ecore_animator_source_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
return src;
}
EAPI void
ECORE_API void
ecore_animator_custom_source_tick_begin_callback_set(Ecore_Cb func,
const void *data)
{
@ -956,7 +934,7 @@ ecore_animator_custom_source_tick_begin_callback_set(Ecore_Cb func,
if (_have_animators()) _begin_tick();
}
EAPI void
ECORE_API void
ecore_animator_custom_source_tick_end_callback_set(Ecore_Cb func,
const void *data)
{
@ -967,7 +945,7 @@ ecore_animator_custom_source_tick_end_callback_set(Ecore_Cb func,
if (_have_animators()) _begin_tick();
}
EAPI void
ECORE_API void
ecore_animator_custom_tick(void)
{
EINA_MAIN_LOOP_CHECK_RETURN;

34
src/lib/ecore/ecore_api.h Normal file
View File

@ -0,0 +1,34 @@
#ifndef _EFL_CORE_API_H
#define _EFL_CORE_API_H
#ifdef ECORE_API
#error ECORE_API should not be already defined
#endif
#ifdef _WIN32
# ifndef ECORE_STATIC
# ifdef ECORE_BUILD
# define ECORE_API __declspec(dllexport)
# else
# define ECORE_API __declspec(dllimport)
# endif
# else
# define ECORE_API
# endif
# define ECORE_API_WEAK
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define ECORE_API __attribute__ ((visibility("default")))
# define ECORE_API_WEAK __attribute__ ((weak))
# else
# define ECORE_API
# define ECORE_API_WEAK
# endif
# else
# define ECORE_API
# define ECORE_API_WEAK
# endif
#endif
#endif

View File

@ -11,7 +11,7 @@
static int app_argc = 0;
static char **app_argv = NULL;
EAPI void
ECORE_API void
ecore_app_args_set(int argc,
const char **argv)
{
@ -25,7 +25,7 @@ ecore_app_args_set(int argc,
app_argv = (char **)argv;
}
EAPI void
ECORE_API void
ecore_app_args_get(int *argc,
char ***argv)
{
@ -35,7 +35,7 @@ ecore_app_args_get(int *argc,
if (argv) *argv = app_argv;
}
EAPI void
ECORE_API void
ecore_app_restart(void)
{
EINA_MAIN_LOOP_CHECK_RETURN;

View File

@ -9,7 +9,7 @@
static Ecore_Event_Message_Handler *_event_msg_handler = NULL;
EAPI Ecore_Event_Handler *
ECORE_API Ecore_Event_Handler *
ecore_event_handler_add(int type,
Ecore_Event_Handler_Cb func,
const void *data)
@ -18,7 +18,7 @@ ecore_event_handler_add(int type,
type, func, (void *)data);
}
EAPI Ecore_Event_Handler *
ECORE_API Ecore_Event_Handler *
ecore_event_handler_prepend(int type,
Ecore_Event_Handler_Cb func,
const void *data)
@ -27,20 +27,20 @@ ecore_event_handler_prepend(int type,
type, func, (void *)data);
}
EAPI void *
ECORE_API void *
ecore_event_handler_del(Ecore_Event_Handler *event_handler)
{
return ecore_event_message_handler_del(_event_msg_handler,
event_handler);
}
EAPI void *
ECORE_API void *
ecore_event_handler_data_get(Ecore_Event_Handler *eh)
{
return ecore_event_message_handler_data_get(_event_msg_handler, eh);
}
EAPI void *
ECORE_API void *
ecore_event_handler_data_set(Ecore_Event_Handler *eh,
const void *data)
{
@ -48,7 +48,7 @@ ecore_event_handler_data_set(Ecore_Event_Handler *eh,
(void *)data);
}
EAPI Ecore_Event *
ECORE_API Ecore_Event *
ecore_event_add(int type,
void *ev,
Ecore_End_Cb func_free,
@ -66,7 +66,7 @@ ecore_event_add(int type,
return (Ecore_Event *)msg;
}
EAPI void *
ECORE_API void *
ecore_event_del(Ecore_Event *event)
{
void *data = NULL;
@ -76,13 +76,13 @@ ecore_event_del(Ecore_Event *event)
return data;
}
EAPI int
ECORE_API int
ecore_event_type_new(void)
{
return ecore_event_message_handler_type_new(_event_msg_handler);
}
EAPI Ecore_Event_Filter *
ECORE_API Ecore_Event_Filter *
ecore_event_filter_add(Ecore_Data_Cb func_start,
Ecore_Filter_Cb func_filter,
Ecore_End_Cb func_end,
@ -93,19 +93,19 @@ ecore_event_filter_add(Ecore_Data_Cb func_start,
func_end, (void *)data);
}
EAPI void *
ECORE_API void *
ecore_event_filter_del(Ecore_Event_Filter *ef)
{
return ecore_event_message_handler_filter_del(_event_msg_handler, ef);
}
EAPI int
ECORE_API int
ecore_event_current_type_get(void)
{
return ecore_event_message_handler_current_type_get(_event_msg_handler);
}
EAPI void *
ECORE_API void *
ecore_event_current_event_get(void)
{
return ecore_event_message_handler_current_event_get(_event_msg_handler);
@ -192,7 +192,7 @@ _ecore_event_signal_realtime_new(void)
return calloc(1, sizeof(Ecore_Event_Signal_Realtime));
}
EAPI void
ECORE_API void
ecore_event_type_flush_internal(int type, ...)
{
va_list args;

View File

@ -33,26 +33,26 @@ struct _ecore_exe_dead_exe
char *cmd;
};
EAPI int ECORE_EXE_EVENT_ADD = 0;
EAPI int ECORE_EXE_EVENT_DEL = 0;
EAPI int ECORE_EXE_EVENT_DATA = 0;
EAPI int ECORE_EXE_EVENT_ERROR = 0;
ECORE_API int ECORE_EXE_EVENT_ADD = 0;
ECORE_API int ECORE_EXE_EVENT_DEL = 0;
ECORE_API int ECORE_EXE_EVENT_DATA = 0;
ECORE_API int ECORE_EXE_EVENT_ERROR = 0;
EAPI void
ECORE_API void
ecore_exe_run_priority_set(int pri)
{
EINA_MAIN_LOOP_CHECK_RETURN;
_impl_ecore_exe_run_priority_set(pri);
}
EAPI int
ECORE_API int
ecore_exe_run_priority_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
return _impl_ecore_exe_run_priority_get();
}
EAPI Ecore_Exe *
ECORE_API Ecore_Exe *
ecore_exe_run(const char *exe_cmd,
const void *data)
{
@ -60,7 +60,7 @@ ecore_exe_run(const char *exe_cmd,
return ecore_exe_pipe_run(exe_cmd, 0, data);
}
EAPI Ecore_Exe *
ECORE_API Ecore_Exe *
ecore_exe_pipe_run(const char *exe_cmd,
Ecore_Exe_Flags flags,
const void *data)
@ -101,7 +101,7 @@ _ecore_exe_efl_object_finalize(Eo *obj, Ecore_Exe_Data *exe)
return _impl_ecore_exe_efl_object_finalize(obj, exe);
}
EAPI void
ECORE_API void
ecore_exe_callback_pre_free_set(Ecore_Exe *obj,
Ecore_Exe_Cb func)
{
@ -111,7 +111,7 @@ ecore_exe_callback_pre_free_set(Ecore_Exe *obj,
exe->pre_free_cb = func;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_exe_send(Ecore_Exe *obj,
const void *data,
int size)
@ -130,7 +130,7 @@ ecore_exe_send(Ecore_Exe *obj,
return _impl_ecore_exe_send(obj, exe, data, size);
}
EAPI void
ECORE_API void
ecore_exe_close_stdin(Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -139,7 +139,7 @@ ecore_exe_close_stdin(Ecore_Exe *obj)
exe->close_stdin = 1;
}
EAPI void
ECORE_API void
ecore_exe_auto_limits_set(Ecore_Exe *obj,
int start_bytes,
int end_bytes,
@ -153,7 +153,7 @@ ecore_exe_auto_limits_set(Ecore_Exe *obj,
start_lines, end_lines);
}
EAPI Ecore_Exe_Event_Data *
ECORE_API Ecore_Exe_Event_Data *
ecore_exe_event_data_get(Ecore_Exe *obj,
Ecore_Exe_Flags flags)
{
@ -163,7 +163,7 @@ ecore_exe_event_data_get(Ecore_Exe *obj,
return _impl_ecore_exe_event_data_get(obj, exe, flags);
}
EAPI void
ECORE_API void
ecore_exe_tag_set(Ecore_Exe *obj,
const char *tag)
{
@ -175,7 +175,7 @@ ecore_exe_tag_set(Ecore_Exe *obj,
else exe->tag = NULL;
}
EAPI const char *
ECORE_API const char *
ecore_exe_tag_get(const Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
@ -184,7 +184,7 @@ ecore_exe_tag_get(const Ecore_Exe *obj)
return exe->tag;
}
EAPI void *
ECORE_API void *
ecore_exe_free(Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
@ -202,7 +202,7 @@ _ecore_exe_efl_object_destructor(Eo *obj, Ecore_Exe_Data *exe)
_impl_ecore_exe_efl_object_destructor(obj, exe);
}
EAPI void
ECORE_API void
ecore_exe_event_data_free(Ecore_Exe_Event_Data *e)
{
if (!e) return;
@ -211,7 +211,7 @@ ecore_exe_event_data_free(Ecore_Exe_Event_Data *e)
free(e);
}
EAPI pid_t
ECORE_API pid_t
ecore_exe_pid_get(const Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
@ -220,7 +220,7 @@ ecore_exe_pid_get(const Ecore_Exe *obj)
return exe->pid;
}
EAPI const char *
ECORE_API const char *
ecore_exe_cmd_get(const Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
@ -229,7 +229,7 @@ ecore_exe_cmd_get(const Ecore_Exe *obj)
return ret;
}
EAPI void *
ECORE_API void *
ecore_exe_data_get(const Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
@ -238,7 +238,7 @@ ecore_exe_data_get(const Ecore_Exe *obj)
return exe->data;
}
EAPI void *
ECORE_API void *
ecore_exe_data_set(Ecore_Exe *obj,
void *data)
{
@ -251,7 +251,7 @@ ecore_exe_data_set(Ecore_Exe *obj,
return ret;
}
EAPI Ecore_Exe_Flags
ECORE_API Ecore_Exe_Flags
ecore_exe_flags_get(const Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
@ -260,13 +260,13 @@ ecore_exe_flags_get(const Ecore_Exe *obj)
return exe->flags;
}
EAPI void
ECORE_API void
ecore_exe_pause(Ecore_Exe *obj)
{
efl_control_suspend_set(obj, EINA_TRUE);
}
EAPI void
ECORE_API void
ecore_exe_continue(Ecore_Exe *obj)
{
efl_control_suspend_set(obj, EINA_FALSE);
@ -280,7 +280,7 @@ _ecore_exe_efl_control_suspend_set(Eo *obj EINA_UNUSED, Ecore_Exe_Data *exe, Ein
else _impl_ecore_exe_continue(obj, exe);
}
EAPI void
ECORE_API void
ecore_exe_interrupt(Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -289,7 +289,7 @@ ecore_exe_interrupt(Ecore_Exe *obj)
_impl_ecore_exe_interrupt(obj, exe);
}
EAPI void
ECORE_API void
ecore_exe_quit(Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -298,7 +298,7 @@ ecore_exe_quit(Ecore_Exe *obj)
_impl_ecore_exe_quit(obj, exe);
}
EAPI void
ECORE_API void
ecore_exe_terminate(Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -307,7 +307,7 @@ ecore_exe_terminate(Ecore_Exe *obj)
_impl_ecore_exe_terminate(obj, exe);
}
EAPI void
ECORE_API void
ecore_exe_kill(Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -316,7 +316,7 @@ ecore_exe_kill(Ecore_Exe *obj)
_impl_ecore_exe_kill(obj, exe);
}
EAPI void
ECORE_API void
ecore_exe_signal(Ecore_Exe *obj,
int num)
{
@ -326,7 +326,7 @@ ecore_exe_signal(Ecore_Exe *obj,
_impl_ecore_exe_signal(obj, exe, num);
}
EAPI void
ECORE_API void
ecore_exe_hup(Ecore_Exe *obj)
{
EINA_MAIN_LOOP_CHECK_RETURN;

View File

@ -1,15 +1,15 @@
EWAPI const Efl_Event_Description _ECORE_EXE_EVENT_DATA_GET =
ECORE_API ECORE_API_WEAK const Efl_Event_Description _ECORE_EXE_EVENT_DATA_GET =
EFL_EVENT_DESCRIPTION("data,get");
EWAPI const Efl_Event_Description _ECORE_EXE_EVENT_DATA_ERROR =
ECORE_API ECORE_API_WEAK const Efl_Event_Description _ECORE_EXE_EVENT_DATA_ERROR =
EFL_EVENT_DESCRIPTION("data,error");
void _ecore_exe_command_set(Eo *obj, Ecore_Exe_Data *pd, const char *exe_cmd, Ecore_Exe_Flags flags);
EOAPI EFL_VOID_FUNC_BODYV(ecore_obj_exe_command_set, EFL_FUNC_CALL(exe_cmd, flags), const char *exe_cmd, Ecore_Exe_Flags flags);
ECORE_API ECORE_API_WEAK EFL_VOID_FUNC_BODYV(ecore_obj_exe_command_set, EFL_FUNC_CALL(exe_cmd, flags), const char *exe_cmd, Ecore_Exe_Flags flags);
void _ecore_exe_command_get(const Eo *obj, Ecore_Exe_Data *pd, const char **exe_cmd, Ecore_Exe_Flags *flags);
EOAPI EFL_VOID_FUNC_BODYV_CONST(ecore_obj_exe_command_get, EFL_FUNC_CALL(exe_cmd, flags), const char **exe_cmd, Ecore_Exe_Flags *flags);
ECORE_API ECORE_API_WEAK EFL_VOID_FUNC_BODYV_CONST(ecore_obj_exe_command_get, EFL_FUNC_CALL(exe_cmd, flags), const char **exe_cmd, Ecore_Exe_Flags *flags);
void _ecore_exe_efl_object_destructor(Eo *obj, Ecore_Exe_Data *pd);

View File

@ -80,7 +80,7 @@ typedef enum
*/
#define ECORE_EXE_CLASS ecore_exe_class_get()
EWAPI const Efl_Class *ecore_exe_class_get(void) EINA_CONST;
ECORE_API ECORE_API_WEAK const Efl_Class *ecore_exe_class_get(void) EINA_CONST;
/**
* @brief Controls the command that's executed. FIXME: May need a split/rename.
@ -91,7 +91,7 @@ EWAPI const Efl_Class *ecore_exe_class_get(void) EINA_CONST;
*
* @ingroup Ecore_Exe
*/
EOAPI void ecore_obj_exe_command_set(Eo *obj, const char *exe_cmd, Ecore_Exe_Flags flags);
ECORE_API ECORE_API_WEAK void ecore_obj_exe_command_set(Eo *obj, const char *exe_cmd, Ecore_Exe_Flags flags);
/**
* @brief Controls the command that's executed. FIXME: May need a split/rename.
@ -102,9 +102,9 @@ EOAPI void ecore_obj_exe_command_set(Eo *obj, const char *exe_cmd, Ecore_Exe_Fla
*
* @ingroup Ecore_Exe
*/
EOAPI void ecore_obj_exe_command_get(const Eo *obj, const char **exe_cmd, Ecore_Exe_Flags *flags);
ECORE_API ECORE_API_WEAK void ecore_obj_exe_command_get(const Eo *obj, const char **exe_cmd, Ecore_Exe_Flags *flags);
EWAPI extern const Efl_Event_Description _ECORE_EXE_EVENT_DATA_GET;
ECORE_API ECORE_API_WEAK extern const Efl_Event_Description _ECORE_EXE_EVENT_DATA_GET;
/** Data received event from the child process
* @return Ecore_Exe_Event_Data
@ -113,7 +113,7 @@ EWAPI extern const Efl_Event_Description _ECORE_EXE_EVENT_DATA_GET;
*/
#define ECORE_EXE_EVENT_DATA_GET (&(_ECORE_EXE_EVENT_DATA_GET))
EWAPI extern const Efl_Event_Description _ECORE_EXE_EVENT_DATA_ERROR;
ECORE_API ECORE_API_WEAK extern const Efl_Event_Description _ECORE_EXE_EVENT_DATA_ERROR;
/** Error received event from the child process
* @return Ecore_Exe_Event_Data

View File

@ -133,10 +133,10 @@ struct _Ecore_Exe_Data
typedef struct _Ecore_Exe_Data Ecore_Exe_Data;
EAPI extern int ECORE_EXE_EVENT_ADD;
EAPI extern int ECORE_EXE_EVENT_DEL;
EAPI extern int ECORE_EXE_EVENT_DATA;
EAPI extern int ECORE_EXE_EVENT_ERROR;
ECORE_API extern int ECORE_EXE_EVENT_ADD;
ECORE_API extern int ECORE_EXE_EVENT_DEL;
ECORE_API extern int ECORE_EXE_EVENT_DATA;
ECORE_API extern int ECORE_EXE_EVENT_ERROR;
Ecore_Exe *_ecore_exe_find(pid_t pid);
void *_ecore_exe_event_del_new(void);

View File

@ -810,7 +810,7 @@ _ecore_getopt_help_prepare(const Ecore_Getopt *parser)
return EINA_TRUE;
}
EAPI void
ECORE_API void
ecore_getopt_help(FILE *fp,
const Ecore_Getopt *parser)
{
@ -822,7 +822,7 @@ ecore_getopt_help(FILE *fp,
_ecore_getopt_help_options(fp, parser);
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_getopt_help_category(FILE *fp,
const Ecore_Getopt *parser,
const char *category)
@ -1977,7 +1977,7 @@ _ecore_getopt_parse_find_long_other(const Ecore_Getopt *parser,
return NULL;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_getopt_parser_has_duplicates(const Ecore_Getopt *parser)
{
const Ecore_Getopt_Desc *desc = parser->descs;
@ -2028,7 +2028,7 @@ _ecore_getopt_find_help(const Ecore_Getopt *parser)
return NULL;
}
EAPI int
ECORE_API int
ecore_getopt_parse(const Ecore_Getopt *parser,
Ecore_Getopt_Value *values,
int argc,
@ -2092,7 +2092,7 @@ error:
return -1;
}
EAPI int
ECORE_API int
ecore_getopt_parse_positional(const Ecore_Getopt *parser,
Ecore_Getopt_Value *values,
int argc,
@ -2159,7 +2159,7 @@ error:
return -1;
}
EAPI Eina_List *
ECORE_API Eina_List *
ecore_getopt_list_free(Eina_List *list)
{
void *data;
@ -2169,7 +2169,7 @@ ecore_getopt_list_free(Eina_List *list)
return NULL;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser EINA_UNUSED,
const Ecore_Getopt_Desc *desc EINA_UNUSED,
const char *str,
@ -2187,7 +2187,7 @@ ecore_getopt_callback_geometry_parse(const Ecore_Getopt *parser EINA_UNUSED
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_getopt_callback_size_parse(const Ecore_Getopt *parser EINA_UNUSED,
const Ecore_Getopt_Desc *desc EINA_UNUSED,
const char *str,

View File

@ -139,6 +139,7 @@ _ecore_glib_context_poll_to(GPollFD *pfds,
ready--;
if (!fstat(itr->fd, &st))
{
#ifndef _MSC_VER
if (S_ISSOCK(st.st_mode))
{
struct sockaddr_in peer;
@ -149,6 +150,7 @@ _ecore_glib_context_poll_to(GPollFD *pfds,
&length))
itr->revents |= G_IO_ERR;
}
#endif
}
}
if (FD_ISSET(itr->fd, efds) && (itr->events & (G_IO_HUP | G_IO_ERR)))
@ -286,7 +288,7 @@ _ecore_glib_shutdown(void)
#endif
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_main_loop_glib_integrate(void)
{
#ifdef HAVE_GLIB
@ -310,7 +312,7 @@ ecore_main_loop_glib_integrate(void)
Eina_Bool _ecore_glib_always_integrate = 1;
EAPI void
ECORE_API void
ecore_main_loop_glib_always_integrate_disable(void)
{
_ecore_glib_always_integrate = 0;

View File

@ -14,14 +14,14 @@ EFL_CALLBACKS_ARRAY_DEFINE(ecore_idle_enterer_callbacks,
{ EFL_EVENT_DEL, _ecore_factorized_idle_event_del });
EAPI Ecore_Idle_Enterer *
ECORE_API Ecore_Idle_Enterer *
ecore_idle_enterer_add(Ecore_Task_Cb func,
const void *data)
{
return _ecore_factorized_idle_add(ecore_idle_enterer_callbacks(), func, data);
}
EAPI Ecore_Idle_Enterer *
ECORE_API Ecore_Idle_Enterer *
ecore_idle_enterer_before_add(Ecore_Task_Cb func,
const void *data)
{
@ -36,7 +36,7 @@ ecore_idle_enterer_before_add(Ecore_Task_Cb func,
return ie;
}
EAPI void *
ECORE_API void *
ecore_idle_enterer_del(Ecore_Idle_Enterer *idle_enterer)
{
return _ecore_factorized_idle_del(idle_enterer);

View File

@ -13,14 +13,14 @@ EFL_CALLBACKS_ARRAY_DEFINE(ecore_idle_exiter_callbacks,
{ EFL_LOOP_EVENT_IDLE_EXIT, _ecore_factorized_idle_process },
{ EFL_EVENT_DEL, _ecore_factorized_idle_event_del });
EAPI Ecore_Idle_Exiter *
ECORE_API Ecore_Idle_Exiter *
ecore_idle_exiter_add(Ecore_Task_Cb func,
const void *data)
{
return _ecore_factorized_idle_add(ecore_idle_exiter_callbacks(), func, data);
}
EAPI void *
ECORE_API void *
ecore_idle_exiter_del(Ecore_Idle_Exiter *idle_exiter)
{
return _ecore_factorized_idle_del(idle_exiter);

View File

@ -105,14 +105,14 @@ EFL_CALLBACKS_ARRAY_DEFINE(ecore_idler_callbacks,
{ EFL_LOOP_EVENT_IDLE, _ecore_factorized_idle_process },
{ EFL_EVENT_DEL, _ecore_factorized_idle_event_del });
EAPI Ecore_Idler *
ECORE_API Ecore_Idler *
ecore_idler_add(Ecore_Task_Cb func,
const void *data)
{
return _ecore_factorized_idle_add(ecore_idler_callbacks(), func, data);
}
EAPI void *
ECORE_API void *
ecore_idler_del(Ecore_Idler *idler)
{
return _ecore_factorized_idle_del(idler);

View File

@ -2,34 +2,10 @@
#ifndef _ECORE_INTERNAL_H
#define _ECORE_INTERNAL_H
#ifdef EAPI
# undef EAPI
#endif
#include <ecore_api.h>
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
EAPI void ecore_loop_arguments_send(int argc, const char **argv);
EAPI Eina_Bool efl_loop_message_process(Eo *obj);
ECORE_API void ecore_loop_arguments_send(int argc, const char **argv);
ECORE_API Eina_Bool efl_loop_message_process(Eo *obj);
static inline Eina_Value
efl_model_list_value_get(Eina_List *childrens,
@ -162,7 +138,4 @@ _efl_future_all_repack(Eo *o EINA_UNUSED, void *data EINA_UNUSED, const Eina_Val
return eina_value_error_init(EFL_MODEL_ERROR_UNKNOWN);
}
#undef EAPI
#define EAPI
#endif

View File

@ -39,7 +39,7 @@ _ecore_job_shutdown(void)
_ecore_job_handler = NULL;
}
EAPI Ecore_Job *
ECORE_API Ecore_Job *
ecore_job_add(Ecore_Cb func,
const void *data)
{
@ -69,7 +69,7 @@ ecore_job_add(Ecore_Cb func,
return job;
}
EAPI void *
ECORE_API void *
ecore_job_del(Ecore_Job *job)
{
void *data;

View File

@ -209,7 +209,7 @@ static gboolean ecore_fds_ready;
static double _ecore_main_loop_wakeup_time = 0.0;
EAPI double _ecore_main_loop_wakeup_time_get(void)
ECORE_API double _ecore_main_loop_wakeup_time_get(void)
{
return _ecore_main_loop_wakeup_time;
}
@ -1280,21 +1280,21 @@ _ecore_main_loop_quit(Eo *obj, Efl_Loop_Data *pd)
#endif
}
EAPI void
ECORE_API void
ecore_main_loop_iterate(void)
{
EINA_MAIN_LOOP_CHECK_RETURN;
efl_loop_iterate(ML_OBJ);
}
EAPI int
ECORE_API int
ecore_main_loop_iterate_may_block(int may_block)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
return efl_loop_iterate_may_block(ML_OBJ, may_block);
}
EAPI void
ECORE_API void
ecore_main_loop_begin(void)
{
DBG("ecore_main_loop_begin");
@ -1304,7 +1304,7 @@ ecore_main_loop_begin(void)
eina_evlog("-mainloop", NULL, 0.0, NULL);
}
EAPI void
ECORE_API void
ecore_main_loop_quit(void)
{
Eina_Value v = EINA_VALUE_EMPTY;
@ -1315,27 +1315,27 @@ ecore_main_loop_quit(void)
efl_loop_quit(ML_OBJ, v);
}
EAPI int
ECORE_API int
ecore_main_loop_nested_get(void)
{
return in_main_loop;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_main_loop_animator_ticked_get(void)
{
DBG("ecore_main_loop_animator_ticked_get");
return _ecore_animator_run_get();
}
EAPI void
ECORE_API void
ecore_main_loop_select_func_set(Ecore_Select_Function func)
{
EINA_MAIN_LOOP_CHECK_RETURN;
main_loop_select = func;
}
EAPI Ecore_Select_Function
ECORE_API Ecore_Select_Function
ecore_main_loop_select_func_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
@ -1432,7 +1432,7 @@ _ecore_main_fd_handler_del(Eo *obj EINA_UNUSED,
return r;
}
EAPI Ecore_Fd_Handler *
ECORE_API Ecore_Fd_Handler *
ecore_main_fd_handler_add(int fd,
Ecore_Fd_Handler_Flags flags,
Ecore_Fd_Cb func,
@ -1449,7 +1449,7 @@ ecore_main_fd_handler_add(int fd,
return fdh;
}
EAPI Ecore_Fd_Handler *
ECORE_API Ecore_Fd_Handler *
ecore_main_fd_handler_file_add(int fd,
Ecore_Fd_Handler_Flags flags,
Ecore_Fd_Cb func,
@ -1463,7 +1463,7 @@ ecore_main_fd_handler_file_add(int fd,
buf_func, buf_data, EINA_TRUE);
}
EAPI void *
ECORE_API void *
ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler)
{
if (!fd_handler) return NULL;
@ -1479,7 +1479,7 @@ ecore_main_fd_handler_del(Ecore_Fd_Handler *fd_handler)
}
#ifdef _WIN32
EAPI Ecore_Win32_Handler *
ECORE_API Ecore_Win32_Handler *
_ecore_main_win32_handler_add(Eo *obj,
Efl_Loop_Data *pd,
Eo *handler,
@ -1525,7 +1525,7 @@ _ecore_main_win32_handler_del(Eo *obj EINA_UNUSED,
return win32_handler->data;
}
EAPI Ecore_Win32_Handler *
ECORE_API Ecore_Win32_Handler *
ecore_main_win32_handler_add(void *h,
Ecore_Win32_Handle_Cb func,
const void *data)
@ -1534,7 +1534,7 @@ ecore_main_win32_handler_add(void *h,
return _ecore_main_win32_handler_add(ML_OBJ, ML_DAT, NULL, h, func, data);
}
EAPI void *
ECORE_API void *
ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler)
{
void *ret = NULL;
@ -1551,7 +1551,7 @@ ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler)
return ret;
}
#else
EAPI Ecore_Win32_Handler *
ECORE_API Ecore_Win32_Handler *
_ecore_main_win32_handler_add(Eo *obj EINA_UNUSED,
Efl_Loop_Data *pd EINA_UNUSED,
Eo *handler EINA_UNUSED,
@ -1570,7 +1570,7 @@ _ecore_main_win32_handler_del(Eo *obj EINA_UNUSED,
return NULL;
}
EAPI Ecore_Win32_Handler *
ECORE_API Ecore_Win32_Handler *
ecore_main_win32_handler_add(void *h EINA_UNUSED,
Ecore_Win32_Handle_Cb func EINA_UNUSED,
const void *data EINA_UNUSED)
@ -1578,14 +1578,14 @@ ecore_main_win32_handler_add(void *h EINA_UNUSED,
return NULL;
}
EAPI void *
ECORE_API void *
ecore_main_win32_handler_del(Ecore_Win32_Handler *win32_handler EINA_UNUSED)
{
return NULL;
}
#endif
EAPI void
ECORE_API void
ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler,
Ecore_Fd_Prep_Cb func,
const void *data)
@ -1610,7 +1610,7 @@ ecore_main_fd_handler_prepare_callback_set(Ecore_Fd_Handler *fd_handler,
(pd->fd_handlers_with_prep, fd_handler);
}
EAPI int
ECORE_API int
ecore_main_fd_handler_fd_get(Ecore_Fd_Handler *fd_handler)
{
if (!fd_handler) return -1;
@ -1626,7 +1626,7 @@ ecore_main_fd_handler_fd_get(Ecore_Fd_Handler *fd_handler)
return fd_handler->fd;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_main_fd_handler_active_get(Ecore_Fd_Handler *fd_handler,
Ecore_Fd_Handler_Flags flags)
{
@ -1646,7 +1646,7 @@ ecore_main_fd_handler_active_get(Ecore_Fd_Handler *fd_handler,
return ret;
}
EAPI void
ECORE_API void
ecore_main_fd_handler_active_set(Ecore_Fd_Handler *fd_handler,
Ecore_Fd_Handler_Flags flags)
{

View File

@ -36,14 +36,11 @@
*/
#define PIPE_FD_INVALID -1
#define PIPE_FD_ERROR -1
#ifdef _WIN32
# include <winsock2.h>
# include <evil_private.h> /* pipe fcntl */
# define pipe_write(fd, buffer, size) send((fd), (char *)(buffer), size, 0)
# define pipe_read(fd, buffer, size) recv((fd), (char *)(buffer), size, 0)
# define pipe_close(fd) closesocket(fd)
# define PIPE_FD_ERROR SOCKET_ERROR
#else
# ifdef HAVE_SYS_EPOLL_H
# include <sys/epoll.h>
@ -53,10 +50,6 @@
# endif
# include <unistd.h>
# include <fcntl.h>
# define pipe_write(fd, buffer, size) write((fd), buffer, size)
# define pipe_read(fd, buffer, size) read((fd), buffer, size)
# define pipe_close(fd) close(fd)
# define PIPE_FD_ERROR -1
#endif /* ! _WIN32 */
#include "Ecore.h"
@ -89,14 +82,14 @@ GENERIC_ALLOC_SIZE_DECLARE(Ecore_Pipe);
static Eina_Bool _ecore_pipe_read(void *data,
Ecore_Fd_Handler *fd_handler);
EAPI Ecore_Pipe *
ECORE_API Ecore_Pipe *
ecore_pipe_add(Ecore_Pipe_Cb handler,
const void *data)
{
return _ecore_pipe_add(handler, data);
}
EAPI void *
ECORE_API void *
ecore_pipe_del(Ecore_Pipe *p)
{
if (!p) return NULL;
@ -104,7 +97,7 @@ ecore_pipe_del(Ecore_Pipe *p)
return _ecore_pipe_del(p);
}
EAPI void
ECORE_API void
ecore_pipe_read_close(Ecore_Pipe *p)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -120,12 +113,12 @@ ecore_pipe_read_close(Ecore_Pipe *p)
}
if (p->fd_read != PIPE_FD_INVALID)
{
pipe_close(p->fd_read);
eina_pipe_free(p->fd_read);
p->fd_read = PIPE_FD_INVALID;
}
}
EAPI int
ECORE_API int
ecore_pipe_read_fd(Ecore_Pipe *p)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(PIPE_FD_INVALID);
@ -133,7 +126,7 @@ ecore_pipe_read_fd(Ecore_Pipe *p)
return p->fd_read;
}
EAPI void
ECORE_API void
ecore_pipe_freeze(Ecore_Pipe *p)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -149,7 +142,7 @@ ecore_pipe_freeze(Ecore_Pipe *p)
}
}
EAPI void
ECORE_API void
ecore_pipe_thaw(Ecore_Pipe *p)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -164,7 +157,7 @@ ecore_pipe_thaw(Ecore_Pipe *p)
NULL, NULL);
}
EAPI int
ECORE_API int
ecore_pipe_wait(Ecore_Pipe *p,
int message_count,
double wait)
@ -172,7 +165,7 @@ ecore_pipe_wait(Ecore_Pipe *p,
return _ecore_pipe_wait(p, message_count, wait);
}
EAPI void
ECORE_API void
ecore_pipe_write_close(Ecore_Pipe *p)
{
if (!ECORE_MAGIC_CHECK(p, ECORE_MAGIC_PIPE))
@ -182,12 +175,12 @@ ecore_pipe_write_close(Ecore_Pipe *p)
}
if (p->fd_write != PIPE_FD_INVALID)
{
pipe_close(p->fd_write);
eina_pipe_free(p->fd_write);
p->fd_write = PIPE_FD_INVALID;
}
}
EAPI int
ECORE_API int
ecore_pipe_write_fd(Ecore_Pipe *p)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(PIPE_FD_INVALID);
@ -195,7 +188,7 @@ ecore_pipe_write_fd(Ecore_Pipe *p)
return p->fd_write;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_pipe_write(Ecore_Pipe *p,
const void *buffer,
unsigned int nbytes)
@ -218,7 +211,7 @@ ecore_pipe_write(Ecore_Pipe *p,
do // First write the len into the pipe
{
ret = pipe_write(p->fd_write, &bytes, sizeof(bytes));
ret = eina_pipe_write(p->fd_write, &bytes, sizeof(bytes));
if (ret == sizeof(nbytes))
{
retry = ECORE_PIPE_WRITE_RETRY;
@ -233,7 +226,7 @@ ecore_pipe_write(Ecore_Pipe *p,
}
else if ((ret == PIPE_FD_ERROR) && (errno == EPIPE))
{
pipe_close(p->fd_write);
eina_pipe_free(p->fd_write);
p->fd_write = PIPE_FD_INVALID;
goto out;
}
@ -253,7 +246,7 @@ ecore_pipe_write(Ecore_Pipe *p,
do // and now pass the data to the pipe
{
ret = pipe_write(p->fd_write,
ret = eina_pipe_write(p->fd_write,
((unsigned char *)buffer) + already_written,
nbytes - already_written);
@ -269,7 +262,7 @@ ecore_pipe_write(Ecore_Pipe *p,
}
else if ((ret == PIPE_FD_ERROR) && (errno == EPIPE))
{
pipe_close(p->fd_write);
eina_pipe_free(p->fd_write);
p->fd_write = PIPE_FD_INVALID;
goto out;
}
@ -289,7 +282,7 @@ out:
return ok;
}
EAPI Ecore_Pipe *
ECORE_API Ecore_Pipe *
ecore_pipe_full_add(Ecore_Pipe_Cb handler,
const void *data,
int fd_read,
@ -308,7 +301,7 @@ ecore_pipe_full_add(Ecore_Pipe_Cb handler,
if ((fd_read == -1) && (fd_write == -1))
{
if (pipe(fds))
if (eina_pipe_new(fds))
{
ecore_pipe_mp_free(p);
return NULL;
@ -383,8 +376,8 @@ _ecore_pipe_del(Ecore_Pipe *p)
if (p->handling > 0) return (void *)p->data;
if (p->fd_handler) _ecore_main_fd_handler_del(ML_OBJ, ML_DAT,
p->fd_handler);
if (p->fd_read != PIPE_FD_INVALID) pipe_close(p->fd_read);
if (p->fd_write != PIPE_FD_INVALID) pipe_close(p->fd_write);
if (p->fd_read != PIPE_FD_INVALID) eina_pipe_free(p->fd_read);
if (p->fd_write != PIPE_FD_INVALID) eina_pipe_free(p->fd_write);
p->fd_handler = NULL;
p->fd_read = PIPE_FD_INVALID;
p->fd_write = PIPE_FD_INVALID;
@ -552,7 +545,7 @@ _ecore_pipe_wait(Ecore_Pipe *p,
if ((fd_timer_found) && (p->timerfd != PIPE_FD_INVALID))
{
if (pipe_read(p->timerfd, &timerfdbuf, sizeof(timerfdbuf)) <
if (eina_pipe_read(p->timerfd, &timerfdbuf, sizeof(timerfdbuf)) <
(int)sizeof(int64_t))
WRN("Could not read timerfd data");
_ecore_pipe_unhandle(p);
@ -612,7 +605,7 @@ _ecore_pipe_read(void *data,
if (p->len == 0)
{
// read the len of the passed data
ret = pipe_read(p->fd_read, &p->len, sizeof(p->len));
ret = eina_pipe_read(p->fd_read, &p->len, sizeof(p->len));
// catch the non error case first
// read amount ok - nothing more to do
@ -634,7 +627,7 @@ _ecore_pipe_read(void *data,
{
// no data on first try through means an error
_ecore_pipe_handler_call(p, NULL, 0);
pipe_close(p->fd_read);
eina_pipe_free(p->fd_read);
p->fd_read = PIPE_FD_INVALID;
p->fd_handler = NULL;
_ecore_pipe_unhandle(p);
@ -668,7 +661,7 @@ _ecore_pipe_read(void *data,
if (WSAGetLastError() != WSAEWOULDBLOCK)
{
_ecore_pipe_handler_call(p, NULL, 0);
pipe_close(p->fd_read);
eina_pipe_free(p->fd_read);
p->fd_read = PIPE_FD_INVALID;
p->fd_handler = NULL;
_ecore_pipe_unhandle(p);
@ -696,7 +689,7 @@ _ecore_pipe_read(void *data,
{
_ecore_pipe_handler_call(p, NULL, 0);
// close the pipe
pipe_close(p->fd_read);
eina_pipe_free(p->fd_read);
p->fd_read = PIPE_FD_INVALID;
p->fd_handler = NULL;
_ecore_pipe_unhandle(p);
@ -705,7 +698,7 @@ _ecore_pipe_read(void *data,
}
// and read the passed data
ret = pipe_read(p->fd_read,
ret = eina_pipe_read(p->fd_read,
((unsigned char *)p->passed_data) + p->already_read,
p->len - p->already_read);
@ -747,7 +740,7 @@ _ecore_pipe_read(void *data,
if (WSAGetLastError() != WSAEWOULDBLOCK)
{
_ecore_pipe_handler_call(p, NULL, 0);
pipe_close(p->fd_read);
eina_pipe_free(p->fd_read);
p->fd_read = PIPE_FD_INVALID;
p->fd_handler = NULL;
_ecore_pipe_unhandle(p);

View File

@ -211,7 +211,7 @@ _ecore_poller_cb_timer(void *data EINA_UNUSED)
return ECORE_CALLBACK_RENEW;
}
EAPI void
ECORE_API void
ecore_poller_poll_interval_set(Ecore_Poller_Type type EINA_UNUSED,
double poll_time)
{
@ -227,14 +227,14 @@ ecore_poller_poll_interval_set(Ecore_Poller_Type type EINA_UNUSED,
_ecore_poller_next_tick_eval();
}
EAPI double
ECORE_API double
ecore_poller_poll_interval_get(Ecore_Poller_Type type EINA_UNUSED)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
return poll_interval;
}
EAPI Ecore_Poller *
ECORE_API Ecore_Poller *
ecore_poller_add(Ecore_Poller_Type type EINA_UNUSED,
int interval,
Ecore_Task_Cb func,
@ -278,7 +278,7 @@ ecore_poller_add(Ecore_Poller_Type type EINA_UNUSED,
return poller;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_poller_poller_interval_set(Ecore_Poller *poller, int interval)
{
int ibit;
@ -310,7 +310,7 @@ ecore_poller_poller_interval_set(Ecore_Poller *poller, int interval)
return EINA_TRUE;
}
EAPI int
ECORE_API int
ecore_poller_poller_interval_get(const Ecore_Poller *poller)
{
int ibit, interval = 1;
@ -328,7 +328,7 @@ ecore_poller_poller_interval_get(const Ecore_Poller *poller)
return interval;
}
EAPI void *
ECORE_API void *
ecore_poller_del(Ecore_Poller *poller)
{
void *data;

View File

@ -2,6 +2,7 @@
#define _ECORE_PRIVATE_H
#include <assert.h>
#include <ecore_api.h>
#include "ecore_internal.h"
@ -9,32 +10,6 @@
#include "ecore_event_message.eo.h"
#include "ecore_event_message_handler.eo.h"
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
extern int _ecore_log_dom;
#ifdef _ECORE_DEFAULT_LOG_DOM
# undef _ECORE_DEFAULT_LOG_DOM
@ -222,7 +197,7 @@ typedef struct _Ecore_Evas_Object_Animator_Interface
void *(*del)(Ecore_Animator *animator);
} Ecore_Evas_Object_Animator_Interface;
EAPI void ecore_evas_object_animator_init(Ecore_Evas_Object_Animator_Interface *iface);
ECORE_API void ecore_evas_object_animator_init(Ecore_Evas_Object_Animator_Interface *iface);
#define EVAS_FRAME_QUEUING 1 /* for test */
@ -247,6 +222,12 @@ EAPI void ecore_evas_object_animator_init(Ecore_Evas_Object_Animator_Interface *
typedef unsigned int Ecore_Magic;
#define ECORE_MAGIC Ecore_Magic __magic
ECORE_API void
_ecore_magic_fail(const void *d,
Ecore_Magic m,
Ecore_Magic req_m,
const char *fname EINA_UNUSED);
#define ECORE_MAGIC_SET(d, m) (d)->__magic = (m)
#define ECORE_MAGIC_CHECK(d, m) ((d) && ((d)->__magic == (m)))
#define ECORE_MAGIC_FAIL(d, m, fn) _ecore_magic_fail((d), (d) ? (d)->__magic : 0, (m), (fn));
@ -261,7 +242,7 @@ typedef unsigned int Ecore_Magic;
#undef IF_FN_DEL
#define IF_FN_DEL(_fn, ptr) if (ptr) { _fn(ptr); ptr = NULL; }
EAPI void
ECORE_API void
ecore_print_warning(const char *function,
const char *sparam);
@ -282,7 +263,7 @@ ecore_print_warning(const char *function,
return; \
}
EAPI void _ecore_magic_fail(const void *d,
ECORE_API void _ecore_magic_fail(const void *d,
Ecore_Magic m,
Ecore_Magic req_m,
const char *fname);
@ -557,7 +538,4 @@ extern Efl_Version _app_efl_version;
#define EFL_LOOP_DATA efl_data_scope_get(efl_main_loop_get(), EFL_LOOP_CLASS)
#undef EAPI
#define EAPI
#endif

View File

@ -654,7 +654,7 @@ _ecore_thread_shutdown(void)
CDD(_ecore_thread_global_hash_cond);
}
EAPI Ecore_Thread *
ECORE_API Ecore_Thread *
ecore_thread_run(Ecore_Thread_Cb func_blocking,
Ecore_Thread_Cb func_end,
Ecore_Thread_Cb func_cancel,
@ -737,7 +737,7 @@ retry:
return (Ecore_Thread *)work;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_cancel(Ecore_Thread *thread)
{
Ecore_Pthread_Worker *volatile work = (Ecore_Pthread_Worker *)thread;
@ -846,7 +846,7 @@ _ecore_thread_wait_end(void *data EINA_UNUSED, Ecore_Thread *thread)
_ecore_thread_wait_reset(waiter, worker);
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_wait(Ecore_Thread *thread, double wait)
{
Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread;
@ -888,7 +888,7 @@ ecore_thread_wait(Ecore_Thread *thread, double wait)
}
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_check(Ecore_Thread *thread)
{
Ecore_Pthread_Worker *volatile worker = (Ecore_Pthread_Worker *)thread;
@ -907,7 +907,7 @@ ecore_thread_check(Ecore_Thread *thread)
return cancel;
}
EAPI Ecore_Thread *
ECORE_API Ecore_Thread *
ecore_thread_feedback_run(Ecore_Thread_Cb func_heavy,
Ecore_Thread_Notify_Cb func_notify,
Ecore_Thread_Cb func_end,
@ -1033,7 +1033,7 @@ on_error:
return (Ecore_Thread *)worker;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_feedback(Ecore_Thread *thread,
const void *data)
{
@ -1086,7 +1086,7 @@ ecore_thread_feedback(Ecore_Thread *thread,
}
#if 0
EAPI Ecore_Thread *
ECORE_API Ecore_Thread *
ecore_thread_message_run(Ecore_Thread_Cb func_main,
Ecore_Thread_Notify_Cb func_notify,
Ecore_Thread_Cb func_end,
@ -1145,7 +1145,7 @@ ecore_thread_message_run(Ecore_Thread_Cb func_main,
#endif
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_reschedule(Ecore_Thread *thread)
{
Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread;
@ -1158,14 +1158,14 @@ ecore_thread_reschedule(Ecore_Thread *thread)
return EINA_TRUE;
}
EAPI int
ECORE_API int
ecore_thread_active_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
return _ecore_thread_count;
}
EAPI int
ECORE_API int
ecore_thread_pending_get(void)
{
int ret;
@ -1177,7 +1177,7 @@ ecore_thread_pending_get(void)
return ret;
}
EAPI int
ECORE_API int
ecore_thread_pending_feedback_get(void)
{
int ret;
@ -1189,7 +1189,7 @@ ecore_thread_pending_feedback_get(void)
return ret;
}
EAPI int
ECORE_API int
ecore_thread_pending_total_get(void)
{
int ret;
@ -1201,14 +1201,14 @@ ecore_thread_pending_total_get(void)
return ret;
}
EAPI int
ECORE_API int
ecore_thread_max_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0);
return _ecore_thread_count_max;
}
EAPI void
ECORE_API void
ecore_thread_max_set(int num)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -1219,14 +1219,14 @@ ecore_thread_max_set(int num)
_ecore_thread_count_max = num;
}
EAPI void
ECORE_API void
ecore_thread_max_reset(void)
{
EINA_MAIN_LOOP_CHECK_RETURN;
_ecore_thread_count_max = eina_cpu_count() * 4;
}
EAPI int
ECORE_API int
ecore_thread_available_get(void)
{
int ret;
@ -1237,7 +1237,7 @@ ecore_thread_available_get(void)
return ret;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_local_data_add(Ecore_Thread *thread,
const char *key,
void *value,
@ -1275,7 +1275,7 @@ ecore_thread_local_data_add(Ecore_Thread *thread,
return ret;
}
EAPI void *
ECORE_API void *
ecore_thread_local_data_set(Ecore_Thread *thread,
const char *key,
void *value,
@ -1316,7 +1316,7 @@ ecore_thread_local_data_set(Ecore_Thread *thread,
return NULL;
}
EAPI void *
ECORE_API void *
ecore_thread_local_data_find(Ecore_Thread *thread,
const char *key)
{
@ -1337,7 +1337,7 @@ ecore_thread_local_data_find(Ecore_Thread *thread,
return NULL;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_local_data_del(Ecore_Thread *thread,
const char *key)
{
@ -1356,7 +1356,7 @@ ecore_thread_local_data_del(Ecore_Thread *thread,
return r;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_global_data_add(const char *key,
void *value,
Eina_Free_Cb cb,
@ -1395,7 +1395,7 @@ ecore_thread_global_data_add(const char *key,
return ret;
}
EAPI void *
ECORE_API void *
ecore_thread_global_data_set(const char *key,
void *value,
Eina_Free_Cb cb)
@ -1434,7 +1434,7 @@ ecore_thread_global_data_set(const char *key,
return NULL;
}
EAPI void *
ECORE_API void *
ecore_thread_global_data_find(const char *key)
{
Ecore_Thread_Data *ret;
@ -1452,7 +1452,7 @@ ecore_thread_global_data_find(const char *key)
return NULL;
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_thread_global_data_del(const char *key)
{
Eina_Bool ret;
@ -1469,7 +1469,7 @@ ecore_thread_global_data_del(const char *key)
return ret;
}
EAPI void *
ECORE_API void *
ecore_thread_global_data_wait(const char *key,
double seconds)
{

View File

@ -10,7 +10,7 @@
static int throttle_val = 0;
EAPI void
ECORE_API void
ecore_throttle_adjust(double amount)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -19,7 +19,7 @@ ecore_throttle_adjust(double amount)
if (throttle_val < 0) throttle_val = 0;
}
EAPI double
ECORE_API double
ecore_throttle_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);

View File

@ -29,7 +29,7 @@ static Eina_Bool _ecore_time_got_clock_id = EINA_FALSE;
static double _ecore_time_clock_conversion = 1e-9;
#endif
EAPI double
ECORE_API double
ecore_time_get(void)
{
#ifdef _WIN32
@ -57,7 +57,7 @@ ecore_time_get(void)
#endif
}
EAPI double
ECORE_API double
ecore_time_unix_get(void)
{
#ifdef HAVE_GETTIMEOFDAY
@ -70,13 +70,13 @@ ecore_time_unix_get(void)
#endif
}
EAPI double
ECORE_API double
ecore_loop_time_get(void)
{
return efl_loop_time_get(ML_OBJ);
}
EAPI void
ECORE_API void
ecore_loop_time_set(double t)
{
efl_loop_time_set(ML_OBJ, t);

View File

@ -65,14 +65,14 @@ static void _efl_loop_timer_set(Efl_Loop_Timer_Data *timer, double at, double in
static double precision = 10.0 / 1000000.0;
EAPI double
ECORE_API double
ecore_timer_precision_get(void)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(0.0);
return precision;
}
EAPI void
ECORE_API void
ecore_timer_precision_set(double value)
{
EINA_MAIN_LOOP_CHECK_RETURN;
@ -185,7 +185,7 @@ EFL_CALLBACKS_ARRAY_DEFINE(legacy_timer,
{ EFL_LOOP_TIMER_EVENT_TIMER_TICK, _ecore_timer_legacy_tick },
{ EFL_EVENT_DEL, _ecore_timer_legacy_del });
EAPI Ecore_Timer *
ECORE_API Ecore_Timer *
ecore_timer_add(double in, Ecore_Task_Cb func, const void *data)
{
Ecore_Timer_Legacy *legacy;
@ -209,7 +209,7 @@ ecore_timer_add(double in, Ecore_Task_Cb func, const void *data)
return timer;
}
EAPI Ecore_Timer *
ECORE_API Ecore_Timer *
ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data)
{
Ecore_Timer_Legacy *legacy;
@ -234,7 +234,7 @@ ecore_timer_loop_add(double in, Ecore_Task_Cb func, const void *data)
return timer;
}
EAPI void *
ECORE_API void *
ecore_timer_del(Ecore_Timer *timer)
{
void *data;
@ -330,7 +330,7 @@ _efl_loop_timer_time_pending_get(const Eo *obj EINA_UNUSED, Efl_Loop_Timer_Data
return ret;
}
EAPI void
ECORE_API void
ecore_timer_freeze(Ecore_Timer *timer)
{
ECORE_TIMER_CHECK(timer);
@ -360,7 +360,7 @@ _efl_loop_timer_efl_object_event_freeze(Eo *obj, Efl_Loop_Timer_Data *timer)
_efl_loop_timer_util_instanciate(timer->loop_data, timer);
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_timer_freeze_get(Ecore_Timer *timer)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(EINA_FALSE);
@ -373,7 +373,7 @@ _efl_loop_timer_efl_object_event_freeze_count_get(const Eo *obj EINA_UNUSED, Efl
return timer->frozen;
}
EAPI void
ECORE_API void
ecore_timer_thaw(Ecore_Timer *timer)
{
ECORE_TIMER_CHECK(timer);
@ -399,7 +399,7 @@ _efl_loop_timer_efl_object_event_thaw(Eo *obj, Efl_Loop_Timer_Data *timer)
_efl_loop_timer_set(timer, timer->pending + now, timer->in);
}
EAPI char *
ECORE_API char *
ecore_timer_dump(void)
{
return NULL;

View File

@ -16,7 +16,7 @@
#if defined (__FreeBSD__) || defined (__OpenBSD__)
# include <dlfcn.h>
static char ***_dl_environ;
#else
#elif !defined(_MSC_VER)
extern char **environ;
#endif

View File

@ -33,7 +33,7 @@ GENERIC_ALLOC_SIZE_DECLARE(Efl_Loop_Promise_Simple_Data);
Eo *_mainloop_singleton = NULL;
Efl_Loop_Data *_mainloop_singleton_data = NULL;
EAPI Eo *
ECORE_API Eo *
efl_main_loop_get(void)
{
return efl_app_main_get();
@ -97,7 +97,7 @@ _efl_loop_time_get(const Eo *obj EINA_UNUSED, Efl_Loop_Data *pd)
return pd->loop_time;
}
EAPI void
ECORE_API void
efl_exit(int exit_code)
{
Eina_Value v = EINA_VALUE_EMPTY;
@ -107,7 +107,7 @@ efl_exit(int exit_code)
efl_loop_quit(efl_main_loop_get(), v);
}
EAPI int
ECORE_API int
efl_loop_exit_code_process(Eina_Value *value)
{
Eina_Value def = EINA_VALUE_EMPTY;
@ -359,7 +359,7 @@ _efl_loop_arguments_cleanup(Eo *o EINA_UNUSED, void *data, const Eina_Future *de
// It doesn't make sense to send those argument to any other mainloop
// As it also doesn't make sense to allow anyone to override this, so
// should be internal for sure, not even protected.
EAPI void
ECORE_API void
ecore_loop_arguments_send(int argc, const char **argv)
{
Eina_Array *arga, *cml;
@ -633,9 +633,9 @@ _efl_loop_message_process(Eo *obj, Efl_Loop_Data *pd)
return EINA_TRUE;
}
EOAPI EFL_FUNC_BODY(efl_loop_message_process, Eina_Bool, 0);
ECORE_API ECORE_API_WEAK EFL_FUNC_BODY(efl_loop_message_process, Eina_Bool, 0);
EWAPI void
ECORE_API ECORE_API_WEAK void
efl_build_version_set(int vmaj, int vmin, int vmic, int revision,
const char *flavor, const char *build_id)
{
@ -667,7 +667,7 @@ EFL_SCHEDULER_ARRAY_DEFINE(loop_scheduler,
EFL_LOOP_EVENT_IDLE_ENTER,
EFL_LOOP_EVENT_IDLE);
EAPI Eina_Future_Scheduler *
ECORE_API Eina_Future_Scheduler *
efl_loop_future_scheduler_get(const Eo *obj)
{
Efl_Loop *loop;

View File

@ -1,35 +1,35 @@
EAPI void
ECORE_API void
ecore_timer_interval_set(Efl_Loop_Timer *obj, double in)
{
efl_loop_timer_interval_set(obj, in);
}
EAPI double
ECORE_API double
ecore_timer_interval_get(const Efl_Loop_Timer *obj)
{
return efl_loop_timer_interval_get(obj);
}
EAPI double
ECORE_API double
ecore_timer_pending_get(const Efl_Loop_Timer *obj)
{
return efl_loop_timer_time_pending_get(obj);
}
EAPI void
ECORE_API void
ecore_timer_reset(Efl_Loop_Timer *obj)
{
efl_loop_timer_reset(obj);
}
EAPI void
ECORE_API void
ecore_timer_loop_reset(Efl_Loop_Timer *obj)
{
efl_loop_timer_loop_reset(obj);
}
EAPI void
ECORE_API void
ecore_timer_delay(Efl_Loop_Timer *obj, double add)
{
efl_loop_timer_delay(obj, add);

View File

@ -24,7 +24,7 @@ typedef Eo Efl_Loop_Timer;
*
* @ingroup Ecore_Timer_Group
*/
EAPI void ecore_timer_interval_set(Efl_Loop_Timer *obj, double in);
ECORE_API void ecore_timer_interval_set(Efl_Loop_Timer *obj, double in);
/**
* @brief Interval the timer ticks on.
@ -35,7 +35,7 @@ EAPI void ecore_timer_interval_set(Efl_Loop_Timer *obj, double in);
*
* @ingroup Ecore_Timer_Group
*/
EAPI double ecore_timer_interval_get(const Efl_Loop_Timer *obj);
ECORE_API double ecore_timer_interval_get(const Efl_Loop_Timer *obj);
/**
* @brief Pending time regarding a timer.
@ -46,7 +46,7 @@ EAPI double ecore_timer_interval_get(const Efl_Loop_Timer *obj);
*
* @ingroup Ecore_Timer_Group
*/
EAPI double ecore_timer_pending_get(const Efl_Loop_Timer *obj);
ECORE_API double ecore_timer_pending_get(const Efl_Loop_Timer *obj);
/**
* @brief Resets a timer to its full interval. This effectively makes the timer
@ -61,7 +61,7 @@ EAPI double ecore_timer_pending_get(const Efl_Loop_Timer *obj);
*
* @ingroup Ecore_Timer_Group
*/
EAPI void ecore_timer_reset(Efl_Loop_Timer *obj);
ECORE_API void ecore_timer_reset(Efl_Loop_Timer *obj);
/** This effectively resets a timer but based on the time when this iteration
* of the main loop started.
@ -70,7 +70,7 @@ EAPI void ecore_timer_reset(Efl_Loop_Timer *obj);
*
* @ingroup Ecore_Timer_Group
*/
EAPI void ecore_timer_loop_reset(Efl_Loop_Timer *obj);
ECORE_API void ecore_timer_loop_reset(Efl_Loop_Timer *obj);
/**
* @brief Adds a delay to the next occurrence of a timer. This doesn't affect
@ -81,6 +81,6 @@ EAPI void ecore_timer_loop_reset(Efl_Loop_Timer *obj);
*
* @ingroup Ecore_Timer_Group
*/
EAPI void ecore_timer_delay(Efl_Loop_Timer *obj, double add);
ECORE_API void ecore_timer_delay(Efl_Loop_Timer *obj, double add);
#endif

View File

@ -666,7 +666,7 @@ _efl_thread_efl_task_run(Eo *obj, Efl_Thread_Data *pd)
// input/output pipes
if (td->flags & EFL_TASK_FLAGS_USE_STDIN)
{
if (pipe(pipe_from_thread) != 0)
if (eina_pipe_new(pipe_from_thread) != 0)
{
ERR("Can't create to_thread pipe");
free(thdat);
@ -675,7 +675,7 @@ _efl_thread_efl_task_run(Eo *obj, Efl_Thread_Data *pd)
}
if (td->flags & EFL_TASK_FLAGS_USE_STDOUT)
{
if (pipe(pipe_to_thread) != 0)
if (eina_pipe_new(pipe_to_thread) != 0)
{
ERR("Can't create from_thread pipe");
if (td->flags & EFL_TASK_FLAGS_USE_STDIN)
@ -723,13 +723,13 @@ _efl_thread_efl_task_run(Eo *obj, Efl_Thread_Data *pd)
}
// control pipes
if (pipe(pipe_to_thread) != 0)
if (eina_pipe_new(pipe_to_thread) != 0)
{
ERR("Can't create to_thread control pipe");
_task_run_pipe_fail_clear(thdat, pd);
return EINA_FALSE;
}
if (pipe(pipe_from_thread) != 0)
if (eina_pipe_new(pipe_from_thread) != 0)
{
ERR("Can't create from_thread control pipe");
_task_run_pipe_fail_clear(thdat, pd);

View File

@ -23,6 +23,7 @@ foreach eo_file : pub_legacy_eo_files
'-o', 'h:' + join_paths(meson.current_build_dir(), eo_file + '.h'),
'-o', 'c:' + join_paths(meson.current_build_dir(), eo_file + '.c'),
'-o', 'd:' + join_paths(meson.current_build_dir(), eo_file + '.d'),
'-e', 'ECORE_API',
'-gchd', '@INPUT@'])
endforeach
@ -83,6 +84,7 @@ foreach eo_file : pub_eo_files
'-o', 'h:' + join_paths(meson.current_build_dir(), eo_file + '.h'),
'-o', 'c:' + join_paths(meson.current_build_dir(), eo_file + '.c'),
'-o', 'd:' + join_paths(meson.current_build_dir(), eo_file + '.d'),
'-e', 'ECORE_API',
'-gchd', '@INPUT@'])
endforeach
@ -99,6 +101,7 @@ ecore_header_src = [
'efl_general.h',
'Ecore_Getopt.h',
'ecore_exe_eo.h',
'ecore_api.h',
'ecore_exe_eo.legacy.h',
'efl_loop_timer_eo.legacy.h',
]
@ -202,7 +205,7 @@ ecore_lib = library('ecore',
dependencies: ecore_pub_deps + [ecore_deps, ecore_ext_deps],
include_directories : config_dir + [include_directories(join_paths('..','..'))],
install: true,
c_args : package_c_args,
c_args : [package_c_args, '-DECORE_BUILD'],
version : meson.project_version()
)

View File

@ -4,30 +4,32 @@
#include <Eina.h>
#include <Eo.h>
#ifdef EAPI
#undef EAPI
#ifdef ECORE_AUDIO_API
#error ECORE_AUDIO_API should not be already defined
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# ifndef ECORE_AUDIO_STATIC
# ifdef ECORE_AUDIO_BUILD
# define ECORE_AUDIO_API __declspec(dllexport)
# else
# define EAPI
# define ECORE_AUDIO_API __declspec(dllimport)
# endif
# else
# define EAPI __declspec(dllimport)
# define ECORE_AUDIO_API
# endif
# define ECORE_AUDIO_API_WEAK
#elif __GNUC__
# if __GNUC__ >= 4
# define ECORE_AUDIO_API __attribute__ ((visibility("default")))
# define ECORE_AUDIO_API_WEAK __attribute__ ((weak))
# else
# define ECORE_AUDIO_API
# define ECORE_AUDIO_API_WEAK
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
# define ECORE_AUDIO_API
# define ECORE_AUDIO_API_WEAK
#endif
/**
@ -176,7 +178,7 @@ typedef struct _Ecore_Audio_Vio Ecore_Audio_Vio;
* When Ecore_Audio is not used anymore, call ecore_audio_shutdown()
* to shut down the Ecore_Audio library.
*/
EAPI int ecore_audio_init(void);
ECORE_AUDIO_API int ecore_audio_init(void);
/**
* @brief Shuts down the Ecore_Audio library.
@ -190,7 +192,7 @@ EAPI int ecore_audio_init(void);
* been called the same number of times than ecore_audio_init(). In that case
* it shuts down all the services it uses.
*/
EAPI int ecore_audio_shutdown(void);
ECORE_AUDIO_API int ecore_audio_shutdown(void);
//Legacy compatibility code
@ -200,14 +202,14 @@ EAPI int ecore_audio_shutdown(void);
* @since 1.8
*
*/
EAPI const char* ecore_audio_obj_name_get(const Efl_Object* obj);
ECORE_AUDIO_API const char* ecore_audio_obj_name_get(const Efl_Object* obj);
/**
* @brief Name of the object
*
* @since 1.8
*
*/
EAPI void ecore_audio_obj_name_set(Efl_Object* obj, const char *name);
ECORE_AUDIO_API void ecore_audio_obj_name_set(Efl_Object* obj, const char *name);
#include <ecore_audio_obj.h>
#include <ecore_audio_obj_in.h>
@ -230,7 +232,4 @@ EAPI void ecore_audio_obj_name_set(Efl_Object* obj, const char *n
}
#endif
#undef EAPI
#define EAPI
#endif

View File

@ -27,7 +27,7 @@ Ecore_Audio_Lib_Sndfile *ecore_audio_sndfile_lib = NULL;
/* externally accessible functions */
EAPI int
ECORE_AUDIO_API int
ecore_audio_init(void)
{
@ -60,7 +60,7 @@ ecore_audio_init(void)
return _ecore_audio_init_count;
}
EAPI int
ECORE_AUDIO_API int
ecore_audio_shutdown(void)
{
DBG("Ecore_Audio shutdown");
@ -263,13 +263,13 @@ ecore_audio_sndfile_lib_unload(void)
#endif /* HAVE_SNDFILE */
EAPI const char*
ECORE_AUDIO_API const char*
ecore_audio_obj_name_get(const Efl_Object* obj)
{
return efl_name_get(obj);
}
EAPI void
ECORE_AUDIO_API void
ecore_audio_obj_name_set(Efl_Object* obj, const char *name)
{
efl_name_set(obj, name);

View File

@ -24,6 +24,7 @@ foreach eo_file : pub_eo_files
'-o', 'h:' + join_paths(meson.current_build_dir(), eo_file + '.h'),
'-o', 'c:' + join_paths(meson.current_build_dir(), eo_file + '.c'),
'-o', 'd:' + join_paths(meson.current_build_dir(), eo_file + '.d'),
'-e', 'ECORE_AUDIO_API',
'-gchd', '@INPUT@'])
endforeach
@ -80,7 +81,7 @@ endif
ecore_audio_lib = library('ecore_audio',
ecore_audio_src, pub_eo_file_target,
c_args : package_c_args,
c_args : [package_c_args, '-DECORE_AUDIO_BUILD'],
dependencies: ecore_audio_pub_deps + ecore_audio_deps + ecore_audio_ext_deps,
include_directories : config_dir,
install: true,

View File

@ -7,31 +7,7 @@
#ifndef _ECORE_AVAHI_H
# define _ECORE_AVAHI_H
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_avahi_api.h>
#ifdef __cplusplus
extern "C" {
@ -55,7 +31,7 @@ typedef struct _Ecore_Avahi Ecore_Avahi; /**< A handle for an Avahi instance. */
* @return A handler that reference the AvahiPoll context
* @since 1.9
*/
EAPI Ecore_Avahi *ecore_avahi_add(void);
ECORE_AVAHI_API Ecore_Avahi *ecore_avahi_add(void);
/**
* @brief Deletes the specified handler of an AvahiPoll.
@ -66,7 +42,7 @@ EAPI Ecore_Avahi *ecore_avahi_add(void);
* Be aware there should not be any reference still using that handler before
* destroying it.
*/
EAPI void ecore_avahi_del(Ecore_Avahi *handler);
ECORE_AVAHI_API void ecore_avahi_del(Ecore_Avahi *handler);
/**
* @brief Gets the AvahiPoll structure to integrate with Ecore main loop.
@ -75,7 +51,7 @@ EAPI void ecore_avahi_del(Ecore_Avahi *handler);
* @return return the actual AvahiPoll structure to use with Avahi.
* @since 1.9
*/
EAPI const void *ecore_avahi_poll_get(Ecore_Avahi *handler); // return AvahiPoll
ECORE_AVAHI_API const void *ecore_avahi_poll_get(Ecore_Avahi *handler); // return AvahiPoll
/**
* @}
@ -85,7 +61,4 @@ EAPI const void *ecore_avahi_poll_get(Ecore_Avahi *handler); // return AvahiPol
}
#endif
#undef EAPI
#define EAPI
#endif

View File

@ -188,7 +188,7 @@ _ecore_avahi_timeout_free(AvahiTimeout *t)
}
#endif
EAPI Ecore_Avahi *
ECORE_AVAHI_API Ecore_Avahi *
ecore_avahi_add(void)
{
#ifdef HAVE_AVAHI
@ -213,7 +213,7 @@ ecore_avahi_add(void)
#endif
}
EAPI void
ECORE_AVAHI_API void
ecore_avahi_del(Ecore_Avahi *handler)
{
#ifdef HAVE_AVAHI
@ -238,7 +238,7 @@ ecore_avahi_del(Ecore_Avahi *handler)
#endif
}
EAPI const void *
ECORE_AVAHI_API const void *
ecore_avahi_poll_get(Ecore_Avahi *handler)
{
#ifdef HAVE_AVAHI

View File

@ -0,0 +1,34 @@
#ifndef _EFL_ECORE_AVAHI_API_H
#define _EFL_ECORE_AVAHI_API_H
#ifdef ECORE_AVAHI_API
#error ECORE_AVAHI_API should not be already defined
#endif
#ifdef _WIN32
# ifndef ECORE_AVAHI_STATIC
# ifdef ECORE_AVAHI_BUILD
# define ECORE_AVAHI_API __declspec(dllexport)
# else
# define ECORE_AVAHI_API __declspec(dllimport)
# endif
# else
# define ECORE_AVAHI_API
# endif
# define ECORE_AVAHI_API_WEAK
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define ECORE_AVAHI_API __attribute__ ((visibility("default")))
# define ECORE_AVAHI_API_WEAK __attribute__ ((weak))
# else
# define ECORE_AVAHI_API
# define ECORE_AVAHI_API_WEAK
# endif
# else
# define ECORE_AVAHI_API
# define ECORE_AVAHI_API_WEAK
# endif
#endif
#endif

View File

@ -9,7 +9,7 @@ config_h.set('HAVE_AVAHI', '1')
ecore_avahi_lib = library('ecore_avahi',
ecore_avahi_src,
c_args : package_c_args,
c_args : [package_c_args, '-DECORE_AVAHI_BUILD'],
dependencies: [m] + ecore_avahi_deps + ecore_avahi_pub_deps,
include_directories : config_dir + [include_directories(join_paths('..','..'))],
install: true,

View File

@ -1,31 +1,7 @@
#ifndef _ECORE_BUFFER_H_
# define _ECORE_BUFFER_H_
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_buffer_api.h>
/**
* @defgroup Ecore_Buffer_Group Ecore_Buffer - Graphics buffer functions
@ -472,7 +448,7 @@ struct _Ecore_Buffer_Backend
*
* @see ecore_buffer_shutdown()
*/
EAPI Eina_Bool ecore_buffer_init(void);
ECORE_BUFFER_API Eina_Bool ecore_buffer_init(void);
/**
* @brief Shuts down the Ecore_Buffer system.
*
@ -482,7 +458,7 @@ EAPI Eina_Bool ecore_buffer_init(void);
*
* @see ecore_buffer_init()
*/
EAPI Eina_Bool ecore_buffer_shutdown(void);
ECORE_BUFFER_API Eina_Bool ecore_buffer_shutdown(void);
/**
* @brief Registers the given buffer backend.
*
@ -492,7 +468,7 @@ EAPI Eina_Bool ecore_buffer_shutdown(void);
*
* @return @c EINA_TRUE if backend has been correctly registered, @c EINA_FALSE otherwise.
*/
EAPI Eina_Bool ecore_buffer_register(Ecore_Buffer_Backend *be);
ECORE_BUFFER_API Eina_Bool ecore_buffer_register(Ecore_Buffer_Backend *be);
/**
* @brief Unregisters the given buffer backend.
*
@ -500,7 +476,7 @@ EAPI Eina_Bool ecore_buffer_register(Ecore_Buffer_Backend *be);
*
* @param[in] be The backend
*/
EAPI void ecore_buffer_unregister(Ecore_Buffer_Backend *be);
ECORE_BUFFER_API void ecore_buffer_unregister(Ecore_Buffer_Backend *be);
/**
* @brief Creates a new Ecore_Buffer given type.
*
@ -514,7 +490,7 @@ EAPI void ecore_buffer_unregister(Ecore_Buffer_Backend *be);
*
* @return Newly allocated Ecore_Buffer instance, NULL otherwise.
*/
EAPI Ecore_Buffer *ecore_buffer_new(const char *engine, unsigned int width, unsigned int height, Ecore_Buffer_Format format, unsigned int flags);
ECORE_BUFFER_API Ecore_Buffer *ecore_buffer_new(const char *engine, unsigned int width, unsigned int height, Ecore_Buffer_Format format, unsigned int flags);
/**
* @brief Frees the given Ecore_Buffer.
*
@ -522,7 +498,7 @@ EAPI Ecore_Buffer *ecore_buffer_new(const char *engine, unsigned int width, unsi
*
* @param[in] buf The Ecore_Buffer to free
*/
EAPI void ecore_buffer_free(Ecore_Buffer *buf);
ECORE_BUFFER_API void ecore_buffer_free(Ecore_Buffer *buf);
/**
* @brief Sets a callback for Ecore_Buffer free events.
*
@ -537,7 +513,7 @@ EAPI void ecore_buffer_free(Ecore_Buffer *buf);
*
* @see ecore_buffer_free_callback_remove()
*/
EAPI void ecore_buffer_free_callback_add(Ecore_Buffer *buf, Ecore_Buffer_Cb func, void *data);
ECORE_BUFFER_API void ecore_buffer_free_callback_add(Ecore_Buffer *buf, Ecore_Buffer_Cb func, void *data);
/**
* @brief Removes a callback for Ecore_Buffer free events.
*
@ -549,7 +525,7 @@ EAPI void ecore_buffer_free_callback_add(Ecore_Buffer *buf, Ecore_Buffe
*
* @see ecore_buffer_free_callback_add()
*/
EAPI void ecore_buffer_free_callback_remove(Ecore_Buffer *buf, Ecore_Buffer_Cb func, void *data);
ECORE_BUFFER_API void ecore_buffer_free_callback_remove(Ecore_Buffer *buf, Ecore_Buffer_Cb func, void *data);
/**
* @brief Get a pointer to the raw data of the given Ecore_Buffer.
*
@ -557,7 +533,7 @@ EAPI void ecore_buffer_free_callback_remove(Ecore_Buffer *buf, Ecore_Bu
*
* @return The pointer of raw data.
*/
EAPI void *ecore_buffer_data_get(Ecore_Buffer *buf);
ECORE_BUFFER_API void *ecore_buffer_data_get(Ecore_Buffer *buf);
/**
* @brief Returns the Pixmap of given Ecore_Buffer.
*
@ -567,7 +543,7 @@ EAPI void *ecore_buffer_data_get(Ecore_Buffer *buf);
*
* @return The Pixmap instance, @c 0 otherwise.
*/
EAPI Ecore_Pixmap ecore_buffer_pixmap_get(Ecore_Buffer *buf);
ECORE_BUFFER_API Ecore_Pixmap ecore_buffer_pixmap_get(Ecore_Buffer *buf);
/**
* @brief Returns the tbm surface handle of given Ecore_Buffer.
*
@ -580,7 +556,7 @@ EAPI Ecore_Pixmap ecore_buffer_pixmap_get(Ecore_Buffer *buf);
* The tbm surface handle will be used for the API of libtbm.
* The API is described in tbm_surface.h in libtbm.
*/
EAPI void *ecore_buffer_tbm_surface_get(Ecore_Buffer *buf);
ECORE_BUFFER_API void *ecore_buffer_tbm_surface_get(Ecore_Buffer *buf);
/**
* @brief Returns size of given Ecore_Buffer.
*
@ -592,7 +568,7 @@ EAPI void *ecore_buffer_tbm_surface_get(Ecore_Buffer *buf);
*
* @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
*/
EAPI Eina_Bool ecore_buffer_size_get(Ecore_Buffer *buf, unsigned int *width, unsigned int *height);
ECORE_BUFFER_API Eina_Bool ecore_buffer_size_get(Ecore_Buffer *buf, unsigned int *width, unsigned int *height);
/**
* @brief Returns format of given Ecore_Buffer.
*
@ -604,7 +580,7 @@ EAPI Eina_Bool ecore_buffer_size_get(Ecore_Buffer *buf, unsigned int *width,
*
* Return value can be one of those pre-defined value such as ECORE_BUFFER_FORMAT_XRGB8888.
*/
EAPI Ecore_Buffer_Format ecore_buffer_format_get(Ecore_Buffer *buf);
ECORE_BUFFER_API Ecore_Buffer_Format ecore_buffer_format_get(Ecore_Buffer *buf);
/**
* @brief Returns the flags of given Ecore_Buffer.
*
@ -616,7 +592,7 @@ EAPI Ecore_Buffer_Format ecore_buffer_format_get(Ecore_Buffer *buf);
*
* NOTE: Not Defined yet.
*/
EAPI unsigned int ecore_buffer_flags_get(Ecore_Buffer *buf);
ECORE_BUFFER_API unsigned int ecore_buffer_flags_get(Ecore_Buffer *buf);
/**
* @}
@ -626,7 +602,4 @@ EAPI unsigned int ecore_buffer_flags_get(Ecore_Buffer *buf);
}
#endif
#undef EAPI
#define EAPI
#endif

View File

@ -4,31 +4,7 @@
#include <Eina.h>
#include <Ecore_Buffer.h>
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_buffer_api.h>
#ifdef __cplusplus
extern "C" {
@ -184,7 +160,7 @@ typedef void (*Ecore_Buffer_Provider_Enqueue_Cb) (Ecore_Buffer_Provider *provide
*
* @see ecore_buffer_queue_shutdown()
*/
EAPI int ecore_buffer_queue_init(void);
ECORE_BUFFER_API int ecore_buffer_queue_init(void);
/**
* @brief Shuts down the Ecore_Buffer_Queue system.
*
@ -196,7 +172,7 @@ EAPI int ecore_buffer_queue_init(void);
*
* @see ecore_buffer_queue_init()
*/
EAPI int ecore_buffer_queue_shutdown(void);
ECORE_BUFFER_API int ecore_buffer_queue_shutdown(void);
/**
* @}
@ -219,7 +195,7 @@ EAPI int ecore_buffer_queue_shutdown(void);
*
* @return Ecore_Buffer_Consumer instance or @c NULL if creation failed.
*/
EAPI Ecore_Buffer_Consumer *ecore_buffer_consumer_new(const char *name, int32_t queue_size, int32_t w, int32_t h);
ECORE_BUFFER_API Ecore_Buffer_Consumer *ecore_buffer_consumer_new(const char *name, int32_t queue_size, int32_t w, int32_t h);
/**
* @brief Frees an Ecore_Buffer_Consumer.
*
@ -229,7 +205,7 @@ EAPI Ecore_Buffer_Consumer *ecore_buffer_consumer_new(const char *name, int32
*
* This frees up any memory used by the Ecore_Buffer_Consumer.
*/
EAPI void ecore_buffer_consumer_free(Ecore_Buffer_Consumer *consumer);
ECORE_BUFFER_API void ecore_buffer_consumer_free(Ecore_Buffer_Consumer *consumer);
/**
* @brief Returns the latest Ecore_Buffer submitted by provider.
*
@ -244,7 +220,7 @@ EAPI void ecore_buffer_consumer_free(Ecore_Buffer_Consumer
* Consumer can store Ecore_Buffer submitted by Provider as much as size of queue
* which is passed as a argument of ecore_buffer_consumer_new().
*/
EAPI Ecore_Buffer *ecore_buffer_consumer_buffer_dequeue(Ecore_Buffer_Consumer *consumer);
ECORE_BUFFER_API Ecore_Buffer *ecore_buffer_consumer_buffer_dequeue(Ecore_Buffer_Consumer *consumer);
/**
* @brief Releases the acquired Ecore_Buffer.
*
@ -262,7 +238,7 @@ EAPI Ecore_Buffer *ecore_buffer_consumer_buffer_dequeue(Ecore_Buffer
* or freed internally if Ecore_Buffer is not necessary anymore.
* If not, the resource of Ecore_Buffer is continually owned by consumer until released.
*/
EAPI Eina_Bool ecore_buffer_consumer_buffer_release(Ecore_Buffer_Consumer *consumer, Ecore_Buffer *buffer);
ECORE_BUFFER_API Eina_Bool ecore_buffer_consumer_buffer_release(Ecore_Buffer_Consumer *consumer, Ecore_Buffer *buffer);
/**
* @brief Checks if Queue of Ecore_Buffer is empty.
*
@ -272,7 +248,7 @@ EAPI Eina_Bool ecore_buffer_consumer_buffer_release(Ecore_Buffer
*
* @return @c EINA_TRUE means queue is empty, @c EINA_FALSE otherwise.
*/
EAPI Eina_Bool ecore_buffer_consumer_queue_is_empty(Ecore_Buffer_Consumer *consumer);
ECORE_BUFFER_API Eina_Bool ecore_buffer_consumer_queue_is_empty(Ecore_Buffer_Consumer *consumer);
/**
* @brief Sets a callback for provider connection events.
*
@ -285,7 +261,7 @@ EAPI Eina_Bool ecore_buffer_consumer_queue_is_empty(Ecore_Buffer
* A call to this function will set a callback on an Ecore_Buffer_Consumer, causing
* @p func to be called whenever @p consumer is connected with provider.
*/
EAPI void ecore_buffer_consumer_provider_add_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Provider_Add_Cb func, void *data);
ECORE_BUFFER_API void ecore_buffer_consumer_provider_add_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Provider_Add_Cb func, void *data);
/**
* @brief Sets a callback for provider disconnection events.
*
@ -298,7 +274,7 @@ EAPI void ecore_buffer_consumer_provider_add_cb_set(Ecore_B
* A call to this function will set a callback on an Ecore_Buffer_Consumer, causing
* @p func to be called whenever @p consumer is disconnected with provider.
*/
EAPI void ecore_buffer_consumer_provider_del_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Provider_Del_Cb func, void *data);
ECORE_BUFFER_API void ecore_buffer_consumer_provider_del_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Provider_Del_Cb func, void *data);
/**
* @brief Sets a callback for enqueued buffer events.
*
@ -313,7 +289,7 @@ EAPI void ecore_buffer_consumer_provider_del_cb_set(Ecore_B
*
* You may success acquire Ecore_Buffer after this callback called.
*/
EAPI void ecore_buffer_consumer_buffer_enqueued_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Enqueue_Cb func, void *data);
ECORE_BUFFER_API void ecore_buffer_consumer_buffer_enqueued_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Enqueue_Cb func, void *data);
/**
* @}
@ -333,7 +309,7 @@ EAPI void ecore_buffer_consumer_buffer_enqueued_cb_set(Ecor
*
* @return Ecore_Buffer_Provider instance or @c NULL if creation failed.
*/
EAPI Ecore_Buffer_Provider *ecore_buffer_provider_new(const char *name);
ECORE_BUFFER_API Ecore_Buffer_Provider *ecore_buffer_provider_new(const char *name);
/**
* @brief Frees an Ecore_Buffer_Provider.
*
@ -343,7 +319,7 @@ EAPI Ecore_Buffer_Provider *ecore_buffer_provider_new(const char *name);
*
* This frees up any memory used by the Ecore_Buffer_Provider.
*/
EAPI void ecore_buffer_provider_free(Ecore_Buffer_Provider *provider);
ECORE_BUFFER_API void ecore_buffer_provider_free(Ecore_Buffer_Provider *provider);
/**
* @brief Returns the Ecore_Buffer released by consumer or State of Queue.
*
@ -365,7 +341,7 @@ EAPI void ecore_buffer_provider_free(Ecore_Buffer_Provider
*
* @see ecore_buffer_new(), ecore_buffer_provider_buffer_enqueue()
*/
EAPI Ecore_Buffer_Return ecore_buffer_provider_buffer_acquire(Ecore_Buffer_Provider *provider, Ecore_Buffer **ret_buf);
ECORE_BUFFER_API Ecore_Buffer_Return ecore_buffer_provider_buffer_acquire(Ecore_Buffer_Provider *provider, Ecore_Buffer **ret_buf);
/**
* @brief Submits the Ecore_Buffer to Consumer to request compositing.
*
@ -382,7 +358,7 @@ EAPI Ecore_Buffer_Return ecore_buffer_provider_buffer_acquire(Ecore_Buffer
*
* @see ecore_buffer_new(), ecore_buffer_provider_buffer_dequeue()
*/
EAPI Eina_Bool ecore_buffer_provider_buffer_enqueue(Ecore_Buffer_Provider *provider, Ecore_Buffer *buffer);
ECORE_BUFFER_API Eina_Bool ecore_buffer_provider_buffer_enqueue(Ecore_Buffer_Provider *provider, Ecore_Buffer *buffer);
/**
* @brief Checks if state of queue.
*
@ -398,7 +374,7 @@ EAPI Eina_Bool ecore_buffer_provider_buffer_enqueue(Ecore_Buffer
*
* @return @c EINA_TRUE means queue is empty, @c EINA_FALSE otherwise.
*/
EAPI Ecore_Buffer_Return ecore_buffer_provider_buffer_acquirable_check(Ecore_Buffer_Provider *provider);
ECORE_BUFFER_API Ecore_Buffer_Return ecore_buffer_provider_buffer_acquirable_check(Ecore_Buffer_Provider *provider);
/**
* @brief Sets a callback for consumer connection events.
*
@ -411,7 +387,7 @@ EAPI Ecore_Buffer_Return ecore_buffer_provider_buffer_acquirable_check(Eco
* A call to this function will set a callback on an Ecore_Buffer_Provider, causing
* @p func to be called whenever @p provider is connected with consumer.
*/
EAPI void ecore_buffer_provider_consumer_add_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Consumer_Add_Cb func, void *data);
ECORE_BUFFER_API void ecore_buffer_provider_consumer_add_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Consumer_Add_Cb func, void *data);
/**
* @brief Sets a callback for consumer disconnection events.
*
@ -424,7 +400,7 @@ EAPI void ecore_buffer_provider_consumer_add_cb_set(Ecore_B
* A call to this function will set a callback on an Ecore_Buffer_Provider, causing
* @p func to be called whenever @p provider is disconnected with consumer.
*/
EAPI void ecore_buffer_provider_consumer_del_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Consumer_Del_Cb func, void *data);
ECORE_BUFFER_API void ecore_buffer_provider_consumer_del_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Consumer_Del_Cb func, void *data);
/**
* @brief Sets a callback for released buffer events.
*
@ -439,7 +415,7 @@ EAPI void ecore_buffer_provider_consumer_del_cb_set(Ecore_B
*
* You may success dequeue the Ecore_Buffer after this callback called.
*/
EAPI void ecore_buffer_provider_buffer_released_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Enqueue_Cb func, void *data);
ECORE_BUFFER_API void ecore_buffer_provider_buffer_released_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Enqueue_Cb func, void *data);
/**
* @}
@ -449,7 +425,4 @@ EAPI void ecore_buffer_provider_buffer_released_cb_set(Ecor
}
#endif
#undef EAPI
#define EAPI
#endif /* _ECORE_BUFFER_QUEUE_H_ */

View File

@ -110,7 +110,7 @@ _ecore_buffer_backends_free(const Eina_Hash *hash EINA_UNUSED, const void *key E
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_BUFFER_API Eina_Bool
ecore_buffer_register(Ecore_Buffer_Backend *be)
{
Ecore_Buffer_Module *bm;
@ -127,7 +127,7 @@ ecore_buffer_register(Ecore_Buffer_Backend *be)
return eina_hash_add(_backends, be->name, bm);
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_unregister(Ecore_Buffer_Backend *be)
{
Ecore_Buffer_Module *bm;
@ -142,7 +142,7 @@ ecore_buffer_unregister(Ecore_Buffer_Backend *be)
free(bm);
}
EAPI Eina_Bool
ECORE_BUFFER_API Eina_Bool
ecore_buffer_init(void)
{
char *path;
@ -206,7 +206,7 @@ err:
return EINA_FALSE;
}
EAPI Eina_Bool
ECORE_BUFFER_API Eina_Bool
ecore_buffer_shutdown(void)
{
if (_ecore_buffer_init_count < 1)
@ -234,7 +234,7 @@ ecore_buffer_shutdown(void)
return EINA_TRUE;
}
EAPI Ecore_Buffer*
ECORE_BUFFER_API Ecore_Buffer*
ecore_buffer_new(const char *engine, unsigned int width, unsigned int height, Ecore_Buffer_Format format, unsigned int flags)
{
Ecore_Buffer_Module *bm;
@ -277,7 +277,7 @@ ecore_buffer_new(const char *engine, unsigned int width, unsigned int height, Ec
return bo;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_free(Ecore_Buffer *buf)
{
Ecore_Buffer_Cb_Data *free_cb;
@ -307,7 +307,7 @@ ecore_buffer_free(Ecore_Buffer *buf)
free(buf);
}
EAPI void *
ECORE_BUFFER_API void *
ecore_buffer_data_get(Ecore_Buffer *buf)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(buf, NULL);
@ -320,7 +320,7 @@ ecore_buffer_data_get(Ecore_Buffer *buf)
return buf->bm->be->data_get(buf->bm->data, buf->buffer_data);
}
EAPI Ecore_Pixmap
ECORE_BUFFER_API Ecore_Pixmap
ecore_buffer_pixmap_get(Ecore_Buffer *buf)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(buf, 0);
@ -333,7 +333,7 @@ ecore_buffer_pixmap_get(Ecore_Buffer *buf)
return buf->bm->be->pixmap_get(buf->bm->data, buf->buffer_data);
}
EAPI void *
ECORE_BUFFER_API void *
ecore_buffer_tbm_surface_get(Ecore_Buffer *buf)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(buf, NULL);
@ -349,7 +349,7 @@ ecore_buffer_tbm_surface_get(Ecore_Buffer *buf)
return buf->bm->be->tbm_surface_get(buf->bm->data, buf->buffer_data);
}
EAPI Eina_Bool
ECORE_BUFFER_API Eina_Bool
ecore_buffer_size_get(Ecore_Buffer *buf, unsigned int *width, unsigned int *height)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(buf, EINA_FALSE);
@ -360,7 +360,7 @@ ecore_buffer_size_get(Ecore_Buffer *buf, unsigned int *width, unsigned int *heig
return EINA_TRUE;
}
EAPI unsigned int
ECORE_BUFFER_API unsigned int
ecore_buffer_format_get(Ecore_Buffer *buf)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(buf, 0);
@ -368,7 +368,7 @@ ecore_buffer_format_get(Ecore_Buffer *buf)
return buf->format;
}
EAPI unsigned int
ECORE_BUFFER_API unsigned int
ecore_buffer_flags_get(Ecore_Buffer *buf)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(buf, 0);
@ -376,7 +376,7 @@ ecore_buffer_flags_get(Ecore_Buffer *buf)
return buf->flags;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_free_callback_add(Ecore_Buffer *buf, Ecore_Buffer_Cb func, void *data)
{
EINA_SAFETY_ON_NULL_RETURN(buf);
@ -393,7 +393,7 @@ ecore_buffer_free_callback_add(Ecore_Buffer *buf, Ecore_Buffer_Cb func, void *da
buf->free_callbacks = eina_inlist_append(buf->free_callbacks, EINA_INLIST_GET(free_cb));
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_free_callback_remove(Ecore_Buffer *buf, Ecore_Buffer_Cb func, void *data)
{
Ecore_Buffer_Cb_Data *free_cb;

View File

@ -0,0 +1,34 @@
#ifndef _EFL_ECORE_BUFFER_API_H
#define _EFL_ECORE_BUFFER_API_H
#ifdef ECORE_BUFFER_API
#error ECORE_BUFFER_API should not be already defined
#endif
#ifdef _WIN32
# ifndef ECORE_BUFFER_STATIC
# ifdef ECORE_BUFFER_BUILD
# define ECORE_BUFFER_API __declspec(dllexport)
# else
# define ECORE_BUFFER_API __declspec(dllimport)
# endif
# else
# define ECORE_BUFFER_API
# endif
# define ECORE_BUFFER_API_WEAK
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define ECORE_BUFFER_API __attribute__ ((visibility("default")))
# define ECORE_BUFFER_API_WEAK __attribute__ ((weak))
# else
# define ECORE_BUFFER_API
# define ECORE_BUFFER_API_WEAK
# endif
# else
# define ECORE_BUFFER_API
# define ECORE_BUFFER_API_WEAK
# endif
#endif
#endif

View File

@ -45,7 +45,7 @@ struct bq_consumer_listener _ecore_buffer_consumer_listener =
_ecore_buffer_consumer_cb_add_buffer
};
EAPI Ecore_Buffer_Consumer *
ECORE_BUFFER_API Ecore_Buffer_Consumer *
ecore_buffer_consumer_new(const char *name, int32_t queue_size, int32_t w, int32_t h)
{
Ecore_Buffer_Consumer *consumer;
@ -90,7 +90,7 @@ ecore_buffer_consumer_new(const char *name, int32_t queue_size, int32_t w, int32
return consumer;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_consumer_free(Ecore_Buffer_Consumer *consumer)
{
EINA_SAFETY_ON_NULL_RETURN(consumer);
@ -106,7 +106,7 @@ ecore_buffer_consumer_free(Ecore_Buffer_Consumer *consumer)
free(consumer);
}
EAPI Eina_Bool
ECORE_BUFFER_API Eina_Bool
ecore_buffer_consumer_buffer_release(Ecore_Buffer_Consumer *consumer, Ecore_Buffer *buffer)
{
Shared_Buffer *sb;
@ -151,7 +151,7 @@ ecore_buffer_consumer_buffer_release(Ecore_Buffer_Consumer *consumer, Ecore_Buff
return EINA_TRUE;
}
EAPI Ecore_Buffer *
ECORE_BUFFER_API Ecore_Buffer *
ecore_buffer_consumer_buffer_dequeue(Ecore_Buffer_Consumer *consumer)
{
Shared_Buffer *sb;
@ -179,7 +179,7 @@ ecore_buffer_consumer_buffer_dequeue(Ecore_Buffer_Consumer *consumer)
return _shared_buffer_buffer_get(sb);
}
EAPI Eina_Bool
ECORE_BUFFER_API Eina_Bool
ecore_buffer_consumer_queue_is_empty(Ecore_Buffer_Consumer *consumer)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(consumer, EINA_FALSE);
@ -187,7 +187,7 @@ ecore_buffer_consumer_queue_is_empty(Ecore_Buffer_Consumer *consumer)
return _ecore_buffer_queue_is_empty(consumer->ebq);
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_consumer_provider_add_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Provider_Add_Cb func, void *data)
{
EINA_SAFETY_ON_NULL_RETURN(consumer);
@ -196,7 +196,7 @@ ecore_buffer_consumer_provider_add_cb_set(Ecore_Buffer_Consumer *consumer, Ecore
consumer->cb.data = data;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_consumer_provider_del_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Provider_Del_Cb func, void *data)
{
EINA_SAFETY_ON_NULL_RETURN(consumer);
@ -205,7 +205,7 @@ ecore_buffer_consumer_provider_del_cb_set(Ecore_Buffer_Consumer *consumer, Ecore
consumer->cb.data = data;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_consumer_buffer_enqueued_cb_set(Ecore_Buffer_Consumer *consumer, Ecore_Buffer_Consumer_Enqueue_Cb func, void *data)
{
EINA_SAFETY_ON_NULL_RETURN(consumer);

View File

@ -39,7 +39,7 @@ struct bq_provider_listener _ecore_buffer_provider_listener =
_ecore_buffer_provider_cb_add_buffer
};
EAPI Ecore_Buffer_Provider *
ECORE_BUFFER_API Ecore_Buffer_Provider *
ecore_buffer_provider_new(const char *name)
{
Ecore_Buffer_Provider *provider;
@ -71,7 +71,7 @@ ecore_buffer_provider_new(const char *name)
return provider;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_provider_free(Ecore_Buffer_Provider *provider)
{
Eina_List *shared_buffers, *l;
@ -96,7 +96,7 @@ ecore_buffer_provider_free(Ecore_Buffer_Provider *provider)
free(provider);
}
EAPI Ecore_Buffer_Return
ECORE_BUFFER_API Ecore_Buffer_Return
ecore_buffer_provider_buffer_acquire(Ecore_Buffer_Provider *provider, Ecore_Buffer **ret_buf)
{
Shared_Buffer *sb;
@ -136,7 +136,7 @@ ecore_buffer_provider_buffer_acquire(Ecore_Buffer_Provider *provider, Ecore_Buff
return ret_flag;
}
EAPI Eina_Bool
ECORE_BUFFER_API Eina_Bool
ecore_buffer_provider_buffer_enqueue(Ecore_Buffer_Provider *provider, Ecore_Buffer *buffer)
{
Shared_Buffer *sb;
@ -191,7 +191,7 @@ ecore_buffer_provider_buffer_enqueue(Ecore_Buffer_Provider *provider, Ecore_Buff
return EINA_TRUE;
}
EAPI Ecore_Buffer_Return
ECORE_BUFFER_API Ecore_Buffer_Return
ecore_buffer_provider_buffer_acquirable_check(Ecore_Buffer_Provider *provider)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(provider, EINA_FALSE);
@ -207,7 +207,7 @@ ecore_buffer_provider_buffer_acquirable_check(Ecore_Buffer_Provider *provider)
return ECORE_BUFFER_RETURN_NOT_EMPTY;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_provider_consumer_add_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Consumer_Add_Cb func, void *data)
{
EINA_SAFETY_ON_NULL_RETURN(provider);
@ -216,7 +216,7 @@ ecore_buffer_provider_consumer_add_cb_set(Ecore_Buffer_Provider *provider, Ecore
provider->cb.data = data;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_provider_consumer_del_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Consumer_Del_Cb func, void *data)
{
EINA_SAFETY_ON_NULL_RETURN(provider);
@ -225,7 +225,7 @@ ecore_buffer_provider_consumer_del_cb_set(Ecore_Buffer_Provider *provider, Ecore
provider->cb.data = data;
}
EAPI void
ECORE_BUFFER_API void
ecore_buffer_provider_buffer_released_cb_set(Ecore_Buffer_Provider *provider, Ecore_Buffer_Provider_Enqueue_Cb func, void *data)
{
EINA_SAFETY_ON_NULL_RETURN(provider);

View File

@ -5,7 +5,7 @@
int _ecore_buffer_queue_log_dom = -1;
static int _ecore_buffer_queue_init_count = 0;
EAPI int
ECORE_BUFFER_API int
ecore_buffer_queue_init(void)
{
if (++_ecore_buffer_queue_init_count != 1)
@ -39,7 +39,7 @@ err:
return --_ecore_buffer_queue_init_count;
}
EAPI int
ECORE_BUFFER_API int
ecore_buffer_queue_shutdown(void)
{
if (--_ecore_buffer_queue_init_count != 0)

View File

@ -20,7 +20,7 @@ ecore_buffer_src = files([
ecore_buffer_lib = library('ecore_buffer',
ecore_buffer_src, pub_eo_file_target,
c_args : package_c_args,
c_args : [package_c_args, '-DECORE_BUFFER_BUILD'],
dependencies: ecore_buffer_pub_deps + ecore_buffer_deps + ecore_buffer_ext_deps,
include_directories : config_dir,
install: true,

View File

@ -10,20 +10,7 @@
#include <Eina.h>
#ifdef EAPI
# undef EAPI
#endif
#ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
#else
# define EAPI
#endif
#include <ecore_cocoa_api.h>
#ifdef __cplusplus
extern "C" {
@ -135,24 +122,24 @@ typedef enum
* Event triggered when a Cocoa window receives focus
* @since 1.18
*/
EAPI extern int ECORE_COCOA_EVENT_WINDOW_FOCUSED;
ECORE_COCOA_API int ECORE_COCOA_EVENT_WINDOW_FOCUSED;
/**
* Event triggered when a Cocoa window loses focus
* @since 1.18
*/
EAPI extern int ECORE_COCOA_EVENT_WINDOW_UNFOCUSED;
ECORE_COCOA_API int ECORE_COCOA_EVENT_WINDOW_UNFOCUSED;
/**
* Event triggered when a Cocoa window is resized
* @since 1.18
*/
EAPI extern int ECORE_COCOA_EVENT_WINDOW_RESIZE_REQUEST;
ECORE_COCOA_API int ECORE_COCOA_EVENT_WINDOW_RESIZE_REQUEST;
/** Event triggered when a Cocoa window get destroyed
* @since 1.18
*/
EAPI extern int ECORE_COCOA_EVENT_WINDOW_DESTROY;
ECORE_COCOA_API int ECORE_COCOA_EVENT_WINDOW_DESTROY;
/**
* @struct _Ecore_Cocoa_Event_Window_Resize_Request
@ -205,14 +192,14 @@ struct _Ecore_Cocoa_Event_Window_Destroy
* @return How many times Ecore_Cocoa has been initted
* @since 1.18
*/
EAPI int ecore_cocoa_init(void);
ECORE_COCOA_API int ecore_cocoa_init(void);
/**
* Shuts the Ecore_Cocoa library down
* @return How many times Ecore_Cocoa has been shut down
* @since 1.18
*/
EAPI int ecore_cocoa_shutdown(void);
ECORE_COCOA_API int ecore_cocoa_shutdown(void);
/*============================================================================*
@ -226,7 +213,7 @@ EAPI int ecore_cocoa_shutdown(void);
* @param [out] h The height of the screen
* @since 1.18
*/
EAPI void ecore_cocoa_screen_size_get(Ecore_Cocoa_Screen *screen, int *w, int *h);
ECORE_COCOA_API void ecore_cocoa_screen_size_get(Ecore_Cocoa_Screen *screen, int *w, int *h);
/*============================================================================*
@ -242,7 +229,7 @@ EAPI void ecore_cocoa_screen_size_get(Ecore_Cocoa_Screen *screen, int *w, int *h
* @return A handler on the window. NULL on failure
* @since 1.18
*/
EAPI Ecore_Cocoa_Window *ecore_cocoa_window_new(int x,
ECORE_COCOA_API Ecore_Cocoa_Window *ecore_cocoa_window_new(int x,
int y,
int w,
int h)
@ -254,7 +241,7 @@ EAPI Ecore_Cocoa_Window *ecore_cocoa_window_new(int x,
* @param window The window to be released
* @since 1.18
*/
EAPI void ecore_cocoa_window_free(Ecore_Cocoa_Window *window)
ECORE_COCOA_API void ecore_cocoa_window_free(Ecore_Cocoa_Window *window)
EINA_ARG_NONNULL(1);
/**
@ -264,7 +251,7 @@ EAPI void ecore_cocoa_window_free(Ecore_Cocoa_Window *window)
* @param y The new origin of the window (Y)
* @since 1.18
*/
EAPI void ecore_cocoa_window_move(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_move(Ecore_Cocoa_Window *window,
int x,
int y)
EINA_ARG_NONNULL(1);
@ -276,7 +263,7 @@ EAPI void ecore_cocoa_window_move(Ecore_Cocoa_Window *window,
* @param h The new height of the window
* @since 1.18
*/
EAPI void ecore_cocoa_window_resize(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_resize(Ecore_Cocoa_Window *window,
int w,
int h)
EINA_ARG_NONNULL(1);
@ -293,7 +280,7 @@ EAPI void ecore_cocoa_window_resize(Ecore_Cocoa_Window *window,
* @see ecore_cocoa_window_move()
* @since 1.18
*/
EAPI void ecore_cocoa_window_move_resize(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_move_resize(Ecore_Cocoa_Window *window,
int x,
int y,
int w,
@ -309,7 +296,7 @@ EAPI void ecore_cocoa_window_move_resize(Ecore_Cocoa_Window *window,
* @param h Pointer used to retrieve its height
* @since 1.18
*/
EAPI void ecore_cocoa_window_geometry_get(const Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_geometry_get(const Ecore_Cocoa_Window *window,
int *x,
int *y,
int *w,
@ -323,7 +310,7 @@ EAPI void ecore_cocoa_window_geometry_get(const Ecore_Cocoa_Window *window,
* @param h Pointer used to retrieve its height
* @since 1.18
*/
EAPI void ecore_cocoa_window_size_get(const Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_size_get(const Ecore_Cocoa_Window *window,
int *w,
int *h)
EINA_ARG_NONNULL(1);
@ -335,7 +322,7 @@ EAPI void ecore_cocoa_window_size_get(const Ecore_Cocoa_Window *window,
* @param h The new minimum height of the window
* @since 1.18
*/
EAPI void ecore_cocoa_window_size_min_set(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_size_min_set(Ecore_Cocoa_Window *window,
int w,
int h)
EINA_ARG_NONNULL(1);
@ -347,7 +334,7 @@ EAPI void ecore_cocoa_window_size_min_set(Ecore_Cocoa_Window *window,
* @param h Pointer used to retrieve its minimum height
* @since 1.18
*/
EAPI void ecore_cocoa_window_size_min_get(const Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_size_min_get(const Ecore_Cocoa_Window *window,
int *w,
int *h)
EINA_ARG_NONNULL(1);
@ -359,7 +346,7 @@ EAPI void ecore_cocoa_window_size_min_get(const Ecore_Cocoa_Window *window,
* @param h The new maximum height of the window
* @since 1.18
*/
EAPI void ecore_cocoa_window_size_max_set(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_size_max_set(Ecore_Cocoa_Window *window,
int w,
int h)
EINA_ARG_NONNULL(1);
@ -371,7 +358,7 @@ EAPI void ecore_cocoa_window_size_max_set(Ecore_Cocoa_Window *window,
* @param h Pointer used to retrieve its maximum height
* @since 1.18
*/
EAPI void ecore_cocoa_window_size_max_get(const Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_size_max_get(const Ecore_Cocoa_Window *window,
int *w,
int *h)
EINA_ARG_NONNULL(1);
@ -383,7 +370,7 @@ EAPI void ecore_cocoa_window_size_max_get(const Ecore_Cocoa_Window *window,
* @param h The height size increment
* @since 1.18
*/
EAPI void ecore_cocoa_window_size_step_set(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_size_step_set(Ecore_Cocoa_Window *window,
int w,
int h)
EINA_ARG_NONNULL(1);
@ -395,7 +382,7 @@ EAPI void ecore_cocoa_window_size_step_set(Ecore_Cocoa_Window *window,
* @param h The height size increment
* @since 1.18
*/
EAPI void ecore_cocoa_window_size_step_get(const Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_size_step_get(const Ecore_Cocoa_Window *window,
int *w,
int *h)
EINA_ARG_NONNULL(1);
@ -405,7 +392,7 @@ EAPI void ecore_cocoa_window_size_step_get(const Ecore_Cocoa_Window *window,
* @param window The Cocoa window to be displayed
* @since 1.18
*/
EAPI void ecore_cocoa_window_show(Ecore_Cocoa_Window *window)
ECORE_COCOA_API void ecore_cocoa_window_show(Ecore_Cocoa_Window *window)
EINA_ARG_NONNULL(1);
/**
@ -413,7 +400,7 @@ EAPI void ecore_cocoa_window_show(Ecore_Cocoa_Window *window)
* @param window The Cocoa window to be hid
* @since 1.18
*/
EAPI void ecore_cocoa_window_hide(Ecore_Cocoa_Window *window)
ECORE_COCOA_API void ecore_cocoa_window_hide(Ecore_Cocoa_Window *window)
EINA_ARG_NONNULL(1);
/**
@ -421,7 +408,7 @@ EAPI void ecore_cocoa_window_hide(Ecore_Cocoa_Window *window)
* @param window The Cocoa window to be raised
* @since 1.18
*/
EAPI void ecore_cocoa_window_raise(Ecore_Cocoa_Window *window)
ECORE_COCOA_API void ecore_cocoa_window_raise(Ecore_Cocoa_Window *window)
EINA_ARG_NONNULL(1);
/**
@ -429,7 +416,7 @@ EAPI void ecore_cocoa_window_raise(Ecore_Cocoa_Window *window)
* @param window The Cocoa window to be lowered
* @since 1.18
*/
EAPI void ecore_cocoa_window_lower(Ecore_Cocoa_Window *window)
ECORE_COCOA_API void ecore_cocoa_window_lower(Ecore_Cocoa_Window *window)
EINA_ARG_NONNULL(1);
/**
@ -437,7 +424,7 @@ EAPI void ecore_cocoa_window_lower(Ecore_Cocoa_Window *window)
* @param window The Cocoa window to be activated
* @since 1.18
*/
EAPI void ecore_cocoa_window_activate(Ecore_Cocoa_Window *window)
ECORE_COCOA_API void ecore_cocoa_window_activate(Ecore_Cocoa_Window *window)
EINA_ARG_NONNULL(1);
/**
@ -446,7 +433,7 @@ EAPI void ecore_cocoa_window_activate(Ecore_Cocoa_Window *window)
* @param title The new title of the Cocoa window
* @since 1.18
*/
EAPI void ecore_cocoa_window_title_set(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_title_set(Ecore_Cocoa_Window *window,
const char *title)
EINA_ARG_NONNULL(1);
@ -456,7 +443,7 @@ EAPI void ecore_cocoa_window_title_set(Ecore_Cocoa_Window *window,
* @param on If #EINA_TRUE, will miniaturize the window. Will deminiaturize it if #EINA_FALSE
* @since 1.18
*/
EAPI void ecore_cocoa_window_iconified_set(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_iconified_set(Ecore_Cocoa_Window *window,
Eina_Bool on)
EINA_ARG_NONNULL(1);
@ -466,7 +453,7 @@ EAPI void ecore_cocoa_window_iconified_set(Ecore_Cocoa_Window *window,
* @param on If #EINA_TRUE, will remove borders. Will restore them if #EINA_FALSE
* @since 1.18
*/
EAPI void ecore_cocoa_window_borderless_set(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_borderless_set(Ecore_Cocoa_Window *window,
Eina_Bool on)
EINA_ARG_NONNULL(1);
@ -480,7 +467,7 @@ EAPI void ecore_cocoa_window_borderless_set(Ecore_Cocoa_Window *window,
* @param view The NSView to be set as @c window content view
* @since 1.18
*/
EAPI void ecore_cocoa_window_view_set(Ecore_Cocoa_Window *window,
ECORE_COCOA_API void ecore_cocoa_window_view_set(Ecore_Cocoa_Window *window,
Ecore_Cocoa_Object *view)
EINA_ARG_NONNULL(1)
EINA_ARG_NONNULL(2);
@ -490,7 +477,7 @@ EAPI void ecore_cocoa_window_view_set(Ecore_Cocoa_Window *window,
* @return The height of the title bar of Cocoa windows
* @since 1.18
*/
EAPI int ecore_cocoa_titlebar_height_get(void);
ECORE_COCOA_API int ecore_cocoa_titlebar_height_get(void);
/**
* Retrieves the actual NSWindow behind the Ecore_Cocoa wrapper
@ -498,7 +485,7 @@ EAPI int ecore_cocoa_titlebar_height_get(void);
* @return The Cocoa NSWindow manipulated by @c window
* @since 1.18
*/
EAPI Ecore_Cocoa_Object *ecore_cocoa_window_get(const Ecore_Cocoa_Window *window)
ECORE_COCOA_API Ecore_Cocoa_Object *ecore_cocoa_window_get(const Ecore_Cocoa_Window *window)
EINA_ARG_NONNULL(1)
EINA_WARN_UNUSED_RESULT;
@ -509,7 +496,7 @@ EAPI Ecore_Cocoa_Object *ecore_cocoa_window_get(const Ecore_Cocoa_Window *window
* @param c The cursor to be set
* @since 1.18
*/
EAPI void ecore_cocoa_window_cursor_set(Ecore_Cocoa_Window *win,
ECORE_COCOA_API void ecore_cocoa_window_cursor_set(Ecore_Cocoa_Window *win,
Ecore_Cocoa_Cursor c)
EINA_ARG_NONNULL(1);
@ -519,7 +506,7 @@ EAPI void ecore_cocoa_window_cursor_set(Ecore_Cocoa_Window *win,
* @param show Shows the cursor if EINA_TRUE. Hides it if EINA_FALSE
* @since 1.18
*/
EAPI void ecore_cocoa_window_cursor_show(Ecore_Cocoa_Window *win, Eina_Bool show);
ECORE_COCOA_API void ecore_cocoa_window_cursor_show(Ecore_Cocoa_Window *win, Eina_Bool show);
EINA_ARG_NONNULL(1);
/**
@ -531,7 +518,7 @@ EAPI void ecore_cocoa_window_cursor_show(Ecore_Cocoa_Window *win, Eina_Bool show
* @see Ecore_Cocoa_Terminate_Cb
* @since 1.19
*/
EAPI void ecore_cocoa_terminate_cb_set(Ecore_Cocoa_Terminate_Cb cb)
ECORE_COCOA_API void ecore_cocoa_terminate_cb_set(Ecore_Cocoa_Terminate_Cb cb)
EINA_ARG_NONNULL(1);
@ -548,7 +535,7 @@ EAPI void ecore_cocoa_terminate_cb_set(Ecore_Cocoa_Terminate_Cb cb)
* @param mime_type The type of object to set the data
* @return EINA_TRUE on success, EINA_FALSE on failure
*/
EAPI Eina_Bool ecore_cocoa_clipboard_set(const void *data,
ECORE_COCOA_API Eina_Bool ecore_cocoa_clipboard_set(const void *data,
int size,
const char *mime_type);
@ -559,19 +546,19 @@ EAPI Eina_Bool ecore_cocoa_clipboard_set(const void *data,
* @return The data retrieved from the clipboard. NULL on failure
*
*/
EAPI void *ecore_cocoa_clipboard_get(int *size,
ECORE_COCOA_API void *ecore_cocoa_clipboard_get(int *size,
const char *mime_type)
EINA_WARN_UNUSED_RESULT;
/*
* Deletes the contents of the Cocoa clipboard
*/
EAPI void ecore_cocoa_clipboard_clear(void);
ECORE_COCOA_API void ecore_cocoa_clipboard_clear(void);
/*
* Returns true when the clipboard contains data that can be received.
*/
EAPI Eina_Bool ecore_cocoa_clipboard_exists(void);
ECORE_COCOA_API Eina_Bool ecore_cocoa_clipboard_exists(void);
#endif /* EFL_BETA_API_SUPPORT */
@ -579,7 +566,4 @@ EAPI Eina_Bool ecore_cocoa_clipboard_exists(void);
}
#endif
#undef EAPI
#define EAPI
#endif

View File

@ -19,10 +19,10 @@
#include "ecore_cocoa_private.h"
EAPI int ECORE_COCOA_EVENT_WINDOW_UNFOCUSED = 0;
EAPI int ECORE_COCOA_EVENT_WINDOW_FOCUSED = 0;
EAPI int ECORE_COCOA_EVENT_WINDOW_RESIZE_REQUEST = 0;
EAPI int ECORE_COCOA_EVENT_WINDOW_DESTROY = 0;
ECORE_COCOA_API int ECORE_COCOA_EVENT_WINDOW_UNFOCUSED = 0;
ECORE_COCOA_API int ECORE_COCOA_EVENT_WINDOW_FOCUSED = 0;
ECORE_COCOA_API int ECORE_COCOA_EVENT_WINDOW_RESIZE_REQUEST = 0;
ECORE_COCOA_API int ECORE_COCOA_EVENT_WINDOW_DESTROY = 0;
static int _ecore_cocoa_init_count = 0;
@ -30,7 +30,7 @@ static int old_flags;
int _ecore_cocoa_log_domain = -1;
EAPI int
ECORE_COCOA_API int
ecore_cocoa_init(void)
{
if (++_ecore_cocoa_init_count != 1)
@ -76,7 +76,7 @@ ecore_cocoa_init(void)
* being shut down.
* @ingroup Ecore_Cocoa_Library_Group
*/
EAPI int
ECORE_COCOA_API int
ecore_cocoa_shutdown(void)
{
if (--_ecore_cocoa_init_count != 0)
@ -393,7 +393,7 @@ _ecore_cocoa_feed_events(void *anEvent)
return pass;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_screen_size_get(Ecore_Cocoa_Screen *screen EINA_UNUSED, int *w, int *h)
{
NSSize pt = [[[NSScreen screens] objectAtIndex:0] frame].size;
@ -404,7 +404,7 @@ ecore_cocoa_screen_size_get(Ecore_Cocoa_Screen *screen EINA_UNUSED, int *w, int
DBG("Screen size get : %dx%d", (int)pt.width, (int)pt.height);
}
EAPI int
ECORE_COCOA_API int
ecore_cocoa_titlebar_height_get(void)
{
static int height = -1;
@ -421,7 +421,7 @@ ecore_cocoa_titlebar_height_get(void)
return height;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_terminate_cb_set(Ecore_Cocoa_Terminate_Cb cb)
{
EINA_SAFETY_ON_NULL_RETURN(cb);

View File

@ -0,0 +1,34 @@
#ifndef _EFL_ECORE_COCOA_API_H
#define _EFL_ECORE_COCOA_API_H
#ifdef ECORE_COCOA_API
#error ECORE_COCOA_API should not be already defined
#endif
#ifdef _WIN32
# ifndef ECORE_COCOA_STATIC
# ifdef ECORE_COCOA_BUILD
# define ECORE_COCOA_API __declspec(dllexport)
# else
# define ECORE_COCOA_API __declspec(dllimport)
# endif
# else
# define ECORE_COCOA_API
# endif
# define ECORE_COCOA_API_WEAK
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define ECORE_COCOA_API __attribute__ ((visibility("default")))
# define ECORE_COCOA_API_WEAK __attribute__ ((weak))
# else
# define ECORE_COCOA_API
# define ECORE_COCOA_API_WEAK
# endif
# else
# define ECORE_COCOA_API
# define ECORE_COCOA_API_WEAK
# endif
#endif
#endif

View File

@ -8,7 +8,7 @@
#include "ecore_cocoa_private.h"
#import "ecore_cocoa_app.h"
EAPI Eina_Bool
ECORE_COCOA_API Eina_Bool
ecore_cocoa_clipboard_set(const void *data,
int size,
const char *raw_mime_type)
@ -46,7 +46,7 @@ ecore_cocoa_clipboard_set(const void *data,
return (ok) ? EINA_TRUE : EINA_FALSE;
}
EAPI Eina_Bool
ECORE_COCOA_API Eina_Bool
ecore_cocoa_clipboard_exists(void)
{
NSDictionary *options;
@ -61,7 +61,7 @@ ecore_cocoa_clipboard_exists(void)
return [pb canReadItemWithDataConformingToTypes: classes];
}
EAPI void *
ECORE_COCOA_API void *
ecore_cocoa_clipboard_get(int *size,
const char *raw_mime_type)
{
@ -158,7 +158,7 @@ fail:
return NULL;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_clipboard_clear(void)
{
[[NSPasteboard generalPasteboard] clearContents];

View File

@ -325,7 +325,7 @@ static NSCursor *_cursors[__ECORE_COCOA_CURSOR_LAST];
@end
EAPI Ecore_Cocoa_Window *
ECORE_COCOA_API Ecore_Cocoa_Window *
ecore_cocoa_window_new(int x,
int y,
int w,
@ -364,7 +364,7 @@ ecore_cocoa_window_new(int x,
return win;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_free(Ecore_Cocoa_Window *window)
{
if (!window)
@ -374,7 +374,7 @@ ecore_cocoa_window_free(Ecore_Cocoa_Window *window)
free(window);
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_size_min_set(Ecore_Cocoa_Window *window,
int w,
int h)
@ -384,7 +384,7 @@ ecore_cocoa_window_size_min_set(Ecore_Cocoa_Window *window,
window->window.contentMinSize = NSMakeSize(w, h);
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_size_min_get(const Ecore_Cocoa_Window *window,
int *w,
int *h)
@ -396,7 +396,7 @@ ecore_cocoa_window_size_min_get(const Ecore_Cocoa_Window *window,
if (h) *h = size.height;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_size_max_set(Ecore_Cocoa_Window *window,
int w,
int h)
@ -406,7 +406,7 @@ ecore_cocoa_window_size_max_set(Ecore_Cocoa_Window *window,
window->window.contentMaxSize = NSMakeSize(w, h);
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_size_max_get(const Ecore_Cocoa_Window *window,
int *w,
int *h)
@ -418,7 +418,7 @@ ecore_cocoa_window_size_max_get(const Ecore_Cocoa_Window *window,
if (h) *h = size.height;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_size_step_set(Ecore_Cocoa_Window *window,
int w,
int h)
@ -428,7 +428,7 @@ ecore_cocoa_window_size_step_set(Ecore_Cocoa_Window *window,
window->window.contentResizeIncrements = NSMakeSize(w, h);
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_size_step_get(const Ecore_Cocoa_Window *window,
int *w,
int *h)
@ -440,7 +440,7 @@ ecore_cocoa_window_size_step_get(const Ecore_Cocoa_Window *window,
if (h) *h = size.height;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_move(Ecore_Cocoa_Window *window,
int x,
int y)
@ -456,7 +456,7 @@ ecore_cocoa_window_move(Ecore_Cocoa_Window *window,
[window->window setFrame:win_frame display:YES];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_resize(Ecore_Cocoa_Window *window,
int w,
int h)
@ -474,7 +474,7 @@ ecore_cocoa_window_resize(Ecore_Cocoa_Window *window,
[win setFrame:win_frame display:YES];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_geometry_get(const Ecore_Cocoa_Window *window,
int *x,
int *y,
@ -490,7 +490,7 @@ ecore_cocoa_window_geometry_get(const Ecore_Cocoa_Window *window,
if (h) *h = frame.size.height;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_size_get(const Ecore_Cocoa_Window *window,
int *w,
int *h)
@ -502,7 +502,7 @@ ecore_cocoa_window_size_get(const Ecore_Cocoa_Window *window,
if (h) *h = size.height;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_move_resize(Ecore_Cocoa_Window *window,
int x,
int y,
@ -523,7 +523,7 @@ ecore_cocoa_window_move_resize(Ecore_Cocoa_Window *window,
[window->window setFrame:win_frame display:YES];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_title_set(Ecore_Cocoa_Window *window, const char *title)
{
EINA_SAFETY_ON_NULL_RETURN(window);
@ -532,7 +532,7 @@ ecore_cocoa_window_title_set(Ecore_Cocoa_Window *window, const char *title)
[window->window setTitle:[NSString stringWithUTF8String:title]];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_show(Ecore_Cocoa_Window *window)
{
EINA_SAFETY_ON_NULL_RETURN(window);
@ -542,7 +542,7 @@ ecore_cocoa_window_show(Ecore_Cocoa_Window *window)
[window->window display];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_hide(Ecore_Cocoa_Window *window)
{
EINA_SAFETY_ON_NULL_RETURN(window);
@ -551,28 +551,28 @@ ecore_cocoa_window_hide(Ecore_Cocoa_Window *window)
[window->window orderOut:NSApp];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_raise(Ecore_Cocoa_Window *window)
{
EINA_SAFETY_ON_NULL_RETURN(window);
[window->window orderFront:nil];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_lower(Ecore_Cocoa_Window *window)
{
EINA_SAFETY_ON_NULL_RETURN(window);
[window->window orderBack:nil];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_activate(Ecore_Cocoa_Window *window)
{
EINA_SAFETY_ON_NULL_RETURN(window);
[window->window makeKeyAndOrderFront:nil];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_iconified_set(Ecore_Cocoa_Window *window,
Eina_Bool on)
{
@ -588,7 +588,7 @@ ecore_cocoa_window_iconified_set(Ecore_Cocoa_Window *window,
}
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_borderless_set(Ecore_Cocoa_Window *window,
Eina_Bool on)
{
@ -603,7 +603,7 @@ ecore_cocoa_window_borderless_set(Ecore_Cocoa_Window *window,
}
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_view_set(Ecore_Cocoa_Window *window,
Ecore_Cocoa_Object *view)
{
@ -625,14 +625,14 @@ ecore_cocoa_window_view_set(Ecore_Cocoa_Window *window,
[area release];
}
EAPI Ecore_Cocoa_Object *
ECORE_COCOA_API Ecore_Cocoa_Object *
ecore_cocoa_window_get(const Ecore_Cocoa_Window *window)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(window, NULL);
return window->window;
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_cursor_set(Ecore_Cocoa_Window *win,
Ecore_Cocoa_Cursor c)
{
@ -645,7 +645,7 @@ ecore_cocoa_window_cursor_set(Ecore_Cocoa_Window *win,
[cursor set];
}
EAPI void
ECORE_COCOA_API void
ecore_cocoa_window_cursor_show(Ecore_Cocoa_Window *win,
Eina_Bool show)
{

View File

@ -33,7 +33,7 @@ evas_include_directories = [
ecore_cocoa_lib = library('ecore_cocoa',
ecore_cocoa_src, pub_eo_file_target,
c_args : package_c_args,
c_args : [package_c_args, '-DECORE_COCOA_BUILD'],
dependencies: ecore_cocoa_deps + ecore_cocoa_pub_deps + ecore_cocoa_ext_deps,
link_args : '-Wl,-U,_evas_textblock_text_markup_to_utf8',
include_directories : config_dir + evas_include_directories,

View File

@ -15,31 +15,7 @@
#include "Efl_Net.h"
#endif
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_con_api.h>
/**
* @defgroup Ecore_Con_Group Ecore_Con - Connection functions
@ -633,51 +609,51 @@ struct _Ecore_Con_Event_Url_Progress
};
/** A client has connected to the server. */
EAPI extern int ECORE_CON_EVENT_CLIENT_ADD;
ECORE_CON_API extern int ECORE_CON_EVENT_CLIENT_ADD;
/** A client has disconnected from the server. */
EAPI extern int ECORE_CON_EVENT_CLIENT_DEL;
ECORE_CON_API extern int ECORE_CON_EVENT_CLIENT_DEL;
/** A client experienced an error.
* @since 1.1
*/
EAPI extern int ECORE_CON_EVENT_CLIENT_ERROR;
ECORE_CON_API extern int ECORE_CON_EVENT_CLIENT_ERROR;
/** A client connection has been upgraded to SSL.
* @since 1.1
*/
EAPI extern int ECORE_CON_EVENT_CLIENT_UPGRADE;
ECORE_CON_API extern int ECORE_CON_EVENT_CLIENT_UPGRADE;
/** A server was created. */
EAPI extern int ECORE_CON_EVENT_SERVER_ADD;
ECORE_CON_API extern int ECORE_CON_EVENT_SERVER_ADD;
/** A server connection was lost. */
EAPI extern int ECORE_CON_EVENT_SERVER_DEL;
ECORE_CON_API extern int ECORE_CON_EVENT_SERVER_DEL;
/** A server experienced an error.
* @since 1.1
*/
EAPI extern int ECORE_CON_EVENT_SERVER_ERROR;
ECORE_CON_API extern int ECORE_CON_EVENT_SERVER_ERROR;
/** A server connection has been upgraded to SSL.
* @since 1.1
*/
EAPI extern int ECORE_CON_EVENT_SERVER_UPGRADE;
ECORE_CON_API extern int ECORE_CON_EVENT_SERVER_UPGRADE;
/** A server connection has sent data to its client.
* @since 1.1
*/
EAPI extern int ECORE_CON_EVENT_CLIENT_WRITE;
ECORE_CON_API extern int ECORE_CON_EVENT_CLIENT_WRITE;
/** A server connection object has sent data.
* @since 1.1
*/
EAPI extern int ECORE_CON_EVENT_SERVER_WRITE;
ECORE_CON_API extern int ECORE_CON_EVENT_SERVER_WRITE;
/** A client connected to the server has sent data. */
EAPI extern int ECORE_CON_EVENT_CLIENT_DATA;
ECORE_CON_API extern int ECORE_CON_EVENT_CLIENT_DATA;
/** A server connection object has data.*/
EAPI extern int ECORE_CON_EVENT_SERVER_DATA;
ECORE_CON_API extern int ECORE_CON_EVENT_SERVER_DATA;
/** A server connection has successfully negotiated an ip:port binding.
* @since 1.2
*/
EAPI extern int ECORE_CON_EVENT_PROXY_BIND;
ECORE_CON_API extern int ECORE_CON_EVENT_PROXY_BIND;
/** A URL object has data. */
EAPI extern int ECORE_CON_EVENT_URL_DATA;
ECORE_CON_API extern int ECORE_CON_EVENT_URL_DATA;
/** A URL object has completed its transfer to and from the server and can be reused. */
EAPI extern int ECORE_CON_EVENT_URL_COMPLETE;
ECORE_CON_API extern int ECORE_CON_EVENT_URL_COMPLETE;
/** A URL object has made progress in its transfer. */
EAPI extern int ECORE_CON_EVENT_URL_PROGRESS;
ECORE_CON_API extern int ECORE_CON_EVENT_URL_PROGRESS;
/**
* @}
@ -698,7 +674,7 @@ EAPI extern int ECORE_CON_EVENT_URL_PROGRESS;
* @note This function already calls ecore_init() internally, so you don't need
* to call it explicitly.
*/
EAPI int ecore_con_init(void);
ECORE_CON_API int ecore_con_init(void);
/**
* @brief Shuts down the Ecore_Con library.
@ -707,7 +683,7 @@ EAPI int ecore_con_init(void);
* @note This function already calls ecore_shutdown() internally, so you don't
* need to call it explicitly unless you called ecore_init() explicitly too.
*/
EAPI int ecore_con_shutdown(void);
ECORE_CON_API int ecore_con_shutdown(void);
/**
* @brief Do an asynchronous DNS lookup.
@ -727,7 +703,7 @@ EAPI int ecore_con_shutdown(void);
* @return @c true if the request did not fail to be set up, @c false
* otherwise.
*/
EAPI Eina_Bool ecore_con_lookup(const char *name, Ecore_Con_Dns_Cb done_cb, const void *data) EINA_ARG_NONNULL(1);
ECORE_CON_API Eina_Bool ecore_con_lookup(const char *name, Ecore_Con_Dns_Cb done_cb, const void *data) EINA_ARG_NONNULL(1);
/**
* @}
@ -748,7 +724,7 @@ EAPI Eina_Bool ecore_con_lookup(const char *name, Ecore_Con_Dns_Cb done_cb, cons
* @c 2 if SSL is available and provided by openssl,
* @c 0 if it is not available.
*/
EAPI int ecore_con_ssl_available_get(void);
ECORE_CON_API int ecore_con_ssl_available_get(void);
/**
* @brief Adds an SSL certificate for use in ecore_con functions.
@ -760,7 +736,7 @@ EAPI int ecore_con_ssl_available_get(void);
* @param cert The path to the certificate.
* @return @c EINA_FALSE if the file cannot be loaded, otherwise @c EINA_TRUE.
*/
EAPI Eina_Bool ecore_con_ssl_server_cert_add(Ecore_Con_Server *svr, const char *cert);
ECORE_CON_API Eina_Bool ecore_con_ssl_server_cert_add(Ecore_Con_Server *svr, const char *cert);
/**
* @brief Adds an SSL private key for use in ecore_con functions.
@ -772,7 +748,7 @@ EAPI Eina_Bool ecore_con_ssl_server_cert_add(Ecore_Con_Server *svr, cons
* @param key_file The path to the key file.
* @return @c EINA_FALSE if the file cannot be loaded, otherwise @c EINA_TRUE.
*/
EAPI Eina_Bool ecore_con_ssl_server_privkey_add(Ecore_Con_Server *svr, const char *key_file);
ECORE_CON_API Eina_Bool ecore_con_ssl_server_privkey_add(Ecore_Con_Server *svr, const char *key_file);
/**
* @brief Adds an SSL CRL for use in ecore_con functions.
@ -784,7 +760,7 @@ EAPI Eina_Bool ecore_con_ssl_server_privkey_add(Ecore_Con_Server *svr, c
* @param crl_file The path to the CRL file.
* @return @c EINA_FALSE if the file cannot be loaded, otherwise @c EINA_TRUE.
*/
EAPI Eina_Bool ecore_con_ssl_server_crl_add(Ecore_Con_Server *svr, const char *crl_file);
ECORE_CON_API Eina_Bool ecore_con_ssl_server_crl_add(Ecore_Con_Server *svr, const char *crl_file);
/**
* @brief Adds an SSL CA file for use in ecore_con functions.
@ -797,7 +773,7 @@ EAPI Eina_Bool ecore_con_ssl_server_crl_add(Ecore_Con_Server *svr, const
* @return @c EINA_FALSE if the file cannot be loaded, otherwise @c EINA_TRUE.
* @note since 1.2, this function can load directories.
*/
EAPI Eina_Bool ecore_con_ssl_server_cafile_add(Ecore_Con_Server *svr, const char *ca_file);
ECORE_CON_API Eina_Bool ecore_con_ssl_server_cafile_add(Ecore_Con_Server *svr, const char *ca_file);
/**
* @brief Enables certificate verification on a server object.
@ -806,7 +782,7 @@ EAPI Eina_Bool ecore_con_ssl_server_cafile_add(Ecore_Con_Server *svr, co
* to enable verification of certificates against loaded certificates.
* @param svr The server object
*/
EAPI void ecore_con_ssl_server_verify(Ecore_Con_Server *svr);
ECORE_CON_API void ecore_con_ssl_server_verify(Ecore_Con_Server *svr);
/**
* @brief Enables hostname-based certificate verification on a server object.
@ -818,7 +794,7 @@ EAPI void ecore_con_ssl_server_verify(Ecore_Con_Server *svr);
* ecore_con_server_add.
* @since 1.1
*/
EAPI void ecore_con_ssl_server_verify_basic(Ecore_Con_Server *svr);
ECORE_CON_API void ecore_con_ssl_server_verify_basic(Ecore_Con_Server *svr);
/**
* @brief Sets the hostname to verify against in certificate verification.
@ -833,7 +809,7 @@ EAPI void ecore_con_ssl_server_verify_basic(Ecore_Con_Server *svr);
* @param name The hostname to verify against
* @since 1.2
*/
EAPI void ecore_con_ssl_server_verify_name_set(Ecore_Con_Server *svr, const char *name);
ECORE_CON_API void ecore_con_ssl_server_verify_name_set(Ecore_Con_Server *svr, const char *name);
/**
* @brief Gets the hostname to verify against in certificate verification.
@ -845,7 +821,7 @@ EAPI void ecore_con_ssl_server_verify_name_set(Ecore_Con_Server *sv
* @return The hostname which will be used
* @since 1.2
*/
EAPI const char *ecore_con_ssl_server_verify_name_get(Ecore_Con_Server *svr);
ECORE_CON_API const char *ecore_con_ssl_server_verify_name_get(Ecore_Con_Server *svr);
/**
* @brief Upgrades a connection to a specified level of encryption.
@ -860,7 +836,7 @@ EAPI const char *ecore_con_ssl_server_verify_name_get(Ecore_Con_Server *sv
* @warning Setting a wrong value for @p ssl_type WILL mess up your program.
* @since 1.1
*/
EAPI Eina_Bool ecore_con_ssl_server_upgrade(Ecore_Con_Server *svr, Ecore_Con_Type ssl_type);
ECORE_CON_API Eina_Bool ecore_con_ssl_server_upgrade(Ecore_Con_Server *svr, Ecore_Con_Type ssl_type);
/**
* @brief Upgrades a connection to a specified level of encryption.
@ -874,7 +850,7 @@ EAPI Eina_Bool ecore_con_ssl_server_upgrade(Ecore_Con_Server *svr, Ecore
* @warning Setting a wrong value for @p ssl_type WILL mess up your program.
* @since 1.1
*/
EAPI Eina_Bool ecore_con_ssl_client_upgrade(Ecore_Con_Client *cl, Ecore_Con_Type ssl_type);
ECORE_CON_API Eina_Bool ecore_con_ssl_client_upgrade(Ecore_Con_Client *cl, Ecore_Con_Type ssl_type);
/**
* @}
@ -898,7 +874,7 @@ EAPI Eina_Bool ecore_con_ssl_client_upgrade(Ecore_Con_Client *cl, Ecore_
* @note This object NEVER needs to be explicitly freed.
* @since 1.2
*/
EAPI Ecore_Con_Socks *ecore_con_socks4_remote_add(const char *ip, int port, const char *username);
ECORE_CON_API Ecore_Con_Socks *ecore_con_socks4_remote_add(const char *ip, int port, const char *username);
/**
* @brief Finds a SOCKS v4 proxy in the proxy list.
@ -913,7 +889,7 @@ EAPI Ecore_Con_Socks *ecore_con_socks4_remote_add(const char *ip, int port, cons
* ecore_con_socks4_remote_add() should be used to return the actual object.
* @since 1.2
*/
EAPI Eina_Bool ecore_con_socks4_remote_exists(const char *ip, int port, const char *username);
ECORE_CON_API Eina_Bool ecore_con_socks4_remote_exists(const char *ip, int port, const char *username);
/**
* @brief Removes a SOCKS v4 proxy from the proxy list and delete it.
@ -927,7 +903,7 @@ EAPI Eina_Bool ecore_con_socks4_remote_exists(const char *ip, int port, c
* @warning Be aware that deleting a proxy which is being used WILL ruin your life.
* @since 1.2
*/
EAPI void ecore_con_socks4_remote_del(const char *ip, int port, const char *username);
ECORE_CON_API void ecore_con_socks4_remote_del(const char *ip, int port, const char *username);
/**
* @brief Adds a SOCKS v5 proxy to the proxy list.
@ -942,7 +918,7 @@ EAPI void ecore_con_socks4_remote_del(const char *ip, int port, cons
* @note This object NEVER needs to be explicitly freed.
* @since 1.2
*/
EAPI Ecore_Con_Socks *ecore_con_socks5_remote_add(const char *ip, int port, const char *username, const char *password);
ECORE_CON_API Ecore_Con_Socks *ecore_con_socks5_remote_add(const char *ip, int port, const char *username, const char *password);
/**
* @brief Finds a SOCKS v5 proxy in the proxy list.
@ -958,7 +934,7 @@ EAPI Ecore_Con_Socks *ecore_con_socks5_remote_add(const char *ip, int port, cons
* ecore_con_socks5_remote_add() should be used to return the actual object.
* @since 1.2
*/
EAPI Eina_Bool ecore_con_socks5_remote_exists(const char *ip, int port, const char *username, const char *password);
ECORE_CON_API Eina_Bool ecore_con_socks5_remote_exists(const char *ip, int port, const char *username, const char *password);
/**
* @brief Removes a SOCKS v5 proxy from the proxy list and delete it.
@ -973,7 +949,7 @@ EAPI Eina_Bool ecore_con_socks5_remote_exists(const char *ip, int port, c
* @warning Be aware that deleting a proxy which is being used WILL ruin your life.
* @since 1.2
*/
EAPI void ecore_con_socks5_remote_del(const char *ip, int port, const char *username, const char *password);
ECORE_CON_API void ecore_con_socks5_remote_del(const char *ip, int port, const char *username, const char *password);
/**
* @brief Sets DNS lookup mode on an existing SOCKS proxy.
@ -988,7 +964,7 @@ EAPI void ecore_con_socks5_remote_del(const char *ip, int port, cons
* @note By default, this setting is DISABLED.
* @since 1.2
*/
EAPI void ecore_con_socks_lookup_set(Ecore_Con_Socks *ecs, Eina_Bool enable);
ECORE_CON_API void ecore_con_socks_lookup_set(Ecore_Con_Socks *ecs, Eina_Bool enable);
/**
* @brief Gets DNS lookup mode on an existing SOCKS proxy.
@ -1002,7 +978,7 @@ EAPI void ecore_con_socks_lookup_set(Ecore_Con_Socks *ecs, Eina_Bool
* @note By default, this setting is DISABLED.
* @since 1.2
*/
EAPI Eina_Bool ecore_con_socks_lookup_get(Ecore_Con_Socks *ecs);
ECORE_CON_API Eina_Bool ecore_con_socks_lookup_get(Ecore_Con_Socks *ecs);
/**
* @brief Enables bind mode on a SOCKS proxy.
@ -1014,7 +990,7 @@ EAPI Eina_Bool ecore_con_socks_lookup_get(Ecore_Con_Socks *ecs);
* @warning Be aware that changing the operation mode of an active proxy may result in undefined behavior
* @since 1.2
*/
EAPI void ecore_con_socks_bind_set(Ecore_Con_Socks *ecs, Eina_Bool is_bind);
ECORE_CON_API void ecore_con_socks_bind_set(Ecore_Con_Socks *ecs, Eina_Bool is_bind);
/**
* @brief Returns bind mode of a SOCKS proxy.
@ -1025,7 +1001,7 @@ EAPI void ecore_con_socks_bind_set(Ecore_Con_Socks *ecs, Eina_Bool i
* @return If true, the connection established will be a port binding.
* @since 1.2
*/
EAPI Eina_Bool ecore_con_socks_bind_get(Ecore_Con_Socks *ecs);
ECORE_CON_API Eina_Bool ecore_con_socks_bind_get(Ecore_Con_Socks *ecs);
/**
* @brief Returns SOCKS version of a SOCKS proxy.
@ -1035,7 +1011,7 @@ EAPI Eina_Bool ecore_con_socks_bind_get(Ecore_Con_Socks *ecs);
* @return @c 0 on error, else @c 4/5
* @since 1.2
*/
EAPI unsigned int ecore_con_socks_version_get(Ecore_Con_Socks *ecs);
ECORE_CON_API unsigned int ecore_con_socks_version_get(Ecore_Con_Socks *ecs);
/**
* @brief Removes a SOCKS v4 proxy from the proxy list and delete it.
@ -1045,7 +1021,7 @@ EAPI unsigned int ecore_con_socks_version_get(Ecore_Con_Socks *ecs);
* @warning Be aware that deleting a proxy which is being used WILL ruin your life.
* @since 1.2
*/
EAPI void ecore_con_socks_remote_del(Ecore_Con_Socks *ecs);
ECORE_CON_API void ecore_con_socks_remote_del(Ecore_Con_Socks *ecs);
/**
* @brief Sets a proxy object to be used with the next server created with ecore_con_server_connect().
@ -1056,7 +1032,7 @@ EAPI void ecore_con_socks_remote_del(Ecore_Con_Socks *ecs);
* @see ecore_con_socks_apply_always()
* @since 1.2
*/
EAPI void ecore_con_socks_apply_once(Ecore_Con_Socks *ecs);
ECORE_CON_API void ecore_con_socks_apply_once(Ecore_Con_Socks *ecs);
/**
* @brief Sets a proxy object to be used with all servers created with ecore_con_server_connect().
@ -1073,7 +1049,7 @@ EAPI void ecore_con_socks_apply_once(Ecore_Con_Socks *ecs);
* port is the port to connect to on the proxy server.
* lookup is 1 if the proxy should perform all DNS lookups, otherwise 0 or omitted.
*/
EAPI void ecore_con_socks_apply_always(Ecore_Con_Socks *ecs);
ECORE_CON_API void ecore_con_socks_apply_always(Ecore_Con_Socks *ecs);
/**
* @}
@ -1178,7 +1154,7 @@ EAPI void ecore_con_socks_apply_always(Ecore_Con_Socks *ecs);
*
* @since 1.19
*/
EAPI char *ecore_con_local_path_new(Eina_Bool is_system, const char *name, int port) EINA_WARN_UNUSED_RESULT EINA_MALLOC EINA_ARG_NONNULL(2);
ECORE_CON_API char *ecore_con_local_path_new(Eina_Bool is_system, const char *name, int port) EINA_WARN_UNUSED_RESULT EINA_MALLOC EINA_ARG_NONNULL(2);
/**
* @brief Creates a server to listen for connections.
@ -1222,7 +1198,7 @@ EAPI char *ecore_con_local_path_new(Eina_Bool is_system, const char *name, int p
* #EFL_NET_SERVER_SIMPLE_CLASS.
* See @li @ref efl_net_server_simple_example.c
*/
EAPI Ecore_Con_Server *ecore_con_server_add(Ecore_Con_Type type,
ECORE_CON_API Ecore_Con_Server *ecore_con_server_add(Ecore_Con_Type type,
const char *name, int port,
const void *data);
@ -1278,7 +1254,7 @@ EAPI Ecore_Con_Server *ecore_con_server_add(Ecore_Con_Type type,
* #EFL_NET_DIALER_SIMPLE_CLASS.
* See @li @ref efl_net_dialer_simple_example.c
*/
EAPI Ecore_Con_Server *ecore_con_server_connect(Ecore_Con_Type type,
ECORE_CON_API Ecore_Con_Server *ecore_con_server_connect(Ecore_Con_Type type,
const char *name, int port,
const void *data);
/**
@ -1291,7 +1267,7 @@ EAPI Ecore_Con_Server *ecore_con_server_connect(Ecore_Con_Type type,
*
* @see ecore_con_server_add, ecore_con_server_connect
*/
EAPI void * ecore_con_server_del(Ecore_Con_Server *svr);
ECORE_CON_API void * ecore_con_server_del(Ecore_Con_Server *svr);
/**
* @brief Retrieves the name of server.
@ -1303,7 +1279,7 @@ EAPI void * ecore_con_server_del(Ecore_Con_Server *svr);
*
* @ingroup Efl_Network_Server
*/
EAPI const char *ecore_con_server_name_get(const Ecore_Con_Server *svr);
ECORE_CON_API const char *ecore_con_server_name_get(const Ecore_Con_Server *svr);
/**
* @brief Retrieves the data associated with the given server.
@ -1313,7 +1289,7 @@ EAPI const char *ecore_con_server_name_get(const Ecore_Con_Server *svr);
*
* @see ecore_con_server_data_set()
*/
EAPI void * ecore_con_server_data_get(Ecore_Con_Server *svr);
ECORE_CON_API void * ecore_con_server_data_get(Ecore_Con_Server *svr);
/**
* @brief Sets the data associated with the given server.
*
@ -1323,7 +1299,7 @@ EAPI void * ecore_con_server_data_get(Ecore_Con_Server *svr);
*
* @see ecore_con_server_data_get()
*/
EAPI void * ecore_con_server_data_set(Ecore_Con_Server *svr,
ECORE_CON_API void * ecore_con_server_data_set(Ecore_Con_Server *svr,
void *data);
/**
* @brief Retrieves whether the given server is currently connected.
@ -1331,7 +1307,7 @@ EAPI void * ecore_con_server_data_set(Ecore_Con_Server *svr,
* @param svr The given server.
* @return @c EINA_TRUE if the server is connected, @c EINA_FALSE otherwise.
*/
EAPI Eina_Bool ecore_con_server_connected_get(const Ecore_Con_Server *svr);
ECORE_CON_API Eina_Bool ecore_con_server_connected_get(const Ecore_Con_Server *svr);
/**
* @brief Retrieves the server port in use.
@ -1341,7 +1317,7 @@ EAPI Eina_Bool ecore_con_server_connected_get(const Ecore_Con_Server *sv
*
* The port where the server is listening for connections.
*/
EAPI int ecore_con_server_port_get(const Ecore_Con_Server *svr);
ECORE_CON_API int ecore_con_server_port_get(const Ecore_Con_Server *svr);
/**
* @brief Checks how long a server has been connected.
*
@ -1352,7 +1328,7 @@ EAPI int ecore_con_server_port_get(const Ecore_Con_Server *svr);
* This function is used to find out the time that has been elapsed since
* ecore_con_server_add() succeeded.
*/
EAPI double ecore_con_server_uptime_get(const Ecore_Con_Server *svr);
ECORE_CON_API double ecore_con_server_uptime_get(const Ecore_Con_Server *svr);
/**
* @brief Sends the given data to the given server.
*
@ -1370,7 +1346,7 @@ EAPI double ecore_con_server_uptime_get(const Ecore_Con_Server *svr);
* @see ecore_con_client_send()
* @see ecore_con_server_flush()
*/
EAPI int ecore_con_server_send(Ecore_Con_Server *svr,
ECORE_CON_API int ecore_con_server_send(Ecore_Con_Server *svr,
const void *data,
int size);
/**
@ -1396,7 +1372,7 @@ EAPI int ecore_con_server_send(Ecore_Con_Server *svr,
* clients have already connected and will not be affected by this call.
* Only clients subsequently trying to connect will be affected.
*/
EAPI void ecore_con_server_client_limit_set(Ecore_Con_Server *svr,
ECORE_CON_API void ecore_con_server_client_limit_set(Ecore_Con_Server *svr,
int client_limit,
char reject_excess_clients);
@ -1412,7 +1388,7 @@ EAPI void ecore_con_server_client_limit_set(Ecore_Con_Server *svr,
* @return The list of clients on this server.
*
*/
EAPI const Eina_List *ecore_con_server_clients_get(const Ecore_Con_Server *svr);
ECORE_CON_API const Eina_List *ecore_con_server_clients_get(const Ecore_Con_Server *svr);
/**
* @brief Gets the IP address of a server that has been connected to.
@ -1424,7 +1400,7 @@ EAPI const Eina_List *ecore_con_server_clients_get(const Ecore_Con_Server *svr);
* deletion for the @p svr object. If no IP is known @c NULL is
* returned.
*/
EAPI const char * ecore_con_server_ip_get(const Ecore_Con_Server *svr);
ECORE_CON_API const char * ecore_con_server_ip_get(const Ecore_Con_Server *svr);
/**
* @brief Flushes all pending data to the given server.
*
@ -1435,7 +1411,7 @@ EAPI const char * ecore_con_server_ip_get(const Ecore_Con_Server *svr);
* @see ecore_con_server_send()
* @see ecore_con_client_flush()
*/
EAPI void ecore_con_server_flush(Ecore_Con_Server *svr);
ECORE_CON_API void ecore_con_server_flush(Ecore_Con_Server *svr);
/**
* @brief Sets the default time after which an inactive client will be disconnected.
*
@ -1454,7 +1430,7 @@ EAPI void ecore_con_server_flush(Ecore_Con_Server *svr);
* @see ecore_con_server_timeout_get()
* @see ecore_con_client_timeout_set()
*/
EAPI void ecore_con_server_timeout_set(Ecore_Con_Server *svr, double timeout);
ECORE_CON_API void ecore_con_server_timeout_set(Ecore_Con_Server *svr, double timeout);
/**
* @brief Gets the default time after which an inactive client will be disconnected.
*
@ -1467,7 +1443,7 @@ EAPI void ecore_con_server_timeout_set(Ecore_Con_Server *svr, doubl
* @see ecore_con_server_timeout_set()
* @see ecore_con_client_timeout_get()
*/
EAPI double ecore_con_server_timeout_get(const Ecore_Con_Server *svr);
ECORE_CON_API double ecore_con_server_timeout_get(const Ecore_Con_Server *svr);
/**
* @brief Gets the fd that the server is connected to.
@ -1481,7 +1457,7 @@ EAPI double ecore_con_server_timeout_get(const Ecore_Con_Server *svr)
* @warning Seriously. Don't use this unless you know what you are doing.
* @since 1.1
*/
EAPI int ecore_con_server_fd_get(const Ecore_Con_Server *svr);
ECORE_CON_API int ecore_con_server_fd_get(const Ecore_Con_Server *svr);
/**
* @brief Gets the fd that the client is connected to.
@ -1493,7 +1469,7 @@ EAPI int ecore_con_server_fd_get(const Ecore_Con_Server *svr);
* It should not be tampered with unless you REALLY know what you are doing.
* @since 1.1
*/
EAPI int ecore_con_client_fd_get(const Ecore_Con_Client *cl);
ECORE_CON_API int ecore_con_client_fd_get(const Ecore_Con_Client *cl);
/**
* @}
*/
@ -1535,7 +1511,7 @@ EAPI int ecore_con_client_fd_get(const Ecore_Con_Client *cl);
* @see ecore_con_server_send()
* @see ecore_con_client_flush()
*/
EAPI int ecore_con_client_send(Ecore_Con_Client *cl,
ECORE_CON_API int ecore_con_client_send(Ecore_Con_Client *cl,
const void *data,
int size);
/**
@ -1544,14 +1520,14 @@ EAPI int ecore_con_client_send(Ecore_Con_Client *cl,
* @param cl The given client.
* @return Data associated with the client.
*/
EAPI void * ecore_con_client_del(Ecore_Con_Client *cl);
ECORE_CON_API void * ecore_con_client_del(Ecore_Con_Client *cl);
/**
* @brief Sets the data associated with the given client to @p data.
*
* @param cl The given client.
* @param data What to set the data to.
*/
EAPI void ecore_con_client_data_set(Ecore_Con_Client *cl,
ECORE_CON_API void ecore_con_client_data_set(Ecore_Con_Client *cl,
const void *data);
/**
* @brief Retrieves the data associated with the given client.
@ -1559,7 +1535,7 @@ EAPI void ecore_con_client_data_set(Ecore_Con_Client *cl,
* @param cl The given client.
* @return The data associated with @p cl.
*/
EAPI void * ecore_con_client_data_get(Ecore_Con_Client *cl);
ECORE_CON_API void * ecore_con_client_data_get(Ecore_Con_Client *cl);
/**
* @brief Gets the IP address of a client that has connected.
@ -1571,7 +1547,7 @@ EAPI void * ecore_con_client_data_get(Ecore_Con_Client *cl);
* The returned string should not be modified, freed or trusted to stay valid
* after deletion for the @p cl object. If no IP is known @c NULL is returned.
*/
EAPI const char * ecore_con_client_ip_get(const Ecore_Con_Client *cl);
ECORE_CON_API const char * ecore_con_client_ip_get(const Ecore_Con_Client *cl);
/**
* @brief Flushes all pending data to the given client.
*
@ -1582,7 +1558,7 @@ EAPI const char * ecore_con_client_ip_get(const Ecore_Con_Client *cl);
* @see ecore_con_client_send()
* @see ecore_con_server_flush()
*/
EAPI void ecore_con_client_flush(Ecore_Con_Client *cl);
ECORE_CON_API void ecore_con_client_flush(Ecore_Con_Client *cl);
/**
* @brief Checks how long a client has been connected.
*
@ -1592,7 +1568,7 @@ EAPI void ecore_con_client_flush(Ecore_Con_Client *cl);
*
* This function is used to find out how long a client has been connected for.
*/
EAPI double ecore_con_client_uptime_get(const Ecore_Con_Client *cl);
ECORE_CON_API double ecore_con_client_uptime_get(const Ecore_Con_Client *cl);
/**
* @brief Gets the default time after which the client will be disconnected when
* inactive.
@ -1605,7 +1581,7 @@ EAPI double ecore_con_client_uptime_get(const Ecore_Con_Client *cl);
*
* @see ecore_con_client_timeout_set()
*/
EAPI double ecore_con_client_timeout_get(const Ecore_Con_Client *cl);
ECORE_CON_API double ecore_con_client_timeout_get(const Ecore_Con_Client *cl);
/**
* @brief Sets the time after which the client will be disconnected when inactive.
*
@ -1625,14 +1601,14 @@ EAPI double ecore_con_client_timeout_get(const Ecore_Con_Client *cl);
* @see ecore_con_client_timeout_get()
* @see ecore_con_server_timeout_set()
*/
EAPI void ecore_con_client_timeout_set(Ecore_Con_Client *cl, double timeout);
ECORE_CON_API void ecore_con_client_timeout_set(Ecore_Con_Client *cl, double timeout);
/**
* @brief Returns whether the client is still connected.
*
* @param cl The given client.
* @return @c EINA_TRUE if connected, @c EINA_FALSE otherwise.
*/
EAPI Eina_Bool ecore_con_client_connected_get(const Ecore_Con_Client *cl);
ECORE_CON_API Eina_Bool ecore_con_client_connected_get(const Ecore_Con_Client *cl);
/**
* @brief Returns the port that the client has connected to.
*
@ -1640,7 +1616,7 @@ EAPI Eina_Bool ecore_con_client_connected_get(const Ecore_Con_Client *cl
* @return The port that @p cl has connected to, or @c -1 on error
* Use this function to return the port on which a given client has connected.
*/
EAPI int ecore_con_client_port_get(const Ecore_Con_Client *cl);
ECORE_CON_API int ecore_con_client_port_get(const Ecore_Con_Client *cl);
/**
* @brief The server the client is connected to.
@ -1648,7 +1624,7 @@ EAPI int ecore_con_client_port_get(const Ecore_Con_Client *cl);
* @param cl The client
* @return The server the client is connected to.
*/
EAPI Ecore_Con_Server *ecore_con_client_server_get(const Ecore_Con_Client *cl);
ECORE_CON_API Ecore_Con_Server *ecore_con_client_server_get(const Ecore_Con_Client *cl);
/**
* @}
@ -1773,7 +1749,7 @@ typedef enum _Ecore_Con_Url_Http_Version
* @since 1.2
* @see ecore_con_url_pipeline_get()
*/
EAPI Eina_Bool ecore_con_url_http_version_set(Ecore_Con_Url *url_con, Ecore_Con_Url_Http_Version version);
ECORE_CON_API Eina_Bool ecore_con_url_http_version_set(Ecore_Con_Url *url_con, Ecore_Con_Url_Http_Version version);
/**
* @brief Initializes the Ecore_Con_Url library.
@ -1783,7 +1759,7 @@ EAPI Eina_Bool ecore_con_url_http_version_set(Ecore_Con_Url *url_con, Ec
* @note This function doesn't call ecore_con_init(). You still need to call it
* explicitly before calling this one.
*/
EAPI int ecore_con_url_init(void);
ECORE_CON_API int ecore_con_url_init(void);
/**
* @brief Shuts down the Ecore_Con_Url library.
@ -1792,7 +1768,7 @@ EAPI int ecore_con_url_init(void);
* @note This function doesn't call ecore_con_shutdown(). You still need to call
* it explicitly after calling this one.
*/
EAPI int ecore_con_url_shutdown(void);
ECORE_CON_API int ecore_con_url_shutdown(void);
/**
* @brief Enables or disable HTTP 1.1 pipelining.
@ -1809,14 +1785,14 @@ EAPI int ecore_con_url_shutdown(void);
*
* @see ecore_con_url_pipeline_get()
*/
EAPI void ecore_con_url_pipeline_set(Eina_Bool enable);
ECORE_CON_API void ecore_con_url_pipeline_set(Eina_Bool enable);
/**
* @brief Is HTTP 1.1 pipelining enable ?
* @return @c EINA_TRUE if it is enable.
*
* @see ecore_con_url_pipeline_set()
*/
EAPI Eina_Bool ecore_con_url_pipeline_get(void);
ECORE_CON_API Eina_Bool ecore_con_url_pipeline_get(void);
/**
* @brief Creates and initializes a new Ecore_Con_Url connection object.
@ -1832,7 +1808,7 @@ EAPI Eina_Bool ecore_con_url_pipeline_get(void);
* @see ecore_con_url_custom_new()
* @see ecore_con_url_url_set()
*/
EAPI Ecore_Con_Url * ecore_con_url_new(const char *url);
ECORE_CON_API Ecore_Con_Url * ecore_con_url_new(const char *url);
/**
@ -1842,7 +1818,7 @@ EAPI Ecore_Con_Url * ecore_con_url_new(const char *url);
* @param url the new URL.
* @return @c EINA_TRUE on success, @c EINA_FALSE on errors.
*/
EAPI Eina_Bool ecore_con_url_url_set(Ecore_Con_Url *url_con,
ECORE_CON_API Eina_Bool ecore_con_url_url_set(Ecore_Con_Url *url_con,
const char *url);
/**
@ -1851,7 +1827,7 @@ EAPI Eina_Bool ecore_con_url_url_set(Ecore_Con_Url *url_con,
* @param url_con the Connection object to retrieve URL.
* @return @c NULL on error, read-only URL string on success.
*/
EAPI const char *ecore_con_url_url_get(Ecore_Con_Url *url_con);
ECORE_CON_API const char *ecore_con_url_url_get(Ecore_Con_Url *url_con);
/**
* @brief Creates a custom connection object.
@ -1868,7 +1844,7 @@ EAPI const char *ecore_con_url_url_get(Ecore_Con_Url *url_con);
* @see ecore_con_url_new()
* @see ecore_con_url_url_set()
*/
EAPI Ecore_Con_Url * ecore_con_url_custom_new(const char *url,
ECORE_CON_API Ecore_Con_Url * ecore_con_url_custom_new(const char *url,
const char *custom_request);
/**
* @brief Destroys an Ecore_Con_Url connection object.
@ -1877,7 +1853,7 @@ EAPI Ecore_Con_Url * ecore_con_url_custom_new(const char *url,
*
* @see ecore_con_url_new()
*/
EAPI void ecore_con_url_free(Ecore_Con_Url *url_con);
ECORE_CON_API void ecore_con_url_free(Ecore_Con_Url *url_con);
/**
* @brief Associates data with a connection object.
@ -1890,7 +1866,7 @@ EAPI void ecore_con_url_free(Ecore_Con_Url *url_con);
*
* @see ecore_con_url_data_get()
*/
EAPI void ecore_con_url_data_set(Ecore_Con_Url *url_con,
ECORE_CON_API void ecore_con_url_data_set(Ecore_Con_Url *url_con,
void *data);
/**
* @brief Retrieves data associated with a Ecore_Con_Url connection object.
@ -1904,7 +1880,7 @@ EAPI void ecore_con_url_data_set(Ecore_Con_Url *url_con,
*
* @see ecore_con_url_data_set()
*/
EAPI void * ecore_con_url_data_get(Ecore_Con_Url *url_con);
ECORE_CON_API void * ecore_con_url_data_get(Ecore_Con_Url *url_con);
/**
* @brief Adds an additional header to the request connection object.
*
@ -1922,7 +1898,7 @@ EAPI void * ecore_con_url_data_get(Ecore_Con_Url *url_con);
* @see ecore_con_url_post()
* @see ecore_con_url_additional_headers_clear()
*/
EAPI void ecore_con_url_additional_header_add(Ecore_Con_Url *url_con,
ECORE_CON_API void ecore_con_url_additional_header_add(Ecore_Con_Url *url_con,
const char *key,
const char *value);
/**
@ -1937,7 +1913,7 @@ EAPI void ecore_con_url_additional_header_add(Ecore_Con_Url *url_co
* @see ecore_con_url_get()
* @see ecore_con_url_post()
*/
EAPI void ecore_con_url_additional_headers_clear(Ecore_Con_Url *url_con);
ECORE_CON_API void ecore_con_url_additional_headers_clear(Ecore_Con_Url *url_con);
/**
* @brief Retrieves headers from last request sent.
*
@ -1949,7 +1925,7 @@ EAPI void ecore_con_url_additional_headers_clear(Ecore_Con_Url *url
*
* @return List of response headers. This list must not be modified by the user.
*/
EAPI const Eina_List * ecore_con_url_response_headers_get(Ecore_Con_Url *url_con);
ECORE_CON_API const Eina_List * ecore_con_url_response_headers_get(Ecore_Con_Url *url_con);
/**
* @brief Sets up a file for receiving response data.
*
@ -1964,7 +1940,7 @@ EAPI const Eina_List * ecore_con_url_response_headers_get(Ecore_Con_Url *url_con
* This call can be used to easily setup a file where the downloaded data will
* be saved.
*/
EAPI void ecore_con_url_fd_set(Ecore_Con_Url *url_con, int fd);
ECORE_CON_API void ecore_con_url_fd_set(Ecore_Con_Url *url_con, int fd);
/**
* @brief Retrieves the number of bytes received.
*
@ -1978,7 +1954,7 @@ EAPI void ecore_con_url_fd_set(Ecore_Con_Url *url_con, int fd);
* @see ecore_con_url_get()
* @see ecore_con_url_post()
*/
EAPI int ecore_con_url_received_bytes_get(Ecore_Con_Url *url_con);
ECORE_CON_API int ecore_con_url_received_bytes_get(Ecore_Con_Url *url_con);
/**
* @brief Sets url_con to use http auth, with given username and password, "safely" or not.
*
@ -1993,7 +1969,7 @@ EAPI int ecore_con_url_received_bytes_get(Ecore_Con_Url *url_con);
* @attention Require libcurl >= 7.19.1 to work, otherwise will always return
* @c 0.
*/
EAPI Eina_Bool ecore_con_url_httpauth_set(Ecore_Con_Url *url_con,
ECORE_CON_API Eina_Bool ecore_con_url_httpauth_set(Ecore_Con_Url *url_con,
const char *username,
const char *password,
Eina_Bool safe);
@ -2017,7 +1993,7 @@ EAPI Eina_Bool ecore_con_url_httpauth_set(Ecore_Con_Url *url_con,
* @see ecore_con_url_time()
* @see ecore_con_url_post()
*/
EAPI Eina_Bool ecore_con_url_get(Ecore_Con_Url *url_con);
ECORE_CON_API Eina_Bool ecore_con_url_get(Ecore_Con_Url *url_con);
/**
* @brief Sends a HEAD request.
*
@ -2037,7 +2013,7 @@ EAPI Eina_Bool ecore_con_url_get(Ecore_Con_Url *url_con);
* @see ecore_con_url_post()
* @since 1.14
*/
EAPI Eina_Bool ecore_con_url_head(Ecore_Con_Url *url_con);
ECORE_CON_API Eina_Bool ecore_con_url_head(Ecore_Con_Url *url_con);
/**
* @brief Sends a post request.
*
@ -2066,7 +2042,7 @@ EAPI Eina_Bool ecore_con_url_head(Ecore_Con_Url *url_con);
* @see ecore_con_url_time()
* @see ecore_con_url_get()
*/
EAPI Eina_Bool ecore_con_url_post(Ecore_Con_Url *url_con,
ECORE_CON_API Eina_Bool ecore_con_url_post(Ecore_Con_Url *url_con,
const void *data, long length,
const char *content_type);
/**
@ -2084,7 +2060,7 @@ EAPI Eina_Bool ecore_con_url_post(Ecore_Con_Url *url_con,
* @sa ecore_con_url_get()
* @sa ecore_con_url_post()
*/
EAPI void ecore_con_url_time(Ecore_Con_Url *url_con,
ECORE_CON_API void ecore_con_url_time(Ecore_Con_Url *url_con,
Ecore_Con_Url_Time time_condition,
double timestamp);
@ -2101,7 +2077,7 @@ EAPI void ecore_con_url_time(Ecore_Con_Url *url_con,
* Upload @p filename to an ftp server set in @p url_con using @p user
* and @p pass to directory @p upload_dir
*/
EAPI Eina_Bool ecore_con_url_ftp_upload(Ecore_Con_Url *url_con,
ECORE_CON_API Eina_Bool ecore_con_url_ftp_upload(Ecore_Con_Url *url_con,
const char *filename,
const char *user,
const char *pass,
@ -2116,14 +2092,14 @@ EAPI Eina_Bool ecore_con_url_ftp_upload(Ecore_Con_Url *url_con,
* information about its operations, which is useful for
* debugging. The verbose information will be sent to stderr.
*/
EAPI void ecore_con_url_verbose_set(Ecore_Con_Url *url_con,
ECORE_CON_API void ecore_con_url_verbose_set(Ecore_Con_Url *url_con,
Eina_Bool verbose);
/**
* @brief Enables or disables EPSV extension.
* @param url_con The Ecore_Con_Url instance which will be acted upon.
* @param use_epsv Boolean to enable/disable the EPSV extension.
*/
EAPI void ecore_con_url_ftp_use_epsv_set(Ecore_Con_Url *url_con,
ECORE_CON_API void ecore_con_url_ftp_use_epsv_set(Ecore_Con_Url *url_con,
Eina_Bool use_epsv);
/**
@ -2138,7 +2114,7 @@ EAPI void ecore_con_url_ftp_use_epsv_set(Ecore_Con_Url *url_con,
* @note Even though this function is called @c ecore_con_url_cookies_init(),
* there is no symmetrical shutdown operation.
*/
EAPI void ecore_con_url_cookies_init(Ecore_Con_Url *url_con);
ECORE_CON_API void ecore_con_url_cookies_init(Ecore_Con_Url *url_con);
/**
* @brief Controls whether session cookies from previous sessions shall be loaded.
*
@ -2159,7 +2135,7 @@ EAPI void ecore_con_url_cookies_init(Ecore_Con_Url *url_con);
*
* @see ecore_con_url_cookies_file_add()
*/
EAPI void ecore_con_url_cookies_ignore_old_session_set(Ecore_Con_Url *url_con,
ECORE_CON_API void ecore_con_url_cookies_ignore_old_session_set(Ecore_Con_Url *url_con,
Eina_Bool ignore);
/**
* @brief Clears currently loaded cookies.
@ -2183,7 +2159,7 @@ EAPI void ecore_con_url_cookies_ignore_old_session_set(Ecore_Con_Ur
* @see ecore_con_url_cookies_session_clear()
* @see ecore_con_url_cookies_ignore_old_session_set()
*/
EAPI void ecore_con_url_cookies_clear(Ecore_Con_Url *url_con);
ECORE_CON_API void ecore_con_url_cookies_clear(Ecore_Con_Url *url_con);
/**
* @brief Clears currently loaded session cookies.
*
@ -2212,7 +2188,7 @@ EAPI void ecore_con_url_cookies_clear(Ecore_Con_Url *url_con);
* @see ecore_con_url_cookies_clear()
* @see ecore_con_url_cookies_ignore_old_session_set()
*/
EAPI void ecore_con_url_cookies_session_clear(Ecore_Con_Url *url_con);
ECORE_CON_API void ecore_con_url_cookies_session_clear(Ecore_Con_Url *url_con);
/**
* @brief Adds a file to the list of files from which to load cookies.
*
@ -2239,7 +2215,7 @@ EAPI void ecore_con_url_cookies_session_clear(Ecore_Con_Url *url_co
* @see ecore_con_url_cookies_ignore_old_session_set()
* @see ecore_con_url_cookies_jar_file_set()
*/
EAPI void ecore_con_url_cookies_file_add(Ecore_Con_Url *url_con,
ECORE_CON_API void ecore_con_url_cookies_file_add(Ecore_Con_Url *url_con,
const char * const file_name);
/**
* @brief Sets the name of the file to which all current cookies will be written when
@ -2262,7 +2238,7 @@ EAPI void ecore_con_url_cookies_file_add(Ecore_Con_Url *url_con,
*
* @see ecore_con_url_cookies_jar_write()
*/
EAPI Eina_Bool ecore_con_url_cookies_jar_file_set(Ecore_Con_Url *url_con,
ECORE_CON_API Eina_Bool ecore_con_url_cookies_jar_file_set(Ecore_Con_Url *url_con,
const char * const cookiejar_file);
/**
* @brief Writes all current cookies to the cookie jar immediately.
@ -2277,7 +2253,7 @@ EAPI Eina_Bool ecore_con_url_cookies_jar_file_set(Ecore_Con_Url *url_con
*
* @see ecore_con_url_cookies_jar_file_set()
*/
EAPI void ecore_con_url_cookies_jar_write(Ecore_Con_Url *url_con);
ECORE_CON_API void ecore_con_url_cookies_jar_write(Ecore_Con_Url *url_con);
/**
* Toggle libcurl's verify peer's certificate option.
@ -2291,7 +2267,7 @@ EAPI void ecore_con_url_cookies_jar_write(Ecore_Con_Url *url_con);
* @param verify Whether or not libcurl will check peer's certificate.
* @since 1.1.0
*/
EAPI void ecore_con_url_ssl_verify_peer_set(Ecore_Con_Url *url_con,
ECORE_CON_API void ecore_con_url_ssl_verify_peer_set(Ecore_Con_Url *url_con,
Eina_Bool verify);
/**
* Set a custom CA to trust for SSL/TLS connections.
@ -2311,7 +2287,7 @@ EAPI void ecore_con_url_ssl_verify_peer_set(Ecore_Con_Url *url_con,
* @return @c 0 on success. When cURL is used, non-zero return values
* are equal to cURL error codes.
*/
EAPI int ecore_con_url_ssl_ca_set(Ecore_Con_Url *url_con,
ECORE_CON_API int ecore_con_url_ssl_ca_set(Ecore_Con_Url *url_con,
const char *ca_path);
/**
@ -2331,7 +2307,7 @@ EAPI int ecore_con_url_ssl_ca_set(Ecore_Con_Url *url_con,
* @return @c EINA_TRUE on success, @c EINA_FALSE on error.
* @since 1.2
*/
EAPI Eina_Bool ecore_con_url_proxy_set(Ecore_Con_Url *url_con, const char *proxy);
ECORE_CON_API Eina_Bool ecore_con_url_proxy_set(Ecore_Con_Url *url_con, const char *proxy);
/**
* @brief Sets zero terminated username to use for proxy.
@ -2347,7 +2323,7 @@ EAPI Eina_Bool ecore_con_url_proxy_set(Ecore_Con_Url *url_con, const char *proxy
*
* @since 1.2
*/
EAPI Eina_Bool ecore_con_url_proxy_username_set(Ecore_Con_Url *url_con, const char *username);
ECORE_CON_API Eina_Bool ecore_con_url_proxy_username_set(Ecore_Con_Url *url_con, const char *username);
/**
* @brief Sets zero terminated password to use for proxy.
@ -2363,7 +2339,7 @@ EAPI Eina_Bool ecore_con_url_proxy_username_set(Ecore_Con_Url *url_con, const ch
*
* @since 1.2
*/
EAPI Eina_Bool ecore_con_url_proxy_password_set(Ecore_Con_Url *url_con, const char *password);
ECORE_CON_API Eina_Bool ecore_con_url_proxy_password_set(Ecore_Con_Url *url_con, const char *password);
/**
* @brief Sets timeout in seconds.
@ -2380,7 +2356,7 @@ EAPI Eina_Bool ecore_con_url_proxy_password_set(Ecore_Con_Url *url_con, const ch
*
* @since 1.2
*/
EAPI void ecore_con_url_timeout_set(Ecore_Con_Url *url_con, double timeout);
ECORE_CON_API void ecore_con_url_timeout_set(Ecore_Con_Url *url_con, double timeout);
/**
* @brief Gets the returned HTTP STATUS code.
@ -2391,7 +2367,7 @@ EAPI void ecore_con_url_timeout_set(Ecore_Con_Url *url_con, double timeout);
*
* @since 1.2
*/
EAPI int ecore_con_url_status_code_get(Ecore_Con_Url *url_con);
ECORE_CON_API int ecore_con_url_status_code_get(Ecore_Con_Url *url_con);
/**
* @brief Sets a maximum upload speed.
@ -2399,7 +2375,7 @@ EAPI int ecore_con_url_status_code_get(Ecore_Con_Url *url_con);
* @param url_obj Connection object
* @param max_speed Maximum upload speed, in bytes per second
*/
EAPI void ecore_con_url_limit_upload_speed(Ecore_Con_Url *url_obj, off_t max_speed);
ECORE_CON_API void ecore_con_url_limit_upload_speed(Ecore_Con_Url *url_obj, off_t max_speed);
/**
* @brief Sets a maximum download speed.
@ -2407,7 +2383,7 @@ EAPI void ecore_con_url_limit_upload_speed(Ecore_Con_Url *url_obj, off_t max_spe
* @param url_obj Connection object
* @param max_speed Maximum download speed, in bytes per second
*/
EAPI void ecore_con_url_limit_download_speed(Ecore_Con_Url *url_obj, off_t max_speed);
ECORE_CON_API void ecore_con_url_limit_download_speed(Ecore_Con_Url *url_obj, off_t max_speed);
/**
* @}
@ -2417,7 +2393,4 @@ EAPI void ecore_con_url_limit_download_speed(Ecore_Con_Url *url_obj, off_t max_s
}
#endif
#undef EAPI
#define EAPI
#endif

View File

@ -5,31 +5,7 @@
#include <Ecore.h>
#include <Ecore_Con.h>
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_con_api.h>
/**
* @defgroup Ecore_Con_Eet_Group Eet connection functions
@ -100,7 +76,7 @@ typedef Eina_Bool (*Ecore_Con_Eet_Server_Cb)(void *data, Ecore_Con_Reply *reply,
*
* @return A new Ecore_Con_Eet server.
*/
EAPI Ecore_Con_Eet *ecore_con_eet_server_new(Ecore_Con_Server *server);
ECORE_CON_API Ecore_Con_Eet *ecore_con_eet_server_new(Ecore_Con_Server *server);
/**
* @brief Creates an Ecore_Con_Eet client.
@ -114,7 +90,7 @@ EAPI Ecore_Con_Eet *ecore_con_eet_server_new(Ecore_Con_Server *server);
*
* @return A new Ecore_Con_Eet client.
*/
EAPI Ecore_Con_Eet *ecore_con_eet_client_new(Ecore_Con_Server *server);
ECORE_CON_API Ecore_Con_Eet *ecore_con_eet_client_new(Ecore_Con_Server *server);
/**
* @brief Frees an existing Ecore_Con_Eet object.
@ -124,7 +100,7 @@ EAPI Ecore_Con_Eet *ecore_con_eet_client_new(Ecore_Con_Server *server);
* ecore_con_eet_client_new.
*
*/
EAPI void ecore_con_eet_server_free(Ecore_Con_Eet *server);
ECORE_CON_API void ecore_con_eet_server_free(Ecore_Con_Eet *server);
/**
* @brief Registers an @c Eet data descriptor on a Ecore_Con_Eet object.
@ -135,7 +111,7 @@ EAPI void ecore_con_eet_server_free(Ecore_Con_Eet *server);
* in the Eet stream.
*
*/
EAPI void ecore_con_eet_register(Ecore_Con_Eet *ece, const char *name, Eet_Data_Descriptor *edd);
ECORE_CON_API void ecore_con_eet_register(Ecore_Con_Eet *ece, const char *name, Eet_Data_Descriptor *edd);
/**
* @brief Registers a data callback on a Ecore_Con_Eet object.
@ -147,7 +123,7 @@ EAPI void ecore_con_eet_register(Ecore_Con_Eet *ece, const char *name, Eet_Data_
* @param data The data to pass to the callback.
*
*/
EAPI void ecore_con_eet_data_callback_add(Ecore_Con_Eet *ece, const char *name, Ecore_Con_Eet_Data_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_data_callback_add(Ecore_Con_Eet *ece, const char *name, Ecore_Con_Eet_Data_Cb func, const void *data);
/**
* @brief Removes a data callback on a Ecore_Con_Eet object.
@ -156,7 +132,7 @@ EAPI void ecore_con_eet_data_callback_add(Ecore_Con_Eet *ece, const char *name,
* @param name The name of the Eet stream to remove callback on.
*
*/
EAPI void ecore_con_eet_data_callback_del(Ecore_Con_Eet *ece, const char *name);
ECORE_CON_API void ecore_con_eet_data_callback_del(Ecore_Con_Eet *ece, const char *name);
/**
* @brief Registers a raw data callback on a Ecore_Con_Eet object.
@ -168,7 +144,7 @@ EAPI void ecore_con_eet_data_callback_del(Ecore_Con_Eet *ece, const char *name);
* @param data The data to pass to the callback.
*
*/
EAPI void ecore_con_eet_raw_data_callback_add(Ecore_Con_Eet *ece, const char *name, Ecore_Con_Eet_Raw_Data_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_raw_data_callback_add(Ecore_Con_Eet *ece, const char *name, Ecore_Con_Eet_Raw_Data_Cb func, const void *data);
/**
* @brief Removes a raw data callback on a Ecore_Con_Eet object.
@ -177,7 +153,7 @@ EAPI void ecore_con_eet_raw_data_callback_add(Ecore_Con_Eet *ece, const char *na
* @param name The name of the raw Eet stream to remove callback on.
*
*/
EAPI void ecore_con_eet_raw_data_callback_del(Ecore_Con_Eet *ece, const char *name);
ECORE_CON_API void ecore_con_eet_raw_data_callback_del(Ecore_Con_Eet *ece, const char *name);
/**
* @brief Registers a client connect callback on a Ecore_Con_Eet object.
@ -189,7 +165,7 @@ EAPI void ecore_con_eet_raw_data_callback_del(Ecore_Con_Eet *ece, const char *na
* @param func The function to call as a callback.
* @param data The data to pass to the callback.
*/
EAPI void ecore_con_eet_client_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_client_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data);
/**
* @brief Removes a client connect callback on a Ecore_Con_Eet object.
@ -198,7 +174,7 @@ EAPI void ecore_con_eet_client_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Co
* @param func The callback to remove.
* @param data The data passed to this function at the callback registration.
*/
EAPI void ecore_con_eet_client_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_client_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data);
/**
* @brief Registers a client disconnect callback on a Ecore_Con_Eet object.
@ -210,7 +186,7 @@ EAPI void ecore_con_eet_client_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Co
* @param func The function to call as a callback.
* @param data The data to pass to the callback.
*/
EAPI void ecore_con_eet_client_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_client_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data);
/**
* @brief Removes a client disconnect callback on a Ecore_Con_Eet object.
@ -219,7 +195,7 @@ EAPI void ecore_con_eet_client_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore
* @param func The callback to remove.
* @param data The data passed to this function at the callback registration.
*/
EAPI void ecore_con_eet_client_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_client_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data);
/**
* @brief Registers a server connect callback on a Ecore_Con_Eet object.
@ -231,7 +207,7 @@ EAPI void ecore_con_eet_client_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore
* @param func The function to call as a callback.
* @param data The data to pass to the callback.
*/
EAPI void ecore_con_eet_server_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_server_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data);
/**
* @brief Removes a server connect callback on a Ecore_Con_Eet object.
@ -240,7 +216,7 @@ EAPI void ecore_con_eet_server_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Co
* @param func The callback to remove.
* @param data The data passed to this function at the callback registration.
*/
EAPI void ecore_con_eet_server_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_server_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data);
/**
* @brief Registers a server disconnect callback on a Ecore_Con_Eet object.
@ -252,7 +228,7 @@ EAPI void ecore_con_eet_server_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Co
* @param func The function to call as a callback.
* @param data The data to pass to the callback.
*/
EAPI void ecore_con_eet_server_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_server_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data);
/**
* @brief Removes a server disconnect callback on a Ecore_Con_Eet object.
@ -261,7 +237,7 @@ EAPI void ecore_con_eet_server_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore
* @param func The callback to remove.
* @param data The data passed to this function at the callback registration.
*/
EAPI void ecore_con_eet_server_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data);
ECORE_CON_API void ecore_con_eet_server_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data);
/**
* @brief Attaches data to an Ecore_Con_Eet object.
@ -269,7 +245,7 @@ EAPI void ecore_con_eet_server_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore
* @param ece An Ecore_Con_Eet object.
* @param data The data to attach to the Ecore_Con_Eet object.
*/
EAPI void ecore_con_eet_data_set(Ecore_Con_Eet *ece, const void *data);
ECORE_CON_API void ecore_con_eet_data_set(Ecore_Con_Eet *ece, const void *data);
/**
* @brief Gets the data attached to an Ecore_Con_Eet object.
@ -277,7 +253,7 @@ EAPI void ecore_con_eet_data_set(Ecore_Con_Eet *ece, const void *data);
* @param ece An Ecore_Con_Eet object.
* @return The data attached to the Ecore_Con_Eet object.
*/
EAPI const void *ecore_con_eet_data_get(Ecore_Con_Eet *ece);
ECORE_CON_API const void *ecore_con_eet_data_get(Ecore_Con_Eet *ece);
/**
* @brief Gets the Ecore_Con_Eet object corresponding to the Ecore_Con_Reply object.
@ -285,7 +261,7 @@ EAPI const void *ecore_con_eet_data_get(Ecore_Con_Eet *ece);
* @param reply An Ecore_Con_Reply object.
* @return The corresponding Ecore_Con_Eet object.
*/
EAPI Ecore_Con_Eet *ecore_con_eet_reply(Ecore_Con_Reply *reply);
ECORE_CON_API Ecore_Con_Eet *ecore_con_eet_reply(Ecore_Con_Reply *reply);
/**
* @brief Sends some data using a protocol type.
@ -294,7 +270,7 @@ EAPI Ecore_Con_Eet *ecore_con_eet_reply(Ecore_Con_Reply *reply);
* @param protocol_name The protocol type to use.
* @param value The data to send.
*/
EAPI void ecore_con_eet_send(Ecore_Con_Reply *reply, const char *protocol_name, void *value);
ECORE_CON_API void ecore_con_eet_send(Ecore_Con_Reply *reply, const char *protocol_name, void *value);
/**
* @brief Sends some raw data using a protocol type.
@ -305,7 +281,7 @@ EAPI void ecore_con_eet_send(Ecore_Con_Reply *reply, const char *protocol_name,
* @param value The data to send.
* @param length The data length.
*/
EAPI void ecore_con_eet_raw_send(Ecore_Con_Reply *reply, const char *protocol_name, const char *section, void *value, unsigned int length);
ECORE_CON_API void ecore_con_eet_raw_send(Ecore_Con_Reply *reply, const char *protocol_name, const char *section, void *value, unsigned int length);
/**
* @}
@ -315,7 +291,4 @@ EAPI void ecore_con_eet_raw_send(Ecore_Con_Reply *reply, const char *protocol_na
}
#endif
#undef EAPI
#define EAPI
#endif

View File

@ -13,31 +13,7 @@
#include <Efl_Core.h>
#ifdef EAPI
# undef EAPI
#endif
#ifdef _WIN32
# ifdef EFL_BUILD
# ifdef DLL_EXPORT
# define EAPI __declspec(dllexport)
# else
# define EAPI
# endif
# else
# define EAPI __declspec(dllimport)
# endif
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else
# define EAPI
# endif
# else
# define EAPI
# endif
#endif
#include <ecore_con_api.h>
#ifdef __cplusplus
extern "C" {
@ -51,7 +27,7 @@ extern "C" {
* @note This function already calls ecore_init() internally, so you don't need
* to call it explicitly.
*/
EAPI int ecore_con_init(void);
ECORE_CON_API int ecore_con_init(void);
/**
* @brief Shuts down the Ecore_Con library.
@ -60,7 +36,7 @@ EAPI int ecore_con_init(void);
* @note This function already calls ecore_shutdown() internally, so you don't
* need to call it explicitly unless you called ecore_init() explicitly too.
*/
EAPI int ecore_con_shutdown(void);
ECORE_CON_API int ecore_con_shutdown(void);
/**
* @brief Initializes the Ecore_Con_Url library.
@ -70,7 +46,7 @@ EAPI int ecore_con_shutdown(void);
* @note This function doesn't call ecore_con_init(). You still need to call it
* explicitly before calling this one.
*/
EAPI int ecore_con_url_init(void);
ECORE_CON_API int ecore_con_url_init(void);
/**
* @brief Shuts down the Ecore_Con_Url library.
@ -79,161 +55,161 @@ EAPI int ecore_con_url_init(void);
* @note This function doesn't call ecore_con_shutdown(). You still need to call
* it explicitly after calling this one.
*/
EAPI int ecore_con_url_shutdown(void);
ECORE_CON_API int ecore_con_url_shutdown(void);
#ifdef EFL_BETA_API_SUPPORT
/** HTTP error: bad content encoding */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_BAD_CONTENT_ENCODING;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_BAD_CONTENT_ENCODING;
/** HTTP error: bad download resume */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_BAD_DOWNLOAD_RESUME;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_BAD_DOWNLOAD_RESUME;
/** HTTP error: bad function argument */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_BAD_FUNCTION_ARGUMENT;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_BAD_FUNCTION_ARGUMENT;
/** HTTP error: chunk failed */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_CHUNK_FAILED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_CHUNK_FAILED;
/** HTTP error: conv failed */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_CONV_FAILED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_CONV_FAILED;
/** HTTP error: conv reqd */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_CONV_REQD;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_CONV_REQD;
/** HTTP error: failed init */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_FAILED_INIT;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_FAILED_INIT;
/** HTTP error: could not read file */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_FILE_COULDNT_READ_FILE;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_FILE_COULDNT_READ_FILE;
/** HTTP error: filesize exceeded */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_FILESIZE_EXCEEDED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_FILESIZE_EXCEEDED;
/** HTTP error: function not found */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_FUNCTION_NOT_FOUND;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_FUNCTION_NOT_FOUND;
/** HTTP error: got nothing */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_GOT_NOTHING;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_GOT_NOTHING;
/** HTTP error: http2 */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_HTTP2;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_HTTP2;
/** HTTP error: http2 stream */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_HTTP2_STREAM;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_HTTP2_STREAM;
/** HTTP error: http post error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_HTTP_POST_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_HTTP_POST_ERROR;
/** HTTP error: http returned error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_HTTP_RETURNED_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_HTTP_RETURNED_ERROR;
/** HTTP error: interface failed */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_INTERFACE_FAILED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_INTERFACE_FAILED;
/** HTTP error: login denied */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_LOGIN_DENIED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_LOGIN_DENIED;
/** HTTP error: no connection available */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_NO_CONNECTION_AVAILABLE;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_NO_CONNECTION_AVAILABLE;
/** HTTP error: not built in */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_NOT_BUILT_IN;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_NOT_BUILT_IN;
/** HTTP error: operation timeout */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_OPERATION_TIMEDOUT;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_OPERATION_TIMEDOUT;
/** HTTP error: partial file */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_PARTIAL_FILE;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_PARTIAL_FILE;
/** HTTP error: peer failed verification */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_PEER_FAILED_VERIFICATION;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_PEER_FAILED_VERIFICATION;
/** HTTP error: range error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_RANGE_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_RANGE_ERROR;
/** HTTP error: read error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_READ_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_READ_ERROR;
/** HTTP error: receive error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_RECV_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_RECV_ERROR;
/** HTTP error: remote access denied */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_REMOTE_ACCESS_DENIED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_REMOTE_ACCESS_DENIED;
/** HTTP error: remote disk full */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_REMOTE_DISK_FULL;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_REMOTE_DISK_FULL;
/** HTTP error: remote file exists */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_REMOTE_FILE_EXISTS;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_REMOTE_FILE_EXISTS;
/** HTTP error: remote file not found */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_REMOTE_FILE_NOT_FOUND;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_REMOTE_FILE_NOT_FOUND;
/** HTTP error: send error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SEND_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SEND_ERROR;
/** HTTP error: send fail rewind */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SEND_FAIL_REWIND;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SEND_FAIL_REWIND;
/** HTTP error: SSL cacert */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CACERT;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_CACERT;
/** HTTP error: SSL cacert bad file */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CACERT_BADFILE;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_CACERT_BADFILE;
/** HTTP error: SSL certproblem */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CERTPROBLEM;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_CERTPROBLEM;
/** HTTP error: SSL cipher */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CIPHER;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_CIPHER;
/** HTTP error: SSL connect error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CONNECT_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_CONNECT_ERROR;
/** HTTP error: SSL crl bad file */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CRL_BADFILE;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_CRL_BADFILE;
/** HTTP error: SSL engine init failed */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_INITFAILED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_INITFAILED;
/** HTTP error: SSL engine not found */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_NOTFOUND;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_NOTFOUND;
/** HTTP error: SSL engine set failed */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_SETFAILED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_SETFAILED;
/** HTTP error: SSL invalid cert status */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_INVALIDCERTSTATUS;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_INVALIDCERTSTATUS;
/** HTTP error: SSL issuer error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_ISSUER_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_ISSUER_ERROR;
/** HTTP error: SSL pinned pub key does not match */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_PINNEDPUBKEYNOTMATCH;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_PINNEDPUBKEYNOTMATCH;
/** HTTP error: SSL shutdown failed */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_SHUTDOWN_FAILED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_SSL_SHUTDOWN_FAILED;
/** HTTP error: too many redirects */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_TOO_MANY_REDIRECTS;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_TOO_MANY_REDIRECTS;
/** HTTP error: unknown option */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_UNKNOWN_OPTION;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_UNKNOWN_OPTION;
/** HTTP error: unsupported protocol */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_UNSUPPORTED_PROTOCOL;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_UNSUPPORTED_PROTOCOL;
/** HTTP error: upload failed */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_UPLOAD_FAILED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_UPLOAD_FAILED;
/** HTTP error: URL mal-formatted */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_URL_MALFORMAT;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_URL_MALFORMAT;
/** HTTP error: usage of SSL failed */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_USE_SSL_FAILED;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_USE_SSL_FAILED;
/** HTTP error: write error */
extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_WRITE_ERROR;
ECORE_CON_API ECORE_CON_API_WEAK extern Eina_Error EFL_NET_HTTP_ERROR_WRITE_ERROR;
#endif /* EFL_BETA_API_SUPPORT */
#include "efl_net_types.eot.h"
@ -293,7 +269,4 @@ extern EWAPI Eina_Error EFL_NET_HTTP_ERROR_WRITE_ERROR;
}
#endif
#undef EAPI
#define EAPI
#endif

View File

@ -64,7 +64,7 @@ char **_efl_net_proxy_helper_url_wait (int id);
void _efl_net_proxy_helper_init (void);
void _efl_net_proxy_helper_shutdown (void);
EAPI int
ECORE_CON_API int
ecore_con_init(void)
{
if (++_ecore_con_init_count != 1)
@ -129,7 +129,7 @@ ecore_con_log_error:
return --_ecore_con_init_count;
}
EAPI int
ECORE_CON_API int
ecore_con_shutdown(void)
{
/* _ecore_con_init_count should not go below zero. */
@ -162,7 +162,7 @@ ecore_con_shutdown(void)
return _ecore_con_init_count;
}
EAPI int
ECORE_CON_API int
ecore_con_ssl_available_get(void)
{
#if HAVE_GNUTLS

View File

@ -0,0 +1,34 @@
#ifndef _EFL_ECORE_CON_API_H
#define _EFL_ECORE_CON_API_H
#ifdef ECORE_CON_API
#error ECORE_CON_API should not be already defined
#endif
#ifdef _WIN32
# ifndef ECORE_CON_STATIC
# ifdef ECORE_CON_BUILD
# define ECORE_CON_API __declspec(dllexport)
# else
# define ECORE_CON_API __declspec(dllimport)
# endif
# else
# define ECORE_CON_API
# endif
# define ECORE_CON_API_WEAK
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define ECORE_CON_API __attribute__ ((visibility("default")))
# define ECORE_CON_API_WEAK __attribute__ ((weak))
# else
# define ECORE_CON_API
# define ECORE_CON_API_WEAK
# endif
# else
# define ECORE_CON_API
# define ECORE_CON_API_WEAK
# endif
#endif
#endif

View File

@ -717,7 +717,7 @@ _ecore_con_eet_base_server_get(const Eo *obj EINA_UNUSED, Ecore_Con_Eet_Base_Dat
* Global API *
**************/
EAPI Ecore_Con_Eet *
ECORE_CON_API Ecore_Con_Eet *
ecore_con_eet_server_new(Ecore_Con_Server *server)
{
Ecore_Con_Eet *ece_obj;
@ -729,7 +729,7 @@ ecore_con_eet_server_new(Ecore_Con_Server *server)
return ece_obj;
}
EAPI Ecore_Con_Eet *
ECORE_CON_API Ecore_Con_Eet *
ecore_con_eet_client_new(Ecore_Con_Server *server)
{
Ecore_Con_Eet *ece_obj;
@ -741,43 +741,43 @@ ecore_con_eet_client_new(Ecore_Con_Server *server)
return ece_obj;
}
EAPI void
ECORE_CON_API void
ecore_con_eet_server_free(Ecore_Con_Eet *server)
{
efl_unref(server);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_register(Ecore_Con_Eet *ece, const char *name, Eet_Data_Descriptor *edd)
{
ecore_con_eet_base_register(ece, name, edd);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_data_callback_add(Ecore_Con_Eet *ece, const char *name, Ecore_Con_Eet_Data_Cb func, const void *data)
{
ecore_con_eet_base_data_callback_set(ece, name, func, data);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_data_callback_del(Ecore_Con_Eet *ece, const char *name)
{
ecore_con_eet_base_data_callback_del(ece, name);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_raw_data_callback_add(Ecore_Con_Eet *ece, const char *name, Ecore_Con_Eet_Raw_Data_Cb func, const void *data)
{
ecore_con_eet_base_raw_data_callback_set(ece, name, func, data);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_raw_data_callback_del(Ecore_Con_Eet *ece, const char *name)
{
ecore_con_eet_base_raw_data_callback_del(ece, name);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_client_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data)
{
Ecore_Con_Eet_Server_Obj_Data *eces = efl_data_scope_get(ece, ECORE_CON_EET_SERVER_OBJ_CLASS);
@ -794,7 +794,7 @@ ecore_con_eet_client_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Clie
eces->client_connect_callbacks = eina_list_append(eces->client_connect_callbacks, c);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_client_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data)
{
Ecore_Con_Eet_Server_Obj_Data *eces = efl_data_scope_get(ece, ECORE_CON_EET_SERVER_OBJ_CLASS);
@ -812,7 +812,7 @@ ecore_con_eet_client_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Clie
}
}
EAPI void
ECORE_CON_API void
ecore_con_eet_client_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data)
{
Ecore_Con_Eet_Server_Obj_Data *eces = efl_data_scope_get(ece, ECORE_CON_EET_SERVER_OBJ_CLASS);
@ -829,7 +829,7 @@ ecore_con_eet_client_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_C
eces->client_disconnect_callbacks = eina_list_append(eces->client_disconnect_callbacks, c);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_client_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Client_Cb func, const void *data)
{
Ecore_Con_Eet_Server_Obj_Data *eced = efl_data_scope_get(ece, ECORE_CON_EET_SERVER_OBJ_CLASS);
@ -847,7 +847,7 @@ ecore_con_eet_client_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_C
}
}
EAPI void
ECORE_CON_API void
ecore_con_eet_server_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data)
{
Ecore_Con_Eet_Client_Obj_Data *eced = efl_data_scope_get(ece, ECORE_CON_EET_CLIENT_OBJ_CLASS);
@ -864,7 +864,7 @@ ecore_con_eet_server_connect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Serv
eced->server_connect_callbacks = eina_list_append(eced->server_connect_callbacks, s);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_server_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data)
{
Ecore_Con_Eet_Client_Obj_Data *eced = efl_data_scope_get(ece, ECORE_CON_EET_CLIENT_OBJ_CLASS);
@ -882,7 +882,7 @@ ecore_con_eet_server_connect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Serv
}
}
EAPI void
ECORE_CON_API void
ecore_con_eet_server_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data)
{
Ecore_Con_Eet_Client_Obj_Data *eced = efl_data_scope_get(ece, ECORE_CON_EET_CLIENT_OBJ_CLASS);
@ -899,7 +899,7 @@ ecore_con_eet_server_disconnect_callback_add(Ecore_Con_Eet *ece, Ecore_Con_Eet_S
eced->server_disconnect_callbacks = eina_list_append(eced->server_disconnect_callbacks, s);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_server_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_Server_Cb func, const void *data)
{
Ecore_Con_Eet_Client_Obj_Data *eced = efl_data_scope_get(ece, ECORE_CON_EET_CLIENT_OBJ_CLASS);
@ -917,32 +917,32 @@ ecore_con_eet_server_disconnect_callback_del(Ecore_Con_Eet *ece, Ecore_Con_Eet_S
}
}
EAPI void
ECORE_CON_API void
ecore_con_eet_data_set(Ecore_Con_Eet *ece, const void *data)
{
efl_key_data_set(ece, ECORE_CON_EET_DATA_KEY, data);
}
EAPI const void *
ECORE_CON_API const void *
ecore_con_eet_data_get(Ecore_Con_Eet *ece)
{
return efl_key_data_get(ece, ECORE_CON_EET_DATA_KEY);
}
EAPI Ecore_Con_Eet *
ECORE_CON_API Ecore_Con_Eet *
ecore_con_eet_reply(Ecore_Con_Reply *reply)
{
if (!reply) return NULL;
return reply->ece;
}
EAPI void
ECORE_CON_API void
ecore_con_eet_send(Ecore_Con_Reply *reply, const char *name, void *value)
{
ecore_con_eet_base_send(reply->ece, reply, name, value);
}
EAPI void
ECORE_CON_API void
ecore_con_eet_raw_send(Ecore_Con_Reply *reply, const char *protocol_name, const char *section, void *value, unsigned int length)
{
Eina_Binbuf *buf = eina_binbuf_manage_new(value, length, 1);

View File

@ -1,39 +1,39 @@
void _ecore_con_eet_base_server_set(Eo *obj, Ecore_Con_Eet_Base_Data *pd, Ecore_Con_Server *data);
EOAPI EFL_VOID_FUNC_BODYV(ecore_con_eet_base_server_set, EFL_FUNC_CALL(data), Ecore_Con_Server *data);
ECORE_CON_API ECORE_CON_API_WEAK EFL_VOID_FUNC_BODYV(ecore_con_eet_base_server_set, EFL_FUNC_CALL(data), Ecore_Con_Server *data);
Ecore_Con_Server *_ecore_con_eet_base_server_get(const Eo *obj, Ecore_Con_Eet_Base_Data *pd);
EOAPI EFL_FUNC_BODY_CONST(ecore_con_eet_base_server_get, Ecore_Con_Server *, NULL);
ECORE_CON_API ECORE_CON_API_WEAK EFL_FUNC_BODY_CONST(ecore_con_eet_base_server_get, Ecore_Con_Server *, NULL);
void _ecore_con_eet_base_data_callback_set(Eo *obj, Ecore_Con_Eet_Base_Data *pd, const char *name, Ecore_Con_Eet_Data_Cb func, const void *data);
EOAPI EFL_VOID_FUNC_BODYV(ecore_con_eet_base_data_callback_set, EFL_FUNC_CALL(name, func, data), const char *name, Ecore_Con_Eet_Data_Cb func, const void *data);
ECORE_CON_API ECORE_CON_API_WEAK EFL_VOID_FUNC_BODYV(ecore_con_eet_base_data_callback_set, EFL_FUNC_CALL(name, func, data), const char *name, Ecore_Con_Eet_Data_Cb func, const void *data);
void _ecore_con_eet_base_raw_data_callback_set(Eo *obj, Ecore_Con_Eet_Base_Data *pd, const char *name, Ecore_Con_Eet_Raw_Data_Cb func, const void *data);
EOAPI EFL_VOID_FUNC_BODYV(ecore_con_eet_base_raw_data_callback_set, EFL_FUNC_CALL(name, func, data), const char *name, Ecore_Con_Eet_Raw_Data_Cb func, const void *data);
ECORE_CON_API ECORE_CON_API_WEAK EFL_VOID_FUNC_BODYV(ecore_con_eet_base_raw_data_callback_set, EFL_FUNC_CALL(name, func, data), const char *name, Ecore_Con_Eet_Raw_Data_Cb func, const void *data);
void _ecore_con_eet_base_data_callback_del(Eo *obj, Ecore_Con_Eet_Base_Data *pd, const char *name);
EOAPI EFL_VOID_FUNC_BODYV(ecore_con_eet_base_data_callback_del, EFL_FUNC_CALL(name), const char *name);
ECORE_CON_API ECORE_CON_API_WEAK EFL_VOID_FUNC_BODYV(ecore_con_eet_base_data_callback_del, EFL_FUNC_CALL(name), const char *name);
void _ecore_con_eet_base_raw_data_callback_del(Eo *obj, Ecore_Con_Eet_Base_Data *pd, const char *name);
EOAPI EFL_VOID_FUNC_BODYV(ecore_con_eet_base_raw_data_callback_del, EFL_FUNC_CALL(name), const char *name);
ECORE_CON_API ECORE_CON_API_WEAK EFL_VOID_FUNC_BODYV(ecore_con_eet_base_raw_data_callback_del, EFL_FUNC_CALL(name), const char *name);
void _ecore_con_eet_base_register(Eo *obj, Ecore_Con_Eet_Base_Data *pd, const char *name, Eet_Data_Descriptor *edd);
EOAPI EFL_VOID_FUNC_BODYV(ecore_con_eet_base_register, EFL_FUNC_CALL(name, edd), const char *name, Eet_Data_Descriptor *edd);
ECORE_CON_API ECORE_CON_API_WEAK EFL_VOID_FUNC_BODYV(ecore_con_eet_base_register, EFL_FUNC_CALL(name, edd), const char *name, Eet_Data_Descriptor *edd);
void _ecore_con_eet_base_send(Eo *obj, Ecore_Con_Eet_Base_Data *pd, Ecore_Con_Reply *reply, const char *name, void *value);
EOAPI EFL_VOID_FUNC_BODYV(ecore_con_eet_base_send, EFL_FUNC_CALL(reply, name, value), Ecore_Con_Reply *reply, const char *name, void *value);
ECORE_CON_API ECORE_CON_API_WEAK EFL_VOID_FUNC_BODYV(ecore_con_eet_base_send, EFL_FUNC_CALL(reply, name, value), Ecore_Con_Reply *reply, const char *name, void *value);
void _ecore_con_eet_base_raw_send(Eo *obj, Ecore_Con_Eet_Base_Data *pd, Ecore_Con_Reply *reply, const char *protocol_name, const char *section, Eina_Binbuf *section_data);
EOAPI EFL_VOID_FUNC_BODYV(ecore_con_eet_base_raw_send, EFL_FUNC_CALL(reply, protocol_name, section, section_data), Ecore_Con_Reply *reply, const char *protocol_name, const char *section, Eina_Binbuf *section_data);
ECORE_CON_API ECORE_CON_API_WEAK EFL_VOID_FUNC_BODYV(ecore_con_eet_base_raw_send, EFL_FUNC_CALL(reply, protocol_name, section, section_data), Ecore_Con_Reply *reply, const char *protocol_name, const char *section, Eina_Binbuf *section_data);
Efl_Object *_ecore_con_eet_base_efl_object_constructor(Eo *obj, Ecore_Con_Eet_Base_Data *pd);

Some files were not shown because too many files have changed in this diff Show More