Compare commits

...

56 Commits

Author SHA1 Message Date
Felipe Magno de Almeida 3e78c99242 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-11-12 13:34:23 -03:00
Felipe Magno de Almeida 5e6945397f 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-10-30 22:52:42 -03:00
Felipe Magno de Almeida 24b6b8f459 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-10-30 23:06:53 -03:00
Felipe Magno de Almeida 4867816835 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-10-30 20:05:30 -03:00
Felipe Magno de Almeida 6cd5fd7291 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-10-30 17:05:00 -03:00
Felipe Magno de Almeida 72e7a9f951 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-10-30 13:27:23 -03:00
Felipe Magno de Almeida dc775bf8cb 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-10-30 10:53:34 -03:00
Felipe Magno de Almeida 64719a4116 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-10-29 19:37:44 -03:00
Felipe Magno de Almeida 2340baf476 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-10-29 13:33:18 -03:00
Felipe Magno de Almeida ca50bab09e 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-10-29 09:33:06 -03:00
Felipe Magno de Almeida 00246298a0 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.

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-10-28 18:32:52 -03:00
Felipe Magno de Almeida 33b59d04d0 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-10-28 13:32:41 -03:00
Felipe Magno de Almeida 4d1c4bf1b3 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-10-28 10:11:36 -03:00
Felipe Magno de Almeida 941dbde5e7 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-10-27 17:32:11 -03:00
Felipe Magno de Almeida 2c3e8e26ef 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-10-27 13:31:56 -03:00
Felipe Magno de Almeida 1984a1a2fb 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-10-26 13:31:38 -03:00
Felipe Magno de Almeida 7c933562d9 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-10-25 10:55:40 -03:00
Felipe Magno de Almeida c0e42a3bf4 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-10-24 09:16:10 -03:00
Felipe Magno de Almeida f0d3585e78 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-10-24 09:01:36 -03:00
Felipe Magno de Almeida a6c6965292 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-10-23 09:14:59 -03:00
Felipe Magno de Almeida 819ab93f8b 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-10-22 09:14:33 -03:00
Felipe Magno de Almeida 8dee56dfbb 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-10-21 09:12:12 -03:00
Felipe Magno de Almeida d222e43b07 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-10-20 09:11:25 -03:00
Felipe Magno de Almeida 856798774d 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-10-19 09:10:51 -03:00
Felipe Magno de Almeida 7b8abe6f85 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-10-18 09:10:00 -03:00
Felipe Magno de Almeida 0b75e82b3d 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-10-17 09:08:18 -03:00
Felipe Magno de Almeida 4a6882c2fd 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-10-16 16:46:40 -03:00
Felipe Magno de Almeida 95c2248065 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-10-15 15:48:08 -03:00
Felipe Magno de Almeida 7948b204bc 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-10-14 16:34:09 -03:00
Felipe Magno de Almeida 300cc7dcf6 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-10-14 17:22:00 -03:00
Felipe Magno de Almeida 62f87b69da 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-10-13 13:00:52 -03:00
Felipe Magno de Almeida a594413ccb elementary: Rename EAPI macro to ELM_API in Elementary 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-10-11 13:00:04 -03:00
Felipe Magno de Almeida 0d39e71f38 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-10-10 16:40:09 -03:00
Felipe Magno de Almeida 50a6a1b83b 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-10-09 13:28:09 -03:00
Felipe Magno de Almeida dc8ece8c41 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-10-06 17:03:55 -03:00
Felipe Magno de Almeida 5d43dd2b24 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-10-03 15:45:29 -03:00
Felipe Magno de Almeida 72f5e7d7ad edje: Add weak symbol
The symbols will be needed when we change how Eolian generates
import/export symbols in Eio
2020-10-01 12:57:05 -03:00
Felipe Magno de Almeida 19bb35fa0a 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-09-30 12:57:14 -03:00
Felipe Magno de Almeida 48e059c5a6 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-09-20 10:25:30 -03:00
Felipe Magno de Almeida b0f5c73ea3 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-09-20 10:23:26 -03:00
Felipe Magno de Almeida e8e39e5fea 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-09-20 10:22:27 -03:00
Felipe Magno de Almeida f47e469247 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-09-20 10:19:07 -03:00
Felipe Magno de Almeida 4f3fbec6c9 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-09-17 10:18:19 -03:00
Felipe Magno de Almeida d688766d0f 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-09-15 10:16:24 -03:00
Felipe Magno de Almeida 2fa81c36b5 evas: Rename EAPI macro to EVAS_API in Evas 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-09-13 10:14:31 -03:00
Felipe Magno de Almeida 7b02a3290f ecore_audio: Rename EAPI macro to ECORE_AUDIO_API in Ecore Audio 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-09-09 15:10:58 -03:00
Felipe Magno de Almeida 872ce2022b eio: Rename EAPI macro to EIO_API in Eio 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-09-07 23:01:06 -03:00
Felipe Magno de Almeida fd87bcf808 eo: Rename EAPI macro to EO_API in Eo 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-09-05 10:27:43 -03:00
Felipe Magno de Almeida e1e62a5203 eldbus: Add Eldbus.h entry point header
Add Eldbus.h so we can have EAPI definition
2020-09-03 22:37:10 -03:00
Felipe Magno de Almeida 1ffabc6391 eio: Add weak symbol
The symbols will be needed when we change how Eolian generates
import/export symbols in Eio
2020-09-01 22:58:10 -03:00
Felipe Magno de Almeida bd8f490228 benchmark: Remove unnecessary import and export macros from benchmark executables
Executables do not need to export and import symbols.
2020-08-27 10:24:25 -03:00
Felipe Magno de Almeida 8948e80de7 eolian: Remove unnecessary import and export macros from test executables
Executables do not need to export and import symbols.
2020-08-23 14:02:51 -03:00
Felipe Magno de Almeida 48921885e2 eolian: Add -e parameter to pass export symbol to eolian generator
Patch from a series of patches to rename EAPI symbols to specific
library DSOs.

Eolian generator must have a parameter so it can generate the correct
symbol export/import macro for the API generated.

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-08-20 17:36:00 -03:00
Felipe Magno de Almeida 1f0c580042 eolian: Rename EAPI macro to EOLIAN_API in Eolian 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-08-19 17:32:20 -03:00
Felipe Magno de Almeida b5d46fb7c4 eina: Rename EAPI macro to EINA_API in Eina 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-08-15 15:26:00 -03:00
Felipe Magno de Almeida 8d18d07689 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-08-11 16:40:00 -03:00
1482 changed files with 24986 additions and 25679 deletions

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

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

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

@ -1,5 +1,10 @@
#include <stdlib.h>
#include <unistd.h>
#ifndef _WIN32
# include <unistd.h>
#else
# include <evil_private.h>
#endif
#include <getopt.h>
#include "main.h"
#include "types.h"
@ -7,6 +12,7 @@
#include "sources.h"
int _eolian_gen_log_dom = -1;
char* _eolian_api_symbol;
enum
{
@ -44,6 +50,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 +501,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 +522,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 +534,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)

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)
@ -472,10 +473,11 @@ _gen_reflect_set(Eina_Strbuf *buf, const char *cnamel,
}
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,
_emit_class_function(Eina_Strbuf *buf, const Eolian_Function *fid, 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);
@ -486,22 +488,11 @@ _emit_class_function(Eina_Strbuf *buf, const Eolian_Function *fid, const Eolian_
eina_strbuf_append_buffer(buf, params_full);
eina_strbuf_append(buf, ")\n");
eina_strbuf_append(buf, "{\n");
eina_strbuf_append_printf(buf, " const Efl_Class *klass = %s();\n", eolian_class_c_get_function_name_get(eolian_function_class_get(fid)));
if (!!strcmp(rtpn, "void") && rtp)
{
const Eolian_Expression *default_value_expression = eolian_function_return_default_value_get(fid, ftype);
eina_strbuf_append_printf(buf, " EINA_SAFETY_ON_NULL_RETURN_VAL(klass,");
_append_defval(buf, default_value_expression, rtp, rtpn);
eina_strbuf_append_printf(buf, ");\n");
eina_strbuf_append(buf, " return ");
}
eina_strbuf_append_printf(buf, " %s();\n", eolian_class_c_get_function_name_get(eolian_function_class_get(fid)));
if (strcmp(rtpn, "void"))
eina_strbuf_append(buf, " return ");
else
{
eina_strbuf_append(buf, " EINA_SAFETY_ON_NULL_RETURN(klass);\n");
eina_strbuf_append(buf, " ");
}
eina_strbuf_append(buf, " ");
eina_strbuf_append_printf(buf, "_%s", ocnamel);
eina_strbuf_append_char(buf, '_');
eina_strbuf_append(buf, eolian_function_name_get(fid));
@ -894,7 +885,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");
@ -936,7 +928,7 @@ _gen_func(const Eolian_Class *cl, const Eolian_Function *fid,
eina_stringshare_del(eofn);
}
if (impl_same_class && eolian_function_is_static(fid))
_emit_class_function(buf, fid, ftype, rtp, rtpn, params_full, ocnamel, func_suffix, params, eolian_function_full_c_name_get(fid, ftype));
_emit_class_function(buf, fid, rtpn, params_full, ocnamel, func_suffix, params, eolian_function_full_c_name_get(fid, ftype));
free(cname);
free(cnamel);
@ -1125,7 +1117,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
int
eina_init(void)
{
int original_return;
@ -1085,7 +1085,7 @@ eina_init(void)
return original_return;
}
EAPI int
int
ecore_evas_init(void)
{
int original_return;
@ -1101,7 +1101,7 @@ ecore_evas_init(void)
}
//hook, to hook in our theme
EAPI int
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
void
ecore_main_loop_begin(void)
{
int original_return;
@ -1123,7 +1123,7 @@ ecore_main_loop_begin(void)
(void)original_return;
}
EAPI Eina_Value*
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
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
int
eina_init(void)
{
int original_return;
@ -332,7 +332,7 @@ eina_init(void)
return original_return;
}
EAPI int
int
ecore_evas_init(void)
{
int original_return;
@ -349,7 +349,7 @@ ecore_evas_init(void)
}
//hook, to hook in our theme
EAPI int
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
void
ecore_main_loop_begin(void)
{
int original_return;
@ -371,7 +371,7 @@ ecore_main_loop_begin(void)
(void)original_return;
}
EAPI Eina_Value*
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
int
eina_shutdown(void)
{
int original_return;

View File

@ -76,6 +76,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 +91,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

@ -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

@ -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

@ -534,14 +534,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 +747,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 +830,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 +843,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 +871,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 +882,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 +907,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 +925,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 +938,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 +956,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 +967,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

@ -286,7 +286,7 @@ _ecore_glib_shutdown(void)
#endif
}
EAPI Eina_Bool
ECORE_API Eina_Bool
ecore_main_loop_glib_integrate(void)
{
#ifdef HAVE_GLIB
@ -310,7 +310,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

@ -89,14 +89,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 +104,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;
@ -125,7 +125,7 @@ ecore_pipe_read_close(Ecore_Pipe *p)
}
}
EAPI int
ECORE_API int
ecore_pipe_read_fd(Ecore_Pipe *p)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(PIPE_FD_INVALID);
@ -133,7 +133,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 +149,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 +164,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 +172,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))
@ -187,7 +187,7 @@ ecore_pipe_write_close(Ecore_Pipe *p)
}
}
EAPI int
ECORE_API int
ecore_pipe_write_fd(Ecore_Pipe *p)
{
EINA_MAIN_LOOP_CHECK_RETURN_VAL(PIPE_FD_INVALID);
@ -195,7 +195,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)
@ -289,7 +289,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,

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

@ -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

@ -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

@ -3,32 +3,7 @@
#include <Eina.h>
#include <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
#include <ecore_audio_api.h>
/**
* @file Ecore_Audio.h
@ -176,7 +151,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 +165,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 +175,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 +205,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

@ -0,0 +1,34 @@
#ifndef _EFL_ECORE_AUDIO_API_H
#define _EFL_ECORE_AUDIO_API_H
#ifdef ECORE_AUDIO_API
#error ECORE_AUDIO_API should not be already defined
#endif
#ifdef _WIN32
# ifndef ECORE_AUDIO_STATIC
# ifdef ECORE_AUDIO_BUILD
# define ECORE_AUDIO_API __declspec(dllexport)
# else
# define ECORE_AUDIO_API __declspec(dllimport)
# endif
# else
# define ECORE_AUDIO_API
# endif
# define ECORE_AUDIO_API_WEAK
#else
# ifdef __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
# define ECORE_AUDIO_API
# define ECORE_AUDIO_API_WEAK
# endif
#endif
#endif

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

View File

@ -29,7 +29,7 @@ typedef struct _Ecore_Con_Reply Ecore_Con_Reply;
*/
#define ECORE_CON_EET_BASE_CLASS ecore_con_eet_base_class_get()
EWAPI const Efl_Class *ecore_con_eet_base_class_get(void) EINA_CONST;
ECORE_CON_API ECORE_CON_API_WEAK const Efl_Class *ecore_con_eet_base_class_get(void) EINA_CONST;
/**
* @brief The server object to which we send and receive.
@ -39,7 +39,7 @@ EWAPI const Efl_Class *ecore_con_eet_base_class_get(void) EINA_CONST;
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI void ecore_con_eet_base_server_set(Eo *obj, Ecore_Con_Server *data);
ECORE_CON_API ECORE_CON_API_WEAK void ecore_con_eet_base_server_set(Eo *obj, Ecore_Con_Server *data);
/**
* @brief The server object to which we send and receive.
@ -50,7 +50,7 @@ EOAPI void ecore_con_eet_base_server_set(Eo *obj, Ecore_Con_Server *data);
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI Ecore_Con_Server *ecore_con_eet_base_server_get(const Eo *obj);
ECORE_CON_API ECORE_CON_API_WEAK Ecore_Con_Server *ecore_con_eet_base_server_get(const Eo *obj);
/**
* @brief A callback function which should be called when data is received by
@ -64,7 +64,7 @@ EOAPI Ecore_Con_Server *ecore_con_eet_base_server_get(const Eo *obj);
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI void ecore_con_eet_base_data_callback_set(Eo *obj, const char *name, Ecore_Con_Eet_Data_Cb func, const void *data);
ECORE_CON_API ECORE_CON_API_WEAK void ecore_con_eet_base_data_callback_set(Eo *obj, const char *name, Ecore_Con_Eet_Data_Cb func, const void *data);
/**
* @brief A callback function which should be calledn when raw data is received
@ -78,7 +78,7 @@ EOAPI void ecore_con_eet_base_data_callback_set(Eo *obj, const char *name, Ecore
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI void ecore_con_eet_base_raw_data_callback_set(Eo *obj, const char *name, Ecore_Con_Eet_Raw_Data_Cb func, const void *data);
ECORE_CON_API ECORE_CON_API_WEAK void ecore_con_eet_base_raw_data_callback_set(Eo *obj, const char *name, Ecore_Con_Eet_Raw_Data_Cb func, const void *data);
/**
* @brief Function to delete the @ref ecore_con_eet_base_data_callback_set.
@ -88,7 +88,7 @@ EOAPI void ecore_con_eet_base_raw_data_callback_set(Eo *obj, const char *name, E
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI void ecore_con_eet_base_data_callback_del(Eo *obj, const char *name);
ECORE_CON_API ECORE_CON_API_WEAK void ecore_con_eet_base_data_callback_del(Eo *obj, const char *name);
/**
* @brief Function to delete the @ref ecore_con_eet_base_raw_data_callback_set.
@ -98,7 +98,7 @@ EOAPI void ecore_con_eet_base_data_callback_del(Eo *obj, const char *name);
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI void ecore_con_eet_base_raw_data_callback_del(Eo *obj, const char *name);
ECORE_CON_API ECORE_CON_API_WEAK void ecore_con_eet_base_raw_data_callback_del(Eo *obj, const char *name);
/**
* @brief Function to register a @ref Eet.Data.Descriptor to the ecore_con_eet
@ -110,7 +110,7 @@ EOAPI void ecore_con_eet_base_raw_data_callback_del(Eo *obj, const char *name);
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI void ecore_con_eet_base_register(Eo *obj, const char *name, Eet_Data_Descriptor *edd);
ECORE_CON_API ECORE_CON_API_WEAK void ecore_con_eet_base_register(Eo *obj, const char *name, Eet_Data_Descriptor *edd);
/**
* @brief Function to send data.
@ -123,7 +123,7 @@ EOAPI void ecore_con_eet_base_register(Eo *obj, const char *name, Eet_Data_Descr
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI void ecore_con_eet_base_send(Eo *obj, Ecore_Con_Reply *reply, const char *name, void *value);
ECORE_CON_API ECORE_CON_API_WEAK void ecore_con_eet_base_send(Eo *obj, Ecore_Con_Reply *reply, const char *name, void *value);
/**
* @brief Function to send raw data.
@ -137,6 +137,6 @@ EOAPI void ecore_con_eet_base_send(Eo *obj, Ecore_Con_Reply *reply, const char *
*
* @ingroup Ecore_Con_Eet_Base
*/
EOAPI void ecore_con_eet_base_raw_send(Eo *obj, Ecore_Con_Reply *reply, const char *protocol_name, const char *section, Eina_Binbuf *section_data);
ECORE_CON_API ECORE_CON_API_WEAK void ecore_con_eet_base_raw_send(Eo *obj, Ecore_Con_Reply *reply, const char *protocol_name, const char *section, Eina_Binbuf *section_data);
#endif

View File

