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

Efl.Gfx.Buffer: Add interface skeletton

This commit is contained in:
Jean-Philippe Andre 2016-03-02 20:46:11 +09:00
parent e3de15d726
commit b458341a13
13 changed files with 1205 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile_Efl.am
View File

@ -9,11 +9,13 @@ efl_eolian_files = \
lib/efl/interfaces/efl_control.eo \
lib/efl/interfaces/efl_file.eo \
lib/efl/interfaces/efl_image.eo \
lib/efl/interfaces/efl_image_load.eo \
lib/efl/interfaces/efl_player.eo \
lib/efl/interfaces/efl_text.eo \
lib/efl/interfaces/efl_text_properties.eo \
lib/efl/interfaces/efl_gfx_stack.eo \
lib/efl/interfaces/efl_gfx_view.eo \
lib/efl/interfaces/efl_gfx_buffer.eo \
lib/efl/interfaces/efl_gfx_shape.eo \
lib/efl/interfaces/efl_gfx_gradient_base.eo \
lib/efl/interfaces/efl_gfx_gradient_linear.eo \

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

@ -59,6 +59,7 @@ typedef Efl_Gfx_Path_Command_Type Efl_Gfx_Path_Command;
#include "interfaces/efl_file.eo.h"
#include "interfaces/efl_image.eo.h"
#include "interfaces/efl_image_animated.eo.h"
#include "interfaces/efl_image_load.eo.h"
#include "interfaces/efl_player.eo.h"
#include "interfaces/efl_text.eo.h"
#include "interfaces/efl_text_properties.eo.h"
@ -73,6 +74,7 @@ EAPI extern const Eo_Event_Description _EFL_GFX_PATH_CHANGED;
#define EFL_GFX_PATH_CHANGED (&(_EFL_GFX_PATH_CHANGED))
#include "interfaces/efl_gfx_base.eo.h"
#include "interfaces/efl_gfx_buffer.eo.h"
#include "interfaces/efl_gfx_stack.eo.h"
#include "interfaces/efl_gfx_fill.eo.h"
#include "interfaces/efl_gfx_view.eo.h"
@ -99,9 +101,9 @@ static inline void efl_gfx_color16_type_set(Efl_Gfx_Color *color,
#ifndef EFL_NOLEGACY_API_SUPPORT
#include "interfaces/efl_gfx_types.eot.h"
#include "interfaces/efl_image_animated.eo.legacy.h"
#include "interfaces/efl_gfx_fill.eo.legacy.h"
#include "interfaces/efl_gfx_base.eo.legacy.h"
#include "interfaces/efl_image_animated.eo.legacy.h"
#endif
typedef Efl_Gfx_Path_Command_Type Efl_Gfx_Path_Command;

165
src/lib/efl/interfaces/efl_gfx_buffer.eo Normal file
View File

@ -0,0 +1,165 @@
import efl_gfx_types;
/* FIXME: this is very very low level. expose to apps? */
enum Efl.Gfx.Buffer.Access_Mode {
none = 0x0,
read = 0x1,
write = 0x2,
cow = 0x4, [[Forces copy-on-write if already mapped as read-only. Requires write.]]
}
interface Efl.Gfx.Buffer ()
{
[[Common APIs for all objects representing images and 2D pixel buffers.]]
legacy_prefix: null;
methods {
@property buffer_size {
[[Rectangular size of the pixel buffer as allocated in memory.]]
set {
[[Potentially not implemented, @.buffer_size may be read-only.]]
}
get {}
values {
w: int; [[Width in pixels.]]
h: int; [[Height in pixels.]]
}
}
@property colorspace {
[[The colorspace defines how pixels are encoded in the image in memory.
By default, images are encoded in 32-bit BGRA, ie. each pixel takes
4 bytes in memory, with each channel B,G,R,A encoding the color with
values from 0 to 255.
All images used in EFL use alpha-premultipied BGRA values, which
means that for each pixel, B <= A, G <= A and R <= A.
]]
get {
[[Returns the current encoding of this buffer's pixels.
See @Efl.Gfx.Colorspace for more information on the supported
formats.
]]
}
values {
cspace: Efl.Gfx.Colorspace;
}
}
@property buffer_stride {
[[Length in bytes of one row of pixels in memory.
Usually this will be equal to width * 4, with a plain BGRA image.
This may return 0 if the stride is not applicable.
When applicable, this will include the @.buffer_borders as well
as potential extra padding.
]]
get {}
values {
stride: int;
}
}
buffer_update_region_add {
[[Mark a sub-region of the given image object to be redrawn.
This function schedules a particular rectangular region of an
image object to be updated (redrawn) at the next rendering cycle.
]]
params {
@in x: int; [[X-offset of the region to be updated.]]
@in y: int; [[Y-offset of the region to be updated.]]
@in w: int; [[Width of the region to be updated.]]
@in h: int; [[Height of the region to be updated.]]
}
}
/* FIXME: too low-level? */
@property buffer_borders {
[[Duplicated pixel borders inside this buffer.
Internally, EFL may require an image to have its border pixels
duplicated, in particular for GL textures. This property exposes
the internal duplicated borders to allow calling @.buffer_map
with the entire pixel data, including those edge pixels.
]]
get {}
values {
l: uint(0); [[Left border pixels, usually 0 or 1]]
r: uint(0); [[Right border pixels, usually 0 or 1]]
t: uint(0); [[Top border pixels, usually 0 or 1]]
b: uint(0); [[Bottom border pixels, usually 0 or 1]]
}
}
/* FIXME: split into read-only and writeable methods? */
/* FIXME: This was copy pasta from ector generic buffer. changed a bit. */
buffer_map {
[[Map a region of this buffer for read or write access by the CPU.
Fetches data from the GPU if needed. This operation may be slow if
cpu_readable_fast or cpu_writeable_fast are not true, or if the
required colorspace is different from the internal one.
Note that if the buffer has @.buffer_borders, then $x and $y may
be negative.
]]
params {
@out length: uint @nonull; [[Accessible buffer size in bytes, should not be $null.]]
@in mode: Efl.Gfx.Buffer.Access_Mode; [[Specifies whether to map for read-only,
write-only or read-write access (OR combinaison of flags).]]
@in x: int @optional; [[X position of the top-left pixel to map, defaults to 0.]]
@in y: int @optional; [[Y position of the top-left pixel to map, defaults to 0.]]
@in w: uint @optional; [[If 0, defaults to the buffer width.]]
@in h: uint @optional; [[If 0, defaults to the buffer height.]]
@in cspace: Efl.Gfx.Colorspace @optional; [[Requested colorspace. If differen from the internal cspace,
map should try to convert the data into a new buffer.
argb8888 by default.]]
@out stride: uint @optional; [[Returns the length in bytes of a mapped line]]
}
return: ubyte* @warn_unused; [[Pointer to the top-left pixel data. Returns $null in case of failure]]
}
buffer_unmap {
[[Unmap a region of this buffer, and update the internal data if needed.
EFL will update the internal image if the map had write access.
]]
params {
@in data: ubyte*; [[Data pointer returned by a previous call to map]]
@in length: uint; [[Must be the same as returned by map.]]
}
}
buffer_set {
[[Set the pixels for this buffer, or allocate a new memory region.
EFL will copy the $pixels to an internal buffer, and update the
GPU-side texture if required. This will mark the image as dirty.
If $pixels is $null, then a new empty buffer will be allocated.
If the buffer already had pixel data, the previous image data will
be dropped and the internal buffer may be resized to fit the new
pixel data.
Note: Use @Efl.Gfx.Buffer.buffer_size.set and @.buffer_map to
request EFL to allocate the buffer itself, instead of using this
function.
]]
params {
@in pixels: ubyte*; [[If $null, allocates an empty buffer]]
@in width: int;
@in height: int;
@in stride: int @optional; [[If 0, automatically guessed from the width.]]
@in cspace: Efl.Gfx.Colorspace @optional; [[argb8888 by default.]]
@in l: uint @optional; [[Left border pixels, usually 0 or 1]]
@in r: uint @optional; [[Right border pixels, usually 0 or 1]]
@in t: uint @optional; [[Top border pixels, usually 0 or 1]]
@in b: uint @optional; [[Bottom border pixels, usually 0 or 1]]
}
return: bool;
}
/* Note: border, span and buffer flags not imported from ector buffer */
}
}

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

@ -133,3 +133,27 @@ struct Efl.Gfx.Shape.Public
{
stroke: Efl.Gfx.Stroke;
}
enum Efl.Gfx.Border_Fill_Mode
{
[[How an image's center region (the complement to the border region) should be rendered by EFL]]
none = 0, [[Image's center region is $b not to be rendered]]
default = 1, [[Image's center region is to be $b blended with objects underneath it, if it has transparency. This is the default behavior for image objects]]
solid = 2 [[Image's center region is to be made solid, even if it has transparency on it]]
}
enum Efl.Gfx.Orientation
{
[[Orientation options for $Efl.Image.orientation
@since 1.14]]
/* FIXME: legacy: evas_image; */
orient_none = 0, [[no orientation change]]
orient_0 = 0, [[no orientation change]]
orient_90 = 1, [[orient 90 degrees clockwise]]
orient_180 = 2, [[orient 180 degrees clockwise]]
orient_270 = 3, [[rotate 90 degrees counter-clockwise (i.e. 270 degrees clockwise)]]
flip_horizontal = 4, [[flip image horizontally]]
flip_vertical = 5, [[flip image vertically]]
flip_transpose = 6, [[flip image along the y = (width - x) line (bottom-left to top-right)]]
flip_transverse = 7 [[flip image along the y = x line (top-left to bottom-right)]]
}

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

@ -5,6 +5,10 @@ interface Efl.Gfx.View {
@property view_size {
[[The dimensions of this object's viewport.
FIXME
WRONG DOC!!!
USELESS API for image files
This property will scale down or crop the image so that it is
treated as if it were of the given size. If the given size is
smaller than the image, it will be cropped. If it's larger, then

124
src/lib/efl/interfaces/efl_image.eo
View File

@ -1,22 +1,9 @@
interface Efl.Image {
interface Efl.Image ()
{
[[Common APIs for all 2D images that can be rendered on the canvas.]]
legacy_prefix: null;
methods {
@property load_size {
[[The loading size of an image.
The image will be loaded into memory as if it was the set size
instead of the original size. This can save a lot of memory,
and is important for scalable types like svg.
]]
set {
[[Requests the canvas to load the image at the given size.]]
}
get {}
values {
w: int; [[Width of the image's load size.]]
h: int; [[Height of the image's load size.]]
}
}
methods {
@property smooth_scale {
[[Whether to use high-quality image scaling algorithm for this image.
@ -33,6 +20,30 @@ interface Efl.Image {
smooth_scale: bool; [[Whether to use smooth scale or not.]]
}
}
@property alpha {
[[Indicates whether the alpha channel should be used.
This does not indicate whether the image source file contains
an alpha channel, only whether to respect it or discard it.
]]
set {
[[Change alpha channel usage for this object.
This function sets a flag on an image object indicating
whether or not to use alpha channel data. A value of $true
makes it use alpha channel data, and $false makes it ignore
that data. Note that this has nothing to do with an object's
color as manipulated by @Efl.Gfx.Base.color.set.
]]
}
get {
[[Retrieve whether alpha channel data is used on this object.]]
}
values {
alpha: bool; [[Whether to use alpha channel ($true) data
or not ($false).]]
}
}
@property ratio {
[[The native width/height ratio of the image.]]
get {
@ -42,5 +53,84 @@ interface Efl.Image {
ratio: double; [[The image's ratio.]]
}
}
@property orientation {
[[The image orientation allows rotating and flipping the image
at render time.
Default is @Efl.Gfx.Orientation.orient_none
@since 1.14
]]
set {}
get {}
values {
orient: Efl.Gfx.Orientation;
}
}
@property border {
[[Dimensions of this image's border, a region that does not scale
with the center area.
When EFL renders an image, its source may be scaled to fit
the size of the object. This function sets an area from
the borders of the image inwards which is not to be scaled.
This function is useful for making frames and for widget
theming, where, for example, buttons may be of varying
sizes, but their border size must remain constant.
The units used for $l, $r, $t and $b are canvas units (pixels).
Note: The border region itself may be scaled by the
@.border_scale.set function.
Note: By default, image objects have no borders set, i.e.
$l, $r, $t and $b start as 0.
Note: Similar to the concepts of 9-patch images or cap insets.
]]
set {}
get {}
values {
l: int; [[The border's left width.]]
r: int; [[The border's right width.]]
t: int; [[The border's top height.]]
b: int; [[The border's bottom height.]]
}
}
@property border_scale {
[[Scaling factor applied to the image borders.
This value multiplies the size of the @.border when scaling an
object.
Default value is 1.0 (no scaling).
]]
set {}
get {}
values {
scale: double; [[The scale factor.]]
}
}
@property border_center_fill {
[[Specifies how the center part of the object (not the borders)
should be drawn when EFL is rendering it.
This function sets how the center part of the image object's
source image is to be drawn, which must be one of the values
in @Efl.Gfx.Border_Fill_Mode. By center we mean the complementary
part of that defined by @.border.set. This is very useful for
making frames and decorations. You would most probably also be
using a filled image (as in @Efl.Gfx.Fill.filled) to use as a frame.
The default value is @Efl.Gfx.Border_Fill_Mode.default, ie. render
and scale the center area, respecting its transparency.
]]
set {}
get {}
values {
fill: Efl.Gfx.Border_Fill_Mode; [[Fill mode of the center region.]]
}
}
}
}

203
src/lib/efl/interfaces/efl_image_load.eo Normal file
View File

@ -0,0 +1,203 @@
/* FIXME: maybe add error code for "currently running" or "pending" ? */
enum Efl.Image_Load.Error
{
none = 0, [[No error on load]]
generic = 1, [[A non-specific error occurred]]
does_not_exist = 2, [[File (or file path) does not exist]]
permission_denied = 3, [[Permission denied to an existing file (or path)]]
resource_allocation_failed = 4, [[Allocation of resources failure prevented load]]
corrupt_file = 5, [[File corrupt (but was detected as a known format)]]
unknown_format = 6 [[File is not a known format]]
}
/* FIXME: state or status??? */
enum Efl.Image_Load.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.load_error.get to know why.]]
cancelled = 5 [[Image load has been cancelled.]]
}
/* FIXME: Efl.Image.Load */
interface Efl.Image_Load ()
{
[[Common APIs for all loadable 2D images.]]
legacy_prefix: null;
methods {
load_async_start {
[[Begin preloading an image object's image data in the background.
Once the background task is done, the event $load,done will be
emitted.
]]
}
load_async_cancel {
[[Cancel preloading an image object's image data in the background.
The event $load,cancelled should be triggered soon after
cancellation happened, and the object should be left in a state
where it has no image data. If cancel is called too late, the image
will be kept in memory.
]]
}
@property load_state {
get {
[[Queries information on the current state of load of the image.
While more relevant to asynchronous load, this will also return
meaningful information about the last synchronous load.
]]
}
values {
state: Efl.Image_Load.State;
}
}
@property load_size {
[[The load size of an image.
The image will be loaded into memory as if it was the specified
size instead of its original size. This can save a lot of memory,
and is important for scalable types like svg.
By default, the load size is not specified, so it is 0x0.
]]
set {
[[Requests the canvas to load the image at the given size.
EFL will try to load the image at the requested size, but does
not garantee an exact match between the request and the loaded
image dimensions.
]]
}
get {
[[Returns the requested load size.]]
}
values {
w: int; [[Width of the image's load size.]]
h: int; [[Height of the image's load size.]]
}
}
@property load_dpi {
set {
[[Set the DPI resolution of an image object's source image.
This function sets the DPI resolution of a given loaded canvas
image. Most useful for the SVG image loader.
]]
}
get {
[[Get the DPI resolution of a loaded image object in the canvas.
This function returns the DPI resolution of the given canvas
image.
]]
}
values {
dpi: double; [[The DPI resolution.]]
}
}
@property load_region_support {
[[Indicates whether the @.load_region property is supported for the
current file.
@since 1.2
]]
get {}
values {
support: bool;
}
}
@property load_region {
set {
[[Inform a given image object to load a selective region of its
source image.
This function is useful when one is not showing all of an
image's area on its image object.
Note: The image loader for the image format in question has
to support selective region loading in order to this function
to take effect.
]]
}
get {
[[Retrieve the coordinates of a given image object's selective
(source image) load region.
Note: Use $null pointers on the coordinates you're not
interested in: they'll be ignored by the function.
]]
}
values {
x: int; [[X-offset of the region to be loaded.]]
y: int; [[Y-offset of the region to be loaded.]]
w: int; [[Width of the region to be loaded.]]
h: int; [[Height of the region to be loaded.]]
}
}
@property load_orientation {
[[Defines whether the orientation information in the image file
should be honored.
The orientation can for instance be set in the EXIF tags of a
JPEG image. If this flag is $false, then the orientation will be
ignored at load time, otherwise the image will be loaded with the
proper orientation.
@since 1.1
]]
set {}
get {}
values {
enable: bool; [[$true means that it should honor the orientation
information.]]
}
}
@property load_scale_down {
[[The scale down factor is a divider on the original image size.
Setting the scale down factor can reduce load time and memory usage,
at the cost of having a scaled down image in memory.
This function sets the scale down factor of a given canvas
image. Most useful for the SVG image loader, but also applies
to JPEG, PNG and BMP.
Powers of two (2, 4, 8) are best supported (especially with JPEG)
]]
set {
[[Requests the image loader to scale down by $div times.
Call this before starting the actual image load.
]]
}
get {}
values {
div: int; [[The scale down dividing factor.]]
}
}
/* FIXME: do we want this? or only rely on the events?
* what if preload is currently running?
*/
@property load_error {
get {
[[Retrieves a number representing any error that occurred during
the last loading of the given image object's source image.
]]
return: Efl.Image_Load.Error @warn_unused; [[
A value giving the last error that occurred, one of
@Efl.Image_Load.Error values. @Efl.Image_Load.Error.none is
returned if there was no error.
]]
}
}
}
events {
load,done;
load,error: Efl.Image_Load.Error;
load,cancelled;
}
}

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

@ -8,11 +8,13 @@
#include "interfaces/efl_file.eo.c"
#include "interfaces/efl_image.eo.c"
#include "interfaces/efl_image_animated.eo.c"
#include "interfaces/efl_image_load.eo.c"
#include "interfaces/efl_player.eo.c"
#include "interfaces/efl_text.eo.c"
#include "interfaces/efl_text_properties.eo.c"
#include "interfaces/efl_gfx_base.eo.c"
#include "interfaces/efl_gfx_buffer.eo.c"
#include "interfaces/efl_gfx_stack.eo.c"
#include "interfaces/efl_gfx_fill.eo.c"
#include "interfaces/efl_gfx_view.eo.c"

4
src/lib/emotion/emotion_object.eo
View File

@ -1,4 +1,4 @@
class Emotion.Object (Evas.Object_Smart, Efl.File, Efl.Player, Efl.Image) {
class Emotion.Object (Evas.Object_Smart, Efl.File, Efl.Player, Efl.Image, Efl.Image_Load) {
eo_prefix: emotion_obj;
methods {
@property option {
@ -74,7 +74,7 @@ class Emotion.Object (Evas.Object_Smart, Efl.File, Efl.Player, Efl.Image) {
Efl.Player.audio_mute.get;
Efl.Player.length.get;
Efl.Player.seekable.get;
Efl.Image.load_size.get;
Efl.Image_Load.load_size.get;
Efl.Image.ratio.get;
Efl.Image.smooth_scale.set;
Efl.Image.smooth_scale.get;

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

@ -748,7 +748,7 @@ emotion_object_size_get(const Evas_Object *obj, int *iw, int *ih)
}
EOLIAN static void
_emotion_object_efl_image_load_size_get(Eo *obj EINA_UNUSED, Emotion_Object_Data *sd, int *iw, int *ih)
_emotion_object_efl_image_load_load_size_get(Eo *obj EINA_UNUSED, Emotion_Object_Data *sd, int *iw, int *ih)
{
if (iw) *iw = sd->video.w;
if (ih) *ih = sd->video.h;

324
src/lib/evas/Evas_Legacy.h
View File

@ -2852,6 +2852,25 @@ EAPI int evas_object_image_animated_loop_count_get(const Evas_Object *obj);
*/
EAPI double evas_object_image_animated_frame_duration_get(const Evas_Object *obj, int start_frame, int frame_num);
/**
* @brief Set the DPI resolution of an image object's source image.
*
* This function sets the DPI resolution of a given loaded canvas image. Most
* useful for the SVG image loader.
*
* @param[in] dpi The DPI resolution.
*/
EAPI void evas_object_image_load_dpi_set(Evas_Object *obj, double dpi);
/**
* @brief Get the DPI resolution of a loaded image object in the canvas.
*
* This function returns the DPI resolution of the given canvas image.
*
* @return The DPI resolution.
*/
EAPI double evas_object_image_load_dpi_get(const Evas_Object *obj);
/**
*
* Set the load size of a given image object's source image.
@ -2889,6 +2908,98 @@ EAPI void evas_object_image_load_size_set(Eo *obj, int w, int h);
*/
EAPI void evas_object_image_load_size_get(const Eo *obj, int *w, int *h);
/**
* @brief Inform a given image object to load a selective region of its source
* image.
*
* This function is useful when one is not showing all of an image's area on
* its image object.
*
* @note The image loader for the image format in question has to support
* selective region loading in order to this function to take effect.
*
* @param[in] x X-offset of the region to be loaded.
* @param[in] y Y-offset of the region to be loaded.
* @param[in] w Width of the region to be loaded.
* @param[in] h Height of the region to be loaded.
*/
EAPI void evas_object_image_load_region_set(Evas_Object *obj, int x, int y, int w, int h);
/**
* @brief Retrieve the coordinates of a given image object's selective (source
* image) load region.
*
* @note Use @c null pointers on the coordinates you're not interested in:
* they'll be ignored by the function.
*
* @param[out] x X-offset of the region to be loaded.
* @param[out] y Y-offset of the region to be loaded.
* @param[out] w Width of the region to be loaded.
* @param[out] h Height of the region to be loaded.
*/
EAPI void evas_object_image_load_region_get(const Evas_Object *obj, int *x, int *y, int *w, int *h);
/**
* @brief Get the support state of a given image.
*
* @return The region support state.
*
* @since 1.2
*
* @ingroup Evas_Image
*/
EAPI Eina_Bool evas_object_image_region_support_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT;
/**
* @brief Define if the orientation information in the image file should be
* honored.
*
* @param[in] enable @c true means that it should honor the orientation
* information.
*
* @since 1.1
*/
EAPI void evas_object_image_load_orientation_set(Evas_Object *obj, Eina_Bool enable);
/**
* @brief Get if the orientation information in the image file should be
* honored.
*
* @return @c true means that it should honor the orientation information.
*
* @since 1.1
*/
EAPI Eina_Bool evas_object_image_load_orientation_get(const Evas_Object *obj);
/**
* @brief Set the scale down factor of a given image object's source image,
* when loading it.
*
* This function sets the scale down factor of a given canvas image. Most
* useful for the SVG image loader.
*
* @param[in] scale_down The scale down factor.
*/
EAPI void evas_object_image_load_scale_down_set(Evas_Object *obj, int scale_down);
/**
* @brief Get the scale down factor of a given image object's source image,
* when loading it.
*
* @return The scale down factor.
*/
EAPI int evas_object_image_load_scale_down_get(const Evas_Object *obj);
/**
* @brief Retrieves a number representing any error that occurred during the
* last loading of the given image object's source image.
*
* @return A value giving the last error that occurred. It should be one of the
* @ref Evas_Load_Error values. #EVAS_LOAD_ERROR_NONE is returned if there was
* no error.
*/
EAPI Evas_Load_Error evas_object_image_load_error_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT;
/**
*
* Sets whether to use high-quality image scaling algorithm on the
@ -3008,8 +3119,6 @@ EAPI void evas_object_image_fill_get(const Evas_Object *obj, Evas_Coord *x, Evas
*
* @param[in] filled @c true to make the fill property follow object size or
* @c false otherwise.
*
* @ingroup Evas_Image
*/
EAPI void evas_object_image_filled_set(Evas_Object *obj, Eina_Bool filled);
@ -3022,10 +3131,173 @@ EAPI void evas_object_image_filled_set(Evas_Object *obj, Eina_Bool filled);
*
* @return @c true to make the fill property follow object size or @c false
* otherwise.
*/
EAPI Eina_Bool evas_object_image_filled_get(const Evas_Object *obj);
/**
* @brief Retrieve whether alpha channel data is being used on the given image
* object.
*
* This function returns @c true if the image object's alpha channel is being
* used, or @c false otherwise.
*
* @return Whether to use alpha channel ($true) data or not ($false).
*
* @ingroup Evas_Image
*/
EAPI Eina_Bool evas_object_image_filled_get(const Evas_Object *obj);
EAPI Eina_Bool evas_object_image_alpha_get(const Evas_Object *obj);
/**
* @brief Enable or disable alpha channel usage on the given image object.
*
* This function sets a flag on an image object indicating whether or not to
* use alpha channel data. A value of @c true makes it use alpha channel data,
* and @c false makes it ignore that data. Note that this has nothing to do
* with an object's color as manipulated by @ref evas_object_color_set.
*
* @param[in] alpha Whether to use alpha channel ($true) data or not ($false).
*/
EAPI void evas_object_image_alpha_set(Evas_Object *obj, Eina_Bool alpha);
/**
* @brief Dimensions of this image's border, a region that does not scale with
* the center area.
*
* When EFL renders an image, its source may be scaled to fit the size of the
* object. This function sets an area from the borders of the image inwards
* which is not to be scaled. This function is useful for making frames and for
* widget theming, where, for example, buttons may be of varying sizes, but
* their border size must remain constant.
*
* The units used for @c l, @c r, @c t and @c b are canvas units (pixels).
*
* @note The border region itself may be scaled by the
* @ref evas_object_image_border_scale_set function.
*
* @note By default, image objects have no borders set, i.e. @c l, @c r, @c t
* and @c b start as 0.
*
* @note Similar to the concepts of 9-patch images or cap insets.
*
* @param[in] l The border's left width.
* @param[in] r The border's right width.
* @param[in] t The border's top height.
* @param[in] b The border's bottom height.
*/
EAPI void evas_object_image_border_set(Evas_Object *obj, int l, int r, int t, int b);
/**
* @brief Dimensions of this image's border, a region that does not scale with
* the center area.
*
* When EFL renders an image, its source may be scaled to fit the size of the
* object. This function sets an area from the borders of the image inwards
* which is not to be scaled. This function is useful for making frames and for
* widget theming, where, for example, buttons may be of varying sizes, but
* their border size must remain constant.
*
* The units used for @c l, @c r, @c t and @c b are canvas units (pixels).
*
* @note The border region itself may be scaled by the
* @ref evas_object_image_border_scale_set function.
*
* @note By default, image objects have no borders set, i.e. @c l, @c r, @c t
* and @c b start as 0.
*
* @note Similar to the concepts of 9-patch images or cap insets.
*
* @param[out] l The border's left width.
* @param[out] r The border's right width.
* @param[out] t The border's top height.
* @param[out] b The border's bottom height.
*/
EAPI void evas_object_image_border_get(const Evas_Object *obj, int *l, int *r, int *t, int *b);
/**
* @brief Scaling factor applied to the image borders.
*
* This value multiplies the size of the @ref evas_object_image_border_get when
* scaling an object.
*
* Default value is 1.0 (no scaling).
*
* @param[in] scale The scale factor.
*/
EAPI void evas_object_image_border_scale_set(Evas_Object *obj, double scale);
/**
* @brief Scaling factor applied to the image borders.
*
* This value multiplies the size of the @ref evas_object_image_border_get when
* scaling an object.
*
* Default value is 1.0 (no scaling).
*
* @return The scale factor.
*/
EAPI double evas_object_image_border_scale_get(const Evas_Object *obj);
/**
* @brief Specifies how the center part of the object (not the borders) should
* be drawn when EFL is rendering it.
*
* This function sets how the center part of the image object's source image is
* to be drawn, which must be one of the values in @ref Evas_Border_Fill_Mode.
* By center we mean the complementary part of that defined by
* @ref evas_object_image_border_set. This one is very useful for making frames
* and decorations. You would most probably also be using a filled image (as in
* @ref Efl.Gfx.Fill.filled) to use as a frame.
*
* The default value is
*
* @param[in] fill Fill mode of the center region of @c obj (a value in
* #Evas_Border_Fill_Mode).
*/
EAPI void evas_object_image_border_center_fill_set(Evas_Object *obj, Evas_Border_Fill_Mode fill);
/**
* @brief Specifies how the center part of the object (not the borders) should
* be drawn when EFL is rendering it.
*
* This function sets how the center part of the image object's source image is
* to be drawn, which must be one of the values in @ref Evas_Border_Fill_Mode.
* By center we mean the complementary part of that defined by
* @ref evas_object_image_border_set. This one is very useful for making frames
* and decorations. You would most probably also be using a filled image (as in
* @ref Efl.Gfx.Fill.filled) to use as a frame.
*
* The default value is
*
* @return Fill mode of the center region of @c obj (a value in
* #Evas_Border_Fill_Mode).
*/
EAPI Evas_Border_Fill_Mode evas_object_image_border_center_fill_get(const Evas_Object *obj);
/**
* @brief Set the image orientation.
*
* This function allows to rotate or flip the image.
*
* @param[in] orient The image orientation @ref Evas_Image_Orient. Default is
* #EVAS_IMAGE_ORIENT_NONE.
*
* @since 1.14
*
* @ingroup Evas_Image
*/
EAPI void evas_object_image_orient_set(Evas_Object *obj, Evas_Image_Orient orient);
/**
* @brief Get the image orientation.
*
* @return The image orientation @ref Evas_Image_Orient. Default is
* #EVAS_IMAGE_ORIENT_NONE.
*
* @since 1.14
*
* @ingroup Evas_Image
*/
EAPI Evas_Image_Orient evas_object_image_orient_get(const Evas_Object *obj);
/**
*
@ -3053,6 +3325,52 @@ EAPI void evas_object_image_size_set(Evas_Object *obj, int w, int h);
*/
EAPI void evas_object_image_size_get(const Evas_Object *obj, int *w, int *h);
/**
* @brief Set the colorspace of a given image of the canvas.
*
* This function sets the colorspace of given canvas image.
*
* @param[in] cspace The new color space.
*
* @ingroup Evas_Image
*/
EAPI void evas_object_image_colorspace_set(Evas_Object *obj, Evas_Colorspace cspace);
/**
* @brief Get the colorspace of a given image of the canvas.
*
* This function returns the colorspace of given canvas image.
*
* @return The new color space.
*
* @ingroup Evas_Image
*/
EAPI Evas_Colorspace evas_object_image_colorspace_get(const Evas_Object *obj);
/**
* @brief Retrieves the row stride of the given image object.
*
* The row stride is the number of bytes between the start of a row and the
* start of the next row for image data.
*
* @return The stride of the image (in bytes).
*
* @ingroup Evas_Image
*/
EAPI int evas_object_image_stride_get(const Evas_Object *obj) EINA_WARN_UNUSED_RESULT;
/**
* @brief Mark a sub-region of the given image object to be redrawn.
*
* This function schedules a particular rectangular region of an image object
* to be updated (redrawn) at the next rendering cycle.
*
* @param[in] y Y-offset of the region to be updated.
* @param[in] w Width of the region to be updated.
* @param[in] h Height of the region to be updated.
*/
EAPI void evas_object_image_data_update_add(Evas_Object *obj, int x, int y, int w, int h);
/*
* Converts the raw image data of the given image object to the
* specified colorspace.

555
src/lib/evas/canvas/evas_image.eo
View File

@ -1,30 +1,11 @@
type @extern Evas_Object_Image_Pixels_Get_Cb: __undefined_type; /* FIXME: func pointers are not supported. */
class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.Fill, Efl.Gfx.View, Evas.Filter)
class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Load, Efl.Image_Animated, Efl.Gfx.Buffer, Efl.Gfx.Fill, Efl.Gfx.View, Evas.Filter)
{
legacy_prefix: evas_object_image;
eo_prefix: evas_obj_image;
methods {
@property load_dpi {
set {
[[Set the DPI resolution of an image object's source image.
This function sets the DPI resolution of a given loaded canvas
image. Most useful for the SVG image loader.
]]
}
get {
[[Get the DPI resolution of a loaded image object in the canvas.
This function returns the DPI resolution of the given canvas
image.
]]
}
values {
dpi: double; [[The DPI resolution.]]
}
}
/* PROXY stuff */
@property source_clip {
set {
[[Clip the proxy object with the source object's clipper.
@ -71,245 +52,6 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
src: Evas.Object *; [[Source object to use for the proxy.]]
}
}
@property content_hint {
set {
[[Set the content hint setting of a given image object of the
canvas.
This function sets the content hint value of the given image
of the canvas. For example, if you're on the GL engine and
your driver implementation supports it, setting this hint to
#EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need zero copies
at texture upload time, which is an "expensive" operation.
]]
}
get {
[[Get the content hint setting of a given image object of the
canvas.
This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.
]]
}
values {
hint: Evas.Image_Content_Hint; [[The content hint value, one of
the @Evas.Image_Content_Hint ones.]]
}
}
@property load_region {
set {
[[Inform a given image object to load a selective region of its
source image.
This function is useful when one is not showing all of an
image's area on its image object.
Note: The image loader for the image format in question has
to support selective region loading in order to this function
to take effect.
]]
}
get {
[[Retrieve the coordinates of a given image object's selective
(source image) load region.
Note: Use $null pointers on the coordinates you're not
interested in: they'll be ignored by the function.
]]
}
values {
x: int; [[X-offset of the region to be loaded.]]
y: int; [[Y-offset of the region to be loaded.]]
w: int; [[Width of the region to be loaded.]]
h: int; [[Height of the region to be loaded.]]
}
}
@property alpha {
set {
[[Enable or disable alpha channel usage on the given image
object.
This function sets a flag on an image object indicating
whether or not to use alpha channel data. A value of $true
makes it use alpha channel data, and $false makes it ignore
that data. Note that this has nothing to do with an object's
color as manipulated by \@ref evas_object_color_set.
]]
}
get {
[[Retrieve whether alpha channel data is being used on the
given image object.
This function returns $true if the image object's alpha
channel is being used, or $false otherwise.
]]
}
values {
alpha: bool; [[Whether to use alpha channel ($true) data
or not ($false).]]
}
}
@property border {
set {
[[Set the dimensions for an image object's border, a region
which won't ever be scaled together with its center.
When Evas is rendering, an image source may be scaled to fit
the size of its image object. This function sets an area from
the borders of the image inwards which is not to be scaled.
This function is useful for making frames and for widget
theming, where, for example, buttons may be of varying
sizes, but their border size must remain constant.
The units used for $l, $r, $t and $b are canvas units.
Note: The border region itself may be scaled by the
@.border_scale.set function.
Note: By default, image objects have no borders set, i. e.
$l, $r, $t and $b start as 0.
]]
/* FIXME-doc
See the following figures for visual explanation:\n
@htmlonly
<img src="image-borders.png" style="max-width: 100%;" />
<a href="image-borders.png">Full-size</a>
@endhtmlonly
@image rtf image-borders.png
@image latex image-borders.eps width=\textwidth
@htmlonly
<img src="border-effect.png" style="max-width: 100%;" />
<a href="border-effect.png">Full-size</a>
@endhtmlonly
@image rtf border-effect.png
@image latex border-effect.eps width=\textwidth
*/
}
get {
[[Retrieve the dimensions for an image object's border, a
region which won't ever be scaled together with its center.
Note: Use $null pointers on the border components you're not
interested in: they'll be ignored by the function.
]]
}
values {
l: int; [[The border's left width.]]
r: int; [[The border's right width.]]
t: int; [[The border's top width.]]
b: int; [[The border's bottom width.]]
}
}
@property border_scale {
set {
[[Sets the scaling factor (multiplier) for the borders of an
image object.
]]
}
get {
[[Retrieves the scaling factor (multiplier) for the borders
of an image object.
]]
}
values {
scale: double; [[The scale factor (default is 1.0 - i.e. no scaling).]]
}
}
@property pixels_dirty {
set {
[[Mark whether the given image object is dirty and needs to
request its pixels.
This function will only properly work if a pixels get
callback has been set.
Warning: Use this function if you really know what you are
doing.
]]
}
get {
[[Retrieves whether the given image object is dirty (needs to
be redrawn).
]]
}
values {
dirty: bool; [[Whether the image is dirty.]]
}
}
@property video_surface {
set {
[[Set the video surface linked to a given image of the canvas.
@since 1.1
]]
values {
surf: Evas.Video_Surface*; [[The new video surface.]]
}
}
get {
[[Get the video surface linekd to a given image of the canvas.
@since 1.1
]]
values {
surf: const(Evas.Video_Surface)*; [[The new video surface.]]
}
}
}
@property video_surface_caps {
set {
[[Set the video surface capabilities to a given image of the canvas.]]
}
get {
[[Get the video surface capabilities to a given image of the canvas.]]
}
values {
caps: uint;
}
}
@property load_orientation {
set {
[[Define if the orientation information in the image file
should be honored.
@since 1.1
]]
}
get {
[[Get if the orientation information in the image file should
be honored.
@since 1.1
]]
}
values {
enable: bool; [[$true means that it should honor the orientation
information.]]
}
}
@property border_center_fill {
set {
[[Sets how the center part of the given image object (not the
borders) should be drawn when Evas is rendering it.
This function sets how the center part of the image object's
source image is to be drawn, which must be one of the values
in @Evas.Border_Fill_Mode. By center we mean the complementary
part of that defined by @.border.set. This one is very useful
for making frames and decorations. You would most probably
also be using a filled image (as in @Efl.Gfx.Fill.filled) to use
as a frame.
]]
}
get {
[[Retrieves how the center part of the given image object (not
the borders) is to be drawn when Evas is rendering it.
]]
}
values {
fill: Evas.Border_Fill_Mode; [[Fill mode of the center region
of $obj (a value in #Evas_Border_Fill_Mode).]]
}
}
@property source_visible {
set {
[[Set the source object to be visible or not.
@ -342,64 +84,6 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
otherwise.]]
}
}
@property native_surface {
set {
[[Set the native surface of a given image of the canvas
This function sets a native surface of a given canvas image.
]]
legacy: null;
}
get {
[[Get the native surface of a given image of the canvas
This function returns the native surface of a given canvas
image.
]]
}
values {
surf: Evas.Native_Surface* @nonull; [[The native surface.]]
}
}
@property load_scale_down {
set {
[[Set the scale down factor of a given image object's source
image, when loading it.
This function sets the scale down factor of a given canvas
image. Most useful for the SVG image loader.
]]
}
get {
[[Get the scale down factor of a given image object's source
image, when loading it.
]]
}
values {
scale_down: int; [[The scale down factor.]]
}
}
@property scale_hint {
set {
[[Set the scale hint of a given image of the canvas.
This function sets the scale hint value of the given image
object in the canvas, which will affect how Evas is to cache
scaled versions of its original source image.
]]
}
get {
[[Get the scale hint of a given image of the canvas.
This function returns the scale hint value of the given image
object of the canvas.
]]
}
values {
hint: Evas.Image_Scale_Hint; [[The scale hint, a value in
@Evas.Image_Scale_Hint.]]
}
}
@property source_events {
set {
[[Set whether an Evas object is to source events.
@ -428,21 +112,74 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
($false).]]
}
}
@property colorspace {
set {
[[Set the colorspace of a given image of the canvas.
This function sets the colorspace of given canvas image.
/* weird stuff - hints */
@property content_hint {
set {
[[Set the content hint setting of a given image object of the
canvas.
This function sets the content hint value of the given image
of the canvas. For example, if you're on the GL engine and
your driver implementation supports it, setting this hint to
#EVAS_IMAGE_CONTENT_HINT_DYNAMIC will make it need zero copies
at texture upload time, which is an "expensive" operation.
]]
}
get {
[[Get the colorspace of a given image of the canvas.
[[Get the content hint setting of a given image object of the
canvas.
This function returns the colorspace of given canvas image.
This returns #EVAS_IMAGE_CONTENT_HINT_NONE on error.
]]
}
values {
cspace: Evas_Colorspace; [[The new color space.]]
hint: Evas.Image_Content_Hint; [[The content hint value, one of
the @Evas.Image_Content_Hint ones.]]
}
}
@property scale_hint {
set {
[[Set the scale hint of a given image of the canvas.
This function sets the scale hint value of the given image
object in the canvas, which will affect how Evas is to cache
scaled versions of its original source image.
]]
}
get {
[[Get the scale hint of a given image of the canvas.
This function returns the scale hint value of the given image
object of the canvas.
]]
}
values {
hint: Evas.Image_Scale_Hint; [[The scale hint, a value in
@Evas.Image_Scale_Hint.]]
}
}
/* GL View */
@property pixels_dirty {
set {
[[Mark whether the given image object is dirty and needs to
request its pixels.
This function will only properly work if a pixels get
callback has been set.
Warning: Use this function if you really know what you are
doing.
]]
}
get {
[[Retrieves whether the given image object is dirty (needs to
be redrawn).
]]
}
values {
dirty: bool; [[Whether the image is dirty.]]
}
}
@property pixels_get_callback {
@ -458,6 +195,60 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
data: void *; [[The data pointer to be passed to $func.]]
}
}
/* Video */
@property video_surface {
set {
[[Set the video surface linked to a given image of the canvas.
@since 1.1
]]
values {
surf: Evas.Video_Surface*; [[The new video surface.]]
}
}
get {
[[Get the video surface linekd to a given image of the canvas.
@since 1.1
]]
values {
surf: const(Evas.Video_Surface)*; [[The new video surface.]]
}
}
}
@property video_surface_caps {
set {
[[Set the video surface capabilities to a given image of the canvas.]]
}
get {
[[Get the video surface capabilities to a given image of the canvas.]]
}
values {
caps: uint;
}
}
/* native surface */
@property native_surface {
set {
[[Set the native surface of a given image of the canvas
This function sets a native surface of a given canvas image.
]]
legacy: null;
}
get {
[[Get the native surface of a given image of the canvas
This function returns the native surface of a given canvas
image.
]]
}
values {
surf: Evas.Native_Surface* @nonull; [[The native surface.]]
}
}
@property data_copy {
set {
[[Replaces the raw image data of the given image object.
@ -482,38 +273,8 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
data: void *; [[The raw data to replace.]]
}
}
@property region_support {
get {
[[Get the support state of a given image.
@since 1.2
]]
return: bool @warn_unused; [[The region support state.]]
}
}
@property load_error {
get {
[[Retrieves a number representing any error that occurred during
the last loading of the given image object's source image.
]]
return: Evas.Load_Error @warn_unused; [[
A value giving the last error that occurred. It should be
one of the @Evas.Load_Error values. #EVAS_LOAD_ERROR_NONE
is returned if there was no error.
]]
}
}
@property stride {
get {
[[Retrieves the row stride of the given image object.
The row stride is the number of bytes between the start of a
row and the start of the next row for image data.
]]
return: int @warn_unused; [[The stride of the image (in bytes).]]
}
}
/* 3d */
@property scene {
set {
[[Set the 3D scene of a given image of the canvas.
@ -522,7 +283,7 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
@since 1.10
]]
legacy: null;
legacy: null;
}
get {
[[Get the 3D scene of a given image of the canvas.
@ -537,26 +298,6 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
scene: Evas.Canvas3D.Scene *; [[3D scene on an image object.]]
}
}
@property orient {
set {
[[Set the image orientation.
This function allows to rotate or flip the image.
@since 1.14
]]
}
get {
[[Get the image orientation.
@since 1.14
]]
}
values {
orient: Evas.Image_Orient; [[The image orientation \@ref Evas_Image_Orient.
Default is #EVAS_IMAGE_ORIENT_NONE.]]
}
}
@property snapshot {
set {
[[The content below the Evas_Object_Image will be rendered
@ -578,29 +319,12 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
the Evas_Object_Image.]]
}
}
preload_begin {
[[Begin preloading an image object's image data in the background.]]
legacy: null;
}
data_update_add {
[[Mark a sub-region of the given image object to be redrawn.
This function schedules a particular rectangular region of an
image object to be updated (redrawn) at the next rendering cycle.
]]
params {
@in x: int; [[X-offset of the region to be updated.]]
@in y: int; [[Y-offset of the region to be updated.]]
@in w: int; [[Width of the region to be updated.]]
@in h: int; [[Height of the region to be updated.]]
}
}
data_set {
[[Sets the raw image data of the given image object.
Note that the raw data must be of the same size (see
\@ref evas_object_image_size_set, which has to be called before
this one) and colorspace (see @.colorspace.set) of the image.
this one) and colorspace (see \@.colorspace.set) of the image.
If data is $null, the current image data will be freed.
Naturally, if one does not set an image object's data
manually, it will still have one, allocated by Evas.
@ -627,7 +351,7 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
Note: The contents' format returned by it depend on the color
space of the given image object.
Note: You may want to use @.data_update_add to inform data
Note: You may want to use \@.data_update_add to inform data
changes, if you did any.
]]
return: void * @warn_unused; [[ The raw image data.]]
@ -636,10 +360,6 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
be modified ($true) or not ($false).]]
}
}
preload_cancel {
[[Cancel preloading an image object's image data in the background.]]
legacy: null;
}
}
implements {
Eo.Base.constructor;
@ -651,6 +371,19 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
Efl.File.mmap.set;
Efl.File.mmap.get;
Efl.File.save;
Efl.Image.orientation.get;
Efl.Image.orientation.set;
Efl.Image.alpha.get;
Efl.Image.alpha.set;
Efl.Image.smooth_scale.set;
Efl.Image.smooth_scale.get;
Efl.Image.ratio.get;
Efl.Image.border.get;
Efl.Image.border.set;
Efl.Image.border_scale.get;
Efl.Image.border_scale.set;
Efl.Image.border_center_fill.get;
Efl.Image.border_center_fill.set;
Efl.Image_Animated.animated.get;
Efl.Image_Animated.animated_frame.get;
Efl.Image_Animated.animated_frame.set;
@ -658,11 +391,23 @@ class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.
Efl.Image_Animated.animated_loop_type.get;
Efl.Image_Animated.animated_loop_count.get;
Efl.Image_Animated.animated_frame_duration.get;
Efl.Image.load_size.set;
Efl.Image.load_size.get;
Efl.Image.smooth_scale.set;
Efl.Image.smooth_scale.get;
Efl.Image.ratio.get;
Efl.Image_Load.load_error.get;
Efl.Image_Load.load_async_start;
Efl.Image_Load.load_async_cancel;
Efl.Image_Load.load_dpi.get;
Efl.Image_Load.load_dpi.set;
Efl.Image_Load.load_size.set;
Efl.Image_Load.load_size.get;
Efl.Image_Load.load_orientation.get;
Efl.Image_Load.load_orientation.set;
Efl.Image_Load.load_scale_down.get;
Efl.Image_Load.load_scale_down.set;
Efl.Image_Load.load_region.get;
Efl.Image_Load.load_region.set;
Efl.Image_Load.load_region_support.get;
Efl.Gfx.Buffer.buffer_update_region_add;
Efl.Gfx.Buffer.buffer_stride.get;
Efl.Gfx.Buffer.colorspace.get;
Efl.Gfx.Fill.fill.set;
Efl.Gfx.Fill.fill.get;
Efl.Gfx.Fill.filled.get;

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

@ -17,7 +17,6 @@
#include "../common/evas_convert_colorspace.h"
#include "../common/evas_convert_yuv.h"
#include "../efl/interfaces/efl_gfx_filter.eo.h"
#include "evas_filter.eo.h"
#include "evas_filter.h"
@ -662,9 +661,10 @@ _evas_image_source_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
}
EOLIAN static void
_evas_image_orient_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Orient orient)
_evas_image_efl_image_orientation_set(Eo *eo_obj, Evas_Image_Data *o, Efl_Gfx_Orientation _orient)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
Evas_Image_Orient orient = (Evas_Image_Orient) _orient;
int iw, ih;
if (o->cur->orient == orient) return;
@ -710,10 +710,10 @@ _evas_image_orient_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Orient orient)
evas_object_change(eo_obj, obj);
}
EOLIAN static Evas_Image_Orient
_evas_image_orient_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
EOLIAN static Efl_Gfx_Orientation
_evas_image_efl_image_orientation_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->orient;
return (Efl_Gfx_Orientation) o->cur->orient;
}
EAPI Eina_Bool
@ -792,7 +792,7 @@ _evas_image_eo_base_dbg_info_get(Eo *eo_obj, Evas_Image_Data *o, Eo_Dbg_Info *ro
if (evas_object_image_load_error_get(eo_obj) != EVAS_LOAD_ERROR_NONE)
{
Evas_Load_Error error = EVAS_LOAD_ERROR_GENERIC;
error = evas_obj_image_load_error_get(eo_obj);
error = (Evas_Load_Error) efl_image_load_error_get(eo_obj);
EO_DBG_INFO_APPEND(group, "Load Error", EINA_VALUE_TYPE_STRING,
evas_load_error_str(error));
}
@ -862,7 +862,7 @@ _evas_image_scene_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
}
EOLIAN static void
_evas_image_border_set(Eo *eo_obj, Evas_Image_Data *o, int l, int r, int t, int b)
_evas_image_efl_image_border_set(Eo *eo_obj, Evas_Image_Data *o, int l, int r, int t, int b)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
@ -889,7 +889,7 @@ _evas_image_border_set(Eo *eo_obj, Evas_Image_Data *o, int l, int r, int t, int
}
EOLIAN static void
_evas_image_border_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *l, int *r, int *t, int *b)
_evas_image_efl_image_border_get(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;
@ -898,9 +898,11 @@ _evas_image_border_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *l, int *
}
EOLIAN static void
_evas_image_border_center_fill_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Border_Fill_Mode fill)
_evas_image_efl_image_border_center_fill_set(Eo *eo_obj, Evas_Image_Data *o, Efl_Gfx_Border_Fill_Mode _fill)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
Evas_Border_Fill_Mode fill = (Evas_Border_Fill_Mode) _fill;
if (fill == o->cur->border.fill) return;
evas_object_async_block(obj);
EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
@ -911,10 +913,10 @@ _evas_image_border_center_fill_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Border_F
evas_object_change(eo_obj, obj);
}
EOLIAN static Evas_Border_Fill_Mode
_evas_image_border_center_fill_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
EOLIAN static Efl_Gfx_Border_Fill_Mode
_evas_image_efl_image_border_center_fill_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->border.fill;
return (Efl_Gfx_Border_Fill_Mode) o->cur->border.fill;
}
EOLIAN static void
@ -950,7 +952,7 @@ _evas_image_efl_gfx_fill_filled_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
}
EOLIAN static void
_evas_image_border_scale_set(Eo *eo_obj, Evas_Image_Data *o, double scale)
_evas_image_efl_image_border_scale_set(Eo *eo_obj, Evas_Image_Data *o, double scale)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
@ -965,19 +967,11 @@ _evas_image_border_scale_set(Eo *eo_obj, Evas_Image_Data *o, double scale)
}
EOLIAN static double
_evas_image_border_scale_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_evas_image_efl_image_border_scale_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->border.scale;
}
EAPI void
evas_object_image_fill_set(Evas_Image *obj,
Evas_Coord x, Evas_Coord y,
Evas_Coord w, Evas_Coord h)
{
efl_gfx_fill_set((Evas_Image *)obj, x, y, w, h);
}
EOLIAN static void
_evas_image_efl_gfx_fill_fill_set(Eo *eo_obj, Evas_Image_Data *o,
int x, int y, int w, int h)
@ -1083,12 +1077,6 @@ _evas_image_efl_gfx_view_view_size_set(Eo *eo_obj, Evas_Image_Data *o, int w, in
evas_object_change(eo_obj, obj);
}
EAPI void
evas_object_image_size_get(const Evas_Image *obj, int *w, int *h)
{
efl_gfx_view_size_get((Evas_Image *)obj, w, h);
}
EOLIAN static void
_evas_image_efl_gfx_view_view_size_get(Eo *eo_obj, Evas_Image_Data *o, int *w, int *h)
{
@ -1132,15 +1120,15 @@ _evas_image_efl_gfx_view_view_size_get(Eo *eo_obj, Evas_Image_Data *o, int *w, i
}
EOLIAN static int
_evas_image_stride_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_evas_image_efl_gfx_buffer_buffer_stride_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->image.stride;;
return o->cur->image.stride;
}
EOLIAN static Evas_Load_Error
_evas_image_load_error_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
EOLIAN static Efl_Image_Load_Error
_evas_image_efl_image_load_load_error_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->load_error;
return (Efl_Image_Load_Error) o->load_error;
}
/* deprecated */
@ -1311,18 +1299,6 @@ _evas_image_data_get(const Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED, Eina_Bo
return data;
}
EAPI void
evas_object_image_preload(Evas_Object *eo_obj, Eina_Bool cancel)
{
MAGIC_CHECK(eo_obj, Evas_Object, MAGIC_OBJ);
return;
MAGIC_CHECK_END();
if (cancel)
evas_obj_image_preload_cancel(eo_obj);
else
evas_obj_image_preload_begin(eo_obj);
}
static void
_image_preload_internal(Eo *eo_obj, void *_pd, Eina_Bool cancel)
{
@ -1356,7 +1332,7 @@ _image_preload_internal(Eo *eo_obj, void *_pd, Eina_Bool cancel)
}
EOLIAN static void
_evas_image_preload_begin(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED)
_evas_image_efl_image_load_load_async_start(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
evas_object_async_block(obj);
@ -1364,7 +1340,7 @@ _evas_image_preload_begin(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED)
}
EOLIAN static void
_evas_image_preload_cancel(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED)
_evas_image_efl_image_load_load_async_cancel(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
evas_object_async_block(obj);
@ -1417,7 +1393,7 @@ _evas_image_data_copy_set(Eo *eo_obj, Evas_Image_Data *o, void *data)
}
EOLIAN static void
_evas_image_data_update_add(Eo *eo_obj, Evas_Image_Data *o, int x, int y, int w, int h)
_evas_image_efl_gfx_buffer_buffer_update_region_add(Eo *eo_obj, Evas_Image_Data *o, int x, int y, int w, int h)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
Eina_Rectangle *r;
@ -1460,7 +1436,7 @@ _evas_image_data_update_add(Eo *eo_obj, Evas_Image_Data *o, int x, int y, int w,
}
EOLIAN static void
_evas_image_alpha_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool has_alpha)
_evas_image_efl_image_alpha_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool has_alpha)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
@ -1506,7 +1482,7 @@ _evas_image_alpha_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool has_alpha)
}
EOLIAN static Eina_Bool
_evas_image_alpha_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_evas_image_efl_image_alpha_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->has_alpha;
}
@ -1868,7 +1844,7 @@ _evas_image_pixels_dirty_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
}
EOLIAN static void
_evas_image_load_dpi_set(Eo *eo_obj, Evas_Image_Data *o, double dpi)
_evas_image_efl_image_load_load_dpi_set(Eo *eo_obj, Evas_Image_Data *o, double dpi)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
if (dpi == o->load_opts->dpi) return;
@ -1888,13 +1864,13 @@ _evas_image_load_dpi_set(Eo *eo_obj, Evas_Image_Data *o, double dpi)
}
EOLIAN static double
_evas_image_load_dpi_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_evas_image_efl_image_load_load_dpi_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->load_opts->dpi;
}
EOLIAN static void
_evas_image_efl_image_load_size_set(Eo *eo_obj, Evas_Image_Data *o, int w, int h)
_evas_image_efl_image_load_load_size_set(Eo *eo_obj, Evas_Image_Data *o, int w, int h)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
if ((o->load_opts->w == w) && (o->load_opts->h == h)) return;
@ -1918,14 +1894,14 @@ _evas_image_efl_image_load_size_set(Eo *eo_obj, Evas_Image_Data *o, int w, int h
}
EOLIAN static void
_evas_image_efl_image_load_size_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *w, int *h)
_evas_image_efl_image_load_load_size_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *w, int *h)
{
if (w) *w = o->load_opts->w;
if (h) *h = o->load_opts->h;
}
EOLIAN static void
_evas_image_load_scale_down_set(Eo *eo_obj, Evas_Image_Data *o, int scale_down)
_evas_image_efl_image_load_load_scale_down_set(Eo *eo_obj, Evas_Image_Data *o, int scale_down)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
if (o->load_opts->scale_down_by == scale_down) return;
@ -1945,13 +1921,13 @@ _evas_image_load_scale_down_set(Eo *eo_obj, Evas_Image_Data *o, int scale_down)
}
EOLIAN static int
_evas_image_load_scale_down_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_evas_image_efl_image_load_load_scale_down_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->load_opts->scale_down_by;
}
EOLIAN static void
_evas_image_load_region_set(Eo *eo_obj, Evas_Image_Data *o, int x, int y, int w, int h)
_evas_image_efl_image_load_load_region_set(Eo *eo_obj, Evas_Image_Data *o, int x, int y, int w, int h)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
if ((o->load_opts->region.x == x) && (o->load_opts->region.y == y) &&
@ -1977,7 +1953,7 @@ _evas_image_load_region_set(Eo *eo_obj, Evas_Image_Data *o, int x, int y, int w,
}
EOLIAN static void
_evas_image_load_region_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *x, int *y, int *w, int *h)
_evas_image_efl_image_load_load_region_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *x, int *y, int *w, int *h)
{
if (x) *x = o->load_opts->region.x;
if (y) *y = o->load_opts->region.y;
@ -1986,7 +1962,7 @@ _evas_image_load_region_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, int *x,
}
EOLIAN static void
_evas_image_load_orientation_set(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Eina_Bool enable)
_evas_image_efl_image_load_load_orientation_set(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Eina_Bool enable)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
if (o->load_opts->orientation == !!enable) return;
@ -1998,15 +1974,17 @@ _evas_image_load_orientation_set(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o, Ein
}
EOLIAN static Eina_Bool
_evas_image_load_orientation_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
_evas_image_efl_image_load_load_orientation_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->load_opts->orientation;;
}
EOLIAN static void
_evas_image_colorspace_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Colorspace cspace)
/* FIXME: This should be deprecated and a legacy binding for pixel_set should be added */
EAPI void
evas_object_image_colorspace_set(Evas_Object *eo_obj, Evas_Colorspace cspace)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS);
evas_object_async_block(obj);
_evas_object_image_cleanup(eo_obj, obj, o);
@ -2019,10 +1997,10 @@ _evas_image_colorspace_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Colorspace cspac
ENFN->image_colorspace_set(ENDT, o->engine_data, cspace);
}
EOLIAN static Evas_Colorspace
_evas_image_colorspace_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
EOLIAN static Efl_Gfx_Colorspace
_evas_image_efl_gfx_buffer_colorspace_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
{
return o->cur->cspace;
return (Efl_Gfx_Colorspace) o->cur->cspace;
}
EOLIAN static void
@ -2243,14 +2221,11 @@ _evas_image_content_hint_get(Eo *eo_obj EINA_UNUSED, Evas_Image_Data *o)
}
EOLIAN static Eina_Bool
_evas_image_region_support_get(Eo *eo_obj, Evas_Image_Data *o)
_evas_image_efl_image_load_load_region_support_get(Eo *eo_obj, Evas_Image_Data *o)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
Eina_Bool region;
region = ENFN->image_can_region_get(ENDT, o->engine_data);
return region;
return ENFN->image_can_region_get(ENDT, o->engine_data);
}
/* animated feature */
@ -4887,15 +4862,32 @@ evas_object_image_filled_add(Evas *eo_e)
}
EAPI void
evas_object_image_filled_set(Evas_Object *eo_obj, Eina_Bool value)
evas_object_image_fill_set(Evas_Image *obj,
Evas_Coord x, Evas_Coord y,
Evas_Coord w, Evas_Coord h)
{
efl_gfx_fill_filled_set(eo_obj, value);
efl_gfx_fill_set((Evas_Image *)obj, x, y, w, h);
}
EAPI void
evas_object_image_preload(Evas_Object *eo_obj, Eina_Bool cancel)
{
if (cancel)
efl_image_load_async_cancel(eo_obj);
else
efl_image_load_async_start(eo_obj);
}
EAPI Eina_Bool
evas_object_image_filled_get(const Evas_Object *eo_obj)
{
return efl_gfx_fill_filled_get((Eo *) eo_obj);
return efl_gfx_fill_filled_get(eo_obj);
}
EAPI void
evas_object_image_filled_set(Evas_Object *eo_obj, Eina_Bool value)
{
efl_gfx_fill_filled_set(eo_obj, value);
}
EAPI void
@ -4903,7 +4895,7 @@ evas_object_image_fill_get(const Evas_Image *obj,
Evas_Coord *x, Evas_Coord *y,
Evas_Coord *w, Evas_Coord *h)
{
efl_gfx_fill_get((Evas_Image *)obj, x, y, w, h);
efl_gfx_fill_get(obj, x, y, w, h);
}
EAPI void
@ -4920,46 +4912,118 @@ evas_object_image_fill_spread_get(const Evas_Image *obj EINA_UNUSED)
return EFL_GFX_FILL_REPEAT;
}
EAPI void
evas_object_image_alpha_set(Evas_Object *obj, Eina_Bool alpha)
{
efl_image_alpha_set(obj, alpha);
}
EAPI Eina_Bool
evas_object_image_alpha_get(const Evas_Object *obj)
{
return efl_image_alpha_get(obj);
}
EAPI void
evas_object_image_border_set(Evas_Object *obj, int l, int r, int t, int b)
{
efl_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)
{
efl_image_border_get(obj, l, r, t, b);
}
EAPI void
evas_object_image_border_scale_set(Evas_Object *obj, double scale)
{
efl_image_border_scale_set(obj, scale);
}
EAPI double
evas_object_image_border_scale_get(const Evas_Object *obj)
{
return efl_image_border_scale_get(obj);
}
EAPI void
evas_object_image_border_center_fill_set(Evas_Object *obj, Evas_Border_Fill_Mode fill)
{
efl_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)
{
return (Evas_Border_Fill_Mode) efl_image_border_center_fill_get(obj);
}
EAPI void
evas_object_image_size_get(const Evas_Image *obj, int *w, int *h)
{
efl_gfx_view_size_get((Evas_Image *)obj, w, h);
}
EAPI void
evas_object_image_size_set(Evas_Image *obj, int w, int h)
{
efl_gfx_view_size_set((Evas_Image *)obj, w, h);
efl_gfx_view_size_set(obj, w, h);
}
EAPI Evas_Colorspace
evas_object_image_colorspace_get(const Evas_Object *obj)
{
return (Evas_Colorspace) efl_gfx_buffer_colorspace_get(obj);
}
EAPI int
evas_object_image_stride_get(const Evas_Object *obj)
{
return efl_gfx_buffer_stride_get(obj);
}
EAPI void
evas_object_image_data_update_add(Evas_Object *obj, int x, int y, int w, int h)
{
efl_gfx_buffer_update_region_add(obj, x, y, w, h);
}
EAPI void
evas_object_image_file_set(Eo *obj, const char *file, const char *key)
{
efl_file_set((Eo *) obj, file, key);
efl_file_set(obj, file, key);
}
EAPI void
evas_object_image_file_get(const Eo *obj, const char **file, const char **key)
{
efl_file_get((Eo *) obj, file, key);
efl_file_get(obj, file, key);
}
EAPI void
evas_object_image_mmap_set(Evas_Image *obj, const Eina_File *f, const char *key)
{
efl_file_mmap_set((Evas_Image *)obj, f, key);
efl_file_mmap_set(obj, f, key);
}
EAPI void
evas_object_image_mmap_get(const Evas_Image *obj, const Eina_File **f, const char **key)
{
efl_file_mmap_get((Evas_Image *)obj, f, key);
efl_file_mmap_get(obj, f, key);
}
EAPI Eina_Bool
evas_object_image_save(const Eo *obj, const char *file, const char *key, const char *flags)
{
return efl_file_save((Eo *) obj, file, key, flags);
return efl_file_save(obj, file, key, flags);
}
EAPI Eina_Bool
evas_object_image_animated_get(const Eo *obj)
{
return efl_image_animated_get((Eo *) obj);
return efl_image_animated_get(obj);
}
EAPI void
@ -4995,25 +5059,97 @@ evas_object_image_animated_frame_duration_get(const Evas_Object *obj, int start_
EAPI void
evas_object_image_load_size_set(Eo *obj, int w, int h)
{
efl_image_load_size_set((Eo *) obj, w, h);
efl_image_load_size_set(obj, w, h);
}
EAPI void
evas_object_image_load_size_get(const Eo *obj, int *w, int *h)
{
efl_image_load_size_get((Eo *) obj, w, h);
efl_image_load_size_get(obj, w, h);
}
EAPI void
evas_object_image_load_dpi_set(Evas_Object *obj, double dpi)
{
efl_image_load_dpi_set(obj, dpi);
}
EAPI double
evas_object_image_load_dpi_get(const Evas_Object *obj)
{
return efl_image_load_dpi_get(obj);
}
EAPI void
evas_object_image_load_region_set(Evas_Object *obj, int x, int y, int w, int h)
{
efl_image_load_region_set(obj, x, y, w, h);
}
EAPI void
evas_object_image_load_region_get(const Evas_Object *obj, int *x, int *y, int *w, int *h)
{
efl_image_load_region_get(obj, x, y, w, h);
}
EAPI Eina_Bool
evas_object_image_region_support_get(const Evas_Image *obj)
{
return efl_image_load_region_support_get(obj);
}
EAPI void
evas_object_image_load_orientation_set(Evas_Object *obj, Eina_Bool enable)
{
efl_image_load_orientation_set(obj, enable);
}
EAPI Eina_Bool
evas_object_image_load_orientation_get(const Evas_Object *obj)
{
return efl_image_load_orientation_get(obj);
}
EAPI void
evas_object_image_load_scale_down_set(Evas_Object *obj, int scale_down)
{
efl_image_load_scale_down_set(obj, scale_down);
}
EAPI int
evas_object_image_load_scale_down_get(const Evas_Object *obj)
{
return efl_image_load_scale_down_get(obj);
}
EAPI Evas_Load_Error
evas_object_image_load_error_get(const Evas_Object *obj)
{
return (Evas_Load_Error) efl_image_load_error_get(obj);
}
EAPI void
evas_object_image_smooth_scale_set(Eo *obj, Eina_Bool smooth_scale)
{
efl_image_smooth_scale_set((Eo *) obj, smooth_scale);
efl_image_smooth_scale_set(obj, smooth_scale);
}
EAPI Eina_Bool
evas_object_image_smooth_scale_get(const Eo *obj)
{
return efl_image_smooth_scale_get((Eo *) obj);
return efl_image_smooth_scale_get(obj);
}
EAPI void
evas_object_image_orient_set(Evas_Image *obj, Evas_Image_Orient orient)
{
efl_image_orientation_set(obj, (Efl_Gfx_Orientation) orient);
}
EAPI Evas_Image_Orient
evas_object_image_orient_get(const Evas_Image *obj)
{
return (Evas_Image_Orient) efl_image_orientation_get(obj);
}
#include "canvas/evas_image.eo.c"