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

Merge branch 'master' into devs/hermet/lottie

This commit is contained in:
Hermet Park 2019-05-23 15:38:30 +09:00
parent 511ac43993 708f67c488
commit 1522ca4e57
39 changed files with 405 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile_Efl.am
View File

@ -48,7 +48,7 @@ efl_eolian_files = \
lib/efl/interfaces/efl_gfx_blur.eo \
lib/efl/interfaces/efl_gfx_hint.eo \
lib/efl/interfaces/efl_model.eo \
lib/efl/interfaces/efl_gfx_orientable.eo \
lib/efl/interfaces/efl_gfx_image_orientable.eo \
lib/efl/interfaces/efl_container.eo \
lib/efl/interfaces/efl_content.eo \
lib/efl/interfaces/efl_gfx_arrangement.eo \

2
src/benchmarks/eina/ecore_hash.c
View File

@ -236,7 +236,7 @@ ecore_hash_hash_set(Ecore_Hash *hash, Ecore_Hash *set)
hash->free_key(node->key);
if (hash->free_value)
hash->free_key(node->value);
hash->free_value(node->value);
node->key = old->key;
node->value = old->value;

4
src/bin/efreet/efreetd_cache.c
View File

@ -487,12 +487,14 @@ icon_changes_monitor_add(const struct stat *st, const char *path)
const char *monpath = path;
if (eina_hash_find(icon_change_monitors, path)) return;
#ifndef _WIN32
if (S_ISLNK(st->st_mode))
{
realp = ecore_file_realpath(path);
if (!realp) return;
monpath = realp;
}
#endif
if (ecore_file_is_dir(monpath))
{
mon = eio_monitor_add(monpath);
@ -513,12 +515,14 @@ desktop_changes_monitor_add(const struct stat *st, const char *path)
const char *monpath = path;
if (eina_hash_find(desktop_change_monitors, path)) return;
#ifndef _WIN32
if (S_ISLNK(st->st_mode))
{
realp = ecore_file_realpath(path);
if (!realp) return;
monpath = realp;
}
#endif
if (ecore_file_is_dir(monpath))
{
mon = eio_monitor_add(monpath);

4
src/bin/elementary/test_evas_mask.c
View File

@ -93,12 +93,8 @@ _toggle_map(void *data, const Efl_Event *ev EINA_UNUSED)
static void
_rotate_win(void *data, const Efl_Event *ev EINA_UNUSED)
{
//Efl_Gfx_Orientation orient;
Eo *win = data;
// FIXME: This is not implemented???
//orient = efl_gfx_orientation_get(win);
//efl_gfx_orientation_set(win, (orient + 90) % 360);
elm_win_rotation_set(win, (elm_win_rotation_get(win) + 90) % 360);
}

20
src/bin/elementary/test_ui_image.c
View File

@ -5,15 +5,15 @@
#include <Efl_Ui.h>
static const struct {
Efl_Gfx_Orientation orient;
Efl_Gfx_Image_Orientation orient;
const char *name;
} images_orient[] = {
{ EFL_GFX_ORIENTATION_NONE, "None" },
{ EFL_GFX_ORIENTATION_RIGHT, "Rotate 90" },
{ EFL_GFX_ORIENTATION_DOWN, "Rotate 180" },
{ EFL_GFX_ORIENTATION_LEFT, "Rotate 270" },
{ EFL_GFX_ORIENTATION_FLIP_HORIZONTAL, "Horizontal Flip" },
{ EFL_GFX_ORIENTATION_FLIP_VERTICAL, "Vertical Flip" },
{ EFL_GFX_IMAGE_ORIENTATION_NONE, "None" },
{ EFL_GFX_IMAGE_ORIENTATION_RIGHT, "Rotate 90" },
{ EFL_GFX_IMAGE_ORIENTATION_DOWN, "Rotate 180" },
{ EFL_GFX_IMAGE_ORIENTATION_LEFT, "Rotate 270" },
{ EFL_GFX_IMAGE_ORIENTATION_FLIP_HORIZONTAL, "Horizontal Flip" },
{ EFL_GFX_IMAGE_ORIENTATION_FLIP_VERTICAL, "Vertical Flip" },
{ 0, NULL }
};
@ -51,11 +51,11 @@ my_im_ch(void *data, const Efl_Event *ev EINA_UNUSED)
Eo *win = data;
Eo *im = efl_key_data_get(win, "im");
Eo *rdg = efl_key_data_get(win, "rdg");
Efl_Gfx_Orientation v = efl_ui_radio_state_value_get(efl_ui_radio_selected_object_get(rdg));
Efl_Gfx_Image_Orientation v = efl_ui_radio_state_value_get(efl_ui_radio_selected_object_get(rdg));
efl_gfx_orientation_set(im, v);
efl_gfx_image_orientation_set(im, v);
fprintf(stderr, "Set %i and got %i\n",
v, efl_gfx_orientation_get(im));
v, efl_gfx_image_orientation_get(im));
}
void

16
src/examples/evas/evas-images5.c
View File