@ -1,5 +1,5 @@
EAPI void
ECORE_CON_API void
ecore_con_eet(Ecore_Con_Eet_Base *obj, const char *name, Eet_Data_Descriptor *edd)
{
ecore_con_eet_base_register(obj, name, edd);

View File

@ -36,7 +36,7 @@ typedef struct _Ecore_Con_Reply Ecore_Con_Reply;
*
* @ingroup (null)_Group
*/
EAPI void ecore_con_eet(Ecore_Con_Eet_Base *obj, const char *name, Eet_Data_Descriptor *edd);
ECORE_CON_API void ecore_con_eet(Ecore_Con_Eet_Base *obj, const char *name, Eet_Data_Descriptor *edd);

View File

@ -19,6 +19,6 @@ typedef Eo Ecore_Con_Eet_Client_Obj;
*/
#define ECORE_CON_EET_CLIENT_OBJ_CLASS ecore_con_eet_client_obj_class_get()
EWAPI const Efl_Class *ecore_con_eet_client_obj_class_get(void) EINA_CONST;
ECORE_CON_API ECORE_CON_API_WEAK const Efl_Class *ecore_con_eet_client_obj_class_get(void) EINA_CONST;
#endif

View File

@ -19,6 +19,6 @@ typedef Eo Ecore_Con_Eet_Server_Obj;
*/
#define ECORE_CON_EET_SERVER_OBJ_CLASS ecore_con_eet_server_obj_class_get()
EWAPI const Efl_Class *ecore_con_eet_server_obj_class_get(void) EINA_CONST;
ECORE_CON_API ECORE_CON_API_WEAK const Efl_Class *ecore_con_eet_server_obj_class_get(void) EINA_CONST;
#endif

View File

@ -151,22 +151,22 @@ GENERIC_ALLOC_FREE_HEADER(Ecore_Con_Event_Client_Upgrade, ecore_con_event_client
#undef GENERIC_ALLOC_FREE_HEADER
/* shared */
EAPI int ECORE_CON_EVENT_SERVER_DEL = 0;
EAPI int ECORE_CON_EVENT_SERVER_ERROR = 0;
ECORE_CON_API int ECORE_CON_EVENT_SERVER_DEL = 0;
ECORE_CON_API int ECORE_CON_EVENT_SERVER_ERROR = 0;
/* ecore_con_server_add() */
EAPI int ECORE_CON_EVENT_CLIENT_ADD = 0;
EAPI int ECORE_CON_EVENT_CLIENT_DEL = 0;
ECORE_CON_API int ECORE_CON_EVENT_CLIENT_ADD = 0;
ECORE_CON_API int ECORE_CON_EVENT_CLIENT_DEL = 0;
/* ecore_con_server_connect() */
EAPI int ECORE_CON_EVENT_SERVER_ADD = 0;
EAPI int ECORE_CON_EVENT_SERVER_DATA = 0;
EAPI int ECORE_CON_EVENT_SERVER_WRITE = 0;
EAPI int ECORE_CON_EVENT_PROXY_BIND = 0; /* we're not supporting proxy bind, keep only for ABI */
EAPI int ECORE_CON_EVENT_SERVER_UPGRADE = 0;
ECORE_CON_API int ECORE_CON_EVENT_SERVER_ADD = 0;
ECORE_CON_API int ECORE_CON_EVENT_SERVER_DATA = 0;
ECORE_CON_API int ECORE_CON_EVENT_SERVER_WRITE = 0;
ECORE_CON_API int ECORE_CON_EVENT_PROXY_BIND = 0; /* we're not supporting proxy bind, keep only for ABI */
ECORE_CON_API int ECORE_CON_EVENT_SERVER_UPGRADE = 0;
/* for each client from ECORE_CON_EVENT_CLIENT_ADD */
EAPI int ECORE_CON_EVENT_CLIENT_DATA = 0;
EAPI int ECORE_CON_EVENT_CLIENT_WRITE = 0;
EAPI int ECORE_CON_EVENT_CLIENT_ERROR = 0;
EAPI int ECORE_CON_EVENT_CLIENT_UPGRADE = 0;
ECORE_CON_API int ECORE_CON_EVENT_CLIENT_DATA = 0;
ECORE_CON_API int ECORE_CON_EVENT_CLIENT_WRITE = 0;
ECORE_CON_API int ECORE_CON_EVENT_CLIENT_ERROR = 0;
ECORE_CON_API int ECORE_CON_EVENT_CLIENT_UPGRADE = 0;
static Eina_List *_servers = NULL;
static Eina_List *_ecore_con_lookups = NULL;
@ -664,7 +664,7 @@ ecore_con_client_add(Ecore_Con_Server *svr, Eo *socket)
return cl;
}
EAPI int
ECORE_CON_API int
ecore_con_client_send(Ecore_Con_Client *cl, const void *data, int size)
{
Eina_Error err;
@ -686,28 +686,28 @@ ecore_con_client_send(Ecore_Con_Client *cl, const void *data, int size)
return slice.len;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_client_connected_get(const Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RETURN(cl, EINA_FALSE);
return !efl_io_closer_closed_get(cl->socket);
}
EAPI void
ECORE_CON_API void
ecore_con_client_timeout_set(Ecore_Con_Client *cl, double timeout)
{
ECORE_CON_CLIENT_CHECK_RETURN(cl);
efl_io_buffered_stream_timeout_inactivity_set(cl->socket, timeout);
}
EAPI double
ECORE_CON_API double
ecore_con_client_timeout_get(const Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RETURN(cl, -1.0);
return efl_io_buffered_stream_timeout_inactivity_get(cl->socket);
}
EAPI void *
ECORE_CON_API void *
ecore_con_client_del(Ecore_Con_Client *cl)
{
const void *data;
@ -720,7 +720,7 @@ ecore_con_client_del(Ecore_Con_Client *cl)
return (void *)data;
}
EAPI void
ECORE_CON_API void
ecore_con_client_data_set(Ecore_Con_Client *cl,
const void *data)
{
@ -728,42 +728,42 @@ ecore_con_client_data_set(Ecore_Con_Client *cl,
cl->data = data;
}
EAPI void *
ECORE_CON_API void *
ecore_con_client_data_get(Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RELAXED_RETURN(cl, NULL);
return (void *)cl->data;
}
EAPI const char *
ECORE_CON_API const char *
ecore_con_client_ip_get(const Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RELAXED_RETURN(cl, NULL);
return cl->ip;
}
EAPI int
ECORE_CON_API int
ecore_con_client_port_get(const Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RELAXED_RETURN(cl, -1);
return cl->port;
}
EAPI Ecore_Con_Server *
ECORE_CON_API Ecore_Con_Server *
ecore_con_client_server_get(const Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RELAXED_RETURN(cl, NULL);
return cl->svr;
}
EAPI double
ECORE_CON_API double
ecore_con_client_uptime_get(const Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RELAXED_RETURN(cl, 0.0);
return ecore_time_get() - cl->start_time;
}
EAPI void
ECORE_CON_API void
ecore_con_client_flush(Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RETURN(cl);
@ -782,7 +782,7 @@ ecore_con_client_flush(Ecore_Con_Client *cl)
efl_net_socket_tcp_cork_set(inner_socket, EINA_TRUE);
}
EAPI int
ECORE_CON_API int
ecore_con_client_fd_get(const Ecore_Con_Client *cl)
{
ECORE_CON_CLIENT_CHECK_RETURN(cl, SOCKET_TO_LOOP_FD(INVALID_SOCKET));
@ -896,7 +896,7 @@ _ecore_con_server_job_schedule(Ecore_Con_Server *svr, Eo *loop,
eina_future_then(efl_loop_job(loop), cb, svr, &svr->ssl.job);
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_ssl_client_upgrade(Ecore_Con_Client *cl, Ecore_Con_Type compl_type)
{
Ecore_Con_Server *svr;
@ -1692,7 +1692,7 @@ _ecore_con_server_server_ssl_job(void *data, const Eina_Value v,
* using ecore_con_server_add()
*/
EAPI Ecore_Con_Server *
ECORE_CON_API Ecore_Con_Server *
ecore_con_server_add(Ecore_Con_Type compl_type,
const char *name,
int port,
@ -2161,7 +2161,7 @@ _ecore_con_server_dialer_ssl_upgrade_job(void *data, const Eina_Value v,
* example server using ecore_con_server_connect().
*/
EAPI Ecore_Con_Server *
ECORE_CON_API Ecore_Con_Server *
ecore_con_server_connect(Ecore_Con_Type compl_type,
const char *name,
int port,
@ -2256,14 +2256,14 @@ ecore_con_server_connect(Ecore_Con_Type compl_type,
return NULL;
}
EAPI const char *
ECORE_CON_API const char *
ecore_con_server_name_get(const Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RELAXED_RETURN(svr, NULL);
return svr->name;
}
EAPI void
ECORE_CON_API void
ecore_con_server_client_limit_set(Ecore_Con_Server *svr,
int client_limit,
char reject_excess_clients)
@ -2273,14 +2273,14 @@ ecore_con_server_client_limit_set(Ecore_Con_Server *svr,
efl_net_server_clients_limit_set(svr->server, client_limit, reject_excess_clients);
}
EAPI const Eina_List *
ECORE_CON_API const Eina_List *
ecore_con_server_clients_get(const Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, NULL);
return svr->clients;
}
EAPI void
ECORE_CON_API void
ecore_con_server_timeout_set(Ecore_Con_Server *svr, double timeout)
{
ECORE_CON_SERVER_CHECK_RETURN(svr);
@ -2291,14 +2291,14 @@ ecore_con_server_timeout_set(Ecore_Con_Server *svr, double timeout)
efl_io_buffered_stream_timeout_inactivity_set(svr->dialer, timeout);
}
EAPI double
ECORE_CON_API double
ecore_con_server_timeout_get(const Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, -1.0);
return svr->timeout;
}
EAPI void *
ECORE_CON_API void *
ecore_con_server_del(Ecore_Con_Server *svr)
{
const void *data;
@ -2311,14 +2311,14 @@ ecore_con_server_del(Ecore_Con_Server *svr)
return (void *)data;
}
EAPI void *
ECORE_CON_API void *
ecore_con_server_data_get(Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RELAXED_RETURN(svr, NULL);
return (void *)svr->data;
}
EAPI void *
ECORE_CON_API void *
ecore_con_server_data_set(Ecore_Con_Server *svr,
void *data)
{
@ -2330,7 +2330,7 @@ ecore_con_server_data_set(Ecore_Con_Server *svr,
return (void *)old;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_server_connected_get(const Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, EINA_FALSE);
@ -2343,14 +2343,14 @@ ecore_con_server_connected_get(const Ecore_Con_Server *svr)
return EINA_TRUE;
}
EAPI int
ECORE_CON_API int
ecore_con_server_port_get(const Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RELAXED_RETURN(svr, -1);
return svr->port;
}
EAPI int
ECORE_CON_API int
ecore_con_server_send(Ecore_Con_Server *svr, const void *data, int size)
{
Eina_Error err;
@ -2394,21 +2394,21 @@ ecore_con_server_send(Ecore_Con_Server *svr, const void *data, int size)
return slice.len;
}
EAPI const char *
ECORE_CON_API const char *
ecore_con_server_ip_get(const Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RELAXED_RETURN(svr, NULL);
return svr->ip;
}
EAPI double
ECORE_CON_API double
ecore_con_server_uptime_get(const Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RELAXED_RETURN(svr, 0.0);
return ecore_time_get() - svr->start_time;
}
EAPI void
ECORE_CON_API void
ecore_con_server_flush(Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RETURN(svr);
@ -2431,7 +2431,7 @@ ecore_con_server_flush(Ecore_Con_Server *svr)
efl_net_socket_tcp_cork_set(inner_dialer, EINA_TRUE);
}
EAPI int
ECORE_CON_API int
ecore_con_server_fd_get(const Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, SOCKET_TO_LOOP_FD(INVALID_SOCKET));
@ -2464,7 +2464,7 @@ ecore_con_server_fd_get(const Ecore_Con_Server *svr)
return SOCKET_TO_LOOP_FD(INVALID_SOCKET);
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_ssl_server_cert_add(Ecore_Con_Server *svr, const char *cert)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, EINA_FALSE);
@ -2479,7 +2479,7 @@ ecore_con_ssl_server_cert_add(Ecore_Con_Server *svr, const char *cert)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_ssl_server_privkey_add(Ecore_Con_Server *svr, const char *privkey)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, EINA_FALSE);
@ -2494,7 +2494,7 @@ ecore_con_ssl_server_privkey_add(Ecore_Con_Server *svr, const char *privkey)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_ssl_server_crl_add(Ecore_Con_Server *svr, const char *crl)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, EINA_FALSE);
@ -2509,7 +2509,7 @@ ecore_con_ssl_server_crl_add(Ecore_Con_Server *svr, const char *crl)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_ssl_server_cafile_add(Ecore_Con_Server *svr, const char *cafile)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, EINA_FALSE);
@ -2524,7 +2524,7 @@ ecore_con_ssl_server_cafile_add(Ecore_Con_Server *svr, const char *cafile)
return EINA_TRUE;
}
EAPI void
ECORE_CON_API void
ecore_con_ssl_server_verify(Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RETURN(svr);
@ -2544,7 +2544,7 @@ ecore_con_ssl_server_verify(Ecore_Con_Server *svr)
svr->ssl.verify = EINA_TRUE;
}
EAPI void
ECORE_CON_API void
ecore_con_ssl_server_verify_basic(Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RETURN(svr);
@ -2565,7 +2565,7 @@ ecore_con_ssl_server_verify_basic(Ecore_Con_Server *svr)
svr->ssl.verify_basic = EINA_TRUE;
}
EAPI void
ECORE_CON_API void
ecore_con_ssl_server_verify_name_set(Ecore_Con_Server *svr, const char *name)
{
ECORE_CON_SERVER_CHECK_RETURN(svr);
@ -2579,14 +2579,14 @@ ecore_con_ssl_server_verify_name_set(Ecore_Con_Server *svr, const char *name)
eina_stringshare_replace(&svr->ssl.verify_name, name);
}
EAPI const char *
ECORE_CON_API const char *
ecore_con_ssl_server_verify_name_get(Ecore_Con_Server *svr)
{
ECORE_CON_SERVER_CHECK_RETURN(svr, NULL);
return svr->ssl.verify_name ? svr->ssl.verify_name : svr->name;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_ssl_server_upgrade(Ecore_Con_Server *svr, Ecore_Con_Type compl_type)
{
double start;
@ -2674,7 +2674,7 @@ _ecore_con_lookup_done_cb(void *data, const char *host, const char *port EINA_UN
* - doesn't return a handle to cancel (likely to access memory after free)
* - doesn't report errors
*/
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_lookup(const char *name, Ecore_Con_Dns_Cb done_cb, const void *data)
{
Ecore_Con_Lookup_Ctx *ctx;

View File

@ -27,7 +27,7 @@
#include "Ecore_Con.h"
#include "ecore_con_private.h"
EAPI char *
ECORE_CON_API char *
ecore_con_local_path_new(Eina_Bool is_system, const char *name, int port)
{
#if _WIN32

View File

@ -361,7 +361,7 @@ _ecore_con_local_win32_listening(void *data)
return 0;
}
EAPI char *
ECORE_CON_API char *
ecore_con_local_path_new(Eina_Bool is_system, const char *name, int port)
{
char buf[256];

View File

@ -172,7 +172,7 @@ ecore_con_socks_init(void)
* General Socks API.
*/
EAPI Ecore_Con_Socks *
ECORE_CON_API Ecore_Con_Socks *
ecore_con_socks4_remote_add(const char *ip, int port, const char *username)
{
Ecore_Con_Socks *ecs;
@ -201,7 +201,7 @@ ecore_con_socks4_remote_add(const char *ip, int port, const char *username)
return ecs;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_socks4_remote_exists(const char *ip, int port, const char *username)
{
if ((!ip) || (!ip[0]) || (port < -1) || (port > 65535) || (username && (!username[0])))
@ -209,7 +209,7 @@ ecore_con_socks4_remote_exists(const char *ip, int port, const char *username)
return !!_ecore_con_socks_find(4, ip, port, username, username ? strlen(username) : 0, NULL, 0);
}
EAPI void
ECORE_CON_API void
ecore_con_socks4_remote_del(const char *ip, int port, const char *username)
{
Ecore_Con_Socks_v4 *v4;
@ -223,7 +223,7 @@ ecore_con_socks4_remote_del(const char *ip, int port, const char *username)
_ecore_con_socks_free((Ecore_Con_Socks *)v4);
}
EAPI Ecore_Con_Socks *
ECORE_CON_API Ecore_Con_Socks *
ecore_con_socks5_remote_add(const char *ip, int port, const char *username, const char *password)
{
Ecore_Con_Socks_v5 *ecs5;
@ -260,7 +260,7 @@ ecore_con_socks5_remote_add(const char *ip, int port, const char *username, cons
return (Ecore_Con_Socks *)ecs5;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_socks5_remote_exists(const char *ip, int port, const char *username, const char *password)
{
if ((!ip) || (!ip[0]) || (port < -1) || (port > 65535) || (username && (!username[0])) || (password && (!password[0])))
@ -268,7 +268,7 @@ ecore_con_socks5_remote_exists(const char *ip, int port, const char *username, c
return !!_ecore_con_socks_find(5, ip, port, username, username ? strlen(username) : 0, password, password ? strlen(password) : 0);
}
EAPI void
ECORE_CON_API void
ecore_con_socks5_remote_del(const char *ip, int port, const char *username, const char *password)
{
Ecore_Con_Socks_v5 *v5;
@ -283,21 +283,21 @@ ecore_con_socks5_remote_del(const char *ip, int port, const char *username, cons
_ecore_con_socks_free((Ecore_Con_Socks *)v5);
}
EAPI void
ECORE_CON_API void
ecore_con_socks_lookup_set(Ecore_Con_Socks *ecs, Eina_Bool enable)
{
ECORE_CON_SOCKS_VERSION_CHECK(ecs);
ecs->lookup = !!enable;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_socks_lookup_get(Ecore_Con_Socks *ecs)
{
ECORE_CON_SOCKS_VERSION_CHECK_RETURN(ecs, EINA_FALSE);
return ecs->lookup;
}
EAPI void
ECORE_CON_API void
ecore_con_socks_bind_set(Ecore_Con_Socks *ecs, Eina_Bool is_bind)
{
EINA_SAFETY_ON_NULL_RETURN(ecs);
@ -305,7 +305,7 @@ ecore_con_socks_bind_set(Ecore_Con_Socks *ecs, Eina_Bool is_bind)
ecs->bind = !!is_bind;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_socks_bind_get(Ecore_Con_Socks *ecs)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ecs, EINA_FALSE);
@ -313,7 +313,7 @@ ecore_con_socks_bind_get(Ecore_Con_Socks *ecs)
return ecs->bind;
}
EAPI unsigned int
ECORE_CON_API unsigned int
ecore_con_socks_version_get(Ecore_Con_Socks *ecs)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ecs, 0);
@ -321,7 +321,7 @@ ecore_con_socks_version_get(Ecore_Con_Socks *ecs)
return ecs->version;
}
EAPI void
ECORE_CON_API void
ecore_con_socks_remote_del(Ecore_Con_Socks *ecs)
{
EINA_SAFETY_ON_NULL_RETURN(ecs);
@ -331,13 +331,13 @@ ecore_con_socks_remote_del(Ecore_Con_Socks *ecs)
_ecore_con_socks_free(ecs);
}
EAPI void
ECORE_CON_API void
ecore_con_socks_apply_once(Ecore_Con_Socks *ecs)
{
_ecore_con_proxy_once = ecs;
}
EAPI void
ECORE_CON_API void
ecore_con_socks_apply_always(Ecore_Con_Socks *ecs)
{
_ecore_con_proxy_global = ecs;

View File

@ -41,7 +41,7 @@ static Eina_List *_url_con_url_list = NULL;
* @{
*/
EAPI int
ECORE_CON_API int
ecore_con_url_init(void)
{
if (++_init_count > 1) return _init_count;
@ -64,7 +64,7 @@ ecore_con_url_init(void)
return --_init_count;
}
EAPI int
ECORE_CON_API int
ecore_con_url_shutdown(void)
{
Ecore_Con_Url *url_con_url;
@ -84,7 +84,7 @@ ecore_con_url_shutdown(void)
return 0;
}
EAPI void
ECORE_CON_API void
ecore_con_url_pipeline_set(Eina_Bool enable)
{
if (!_c_init()) return;
@ -93,7 +93,7 @@ ecore_con_url_pipeline_set(Eina_Bool enable)
pipelining = enable;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_pipeline_get(void)
{
return pipelining;
@ -778,7 +778,7 @@ _ecore_con_url_request_prepare(Ecore_Con_Url *url_con, const char *method)
return EINA_FALSE;
}
EAPI Ecore_Con_Url *
ECORE_CON_API Ecore_Con_Url *
ecore_con_url_new(const char *url)
{
Ecore_Con_Url *url_con;
@ -798,7 +798,7 @@ ecore_con_url_new(const char *url)
return url_con;
}
EAPI Ecore_Con_Url *
ECORE_CON_API Ecore_Con_Url *
ecore_con_url_custom_new(const char *url,
const char *custom_request)
{
@ -815,7 +815,7 @@ ecore_con_url_custom_new(const char *url,
return url_con;
}
EAPI void
ECORE_CON_API void
ecore_con_url_free(Ecore_Con_Url *url_con)
{
ECORE_CON_URL_CHECK_RETURN(url_con);
@ -826,14 +826,14 @@ ecore_con_url_free(Ecore_Con_Url *url_con)
_ecore_con_url_free_internal(url_con);
}
EAPI void *
ECORE_CON_API void *
ecore_con_url_data_get(Ecore_Con_Url *url_con)
{
ECORE_CON_URL_CHECK_RETURN(url_con, NULL);
return url_con->data;
}
EAPI void
ECORE_CON_API void
ecore_con_url_data_set(Ecore_Con_Url *url_con,
void *data)
{
@ -841,7 +841,7 @@ ecore_con_url_data_set(Ecore_Con_Url *url_con,
url_con->data = data;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_url_set(Ecore_Con_Url *url_con,
const char *url)
{
@ -850,7 +850,7 @@ ecore_con_url_url_set(Ecore_Con_Url *url_con,
return EINA_TRUE;
}
EAPI const char *
ECORE_CON_API const char *
ecore_con_url_url_get(Ecore_Con_Url *url_con)
{
ECORE_CON_URL_CHECK_RETURN(url_con, NULL);
@ -858,7 +858,7 @@ ecore_con_url_url_get(Ecore_Con_Url *url_con)
}
/* LEGACY: HTTP requests */
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_get(Ecore_Con_Url *url_con)
{
Eina_Error err;
@ -879,7 +879,7 @@ ecore_con_url_get(Ecore_Con_Url *url_con)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_head(Ecore_Con_Url *url_con)
{
Eina_Error err;
@ -900,7 +900,7 @@ ecore_con_url_head(Ecore_Con_Url *url_con)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_post(Ecore_Con_Url *url_con,
const void *data,
long length,
@ -963,7 +963,7 @@ ecore_con_url_post(Ecore_Con_Url *url_con,
}
/* LEGACY: headers */
EAPI void
ECORE_CON_API void
ecore_con_url_additional_header_add(Ecore_Con_Url *url_con,
const char *key,
const char *value)
@ -990,14 +990,14 @@ ecore_con_url_additional_header_add(Ecore_Con_Url *url_con,
header);
}
EAPI void
ECORE_CON_API void
ecore_con_url_additional_headers_clear(Ecore_Con_Url *url_con)
{
ECORE_CON_URL_CHECK_RETURN(url_con);
_ecore_con_url_request_headers_free(url_con);
}
EAPI void
ECORE_CON_API void
ecore_con_url_time(Ecore_Con_Url *url_con,
Ecore_Con_Url_Time time_condition,
double timestamp)
@ -1008,7 +1008,7 @@ ecore_con_url_time(Ecore_Con_Url *url_con,
}
/* LEGACY: cookies */
EAPI void
ECORE_CON_API void
ecore_con_url_cookies_init(Ecore_Con_Url *url_con)
{
CURL *curl_easy;
@ -1026,7 +1026,7 @@ ecore_con_url_cookies_init(Ecore_Con_Url *url_con)
_c->curl_easy_setopt(curl_easy, CURLOPT_COOKIEFILE, "");
}
EAPI void
ECORE_CON_API void
ecore_con_url_cookies_file_add(Ecore_Con_Url *url_con,
const char * const file_name)
{
@ -1046,7 +1046,7 @@ ecore_con_url_cookies_file_add(Ecore_Con_Url *url_con,
_c->curl_easy_setopt(curl_easy, CURLOPT_COOKIEFILE, file_name);
}
EAPI void
ECORE_CON_API void
ecore_con_url_cookies_clear(Ecore_Con_Url *url_con)
{
static const char cookielist_cmd_all[] = "ALL";
@ -1067,7 +1067,7 @@ ecore_con_url_cookies_clear(Ecore_Con_Url *url_con)
_c->curl_easy_setopt(curl_easy, CURLOPT_COOKIELIST, cookielist_cmd_all);
}
EAPI void
ECORE_CON_API void
ecore_con_url_cookies_session_clear(Ecore_Con_Url *url_con)
{
static const char cookielist_cmd_sess[] = "SESS";
@ -1088,7 +1088,7 @@ ecore_con_url_cookies_session_clear(Ecore_Con_Url *url_con)
_c->curl_easy_setopt(curl_easy, CURLOPT_COOKIELIST, cookielist_cmd_sess);
}
EAPI void
ECORE_CON_API void
ecore_con_url_cookies_ignore_old_session_set(Ecore_Con_Url *url_con,
Eina_Bool ignore)
{
@ -1096,7 +1096,7 @@ ecore_con_url_cookies_ignore_old_session_set(Ecore_Con_Url *url_con,
url_con->cookies.ignore_old_session = ignore;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_cookies_jar_file_set(Ecore_Con_Url *url_con,
const char * const cookiejar_file)
{
@ -1117,7 +1117,7 @@ ecore_con_url_cookies_jar_file_set(Ecore_Con_Url *url_con,
return EINA_TRUE;
}
EAPI void
ECORE_CON_API void
ecore_con_url_cookies_jar_write(Ecore_Con_Url *url_con)
{
CURL *curl_easy;
@ -1134,7 +1134,7 @@ ecore_con_url_cookies_jar_write(Ecore_Con_Url *url_con)
}
/* LEGACY: file upload/download */
EAPI void
ECORE_CON_API void
ecore_con_url_fd_set(Ecore_Con_Url *url_con, int fd)
{
ECORE_CON_URL_CHECK_RETURN(url_con);
@ -1145,7 +1145,7 @@ ecore_con_url_fd_set(Ecore_Con_Url *url_con, int fd)
if (!url_con->dialer) return;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_ftp_upload(Ecore_Con_Url *url_con,
const char *filename,
const char *user,
@ -1211,7 +1211,7 @@ ecore_con_url_ftp_upload(Ecore_Con_Url *url_con,
return EINA_FALSE;
}
EAPI void
ECORE_CON_API void
ecore_con_url_ftp_use_epsv_set(Ecore_Con_Url *url_con,
Eina_Bool use_epsv)
{
@ -1219,7 +1219,7 @@ ecore_con_url_ftp_use_epsv_set(Ecore_Con_Url *url_con,
url_con->ftp_use_epsv = use_epsv;
}
EAPI void
ECORE_CON_API void
ecore_con_url_limit_upload_speed(Ecore_Con_Url *url_con, off_t max_speed)
{
CURL *curl_easy;
@ -1233,7 +1233,7 @@ ecore_con_url_limit_upload_speed(Ecore_Con_Url *url_con, off_t max_speed)
_c->curl_easy_setopt(curl_easy, CURLOPT_MAX_SEND_SPEED_LARGE, max_speed);
}
EAPI void
ECORE_CON_API void
ecore_con_url_limit_download_speed(Ecore_Con_Url *url_con, off_t max_speed)
{
CURL *curl_easy;
@ -1248,7 +1248,7 @@ ecore_con_url_limit_download_speed(Ecore_Con_Url *url_con, off_t max_speed)
}
/* LEGACY: proxy */
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_proxy_password_set(Ecore_Con_Url *url_con, const char *password)
{
ECORE_CON_URL_CHECK_RETURN(url_con, EINA_FALSE);
@ -1257,7 +1257,7 @@ ecore_con_url_proxy_password_set(Ecore_Con_Url *url_con, const char *password)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_proxy_username_set(Ecore_Con_Url *url_con, const char *username)
{
ECORE_CON_URL_CHECK_RETURN(url_con, EINA_FALSE);
@ -1266,7 +1266,7 @@ ecore_con_url_proxy_username_set(Ecore_Con_Url *url_con, const char *username)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_proxy_set(Ecore_Con_Url *url_con, const char *proxy_url)
{
ECORE_CON_URL_CHECK_RETURN(url_con, EINA_FALSE);
@ -1275,14 +1275,14 @@ ecore_con_url_proxy_set(Ecore_Con_Url *url_con, const char *proxy_url)
}
/* LEGACY: response */
EAPI int
ECORE_CON_API int
ecore_con_url_received_bytes_get(Ecore_Con_Url *url_con)
{
ECORE_CON_URL_CHECK_RETURN(url_con, EINA_FALSE);
return url_con->received_bytes;
}
EAPI int
ECORE_CON_API int
ecore_con_url_status_code_get(Ecore_Con_Url *url_con)
{
ECORE_CON_URL_CHECK_RETURN(url_con, 0);
@ -1290,7 +1290,7 @@ ecore_con_url_status_code_get(Ecore_Con_Url *url_con)
return efl_net_dialer_http_response_status_get(url_con->dialer);
}
EAPI const Eina_List *
ECORE_CON_API const Eina_List *
ecore_con_url_response_headers_get(Ecore_Con_Url *url_con)
{
ECORE_CON_URL_CHECK_RETURN(url_con, NULL);
@ -1298,7 +1298,7 @@ ecore_con_url_response_headers_get(Ecore_Con_Url *url_con)
}
/* LEGACY: SSL */
EAPI int
ECORE_CON_API int
ecore_con_url_ssl_ca_set(Ecore_Con_Url *url_con,
const char *ca_path)
{
@ -1308,7 +1308,7 @@ ecore_con_url_ssl_ca_set(Ecore_Con_Url *url_con,
return 0;
}
EAPI void
ECORE_CON_API void
ecore_con_url_ssl_verify_peer_set(Ecore_Con_Url *url_con,
Eina_Bool verify)
{
@ -1317,7 +1317,7 @@ ecore_con_url_ssl_verify_peer_set(Ecore_Con_Url *url_con,
}
/* LEGACY: misc */
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_httpauth_set(Ecore_Con_Url *url_con,
const char *username,
const char *password,
@ -1334,7 +1334,7 @@ ecore_con_url_httpauth_set(Ecore_Con_Url *url_con,
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_CON_API Eina_Bool
ecore_con_url_http_version_set(Ecore_Con_Url *url_con, Ecore_Con_Url_Http_Version version)
{
ECORE_CON_URL_CHECK_RETURN(url_con, EINA_FALSE);
@ -1375,7 +1375,7 @@ _ecore_con_url_timeout_cb(void *data)
return EINA_FALSE;
}
EAPI void
ECORE_CON_API void
ecore_con_url_timeout_set(Ecore_Con_Url *url_con, double timeout)
{
ECORE_CON_URL_CHECK_RETURN(url_con);
@ -1393,7 +1393,7 @@ ecore_con_url_timeout_set(Ecore_Con_Url *url_con, double timeout)
url_con->timer = ecore_timer_add(timeout, _ecore_con_url_timeout_cb, url_con);
}
EAPI void
ECORE_CON_API void
ecore_con_url_verbose_set(Ecore_Con_Url *url_con,
Eina_Bool verbose)
{

View File

@ -22,57 +22,57 @@ Ecore_Con_Curl *_c = NULL;
Eina_Bool _c_fail = EINA_FALSE;
double _c_timeout = 0.0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_BAD_CONTENT_ENCODING = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_BAD_DOWNLOAD_RESUME = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_BAD_FUNCTION_ARGUMENT = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_CHUNK_FAILED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_CONV_FAILED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_CONV_REQD = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_FAILED_INIT = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_FILE_COULDNT_READ_FILE = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_FILESIZE_EXCEEDED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_FUNCTION_NOT_FOUND = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_GOT_NOTHING = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_HTTP2 = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_HTTP2_STREAM = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_HTTP_POST_ERROR = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_HTTP_RETURNED_ERROR = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_INTERFACE_FAILED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_LOGIN_DENIED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_NO_CONNECTION_AVAILABLE = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_NOT_BUILT_IN = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_OPERATION_TIMEDOUT = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_PARTIAL_FILE = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_PEER_FAILED_VERIFICATION = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_RANGE_ERROR = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_READ_ERROR = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_RECV_ERROR = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_REMOTE_ACCESS_DENIED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_REMOTE_DISK_FULL = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_REMOTE_FILE_EXISTS = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_REMOTE_FILE_NOT_FOUND = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SEND_ERROR = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SEND_FAIL_REWIND = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CACERT = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CACERT_BADFILE = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CERTPROBLEM = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CIPHER = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CONNECT_ERROR = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_CRL_BADFILE = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_INITFAILED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_NOTFOUND = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_SETFAILED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_INVALIDCERTSTATUS = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_ISSUER_ERROR = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_PINNEDPUBKEYNOTMATCH = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_SSL_SHUTDOWN_FAILED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_TOO_MANY_REDIRECTS = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_UNKNOWN_OPTION = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_UNSUPPORTED_PROTOCOL = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_UPLOAD_FAILED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_URL_MALFORMAT = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_USE_SSL_FAILED = 0;
EWAPI Eina_Error EFL_NET_HTTP_ERROR_WRITE_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_BAD_CONTENT_ENCODING = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_BAD_DOWNLOAD_RESUME = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_BAD_FUNCTION_ARGUMENT = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_CHUNK_FAILED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_CONV_FAILED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_CONV_REQD = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_FAILED_INIT = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_FILE_COULDNT_READ_FILE = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_FILESIZE_EXCEEDED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_FUNCTION_NOT_FOUND = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_GOT_NOTHING = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_HTTP2 = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_HTTP2_STREAM = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_HTTP_POST_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_HTTP_RETURNED_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_INTERFACE_FAILED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_LOGIN_DENIED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_NO_CONNECTION_AVAILABLE = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_NOT_BUILT_IN = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_OPERATION_TIMEDOUT = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_PARTIAL_FILE = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_PEER_FAILED_VERIFICATION = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_RANGE_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_READ_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_RECV_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_REMOTE_ACCESS_DENIED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_REMOTE_DISK_FULL = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_REMOTE_FILE_EXISTS = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_REMOTE_FILE_NOT_FOUND = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SEND_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SEND_FAIL_REWIND = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_CACERT = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_CACERT_BADFILE = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_CERTPROBLEM = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_CIPHER = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_CONNECT_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_CRL_BADFILE = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_INITFAILED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_NOTFOUND = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_ENGINE_SETFAILED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_INVALIDCERTSTATUS = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_ISSUER_ERROR = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_PINNEDPUBKEYNOTMATCH = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_SSL_SHUTDOWN_FAILED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_TOO_MANY_REDIRECTS = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_UNKNOWN_OPTION = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_UNSUPPORTED_PROTOCOL = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_UPLOAD_FAILED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_URL_MALFORMAT = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_USE_SSL_FAILED = 0;
ECORE_CON_API ECORE_CON_API_WEAK Eina_Error EFL_NET_HTTP_ERROR_WRITE_ERROR = 0;
Eina_Error
_curlcode_to_eina_error(const CURLcode code)

View File

@ -70,6 +70,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_CON_API',
'-gchd', '@INPUT@'])
endforeach
@ -91,6 +92,7 @@ foreach eo_file : pub_eo_types_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_CON_API',
'-gchd', '@INPUT@'])
endforeach
@ -187,7 +189,7 @@ ecore_con_lib = library('ecore_con',
dependencies: [ecore_con_deps, ecore_con_ext_deps, ecore_con_pub_deps],
include_directories : config_dir,
install: true,
c_args : package_c_args,
c_args : [package_c_args, '-DECORE_CON_BUILD'],
version : meson.project_version()
)

View File

@ -8,19 +8,7 @@
# include <Eeze.h>
# include <xkbcommon/xkbcommon.h>
# ifdef EAPI
# undef EAPI
# endif
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else // if __GNUC__ >= 4
# define EAPI
# endif // if __GNUC__ >= 4
# else // ifdef __GNUC__
# define EAPI
# endif // ifdef __GNUC__
# include <ecore_drm_api.h>
# warning The Ecore_Drm library has been deprecated. Please use the Ecore_Drm2 library
@ -202,11 +190,11 @@ typedef struct _Ecore_Drm_Event_Output Ecore_Drm_Event_Output;
/** @since 1.14 */
typedef void (*Ecore_Drm_Pageflip_Cb)(void *data);
EAPI extern int ECORE_DRM_EVENT_ACTIVATE;
ECORE_DRM_API extern int ECORE_DRM_EVENT_ACTIVATE;
EAPI extern int ECORE_DRM_EVENT_OUTPUT; /**< @since 1.14 */
ECORE_DRM_API extern int ECORE_DRM_EVENT_OUTPUT; /**< @since 1.14 */
EAPI extern int ECORE_DRM_EVENT_SEAT_ADD; /**< @since 1.14 */
ECORE_DRM_API extern int ECORE_DRM_EVENT_SEAT_ADD; /**< @since 1.14 */
/**
* @file
@ -225,8 +213,8 @@ EAPI extern int ECORE_DRM_EVENT_SEAT_ADD; /**< @since 1.14 */
*
*/
EAPI int ecore_drm_init(void);
EAPI int ecore_drm_shutdown(void);
ECORE_DRM_API int ecore_drm_init(void);
ECORE_DRM_API int ecore_drm_shutdown(void);
/**
* @ingroup Ecore_Drm_Device_Group
@ -240,7 +228,7 @@ EAPI int ecore_drm_shutdown(void);
* @return An opaque Ecore_Drm_Device structure representing the card.
*
*/
EAPI Ecore_Drm_Device *ecore_drm_device_find(const char *name, const char *seat);
ECORE_DRM_API Ecore_Drm_Device *ecore_drm_device_find(const char *name, const char *seat);
/**
* @ingroup Ecore_Drm_Device_Group
@ -251,7 +239,7 @@ EAPI Ecore_Drm_Device *ecore_drm_device_find(const char *name, const char *seat)
* @param dev The Ecore_Drm_Device to free
*
*/
EAPI void ecore_drm_device_free(Ecore_Drm_Device *dev);
ECORE_DRM_API void ecore_drm_device_free(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -264,7 +252,7 @@ EAPI void ecore_drm_device_free(Ecore_Drm_Device *dev);
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure
*
*/
EAPI Eina_Bool ecore_drm_device_open(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_device_open(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -277,7 +265,7 @@ EAPI Eina_Bool ecore_drm_device_open(Ecore_Drm_Device *dev);
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure
*
*/
EAPI Eina_Bool ecore_drm_device_close(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_device_close(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -290,7 +278,7 @@ EAPI Eina_Bool ecore_drm_device_close(Ecore_Drm_Device *dev);
* @return @c EINA_TRUE if device is master, @c EINA_FALSE otherwise
*
*/
EAPI Eina_Bool ecore_drm_device_master_get(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_device_master_get(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -303,7 +291,7 @@ EAPI Eina_Bool ecore_drm_device_master_get(Ecore_Drm_Device *dev);
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure
*
*/
EAPI Eina_Bool ecore_drm_device_master_set(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_device_master_set(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -316,7 +304,7 @@ EAPI Eina_Bool ecore_drm_device_master_set(Ecore_Drm_Device *dev);
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure
*
*/
EAPI Eina_Bool ecore_drm_device_master_drop(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_device_master_drop(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -329,7 +317,7 @@ EAPI Eina_Bool ecore_drm_device_master_drop(Ecore_Drm_Device *dev);
* @return fd Value on success, @c -1 on failure
*
*/
EAPI int ecore_drm_device_fd_get(Ecore_Drm_Device *dev);
ECORE_DRM_API int ecore_drm_device_fd_get(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -342,7 +330,7 @@ EAPI int ecore_drm_device_fd_get(Ecore_Drm_Device *dev);
*
* @since 1.10
*/
EAPI void ecore_drm_device_window_set(Ecore_Drm_Device *dev, unsigned int window);
ECORE_DRM_API void ecore_drm_device_window_set(Ecore_Drm_Device *dev, unsigned int window);
/**
* @ingroup Ecore_Drm_Device_Group
@ -357,7 +345,7 @@ EAPI void ecore_drm_device_window_set(Ecore_Drm_Device *dev, unsigned int window
*
* @since 1.10
*/
EAPI const char *ecore_drm_device_name_get(Ecore_Drm_Device *dev);
ECORE_DRM_API const char *ecore_drm_device_name_get(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -372,7 +360,7 @@ EAPI const char *ecore_drm_device_name_get(Ecore_Drm_Device *dev);
*
* @since 1.14
*/
EAPI Eina_Bool ecore_drm_device_software_setup(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_device_software_setup(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Device_Group
@ -387,7 +375,7 @@ EAPI Eina_Bool ecore_drm_device_software_setup(Ecore_Drm_Device *dev);
*
* @since 1.17
*/
EAPI Eina_Bool ecore_drm_device_pointer_left_handed_set(Ecore_Drm_Device *dev, Eina_Bool left_handed);
ECORE_DRM_API Eina_Bool ecore_drm_device_pointer_left_handed_set(Ecore_Drm_Device *dev, Eina_Bool left_handed);
/**
* @ingroup Ecore_Drm_Device_Group
@ -399,7 +387,7 @@ EAPI Eina_Bool ecore_drm_device_pointer_left_handed_set(Ecore_Drm_Device *dev, E
*
* @since 1.17
*/
EAPI void ecore_drm_device_keyboard_cached_context_set(struct xkb_context *ctx);
ECORE_DRM_API void ecore_drm_device_keyboard_cached_context_set(struct xkb_context *ctx);
/**
* @ingroup Ecore_Drm_Device_Group
@ -411,7 +399,7 @@ EAPI void ecore_drm_device_keyboard_cached_context_set(struct xkb_context *ctx);
*
* @since 1.17
*/
EAPI void ecore_drm_device_keyboard_cached_keymap_set(struct xkb_keymap *map);
ECORE_DRM_API void ecore_drm_device_keyboard_cached_keymap_set(struct xkb_keymap *map);
/**
* @ingroup Ecore_Drm_Device_Group
@ -428,7 +416,7 @@ EAPI void ecore_drm_device_keyboard_cached_keymap_set(struct xkb_keymap *map);
*
* @since 1.14
*/
EAPI Ecore_Drm_Output *ecore_drm_device_output_find(Ecore_Drm_Device *dev, int x, int y);
ECORE_DRM_API Ecore_Drm_Output *ecore_drm_device_output_find(Ecore_Drm_Device *dev, int x, int y);
/**
* @ingroup Ecore_Drm_Tty_Group
@ -441,7 +429,7 @@ EAPI Ecore_Drm_Output *ecore_drm_device_output_find(Ecore_Drm_Device *dev, int x
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure
*
*/
EAPI Eina_Bool ecore_drm_tty_open(Ecore_Drm_Device *dev, const char *name);
ECORE_DRM_API Eina_Bool ecore_drm_tty_open(Ecore_Drm_Device *dev, const char *name);
/**
* @ingroup Ecore_Drm_Tty_Group
@ -452,7 +440,7 @@ EAPI Eina_Bool ecore_drm_tty_open(Ecore_Drm_Device *dev, const char *name);
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure
*
*/
EAPI Eina_Bool ecore_drm_tty_close(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_tty_close(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Tty_Group
@ -463,7 +451,7 @@ EAPI Eina_Bool ecore_drm_tty_close(Ecore_Drm_Device *dev);
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure
*
*/
EAPI Eina_Bool ecore_drm_tty_release(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_tty_release(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Tty_Group
@ -474,7 +462,7 @@ EAPI Eina_Bool ecore_drm_tty_release(Ecore_Drm_Device *dev);
* @return @c EINA_TRUE on success, @c EINA_FALSE on failure
*
*/
EAPI Eina_Bool ecore_drm_tty_acquire(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_tty_acquire(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Tty_Group
@ -487,7 +475,7 @@ EAPI Eina_Bool ecore_drm_tty_acquire(Ecore_Drm_Device *dev);
*
* @since 1.10
*/
EAPI int ecore_drm_tty_get(Ecore_Drm_Device *dev);
ECORE_DRM_API int ecore_drm_tty_get(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Output_Group
@ -501,7 +489,7 @@ EAPI int ecore_drm_tty_get(Ecore_Drm_Device *dev);
* @return EINA_TRUE on success, EINA_FALSE on failure.
*
*/
EAPI Eina_Bool ecore_drm_outputs_create(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_outputs_create(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Output_Group
@ -512,7 +500,7 @@ EAPI Eina_Bool ecore_drm_outputs_create(Ecore_Drm_Device *dev);
* @param output The Ecore_Drm_Output to free
*
*/
EAPI void ecore_drm_output_free(Ecore_Drm_Output *output);
ECORE_DRM_API void ecore_drm_output_free(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -526,7 +514,7 @@ EAPI void ecore_drm_output_free(Ecore_Drm_Output *output);
* @param h The height of cursor
*
*/
EAPI void ecore_drm_output_cursor_size_set(Ecore_Drm_Output *output, int handle, int w, int h);
ECORE_DRM_API void ecore_drm_output_cursor_size_set(Ecore_Drm_Output *output, int handle, int w, int h);
/**
* @ingroup Ecore_Drm_Output_Group
@ -538,7 +526,7 @@ EAPI void ecore_drm_output_cursor_size_set(Ecore_Drm_Output *output, int handle,
*
* @since 1.14
*/
EAPI Eina_Bool ecore_drm_output_enable(Ecore_Drm_Output *output);
ECORE_DRM_API Eina_Bool ecore_drm_output_enable(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -550,13 +538,13 @@ EAPI Eina_Bool ecore_drm_output_enable(Ecore_Drm_Output *output);
*
* @since 1.14
*/
EAPI void ecore_drm_output_disable(Ecore_Drm_Output *output);
ECORE_DRM_API void ecore_drm_output_disable(Ecore_Drm_Output *output);
/* TODO: Doxy */
EAPI void ecore_drm_output_fb_release(Ecore_Drm_Output *output, Ecore_Drm_Fb *fb);
ECORE_DRM_API void ecore_drm_output_fb_release(Ecore_Drm_Output *output, Ecore_Drm_Fb *fb);
/* TODO: Doxy */
EAPI void ecore_drm_output_repaint(Ecore_Drm_Output *output);
ECORE_DRM_API void ecore_drm_output_repaint(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -570,13 +558,13 @@ EAPI void ecore_drm_output_repaint(Ecore_Drm_Output *output);
* @param *h The parameter in which output height is stored
*
*/
EAPI void ecore_drm_output_size_get(Ecore_Drm_Device *dev, int output, int *w, int *h);
ECORE_DRM_API void ecore_drm_output_size_get(Ecore_Drm_Device *dev, int output, int *w, int *h);
/**
* TODO: Doxy
* @since 1.12
*/
EAPI void ecore_drm_outputs_geometry_get(Ecore_Drm_Device *dev, int *x, int *y, int *w, int *h);
ECORE_DRM_API void ecore_drm_outputs_geometry_get(Ecore_Drm_Device *dev, int *x, int *y, int *w, int *h);
/**
* @ingroup Ecore_Drm_Output_Group
@ -590,7 +578,7 @@ EAPI void ecore_drm_outputs_geometry_get(Ecore_Drm_Device *dev, int *x, int *y,
*
* @since 1.14
*/
EAPI unsigned int ecore_drm_output_crtc_id_get(Ecore_Drm_Output *output);
ECORE_DRM_API unsigned int ecore_drm_output_crtc_id_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -604,7 +592,7 @@ EAPI unsigned int ecore_drm_output_crtc_id_get(Ecore_Drm_Output *output);
*
* @since 1.14
*/
EAPI unsigned int ecore_drm_output_crtc_buffer_get(Ecore_Drm_Output *output);
ECORE_DRM_API unsigned int ecore_drm_output_crtc_buffer_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -618,27 +606,27 @@ EAPI unsigned int ecore_drm_output_crtc_buffer_get(Ecore_Drm_Output *output);
*
* @since 1.14
*/
EAPI unsigned int ecore_drm_output_connector_id_get(Ecore_Drm_Output *output);
ECORE_DRM_API unsigned int ecore_drm_output_connector_id_get(Ecore_Drm_Output *output);
/** @defgroup Ecore_Drm_Input_Group Drm input handling
* @{
*/
EAPI Eina_Bool ecore_drm_inputs_create(Ecore_Drm_Device *dev);
EAPI void ecore_drm_inputs_destroy(Ecore_Drm_Device *dev);
EAPI Eina_Bool ecore_drm_inputs_enable(Ecore_Drm_Input *input);
EAPI void ecore_drm_inputs_disable(Ecore_Drm_Input *input);
EAPI void ecore_drm_inputs_device_axis_size_set(Ecore_Drm_Evdev *dev, int w, int h);
ECORE_DRM_API Eina_Bool ecore_drm_inputs_create(Ecore_Drm_Device *dev);
ECORE_DRM_API void ecore_drm_inputs_destroy(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_inputs_enable(Ecore_Drm_Input *input);
ECORE_DRM_API void ecore_drm_inputs_disable(Ecore_Drm_Input *input);
ECORE_DRM_API void ecore_drm_inputs_device_axis_size_set(Ecore_Drm_Evdev *dev, int w, int h);
/**
* @}
*/
EAPI Eina_Bool ecore_drm_sprites_create(Ecore_Drm_Device *dev);
EAPI void ecore_drm_sprites_destroy(Ecore_Drm_Device *dev);
EAPI void ecore_drm_sprites_fb_set(Ecore_Drm_Sprite *sprite, int fb_id, int flags);
EAPI Eina_Bool ecore_drm_sprites_crtc_supported(Ecore_Drm_Output *output, unsigned int supported);
ECORE_DRM_API Eina_Bool ecore_drm_sprites_create(Ecore_Drm_Device *dev);
ECORE_DRM_API void ecore_drm_sprites_destroy(Ecore_Drm_Device *dev);
ECORE_DRM_API void ecore_drm_sprites_fb_set(Ecore_Drm_Sprite *sprite, int fb_id, int flags);
ECORE_DRM_API Eina_Bool ecore_drm_sprites_crtc_supported(Ecore_Drm_Output *output, unsigned int supported);
EAPI Ecore_Drm_Fb *ecore_drm_fb_create(Ecore_Drm_Device *dev, int width, int height);
EAPI void ecore_drm_fb_destroy(Ecore_Drm_Fb *fb);
ECORE_DRM_API Ecore_Drm_Fb *ecore_drm_fb_create(Ecore_Drm_Device *dev, int width, int height);
ECORE_DRM_API void ecore_drm_fb_destroy(Ecore_Drm_Fb *fb);
/**
* @ingroup Ecore_Drm_Fb_Group
@ -652,7 +640,7 @@ EAPI void ecore_drm_fb_destroy(Ecore_Drm_Fb *fb);
*
* @since 1.14
*/
EAPI void ecore_drm_fb_dirty(Ecore_Drm_Fb *fb, Eina_Rectangle *rects, unsigned int count);
ECORE_DRM_API void ecore_drm_fb_dirty(Ecore_Drm_Fb *fb, Eina_Rectangle *rects, unsigned int count);
/**
* @ingroup Ecore_Drm_Fb_Group
@ -668,7 +656,7 @@ EAPI void ecore_drm_fb_dirty(Ecore_Drm_Fb *fb, Eina_Rectangle *rects, unsigned i
*
* @since 1.14
*/
EINA_DEPRECATED EAPI void ecore_drm_fb_set(Ecore_Drm_Device *dev, Ecore_Drm_Fb *fb);
EINA_DEPRECATED ECORE_DRM_API void ecore_drm_fb_set(Ecore_Drm_Device *dev, Ecore_Drm_Fb *fb);
/**
* @internal
@ -685,10 +673,10 @@ EINA_DEPRECATED EAPI void ecore_drm_fb_set(Ecore_Drm_Device *dev, Ecore_Drm_Fb *
*
* @since 1.14
*/
EAPI void ecore_drm_fb_send(Ecore_Drm_Device *dev, Ecore_Drm_Fb *fb, Ecore_Drm_Pageflip_Cb func, void *data);
ECORE_DRM_API void ecore_drm_fb_send(Ecore_Drm_Device *dev, Ecore_Drm_Fb *fb, Ecore_Drm_Pageflip_Cb func, void *data);
EAPI Eina_Bool ecore_drm_launcher_connect(Ecore_Drm_Device *dev);
EAPI void ecore_drm_launcher_disconnect(Ecore_Drm_Device *dev);
ECORE_DRM_API Eina_Bool ecore_drm_launcher_connect(Ecore_Drm_Device *dev);
ECORE_DRM_API void ecore_drm_launcher_disconnect(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Output_Group
@ -702,7 +690,7 @@ EAPI void ecore_drm_launcher_disconnect(Ecore_Drm_Device *dev);
*
* @since 1.14
*/
EAPI void ecore_drm_output_position_get(Ecore_Drm_Output *output, int *x, int *y);
ECORE_DRM_API void ecore_drm_output_position_get(Ecore_Drm_Output *output, int *x, int *y);
/**
* @ingroup Ecore_Drm_Output_Group
@ -717,7 +705,7 @@ EAPI void ecore_drm_output_position_get(Ecore_Drm_Output *output, int *x, int *y
*
* @since 1.14
*/
EAPI void ecore_drm_output_current_resolution_get(Ecore_Drm_Output *output, int *w, int *h, unsigned int *refresh);
ECORE_DRM_API void ecore_drm_output_current_resolution_get(Ecore_Drm_Output *output, int *w, int *h, unsigned int *refresh);
/**
* @ingroup Ecore_Drm_Output_Group
@ -731,7 +719,7 @@ EAPI void ecore_drm_output_current_resolution_get(Ecore_Drm_Output *output, int
*
* @since 1.14
*/
EAPI void ecore_drm_output_physical_size_get(Ecore_Drm_Output *output, int *w, int *h);
ECORE_DRM_API void ecore_drm_output_physical_size_get(Ecore_Drm_Output *output, int *w, int *h);
/**
* @ingroup Ecore_Drm_Output_Group
@ -744,7 +732,7 @@ EAPI void ecore_drm_output_physical_size_get(Ecore_Drm_Output *output, int *w, i
*
* @since 1.14
*/
EAPI unsigned int ecore_drm_output_subpixel_order_get(Ecore_Drm_Output *output);
ECORE_DRM_API unsigned int ecore_drm_output_subpixel_order_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -757,7 +745,7 @@ EAPI unsigned int ecore_drm_output_subpixel_order_get(Ecore_Drm_Output *output);
*
* @since 1.14
*/
EAPI Eina_Stringshare *ecore_drm_output_model_get(Ecore_Drm_Output *output);
ECORE_DRM_API Eina_Stringshare *ecore_drm_output_model_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -770,7 +758,7 @@ EAPI Eina_Stringshare *ecore_drm_output_model_get(Ecore_Drm_Output *output);
*
* @since 1.14
*/
EAPI Eina_Stringshare *ecore_drm_output_make_get(Ecore_Drm_Output *output);
ECORE_DRM_API Eina_Stringshare *ecore_drm_output_make_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -783,7 +771,7 @@ EAPI Eina_Stringshare *ecore_drm_output_make_get(Ecore_Drm_Output *output);
*
* @since 1.15
*/
EAPI char *ecore_drm_output_name_get(Ecore_Drm_Output *output);
ECORE_DRM_API char *ecore_drm_output_name_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -796,7 +784,7 @@ EAPI char *ecore_drm_output_name_get(Ecore_Drm_Output *output);
*
* @since 1.14
*/
EAPI void ecore_drm_output_dpms_set(Ecore_Drm_Output *output, int level);
ECORE_DRM_API void ecore_drm_output_dpms_set(Ecore_Drm_Output *output, int level);
/**
* @ingroup Ecore_Drm_Output_Group
@ -812,7 +800,7 @@ EAPI void ecore_drm_output_dpms_set(Ecore_Drm_Output *output, int level);
*
* @since 1.14
*/
EAPI void ecore_drm_output_gamma_set(Ecore_Drm_Output *output, uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b);
ECORE_DRM_API void ecore_drm_output_gamma_set(Ecore_Drm_Output *output, uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b);
/**
* @ingroup Ecore_Drm_Device_Group
@ -826,7 +814,7 @@ EAPI void ecore_drm_output_gamma_set(Ecore_Drm_Output *output, uint16_t size, ui
*
* @since 1.14
*/
EAPI void ecore_drm_device_pointer_xy_get(Ecore_Drm_Device *dev, int *x, int *y);
ECORE_DRM_API void ecore_drm_device_pointer_xy_get(Ecore_Drm_Device *dev, int *x, int *y);
/**
* @ingroup Ecore_Drm_Device_Group
@ -840,7 +828,7 @@ EAPI void ecore_drm_device_pointer_xy_get(Ecore_Drm_Device *dev, int *x, int *y)
*
* @since 1.18
*/
EAPI void ecore_drm_device_pointer_warp(Ecore_Drm_Device *dev, int x, int y);
ECORE_DRM_API void ecore_drm_device_pointer_warp(Ecore_Drm_Device *dev, int x, int y);
/**
* @ingroup Ecore_Drm_Device_Group
@ -850,7 +838,7 @@ EAPI void ecore_drm_device_pointer_warp(Ecore_Drm_Device *dev, int x, int y);
*
* @since 1.14
*/
EAPI const Eina_List *ecore_drm_devices_get(void);
ECORE_DRM_API const Eina_List *ecore_drm_devices_get(void);
/**
* @ingroup Ecore_Drm_Device_Group
@ -864,7 +852,7 @@ EAPI const Eina_List *ecore_drm_devices_get(void);
*
* @since 1.15
*/
EAPI void ecore_drm_screen_size_range_get(Ecore_Drm_Device *dev, int *minw, int *minh, int *maxw, int *maxh);
ECORE_DRM_API void ecore_drm_screen_size_range_get(Ecore_Drm_Device *dev, int *minw, int *minh, int *maxw, int *maxh);
/**
* @ingroup Ecore_Drm_Output_Group
@ -876,7 +864,7 @@ EAPI void ecore_drm_screen_size_range_get(Ecore_Drm_Device *dev, int *minw, int
*
* @since 1.15
*/
EAPI Eina_Bool ecore_drm_output_connected_get(Ecore_Drm_Output *output);
ECORE_DRM_API Eina_Bool ecore_drm_output_connected_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -888,7 +876,7 @@ EAPI Eina_Bool ecore_drm_output_connected_get(Ecore_Drm_Output *output);
*
* @since 1.15
*/
EAPI unsigned int ecore_drm_output_connector_type_get(Ecore_Drm_Output *output);
ECORE_DRM_API unsigned int ecore_drm_output_connector_type_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -900,7 +888,7 @@ EAPI unsigned int ecore_drm_output_connector_type_get(Ecore_Drm_Output *output);
*
* @since 1.15
*/
EAPI Eina_Bool ecore_drm_output_backlight_get(Ecore_Drm_Output *output);
ECORE_DRM_API Eina_Bool ecore_drm_output_backlight_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -912,7 +900,7 @@ EAPI Eina_Bool ecore_drm_output_backlight_get(Ecore_Drm_Output *output);
*
* @since 1.15
*/
EAPI char *ecore_drm_output_edid_get(Ecore_Drm_Output *output);
ECORE_DRM_API char *ecore_drm_output_edid_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -926,7 +914,7 @@ EAPI char *ecore_drm_output_edid_get(Ecore_Drm_Output *output);
*
* @since 1.15
*/
EAPI Eina_List *ecore_drm_output_modes_get(Ecore_Drm_Output *output);
ECORE_DRM_API Eina_List *ecore_drm_output_modes_get(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -938,7 +926,7 @@ EAPI Eina_List *ecore_drm_output_modes_get(Ecore_Drm_Output *output);
*
* @since 1.15
*/
EAPI Ecore_Drm_Output *ecore_drm_output_primary_get(Ecore_Drm_Device *dev);
ECORE_DRM_API Ecore_Drm_Output *ecore_drm_output_primary_get(Ecore_Drm_Device *dev);
/**
* @ingroup Ecore_Drm_Output_Group
@ -948,7 +936,7 @@ EAPI Ecore_Drm_Output *ecore_drm_output_primary_get(Ecore_Drm_Device *dev);
*
* @since 1.15
*/
EAPI void ecore_drm_output_primary_set(Ecore_Drm_Output *output);
ECORE_DRM_API void ecore_drm_output_primary_set(Ecore_Drm_Output *output);
/**
* @ingroup Ecore_Drm_Output_Group
@ -960,7 +948,7 @@ EAPI void ecore_drm_output_primary_set(Ecore_Drm_Output *output);
*
* @since 1.15
*/
EAPI void ecore_drm_output_crtc_size_get(Ecore_Drm_Output *output, int *width, int *height);
ECORE_DRM_API void ecore_drm_output_crtc_size_get(Ecore_Drm_Output *output, int *width, int *height);
/**
* @ingroup Ecore_Drm_Device_Group
@ -976,7 +964,7 @@ EAPI void ecore_drm_output_crtc_size_get(Ecore_Drm_Output *output, int *width, i
*
* @since 1.15
*/
EAPI Ecore_Drm_Output *ecore_drm_device_output_name_find(Ecore_Drm_Device *dev, const char *name);
ECORE_DRM_API Ecore_Drm_Output *ecore_drm_device_output_name_find(Ecore_Drm_Device *dev, const char *name);
/**
* @ingroup Ecore_Drm_Output_Group
@ -992,7 +980,7 @@ EAPI Ecore_Drm_Output *ecore_drm_device_output_name_find(Ecore_Drm_Device *dev,
*
* @since 1.15
*/
EAPI Eina_Bool ecore_drm_output_possible_crtc_get(Ecore_Drm_Output *output, unsigned int crtc);
ECORE_DRM_API Eina_Bool ecore_drm_output_possible_crtc_get(Ecore_Drm_Output *output, unsigned int crtc);
/**
* @ingroup Ecore_Drm_Output_Group
@ -1009,15 +997,15 @@ EAPI Eina_Bool ecore_drm_output_possible_crtc_get(Ecore_Drm_Output *output, unsi
*
* @since 1.15
*/
EAPI Eina_Bool ecore_drm_output_mode_set(Ecore_Drm_Output *output, Ecore_Drm_Output_Mode *mode, int x, int y);
ECORE_DRM_API Eina_Bool ecore_drm_output_mode_set(Ecore_Drm_Output *output, Ecore_Drm_Output_Mode *mode, int x, int y);
/* TODO: doxy */
/* @since 1.18 */
EAPI unsigned int ecore_drm_output_supported_rotations_get(Ecore_Drm_Output *output, Ecore_Drm_Plane_Type type);
ECORE_DRM_API unsigned int ecore_drm_output_supported_rotations_get(Ecore_Drm_Output *output, Ecore_Drm_Plane_Type type);
/* TODO: doxy */
/* @since 1.18 */
EAPI Eina_Bool ecore_drm_output_rotation_set(Ecore_Drm_Output *output, Ecore_Drm_Plane_Type type, unsigned int rotation);
ECORE_DRM_API Eina_Bool ecore_drm_output_rotation_set(Ecore_Drm_Output *output, Ecore_Drm_Plane_Type type, unsigned int rotation);
/**
* @ingroup Ecore_Drm_Input_Group
@ -1033,7 +1021,7 @@ EAPI Eina_Bool ecore_drm_output_rotation_set(Ecore_Drm_Output *output, Ecore_Drm
*
* @since 1.17
*/
EAPI Eina_Bool ecore_drm_evdev_key_remap_enable(Ecore_Drm_Evdev *edev, Eina_Bool enable);
ECORE_DRM_API Eina_Bool ecore_drm_evdev_key_remap_enable(Ecore_Drm_Evdev *edev, Eina_Bool enable);
/**
* @ingroup Ecore_Drm_Input_Group
@ -1052,13 +1040,10 @@ EAPI Eina_Bool ecore_drm_evdev_key_remap_enable(Ecore_Drm_Evdev *edev, Eina_Bool
*
* @since 1.17
*/
EAPI Eina_Bool ecore_drm_evdev_key_remap_set(Ecore_Drm_Evdev *edev, int *from_keys, int *to_keys, int num);
ECORE_DRM_API Eina_Bool ecore_drm_evdev_key_remap_set(Ecore_Drm_Evdev *edev, int *from_keys, int *to_keys, int num);
# ifdef __cplusplus
}
# endif
# undef EAPI
# define EAPI
#endif

View File

@ -34,7 +34,7 @@ static int _ecore_drm_init_count = 0;
/* external variables */
int _ecore_drm_log_dom = -1;
EAPI int ECORE_DRM_EVENT_ACTIVATE = 0;
ECORE_DRM_API int ECORE_DRM_EVENT_ACTIVATE = 0;
static void
_ecore_drm_event_activate_free(void *data EINA_UNUSED, void *event)
@ -68,7 +68,7 @@ _ecore_drm_event_activate_send(Eina_Bool active)
*
* @ingroup Ecore_Drm_Init_Group
*/
EAPI int
ECORE_DRM_API int
ecore_drm_init(void)
{
/* if we have already initialized, return the count */
@ -134,7 +134,7 @@ log_err:
*
* @ingroup Ecore_Drm_Init_Group
*/
EAPI int
ECORE_DRM_API int
ecore_drm_shutdown(void)
{
Eina_List *lists;

View File

@ -0,0 +1,32 @@
#ifndef _EFL_ECORE_DRM_API_H
#define _EFL_ECORE_DRM_API_H
#ifdef ECORE_DRM_API
#error ECORE_DRM_API should not be already defined
#endif
#ifdef _WIN32
# ifndef ECORE_DRM_STATIC
# ifdef ECORE_DRM_BUILD
# define ECORE_DRM_API __declspec(dllexport)
# else
# define ECORE_DRM_API __declspec(dllimport)
# endif
# else
# define ECORE_DRM_API
# endif
# define ECORE_DRM_API_WEAK
#else
# ifdef __GNUC__
# if __GNUC__ >= 4
# define ECORE_DRM_API __attribute__ ((visibility("default")))
# define ECORE_DRM_API_WEAK __attribute__ ((weak))
# else
# define ECORE_DRM_API
# define ECORE_DRM_API_WEAK
# endif
# else
# define ECORE_DRM_API
# define ECORE_DRM_API_WEAK
# endif
#endif

View File

@ -198,7 +198,7 @@ _ecore_drm_device_cached_keymap_update(struct xkb_keymap *map)
* the DRM device itself.
*/
EAPI Ecore_Drm_Device *
ECORE_DRM_API Ecore_Drm_Device *
ecore_drm_device_find(const char *name, const char *seat)
{
Ecore_Drm_Device *dev = NULL;
@ -297,7 +297,7 @@ out:
return dev;
}
EAPI void
ECORE_DRM_API void
ecore_drm_device_free(Ecore_Drm_Device *dev)
{
unsigned int i = 0;
@ -334,7 +334,7 @@ ecore_drm_device_free(Ecore_Drm_Device *dev)
free(dev);
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_device_open(Ecore_Drm_Device *dev)
{
uint64_t caps;
@ -423,7 +423,7 @@ ecore_drm_device_open(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_device_close(Ecore_Drm_Device *dev)
{
/* check for valid device */
@ -448,13 +448,13 @@ ecore_drm_device_close(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI const Eina_List *
ECORE_DRM_API const Eina_List *
ecore_drm_devices_get(void)
{
return drm_devices;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_device_master_get(Ecore_Drm_Device *dev)
{
drm_magic_t mag;
@ -470,7 +470,7 @@ ecore_drm_device_master_get(Ecore_Drm_Device *dev)
return EINA_FALSE;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_device_master_set(Ecore_Drm_Device *dev)
{
/* check for valid device */
@ -483,7 +483,7 @@ ecore_drm_device_master_set(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_device_master_drop(Ecore_Drm_Device *dev)
{
/* check for valid device */
@ -496,14 +496,14 @@ ecore_drm_device_master_drop(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI int
ECORE_DRM_API int
ecore_drm_device_fd_get(Ecore_Drm_Device *dev)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(dev, -1);
return dev->drm.fd;
}
EAPI void
ECORE_DRM_API void
ecore_drm_device_window_set(Ecore_Drm_Device *dev, unsigned int window)
{
/* check for valid device */
@ -512,7 +512,7 @@ ecore_drm_device_window_set(Ecore_Drm_Device *dev, unsigned int window)
dev->window = window;
}
EAPI const char *
ECORE_DRM_API const char *
ecore_drm_device_name_get(Ecore_Drm_Device *dev)
{
/* check for valid device */
@ -521,7 +521,7 @@ ecore_drm_device_name_get(Ecore_Drm_Device *dev)
return dev->drm.name;
}
EAPI void
ECORE_DRM_API void
ecore_drm_device_pointer_xy_get(Ecore_Drm_Device *dev, int *x, int *y)
{
Ecore_Drm_Seat *seat;
@ -550,7 +550,7 @@ ecore_drm_device_pointer_xy_get(Ecore_Drm_Device *dev, int *x, int *y)
}
}
EAPI void
ECORE_DRM_API void
ecore_drm_device_pointer_warp(Ecore_Drm_Device *dev, int x, int y)
{
Ecore_Drm_Seat *seat;
@ -574,7 +574,7 @@ ecore_drm_device_pointer_warp(Ecore_Drm_Device *dev, int x, int y)
}
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_device_software_setup(Ecore_Drm_Device *dev)
{
unsigned int i = 0;
@ -621,7 +621,7 @@ err:
return EINA_FALSE;
}
EAPI Ecore_Drm_Output *
ECORE_DRM_API Ecore_Drm_Output *
ecore_drm_device_output_find(Ecore_Drm_Device *dev, int x, int y)
{
Ecore_Drm_Output *output;
@ -651,7 +651,7 @@ ecore_drm_device_output_find(Ecore_Drm_Device *dev, int x, int y)
return NULL;
}
EAPI void
ECORE_DRM_API void
ecore_drm_screen_size_range_get(Ecore_Drm_Device *dev, int *minw, int *minh, int *maxw, int *maxh)
{
EINA_SAFETY_ON_NULL_RETURN(dev);
@ -662,7 +662,7 @@ ecore_drm_screen_size_range_get(Ecore_Drm_Device *dev, int *minw, int *minh, int
if (maxh) *maxh = dev->max_height;
}
EAPI Ecore_Drm_Output *
ECORE_DRM_API Ecore_Drm_Output *
ecore_drm_device_output_name_find(Ecore_Drm_Device *dev, const char *name)
{
Ecore_Drm_Output *output;
@ -678,7 +678,7 @@ ecore_drm_device_output_name_find(Ecore_Drm_Device *dev, const char *name)
return NULL;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_device_pointer_left_handed_set(Ecore_Drm_Device *dev, Eina_Bool left_handed)
{
Ecore_Drm_Seat *seat = NULL;
@ -712,7 +712,7 @@ ecore_drm_device_pointer_left_handed_set(Ecore_Drm_Device *dev, Eina_Bool left_h
return EINA_TRUE;
}
EAPI void
ECORE_DRM_API void
ecore_drm_device_keyboard_cached_context_set(struct xkb_context *ctx)
{
EINA_SAFETY_ON_NULL_RETURN(ctx);
@ -725,7 +725,7 @@ ecore_drm_device_keyboard_cached_context_set(struct xkb_context *ctx)
cached_context = ctx;
}
EAPI void
ECORE_DRM_API void
ecore_drm_device_keyboard_cached_keymap_set(struct xkb_keymap *map)
{
EINA_SAFETY_ON_NULL_RETURN(map);

View File

@ -972,7 +972,7 @@ _ecore_drm_evdev_event_process(struct libinput_event *event)
* height must set for it. If its absolute set the ioctl correctly, if
* not, unsupported device.
*/
EAPI void
ECORE_DRM_API void
ecore_drm_inputs_device_axis_size_set(Ecore_Drm_Evdev *edev, int w, int h)
{
const char *sysname;
@ -1029,7 +1029,7 @@ cont:
* If the given enable value is EINA_FALSE, the key remap functionality wil be disable and
* the existing hash table for remapping keys will be freed.
*/
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_evdev_key_remap_enable(Ecore_Drm_Evdev *edev, Eina_Bool enable)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(edev, EINA_FALSE);
@ -1063,7 +1063,7 @@ ecore_drm_evdev_key_remap_enable(Ecore_Drm_Evdev *edev, Eina_Bool enable)
* the keycode of it can be replaced with the key found in the hash table.
* If there is no key found, the coming keycode will be used.
*/
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_evdev_key_remap_set(Ecore_Drm_Evdev *edev, int *from_keys, int *to_keys, int num)
{
int i;

View File

@ -74,7 +74,7 @@ _ecore_drm_fb_create2(int fd, Ecore_Drm_Fb *fb)
return EINA_TRUE;
}
EAPI Ecore_Drm_Fb *
ECORE_DRM_API Ecore_Drm_Fb *
ecore_drm_fb_create(Ecore_Drm_Device *dev, int width, int height)
{
Ecore_Drm_Fb *fb;
@ -148,7 +148,7 @@ create_err:
return NULL;
}
EAPI void
ECORE_DRM_API void
ecore_drm_fb_destroy(Ecore_Drm_Fb *fb)
{
struct drm_mode_destroy_dumb darg;
@ -163,7 +163,7 @@ ecore_drm_fb_destroy(Ecore_Drm_Fb *fb)
free(fb);
}
EAPI void
ECORE_DRM_API void
ecore_drm_fb_dirty(Ecore_Drm_Fb *fb, Eina_Rectangle *rects, unsigned int count)
{
EINA_SAFETY_ON_NULL_RETURN(fb);
@ -193,7 +193,7 @@ ecore_drm_fb_dirty(Ecore_Drm_Fb *fb, Eina_Rectangle *rects, unsigned int count)
#endif
}
EAPI void
ECORE_DRM_API void
ecore_drm_fb_set(Ecore_Drm_Device *dev EINA_UNUSED, Ecore_Drm_Fb *fb EINA_UNUSED)
{
/* ecore_drm_fb_set no longer has any functionality distinct from
@ -253,7 +253,7 @@ _ecore_drm_output_fb_send(Ecore_Drm_Device *dev, Ecore_Drm_Fb *fb, Ecore_Drm_Out
output->current = fb;
}
EAPI void
ECORE_DRM_API void
ecore_drm_fb_send(Ecore_Drm_Device *dev, Ecore_Drm_Fb *fb, Ecore_Drm_Pageflip_Cb func EINA_UNUSED, void *data EINA_UNUSED)
{
Ecore_Drm_Output *output;

View File

@ -28,7 +28,7 @@
#include "ecore_drm_private.h"
EAPI int ECORE_DRM_EVENT_SEAT_ADD = -1;
ECORE_DRM_API int ECORE_DRM_EVENT_SEAT_ADD = -1;
static Eina_Hash *_fd_hash = NULL;
/* local functions */
@ -230,7 +230,7 @@ const struct libinput_interface _input_interface =
};
/* public functions */
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_inputs_create(Ecore_Drm_Device *dev)
{
Ecore_Drm_Input *input;
@ -285,7 +285,7 @@ err:
return EINA_FALSE;
}
EAPI void
ECORE_DRM_API void
ecore_drm_inputs_destroy(Ecore_Drm_Device *dev)
{
Ecore_Drm_Input *input;
@ -313,7 +313,7 @@ ecore_drm_inputs_destroy(Ecore_Drm_Device *dev)
}
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_inputs_enable(Ecore_Drm_Input *input)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(input, EINA_FALSE);
@ -351,7 +351,7 @@ err:
return EINA_FALSE;
}
EAPI void
ECORE_DRM_API void
ecore_drm_inputs_disable(Ecore_Drm_Input *input)
{
EINA_SAFETY_ON_NULL_RETURN(input);

View File

@ -81,7 +81,7 @@ _ecore_drm_launcher_device_flags_set(int fd, int flags)
return fd;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_launcher_connect(Ecore_Drm_Device *dev)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(dev, EINA_FALSE);
@ -113,7 +113,7 @@ ecore_drm_launcher_connect(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI void
ECORE_DRM_API void
ecore_drm_launcher_disconnect(Ecore_Drm_Device *dev)
{
EINA_SAFETY_ON_NULL_RETURN(dev);

View File

@ -45,7 +45,7 @@ static const char *conn_types[] =
"DSI",
};
EAPI int ECORE_DRM_EVENT_OUTPUT = 0;
ECORE_DRM_API int ECORE_DRM_EVENT_OUTPUT = 0;
static void
_ecore_drm_output_event_free(void *data EINA_UNUSED, void *event)
@ -925,7 +925,7 @@ _ecore_drm_output_render_disable(Ecore_Drm_Output *output)
*
*/
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_outputs_create(Ecore_Drm_Device *dev)
{
Eina_Bool ret = EINA_TRUE;
@ -998,13 +998,13 @@ next:
return ret;
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_free(Ecore_Drm_Output *output)
{
_ecore_drm_output_free(output);
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_cursor_size_set(Ecore_Drm_Output *output, int handle, int w, int h)
{
EINA_SAFETY_ON_NULL_RETURN(output);
@ -1012,7 +1012,7 @@ ecore_drm_output_cursor_size_set(Ecore_Drm_Output *output, int handle, int w, in
drmModeSetCursor(output->dev->drm.fd, output->crtc_id, handle, w, h);
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_output_enable(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, EINA_FALSE);
@ -1025,7 +1025,7 @@ ecore_drm_output_enable(Ecore_Drm_Output *output)
return EINA_TRUE;
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_disable(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN(output);
@ -1036,7 +1036,7 @@ ecore_drm_output_disable(Ecore_Drm_Output *output)
_ecore_drm_output_event_send(output, EINA_FALSE);
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_fb_release(Ecore_Drm_Output *output, Ecore_Drm_Fb *fb)
{
EINA_SAFETY_ON_NULL_RETURN(output);
@ -1044,7 +1044,7 @@ ecore_drm_output_fb_release(Ecore_Drm_Output *output, Ecore_Drm_Fb *fb)
_ecore_drm_output_fb_release(output, fb);
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_repaint(Ecore_Drm_Output *output)
{
Ecore_Drm_Device *dev;
@ -1132,7 +1132,7 @@ err:
}
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_size_get(Ecore_Drm_Device *dev, int output, int *w, int *h)
{
drmModeFB *fb;
@ -1147,7 +1147,7 @@ ecore_drm_output_size_get(Ecore_Drm_Device *dev, int output, int *w, int *h)
drmModeFreeFB(fb);
}
EAPI void
ECORE_DRM_API void
ecore_drm_outputs_geometry_get(Ecore_Drm_Device *dev, int *x, int *y, int *w, int *h)
{
Ecore_Drm_Output *output;
@ -1174,7 +1174,7 @@ ecore_drm_outputs_geometry_get(Ecore_Drm_Device *dev, int *x, int *y, int *w, in
if (h) *h = oh;
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_position_get(Ecore_Drm_Output *output, int *x, int *y)
{
EINA_SAFETY_ON_NULL_RETURN(output);
@ -1183,7 +1183,7 @@ ecore_drm_output_position_get(Ecore_Drm_Output *output, int *x, int *y)
if (y) *y = output->y;
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_current_resolution_get(Ecore_Drm_Output *output, int *w, int *h, unsigned int *refresh)
{
if (w) *w = 0;
@ -1199,7 +1199,7 @@ ecore_drm_output_current_resolution_get(Ecore_Drm_Output *output, int *w, int *h
if (refresh) *refresh = output->current_mode->refresh;
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_physical_size_get(Ecore_Drm_Output *output, int *w, int *h)
{
EINA_SAFETY_ON_NULL_RETURN(output);
@ -1208,7 +1208,7 @@ ecore_drm_output_physical_size_get(Ecore_Drm_Output *output, int *w, int *h)
if (h) *h = output->phys_height;
}
EAPI unsigned int
ECORE_DRM_API unsigned int
ecore_drm_output_subpixel_order_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, 0);
@ -1216,7 +1216,7 @@ ecore_drm_output_subpixel_order_get(Ecore_Drm_Output *output)
return output->subpixel;
}
EAPI Eina_Stringshare *
ECORE_DRM_API Eina_Stringshare *
ecore_drm_output_model_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, NULL);
@ -1224,7 +1224,7 @@ ecore_drm_output_model_get(Ecore_Drm_Output *output)
return output->model;
}
EAPI Eina_Stringshare *
ECORE_DRM_API Eina_Stringshare *
ecore_drm_output_make_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, NULL);
@ -1232,7 +1232,7 @@ ecore_drm_output_make_get(Ecore_Drm_Output *output)
return output->make;
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_dpms_set(Ecore_Drm_Output *output, int level)
{
EINA_SAFETY_ON_NULL_RETURN(output);
@ -1243,7 +1243,7 @@ ecore_drm_output_dpms_set(Ecore_Drm_Output *output, int level)
output->dpms->prop_id, level);
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_gamma_set(Ecore_Drm_Output *output, uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b)
{
EINA_SAFETY_ON_NULL_RETURN(output);
@ -1256,7 +1256,7 @@ ecore_drm_output_gamma_set(Ecore_Drm_Output *output, uint16_t size, uint16_t *r,
ERR("Failed to set output gamma: %m");
}
EAPI unsigned int
ECORE_DRM_API unsigned int
ecore_drm_output_crtc_id_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, 0);
@ -1264,7 +1264,7 @@ ecore_drm_output_crtc_id_get(Ecore_Drm_Output *output)
return output->crtc_id;
}
EAPI unsigned int
ECORE_DRM_API unsigned int
ecore_drm_output_crtc_buffer_get(Ecore_Drm_Output *output)
{
drmModeCrtc *crtc;
@ -1283,7 +1283,7 @@ ecore_drm_output_crtc_buffer_get(Ecore_Drm_Output *output)
return id;
}
EAPI unsigned int
ECORE_DRM_API unsigned int
ecore_drm_output_connector_id_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, 0);
@ -1291,7 +1291,7 @@ ecore_drm_output_connector_id_get(Ecore_Drm_Output *output)
return output->conn_id;
}
EAPI char *
ECORE_DRM_API char *
ecore_drm_output_name_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, NULL);
@ -1299,7 +1299,7 @@ ecore_drm_output_name_get(Ecore_Drm_Output *output)
return strdup(output->name);
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_output_connected_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, EINA_FALSE);
@ -1307,7 +1307,7 @@ ecore_drm_output_connected_get(Ecore_Drm_Output *output)
return output->connected;
}
EAPI unsigned int
ECORE_DRM_API unsigned int
ecore_drm_output_connector_type_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, 0);
@ -1315,14 +1315,14 @@ ecore_drm_output_connector_type_get(Ecore_Drm_Output *output)
return output->conn_type;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_output_backlight_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, EINA_FALSE);
return (output->backlight != NULL);
}
EAPI char *
ECORE_DRM_API char *
ecore_drm_output_edid_get(Ecore_Drm_Output *output)
{
char *edid_str = NULL;
@ -1348,7 +1348,7 @@ ecore_drm_output_edid_get(Ecore_Drm_Output *output)
return edid_str;
}
EAPI Eina_List *
ECORE_DRM_API Eina_List *
ecore_drm_output_modes_get(Ecore_Drm_Output *output)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(output, NULL);
@ -1357,7 +1357,7 @@ ecore_drm_output_modes_get(Ecore_Drm_Output *output)
return output->modes;
}
EAPI Ecore_Drm_Output *
ECORE_DRM_API Ecore_Drm_Output *
ecore_drm_output_primary_get(Ecore_Drm_Device *dev)
{
Ecore_Drm_Output *ret;
@ -1371,7 +1371,7 @@ ecore_drm_output_primary_get(Ecore_Drm_Device *dev)
return NULL;
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_primary_set(Ecore_Drm_Output *output)
{
const Eina_List *l;
@ -1387,7 +1387,7 @@ ecore_drm_output_primary_set(Ecore_Drm_Output *output)
output->primary = EINA_TRUE;
}
EAPI void
ECORE_DRM_API void
ecore_drm_output_crtc_size_get(Ecore_Drm_Output *output, int *width, int *height)
{
if (width) *width = 0;
@ -1399,7 +1399,7 @@ ecore_drm_output_crtc_size_get(Ecore_Drm_Output *output, int *width, int *height
if (height) *height = output->crtc->height;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_output_possible_crtc_get(Ecore_Drm_Output *output, unsigned int crtc)
{
Ecore_Drm_Device *dev;
@ -1469,7 +1469,7 @@ next:
return ret;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_output_mode_set(Ecore_Drm_Output *output, Ecore_Drm_Output_Mode *mode, int x, int y)
{
Ecore_Drm_Device *dev;
@ -1516,7 +1516,7 @@ ecore_drm_output_mode_set(Ecore_Drm_Output *output, Ecore_Drm_Output_Mode *mode,
return ret;
}
EAPI unsigned int
ECORE_DRM_API unsigned int
ecore_drm_output_supported_rotations_get(Ecore_Drm_Output *output, Ecore_Drm_Plane_Type type)
{
Ecore_Drm_Plane *plane;
@ -1535,7 +1535,7 @@ ecore_drm_output_supported_rotations_get(Ecore_Drm_Output *output, Ecore_Drm_Pla
return rot;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_output_rotation_set(Ecore_Drm_Output *output, Ecore_Drm_Plane_Type type, unsigned int rotation)
{
Ecore_Drm_Plane *plane;

View File

@ -37,7 +37,7 @@
/* TODO: DOXY !! */
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_sprites_create(Ecore_Drm_Device *dev)
{
drmModePlaneRes *res;
@ -84,7 +84,7 @@ ecore_drm_sprites_create(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI void
ECORE_DRM_API void
ecore_drm_sprites_destroy(Ecore_Drm_Device *dev)
{
Ecore_Drm_Sprite *sprite;
@ -106,7 +106,7 @@ ecore_drm_sprites_destroy(Ecore_Drm_Device *dev)
}
}
EAPI void
ECORE_DRM_API void
ecore_drm_sprites_fb_set(Ecore_Drm_Sprite *sprite, int fb_id, int flags)
{
EINA_SAFETY_ON_TRUE_RETURN((!sprite) || (!sprite->output));
@ -127,7 +127,7 @@ ecore_drm_sprites_fb_set(Ecore_Drm_Sprite *sprite, int fb_id, int flags)
}
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_sprites_crtc_supported(Ecore_Drm_Output *output, unsigned int supported)
{
Ecore_Drm_Device *dev;

View File

@ -160,7 +160,7 @@ err_kmode:
* Functions that deal with opening, closing, and otherwise using a tty
*/
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_tty_open(Ecore_Drm_Device *dev, const char *name)
{
char tty[32] = "<stdin>";
@ -253,7 +253,7 @@ _ecore_drm_tty_restore(Ecore_Drm_Device *dev)
ERR("Could not reset VT handling\n");
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_tty_close(Ecore_Drm_Device *dev)
{
/* check for valid device */
@ -276,7 +276,7 @@ ecore_drm_tty_close(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_tty_release(Ecore_Drm_Device *dev)
{
/* check for valid device */
@ -293,7 +293,7 @@ ecore_drm_tty_release(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI Eina_Bool
ECORE_DRM_API Eina_Bool
ecore_drm_tty_acquire(Ecore_Drm_Device *dev)
{
/* check for valid device */
@ -310,7 +310,7 @@ ecore_drm_tty_acquire(Ecore_Drm_Device *dev)
return EINA_TRUE;
}
EAPI int
ECORE_DRM_API int
ecore_drm_tty_get(Ecore_Drm_Device *dev)
{
/* check for valid device */

View File

@ -25,7 +25,7 @@ ecore_drm_lib = library('ecore_drm',
dependencies: [m] + ecore_drm_deps + ecore_drm_pub_deps,
include_directories : config_dir + [include_directories(join_paths('..','..'))],
install: true,
c_args : package_c_args,
c_args : [package_c_args, '-DECORE_DRM_BUILD'],
)
ecore_drm = declare_dependency(

View File

@ -3,19 +3,7 @@
# include <Ecore.h>
# ifdef EAPI
# undef EAPI
# endif
# ifdef __GNUC__
# if __GNUC__ >= 4
# define EAPI __attribute__ ((visibility("default")))
# else // if __GNUC__ >= 4
# define EAPI
# endif // if __GNUC__ >= 4
# else // ifdef __GNUC__
# define EAPI
# endif // ifdef __GNUC__
# include <ecore_drm2_api.h>
# ifdef EFL_BETA_API_SUPPORT
@ -96,8 +84,8 @@ typedef struct _Ecore_Drm2_Context
unsigned int tv_usec, unsigned int crtc_id, void *user_data);
} Ecore_Drm2_Context;
EAPI extern int ECORE_DRM2_EVENT_OUTPUT_CHANGED;
EAPI extern int ECORE_DRM2_EVENT_ACTIVATE;
ECORE_DRM2_API extern int ECORE_DRM2_EVENT_OUTPUT_CHANGED;
ECORE_DRM2_API extern int ECORE_DRM2_EVENT_ACTIVATE;
typedef void (*Ecore_Drm2_Release_Handler)(void *data, Ecore_Drm2_Fb *b);
typedef void (*Ecore_Drm2_Fb_Status_Handler)(Ecore_Drm2_Fb *b, Ecore_Drm2_Fb_Status status, void *data);
@ -133,7 +121,7 @@ typedef void (*Ecore_Drm2_Fb_Status_Handler)(Ecore_Drm2_Fb *b, Ecore_Drm2_Fb_Sta
* @ingroup Ecore_Drm2_Init_Group
* @since 1.18
*/
EAPI int ecore_drm2_init(void);
ECORE_DRM2_API int ecore_drm2_init(void);
/**
* Shutdown the Ecore_Drm2 library
@ -144,7 +132,7 @@ EAPI int ecore_drm2_init(void);
* @ingroup Ecore_Drm2_Init_Group
* @since 1.18
*/
EAPI int ecore_drm2_shutdown(void);
ECORE_DRM2_API int ecore_drm2_shutdown(void);
/**
* Read and process pending Drm events
@ -161,7 +149,7 @@ EAPI int ecore_drm2_shutdown(void);
* @ingroup Ecore_Drm_Init_Group
* @since 1.19
*/
EAPI int ecore_drm2_event_handle(Ecore_Drm2_Device *dev, Ecore_Drm2_Context *drmctx);
ECORE_DRM2_API int ecore_drm2_event_handle(Ecore_Drm2_Device *dev, Ecore_Drm2_Context *drmctx);
/**
* @defgroup Ecore_Drm2_Device_Group Drm device functions
@ -181,7 +169,7 @@ EAPI int ecore_drm2_event_handle(Ecore_Drm2_Device *dev, Ecore_Drm2_Context *drm
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI Ecore_Drm2_Device *ecore_drm2_device_open(const char *seat, unsigned int tty);
ECORE_DRM2_API Ecore_Drm2_Device *ecore_drm2_device_open(const char *seat, unsigned int tty);
/**
* Close an open Ecore_Drm2_Device
@ -191,7 +179,7 @@ EAPI Ecore_Drm2_Device *ecore_drm2_device_open(const char *seat, unsigned int tt
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI void ecore_drm2_device_close(Ecore_Drm2_Device *device);
ECORE_DRM2_API void ecore_drm2_device_close(Ecore_Drm2_Device *device);
/**
* Get the type of clock used by a given Ecore_Drm2_Device
@ -203,7 +191,7 @@ EAPI void ecore_drm2_device_close(Ecore_Drm2_Device *device);
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI int ecore_drm2_device_clock_id_get(Ecore_Drm2_Device *device);
ECORE_DRM2_API int ecore_drm2_device_clock_id_get(Ecore_Drm2_Device *device);
/**
* Get the size of the cursor supported by a given Ecore_Drm2_Device
@ -215,7 +203,7 @@ EAPI int ecore_drm2_device_clock_id_get(Ecore_Drm2_Device *device);
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI void ecore_drm2_device_cursor_size_get(Ecore_Drm2_Device *device, int *width, int *height);
ECORE_DRM2_API void ecore_drm2_device_cursor_size_get(Ecore_Drm2_Device *device, int *width, int *height);
/**
* Get the current pointer position
@ -227,7 +215,7 @@ EAPI void ecore_drm2_device_cursor_size_get(Ecore_Drm2_Device *device, int *widt
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI void ecore_drm2_device_pointer_xy_get(Ecore_Drm2_Device *device, int *x, int *y);
ECORE_DRM2_API void ecore_drm2_device_pointer_xy_get(Ecore_Drm2_Device *device, int *x, int *y);
/**
* Warp the pointer position to given coordinates
@ -239,7 +227,7 @@ EAPI void ecore_drm2_device_pointer_xy_get(Ecore_Drm2_Device *device, int *x, in
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI void ecore_drm2_device_pointer_warp(Ecore_Drm2_Device *device, int x, int y);
ECORE_DRM2_API void ecore_drm2_device_pointer_warp(Ecore_Drm2_Device *device, int x, int y);
/**
* Set a left handed mode for the given device
@ -252,7 +240,7 @@ EAPI void ecore_drm2_device_pointer_warp(Ecore_Drm2_Device *device, int x, int y
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_device_pointer_left_handed_set(Ecore_Drm2_Device *device, Eina_Bool left);
ECORE_DRM2_API Eina_Bool ecore_drm2_device_pointer_left_handed_set(Ecore_Drm2_Device *device, Eina_Bool left);
/**
* Set which window is to be used for input events
@ -263,7 +251,7 @@ EAPI Eina_Bool ecore_drm2_device_pointer_left_handed_set(Ecore_Drm2_Device *devi
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI void ecore_drm2_device_window_set(Ecore_Drm2_Device *device, unsigned int window);
ECORE_DRM2_API void ecore_drm2_device_window_set(Ecore_Drm2_Device *device, unsigned int window);
/**
* Set maximium position that pointer device is allowed to move
@ -275,7 +263,7 @@ EAPI void ecore_drm2_device_window_set(Ecore_Drm2_Device *device, unsigned int w
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI void ecore_drm2_device_pointer_max_set(Ecore_Drm2_Device *device, int w, int h);
ECORE_DRM2_API void ecore_drm2_device_pointer_max_set(Ecore_Drm2_Device *device, int w, int h);
/**
* Set pointer acceleration speed
@ -286,7 +274,7 @@ EAPI void ecore_drm2_device_pointer_max_set(Ecore_Drm2_Device *device, int w, in
* @ingroup Ecore_Drm2_Device_Group
* @since 1.21
*/
EAPI void ecore_drm2_device_pointer_accel_speed_set(Ecore_Drm2_Device *device, double speed);
ECORE_DRM2_API void ecore_drm2_device_pointer_accel_speed_set(Ecore_Drm2_Device *device, double speed);
/**
* Set pointer acceleration profile
@ -297,7 +285,7 @@ EAPI void ecore_drm2_device_pointer_accel_speed_set(Ecore_Drm2_Device *device, d
* @ingroup Ecore_Drm2_Device_Group
* @since 1.21
*/
EAPI void ecore_drm2_device_pointer_accel_profile_set(Ecore_Drm2_Device *device, uint32_t profile);
ECORE_DRM2_API void ecore_drm2_device_pointer_accel_profile_set(Ecore_Drm2_Device *device, uint32_t profile);
/**
* Set pointer value rotation
@ -310,7 +298,7 @@ EAPI void ecore_drm2_device_pointer_accel_profile_set(Ecore_Drm2_Device *device,
* @ingroup Ecore_Drm2_Device_Group
* @since 1.20
*/
EAPI Eina_Bool ecore_drm2_device_pointer_rotation_set(Ecore_Drm2_Device *device, int rotation);
ECORE_DRM2_API Eina_Bool ecore_drm2_device_pointer_rotation_set(Ecore_Drm2_Device *device, int rotation);
/**
* Enable or disable pointer tap-to-click
@ -321,7 +309,7 @@ EAPI Eina_Bool ecore_drm2_device_pointer_rotation_set(Ecore_Drm2_Device *device,
* @ingroup Ecore_Drm2_Device_Group
* @since 1.22
*/
EAPI void ecore_drm2_device_touch_tap_to_click_enabled_set(Ecore_Drm2_Device *device, Eina_Bool enabled);
ECORE_DRM2_API void ecore_drm2_device_touch_tap_to_click_enabled_set(Ecore_Drm2_Device *device, Eina_Bool enabled);
/**
* Set info to be used on keyboards
@ -334,7 +322,7 @@ EAPI void ecore_drm2_device_touch_tap_to_click_enabled_set(Ecore_Drm2_Device *de
* @ingroup Ecore_Drm2_Device_Group
* @since 1.20
*/
EAPI void ecore_drm2_device_keyboard_info_set(Ecore_Drm2_Device *device, void *context, void *keymap, int group);
ECORE_DRM2_API void ecore_drm2_device_keyboard_info_set(Ecore_Drm2_Device *device, void *context, void *keymap, int group);
/**
* Set a group layout to be used on keyboards
@ -345,7 +333,7 @@ EAPI void ecore_drm2_device_keyboard_info_set(Ecore_Drm2_Device *device, void *c
* @ingroup Ecore_Drm2_Device_Group
* @since 1.20
*/
EAPI void ecore_drm2_device_keyboard_group_set(Ecore_Drm2_Device *device, int group);
ECORE_DRM2_API void ecore_drm2_device_keyboard_group_set(Ecore_Drm2_Device *device, int group);
/**
* Get the crtcs of a given device
@ -358,7 +346,7 @@ EAPI void ecore_drm2_device_keyboard_group_set(Ecore_Drm2_Device *device, int gr
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI unsigned int *ecore_drm2_device_crtcs_get(Ecore_Drm2_Device *device, int *num);
ECORE_DRM2_API unsigned int *ecore_drm2_device_crtcs_get(Ecore_Drm2_Device *device, int *num);
/**
* Get the minimum and maximum screen size range
@ -372,7 +360,7 @@ EAPI unsigned int *ecore_drm2_device_crtcs_get(Ecore_Drm2_Device *device, int *n
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI void ecore_drm2_device_screen_size_range_get(Ecore_Drm2_Device *device, int *minw, int *minh, int *maxw, int *maxh);
ECORE_DRM2_API void ecore_drm2_device_screen_size_range_get(Ecore_Drm2_Device *device, int *minw, int *minh, int *maxw, int *maxh);
/**
* Calibrate any input devices for given screen size
@ -384,7 +372,7 @@ EAPI void ecore_drm2_device_screen_size_range_get(Ecore_Drm2_Device *device, int
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI void ecore_drm2_device_calibrate(Ecore_Drm2_Device *device, int w, int h);
ECORE_DRM2_API void ecore_drm2_device_calibrate(Ecore_Drm2_Device *device, int w, int h);
/**
* Try to switch to a given virtual terminal
@ -397,7 +385,7 @@ EAPI void ecore_drm2_device_calibrate(Ecore_Drm2_Device *device, int w, int h);
* @ingroup Ecore_Drm2_Device_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_device_vt_set(Ecore_Drm2_Device *device, int vt);
ECORE_DRM2_API Eina_Bool ecore_drm2_device_vt_set(Ecore_Drm2_Device *device, int vt);
/**
* Get if a given device prefers the use of shadow buffers
@ -409,7 +397,7 @@ EAPI Eina_Bool ecore_drm2_device_vt_set(Ecore_Drm2_Device *device, int vt);
* @ingroup Ecore_Drm2_Device_Group
* @since 1.19
*/
EAPI Eina_Bool ecore_drm2_device_prefer_shadow(Ecore_Drm2_Device *device);
ECORE_DRM2_API Eina_Bool ecore_drm2_device_prefer_shadow(Ecore_Drm2_Device *device);
/**
* Get the default depth & bpp from a given device
@ -421,7 +409,7 @@ EAPI Eina_Bool ecore_drm2_device_prefer_shadow(Ecore_Drm2_Device *device);
* @ingroup Ecore_Drm2_Device_Group
* @since 1.25
*/
EAPI void ecore_drm2_device_preferred_depth_get(Ecore_Drm2_Device *device, int *depth, int *bpp);
ECORE_DRM2_API void ecore_drm2_device_preferred_depth_get(Ecore_Drm2_Device *device, int *depth, int *bpp);
/**
* @defgroup Ecore_Drm2_Output_Group Drm output functions
@ -439,7 +427,7 @@ EAPI void ecore_drm2_device_preferred_depth_get(Ecore_Drm2_Device *device, int *
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_outputs_create(Ecore_Drm2_Device *device);
ECORE_DRM2_API Eina_Bool ecore_drm2_outputs_create(Ecore_Drm2_Device *device);
/**
* Destroy any created outputs
@ -449,7 +437,7 @@ EAPI Eina_Bool ecore_drm2_outputs_create(Ecore_Drm2_Device *device);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI void ecore_drm2_outputs_destroy(Ecore_Drm2_Device *device);
ECORE_DRM2_API void ecore_drm2_outputs_destroy(Ecore_Drm2_Device *device);
/**
* Get the list of outputs from a drm device
@ -461,7 +449,7 @@ EAPI void ecore_drm2_outputs_destroy(Ecore_Drm2_Device *device);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI const Eina_List *ecore_drm2_outputs_get(Ecore_Drm2_Device *device);
ECORE_DRM2_API const Eina_List *ecore_drm2_outputs_get(Ecore_Drm2_Device *device);
/**
* Get the dpms level of a given output
@ -474,7 +462,7 @@ EAPI const Eina_List *ecore_drm2_outputs_get(Ecore_Drm2_Device *device);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI int ecore_drm2_output_dpms_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API int ecore_drm2_output_dpms_get(Ecore_Drm2_Output *output);
/**
* Set the dpms level of a given output
@ -485,7 +473,7 @@ EAPI int ecore_drm2_output_dpms_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI void ecore_drm2_output_dpms_set(Ecore_Drm2_Output *output, int level);
ECORE_DRM2_API void ecore_drm2_output_dpms_set(Ecore_Drm2_Output *output, int level);
/**
* Get the edid of a given output
@ -497,7 +485,7 @@ EAPI void ecore_drm2_output_dpms_set(Ecore_Drm2_Output *output, int level);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI char *ecore_drm2_output_edid_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API char *ecore_drm2_output_edid_get(Ecore_Drm2_Output *output);
/**
* Get if a given output has a backlight
@ -509,7 +497,7 @@ EAPI char *ecore_drm2_output_edid_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_output_backlight_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_backlight_get(Ecore_Drm2_Output *output);
/**
* Find an output at the given position
@ -523,7 +511,7 @@ EAPI Eina_Bool ecore_drm2_output_backlight_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Ecore_Drm2_Output *ecore_drm2_output_find(Ecore_Drm2_Device *device, int x, int y);
ECORE_DRM2_API Ecore_Drm2_Output *ecore_drm2_output_find(Ecore_Drm2_Device *device, int x, int y);
/**
* Get the dpi of a given output
@ -535,7 +523,7 @@ EAPI Ecore_Drm2_Output *ecore_drm2_output_find(Ecore_Drm2_Device *device, int x,
* @ingroup Ecore_Drm2_Output_Group
* @since 1.19
*/
EAPI void ecore_drm2_output_dpi_get(Ecore_Drm2_Output *output, int *xdpi, int *ydpi);
ECORE_DRM2_API void ecore_drm2_output_dpi_get(Ecore_Drm2_Output *output, int *xdpi, int *ydpi);
/**
* Get the id of the crtc that an output is using
@ -547,7 +535,7 @@ EAPI void ecore_drm2_output_dpi_get(Ecore_Drm2_Output *output, int *xdpi, int *y
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI unsigned int ecore_drm2_output_crtc_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API unsigned int ecore_drm2_output_crtc_get(Ecore_Drm2_Output *output);
/**
* Return the most recently set Ecore_Drm2_Fb for a given output
@ -563,7 +551,7 @@ EAPI unsigned int ecore_drm2_output_crtc_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.19
*/
EAPI Ecore_Drm2_Fb *ecore_drm2_output_latest_fb_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API Ecore_Drm2_Fb *ecore_drm2_output_latest_fb_get(Ecore_Drm2_Output *output);
/**
* Get if a given output is marked as the primary output
@ -575,7 +563,7 @@ EAPI Ecore_Drm2_Fb *ecore_drm2_output_latest_fb_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_output_primary_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_primary_get(Ecore_Drm2_Output *output);
/**
* Set a given output to be primary
@ -586,7 +574,7 @@ EAPI Eina_Bool ecore_drm2_output_primary_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI void ecore_drm2_output_primary_set(Ecore_Drm2_Output *output, Eina_Bool primary);
ECORE_DRM2_API void ecore_drm2_output_primary_set(Ecore_Drm2_Output *output, Eina_Bool primary);
/**
* Get if a given output is enabled
@ -598,7 +586,7 @@ EAPI void ecore_drm2_output_primary_set(Ecore_Drm2_Output *output, Eina_Bool pri
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_output_enabled_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_enabled_get(Ecore_Drm2_Output *output);
/**
* Set if a given output is enabled
@ -609,7 +597,7 @@ EAPI Eina_Bool ecore_drm2_output_enabled_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI void ecore_drm2_output_enabled_set(Ecore_Drm2_Output *output, Eina_Bool enabled);
ECORE_DRM2_API void ecore_drm2_output_enabled_set(Ecore_Drm2_Output *output, Eina_Bool enabled);
/**
* Get the physical size of a given output
@ -623,7 +611,7 @@ EAPI void ecore_drm2_output_enabled_set(Ecore_Drm2_Output *output, Eina_Bool ena
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI void ecore_drm2_output_physical_size_get(Ecore_Drm2_Output *output, int *w, int *h);
ECORE_DRM2_API void ecore_drm2_output_physical_size_get(Ecore_Drm2_Output *output, int *w, int *h);
/**
* Get a list of the modes supported on a given output
@ -637,7 +625,7 @@ EAPI void ecore_drm2_output_physical_size_get(Ecore_Drm2_Output *output, int *w,
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI const Eina_List *ecore_drm2_output_modes_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API const Eina_List *ecore_drm2_output_modes_get(Ecore_Drm2_Output *output);
/**
* Get information from an existing output mode
@ -651,7 +639,7 @@ EAPI const Eina_List *ecore_drm2_output_modes_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI void ecore_drm2_output_mode_info_get(Ecore_Drm2_Output_Mode *mode, int *w, int *h, unsigned int *refresh, unsigned int *flags);
ECORE_DRM2_API void ecore_drm2_output_mode_info_get(Ecore_Drm2_Output_Mode *mode, int *w, int *h, unsigned int *refresh, unsigned int *flags);
/**
* Set a given mode to be used on a given output
@ -666,7 +654,7 @@ EAPI void ecore_drm2_output_mode_info_get(Ecore_Drm2_Output_Mode *mode, int *w,
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_output_mode_set(Ecore_Drm2_Output *output, Ecore_Drm2_Output_Mode *mode, int x, int y);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_mode_set(Ecore_Drm2_Output *output, Ecore_Drm2_Output_Mode *mode, int x, int y);
/**
* Get the name of a given output
@ -678,7 +666,7 @@ EAPI Eina_Bool ecore_drm2_output_mode_set(Ecore_Drm2_Output *output, Ecore_Drm2_
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI char *ecore_drm2_output_name_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API char *ecore_drm2_output_name_get(Ecore_Drm2_Output *output);
/**
* Get the model of a given output
@ -690,7 +678,7 @@ EAPI char *ecore_drm2_output_name_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI char *ecore_drm2_output_model_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API char *ecore_drm2_output_model_get(Ecore_Drm2_Output *output);
/**
* Get if a given output is connected
@ -702,7 +690,7 @@ EAPI char *ecore_drm2_output_model_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_output_connected_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_connected_get(Ecore_Drm2_Output *output);
/**
* Get if a given output is cloned
@ -714,7 +702,7 @@ EAPI Eina_Bool ecore_drm2_output_connected_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_output_cloned_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_cloned_get(Ecore_Drm2_Output *output);
/**
* Get the connector type of a given output
@ -726,7 +714,7 @@ EAPI Eina_Bool ecore_drm2_output_cloned_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI unsigned int ecore_drm2_output_connector_type_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API unsigned int ecore_drm2_output_connector_type_get(Ecore_Drm2_Output *output);
/**
* Get the geometry and refresh rate for a given output
@ -741,7 +729,7 @@ EAPI unsigned int ecore_drm2_output_connector_type_get(Ecore_Drm2_Output *output
* @ingroup Ecore_Drm2_Output_Group
* @since 1.21
*/
EAPI void ecore_drm2_output_info_get(Ecore_Drm2_Output *output, int *x, int *y, int *w, int *h, unsigned int *refresh);
ECORE_DRM2_API void ecore_drm2_output_info_get(Ecore_Drm2_Output *output, int *x, int *y, int *w, int *h, unsigned int *refresh);
/**
* Get if an output can be used on a given crtc
@ -757,7 +745,7 @@ EAPI void ecore_drm2_output_info_get(Ecore_Drm2_Output *output, int *x, int *y,
* @ingroup Ecore_Drm2_Output_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_output_possible_crtc_get(Ecore_Drm2_Output *output, unsigned int crtc);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_possible_crtc_get(Ecore_Drm2_Output *output, unsigned int crtc);
/**
* Set the gamma level of an Ecore_Drm_Output
@ -773,7 +761,7 @@ EAPI Eina_Bool ecore_drm2_output_possible_crtc_get(Ecore_Drm2_Output *output, un
* @ingroup Ecore_Drm2_Output_Group
* @since 1.19
*/
EAPI void ecore_drm2_output_gamma_set(Ecore_Drm2_Output *output, uint16_t size, uint16_t *red, uint16_t *green, uint16_t *blue);
ECORE_DRM2_API void ecore_drm2_output_gamma_set(Ecore_Drm2_Output *output, uint16_t size, uint16_t *red, uint16_t *green, uint16_t *blue);
/**
* Get the supported rotations of a given output
@ -788,7 +776,7 @@ EAPI void ecore_drm2_output_gamma_set(Ecore_Drm2_Output *output, uint16_t size,
* @ingroup Ecore_Drm2_Output_Group
* @since 1.19
*/
EAPI int ecore_drm2_output_supported_rotations_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API int ecore_drm2_output_supported_rotations_get(Ecore_Drm2_Output *output);
/**
* Set a rotation on a given output
@ -804,7 +792,7 @@ EAPI int ecore_drm2_output_supported_rotations_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.19
*/
EAPI Eina_Bool ecore_drm2_output_rotation_set(Ecore_Drm2_Output *output, int rotation);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_rotation_set(Ecore_Drm2_Output *output, int rotation);
/**
* Get current output rotation
@ -816,7 +804,7 @@ EAPI Eina_Bool ecore_drm2_output_rotation_set(Ecore_Drm2_Output *output, int rot
* @ingroup Ecore_Drm2_Output_Group
* @since 1.22
*/
EAPI int ecore_drm2_output_rotation_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API int ecore_drm2_output_rotation_get(Ecore_Drm2_Output *output);
/**
* Set the user data for the output's page flip handler
@ -827,7 +815,7 @@ EAPI int ecore_drm2_output_rotation_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.19
*/
EAPI void ecore_drm2_output_user_data_set(Ecore_Drm2_Output *o, void *data);
ECORE_DRM2_API void ecore_drm2_output_user_data_set(Ecore_Drm2_Output *o, void *data);
/**
* Get the user data for a given output
@ -839,7 +827,7 @@ EAPI void ecore_drm2_output_user_data_set(Ecore_Drm2_Output *o, void *data);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.21
*/
EAPI void *ecore_drm2_output_user_data_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API void *ecore_drm2_output_user_data_get(Ecore_Drm2_Output *output);
/**
* Get the subpixel state of the output
@ -848,7 +836,7 @@ EAPI void *ecore_drm2_output_user_data_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.20
*/
EAPI unsigned int ecore_drm2_output_subpixel_get(const Ecore_Drm2_Output *output);
ECORE_DRM2_API unsigned int ecore_drm2_output_subpixel_get(const Ecore_Drm2_Output *output);
/**
* Set the relative mode for an output
@ -859,7 +847,7 @@ EAPI unsigned int ecore_drm2_output_subpixel_get(const Ecore_Drm2_Output *output
* @ingroup Ecore_Drm2_Output_Group
* @since 1.21
*/
EAPI void ecore_drm2_output_relative_mode_set(Ecore_Drm2_Output *output, Ecore_Drm2_Relative_Mode mode);
ECORE_DRM2_API void ecore_drm2_output_relative_mode_set(Ecore_Drm2_Output *output, Ecore_Drm2_Relative_Mode mode);
/**
* Get the relative mode of an output
@ -871,7 +859,7 @@ EAPI void ecore_drm2_output_relative_mode_set(Ecore_Drm2_Output *output, Ecore_D
* @ingroup Ecore_Drm2_Output_Group
* @since 1.21
*/
EAPI Ecore_Drm2_Relative_Mode ecore_drm2_output_relative_mode_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API Ecore_Drm2_Relative_Mode ecore_drm2_output_relative_mode_get(Ecore_Drm2_Output *output);
/**
* Set which output a given output is relative to
@ -882,7 +870,7 @@ EAPI Ecore_Drm2_Relative_Mode ecore_drm2_output_relative_mode_get(Ecore_Drm2_Out
* @ingroup Ecore_Drm2_Output_Group
* @since 1.21
*/
EAPI void ecore_drm2_output_relative_to_set(Ecore_Drm2_Output *output, const char *relative);
ECORE_DRM2_API void ecore_drm2_output_relative_to_set(Ecore_Drm2_Output *output, const char *relative);
/**
* Get which output is relative to a given output
@ -894,7 +882,7 @@ EAPI void ecore_drm2_output_relative_to_set(Ecore_Drm2_Output *output, const cha
* @ingroup Ecore_Drm2_Output_Group
* @since 1.21
*/
EAPI const char *ecore_drm2_output_relative_to_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API const char *ecore_drm2_output_relative_to_get(Ecore_Drm2_Output *output);
/**
* @defgroup Ecore_Drm2_Fb_Group Drm framebuffer functions
@ -917,9 +905,9 @@ EAPI const char *ecore_drm2_output_relative_to_get(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.18
*/
EAPI Ecore_Drm2_Fb *ecore_drm2_fb_create(Ecore_Drm2_Device *dev, int width, int height, int depth, int bpp, unsigned int format);
ECORE_DRM2_API Ecore_Drm2_Fb *ecore_drm2_fb_create(Ecore_Drm2_Device *dev, int width, int height, int depth, int bpp, unsigned int format);
EAPI Ecore_Drm2_Fb *ecore_drm2_fb_gbm_create(Ecore_Drm2_Device *dev, int width, int height, int depth, int bpp, unsigned int format, unsigned int handle, unsigned int stride, void *bo);
ECORE_DRM2_API Ecore_Drm2_Fb *ecore_drm2_fb_gbm_create(Ecore_Drm2_Device *dev, int width, int height, int depth, int bpp, unsigned int format, unsigned int handle, unsigned int stride, void *bo);
/**
* Get a framebuffer's mmap'd data
@ -931,7 +919,7 @@ EAPI Ecore_Drm2_Fb *ecore_drm2_fb_gbm_create(Ecore_Drm2_Device *dev, int width,
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.18
*/
EAPI void *ecore_drm2_fb_data_get(Ecore_Drm2_Fb *fb);
ECORE_DRM2_API void *ecore_drm2_fb_data_get(Ecore_Drm2_Fb *fb);
/**
* Get a framebuffer's size
@ -943,7 +931,7 @@ EAPI void *ecore_drm2_fb_data_get(Ecore_Drm2_Fb *fb);
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.18
*/
EAPI unsigned int ecore_drm2_fb_size_get(Ecore_Drm2_Fb *fb);
ECORE_DRM2_API unsigned int ecore_drm2_fb_size_get(Ecore_Drm2_Fb *fb);
/**
* Get a framebuffer's stride
@ -955,7 +943,7 @@ EAPI unsigned int ecore_drm2_fb_size_get(Ecore_Drm2_Fb *fb);
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.18
*/
EAPI unsigned int ecore_drm2_fb_stride_get(Ecore_Drm2_Fb *fb);
ECORE_DRM2_API unsigned int ecore_drm2_fb_stride_get(Ecore_Drm2_Fb *fb);
/**
* Mark regions of a framebuffer as dirty
@ -967,7 +955,7 @@ EAPI unsigned int ecore_drm2_fb_stride_get(Ecore_Drm2_Fb *fb);
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.18
*/
EAPI void ecore_drm2_fb_dirty(Ecore_Drm2_Fb *fb, Eina_Rectangle *rects, unsigned int count);
ECORE_DRM2_API void ecore_drm2_fb_dirty(Ecore_Drm2_Fb *fb, Eina_Rectangle *rects, unsigned int count);
/**
* Schedule a pageflip to the given Ecore_Drm2_Fb
@ -983,7 +971,7 @@ EAPI void ecore_drm2_fb_dirty(Ecore_Drm2_Fb *fb, Eina_Rectangle *rects, unsigned
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.18
*/
EAPI int ecore_drm2_fb_flip(Ecore_Drm2_Fb *fb, Ecore_Drm2_Output *output);
ECORE_DRM2_API int ecore_drm2_fb_flip(Ecore_Drm2_Fb *fb, Ecore_Drm2_Output *output);
/**
* Must be called by a page flip handler when the flip completes.
@ -995,7 +983,7 @@ EAPI int ecore_drm2_fb_flip(Ecore_Drm2_Fb *fb, Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.18
*/
EAPI Eina_Bool ecore_drm2_fb_flip_complete(Ecore_Drm2_Output *output);
ECORE_DRM2_API Eina_Bool ecore_drm2_fb_flip_complete(Ecore_Drm2_Output *output);
/**
* Return the Ecore_Drm2_Fb's busy status
@ -1007,7 +995,7 @@ EAPI Eina_Bool ecore_drm2_fb_flip_complete(Ecore_Drm2_Output *output);
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.19
*/
EAPI Eina_Bool ecore_drm2_fb_busy_get(Ecore_Drm2_Fb *fb);
ECORE_DRM2_API Eina_Bool ecore_drm2_fb_busy_get(Ecore_Drm2_Fb *fb);
/**
* Try to force a framebuffer release for an output
@ -1027,7 +1015,7 @@ EAPI Eina_Bool ecore_drm2_fb_busy_get(Ecore_Drm2_Fb *fb);
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.19
*/
EAPI Eina_Bool ecore_drm2_fb_release(Ecore_Drm2_Output *o, Eina_Bool panic);
ECORE_DRM2_API Eina_Bool ecore_drm2_fb_release(Ecore_Drm2_Output *o, Eina_Bool panic);
/**
* Get the Framebuffer's gbm buffer object
@ -1039,7 +1027,7 @@ EAPI Eina_Bool ecore_drm2_fb_release(Ecore_Drm2_Output *o, Eina_Bool panic);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.19
*/
EAPI void *ecore_drm2_fb_bo_get(Ecore_Drm2_Fb *fb);
ECORE_DRM2_API void *ecore_drm2_fb_bo_get(Ecore_Drm2_Fb *fb);
/**
* Import a dmabuf object as a Framebuffer
@ -1060,7 +1048,7 @@ EAPI void *ecore_drm2_fb_bo_get(Ecore_Drm2_Fb *fb);
* @since 1.20
*
*/
EAPI Ecore_Drm2_Fb *ecore_drm2_fb_dmabuf_import(Ecore_Drm2_Device *dev, int width, int height, int depth, int bpp, unsigned int format, unsigned int strides[4], int dmabuf_fd[4], int dmabuf_fd_count);
ECORE_DRM2_API Ecore_Drm2_Fb *ecore_drm2_fb_dmabuf_import(Ecore_Drm2_Device *dev, int width, int height, int depth, int bpp, unsigned int format, unsigned int strides[4], int dmabuf_fd[4], int dmabuf_fd_count);
/**
* Discard a framebuffer object
@ -1073,7 +1061,7 @@ EAPI Ecore_Drm2_Fb *ecore_drm2_fb_dmabuf_import(Ecore_Drm2_Device *dev, int widt
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.20
*/
EAPI void ecore_drm2_fb_discard(Ecore_Drm2_Fb *fb);
ECORE_DRM2_API void ecore_drm2_fb_discard(Ecore_Drm2_Fb *fb);
/**
* @defgroup Ecore_Drm2_Plane_Group Functions that deal with hardware planes
@ -1092,7 +1080,7 @@ EAPI void ecore_drm2_fb_discard(Ecore_Drm2_Fb *fb);
* @ingroup Ecore_Drm2_Plane_Group
* @since 1.20
*/
EAPI Ecore_Drm2_Plane *ecore_drm2_plane_assign(Ecore_Drm2_Output *output, Ecore_Drm2_Fb *fb, int x, int y);
ECORE_DRM2_API Ecore_Drm2_Plane *ecore_drm2_plane_assign(Ecore_Drm2_Output *output, Ecore_Drm2_Fb *fb, int x, int y);
/**
* Remove a hardware plane from display
@ -1102,7 +1090,7 @@ EAPI Ecore_Drm2_Plane *ecore_drm2_plane_assign(Ecore_Drm2_Output *output, Ecore_
* @ingroup Ecore_Drm2_Plane_Group
* @since 1.20
*/
EAPI void ecore_drm2_plane_release(Ecore_Drm2_Plane *plane);
ECORE_DRM2_API void ecore_drm2_plane_release(Ecore_Drm2_Plane *plane);
/**
* Set plane destination values
@ -1116,7 +1104,7 @@ EAPI void ecore_drm2_plane_release(Ecore_Drm2_Plane *plane);
* @ingroup Ecore_Drm2_Plane_Group
* @since 1.20
*/
EAPI void ecore_drm2_plane_destination_set(Ecore_Drm2_Plane *plane, int x, int y, int w, int h);
ECORE_DRM2_API void ecore_drm2_plane_destination_set(Ecore_Drm2_Plane *plane, int x, int y, int w, int h);
/**
* Set plane frame buffer
@ -1129,7 +1117,7 @@ EAPI void ecore_drm2_plane_destination_set(Ecore_Drm2_Plane *plane, int x, int y
* @ingroup Ecore_Drm2_Plane_Group
* @since 1.20
*/
EAPI Eina_Bool ecore_drm2_plane_fb_set(Ecore_Drm2_Plane *plane, Ecore_Drm2_Fb *fb);
ECORE_DRM2_API Eina_Bool ecore_drm2_plane_fb_set(Ecore_Drm2_Plane *plane, Ecore_Drm2_Fb *fb);
/**
* Register a callback for buffer status updates
@ -1147,7 +1135,7 @@ EAPI Eina_Bool ecore_drm2_plane_fb_set(Ecore_Drm2_Plane *plane, Ecore_Drm2_Fb *f
* @ingroup Ecore_Drm2_Fb_Group
* @since 1.20
*/
EAPI void ecore_drm2_fb_status_handler_set(Ecore_Drm2_Fb *fb, Ecore_Drm2_Fb_Status_Handler handler, void *data);
ECORE_DRM2_API void ecore_drm2_fb_status_handler_set(Ecore_Drm2_Fb *fb, Ecore_Drm2_Fb_Status_Handler handler, void *data);
/**
* Get the time of the last vblank
@ -1166,7 +1154,7 @@ EAPI void ecore_drm2_fb_status_handler_set(Ecore_Drm2_Fb *fb, Ecore_Drm2_Fb_Stat
* @ingroup Ecore_Drm2_Output_Group
* @since 1.20
*/
EAPI Eina_Bool ecore_drm2_output_blanktime_get(Ecore_Drm2_Output *output, int sequence, long *sec, long *usec);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_blanktime_get(Ecore_Drm2_Output *output, int sequence, long *sec, long *usec);
/**
* Get the fd of an Ecore_Drm2_Device
@ -1178,7 +1166,7 @@ EAPI Eina_Bool ecore_drm2_output_blanktime_get(Ecore_Drm2_Output *output, int se
* @ingroup Ecore_Drm2_Device_Group
* @since 1.20
*/
EAPI int ecore_drm2_device_fd_get(Ecore_Drm2_Device *device);
ECORE_DRM2_API int ecore_drm2_device_fd_get(Ecore_Drm2_Device *device);
/**
* Check if there's a pageflip in progress for an output
@ -1191,7 +1179,7 @@ EAPI int ecore_drm2_device_fd_get(Ecore_Drm2_Device *device);
* @ingroup Ecore_Drm2_Output_Group
* @since 1.20
*/
EAPI Eina_Bool ecore_drm2_output_pending_get(Ecore_Drm2_Output *output);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_pending_get(Ecore_Drm2_Output *output);
/**
* Set the background color of an output's crtc
@ -1208,7 +1196,7 @@ EAPI Eina_Bool ecore_drm2_output_pending_get(Ecore_Drm2_Output *output);
*
* @since 1.23
*/
EAPI Eina_Bool ecore_drm2_output_background_color_set(Ecore_Drm2_Output *output, uint64_t r, uint64_t g, uint64_t b, uint64_t a);
ECORE_DRM2_API Eina_Bool ecore_drm2_output_background_color_set(Ecore_Drm2_Output *output, uint64_t r, uint64_t g, uint64_t b, uint64_t a);
/**
* Check if vblank is supported by the current video driver
@ -1219,7 +1207,7 @@ EAPI Eina_Bool ecore_drm2_output_background_color_set(Ecore_Drm2_Output *output,
*
* @ingroup Ecore_Drm2_Device_Group
* @since 1.23 */
EAPI Eina_Bool ecore_drm2_vblank_supported(Ecore_Drm2_Device *dev);
ECORE_DRM2_API Eina_Bool ecore_drm2_vblank_supported(Ecore_Drm2_Device *dev);
# endif

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