forked from enlightenment/efl
770 lines
26 KiB
Plaintext
770 lines
26 KiB
Plaintext
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.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.]]
|
|
}
|
|
}
|
|
|
|
@property source_clip {
|
|
set {
|
|
[[Clip the proxy object with the source object's clipper.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
get {
|
|
[[Determine whether an object is clipped by source object's
|
|
clipper.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
values {
|
|
source_clip: bool; [[Whether $obj is clipped by the source
|
|
clipper ($true) or not ($false).]]
|
|
}
|
|
}
|
|
@property source {
|
|
set {
|
|
[[Set the source object on an image object to used as a proxy.
|
|
|
|
If an image object is set to behave as a proxy, it will mirror
|
|
the rendering contents of a given source object in its drawing
|
|
region, without affecting that source in any way. The source
|
|
must be another valid Evas object. Other effects may be
|
|
applied to the proxy, such as a map (see
|
|
\@ref evas_object_map_set) to create a reflection of the
|
|
original object (for example).
|
|
|
|
Any existing source object on $obj will be removed after this
|
|
call. Setting $src to $null clears the proxy object (not in
|
|
"proxy state" anymore).
|
|
|
|
Warning: You cannot set a proxy as another proxy's source.
|
|
]]
|
|
return: bool;
|
|
}
|
|
get {
|
|
[[Get the current source object of an image object.]]
|
|
}
|
|
values {
|
|
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.
|
|
|
|
If $visible is set to $false, the source object of the
|
|
proxy ($obj) will be invisible.
|
|
|
|
This API works differently to \@ref evas_object_show and
|
|
\@ref evas_object_hide. Once source object is hidden, the
|
|
proxy object will be hidden as well. Actually in this case
|
|
both objects are excluded from the Evas internal update circle.
|
|
|
|
By this API, instead, one can toggle the visibility of a
|
|
proxy's source object remaining the proxy visibility untouched.
|
|
|
|
Warning: If the all of proxies are deleted, then the source
|
|
visibility of the source object will be cancelled.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the state of the source object visibility.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
values {
|
|
visible: bool; [[$true is source object to be shown, $false
|
|
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.
|
|
|
|
Set whether an Evas object is to repeat events to source.
|
|
|
|
If $source is $true, it will make events on $obj to also be
|
|
repeated for the source object (see @.source.set). Even the
|
|
$obj and source geometries are different, the event position
|
|
will be transformed to the source object's space.
|
|
|
|
If $source is $false, events occurring on $obj will be
|
|
processed only on it.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
get {
|
|
[[Determine whether an object is set to source events.
|
|
|
|
@since 1.8
|
|
]]
|
|
}
|
|
values {
|
|
source: bool; [[Whether $obj is to pass events ($true) or not
|
|
($false).]]
|
|
}
|
|
}
|
|
@property colorspace {
|
|
set {
|
|
[[Set the colorspace of a given image of the canvas.
|
|
|
|
This function sets the colorspace of given canvas image.
|
|
]]
|
|
}
|
|
get {
|
|
[[Get the colorspace of a given image of the canvas.
|
|
|
|
This function returns the colorspace of given canvas image.
|
|
]]
|
|
}
|
|
values {
|
|
cspace: Evas_Colorspace; [[The new color space.]]
|
|
}
|
|
}
|
|
@property pixels_get_callback {
|
|
set {
|
|
[[Set the callback function to get pixels from a canvas' image.
|
|
|
|
This functions sets a function to be the callback function
|
|
that get pixels from a image of the canvas.
|
|
]]
|
|
}
|
|
values {
|
|
func: Evas_Object_Image_Pixels_Get_Cb @nonull; [[The callback function.]]
|
|
data: void *; [[The data pointer to be passed to $func.]]
|
|
}
|
|
}
|
|
@property data_copy {
|
|
set {
|
|
[[Replaces the raw image data of the given image object.
|
|
|
|
This function lets the application replace an image object's
|
|
internal pixel buffer with an user-allocated one. For best
|
|
results, you should generally first call
|
|
\@ref evas_object_image_size_set with the width and height
|
|
for the new buffer.
|
|
|
|
This call is best suited for when you will be using image
|
|
data with different dimensions than the existing image data,
|
|
if any. If you only need to modify the existing image in some
|
|
fashion, then using @.data_get is probably what you are after.
|
|
|
|
Note that the caller is responsible for freeing the buffer
|
|
when finished with it, as user-set image data will not be
|
|
automatically freed when the image object is deleted.
|
|
]]
|
|
}
|
|
values {
|
|
data: void *; [[The raw data to replace.]]
|
|
}
|
|
}
|
|
@property animated_frame {
|
|
set {
|
|
[[Set the frame to current frame of an image object.
|
|
|
|
This set image object's current frame to frame_num with 1
|
|
being the first frame.
|
|
|
|
See also \@ref evas_object_image_animated_get,
|
|
@.animated_frame_count.get, @.animated_loop_type.get,
|
|
@.animated_loop_count.get, @.animated_frame_duration_get.
|
|
|
|
@since 1.1
|
|
]]
|
|
}
|
|
values {
|
|
frame_index: int; [[The index of current frame.]]
|
|
}
|
|
}
|
|
@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 animated_frame_count {
|
|
get {
|
|
[[Get the total number of frames of the image object.
|
|
|
|
This returns total number of frames the image object
|
|
supports (if animated).
|
|
|
|
See also \@ref evas_object_image_animated_get,
|
|
@.animated_frame_count.get, @.animated_loop_type.get,
|
|
@.animated_loop_count.get, @.animated_frame_duration_get.
|
|
|
|
@since 1.1
|
|
]]
|
|
return: int; [[The number of frames.]]
|
|
}
|
|
}
|
|
@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).]]
|
|
}
|
|
}
|
|
@property animated_loop_type {
|
|
get {
|
|
[[Get the kind of looping the image object does.
|
|
|
|
This returns the kind of looping the image object wants to do.
|
|
|
|
If it returns EVAS_IMAGE_ANIMATED_HINT_LOOP, you should display
|
|
frames in a sequence like: 1->2->3->1->2->3->1...
|
|
|
|
If it returns EVAS_IMAGE_ANIMATED_HINT_PINGPONG, it is better
|
|
to display frames in a sequence like: 1->2->3->2->1->2->3->1...
|
|
|
|
The default type is EVAS_IMAGE_ANIMATED_HINT_LOOP.
|
|
|
|
See also \@ref evas_object_image_animated_get,
|
|
@.animated_frame_count.get, @.animated_loop_type.get,
|
|
@.animated_loop_count.get, @.animated_frame_duration_get.
|
|
|
|
@since 1.1
|
|
]]
|
|
return: Evas.Image_Animated_Loop_Hint; [[Loop type of the image object.]]
|
|
}
|
|
}
|
|
@property animated_loop_count {
|
|
get {
|
|
[[Get the number times the animation of the object loops.
|
|
|
|
This returns loop count of image. The loop count is the number
|
|
of times the animation will play fully from first to last frame
|
|
until the animation should stop (at the final frame).
|
|
|
|
If 0 is returned, then looping should happen indefinitely
|
|
(no limit to the number of times it loops).
|
|
|
|
See also \@ref evas_object_image_animated_get,
|
|
@.animated_frame_count.get, @.animated_loop_type.get,
|
|
@.animated_loop_count.get, @.animated_frame_duration_get.
|
|
|
|
@since 1.1
|
|
]]
|
|
return: int; [[The number of loop of an animated image object.]]
|
|
}
|
|
}
|
|
|
|
@property scene {
|
|
set {
|
|
[[Set the 3D scene of a given image of the canvas.
|
|
|
|
This function sets a 3d scene of a given canvas image.
|
|
|
|
@since 1.10
|
|
]]
|
|
legacy: null;
|
|
}
|
|
get {
|
|
[[Get the 3D scene of a given image of the canvas.
|
|
|
|
This function returns the 3d scene of a given canvas image.
|
|
|
|
@since 1.10
|
|
]]
|
|
legacy: null;
|
|
}
|
|
values {
|
|
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
|
|
inside it and you can reuse it as a source for any kind
|
|
of effect.
|
|
|
|
@since 1.15
|
|
]]
|
|
}
|
|
get {
|
|
[[Determine wether the Evas_Object_Image replicate the content
|
|
of the canvas below.
|
|
|
|
@since 1.15
|
|
]]
|
|
}
|
|
values {
|
|
s: bool; [[Wether to put the content of the canvas below inside
|
|
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.]]
|
|
}
|
|
}
|
|
animated_frame_duration_get @const {
|
|
[[Get the duration of a sequence of frames.
|
|
|
|
This returns total duration that the specified sequence of
|
|
frames should take in seconds.
|
|
|
|
If you set start_frame to 1 and frame_num 0, you get frame 1's
|
|
duration. If you set start_frame to 1 and frame_num 1, you get
|
|
frame 1's duration + frame2's duration.
|
|
|
|
See also \@ref evas_object_image_animated_get,
|
|
@.animated_frame_count.get, @.animated_loop_type.get,
|
|
@.animated_loop_count.get, @.animated_frame_duration_get.
|
|
|
|
@since 1.1
|
|
]]
|
|
return: double;
|
|
params {
|
|
@in start_frame: int; [[The first frame.]]
|
|
@in frame_num: int; [[Number of frames in the sequence.]]
|
|
}
|
|
}
|
|
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.
|
|
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.
|
|
]]
|
|
params {
|
|
@in data: void *; [[The raw data, or $null.]]
|
|
}
|
|
}
|
|
data_get @const {
|
|
[[Get a pointer to the raw image data of the given image object.
|
|
|
|
This function returns a pointer to an image object's internal
|
|
pixel buffer, for reading only or read/write. If you request
|
|
it for writing, the image will be marked dirty so that it gets
|
|
redrawn at the next update.
|
|
|
|
Each time you call this function on an image object, its data
|
|
buffer will have an internal reference counter incremented.
|
|
Decrement it back by using @.data_set.
|
|
|
|
This is best suited for when you want to modify an existing
|
|
image, without changing its dimensions.
|
|
|
|
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
|
|
changes, if you did any.
|
|
]]
|
|
return: void * @warn_unused; [[ The raw image data.]]
|
|
params {
|
|
@in for_writing: bool; [[Whether the data being retrieved will
|
|
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;
|
|
Eo.Base.destructor;
|
|
Eo.Base.dbg_info_get;
|
|
Eo.Base.finalize;
|
|
Efl.File.file.set;
|
|
Efl.File.file.get;
|
|
Efl.File.mmap.set;
|
|
Efl.File.mmap.get;
|
|
Efl.File.save;
|
|
Efl.Image.animated.get;
|
|
Efl.Image.load_size.set;
|
|
Efl.Image.load_size.get;
|
|
Efl.Image.smooth_scale.set;
|
|
Efl.Image.smooth_scale.get;
|
|
Efl.Gfx.Fill.fill.set;
|
|
Efl.Gfx.Fill.fill.get;
|
|
Efl.Gfx.Fill.filled.get;
|
|
Efl.Gfx.Fill.filled.set;
|
|
Efl.Gfx.View.size.set;
|
|
Efl.Gfx.View.size.get;
|
|
Efl.Gfx.Filter.filter_program.set;
|
|
Evas.Filter.filter_input_alpha;
|
|
Evas.Filter.filter_input_render;
|
|
Evas.Filter.filter_dirty;
|
|
}
|
|
}
|