enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

Efl.Gfx.Image* (From Efl.Image*) 

Ref https://phab.enlightenment.org/T6847

Reviewed-by: Cedric Bail <cedric@osg.samsung.com>
This commit is contained in:
Xavi Artigas 2018-04-19 13:26:59 +02:00 committed by Cedric Bail
parent 6073833b90
commit 5697f6e94b
45 changed files with 275 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Makefile_Efl.am
View File

@ -3,8 +3,8 @@ efl_eolian_legacy_files = \
lib/efl/interfaces/efl_gfx_fill.eo \
lib/efl/interfaces/efl_gfx_entity.eo \
lib/efl/interfaces/efl_gfx_color.eo \
lib/efl/interfaces/efl_image.eo \
lib/efl/interfaces/efl_image_animation_controller.eo \
lib/efl/interfaces/efl_gfx_image.eo \
lib/efl/interfaces/efl_gfx_image_animation_controller.eo \
lib/efl/interfaces/efl_input_device.eo \
lib/efl/interfaces/efl_ui_draggable.eo \
lib/efl/interfaces/efl_ui_clickable.eo \
@ -22,7 +22,7 @@ efl_eolian_files = \
lib/efl/interfaces/efl_control.eo \
lib/efl/interfaces/efl_duplicate.eo \
lib/efl/interfaces/efl_file.eo \
lib/efl/interfaces/efl_image_load_controller.eo \
lib/efl/interfaces/efl_gfx_image_load_controller.eo \
lib/efl/interfaces/efl_part.eo \
lib/efl/interfaces/efl_playable.eo \
lib/efl/interfaces/efl_player.eo \

16
src/bin/elementary/test_bg.c
View File

