Mirrors_UI_SDK/lvgl
1
0
Fork 0
mirror of https://github.com/lvgl/lvgl.git synced 2026-05-21 22:52:46 +08:00
Code Issues Actions 58 Packages Projects Releases Wiki Activity

reduce API size: add underscore prefix to internal functions

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi
2020-05-13 14:11:16 +02:00
parent 79329bdb45
commit 97392f4fdf
90 changed files with 1689 additions and 1923 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lvgl.h
-1
View File
@@ -27,7 +27,6 @@ extern "C" {
#include "src/lv_core/lv_refr.h"
#include "src/lv_core/lv_disp.h"
#include "src/lv_core/lv_debug.h"
#include "src/lv_themes/lv_theme.h"
src/lv_core/lv_debug.c
+3 -3
View File
@@ -75,7 +75,7 @@ bool lv_debug_check_obj_valid(const lv_obj_t * obj)
lv_disp_t * disp = lv_disp_get_next(NULL);
while(disp) {
lv_obj_t * scr;
LV_LL_READ(disp->scr_ll, scr) {
_LV_LL_READ(disp->scr_ll, scr) {
if(scr == obj) return true;
bool found = obj_valid_child(scr, obj);
@@ -160,7 +160,7 @@ void lv_debug_log_error(const char * msg, uint64_t value)
char * bufp = buf;
/*Add the function name*/
lv_memcpy(bufp, msg, msg_len);
_lv_memcpy(bufp, msg, msg_len);
bufp += msg_len;
/*Add value in hey*/
@@ -200,7 +200,7 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
{
/*Check all children of `parent`*/
lv_obj_t * child;
LV_LL_READ(parent->child_ll, child) {
_LV_LL_READ(parent->child_ll, child) {
if(child == obj_to_find) return true;
/*Check the children*/
src/lv_core/lv_disp.c
+19 -18
View File
@@ -112,24 +112,7 @@ void lv_disp_assign_screen(lv_disp_t * disp, lv_obj_t * scr)
if(old_disp == disp) return;
lv_ll_chg_list(&old_disp->scr_ll, &disp->scr_ll, scr, true);
}
/**
* Get a pointer to the screen refresher task to
* modify its parameters with `lv_task_...` functions.
* @param disp pointer to a display
* @return pointer to the display refresher task. (NULL on error)
*/
lv_task_t * lv_disp_get_refr_task(lv_disp_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) {
LV_LOG_WARN("lv_disp_get_refr_task: no display registered");
return NULL;
}
return disp->refr_task;
_lv_ll_chg_list(&old_disp->scr_ll, &disp->scr_ll, scr, true);
}
/**
@@ -174,6 +157,24 @@ void lv_disp_trig_activity(lv_disp_t * disp)
disp->last_activity_time = lv_tick_get();
}
/**
* Get a pointer to the screen refresher task to
* modify its parameters with `lv_task_...` functions.
* @param disp pointer to a display
* @return pointer to the display refresher task. (NULL on error)
*/
lv_task_t * _lv_disp_get_refr_task(lv_disp_t * disp)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) {
LV_LOG_WARN("lv_disp_get_refr_task: no display registered");
return NULL;
}
return disp->refr_task;
}
/**********************
* STATIC FUNCTIONS
**********************/
src/lv_core/lv_disp.h
+8 -8
View File
@@ -64,14 +64,6 @@ lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp);
*/
void lv_disp_assign_screen(lv_disp_t * disp, lv_obj_t * scr);
/**
* Get a pointer to the screen refresher task to
* modify its parameters with `lv_task_...` functions.
* @param disp pointer to a display
* @return pointer to the display refresher task. (NULL on error)
*/
lv_task_t * lv_disp_get_refr_task(lv_disp_t * disp);
/**
* Get elapsed time since last user activity on a display (e.g. click)
* @param disp pointer to an display (NULL to get the overall smallest inactivity)
@@ -85,6 +77,14 @@ uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp);
*/
void lv_disp_trig_activity(lv_disp_t * disp);
/**
* Get a pointer to the screen refresher task to
* modify its parameters with `lv_task_...` functions.
* @param disp pointer to a display
* @return pointer to the display refresher task. (NULL on error)
*/
lv_task_t * _lv_disp_get_refr_task(lv_disp_t * disp);
/*------------------------------------------------
* To improve backward compatibility
* Recommended only if you have one display
src/lv_core/lv_group.c
+19 -19
View File
@@ -48,9 +48,9 @@ static void obj_to_foreground(lv_obj_t * obj);
/**
* Init. the group module
*/
void lv_group_init(void)
void _lv_group_init(void)
{
lv_ll_init(&LV_GC_ROOT(_lv_group_ll), sizeof(lv_group_t));
_lv_ll_init(&LV_GC_ROOT(_lv_group_ll), sizeof(lv_group_t));
}
/**
@@ -59,10 +59,10 @@ void lv_group_init(void)
*/
lv_group_t * lv_group_create(void)
{
lv_group_t * group = lv_ll_ins_head(&LV_GC_ROOT(_lv_group_ll));
lv_group_t * group = _lv_ll_ins_head(&LV_GC_ROOT(_lv_group_ll));
LV_ASSERT_MEM(group);
if(group == NULL) return NULL;
lv_ll_init(&group->obj_ll, sizeof(lv_obj_t *));
_lv_ll_init(&group->obj_ll, sizeof(lv_obj_t *));
group->obj_focus = NULL;
group->frozen = 0;
@@ -73,7 +73,7 @@ lv_group_t * lv_group_create(void)
group->wrap = 1;
#if LV_USE_USER_DATA
lv_memset_00(&group->user_data, sizeof(lv_group_user_data_t));
_lv_memset_00(&group->user_data, sizeof(lv_group_user_data_t));
#endif
return group;
@@ -93,12 +93,12 @@ void lv_group_del(lv_group_t * group)
/*Remove the objects from the group*/
lv_obj_t ** obj;
LV_LL_READ(group->obj_ll, obj) {
_LV_LL_READ(group->obj_ll, obj) {
(*obj)->group_p = NULL;
}
lv_ll_clear(&(group->obj_ll));
lv_ll_remove(&LV_GC_ROOT(_lv_group_ll), group);
_lv_ll_clear(&(group->obj_ll));
_lv_ll_remove(&LV_GC_ROOT(_lv_group_ll), group);
lv_mem_free(group);
}
@@ -112,7 +112,7 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
if(group == NULL) return;
/*Do not add the object twice*/
lv_obj_t ** obj_i;
LV_LL_READ(group->obj_ll, obj_i) {
_LV_LL_READ(group->obj_ll, obj_i) {
if((*obj_i) == obj) {
LV_LOG_INFO("lv_group_add_obj: the object is already added to this group");
return;
@@ -129,14 +129,14 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
}
obj->group_p = group;
lv_obj_t ** next = lv_ll_ins_tail(&group->obj_ll);
lv_obj_t ** next = _lv_ll_ins_tail(&group->obj_ll);
LV_ASSERT_MEM(next);
if(next == NULL) return;
*next = obj;
/* If the head and the tail is equal then there is only one object in the linked list.
* In this case automatically activate it*/
if(lv_ll_get_head(&group->obj_ll) == next) {
if(_lv_ll_get_head(&group->obj_ll) == next) {
lv_group_refocus(group);
}
}
@@ -156,7 +156,7 @@ void lv_group_remove_obj(lv_obj_t * obj)
if(g->frozen) g->frozen = 0;
/*If this is the only object in the group then focus to nothing.*/
if(lv_ll_get_head(&g->obj_ll) == g->obj_focus && lv_ll_get_tail(&g->obj_ll) == g->obj_focus) {
if(_lv_ll_get_head(&g->obj_ll) == g->obj_focus && _lv_ll_get_tail(&g->obj_ll) == g->obj_focus) {
(*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
}
/*If there more objects in the group then focus to the next/prev object*/
@@ -174,9 +174,9 @@ void lv_group_remove_obj(lv_obj_t * obj)
/*Search the object and remove it from its group */
lv_obj_t ** i;
LV_LL_READ(g->obj_ll, i) {
_LV_LL_READ(g->obj_ll, i) {
if(*i == obj) {
lv_ll_remove(&g->obj_ll, i);
_lv_ll_remove(&g->obj_ll, i);
lv_mem_free(i);
obj->group_p = NULL;
break;
@@ -199,11 +199,11 @@ void lv_group_remove_all_objs(lv_group_t * group)
/*Remove the objects from the group*/
lv_obj_t ** obj;
LV_LL_READ(group->obj_ll, obj) {
_LV_LL_READ(group->obj_ll, obj) {
(*obj)->group_p = NULL;
}
lv_ll_clear(&(group->obj_ll));
_lv_ll_clear(&(group->obj_ll));
}
/**
@@ -224,7 +224,7 @@ void lv_group_focus_obj(lv_obj_t * obj)
lv_group_set_editing(g, false);
lv_obj_t ** i;
LV_LL_READ(g->obj_ll, i) {
_LV_LL_READ(g->obj_ll, i) {
if(*i == obj) {
if(g->obj_focus != NULL) {
(*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
@@ -256,7 +256,7 @@ void lv_group_focus_obj(lv_obj_t * obj)
*/
void lv_group_focus_next(lv_group_t * group)
{
focus_next_core(group, lv_ll_get_head, lv_ll_get_next);
focus_next_core(group, _lv_ll_get_head, _lv_ll_get_next);
}
/**
@@ -265,7 +265,7 @@ void lv_group_focus_next(lv_group_t * group)
*/
void lv_group_focus_prev(lv_group_t * group)
{
focus_next_core(group, lv_ll_get_tail, lv_ll_get_prev);
focus_next_core(group, _lv_ll_get_tail, _lv_ll_get_prev);
}
/**
src/lv_core/lv_group.h
+1 -1
View File
@@ -81,7 +81,7 @@ typedef uint8_t lv_group_refocus_policy_t;
* Init. the group module
* @remarks Internal function, do not call directly.
*/
void lv_group_init(void);
void _lv_group_init(void);
/**
* Create a new object group
src/lv_core/lv_indev.c
+16 -16
View File
@@ -63,7 +63,7 @@ static lv_obj_t * indev_obj_act = NULL;
/**
* Initialize the display input device subsystem
*/
void lv_indev_init(void)
void _lv_indev_init(void)
{
lv_indev_reset(NULL, NULL); /*Reset all input devices*/
}
@@ -72,7 +72,7 @@ void lv_indev_init(void)
* Called periodically to read the input devices
* @param param pointer to and input device to read
*/
void lv_indev_read_task(lv_task_t * task)
void _lv_indev_read_task(lv_task_t * task)
{
LV_LOG_TRACE("indev read task started");
@@ -90,7 +90,7 @@ void lv_indev_read_task(lv_task_t * task)
bool more_to_read;
do {
/*Read the data*/
more_to_read = lv_indev_read(indev_act, &data);
more_to_read = _lv_indev_read(indev_act, &data);
/*The active object might deleted even in the read function*/
indev_proc_reset_query_handler(indev_act);
@@ -364,6 +364,15 @@ void lv_indev_wait_release(lv_indev_t * indev)
indev->proc.wait_until_release = 1;
}
/**
* Gets a pointer to the currently active object in the currently processed input device.
* @return pointer to currently active object or NULL if no active object
*/
lv_obj_t * lv_indev_get_obj_act(void)
{
return indev_obj_act;
}
/**
* Get a pointer to the indev read task to
* modify its parameters with `lv_task_...` functions.
@@ -380,15 +389,6 @@ lv_task_t * lv_indev_get_read_task(lv_disp_t * indev)
return indev->refr_task;
}
/**
* Gets a pointer to the currently active object in the currently processed input device.
* @return pointer to currently active object or NULL if no active object
*/
lv_obj_t * lv_indev_get_obj_act(void)
{
return indev_obj_act;
}
/**********************
* STATIC FUNCTIONS
**********************/
@@ -658,7 +658,7 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
/*On enter long press toggle edit mode.*/
if(editable) {
/*Don't leave edit mode if there is only one object (nowhere to navigate)*/
if(lv_ll_is_empty(&g->obj_ll) == false) {
if(_lv_ll_is_empty(&g->obj_ll) == false) {
lv_group_set_editing(g, lv_group_get_editing(g) ? false : true); /*Toggle edit mode on long press*/
}
}
@@ -695,7 +695,7 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
/*An object is being edited and the button is released. */
else if(g->editing) {
/*Ignore long pressed enter release because it comes from mode switch*/
if(!i->proc.long_pr_sent || lv_ll_is_empty(&g->obj_ll)) {
if(!i->proc.long_pr_sent || _lv_ll_is_empty(&g->obj_ll)) {
indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_RELEASED, NULL);
if(indev_reset_check(&i->proc)) return;
@@ -1060,7 +1060,7 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
if(lv_obj_hittest(obj, point)) {
lv_obj_t * i;
LV_LL_READ(obj->child_ll, i) {
_LV_LL_READ(obj->child_ll, i) {
found_p = lv_indev_search_obj(i, point);
/*If a child was found then break*/
@@ -1305,7 +1305,7 @@ static void indev_drag(lv_indev_proc_t * proc)
lv_coord_t act_par_h = lv_obj_get_height(lv_obj_get_parent(drag_obj));
if(act_par_w == prev_par_w && act_par_h == prev_par_h) {
uint16_t new_inv_buf_size = lv_disp_get_inv_buf_size(indev_act->driver.disp);
lv_disp_pop_from_inv_buf(indev_act->driver.disp, new_inv_buf_size - inv_buf_size);
_lv_disp_pop_from_inv_buf(indev_act->driver.disp, new_inv_buf_size - inv_buf_size);
}
}
src/lv_core/lv_indev.h
+10 -9
View File
@@ -32,13 +32,13 @@ extern "C" {
/**
* Initialize the display input device subsystem
*/
void lv_indev_init(void);
void _lv_indev_init(void);
/**
* Called periodically to read the input devices
* @param task pointer to the task itself
*/
void lv_indev_read_task(lv_task_t * task);
void _lv_indev_read_task(lv_task_t * task);
/**
* Get the currently processed input device. Can be used in action functions too.
@@ -149,13 +149,6 @@ lv_res_t lv_indev_finish_drag(lv_indev_t * indev);
*/
void lv_indev_wait_release(lv_indev_t * indev);
/**
* Get a pointer to the indev read task to
* modify its parameters with `lv_task_...` functions.
* @param indev pointer to an inout device
* @return pointer to the indev read refresher task. (NULL on error)
*/
lv_task_t * lv_indev_get_read_task(lv_disp_t * indev);
/**
* Gets a pointer to the currently active object in indev proc functions.
@@ -172,6 +165,14 @@ lv_obj_t * lv_indev_get_obj_act(void);
*/
lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point);
/**
* Get a pointer to the indev read task to
* modify its parameters with `lv_task_...` functions.
* @param indev pointer to an inout device
* @return pointer to the indev read refresher task. (NULL on error)
*/
lv_task_t * lv_indev_get_read_task(lv_disp_t * indev);
/**********************
* MACROS
**********************/
src/lv_core/lv_obj.c
+82 -82
View File
File diff suppressed because it is too large Load Diff
src/lv_core/lv_obj.h
+1 -1
View File
@@ -611,7 +611,7 @@ void _lv_obj_set_style_local_ptr(lv_obj_t * obj, uint8_t type, lv_style_property
* For example: `lv_obj_style_remove_border_opa()`
* @return true: the property was found and removed; false: teh property was not found
*/
bool _lv_obj_remove_style_local_prop(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
bool lv_obj_remove_style_local_prop(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
/*-----------------
* Attribute set
src/lv_core/lv_obj_style_dec.h
+1 -13
View File
@@ -95,20 +95,8 @@ extern "C" {
}
#define _LV_OBJ_STYLE_SET_GET_DECLARE(prop_name, func_name, value_type, style_type, scalar) \
_OBJ_GET_STYLE_##scalar(prop_name, func_name, value_type, style_type) \
_OBJ_GET_STYLE_##scalar(prop_name, func_name, value_type, style_type) \
_OBJ_SET_STYLE_LOCAL_##scalar(prop_name, func_name, value_type, style_type) \
static inline void lv_obj_get_style_local_##func_name (lv_obj_t * obj, uint8_t part, lv_state_t state, void * res) \
{ \
_lv_style_get##style_type (lv_obj_get_local_style(obj, part), LV_STYLE_##prop_name | (state << LV_STYLE_STATE_POS), res); \
} \
static inline void lv_obj_remove_style_local_##func_name (lv_obj_t * obj, uint8_t part, lv_state_t state) \
{ \
_lv_obj_remove_style_local_prop(obj, part, LV_STYLE_##prop_name | (state << LV_STYLE_STATE_POS)); \
} \
static inline int16_t lv_style_get_##func_name (lv_style_t * style, lv_state_t state, void * res) \
{ \
return _lv_style_get##style_type (style, LV_STYLE_##prop_name | (state << LV_STYLE_STATE_POS), res); \
} \
_OBJ_SET_STYLE_##scalar(prop_name, func_name, value_type, style_type)
_LV_OBJ_STYLE_SET_GET_DECLARE(RADIUS, radius, lv_style_int_t, _int, scalar)
src/lv_core/lv_refr.c
+26 -26
View File
@@ -65,7 +65,7 @@ static lv_disp_t * disp_refr; /*Display being refreshed*/
/**
* Initialize the screen refresh subsystem
*/
void lv_refr_init(void)
void _lv_refr_init(void)
{
/*Nothing to do*/
}
@@ -84,13 +84,13 @@ void lv_refr_now(lv_disp_t * disp)
#endif
if(disp) {
lv_disp_refr_task(disp->refr_task);
_lv_disp_refr_task(disp->refr_task);
}
else {
lv_disp_t * d;
d = lv_disp_get_next(NULL);
while(d) {
lv_disp_refr_task(d->refr_task);
_lv_disp_refr_task(d->refr_task);
d = lv_disp_get_next(d);
}
}
@@ -102,7 +102,7 @@ void lv_refr_now(lv_disp_t * disp)
* @param disp pointer to display where the area should be invalidated (NULL can be used if there is
* only one display)
*/
void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
{
if(!disp) disp = lv_disp_get_default();
if(!disp) return;
@@ -122,7 +122,7 @@ void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
lv_area_t com_area;
bool suc;
suc = lv_area_intersect(&com_area, area_p, &scr_area);
suc = _lv_area_intersect(&com_area, area_p, &scr_area);
/*The area is truncated to the screen*/
if(suc != false) {
@@ -131,7 +131,7 @@ void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
/*Save only if this area is not in one of the saved areas*/
uint16_t i;
for(i = 0; i < disp->inv_p; i++) {
if(lv_area_is_in(&com_area, &disp->inv_areas[i], 0) != false) return;
if(_lv_area_is_in(&com_area, &disp->inv_areas[i], 0) != false) return;
}
/*Save the area*/
@@ -151,7 +151,7 @@ void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
* Get the display which is being refreshed
* @return the display being refreshed
*/
lv_disp_t * lv_refr_get_disp_refreshing(void)
lv_disp_t * _lv_refr_get_disp_refreshing(void)
{
return disp_refr;
}
@@ -162,7 +162,7 @@ lv_disp_t * lv_refr_get_disp_refreshing(void)
* It can be used to trick the drawing functions about there is an active display.
* @param the display being refreshed
*/
void lv_refr_set_disp_refreshing(lv_disp_t * disp)
void _lv_refr_set_disp_refreshing(lv_disp_t * disp)
{
disp_refr = disp;
}
@@ -171,7 +171,7 @@ void lv_refr_set_disp_refreshing(lv_disp_t * disp)
* Called periodically to handle the refreshing
* @param task pointer to the task itself
*/
void lv_disp_refr_task(lv_task_t * task)
void _lv_disp_refr_task(lv_task_t * task)
{
LV_LOG_TRACE("lv_refr_task: started");
@@ -226,7 +226,7 @@ void lv_disp_refr_task(lv_task_t * task)
uint32_t line_length = lv_area_get_width(&disp_refr->inv_areas[a]) * sizeof(lv_color_t);
for(y = disp_refr->inv_areas[a].y1; y <= disp_refr->inv_areas[a].y2; y++) {
lv_memcpy(buf_act + start_offs, buf_ina + start_offs, line_length);
_lv_memcpy(buf_act + start_offs, buf_ina + start_offs, line_length);
start_offs += hres * sizeof(lv_color_t);
}
}
@@ -234,8 +234,8 @@ void lv_disp_refr_task(lv_task_t * task)
} /*End of true double buffer handling*/
/*Clean up*/
lv_memset_00(disp_refr->inv_areas, sizeof(disp_refr->inv_areas));
lv_memset_00(disp_refr->inv_area_joined, sizeof(disp_refr->inv_area_joined));
_lv_memset_00(disp_refr->inv_areas, sizeof(disp_refr->inv_areas));
_lv_memset_00(disp_refr->inv_area_joined, sizeof(disp_refr->inv_area_joined));
disp_refr->inv_p = 0;
elaps = lv_tick_elaps(start);
@@ -245,8 +245,8 @@ void lv_disp_refr_task(lv_task_t * task)
}
}
lv_mem_buf_free_all();
lv_font_clean_up_fmt_txt();
_lv_mem_buf_free_all();
_lv_font_clean_up_fmt_txt();
#if LV_USE_PERF_MONITOR && LV_USE_LABEL
static lv_obj_t * perf_label = NULL;
@@ -308,11 +308,11 @@ static void lv_refr_join_area(void)
}
/*Check if the areas are on each other*/
if(lv_area_is_on(&disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]) == false) {
if(_lv_area_is_on(&disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]) == false) {
continue;
}
lv_area_join(&joined_area, &disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]);
_lv_area_join(&joined_area, &disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]);
/*Join two area only if the joined area size is smaller*/
if(lv_area_get_size(&joined_area) < (lv_area_get_size(&disp_refr->inv_areas[join_in]) +
@@ -470,7 +470,7 @@ static void lv_refr_area_part(const lv_area_t * area_p)
/*Get the new mask from the original area and the act. VDB
It will be a part of 'area_p'*/
lv_area_t start_mask;
lv_area_intersect(&start_mask, area_p, &vdb->area);
_lv_area_intersect(&start_mask, area_p, &vdb->area);
/*Get the most top object which is not covered by others*/
top_p = lv_refr_get_top_obj(&start_mask, lv_disp_get_scr_act(disp_refr));
@@ -500,13 +500,13 @@ static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
lv_obj_t * found_p = NULL;
/*If this object is fully cover the draw area check the children too */
if(lv_area_is_in(area_p, &obj->coords, 0) && obj->hidden == 0) {
if(_lv_area_is_in(area_p, &obj->coords, 0) && obj->hidden == 0) {
lv_design_res_t design_res = obj->design_cb ? obj->design_cb(obj, area_p,
LV_DESIGN_COVER_CHK) : LV_DESIGN_RES_NOT_COVER;
if(design_res == LV_DESIGN_RES_MASKED) return NULL;
lv_obj_t * i;
LV_LL_READ(obj->child_ll, i) {
_LV_LL_READ(obj->child_ll, i) {
found_p = lv_refr_get_top_obj(area_p, i);
/*If a children is ok then break*/
@@ -551,12 +551,12 @@ static void lv_refr_obj_and_children(lv_obj_t * top_p, const lv_area_t * mask_p)
/*Do until not reach the screen*/
while(par != NULL) {
/*object before border_p has to be redrawn*/
lv_obj_t * i = lv_ll_get_prev(&(par->child_ll), border_p);
lv_obj_t * i = _lv_ll_get_prev(&(par->child_ll), border_p);
while(i != NULL) {
/*Refresh the objects*/
lv_refr_obj(i, mask_p);
i = lv_ll_get_prev(&(par->child_ll), i);
i = _lv_ll_get_prev(&(par->child_ll), i);
}
/*Call the post draw design function of the parents of the to object*/
@@ -592,7 +592,7 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
obj_area.y1 -= ext_size;
obj_area.x2 += ext_size;
obj_area.y2 += ext_size;
union_ok = lv_area_intersect(&obj_ext_mask, mask_ori_p, &obj_area);
union_ok = _lv_area_intersect(&obj_ext_mask, mask_ori_p, &obj_area);
/*Draw the parent and its children only if they ore on 'mask_parent'*/
if(union_ok != false) {
@@ -619,12 +619,12 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
#endif
/*Create a new 'obj_mask' without 'ext_size' because the children can't be visible there*/
lv_obj_get_coords(obj, &obj_area);
union_ok = lv_area_intersect(&obj_mask, mask_ori_p, &obj_area);
union_ok = _lv_area_intersect(&obj_mask, mask_ori_p, &obj_area);
if(union_ok != false) {
lv_area_t mask_child; /*Mask from obj and its child*/
lv_obj_t * child_p;
lv_area_t child_area;
LV_LL_READ_BACK(obj->child_ll, child_p) {
_LV_LL_READ_BACK(obj->child_ll, child_p) {
lv_obj_get_coords(child_p, &child_area);
ext_size = child_p->ext_draw_pad;
child_area.x1 -= ext_size;
@@ -633,7 +633,7 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
child_area.y2 += ext_size;
/* Get the union (common parts) of original mask (from obj)
* and its child */
union_ok = lv_area_intersect(&mask_child, &obj_mask, &child_area);
union_ok = _lv_area_intersect(&mask_child, &obj_mask, &child_area);
/*If the parent and the child has common area then refresh the child */
if(union_ok) {
@@ -669,7 +669,7 @@ static void lv_refr_vdb_flush(void)
else vdb->flushing_last = 0;
/*Flush the rendered content to the display*/
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
if(disp->driver.flush_cb) disp->driver.flush_cb(&disp->driver, &vdb->area, vdb->buf_act);
if(vdb->buf1 && vdb->buf2) {
src/lv_core/lv_refr.h
+5 -5
View File
@@ -45,7 +45,7 @@ extern "C" {
/**
* Initialize the screen refresh subsystem
*/
void lv_refr_init(void);
void _lv_refr_init(void);
/**
* Redraw the invalidated areas now.
@@ -62,13 +62,13 @@ void lv_refr_now(lv_disp_t * disp);
* @param disp pointer to display where the area should be invalidated (NULL can be used if there is
* only one display)
*/
void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p);
void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p);
/**
* Get the display which is being refreshed
* @return the display being refreshed
*/
lv_disp_t * lv_refr_get_disp_refreshing(void);
lv_disp_t * _lv_refr_get_disp_refreshing(void);
/**
* Set the display which is being refreshed.
@@ -76,13 +76,13 @@ lv_disp_t * lv_refr_get_disp_refreshing(void);
* It can be used to trick the drawing functions about there is an active display.
* @param the display being refreshed
*/
void lv_refr_set_disp_refreshing(lv_disp_t * disp);
void _lv_refr_set_disp_refreshing(lv_disp_t * disp);
/**
* Called periodically to handle the refreshing
* @param task pointer to the task itself
*/
void lv_disp_refr_task(lv_task_t * task);
void _lv_disp_refr_task(lv_task_t * task);
/**********************
* STATIC FUNCTIONS
src/lv_core/lv_style.c
+53 -53
View File
@@ -60,7 +60,7 @@ static lv_style_t * get_alloc_local_style(lv_style_list_t * list);
*/
void lv_style_init(lv_style_t * style)
{
lv_memset_00(style, sizeof(lv_style_t));
_lv_memset_00(style, sizeof(lv_style_t));
#if LV_USE_ASSERT_STYLE
style->sentinel = LV_DEBUG_STYLE_SENTINEL_VALUE;
#endif
@@ -80,9 +80,9 @@ void lv_style_copy(lv_style_t * style_dest, const lv_style_t * style_src)
if(style_src->map == NULL) return;
uint16_t size = lv_style_get_mem_size(style_src);
uint16_t size = _lv_style_get_mem_size(style_src);
style_dest->map = lv_mem_alloc(size);
lv_memcpy(style_dest->map, style_src->map, size);
_lv_memcpy(style_dest->map, style_src->map, size);
}
/**
@@ -107,7 +107,7 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_property_t prop)
attr_goal.full = (prop >> 8) & 0xFFU;
if(attr_found.bits.state == attr_goal.bits.state) {
uint32_t map_size = lv_style_get_mem_size(style);
uint32_t map_size = _lv_style_get_mem_size(style);
uint8_t prop_size = sizeof(lv_style_property_t);
if((prop & 0xF) < LV_STYLE_ID_COLOR) prop_size += sizeof(lv_style_int_t);
else if((prop & 0xF) < LV_STYLE_ID_OPA) prop_size += sizeof(lv_color_t);
@@ -135,7 +135,7 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_property_t prop)
*/
void lv_style_list_init(lv_style_list_t * list)
{
lv_memset_00(list, sizeof(lv_style_list_t));
_lv_memset_00(list, sizeof(lv_style_list_t));
#if LV_USE_ASSERT_STYLE
list->sentinel = LV_DEBUG_STYLE_LIST_SENTINEL_VALUE;
#endif
@@ -151,7 +151,7 @@ void lv_style_list_copy(lv_style_list_t * list_dest, const lv_style_list_t * lis
LV_ASSERT_STYLE_LIST(list_dest);
LV_ASSERT_STYLE_LIST(list_src);
lv_style_list_reset(list_dest);
_lv_style_list_reset(list_dest);
if(list_src->style_list == NULL) return;
@@ -159,24 +159,24 @@ void lv_style_list_copy(lv_style_list_t * list_dest, const lv_style_list_t * lis
if(list_src->has_local == 0) {
if(list_src->has_trans) {
list_dest->style_list = lv_mem_alloc((list_src->style_cnt - 1) * sizeof(lv_style_t *));
lv_memcpy(list_dest->style_list, list_src->style_list + 1, (list_src->style_cnt - 1) * sizeof(lv_style_t *));
_lv_memcpy(list_dest->style_list, list_src->style_list + 1, (list_src->style_cnt - 1) * sizeof(lv_style_t *));
list_dest->style_cnt = list_src->style_cnt - 1;
}
else {
list_dest->style_list = lv_mem_alloc(list_src->style_cnt * sizeof(lv_style_t *));
lv_memcpy(list_dest->style_list, list_src->style_list, list_src->style_cnt * sizeof(lv_style_t *));
_lv_memcpy(list_dest->style_list, list_src->style_list, list_src->style_cnt * sizeof(lv_style_t *));
list_dest->style_cnt = list_src->style_cnt;
}
}
else {
if(list_src->has_trans) {
list_dest->style_list = lv_mem_alloc((list_src->style_cnt - 2) * sizeof(lv_style_t *));
lv_memcpy(list_dest->style_list, list_src->style_list + 2, (list_src->style_cnt - 2) * sizeof(lv_style_t *));
_lv_memcpy(list_dest->style_list, list_src->style_list + 2, (list_src->style_cnt - 2) * sizeof(lv_style_t *));
list_dest->style_cnt = list_src->style_cnt - 2;
}
else {
list_dest->style_list = lv_mem_alloc((list_src->style_cnt - 1) * sizeof(lv_style_t *));
lv_memcpy(list_dest->style_list, list_src->style_list + 1, (list_src->style_cnt - 1) * sizeof(lv_style_t *));
_lv_memcpy(list_dest->style_list, list_src->style_list + 1, (list_src->style_cnt - 1) * sizeof(lv_style_t *));
list_dest->style_cnt = list_src->style_cnt - 1;
}
@@ -192,7 +192,7 @@ void lv_style_list_copy(lv_style_list_t * list_dest, const lv_style_list_t * lis
* @param list pointer to a style list
* @param style pointer to a style to add
*/
void lv_style_list_add_style(lv_style_list_t * list, lv_style_t * style)
void _lv_style_list_add_style(lv_style_list_t * list, lv_style_t * style)
{
LV_ASSERT_STYLE_LIST(list);
LV_ASSERT_STYLE(style);
@@ -200,7 +200,7 @@ void lv_style_list_add_style(lv_style_list_t * list, lv_style_t * style)
if(list == NULL) return;
/*Remove the style first if already exists*/
lv_style_list_remove_style(list, style);
_lv_style_list_remove_style(list, style);
lv_style_t ** new_classes;
if(list->style_cnt == 0) new_classes = lv_mem_alloc(sizeof(lv_style_t *));
@@ -230,7 +230,7 @@ void lv_style_list_add_style(lv_style_list_t * list, lv_style_t * style)
* @param style_list pointer to a style list
* @param style pointer to a style to remove
*/
void lv_style_list_remove_style(lv_style_list_t * list, lv_style_t * style)
void _lv_style_list_remove_style(lv_style_list_t * list, lv_style_t * style)
{
LV_ASSERT_STYLE_LIST(list);
LV_ASSERT_STYLE(style);
@@ -279,7 +279,7 @@ void lv_style_list_remove_style(lv_style_list_t * list, lv_style_t * style)
* Leave `ignore_trans` flag as it is.
* @param list pointer to a style list.
*/
void lv_style_list_reset(lv_style_list_t * list)
void _lv_style_list_reset(lv_style_list_t * list)
{
LV_ASSERT_STYLE_LIST(list);
@@ -294,7 +294,7 @@ void lv_style_list_reset(lv_style_list_t * list)
}
if(list->has_trans) {
lv_style_t * trans = lv_style_list_get_transition_style(list);
lv_style_t * trans = _lv_style_list_get_transition_style(list);
if(trans) {
lv_style_reset(trans);
lv_mem_free(trans);
@@ -329,7 +329,7 @@ void lv_style_reset(lv_style_t * style)
* @param style pointer to a style
* @return size of the properties in bytes
*/
uint16_t lv_style_get_mem_size(const lv_style_t * style)
uint16_t _lv_style_get_mem_size(const lv_style_t * style)
{
LV_ASSERT_STYLE(style);
@@ -373,7 +373,7 @@ void _lv_style_set_int(lv_style_t * style, lv_style_property_t prop, lv_style_in
attr_goal.full = (prop >> 8) & 0xFFU;
if(attr_found.bits.state == attr_goal.bits.state) {
lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &value, sizeof(lv_style_int_t));
_lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &value, sizeof(lv_style_int_t));
return;
}
}
@@ -383,16 +383,16 @@ void _lv_style_set_int(lv_style_t * style, lv_style_property_t prop, lv_style_in
lv_style_property_t end_mark = _LV_STYLE_CLOSEING_PROP;
uint8_t end_mark_size = sizeof(end_mark);
uint16_t size = lv_style_get_mem_size(style);
uint16_t size = _lv_style_get_mem_size(style);
if(size == 0) size += end_mark_size;
size += sizeof(lv_style_property_t) + sizeof(lv_style_int_t);
style->map = lv_mem_realloc(style->map, size);
LV_ASSERT_MEM(style->map);
if(style == NULL) return;
lv_memcpy_small(style->map + size - new_prop_size - end_mark_size, &prop, sizeof(lv_style_property_t));
lv_memcpy_small(style->map + size - sizeof(lv_style_int_t) - end_mark_size, &value, sizeof(lv_style_int_t));
lv_memcpy_small(style->map + size - end_mark_size, &end_mark, sizeof(end_mark));
_lv_memcpy_small(style->map + size - new_prop_size - end_mark_size, &prop, sizeof(lv_style_property_t));
_lv_memcpy_small(style->map + size - sizeof(lv_style_int_t) - end_mark_size, &value, sizeof(lv_style_int_t));
_lv_memcpy_small(style->map + size - end_mark_size, &end_mark, sizeof(end_mark));
}
/**
@@ -419,7 +419,7 @@ void _lv_style_set_color(lv_style_t * style, lv_style_property_t prop, lv_color_
attr_goal.full = (prop >> 8) & 0xFFU;
if(attr_found.bits.state == attr_goal.bits.state) {
lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &color, sizeof(lv_color_t));
_lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &color, sizeof(lv_color_t));
return;
}
}
@@ -429,7 +429,7 @@ void _lv_style_set_color(lv_style_t * style, lv_style_property_t prop, lv_color_
lv_style_property_t end_mark = _LV_STYLE_CLOSEING_PROP;
uint8_t end_mark_size = sizeof(end_mark);
uint16_t size = lv_style_get_mem_size(style);
uint16_t size = _lv_style_get_mem_size(style);
if(size == 0) size += end_mark_size;
size += sizeof(lv_style_property_t) + sizeof(lv_color_t);
@@ -437,9 +437,9 @@ void _lv_style_set_color(lv_style_t * style, lv_style_property_t prop, lv_color_
LV_ASSERT_MEM(style->map);
if(style == NULL) return;
lv_memcpy_small(style->map + size - new_prop_size - end_mark_size, &prop, sizeof(lv_style_property_t));
lv_memcpy_small(style->map + size - sizeof(lv_color_t) - end_mark_size, &color, sizeof(lv_color_t));
lv_memcpy_small(style->map + size - end_mark_size, &end_mark, sizeof(end_mark));
_lv_memcpy_small(style->map + size - new_prop_size - end_mark_size, &prop, sizeof(lv_style_property_t));
_lv_memcpy_small(style->map + size - sizeof(lv_color_t) - end_mark_size, &color, sizeof(lv_color_t));
_lv_memcpy_small(style->map + size - end_mark_size, &end_mark, sizeof(end_mark));
}
/**
@@ -466,7 +466,7 @@ void _lv_style_set_opa(lv_style_t * style, lv_style_property_t prop, lv_opa_t op
attr_goal.full = (prop >> 8) & 0xFFU;
if(attr_found.bits.state == attr_goal.bits.state) {
lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &opa, sizeof(lv_opa_t));
_lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &opa, sizeof(lv_opa_t));
return;
}
}
@@ -476,7 +476,7 @@ void _lv_style_set_opa(lv_style_t * style, lv_style_property_t prop, lv_opa_t op
lv_style_property_t end_mark = _LV_STYLE_CLOSEING_PROP;
uint8_t end_mark_size = sizeof(end_mark);
uint16_t size = lv_style_get_mem_size(style);
uint16_t size = _lv_style_get_mem_size(style);
if(size == 0) size += end_mark_size;
size += sizeof(lv_style_property_t) + sizeof(lv_opa_t);
@@ -484,9 +484,9 @@ void _lv_style_set_opa(lv_style_t * style, lv_style_property_t prop, lv_opa_t op
LV_ASSERT_MEM(style->map);
if(style == NULL) return;
lv_memcpy_small(style->map + size - new_prop_size - end_mark_size, &prop, sizeof(lv_style_property_t));
lv_memcpy_small(style->map + size - sizeof(lv_opa_t) - end_mark_size, &opa, sizeof(lv_opa_t));
lv_memcpy_small(style->map + size - end_mark_size, &end_mark, sizeof(end_mark));
_lv_memcpy_small(style->map + size - new_prop_size - end_mark_size, &prop, sizeof(lv_style_property_t));
_lv_memcpy_small(style->map + size - sizeof(lv_opa_t) - end_mark_size, &opa, sizeof(lv_opa_t));
_lv_memcpy_small(style->map + size - end_mark_size, &end_mark, sizeof(end_mark));
}
/**
@@ -513,7 +513,7 @@ void _lv_style_set_ptr(lv_style_t * style, lv_style_property_t prop, const void
attr_goal.full = (prop >> 8) & 0xFFU;
if(attr_found.bits.state == attr_goal.bits.state) {
lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &p, sizeof(const void *));
_lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &p, sizeof(const void *));
return;
}
}
@@ -523,7 +523,7 @@ void _lv_style_set_ptr(lv_style_t * style, lv_style_property_t prop, const void
lv_style_property_t end_mark = _LV_STYLE_CLOSEING_PROP;
uint8_t end_mark_size = sizeof(end_mark);
uint16_t size = lv_style_get_mem_size(style);
uint16_t size = _lv_style_get_mem_size(style);
if(size == 0) size += end_mark_size;
size += sizeof(lv_style_property_t) + sizeof(const void *);
@@ -531,9 +531,9 @@ void _lv_style_set_ptr(lv_style_t * style, lv_style_property_t prop, const void
LV_ASSERT_MEM(style->map);
if(style == NULL) return;
lv_memcpy_small(style->map + size - new_prop_size - end_mark_size, &prop, sizeof(lv_style_property_t));
lv_memcpy_small(style->map + size - sizeof(const void *) - end_mark_size, &p, sizeof(const void *));
lv_memcpy_small(style->map + size - end_mark_size, &end_mark, sizeof(end_mark));
_lv_memcpy_small(style->map + size - new_prop_size - end_mark_size, &prop, sizeof(lv_style_property_t));
_lv_memcpy_small(style->map + size - sizeof(const void *) - end_mark_size, &p, sizeof(const void *));
_lv_memcpy_small(style->map + size - end_mark_size, &end_mark, sizeof(end_mark));
}
/**
@@ -559,7 +559,7 @@ int16_t _lv_style_get_int(const lv_style_t * style, lv_style_property_t prop, vo
return -1;
}
else {
lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_style_int_t));
_lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_style_int_t));
lv_style_attr_t attr_act;
attr_act.full = style->map[id + 1];
@@ -596,7 +596,7 @@ int16_t _lv_style_get_opa(const lv_style_t * style, lv_style_property_t prop, vo
return -1;
}
else {
lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_opa_t));
_lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_opa_t));
lv_style_attr_t attr_act;
attr_act.full = style->map[id + 1];
@@ -630,7 +630,7 @@ int16_t _lv_style_get_color(const lv_style_t * style, lv_style_property_t prop,
return -1;
}
else {
lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_color_t));
_lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_color_t));
lv_style_attr_t attr_act;
attr_act.full = style->map[id + 1];
@@ -665,7 +665,7 @@ int16_t _lv_style_get_ptr(const lv_style_t * style, lv_style_property_t prop, vo
return -1;
}
else {
lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(const void *));
_lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(const void *));
lv_style_attr_t attr_act;
attr_act.full = style->map[id + 1];
@@ -695,7 +695,7 @@ lv_style_t * lv_style_list_get_local_style(lv_style_list_t * list)
* @param list pointer to a style list where the local property should be set
* @return pointer to the transition style if exists else `NULL`.
*/
lv_style_t * lv_style_list_get_transition_style(lv_style_list_t * list)
lv_style_t * _lv_style_list_get_transition_style(lv_style_list_t * list)
{
LV_ASSERT_STYLE_LIST(list);
@@ -708,10 +708,10 @@ lv_style_t * lv_style_list_get_transition_style(lv_style_list_t * list)
* @param list pointer to a style list
* @return the transition style of a style list
*/
lv_style_t * lv_style_list_add_trans_style(lv_style_list_t * list)
lv_style_t * _lv_style_list_add_trans_style(lv_style_list_t * list)
{
LV_ASSERT_STYLE_LIST(list);
if(list->has_trans) return lv_style_list_get_transition_style(list);
if(list->has_trans) return _lv_style_list_get_transition_style(list);
lv_style_t * trans_style = lv_mem_alloc(sizeof(lv_style_t));
LV_ASSERT_MEM(trans_style);
@@ -722,7 +722,7 @@ lv_style_t * lv_style_list_add_trans_style(lv_style_list_t * list)
lv_style_init(trans_style);
lv_style_list_add_style(list, trans_style);
_lv_style_list_add_style(list, trans_style);
list->has_trans = 1;
/*If the list has local style trans was added after it. But trans should be the first so swap them*/
@@ -743,7 +743,7 @@ lv_style_t * lv_style_list_add_trans_style(lv_style_list_t * list)
* @param value the value to set
* @note for performance reasons it's not checked if the property really has integer type
*/
void lv_style_list_set_local_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t value)
void _lv_style_list_set_local_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t value)
{
LV_ASSERT_STYLE_LIST(list);
@@ -759,7 +759,7 @@ void lv_style_list_set_local_int(lv_style_list_t * list, lv_style_property_t pro
* @param value the value to set
* @note for performance reasons it's not checked if the property really has opacity type
*/
void lv_style_list_set_local_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t value)
void _lv_style_list_set_local_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t value)
{
LV_ASSERT_STYLE_LIST(list);
@@ -775,7 +775,7 @@ void lv_style_list_set_local_opa(lv_style_list_t * list, lv_style_property_t pro
* @param value the value to set
* @note for performance reasons it's not checked if the property really has color type
*/
void lv_style_list_set_local_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t value)
void _lv_style_list_set_local_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t value)
{
LV_ASSERT_STYLE_LIST(list);
@@ -791,7 +791,7 @@ void lv_style_list_set_local_color(lv_style_list_t * list, lv_style_property_t p
* @param value the value to set
* @note for performance reasons it's not checked if the property really has pointer type
*/
void lv_style_list_set_local_ptr(lv_style_list_t * list, lv_style_property_t prop, const void * value)
void _lv_style_list_set_local_ptr(lv_style_list_t * list, lv_style_property_t prop, const void * value)
{
LV_ASSERT_STYLE_LIST(list);
@@ -812,7 +812,7 @@ void lv_style_list_set_local_ptr(lv_style_list_t * list, lv_style_property_t pro
* LV_RES_INV: there was NO matching property in the list
* @note for performance reasons it's not checked if the property really has integer type
*/
lv_res_t lv_style_list_get_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t * res)
lv_res_t _lv_style_list_get_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t * res)
{
LV_ASSERT_STYLE_LIST(list);
@@ -864,7 +864,7 @@ lv_res_t lv_style_list_get_int(lv_style_list_t * list, lv_style_property_t prop,
* LV_RES_INV: there was NO matching property in the list
* @note for performance reasons it's not checked if the property really has color type
*/
lv_res_t lv_style_list_get_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t * res)
lv_res_t _lv_style_list_get_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t * res)
{
LV_ASSERT_STYLE_LIST(list);
@@ -914,7 +914,7 @@ lv_res_t lv_style_list_get_color(lv_style_list_t * list, lv_style_property_t pro
* LV_RES_INV: there was NO matching property in the list
* @note for performance reasons it's not checked if the property really has opacity type
*/
lv_res_t lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t * res)
lv_res_t _lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t * res)
{
LV_ASSERT_STYLE_LIST(list);
@@ -964,7 +964,7 @@ lv_res_t lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop,
* LV_RES_INV: there was NO matching property in the list
* @note for performance reasons it's not checked if the property really has pointer type
*/
lv_res_t lv_style_list_get_ptr(lv_style_list_t * list, lv_style_property_t prop, const void ** res)
lv_res_t _lv_style_list_get_ptr(lv_style_list_t * list, lv_style_property_t prop, const void ** res)
{
LV_ASSERT_STYLE_LIST(list);
@@ -1082,7 +1082,7 @@ static lv_style_t * get_alloc_local_style(lv_style_list_t * list)
lv_style_init(local_style);
/*Add the local style to the furst place*/
lv_style_list_add_style(list, local_style);
_lv_style_list_add_style(list, local_style);
list->has_local = 1;
return local_style;
src/lv_core/lv_style.h
+14 -16
View File
@@ -267,21 +267,21 @@ void lv_style_list_copy(lv_style_list_t * list_dest, const lv_style_list_t * lis
* @param list pointer to a style list
* @param style pointer to a style to add
*/
void lv_style_list_add_style(lv_style_list_t * list, lv_style_t * style);
void _lv_style_list_add_style(lv_style_list_t * list, lv_style_t * style);
/**
* Remove a style from a style list
* @param style_list pointer to a style list
* @param style pointer to a style to remove
*/
void lv_style_list_remove_style(lv_style_list_t * list, lv_style_t * style);
void _lv_style_list_remove_style(lv_style_list_t * list, lv_style_t * style);
/**
* Remove all styles added from style list, clear the local style, transition style and free all allocated memories.
* Leave `ignore_trans` flag as it is.
* @param list pointer to a style list.
*/
void lv_style_list_reset(lv_style_list_t * style_list);
void _lv_style_list_reset(lv_style_list_t * style_list);
static inline lv_style_t * lv_style_list_get_style(lv_style_list_t * list, uint8_t id)
{
@@ -301,7 +301,7 @@ void lv_style_reset(lv_style_t * style);
* @param style pointer to a style
* @return size of the properties in bytes
*/
uint16_t lv_style_get_mem_size(const lv_style_t * style);
uint16_t _lv_style_get_mem_size(const lv_style_t * style);
/**
* Copy a style to an other
@@ -367,8 +367,6 @@ void _lv_style_set_opa(lv_style_t * style, lv_style_property_t prop, lv_opa_t op
*/
void _lv_style_set_ptr(lv_style_t * style, lv_style_property_t prop, const void * p);
/**
* Get an integer typed property from a style.
* @param style pointer to a style from where the property should be get
@@ -441,14 +439,14 @@ lv_style_t * lv_style_list_get_local_style(lv_style_list_t * list);
* @param list pointer to a style list where the local property should be set
* @return pointer to the transition style if exists else `NULL`.
*/
lv_style_t * lv_style_list_get_transition_style(lv_style_list_t * list);
lv_style_t * _lv_style_list_get_transition_style(lv_style_list_t * list);
/**
* Allocate the transition style in a style list. If already exists simply return it.
* @param list pointer to a style list
* @return the transition style of a style list
*/
lv_style_t * lv_style_list_add_trans_style(lv_style_list_t * list);
lv_style_t * _lv_style_list_add_trans_style(lv_style_list_t * list);
/**
* Set a local integer typed property in a style list.
@@ -458,7 +456,7 @@ lv_style_t * lv_style_list_add_trans_style(lv_style_list_t * list);
* @param value the value to set
* @note for performance reasons it's not checked if the property really has integer type
*/
void lv_style_list_set_local_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t value);
void _lv_style_list_set_local_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t value);
/**
* Set a local color typed property in a style list.
@@ -468,7 +466,7 @@ void lv_style_list_set_local_int(lv_style_list_t * list, lv_style_property_t pro
* @param value the value to set
* @note for performance reasons it's not checked if the property really has color type
*/
void lv_style_list_set_local_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t value);
void _lv_style_list_set_local_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t value);
/**
* Set a local opacity typed property in a style list.
@@ -478,7 +476,7 @@ void lv_style_list_set_local_color(lv_style_list_t * list, lv_style_property_t p
* @param value the value to set
* @note for performance reasons it's not checked if the property really has opacity type
*/
void lv_style_list_set_local_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t value);
void _lv_style_list_set_local_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t value);
/**
* Set a local pointer typed property in a style list.
@@ -488,7 +486,7 @@ void lv_style_list_set_local_opa(lv_style_list_t * list, lv_style_property_t pro
* @param value the value to set
* @note for performance reasons it's not checked if the property really has pointer type
*/
void lv_style_list_set_local_ptr(lv_style_list_t * list, lv_style_property_t prop, const void * value);
void _lv_style_list_set_local_ptr(lv_style_list_t * list, lv_style_property_t prop, const void * value);
/**
* Get an integer typed property from a style list.
@@ -501,7 +499,7 @@ void lv_style_list_set_local_ptr(lv_style_list_t * list, lv_style_property_t pro
* LV_RES_INV: there was NO matching property in the list
* @note for performance reasons it's not checked if the property really has integer type
*/
lv_res_t lv_style_list_get_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t * res);
lv_res_t _lv_style_list_get_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t * res);
/**
* Get a color typed property from a style list.
@@ -514,7 +512,7 @@ lv_res_t lv_style_list_get_int(lv_style_list_t * list, lv_style_property_t prop,
* LV_RES_INV: there was NO matching property in the list
* @note for performance reasons it's not checked if the property really has color type
*/
lv_res_t lv_style_list_get_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t * res);
lv_res_t _lv_style_list_get_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t * res);
/**
@@ -528,7 +526,7 @@ lv_res_t lv_style_list_get_color(lv_style_list_t * list, lv_style_property_t pro
* LV_RES_INV: there was NO matching property in the list
* @note for performance reasons it's not checked if the property really has opacity type
*/
lv_res_t lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t * res);
lv_res_t _lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t * res);
/**
* Get a pointer typed property from a style list.
@@ -541,7 +539,7 @@ lv_res_t lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop,
* LV_RES_INV: there was NO matching property in the list
* @note for performance reasons it's not checked if the property really has pointer type
*/
lv_res_t lv_style_list_get_ptr(lv_style_list_t * list, lv_style_property_t prop, const void ** res);
lv_res_t _lv_style_list_get_ptr(lv_style_list_t * list, lv_style_property_t prop, const void ** res);
/*************************
src/lv_draw/lv_draw_arc.c
+50 -50
View File
@@ -177,13 +177,13 @@ static void draw_quarter_0(quarter_draw_dsc_t * q)
if(q->start_quarter == 0 && q->end_quarter == 0 && q->start_angle < q->end_angle) {
/*Small arc here*/
quarter_area.y1 = q->center_y + ((lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
else if(q->start_quarter == 0 || q->end_quarter == 0) {
@@ -192,20 +192,20 @@ static void draw_quarter_0(quarter_draw_dsc_t * q)
quarter_area.x1 = q->center_x;
quarter_area.y2 = q->center_y + q->radius;
quarter_area.y1 = q->center_y + ((lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
if(q->end_quarter == 0) {
quarter_area.x2 = q->center_x + q->radius;
quarter_area.y1 = q->center_y;
quarter_area.y2 = q->center_y + ((lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
}
@@ -219,7 +219,7 @@ static void draw_quarter_0(quarter_draw_dsc_t * q)
quarter_area.x2 = q->center_x + q->radius;
quarter_area.y2 = q->center_y + q->radius;
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
}
@@ -230,13 +230,13 @@ static void draw_quarter_1(quarter_draw_dsc_t * q)
if(q->start_quarter == 1 && q->end_quarter == 1 && q->start_angle < q->end_angle) {
/*Small arc here*/
quarter_area.y2 = q->center_y + ((lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
else if(q->start_quarter == 1 || q->end_quarter == 1) {
@@ -245,20 +245,20 @@ static void draw_quarter_1(quarter_draw_dsc_t * q)
quarter_area.x1 = q->center_x - q->radius;
quarter_area.y1 = q->center_y;
quarter_area.y2 = q->center_y + ((lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
if(q->end_quarter == 1) {
quarter_area.x2 = q->center_x - 1;
quarter_area.y2 = q->center_y + q->radius;
quarter_area.y1 = q->center_y + ((lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
}
@@ -272,7 +272,7 @@ static void draw_quarter_1(quarter_draw_dsc_t * q)
quarter_area.x2 = q->center_x - 1;
quarter_area.y2 = q->center_y + q->radius;
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
}
@@ -283,13 +283,13 @@ static void draw_quarter_2(quarter_draw_dsc_t * q)
if(q->start_quarter == 2 && q->end_quarter == 2 && q->start_angle < q->end_angle) {
/*Small arc here*/
quarter_area.x1 = q->center_x + ((lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
else if(q->start_quarter == 2 || q->end_quarter == 2) {
@@ -298,20 +298,20 @@ static void draw_quarter_2(quarter_draw_dsc_t * q)
quarter_area.x2 = q->center_x - 1;
quarter_area.y1 = q->center_y - q->radius;
quarter_area.x1 = q->center_x + ((lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
if(q->end_quarter == 2) {
quarter_area.x1 = q->center_x - q->radius;
quarter_area.y2 = q->center_y - 1;
quarter_area.x2 = q->center_x + ((lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((lv_trigo_sin(q->end_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
}
@@ -325,7 +325,7 @@ static void draw_quarter_2(quarter_draw_dsc_t * q)
quarter_area.x2 = q->center_x - 1;
quarter_area.y2 = q->center_y - 1;
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
}
@@ -337,13 +337,13 @@ static void draw_quarter_3(quarter_draw_dsc_t * q)
if(q->start_quarter == 3 && q->end_quarter == 3 && q->start_angle < q->end_angle) {
/*Small arc here*/
quarter_area.x1 = q->center_x + ((lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
else if(q->start_quarter == 3 || q->end_quarter == 3) {
@@ -352,20 +352,20 @@ static void draw_quarter_3(quarter_draw_dsc_t * q)
quarter_area.x2 = q->center_x + q->radius;
quarter_area.y2 = q->center_y - 1;
quarter_area.x1 = q->center_x + ((lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
if(q->end_quarter == 3) {
quarter_area.x1 = q->center_x;
quarter_area.y1 = q->center_y - q->radius;
quarter_area.x2 = q->center_x + ((lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
}
@@ -379,7 +379,7 @@ static void draw_quarter_3(quarter_draw_dsc_t * q)
quarter_area.x2 = q->center_x + q->radius;
quarter_area.y2 = q->center_y - 1;
bool ok = lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
}
}
@@ -405,8 +405,8 @@ static void get_rounded_area(int16_t angle, lv_coord_t radius, uint8_t tickness,
int32_t cir_x;
int32_t cir_y;
cir_x = ((radius - rx_corr - thick_half) * lv_trigo_sin(90 - angle)) >> (LV_TRIGO_SHIFT - ps);
cir_y = ((radius - ry_corr - thick_half) * lv_trigo_sin(angle)) >> (LV_TRIGO_SHIFT - ps);
cir_x = ((radius - rx_corr - thick_half) * _lv_trigo_sin(90 - angle)) >> (LV_TRIGO_SHIFT - ps);
cir_y = ((radius - ry_corr - thick_half) * _lv_trigo_sin(angle)) >> (LV_TRIGO_SHIFT - ps);
/* Actually the center of the pixel need to be calculated so apply 1/2 px offset*/
if(cir_x > 0) {
src/lv_draw/lv_draw_blend.c
+11 -11
View File
@@ -117,7 +117,7 @@ static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_co
* @param opa overall opacity in 0x00..0xff range
* @param mode blend mode from `lv_blend_mode_t`
*/
LV_ATTRIBUTE_FAST_MEM void lv_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area,
LV_ATTRIBUTE_FAST_MEM void _lv_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area,
lv_color_t color, lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa,
lv_blend_mode_t mode)
{
@@ -125,7 +125,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_blend_fill(const lv_area_t * clip_area, const lv_a
if(opa < LV_OPA_MIN) return;
if(mask_res == LV_DRAW_MASK_RES_TRANSP) return;
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
const lv_area_t * disp_area = &vdb->area;
lv_color_t * disp_buf = vdb->buf_act;
@@ -135,7 +135,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_blend_fill(const lv_area_t * clip_area, const lv_a
* It is always the same or inside `fill_area` */
lv_area_t draw_area;
bool is_common;
is_common = lv_area_intersect(&draw_area, clip_area, fill_area);
is_common = _lv_area_intersect(&draw_area, clip_area, fill_area);
if(!is_common) return;
/* Now `draw_area` has absolute coordinates.
@@ -181,7 +181,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_blend_fill(const lv_area_t * clip_area, const lv_a
* @param opa overall opacity in 0x00..0xff range
* @param mode blend mode from `lv_blend_mode_t`
*/
LV_ATTRIBUTE_FAST_MEM void lv_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
LV_ATTRIBUTE_FAST_MEM void _lv_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
const lv_color_t * map_buf,
lv_opa_t * mask, lv_draw_mask_res_t mask_res,
lv_opa_t opa, lv_blend_mode_t mode)
@@ -194,10 +194,10 @@ LV_ATTRIBUTE_FAST_MEM void lv_blend_map(const lv_area_t * clip_area, const lv_ar
* It is always the same or inside `fill_area` */
lv_area_t draw_area;
bool is_common;
is_common = lv_area_intersect(&draw_area, clip_area, map_area);
is_common = _lv_area_intersect(&draw_area, clip_area, map_area);
if(!is_common) return;
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
const lv_area_t * disp_area = &vdb->area;
lv_color_t * disp_buf = vdb->buf_act;
@@ -241,7 +241,7 @@ static void fill_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf, con
const lv_opa_t * mask, lv_draw_mask_res_t mask_res)
{
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
/*Get the width of the `disp_area` it will be used to go to the next line*/
int32_t disp_w = lv_area_get_width(disp_area);
@@ -295,7 +295,7 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(const lv_area_t * disp_area, lv_co
{
#if LV_USE_GPU || LV_COLOR_SCREEN_TRANSP
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
#endif
/*Get the width of the `disp_area` it will be used to go to the next line*/
@@ -587,7 +587,7 @@ static void map_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf, cons
const lv_opa_t * mask, lv_draw_mask_res_t mask_res)
{
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
/*Get the width of the `disp_area` it will be used to go to the next line*/
int32_t disp_w = lv_area_get_width(disp_area);
@@ -667,7 +667,7 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(const lv_area_t * disp_area, lv_col
map_buf_first += (draw_area->x1 - (map_area->x1 - disp_area->x1));
#if LV_COLOR_SCREEN_TRANSP || LV_USE_GPU
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
#endif
int32_t x;
@@ -696,7 +696,7 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(const lv_area_t * disp_area, lv_col
/*Software rendering*/
for(y = 0; y < draw_area_h; y++) {
lv_memcpy(disp_buf_first, map_buf_first, draw_area_w * sizeof(lv_color_t));
_lv_memcpy(disp_buf_first, map_buf_first, draw_area_w * sizeof(lv_color_t));
disp_buf_first += disp_w;
map_buf_first += map_w;
}
src/lv_draw/lv_draw_blend.h
+2 -2
View File
@@ -36,11 +36,11 @@ typedef uint8_t lv_blend_mode_t;
* GLOBAL PROTOTYPES
**********************/
LV_ATTRIBUTE_FAST_MEM void lv_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area, lv_color_t color,
LV_ATTRIBUTE_FAST_MEM void _lv_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area, lv_color_t color,
lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa, lv_blend_mode_t mode);
LV_ATTRIBUTE_FAST_MEM void lv_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
LV_ATTRIBUTE_FAST_MEM void _lv_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
const lv_color_t * map_buf,
lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa, lv_blend_mode_t mode);
src/lv_draw/lv_draw_img.c
+27 -27
View File
@@ -52,7 +52,7 @@ static void show_error(const lv_area_t * coords, const lv_area_t * clip_area, co
void lv_draw_img_dsc_init(lv_draw_img_dsc_t * dsc)
{
lv_memset_00(dsc, sizeof(lv_draw_img_dsc_t));
_lv_memset_00(dsc, sizeof(lv_draw_img_dsc_t));
dsc->recolor = LV_COLOR_BLACK;
dsc->opa = LV_OPA_COVER;
dsc->zoom = LV_IMG_ZOOM_NONE;
@@ -236,7 +236,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
{
if(draw_dsc->opa <= LV_OPA_MIN) return LV_RES_OK;
lv_img_cache_entry_t * cdsc = lv_img_cache_open(src, draw_dsc->recolor);
lv_img_cache_entry_t * cdsc = _lv_img_cache_open(src, draw_dsc->recolor);
if(cdsc == NULL) return LV_RES_INV;
@@ -257,7 +257,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
int32_t w = lv_area_get_width(coords);
int32_t h = lv_area_get_height(coords);
lv_img_buf_get_transformed_area(&map_area_rot, w, h, draw_dsc->angle, draw_dsc->zoom, &draw_dsc->pivot);
_lv_img_buf_get_transformed_area(&map_area_rot, w, h, draw_dsc->angle, draw_dsc->zoom, &draw_dsc->pivot);
map_area_rot.x1 += coords->x1;
map_area_rot.y1 += coords->y1;
@@ -267,7 +267,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
lv_area_t mask_com; /*Common area of mask and coords*/
bool union_ok;
union_ok = lv_area_intersect(&mask_com, clip_area, &map_area_rot);
union_ok = _lv_area_intersect(&mask_com, clip_area, &map_area_rot);
if(union_ok == false) {
return LV_RES_OK; /*Out of mask. There is nothing to draw so the image is drawn
successfully.*/
@@ -279,7 +279,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
else {
lv_area_t mask_com; /*Common area of mask and coords*/
bool union_ok;
union_ok = lv_area_intersect(&mask_com, clip_area, coords);
union_ok = _lv_area_intersect(&mask_com, clip_area, coords);
if(union_ok == false) {
return LV_RES_OK; /*Out of mask. There is nothing to draw so the image is drawn
successfully.*/
@@ -287,7 +287,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
int32_t width = lv_area_get_width(&mask_com);
uint8_t * buf = lv_mem_buf_get(lv_area_get_width(&mask_com) *
uint8_t * buf = _lv_mem_buf_get(lv_area_get_width(&mask_com) *
LV_IMG_PX_SIZE_ALPHA_BYTE); /*+1 because of the possible alpha byte*/
lv_area_t line;
@@ -299,14 +299,14 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
lv_res_t read_res;
for(row = mask_com.y1; row <= mask_com.y2; row++) {
lv_area_t mask_line;
union_ok = lv_area_intersect(&mask_line, clip_area, &line);
union_ok = _lv_area_intersect(&mask_line, clip_area, &line);
if(union_ok == false) continue;
read_res = lv_img_decoder_read_line(&cdsc->dec_dsc, x, y, width, buf);
if(read_res != LV_RES_OK) {
lv_img_decoder_close(&cdsc->dec_dsc);
LV_LOG_WARN("Image draw can't read the line");
lv_mem_buf_release(buf);
_lv_mem_buf_release(buf);
return LV_RES_INV;
}
@@ -316,7 +316,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
line.y2++;
y++;
}
lv_mem_buf_release(buf);
_lv_mem_buf_release(buf);
}
return LV_RES_OK;
@@ -344,7 +344,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
lv_area_t draw_area;
lv_area_copy(&draw_area, clip_area);
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
const lv_area_t * disp_area = &vdb->area;
@@ -360,7 +360,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
/*The simplest case just copy the pixels into the VDB*/
if(other_mask_cnt == 0 && draw_dsc->angle == 0 && draw_dsc->zoom == LV_IMG_ZOOM_NONE &&
chroma_key == false && alpha_byte == false && draw_dsc->recolor_opa == LV_OPA_TRANSP) {
lv_blend_map(clip_area, map_area, (lv_color_t *)map_p, NULL, LV_DRAW_MASK_RES_FULL_COVER, draw_dsc->opa,
_lv_blend_map(clip_area, map_area, (lv_color_t *)map_p, NULL, LV_DRAW_MASK_RES_FULL_COVER, draw_dsc->opa,
draw_dsc->blend_mode);
}
/*In the other cases every pixel need to be checked one-by-one*/
@@ -370,8 +370,8 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
/*Build the image and a mask line-by-line*/
uint32_t mask_buf_size = lv_area_get_size(&draw_area) > LV_HOR_RES_MAX ? LV_HOR_RES_MAX : lv_area_get_size(&draw_area);
lv_color_t * map2 = lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t));
lv_opa_t * mask_buf = lv_mem_buf_get(mask_buf_size);
lv_color_t * map2 = _lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t));
lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
/*Go to the first displayed pixel of the map*/
int32_t map_w = lv_area_get_width(map_area);
@@ -438,7 +438,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
blend_area.y2 ++;
}
else {
lv_blend_map(clip_area, &blend_area, map2, mask_buf, LV_DRAW_MASK_RES_CHANGED, draw_dsc->opa, draw_dsc->blend_mode);
_lv_blend_map(clip_area, &blend_area, map2, mask_buf, LV_DRAW_MASK_RES_CHANGED, draw_dsc->opa, draw_dsc->blend_mode);
blend_area.y1 = blend_area.y2 + 1;
blend_area.y2 = blend_area.y1;
@@ -449,18 +449,18 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
/*Flush the last part*/
if(blend_area.y1 != blend_area.y2) {
blend_area.y2--;
lv_blend_map(clip_area, &blend_area, map2, mask_buf, LV_DRAW_MASK_RES_CHANGED, draw_dsc->opa, draw_dsc->blend_mode);
_lv_blend_map(clip_area, &blend_area, map2, mask_buf, LV_DRAW_MASK_RES_CHANGED, draw_dsc->opa, draw_dsc->blend_mode);
}
lv_mem_buf_release(mask_buf);
lv_mem_buf_release(map2);
_lv_mem_buf_release(mask_buf);
_lv_mem_buf_release(map2);
}
/*Most complicated case: transform or other mask or chroma keyed*/
else {
#if LV_USE_IMG_TRANSFORM
lv_img_transform_dsc_t trans_dsc;
lv_memset_00(&trans_dsc, sizeof(lv_img_transform_dsc_t));
_lv_memset_00(&trans_dsc, sizeof(lv_img_transform_dsc_t));
if(transform) {
lv_img_cf_t cf = LV_IMG_CF_TRUE_COLOR;
if(alpha_byte) cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
@@ -477,7 +477,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
trans_dsc.cfg.color = draw_dsc->recolor;
trans_dsc.cfg.antialias = draw_dsc->antialias;
lv_img_buf_transform_init(&trans_dsc);
_lv_img_buf_transform_init(&trans_dsc);
}
#endif
uint16_t recolor_premult[3] = {0};
@@ -493,7 +493,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
/*Prepare the `mask_buf`if there are other masks*/
if(other_mask_cnt) {
lv_memset_ff(mask_buf, mask_buf_size);
_lv_memset_ff(mask_buf, mask_buf_size);
}
int32_t x;
@@ -516,7 +516,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
/*Transform*/
bool ret;
ret = lv_img_buf_transform(&trans_dsc, rot_x + x, rot_y + y);
ret = _lv_img_buf_transform(&trans_dsc, rot_x + x, rot_y + y);
if(ret == false) {
mask_buf[px_i] = LV_OPA_TRANSP;
continue;
@@ -570,7 +570,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
mask_res_sub = lv_draw_mask_apply(mask_buf + px_i_start, draw_area.x1 + vdb->area.x1, y + draw_area.y1 + vdb->area.y1,
lv_area_get_width(&draw_area));
if(mask_res_sub == LV_DRAW_MASK_RES_TRANSP) {
lv_memset_00(mask_buf + px_i_start, lv_area_get_width(&draw_area));
_lv_memset_00(mask_buf + px_i_start, lv_area_get_width(&draw_area));
mask_res = LV_DRAW_MASK_RES_CHANGED;
}
else if(mask_res_sub == LV_DRAW_MASK_RES_CHANGED) {
@@ -583,7 +583,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
blend_area.y2 ++;
}
else {
lv_blend_map(clip_area, &blend_area, map2, mask_buf, mask_res, draw_dsc->opa, draw_dsc->blend_mode);
_lv_blend_map(clip_area, &blend_area, map2, mask_buf, mask_res, draw_dsc->opa, draw_dsc->blend_mode);
blend_area.y1 = blend_area.y2 + 1;
blend_area.y2 = blend_area.y1;
@@ -594,19 +594,19 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
/*Prepare the `mask_buf`if there are other masks*/
if(other_mask_cnt) {
lv_memset_ff(mask_buf, mask_buf_size);
_lv_memset_ff(mask_buf, mask_buf_size);
}
}
}
/*Flush the last part*/
if(blend_area.y1 != blend_area.y2) {
blend_area.y2--;
lv_blend_map(clip_area, &blend_area, map2, mask_buf, mask_res, draw_dsc->opa, draw_dsc->blend_mode);
_lv_blend_map(clip_area, &blend_area, map2, mask_buf, mask_res, draw_dsc->opa, draw_dsc->blend_mode);
}
}
lv_mem_buf_release(mask_buf);
lv_mem_buf_release(map2);
_lv_mem_buf_release(mask_buf);
_lv_mem_buf_release(map2);
}
}
src/lv_draw/lv_draw_label.c
+33 -33
View File
@@ -92,7 +92,7 @@ const uint8_t _lv_bpp8_opa_table[256] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1
LV_ATTRIBUTE_FAST_MEM void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc)
{
lv_memset_00(dsc, sizeof(lv_draw_label_dsc_t));
_lv_memset_00(dsc, sizeof(lv_draw_label_dsc_t));
dsc->opa = LV_OPA_COVER;
dsc->color = LV_COLOR_BLACK;
dsc->font = LV_THEME_DEFAULT_FONT_NORMAL;
@@ -121,7 +121,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
if(txt[0] == '\0') return;
lv_area_t clipped_area;
bool clip_ok = lv_area_intersect(&clipped_area, coords, mask);
bool clip_ok = _lv_area_intersect(&clipped_area, coords, mask);
if(!clip_ok) return;
@@ -132,7 +132,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
else {
/*If EXAPND is enabled then not limit the text's width to the object's width*/
lv_point_t p;
lv_txt_get_size(&p, txt, dsc->font, dsc->letter_space, dsc->line_space, LV_COORD_MAX,
_lv_txt_get_size(&p, txt, dsc->font, dsc->letter_space, dsc->line_space, LV_COORD_MAX,
dsc->flag);
w = p.x;
}
@@ -170,13 +170,13 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
pos.y += hint->y;
}
uint32_t line_end = line_start + lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
uint32_t line_end = line_start + _lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
/*Go the first visible line*/
while(pos.y + line_height_font < mask->y1) {
/*Go to next line*/
line_start = line_end;
line_end += lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
line_end += _lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
pos.y += line_height;
/*Save at the threshold coordinate*/
@@ -191,14 +191,14 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
/*Align to middle*/
if(dsc->flag & LV_TXT_FLAG_CENTER) {
line_width = lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
line_width = _lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
pos.x += (lv_area_get_width(coords) - line_width) / 2;
}
/*Align to the right*/
else if(dsc->flag & LV_TXT_FLAG_RIGHT) {
line_width = lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
line_width = _lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
pos.x += lv_area_get_width(coords) - line_width;
}
@@ -241,8 +241,8 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
cmd_state = CMD_STATE_WAIT;
i = 0;
#if LV_USE_BIDI
char * bidi_txt = lv_mem_buf_get(line_end - line_start + 1);
lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, dsc->bidi_dir, NULL, 0);
char * bidi_txt = _lv_mem_buf_get(line_end - line_start + 1);
_lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, dsc->bidi_dir, NULL, 0);
#else
const char * bidi_txt = txt + line_start;
#endif
@@ -251,16 +251,16 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
uint16_t logical_char_pos = 0;
if(sel_start != 0xFFFF && sel_end != 0xFFFF) {
#if LV_USE_BIDI
logical_char_pos = lv_txt_encoded_get_char_id(txt, line_start);
uint16_t t = lv_txt_encoded_get_char_id(bidi_txt, i);
logical_char_pos += lv_bidi_get_logical_pos(bidi_txt, NULL, line_end - line_start, dsc->bidi_dir, t, NULL);
logical_char_pos = _lv_txt_encoded_get_char_id(txt, line_start);
uint16_t t = _lv_txt_encoded_get_char_id(bidi_txt, i);
logical_char_pos += _lv_bidi_get_logical_pos(bidi_txt, NULL, line_end - line_start, dsc->bidi_dir, t, NULL);
#else
logical_char_pos = lv_txt_encoded_get_char_id(txt, line_start + i);
logical_char_pos = _lv_txt_encoded_get_char_id(txt, line_start + i);
#endif
}
uint32_t letter = lv_txt_encoded_next(bidi_txt, &i);
uint32_t letter_next = lv_txt_encoded_next(&bidi_txt[i], NULL);
uint32_t letter = _lv_txt_encoded_next(bidi_txt, &i);
uint32_t letter_next = _lv_txt_encoded_next(&bidi_txt[i], NULL);
/*Handle the re-color command*/
if((dsc->flag & LV_TXT_FLAG_RECOLOR) != 0) {
@@ -285,7 +285,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
/*Get the parameter*/
if(i - par_start == LABEL_RECOLOR_PAR_LENGTH + 1) {
char buf[LABEL_RECOLOR_PAR_LENGTH + 1];
lv_memcpy_small(buf, &bidi_txt[par_start], LABEL_RECOLOR_PAR_LENGTH);
_lv_memcpy_small(buf, &bidi_txt[par_start], LABEL_RECOLOR_PAR_LENGTH);
buf[LABEL_RECOLOR_PAR_LENGTH] = '\0';
int r, g, b;
r = (hex_char_to_num(buf[0]) << 4) + hex_char_to_num(buf[1]);
@@ -347,18 +347,18 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
}
#if LV_USE_BIDI
lv_mem_buf_release(bidi_txt);
_lv_mem_buf_release(bidi_txt);
bidi_txt = NULL;
#endif
/*Go to next line*/
line_start = line_end;
line_end += lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
line_end += _lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
pos.x = coords->x1;
/*Align to middle*/
if(dsc->flag & LV_TXT_FLAG_CENTER) {
line_width =
lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
_lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
pos.x += (lv_area_get_width(coords) - line_width) / 2;
@@ -366,7 +366,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
/*Align to the right*/
else if(dsc->flag & LV_TXT_FLAG_RIGHT) {
line_width =
lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
_lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
pos.x += lv_area_get_width(coords) - line_width;
}
@@ -519,7 +519,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_coord_t pos_x, lv_coord_
col_bit = bit_ofs & 0x7; /* "& 0x7" equals to "% 8" just faster */
uint32_t mask_buf_size = box_w * box_h > LV_HOR_RES_MAX ? LV_HOR_RES_MAX : box_w * box_h;
lv_opa_t * mask_buf = lv_mem_buf_get(mask_buf_size);
lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
int32_t mask_p = 0;
lv_area_t fill_area;
@@ -568,7 +568,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_coord_t pos_x, lv_coord_
lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf + mask_p_start, fill_area.x1, fill_area.y2,
lv_area_get_width(&fill_area));
if(mask_res == LV_DRAW_MASK_RES_TRANSP) {
lv_memset_00(mask_buf + mask_p_start, lv_area_get_width(&fill_area));
_lv_memset_00(mask_buf + mask_p_start, lv_area_get_width(&fill_area));
}
}
@@ -576,7 +576,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_coord_t pos_x, lv_coord_
fill_area.y2 ++;
}
else {
lv_blend_fill(clip_area, &fill_area,
_lv_blend_fill(clip_area, &fill_area,
color, mask_buf, LV_DRAW_MASK_RES_CHANGED, LV_OPA_COVER,
blend_mode);
@@ -593,13 +593,13 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_coord_t pos_x, lv_coord_
/*Flush the last part*/
if(fill_area.y1 != fill_area.y2) {
fill_area.y2--;
lv_blend_fill(clip_area, &fill_area,
_lv_blend_fill(clip_area, &fill_area,
color, mask_buf, LV_DRAW_MASK_RES_CHANGED, LV_OPA_COVER,
blend_mode);
mask_p = 0;
}
lv_mem_buf_release(mask_buf);
_lv_mem_buf_release(mask_buf);
}
static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_dsc_t * g, const lv_area_t * clip_area,
@@ -656,12 +656,12 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
col_bit = bit_ofs & 0x7; /* "& 0x7" equals to "% 8" just faster */
int32_t mask_buf_size = box_w * box_h > LV_HOR_RES_MAX ? LV_HOR_RES_MAX : g->box_w * g->box_h;
lv_opa_t * mask_buf = lv_mem_buf_get(mask_buf_size);
lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
int32_t mask_p = 0;
lv_color_t * color_buf = lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t));
lv_color_t * color_buf = _lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t));
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
int32_t vdb_width = lv_area_get_width(&vdb->area);
@@ -772,7 +772,7 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf + mask_p_start, map_area.x1, map_area.y2,
lv_area_get_width(&map_area));
if(mask_res == LV_DRAW_MASK_RES_TRANSP) {
lv_memset_00(mask_buf + mask_p_start, lv_area_get_width(&map_area));
_lv_memset_00(mask_buf + mask_p_start, lv_area_get_width(&map_area));
}
}
@@ -780,7 +780,7 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
map_area.y2 ++;
}
else {
lv_blend_map(clip_area, &map_area, color_buf, mask_buf, LV_DRAW_MASK_RES_CHANGED, opa, blend_mode);
_lv_blend_map(clip_area, &map_area, color_buf, mask_buf, LV_DRAW_MASK_RES_CHANGED, opa, blend_mode);
map_area.y1 = map_area.y2 + 1;
map_area.y2 = map_area.y1;
@@ -799,11 +799,11 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
/*Flush the last part*/
if(map_area.y1 != map_area.y2) {
map_area.y2--;
lv_blend_map(clip_area, &map_area, color_buf, mask_buf, LV_DRAW_MASK_RES_CHANGED, opa, blend_mode);
_lv_blend_map(clip_area, &map_area, color_buf, mask_buf, LV_DRAW_MASK_RES_CHANGED, opa, blend_mode);
}
lv_mem_buf_release(mask_buf);
lv_mem_buf_release(color_buf);
_lv_mem_buf_release(mask_buf);
_lv_mem_buf_release(color_buf);
}
src/lv_draw/lv_draw_line.c
+25 -25
View File
@@ -48,7 +48,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
LV_ATTRIBUTE_FAST_MEM void lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc)
{
lv_memset_00(dsc, sizeof(lv_draw_line_dsc_t));
_lv_memset_00(dsc, sizeof(lv_draw_line_dsc_t));
dsc->width = 1;
dsc->opa = LV_OPA_COVER;
dsc->color = LV_COLOR_BLACK;
@@ -77,7 +77,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_line(const lv_point_t * point1, const lv_poin
clip_line.y2 = LV_MATH_MAX(point1->y, point2->y) + dsc->width / 2;
bool is_common;
is_common = lv_area_intersect(&clip_line, &clip_line, clip);
is_common = _lv_area_intersect(&clip_line, &clip_line, clip);
if(!is_common) return;
if(point1->y == point2->y) draw_line_hor(point1, point2, &clip_line, dsc);
@@ -124,7 +124,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
{
lv_opa_t opa = dsc->opa;
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
const lv_area_t * disp_area = &vdb->area;
@@ -147,7 +147,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
/*If there is no mask then simply draw a rectangle*/
if(simple_mode) {
lv_blend_fill(clip, &draw_area,
_lv_blend_fill(clip, &draw_area,
dsc->color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa,
dsc->blend_mode);
}
@@ -156,7 +156,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
/* Get clipped fill area which is the real draw area.
* It is always the same or inside `fill_area` */
bool is_common;
is_common = lv_area_intersect(&draw_area, clip, &draw_area);
is_common = _lv_area_intersect(&draw_area, clip, &draw_area);
if(!is_common) return;
/* Now `draw_area` has absolute coordinates.
@@ -179,10 +179,10 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
dash_start = (vdb->area.x1 + draw_area.x1) % (dsc->dash_gap + dsc->dash_width);
}
lv_opa_t * mask_buf = lv_mem_buf_get(draw_area_w);
lv_opa_t * mask_buf = _lv_mem_buf_get(draw_area_w);
int32_t h;
for(h = draw_area.y1; h <= draw_area.y2; h++) {
lv_memset_ff(mask_buf, draw_area_w);
_lv_memset_ff(mask_buf, draw_area_w);
lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
if(dashed) {
@@ -207,14 +207,14 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
}
}
lv_blend_fill(clip, &fill_area,
_lv_blend_fill(clip, &fill_area,
dsc->color, mask_buf, mask_res, dsc->opa,
dsc->blend_mode);
fill_area.y1++;
fill_area.y2++;
}
lv_mem_buf_release(mask_buf);
_lv_mem_buf_release(mask_buf);
}
}
@@ -225,7 +225,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
{
lv_opa_t opa = dsc->opa;
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
const lv_area_t * disp_area = &vdb->area;
@@ -248,7 +248,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
/*If there is no mask then simply draw a rectangle*/
if(simple_mode) {
lv_blend_fill(clip, &draw_area,
_lv_blend_fill(clip, &draw_area,
dsc->color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa,
dsc->blend_mode);
}
@@ -257,7 +257,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
/* Get clipped fill area which is the real draw area.
* It is always the same or inside `fill_area` */
bool is_common;
is_common = lv_area_intersect(&draw_area, clip, &draw_area);
is_common = _lv_area_intersect(&draw_area, clip, &draw_area);
if(!is_common) return;
/* Now `draw_area` has absolute coordinates.
@@ -275,7 +275,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
fill_area.y1 = draw_area.y1 + disp_area->y1;
fill_area.y2 = fill_area.y1;
lv_opa_t * mask_buf = lv_mem_buf_get(draw_area_w);
lv_opa_t * mask_buf = _lv_mem_buf_get(draw_area_w);
lv_style_int_t dash_start = 0;
if(dashed) {
@@ -286,7 +286,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
int32_t h;
for(h = draw_area.y1; h <= draw_area.y2; h++) {
lv_memset_ff(mask_buf, draw_area_w);
_lv_memset_ff(mask_buf, draw_area_w);
lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
if(dashed) {
@@ -302,14 +302,14 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
dash_cnt ++;
}
lv_blend_fill(clip, &fill_area,
_lv_blend_fill(clip, &fill_area,
dsc->color, mask_buf, mask_res, dsc->opa,
LV_BLEND_MODE_NORMAL);
fill_area.y1++;
fill_area.y2++;
}
lv_mem_buf_release(mask_buf);
_lv_mem_buf_release(mask_buf);
}
}
@@ -364,7 +364,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(const lv_point_t * point1, cons
/* Get the union of `coords` and `clip`*/
/* `clip` is already truncated to the `vdb` size
* in 'lv_refr_area' function */
bool is_common = lv_area_intersect(&draw_area, &draw_area, clip);
bool is_common = _lv_area_intersect(&draw_area, &draw_area, clip);
if(is_common == false) return;
lv_draw_mask_line_param_t mask_left_param;
@@ -407,7 +407,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(const lv_point_t * point1, cons
mask_bottom_id = lv_draw_mask_add(&mask_bottom_param, NULL);
}
lv_disp_t * disp = lv_refr_get_disp_refreshing();
lv_disp_t * disp = _lv_refr_get_disp_refreshing();
lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
const lv_area_t * disp_area = &vdb->area;
@@ -426,7 +426,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(const lv_point_t * point1, cons
/*Draw the background line by line*/
int32_t h;
size_t mask_buf_size = LV_MATH_MIN(lv_area_get_size(&draw_area), LV_HOR_RES_MAX);
lv_opa_t * mask_buf = lv_mem_buf_get(mask_buf_size);
lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
lv_area_t fill_area;
fill_area.x1 = draw_area.x1 + disp_area->x1;
@@ -438,13 +438,13 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(const lv_point_t * point1, cons
uint32_t mask_p = 0;
lv_memset_ff(mask_buf, mask_buf_size);
_lv_memset_ff(mask_buf, mask_buf_size);
/*Fill the first row with 'color'*/
for(h = draw_area.y1 + disp_area->y1; h <= draw_area.y2 + disp_area->y1; h++) {
lv_draw_mask_res_t mask_res = lv_draw_mask_apply(&mask_buf[mask_p], x, h, draw_area_w);
if(mask_res == LV_DRAW_MASK_RES_TRANSP) {
lv_memset_00(&mask_buf[mask_p], draw_area_w);
_lv_memset_00(&mask_buf[mask_p], draw_area_w);
}
mask_p += draw_area_w;
@@ -452,27 +452,27 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(const lv_point_t * point1, cons
fill_area.y2 ++;
}
else {
lv_blend_fill(&fill_area, clip,
_lv_blend_fill(&fill_area, clip,
dsc->color, mask_buf, LV_DRAW_MASK_RES_CHANGED, dsc->opa,
dsc->blend_mode);
fill_area.y1 = fill_area.y2 + 1;
fill_area.y2 = fill_area.y1;
mask_p = 0;
lv_memset_ff(mask_buf, mask_buf_size);
_lv_memset_ff(mask_buf, mask_buf_size);
}
}
/*Flush the last part*/
if(fill_area.y1 != fill_area.y2) {
fill_area.y2--;
lv_blend_fill(&fill_area, clip,
_lv_blend_fill(&fill_area, clip,
dsc->color, mask_buf, LV_DRAW_MASK_RES_CHANGED, dsc->opa,
dsc->blend_mode);
}
lv_mem_buf_release(mask_buf);
_lv_mem_buf_release(mask_buf);
lv_draw_mask_remove_id(mask_left_id);
lv_draw_mask_remove_id(mask_right_id);
src/lv_draw/lv_draw_mask.c
+32 -32
View File
@@ -194,7 +194,7 @@ LV_ATTRIBUTE_FAST_MEM uint8_t lv_draw_mask_get_cnt(void)
void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t p1y, lv_coord_t p2x,
lv_coord_t p2y, lv_draw_mask_line_side_t side)
{
lv_memset_00(param, sizeof(lv_draw_mask_line_param_t));
_lv_memset_00(param, sizeof(lv_draw_mask_line_param_t));
if(p1y > p2y) {
lv_coord_t t;
@@ -293,8 +293,8 @@ void lv_draw_mask_line_angle_init(lv_draw_mask_line_param_t * param, lv_coord_t
int32_t p2x;
int32_t p2y;
p2x = (lv_trigo_sin(angle + 90) >> 5) + p1x;
p2y = (lv_trigo_sin(angle) >> 5) + py;
p2x = (_lv_trigo_sin(angle + 90) >> 5) + p1x;
p2y = (_lv_trigo_sin(angle) >> 5) + py;
lv_draw_mask_line_points_init(param, p1x, py, p2x, p2y, side);
}
@@ -465,7 +465,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_line(lv_opa_t * mas
else {
int32_t k = - abs_x;
if(k < 0) return LV_DRAW_MASK_RES_TRANSP;
if(k >= 0 && k < len) lv_memset_00(&mask_buf[k], len - k);
if(k >= 0 && k < len) _lv_memset_00(&mask_buf[k], len - k);
return LV_DRAW_MASK_RES_CHANGED;
}
}
@@ -475,7 +475,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_line(lv_opa_t * mas
int32_t k = - abs_x;
if(k < 0) k = 0;
if(k >= len) return LV_DRAW_MASK_RES_TRANSP;
else if(k >= 0 && k < len) lv_memset_00(&mask_buf[0], k);
else if(k >= 0 && k < len) _lv_memset_00(&mask_buf[0], k);
return LV_DRAW_MASK_RES_CHANGED;
}
}
@@ -594,7 +594,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_flat(lv_opa_t * mask_b
return LV_DRAW_MASK_RES_TRANSP;
}
if(k >= 0) {
lv_memset_00(&mask_buf[0], k);
_lv_memset_00(&mask_buf[0], k);
}
}
else {
@@ -603,7 +603,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_flat(lv_opa_t * mask_b
return LV_DRAW_MASK_RES_TRANSP;
}
if(k <= len) {
lv_memset_00(&mask_buf[k], len - k);
_lv_memset_00(&mask_buf[k], len - k);
}
}
@@ -673,13 +673,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_
if(k >= len) {
return LV_DRAW_MASK_RES_TRANSP;
}
if(k >= 0) lv_memset_00(&mask_buf[0], k);
if(k >= 0) _lv_memset_00(&mask_buf[0], k);
}
else {
if(k > len) k = len;
if(k == 0) return LV_DRAW_MASK_RES_TRANSP;
else if(k > 0) lv_memset_00(&mask_buf[k], len - k);
else if(k > 0) _lv_memset_00(&mask_buf[k], len - k);
}
}
@@ -708,12 +708,12 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_
k = xsi - abs_x - 1;
if(k > len) k = len;
else if(k > 0) lv_memset_00(&mask_buf[0], k);
else if(k > 0) _lv_memset_00(&mask_buf[0], k);
}
else {
if(k > len) return LV_DRAW_MASK_RES_FULL_COVER;
if(k >= 0) lv_memset_00(&mask_buf[k], len - k);
if(k >= 0) _lv_memset_00(&mask_buf[k], len - k);
}
}
@@ -738,13 +738,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_
if(p->inv) {
k = xsi - abs_x;
if(k > len) return LV_DRAW_MASK_RES_TRANSP;
if(k >= 0) lv_memset_00(&mask_buf[0], k);
if(k >= 0) _lv_memset_00(&mask_buf[0], k);
}
else {
if(k > len) k = len;
if(k == 0) return LV_DRAW_MASK_RES_TRANSP;
else if(k > 0) lv_memset_00(&mask_buf[k], len - k);
else if(k > 0) _lv_memset_00(&mask_buf[k], len - k);
}
}
}
@@ -794,7 +794,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma
if(tmp > 0) {
res1 = lv_draw_mask_line(&mask_buf[0], abs_x, abs_y, tmp, &p->start_line);
if(res1 == LV_DRAW_MASK_RES_TRANSP) {
lv_memset_00(&mask_buf[0], tmp);
_lv_memset_00(&mask_buf[0], tmp);
}
}
@@ -802,7 +802,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma
if(tmp < 0) tmp = 0;
res2 = lv_draw_mask_line(&mask_buf[tmp], abs_x + tmp, abs_y, len - tmp, &p->end_line);
if(res2 == LV_DRAW_MASK_RES_TRANSP) {
lv_memset_00(&mask_buf[tmp], len - tmp);
_lv_memset_00(&mask_buf[tmp], len - tmp);
}
if(res1 == res2) return res1;
else return LV_DRAW_MASK_RES_CHANGED;
@@ -836,7 +836,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma
if(tmp > 0) {
res1 = lv_draw_mask_line(&mask_buf[0], abs_x, abs_y, tmp, (lv_draw_mask_line_param_t *)&p->end_line);
if(res1 == LV_DRAW_MASK_RES_TRANSP) {
lv_memset_00(&mask_buf[0], tmp);
_lv_memset_00(&mask_buf[0], tmp);
}
}
@@ -844,7 +844,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma
if(tmp < 0) tmp = 0;
res2 = lv_draw_mask_line(&mask_buf[tmp], abs_x + tmp, abs_y, len - tmp, (lv_draw_mask_line_param_t *)&p->start_line);
if(res2 == LV_DRAW_MASK_RES_TRANSP) {
lv_memset_00(&mask_buf[tmp], len - tmp);
_lv_memset_00(&mask_buf[tmp], len - tmp);
}
if(res1 == res2) return res1;
else return LV_DRAW_MASK_RES_CHANGED;
@@ -920,13 +920,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
int32_t last = rect.x1 - abs_x;
if(last > len) return LV_DRAW_MASK_RES_TRANSP;
if(last >= 0) {
lv_memset_00(&mask_buf[0], last);
_lv_memset_00(&mask_buf[0], last);
}
int32_t first = rect.x2 - abs_x + 1;
if(first <= 0) return LV_DRAW_MASK_RES_TRANSP;
else if(first < len) {
lv_memset_00(&mask_buf[first], len - first);
_lv_memset_00(&mask_buf[first], len - first);
}
if(last == 0 && first == len) return LV_DRAW_MASK_RES_FULL_COVER;
else return LV_DRAW_MASK_RES_CHANGED;
@@ -938,7 +938,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
int32_t last = rect.x2 - abs_x - first + 1;
if(first + last > len) last = len - first;
if(last >= 0) {
lv_memset_00(&mask_buf[first], last);
_lv_memset_00(&mask_buf[first], last);
}
}
}
@@ -976,9 +976,9 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
x0.i = p->y_prev_x.i;
}
else {
lv_sqrt(r2 - (y * y), &x0, sqrt_mask);
_lv_sqrt(r2 - (y * y), &x0, sqrt_mask);
}
lv_sqrt(r2 - ((y - 1) * (y - 1)), &x1, sqrt_mask);
_lv_sqrt(r2 - ((y - 1) * (y - 1)), &x1, sqrt_mask);
p->y_prev = y - 1;
p->y_prev_x.f = x1.f;
p->y_prev_x.i = x1.i;
@@ -994,10 +994,10 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
x1.i = p->y_prev_x.i;
}
else {
lv_sqrt(r2 - ((y - 1) * (y - 1)), &x1, sqrt_mask);
_lv_sqrt(r2 - ((y - 1) * (y - 1)), &x1, sqrt_mask);
}
lv_sqrt(r2 - (y * y), &x0, sqrt_mask);
_lv_sqrt(r2 - (y * y), &x0, sqrt_mask);
p->y_prev = y;
p->y_prev_x.f = x0.f;
p->y_prev_x.i = x0.i;
@@ -1036,13 +1036,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
return LV_DRAW_MASK_RES_TRANSP;
}
if(kl >= 0) {
lv_memset_00(&mask_buf[0], kl);
_lv_memset_00(&mask_buf[0], kl);
}
if(kr < 0) {
return LV_DRAW_MASK_RES_TRANSP;
}
if(kr <= len) {
lv_memset_00(&mask_buf[kr], len - kr);
_lv_memset_00(&mask_buf[kr], len - kr);
}
}
else {
@@ -1053,7 +1053,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
int32_t len_tmp = kr - first;
if(len_tmp + first > len) len_tmp = len - first;
if(first < len && len_tmp >= 0) {
lv_memset_00(&mask_buf[first], len_tmp);
_lv_memset_00(&mask_buf[first], len_tmp);
}
}
}
@@ -1070,7 +1070,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
int32_t len_tmp = kr - first;
if(len_tmp + first > len) len_tmp = len - first;
if(first < len && len_tmp >= 0) {
lv_memset_00(&mask_buf[first], len_tmp);
_lv_memset_00(&mask_buf[first], len_tmp);
}
}
@@ -1079,7 +1079,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
lv_sqrt_res_t y_prev;
lv_sqrt_res_t y_next;
lv_sqrt(r2 - (x0.i * x0.i), &y_prev, sqrt_mask);
_lv_sqrt(r2 - (x0.i * x0.i), &y_prev, sqrt_mask);
if(y_prev.f == 0) {
y_prev.i--;
@@ -1088,7 +1088,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
/*The first y intersection is special as it might be in the previous line*/
if(y_prev.i >= y) {
lv_sqrt(r2 - (i * i), &y_next, sqrt_mask);
_lv_sqrt(r2 - (i * i), &y_next, sqrt_mask);
m = 255 - (((255 - x0.f) * (255 - y_next.f)) >> 9);
if(outer) m = 255 - m;
@@ -1131,12 +1131,12 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
if(kl > len) {
return LV_DRAW_MASK_RES_TRANSP;
}
if(kl >= 0) lv_memset_00(&mask_buf[0], kl);
if(kl >= 0) _lv_memset_00(&mask_buf[0], kl);
if(kr < 0) {
return LV_DRAW_MASK_RES_TRANSP;
}
if(kr < len) lv_memset_00(&mask_buf[kr], len - kr);
if(kr < len) _lv_memset_00(&mask_buf[kr], len - kr);
}
}
}
src/lv_draw/lv_draw_rect.c
+97 -98
View File
File diff suppressed because it is too large Load Diff
src/lv_draw/lv_draw_triangle.c
+3 -3
View File
@@ -71,7 +71,7 @@ void lv_draw_polygon(const lv_point_t points[], uint16_t point_cnt, const lv_are
bool is_common;
lv_area_t poly_mask;
is_common = lv_area_intersect(&poly_mask, &poly_coords, clip_area);
is_common = _lv_area_intersect(&poly_mask, &poly_coords, clip_area);
if(!is_common) return;
/*Find the lowest point*/
@@ -85,7 +85,7 @@ void lv_draw_polygon(const lv_point_t points[], uint16_t point_cnt, const lv_are
}
}
lv_draw_mask_line_param_t * mp = lv_mem_buf_get(sizeof(lv_draw_mask_line_param_t) * point_cnt);
lv_draw_mask_line_param_t * mp = _lv_mem_buf_get(sizeof(lv_draw_mask_line_param_t) * point_cnt);
lv_draw_mask_line_param_t * mp_next = mp;
int32_t i_prev_left = y_min_i;
@@ -156,7 +156,7 @@ void lv_draw_polygon(const lv_point_t points[], uint16_t point_cnt, const lv_are
lv_draw_mask_remove_custom(mp);
lv_mem_buf_release(mp);
_lv_mem_buf_release(mp);
}
src/lv_draw/lv_img_buf.c
+19 -19
View File
@@ -58,7 +58,7 @@ lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t
dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3;
uint32_t px = dsc->header.w * y * px_size + x * px_size;
lv_memcpy_small(&p_color, &buf_u8[px], sizeof(lv_color_t));
_lv_memcpy_small(&p_color, &buf_u8[px], sizeof(lv_color_t));
#if LV_COLOR_SIZE == 32
p_color.ch.alpha = 0xFF; /*Only the color should be get so use a deafult alpha value*/
#endif
@@ -245,12 +245,12 @@ void lv_img_buf_set_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_
if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) {
uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3;
uint32_t px = dsc->header.w * y * px_size + x * px_size;
lv_memcpy_small(&buf_u8[px], &c, px_size);
_lv_memcpy_small(&buf_u8[px], &c, px_size);
}
else if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3;
uint32_t px = dsc->header.w * y * px_size + x * px_size;
lv_memcpy_small(&buf_u8[px], &c, px_size - 1); /*-1 to not overwrite the alpha value*/
_lv_memcpy_small(&buf_u8[px], &c, px_size - 1); /*-1 to not overwrite the alpha value*/
}
else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) {
buf_u8 += sizeof(lv_color32_t) * 2; /*Skip the palette*/
@@ -318,7 +318,7 @@ void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c)
lv_color32_t c32;
c32.full = lv_color_to32(c);
uint8_t * buf = (uint8_t *)dsc->data;
lv_memcpy_small(&buf[id * sizeof(c32)], &c32, sizeof(c32));
_lv_memcpy_small(&buf[id * sizeof(c32)], &c32, sizeof(c32));
}
/**
@@ -335,7 +335,7 @@ lv_img_dsc_t * lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
if(dsc == NULL)
return NULL;
lv_memset_00(dsc, sizeof(lv_img_dsc_t));
_lv_memset_00(dsc, sizeof(lv_img_dsc_t));
/* Get image data size */
dsc->data_size = lv_img_buf_get_img_size(w, h, cf);
@@ -350,7 +350,7 @@ lv_img_dsc_t * lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
lv_mem_free(dsc);
return NULL;
}
lv_memset_00((uint8_t *)dsc->data, dsc->data_size);
_lv_memset_00((uint8_t *)dsc->data, dsc->data_size);
/* Fill in header */
dsc->header.always_zero = 0;
@@ -417,7 +417,7 @@ uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
* Initialize a descriptor to tranform an image
* @param dsc pointer to an `lv_img_transform_dsc_t` variable whose `cfg` field is initialized
*/
void lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc)
void _lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc)
{
dsc->tmp.pivot_x_256 = dsc->cfg.pivot_x * 256;
dsc->tmp.pivot_y_256 = dsc->cfg.pivot_y * 256;
@@ -426,11 +426,11 @@ void lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc)
int32_t angle_hight = angle_low + 1;
int32_t angle_rem = dsc->cfg.angle - (angle_low * 10);
int32_t s1 = lv_trigo_sin(-angle_low);
int32_t s2 = lv_trigo_sin(-angle_hight);
int32_t s1 = _lv_trigo_sin(-angle_low);
int32_t s2 = _lv_trigo_sin(-angle_hight);
int32_t c1 = lv_trigo_sin(-angle_low + 90);
int32_t c2 = lv_trigo_sin(-angle_hight + 90);
int32_t c1 = _lv_trigo_sin(-angle_low + 90);
int32_t c2 = _lv_trigo_sin(-angle_hight + 90);
dsc->tmp.sinma = (s1 * (10 - angle_rem) + s2 * angle_rem) / 10;
dsc->tmp.cosma = (c1 * (10 - angle_rem) + c2 * angle_rem) / 10;
@@ -467,7 +467,7 @@ void lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc)
* @param zoom zoom, (256 no zoom)
* @param pivot x,y pivot coordinates of rotation
*/
void lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h, int16_t angle, uint16_t zoom,
void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h, int16_t angle, uint16_t zoom,
lv_point_t * pivot)
{
#if LV_USE_IMG_TRANSFORM
@@ -475,11 +475,11 @@ void lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h
int32_t angle_hight = angle_low + 1;
int32_t angle_rem = angle - (angle_low * 10);
int32_t s1 = lv_trigo_sin(angle_low);
int32_t s2 = lv_trigo_sin(angle_hight);
int32_t s1 = _lv_trigo_sin(angle_low);
int32_t s2 = _lv_trigo_sin(angle_hight);
int32_t c1 = lv_trigo_sin(angle_low + 90);
int32_t c2 = lv_trigo_sin(angle_hight + 90);
int32_t c1 = _lv_trigo_sin(angle_low + 90);
int32_t c2 = _lv_trigo_sin(angle_hight + 90);
int32_t sinma = (s1 * (10 - angle_rem) + s2 * angle_rem) / 10;
int32_t cosma = (c1 * (10 - angle_rem) + c2 * angle_rem) / 10;
@@ -591,9 +591,9 @@ bool _lv_img_buf_transform_anti_alias(lv_img_transform_dsc_t * dsc)
lv_opa_t a11 = 0;
if(dsc->tmp.native_color) {
lv_memcpy_small(&c01, &src_u8[dsc->tmp.pxi + dsc->tmp.px_size * xn], sizeof(lv_color_t));
lv_memcpy_small(&c10, &src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn], sizeof(lv_color_t));
lv_memcpy_small(&c11, &src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn + dsc->tmp.px_size * xn],
_lv_memcpy_small(&c01, &src_u8[dsc->tmp.pxi + dsc->tmp.px_size * xn], sizeof(lv_color_t));
_lv_memcpy_small(&c10, &src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn], sizeof(lv_color_t));
_lv_memcpy_small(&c11, &src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn + dsc->tmp.px_size * xn],
sizeof(lv_color_t));
if(dsc->tmp.has_alpha) {
a10 = src_u8[dsc->tmp.pxi + dsc->tmp.px_size * xn + dsc->tmp.px_size - 1];
src/lv_draw/lv_img_buf.h
+5 -6
View File
@@ -30,7 +30,6 @@ extern "C" {
#define LV_IMG_PX_SIZE_ALPHA_BYTE 4
#endif
#define LV_IMG_BUF_SIZE_TRUE_COLOR(w, h) ((LV_COLOR_SIZE / 8) * w * h)
#define LV_IMG_BUF_SIZE_TRUE_COLOR_CHROMA_KEYED(w, h) ((LV_COLOR_SIZE / 8) * w * h)
#define LV_IMG_BUF_SIZE_TRUE_COLOR_ALPHA(w, h) (LV_IMG_PX_SIZE_ALPHA_BYTE * w * h)
@@ -257,7 +256,7 @@ uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf);
* Initialize a descriptor to rotate an image
* @param dsc pointer to an `lv_img_transform_dsc_t` variable whose `cfg` field is initialized
*/
void lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc);
void _lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc);
/**
* Continue transformation by taking the neighbors into account
@@ -274,7 +273,7 @@ bool _lv_img_buf_transform_anti_alias(lv_img_transform_dsc_t * dsc);
* @return true: there is valid pixel on these x/y coordinates; false: the rotated pixel was out of the image
* @note the result is written back to `dsc->res_color` and `dsc->res_opa`
*/
static inline bool lv_img_buf_transform(lv_img_transform_dsc_t * dsc, lv_coord_t x, lv_coord_t y)
static inline bool _lv_img_buf_transform(lv_img_transform_dsc_t * dsc, lv_coord_t x, lv_coord_t y)
{
const uint8_t * src_u8 = dsc->cfg.src;
@@ -318,12 +317,12 @@ static inline bool lv_img_buf_transform(lv_img_transform_dsc_t * dsc, lv_coord_t
px_size = LV_COLOR_SIZE >> 3;
pxi = dsc->cfg.src_w * ys_int * px_size + xs_int * px_size;
lv_memcpy_small(&dsc->res.color, &src_u8[pxi], px_size);
_lv_memcpy_small(&dsc->res.color, &src_u8[pxi], px_size);
}
else {
px_size = LV_IMG_PX_SIZE_ALPHA_BYTE;
pxi = dsc->cfg.src_w * ys_int * px_size + xs_int * px_size;
lv_memcpy_small(&dsc->res.color, &src_u8[pxi], px_size - 1);
_lv_memcpy_small(&dsc->res.color, &src_u8[pxi], px_size - 1);
dsc->res.opa = src_u8[pxi + px_size - 1];
}
}
@@ -363,7 +362,7 @@ static inline bool lv_img_buf_transform(lv_img_transform_dsc_t * dsc, lv_coord_t
* @param zoom zoom, (256 no zoom)
* @param pivot x,y pivot coordinates of rotation
*/
void lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h, int16_t angle, uint16_t zoom,
void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h, int16_t angle, uint16_t zoom,
lv_point_t * pivot);
/**********************
src/lv_draw/lv_img_cache.c
+7 -7
View File
@@ -62,7 +62,7 @@ static uint16_t entry_cnt;
* @param style style of the image
* @return pointer to the cache entry or NULL if can open the image
*/
lv_img_cache_entry_t * lv_img_cache_open(const void * src, lv_color_t color)
lv_img_cache_entry_t * _lv_img_cache_open(const void * src, lv_color_t color)
{
if(entry_cnt == 0) {
LV_LOG_WARN("lv_img_cache_open: the cache size is 0");
@@ -130,8 +130,8 @@ lv_img_cache_entry_t * lv_img_cache_open(const void * src, lv_color_t color)
if(open_res == LV_RES_INV) {
LV_LOG_WARN("Image draw cannot open the image resource");
lv_img_decoder_close(&cached_src->dec_dsc);
lv_memset_00(&cached_src->dec_dsc, sizeof(lv_img_decoder_dsc_t));
lv_memset_00(cached_src, sizeof(lv_img_cache_entry_t));
_lv_memset_00(&cached_src->dec_dsc, sizeof(lv_img_decoder_dsc_t));
_lv_memset_00(cached_src, sizeof(lv_img_cache_entry_t));
cached_src->life = INT32_MIN; /*Make the empty entry very "weak" to force its use */
return NULL;
}
@@ -175,8 +175,8 @@ void lv_img_cache_set_size(uint16_t new_entry_cnt)
/*Clean the cache*/
uint16_t i;
for(i = 0; i < entry_cnt; i++) {
lv_memset_00(&LV_GC_ROOT(_lv_img_cache_array)[i].dec_dsc, sizeof(lv_img_decoder_dsc_t));
lv_memset_00(&LV_GC_ROOT(_lv_img_cache_array)[i], sizeof(lv_img_cache_entry_t));
_lv_memset_00(&LV_GC_ROOT(_lv_img_cache_array)[i].dec_dsc, sizeof(lv_img_decoder_dsc_t));
_lv_memset_00(&LV_GC_ROOT(_lv_img_cache_array)[i], sizeof(lv_img_cache_entry_t));
}
}
@@ -197,8 +197,8 @@ void lv_img_cache_invalidate_src(const void * src)
lv_img_decoder_close(&cache[i].dec_dsc);
}
lv_memset_00(&cache[i].dec_dsc, sizeof(lv_img_decoder_dsc_t));
lv_memset_00(&cache[i], sizeof(lv_img_cache_entry_t));
_lv_memset_00(&cache[i].dec_dsc, sizeof(lv_img_decoder_dsc_t));
_lv_memset_00(&cache[i], sizeof(lv_img_cache_entry_t));
}
}
}
src/lv_draw/lv_img_cache.h
+1 -1
View File
@@ -49,7 +49,7 @@ typedef struct {
* @param style style of the image
* @return pointer to the cache entry or NULL if can open the image
*/
lv_img_cache_entry_t * lv_img_cache_open(const void * src, lv_color_t color);
lv_img_cache_entry_t * _lv_img_cache_open(const void * src, lv_color_t color);
/**
* Set the number of images to be cached.
src/lv_draw/lv_img_decoder.c
+15 -15
View File
@@ -59,9 +59,9 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
/**
* Initialize the image decoder module
* */
void lv_img_decoder_init(void)
void _lv_img_decoder_init(void)
{
lv_ll_init(&LV_GC_ROOT(_lv_img_defoder_ll), sizeof(lv_img_decoder_t));
_lv_ll_init(&LV_GC_ROOT(_lv_img_defoder_ll), sizeof(lv_img_decoder_t));
lv_img_decoder_t * decoder;
@@ -92,7 +92,7 @@ lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
lv_res_t res = LV_RES_INV;
lv_img_decoder_t * d;
LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d) {
_LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d) {
res = LV_RES_INV;
if(d->info_cb) {
res = d->info_cb(d, src, header);
@@ -133,7 +133,7 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co
lv_res_t res = LV_RES_INV;
lv_img_decoder_t * d;
LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d) {
_LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d) {
/*Info an Open callbacks are required*/
if(d->info_cb == NULL || d->open_cb == NULL) continue;
@@ -151,7 +151,7 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co
}
if(res == LV_RES_INV) {
lv_memset_00(dsc, sizeof(lv_img_decoder_dsc_t));
_lv_memset_00(dsc, sizeof(lv_img_decoder_dsc_t));
}
return res;
@@ -197,11 +197,11 @@ void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc)
lv_img_decoder_t * lv_img_decoder_create(void)
{
lv_img_decoder_t * decoder;
decoder = lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll));
decoder = _lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll));
LV_ASSERT_MEM(decoder);
if(decoder == NULL) return NULL;
lv_memset_00(decoder, sizeof(lv_img_decoder_t));
_lv_memset_00(decoder, sizeof(lv_img_decoder_t));
return decoder;
}
@@ -212,7 +212,7 @@ lv_img_decoder_t * lv_img_decoder_create(void)
*/
void lv_img_decoder_delete(lv_img_decoder_t * decoder)
{
lv_ll_remove(&LV_GC_ROOT(_lv_img_defoder_ll), decoder);
_lv_ll_remove(&LV_GC_ROOT(_lv_img_defoder_ll), decoder);
lv_mem_free(decoder);
}
@@ -341,7 +341,7 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
return LV_RES_INV;
}
lv_memset_00(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t));
_lv_memset_00(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t));
}
lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
@@ -353,7 +353,7 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
return LV_RES_INV;
}
lv_memcpy_small(user_data->f, &f, sizeof(f));
_lv_memcpy_small(user_data->f, &f, sizeof(f));
#else
LV_LOG_WARN("Image built-in decoder cannot read file because LV_USE_FILESYSTEM = 0");
@@ -399,7 +399,7 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
lv_img_decoder_built_in_close(decoder, dsc);
return LV_RES_INV;
}
lv_memset_00(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t));
_lv_memset_00(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t));
}
lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
@@ -639,7 +639,7 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
#if LV_USE_FILESYSTEM
lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
uint8_t * fs_buf = lv_mem_buf_get(w);
uint8_t * fs_buf = _lv_mem_buf_get(w);
#endif
const uint8_t * data_tmp = NULL;
@@ -673,7 +673,7 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
}
}
#if LV_USE_FILESYSTEM
lv_mem_buf_release(fs_buf);
_lv_mem_buf_release(fs_buf);
#endif
return LV_RES_OK;
@@ -727,7 +727,7 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
#if LV_USE_FILESYSTEM
uint8_t * fs_buf = lv_mem_buf_get(w);
uint8_t * fs_buf = _lv_mem_buf_get(w);
#endif
const uint8_t * data_tmp = NULL;
if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
@@ -771,7 +771,7 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
}
}
#if LV_USE_FILESYSTEM
lv_mem_buf_release(fs_buf);
_lv_mem_buf_release(fs_buf);
#endif
return LV_RES_OK;
#else
src/lv_draw/lv_img_decoder.h
+1 -3
View File
@@ -135,7 +135,7 @@ typedef struct _lv_img_decoder_dsc {
/**
* Initialize the image decoder module
*/
void lv_img_decoder_init(void);
void _lv_img_decoder_init(void);
/**
* Get information about an image.
@@ -221,8 +221,6 @@ void lv_img_decoder_set_read_line_cb(lv_img_decoder_t * decoder, lv_img_decoder_
*/
void lv_img_decoder_set_close_cb(lv_img_decoder_t * decoder, lv_img_decoder_close_f_t close_cb);
/**
* Get info about a built-in image
* @param decoder the decoder where this function belongs
src/lv_font/lv_font_fmt_txt.c
+10 -10
View File
@@ -101,7 +101,7 @@ const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t unic
case 4: buf_size = (gsize + 1) >> 1; break;
}
if(lv_mem_get_size(decompr_buf) < buf_size) {
if(_lv_mem_get_size(decompr_buf) < buf_size) {
decompr_buf = lv_mem_realloc(decompr_buf, buf_size);
LV_ASSERT_MEM(decompr_buf);
if(decompr_buf == NULL) return NULL;
@@ -169,7 +169,7 @@ bool lv_font_get_glyph_dsc_fmt_txt(const lv_font_t * font, lv_font_glyph_dsc_t *
/**
* Free the allocated memories.
*/
void lv_font_clean_up_fmt_txt(void)
void _lv_font_clean_up_fmt_txt(void)
{
if(decompr_buf) {
lv_mem_free(decompr_buf);
@@ -206,7 +206,7 @@ static uint32_t get_glyph_dsc_id(const lv_font_t * font, uint32_t letter)
glyph_id = fdsc->cmaps[i].glyph_id_start + gid_ofs_8[rcp];
}
else if(fdsc->cmaps[i].type == LV_FONT_FMT_TXT_CMAP_SPARSE_TINY) {
uint8_t * p = lv_utils_bsearch(&rcp, fdsc->cmaps[i].unicode_list, fdsc->cmaps[i].list_length,
uint8_t * p = _lv_utils_bsearch(&rcp, fdsc->cmaps[i].unicode_list, fdsc->cmaps[i].list_length,
sizeof(fdsc->cmaps[i].unicode_list[0]), unicode_list_compare);
if(p) {
@@ -216,7 +216,7 @@ static uint32_t get_glyph_dsc_id(const lv_font_t * font, uint32_t letter)
}
}
else if(fdsc->cmaps[i].type == LV_FONT_FMT_TXT_CMAP_SPARSE_FULL) {
uint8_t * p = lv_utils_bsearch(&rcp, fdsc->cmaps[i].unicode_list, fdsc->cmaps[i].list_length,
uint8_t * p = _lv_utils_bsearch(&rcp, fdsc->cmaps[i].unicode_list, fdsc->cmaps[i].list_length,
sizeof(fdsc->cmaps[i].unicode_list[0]), unicode_list_compare);
if(p) {
@@ -253,7 +253,7 @@ static int8_t get_kern_value(const lv_font_t * font, uint32_t gid_left, uint32_t
* The pairs are ordered left_id first, then right_id secondly. */
const uint8_t * g_ids = kdsc->glyph_ids;
uint16_t g_id_both = (gid_right << 8) + gid_left; /*Create one number from the ids*/
uint8_t * kid_p = lv_utils_bsearch(&g_id_both, g_ids, kdsc->pair_cnt, 2, kern_pair_8_compare);
uint8_t * kid_p = _lv_utils_bsearch(&g_id_both, g_ids, kdsc->pair_cnt, 2, kern_pair_8_compare);
/*If the `g_id_both` were found get its index from the pointer*/
if(kid_p) {
@@ -267,7 +267,7 @@ static int8_t get_kern_value(const lv_font_t * font, uint32_t gid_left, uint32_t
* The pairs are ordered left_id first, then right_id secondly. */
const uint16_t * g_ids = kdsc->glyph_ids;
lv_uintptr_t g_id_both = (uint32_t)((uint32_t)gid_right << 8) + gid_left; /*Create one number from the ids*/
uint8_t * kid_p = lv_utils_bsearch(&g_id_both, g_ids, kdsc->pair_cnt, 4, kern_pair_16_compare);
uint8_t * kid_p = _lv_utils_bsearch(&g_id_both, g_ids, kdsc->pair_cnt, 4, kern_pair_16_compare);
/*If the `g_id_both` were found get its index from the pointer*/
if(kid_p) {
@@ -333,8 +333,8 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord
rle_init(in, bpp);
uint8_t * line_buf1 = lv_mem_buf_get(w);
uint8_t * line_buf2 = lv_mem_buf_get(w);
uint8_t * line_buf1 = _lv_mem_buf_get(w);
uint8_t * line_buf2 = _lv_mem_buf_get(w);
decompress_line(line_buf1, w);
@@ -356,8 +356,8 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord
}
}
lv_mem_buf_release(line_buf1);
lv_mem_buf_release(line_buf2);
_lv_mem_buf_release(line_buf1);
_lv_mem_buf_release(line_buf2);
}
/**
src/lv_font/lv_font_fmt_txt.h
+1 -1
View File
@@ -221,7 +221,7 @@ bool lv_font_get_glyph_dsc_fmt_txt(const lv_font_t * font, lv_font_glyph_dsc_t *
/**
* Free the allocated memories.
*/
void lv_font_clean_up_fmt_txt(void);
void _lv_font_clean_up_fmt_txt(void);
/**********************
* MACROS
src/lv_hal/lv_hal_disp.c
+14 -14
View File
@@ -56,7 +56,7 @@ static lv_disp_t * disp_def;
*/
void lv_disp_drv_init(lv_disp_drv_t * driver)
{
lv_memset_00(driver, sizeof(lv_disp_drv_t));
_lv_memset_00(driver, sizeof(lv_disp_drv_t));
driver->flush_cb = NULL;
driver->hor_res = LV_HOR_RES_MAX;
@@ -103,7 +103,7 @@ void lv_disp_drv_init(lv_disp_drv_t * driver)
*/
void lv_disp_buf_init(lv_disp_buf_t * disp_buf, void * buf1, void * buf2, uint32_t size_in_px_cnt)
{
lv_memset_00(disp_buf, sizeof(lv_disp_buf_t));
_lv_memset_00(disp_buf, sizeof(lv_disp_buf_t));
disp_buf->buf1 = buf1;
disp_buf->buf2 = buf2;
@@ -119,16 +119,16 @@ void lv_disp_buf_init(lv_disp_buf_t * disp_buf, void * buf1, void * buf2, uint32
*/
lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
{
lv_disp_t * disp = lv_ll_ins_head(&LV_GC_ROOT(_lv_disp_ll));
lv_disp_t * disp = _lv_ll_ins_head(&LV_GC_ROOT(_lv_disp_ll));
if(!disp) {
LV_ASSERT_MEM(disp);
return NULL;
}
lv_memset_00(disp, sizeof(lv_disp_t));
lv_memcpy(&disp->driver, driver, sizeof(lv_disp_drv_t));
_lv_memset_00(disp, sizeof(lv_disp_t));
_lv_memcpy(&disp->driver, driver, sizeof(lv_disp_drv_t));
lv_ll_init(&disp->scr_ll, sizeof(lv_obj_t));
_lv_ll_init(&disp->scr_ll, sizeof(lv_obj_t));
disp->last_activity_time = 0;
if(disp_def == NULL) disp_def = disp;
@@ -137,7 +137,7 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
disp_def = disp; /*Temporarily change the default screen to create the default screens on the
new display*/
/*Create a refresh task*/
disp->refr_task = lv_task_create(lv_disp_refr_task, LV_DISP_DEF_REFR_PERIOD, LV_REFR_TASK_PRIO, disp);
disp->refr_task = lv_task_create(_lv_disp_refr_task, LV_DISP_DEF_REFR_PERIOD, LV_REFR_TASK_PRIO, disp);
LV_ASSERT_MEM(disp->refr_task);
if(disp->refr_task == NULL) return NULL;
@@ -171,7 +171,7 @@ void lv_disp_drv_update(lv_disp_t * disp, lv_disp_drv_t * new_drv)
memcpy(&disp->driver, new_drv, sizeof(lv_disp_drv_t));
lv_obj_t * scr;
LV_LL_READ(disp->scr_ll, scr) {
_LV_LL_READ(disp->scr_ll, scr) {
lv_obj_set_size(scr, lv_disp_get_hor_res(disp), lv_disp_get_ver_res(disp));
}
}
@@ -195,10 +195,10 @@ void lv_disp_remove(lv_disp_t * disp)
indev = lv_indev_get_next(indev);
}
lv_ll_remove(&LV_GC_ROOT(_lv_disp_ll), disp);
_lv_ll_remove(&LV_GC_ROOT(_lv_disp_ll), disp);
lv_mem_free(disp);
if(was_default) lv_disp_set_default(lv_ll_get_head(&LV_GC_ROOT(_lv_disp_ll)));
if(was_default) lv_disp_set_default(_lv_ll_get_head(&LV_GC_ROOT(_lv_disp_ll)));
}
/**
@@ -305,7 +305,7 @@ LV_ATTRIBUTE_FLUSH_READY void lv_disp_flush_ready(lv_disp_drv_t * disp_drv)
/*If the screen is transparent initialize it when the flushing is ready*/
#if LV_COLOR_SCREEN_TRANSP
if(disp_drv->screen_transp) {
lv_memset_00(disp_drv->buffer->buf_act, disp_drv->buffer->size * sizeof(lv_color32_t));
_lv_memset_00(disp_drv->buffer->buf_act, disp_drv->buffer->size * sizeof(lv_color32_t));
}
#endif
@@ -333,9 +333,9 @@ LV_ATTRIBUTE_FLUSH_READY bool lv_disp_flush_is_last(lv_disp_drv_t * disp_drv)
lv_disp_t * lv_disp_get_next(lv_disp_t * disp)
{
if(disp == NULL)
return lv_ll_get_head(&LV_GC_ROOT(_lv_disp_ll));
return _lv_ll_get_head(&LV_GC_ROOT(_lv_disp_ll));
else
return lv_ll_get_next(&LV_GC_ROOT(_lv_disp_ll), disp);
return _lv_ll_get_next(&LV_GC_ROOT(_lv_disp_ll), disp);
}
/**
@@ -361,7 +361,7 @@ uint16_t lv_disp_get_inv_buf_size(lv_disp_t * disp)
* Pop (delete) the last 'num' invalidated areas from the buffer
* @param num number of areas to delete
*/
void lv_disp_pop_from_inv_buf(lv_disp_t * disp, uint16_t num)
void _lv_disp_pop_from_inv_buf(lv_disp_t * disp, uint16_t num)
{
if(disp->inv_p < num)
src/lv_hal/lv_hal_disp.h
+1 -1
View File
@@ -306,7 +306,7 @@ uint16_t lv_disp_get_inv_buf_size(lv_disp_t * disp);
* Pop (delete) the last 'num' invalidated areas from the buffer
* @param num number of areas to delete
*/
void lv_disp_pop_from_inv_buf(lv_disp_t * disp, uint16_t num);
void _lv_disp_pop_from_inv_buf(lv_disp_t * disp, uint16_t num);
/**
* Check the driver configuration if it's double buffered (both `buf1` and `buf2` are set)
src/lv_hal/lv_hal_indev.c
+9 -9
View File
@@ -51,7 +51,7 @@
*/
void lv_indev_drv_init(lv_indev_drv_t * driver)
{
lv_memset_00(driver, sizeof(lv_indev_drv_t));
_lv_memset_00(driver, sizeof(lv_indev_drv_t));
driver->type = LV_INDEV_TYPE_NONE;
driver->drag_limit = LV_INDEV_DEF_DRAG_LIMIT;
@@ -78,21 +78,21 @@ lv_indev_t * lv_indev_drv_register(lv_indev_drv_t * driver)
return NULL;
}
lv_indev_t * indev = lv_ll_ins_head(&LV_GC_ROOT(_lv_indev_ll));
lv_indev_t * indev = _lv_ll_ins_head(&LV_GC_ROOT(_lv_indev_ll));
if(!indev) {
LV_ASSERT_MEM(indev);
return NULL;
}
lv_memset_00(indev, sizeof(lv_indev_t));
lv_memcpy(&indev->driver, driver, sizeof(lv_indev_drv_t));
_lv_memset_00(indev, sizeof(lv_indev_t));
_lv_memcpy(&indev->driver, driver, sizeof(lv_indev_drv_t));
indev->proc.reset_query = 1;
indev->cursor = NULL;
indev->group = NULL;
indev->btn_points = NULL;
indev->driver.read_task = lv_task_create(lv_indev_read_task, LV_INDEV_DEF_READ_PERIOD, LV_TASK_PRIO_HIGH, indev);
indev->driver.read_task = lv_task_create(_lv_indev_read_task, LV_INDEV_DEF_READ_PERIOD, LV_TASK_PRIO_HIGH, indev);
return indev;
}
@@ -116,9 +116,9 @@ void lv_indev_drv_update(lv_indev_t * indev, lv_indev_drv_t * new_drv)
lv_indev_t * lv_indev_get_next(lv_indev_t * indev)
{
if(indev == NULL)
return lv_ll_get_head(&LV_GC_ROOT(_lv_indev_ll));
return _lv_ll_get_head(&LV_GC_ROOT(_lv_indev_ll));
else
return lv_ll_get_next(&LV_GC_ROOT(_lv_indev_ll), indev);
return _lv_ll_get_next(&LV_GC_ROOT(_lv_indev_ll), indev);
}
/**
@@ -127,11 +127,11 @@ lv_indev_t * lv_indev_get_next(lv_indev_t * indev)
* @param data input device will write its data here
* @return false: no more data; true: there more data to read (buffered)
*/
bool lv_indev_read(lv_indev_t * indev, lv_indev_data_t * data)
bool _lv_indev_read(lv_indev_t * indev, lv_indev_data_t * data)
{
bool cont = false;
lv_memset_00(data, sizeof(lv_indev_data_t));
_lv_memset_00(data, sizeof(lv_indev_data_t));
/* For touchpad sometimes users don't the last pressed coordinate on release.
* So be sure a coordinates are initialized to the last point */
src/lv_hal/lv_hal_indev.h
+1 -1
View File
@@ -220,7 +220,7 @@ lv_indev_t * lv_indev_get_next(lv_indev_t * indev);
* @param data input device will write its data here
* @return false: no more data; true: there more data to read (buffered)
*/
bool lv_indev_read(lv_indev_t * indev, lv_indev_data_t * data);
bool _lv_indev_read(lv_indev_t * indev, lv_indev_data_t * data);
/**********************
* MACROS
src/lv_misc/lv_anim.c
+24 -24
View File
@@ -58,9 +58,9 @@ const lv_anim_path_t lv_anim_path_def = {.cb = lv_anim_path_linear};
/**
* Init. the animation module
*/
void lv_anim_core_init(void)
void _lv_anim_core_init(void)
{
lv_ll_init(&LV_GC_ROOT(_lv_anim_ll), sizeof(lv_anim_t));
_lv_ll_init(&LV_GC_ROOT(_lv_anim_ll), sizeof(lv_anim_t));
last_task_run = lv_tick_get();
_lv_anim_task = lv_task_create(anim_task, LV_DISP_DEF_REFR_PERIOD, LV_ANIM_TASK_PRIO, NULL);
anim_mark_list_change(); /*Turn off the animation task*/
@@ -78,11 +78,11 @@ void lv_anim_core_init(void)
*/
void lv_anim_init(lv_anim_t * a)
{
lv_memset_00(a, sizeof(lv_anim_t));
_lv_memset_00(a, sizeof(lv_anim_t));
a->time = 500;
a->start = 0;
a->end = 100;
lv_memcpy_small(&a->path, &lv_anim_path_def, sizeof(lv_anim_path_cb_t));
_lv_memcpy_small(&a->path, &lv_anim_path_def, sizeof(lv_anim_path_cb_t));
a->repeat_cnt = 1;
a->early_apply = 1;
}
@@ -97,18 +97,18 @@ void lv_anim_start(lv_anim_t * a)
if(a->exec_cb != NULL) lv_anim_del(a->var, a->exec_cb); /*fp == NULL would delete all animations of var*/
/*If the list is empty the anim task was suspended and it's last run measure is invalid*/
if(lv_ll_is_empty(&LV_GC_ROOT(_lv_anim_ll))) {
if(_lv_ll_is_empty(&LV_GC_ROOT(_lv_anim_ll))) {
last_task_run = lv_tick_get() - 1;
}
/*Add the new animation to the animation linked list*/
lv_anim_t * new_anim = lv_ll_ins_head(&LV_GC_ROOT(_lv_anim_ll));
lv_anim_t * new_anim = _lv_ll_ins_head(&LV_GC_ROOT(_lv_anim_ll));
LV_ASSERT_MEM(new_anim);
if(new_anim == NULL) return;
/*Initialize the animation descriptor*/
a->time_orig = a->time;
lv_memcpy(new_anim, a, sizeof(lv_anim_t));
_lv_memcpy(new_anim, a, sizeof(lv_anim_t));
/*Set the start value*/
if(new_anim->early_apply) {
@@ -134,13 +134,13 @@ bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb)
lv_anim_t * a;
lv_anim_t * a_next;
bool del = false;
a = lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
a = _lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
while(a != NULL) {
/*'a' might be deleted, so get the next object while 'a' is valid*/
a_next = lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a);
a_next = _lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a);
if(a->var == var && (a->exec_cb == exec_cb || exec_cb == NULL)) {
lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a);
_lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a);
lv_mem_free(a);
anim_mark_list_change(); /*Read by `anim_task`. It need to know if a delete occurred in
the linked list*/
@@ -163,7 +163,7 @@ bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb)
lv_anim_t * lv_anim_get(void * var, lv_anim_exec_xcb_t exec_cb)
{
lv_anim_t * a;
LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) {
_LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) {
if(a->var == var && a->exec_cb == exec_cb) {
return a;
}
@@ -180,7 +180,7 @@ uint16_t lv_anim_count_running(void)
{
uint16_t cnt = 0;
lv_anim_t * a;
LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) cnt++;
_LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) cnt++;
return cnt;
}
@@ -257,7 +257,7 @@ lv_anim_value_t lv_anim_path_ease_in(const lv_anim_path_t * path, const lv_anim_
else
t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
int32_t step = lv_bezier3(t, 0, 1, 1, 1024);
int32_t step = _lv_bezier3(t, 0, 1, 1, 1024);
int32_t new_value;
new_value = (int32_t)step * (a->end - a->start);
@@ -282,7 +282,7 @@ lv_anim_value_t lv_anim_path_ease_out(const lv_anim_path_t * path, const lv_anim
else
t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
int32_t step = lv_bezier3(t, 0, 1023, 1023, 1024);
int32_t step = _lv_bezier3(t, 0, 1023, 1023, 1024);
int32_t new_value;
new_value = (int32_t)step * (a->end - a->start);
@@ -307,7 +307,7 @@ lv_anim_value_t lv_anim_path_ease_in_out(const lv_anim_path_t * path, const lv_a
else
t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
int32_t step = lv_bezier3(t, 0, 100, 924, 1024);
int32_t step = _lv_bezier3(t, 0, 100, 924, 1024);
int32_t new_value;
new_value = (int32_t)step * (a->end - a->start);
@@ -332,7 +332,7 @@ lv_anim_value_t lv_anim_path_overshoot(const lv_anim_path_t * path, const lv_ani
else
t = (uint32_t)((uint32_t)a->act_time * 1024) / a->time;
int32_t step = lv_bezier3(t, 0, 1000, 2000, 1024);
int32_t step = _lv_bezier3(t, 0, 1000, 2000, 1024);
int32_t new_value;
new_value = (int32_t)step * (a->end - a->start);
@@ -394,7 +394,7 @@ lv_anim_value_t lv_anim_path_bounce(const lv_anim_path_t * path, const lv_anim_t
if(t > 1024) t = 1024;
int32_t step = lv_bezier3(t, 1024, 1024, 800, 0);
int32_t step = _lv_bezier3(t, 1024, 1024, 800, 0);
int32_t new_value;
new_value = (int32_t)step * diff;
@@ -431,13 +431,13 @@ static void anim_task(lv_task_t * param)
(void)param;
lv_anim_t * a;
LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) {
_LV_LL_READ(LV_GC_ROOT(_lv_anim_ll), a) {
a->has_run = 0;
}
uint32_t elaps = lv_tick_elaps(last_task_run);
a = lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
a = _lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
while(a != NULL) {
/*It can be set by `lv_anim_del()` typically in `end_cb`. If set then an animation delete
@@ -475,9 +475,9 @@ static void anim_task(lv_task_t * param)
/* If the linked list changed due to anim. delete then it's not safe to continue
* the reading of the list from here -> start from the head*/
if(anim_list_changed)
a = lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
a = _lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll));
else
a = lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a);
a = _lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), a);
}
last_task_run = lv_tick_get();
@@ -504,8 +504,8 @@ static bool anim_ready_handler(lv_anim_t * a)
/*Create copy from the animation and delete the animation from the list.
* This way the `ready_cb` will see the animations like it's animation is ready deleted*/
lv_anim_t a_tmp;
lv_memcpy(&a_tmp, a, sizeof(lv_anim_t));
lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a);
_lv_memcpy(&a_tmp, a, sizeof(lv_anim_t));
_lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a);
lv_mem_free(a);
/*Flag that the list has changed */
anim_mark_list_change();
@@ -538,7 +538,7 @@ static bool anim_ready_handler(lv_anim_t * a)
static void anim_mark_list_change(void)
{
anim_list_changed = true;
if(lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)) == NULL)
if(_lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)) == NULL)
lv_task_set_prio(_lv_anim_task, LV_TASK_PRIO_OFF);
else
lv_task_set_prio(_lv_anim_task, LV_ANIM_TASK_PRIO);
src/lv_misc/lv_anim.h
+3 -3
View File
@@ -108,7 +108,7 @@ typedef struct _lv_anim_t {
/**
* Init. the animation module
*/
void lv_anim_core_init(void);
void _lv_anim_core_init(void);
/**
* Initialize an animation variable.
@@ -198,7 +198,7 @@ static inline void lv_anim_set_custom_exec_cb(lv_anim_t * a, lv_anim_custom_exec
*/
static inline void lv_anim_set_path(lv_anim_t * a, const lv_anim_path_t * path)
{
lv_memcpy_small(&a->path, path, sizeof(lv_anim_path_t));
_lv_memcpy_small(&a->path, path, sizeof(lv_anim_path_t));
}
@@ -274,7 +274,7 @@ void lv_anim_start(lv_anim_t * a);
*/
static inline void lv_anim_path_init(lv_anim_path_t * path)
{
lv_memset_00(path, sizeof(lv_anim_path_t));
_lv_memset_00(path, sizeof(lv_anim_path_t));
}
/**
src/lv_misc/lv_area.c
+15 -28
View File
@@ -79,7 +79,7 @@ void lv_area_set_height(lv_area_t * area_p, lv_coord_t h)
* @param x the new x coordinate of the area
* @param y the new y coordinate of the area
*/
void lv_area_set_pos(lv_area_t * area_p, lv_coord_t x, lv_coord_t y)
void _lv_area_set_pos(lv_area_t * area_p, lv_coord_t x, lv_coord_t y)
{
lv_coord_t w = lv_area_get_width(area_p);
lv_coord_t h = lv_area_get_height(area_p);
@@ -110,7 +110,7 @@ uint32_t lv_area_get_size(const lv_area_t * area_p)
* @param a2_p pointer to the second area
* @return false: the two area has NO common parts, res_p is invalid
*/
bool lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area_t * a2_p)
bool _lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area_t * a2_p)
{
/* Get the smaller area from 'a1_p' and 'a2_p' */
res_p->x1 = LV_MATH_MAX(a1_p->x1, a2_p->x1);
@@ -132,7 +132,7 @@ bool lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area_
* @param a1_p pointer to the first area
* @param a2_p pointer to the second area
*/
void lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t * a2_p)
void _lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t * a2_p)
{
a_res_p->x1 = LV_MATH_MIN(a1_p->x1, a2_p->x1);
a_res_p->y1 = LV_MATH_MIN(a1_p->y1, a2_p->y1);
@@ -147,7 +147,7 @@ void lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t *
* @param radius radius of area (e.g. for rounded rectangle)
* @return false:the point is out of the area
*/
bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord_t radius)
bool _lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord_t radius)
{
/*First check the basic area*/
bool is_on_rect = false;
@@ -174,7 +174,7 @@ bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord
corner_area.x2 = a_p->x1 + radius;
corner_area.y1 = a_p->y1;
corner_area.y2 = a_p->y1 + radius;
if(lv_area_is_point_on(&corner_area, p_p, 0)) {
if(_lv_area_is_point_on(&corner_area, p_p, 0)) {
corner_area.x2 += radius;
corner_area.y2 += radius;
return lv_point_within_circle(&corner_area, p_p);
@@ -182,7 +182,7 @@ bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord
/*Bottom left*/
corner_area.y1 = a_p->y2 - radius;
corner_area.y2 = a_p->y2;
if(lv_area_is_point_on(&corner_area, p_p, 0)) {
if(_lv_area_is_point_on(&corner_area, p_p, 0)) {
corner_area.x2 += radius;
corner_area.y1 -= radius;
return lv_point_within_circle(&corner_area, p_p);
@@ -190,7 +190,7 @@ bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord
/*Bottom right*/
corner_area.x1 = a_p->x2 - radius;
corner_area.x2 = a_p->x2;
if(lv_area_is_point_on(&corner_area, p_p, 0)) {
if(_lv_area_is_point_on(&corner_area, p_p, 0)) {
corner_area.x1 -= radius;
corner_area.y1 -= radius;
return lv_point_within_circle(&corner_area, p_p);
@@ -198,7 +198,7 @@ bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord
/*Top right*/
corner_area.y1 = a_p->y1;
corner_area.y2 = a_p->y1 + radius;
if(lv_area_is_point_on(&corner_area, p_p, 0)) {
if(_lv_area_is_point_on(&corner_area, p_p, 0)) {
corner_area.x1 -= radius;
corner_area.y2 += radius;
return lv_point_within_circle(&corner_area, p_p);
@@ -213,7 +213,7 @@ bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord
* @param a2_p pointer to an other area
* @return false: a1_p and a2_p has no common parts
*/
bool lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p)
bool _lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p)
{
if((a1_p->x1 <= a2_p->x2) && (a1_p->x2 >= a2_p->x1) && (a1_p->y1 <= a2_p->y2) && (a1_p->y2 >= a2_p->y1)) {
return true;
@@ -230,7 +230,7 @@ bool lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p)
* @param radius radius of `aholder_p` (e.g. for rounded rectangle)
* @return true: `ain_p` is fully inside `aholder_p`
*/
bool lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p, lv_coord_t radius)
bool _lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p, lv_coord_t radius)
{
bool is_in = false;
@@ -246,36 +246,23 @@ bool lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p, lv_coor
p.x = ain_p->x1;
p.y = ain_p->y1;
if(lv_area_is_point_on(aholder_p, &p, radius) == false) return false;
if(_lv_area_is_point_on(aholder_p, &p, radius) == false) return false;
p.x = ain_p->x2;
p.y = ain_p->y1;
if(lv_area_is_point_on(aholder_p, &p, radius) == false) return false;
if(_lv_area_is_point_on(aholder_p, &p, radius) == false) return false;
p.x = ain_p->x1;
p.y = ain_p->y2;
if(lv_area_is_point_on(aholder_p, &p, radius) == false) return false;
if(_lv_area_is_point_on(aholder_p, &p, radius) == false) return false;
p.x = ain_p->x2;
p.y = ain_p->y2;
if(lv_area_is_point_on(aholder_p, &p, radius) == false) return false;
if(_lv_area_is_point_on(aholder_p, &p, radius) == false) return false;
return true;
}
/**
* Increment or decrement an area's size by a single amount
* @param a_p pointer to an area to grow
* @param amount amount to increment the area, or negative to decrement
*/
void lv_area_increment(lv_area_t * a_p, const lv_coord_t amount)
{
a_p->x1 -= amount;
a_p->y1 -= amount;
a_p->x2 += amount;
a_p->y2 += amount;
}
/**
* Align an area to an other
* @param base an are where the other will be aligned
@@ -283,7 +270,7 @@ void lv_area_increment(lv_area_t * a_p, const lv_coord_t amount)
* @param align `LV_ALIGN_...`
* @param res x/y coordinates where `to_align` align area should be placed
*/
void lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align_t align, lv_point_t * res)
void _lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align_t align, lv_point_t * res)
{
switch(align) {
src/lv_misc/lv_area.h
+9 -14
View File
@@ -99,7 +99,7 @@ void lv_area_set(lv_area_t * area_p, lv_coord_t x1, lv_coord_t y1, lv_coord_t x2
*/
inline static void lv_area_copy(lv_area_t * dest, const lv_area_t * src)
{
lv_memcpy_small(dest, src, sizeof(lv_area_t));
_lv_memcpy_small(dest, src, sizeof(lv_area_t));
}
/**
@@ -142,7 +142,7 @@ void lv_area_set_height(lv_area_t * area_p, lv_coord_t h);
* @param x the new x coordinate of the area
* @param y the new y coordinate of the area
*/
void lv_area_set_pos(lv_area_t * area_p, lv_coord_t x, lv_coord_t y);
void _lv_area_set_pos(lv_area_t * area_p, lv_coord_t x, lv_coord_t y);
/**
* Return with area of an area (x * y)
@@ -158,7 +158,7 @@ uint32_t lv_area_get_size(const lv_area_t * area_p);
* @param a2_p pointer to the second area
* @return false: the two area has NO common parts, res_p is invalid
*/
bool lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area_t * a2_p);
bool _lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area_t * a2_p);
/**
* Join two areas into a third which involves the other two
@@ -166,7 +166,7 @@ bool lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area_
* @param a1_p pointer to the first area
* @param a2_p pointer to the second area
*/
void lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t * a2_p);
void _lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t * a2_p);
/**
* Check if a point is on an area
@@ -175,7 +175,7 @@ void lv_area_join(lv_area_t * a_res_p, const lv_area_t * a1_p, const lv_area_t *
* @param radius radius of area (e.g. for rounded rectangle)
* @return false:the point is out of the area
*/
bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord_t radius);
bool _lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord_t radius);
/**
* Check if two area has common parts
@@ -183,7 +183,7 @@ bool lv_area_is_point_on(const lv_area_t * a_p, const lv_point_t * p_p, lv_coord
* @param a2_p pointer to an other area
* @return false: a1_p and a2_p has no common parts
*/
bool lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p);
bool _lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p);
/**
* Check if an area is fully on an other
@@ -192,14 +192,8 @@ bool lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p);
* @param radius radius of `aholder_p` (e.g. for rounded rectangle)
* @return true: `ain_p` is fully inside `aholder_p`
*/
bool lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p, lv_coord_t radius);
bool _lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p, lv_coord_t radius);
/**
* Increment or decrement an area's size by a single amount
* @param a_p pointer to an area to grow
* @param amount amount to increment the area, or negative to decrement
*/
void lv_area_increment(lv_area_t * a_p, const lv_coord_t amount);
/**
* Align an area to an other
@@ -208,7 +202,8 @@ void lv_area_increment(lv_area_t * a_p, const lv_coord_t amount);
* @param align `LV_ALIGN_...`
* @param res x/y coordinates where `to_align` align area should be placed
*/
void lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align_t align, lv_point_t * res);
void _lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align_t align, lv_point_t * res);
/**********************
* MACROS
**********************/
src/lv_misc/lv_bidi.c
+44 -44
View File
@@ -74,9 +74,9 @@ static uint8_t br_stack_p;
* @param str_out store the result here. Has the be `strlen(str_in)` length
* @param base_dir `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL`
*/
void lv_bidi_process(const char * str_in, char * str_out, lv_bidi_dir_t base_dir)
void _lv_bidi_process(const char * str_in, char * str_out, lv_bidi_dir_t base_dir)
{
if(base_dir == LV_BIDI_DIR_AUTO) base_dir = lv_bidi_detect_base_dir(str_in);
if(base_dir == LV_BIDI_DIR_AUTO) base_dir = _lv_bidi_detect_base_dir(str_in);
uint32_t par_start = 0;
uint32_t par_len;
@@ -88,7 +88,7 @@ void lv_bidi_process(const char * str_in, char * str_out, lv_bidi_dir_t base_dir
while(str_in[par_start] != '\0') {
par_len = lv_bidi_get_next_paragraph(&str_in[par_start]);
lv_bidi_process_paragraph(&str_in[par_start], &str_out[par_start], par_len, base_dir, NULL, 0);
_lv_bidi_process_paragraph(&str_in[par_start], &str_out[par_start], par_len, base_dir, NULL, 0);
par_start += par_len;
while(str_in[par_start] == '\n' || str_in[par_start] == '\r') {
@@ -105,12 +105,12 @@ void lv_bidi_process(const char * str_in, char * str_out, lv_bidi_dir_t base_dir
* @param txt the text to process
* @return `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL`
*/
lv_bidi_dir_t lv_bidi_detect_base_dir(const char * txt)
lv_bidi_dir_t _lv_bidi_detect_base_dir(const char * txt)
{
uint32_t i = 0;
uint32_t letter;
while(txt[i] != '\0') {
letter = lv_txt_encoded_next(txt, &i);
letter = _lv_txt_encoded_next(txt, &i);
lv_bidi_dir_t dir;
dir = lv_bidi_get_letter_dir(letter);
@@ -134,28 +134,28 @@ lv_bidi_dir_t lv_bidi_detect_base_dir(const char * txt)
* @param is_rtl tell the the char at `viasual_pos` is RTL or LTR context
* @return the logical character position
*/
uint16_t lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t len, lv_bidi_dir_t base_dir,
uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t len, lv_bidi_dir_t base_dir,
uint32_t visual_pos, bool * is_rtl)
{
uint32_t pos_conv_len = get_txt_len(str_in, len);
char * buf = lv_mem_buf_get(len + 1);
char * buf = _lv_mem_buf_get(len + 1);
if(buf == NULL) return (uint16_t) -1;
uint16_t * pos_conv_buf = lv_mem_buf_get(pos_conv_len * sizeof(uint16_t));
uint16_t * pos_conv_buf = _lv_mem_buf_get(pos_conv_len * sizeof(uint16_t));
if(pos_conv_buf == NULL) {
lv_mem_buf_release(buf);
_lv_mem_buf_release(buf);
return (uint16_t) -1;
}
if(bidi_txt) *bidi_txt = buf;
lv_bidi_process_paragraph(str_in, bidi_txt ? *bidi_txt : NULL, len, base_dir, pos_conv_buf, pos_conv_len);
_lv_bidi_process_paragraph(str_in, bidi_txt ? *bidi_txt : NULL, len, base_dir, pos_conv_buf, pos_conv_len);
if(is_rtl) *is_rtl = IS_RTL_POS(pos_conv_buf[visual_pos]);
if(bidi_txt == NULL) lv_mem_buf_release(buf);
if(bidi_txt == NULL) _lv_mem_buf_release(buf);
uint16_t res = GET_POS(pos_conv_buf[visual_pos]);
lv_mem_buf_release(pos_conv_buf);
_lv_mem_buf_release(pos_conv_buf);
return res;
}
@@ -171,35 +171,35 @@ uint16_t lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t
* @param is_rtl tell the the char at `logical_pos` is RTL or LTR context
* @return the visual character position
*/
uint16_t lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t len, lv_bidi_dir_t base_dir,
uint16_t _lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t len, lv_bidi_dir_t base_dir,
uint32_t logical_pos, bool * is_rtl)
{
uint32_t pos_conv_len = get_txt_len(str_in, len);
char * buf = lv_mem_buf_get(len + 1);
char * buf = _lv_mem_buf_get(len + 1);
if(buf == NULL) return (uint16_t) -1;
uint16_t * pos_conv_buf = lv_mem_buf_get(pos_conv_len * sizeof(uint16_t));
uint16_t * pos_conv_buf = _lv_mem_buf_get(pos_conv_len * sizeof(uint16_t));
if(pos_conv_buf == NULL) {
lv_mem_buf_release(buf);
_lv_mem_buf_release(buf);
return (uint16_t) -1;
}
if(bidi_txt) *bidi_txt = buf;
lv_bidi_process_paragraph(str_in, bidi_txt ? *bidi_txt : NULL, len, base_dir, pos_conv_buf, pos_conv_len);
_lv_bidi_process_paragraph(str_in, bidi_txt ? *bidi_txt : NULL, len, base_dir, pos_conv_buf, pos_conv_len);
for(uint16_t i = 0; i < pos_conv_len; i++) {
if(GET_POS(pos_conv_buf[i]) == logical_pos) {
if(is_rtl) *is_rtl = IS_RTL_POS(pos_conv_buf[i]);
lv_mem_buf_release(pos_conv_buf);
_lv_mem_buf_release(pos_conv_buf);
if(bidi_txt == NULL) lv_mem_buf_release(buf);
if(bidi_txt == NULL) _lv_mem_buf_release(buf);
return i;
}
}
lv_mem_buf_release(pos_conv_buf);
if(bidi_txt == NULL) lv_mem_buf_release(buf);
_lv_mem_buf_release(pos_conv_buf);
if(bidi_txt == NULL) _lv_mem_buf_release(buf);
return (uint16_t) -1;
}
@@ -213,7 +213,7 @@ uint16_t lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t
* Can be `NULL` is unused
* @param pos_conv_len length of `pos_conv_out` in element count
*/
void lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len, lv_bidi_dir_t base_dir,
void _lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len, lv_bidi_dir_t base_dir,
uint16_t * pos_conv_out, uint16_t pos_conv_len)
{
uint32_t run_len = 0;
@@ -224,7 +224,7 @@ void lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len
uint16_t pos_conv_rd = 0;
uint16_t pos_conv_wr;
if(base_dir == LV_BIDI_DIR_AUTO) base_dir = lv_bidi_detect_base_dir(str_in);
if(base_dir == LV_BIDI_DIR_AUTO) base_dir = _lv_bidi_detect_base_dir(str_in);
if(base_dir == LV_BIDI_DIR_RTL) {
wr = len;
pos_conv_wr = pos_conv_len;
@@ -243,7 +243,7 @@ void lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len
/*Process neutral chars in the beginning*/
while(rd < len) {
uint32_t letter = lv_txt_encoded_next(str_in, &rd);
uint32_t letter = _lv_txt_encoded_next(str_in, &rd);
pos_conv_rd++;
dir = lv_bidi_get_letter_dir(letter);
if(dir == LV_BIDI_DIR_NEUTRAL) dir = bracket_process(str_in, rd, len, letter, base_dir);
@@ -251,14 +251,14 @@ void lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len
}
if(rd && str_in[rd] != '\0') {
lv_txt_encoded_prev(str_in, &rd);
_lv_txt_encoded_prev(str_in, &rd);
pos_conv_rd--;
}
if(rd) {
if(base_dir == LV_BIDI_DIR_LTR) {
if(str_out) {
lv_memcpy(&str_out[wr], str_in, rd);
_lv_memcpy(&str_out[wr], str_in, rd);
wr += rd;
}
if(pos_conv_out) {
@@ -281,7 +281,7 @@ void lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len
if(base_dir == LV_BIDI_DIR_LTR) {
if(run_dir == LV_BIDI_DIR_LTR) {
if(str_out) lv_memcpy(&str_out[wr], &str_in[rd], run_len);
if(str_out) _lv_memcpy(&str_out[wr], &str_in[rd], run_len);
if(pos_conv_out) fill_pos_conv(&pos_conv_out[pos_conv_wr], pos_conv_run_len, pos_conv_rd);
}
else rtl_reverse(str_out ? &str_out[wr] : NULL, &str_in[rd], run_len, pos_conv_out ? &pos_conv_out[pos_conv_wr] : NULL,
@@ -293,7 +293,7 @@ void lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len
wr -= run_len;
pos_conv_wr -= pos_conv_run_len;
if(run_dir == LV_BIDI_DIR_LTR) {
if(str_out) lv_memcpy(&str_out[wr], &str_in[rd], run_len);
if(str_out) _lv_memcpy(&str_out[wr], &str_in[rd], run_len);
if(pos_conv_out) fill_pos_conv(&pos_conv_out[pos_conv_wr], pos_conv_run_len, pos_conv_rd);
}
else rtl_reverse(str_out ? &str_out[wr] : NULL, &str_in[rd], run_len, pos_conv_out ? &pos_conv_out[pos_conv_wr] : NULL,
@@ -318,10 +318,10 @@ static uint32_t lv_bidi_get_next_paragraph(const char * txt)
{
uint32_t i = 0;
lv_txt_encoded_next(txt, &i);
_lv_txt_encoded_next(txt, &i);
while(txt[i] != '\0' && txt[i] != '\n' && txt[i] != '\r') {
lv_txt_encoded_next(txt, &i);
_lv_txt_encoded_next(txt, &i);
}
return i;
@@ -351,7 +351,7 @@ static bool lv_bidi_letter_is_weak(uint32_t letter)
static const char weaks[] = "0123456789";
do {
uint32_t x = lv_txt_encoded_next(weaks, &i);
uint32_t x = _lv_txt_encoded_next(weaks, &i);
if(letter == x) {
return true;
}
@@ -399,7 +399,7 @@ static uint32_t get_txt_len(const char * txt, uint32_t max_len)
uint32_t i = 0;
while(i < max_len && txt[i] != '\0') {
lv_txt_encoded_next(txt, &i);
_lv_txt_encoded_next(txt, &i);
len++;
}
@@ -423,13 +423,13 @@ static lv_bidi_dir_t get_next_run(const char * txt, lv_bidi_dir_t base_dir, uint
uint16_t pos_conv_i = 0;
letter = lv_txt_encoded_next(txt, NULL);
letter = _lv_txt_encoded_next(txt, NULL);
lv_bidi_dir_t dir = lv_bidi_get_letter_dir(letter);
if(dir == LV_BIDI_DIR_NEUTRAL) dir = bracket_process(txt, 0, max_len, letter, base_dir);
/*Find the first strong char. Skip the neutrals*/
while(dir == LV_BIDI_DIR_NEUTRAL || dir == LV_BIDI_DIR_WEAK) {
letter = lv_txt_encoded_next(txt, &i);
letter = _lv_txt_encoded_next(txt, &i);
pos_conv_i++;
dir = lv_bidi_get_letter_dir(letter);
if(dir == LV_BIDI_DIR_NEUTRAL) dir = bracket_process(txt, i, max_len, letter, base_dir);
@@ -451,7 +451,7 @@ static lv_bidi_dir_t get_next_run(const char * txt, lv_bidi_dir_t base_dir, uint
/*Find the next char which has different direction*/
lv_bidi_dir_t next_dir = base_dir;
while(i_prev < max_len && txt[i] != '\0' && txt[i] != '\n' && txt[i] != '\r') {
letter = lv_txt_encoded_next(txt, &i);
letter = _lv_txt_encoded_next(txt, &i);
pos_conv_i++;
next_dir = lv_bidi_get_letter_dir(letter);
if(next_dir == LV_BIDI_DIR_NEUTRAL) next_dir = bracket_process(txt, i, max_len, letter, base_dir);
@@ -506,7 +506,7 @@ static void rtl_reverse(char * dest, const char * src, uint32_t len, uint16_t *
uint16_t pos_conv_wr = 0;
while(i) {
uint32_t letter = lv_txt_encoded_prev(src, &i);
uint32_t letter = _lv_txt_encoded_prev(src, &i);
uint16_t pos_conv_letter = --pos_conv_i;
/*Keep weak letters (numbers) as LTR*/
@@ -516,7 +516,7 @@ static void rtl_reverse(char * dest, const char * src, uint32_t len, uint16_t *
uint16_t pos_conv_last_weak = pos_conv_i;
uint16_t pos_conv_first_weak = pos_conv_i;
while(i) {
letter = lv_txt_encoded_prev(src, &i);
letter = _lv_txt_encoded_prev(src, &i);
pos_conv_letter = --pos_conv_i;
/*No need to call `char_change_to_pair` because there not such chars here*/
@@ -524,7 +524,7 @@ static void rtl_reverse(char * dest, const char * src, uint32_t len, uint16_t *
/*Finish on non-weak char */
/*but treat number and currency related chars as weak*/
if(lv_bidi_letter_is_weak(letter) == false && letter != '.' && letter != ',' && letter != '$' && letter != '%') {
lv_txt_encoded_next(src, &i); /*Rewind one letter*/
_lv_txt_encoded_next(src, &i); /*Rewind one letter*/
pos_conv_i++;
first_weak = i;
pos_conv_first_weak = pos_conv_i;
@@ -536,7 +536,7 @@ static void rtl_reverse(char * dest, const char * src, uint32_t len, uint16_t *
pos_conv_first_weak = 0;
}
if(dest) lv_memcpy(&dest[wr], &src[first_weak], last_weak - first_weak + 1);
if(dest) _lv_memcpy(&dest[wr], &src[first_weak], last_weak - first_weak + 1);
if(pos_conv_out) fill_pos_conv(&pos_conv_out[pos_conv_wr], pos_conv_last_weak - pos_conv_first_weak + 1,
pos_conv_rd_base + pos_conv_first_weak);
wr += last_weak - first_weak + 1;
@@ -545,7 +545,7 @@ static void rtl_reverse(char * dest, const char * src, uint32_t len, uint16_t *
/*Simply store in reversed order*/
else {
uint32_t letter_size = lv_txt_encoded_size((const char *)&src[i]);
uint32_t letter_size = _lv_txt_encoded_size((const char *)&src[i]);
/*Swap arithmetical symbols*/
if(letter_size == 1) {
uint32_t new_letter = letter = char_change_to_pair(letter);
@@ -556,7 +556,7 @@ static void rtl_reverse(char * dest, const char * src, uint32_t len, uint16_t *
}
/*Just store the letter*/
else {
if(dest) lv_memcpy(&dest[wr], &src[i], letter_size);
if(dest) _lv_memcpy(&dest[wr], &src[i], letter_size);
if(pos_conv_out) pos_conv_out[pos_conv_wr] = SET_RTL_POS(pos_conv_rd_base + pos_conv_i, true);
wr += letter_size;
pos_conv_wr++;
@@ -593,7 +593,7 @@ static lv_bidi_dir_t bracket_process(const char * txt, uint32_t next_pos, uint32
* If a char with base dir. direction is found then the brackets will have `base_dir` direction*/
uint32_t txt_i = next_pos;
while(txt_i < len) {
uint32_t letter_next = lv_txt_encoded_next(txt, &txt_i);
uint32_t letter_next = _lv_txt_encoded_next(txt, &txt_i);
if(letter_next == bracket_right[i]) {
/*Closing bracket found*/
break;
@@ -615,9 +615,9 @@ static lv_bidi_dir_t bracket_process(const char * txt, uint32_t next_pos, uint32
/*If there were no matching strong chars in the brackets then check the previous chars*/
txt_i = next_pos;
if(txt_i) lv_txt_encoded_prev(txt, &txt_i);
if(txt_i) _lv_txt_encoded_prev(txt, &txt_i);
while(txt_i > 0) {
uint32_t letter_next = lv_txt_encoded_prev(txt, &txt_i);
uint32_t letter_next = _lv_txt_encoded_prev(txt, &txt_i);
lv_bidi_dir_t letter_dir = lv_bidi_get_letter_dir(letter_next);
if(letter_dir == LV_BIDI_DIR_LTR || letter_dir == LV_BIDI_DIR_RTL) {
bracket_dir = letter_dir;
src/lv_misc/lv_bidi.h
+5 -5
View File
@@ -54,14 +54,14 @@ typedef uint8_t lv_bidi_dir_t;
* @param str_out store the result here. Has the be `strlen(str_in)` length
* @param base_dir `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL`
*/
void lv_bidi_process(const char * str_in, char * str_out, lv_bidi_dir_t base_dir);
void _lv_bidi_process(const char * str_in, char * str_out, lv_bidi_dir_t base_dir);
/**
* Auto-detect the direction of a text based on the first strong character
* @param txt the text to process
* @return `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL`
*/
lv_bidi_dir_t lv_bidi_detect_base_dir(const char * txt);
lv_bidi_dir_t _lv_bidi_detect_base_dir(const char * txt);
/**
* Get the logical position of a character in a line
@@ -75,7 +75,7 @@ lv_bidi_dir_t lv_bidi_detect_base_dir(const char * txt);
* @param is_rtl tell the the char at `viasual_pos` is RTL or LTR context
* @return the logical character position
*/
uint16_t lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t len, lv_bidi_dir_t base_dir,
uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t len, lv_bidi_dir_t base_dir,
uint32_t visual_pos, bool * is_rtl);
/**
@@ -90,7 +90,7 @@ uint16_t lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t
* @param is_rtl tell the the char at `logical_pos` is RTL or LTR context
* @return the visual character position
*/
uint16_t lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t len, lv_bidi_dir_t base_dir,
uint16_t _lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t len, lv_bidi_dir_t base_dir,
uint32_t logical_pos, bool * is_rtl);
/**
@@ -103,7 +103,7 @@ uint16_t lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t
* Can be `NULL` is unused
* @param pos_conv_len length of `pos_conv_out` in element count
*/
void lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len, lv_bidi_dir_t base_dir,
void _lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len, lv_bidi_dir_t base_dir,
uint16_t * pos_conv_out, uint16_t pos_conv_len);
/**********************
src/lv_misc/lv_circ.c
-80
View File
@@ -1,80 +0,0 @@
/**
* @file lv_circ.c
* Circle drawing algorithm (with Bresenham)
* Only a 1/8 circle is calculated. Use CIRC_OCT1_X, CIRC_OCT1_Y macros to get
* the other octets.
*/
/*********************
* INCLUDES
*********************/
#include "lv_circ.h"
/*********************
* DEFINES
*********************/
/**********************
* TYPEDEFS
**********************/
/**********************
* STATIC PROTOTYPES
**********************/
/**********************
* STATIC VARIABLES
**********************/
/**********************
* MACROS
**********************/
/**********************
* GLOBAL FUNCTIONS
**********************/
/**
* Initialize the circle drawing
* @param c pointer to a point. The coordinates will be calculated here
* @param tmp point to a variable. It will store temporary data
* @param radius radius of the circle
*/
void lv_circ_init(lv_point_t * c, lv_coord_t * tmp, lv_coord_t radius)
{
c->x = radius;
c->y = 0;
*tmp = 1 - radius;
}
/**
* Test the circle drawing is ready or not
* @param c same as in circ_init
* @return true if the circle is not ready yet
*/
bool lv_circ_cont(lv_point_t * c)
{
return c->y <= c->x ? true : false;
}
/**
* Get the next point from the circle
* @param c same as in circ_init. The next point stored here.
* @param tmp same as in circ_init.
*/
void lv_circ_next(lv_point_t * c, lv_coord_t * tmp)
{
c->y++;
if(*tmp <= 0) {
(*tmp) += 2 * c->y + 1; /*Change in decision criterion for y -> y+1*/
}
else {
c->x--;
(*tmp) += 2 * (c->y - c->x) + 1; /*Change for y -> y+1, x -> x-1*/
}
}
/**********************
* STATIC FUNCTIONS
**********************/
src/lv_misc/lv_circ.h
-77
View File
@@ -1,77 +0,0 @@
/**
* @file lv_circ.h
*
*/
#ifndef LV_CIRC_H
#define LV_CIRC_H
#ifdef __cplusplus
extern "C" {
#endif
/*********************
* INCLUDES
*********************/
#include <stddef.h>
#include "lv_area.h"
/*********************
* DEFINES
*********************/
#define LV_CIRC_OCT1_X(p) (p.x)
#define LV_CIRC_OCT1_Y(p) (p.y)
#define LV_CIRC_OCT2_X(p) (p.y)
#define LV_CIRC_OCT2_Y(p) (p.x)
#define LV_CIRC_OCT3_X(p) (-p.y)
#define LV_CIRC_OCT3_Y(p) (p.x)
#define LV_CIRC_OCT4_X(p) (-p.x)
#define LV_CIRC_OCT4_Y(p) (p.y)
#define LV_CIRC_OCT5_X(p) (-p.x)
#define LV_CIRC_OCT5_Y(p) (-p.y)
#define LV_CIRC_OCT6_X(p) (-p.y)
#define LV_CIRC_OCT6_Y(p) (-p.x)
#define LV_CIRC_OCT7_X(p) (p.y)
#define LV_CIRC_OCT7_Y(p) (-p.x)
#define LV_CIRC_OCT8_X(p) (p.x)
#define LV_CIRC_OCT8_Y(p) (-p.y)
/**********************
* TYPEDEFS
**********************/
/**********************
* GLOBAL PROTOTYPES
**********************/
/**
* Initialize the circle drawing
* @param c pointer to a point. The coordinates will be calculated here
* @param tmp point to a variable. It will store temporary data
* @param radius radius of the circle
*/
void lv_circ_init(lv_point_t * c, lv_coord_t * tmp, lv_coord_t radius);
/**
* Test the circle drawing is ready or not
* @param c same as in circ_init
* @return true if the circle is not ready yet
*/
bool lv_circ_cont(lv_point_t * c);
/**
* Get the next point from the circle
* @param c same as in circ_init. The next point stored here.
* @param tmp same as in circ_init.
*/
void lv_circ_next(lv_point_t * c, lv_coord_t * tmp);
/**********************
* MACROS
**********************/
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif
src/lv_misc/lv_fs.c
+7 -7
View File
@@ -54,9 +54,9 @@ static const char * lv_fs_get_real_path(const char * path);
/**
* Initialize the File system interface
*/
void lv_fs_init(void)
void _lv_fs_init(void)
{
lv_ll_init(&LV_GC_ROOT(_lv_drv_ll), sizeof(lv_fs_drv_t));
_lv_ll_init(&LV_GC_ROOT(_lv_drv_ll), sizeof(lv_fs_drv_t));
}
/**
@@ -475,7 +475,7 @@ lv_fs_res_t lv_fs_free_space(char letter, uint32_t * total_p, uint32_t * free_p)
*/
void lv_fs_drv_init(lv_fs_drv_t * drv)
{
lv_memset_00(drv, sizeof(lv_fs_drv_t));
_lv_memset_00(drv, sizeof(lv_fs_drv_t));
}
/**
@@ -487,11 +487,11 @@ void lv_fs_drv_register(lv_fs_drv_t * drv_p)
{
/*Save the new driver*/
lv_fs_drv_t * new_drv;
new_drv = lv_ll_ins_head(&LV_GC_ROOT(_lv_drv_ll));
new_drv = _lv_ll_ins_head(&LV_GC_ROOT(_lv_drv_ll));
LV_ASSERT_MEM(new_drv);
if(new_drv == NULL) return;
lv_memcpy(new_drv, drv_p, sizeof(lv_fs_drv_t));
_lv_memcpy(new_drv, drv_p, sizeof(lv_fs_drv_t));
}
/**
@@ -503,7 +503,7 @@ lv_fs_drv_t * lv_fs_get_drv(char letter)
{
lv_fs_drv_t * drv;
LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
_LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
if(drv->letter == letter) {
return drv;
}
@@ -521,7 +521,7 @@ char * lv_fs_get_letters(char * buf)
lv_fs_drv_t * drv;
uint8_t i = 0;
LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
_LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
buf[i] = drv->letter;
i++;
}
src/lv_misc/lv_fs.h
+1 -1
View File
@@ -104,7 +104,7 @@ typedef struct {
/**
* Initialize the File system interface
*/
void lv_fs_init(void);
void _lv_fs_init(void);
/**
* Initialize a file system driver with default values.
src/lv_misc/lv_gc.c
+2 -2
View File
@@ -42,9 +42,9 @@
* GLOBAL FUNCTIONS
**********************/
void lv_gc_clear_roots(void)
void _lv_gc_clear_roots(void)
{
#define LV_CLEAR_ROOT(root_type, root_name) lv_memset_00(&LV_GC_ROOT(root_name), sizeof(LV_GC_ROOT(root_name)));
#define LV_CLEAR_ROOT(root_type, root_name) _lv_memset_00(&LV_GC_ROOT(root_name), sizeof(LV_GC_ROOT(root_name)));
LV_ITERATE_ROOTS(LV_CLEAR_ROOT)
}
src/lv_misc/lv_gc.h
+1 -1
View File
@@ -60,7 +60,7 @@ LV_ITERATE_ROOTS(LV_EXTERN_ROOT)
* GLOBAL PROTOTYPES
**********************/
void lv_gc_clear_roots(void);
void _lv_gc_clear_roots(void);
/**********************
* MACROS
src/lv_misc/lv_ll.c
+37 -37
View File
@@ -47,7 +47,7 @@ static void node_set_next(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * nex
* @param ll_dsc pointer to ll_dsc variable
* @param node_size the size of 1 node in bytes
*/
void lv_ll_init(lv_ll_t * ll_p, uint32_t node_size)
void _lv_ll_init(lv_ll_t * ll_p, uint32_t node_size)
{
ll_p->head = NULL;
ll_p->tail = NULL;
@@ -73,7 +73,7 @@ void lv_ll_init(lv_ll_t * ll_p, uint32_t node_size)
* @param ll_p pointer to linked list
* @return pointer to the new head
*/
void * lv_ll_ins_head(lv_ll_t * ll_p)
void * _lv_ll_ins_head(lv_ll_t * ll_p)
{
lv_ll_node_t * n_new;
@@ -102,14 +102,14 @@ void * lv_ll_ins_head(lv_ll_t * ll_p)
* @param n_act pointer a node
* @return pointer to the new head
*/
void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act)
void * _lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act)
{
lv_ll_node_t * n_new;
if(NULL == ll_p || NULL == n_act) return NULL;
if(lv_ll_get_head(ll_p) == n_act) {
n_new = lv_ll_ins_head(ll_p);
if(_lv_ll_get_head(ll_p) == n_act) {
n_new = _lv_ll_ins_head(ll_p);
if(n_new == NULL) return NULL;
}
else {
@@ -117,7 +117,7 @@ void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act)
if(n_new == NULL) return NULL;
lv_ll_node_t * n_prev;
n_prev = lv_ll_get_prev(ll_p, n_act);
n_prev = _lv_ll_get_prev(ll_p, n_act);
node_set_next(ll_p, n_prev, n_new);
node_set_prev(ll_p, n_new, n_prev);
node_set_prev(ll_p, n_act, n_new);
@@ -132,7 +132,7 @@ void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act)
* @param ll_p pointer to linked list
* @return pointer to the new tail
*/
void * lv_ll_ins_tail(lv_ll_t * ll_p)
void * _lv_ll_ins_tail(lv_ll_t * ll_p)
{
lv_ll_node_t * n_new;
@@ -160,11 +160,11 @@ void * lv_ll_ins_tail(lv_ll_t * ll_p)
* @param ll_p pointer to the linked list of 'node_p'
* @param node_p pointer to node in 'll_p' linked list
*/
void lv_ll_remove(lv_ll_t * ll_p, void * node_p)
void _lv_ll_remove(lv_ll_t * ll_p, void * node_p)
{
if(lv_ll_get_head(ll_p) == node_p) {
if(_lv_ll_get_head(ll_p) == node_p) {
/*The new head will be the node after 'n_act'*/
ll_p->head = lv_ll_get_next(ll_p, node_p);
ll_p->head = _lv_ll_get_next(ll_p, node_p);
if(ll_p->head == NULL) {
ll_p->tail = NULL;
}
@@ -172,9 +172,9 @@ void lv_ll_remove(lv_ll_t * ll_p, void * node_p)
node_set_prev(ll_p, ll_p->head, NULL);
}
}
else if(lv_ll_get_tail(ll_p) == node_p) {
else if(_lv_ll_get_tail(ll_p) == node_p) {
/*The new tail will be the node before 'n_act'*/
ll_p->tail = lv_ll_get_prev(ll_p, node_p);
ll_p->tail = _lv_ll_get_prev(ll_p, node_p);
if(ll_p->tail == NULL) {
ll_p->head = NULL;
}
@@ -183,8 +183,8 @@ void lv_ll_remove(lv_ll_t * ll_p, void * node_p)
}
}
else {
lv_ll_node_t * n_prev = lv_ll_get_prev(ll_p, node_p);
lv_ll_node_t * n_next = lv_ll_get_next(ll_p, node_p);
lv_ll_node_t * n_prev = _lv_ll_get_prev(ll_p, node_p);
lv_ll_node_t * n_next = _lv_ll_get_next(ll_p, node_p);
node_set_next(ll_p, n_prev, n_next);
node_set_prev(ll_p, n_next, n_prev);
@@ -195,18 +195,18 @@ void lv_ll_remove(lv_ll_t * ll_p, void * node_p)
* Remove and free all elements from a linked list. The list remain valid but become empty.
* @param ll_p pointer to linked list
*/
void lv_ll_clear(lv_ll_t * ll_p)
void _lv_ll_clear(lv_ll_t * ll_p)
{
void * i;
void * i_next;
i = lv_ll_get_head(ll_p);
i = _lv_ll_get_head(ll_p);
i_next = NULL;
while(i != NULL) {
i_next = lv_ll_get_next(ll_p, i);
i_next = _lv_ll_get_next(ll_p, i);
lv_ll_remove(ll_p, i);
_lv_ll_remove(ll_p, i);
lv_mem_free(i);
i = i_next;
@@ -221,9 +221,9 @@ void lv_ll_clear(lv_ll_t * ll_p)
* @param head true: be the head in the new list
* false be the head in the new list
*/
void lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool head)
void _lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool head)
{
lv_ll_remove(ll_ori_p, node);
_lv_ll_remove(ll_ori_p, node);
if(head) {
/*Set node as head*/
@@ -260,7 +260,7 @@ void lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool he
* @param ll_p pointer to linked list
* @return pointer to the head of 'll_p'
*/
void * lv_ll_get_head(const lv_ll_t * ll_p)
void * _lv_ll_get_head(const lv_ll_t * ll_p)
{
void * head = NULL;
@@ -276,7 +276,7 @@ void * lv_ll_get_head(const lv_ll_t * ll_p)
* @param ll_p pointer to linked list
* @return pointer to the head of 'll_p'
*/
void * lv_ll_get_tail(const lv_ll_t * ll_p)
void * _lv_ll_get_tail(const lv_ll_t * ll_p)
{
void * tail = NULL;
@@ -293,13 +293,13 @@ void * lv_ll_get_tail(const lv_ll_t * ll_p)
* @param n_act pointer a node
* @return pointer to the next node
*/
void * lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act)
void * _lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act)
{
void * next = NULL;
if(ll_p != NULL) {
const lv_ll_node_t * n_act_d = n_act;
lv_memcpy_small(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizeof(void *));
_lv_memcpy_small(&next, n_act_d + LL_NEXT_P_OFFSET(ll_p), sizeof(void *));
}
return next;
@@ -311,13 +311,13 @@ void * lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act)
* @param n_act pointer a node
* @return pointer to the previous node
*/
void * lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act)
void * _lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act)
{
void * prev = NULL;
if(ll_p != NULL) {
const lv_ll_node_t * n_act_d = n_act;
lv_memcpy_small(&prev, n_act_d + LL_PREV_P_OFFSET(ll_p), sizeof(void *));
_lv_memcpy_small(&prev, n_act_d + LL_PREV_P_OFFSET(ll_p), sizeof(void *));
}
return prev;
@@ -328,12 +328,12 @@ void * lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act)
* @param ll_p pointer to linked list
* @return length of the linked list
*/
uint32_t lv_ll_get_len(const lv_ll_t * ll_p)
uint32_t _lv_ll_get_len(const lv_ll_t * ll_p)
{
uint32_t len = 0;
void * node;
for(node = lv_ll_get_head(ll_p); node != NULL; node = lv_ll_get_next(ll_p, node)) {
for(node = _lv_ll_get_head(ll_p); node != NULL; node = _lv_ll_get_next(ll_p, node)) {
len++;
}
@@ -346,20 +346,20 @@ uint32_t lv_ll_get_len(const lv_ll_t * ll_p)
* @param n_act pointer to node to move
* @param n_after pointer to a node which should be after `n_act`
*/
void lv_ll_move_before(lv_ll_t * ll_p, void * n_act, void * n_after)
void _lv_ll_move_before(lv_ll_t * ll_p, void * n_act, void * n_after)
{
if(n_act == n_after) return; /*Can't move before itself*/
void * n_before;
if(n_after != NULL)
n_before = lv_ll_get_prev(ll_p, n_after);
n_before = _lv_ll_get_prev(ll_p, n_after);
else
n_before = lv_ll_get_tail(ll_p); /*if `n_after` is NULL `n_act` should be the new tail*/
n_before = _lv_ll_get_tail(ll_p); /*if `n_after` is NULL `n_act` should be the new tail*/
if(n_act == n_before) return; /*Already before `n_after`*/
/*It's much easier to remove from the list and add again*/
lv_ll_remove(ll_p, n_act);
_lv_ll_remove(ll_p, n_act);
/*Add again by setting the prev. and next nodes*/
node_set_next(ll_p, n_before, n_act);
@@ -379,7 +379,7 @@ void lv_ll_move_before(lv_ll_t * ll_p, void * n_act, void * n_after)
* @param ll_p pointer to a linked list
* @return true: the linked list is empty; false: not empty
*/
bool lv_ll_is_empty(lv_ll_t * ll_p)
bool _lv_ll_is_empty(lv_ll_t * ll_p)
{
if(ll_p == NULL) return true;
@@ -404,9 +404,9 @@ static void node_set_prev(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * pre
uint32_t node_p_size = sizeof(lv_ll_node_t *);
if(prev)
lv_memcpy_small(act + LL_PREV_P_OFFSET(ll_p), &prev, node_p_size);
_lv_memcpy_small(act + LL_PREV_P_OFFSET(ll_p), &prev, node_p_size);
else
lv_memset_00(act + LL_PREV_P_OFFSET(ll_p), node_p_size);
_lv_memset_00(act + LL_PREV_P_OFFSET(ll_p), node_p_size);
}
/**
@@ -421,7 +421,7 @@ static void node_set_next(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * nex
uint32_t node_p_size = sizeof(lv_ll_node_t *);
if(next)
lv_memcpy_small(act + LL_NEXT_P_OFFSET(ll_p), &next, node_p_size);
_lv_memcpy_small(act + LL_NEXT_P_OFFSET(ll_p), &next, node_p_size);
else
lv_memset_00(act + LL_NEXT_P_OFFSET(ll_p), node_p_size);
_lv_memset_00(act + LL_NEXT_P_OFFSET(ll_p), node_p_size);
}
src/lv_misc/lv_ll.h
+17 -16
View File
@@ -45,14 +45,14 @@ typedef struct {
* @param ll_dsc pointer to ll_dsc variable
* @param node_size the size of 1 node in bytes
*/
void lv_ll_init(lv_ll_t * ll_p, uint32_t node_size);
void _lv_ll_init(lv_ll_t * ll_p, uint32_t node_size);
/**
* Add a new head to a linked list
* @param ll_p pointer to linked list
* @return pointer to the new head
*/
void * lv_ll_ins_head(lv_ll_t * ll_p);
void * _lv_ll_ins_head(lv_ll_t * ll_p);
/**
* Insert a new node in front of the n_act node
@@ -60,14 +60,14 @@ void * lv_ll_ins_head(lv_ll_t * ll_p);
* @param n_act pointer a node
* @return pointer to the new head
*/
void * lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act);
void * _lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act);
/**
* Add a new tail to a linked list
* @param ll_p pointer to linked list
* @return pointer to the new tail
*/
void * lv_ll_ins_tail(lv_ll_t * ll_p);
void * _lv_ll_ins_tail(lv_ll_t * ll_p);
/**
* Remove the node 'node_p' from 'll_p' linked list.
@@ -75,13 +75,13 @@ void * lv_ll_ins_tail(lv_ll_t * ll_p);
* @param ll_p pointer to the linked list of 'node_p'
* @param node_p pointer to node in 'll_p' linked list
*/
void lv_ll_remove(lv_ll_t * ll_p, void * node_p);
void _lv_ll_remove(lv_ll_t * ll_p, void * node_p);
/**
* Remove and free all elements from a linked list. The list remain valid but become empty.
* @param ll_p pointer to linked list
*/
void lv_ll_clear(lv_ll_t * ll_p);
void _lv_ll_clear(lv_ll_t * ll_p);
/**
* Move a node to a new linked list
@@ -91,21 +91,21 @@ void lv_ll_clear(lv_ll_t * ll_p);
* @param head true: be the head in the new list
* false be the head in the new list
*/
void lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool head);
void _lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool head);
/**
* Return with head node of the linked list
* @param ll_p pointer to linked list
* @return pointer to the head of 'll_p'
*/
void * lv_ll_get_head(const lv_ll_t * ll_p);
void * _lv_ll_get_head(const lv_ll_t * ll_p);
/**
* Return with tail node of the linked list
* @param ll_p pointer to linked list
* @return pointer to the head of 'll_p'
*/
void * lv_ll_get_tail(const lv_ll_t * ll_p);
void * _lv_ll_get_tail(const lv_ll_t * ll_p);
/**
* Return with the pointer of the next node after 'n_act'
@@ -113,7 +113,7 @@ void * lv_ll_get_tail(const lv_ll_t * ll_p);
* @param n_act pointer a node
* @return pointer to the next node
*/
void * lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act);
void * _lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act);
/**
* Return with the pointer of the previous node after 'n_act'
@@ -121,14 +121,14 @@ void * lv_ll_get_next(const lv_ll_t * ll_p, const void * n_act);
* @param n_act pointer a node
* @return pointer to the previous node
*/
void * lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act);
void * _lv_ll_get_prev(const lv_ll_t * ll_p, const void * n_act);
/**
* Return the length of the linked list.
* @param ll_p pointer to linked list
* @return length of the linked list
*/
uint32_t lv_ll_get_len(const lv_ll_t * ll_p);
uint32_t _lv_ll_get_len(const lv_ll_t * ll_p);
/**
* TODO
@@ -144,21 +144,22 @@ void lv_ll_swap(lv_ll_t * ll_p, void * n1_p, void * n2_p);
* @param n_act pointer to node to move
* @param n_after pointer to a node which should be after `n_act`
*/
void lv_ll_move_before(lv_ll_t * ll_p, void * n_act, void * n_after);
void _lv_ll_move_before(lv_ll_t * ll_p, void * n_act, void * n_after);
/**
* Check if a linked list is empty
* @param ll_p pointer to a linked list
* @return true: the linked list is empty; false: not empty
*/
bool lv_ll_is_empty(lv_ll_t * ll_p);
bool _lv_ll_is_empty(lv_ll_t * ll_p);
/**********************
* MACROS
**********************/
#define LV_LL_READ(list, i) for(i = lv_ll_get_head(&list); i != NULL; i = lv_ll_get_next(&list, i))
#define _LV_LL_READ(list, i) for(i = _lv_ll_get_head(&list); i != NULL; i = _lv_ll_get_next(&list, i))
#define LV_LL_READ_BACK(list, i) for(i = lv_ll_get_tail(&list); i != NULL; i = lv_ll_get_prev(&list, i))
#define _LV_LL_READ_BACK(list, i) for(i = _lv_ll_get_tail(&list); i != NULL; i = _lv_ll_get_prev(&list, i))
#ifdef __cplusplus
} /* extern "C" */

Some files were not shown because too many files have changed in this diff Show More