lib/efl/interfaces/efl_gfx_entity.eo \
lib/efl/interfaces/efl_gfx_color.eo \
lib/efl/interfaces/efl_image.eo \
- lib/efl/interfaces/efl_image_animated.eo \
+ lib/efl/interfaces/efl_image_animation_controller.eo \
lib/efl/interfaces/efl_input_device.eo \
lib/efl/interfaces/efl_ecore_input_device.eo \
lib/efl/interfaces/efl_ui_draggable.eo \
#include "interfaces/efl_duplicate.eo.h"
#include "interfaces/efl_file.eo.h"
#include "interfaces/efl_image.eo.h"
-#include "interfaces/efl_image_animated.eo.h"
+#include "interfaces/efl_image_animation_controller.eo.h"
#include "interfaces/efl_image_load.eo.h"
#include "interfaces/efl_part.eo.h"
#include "interfaces/efl_playable.eo.h"
#include "interfaces/efl_gfx_fill.eo.legacy.h"
#include "interfaces/efl_gfx_entity.eo.legacy.h"
#include "interfaces/efl_image.eo.legacy.h"
-#include "interfaces/efl_image_animated.eo.legacy.h"
+#include "interfaces/efl_image_animation_controller.eo.legacy.h"
#include "interfaces/efl_input_device.eo.legacy.h"
#include "interfaces/efl_ecore_input_device.eo.legacy.h"
#include "interfaces/efl_text_types.eot.h"
/* FIXME: invalid type from evas/emile! */
/* type @extern Evas.Animated_Loop_Hint: int; */
-enum Efl.Image.Animated.Loop_Hint {
+enum Efl.Image_Animation_Controller_Loop_Hint {
[[Image animation loop modes]]
none = 0, [[No looping order specified.]]
loop = 1, [[Standard loop: 1->2->3->1->2->3->1]]
pingpong = 2 [[Ping-pong bouncing loop: 1->2->3->2->1->2->3->1]]
}
-/* FIXME: rename to Efl.Image.Animated when eo/eolian are fixed */
+/* FIXME: rename to Efl.Image_Animation_Controller when eo/eolian are fixed */
-interface Efl.Image.Animated ()
+interface Efl.Image_Animation_Controller ()
{
[[Efl animated image interface]]
eo_prefix: efl_image;
This returns the kind of looping the image object wants to do.
- If it returns @Efl.Image.Animated.Loop_Hint.loop, you should
+ If it returns @Efl.Image_Animation_Controller_Loop_Hint.loop, you should
display frames in a sequence like: 1->2->3->1->2->3->1...
- If it returns @Efl.Image.Animated.Loop_Hint.pingpong, it is
+ If it returns @Efl.Image_Animation_Controller_Loop_Hint.pingpong, it is
better to display frames in a sequence like:
1->2->3->2->1->2->3->1...
- The default type is @Efl.Image.Animated.Loop_Hint.loop.
+ The default type is @Efl.Image_Animation_Controller_Loop_Hint.loop.
@since 1.1
]]
- return: Efl.Image.Animated.Loop_Hint; [[Loop type of the image object.]]
+ return: Efl.Image_Animation_Controller_Loop_Hint; [[Loop type of the image object.]]
}
}
@property animated_loop_count {
#include "interfaces/efl_control.eo.c"
#include "interfaces/efl_duplicate.eo.c"
#include "interfaces/efl_image.eo.c"
-#include "interfaces/efl_image_animated.eo.c"
+#include "interfaces/efl_image_animation_controller.eo.c"
#include "interfaces/efl_image_load.eo.c"
#include "interfaces/efl_part.eo.c"
#include "interfaces/efl_playable.eo.c"
}
EOLIAN static Eina_Bool
-_efl_canvas_image_efl_image_animated_animated_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
+_efl_canvas_image_efl_image_animation_controller_animated_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_get(eo_obj);
}
}
EOLIAN static int
-_efl_canvas_image_efl_image_animated_animated_frame_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
+_efl_canvas_image_efl_image_animation_controller_animated_frame_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_frame_count_get(eo_obj);
}
-Efl_Image_Animated_Loop_Hint
+Efl_Image_Animation_Controller_Loop_Hint
_evas_image_animated_loop_type_get(const Eo *eo_obj)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
if (!ENFN->image_animated_loop_type_get ||
!evas_object_image_animated_get(eo_obj))
- return EFL_IMAGE_ANIMATED_LOOP_HINT_NONE;
+ return EFL_IMAGE_ANIMATION_CONTROLLER_LOOP_HINT_NONE;
- return (Efl_Image_Animated_Loop_Hint) ENFN->image_animated_loop_type_get(ENC, o->engine_data);
+ return (Efl_Image_Animation_Controller_Loop_Hint) ENFN->image_animated_loop_type_get(ENC, o->engine_data);
}
-EOLIAN static Efl_Image_Animated_Loop_Hint
-_efl_canvas_image_efl_image_animated_animated_loop_type_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
+EOLIAN static Efl_Image_Animation_Controller_Loop_Hint
+_efl_canvas_image_efl_image_animation_controller_animated_loop_type_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_loop_type_get(eo_obj);
}
}
EOLIAN static int
-_efl_canvas_image_efl_image_animated_animated_loop_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
+_efl_canvas_image_efl_image_animation_controller_animated_loop_count_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_loop_count_get(eo_obj);
}
}
EOLIAN static double
-_efl_canvas_image_efl_image_animated_animated_frame_duration_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int start_frame, int frame_num)
+_efl_canvas_image_efl_image_animation_controller_animated_frame_duration_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int start_frame, int frame_num)
{
return _evas_image_animated_frame_duration_get(eo_obj, start_frame, frame_num);
}
}
EOLIAN static Eina_Bool
-_efl_canvas_image_efl_image_animated_animated_frame_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int frame_index)
+_efl_canvas_image_efl_image_animation_controller_animated_frame_set(Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED, int frame_index)
{
return _evas_image_animated_frame_set(eo_obj, frame_index);
}
}
EOLIAN static int
-_efl_canvas_image_efl_image_animated_animated_frame_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
+_efl_canvas_image_efl_image_animation_controller_animated_frame_get(const Eo *eo_obj, void *_pd EINA_UNUSED EINA_UNUSED)
{
return _evas_image_animated_frame_get(eo_obj);
}
class Efl.Canvas.Image (Efl.Canvas.Image_Internal, Efl.Gfx.Buffer,
- Efl.Image.Load, Efl.Image.Animated,
+ Efl.Image.Load, Efl.Image_Animation_Controller,
Efl.File)
{
[[Low-level Image object.
Efl.Gfx.Buffer.buffer_unmap;
Efl.File.mmap { get; set; }
Efl.File.load_error { get; }
- Efl.Image.Animated.animated { get; }
- Efl.Image.Animated.animated_frame { get; 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_Animation_Controller.animated { get; }
+ Efl.Image_Animation_Controller.animated_frame { get; set; }
+ Efl.Image_Animation_Controller.animated_frame_count { get; }
+ Efl.Image_Animation_Controller.animated_loop_type { get; }
+ Efl.Image_Animation_Controller.animated_loop_count { get; }
+ Efl.Image_Animation_Controller.animated_frame_duration { get; }
Efl.Image.Load.load_async_start;
Efl.Image.Load.load_async_cancel;
Efl.Image.Load.load_dpi { get; set; }
Eina_Bool _evas_image_load_region_support_get(const Eo *eo_obj);
void _evas_image_orientation_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Orient orient);
-/* Efl.Image.Animated */
+/* Efl.Image_Animation_Controller */
Eina_Bool _evas_image_animated_get(const Eo *eo_obj);
int _evas_image_animated_frame_count_get(const Eo *eo_obj);
-Efl_Image_Animated_Loop_Hint _evas_image_animated_loop_type_get(const Eo *eo_obj);
+Efl_Image_Animation_Controller_Loop_Hint _evas_image_animated_loop_type_get(const Eo *eo_obj);
int _evas_image_animated_loop_count_get(const Eo *eo_obj);
double _evas_image_animated_frame_duration_get(const Eo *eo_obj, int start_frame, int frame_num);
Eina_Bool _evas_image_animated_frame_set(Eo *eo_obj, int frame_index);