@ -317,7 +317,7 @@ _image_cb(void *data, const Efl_Event *ev)
{
efl_file_get(ev->object, &f, &k);
o = efl_add(EFL_UI_IMAGE_CLASS, win,
efl_image_scale_type_set(efl_added, EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_gfx_image_scale_type_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_file_set(efl_added, f, k)
);
efl_content_set(efl_part(win, "background"), o);
@ -375,7 +375,7 @@ _cb_radio_changed_scale_type(void *data, const Efl_Event *ev)
{
Evas_Object *o_bg = data;
efl_image_scale_type_set(o_bg, efl_ui_nstate_value_get(ev->object));
efl_gfx_image_scale_type_set(o_bg, efl_ui_nstate_value_get(ev->object));
}
static void
@ -432,14 +432,14 @@ test_bg_scale_type(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
efl_pack(box, efl_added));
rdg = rd = efl_add(EFL_UI_RADIO_CLASS, hbox,
efl_ui_radio_state_value_set(efl_added, EFL_IMAGE_SCALE_TYPE_FILL),
efl_ui_radio_state_value_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_FILL),
efl_text_set(efl_added, "Fill"),
efl_gfx_size_hint_weight_set(efl_added, EFL_GFX_SIZE_HINT_EXPAND, 0.0),
efl_event_callback_add(efl_added, EFL_UI_RADIO_EVENT_CHANGED, _cb_radio_changed_scale_type, o_bg),
efl_pack(hbox, efl_added));
rd = efl_add(EFL_UI_RADIO_CLASS, hbox,
efl_ui_radio_state_value_set(efl_added, EFL_IMAGE_SCALE_TYPE_FIT_INSIDE),
efl_ui_radio_state_value_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE),
efl_ui_radio_group_add(efl_added, rdg),
efl_text_set(efl_added, "Fit Inside"),
efl_gfx_size_hint_weight_set(efl_added, EFL_GFX_SIZE_HINT_EXPAND, 0.0),
@ -448,7 +448,7 @@ test_bg_scale_type(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
rd = efl_add(EFL_UI_RADIO_CLASS, hbox,
efl_ui_radio_state_value_set(efl_added, EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_ui_radio_state_value_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_ui_radio_group_add(efl_added, rdg),
efl_text_set(efl_added, "Fit Outside"),
efl_gfx_size_hint_weight_set(efl_added, EFL_GFX_SIZE_HINT_EXPAND, 0.0),
@ -456,7 +456,7 @@ test_bg_scale_type(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
efl_pack(hbox, efl_added));
rd = efl_add(EFL_UI_RADIO_CLASS, hbox,
efl_ui_radio_state_value_set(efl_added, EFL_IMAGE_SCALE_TYPE_NONE),
efl_ui_radio_state_value_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_NONE),
efl_ui_radio_group_add(efl_added, rdg),
efl_text_set(efl_added, "None"),
efl_gfx_size_hint_weight_set(efl_added, EFL_GFX_SIZE_HINT_EXPAND, 0.0),
@ -464,14 +464,14 @@ test_bg_scale_type(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *e
efl_pack(hbox, efl_added));
rd = efl_add(EFL_UI_RADIO_CLASS, hbox,
efl_ui_radio_state_value_set(efl_added, EFL_IMAGE_SCALE_TYPE_TILE),
efl_ui_radio_state_value_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_TILE),
efl_ui_radio_group_add(efl_added, rdg),
efl_text_set(efl_added, "Tile"),
efl_gfx_size_hint_weight_set(efl_added, EFL_GFX_SIZE_HINT_EXPAND, 0.0),
efl_event_callback_add(efl_added, EFL_UI_RADIO_EVENT_CHANGED, _cb_radio_changed_scale_type, o_bg),
efl_pack(hbox, efl_added));
efl_ui_nstate_value_set(rdg, EFL_IMAGE_SCALE_TYPE_FILL);
efl_ui_nstate_value_set(rdg, EFL_GFX_IMAGE_SCALE_TYPE_FILL);
efl_add(EFL_UI_CHECK_CLASS, hbox,
efl_text_set(efl_added, "Bg Color"),

2
src/bin/elementary/test_efl_gfx_map.c
View File

@ -54,7 +54,7 @@ test_efl_gfx_map(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
img = efl_add(EFL_UI_IMAGE_CLASS, win,
efl_gfx_size_hint_min_set(efl_added, EINA_SIZE2D(64, 64)),
efl_file_set(efl_added, buf, NULL));
efl_image_scale_type_set(img, EFL_IMAGE_SCALE_TYPE_FILL);
efl_gfx_image_scale_type_set(img, EFL_GFX_IMAGE_SCALE_TYPE_FILL);
evas_object_event_callback_add(img, EVAS_CALLBACK_RESIZE,
_image_resize_cb, NULL);

2
src/bin/elementary/test_evas_map.c
View File

@ -62,7 +62,7 @@ test_evas_map(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED,
img = efl_add(EFL_UI_IMAGE_CLASS, win,
efl_gfx_size_hint_min_set(efl_added, EINA_SIZE2D(64, 64)),
efl_file_set(efl_added, buf, NULL));
efl_image_scale_type_set(img, EFL_IMAGE_SCALE_TYPE_FILL);
efl_gfx_image_scale_type_set(img, EFL_GFX_IMAGE_SCALE_TYPE_FILL);
evas_object_event_callback_add(img, EVAS_CALLBACK_RESIZE,
_image_resize_cb, NULL);

16
src/bin/elementary/test_image.c
View File

@ -99,14 +99,14 @@ im_align_cb(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUS
}
static const struct {
Efl_Image_Scale_Type scale_type;
Efl_Gfx_Image_Scale_Type scale_type;
const char *name;
} images_scale_type[] = {
{ EFL_IMAGE_SCALE_TYPE_NONE, "None" },
{ EFL_IMAGE_SCALE_TYPE_FILL, "Fill" },
{ EFL_IMAGE_SCALE_TYPE_FIT_INSIDE, "Fit Inside" },
{ EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE, "Fit Outside" },
{ EFL_IMAGE_SCALE_TYPE_TILE, "Tile" },
{ EFL_GFX_IMAGE_SCALE_TYPE_NONE, "None" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FILL, "Fill" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE, "Fit Inside" },
{ EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE, "Fit Outside" },
{ EFL_GFX_IMAGE_SCALE_TYPE_TILE, "Tile" },
{ 0, NULL }
};
@ -118,9 +118,9 @@ my_im_scale_ch(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_U
Evas_Object *rdg = evas_object_data_get(win, "rdg");
int v = elm_radio_value_get(rdg);
efl_image_scale_type_set(im, images_scale_type[v].scale_type);
efl_gfx_image_scale_type_set(im, images_scale_type[v].scale_type);
fprintf(stderr, "Set %d[%s] and got %d\n",
images_scale_type[v].scale_type, images_scale_type[v].name, efl_image_scale_type_get(im));
images_scale_type[v].scale_type, images_scale_type[v].name, efl_gfx_image_scale_type_get(im));
}
void

6
src/bin/elementary/test_part_bg.c
View File

@ -39,7 +39,7 @@ _scale_type_cb(void *data, const Efl_Event *ev EINA_UNUSED)
{
Evas_Object *radio = data;
Evas_Object *target;
Efl_Image_Scale_Type type;
Efl_Gfx_Image_Scale_Type type;
char buf[PATH_MAX];
radio = efl_ui_radio_selected_object_get(radio);
@ -47,9 +47,9 @@ _scale_type_cb(void *data, const Efl_Event *ev EINA_UNUSED)
snprintf(buf, sizeof(buf), "%s/images/plant_01.jpg", elm_app_data_dir_get());
efl_file_set(efl_part(target, "background"), buf, NULL);
type = efl_image_scale_type_get(efl_part(target, "background"));
type = efl_gfx_image_scale_type_get(efl_part(target, "background"));
type = (type + 1) % 5;
efl_image_scale_type_set(efl_part(target, "background"), type);
efl_gfx_image_scale_type_set(efl_part(target, "background"), type);
}
static Evas_Object *

2
src/examples/elementary/bg_cxx_example_02.cc
View File

@ -30,7 +30,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev)
path = "performance/background.png";
efl::ui::Bg_Widget bg(instantiate, win);
bg.scale_type_set(EFL_IMAGE_SCALE_TYPE_FILL);
bg.scale_type_set(EFL_GFX_IMAGE_SCALE_TYPE_FILL);
bg.file_set(path, nullptr);
win.content_set(bg);

2
src/examples/elementary/icon_cxx_example_01.cc
View File

@ -20,7 +20,7 @@ elm_main (int argc EINA_UNUSED, char **argv EINA_UNUSED)
std::cout << ", name = " << icon.icon_get() << std::endl;
icon.scale_type_set(EFL_IMAGE_SCALE_TYPE_NONE);
icon.scale_type_set(EFL_GFX_IMAGE_SCALE_TYPE_NONE);
//icon.resizable_set(false, true);
//icon.smooth_set(false);
//icon.fill_outside_set(true);

4
src/examples/evas/evas-object-manipulation-eo.c
View File

@ -220,8 +220,8 @@ main(void)
}
else
{
efl_image_border_set(d.clipper_border, 3, 3, 3, 3);
efl_image_border_center_fill_set(d.clipper_border, EFL_GFX_BORDER_FILL_MODE_NONE);
efl_gfx_image_border_set(d.clipper_border, 3, 3, 3, 3);
efl_gfx_image_border_center_fill_set(d.clipper_border, EFL_GFX_BORDER_FILL_MODE_NONE);
efl_gfx_entity_position_set(d.clipper_border, EINA_POSITION2D((WIDTH / 4) -3, (HEIGHT / 4) - 3));
efl_gfx_entity_size_set(d.clipper_border, EINA_SIZE2D((WIDTH / 2) + 6, (HEIGHT / 2) + 6));
efl_gfx_entity_visible_set(d.clipper_border, EINA_TRUE);

4
src/lib/edje/edje_calc.c
View File

@ -3090,7 +3090,7 @@ _edje_proxy_recalc_apply(Edje *ed, Edje_Real_Part *ep, Edje_Calc_Params *p3, Edj
}
efl_gfx_fill_set(ep->object, (Eina_Rect) p3->type.common->fill);
efl_image_smooth_scale_set(ep->object, p3->smooth);
efl_gfx_image_smooth_scale_set(ep->object, p3->smooth);
evas_object_image_source_visible_set(ep->object, chosen_desc->proxy.source_visible);
evas_object_image_source_clip_set(ep->object, chosen_desc->proxy.source_clip);
}
@ -3130,7 +3130,7 @@ _edje_image_recalc_apply(Edje *ed, Edje_Real_Part *ep, Edje_Calc_Params *p3, Edj
}
efl_gfx_fill_set(ep->object, (Eina_Rect) p3->type.common->fill);
efl_image_smooth_scale_set(ep->object, p3->smooth);
efl_gfx_image_smooth_scale_set(ep->object, p3->smooth);
if (chosen_desc->image.border.scale)
{
if (p3->type.common->spec.image.border_scale_by > FROM_DOUBLE(0.0))

4
src/lib/edje/edje_legacy.c
View File

@ -5,10 +5,10 @@
EAPI Edje_Load_Error
edje_object_load_error_get(const Eo *obj)
{
Efl_Image_Load_Error p = efl_file_load_error_get(obj);
Efl_Gfx_Image_Load_Error p = efl_file_load_error_get(obj);
Edje *ed;
if (p != EFL_IMAGE_LOAD_ERROR_NONE) return EDJE_LOAD_ERROR_DOES_NOT_EXIST;
if (p != EFL_GFX_IMAGE_LOAD_ERROR_NONE) return EDJE_LOAD_ERROR_DOES_NOT_EXIST;
ed = _edje_fetch(obj);
if (!ed) return EDJE_LOAD_ERROR_GENERIC;

28
src/lib/edje/edje_load.c
View File

@ -166,25 +166,25 @@ _efl_canvas_layout_efl_file_file_get(Eo *obj EINA_UNUSED, Edje *ed, const char *
if (group) *group = ed->group;
}
EOLIAN Efl_Image_Load_Error
EOLIAN Efl_Gfx_Image_Load_Error
_efl_canvas_layout_efl_file_load_error_get(const Eo *obj, Edje *ed)
{
Efl_Image_Load_Error p = efl_file_load_error_get(efl_super(obj, EFL_CANVAS_LAYOUT_CLASS));
Efl_Gfx_Image_Load_Error p = efl_file_load_error_get(efl_super(obj, EFL_CANVAS_LAYOUT_CLASS));
if (p != EFL_IMAGE_LOAD_ERROR_NONE) return p;
if (p != EFL_GFX_IMAGE_LOAD_ERROR_NONE) return p;
switch (ed->load_error)
{
case EDJE_LOAD_ERROR_NONE: return EFL_IMAGE_LOAD_ERROR_NONE;
case EDJE_LOAD_ERROR_GENERIC: return EFL_IMAGE_LOAD_ERROR_GENERIC;
case EDJE_LOAD_ERROR_DOES_NOT_EXIST: return EFL_IMAGE_LOAD_ERROR_DOES_NOT_EXIST;
case EDJE_LOAD_ERROR_PERMISSION_DENIED: return EFL_IMAGE_LOAD_ERROR_PERMISSION_DENIED;
case EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED: return EFL_IMAGE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
case EDJE_LOAD_ERROR_CORRUPT_FILE: return EFL_IMAGE_LOAD_ERROR_CORRUPT_FILE;
case EDJE_LOAD_ERROR_UNKNOWN_FORMAT: return EFL_IMAGE_LOAD_ERROR_UNKNOWN_FORMAT;
case EDJE_LOAD_ERROR_INCOMPATIBLE_FILE: return EFL_IMAGE_LOAD_ERROR_INCOMPATIBLE_FILE;
case EDJE_LOAD_ERROR_UNKNOWN_COLLECTION: return EFL_IMAGE_LOAD_ERROR_UNKNOWN_COLLECTION;
case EDJE_LOAD_ERROR_RECURSIVE_REFERENCE: return EFL_IMAGE_LOAD_ERROR_RECURSIVE_REFERENCE;
default: return EFL_IMAGE_LOAD_ERROR_GENERIC;
case EDJE_LOAD_ERROR_NONE: return EFL_GFX_IMAGE_LOAD_ERROR_NONE;
case EDJE_LOAD_ERROR_GENERIC: return EFL_GFX_IMAGE_LOAD_ERROR_GENERIC;
case EDJE_LOAD_ERROR_DOES_NOT_EXIST: return EFL_GFX_IMAGE_LOAD_ERROR_DOES_NOT_EXIST;
case EDJE_LOAD_ERROR_PERMISSION_DENIED: return EFL_GFX_IMAGE_LOAD_ERROR_PERMISSION_DENIED;
case EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED: return EFL_GFX_IMAGE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED;
case EDJE_LOAD_ERROR_CORRUPT_FILE: return EFL_GFX_IMAGE_LOAD_ERROR_CORRUPT_FILE;
case EDJE_LOAD_ERROR_UNKNOWN_FORMAT: return EFL_GFX_IMAGE_LOAD_ERROR_UNKNOWN_FORMAT;
case EDJE_LOAD_ERROR_INCOMPATIBLE_FILE: return EFL_GFX_IMAGE_LOAD_ERROR_INCOMPATIBLE_FILE;
case EDJE_LOAD_ERROR_UNKNOWN_COLLECTION: return EFL_GFX_IMAGE_LOAD_ERROR_UNKNOWN_COLLECTION;
case EDJE_LOAD_ERROR_RECURSIVE_REFERENCE: return EFL_GFX_IMAGE_LOAD_ERROR_RECURSIVE_REFERENCE;
default: return EFL_GFX_IMAGE_LOAD_ERROR_GENERIC;
}
}

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

@ -72,9 +72,9 @@ typedef Efl_Gfx_Path_Command_Type Efl_Gfx_Path_Command;
#include "interfaces/efl_control.eo.h"
#include "interfaces/efl_duplicate.eo.h"
#include "interfaces/efl_file.eo.h"
#include "interfaces/efl_image.eo.h"
#include "interfaces/efl_image_animation_controller.eo.h"
#include "interfaces/efl_image_load_controller.eo.h"
#include "interfaces/efl_gfx_image.eo.h"
#include "interfaces/efl_gfx_image_animation_controller.eo.h"
#include "interfaces/efl_gfx_image_load_controller.eo.h"
#include "interfaces/efl_part.eo.h"
#include "interfaces/efl_playable.eo.h"
#include "interfaces/efl_player.eo.h"
@ -174,8 +174,8 @@ typedef Efl_Gfx_Path_Command_Type Efl_Gfx_Path_Command;
#include "interfaces/efl_input_types.eot.h"
#include "interfaces/efl_gfx_fill.eo.legacy.h"
#include "interfaces/efl_gfx_entity.eo.legacy.h"
#include "interfaces/efl_image.eo.legacy.h"
#include "interfaces/efl_image_animation_controller.eo.legacy.h"
#include "interfaces/efl_gfx_image.eo.legacy.h"
#include "interfaces/efl_gfx_image_animation_controller.eo.legacy.h"
#include "interfaces/efl_input_device.eo.legacy.h"
#include "interfaces/efl_text_types.eot.h"
#endif

8
src/lib/efl/interfaces/efl_file.c
View File

@ -7,7 +7,7 @@
typedef struct _Efl_File_Data Efl_File_Data;
struct _Efl_File_Data
{
Efl_Image_Load_Error error;
Efl_Gfx_Image_Load_Error error;
};
static Eina_Bool
@ -17,7 +17,7 @@ _efl_file_file_set(Eo *obj, Efl_File_Data *pd, const char *file, const char *key
Eina_File *f = NULL;
Eina_Bool r = EINA_FALSE;
pd->error = EFL_IMAGE_LOAD_ERROR_DOES_NOT_EXIST;
pd->error = EFL_GFX_IMAGE_LOAD_ERROR_DOES_NOT_EXIST;
tmp = (char*)(file);
if (tmp)
@ -31,7 +31,7 @@ _efl_file_file_set(Eo *obj, Efl_File_Data *pd, const char *file, const char *key
if (!f) goto on_error;
}
pd->error = EFL_IMAGE_LOAD_ERROR_NONE;
pd->error = EFL_GFX_IMAGE_LOAD_ERROR_NONE;
r = efl_file_mmap_set(obj, f, key);
if (f) eina_file_close(f);
@ -53,7 +53,7 @@ _efl_file_file_get(const Eo *obj, Efl_File_Data *pd EINA_UNUSED, const char **fi
else if (file) *file = NULL;
}
static Efl_Image_Load_Error
static Efl_Gfx_Image_Load_Error
_efl_file_load_error_get(const Eo *obj EINA_UNUSED, Efl_File_Data *pd)
{
return pd->error;

2
src/lib/efl/interfaces/efl_file.eo
View File

@ -9,7 +9,7 @@ mixin Efl.File {
[[Gets the (last) file loading error for a given object.]]
}
values {
error: Efl.Image.Load.Error(Efl.Image.Load.Error.none); [[The load error code.]]
error: Efl.Gfx.Image_Load_Error(Efl.Gfx.Image_Load_Error.none); [[The load error code.]]
}
}
@property mmap {

20
src/lib/efl/interfaces/efl_image.eo → src/lib/efl/interfaces/efl_gfx_image.eo
View File

@ -1,7 +1,7 @@
import efl_gfx_types;
import efl_gfx_fill;
enum Efl.Image_Content_Hint
enum Efl.Gfx.Image_Content_Hint
{
[[How an image's data is to be treated by EFL, for optimization.]]
none = 0, [[No hint on the content (default).]]
@ -9,7 +9,7 @@ enum Efl.Image_Content_Hint
static = 2 [[The content won't change over time.]]
}
enum Efl.Image_Scale_Hint
enum Efl.Gfx.Image_Scale_Hint
{
/* FIXME: Legacy is in Emile, where it does not belong. */
[[How an image's data is to be treated by EFL, with regard to scaling cache.]]
@ -18,7 +18,7 @@ enum Efl.Image_Scale_Hint
static = 2 [[Image will not be re-scaled over time, thus turning scaling cache ON for its data.]]
}
enum Efl.Image_Scale_Type
enum Efl.Gfx.Image_Scale_Type
{
[[Enumeration that defines scale types of an image.]]
fill, [[Scale the image so that it matches
@ -40,7 +40,7 @@ enum Efl.Image_Scale_Type
none [[Not scale the image]]
}
interface Efl.Image ()
interface Efl.Gfx.Image ()
{
[[Common APIs for all 2D images that can be rendered on the canvas.]]
@ -64,7 +64,7 @@ interface Efl.Image ()
@property scale_type {
[[Control how the image is scaled.]]
values {
scale_type: Efl.Image_Scale_Type; [[Image scale type]]
scale_type: Efl.Gfx.Image_Scale_Type; [[Image scale type]]
}
}
@property ratio {
@ -157,7 +157,7 @@ interface Efl.Image ()
}
}
/* Note: those are obscure features of evas image. Expose in Efl.Image? */
/* Note: those are obscure features of evas image. Expose in Efl.Gfx.Image? */
@property content_hint {
set {
[[Set the content hint setting of a given image object of the
@ -178,8 +178,8 @@ interface Efl.Image ()
]]
}
values {
hint: Efl.Image_Content_Hint; [[Dynamic or static content hint,
see @Efl.Image_Content_Hint]]
hint: Efl.Gfx.Image_Content_Hint; [[Dynamic or static content hint,
see @Efl.Gfx.Image_Content_Hint]]
}
}
@property scale_hint {
@ -199,8 +199,8 @@ interface Efl.Image ()
]]
}
values {
hint: Efl.Image_Scale_Hint; [[Scalable or static size hint,
see @Efl.Image_Scale_Hint]]
hint: Efl.Gfx.Image_Scale_Hint; [[Scalable or static size hint,
see @Efl.Gfx.Image_Scale_Hint]]
}
}
}

16
src/lib/efl/interfaces/efl_image_animation_controller.eo → src/lib/efl/interfaces/efl_gfx_image_animation_controller.eo
View File

@ -1,19 +1,19 @@
/* FIXME: invalid type from evas/emile! */
/* type @extern Evas.Animated_Loop_Hint: int; */
enum Efl.Image_Animation_Controller_Loop_Hint {
enum Efl.Gfx.Image_Animation_Controller_Loop_Hint {
[[Image animation loop modes]]
none = 0, [[No looping order specified.]]
loop = 1, [[Standard loop: 1->2->3->1->2->3->1]]
pingpong = 2 [[Ping-pong bouncing loop: 1->2->3->2->1->2->3->1]]
}
/* FIXME: rename to Efl.Image_Animation_Controller when eo/eolian are fixed */
/* FIXME: rename to Efl.Gfx.Image_Animation_Controller when eo/eolian are fixed */
interface Efl.Image_Animation_Controller ()
interface Efl.Gfx.Image_Animation_Controller ()
{
[[Efl animated image interface]]
eo_prefix: efl_image;
eo_prefix: efl_gfx_image;
methods {
@property animated {
@ -65,18 +65,18 @@ interface Efl.Image_Animation_Controller ()
This returns the kind of looping the image object wants to do.
If it returns @Efl.Image_Animation_Controller_Loop_Hint.loop, you should
If it returns @Efl.Gfx.Image_Animation_Controller_Loop_Hint.loop, you should
display frames in a sequence like: 1->2->3->1->2->3->1...
If it returns @Efl.Image_Animation_Controller_Loop_Hint.pingpong, it is
If it returns @Efl.Gfx.Image_Animation_Controller_Loop_Hint.pingpong, it is
better to display frames in a sequence like:
1->2->3->2->1->2->3->1...
The default type is @Efl.Image_Animation_Controller_Loop_Hint.loop.
The default type is @Efl.Gfx.Image_Animation_Controller_Loop_Hint.loop.
@since 1.1
]]
return: Efl.Image_Animation_Controller_Loop_Hint; [[Loop type of the image object.]]
return: Efl.Gfx.Image_Animation_Controller_Loop_Hint; [[Loop type of the image object.]]
}
}
@property animated_loop_count {

10
src/lib/efl/interfaces/efl_image_load_controller.eo → src/lib/efl/interfaces/efl_gfx_image_load_controller.eo
View File

@ -2,18 +2,18 @@ import eina_types;
import efl_gfx_types;
/*
enum Efl.Image_Load_Controller_State
enum Efl.Gfx.Image_Load_Controller_State
{
none = 0, [[Not loading any image.]]
loaded = 1, [[Image data is loaded, nothing is pending.]]
pending = 2, [[The image has been queued for load, but actual loading may not have started yet.]]
loading = 3, [[The image is currently loading.]]
error = 4, [[Image load has failed. Call @Efl.Image_Load_Controller.load_error.get to know why.]]
error = 4, [[Image load has failed. Call @Efl.Gfx.Image_Load_Controller.load_error.get to know why.]]
cancelled = 5 [[Image load has been cancelled.]]
}
*/
interface Efl.Image_Load_Controller ()
interface Efl.Gfx.Image_Load_Controller ()
{
[[Common APIs for all loadable 2D images.]]
@ -44,7 +44,7 @@ interface Efl.Image_Load_Controller ()
]]
}
values {
state: Efl.Image_Load_Controller_State; [[Image loading status]]
state: Efl.Gfx.Image_Load_Controller_State; [[Image loading status]]
}
}
*/
@ -182,7 +182,7 @@ interface Efl.Image_Load_Controller ()
}
events {
load,done; [[Called when he image was loaded]]
load,error: Efl.Image.Load.Error; [[Called when an error happened during image loading]]
load,error: Efl.Gfx.Image_Load_Error; [[Called when an error happened during image loading]]
load,cancelled; [[Called when the image loading was cancelled]]
}
}

2
src/lib/efl/interfaces/efl_gfx_types.eot
View File

@ -188,7 +188,7 @@ enum Efl.Gfx.Size_Hint_Aspect
aspect.]]
}
enum Efl.Image.Load.Error
enum Efl.Gfx.Image_Load_Error
{
[[Image or Edje load error type]]
none = 0, [[No error on load]]

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

@ -11,9 +11,9 @@
#include "interfaces/efl_config.eo.c"
#include "interfaces/efl_control.eo.c"
#include "interfaces/efl_duplicate.eo.c"
#include "interfaces/efl_image.eo.c"
#include "interfaces/efl_image_animation_controller.eo.c"
#include "interfaces/efl_image_load_controller.eo.c"
#include "interfaces/efl_gfx_image.eo.c"
#include "interfaces/efl_gfx_image_animation_controller.eo.c"
#include "interfaces/efl_gfx_image_load_controller.eo.c"
#include "interfaces/efl_part.eo.c"
#include "interfaces/efl_playable.eo.c"
#include "interfaces/efl_player.eo.c"

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

@ -1,4 +1,4 @@
interface Efl.Ui.Bg (Efl.Interface, Efl.Gfx.Entity, Efl.Image, Efl.File)
interface Efl.Ui.Bg (Efl.Interface, Efl.Gfx.Entity, Efl.Gfx.Image, Efl.File)
{
[[The bg (background) widget is used for setting (solid) background decorations

50
src/lib/elementary/efl_ui_bg_widget.c
View File

@ -43,7 +43,7 @@ _efl_ui_bg_widget_efl_object_constructor(Eo *obj, Efl_Ui_Bg_Widget_Data *pd)
efl_content_set(efl_part(obj, "elm.swallow.rectangle"), efl_added));
pd->img = efl_add(EFL_UI_IMAGE_CLASS, obj,
efl_image_scale_type_set(efl_added, EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_gfx_image_scale_type_set(efl_added, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE),
efl_content_set(efl_part(obj, "elm.swallow.background"), efl_added));
pd->file = NULL;
pd->key = NULL;
@ -67,51 +67,51 @@ _efl_ui_bg_widget_efl_object_destructor(Eo *obj, Efl_Ui_Bg_Widget_Data *sd)
EAPI void
elm_bg_option_set(Evas_Object *obj, Elm_Bg_Option option)
{
Efl_Image_Scale_Type type;
Efl_Gfx_Image_Scale_Type type;
switch (option)
{
case ELM_BG_OPTION_CENTER:
type = EFL_IMAGE_SCALE_TYPE_NONE;
type = EFL_GFX_IMAGE_SCALE_TYPE_NONE;
break;
case ELM_BG_OPTION_SCALE:
type = EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
break;
case ELM_BG_OPTION_TILE:
type = EFL_IMAGE_SCALE_TYPE_TILE;
type = EFL_GFX_IMAGE_SCALE_TYPE_TILE;
break;
case ELM_BG_OPTION_STRETCH:
type = EFL_IMAGE_SCALE_TYPE_FILL;
type = EFL_GFX_IMAGE_SCALE_TYPE_FILL;
break;
case ELM_BG_OPTION_LAST:
default:
type = EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
}
efl_image_scale_type_set(obj, type);
efl_gfx_image_scale_type_set(obj, type);
}
EAPI Elm_Bg_Option
elm_bg_option_get(const Evas_Object *obj)
{
Efl_Image_Scale_Type type;
Efl_Gfx_Image_Scale_Type type;
Elm_Bg_Option option = ELM_BG_OPTION_LAST;
type = efl_image_scale_type_get(obj);
type = efl_gfx_image_scale_type_get(obj);
switch (type)
{
case EFL_IMAGE_SCALE_TYPE_NONE:
case EFL_GFX_IMAGE_SCALE_TYPE_NONE:
option = ELM_BG_OPTION_CENTER;
break;
case EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE:
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE:
option = ELM_BG_OPTION_SCALE;
break;
case EFL_IMAGE_SCALE_TYPE_TILE:
case EFL_GFX_IMAGE_SCALE_TYPE_TILE:
option = ELM_BG_OPTION_TILE;
break;
case EFL_IMAGE_SCALE_TYPE_FILL:
case EFL_GFX_IMAGE_SCALE_TYPE_FILL:
option = ELM_BG_OPTION_STRETCH;
break;
case EFL_IMAGE_SCALE_TYPE_FIT_INSIDE:
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE:
default:
ERR("Scale type %d cannot be converted to Elm_Bg_Option", type);
break;
@ -121,15 +121,15 @@ elm_bg_option_get(const Evas_Object *obj)
}
EOLIAN static void
_efl_ui_bg_widget_efl_image_scale_type_set(Eo *obj EINA_UNUSED, Efl_Ui_Bg_Widget_Data *sd, Efl_Image_Scale_Type scale_type)
_efl_ui_bg_widget_efl_gfx_image_scale_type_set(Eo *obj EINA_UNUSED, Efl_Ui_Bg_Widget_Data *sd, Efl_Gfx_Image_Scale_Type scale_type)
{
efl_image_scale_type_set(sd->img, scale_type);
efl_gfx_image_scale_type_set(sd->img, scale_type);
}
EOLIAN static Efl_Image_Scale_Type
_efl_ui_bg_widget_efl_image_scale_type_get(const Eo *obj EINA_UNUSED, Efl_Ui_Bg_Widget_Data *sd)
EOLIAN static Efl_Gfx_Image_Scale_Type
_efl_ui_bg_widget_efl_gfx_image_scale_type_get(const Eo *obj EINA_UNUSED, Efl_Ui_Bg_Widget_Data *sd)
{
return efl_image_scale_type_get(sd->img);
return efl_gfx_image_scale_type_get(sd->img);
}
EAPI void
@ -178,19 +178,19 @@ EAPI void
elm_bg_load_size_set(Evas_Object *obj, int w, int h)
{
EFL_UI_BG_WIDGET_DATA_GET_OR_RETURN(obj, sd);
efl_image_load_controller_load_size_set(sd->img, EINA_SIZE2D(w, h));
efl_gfx_image_load_controller_load_size_set(sd->img, EINA_SIZE2D(w, h));
}
EOLIAN static void
_efl_ui_bg_widget_efl_image_load_controller_load_size_set(Eo *obj EINA_UNUSED, Efl_Ui_Bg_Widget_Data *sd, Eina_Size2D sz)
_efl_ui_bg_widget_efl_gfx_image_load_controller_load_size_set(Eo *obj EINA_UNUSED, Efl_Ui_Bg_Widget_Data *sd, Eina_Size2D sz)
{
efl_image_load_controller_load_size_set(sd->img, sz);
efl_gfx_image_load_controller_load_size_set(sd->img, sz);
}
EOLIAN static Eina_Size2D
_efl_ui_bg_widget_efl_image_load_controller_load_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Bg_Widget_Data *sd)
_efl_ui_bg_widget_efl_gfx_image_load_controller_load_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Bg_Widget_Data *sd)
{
return efl_image_load_controller_load_size_get(sd->img);
return efl_gfx_image_load_controller_load_size_get(sd->img);
}
EAPI Eina_Bool

6
src/lib/elementary/efl_ui_bg_widget.eo
View File

@ -1,4 +1,4 @@
class Efl.Ui.Bg_Widget (Efl.Ui.Layout, Efl.Ui.Bg, Efl.Image_Load_Controller)
class Efl.Ui.Bg_Widget (Efl.Ui.Layout, Efl.Ui.Bg, Efl.Gfx.Image_Load_Controller)
{
[[The bg (background) widget is used for setting (solid) background decorations
@ -13,7 +13,7 @@ class Efl.Ui.Bg_Widget (Efl.Ui.Layout, Efl.Ui.Bg, Efl.Image_Load_Controller)
Efl.File.file { get; set; }
Efl.File.mmap { get; set; }
Efl.Gfx.Color.color { get; set; }
Efl.Image.scale_type { get; set; }
Efl.Image_Load_Controller.load_size { get; set; }
Efl.Gfx.Image.scale_type { get; set; }
Efl.Gfx.Image_Load_Controller.load_size { get; set; }
}
}

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

@ -181,15 +181,15 @@ _image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
// according to (iw x ih), (sd->img_w x sd->img_h), and scale_type
switch (sd->scale_type)
{
case EFL_IMAGE_SCALE_TYPE_NONE:
case EFL_GFX_IMAGE_SCALE_TYPE_NONE:
w = iw;
h = ih;
break;
case EFL_IMAGE_SCALE_TYPE_FILL:
case EFL_GFX_IMAGE_SCALE_TYPE_FILL:
w = sd->img_w;
h = sd->img_h;
break;
case EFL_IMAGE_SCALE_TYPE_FIT_INSIDE:
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE:
w = sd->img_w;
h = ((double)ih * w) / (double)iw;
@ -206,7 +206,7 @@ _image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
h = ih;
}
break;
case EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE:
case EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE:
w = sd->img_w;
h = ((double)ih * w) / (double)iw;
if (h < sd->img_h)
@ -222,7 +222,7 @@ _image_sizing_eval(Efl_Ui_Image_Data *sd, Evas_Object *img)
h = ih;
}
break;
case EFL_IMAGE_SCALE_TYPE_TILE:
case EFL_GFX_IMAGE_SCALE_TYPE_TILE:
x = sd->img_x;
y = sd->img_y;
w = sd->img_w;
@ -524,14 +524,14 @@ _efl_ui_image_edje_file_set(Evas_Object *obj,
}
EOLIAN static void
_efl_ui_image_efl_image_smooth_scale_set(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd, Eina_Bool smooth)
_efl_ui_image_efl_gfx_image_smooth_scale_set(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd, Eina_Bool smooth)
{
sd->smooth = smooth;
if (!sd->edje) evas_object_image_smooth_scale_set(sd->img, smooth);
}
EOLIAN static Eina_Bool
_efl_ui_image_efl_image_smooth_scale_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
_efl_ui_image_efl_gfx_image_smooth_scale_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
{
return sd->smooth;
}
@ -762,7 +762,7 @@ _efl_ui_image_sizing_eval(Evas_Object *obj)
EFL_UI_IMAGE_DATA_GET_OR_RETURN(obj, sd);
_efl_ui_image_internal_sizing_eval(obj, sd);
efl_image_smooth_scale_set(obj, sd->smooth);
efl_gfx_image_smooth_scale_set(obj, sd->smooth);
if (sd->no_scale)
_efl_ui_image_internal_scale_set(obj, sd, 1.0);
@ -857,7 +857,7 @@ _efl_ui_image_efl_object_constructor(Eo *obj, Efl_Ui_Image_Data *pd)
evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_IMAGE);
pd->scale_type = EFL_IMAGE_SCALE_TYPE_FIT_INSIDE;
pd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE;
pd->self = obj;
return obj;
@ -1257,12 +1257,12 @@ _efl_ui_image_efl_gfx_view_view_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image
}
EOLIAN static Eina_Size2D
_efl_ui_image_efl_image_image_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
_efl_ui_image_efl_gfx_image_image_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
{
if (sd->edje)
return EINA_SIZE2D(0, 0);
return efl_image_size_get(sd->img);
return efl_gfx_image_size_get(sd->img);
}
EAPI void
@ -1270,11 +1270,11 @@ elm_image_prescale_set(Evas_Object *obj,
int size)
{
EFL_UI_IMAGE_CHECK(obj);
efl_image_load_controller_load_size_set(obj, EINA_SIZE2D(size, size));
efl_gfx_image_load_controller_load_size_set(obj, EINA_SIZE2D(size, size));
}
EOLIAN static void
_efl_ui_image_efl_image_load_controller_load_size_set(Eo *obj, Efl_Ui_Image_Data *sd, Eina_Size2D sz)
_efl_ui_image_efl_gfx_image_load_controller_load_size_set(Eo *obj, Efl_Ui_Image_Data *sd, Eina_Size2D sz)
{
sd->load_size = sz;
_efl_ui_image_load_size_set_internal(obj, sd);
@ -1286,13 +1286,13 @@ elm_image_prescale_get(const Evas_Object *obj)
Eina_Size2D sz;
EFL_UI_IMAGE_CHECK(obj) 0;
sz = efl_image_load_controller_load_size_get(obj);
sz = efl_gfx_image_load_controller_load_size_get(obj);
return MAX(sz.w, sz.h);
}
EOLIAN static Eina_Size2D
_efl_ui_image_efl_image_load_controller_load_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
_efl_ui_image_efl_gfx_image_load_controller_load_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
{
return sd->load_size;
}
@ -1506,7 +1506,7 @@ _efl_ui_image_efl_player_play_get(const Eo *obj, Efl_Ui_Image_Data *sd)
}
EOLIAN static void
_efl_ui_image_efl_image_scale_type_set(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd EINA_UNUSED, Efl_Image_Scale_Type scale_type)
_efl_ui_image_efl_gfx_image_scale_type_set(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd EINA_UNUSED, Efl_Gfx_Image_Scale_Type scale_type)
{
if (scale_type == sd->scale_type) return;
@ -1515,8 +1515,8 @@ _efl_ui_image_efl_image_scale_type_set(Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *s
_efl_ui_image_internal_sizing_eval(obj, sd);
}
EOLIAN static Efl_Image_Scale_Type
_efl_ui_image_efl_image_scale_type_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
EOLIAN static Efl_Gfx_Image_Scale_Type
_efl_ui_image_efl_gfx_image_scale_type_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Data *sd)
{
return sd->scale_type;
}
@ -1961,7 +1961,7 @@ EAPI void
elm_image_smooth_set(Evas_Object *obj, Eina_Bool smooth)
{
EINA_SAFETY_ON_FALSE_RETURN(efl_isa(obj, MY_CLASS));
efl_image_smooth_scale_set(obj, smooth);
efl_gfx_image_smooth_scale_set(obj, smooth);
_efl_ui_image_sizing_eval(obj);
}
@ -1969,7 +1969,7 @@ EAPI Eina_Bool
elm_image_smooth_get(const Evas_Object *obj)
{
EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_isa(obj, MY_CLASS), EINA_FALSE);
return efl_image_smooth_scale_get(obj);
return efl_gfx_image_smooth_scale_get(obj);
}
// A11Y - END
@ -2063,11 +2063,11 @@ elm_image_fill_outside_set(Evas_Object *obj, Eina_Bool fill_outside)
if (sd->aspect_fixed)
{
if (sd->fill_inside) sd->scale_type = EFL_IMAGE_SCALE_TYPE_FIT_INSIDE;
else sd->scale_type = EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
if (sd->fill_inside) sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE;
else sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
}
else
sd->scale_type = EFL_IMAGE_SCALE_TYPE_FILL;
sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FILL;
_efl_ui_image_internal_sizing_eval(obj, sd);
}
@ -2237,11 +2237,11 @@ elm_image_aspect_fixed_set(Evas_Object *obj, Eina_Bool fixed)
if (sd->aspect_fixed)
{
if (sd->fill_inside) sd->scale_type = EFL_IMAGE_SCALE_TYPE_FIT_INSIDE;
else sd->scale_type = EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
if (sd->fill_inside) sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_INSIDE;
else sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE;
}
else
sd->scale_type = EFL_IMAGE_SCALE_TYPE_FILL;
sd->scale_type = EFL_GFX_IMAGE_SCALE_TYPE_FILL;
_efl_ui_image_sizing_eval(obj);
}

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

@ -19,7 +19,7 @@ struct Efl.Ui.Image.Error
}
class Efl.Ui.Image (Efl.Ui.Widget, Efl.Ui.Clickable, Efl.Ui.Draggable,
Efl.File, Efl.Image, Efl.Image_Load_Controller, Efl.Player, Efl.Gfx.View,
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.Orientation,
Efl.Ui.View, Efl.Ui.Model.Connect, Efl.Layout.Calc,
@ -96,10 +96,10 @@ class Efl.Ui.Image (Efl.Ui.Widget, Efl.Ui.Clickable, Efl.Ui.Draggable,
Efl.Gfx.Entity.position { set; }
Efl.Gfx.Entity.size { set; }
Efl.Gfx.View.view_size { get; }
Efl.Image.image_size { get; }
Efl.Image_Load_Controller.load_size { get; set; }
Efl.Image.smooth_scale { get; set; }
Efl.Image.scale_type { get; set; }
Efl.Gfx.Image.image_size { get; }
Efl.Gfx.Image_Load_Controller.load_size { get; set; }
Efl.Gfx.Image.smooth_scale { get; set; }
Efl.Gfx.Image.scale_type { get; set; }
Efl.Orientation.orientation { get; set; }
Efl.Orientation.flip { get; set; }
Efl.Player.playable { get; }

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

@ -1795,7 +1795,7 @@ _efl_ui_image_zoomable_efl_object_constructor(Eo *obj, Efl_Ui_Image_Zoomable_Dat
}
EOLIAN static Eina_Size2D
_efl_ui_image_zoomable_efl_image_image_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Zoomable_Data *pd)
_efl_ui_image_zoomable_efl_gfx_image_image_size_get(const Eo *obj EINA_UNUSED, Efl_Ui_Image_Zoomable_Data *pd)
{
return EINA_SIZE2D(pd->size.imw, pd->size.imh);
}

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

@ -50,7 +50,7 @@ class Efl.Ui.Image_Zoomable (Efl.Ui.Widget, Efl.Ui.Image, Efl.Ui.Zoom,
Efl.Gfx.Entity.position { set; }
Efl.Gfx.Entity.size { set; }
Efl.Gfx.View.view_size { get; }
Efl.Image.image_size { get; }
Efl.Gfx.Image.image_size { get; }
Efl.Ui.Image.icon { set; get; }
Efl.Player.playable { get; }
Efl.Player.play { get; set; }

2
src/lib/elementary/efl_ui_text_factory_images.c
View File

@ -68,7 +68,7 @@ _efl_ui_text_factory_images_efl_canvas_text_factory_create(Eo *obj EINA_UNUSED,
efl_file_set(o, key, NULL);
}
if (efl_file_load_error_get(o) != EFL_IMAGE_LOAD_ERROR_NONE)
if (efl_file_load_error_get(o) != EFL_GFX_IMAGE_LOAD_ERROR_NONE)
{
efl_del(o);
o = NULL;

10
src/lib/elementary/efl_ui_widget.c
View File

@ -6045,19 +6045,19 @@ _efl_ui_widget_part_bg_efl_gfx_color_color_get(const Eo *obj, void *pd EINA_UNUS
}
EOLIAN static void
_efl_ui_widget_part_bg_efl_image_scale_type_set(Eo *obj, void *pd EINA_UNUSED, Efl_Image_Scale_Type scale_type)
_efl_ui_widget_part_bg_efl_gfx_image_scale_type_set(Eo *obj, void *pd EINA_UNUSED, Efl_Gfx_Image_Scale_Type scale_type)
{
Evas_Object *bg_obj = efl_ui_widget_part_bg_get(obj);
efl_image_scale_type_set(bg_obj, scale_type);
efl_gfx_image_scale_type_set(bg_obj, scale_type);
}
EOLIAN static Efl_Image_Scale_Type
_efl_ui_widget_part_bg_efl_image_scale_type_get(const Eo *obj, void *pd EINA_UNUSED)
EOLIAN static Efl_Gfx_Image_Scale_Type
_efl_ui_widget_part_bg_efl_gfx_image_scale_type_get(const Eo *obj, void *pd EINA_UNUSED)
{
Evas_Object *bg_obj = efl_ui_widget_part_bg_get(obj);
return efl_image_scale_type_get(bg_obj);
return efl_gfx_image_scale_type_get(bg_obj);
}
#include "efl_ui_widget_part_bg.eo.c"

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

@ -76,7 +76,7 @@ struct _Efl_Ui_Image_Data
} async;
Efl_Ui_Image_Preload_Status preload_status;
Efl_Image_Scale_Type scale_type;
Efl_Gfx_Image_Scale_Type scale_type;
const char *stdicon;

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

@ -6,6 +6,6 @@ class Efl.Ui.Widget.Part_Bg (Efl.Ui.Widget.Part, Efl.Gfx.Color, Efl.Ui.Bg)
Efl.File.file { get; set; }
//Efl.File.mmap { get; set; }
Efl.Gfx.Color.color { set; get; }
Efl.Image.scale_type { get; set; }
Efl.Gfx.Image.scale_type { get; set; }
}
}

