2016-03-16 22:14:06 -07:00
|
|
|
#include "evas_image_private.h"
|
2016-03-21 19:13:55 -07:00
|
|
|
#include "efl_canvas_image.eo.h"
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2016-03-21 19:13:55 -07:00
|
|
|
#define MY_CLASS EFL_CANVAS_IMAGE_CLASS
|
2016-11-07 14:40:58 -08:00
|
|
|
#define MY_CLASS_NAME efl_class_name_get(MY_CLASS)
|
2016-03-21 19:13:55 -07:00
|
|
|
|
2019-04-18 06:05:31 -07:00
|
|
|
void
|
|
|
|
_evas_image_file_unload(Eo *eo_obj)
|
|
|
|
{
|
|
|
|
Evas_Object_Protected_Data *obj;
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
|
|
|
|
|
|
|
if (!o->cur->f) return;
|
|
|
|
|
|
|
|
obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
evas_object_async_block(obj);
|
|
|
|
_evas_image_init_set(NULL, NULL, eo_obj, obj, o, NULL);
|
|
|
|
o->buffer_data_set = EINA_FALSE;
|
|
|
|
_evas_image_done_set(eo_obj, obj, o);
|
|
|
|
o->load_error = EFL_GFX_IMAGE_LOAD_ERROR_NONE;
|
|
|
|
}
|
2020-02-26 06:38:13 -08:00
|
|
|
|
|
|
|
void
|
|
|
|
_evas_image_preload_update(Eo *eo_obj, Eina_File *f)
|
|
|
|
{
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
|
|
|
if (o->cur->f) return;
|
|
|
|
EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, cur)
|
|
|
|
{
|
|
|
|
cur->f = eina_file_dup(f);
|
|
|
|
}
|
|
|
|
EINA_COW_IMAGE_STATE_WRITE_END(o, cur)
|
|
|
|
}
|
|
|
|
|
2016-03-16 22:14:06 -07:00
|
|
|
Eina_Bool
|
2020-02-14 05:33:43 -08:00
|
|
|
_evas_image_file_load(Eo *eo_obj, Evas_Image_Data *o)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2019-01-24 09:15:11 -08:00
|
|
|
Evas_Object_Protected_Data *obj;
|
2016-03-16 22:14:06 -07:00
|
|
|
Evas_Image_Load_Opts lo;
|
2019-02-27 10:17:09 -08:00
|
|
|
const Eina_File *f = efl_file_mmap_get(eo_obj);
|
|
|
|
const char *key = efl_file_key_get(eo_obj);
|
2019-03-04 10:36:57 -08:00
|
|
|
int load_error;
|
2020-03-10 06:27:30 -07:00
|
|
|
int frame_index;
|
2019-02-27 10:17:09 -08:00
|
|
|
|
2020-02-14 05:33:43 -08:00
|
|
|
if (!o->skip_head)
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(f, EINA_FALSE);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2020-02-14 05:33:43 -08:00
|
|
|
if (f && (o->cur->f == f))
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
if ((!o->cur->key) && (!key))
|
2019-02-27 10:17:09 -08:00
|
|
|
return EINA_TRUE;
|
2016-03-16 22:14:06 -07:00
|
|
|
if ((o->cur->key) && (key) && (!strcmp(o->cur->key, key)))
|
2019-02-27 10:17:09 -08:00
|
|
|
return EINA_TRUE;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
2019-01-24 09:15:11 -08:00
|
|
|
|
|
|
|
obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
evas_object_async_block(obj);
|
2017-10-04 21:01:35 -07:00
|
|
|
_evas_image_init_set(f, key, eo_obj, obj, o, &lo);
|
2020-02-14 05:33:43 -08:00
|
|
|
if (f)
|
|
|
|
o->engine_data = ENFN->image_mmap(ENC, o->cur->f, o->cur->key, &load_error, &lo);
|
|
|
|
else
|
|
|
|
o->engine_data = ENFN->image_load(ENC, efl_file_get(eo_obj), o->cur->key, &load_error, &lo);
|
2020-03-10 06:27:30 -07:00
|
|
|
|
|
|
|
if (_evas_image_animated_get(eo_obj))
|
|
|
|
{
|
|
|
|
frame_index = ENFN->image_animated_frame_get(ENC, o->engine_data);
|
|
|
|
_evas_image_animated_frame_set(eo_obj, frame_index);
|
|
|
|
}
|
|
|
|
|
2019-03-04 10:36:57 -08:00
|
|
|
o->load_error = _evas_load_error_to_efl_gfx_image_load_error(load_error);
|
2016-03-21 04:15:20 -07:00
|
|
|
o->buffer_data_set = EINA_FALSE;
|
2016-03-16 22:14:06 -07:00
|
|
|
_evas_image_done_set(eo_obj, obj, o);
|
2017-05-23 23:07:21 -07:00
|
|
|
o->file_size.w = o->cur->image.w;
|
|
|
|
o->file_size.h = o->cur->image.h;
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2020-02-26 06:41:14 -08:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_canvas_image_efl_file_loaded_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
|
|
|
if (!o->skip_head)
|
|
|
|
return efl_file_loaded_get(efl_super(eo_obj, MY_CLASS));
|
|
|
|
return !!o->cur->f;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static const Eina_File *
|
|
|
|
_efl_canvas_image_efl_file_mmap_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
|
|
|
if (!o->skip_head)
|
|
|
|
return efl_file_mmap_get(efl_super(eo_obj, MY_CLASS));
|
|
|
|
return o->cur->f;
|
|
|
|
}
|
|
|
|
|
2019-02-27 10:17:09 -08:00
|
|
|
EOLIAN static Eina_Error
|
|
|
|
_efl_canvas_image_efl_file_load(Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2019-02-27 10:17:09 -08:00
|
|
|
if (efl_file_loaded_get(eo_obj)) return 0;
|
2020-02-14 05:33:43 -08:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
|
|
|
Eina_Error err = 0;
|
|
|
|
|
|
|
|
if (!o->skip_head)
|
|
|
|
err = efl_file_load(efl_super(eo_obj, MY_CLASS));
|
2019-02-27 10:17:09 -08:00
|
|
|
if (err) return err;
|
2020-02-14 05:33:43 -08:00
|
|
|
if (_evas_image_file_load(eo_obj, o))
|
2019-02-27 10:17:09 -08:00
|
|
|
return 0;
|
|
|
|
return EFL_GFX_IMAGE_LOAD_ERROR_DOES_NOT_EXIST;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
2019-04-18 06:05:31 -07:00
|
|
|
EOLIAN static void
|
|
|
|
_efl_canvas_image_efl_file_unload(Eo *eo_obj, void *_pd EINA_UNUSED)
|
|
|
|
{
|
|
|
|
efl_file_unload(efl_super(eo_obj, MY_CLASS));
|
|
|
|
_evas_image_file_unload(eo_obj);
|
|
|
|
}
|
|
|
|
|
2019-02-27 10:17:09 -08:00
|
|
|
const Eina_File *
|
|
|
|
_evas_image_mmap_get(const Eo *eo_obj)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2019-02-27 10:17:09 -08:00
|
|
|
return o->cur->f;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
2019-02-27 10:17:09 -08:00
|
|
|
const char *
|
|
|
|
_evas_image_key_get(const Eo *eo_obj)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2019-02-27 10:17:09 -08:00
|
|
|
return o->cur->key;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
2019-02-27 10:17:09 -08:00
|
|
|
void
|
|
|
|
_efl_canvas_image_load_error_set(Eo *eo_obj EINA_UNUSED, Eina_Error err)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2019-02-27 10:17:09 -08:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
|
|
|
o->load_error = err;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
2016-03-21 19:13:55 -07:00
|
|
|
static void
|
|
|
|
_image_preload_internal(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool cancel)
|
|
|
|
{
|
|
|
|
if (!o->engine_data)
|
|
|
|
{
|
evas image: fix a bug in image preloading.
Summary:
Current preloading is too buggy since it's on thread-based.
This is a fundamental improvement to fix a bug.
The critical issue here is,
When preloading img object suddenly cancel its preloading,
the object possibly cannot render image next then because
renderer doesn't have any idea when async cancelling is
finished. Renderer just tries to render regardless of
image loading status, and this could occur no-texture(in gl case)
image object.
So, here improvement is, adding a notification for async cancelled
so that putting img objects to redraw images properly after their preloading is
cancelled.
The best scenario to reproduce this bug is this one.
Evas_Object *img2 = evas_object_image_filled_add(evas);
evas_object_image_file_set(img2, "test.jpg", NULL);
evas_object_image_preload(img2, EINA_FALSE);
evas_object_resize(img2, 200, 200);
evas_object_show(img2);
Evas_Object *img = evas_object_image_filled_add(evas);
evas_object_image_file_set(img, "test.jpg", NULL);
evas_object_image_preload(img, EINA_FALSE);
evas_object_move(img, 200, 200);
evas_object_resize(img, 200, 200);
evas_object_show(img);
evas_object_image_preload(img2, EINA_TRUE);
If you run this on gl backend, occasionally happens rendering fail.
Yet there other bugs on preloading feature....
@fix
Reviewers: #committers, raster
Subscribers: cedric, #reviewers, #committers, zmike
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D6919
2018-09-02 23:19:02 -07:00
|
|
|
o->preload = EVAS_IMAGE_PRELOADING;
|
2016-03-21 19:13:55 -07:00
|
|
|
evas_object_inform_call_image_preloaded(eo_obj);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// FIXME: if already busy preloading, then dont request again until
|
|
|
|
// preload done
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
2016-03-21 19:13:55 -07:00
|
|
|
if (cancel)
|
|
|
|
{
|
evas image: fix a bug in image preloading.
Summary:
Current preloading is too buggy since it's on thread-based.
This is a fundamental improvement to fix a bug.
The critical issue here is,
When preloading img object suddenly cancel its preloading,
the object possibly cannot render image next then because
renderer doesn't have any idea when async cancelling is
finished. Renderer just tries to render regardless of
image loading status, and this could occur no-texture(in gl case)
image object.
So, here improvement is, adding a notification for async cancelled
so that putting img objects to redraw images properly after their preloading is
cancelled.
The best scenario to reproduce this bug is this one.
Evas_Object *img2 = evas_object_image_filled_add(evas);
evas_object_image_file_set(img2, "test.jpg", NULL);
evas_object_image_preload(img2, EINA_FALSE);
evas_object_resize(img2, 200, 200);
evas_object_show(img2);
Evas_Object *img = evas_object_image_filled_add(evas);
evas_object_image_file_set(img, "test.jpg", NULL);
evas_object_image_preload(img, EINA_FALSE);
evas_object_move(img, 200, 200);
evas_object_resize(img, 200, 200);
evas_object_show(img);
evas_object_image_preload(img2, EINA_TRUE);
If you run this on gl backend, occasionally happens rendering fail.
Yet there other bugs on preloading feature....
@fix
Reviewers: #committers, raster
Subscribers: cedric, #reviewers, #committers, zmike
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D6919
2018-09-02 23:19:02 -07:00
|
|
|
if (o->preload & EVAS_IMAGE_PRELOADING)
|
2016-03-21 19:13:55 -07:00
|
|
|
{
|
evas image: fix a bug in image preloading.
Summary:
Current preloading is too buggy since it's on thread-based.
This is a fundamental improvement to fix a bug.
The critical issue here is,
When preloading img object suddenly cancel its preloading,
the object possibly cannot render image next then because
renderer doesn't have any idea when async cancelling is
finished. Renderer just tries to render regardless of
image loading status, and this could occur no-texture(in gl case)
image object.
So, here improvement is, adding a notification for async cancelled
so that putting img objects to redraw images properly after their preloading is
cancelled.
The best scenario to reproduce this bug is this one.
Evas_Object *img2 = evas_object_image_filled_add(evas);
evas_object_image_file_set(img2, "test.jpg", NULL);
evas_object_image_preload(img2, EINA_FALSE);
evas_object_resize(img2, 200, 200);
evas_object_show(img2);
Evas_Object *img = evas_object_image_filled_add(evas);
evas_object_image_file_set(img, "test.jpg", NULL);
evas_object_image_preload(img, EINA_FALSE);
evas_object_move(img, 200, 200);
evas_object_resize(img, 200, 200);
evas_object_show(img);
evas_object_image_preload(img2, EINA_TRUE);
If you run this on gl backend, occasionally happens rendering fail.
Yet there other bugs on preloading feature....
@fix
Reviewers: #committers, raster
Subscribers: cedric, #reviewers, #committers, zmike
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D6919
2018-09-02 23:19:02 -07:00
|
|
|
o->preload |= EVAS_IMAGE_PRELOAD_CANCEL;
|
|
|
|
ENFN->image_data_preload_cancel(ENC, o->engine_data, eo_obj, EINA_TRUE);
|
2016-03-21 19:13:55 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-10-11 22:27:35 -07:00
|
|
|
if (o->preload != EVAS_IMAGE_PRELOADING)
|
2016-03-21 19:13:55 -07:00
|
|
|
{
|
evas image: fix a bug in image preloading.
Summary:
Current preloading is too buggy since it's on thread-based.
This is a fundamental improvement to fix a bug.
The critical issue here is,
When preloading img object suddenly cancel its preloading,
the object possibly cannot render image next then because
renderer doesn't have any idea when async cancelling is
finished. Renderer just tries to render regardless of
image loading status, and this could occur no-texture(in gl case)
image object.
So, here improvement is, adding a notification for async cancelled
so that putting img objects to redraw images properly after their preloading is
cancelled.
The best scenario to reproduce this bug is this one.
Evas_Object *img2 = evas_object_image_filled_add(evas);
evas_object_image_file_set(img2, "test.jpg", NULL);
evas_object_image_preload(img2, EINA_FALSE);
evas_object_resize(img2, 200, 200);
evas_object_show(img2);
Evas_Object *img = evas_object_image_filled_add(evas);
evas_object_image_file_set(img, "test.jpg", NULL);
evas_object_image_preload(img, EINA_FALSE);
evas_object_move(img, 200, 200);
evas_object_resize(img, 200, 200);
evas_object_show(img);
evas_object_image_preload(img2, EINA_TRUE);
If you run this on gl backend, occasionally happens rendering fail.
Yet there other bugs on preloading feature....
@fix
Reviewers: #committers, raster
Subscribers: cedric, #reviewers, #committers, zmike
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D6919
2018-09-02 23:19:02 -07:00
|
|
|
o->preload = EVAS_IMAGE_PRELOADING;
|
2017-08-25 10:51:10 -07:00
|
|
|
ENFN->image_data_preload_request(ENC, o->engine_data, eo_obj);
|
2016-03-21 19:13:55 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-16 22:14:06 -07:00
|
|
|
void
|
|
|
|
_evas_image_load_async_start(Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
evas_object_async_block(obj);
|
|
|
|
_image_preload_internal(eo_obj, o, EINA_FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_async_start(Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_load_async_start(eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_evas_image_load_async_cancel(Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
evas_object_async_block(obj);
|
|
|
|
_image_preload_internal(eo_obj, o, EINA_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_async_cancel(Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_load_async_cancel(eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_evas_image_load_dpi_set(Eo *eo_obj, double dpi)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2017-01-06 09:57:46 -08:00
|
|
|
if (EINA_DBL_EQ(dpi, o->load_opts->dpi)) return;
|
2016-03-16 22:14:06 -07:00
|
|
|
evas_object_async_block(obj);
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low)
|
|
|
|
low->dpi = dpi;
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_END(o, low);
|
|
|
|
|
2017-10-04 21:01:35 -07:00
|
|
|
if (o->cur->f)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_unload(eo_obj, obj, 0);
|
|
|
|
evas_object_inform_call_image_unloaded(eo_obj);
|
|
|
|
_evas_image_load(eo_obj, obj, o);
|
|
|
|
o->changed = EINA_TRUE;
|
|
|
|
evas_object_change(eo_obj, obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_dpi_set(Eo *eo_obj, void *_pd EINA_UNUSED, double dpi)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_load_dpi_set(eo_obj, dpi);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
_evas_image_load_dpi_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
return o->load_opts->dpi;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static double
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_dpi_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_load_dpi_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_evas_image_load_size_set(Eo *eo_obj, int w, int h)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
if ((o->load_opts->w == w) && (o->load_opts->h == h)) return;
|
|
|
|
evas_object_async_block(obj);
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low)
|
|
|
|
{
|
|
|
|
low->w = w;
|
|
|
|
low->h = h;
|
|
|
|
}
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_END(o, low);
|
|
|
|
|
2017-10-04 21:01:35 -07:00
|
|
|
if (o->cur->f)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_unload(eo_obj, obj, 0);
|
|
|
|
evas_object_inform_call_image_unloaded(eo_obj);
|
|
|
|
_evas_image_load(eo_obj, obj, o);
|
|
|
|
o->changed = EINA_TRUE;
|
|
|
|
evas_object_change(eo_obj, obj);
|
|
|
|
}
|
|
|
|
o->proxyerror = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_size_set(Eo *eo_obj, void *_pd EINA_UNUSED, Eina_Size2D sz)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2017-09-18 04:56:45 -07:00
|
|
|
_evas_image_load_size_set(eo_obj, sz.w, sz.h);
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_evas_image_load_size_get(const Eo *eo_obj, int *w, int *h)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
if (w) *w = o->load_opts->w;
|
|
|
|
if (h) *h = o->load_opts->h;
|
|
|
|
}
|
|
|
|
|
2017-09-18 04:56:45 -07:00
|
|
|
EOLIAN static Eina_Size2D
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_size_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2017-09-18 04:56:45 -07:00
|
|
|
Eina_Size2D sz;
|
|
|
|
_evas_image_load_size_get(eo_obj, &sz.w, &sz.h);
|
|
|
|
return sz;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_evas_image_load_scale_down_set(Eo *eo_obj, int scale_down)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
if (o->load_opts->scale_down_by == scale_down) return;
|
|
|
|
evas_object_async_block(obj);
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low)
|
|
|
|
low->scale_down_by = scale_down;
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_END(o, low);
|
|
|
|
|
2017-10-04 21:01:35 -07:00
|
|
|
if (o->cur->f)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_unload(eo_obj, obj, 0);
|
|
|
|
evas_object_inform_call_image_unloaded(eo_obj);
|
|
|
|
_evas_image_load(eo_obj, obj, o);
|
|
|
|
o->changed = EINA_TRUE;
|
|
|
|
evas_object_change(eo_obj, obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_scale_down_set(Eo *eo_obj, void *_pd EINA_UNUSED, int scale_down)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_load_scale_down_set(eo_obj, scale_down);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
_evas_image_load_scale_down_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
return o->load_opts->scale_down_by;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static int
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_scale_down_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_load_scale_down_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
2017-01-01 05:15:24 -08:00
|
|
|
void
|
|
|
|
_evas_image_load_head_skip_set(const Eo *eo_obj, Eina_Bool skip)
|
|
|
|
{
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
|
|
|
o->skip_head = skip;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-04-19 04:26:59 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_skip_header_set(Eo *eo_obj, void *_pd EINA_UNUSED, Eina_Bool skip)
|
2017-01-01 05:15:24 -08:00
|
|
|
{
|
|
|
|
_evas_image_load_head_skip_set(eo_obj, skip);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
_evas_image_load_head_skip_get(const Eo *eo_obj)
|
|
|
|
{
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
|
|
|
return o->skip_head;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2018-04-19 04:26:59 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_skip_header_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2017-01-01 05:15:24 -08:00
|
|
|
{
|
|
|
|
return _evas_image_load_head_skip_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
2016-03-16 22:14:06 -07:00
|
|
|
void
|
|
|
|
_evas_image_load_region_set(Eo *eo_obj, int x, int y, int w, int h)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
if ((o->load_opts->region.x == x) && (o->load_opts->region.y == y) &&
|
|
|
|
(o->load_opts->region.w == w) && (o->load_opts->region.h == h)) return;
|
|
|
|
evas_object_async_block(obj);
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low)
|
|
|
|
{
|
|
|
|
low->region.x = x;
|
|
|
|
low->region.y = y;
|
|
|
|
low->region.w = w;
|
|
|
|
low->region.h = h;
|
|
|
|
}
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_END(o, low);
|
|
|
|
|
2017-10-04 21:01:35 -07:00
|
|
|
if (o->cur->f)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_unload(eo_obj, obj, 0);
|
|
|
|
evas_object_inform_call_image_unloaded(eo_obj);
|
|
|
|
_evas_image_load(eo_obj, obj, o);
|
|
|
|
o->changed = EINA_TRUE;
|
|
|
|
evas_object_change(eo_obj, obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_region_set(Eo *eo_obj, void *_pd EINA_UNUSED, Eina_Rect region)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2017-09-18 05:01:19 -07:00
|
|
|
_evas_image_load_region_set(eo_obj, region.x, region.y, region.w, region.h);
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_evas_image_load_region_get(const Eo *eo_obj, int *x, int *y, int *w, int *h)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
if (x) *x = o->load_opts->region.x;
|
|
|
|
if (y) *y = o->load_opts->region.y;
|
|
|
|
if (w) *w = o->load_opts->region.w;
|
|
|
|
if (h) *h = o->load_opts->region.h;
|
|
|
|
}
|
|
|
|
|
2017-09-18 05:01:19 -07:00
|
|
|
EOLIAN static Eina_Rect
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_region_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2017-09-18 05:01:19 -07:00
|
|
|
Eina_Rect r;
|
|
|
|
_evas_image_load_region_get(eo_obj, &r.x, &r.y, &r.w, &r.h);
|
|
|
|
return r;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_evas_image_load_orientation_set(Eo *eo_obj, Eina_Bool enable)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
if (o->load_opts->orientation == !!enable) return;
|
|
|
|
evas_object_async_block(obj);
|
|
|
|
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_BEGIN(o, low)
|
|
|
|
low->orientation = !!enable;
|
|
|
|
EINA_COW_LOAD_OPTS_WRITE_END(o, low);
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static void
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_orientation_set(Eo *eo_obj, void *_pd EINA_UNUSED, Eina_Bool enable)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
_evas_image_load_orientation_set(eo_obj, enable);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
_evas_image_load_orientation_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2016-03-21 04:15:20 -07:00
|
|
|
return o->load_opts->orientation;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_orientation_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_load_orientation_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool
|
|
|
|
_evas_image_load_region_support_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2017-08-25 10:51:10 -07:00
|
|
|
return ENFN->image_can_region_get(ENC, o->engine_data);
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_image_load_controller_load_region_support_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_load_region_support_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* animated feature */
|
|
|
|
Eina_Bool
|
|
|
|
_evas_image_animated_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
if (!ENFN->image_animated_get)
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
2017-08-25 10:50:40 -07:00
|
|
|
return ENFN->image_animated_get(ENC, o->engine_data);
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2019-01-29 02:16:34 -08:00
|
|
|
_efl_canvas_image_efl_gfx_frame_controller_animated_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_animated_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
_evas_image_animated_frame_count_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2016-03-21 04:15:20 -07:00
|
|
|
if (!ENFN->image_animated_frame_count_get ||
|
|
|
|
!evas_object_image_animated_get(eo_obj))
|
|
|
|
return -1;
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
2017-08-25 10:50:40 -07:00
|
|
|
return ENFN->image_animated_frame_count_get(ENC, o->engine_data);
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static int
|
2019-01-29 02:16:34 -08:00
|
|
|
_efl_canvas_image_efl_gfx_frame_controller_frame_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_animated_frame_count_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
2019-01-29 02:16:34 -08:00
|
|
|
Efl_Gfx_Frame_Controller_Loop_Hint
|
2016-03-16 22:14:06 -07:00
|
|
|
_evas_image_animated_loop_type_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2016-03-21 04:15:20 -07:00
|
|
|
if (!ENFN->image_animated_loop_type_get ||
|
|
|
|
!evas_object_image_animated_get(eo_obj))
|
2019-01-29 02:16:34 -08:00
|
|
|
return EFL_GFX_FRAME_CONTROLLER_LOOP_HINT_NONE;
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2019-01-29 02:16:34 -08:00
|
|
|
return (Efl_Gfx_Frame_Controller_Loop_Hint) ENFN->image_animated_loop_type_get(ENC, o->engine_data);
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
2019-01-29 02:16:34 -08:00
|
|
|
EOLIAN static Efl_Gfx_Frame_Controller_Loop_Hint
|
|
|
|
_efl_canvas_image_efl_gfx_frame_controller_loop_type_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_animated_loop_type_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
_evas_image_animated_loop_count_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2016-03-21 04:15:20 -07:00
|
|
|
if (!ENFN->image_animated_loop_count_get ||
|
|
|
|
!evas_object_image_animated_get(eo_obj))
|
|
|
|
return -1;
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2017-08-25 10:50:40 -07:00
|
|
|
return ENFN->image_animated_loop_count_get(ENC, o->engine_data);
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static int
|
2019-01-29 02:16:34 -08:00
|
|
|
_efl_canvas_image_efl_gfx_frame_controller_loop_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_animated_loop_count_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
_evas_image_animated_frame_duration_get(const Eo *eo_obj, int start_frame, int frame_num)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
int frame_count = 0;
|
|
|
|
|
2016-03-21 04:15:20 -07:00
|
|
|
if (!ENFN->image_animated_frame_count_get ||
|
|
|
|
!ENFN->image_animated_frame_duration_get)
|
|
|
|
return -1.0;
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2017-08-25 10:50:40 -07:00
|
|
|
frame_count = ENFN->image_animated_frame_count_get(ENC, o->engine_data);
|
2016-03-21 04:15:20 -07:00
|
|
|
if ((start_frame + frame_num) > frame_count)
|
|
|
|
return -1.0;
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2017-08-25 10:50:40 -07:00
|
|
|
return ENFN->image_animated_frame_duration_get(ENC, o->engine_data, start_frame, frame_num);
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static double
|
2019-01-29 02:16:34 -08:00
|
|
|
_efl_canvas_image_efl_gfx_frame_controller_frame_duration_get(const Eo *eo_obj, void *_pd EINA_UNUSED, int start_frame, int frame_num)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_animated_frame_duration_get(eo_obj, start_frame, frame_num);
|
|
|
|
}
|
|
|
|
|
2019-11-25 17:54:37 -08:00
|
|
|
Eina_Bool _efl_canvas_image_efl_gfx_frame_controller_sector_set(Eo *obj EINA_UNUSED,
|
|
|
|
void *_pd EINA_UNUSED,
|
|
|
|
const char *name EINA_UNUSED,
|
|
|
|
int startframe EINA_UNUSED,
|
|
|
|
int endframe EINA_UNUSED)
|
|
|
|
{
|
|
|
|
// TODO: We need to implement the feature to section playback of image animation.
|
|
|
|
ERR("efl_gfx_frame_controller_sector_set not implemented for efl_canvas_image yet.");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
Eina_Bool _efl_canvas_image_efl_gfx_frame_controller_sector_get(const Eo *obj EINA_UNUSED,
|
|
|
|
void *_pd EINA_UNUSED,
|
|
|
|
const char *name EINA_UNUSED,
|
|
|
|
int *startframe EINA_UNUSED,
|
|
|
|
int *endframe EINA_UNUSED)
|
|
|
|
{
|
|
|
|
// TODO: We need to implement the feature to section playback of image animation.
|
|
|
|
ERR("efl_gfx_frame_controller_sector_get not implemented for efl_canvas_image yet.");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2016-03-16 22:14:06 -07:00
|
|
|
Eina_Bool
|
|
|
|
_evas_image_animated_frame_set(Eo *eo_obj, int frame_index)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
int frame_count = 0;
|
|
|
|
|
2017-10-04 21:01:35 -07:00
|
|
|
if (!o->cur->f) return EINA_FALSE;
|
2016-03-16 22:14:06 -07:00
|
|
|
if (o->cur->frame == frame_index) return EINA_TRUE;
|
|
|
|
|
|
|
|
if (!evas_object_image_animated_get(eo_obj)) return EINA_FALSE;
|
|
|
|
evas_object_async_block(obj);
|
|
|
|
frame_count = evas_object_image_animated_frame_count_get(eo_obj);
|
|
|
|
|
|
|
|
/* limit the size of frame to FRAME_MAX */
|
|
|
|
if ((frame_count > FRAME_MAX) || (frame_count < 0) || (frame_index > frame_count))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
if (!ENFN->image_animated_frame_set) return EINA_FALSE;
|
2017-08-25 10:50:40 -07:00
|
|
|
ENFN->image_animated_frame_set(ENC, o->engine_data, frame_index);
|
|
|
|
// if (!ENFN->image_animated_frame_set(ENC, o->engine_data, frame_index)) return;
|
2016-03-16 22:14:06 -07:00
|
|
|
|
|
|
|
EINA_COW_WRITE_BEGIN(evas_object_image_state_cow, o->prev, Evas_Object_Image_State, prev_write)
|
|
|
|
prev_write->frame = o->cur->frame;
|
|
|
|
EINA_COW_WRITE_END(evas_object_image_state_cow, o->prev, prev_write);
|
|
|
|
|
|
|
|
EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
|
2017-08-25 10:50:40 -07:00
|
|
|
state_write->frame = frame_index;
|
2016-03-16 22:14:06 -07:00
|
|
|
EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
|
|
|
|
|
|
|
|
o->changed = EINA_TRUE;
|
|
|
|
evas_object_change(eo_obj, obj);
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2019-01-29 02:16:34 -08:00
|
|
|
_efl_canvas_image_efl_gfx_frame_controller_frame_set(Eo *eo_obj, void *_pd EINA_UNUSED, int frame_index)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_animated_frame_set(eo_obj, frame_index);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
_evas_image_animated_frame_get(const Eo *eo_obj)
|
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-16 22:14:06 -07:00
|
|
|
|
2017-10-04 21:01:35 -07:00
|
|
|
if (!o->cur->f) return EINA_FALSE;
|
2016-03-16 22:14:06 -07:00
|
|
|
if (!evas_object_image_animated_get(eo_obj)) return EINA_FALSE;
|
|
|
|
return o->cur->frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static int
|
2019-01-29 02:16:34 -08:00
|
|
|
_efl_canvas_image_efl_gfx_frame_controller_frame_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
|
|
|
return _evas_image_animated_frame_get(eo_obj);
|
|
|
|
}
|
|
|
|
|
2017-09-18 03:30:30 -07:00
|
|
|
EOLIAN static Eina_Size2D
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_buffer_buffer_size_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
|
2016-03-21 04:15:20 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-21 04:15:20 -07:00
|
|
|
|
2017-09-18 03:30:30 -07:00
|
|
|
return EINA_SIZE2D(o->cur->image.w, o->cur->image.h);
|
2016-03-21 04:15:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2016-03-25 00:44:25 -07:00
|
|
|
_image_pixels_set(Evas_Object_Protected_Data *obj,
|
2016-09-01 05:46:42 -07:00
|
|
|
Evas_Image_Data *o, const Eina_Slice *slice,
|
|
|
|
int w, int h, int stride, Efl_Gfx_Colorspace cspace, int plane,
|
|
|
|
Eina_Bool copy)
|
2016-03-21 04:15:20 -07:00
|
|
|
{
|
2016-09-02 01:41:36 -07:00
|
|
|
Eina_Bool resized = EINA_FALSE, ret = EINA_FALSE;
|
2016-03-21 04:15:20 -07:00
|
|
|
int int_stride = 0;
|
|
|
|
|
|
|
|
// FIXME: buffer border support is not implemented
|
|
|
|
|
2016-03-28 23:07:20 -07:00
|
|
|
if (ENFN->image_data_maps_get)
|
2016-03-21 19:13:55 -07:00
|
|
|
{
|
2017-08-25 10:51:10 -07:00
|
|
|
if (ENFN->image_data_maps_get(ENC, o->engine_data, NULL) > 0)
|
2016-03-28 23:07:20 -07:00
|
|
|
{
|
|
|
|
ERR("can not set pixels when there are open memory maps");
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
2016-03-21 19:13:55 -07:00
|
|
|
}
|
|
|
|
|
2016-03-21 04:15:20 -07:00
|
|
|
if (o->pixels_checked_out)
|
|
|
|
{
|
|
|
|
// is there anything to do?
|
2016-09-02 01:41:36 -07:00
|
|
|
ERR("Calling efl_gfx_buffer_%s_set after evas_object_image_data_get is "
|
|
|
|
"not valid.", copy ? "copy" : "managed");
|
|
|
|
return EINA_FALSE;
|
2016-03-21 04:15:20 -07:00
|
|
|
}
|
|
|
|
|
2016-09-02 01:41:36 -07:00
|
|
|
if (o->engine_data)
|
2016-09-01 05:46:42 -07:00
|
|
|
{
|
2016-09-02 01:41:36 -07:00
|
|
|
Evas_Colorspace ics;
|
|
|
|
int iw = 0, ih = 0;
|
|
|
|
Eina_Bool alpha;
|
|
|
|
|
2017-08-25 10:51:10 -07:00
|
|
|
ENFN->image_size_get(ENC, o->engine_data, &iw, &ih);
|
|
|
|
ics = ENFN->image_colorspace_get(ENC, o->engine_data);
|
|
|
|
alpha = ENFN->image_alpha_get(ENC, o->engine_data);
|
2019-03-07 13:06:03 -08:00
|
|
|
if ((w != iw) || (h != ih) || (ics != (Evas_Colorspace)cspace) || (alpha != o->cur->has_alpha))
|
2016-09-01 05:46:42 -07:00
|
|
|
{
|
2017-08-25 10:51:10 -07:00
|
|
|
ENFN->image_free(ENC, o->engine_data);
|
2016-09-02 01:41:36 -07:00
|
|
|
o->engine_data = NULL;
|
2016-09-01 05:46:42 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-04 21:53:00 -07:00
|
|
|
if (!slice || !slice->mem)
|
2016-03-21 04:15:20 -07:00
|
|
|
{
|
2016-09-04 21:53:00 -07:00
|
|
|
// note: we release all planes at once
|
2016-09-02 01:41:36 -07:00
|
|
|
if (o->engine_data)
|
2017-08-25 10:51:10 -07:00
|
|
|
ENFN->image_free(ENC, o->engine_data);
|
2020-08-25 03:24:19 -07:00
|
|
|
o->engine_data = ENFN->image_new_from_copied_data(ENC, w, h, NULL, o->cur->has_alpha, (Evas_Colorspace)cspace);
|
2016-03-21 04:15:20 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-09-04 21:53:00 -07:00
|
|
|
o->buffer_data_set = EINA_TRUE;
|
2017-08-25 10:51:10 -07:00
|
|
|
o->engine_data = ENFN->image_data_slice_add(ENC, o->engine_data,
|
2016-09-04 21:53:00 -07:00
|
|
|
slice, copy, w, h, stride,
|
2020-08-25 03:24:19 -07:00
|
|
|
(Evas_Colorspace)cspace, plane, o->cur->has_alpha);
|
2016-03-21 04:15:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!o->engine_data)
|
|
|
|
{
|
2016-09-02 01:41:36 -07:00
|
|
|
ERR("Failed to create internal image");
|
2016-03-21 04:15:20 -07:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2016-09-04 21:53:00 -07:00
|
|
|
if ((o->cur->image.w != w) || (o->cur->image.h != h))
|
|
|
|
resized = EINA_TRUE;
|
|
|
|
|
2016-03-21 04:15:20 -07:00
|
|
|
if (ENFN->image_scale_hint_set)
|
2017-08-25 10:51:10 -07:00
|
|
|
ENFN->image_scale_hint_set(ENC, o->engine_data, o->scale_hint);
|
2016-03-21 04:15:20 -07:00
|
|
|
|
|
|
|
if (ENFN->image_content_hint_set)
|
2017-08-25 10:51:10 -07:00
|
|
|
ENFN->image_content_hint_set(ENC, o->engine_data, o->content_hint);
|
2016-03-21 04:15:20 -07:00
|
|
|
|
|
|
|
if (ENFN->image_stride_get)
|
2017-08-25 10:51:10 -07:00
|
|
|
ENFN->image_stride_get(ENC, o->engine_data, &int_stride);
|
2016-03-21 04:15:20 -07:00
|
|
|
|
2017-10-04 21:01:35 -07:00
|
|
|
if (resized || o->cur->f || o->cur->key ||
|
2019-03-07 13:06:03 -08:00
|
|
|
(o->cur->image.stride != int_stride) || (cspace != (Efl_Gfx_Colorspace)o->cur->cspace))
|
2016-03-21 04:15:20 -07:00
|
|
|
{
|
|
|
|
EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, cur)
|
|
|
|
{
|
2017-10-04 21:01:35 -07:00
|
|
|
cur->f = NULL;
|
2016-03-21 04:15:20 -07:00
|
|
|
cur->key = NULL;
|
2020-08-25 03:24:19 -07:00
|
|
|
cur->cspace = (Evas_Colorspace)cspace;
|
2016-03-21 04:15:20 -07:00
|
|
|
cur->image.w = w;
|
|
|
|
cur->image.h = h;
|
|
|
|
cur->image.stride = int_stride;
|
|
|
|
}
|
|
|
|
EINA_COW_IMAGE_STATE_WRITE_END(o, cur)
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = EINA_TRUE;
|
|
|
|
|
|
|
|
end:
|
|
|
|
o->written = EINA_TRUE;
|
|
|
|
if (resized)
|
|
|
|
evas_object_inform_call_image_resize(obj->object);
|
|
|
|
|
2017-09-18 03:30:30 -07:00
|
|
|
efl_gfx_buffer_update_add(obj->object, NULL);
|
2016-03-21 04:15:20 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2016-09-01 05:46:42 -07:00
|
|
|
_efl_canvas_image_efl_gfx_buffer_buffer_managed_set(Eo *eo_obj, void *_pd EINA_UNUSED,
|
|
|
|
const Eina_Slice *slice,
|
2017-09-18 03:30:30 -07:00
|
|
|
Eina_Size2D size, int stride,
|
2016-09-01 05:46:42 -07:00
|
|
|
Efl_Gfx_Colorspace cspace,
|
|
|
|
int plane)
|
2016-03-21 04:15:20 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-21 04:15:20 -07:00
|
|
|
|
2017-09-18 03:30:30 -07:00
|
|
|
return _image_pixels_set(obj, o, slice, size.w, size.h, stride, cspace, plane, EINA_FALSE);
|
2016-03-21 04:15:20 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
EOLIAN static Eina_Bool
|
2016-03-25 00:44:25 -07:00
|
|
|
_efl_canvas_image_efl_gfx_buffer_buffer_copy_set(Eo *eo_obj, void *_pd EINA_UNUSED,
|
2017-09-18 03:30:30 -07:00
|
|
|
const Eina_Slice *slice, Eina_Size2D size, int stride,
|
2016-09-01 05:46:42 -07:00
|
|
|
Efl_Gfx_Colorspace cspace, int plane)
|
2016-03-21 04:15:20 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-21 04:15:20 -07:00
|
|
|
|
2017-09-18 03:30:30 -07:00
|
|
|
return _image_pixels_set(obj, o, slice, size.w, size.h, stride, cspace, plane, EINA_TRUE);
|
2016-03-21 04:15:20 -07:00
|
|
|
}
|
|
|
|
|
2017-09-18 03:59:11 -07:00
|
|
|
EOLIAN static Eina_Slice
|
2018-09-10 01:26:12 -07:00
|
|
|
_efl_canvas_image_efl_gfx_buffer_buffer_managed_get(Eo *eo_obj, void *_pd EINA_UNUSED,
|
2017-09-18 03:59:11 -07:00
|
|
|
int plane)
|
2016-03-21 04:15:20 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-09-01 05:46:42 -07:00
|
|
|
Evas_Colorspace cspace = EVAS_COLORSPACE_ARGB8888;
|
2017-09-18 03:59:11 -07:00
|
|
|
Eina_Slice slice = {};
|
2016-09-01 05:46:42 -07:00
|
|
|
|
2016-09-02 01:55:33 -07:00
|
|
|
if (!o->buffer_data_set || !o->engine_data || !ENFN->image_data_direct_get)
|
2017-09-18 03:59:11 -07:00
|
|
|
return slice;
|
2016-09-01 05:46:42 -07:00
|
|
|
|
2019-05-02 04:50:24 -07:00
|
|
|
ENFN->image_data_direct_get(ENC, o->engine_data, plane, &slice, &cspace, EINA_FALSE, NULL);
|
|
|
|
|
2017-09-18 03:59:11 -07:00
|
|
|
return slice;
|
2016-03-21 04:15:20 -07:00
|
|
|
}
|
|
|
|
|
2017-09-18 03:59:11 -07:00
|
|
|
EOLIAN static Eina_Rw_Slice
|
2016-03-25 00:44:25 -07:00
|
|
|
_efl_canvas_image_efl_gfx_buffer_buffer_map(Eo *eo_obj, void *_pd EINA_UNUSED,
|
2016-03-21 19:13:55 -07:00
|
|
|
Efl_Gfx_Buffer_Access_Mode mode,
|
2017-09-18 03:30:30 -07:00
|
|
|
const Eina_Rect *region,
|
2016-09-01 05:46:42 -07:00
|
|
|
Efl_Gfx_Colorspace cspace,
|
|
|
|
int plane, int *stride)
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-09-01 05:04:37 -07:00
|
|
|
int s = 0, width = 0, height = 0;
|
2017-09-18 03:59:11 -07:00
|
|
|
Eina_Rw_Slice slice = {};
|
2017-09-18 03:30:30 -07:00
|
|
|
int x, y, w, h;
|
2016-09-01 05:46:42 -07:00
|
|
|
|
2016-03-21 19:13:55 -07:00
|
|
|
if (!ENFN->image_data_map)
|
|
|
|
goto end; // not implemented
|
|
|
|
|
2016-03-25 01:46:41 -07:00
|
|
|
if (o->engine_data)
|
2017-08-25 10:51:10 -07:00
|
|
|
ENFN->image_size_get(ENC, o->engine_data, &width, &height);
|
2016-03-25 01:46:41 -07:00
|
|
|
|
|
|
|
if (!o->engine_data || !width || !height)
|
2016-03-22 21:33:08 -07:00
|
|
|
{
|
2016-03-25 01:46:41 -07:00
|
|
|
// TODO: Create a map_surface and draw there. Maybe. This could
|
|
|
|
// depend on the flags (eg. add a "force render" flag).
|
|
|
|
WRN("This image image has no data available");
|
2016-03-22 21:33:08 -07:00
|
|
|
goto end;
|
|
|
|
}
|
2016-03-21 19:13:55 -07:00
|
|
|
|
2017-09-18 03:30:30 -07:00
|
|
|
if (region)
|
|
|
|
{
|
|
|
|
x = region->x;
|
|
|
|
y = region->y;
|
|
|
|
w = region->w;
|
|
|
|
h = region->h;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
x = y = 0;
|
|
|
|
w = width;
|
|
|
|
h = height;
|
|
|
|
}
|
2016-03-25 00:44:25 -07:00
|
|
|
|
2017-09-18 03:30:30 -07:00
|
|
|
if ((x < 0) || (y < 0) || (w <= 0) || (h <= 0) || ((x + w) > width) || ((y + h) > height))
|
2016-03-16 22:14:06 -07:00
|
|
|
{
|
2016-03-21 19:13:55 -07:00
|
|
|
ERR("Invalid map dimensions: %dx%d +%d,%d. Image is %dx%d.",
|
2016-03-25 01:46:41 -07:00
|
|
|
w, h, x, y, width, height);
|
2016-03-21 19:13:55 -07:00
|
|
|
goto end;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
2016-03-21 19:13:55 -07:00
|
|
|
|
2020-08-25 03:24:19 -07:00
|
|
|
if (ENFN->image_data_map(ENC, &o->engine_data, &slice, &s, x, y, w, h, (Evas_Colorspace)cspace, mode, plane))
|
2016-09-01 05:04:37 -07:00
|
|
|
{
|
2016-09-01 05:46:42 -07:00
|
|
|
DBG("map(%p, %d,%d %dx%d plane:%d) -> " EINA_SLICE_FMT,
|
2017-09-18 03:59:11 -07:00
|
|
|
eo_obj, x, y, w, h, plane, EINA_SLICE_PRINT(slice));
|
2016-09-01 05:04:37 -07:00
|
|
|
}
|
2016-09-01 05:46:42 -07:00
|
|
|
else DBG("map(%p, %d,%d %dx%d plane:%d) -> (null)", eo_obj, x, y, w, h, plane);
|
2016-03-21 19:13:55 -07:00
|
|
|
|
|
|
|
end:
|
2016-03-25 01:46:41 -07:00
|
|
|
if (stride) *stride = s;
|
2017-09-18 03:59:11 -07:00
|
|
|
return slice;
|
2016-03-21 19:13:55 -07:00
|
|
|
}
|
|
|
|
|
2016-03-25 00:44:25 -07:00
|
|
|
EOLIAN static Eina_Bool
|
|
|
|
_efl_canvas_image_efl_gfx_buffer_buffer_unmap(Eo *eo_obj, void *_pd EINA_UNUSED,
|
2017-09-18 03:59:11 -07:00
|
|
|
Eina_Rw_Slice slice)
|
2016-03-21 19:13:55 -07:00
|
|
|
{
|
2016-08-15 06:44:41 -07:00
|
|
|
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
|
|
|
|
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
|
2016-03-21 19:13:55 -07:00
|
|
|
|
2017-09-18 03:59:11 -07:00
|
|
|
if (!slice.mem || !ENFN->image_data_unmap || !o->engine_data)
|
2016-03-25 00:44:25 -07:00
|
|
|
return EINA_FALSE;
|
2016-03-21 19:13:55 -07:00
|
|
|
|
2017-09-18 03:59:11 -07:00
|
|
|
if (!ENFN->image_data_unmap(ENC, o->engine_data, &slice))
|
2016-03-25 00:44:25 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
2016-03-16 22:14:06 -07:00
|
|
|
}
|
|
|
|
|
2016-11-07 14:40:58 -08:00
|
|
|
EOLIAN static void
|
|
|
|
_efl_canvas_image_efl_object_dbg_info_get(Eo *obj, void *pd EINA_UNUSED, Efl_Dbg_Info *root)
|
|
|
|
{
|
|
|
|
efl_dbg_info_get(efl_super(obj, MY_CLASS), root);
|
|
|
|
|
2019-02-27 10:17:09 -08:00
|
|
|
if ((efl_gfx_image_load_error_get(obj) != EFL_GFX_IMAGE_LOAD_ERROR_NONE) &&
|
2017-07-23 02:36:44 -07:00
|
|
|
(root))
|
2016-11-07 14:40:58 -08:00
|
|
|
{
|
|
|
|
Efl_Dbg_Info *group = EFL_DBG_INFO_LIST_APPEND(root, MY_CLASS_NAME);
|
2019-03-04 10:36:57 -08:00
|
|
|
Eina_Error error = EFL_GFX_IMAGE_LOAD_ERROR_GENERIC;
|
2016-11-07 14:40:58 -08:00
|
|
|
|
2019-03-04 10:36:57 -08:00
|
|
|
error = efl_gfx_image_load_error_get(obj);
|
2016-11-07 14:40:58 -08:00
|
|
|
EFL_DBG_INFO_APPEND(group, "Load Error", EINA_VALUE_TYPE_STRING,
|
2019-03-04 10:36:57 -08:00
|
|
|
eina_error_msg_get(error));
|
2016-11-07 14:40:58 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-21 08:58:38 -07:00
|
|
|
#define EFL_CANVAS_IMAGE_EXTRA_OPS \
|
|
|
|
EFL_OBJECT_OP_FUNC(efl_dbg_info_get, _efl_canvas_image_efl_object_dbg_info_get)
|
2016-11-07 14:40:58 -08:00
|
|
|
|
2016-03-16 22:14:06 -07:00
|
|
|
#include "efl_canvas_image.eo.c"
|