This interface groups all low-level animated image functions.
FIXME:
- Rename to Efl.Image.Animated once eolian is fixed
- Fix mess with emile enum (loop_hint)
efl_eolian_legacy_files = \
lib/efl/interfaces/efl_gfx_fill.eo \
lib/efl/interfaces/efl_gfx_base.eo \
+ lib/efl/interfaces/efl_image_animated.eo \
$(NULL)
efl_eolian_files = \
#include "interfaces/efl_control.eo.h"
#include "interfaces/efl_file.eo.h"
#include "interfaces/efl_image.eo.h"
+#include "interfaces/efl_image_animated.eo.h"
#include "interfaces/efl_player.eo.h"
#include "interfaces/efl_text.eo.h"
#include "interfaces/efl_text_properties.eo.h"
#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"
#endif
interface Efl.Image {
legacy_prefix: null;
methods {
- @property animated {
- /* FIXME: Move to specific interface */
- get {
- [[Check if an image can be animated (has multiple frames).
-
- This will be $true for animated Gif files for instance but $false
- for still images.
- ]]
- }
- values {
- is_animated: bool; [[$true if the image is animated]]
- }
- }
@property load_size {
[[The loading size of an image.
--- /dev/null
+/* FIXME: invalid type from evas/emile! */
+/* type @extern Evas.Animated_Loop_Hint: int; */
+
+enum Efl.Image_Animated.Loop_Hint {
+ 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.Animated when eo/eolian are fixed */
+
+interface Efl.Image_Animated ()
+{
+ legacy_prefix: null;
+ eo_prefix: efl_image;
+
+ methods {
+ @property animated {
+ get {
+ [[Check if an image can be animated (has multiple frames).
+
+ This will be $true for animated Gif files for instance but $false
+ for still images.
+
+ @since 1.1
+ ]]
+ }
+ values {
+ is_animated: bool; [[$true if the image is animated]]
+ }
+ }
+ @property animated_frame {
+ [[Index of the current frame of an animated image.
+
+ Ranges from 1 to @.animated_frame_count. Valid only if @.animated.
+ ]]
+ set {
+ [[Set the frame to current frame of an image object.
+
+ @since 1.1
+ ]]
+ return: bool; [[Returns $true if the frame index is valid.]]
+ }
+ get {}
+ values {
+ frame_index: int; [[The index of current frame.]]
+ }
+ }
+ @property animated_frame_count {
+ get {
+ [[Get the total number of frames of the image, if animated.
+
+ Returns -1 if not animated.
+
+ @since 1.1
+ ]]
+ return: int; [[The number of frames in the animated image.]]
+ }
+ }
+ @property animated_loop_type {
+ /* FIXME: external type used from evas / emile */
+ 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 @Efl.Image_Animated.Loop_Hint.loop, you should
+ display frames in a sequence like: 1->2->3->1->2->3->1...
+
+ If it returns @Efl.Image_Animated.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_Animated.Loop_Hint.loop.
+
+ @since 1.1
+ ]]
+ return: Efl.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).
+
+ @since 1.1
+ ]]
+ return: int; [[The number of loop of an animated image object.]]
+ }
+ }
+ @property animated_frame_duration {
+ get {
+ [[Get the duration of a sequence of frames.
+
+ This returns total duration in seconds that the specified
+ sequence of frames should take.
+
+ If $start_frame is 1 and $frame_num is 0, this returns the
+ duration of frame 1. If $start_frame is 1 and $frame_num is 1,
+ this returns the total duration of frame 1 + frame 2.
+
+ @since 1.1
+ ]]
+ }
+ keys {
+ start_frame: int; [[The first frame, rangers from 1 to @.animated_frame_count.]]
+ frame_num: int; [[Number of frames in the sequence, starts from 0.]]
+ }
+ values {
+ duration: double;
+ }
+ }
+ }
+}
#include "interfaces/efl_control.eo.c"
#include "interfaces/efl_file.eo.c"
#include "interfaces/efl_image.eo.c"
+#include "interfaces/efl_image_animated.eo.c"
#include "interfaces/efl_player.eo.c"
#include "interfaces/efl_text.eo.c"
#include "interfaces/efl_text_properties.eo.c"
EAPI Eina_Bool evas_object_image_animated_get(const Eo *obj);
/**
+ * @brief 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,
+ * @ref evas_object_image_animated_frame_count_get,
+ * @ref evas_object_image_animated_loop_type_get,
+ * @ref evas_object_image_animated_loop_count_get,
+ * @ref evas_object_image_animated_frame_duration_get.
+ *
+ * @param[in] frame_index The index of current frame.
+ *
+ * @since 1.1
+ */
+EAPI void evas_object_image_animated_frame_set(Evas_Object *obj, int frame_index);
+
+/**
+ * @brief 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,
+ * @ref evas_object_image_animated_loop_type_get,
+ * @ref evas_object_image_animated_loop_count_get,
+ * @ref evas_object_image_animated_frame_duration_get.
+ *
+ * @return The number of frames.
+ *
+ * @since 1.1
+ */
+EAPI int evas_object_image_animated_frame_count_get(const Evas_Object *obj);
+
+/**
+ * @brief 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,
+ * @ref evas_object_image_animated_frame_count_get,
+ * @ref evas_object_image_animated_loop_count_get,
+ * @ref evas_object_image_animated_frame_duration_get.
+ *
+ * @return Loop type of the image object.
+ *
+ * @since 1.1
+ */
+EAPI Evas_Image_Animated_Loop_Hint evas_object_image_animated_loop_type_get(const Evas_Object *obj);
+
+/**
+ * @brief 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,
+ * @ref evas_object_image_animated_frame_count_get,
+ * @ref evas_object_image_animated_loop_type_get,
+ * @ref evas_object_image_animated_frame_duration_get.
+ *
+ * @return The number of loop of an animated image object.
+ *
+ * @since 1.1
+ */
+EAPI int evas_object_image_animated_loop_count_get(const Evas_Object *obj);
+
+/**
+ * @brief 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,
+ * @ref evas_object_image_animated_frame_count_get,
+ * @ref evas_object_image_animated_loop_type_get,
+ * @ref evas_object_image_animated_loop_count_get,
+ *
+ * @param[in] frame_num Number of frames in the sequence.
+ *
+ * @since 1.1
+ */
+EAPI double evas_object_image_animated_frame_duration_get(const Evas_Object *obj, int start_frame, int frame_num);
+
+/**
*
* Set the load size of a given image object's source image.
*
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)
+class Evas.Image (Evas.Object, Efl.File, Efl.Image, Efl.Image_Animated, Efl.Gfx.Fill, Efl.Gfx.View, Evas.Filter)
{
legacy_prefix: evas_object_image;
eo_prefix: evas_obj_image;
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.
]]
}
}
- @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.
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 {
@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.
Efl.File.mmap.set;
Efl.File.mmap.get;
Efl.File.save;
- Efl.Image.animated.get;
+ Efl.Image_Animated.animated.get;
+ Efl.Image_Animated.animated_frame.get;
+ Efl.Image_Animated.animated_frame.set;
+ Efl.Image_Animated.animated_frame_count.get;
+ 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;
/* animated feature */
EOLIAN static Eina_Bool
-_evas_image_efl_image_animated_get(Eo *eo_obj, Evas_Image_Data *o)
+_evas_image_efl_image_animated_animated_get(Eo *eo_obj, Evas_Image_Data *o)
{
Eina_Bool animated;
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
}
EOLIAN static int
-_evas_image_animated_frame_count_get(Eo *eo_obj, Evas_Image_Data *o)
+_evas_image_efl_image_animated_animated_frame_count_get(Eo *eo_obj, Evas_Image_Data *o)
{
int frame_count;
frame_count = -1;
return frame_count;
}
-EOLIAN static Evas_Image_Animated_Loop_Hint
-_evas_image_animated_loop_type_get(Eo *eo_obj, Evas_Image_Data *o)
+EOLIAN static Efl_Image_Animated_Loop_Hint
+_evas_image_efl_image_animated_animated_loop_type_get(Eo *eo_obj, Evas_Image_Data *o)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
+ Efl_Image_Animated_Loop_Hint hint = EFL_IMAGE_ANIMATED_LOOP_HINT_NONE;
- Evas_Image_Animated_Loop_Hint hint;
- hint = EVAS_IMAGE_ANIMATED_HINT_NONE;
if (!evas_object_image_animated_get(eo_obj)) return hint;
if (ENFN->image_animated_loop_type_get)
- hint = ENFN->image_animated_loop_type_get(ENDT, o->engine_data);
+ hint = (Efl_Image_Animated_Loop_Hint) ENFN->image_animated_loop_type_get(ENDT, o->engine_data);
return hint;
}
EOLIAN static int
-_evas_image_animated_loop_count_get(Eo *eo_obj, Evas_Image_Data *o)
+_evas_image_efl_image_animated_animated_loop_count_get(Eo *eo_obj, Evas_Image_Data *o)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
}
EOLIAN static double
-_evas_image_animated_frame_duration_get(const Eo *eo_obj, Evas_Image_Data *o, int start_frame, int frame_num)
+_evas_image_efl_image_animated_animated_frame_duration_get(Eo *eo_obj, Evas_Image_Data *o, int start_frame, int frame_num)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
+ double frame_duration = -1;
int frame_count = 0;
- double frame_duration;
- frame_duration = -1;
-
if (!ENFN->image_animated_frame_count_get) return frame_duration;
frame_count = ENFN->image_animated_frame_count_get(ENDT, o->engine_data);
return frame_duration;
}
-EOLIAN static void
-_evas_image_animated_frame_set(Eo *eo_obj, Evas_Image_Data *o, int frame_index)
+EOLIAN static Eina_Bool
+_evas_image_efl_image_animated_animated_frame_set(Eo *eo_obj, Evas_Image_Data *o, int frame_index)
{
Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
int frame_count = 0;
- if (!o->cur->u.file) return;
- if (o->cur->frame == frame_index) return;
+ if (!o->cur->u.file) return EINA_FALSE;
+ if (o->cur->frame == frame_index) return EINA_TRUE;
- if (!evas_object_image_animated_get(eo_obj)) return;
+ if (!evas_object_image_animated_get(eo_obj)) return EINA_FALSE;
evas_object_async_block(obj);
frame_count = evas_object_image_animated_frame_count_get(eo_obj);
/* limit the size of frame to FRAME_MAX */
if ((frame_count > FRAME_MAX) || (frame_count < 0) || (frame_index > frame_count))
- return;
+ return EINA_FALSE;
- if (!ENFN->image_animated_frame_set) return;
+ if (!ENFN->image_animated_frame_set) return EINA_FALSE;
ENFN->image_animated_frame_set(ENDT, o->engine_data, frame_index);
// if (!ENFN->image_animated_frame_set(ENDT, o->engine_data, frame_index)) return;
o->changed = EINA_TRUE;
evas_object_change(eo_obj, obj);
+ return EINA_TRUE;
+}
+
+EOLIAN static int
+_evas_image_efl_image_animated_animated_frame_get(Eo *eo_obj, Evas_Image_Data *o)
+{
+ if (!o->cur->u.file) return EINA_FALSE;
+ if (!evas_object_image_animated_get(eo_obj)) return EINA_FALSE;
+ return o->cur->frame;
}
EOLIAN void
}
EAPI void
+evas_object_image_animated_frame_set(Evas_Object *obj, int frame_index)
+{
+ efl_image_animated_frame_set(obj, frame_index);
+}
+
+EAPI int
+evas_object_image_animated_frame_count_get(const Evas_Object *obj)
+{
+ return efl_image_animated_frame_count_get(obj);
+}
+
+EAPI Evas_Image_Animated_Loop_Hint
+evas_object_image_animated_loop_type_get(const Evas_Object *obj)
+{
+ return (Evas_Image_Animated_Loop_Hint) efl_image_animated_loop_type_get(obj);
+}
+
+EAPI int
+evas_object_image_animated_loop_count_get(const Evas_Object *obj)
+{
+ return efl_image_animated_loop_count_get(obj);
+}
+
+EAPI double
+evas_object_image_animated_frame_duration_get(const Evas_Object *obj, int start_frame, int frame_num)
+{
+ return efl_image_animated_frame_duration_get(obj, start_frame, frame_num);
+}
+
+EAPI void
evas_object_image_load_size_set(Eo *obj, int w, int h)
{
efl_image_load_size_set((Eo *) obj, w, h);
type @extern Evas.Load_Error: int; /* FIXME: Need to migrate emile. */
type @extern Evas.Image_Scale_Hint: int; /* FIXME: Need to migrate emile. */
-type @extern Evas.Image_Animated_Loop_Hint: int; /* FIXME: Need to migrate emile. */
struct @extern Evas.Video_Surface; /* FIXME: The structure is full of the unsupported func pointers. */
/* FIXME: Unsupported annonymous structures inside */
projects / platform / upstream / efl.git / commitdiff