Tizen Native API
5.0
|
Ecore animators are a helper to simplify creating animations.
Creating an animation is as simple as saying for how long it should be run and having a callback that does the animation, something like this:
static Eina_Bool _do_animation(void *data, double pos) { evas_object_move(data, 100 * pos, 100 * pos); ... do some more animating ... } ... ecore_animator_timeline_add(2, _do_animation, my_evas_object);
In the sample above we create an animation to move my_evas_object
from position (0,0) to (100,100) in 2 seconds.
If your animation will run for an unspecified amount of time you can use ecore_animator_add(), which is like using ecore_timer_add() with the interval being the framerate. Note that this has tangible benefits to creating a timer for each animation in terms of performance.
For a more detailed example that show several animation see Ecore animator example.
Functions | |
void | ecore_animator_frametime_set (double frametime) |
Sets the animator call interval in seconds. | |
double | ecore_animator_frametime_get (void) |
Gets the animator call interval in seconds. | |
double | ecore_animator_pos_map (double pos, Ecore_Pos_Map map, double v1, double v2) |
Maps an input position from 0.0 to 1.0 along a timeline to a position in a different curve. | |
double | ecore_animator_pos_map_n (double pos, Ecore_Pos_Map map, int v_size, double *v) |
Maps an input position from 0.0 to 1.0 along a timeline to a position in a different curve. | |
void | ecore_animator_source_set (Ecore_Animator_Source source) |
Sets the source of animator ticks for the mainloop. | |
Ecore_Animator_Source | ecore_animator_source_get (void) |
Gets the animator source currently set. | |
void | ecore_animator_custom_source_tick_begin_callback_set (Ecore_Cb func, const void *data) |
Sets the function that begins a custom animator tick source. | |
void | ecore_animator_custom_source_tick_end_callback_set (Ecore_Cb func, const void *data) |
Sets the function that ends a custom animator tick source. | |
void | ecore_animator_custom_tick (void) |
Triggers a custom animator tick. | |
Ecore_Animator * | ecore_animator_add (Ecore_Task_Cb func, const void *data) |
Adds an animator to call func at every animation tick during main loop execution. | |
Ecore_Animator * | ecore_animator_timeline_add (double runtime, Ecore_Timeline_Cb func, const void *data) |
Adds an animator that runs for a limited time. | |
void * | ecore_animator_del (Ecore_Animator *animator) |
Deletes the specified animator from the animator list. | |
void | ecore_animator_freeze (Ecore_Animator *animator) |
Suspends the specified animator. | |
void | ecore_animator_thaw (Ecore_Animator *animator) |
Restores execution of the specified animator. | |
Typedefs | |
typedef Eina_Bool(* | Ecore_Timeline_Cb )(void *data, double pos) |
typedef Eo | Ecore_Animator |
typedef Eo Ecore_Animator |
A handle for animators
A callback run for a task (animators with runtimes)
Defines the timing sources for animators.
ECORE_ANIMATOR_SOURCE_TIMER |
The default system clock/timer based animator that ticks every "frametime" seconds |
ECORE_ANIMATOR_SOURCE_CUSTOM |
A custom animator trigger that you need to call ecore_animator_custom_tick() to make it tick |
enum _Ecore_Pos_Map |
Defines the position mappings for the animation.
Ecore_Animator* ecore_animator_add | ( | Ecore_Task_Cb | func, |
const void * | data | ||
) |
Adds an animator to call func
at every animation tick during main loop execution.
func | The function to call when it ticks off |
data | The data to pass to the function |
This function adds an animator and returns its handle on success and NULL
on failure. The function func
will be called every N seconds where N is the frametime
interval set by ecore_animator_frametime_set(). The function will be passed the data
pointer as its parameter.
When the animator func
is called, it must return a boolean value. If it returns EINA_TRUE
(or ECORE_CALLBACK_RENEW
), it will be called again at the next tick, or if it returns EINA_FALSE
(or ECORE_CALLBACK_CANCEL
) it will be deleted automatically making any references/handles for it invalid.
frametime
value is 1/30th of a second.void ecore_animator_custom_source_tick_begin_callback_set | ( | Ecore_Cb | func, |
const void * | data | ||
) |
Sets the function that begins a custom animator tick source.
func | The function to call when ticking is to begin |
data | The data passed to the tick begin function as its parameter |
The Ecore Animator infrastructure handles tracking if animators are needed or not and which ones need to be called and when, but when the tick source is custom, you have to provide a tick source by calling ecore_animator_custom_tick() to indicate a frame tick happened. In order to allow the source of ticks to be dynamically enabled or disabled as needed, the func
when set is called to enable the tick source to produce tick events that call ecore_animator_custom_tick(). If func
is NULL
then no function is called to begin custom ticking.
void ecore_animator_custom_source_tick_end_callback_set | ( | Ecore_Cb | func, |
const void * | data | ||
) |
Sets the function that ends a custom animator tick source.
func | The function to call when ticking is to end |
data | The data passed to the tick end function as its parameter |
This function is a matching pair to the function set by ecore_animator_custom_source_tick_begin_callback_set() and is called when ticking is to stop. If func
is NULL
then no function will be called to stop ticking. For more information please see ecore_animator_custom_source_tick_begin_callback_set().
void ecore_animator_custom_tick | ( | void | ) |
Triggers a custom animator tick.
When animator source is set to ECORE_ANIMATOR_SOURCE_CUSTOM, then calling this function triggers a run of all animators currently registered with Ecore as this indicates a "frame tick" happened. This will do nothing if the animator source(set by ecore_animator_source_set()) is not set to ECORE_ANIMATOR_SOURCE_CUSTOM.
void* ecore_animator_del | ( | Ecore_Animator * | animator | ) |
Deletes the specified animator from the animator list.
animator | The animator to delete |
Deletes the specified animator
from the set of animators that are executed during main loop execution. This function returns the data parameter that was being passed to the callback on success, or NULL
on failure. After this call returns the specified animator object animator
is invalid and should not be used again. It will not get called again after deletion.
double ecore_animator_frametime_get | ( | void | ) |
Gets the animator call interval in seconds.
This function retrieves the time in seconds between animator ticks.
void ecore_animator_frametime_set | ( | double | frametime | ) |
Sets the animator call interval in seconds.
frametime | The time in seconds in between animator ticks. |
This function sets the time interval (in seconds) between animator ticks. At every tick the callback of every existing animator will be called.
frametime
value is 1/30th of a second.void ecore_animator_freeze | ( | Ecore_Animator * | animator | ) |
Suspends the specified animator.
animator | The animator to delete |
The specified animator
will be temporarily removed from the set of animators that are executed during main loop.
pos
argument given to the callback will increase as if the animator hadn't been frozen and the animator may have it's execution halted if runtime
elapsed.double ecore_animator_pos_map | ( | double | pos, |
Ecore_Pos_Map | map, | ||
double | v1, | ||
double | v2 | ||
) |
Maps an input position from 0.0 to 1.0 along a timeline to a position in a different curve.
pos | The input position to map |
map | The mapping to use |
v1 | A parameter use by the mapping (pass 0.0 if not used) |
v2 | A parameter use by the mapping (pass 0.0 if not used) |
Takes an input position (0.0 to 1.0) and maps to a new position (normally between 0.0 and 1.0, but it may go above/below 0.0 or 1.0 to show that it has "overshot" the mark) using some interpolation (mapping) algorithm.
This function useful to create non-linear animations. It offers a variety of possible animation curves to be used:
pos
One way to use this would be:
double pos; // input position in a timeline from 0.0 to 1.0 double out; // output position after mapping int x1, y1, x2, y2; // x1 & y1 are start position, x2 & y2 are end position int x, y; // x & y are the calculated position out = ecore_animator_pos_map(pos, ECORE_POS_MAP_BOUNCE, 1.8, 7); x = (x1 * out) + (x2 * (1.0 - out)); y = (y1 * out) + (y2 * (1.0 - out)); move_my_object_to(myobject, x, y);
This will make an animation that bounces 7 each times diminishing by a factor of 1.8.
double ecore_animator_pos_map_n | ( | double | pos, |
Ecore_Pos_Map | map, | ||
int | v_size, | ||
double * | v | ||
) |
Maps an input position from 0.0 to 1.0 along a timeline to a position in a different curve.
pos | The input position to map |
map | The mapping to use |
v_size | The size of the v array. |
v | An array with the double parameters to be used by the mapping. NULL if not used. |
Takes an input position (0.0 to 1.0) and maps to a new position (normally between 0.0 and 1.0, but it may go above/below 0.0 or 1.0 to show that it has "overshot" the mark) using some interpolation (mapping) algorithm.
This function useful to create non-linear animations. It offers a variety of possible animation curves to be used:
pos
One way to use this would be:
double pos; // input position in a timeline from 0.0 to 1.0 double out; // output position after mapping int x1, y1, x2, y2; // x1 & y1 are start position, x2 & y2 are end position int x, y; // x & y are the calculated position double v[2] = {1.8, 7}; out = ecore_animator_pos_map(pos, ECORE_POS_MAP_BOUNCE, 2, v); x = (x1 * out) + (x2 * (1.0 - out)); y = (y1 * out) + (y2 * (1.0 - out)); move_my_object_to(myobject, x, y);
This will make an animation that bounces 7 each times diminishing by a factor of 1.8.
Ecore_Animator_Source ecore_animator_source_get | ( | void | ) |
Gets the animator source currently set.
This gets the current animator source.
void ecore_animator_source_set | ( | Ecore_Animator_Source | source | ) |
Sets the source of animator ticks for the mainloop.
source | The source of animator ticks to use |
This sets the source of animator ticks. When an animator is active the mainloop will "tick" over frame by frame calling all animators that are registered until none are. The mainloop will tick at a given rate based on the animator source. The default source is the system clock timer source - ECORE_ANIMATOR_SOURCE_TIMER. This source uses the system clock to tick over every N seconds (specified by ecore_animator_frametime_set(), with the default being 1/30th of a second unless set otherwise). You can set a custom tick source by setting the source to ECORE_ANIMATOR_SOURCE_CUSTOM and then drive it yourself based on some input tick source (like another application via ipc, some vertical blanking interrupt, and etc.) using ecore_animator_custom_source_tick_begin_callback_set() and ecore_animator_custom_source_tick_end_callback_set() to set the functions that will be called to start and stop the ticking source, which when it gets a "tick" should call ecore_animator_custom_tick() to make the "tick" over 1 frame.
void ecore_animator_thaw | ( | Ecore_Animator * | animator | ) |
Restores execution of the specified animator.
animator | The animator to delete |
The specified animator
will be put back in the set of animators that are executed during main loop.
Ecore_Animator* ecore_animator_timeline_add | ( | double | runtime, |
Ecore_Timeline_Cb | func, | ||
const void * | data | ||
) |
Adds an animator that runs for a limited time.
runtime | The time to run in seconds |
func | The function to call when it ticks off |
data | The data to pass to the function |
This function is just like ecore_animator_add() except the animator only runs for a limited time specified in seconds by runtime
. Once the runtime the animator has elapsed (animator finished) it will automatically be deleted. The callback function func
can return ECORE_CALLBACK_RENEW
to keep the animator running or ECORE_CALLBACK_CANCEL
ro stop it and have it be deleted automatically at any time.
The func
will ALSO be passed a position parameter that will be in value from 0.0 to 1.0 to indicate where along the timeline (0.0 start, 1.0 end) the animator run is at. If the callback wishes not to have a linear transition it can "map" this value to one of several curves and mappings via ecore_animator_pos_map().
frametime
value is 1/30th of a second.