summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJonas M. Gastal <jgastal@profusion.mobi>2011-06-16 18:13:03 +0000
committerJonas M. Gastal <jgastal@profusion.mobi>2011-06-16 18:13:03 +0000
commit718cca963cb281fd6c870b0da59d7164a406355d (patch)
tree31f4b803ad6ccbb9a24fca096e785eeeb7ff4284
parenta4cb2b2f0e12c9db4dd6201821522adccb9fc8d8 (diff)
Elementary: elm_animator documentation and example.
SVN revision: 60405
-rw-r--r--legacy/elementary/doc/img/elm_animator_curve_style.pngbin0 -> 23523 bytes
-rw-r--r--legacy/elementary/src/examples/animator_example_01.c103
-rw-r--r--legacy/elementary/src/lib/Elementary.h.in253
-rw-r--r--legacy/elementary/src/lib/elm_animator.c139
4 files changed, 355 insertions, 140 deletions
diff --git a/legacy/elementary/doc/img/elm_animator_curve_style.png b/legacy/elementary/doc/img/elm_animator_curve_style.png
new file mode 100644
index 0000000000..8802b2b691
--- /dev/null
+++ b/legacy/elementary/doc/img/elm_animator_curve_style.png
Binary files differ
diff --git a/legacy/elementary/src/examples/animator_example_01.c b/legacy/elementary/src/examples/animator_example_01.c
new file mode 100644
index 0000000000..eea2bb62f8
--- /dev/null
+++ b/legacy/elementary/src/examples/animator_example_01.c
@@ -0,0 +1,103 @@
1//Compile with:
2//gcc -g `pkg-config --cflags --libs elementary` animator_example_01.c -o animator_example_01
3
4#include <Elementary.h>
5#include <limits.h>
6
7static void
8on_done(void *data, Evas_Object *obj, void *event_info)
9{
10 elm_exit();
11}
12
13static void
14_op_cb(void *data, Elm_Animator *animator, double frame)
15{
16 evas_object_resize(data, 100 * frame, 100 * frame);
17 evas_object_move(data, 50 * frame, 50 * frame);
18 evas_object_color_set(data, 255 * frame, 0, 255 * (1 - frame), 255);
19}
20
21static void
22_end_cb(void *data)
23{
24 printf("Wow, you're very patient!\n");
25}
26
27static void
28_pause_resume(void *data, Evas_Object *obj, void *event_info)
29{
30 static Eina_Bool paused = EINA_FALSE;
31 if (!paused)
32 {
33 elm_animator_pause(data);
34 elm_button_label_set(obj, "Resume");
35 paused = EINA_TRUE;
36 }
37 else
38 {
39 elm_animator_resume(data);
40 elm_button_label_set(obj, "Pause");
41 paused = EINA_FALSE;
42 }
43}
44
45static void
46_stop(void *data, Evas_Object *obj, void *event_info)
47{
48 elm_animator_stop(data);
49}
50
51EAPI int
52elm_main(int argc, char **argv)
53{
54 Evas_Object *win, *bg, *button, *rectangle;
55 Elm_Animator *animator;
56
57 win = elm_win_add(NULL, "animator", ELM_WIN_BASIC);
58 elm_win_title_set(win, "Animator");
59 evas_object_smart_callback_add(win, "delete,request", on_done, NULL);
60
61 bg = elm_bg_add(win);
62 elm_win_resize_object_add(win, bg);
63 evas_object_resize(bg, 200, 200);
64 evas_object_show(bg);
65
66 rectangle = evas_object_rectangle_add(evas_object_evas_get(win));
67 evas_object_color_set(rectangle, 0, 0, 255, 255);
68 evas_object_show(rectangle);
69
70 animator = elm_animator_add(NULL);
71 elm_animator_duration_set(animator, 1);
72 elm_animator_auto_reverse_set(animator, EINA_TRUE);
73 elm_animator_repeat_set(animator, UINT_MAX);
74 elm_animator_curve_style_set(animator, ELM_ANIMATOR_CURVE_IN_OUT);
75 elm_animator_operation_callback_set(animator, _op_cb, rectangle);
76 elm_animator_completion_callback_set(animator, _end_cb, NULL);
77 elm_animator_animate(animator);
78
79 button = elm_button_add(win);
80 elm_button_label_set(button, "Pause");
81 evas_object_resize(button, 50, 30);
82 evas_object_move(button, 10, 210);
83 evas_object_smart_callback_add(button, "clicked", _pause_resume, animator);
84 evas_object_show(button);
85
86 button = elm_button_add(win);
87 elm_button_label_set(button, "Stop");
88 evas_object_resize(button, 50, 30);
89 evas_object_move(button, 70, 210);
90 evas_object_smart_callback_add(button, "clicked", _stop, animator);
91 evas_object_show(button);
92
93 evas_object_resize(win, 200, 250);
94 evas_object_show(win);
95
96 elm_run();
97
98 evas_object_del(rectangle);
99 elm_animator_del(animator);
100
101 return 0;
102}
103ELM_MAIN()
diff --git a/legacy/elementary/src/lib/Elementary.h.in b/legacy/elementary/src/lib/Elementary.h.in
index 45924dcf83..8d6eb50f19 100644
--- a/legacy/elementary/src/lib/Elementary.h.in
+++ b/legacy/elementary/src/lib/Elementary.h.in
@@ -3304,7 +3304,120 @@ EAPI Elm_Genlist_Item *elm_genlist_item_sorted_insert(Evas_Object *obj, const El
3304 * default 3304 * default
3305 */ 3305 */
3306 3306
3307 /* animator */ 3307 /**
3308 * @page elm_animator_example_page_01 Animator usage
3309 * @dontinclude animator_example_01.c
3310 *
3311 * For this example we will be using a bit of evas, you could animate a
3312 * elementary widget in much the same way, but to keep things simple we use
3313 * an evas_object_rectangle.
3314 *
3315 * As every other example we start with our include and a simple callback to
3316 * exit the app when the window is closed:
3317 * @skipline #include
3318 * @until }
3319 *
3320 * This next callback is the one that actually creates our animation, it
3321 * changes the size, position and color of a rectangle given to it in @a
3322 * data:
3323 * @until }
3324 *
3325 * Next we have a callback that prints a string, nothing special:
3326 * @until }
3327 *
3328 * This next callback is a little more interesting, it has a state variable
3329 * to know if the animation is currently paused or running, and it toogles
3330 * the state of the animation accordingly:
3331 * @until }
3332 * @until }
3333 * @until }
3334 *
3335 * Finally we have a callback to stop the animation:
3336 * @until }
3337 *
3338 * As with every example we need to do a bit of setup before we can actually
3339 * use an animation, but for the purposes of this example that's not relevant
3340 * so let's just skip to the good stuff, creating an animator:
3341 * @skipline animator_add
3342 * @note Since elm_animator is not a widget we can give it a NULL parent.
3343 *
3344 * Now that we have an elm_animator we set it's duration to 1 second:
3345 * @line duration_set
3346 *
3347 * We would also like our animation to be reversible, so:
3348 * @line reverse_set
3349 *
3350 * We also set our animation to repeat as many times as possible, which will
3351 * mean that _end_cb will only be called after UINT_MAX * 2 seconds(UINT_MAX
3352 * for the animation running forward and UNIT_MAX for the animation running
3353 * backwards):
3354 * @line repeat_set
3355 *
3356 * To add some fun to our animation we will use the IN_OUT curve style:
3357 * @line curve_style
3358 *
3359 * To actually animate anything we need an operation callback:
3360 * @line operation_callback
3361 *
3362 * Even though we set our animation to repeat for a very long time we are
3363 * going to set a end callback to it:
3364 * @line completion_callback
3365 * @note Notice that stoping the animation with the stop button will not make
3366 * _end_cb be called.
3367 *
3368 * Now that we have fully set up our animator we can tell it to start
3369 * animating:
3370 * @line animate
3371 *
3372 * There's a bit more of code that doesn't really matter to use so we skip
3373 * right down to our last interesting point:
3374 * @skipline animator_del
3375 * @note Because we created our animator with no parent we need to delete it
3376 * ourselves.
3377 *
3378 * The full source code for this example can be found @ref
3379 * animator_example_01_c "here"
3380 */
3381 /**
3382 * @page animator_example_01_c Animator example 01
3383 * @include animator_example_01.c
3384 * @example animator_example_01.c
3385 */
3386 /**
3387 * @addtogroup Animator Animator
3388 * @ingroup Elementary
3389 *
3390 * @brief Functions to ease creation of animations.
3391 *
3392 * elm_animator is designed to provide an easy way to create animations.
3393 * Creating an animation with elm_animator is as simple as setting a
3394 * duration, an operating callback and telling it to run the animation.
3395 * However that is not the full extent of elm_animator's ability, animations
3396 * can be paused and resumed, reversed and the animation need not be linear.
3397 *
3398 * To run an animation you must specify at least a duration and operation
3399 * callback, not setting any other properties will create a linear animation
3400 * that runs once and is not reversed.
3401 *
3402 * @ref elm_animator_example_page_01 "This" example should make all of that
3403 * very clear.
3404 *
3405 * @warning elm_animator is @b not a widget.
3406 * @{
3407 */
3408 /**
3409 * @brief Type of curve desired for animation.
3410 *
3411 * The speed in which an animation happens doesn't have to be linear, some
3412 * animations will look better if they're accelerating or decelerating, so
3413 * elm_animator provides four options in this regard:
3414 * @image html elm_animator_curve_style.png
3415 * As can be seen in the image the speed of the animation will be:
3416 * @li ELM_ANIMATOR_CURVE_LINEAR constant
3417 * @li ELM_ANIMATOR_CURVE_IN_OUT start slow, speed up and then slow down
3418 * @li ELM_ANIMATOR_CURVE_IN start slow and then speed up
3419 * @li ELM_ANIMATOR_CURVE_OUT start fast and then slow down
3420 */
3308 typedef enum 3421 typedef enum
3309 { 3422 {
3310 ELM_ANIMATOR_CURVE_LINEAR, 3423 ELM_ANIMATOR_CURVE_LINEAR,
@@ -3326,22 +3439,160 @@ EAPI Elm_Genlist_Item *elm_genlist_item_sorted_insert(Evas_Object *obj, const El
3326 */ 3439 */
3327 typedef void (*Elm_Animator_Completion_Cb) (void *data); 3440 typedef void (*Elm_Animator_Completion_Cb) (void *data);
3328 3441
3442 /**
3443 * @brief Create a new animator.
3444 *
3445 * @param[in] parent Parent object
3446 *
3447 * The @a parent argument can be set to NULL for no parent. If a parent is set
3448 * there is no need to call elm_animator_del(), when the parent is deleted it
3449 * will delete the animator.
3450 */
3329 EAPI Elm_Animator* elm_animator_add(Evas_Object *parent); 3451 EAPI Elm_Animator* elm_animator_add(Evas_Object *parent);
3452 /**
3453 * Deletes the animator freeing any resources it used. If the animator was
3454 * created with a NULL parent this must be called, otherwise it will be
3455 * automatically called when the parent is deleted.
3456 *
3457 * @param[in] animator Animator object
3458 */
3330 EAPI void elm_animator_del(Elm_Animator *animator) EINA_ARG_NONNULL(1); 3459 EAPI void elm_animator_del(Elm_Animator *animator) EINA_ARG_NONNULL(1);
3460 /**
3461 * Set the duration of the animation.
3462 *
3463 * @param[in] animator Animator object
3464 * @param[in] duration Duration in second
3465 */
3331 EAPI void elm_animator_duration_set(Elm_Animator *animator, double duration) EINA_ARG_NONNULL(1); 3466 EAPI void elm_animator_duration_set(Elm_Animator *animator, double duration) EINA_ARG_NONNULL(1);
3467 /**
3468 * @brief Set the callback function for animator operation.
3469 *
3470 * @param[in] animator Animator object
3471 * @param[in] func @ref Elm_Animator_Operation_Cb "Callback" function pointer
3472 * @param[in] data Callback function user argument
3473 *
3474 * The @p func callback will be called with a frame value in range [0, 1] which
3475 * indicates how far along the animation should be. It is the job of @p func to
3476 * actually change the state of any object(or objects) that are being animated.
3477 */
3332 EAPI void elm_animator_operation_callback_set(Elm_Animator *animator, Elm_Animator_Operation_Cb func, void *data) EINA_ARG_NONNULL(1); 3478 EAPI void elm_animator_operation_callback_set(Elm_Animator *animator, Elm_Animator_Operation_Cb func, void *data) EINA_ARG_NONNULL(1);
3479 /**
3480 * Set the callback function for the when the animation ends.
3481 *
3482 * @param[in] animator Animator object
3483 * @param[in] func Callback function pointe
3484 * @param[in] data Callback function user argument
3485 *
3486 * @warning @a func will not be executed if elm_animator_stop() is called.
3487 */
3333 EAPI void elm_animator_completion_callback_set(Elm_Animator *animator, Elm_Animator_Completion_Cb func, void *data) EINA_ARG_NONNULL(1); 3488 EAPI void elm_animator_completion_callback_set(Elm_Animator *animator, Elm_Animator_Completion_Cb func, void *data) EINA_ARG_NONNULL(1);
3489 /**
3490 * @brief Stop animator.
3491 *
3492 * @param[in] animator Animator object
3493 *
3494 * If called before elm_animator_animate() it does nothing. If there is an
3495 * animation in progress the animation will be stopped(the operation callback
3496 * will not be executed again) and it can't be restarted using
3497 * elm_animator_resume().
3498 */
3334 EAPI void elm_animator_stop(Elm_Animator *animator) EINA_ARG_NONNULL(1); 3499 EAPI void elm_animator_stop(Elm_Animator *animator) EINA_ARG_NONNULL(1);
3500 /**
3501 * Set the animator repeat count.
3502 *
3503 * @param[in] animator Animator object
3504 * @param[in] repeat_cnt Repeat count
3505 */
3335 EAPI void elm_animator_repeat_set(Elm_Animator *animator, unsigned int repeat_cnt) EINA_ARG_NONNULL(1); 3506 EAPI void elm_animator_repeat_set(Elm_Animator *animator, unsigned int repeat_cnt) EINA_ARG_NONNULL(1);
3507 /**
3508 * @brief Start animation.
3509 *
3510 * @param[in] animator Animator object
3511 *
3512 * This function starts the animation if the nescessary properties(duration
3513 * and operation callback) have been set. Once started the animation will
3514 * run until complete or elm_animator_stop() is called.
3515 */
3336 EAPI void elm_animator_animate(Elm_Animator *animator) EINA_ARG_NONNULL(1); 3516 EAPI void elm_animator_animate(Elm_Animator *animator) EINA_ARG_NONNULL(1);
3517 /**
3518 * Sets the animation @ref Elm_Animator_Curve_Style "acceleration style".
3519 *
3520 * @param[in] animator Animator object
3521 * @param[in] cs Curve style. Default is ELM_ANIMATOR_CURVE_LINEAR
3522 */
3337 EAPI void elm_animator_curve_style_set(Elm_Animator *animator, Elm_Animator_Curve_Style cs) EINA_ARG_NONNULL(1); 3523 EAPI void elm_animator_curve_style_set(Elm_Animator *animator, Elm_Animator_Curve_Style cs) EINA_ARG_NONNULL(1);
3524 /**
3525 * Gets the animation @ref Elm_Animator_Curve_Style "acceleration style".
3526 *
3527 * @param[in] animator Animator object
3528 * @param[in] cs Curve style. Default is ELM_ANIMATOR_CURVE_LINEAR
3529 */
3338 EAPI Elm_Animator_Curve_Style elm_animator_curve_style_get(const Elm_Animator *animator); EINA_ARG_NONNULL(1); 3530 EAPI Elm_Animator_Curve_Style elm_animator_curve_style_get(const Elm_Animator *animator); EINA_ARG_NONNULL(1);
3531 /**
3532 * @brief Sets wether the animation should be automatically reversed.
3533 *
3534 * @param[in] animator Animator object
3535 * @param[in] reverse Reverse or not
3536 *
3537 * This controls wether the animation will be run on reverse imediately after
3538 * running forward. When this is set together with repetition the animation
3539 * will run in reverse once for each time it ran forward.@n
3540 * Runnin an animation in reverse is accomplished by calling the operation
3541 * callback with a frame value starting at 1 and diminshing until 0.
3542 */
3339 EAPI void elm_animator_auto_reverse_set(Elm_Animator *animator, Eina_Bool reverse) EINA_ARG_NONNULL(1); 3543 EAPI void elm_animator_auto_reverse_set(Elm_Animator *animator, Eina_Bool reverse) EINA_ARG_NONNULL(1);
3544 /**
3545 * Gets wether the animation will automatically reversed
3546 *
3547 * @param[in] animator Animator object
3548 */
3340 EAPI Eina_Bool elm_animator_auto_reverse_get(const Elm_Animator *animator) EINA_ARG_NONNULL(1); 3549 EAPI Eina_Bool elm_animator_auto_reverse_get(const Elm_Animator *animator) EINA_ARG_NONNULL(1);
3550 /**
3551 * Gets the status for the animator operation. The status of the animator @b
3552 * doesn't take in to account elm_animator_pause() or elm_animator_resume(), it
3553 * only informs if the animation was started and has not ended(either normally
3554 * or through elm_animator_stop()).
3555 *
3556 * @param[in] animator Animator object
3557 */
3341 EAPI Eina_Bool elm_animator_operating_get(const Elm_Animator *animator) EINA_ARG_NONNULL(1); 3558 EAPI Eina_Bool elm_animator_operating_get(const Elm_Animator *animator) EINA_ARG_NONNULL(1);
3559 /**
3560 * Gets how many times the animation will be repeated
3561 *
3562 * @param[in] animator Animator object
3563 */
3342 EAPI unsigned int elm_animator_repeat_get(const Elm_Animator *animator) EINA_ARG_NONNULL(1); 3564 EAPI unsigned int elm_animator_repeat_get(const Elm_Animator *animator) EINA_ARG_NONNULL(1);
3565 /**
3566 * Pause the animator.
3567 *
3568 * @param[in] animator Animator object
3569 *
3570 * This causes the animation to be temporarily stopped(the operation callback
3571 * will not be called). If the animation is not yet running this is a no-op.
3572 * Once an animation has been paused with this function it can be resumed
3573 * using elm_animator_resume().
3574 */
3343 EAPI void elm_animator_pause(Elm_Animator *animator) EINA_ARG_NONNULL(1); 3575 EAPI void elm_animator_pause(Elm_Animator *animator) EINA_ARG_NONNULL(1);
3576 /**
3577 * @brief Resumes the animator.
3578 *
3579 * @param[in] animator Animator object
3580 *
3581 * Resumes an animation that was paused using elm_animator_pause(), after
3582 * calling this function calls to the operation callback will happen
3583 * normally. If an animation is stopped by means of elm_animator_stop it
3584 * @b can't be restarted with this function.@n
3585 *
3586 * @warning When an animation is resumed it doesn't start from where it was paused, it
3587 * will go to where it would have been if it had not been paused. If an
3588 * animation with a duration of 3 seconds is paused after 1 second for 1 second
3589 * it will resume as if it had ben animating for 2 seconds, the operating
3590 * callback will be called with a frame value of aproximately 2/3.
3591 */
3344 EAPI void elm_animator_resume(Elm_Animator *animator) EINA_ARG_NONNULL(1); 3592 EAPI void elm_animator_resume(Elm_Animator *animator) EINA_ARG_NONNULL(1);
3593 /**
3594 * @}
3595 */
3345 3596
3346 /* calendar */ 3597 /* calendar */
3347 typedef enum 3598 typedef enum
diff --git a/legacy/elementary/src/lib/elm_animator.c b/legacy/elementary/src/lib/elm_animator.c
index 3d1993b04f..5808495e0f 100644
--- a/legacy/elementary/src/lib/elm_animator.c
+++ b/legacy/elementary/src/lib/elm_animator.c
@@ -14,18 +14,6 @@
14 } while (0) 14 } while (0)
15 15
16 16
17/**
18 * @addtogroup Animator Animator
19 * @ingroup Elementary
20 *
21 * elm_animator is designed to provides animation frame.
22 * It is somewhat different with any others widgets however elm_animator
23 * might useful when your GUIs have animation.
24 * Basically, it computes normalized frame value for animation,
25 * provides additional functions to adjust this also.
26 *
27 */
28
29struct _Elm_Animator 17struct _Elm_Animator
30{ 18{
31#define ELM_ANIMATOR_MAGIC 0x40777770 19#define ELM_ANIMATOR_MAGIC 0x40777770
@@ -164,14 +152,6 @@ _animator_parent_del(void *data, Evas *evas __UNUSED__,
164 elm_animator_del(data); 152 elm_animator_del(data);
165} 153}
166 154
167/**
168 * Get the value of reverse mode.
169 *
170 * @param[in] animator Animator object
171 * @return EINA_TRUE is reverse mode
172 *
173 * @ingroup Animator
174 */
175EAPI Eina_Bool 155EAPI Eina_Bool
176elm_animator_auto_reverse_get(const Elm_Animator *animator) 156elm_animator_auto_reverse_get(const Elm_Animator *animator)
177{ 157{
@@ -179,14 +159,6 @@ elm_animator_auto_reverse_get(const Elm_Animator *animator)
179 return animator->auto_reverse; 159 return animator->auto_reverse;
180} 160}
181 161
182/**
183 * Get the value of repeat count.
184 *
185 * @param[in] animator Animator object
186 * @return Repeat count
187 *
188 * @ingroup Animator
189 */
190EAPI unsigned int 162EAPI unsigned int
191elm_animator_repeat_get(const Elm_Animator *animator) 163elm_animator_repeat_get(const Elm_Animator *animator)
192{ 164{
@@ -194,14 +166,6 @@ elm_animator_repeat_get(const Elm_Animator *animator)
194 return animator->repeat_cnt; 166 return animator->repeat_cnt;
195} 167}
196 168
197/**
198 * Set the animation acceleration style.
199 *
200 * @param[in] animator Animator object
201 * @param[in] cs Curve style. Default is ELM_ANIMATOR_CURVE_LINEAR
202 *
203 * @ingroup Animator
204 */
205EAPI Elm_Animator_Curve_Style 169EAPI Elm_Animator_Curve_Style
206elm_animator_curve_style_get(const Elm_Animator *animator) 170elm_animator_curve_style_get(const Elm_Animator *animator)
207{ 171{
@@ -209,14 +173,6 @@ elm_animator_curve_style_get(const Elm_Animator *animator)
209 return animator->curve_style; 173 return animator->curve_style;
210} 174}
211 175
212/**
213 * Set auto reverse function.
214 *
215 * @param[in] animator Animator object
216 * @param[in] reverse Reverse or not
217 *
218 * @ingroup Animator
219 */
220EAPI void 176EAPI void
221elm_animator_auto_reverse_set(Elm_Animator *animator, Eina_Bool reverse) 177elm_animator_auto_reverse_set(Elm_Animator *animator, Eina_Bool reverse)
222{ 178{
@@ -231,14 +187,6 @@ elm_animator_auto_reverse_set(Elm_Animator *animator, Eina_Bool reverse)
231 _animator_compute_no_reverse_repeat_count(animator->repeat_cnt); 187 _animator_compute_no_reverse_repeat_count(animator->repeat_cnt);
232} 188}
233 189
234/**
235 * Set the animation acceleration style.
236 *
237 * @param[in] animator Animator object
238 * @param[in] cs Curve style. Default is ELM_ANIMATOR_CURVE_LINEAR
239 *
240 * @ingroup Animator
241 */
242EAPI void 190EAPI void
243elm_animator_curve_style_set(Elm_Animator *animator, 191elm_animator_curve_style_set(Elm_Animator *animator,
244 Elm_Animator_Curve_Style cs) 192 Elm_Animator_Curve_Style cs)
@@ -246,15 +194,6 @@ elm_animator_curve_style_set(Elm_Animator *animator,
246 ELM_ANIMATOR_CHECK_OR_RETURN(animator); 194 ELM_ANIMATOR_CHECK_OR_RETURN(animator);
247 animator->curve_style = cs; 195 animator->curve_style = cs;
248} 196}
249
250/**
251 * Set the operation duration.
252 *
253 * @param[in] animator Animator object
254 * @param[in] duration Duration in second
255 *
256 * @ingroup Animator
257 */
258EAPI void 197EAPI void
259elm_animator_duration_set(Elm_Animator *animator, double duration) 198elm_animator_duration_set(Elm_Animator *animator, double duration)
260{ 199{
@@ -263,16 +202,6 @@ elm_animator_duration_set(Elm_Animator *animator, double duration)
263 animator->duration = duration; 202 animator->duration = duration;
264} 203}
265 204
266/**
267 * Set the callback function for animator operation.
268 * The range of callback function frame data is to 0 ~ 1
269 * User can refer this frame value for one's animation frame data.
270 * @param[in] animator Animator object
271 * @param[in] func Callback function pointer
272 * @param[in] data Callback function user argument
273 *
274 * @ingroup Animator
275 */
276EAPI void 205EAPI void
277elm_animator_operation_callback_set(Elm_Animator *animator, 206elm_animator_operation_callback_set(Elm_Animator *animator,
278 Elm_Animator_Operation_Cb func, 207 Elm_Animator_Operation_Cb func,
@@ -284,14 +213,6 @@ elm_animator_operation_callback_set(Elm_Animator *animator,
284 animator->animator_arg = data; 213 animator->animator_arg = data;
285} 214}
286 215
287/**
288 * Add new animator.
289 *
290 * @param[in] parent Parent object
291 * @return animator object
292 *
293 * @ingroup Animator
294 */
295EAPI Elm_Animator * 216EAPI Elm_Animator *
296elm_animator_add(Evas_Object *parent) 217elm_animator_add(Evas_Object *parent)
297{ 218{
@@ -307,14 +228,6 @@ elm_animator_add(Evas_Object *parent)
307 return animator; 228 return animator;
308} 229}
309 230
310/**
311 * Get the status for the animator operation.
312 *
313 * @param[in] animator Animator object
314 * @return EINA_TRUE is animator is operating.
315 *
316 * @ingroup Animator
317 */
318EAPI Eina_Bool 231EAPI Eina_Bool
319elm_animator_operating_get(const Elm_Animator *animator) 232elm_animator_operating_get(const Elm_Animator *animator)
320{ 233{
@@ -322,13 +235,6 @@ elm_animator_operating_get(const Elm_Animator *animator)
322 return animator->on_animating; 235 return animator->on_animating;
323} 236}
324 237
325/**
326 * Delete animator.
327 *
328 * @param[in] animator Animator object
329 *
330 * @ingroup Animator
331 */
332EAPI void 238EAPI void
333elm_animator_del(Elm_Animator *animator) 239elm_animator_del(Elm_Animator *animator)
334{ 240{
@@ -342,15 +248,6 @@ elm_animator_del(Elm_Animator *animator)
342 free(animator); 248 free(animator);
343} 249}
344 250
345/**
346 * Set the callback function for the animator end.
347 *
348 * @param[in] animator Animator object
349 * @param[in] func Callback function pointe
350 * @param[in] data Callback function user argument
351 *
352 * @ingroup Animator
353 */
354EAPI void 251EAPI void
355elm_animator_completion_callback_set(Elm_Animator *animator, 252elm_animator_completion_callback_set(Elm_Animator *animator,
356 Elm_Animator_Completion_Cb func, 253 Elm_Animator_Completion_Cb func,
@@ -362,13 +259,6 @@ elm_animator_completion_callback_set(Elm_Animator *animator,
362 animator->completion_arg = data; 259 animator->completion_arg = data;
363} 260}
364 261
365/**
366 * Pause the animator.
367 *
368 * @param[in] animator Animator object
369 *
370 * @ingroup Animator
371 */
372EAPI void 262EAPI void
373elm_animator_pause(Elm_Animator *animator) 263elm_animator_pause(Elm_Animator *animator)
374{ 264{
@@ -377,13 +267,6 @@ elm_animator_pause(Elm_Animator *animator)
377 ecore_animator_freeze(animator->animator); 267 ecore_animator_freeze(animator->animator);
378} 268}
379 269
380/**
381 * Resume the animator.
382 *
383 * @param[in] animator Animator object
384 *
385 * @ingroup Animator
386 */
387EAPI void 270EAPI void
388elm_animator_resume(Elm_Animator *animator) 271elm_animator_resume(Elm_Animator *animator)
389{ 272{
@@ -392,13 +275,6 @@ elm_animator_resume(Elm_Animator *animator)
392 ecore_animator_thaw(animator->animator); 275 ecore_animator_thaw(animator->animator);
393} 276}
394 277
395/**
396 * Stop animator.
397 *
398 * @param[in] animator Animator object
399 *
400 * @ingroup Animator
401 */
402EAPI void 278EAPI void
403elm_animator_stop(Elm_Animator *animator) 279elm_animator_stop(Elm_Animator *animator)
404{ 280{
@@ -407,14 +283,6 @@ elm_animator_stop(Elm_Animator *animator)
407 _delete_animator(animator); 283 _delete_animator(animator);
408} 284}
409 285
410/**
411 * Set the animator repeat count.
412 *
413 * @param[in] animator Animator object
414 * @param[in] repeat_cnt Repeat count
415 *
416 * @ingroup Animator
417 */
418EAPI void 286EAPI void
419elm_animator_repeat_set(Elm_Animator *animator, unsigned int repeat_cnt) 287elm_animator_repeat_set(Elm_Animator *animator, unsigned int repeat_cnt)
420{ 288{
@@ -424,13 +292,6 @@ elm_animator_repeat_set(Elm_Animator *animator, unsigned int repeat_cnt)
424 animator->repeat_cnt = _animator_compute_reverse_repeat_count(repeat_cnt); 292 animator->repeat_cnt = _animator_compute_reverse_repeat_count(repeat_cnt);
425} 293}
426 294
427/**
428 * Animate now.
429 *
430 * @param[in] animator Animator object
431 *
432 * @ingroup Animator
433 */
434EAPI void 295EAPI void
435elm_animator_animate(Elm_Animator *animator) 296elm_animator_animate(Elm_Animator *animator)
436{ 297{