2
src/lib/elementary/efl_ui_win.c
View File

@ -7235,7 +7235,7 @@ _efl_ui_win_part_file_set(Eo *obj, Efl_Ui_Win_Data *sd, const char *part, const
if (file)
{
bg = efl_add(EFL_UI_IMAGE_CLASS, obj);
efl_image_scale_type_set(bg, EFL_IMAGE_SCALE_TYPE_FIT_OUTSIDE);
efl_gfx_image_scale_type_set(bg, EFL_GFX_IMAGE_SCALE_TYPE_FIT_OUTSIDE);
ok = efl_file_set(bg, file, key);
if (!ok) ELM_SAFE_DEL(bg);
_elm_win_bg_set(sd, bg);

8
src/lib/emotion/efl_canvas_video.eo
View File

@ -1,4 +1,4 @@
class Efl.Canvas.Video (Efl.Canvas.Group, Efl.File, Efl.Player, Efl.Image, Efl.Image_Load_Controller)
class Efl.Canvas.Video (Efl.Canvas.Group, Efl.File, Efl.Player, Efl.Gfx.Image, Efl.Gfx.Image_Load_Controller)
{
[[Efl canvas video class]]
methods {
@ -63,9 +63,9 @@ class Efl.Canvas.Video (Efl.Canvas.Group, Efl.File, Efl.Player, Efl.Image, Efl.I
Efl.Player.mute { get; set; }
Efl.Player.length { get; }
Efl.Player.seekable { get; }
Efl.Image_Load_Controller.load_size { get; }
Efl.Image.ratio { get; }
Efl.Image.smooth_scale { get; set; }
Efl.Gfx.Image_Load_Controller.load_size { get; }
Efl.Gfx.Image.ratio { get; }
Efl.Gfx.Image.smooth_scale { get; set; }
}
events {
frame,decode; [[Called when the frame was decoded]]

16
src/lib/emotion/emotion_smart.c
View File

@ -740,13 +740,13 @@ emotion_object_size_get(const Evas_Object *obj, int *iw, int *ih)
{
Eina_Size2D sz;
sz = efl_image_load_controller_load_size_get(obj);
sz = efl_gfx_image_load_controller_load_size_get(obj);
if (iw) *iw = sz.w;
if (ih) *ih = sz.h;
}
EOLIAN static Eina_Size2D
_efl_canvas_video_efl_image_load_controller_load_size_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Video_Data *sd)
_efl_canvas_video_efl_gfx_image_load_controller_load_size_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Video_Data *sd)
{
// FIXME: Shouldn't this be efl_gfx_view_size instead?
return EINA_SIZE2D(sd->video.w, sd->video.h);
@ -755,11 +755,11 @@ _efl_canvas_video_efl_image_load_controller_load_size_get(const Eo *obj EINA_UNU
EAPI void
emotion_object_smooth_scale_set(Evas_Object *obj, Eina_Bool smooth)
{
efl_image_smooth_scale_set(obj, smooth);
efl_gfx_image_smooth_scale_set(obj, smooth);
}
EOLIAN static void
_efl_canvas_video_efl_image_smooth_scale_set(Eo *obj EINA_UNUSED, Efl_Canvas_Video_Data *sd, Eina_Bool smooth)
_efl_canvas_video_efl_gfx_image_smooth_scale_set(Eo *obj EINA_UNUSED, Efl_Canvas_Video_Data *sd, Eina_Bool smooth)
{
evas_object_image_smooth_scale_set(sd->obj, smooth);
}
@ -767,11 +767,11 @@ _efl_canvas_video_efl_image_smooth_scale_set(Eo *obj EINA_UNUSED, Efl_Canvas_Vid
EAPI Eina_Bool
emotion_object_smooth_scale_get(const Evas_Object *obj)
{
return efl_image_smooth_scale_get(obj);
return efl_gfx_image_smooth_scale_get(obj);
}
EOLIAN static Eina_Bool
_efl_canvas_video_efl_image_smooth_scale_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Video_Data *sd)
_efl_canvas_video_efl_gfx_image_smooth_scale_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Video_Data *sd)
{
return evas_object_image_smooth_scale_get(sd->obj);
}
@ -779,11 +779,11 @@ _efl_canvas_video_efl_image_smooth_scale_get(const Eo *obj EINA_UNUSED, Efl_Canv
EAPI double
emotion_object_ratio_get(const Evas_Object *obj)
{
return efl_image_ratio_get(obj);
return efl_gfx_image_ratio_get(obj);
}
EOLIAN static double
_efl_canvas_video_efl_image_ratio_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Video_Data *sd)
_efl_canvas_video_efl_gfx_image_ratio_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Video_Data *sd)
{
if (!sd->engine_instance) return 0.0;
return sd->ratio;

8
src/lib/evas/Evas_Common.h
View File

@ -246,10 +246,10 @@ typedef struct _Evas_Pixel_Import_Source Evas_Pixel_Import_Source; /**< A source
/* Opaque types */
typedef Eo Evas_Device; /**< A source device handle - where the event came from */
typedef Efl_Image_Content_Hint Evas_Image_Content_Hint;
#define EVAS_IMAGE_CONTENT_HINT_NONE EFL_IMAGE_CONTENT_HINT_NONE
#define EVAS_IMAGE_CONTENT_HINT_DYNAMIC EFL_IMAGE_CONTENT_HINT_DYNAMIC
#define EVAS_IMAGE_CONTENT_HINT_STATIC EFL_IMAGE_CONTENT_HINT_STATIC
typedef Efl_Gfx_Image_Content_Hint Evas_Image_Content_Hint;
#define EVAS_IMAGE_CONTENT_HINT_NONE EFL_GFX_IMAGE_CONTENT_HINT_NONE
#define EVAS_IMAGE_CONTENT_HINT_DYNAMIC EFL_GFX_IMAGE_CONTENT_HINT_DYNAMIC
#define EVAS_IMAGE_CONTENT_HINT_STATIC EFL_GFX_IMAGE_CONTENT_HINT_STATIC
typedef enum _Evas_Alloc_Error
{

20
src/lib/evas/Evas_Loader.h
View File

@ -134,16 +134,16 @@ typedef Emile_Image_Property Evas_Image_Property;
typedef struct _Evas_Image_Load_Func Evas_Image_Load_Func;
typedef Efl_Image_Load_Error Evas_Load_Error;
typedef Efl_Gfx_Image_Load_Error Evas_Load_Error;
#define EVAS_LOAD_ERROR_NONE EFL_IMAGE_LOAD_ERROR_NONE
#define EVAS_LOAD_ERROR_GENERIC EFL_IMAGE_LOAD_ERROR_GENERIC
#define EVAS_LOAD_ERROR_DOES_NOT_EXIST EFL_IMAGE_LOAD_ERROR_DOES_NOT_EXIST
#define EVAS_LOAD_ERROR_PERMISSION_DENIED EFL_IMAGE_LOAD_ERROR_PERMISSION_DENIED
#define EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED EFL_IMAGE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED
#define EVAS_LOAD_ERROR_CORRUPT_FILE EFL_IMAGE_LOAD_ERROR_CORRUPT_FILE
#define EVAS_LOAD_ERROR_UNKNOWN_FORMAT EFL_IMAGE_LOAD_ERROR_UNKNOWN_FORMAT
#define EVAS_LOAD_ERROR_CANCELLED EFL_IMAGE_LOAD_ERROR_CANCELLED
#define EVAS_LOAD_ERROR_NONE EFL_GFX_IMAGE_LOAD_ERROR_NONE
#define EVAS_LOAD_ERROR_GENERIC EFL_GFX_IMAGE_LOAD_ERROR_GENERIC
#define EVAS_LOAD_ERROR_DOES_NOT_EXIST EFL_GFX_IMAGE_LOAD_ERROR_DOES_NOT_EXIST
#define EVAS_LOAD_ERROR_PERMISSION_DENIED EFL_GFX_IMAGE_LOAD_ERROR_PERMISSION_DENIED
#define EVAS_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED EFL_GFX_IMAGE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED
#define EVAS_LOAD_ERROR_CORRUPT_FILE EFL_GFX_IMAGE_LOAD_ERROR_CORRUPT_FILE
#define EVAS_LOAD_ERROR_UNKNOWN_FORMAT EFL_GFX_IMAGE_LOAD_ERROR_UNKNOWN_FORMAT
#define EVAS_LOAD_ERROR_CANCELLED EFL_GFX_IMAGE_LOAD_ERROR_CANCELLED
typedef Emile_Image_Animated_Loop_Hint Evas_Image_Animated_Loop_Hint;
@ -219,7 +219,7 @@ EAPI Eina_Bool evas_module_task_cancelled (void); /**< @since 1.19 */
Count = 0; \
if (evas_module_task_cancelled()) \
{ \
*Error = EFL_IMAGE_LOAD_ERROR_CANCELLED; \
*Error = EFL_GFX_IMAGE_LOAD_ERROR_CANCELLED; \
goto Error_Handler; \
} \
} \

62
src/lib/evas/canvas/efl_canvas_image.c
View File

@ -54,17 +54,17 @@ _efl_canvas_image_efl_file_mmap_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA
_evas_image_mmap_get(eo_obj, f, key);
}
Efl_Image_Load_Error
Efl_Gfx_Image_Load_Error
_evas_image_load_error_get(const Eo *eo_obj)
{
Evas_Image_Data *o = efl_data_scope_get(eo_obj, EFL_CANVAS_IMAGE_INTERNAL_CLASS);
Efl_Image_Load_Error r = efl_file_load_error_get(efl_cast(eo_obj, EFL_FILE_MIXIN));
Efl_Gfx_Image_Load_Error r = efl_file_load_error_get(efl_cast(eo_obj, EFL_FILE_MIXIN));
if (r != EFL_IMAGE_LOAD_ERROR_NONE) return r;
if (r != EFL_GFX_IMAGE_LOAD_ERROR_NONE) return r;
return o->load_error;
}
EOLIAN static Efl_Image_Load_Error
EOLIAN static Efl_Gfx_Image_Load_Error
_efl_canvas_image_efl_file_load_error_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_load_error_get(eo_obj);
@ -111,7 +111,7 @@ _evas_image_load_async_start(Eo *eo_obj)
}
EOLIAN static void
_efl_canvas_image_efl_image_load_controller_load_async_start(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_async_start(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
_evas_image_load_async_start(eo_obj);
}
@ -127,7 +127,7 @@ _evas_image_load_async_cancel(Eo *eo_obj)
}
EOLIAN static void
_efl_canvas_image_efl_image_load_controller_load_async_cancel(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_async_cancel(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
_evas_image_load_async_cancel(eo_obj);
}
@ -155,7 +155,7 @@ _evas_image_load_dpi_set(Eo *eo_obj, double dpi)
}
EOLIAN static void
_efl_canvas_image_efl_image_load_controller_load_dpi_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, double dpi)
_efl_canvas_image_efl_gfx_image_load_controller_load_dpi_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, double dpi)
{
_evas_image_load_dpi_set(eo_obj, dpi);
}
@ -169,7 +169,7 @@ _evas_image_load_dpi_get(const Eo *eo_obj)
}
EOLIAN static double
_efl_canvas_image_efl_image_load_controller_load_dpi_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_dpi_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_load_dpi_get(eo_obj);
}
@ -201,7 +201,7 @@ _evas_image_load_size_set(Eo *eo_obj, int w, int h)
}
EOLIAN static void
_efl_canvas_image_efl_image_load_controller_load_size_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, Eina_Size2D sz)
_efl_canvas_image_efl_gfx_image_load_controller_load_size_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, Eina_Size2D sz)
{
_evas_image_load_size_set(eo_obj, sz.w, sz.h);
}
@ -216,7 +216,7 @@ _evas_image_load_size_get(const Eo *eo_obj, int *w, int *h)
}
EOLIAN static Eina_Size2D
_efl_canvas_image_efl_image_load_controller_load_size_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_size_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
Eina_Size2D sz;
_evas_image_load_size_get(eo_obj, &sz.w, &sz.h);
@ -246,7 +246,7 @@ _evas_image_load_scale_down_set(Eo *eo_obj, int scale_down)
}
EOLIAN static void
_efl_canvas_image_efl_image_load_controller_load_scale_down_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int scale_down)
_efl_canvas_image_efl_gfx_image_load_controller_load_scale_down_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int scale_down)
{
_evas_image_load_scale_down_set(eo_obj, scale_down);
}
@ -260,7 +260,7 @@ _evas_image_load_scale_down_get(const Eo *eo_obj)
}
EOLIAN static int
_efl_canvas_image_efl_image_load_controller_load_scale_down_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_scale_down_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_load_scale_down_get(eo_obj);
}
@ -273,7 +273,7 @@ _evas_image_load_head_skip_set(const Eo *eo_obj, Eina_Bool skip)
}
EOLIAN static void
_efl_canvas_image_efl_image_load_controller_load_skip_header_set(Eo *eo_obj, void *_pd EINA_UNUSED, Eina_Bool skip)
_efl_canvas_image_efl_gfx_image_load_controller_load_skip_header_set(Eo *eo_obj, void *_pd EINA_UNUSED, Eina_Bool skip)
{
_evas_image_load_head_skip_set(eo_obj, skip);
}
@ -286,7 +286,7 @@ _evas_image_load_head_skip_get(const Eo *eo_obj)
}
EOLIAN static Eina_Bool
_efl_canvas_image_efl_image_load_controller_load_skip_header_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_skip_header_get(const Eo *eo_obj, void *_pd EINA_UNUSED)
{
return _evas_image_load_head_skip_get(eo_obj);
}
@ -320,7 +320,7 @@ _evas_image_load_region_set(Eo *eo_obj, int x, int y, int w, int h)
}
EOLIAN static void
_efl_canvas_image_efl_image_load_controller_load_region_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, Eina_Rect region)
_efl_canvas_image_efl_gfx_image_load_controller_load_region_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, Eina_Rect region)
{
_evas_image_load_region_set(eo_obj, region.x, region.y, region.w, region.h);
}
@ -337,7 +337,7 @@ _evas_image_load_region_get(const Eo *eo_obj, int *x, int *y, int *w, int *h)
}
EOLIAN static Eina_Rect
_efl_canvas_image_efl_image_load_controller_load_region_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_region_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
Eina_Rect r;
_evas_image_load_region_get(eo_obj, &r.x, &r.y, &r.w, &r.h);
@ -359,7 +359,7 @@ _evas_image_load_orientation_set(Eo *eo_obj, Eina_Bool enable)
}
EOLIAN static void
_efl_canvas_image_efl_image_load_controller_load_orientation_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, Eina_Bool enable)
_efl_canvas_image_efl_gfx_image_load_controller_load_orientation_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, Eina_Bool enable)
{
_evas_image_load_orientation_set(eo_obj, enable);
}
@ -373,7 +373,7 @@ _evas_image_load_orientation_get(const Eo *eo_obj)
}
EOLIAN static Eina_Bool
_efl_canvas_image_efl_image_load_controller_load_orientation_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_orientation_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_load_orientation_get(eo_obj);
}
@ -388,7 +388,7 @@ _evas_image_load_region_support_get(const Eo *eo_obj)
}
EOLIAN static Eina_Bool
_efl_canvas_image_efl_image_load_controller_load_region_support_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_load_controller_load_region_support_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_load_region_support_get(eo_obj);
}
@ -407,7 +407,7 @@ _evas_image_animated_get(const Eo *eo_obj)
}
EOLIAN static Eina_Bool
_efl_canvas_image_efl_image_animation_controller_animated_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_animation_controller_animated_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_get(eo_obj);
}
@ -427,12 +427,12 @@ _evas_image_animated_frame_count_get(const Eo *eo_obj)
}
EOLIAN static int
_efl_canvas_image_efl_image_animation_controller_animated_frame_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_animation_controller_animated_frame_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_frame_count_get(eo_obj);
}
Efl_Image_Animation_Controller_Loop_Hint
Efl_Gfx_Image_Animation_Controller_Loop_Hint
_evas_image_animated_loop_type_get(const Eo *eo_obj)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
@ -440,13 +440,13 @@ _evas_image_animated_loop_type_get(const Eo *eo_obj)
if (!ENFN->image_animated_loop_type_get ||
!evas_object_image_animated_get(eo_obj))
return EFL_IMAGE_ANIMATION_CONTROLLER_LOOP_HINT_NONE;
return EFL_GFX_IMAGE_ANIMATION_CONTROLLER_LOOP_HINT_NONE;
return (Efl_Image_Animation_Controller_Loop_Hint) ENFN->image_animated_loop_type_get(ENC, o->engine_data);
return (Efl_Gfx_Image_Animation_Controller_Loop_Hint) ENFN->image_animated_loop_type_get(ENC, o->engine_data);
}
EOLIAN static Efl_Image_Animation_Controller_Loop_Hint
_efl_canvas_image_efl_image_animation_controller_animated_loop_type_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
EOLIAN static Efl_Gfx_Image_Animation_Controller_Loop_Hint
_efl_canvas_image_efl_gfx_image_animation_controller_animated_loop_type_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_loop_type_get(eo_obj);
}
@ -465,7 +465,7 @@ _evas_image_animated_loop_count_get(const Eo *eo_obj)
}
EOLIAN static int
_efl_canvas_image_efl_image_animation_controller_animated_loop_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_animation_controller_animated_loop_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_loop_count_get(eo_obj);
}
@ -489,7 +489,7 @@ _evas_image_animated_frame_duration_get(const Eo *eo_obj, int start_frame, int f
}
EOLIAN static double
_efl_canvas_image_efl_image_animation_controller_animated_frame_duration_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int start_frame, int frame_num)
_efl_canvas_image_efl_gfx_image_animation_controller_animated_frame_duration_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int start_frame, int frame_num)
{
return _evas_image_animated_frame_duration_get(eo_obj, start_frame, frame_num);
}
@ -531,7 +531,7 @@ _evas_image_animated_frame_set(Eo *eo_obj, int frame_index)
}
EOLIAN static Eina_Bool
_efl_canvas_image_efl_image_animation_controller_animated_frame_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int frame_index)
_efl_canvas_image_efl_gfx_image_animation_controller_animated_frame_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int frame_index)
{
return _evas_image_animated_frame_set(eo_obj, frame_index);
}
@ -547,7 +547,7 @@ _evas_image_animated_frame_get(const Eo *eo_obj)
}
EOLIAN static int
_efl_canvas_image_efl_image_animation_controller_animated_frame_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
_efl_canvas_image_efl_gfx_image_animation_controller_animated_frame_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_frame_get(eo_obj);
}
@ -784,7 +784,7 @@ _efl_canvas_image_efl_object_dbg_info_get(Eo *obj, void *pd EINA_UNUSED, Efl_Dbg
{
efl_dbg_info_get(efl_super(obj, MY_CLASS), root);
if ((efl_file_load_error_get(obj) != EFL_IMAGE_LOAD_ERROR_NONE) &&
if ((efl_file_load_error_get(obj) != EFL_GFX_IMAGE_LOAD_ERROR_NONE) &&
(root))
{
Efl_Dbg_Info *group = EFL_DBG_INFO_LIST_APPEND(root, MY_CLASS_NAME);

32
src/lib/evas/canvas/efl_canvas_image.eo
View File

@ -1,5 +1,5 @@
class Efl.Canvas.Image (Efl.Canvas.Image_Internal, Efl.Gfx.Buffer,
Efl.Image_Load_Controller, Efl.Image_Animation_Controller,
Efl.Gfx.Image_Load_Controller, Efl.Gfx.Image_Animation_Controller,
Efl.File)
{
[[Low-level Image object.
@ -18,20 +18,20 @@ class Efl.Canvas.Image (Efl.Canvas.Image_Internal, Efl.Gfx.Buffer,
Efl.Gfx.Buffer.buffer_unmap;
Efl.File.mmap { get; set; }
Efl.File.load_error { get; }
Efl.Image_Animation_Controller.animated { get; }
Efl.Image_Animation_Controller.animated_frame { get; set; }
Efl.Image_Animation_Controller.animated_frame_count { get; }
Efl.Image_Animation_Controller.animated_loop_type { get; }
Efl.Image_Animation_Controller.animated_loop_count { get; }
Efl.Image_Animation_Controller.animated_frame_duration { get; }
Efl.Image_Load_Controller.load_async_start;
Efl.Image_Load_Controller.load_async_cancel;
Efl.Image_Load_Controller.load_dpi { get; set; }
Efl.Image_Load_Controller.load_size { get; set; }
Efl.Image_Load_Controller.load_orientation { get; set; }
Efl.Image_Load_Controller.load_scale_down { get; set; }
Efl.Image_Load_Controller.load_skip_header { get; set; }
Efl.Image_Load_Controller.load_region { get; set; }
Efl.Image_Load_Controller.load_region_support { get; }
Efl.Gfx.Image_Animation_Controller.animated { get; }
Efl.Gfx.Image_Animation_Controller.animated_frame { get; set; }
Efl.Gfx.Image_Animation_Controller.animated_frame_count { get; }
Efl.Gfx.Image_Animation_Controller.animated_loop_type { get; }
Efl.Gfx.Image_Animation_Controller.animated_loop_count { get; }
Efl.Gfx.Image_Animation_Controller.animated_frame_duration { get; }
Efl.Gfx.Image_Load_Controller.load_async_start;
Efl.Gfx.Image_Load_Controller.load_async_cancel;
Efl.Gfx.Image_Load_Controller.load_dpi { get; set; }
Efl.Gfx.Image_Load_Controller.load_size { get; set; }
Efl.Gfx.Image_Load_Controller.load_orientation { get; set; }
Efl.Gfx.Image_Load_Controller.load_scale_down { get; set; }
Efl.Gfx.Image_Load_Controller.load_skip_header { get; set; }
Efl.Gfx.Image_Load_Controller.load_region { get; set; }
Efl.Gfx.Image_Load_Controller.load_region_support { get; }
}
}

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

@ -1,5 +1,5 @@
abstract Efl.Canvas.Image_Internal (Efl.Canvas.Object, Efl.Canvas.Filter.Internal,
Efl.Image, Efl.Gfx.Buffer,
Efl.Gfx.Image, Efl.Gfx.Buffer,
Efl.Gfx.Fill, Efl.Gfx.View,
Efl.Orientation, Efl.File)
{
@ -13,14 +13,14 @@ abstract Efl.Canvas.Image_Internal (Efl.Canvas.Object, Efl.Canvas.Filter.Interna
Efl.File.save;
Efl.Orientation.orientation { get; set; }
Efl.Orientation.flip { get; set; }
Efl.Image.smooth_scale { get; set; }
Efl.Image.ratio { get; }
Efl.Image.border { get; set; }
Efl.Image.border_scale { get; set; }
Efl.Image.border_center_fill { get; set; }
Efl.Image.scale_hint { get; set; }
Efl.Image.content_hint { get; set; }
Efl.Image.image_size { get; }
Efl.Gfx.Image.smooth_scale { get; set; }
Efl.Gfx.Image.ratio { get; }
Efl.Gfx.Image.border { get; set; }
Efl.Gfx.Image.border_scale { get; set; }
Efl.Gfx.Image.border_center_fill { get; set; }
Efl.Gfx.Image.scale_hint { get; set; }
Efl.Gfx.Image.content_hint { get; set; }
Efl.Gfx.Image.image_size { get; }
Efl.Gfx.Buffer.alpha { get; set; }
Efl.Gfx.Buffer.buffer_update_add;
Efl.Gfx.Buffer.colorspace { get; }

6
src/lib/evas/canvas/evas_callbacks.c
View File

@ -58,17 +58,17 @@ DEFINE_EVAS_CALLBACKS(_legacy_evas_callback_table, EVAS_CALLBACK_LAST,
EVAS_OBJECT_EVENT_DEL,
EFL_EVENT_HOLD,
EFL_GFX_ENTITY_EVENT_CHANGE_SIZE_HINTS,
EFL_IMAGE_EVENT_PRELOAD,
EFL_GFX_IMAGE_EVENT_PRELOAD,
EFL_CANVAS_SCENE_EVENT_FOCUS_IN,
EFL_CANVAS_SCENE_EVENT_FOCUS_OUT,
EVAS_CANVAS_EVENT_RENDER_FLUSH_PRE,
EVAS_CANVAS_EVENT_RENDER_FLUSH_POST,
EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_IN,
EFL_CANVAS_SCENE_EVENT_OBJECT_FOCUS_OUT,
EFL_IMAGE_EVENT_UNLOAD,
EFL_GFX_IMAGE_EVENT_UNLOAD,
EFL_CANVAS_SCENE_EVENT_RENDER_PRE,
EFL_CANVAS_SCENE_EVENT_RENDER_POST,
EFL_IMAGE_EVENT_RESIZE,
EFL_GFX_IMAGE_EVENT_RESIZE,
EFL_CANVAS_SCENE_EVENT_DEVICE_CHANGED,
EFL_EVENT_POINTER_AXIS,
EVAS_CANVAS_EVENT_VIEWPORT_RESIZE );

24
src/lib/evas/canvas/evas_image_legacy.c
View File

@ -118,42 +118,42 @@ EAPI void
evas_object_image_border_set(Evas_Object *obj, int l, int r, int t, int b)
{
EVAS_IMAGE_API(obj);
efl_image_border_set(obj, l, r, t, b);
efl_gfx_image_border_set(obj, l, r, t, b);
}
EAPI void
evas_object_image_border_get(const Evas_Object *obj, int *l, int *r, int *t, int *b)
{
EVAS_IMAGE_API(obj);
efl_image_border_get(obj, l, r, t, b);
efl_gfx_image_border_get(obj, l, r, t, b);
}
EAPI void
evas_object_image_border_scale_set(Evas_Object *obj, double scale)
{
EVAS_IMAGE_API(obj);
efl_image_border_scale_set(obj, scale);
efl_gfx_image_border_scale_set(obj, scale);
}
EAPI double
evas_object_image_border_scale_get(const Evas_Object *obj)
{
EVAS_IMAGE_API(obj, 1.0);
return efl_image_border_scale_get(obj);
return efl_gfx_image_border_scale_get(obj);
}
EAPI void
evas_object_image_border_center_fill_set(Evas_Object *obj, Evas_Border_Fill_Mode fill)
{
EVAS_IMAGE_API(obj);
efl_image_border_center_fill_set(obj, (Efl_Gfx_Border_Fill_Mode) fill);
efl_gfx_image_border_center_fill_set(obj, (Efl_Gfx_Border_Fill_Mode) fill);
}
EAPI Evas_Border_Fill_Mode
evas_object_image_border_center_fill_get(const Evas_Object *obj)
{
EVAS_IMAGE_API(obj, EVAS_BORDER_FILL_DEFAULT);
return (Evas_Border_Fill_Mode) efl_image_border_center_fill_get(obj);
return (Evas_Border_Fill_Mode) efl_gfx_image_border_center_fill_get(obj);
}
EAPI void
@ -370,14 +370,14 @@ EAPI void
evas_object_image_smooth_scale_set(Evas_Object *obj, Eina_Bool smooth_scale)
{
EVAS_IMAGE_API(obj);
efl_image_smooth_scale_set(obj, smooth_scale);
efl_gfx_image_smooth_scale_set(obj, smooth_scale);
}
EAPI Eina_Bool
evas_object_image_smooth_scale_get(const Evas_Object *obj)
{
EVAS_IMAGE_API(obj, EINA_FALSE);
return efl_image_smooth_scale_get(obj);
return efl_gfx_image_smooth_scale_get(obj);
}
EAPI void
@ -475,28 +475,28 @@ EAPI void
evas_object_image_content_hint_set(Evas_Object *obj, Evas_Image_Content_Hint hint)
{
EVAS_IMAGE_API(obj);
return efl_image_content_hint_set(obj, hint);
return efl_gfx_image_content_hint_set(obj, hint);
}
EAPI Evas_Image_Content_Hint
evas_object_image_content_hint_get(const Evas_Object *obj)
{
EVAS_IMAGE_API(obj, EVAS_IMAGE_CONTENT_HINT_NONE);
return efl_image_content_hint_get(obj);
return efl_gfx_image_content_hint_get(obj);
}
EAPI void
evas_object_image_scale_hint_set(Evas_Object *obj, Evas_Image_Scale_Hint hint)
{
EVAS_IMAGE_API(obj);
return efl_image_scale_hint_set(obj, (Efl_Image_Scale_Hint) hint);
return efl_gfx_image_scale_hint_set(obj, (Efl_Gfx_Image_Scale_Hint) hint);
}
EAPI Evas_Image_Scale_Hint
evas_object_image_scale_hint_get(const Evas_Object *obj)
{
EVAS_IMAGE_API(obj, EVAS_IMAGE_SCALE_HINT_NONE);
return (Evas_Image_Scale_Hint) efl_image_scale_hint_get(obj);
return (Evas_Image_Scale_Hint) efl_gfx_image_scale_hint_get(obj);
}
EAPI void

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

@ -111,8 +111,8 @@ struct _Evas_Image_Data
int pixels_checked_out;
int load_error;
Efl_Image_Scale_Hint scale_hint;
Efl_Image_Content_Hint content_hint;
Efl_Gfx_Image_Scale_Hint scale_hint;
Efl_Gfx_Image_Content_Hint content_hint;
Efl_Flip flip_value;
Efl_Orient orient_value;
@ -163,7 +163,7 @@ Eina_Bool _evas_image_file_set(Eo *eo_obj, const char *file, const char *key);
void _evas_image_file_get(const Eo *eo_obj, const char **file, const char **key);
/* Efl.Image.Load */
Efl_Image_Load_Error _evas_image_load_error_get(const Eo *eo_obj);
Efl_Gfx_Image_Load_Error _evas_image_load_error_get(const Eo *eo_obj);
void _evas_image_load_post_update(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj);
void _evas_image_load_async_start(Eo *eo_obj);
void _evas_image_load_async_cancel(Eo *eo_obj);
@ -185,7 +185,7 @@ void _evas_image_orientation_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Orie
/* Efl.Image_Animation_Controller */
Eina_Bool _evas_image_animated_get(const Eo *eo_obj);
int _evas_image_animated_frame_count_get(const Eo *eo_obj);
Efl_Image_Animation_Controller_Loop_Hint _evas_image_animated_loop_type_get(const Eo *eo_obj);
Efl_Gfx_Image_Animation_Controller_Loop_Hint _evas_image_animated_loop_type_get(const Eo *eo_obj);
int _evas_image_animated_loop_count_get(const Eo *eo_obj);
double _evas_image_animated_frame_duration_get(const Eo *eo_obj, int start_frame, int frame_num);
Eina_Bool _evas_image_animated_frame_set(Eo *eo_obj, int frame_index);

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

@ -504,7 +504,7 @@ _efl_canvas_image_internal_efl_object_dbg_info_get(Eo *eo_obj, Evas_Image_Data *
}
EOLIAN static void
_efl_canvas_image_internal_efl_image_border_set(Eo *eo_obj, Evas_Image_Data *o, int l, int r, int t, int b)
_efl_canvas_image_internal_efl_gfx_image_border_set(Eo *eo_obj, Evas_Image_Data *o, int l, int r, int t, int b)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
@ -531,7 +531,7 @@ _efl_canvas_image_internal_efl_image_border_set(Eo *eo_obj, Evas_Image_Data *o,
}
EOLIAN static void
_efl_canvas_image_internal_efl_image_border_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *l, int *r, int *t, int *b)
_efl_canvas_image_internal_efl_gfx_image_border_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *l, int *r, int *t, int *b)
{
if (l) *l = o->cur->border.l;
if (r) *r = o->cur->border.r;
@ -540,7 +540,7 @@ _efl_canvas_image_internal_efl_image_border_get(const Eo *eo_obj EINA_UNUSED, Ev
}
EOLIAN static void
_efl_canvas_image_internal_efl_image_border_center_fill_set(Eo *eo_obj, Evas_Image_Data *o, Efl_Gfx_Border_Fill_Mode _fill)
_efl_canvas_image_internal_efl_gfx_image_border_center_fill_set(Eo *eo_obj, Evas_Image_Data *o, Efl_Gfx_Border_Fill_Mode _fill)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
Evas_Border_Fill_Mode fill = (Evas_Border_Fill_Mode)_fill;
@ -556,7 +556,7 @@ _efl_canvas_image_internal_efl_image_border_center_fill_set(Eo *eo_obj, Evas_Ima
}
EOLIAN static Efl_Gfx_Border_Fill_Mode
_efl_canvas_image_internal_efl_image_border_center_fill_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_efl_canvas_image_internal_efl_gfx_image_border_center_fill_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return (Efl_Gfx_Border_Fill_Mode)o->cur->border.fill;
}
@ -594,7 +594,7 @@ _efl_canvas_image_internal_efl_gfx_fill_fill_auto_get(const Eo *eo_obj EINA_UNUS
}
EOLIAN static void
_efl_canvas_image_internal_efl_image_border_scale_set(Eo *eo_obj, Evas_Image_Data *o, double scale)
_efl_canvas_image_internal_efl_gfx_image_border_scale_set(Eo *eo_obj, Evas_Image_Data *o, double scale)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
@ -609,7 +609,7 @@ _efl_canvas_image_internal_efl_image_border_scale_set(Eo *eo_obj, Evas_Image_Dat
}
EOLIAN static double
_efl_canvas_image_internal_efl_image_border_scale_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_efl_canvas_image_internal_efl_gfx_image_border_scale_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->border.scale;
}
@ -660,7 +660,7 @@ _efl_canvas_image_internal_efl_gfx_fill_fill_get(const Eo *eo_obj EINA_UNUSED, E
}
EOLIAN static Eina_Size2D
_efl_canvas_image_internal_efl_image_image_size_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_efl_canvas_image_internal_efl_gfx_image_image_size_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return EINA_SIZE2D(o->file_size.w, o->file_size.h);
}
@ -827,7 +827,7 @@ _efl_canvas_image_internal_efl_gfx_buffer_alpha_get(const Eo *eo_obj EINA_UNUSED
}
EOLIAN static void
_efl_canvas_image_internal_efl_image_smooth_scale_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool smooth_scale)
_efl_canvas_image_internal_efl_gfx_image_smooth_scale_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool smooth_scale)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
@ -844,13 +844,13 @@ _efl_canvas_image_internal_efl_image_smooth_scale_set(Eo *eo_obj, Evas_Image_Dat
}
EOLIAN static Eina_Bool
_efl_canvas_image_internal_efl_image_smooth_scale_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_efl_canvas_image_internal_efl_gfx_image_smooth_scale_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->smooth_scale;
}
EOLIAN static double
_efl_canvas_image_internal_efl_image_ratio_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_efl_canvas_image_internal_efl_gfx_image_ratio_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
if (!o->cur->image.h) return 1.0;
return (double)o->cur->image.w / (double)o->cur->image.h;
@ -1050,7 +1050,7 @@ _evas_image_native_surface_get(const Evas_Object *eo_obj)
}
EOLIAN static void
_efl_canvas_image_internal_efl_image_scale_hint_set(Eo *eo_obj, Evas_Image_Data *o, Efl_Image_Scale_Hint hint)
_efl_canvas_image_internal_efl_gfx_image_scale_hint_set(Eo *eo_obj, Evas_Image_Data *o, Efl_Gfx_Image_Scale_Hint hint)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
evas_object_async_block(obj);
@ -1076,14 +1076,14 @@ _efl_canvas_image_internal_efl_image_scale_hint_set(Eo *eo_obj, Evas_Image_Data
}
}
EOLIAN static Efl_Image_Scale_Hint
_efl_canvas_image_internal_efl_image_scale_hint_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
EOLIAN static Efl_Gfx_Image_Scale_Hint
_efl_canvas_image_internal_efl_gfx_image_scale_hint_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->scale_hint;
}
EOLIAN static void
_efl_canvas_image_internal_efl_image_content_hint_set(Eo *eo_obj, Evas_Image_Data *o, Efl_Image_Content_Hint hint)
_efl_canvas_image_internal_efl_gfx_image_content_hint_set(Eo *eo_obj, Evas_Image_Data *o, Efl_Gfx_Image_Content_Hint hint)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
evas_object_async_block(obj);
@ -1109,8 +1109,8 @@ _efl_canvas_image_internal_efl_image_content_hint_set(Eo *eo_obj, Evas_Image_Dat
}
}
EOLIAN static Efl_Image_Content_Hint
_efl_canvas_image_internal_efl_image_content_hint_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
EOLIAN static Efl_Gfx_Image_Content_Hint
_efl_canvas_image_internal_efl_gfx_image_content_hint_get(const Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->content_hint;
}