@ -76,7 +76,7 @@ _on_keydown(void *data EINA_UNUSED,
void *einfo)
{
Evas_Event_Key_Down *ev = einfo;
Efl_Gfx_Orientation orient = efl_gfx_orientation_get(d.img);
Efl_Gfx_Image_Orientation orient = efl_gfx_image_orientation_get(d.img);
if (strcmp(ev->key, "h") == 0) /* print help */
{
@ -110,25 +110,25 @@ _on_keydown(void *data EINA_UNUSED,
switch (key_val)
{
case 0:
efl_gfx_orientation_set(d.img, EFL_GFX_ORIENTATION_UP | (orient & EFL_GFX_ORIENTATION_FLIP_BITMASK));
efl_gfx_image_orientation_set(d.img, EFL_GFX_IMAGE_ORIENTATION_UP | (orient & EFL_GFX_IMAGE_ORIENTATION_FLIP_BITMASK));
break;
case 1:
efl_gfx_orientation_set(d.img, EFL_GFX_ORIENTATION_RIGHT | (orient & EFL_GFX_ORIENTATION_FLIP_BITMASK));
efl_gfx_image_orientation_set(d.img, EFL_GFX_IMAGE_ORIENTATION_RIGHT | (orient & EFL_GFX_IMAGE_ORIENTATION_FLIP_BITMASK));
break;
case 2:
efl_gfx_orientation_set(d.img, EFL_GFX_ORIENTATION_DOWN | (orient & EFL_GFX_ORIENTATION_FLIP_BITMASK));
efl_gfx_image_orientation_set(d.img, EFL_GFX_IMAGE_ORIENTATION_DOWN | (orient & EFL_GFX_IMAGE_ORIENTATION_FLIP_BITMASK));
break;
case 3:
efl_gfx_orientation_set(d.img, EFL_GFX_ORIENTATION_LEFT | (orient & EFL_GFX_ORIENTATION_FLIP_BITMASK));
efl_gfx_image_orientation_set(d.img, EFL_GFX_IMAGE_ORIENTATION_LEFT | (orient & EFL_GFX_IMAGE_ORIENTATION_FLIP_BITMASK));
break;
case 4:
efl_gfx_orientation_set(d.img, (orient & EFL_GFX_ORIENTATION_ROTATION_BITMASK) | EFL_GFX_ORIENTATION_FLIP_HORIZONTAL);
efl_gfx_image_orientation_set(d.img, (orient & EFL_GFX_IMAGE_ORIENTATION_ROTATION_BITMASK) | EFL_GFX_IMAGE_ORIENTATION_FLIP_HORIZONTAL);
break;
case 5:
efl_gfx_orientation_set(d.img, (orient & EFL_GFX_ORIENTATION_ROTATION_BITMASK) | EFL_GFX_ORIENTATION_FLIP_VERTICAL);
efl_gfx_image_orientation_set(d.img, (orient & EFL_GFX_IMAGE_ORIENTATION_ROTATION_BITMASK) | EFL_GFX_IMAGE_ORIENTATION_FLIP_VERTICAL);
break;
case 6:
efl_gfx_orientation_set(d.img, (orient & EFL_GFX_ORIENTATION_ROTATION_BITMASK));
efl_gfx_image_orientation_set(d.img, (orient & EFL_GFX_IMAGE_ORIENTATION_ROTATION_BITMASK));
break;
}
}

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

@ -9,6 +9,8 @@
# include <config.h>
#endif
#include <evil_private.h> /* evil_format_message evil_last_error_get */
#include "Ecore.h"
#include "Ecore_Con.h"
#include "ecore_con_private.h"

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

@ -6,6 +6,8 @@
# include <config.h>
#endif
#include <evil_private.h> /* evil_format_message evil_last_error_get */
#include "Ecore.h"
#include "Ecore_Con.h"
#include "ecore_con_private.h"

11
src/lib/ecore_drm2/Ecore_Drm2.h
View File

@ -1196,6 +1196,17 @@ EAPI Eina_Bool ecore_drm2_output_pending_get(Ecore_Drm2_Output *output);
*/
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);
/**
* Check if vblank is supported by the current video driver
*
* @param dev
*
* @return EINA_TRUE if vblank is supported, EINA_FALSE otherwise
*
* @ingroup Ecore_Drm2_Device_Group
* @since 1.23 */
EAPI Eina_Bool ecore_drm2_vblank_supported(Ecore_Drm2_Device *dev);
# endif
#endif

17
src/lib/ecore_drm2/ecore_drm2_device.c
View File

@ -891,6 +891,23 @@ ecore_drm2_device_fd_get(Ecore_Drm2_Device *device)
return device->fd;
}
EAPI Eina_Bool
ecore_drm2_vblank_supported(Ecore_Drm2_Device *dev)
{
drmVBlank tmp;
int ret = 0;
EINA_SAFETY_ON_NULL_RETURN_VAL(dev, EINA_FALSE);
memset(&tmp, 0, sizeof(drmVBlank));
tmp.request.type = DRM_VBLANK_RELATIVE;
ret = sym_drmWaitVBlank(dev->fd, &tmp);
if (ret != 0) return EINA_FALSE;
return EINA_TRUE;
}
/* prevent crashing with old apps compiled against these functions */
EAPI void ecore_drm2_device_keyboard_cached_context_set(){};
EAPI void ecore_drm2_device_keyboard_cached_keymap_set(){};

3
src/lib/ecore_evas/ecore_evas_module.c
View File

@ -224,7 +224,8 @@ _ecore_evas_available_engines_get(void)
const char *name;
#ifdef _WIN32
EVIL_PATH_SEP_WIN32_TO_UNIX(info->path);
name = strrchr(info->path, '\\');
if (name) name++;
#endif
name = strrchr(info->path, '/');
if (name) name++;

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

