# lv_anim.h (/api/misc/lv_anim_h)
Functions [#functions]
lv_anim_set_var [#lv_anim_set_var]
Set a variable to animate
```c title=" " lineNumbers=1
void lv_anim_set_var(lv_anim_t *a, void *var)
```
Parameters
| Name | Type | Description |
| ----- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `var` | `void *` | pointer to a variable to animate |
lv_anim_set_exec_cb [#lv_anim_set_exec_cb]
Set a function to animate `var`
```c title=" " lineNumbers=1
void lv_anim_set_exec_cb(lv_anim_t *a, lv_anim_exec_xcb_t exec_cb)
```
Parameters
| Name | Type | Description |
| --------- | -------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `exec_cb` | | a function to execute during animation LVGL's built-in functions can be used. E.g. lv\_obj\_set\_x |
lv_anim_set_duration [#lv_anim_set_duration]
Set the duration of an animation
```c title=" " lineNumbers=1
void lv_anim_set_duration(lv_anim_t *a, uint32_t duration)
```
Parameters
| Name | Type | Description |
| ---------- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `duration` | | duration of the animation in milliseconds |
lv_anim_set_delay [#lv_anim_set_delay]
Set a delay before starting the animation
```c title=" " lineNumbers=1
void lv_anim_set_delay(lv_anim_t *a, uint32_t delay)
```
Parameters
| Name | Type | Description |
| ------- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `delay` | | delay before the animation in milliseconds |
lv_anim_set_values [#lv_anim_set_values]
Set the start and end values of an animation
```c title=" " lineNumbers=1
void lv_anim_set_values(lv_anim_t *a, int32_t start, int32_t end)
```
Parameters
| Name | Type | Description |
| ------- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `start` | | the start value |
| `end` | | the end value |
lv_anim_set_custom_exec_cb [#lv_anim_set_custom_exec_cb]
Similar to `lv_anim_set_exec_cb` but `lv_anim_custom_exec_cb_t` receives `lv_anim_t *` as its first parameter instead of `void *`. This function might be used when LVGL is bound to other languages because it's more consistent to have `lv_anim_t *` as first parameter.
```c title=" " lineNumbers=1
void lv_anim_set_custom_exec_cb(lv_anim_t *a, lv_anim_custom_exec_cb_t exec_cb)
```
Parameters
| Name | Type | Description |
| --------- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `exec_cb` | | a function to execute. |
lv_anim_set_path_cb [#lv_anim_set_path_cb]
Set the path (curve) of the animation.
```c title=" " lineNumbers=1
void lv_anim_set_path_cb(lv_anim_t *a, lv_anim_path_cb_t path_cb)
```
Parameters
| Name | Type | Description |
| --------- | -------------------------------------------------- | ----------------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `path_cb` | | a function to set the current value of the animation. |
lv_anim_set_start_cb [#lv_anim_set_start_cb]
Set a function call when the animation really starts (considering `delay`)
```c title=" " lineNumbers=1
void lv_anim_set_start_cb(lv_anim_t *a, lv_anim_start_cb_t start_cb)
```
Parameters
| Name | Type | Description |
| ---------- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `start_cb` | | a function call when the animation starts |
lv_anim_set_get_value_cb [#lv_anim_set_get_value_cb]
Set a function to use the current value of the variable and make start and end value relative to the returned current value.
```c title=" " lineNumbers=1
void lv_anim_set_get_value_cb(lv_anim_t *a, lv_anim_get_value_cb_t get_value_cb)
```
Parameters
| Name | Type | Description |
| -------------- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `get_value_cb` | | a function call when the animation starts |
lv_anim_set_completed_cb [#lv_anim_set_completed_cb]
Set a function call when the animation is completed
```c title=" " lineNumbers=1
void lv_anim_set_completed_cb(lv_anim_t *a, lv_anim_completed_cb_t completed_cb)
```
Parameters
| Name | Type | Description |
| -------------- | -------------------------------------------------- | ----------------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `completed_cb` | | a function call when the animation is fully completed |
lv_anim_set_deleted_cb [#lv_anim_set_deleted_cb]
Set a function call when the animation is deleted.
```c title=" " lineNumbers=1
void lv_anim_set_deleted_cb(lv_anim_t *a, lv_anim_deleted_cb_t deleted_cb)
```
Parameters
| Name | Type | Description |
| ------------ | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `deleted_cb` | | a function call when the animation is deleted |
lv_anim_set_reverse_duration [#lv_anim_set_reverse_duration]
Make the animation to play back to when the forward direction is ready
```c title=" " lineNumbers=1
void lv_anim_set_reverse_duration(lv_anim_t *a, uint32_t duration)
```
Parameters
| Name | Type | Description |
| ---------- | -------------------------------------------------- | ------------------------------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `duration` | | duration of playback animation in milliseconds. 0: disable playback |
lv_anim_set_reverse_time [#lv_anim_set_reverse_time]
Legacy `lv_anim_set_reverse_time` API will be removed soon, use `lv_anim_set_reverse_duration` instead.
```c title=" " lineNumbers=1
void lv_anim_set_reverse_time(lv_anim_t *a, uint32_t duration)
```
Parameters
| Name | Type |
| ---------- | -------------------------------------------------- |
| `a` | |
| `duration` | |
lv_anim_set_reverse_delay [#lv_anim_set_reverse_delay]
Make the animation to play back to when the forward direction is ready
```c title=" " lineNumbers=1
void lv_anim_set_reverse_delay(lv_anim_t *a, uint32_t delay)
```
Parameters
| Name | Type | Description |
| ------- | -------------------------------------------------- | ------------------------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `delay` | | delay in milliseconds before starting the playback animation. |
lv_anim_set_repeat_count [#lv_anim_set_repeat_count]
Make the animation repeat itself.
```c title=" " lineNumbers=1
void lv_anim_set_repeat_count(lv_anim_t *a, uint32_t cnt)
```
Parameters
| Name | Type | Description |
| ----- | -------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `cnt` | | repeat count or `LV_ANIM_REPEAT_INFINITE` for infinite repetition. 0: to disable repetition. |
lv_anim_set_repeat_delay [#lv_anim_set_repeat_delay]
Set a delay before repeating the animation.
```c title=" " lineNumbers=1
void lv_anim_set_repeat_delay(lv_anim_t *a, uint32_t delay)
```
Parameters
| Name | Type | Description |
| ------- | -------------------------------------------------- | ----------------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `delay` | | delay in milliseconds before repeating the animation. |
lv_anim_set_early_apply [#lv_anim_set_early_apply]
Set a whether the animation's should be applied immediately or only when the delay expired.
```c title=" " lineNumbers=1
void lv_anim_set_early_apply(lv_anim_t *a, bool en)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `en` | | true: apply the start value immediately in `lv_anim_start`; false: apply the start value only when `delay` ms is elapsed and the animations really starts |
lv_anim_set_user_data [#lv_anim_set_user_data]
Set the custom user data field of the animation.
```c title=" " lineNumbers=1
void lv_anim_set_user_data(lv_anim_t *a, void *user_data)
```
Parameters
| Name | Type | Description |
| ----------- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `user_data` | `void *` | pointer to the new user\_data. |
lv_anim_set_bezier3_param [#lv_anim_set_bezier3_param]
Set parameter for cubic bezier path
```c title=" " lineNumbers=1
void lv_anim_set_bezier3_param(lv_anim_t *a, int16_t x1, int16_t y1, int16_t x2, int16_t y2)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `x1` | | first control point X |
| `y1` | | first control point Y |
| `x2` | | second control point X |
| `y2` | | second control point Y |
lv_anim_set_external_data [#lv_anim_set_external_data]
Associates external user data with an animation instance.
Attaches arbitrary user-defined data to an LVGL animation object along with an optional destructor callback that will be automatically invoked when the animation completes or is deleted, enabling proper resource cleanup.
```c title=" " lineNumbers=1
void lv_anim_set_external_data(lv_anim_t *anim, void *data, void(*free_cb)(void *data))
```
Parameters
| Name | Type | Description |
| --------- | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `anim` | | Pointer to the animation object to configure |
| `data` | `void *` | User-defined data pointer to associate |
| `free_cb` | `void(*)(void *data)` | Cleanup callback that receives ext\_data when:
- Animation completes naturally
- Animation is deleted prematurely
- New data replaces current association NULL indicates no cleanup required |
lv_anim_get_delay [#lv_anim_get_delay]
Get a delay before starting the animation
```c title=" " lineNumbers=1
uint32_t lv_anim_get_delay(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
**Returns:** — delay before the animation in milliseconds
lv_anim_get_playtime [#lv_anim_get_playtime]
Get the time used to play the animation.
```c title=" " lineNumbers=1
uint32_t lv_anim_get_playtime(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ------------------------ |
| `a` | | pointer to an animation. |
**Returns:** — the play time in milliseconds.
lv_anim_get_time [#lv_anim_get_time]
Get the duration of an animation
```c title=" " lineNumbers=1
uint32_t lv_anim_get_time(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
**Returns:** — the duration of the animation in milliseconds
lv_anim_get_repeat_count [#lv_anim_get_repeat_count]
Get the repeat count of the animation.
```c title=" " lineNumbers=1
uint32_t lv_anim_get_repeat_count(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
**Returns:** — the repeat count or `LV_ANIM_REPEAT_INFINITE` for infinite repetition. 0: disabled repetition.
lv_anim_get_user_data [#lv_anim_get_user_data]
Get the user\_data field of the animation
```c title=" " lineNumbers=1
void * lv_anim_get_user_data(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
**Returns:** `void *` — the pointer to the custom user\_data of the animation
lv_anim_get [#lv_anim_get]
Get the animation of a variable and its `exec_cb`.
```c title=" " lineNumbers=1
lv_anim_t * lv_anim_get(void *var, lv_anim_exec_xcb_t exec_cb)
```
Parameters
| Name | Type | Description |
| --------- | ------------------------------------- | ----------------------------------------------------------------------------------- |
| `var` | `void *` | pointer to variable |
| `exec_cb` | | a function pointer which is animating 'var', or NULL to return first matching 'var' |
**Returns:** — pointer to the animation.
lv_anim_get_timer [#lv_anim_get_timer]
Get global animation refresher timer.
```c title=" " lineNumbers=1
lv_timer_t * lv_anim_get_timer(void)
```
**Returns:** — pointer to the animation refresher timer.
lv_anim_custom_get [#lv_anim_custom_get]
Get the animation of a variable and its `exec_cb`. This function exists because it's logical that all anim. functions receives an `lv_anim_t` as their first parameter. It's not practical in C but might make the API more consequent and makes easier to generate bindings.
```c title=" " lineNumbers=1
lv_anim_t * lv_anim_custom_get(lv_anim_t *a, lv_anim_custom_exec_cb_t exec_cb)
```
Parameters
| Name | Type | Description |
| --------- | -------------------------------------------------- | ----------------------------------------------------------------------------------- |
| `a` | | pointer to an animation. |
| `exec_cb` | | a function pointer which is animating 'var', or NULL to return first matching 'var' |
**Returns:** — pointer to the animation.
lv_anim_init [#lv_anim_init]
Initialize an animation variable. E.g.: lv\_anim\_t a; lv\_anim\_init(\&a); lv\_anim\_set\_...(\&a); lv\_anim\_start(\&a);
```c title=" " lineNumbers=1
void lv_anim_init(lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------- | ------------------------------------------------ |
| `a` | | pointer to an `lv_anim_t` variable to initialize |
lv_anim_resume [#lv_anim_resume]
Resumes a paused animation
```c title=" " lineNumbers=1
void lv_anim_resume(lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
lv_anim_pause [#lv_anim_pause]
Pauses the animation
```c title=" " lineNumbers=1
void lv_anim_pause(lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
lv_anim_pause_for [#lv_anim_pause_for]
Pauses the animation for ms milliseconds
```c title=" " lineNumbers=1
void lv_anim_pause_for(lv_anim_t *a, uint32_t ms)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
| `ms` | | the pause time in milliseconds |
lv_anim_is_paused [#lv_anim_is_paused]
Check if the animation is paused
```c title=" " lineNumbers=1
bool lv_anim_is_paused(lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------- | ---------------------------------------------- |
| `a` | | pointer to an initialized `lv_anim_t` variable |
**Returns:** — true if the animation is paused else false
lv_anim_start [#lv_anim_start]
Create an animation
```c title=" " lineNumbers=1
lv_anim_t * lv_anim_start(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------------------------------------------- |
| `a` | | an initialized 'anim\_t' variable. Not required after call. |
**Returns:** — pointer to the created animation (different from the `a` parameter)
lv_anim_delete [#lv_anim_delete]
Delete animation(s) of a variable with a given animator function
```c title=" " lineNumbers=1
bool lv_anim_delete(void *var, lv_anim_exec_xcb_t exec_cb)
```
Parameters
| Name | Type | Description |
| --------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| `var` | `void *` | pointer to variable |
| `exec_cb` | | a function pointer which is animating 'var', or NULL to ignore it and delete all the animations of 'var |
**Returns:** — true: at least 1 animation is deleted, false: no animation is deleted
lv_anim_delete_all [#lv_anim_delete_all]
Delete all the animations
```c title=" " lineNumbers=1
void lv_anim_delete_all(void)
```
lv_anim_custom_delete [#lv_anim_custom_delete]
Delete an animation by getting the animated variable from `a`. Only animations with `exec_cb` will be deleted. This function exists because it's logical that all anim. functions receives an `lv_anim_t` as their first parameter. It's not practical in C but might make the API more consequent and makes easier to generate bindings.
```c title=" " lineNumbers=1
bool lv_anim_custom_delete(lv_anim_t *a, lv_anim_custom_exec_cb_t exec_cb)
```
Parameters
| Name | Type | Description |
| --------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| `a` | | pointer to an animation. |
| `exec_cb` | | a function pointer which is animating 'var', or NULL to ignore it and delete all the animations of 'var |
**Returns:** — true: at least 1 animation is deleted, false: no animation is deleted
lv_anim_count_running [#lv_anim_count_running]
Get the number of currently running animations
```c title=" " lineNumbers=1
uint16_t lv_anim_count_running(void)
```
**Returns:** — the number of running animations
lv_anim_speed [#lv_anim_speed]
Store the speed as a special value which can be used as time in animations. It will be converted to time internally based on the start and end values. The return value can be used as a constant with multiple animations and let LVGL convert the speed to time based on the actual values. LIMITATION: the max time stored this way can be 10,000 ms.
```c title=" " lineNumbers=1
uint32_t lv_anim_speed(uint32_t speed)
```
Parameters
| Name | Type | Description |
| ------- | --------------------------- | ------------------------------------------------------------------------ |
| `speed` | | the speed of the animation in with unit / sec resolution in 0..10k range |
**Returns:** — a special value which can be used as an animation time
internally speed is stored as 10 unit/sec
lv_anim_speed_clamped [#lv_anim_speed_clamped]
Store the speed as a special value which can be used as time in animations. It will be converted to time internally based on the start and end values. The return value can be used as a constant with multiple animations and let LVGL convert the speed to time based on the actual values.
```c title=" " lineNumbers=1
uint32_t lv_anim_speed_clamped(uint32_t speed, uint32_t min_time, uint32_t max_time)
```
Parameters
| Name | Type | Description |
| ---------- | --------------------------- | ---------------------------------------------------------------------- |
| `speed` | | the speed of the animation in as unit / sec resolution in 0..10k range |
| `min_time` | | the minimum time in 0..10k range |
| `max_time` | | the maximum time in 0..10k range |
**Returns:** — a special value in where all three values are stored and can be used as an animation time
internally speed is stored as 10 unit/sec
internally min/max\_time are stored with 10 ms unit
lv_anim_resolve_speed [#lv_anim_resolve_speed]
Resolve the speed (created with `lv_anim_speed` or `lv_anim_speed_clamped`) to time based on start and end values.
```c title=" " lineNumbers=1
uint32_t lv_anim_resolve_speed(uint32_t speed, int32_t start, int32_t end)
```
Parameters
| Name | Type | Description |
| ------- | --------------------------- | ----------------------------------------------------------- |
| `speed` | | return values of `lv_anim_speed` or `lv_anim_speed_clamped` |
| `start` | | the start value of the animation |
| `end` | | the end value of the animation |
**Returns:** — the time required to get from `start` to `end` with the given `speed` setting
lv_anim_speed_to_time [#lv_anim_speed_to_time]
Calculate the time of an animation based on its speed, start and end values. It simpler than `lv_anim_speed` or `lv_anim_speed_clamped` as it converts speed, start, and end to a time immediately. As it's simpler there is no limit on the maximum time.
```c title=" " lineNumbers=1
uint32_t lv_anim_speed_to_time(uint32_t speed, int32_t start, int32_t end)
```
Parameters
| Name | Type | Description |
| ------- | --------------------------- | -------------------------- |
| `speed` | | the speed of the animation |
| `start` | | the start value |
| `end` | | the end value |
**Returns:** — the time of the animation in milliseconds
lv_anim_refr_now [#lv_anim_refr_now]
Manually refresh the state of the animations. Useful to make the animations running in a blocking process where `lv_timer_handler` can't run for a while. Shouldn't be used directly because it is called in .
```c title=" " lineNumbers=1
void lv_anim_refr_now(void)
```
lv_anim_path_linear [#lv_anim_path_linear]
Calculate the current value of an animation applying linear characteristic
```c title=" " lineNumbers=1
int32_t lv_anim_path_linear(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------- |
| `a` | | pointer to an animation |
**Returns:** — the current value to set
lv_anim_path_ease_in [#lv_anim_path_ease_in]
Calculate the current value of an animation slowing down the start phase
```c title=" " lineNumbers=1
int32_t lv_anim_path_ease_in(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------- |
| `a` | | pointer to an animation |
**Returns:** — the current value to set
lv_anim_path_ease_out [#lv_anim_path_ease_out]
Calculate the current value of an animation slowing down the end phase
```c title=" " lineNumbers=1
int32_t lv_anim_path_ease_out(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------- |
| `a` | | pointer to an animation |
**Returns:** — the current value to set
lv_anim_path_ease_in_out [#lv_anim_path_ease_in_out]
Calculate the current value of an animation applying an "S" characteristic (cosine)
```c title=" " lineNumbers=1
int32_t lv_anim_path_ease_in_out(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------- |
| `a` | | pointer to an animation |
**Returns:** — the current value to set
lv_anim_path_overshoot [#lv_anim_path_overshoot]
Calculate the current value of an animation with overshoot at the end
```c title=" " lineNumbers=1
int32_t lv_anim_path_overshoot(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------- |
| `a` | | pointer to an animation |
**Returns:** — the current value to set
lv_anim_path_bounce [#lv_anim_path_bounce]
Calculate the current value of an animation with 3 bounces
```c title=" " lineNumbers=1
int32_t lv_anim_path_bounce(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------- |
| `a` | | pointer to an animation |
**Returns:** — the current value to set
lv_anim_path_step [#lv_anim_path_step]
Calculate the current value of an animation applying step characteristic. (Set end value on the end of the animation)
```c title=" " lineNumbers=1
int32_t lv_anim_path_step(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------- |
| `a` | | pointer to an animation |
**Returns:** — the current value to set
lv_anim_path_custom_bezier3 [#lv_anim_path_custom_bezier3]
A custom cubic bezier animation path, need to specify cubic-parameters in a->parameter.bezier3
```c title=" " lineNumbers=1
int32_t lv_anim_path_custom_bezier3(const lv_anim_t *a)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------------------------------------- | ----------------------- |
| `a` | | pointer to an animation |
**Returns:** — the current value to set
Structs [#structs]
lv_anim_bezier3_para_t [#lv_anim_bezier3_para_t]
Parameter used when path is custom\_bezier
| Member | Type | Description |
| ------ | -------------------------- | ----------- |
| `x1` | | |
| `y1` | | |
| `x2` | | |
| `y2` | | |
\_lv_anim_t [#_lv_anim_t]
Describes an animation
| Member | Type | Description |
| -------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ext_data` | | |
| `var` | `void *` | Variable (Widget or other user-provided object) to animate |
| `exec_cb` | | Function to execute to animate |
| `custom_exec_cb` | | Function to execute to animate, same purpose as exec\_cb but different parameters |
| `start_cb` | | Call it when animation is starts (considering `delay`) |
| `completed_cb` | | Call it when animation is fully completed |
| `deleted_cb` | | Call it when animation is deleted |
| `get_value_cb` | | Get current value in relative mode |
| `user_data` | `void *` | Custom user data |
| `path_cb` | | Provides path (curve) of animation |
| `start_value` | | Start value |
| `current_value` | | Current value |
| `end_value` | | End value |
| `duration` | | Animation duration in ms |
| `act_time` | | Ms elapsed since animation started. Set to negative to make delay. |
| `reverse_delay` | | Wait (in ms) after forward play ends and before reverse play begins. |
| `reverse_duration` | | Reverse animation duration in ms |
| `repeat_delay` | | Wait before repeating |
| `repeat_cnt` | | Repeat count for animation |
| `parameter` | | |
| `last_timer_run` | | |
| `pause_time` | | The time when the animation was paused |
| `pause_duration` | | The amount of the time the animation must stay paused for |
| `is_paused` | | Indicates that the animation is paused |
| `reverse_play_in_progress` | | Reverse play is in progress |
| `run_round` | | When not equal to global.anim\_state.anim\_run\_round (which toggles each time animation timer executes), indicates this animation needs to be updated. |
| `start_cb_called` | | Indicates that `start_cb` was already called |
| `early_apply` | | 1: Apply start value immediately even is there is a `delay` |
\_lv_anim_t::_lv_anim_path_para_t [#_lv_anim_t_lv_anim_path_para_t]
| Member | Type | Description |
| --------- | ----------------------------------------- | ------------------------------------------ |
| `bezier3` | | Parameter used when path is custom\_bezier |
Typedefs [#typedefs]
lv_anim_enable_t [#lv_anim_enable_t]
```c title=" " lineNumbers=1
typedef bool lv_anim_enable_t
```
* `lv_obj_scroll_by` — param `anim_en`
* `lv_obj_scroll_by_bounded` — param `anim_en`
* `lv_obj_scroll_to` — param `anim_en`
* `lv_obj_scroll_to_x` — param `anim_en`
* `lv_obj_scroll_to_y` — param `anim_en`
* `lv_obj_scroll_to_view` — param `anim_en`
* `lv_obj_scroll_to_view_recursive` — param `anim_en`
* `lv_obj_update_snap` — param `anim_en`
* `lv_obj_readjust_scroll` — param `anim_en`
* `lv_gridnav_set_focused` — param `anim_en`
* `lv_bar_set_value` — param `anim`
* `lv_bar_set_start_value` — param `anim`
* `lv_roller_set_selected` — param `anim`
* `lv_roller_set_selected_str` — param `anim`
* `lv_slider_set_value` — param `anim`
* `lv_slider_set_start_value` — param `anim`
* `lv_tabview_set_active` — param `anim_en`
* `lv_tileview_set_tile` — param `anim_en`
* `lv_tileview_set_tile_by_index` — param `anim_en`
lv_anim_path_cb_t [#lv_anim_path_cb_t]
```c title=" " lineNumbers=1
typedef int32_t(* lv_anim_path_cb_t) (const lv_anim_t *)
```
Get the current value during an animation
* `lv_anim_set_path_cb` — param `path_cb`
* `lv_style_transition_dsc_init` — param `path_cb`
lv_anim_exec_xcb_t [#lv_anim_exec_xcb_t]
```c title=" " lineNumbers=1
typedef void(* lv_anim_exec_xcb_t) (void *, int32_t)
```
Generic prototype of "animator" functions. First parameter is the variable to animate. Second parameter is the value to set. Compatible with `lv_xxx_set_yyy(obj, value)` functions The `x` in `_xcb_t` means it's not a fully generic prototype because it doesn't receive `lv_anim_t *` as its first argument
* `lv_anim_set_exec_cb` — param `exec_cb`
* `lv_anim_delete` — param `exec_cb`
* `lv_anim_get` — param `exec_cb`
lv_anim_custom_exec_cb_t [#lv_anim_custom_exec_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_anim_custom_exec_cb_t) (lv_anim_t *, int32_t)
```
Same as `lv_anim_exec_xcb_t` but receives `lv_anim_t *` as the first parameter. It's more consistent but less convenient. Might be used by binding generator functions.
* `lv_anim_set_custom_exec_cb` — param `exec_cb`
* `lv_anim_custom_delete` — param `exec_cb`
* `lv_anim_custom_get` — param `exec_cb`
lv_anim_completed_cb_t [#lv_anim_completed_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_anim_completed_cb_t) (lv_anim_t *)
```
Callback to call when the animation is ready
* `lv_anim_set_completed_cb` — param `completed_cb`
* `lv_animimg_set_completed_cb` — param `completed_cb`
lv_anim_start_cb_t [#lv_anim_start_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_anim_start_cb_t) (lv_anim_t *)
```
Callback to call when the animation really stars (considering `delay`)
* `lv_anim_set_start_cb` — param `start_cb`
* `lv_animimg_set_start_cb` — param `start_cb`
lv_anim_get_value_cb_t [#lv_anim_get_value_cb_t]
```c title=" " lineNumbers=1
typedef int32_t(* lv_anim_get_value_cb_t) (lv_anim_t *)
```
Callback used when the animation values are relative to get the current value
* `lv_anim_set_get_value_cb` — param `get_value_cb`
lv_anim_deleted_cb_t [#lv_anim_deleted_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_anim_deleted_cb_t) (lv_anim_t *)
```
Callback used when the animation is deleted
* `lv_anim_set_deleted_cb` — param `deleted_cb`
Macros [#macros]
LV_ANIM_REPEAT_INFINITE [#lv_anim_repeat_infinite]
```c title=" " lineNumbers=1
#define LV_ANIM_REPEAT_INFINITE 0xFFFFFFFF
```
LV_ANIM_PLAYTIME_INFINITE [#lv_anim_playtime_infinite]
```c title=" " lineNumbers=1
#define LV_ANIM_PLAYTIME_INFINITE 0xFFFFFFFF
```
LV_ANIM_PAUSE_FOREVER [#lv_anim_pause_forever]
```c title=" " lineNumbers=1
#define LV_ANIM_PAUSE_FOREVER 0xFFFFFFFF
```
\_PARA [#_para]
```c title=" " lineNumbers=1
#define _PARA(a, x1, y1, x2, y2) \
((a)->parameter.bezier3 = \
(lv_anim_bezier3_para_t) { \
LV_BEZIER_VAL_FLOAT(x1), LV_BEZIER_VAL_FLOAT(y1), \
LV_BEZIER_VAL_FLOAT(x2), LV_BEZIER_VAL_FLOAT(y2) } \
)
```
LV_ANIM_SET_EASE_IN_SINE [#lv_anim_set_ease_in_sine]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_SINE(a) \
_PARA(a, 0.12, 0, 0.39, 0)
```
LV_ANIM_SET_EASE_OUT_SINE [#lv_anim_set_ease_out_sine]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_OUT_SINE(a) \
_PARA(a, 0.61, 1, 0.88, 1)
```
LV_ANIM_SET_EASE_IN_OUT_SINE [#lv_anim_set_ease_in_out_sine]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_OUT_SINE(a) \
_PARA(a, 0.37, 0, 0.63, 1)
```
LV_ANIM_SET_EASE_IN_QUAD [#lv_anim_set_ease_in_quad]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_QUAD(a) \
_PARA(a, 0.11, 0, 0.5, 0)
```
LV_ANIM_SET_EASE_OUT_QUAD [#lv_anim_set_ease_out_quad]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_OUT_QUAD(a) \
_PARA(a, 0.5, 1, 0.89, 1)
```
LV_ANIM_SET_EASE_IN_OUT_QUAD [#lv_anim_set_ease_in_out_quad]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_OUT_QUAD(a) \
_PARA(a, 0.45, 0, 0.55, 1)
```
LV_ANIM_SET_EASE_IN_CUBIC [#lv_anim_set_ease_in_cubic]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_CUBIC(a) \
_PARA(a, 0.32, 0, 0.67, 0)
```
LV_ANIM_SET_EASE_OUT_CUBIC [#lv_anim_set_ease_out_cubic]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_OUT_CUBIC(a) \
_PARA(a, 0.33, 1, 0.68, 1)
```
LV_ANIM_SET_EASE_IN_OUT_CUBIC [#lv_anim_set_ease_in_out_cubic]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_OUT_CUBIC(a) \
_PARA(a, 0.65, 0, 0.35, 1)
```
LV_ANIM_SET_EASE_IN_QUART [#lv_anim_set_ease_in_quart]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_QUART(a) \
_PARA(a, 0.5, 0, 0.75, 0)
```
LV_ANIM_SET_EASE_OUT_QUART [#lv_anim_set_ease_out_quart]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_OUT_QUART(a) \
_PARA(a, 0.25, 1, 0.5, 1)
```
LV_ANIM_SET_EASE_IN_OUT_QUART [#lv_anim_set_ease_in_out_quart]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_OUT_QUART(a) \
_PARA(a, 0.76, 0, 0.24, 1)
```
LV_ANIM_SET_EASE_IN_QUINT [#lv_anim_set_ease_in_quint]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_QUINT(a) \
_PARA(a, 0.64, 0, 0.78, 0)
```
LV_ANIM_SET_EASE_OUT_QUINT [#lv_anim_set_ease_out_quint]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_OUT_QUINT(a) \
_PARA(a, 0.22, 1, 0.36, 1)
```
LV_ANIM_SET_EASE_IN_OUT_QUINT [#lv_anim_set_ease_in_out_quint]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_OUT_QUINT(a) \
_PARA(a, 0.83, 0, 0.17, 1)
```
LV_ANIM_SET_EASE_IN_EXPO [#lv_anim_set_ease_in_expo]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_EXPO(a) \
_PARA(a, 0.7, 0, 0.84, 0)
```
LV_ANIM_SET_EASE_OUT_EXPO [#lv_anim_set_ease_out_expo]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_OUT_EXPO(a) \
_PARA(a, 0.16, 1, 0.3, 1)
```
LV_ANIM_SET_EASE_IN_OUT_EXPO [#lv_anim_set_ease_in_out_expo]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_OUT_EXPO(a) \
_PARA(a, 0.87, 0, 0.13, 1)
```
LV_ANIM_SET_EASE_IN_CIRC [#lv_anim_set_ease_in_circ]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_CIRC(a) \
_PARA(a, 0.55, 0, 1, 0.45)
```
LV_ANIM_SET_EASE_OUT_CIRC [#lv_anim_set_ease_out_circ]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_OUT_CIRC(a) \
_PARA(a, 0, 0.55, 0.45, 1)
```
LV_ANIM_SET_EASE_IN_OUT_CIRC [#lv_anim_set_ease_in_out_circ]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_OUT_CIRC(a) \
_PARA(a, 0.85, 0, 0.15, 1)
```
LV_ANIM_SET_EASE_IN_BACK [#lv_anim_set_ease_in_back]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_BACK(a) \
_PARA(a, 0.36, 0, 0.66, -0.56)
```
LV_ANIM_SET_EASE_OUT_BACK [#lv_anim_set_ease_out_back]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_OUT_BACK(a) \
_PARA(a, 0.34, 1.56, 0.64, 1)
```
LV_ANIM_SET_EASE_IN_OUT_BACK [#lv_anim_set_ease_in_out_back]
```c title=" " lineNumbers=1
#define LV_ANIM_SET_EASE_IN_OUT_BACK(a) \
_PARA(a, 0.68, -0.6, 0.32, 1.6)
```
LV_ANIM_OFF [#lv_anim_off]
```c title=" " lineNumbers=1
#define LV_ANIM_OFF false
```
Can be used to indicate if animations are enabled or disabled in a case
LV_ANIM_ON [#lv_anim_on]
```c title=" " lineNumbers=1
#define LV_ANIM_ON true
```
Dependencies [#dependencies]