6
src/lib/evas/canvas/evas_object_inform.c
View File

@ -72,7 +72,7 @@ evas_object_inform_call_image_preloaded(Evas_Object *eo_obj)
_evas_object_image_preloading_set(eo_obj, 0);
event_id = _evas_object_event_new();
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_PRELOADED, NULL, event_id, EFL_IMAGE_EVENT_PRELOAD);
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_PRELOADED, NULL, event_id, EFL_GFX_IMAGE_EVENT_PRELOAD);
_evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas, event_id);
}
@ -82,7 +82,7 @@ evas_object_inform_call_image_unloaded(Evas_Object *eo_obj)
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
int event_id = _evas_object_event_new();
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_UNLOADED, NULL, event_id, EFL_IMAGE_EVENT_UNLOAD);
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_UNLOADED, NULL, event_id, EFL_GFX_IMAGE_EVENT_UNLOAD);
_evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas, event_id);
}
@ -92,6 +92,6 @@ evas_object_inform_call_image_resize(Evas_Object *eo_obj)
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
int event_id = _evas_object_event_new();
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_RESIZE, NULL, event_id, EFL_IMAGE_EVENT_RESIZE);
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_IMAGE_RESIZE, NULL, event_id, EFL_GFX_IMAGE_EVENT_RESIZE);
_evas_post_event_callback_call(obj->layer->evas->evas, obj->layer->evas, event_id);
}

2
src/modules/evas/vg_savers/svg/evas_vg_save_svg.c
View File

@ -138,7 +138,7 @@ evas_vg_save_file_svg(Vg_File_Data *evg_data, const char *file, const char *key
if (!f)
{
ERR("Cannot open file '%s' for SVG save", file);
return EFL_IMAGE_LOAD_ERROR_GENERIC;
return EFL_GFX_IMAGE_LOAD_ERROR_GENERIC;
}
root = vg_common_create_svg_node(evg_data);