@ -539,6 +539,8 @@ ecore_ipc_server_add(Ecore_Ipc_Type type, const char *name, int port, const void
return NULL;
}
static Efl_Callback_Array_Item *_ecore_ipc_dialer_cbs(void);
static void
_ecore_ipc_dialer_del(Ecore_Ipc_Server *svr)
{
@ -564,6 +566,10 @@ _ecore_ipc_dialer_del(Ecore_Ipc_Server *svr)
if (svr->dialer.dialer)
{
efl_event_callback_array_del(svr->dialer.dialer, _ecore_ipc_dialer_cbs(), svr);
if (!efl_io_closer_closed_get(svr->dialer.dialer))
efl_io_closer_close(svr->dialer.dialer);
efl_del(svr->dialer.dialer);
svr->dialer.dialer = NULL;
}

2
src/lib/efl/Efl.h
View File

@ -90,7 +90,7 @@ typedef Efl_Gfx_Path_Command_Type Efl_Gfx_Path_Command;
#include "interfaces/efl_gfx_image.eo.h"
#include "interfaces/efl_gfx_frame_controller.eo.h"
#include "interfaces/efl_gfx_image_load_controller.eo.h"
#include "interfaces/efl_gfx_orientable.eo.h"
#include "interfaces/efl_gfx_image_orientable.eo.h"
#include "interfaces/efl_part.eo.h"
#include "interfaces/efl_playable.eo.h"
#include "interfaces/efl_player.eo.h"

10
src/lib/efl/interfaces/efl_gfx_orientable.eo → src/lib/efl/interfaces/efl_gfx_image_orientable.eo
View File

@ -1,6 +1,6 @@
parse efl_ui_direction;
enum @beta Efl.Gfx.Orientation
enum @beta Efl.Gfx.Image_Orientation
{
[[An orientation type, to rotate and flip images.
@ -25,19 +25,19 @@ enum @beta Efl.Gfx.Orientation
flip_bitmask = 12 [[Bitmask that can be used to isolate flipping values, that is, $flip_vertical and $flip_horizontal.]]
}
interface @beta Efl.Gfx.Orientable
interface @beta Efl.Gfx.Image_Orientable
{
[[Interface for objects which can be oriented.]]
c_prefix: efl_gfx_orientation;
c_prefix: efl_gfx_image;
methods {
@property orientation {
[[Control the orientation (rotation and flipping) of a given object.
[[Control the orientation (rotation and flipping) of a visual object.
This can be used to set the rotation on an image or a window, for
instance.
]]
values {
dir: Efl.Gfx.Orientation(Efl.Gfx.Orientation.none); [[The final orientation of the object.]]
dir: Efl.Gfx.Image_Orientation(Efl.Gfx.Image_Orientation.none); [[The final orientation of the object.]]
}
}
}

2
src/lib/efl/interfaces/efl_interfaces_main.c
View File

@ -32,7 +32,7 @@
#include "interfaces/efl_gfx_stack.eo.c"
#include "interfaces/efl_gfx_fill.eo.c"
#include "interfaces/efl_gfx_view.eo.c"
#include "interfaces/efl_gfx_orientable.eo.c"
#include "interfaces/efl_gfx_image_orientable.eo.c"
#include "interfaces/efl_gfx_text_class.eo.c"
#include "interfaces/efl_gfx_size_class.eo.c"

4
src/lib/efl/interfaces/efl_ui_direction.eo
View File

@ -1,13 +1,13 @@
// FIXME: Documentation lacks proper references due to cyclic imports.
// FIXME: What about AnyRTL? And other strange directions?
parse efl_gfx_orientable;
parse efl_gfx_image_orientable;
enum @beta Efl.Ui.Dir
{
[[Direction for UI objects and layouts.
Not to be confused with @Efl.Gfx.Orientation which is for images and canvases. This
Not to be confused with @Efl.Gfx.Image_Orientation which is for images and canvases. This
enum is used to define how widgets should expand and orient themselves,
not to rotate images.

2
src/lib/efl/interfaces/meson.build
View File

@ -64,7 +64,7 @@ pub_eo_files = [
'efl_gfx_hint.eo',
'efl_model.eo',
'efl_interpolator.eo',
'efl_gfx_orientable.eo',
'efl_gfx_image_orientable.eo',
'efl_container.eo',
'efl_content.eo',
'efl_pack.eo',

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

@ -274,8 +274,10 @@ _efl_io_model_info_type_get(const Eina_File_Direct_Info *info, const Eina_Stat *
return EINA_FILE_BLK;
else if (S_ISFIFO(st->mode))
return EINA_FILE_FIFO;
#ifndef _WIN32
else if (S_ISLNK(st->mode))
return EINA_FILE_LNK;
#endif
#ifdef S_ISSOCK
else if (S_ISSOCK(st->mode))
return EINA_FILE_SOCK;

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

@ -95,8 +95,10 @@ _eio_file_recursiv_ls(Ecore_Thread *thread,
if (_eio_lstat(info->path, &buffer) != 0)
continue;
#ifndef _WIN32
if (S_ISLNK(buffer.st_mode))
info->type = EINA_FILE_LNK;
#endif
default:
break;
}

30
src/lib/elementary/efl_ui_image.c
View File

@ -807,7 +807,7 @@ _efl_ui_image_sizing_eval(Evas_Object *obj)
//Retained way. Nothing does, if either way hasn't been changed.
if (!sd->edje)
{
efl_gfx_orientation_set(sd->img, sd->orient);
efl_gfx_image_orientation_set(sd->img, sd->orient);
}
if (sd->img)
@ -1364,7 +1364,7 @@ _efl_ui_image_efl_gfx_image_load_controller_load_size_get(const Eo *obj EINA_UNU
}
EOLIAN static void
_efl_ui_image_efl_gfx_orientable_orientation_set(Eo *obj, Efl_Ui_Image_Data *sd, Efl_Gfx_Orientation orient)
_efl_ui_image_efl_gfx_image_orientable_orientation_set(Eo *obj, Efl_Ui_Image_Data *sd, Efl_Gfx_Image_Orientation orient)
{
if (sd->edje) return;
if (sd->orient == orient) return;
@ -1373,8 +1373,8 @@ _efl_ui_image_efl_gfx_orientable_orientation_set(Eo *obj, Efl_Ui_Image_Data *sd,
_efl_ui_image_sizing_eval(obj);
}
EOLIAN static Efl_Gfx_Orientation
_efl_ui_image_efl_gfx_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
EOLIAN static Efl_Gfx_Image_Orientation
_efl_ui_image_efl_gfx_image_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
{
return sd->orient;
}
@ -2118,23 +2118,23 @@ elm_image_preload_disabled_set(Evas_Object *obj, Eina_Bool disable)
EAPI void
elm_image_orient_set(Evas_Object *obj, Elm_Image_Orient elm_orient)
{
// This array takes an Elm_Image_Orient and turns it into an Efl_Gfx_Orientation
static const Efl_Gfx_Orientation efl_orient[8] = {
EFL_GFX_ORIENTATION_NONE,
EFL_GFX_ORIENTATION_RIGHT,
EFL_GFX_ORIENTATION_DOWN,
EFL_GFX_ORIENTATION_LEFT,
EFL_GFX_ORIENTATION_FLIP_HORIZONTAL,
EFL_GFX_ORIENTATION_FLIP_VERTICAL,
EFL_GFX_ORIENTATION_LEFT | EFL_GFX_ORIENTATION_FLIP_VERTICAL,
EFL_GFX_ORIENTATION_RIGHT | EFL_GFX_ORIENTATION_FLIP_VERTICAL
// This array takes an Elm_Image_Orient and turns it into an Efl_Gfx_Image_Orientation
static const Efl_Gfx_Image_Orientation efl_orient[8] = {
EFL_GFX_IMAGE_ORIENTATION_NONE,
EFL_GFX_IMAGE_ORIENTATION_RIGHT,
EFL_GFX_IMAGE_ORIENTATION_DOWN,
EFL_GFX_IMAGE_ORIENTATION_LEFT,
EFL_GFX_IMAGE_ORIENTATION_FLIP_HORIZONTAL,
EFL_GFX_IMAGE_ORIENTATION_FLIP_VERTICAL,
EFL_GFX_IMAGE_ORIENTATION_LEFT | EFL_GFX_IMAGE_ORIENTATION_FLIP_VERTICAL,
EFL_GFX_IMAGE_ORIENTATION_RIGHT | EFL_GFX_IMAGE_ORIENTATION_FLIP_VERTICAL
};
EFL_UI_IMAGE_CHECK(obj);
EFL_UI_IMAGE_DATA_GET(obj, sd);
EINA_SAFETY_ON_FALSE_RETURN(elm_orient >= 0 && elm_orient < 8);
sd->image_orient = elm_orient;
efl_gfx_orientation_set(obj, efl_orient[elm_orient]);
efl_gfx_image_orientation_set(obj, efl_orient[elm_orient]);
}
EAPI Elm_Image_Orient

4
src/lib/elementary/efl_ui_image.eo
View File

@ -19,7 +19,7 @@ struct @beta Efl.Ui.Image_Error
class @beta Efl.Ui.Image extends Efl.Ui.Widget implements Efl.Ui.Clickable, Efl.Ui.Draggable,
Efl.File, Efl.Gfx.Image, Efl.Gfx.Image_Load_Controller, Efl.Player, Efl.Gfx.View,
Efl.Access.Component, Efl.Access.Widget.Action, Efl.Gfx.Color,
Efl.Gfx.Orientable,
Efl.Gfx.Image_Orientable,
Efl.Layout.Calc,
Efl.Layout.Group, Efl.Layout.Signal
{
@ -100,7 +100,7 @@ class @beta Efl.Ui.Image extends Efl.Ui.Widget implements Efl.Ui.Clickable, Efl.
Efl.Gfx.Image_Load_Controller.load_size { get; set; }
Efl.Gfx.Image.smooth_scale { get; set; }
Efl.Gfx.Image.scale_type { get; set; }
Efl.Gfx.Orientable.orientation { get; set; }
Efl.Gfx.Image_Orientable.orientation { get; set; }
Efl.Player.playable { get; }
Efl.Player.play { get; set; }
Efl.Layout.Signal.signal_emit;

78
src/lib/elementary/efl_ui_image_zoomable.c
View File

@ -622,7 +622,7 @@ _grid_create(Evas_Object *obj)
g->grid[tn].img =
evas_object_image_add(evas_object_evas_get(obj));
evas_object_image_load_orientation_set(g->grid[tn].img, EINA_TRUE);
efl_gfx_orientation_set(g->grid[tn].img, sd->orient);
efl_gfx_image_orientation_set(g->grid[tn].img, sd->orient);
evas_object_image_scale_hint_set
(g->grid[tn].img, EVAS_IMAGE_SCALE_HINT_DYNAMIC);
evas_object_pass_events_set(g->grid[tn].img, EINA_TRUE);
@ -1321,7 +1321,7 @@ _orient_apply(Eo *obj, Efl_Ui_Image_Zoomable_Data *sd)
}
}
efl_gfx_orientation_set(sd->img, sd->orient);
efl_gfx_image_orientation_set(sd->img, sd->orient);
evas_object_image_size_get(sd->img, &iw, &ih);
sd->size.imw = iw;
sd->size.imh = ih;
@ -1331,8 +1331,8 @@ _orient_apply(Eo *obj, Efl_Ui_Image_Zoomable_Data *sd)
}
EOLIAN static void
_efl_ui_image_zoomable_efl_gfx_orientable_orientation_set(Eo *obj, Efl_Ui_Image_Zoomable_Data *sd,
Efl_Gfx_Orientation orient)
_efl_ui_image_zoomable_efl_gfx_image_orientable_orientation_set(Eo *obj, Efl_Ui_Image_Zoomable_Data *sd,
Efl_Gfx_Image_Orientation orient)
{
if (sd->orient == orient) return;
@ -1340,8 +1340,8 @@ _efl_ui_image_zoomable_efl_gfx_orientable_orientation_set(Eo *obj, Efl_Ui_Image_
_orient_apply(obj, sd);
}
EOLIAN static Efl_Gfx_Orientation
_efl_ui_image_zoomable_efl_gfx_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Zoomable_Data *sd)
EOLIAN static Efl_Gfx_Image_Orientation
_efl_ui_image_zoomable_efl_gfx_image_orientable_orientation_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Zoomable_Data *sd)
{
return sd->orient;
}
@ -2056,7 +2056,7 @@ _img_proxy_set(Evas_Object *obj, Efl_Ui_Image_Zoomable_Data *sd,
tz = sd->zoom;
sd->zoom = 0.0;
elm_photocam_zoom_set(obj, tz);
sd->orient = EFL_GFX_ORIENTATION_NONE;
sd->orient = EFL_GFX_IMAGE_ORIENTATION_NONE;
sd->orientation_changed = EINA_FALSE;
return 0;
@ -2141,7 +2141,7 @@ _internal_file_set(Eo *obj, Efl_Ui_Image_Zoomable_Data *sd, Evas_Load_Error *ret
tz = sd->zoom;
sd->zoom = 0.0;
elm_photocam_zoom_set(obj, tz);
sd->orient = EFL_GFX_ORIENTATION_NONE;
sd->orient = EFL_GFX_IMAGE_ORIENTATION_NONE;
sd->orientation_changed = EINA_FALSE;
if (ret) *ret = evas_object_image_load_error_get(sd->img);
@ -3172,45 +3172,45 @@ elm_photocam_add(Evas_Object *parent)
return elm_legacy_add(EFL_UI_IMAGE_ZOOMABLE_LEGACY_CLASS, parent);
}
static inline Efl_Gfx_Orientation
static inline Efl_Gfx_Image_Orientation
_evas_orient_to_efl_orient(const Evas_Image_Orient evas_orient)
{
// This array takes an Elm_Image_Orient and turns it into an Efl_Gfx_Orientation
static const Efl_Gfx_Orientation efl_orient[8] = {
EFL_GFX_ORIENTATION_NONE,
EFL_GFX_ORIENTATION_RIGHT,
EFL_GFX_ORIENTATION_DOWN,
EFL_GFX_ORIENTATION_LEFT,
EFL_GFX_ORIENTATION_FLIP_HORIZONTAL,
EFL_GFX_ORIENTATION_FLIP_VERTICAL,
EFL_GFX_ORIENTATION_LEFT | EFL_GFX_ORIENTATION_FLIP_VERTICAL,
EFL_GFX_ORIENTATION_RIGHT | EFL_GFX_ORIENTATION_FLIP_VERTICAL
// This array takes an Elm_Image_Orient and turns it into an Efl_Gfx_Image_Orientation
static const Efl_Gfx_Image_Orientation efl_orient[8] = {
EFL_GFX_IMAGE_ORIENTATION_NONE,
EFL_GFX_IMAGE_ORIENTATION_RIGHT,
EFL_GFX_IMAGE_ORIENTATION_DOWN,
EFL_GFX_IMAGE_ORIENTATION_LEFT,
EFL_GFX_IMAGE_ORIENTATION_FLIP_HORIZONTAL,
EFL_GFX_IMAGE_ORIENTATION_FLIP_VERTICAL,
EFL_GFX_IMAGE_ORIENTATION_LEFT | EFL_GFX_IMAGE_ORIENTATION_FLIP_VERTICAL,
EFL_GFX_IMAGE_ORIENTATION_RIGHT | EFL_GFX_IMAGE_ORIENTATION_FLIP_VERTICAL
};
EINA_SAFETY_ON_FALSE_RETURN_VAL(evas_orient >= 0 && evas_orient < 8, EFL_GFX_ORIENTATION_NONE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(evas_orient >= 0 && evas_orient < 8, EFL_GFX_IMAGE_ORIENTATION_NONE);
return efl_orient[evas_orient];
}
static inline Evas_Image_Orient
_efl_orient_to_evas_orient(Efl_Gfx_Orientation efl_orient)
_efl_orient_to_evas_orient(Efl_Gfx_Image_Orientation efl_orient)
{
// This array takes an Efl_Gfx_Orientation and turns it into an Elm_Image_Orient
// This array takes an Efl_Gfx_Image_Orientation and turns it into an Elm_Image_Orient
static const Evas_Image_Orient evas_orient[16] = {
EVAS_IMAGE_ORIENT_NONE, // EFL_GFX_ORIENTATION_NONE
EVAS_IMAGE_ORIENT_90, // EFL_GFX_ORIENTATION_RIGHT
EVAS_IMAGE_ORIENT_180, // EFL_GFX_ORIENTATION_DOWN
EVAS_IMAGE_ORIENT_270, // EFL_GFX_ORIENTATION_LEFT
EVAS_IMAGE_FLIP_HORIZONTAL, // EFL_GFX_ORIENTATION_NONE + FLIP_HOR
EVAS_IMAGE_FLIP_TRANSPOSE, // EFL_GFX_ORIENTATION_RIGHT + FLIP_HOR
EVAS_IMAGE_FLIP_VERTICAL, // EFL_GFX_ORIENTATION_DOWN + FLIP_HOR
EVAS_IMAGE_FLIP_TRANSVERSE, // EFL_GFX_ORIENTATION_LEFT + FLIP_HOR
EVAS_IMAGE_FLIP_VERTICAL, // EFL_GFX_ORIENTATION_NONE + FLIP_VER
EVAS_IMAGE_FLIP_TRANSVERSE, // EFL_GFX_ORIENTATION_RIGHT + FLIP_VER
EVAS_IMAGE_FLIP_HORIZONTAL, // EFL_GFX_ORIENTATION_DOWN + FLIP_VER
EVAS_IMAGE_FLIP_TRANSPOSE, // EFL_GFX_ORIENTATION_LEFT + FLIP_VER
EVAS_IMAGE_ORIENT_180, // EFL_GFX_ORIENTATION_NONE + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_270, // EFL_GFX_ORIENTATION_RIGHT + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_0, // EFL_GFX_ORIENTATION_DOWN + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_90 // EFL_GFX_ORIENTATION_LEFT + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_NONE, // EFL_GFX_IMAGE_ORIENTATION_NONE
EVAS_IMAGE_ORIENT_90, // EFL_GFX_IMAGE_ORIENTATION_RIGHT
EVAS_IMAGE_ORIENT_180, // EFL_GFX_IMAGE_ORIENTATION_DOWN
EVAS_IMAGE_ORIENT_270, // EFL_GFX_IMAGE_ORIENTATION_LEFT
EVAS_IMAGE_FLIP_HORIZONTAL, // EFL_GFX_IMAGE_ORIENTATION_NONE + FLIP_HOR
EVAS_IMAGE_FLIP_TRANSPOSE, // EFL_GFX_IMAGE_ORIENTATION_RIGHT + FLIP_HOR
EVAS_IMAGE_FLIP_VERTICAL, // EFL_GFX_IMAGE_ORIENTATION_DOWN + FLIP_HOR
EVAS_IMAGE_FLIP_TRANSVERSE, // EFL_GFX_IMAGE_ORIENTATION_LEFT + FLIP_HOR
EVAS_IMAGE_FLIP_VERTICAL, // EFL_GFX_IMAGE_ORIENTATION_NONE + FLIP_VER
EVAS_IMAGE_FLIP_TRANSVERSE, // EFL_GFX_IMAGE_ORIENTATION_RIGHT + FLIP_VER
EVAS_IMAGE_FLIP_HORIZONTAL, // EFL_GFX_IMAGE_ORIENTATION_DOWN + FLIP_VER
EVAS_IMAGE_FLIP_TRANSPOSE, // EFL_GFX_IMAGE_ORIENTATION_LEFT + FLIP_VER
EVAS_IMAGE_ORIENT_180, // EFL_GFX_IMAGE_ORIENTATION_NONE + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_270, // EFL_GFX_IMAGE_ORIENTATION_RIGHT + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_0, // EFL_GFX_IMAGE_ORIENTATION_DOWN + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_90 // EFL_GFX_IMAGE_ORIENTATION_LEFT + FLIP_HOR + FLIP_VER
};
EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_orient >= 0 && efl_orient < 16, EVAS_IMAGE_ORIENT_NONE);
return evas_orient[efl_orient];
@ -3219,7 +3219,7 @@ _efl_orient_to_evas_orient(Efl_Gfx_Orientation efl_orient)
EAPI void
elm_photocam_image_orient_set(Eo *obj, Evas_Image_Orient evas_orient)
{
efl_gfx_orientation_set(obj, _evas_orient_to_efl_orient(evas_orient));
efl_gfx_image_orientation_set(obj, _evas_orient_to_efl_orient(evas_orient));
}
EAPI Evas_Image_Orient

2
src/lib/elementary/efl_ui_image_zoomable.eo
View File

@ -65,7 +65,7 @@ class @beta Efl.Ui.Image_Zoomable extends Efl.Ui.Image implements Efl.Ui.Zoom,
Efl.Access.Widget.Action.elm_actions { get; }
Efl.File.load;
Efl.File.file { get; set; }
Efl.Gfx.Orientable.orientation { get; set; }
Efl.Gfx.Image_Orientable.orientation { get; set; }
Efl.Layout.Group.group_size_min { get; }
Efl.Layout.Group.group_size_max { get; }
Efl.Layout.Signal.signal_callback_add;

2
src/lib/elementary/efl_ui_image_zoomable_private.h
View File

@ -129,7 +129,7 @@ struct _Efl_Ui_Image_Zoomable_Data
int frame_count;
Eina_List *grids;
Efl_Gfx_Orientation orient;
Efl_Gfx_Image_Orientation orient;
Eina_Bool main_load_pending : 1;
Eina_Bool longpressed : 1;

2
src/lib/elementary/efl_ui_widget_image.h
View File

@ -65,7 +65,7 @@ struct _Efl_Ui_Image_Data
int cur_frame;
Elm_Image_Orient image_orient; // to support EAPI
Efl_Gfx_Orientation orient;
Efl_Gfx_Image_Orientation orient;
struct {
Ecore_Thread *th;

4
src/lib/elua/io.c
View File

@ -1,5 +1,9 @@
#include "elua_private.h"
#ifdef _WIN32
# include <evil_private.h> /* realpath */
#endif
/* expand fname to full path name (so that PATH is ignored) plus turn
* stuff into a command, and also verify whether the path exists */
static char *

5
src/lib/emotion/emotion_modules.c
View File

@ -2,6 +2,11 @@
# include "config.h"
#endif
#ifdef _WIN32
/* normally, they will never be called as it's for Wayland */
# include <evil_private.h> /* setenv unsetenv */
#endif
#include "emotion_private.h"
#include "../../static_libs/buildsystem/buildsystem.h"
#include <unistd.h>

4
src/lib/evas/canvas/efl_canvas_image_internal.eo
View File

@ -1,7 +1,7 @@
abstract @beta Efl.Canvas.Image_Internal extends Efl.Canvas.Object implements Efl.Canvas.Filter.Internal,
Efl.Gfx.Image, Efl.Gfx.Buffer,
Efl.Gfx.Fill, Efl.Gfx.View,
Efl.Gfx.Orientable, Efl.File_Save
Efl.Gfx.Image_Orientable, Efl.File_Save
{
[[Efl canvas internal image class]]
data: Evas_Image_Data;
@ -11,7 +11,7 @@ abstract @beta Efl.Canvas.Image_Internal extends Efl.Canvas.Object implements Ef
Efl.Object.finalize;
Efl.Object.debug_name_override;
Efl.File_Save.save;
Efl.Gfx.Orientable.orientation { get; set; }
Efl.Gfx.Image_Orientable.orientation { get; set; }
Efl.Gfx.Image.smooth_scale { get; set; }
Efl.Gfx.Image.ratio { get; }
Efl.Gfx.Image.border { get; set; }

2
src/lib/evas/canvas/evas_image_private.h
View File

@ -115,7 +115,7 @@ struct _Evas_Image_Data
Efl_Gfx_Image_Scale_Hint scale_hint;
Efl_Gfx_Image_Content_Hint content_hint;
Efl_Gfx_Orientation orient_value;
Efl_Gfx_Image_Orientation orient_value;
struct {
short w, h;

40
src/lib/evas/canvas/evas_object_image.c
View File

@ -412,26 +412,26 @@ _evas_image_orientation_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Orient or
}
EOLIAN static void
_efl_canvas_image_internal_efl_gfx_orientable_orientation_set(Eo *obj, Evas_Image_Data *o, Efl_Gfx_Orientation efl_orient)
_efl_canvas_image_internal_efl_gfx_image_orientable_orientation_set(Eo *obj, Evas_Image_Data *o, Efl_Gfx_Image_Orientation efl_orient)
{
// This array takes an Efl_Gfx_Orientation and turns it into an Elm_Image_Orient
// This array takes an Efl_Gfx_Image_Orientation and turns it into an Elm_Image_Orient
static const Evas_Image_Orient evas_orient[16] = {
EVAS_IMAGE_ORIENT_NONE, // EFL_GFX_ORIENTATION_NONE
EVAS_IMAGE_ORIENT_90, // EFL_GFX_ORIENTATION_RIGHT
EVAS_IMAGE_ORIENT_180, // EFL_GFX_ORIENTATION_DOWN
EVAS_IMAGE_ORIENT_270, // EFL_GFX_ORIENTATION_LEFT
EVAS_IMAGE_FLIP_HORIZONTAL, // EFL_GFX_ORIENTATION_NONE + FLIP_HOR
EVAS_IMAGE_FLIP_TRANSPOSE, // EFL_GFX_ORIENTATION_RIGHT + FLIP_HOR
EVAS_IMAGE_FLIP_VERTICAL, // EFL_GFX_ORIENTATION_DOWN + FLIP_HOR
EVAS_IMAGE_FLIP_TRANSVERSE, // EFL_GFX_ORIENTATION_LEFT + FLIP_HOR
EVAS_IMAGE_FLIP_VERTICAL, // EFL_GFX_ORIENTATION_NONE + FLIP_VER
EVAS_IMAGE_FLIP_TRANSVERSE, // EFL_GFX_ORIENTATION_RIGHT + FLIP_VER
EVAS_IMAGE_FLIP_HORIZONTAL, // EFL_GFX_ORIENTATION_DOWN + FLIP_VER
EVAS_IMAGE_FLIP_TRANSPOSE, // EFL_GFX_ORIENTATION_LEFT + FLIP_VER
EVAS_IMAGE_ORIENT_180, // EFL_GFX_ORIENTATION_NONE + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_270, // EFL_GFX_ORIENTATION_RIGHT + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_0, // EFL_GFX_ORIENTATION_DOWN + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_90 // EFL_GFX_ORIENTATION_LEFT + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_NONE, // EFL_GFX_IMAGE_ORIENTATION_NONE
EVAS_IMAGE_ORIENT_90, // EFL_GFX_IMAGE_ORIENTATION_RIGHT
EVAS_IMAGE_ORIENT_180, // EFL_GFX_IMAGE_ORIENTATION_DOWN
EVAS_IMAGE_ORIENT_270, // EFL_GFX_IMAGE_ORIENTATION_LEFT
EVAS_IMAGE_FLIP_HORIZONTAL, // EFL_GFX_IMAGE_ORIENTATION_NONE + FLIP_HOR
EVAS_IMAGE_FLIP_TRANSPOSE, // EFL_GFX_IMAGE_ORIENTATION_RIGHT + FLIP_HOR
EVAS_IMAGE_FLIP_VERTICAL, // EFL_GFX_IMAGE_ORIENTATION_DOWN + FLIP_HOR
EVAS_IMAGE_FLIP_TRANSVERSE, // EFL_GFX_IMAGE_ORIENTATION_LEFT + FLIP_HOR
EVAS_IMAGE_FLIP_VERTICAL, // EFL_GFX_IMAGE_ORIENTATION_NONE + FLIP_VER
EVAS_IMAGE_FLIP_TRANSVERSE, // EFL_GFX_IMAGE_ORIENTATION_RIGHT + FLIP_VER
EVAS_IMAGE_FLIP_HORIZONTAL, // EFL_GFX_IMAGE_ORIENTATION_DOWN + FLIP_VER
EVAS_IMAGE_FLIP_TRANSPOSE, // EFL_GFX_IMAGE_ORIENTATION_LEFT + FLIP_VER
EVAS_IMAGE_ORIENT_180, // EFL_GFX_IMAGE_ORIENTATION_NONE + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_270, // EFL_GFX_IMAGE_ORIENTATION_RIGHT + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_0, // EFL_GFX_IMAGE_ORIENTATION_DOWN + FLIP_HOR + FLIP_VER
EVAS_IMAGE_ORIENT_90 // EFL_GFX_IMAGE_ORIENTATION_LEFT + FLIP_HOR + FLIP_VER
};
EINA_SAFETY_ON_FALSE_RETURN(efl_orient >= 0 && efl_orient < 16);
@ -439,8 +439,8 @@ _efl_canvas_image_internal_efl_gfx_orientable_orientation_set(Eo *obj, Evas_Imag
_evas_image_orientation_set(obj, o, evas_orient[efl_orient]);
}
EOLIAN static Efl_Gfx_Orientation
_efl_canvas_image_internal_efl_gfx_orientable_orientation_get(const Eo *obj EINA_UNUSED, Evas_Image_Data *o)
EOLIAN static Efl_Gfx_Image_Orientation
_efl_canvas_image_internal_efl_gfx_image_orientable_orientation_get(const Eo *obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->orient_value;
}

11
src/modules/ecore_evas/engines/drm/ecore_evas_drm.c
View File

@ -1031,6 +1031,17 @@ _ecore_evas_new_internal(const char *device, int x, int y, int w, int h, Eina_Bo
ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_evas_drm_engine_func;
ee->engine.data = edata;
if (!ecore_drm2_vblank_supported(edata->dev))
{
ee->engine.func->fn_animator_register = NULL;
ee->engine.func->fn_animator_unregister = NULL;
}
else
{
ee->engine.func->fn_animator_register = _drm_animator_register;
ee->engine.func->fn_animator_unregister = _drm_animator_unregister;
}
/* FIXME */
/* if (edata->device) ee->name = strdup(edata->device); */

86
src/tests/efl_mono/dummy_child.c Normal file
View File

@ -0,0 +1,86 @@
#include "libefl_mono_native_test.h"
typedef struct Dummy_Child_Data
{
int iface_prop;
const char* a;
double b;
Eina_Bool iface_was_set;
Eina_Bool obligatory_beta_ctor_was_called;
Eina_Bool optional_beta_ctor_was_called;
} Dummy_Child_Data;
/// Dummy.Child
static Efl_Object *
_dummy_child_efl_object_constructor(Eo *obj, Dummy_Child_Data *pd)
{
efl_constructor(efl_super(obj, DUMMY_CHILD_CLASS));
pd->iface_prop = 1984;
pd->iface_was_set = EINA_FALSE;
pd->obligatory_beta_ctor_was_called = EINA_FALSE;
pd->optional_beta_ctor_was_called = EINA_FALSE;
return obj;
}
void _dummy_child_dummy_test_iface_iface_prop_set(EINA_UNUSED Eo *obj, Dummy_Child_Data *pd, int value)
{
pd->iface_prop = value;
pd->iface_was_set = EINA_TRUE;
}
int _dummy_child_dummy_test_iface_iface_prop_get(EINA_UNUSED const Eo *obj, Dummy_Child_Data *pd)
{
return pd->iface_prop;
}
void _dummy_child_double_params(EINA_UNUSED Eo* obj, Dummy_Child_Data *pd, const char* a, double b)
{
if (pd->a)
free((void*)pd->a);
pd->a = malloc(sizeof(char)*(strlen(a) + 1));
strcpy((char*)pd->a, a);
pd->b = b;
}
Eina_Bool _dummy_child_iface_was_set_get(EINA_UNUSED const Eo* obj, Dummy_Child_Data *pd)
{
return pd->iface_was_set;
}
void _dummy_child_obligatory_beta_ctor(EINA_UNUSED Eo* obj, Dummy_Child_Data *pd, EINA_UNUSED int a)
{
pd->obligatory_beta_ctor_was_called = EINA_TRUE;
}
void _dummy_child_optional_beta_ctor(EINA_UNUSED Eo* obj, Dummy_Child_Data *pd, EINA_UNUSED int a)
{
pd->optional_beta_ctor_was_called = EINA_TRUE;
}
Eina_Bool _dummy_child_obligatory_beta_ctor_was_called_get(EINA_UNUSED const Eo* obj, Dummy_Child_Data *pd)
{
return pd->obligatory_beta_ctor_was_called;
}
Eina_Bool _dummy_child_optional_beta_ctor_was_called_get(EINA_UNUSED const Eo* obj, Dummy_Child_Data *pd)
{
return pd->optional_beta_ctor_was_called;
}
EOLIAN static void
_dummy_child_class_constructor(Efl_Class *klass)
{
(void)klass;
}
EOLIAN static void
_dummy_child_class_destructor(Efl_Class *klass)
{
(void)klass;
}
#include "dummy_child.eo.c"

8
src/tests/efl_mono/dummy_inherit_helper.c Normal file
View File

@ -0,0 +1,8 @@
#include "libefl_mono_native_test.h"
typedef struct Dummy_Inherit_Helper_Data
{
} Dummy_Inherit_Helper_Data;
#include "dummy_inherit_helper.eo.c"

5
src/tests/efl_mono/dummy_interfaces.c Normal file
View File

@ -0,0 +1,5 @@
// Include file for interfaces .eo.c files
#include "libefl_mono_native_test.h"
#include "dummy_test_iface.eo.c"
#include "dummy_inherit_iface.eo.c"

18
src/tests/efl_mono/dummy_numberwrapper.c Normal file
View File

@ -0,0 +1,18 @@
#include "libefl_mono_native_test.h"
typedef struct Dummy_Numberwrapper_Data
{
int number;
} Dummy_Numberwrapper_Data;
void _dummy_numberwrapper_number_set(EINA_UNUSED Eo *obj, Dummy_Numberwrapper_Data *pd, int n)
{
pd->number = n;
}
int _dummy_numberwrapper_number_get(EINA_UNUSED const Eo *obj, Dummy_Numberwrapper_Data *pd)
{
return pd->number;
}
#include "dummy_numberwrapper.eo.c"

35
src/tests/efl_mono/dummy_part_holder.c Normal file
View File

@ -0,0 +1,35 @@
#include "libefl_mono_native_test.h"
typedef struct Dummy_Part_Holder_Data
{
Eo *one;
Eo *two;
} Dummy_Part_Holder_Data;
// Part holder
static Efl_Object*
_dummy_part_holder_efl_object_constructor(Eo *obj, Dummy_Part_Holder_Data *pd)
{
efl_constructor(efl_super(obj, DUMMY_PART_HOLDER_CLASS));
// To avoid an infinite loop calling the same constructor
if (!efl_parent_get(obj))
{
pd->one = efl_add(DUMMY_TEST_OBJECT_CLASS, obj, efl_name_set(efl_added, "part_one"));
pd->two = efl_add(DUMMY_TEST_OBJECT_CLASS, obj, efl_name_set(efl_added, "part_two"));
}
return obj;
}
Efl_Object *_dummy_part_holder_efl_part_part_get(EINA_UNUSED const Eo *obj, Dummy_Part_Holder_Data *pd, const char *name)
{
if (!strcmp(name, "one"))
return pd->one;
else if (!strcmp(name, "two"))
return pd->two;
else
return NULL;
}
#include "dummy_part_holder.eo.c"

210
src/tests/efl_mono/libefl_mono_native_test.c → src/tests/efl_mono/dummy_test_object.c
View File

@ -1,62 +1,5 @@
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define EFL_PART_PROTECTED
#include <Ecore.h>
#include <Eo.h>
#ifdef EOAPI
#undef EOAPI
#endif
#ifdef EWAPI
#undef EWAPI
#endif
#ifdef EAPI
#undef EAPI
#endif
#define EOAPI EAPI EAPI_WEAK
#define EWAPI 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 "dummy_test_iface.eo.h"
#include "dummy_inherit_iface.eo.h"
#include "dummy_numberwrapper.eo.h"
#include "dummy_test_object.eo.h"
#include "dummy_child.eo.h"
#include "dummy_inherit_helper.eo.h"
#include "dummy_part_holder.eo.h"
#include <interfaces/efl_part.eo.h>
#define EQUAL(a, b) ((a) == (b) ? 1 : (fprintf(stderr, "NOT EQUAL! %s:%i (%s)", __FILE__, __LINE__, __FUNCTION__), fflush(stderr), 0))
#define STR_EQUAL(a, b) (strcmp((a), (b)) == 0 ? 1 : (fprintf(stderr, "NOT EQUAL! %s:%i (%s) '%s' != '%s'", __FILE__, __LINE__, __FUNCTION__, (a), (b)), fflush(stderr), 0))
#include "libefl_mono_native_test.h"
typedef struct Dummy_Test_Object_Data
{
@ -75,35 +18,6 @@ typedef struct Dummy_Test_Object_Data
Eo *iface_provider;
} Dummy_Test_Object_Data;
typedef struct Dummy_Numberwrapper_Data
{
int number;
} Dummy_Numberwrapper_Data;
typedef struct Dummy_Child_Data
{
int iface_prop;
const char* a;
double b;
Eina_Bool iface_was_set;
Eina_Bool obligatory_beta_ctor_was_called;
Eina_Bool optional_beta_ctor_was_called;
} Dummy_Child_Data;
typedef struct Dummy_Part_Holder_Data
{
Eo *one;
Eo *two;
} Dummy_Part_Holder_Data;
typedef struct Dummy_Inherit_Helper_Data
{
} Dummy_Inherit_Helper_Data;
typedef struct Dummy_Inherit_Iface_Data
{
} Dummy_Inherit_Iface_Data;
static
void *_new_int(int v)
{
@ -3684,22 +3598,6 @@ _dummy_test_object_destroy_cmp_array_objects(void)
efl_unref(modified_seq_obj[i]);
}
// ################## //
// Test.Numberwrapper //
// ################## //
void _dummy_numberwrapper_number_set(EINA_UNUSED Eo *obj, Dummy_Numberwrapper_Data *pd, int n)
{
pd->number = n;
}
int _dummy_numberwrapper_number_get(EINA_UNUSED const Eo *obj, Dummy_Numberwrapper_Data *pd)
{
return pd->number;
}
void _dummy_test_object_set_value_ptr(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Value *value)
{
if (pd->stored_value) {
@ -3973,78 +3871,6 @@ Efl_Object *_dummy_test_object_call_find_provider_for_iface(Eo *obj, EINA_UNUSED
return efl_provider_find(obj, DUMMY_TEST_IFACE_INTERFACE);
}
/// Dummy.Child
static Efl_Object *
_dummy_child_efl_object_constructor(Eo *obj, Dummy_Child_Data *pd)
{
efl_constructor(efl_super(obj, DUMMY_CHILD_CLASS));
pd->iface_prop = 1984;
pd->iface_was_set = EINA_FALSE;
pd->obligatory_beta_ctor_was_called = EINA_FALSE;
pd->optional_beta_ctor_was_called = EINA_FALSE;
return obj;
}
void _dummy_child_dummy_test_iface_iface_prop_set(EINA_UNUSED Eo *obj, Dummy_Child_Data *pd, int value)
{
pd->iface_prop = value;
pd->iface_was_set = EINA_TRUE;
}
int _dummy_child_dummy_test_iface_iface_prop_get(EINA_UNUSED const Eo *obj, Dummy_Child_Data *pd)
{
return pd->iface_prop;
}
void _dummy_child_double_params(EINA_UNUSED Eo* obj, Dummy_Child_Data *pd, const char* a, double b)
{
if (pd->a)
free((void*)pd->a);
pd->a = malloc(sizeof(char)*(strlen(a) + 1));
strcpy((char*)pd->a, a);
pd->b = b;
}
Eina_Bool _dummy_child_iface_was_set_get(EINA_UNUSED const Eo* obj, Dummy_Child_Data *pd)
{
return pd->iface_was_set;
}
void _dummy_child_obligatory_beta_ctor(EINA_UNUSED Eo* obj, Dummy_Child_Data *pd, EINA_UNUSED int a)
{
pd->obligatory_beta_ctor_was_called = EINA_TRUE;
}
void _dummy_child_optional_beta_ctor(EINA_UNUSED Eo* obj, Dummy_Child_Data *pd, EINA_UNUSED int a)
{
pd->optional_beta_ctor_was_called = EINA_TRUE;
}
Eina_Bool _dummy_child_obligatory_beta_ctor_was_called_get(EINA_UNUSED const Eo* obj, Dummy_Child_Data *pd)
{
return pd->obligatory_beta_ctor_was_called;
}
Eina_Bool _dummy_child_optional_beta_ctor_was_called_get(EINA_UNUSED const Eo* obj, Dummy_Child_Data *pd)
{
return pd->optional_beta_ctor_was_called;
}
EOLIAN static void
_dummy_child_class_constructor(Efl_Class *klass)
{
(void)klass;
}
EOLIAN static void
_dummy_child_class_destructor(Efl_Class *klass)
{
(void)klass;
}
// Inherit
int _dummy_inherit_helper_receive_dummy_and_call_int_out(Dummy_Test_Object *x)
{
@ -4058,39 +3884,5 @@ const char* _dummy_inherit_helper_receive_dummy_and_call_in_stringshare(Dummy_Te
return dummy_inherit_iface_stringshare_test (x, eina_stringshare_add("hello world"));
}
// Part holder
static Efl_Object*
_dummy_part_holder_efl_object_constructor(Eo *obj, Dummy_Part_Holder_Data *pd)
{
efl_constructor(efl_super(obj, DUMMY_PART_HOLDER_CLASS));
// To avoid an infinite loop calling the same constructor
if (!efl_parent_get(obj))
{
pd->one = efl_add(DUMMY_TEST_OBJECT_CLASS, obj, efl_name_set(efl_added, "part_one"));
pd->two = efl_add(DUMMY_TEST_OBJECT_CLASS, obj, efl_name_set(efl_added, "part_two"));
}
return obj;
}
Efl_Object *_dummy_part_holder_efl_part_part_get(EINA_UNUSED const Eo *obj, Dummy_Part_Holder_Data *pd, const char *name)
{
if (!strcmp(name, "one"))
return pd->one;
else if (!strcmp(name, "two"))
return pd->two;
else
return NULL;
}
#include "dummy_test_object.eo.c"
#include "dummy_numberwrapper.eo.c"
#include "dummy_child.eo.c"
#include "dummy_test_iface.eo.c"
#include "dummy_inherit_helper.eo.c"
#include "dummy_inherit_iface.eo.c"
#include "dummy_part_holder.eo.c"

63
src/tests/efl_mono/libefl_mono_native_test.h Normal file
View File

@ -0,0 +1,63 @@
#ifndef LIBEFL_MONO_NATIVE_TEST_H
#define LIBEFL_MONO_NATIVE_TEST_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define EFL_PART_PROTECTED
#include <Ecore.h>
#include <Eo.h>
#ifdef EOAPI
#undef EOAPI
#endif
#ifdef EWAPI
#undef EWAPI
#endif
#ifdef EAPI
#undef EAPI
#endif
#define EOAPI EAPI EAPI_WEAK
#define EWAPI 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 "dummy_test_iface.eo.h"
#include "dummy_inherit_iface.eo.h"
#include "dummy_numberwrapper.eo.h"
#include "dummy_test_object.eo.h"
#include "dummy_child.eo.h"
#include "dummy_inherit_helper.eo.h"
#include "dummy_part_holder.eo.h"
#include <interfaces/efl_part.eo.h>
#define EQUAL(a, b) ((a) == (b) ? 1 : (fprintf(stderr, "NOT EQUAL! %s:%i (%s)", __FILE__, __LINE__, __FUNCTION__), fflush(stderr), 0))
#define STR_EQUAL(a, b) (strcmp((a), (b)) == 0 ? 1 : (fprintf(stderr, "NOT EQUAL! %s:%i (%s) '%s' != '%s'", __FILE__, __LINE__, __FUNCTION__, (a), (b)), fflush(stderr), 0))
#endif

10
src/tests/efl_mono/meson.build
View File

@ -15,7 +15,15 @@ endforeach
efl_mono_native_test = library('efl_mono_native_test',
eo_file_targets + ['libefl_mono_native_test.c'],
eo_file_targets + [
'libefl_mono_native_test.h',
'dummy_child.c',
'dummy_inherit_helper.c',
'dummy_interfaces.c',
'dummy_numberwrapper.c',
'dummy_part_holder.c',
'dummy_test_object.c',
],
dependencies : [ecore, eo, efl],
)