Embedded/lvgl
1
0
Fork 0
mirror of https://github.com/lvgl/lvgl.git synced 2025-01-21 06:53:01 +08:00
Code Issues Projects Releases Wiki Activity

raname lv_obj_rare_attr_t to lv_obj_spec_attr_t and finialize it

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi 2020-10-29 22:46:37 +01:00
parent 7a950f1863
commit 4fbc518d6a
15 changed files with 344 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
src/lv_core/lv_flex.c
View File

@ -38,20 +38,25 @@ static void place_content(lv_coord_t place, lv_coord_t max_size, lv_coord_t trac
void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place)
{
if(obj->flex_cont.dir == flex_dir && obj->flex_cont.place == flex_place) return;
if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
obj->flex_cont.dir = flex_dir;
obj->flex_cont.place = flex_place;
if(obj->spec_attr->flex_cont.dir == flex_dir && obj->spec_attr->flex_cont.place == flex_place) return;
obj->spec_attr->flex_cont.dir = flex_dir & 0x3;
obj->spec_attr->flex_cont.wrap = flex_dir & LV_FLEX_WRAP ? 1 : 0;
obj->spec_attr->flex_cont.rev = flex_dir & LV_FLEX_REVERSE ? 1 : 0;
obj->spec_attr->flex_cont.place = flex_place;
_lv_flex_refresh(obj);
}
void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap)
{
if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
if(obj->flex_cont.gap == gap) return;
if(obj->spec_attr->flex_cont.gap == gap) return;
obj->flex_cont.gap = gap;
obj->spec_attr->flex_cont.gap = gap;
_lv_flex_refresh(obj);
}
@ -62,21 +67,52 @@ void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place)
lv_obj_set_pos(obj, f, f);
}
lv_flex_dir_t lv_obj_get_flex_dir(const lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->flex_cont.dir;
else return LV_FLEX_DIR_NONE;
}
lv_flex_place_t lv_obj_get_flex_place(const lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->flex_cont.place;
else return LV_FLEX_START;
}
bool lv_obj_get_flex_wrap(const lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->flex_cont.wrap;
else return false;
}
bool lv_obj_get_flex_reverse(const lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->flex_cont.rev;
else return false;
}
lv_coord_t lv_obj_get_flex_gap(const lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->flex_cont.gap;
else return 0;
}
void _lv_flex_refresh(lv_obj_t * cont)
{
if(cont->flex_cont.dir == LV_FLEX_DIR_NONE) return;
lv_flex_dir_t dir = lv_obj_get_flex_dir(cont);
if(dir == LV_FLEX_DIR_NONE) return;
lv_flex_dir_t dir = cont->flex_cont.dir & 0x3;
bool row = dir == LV_FLEX_DIR_ROW ? true : false;
/*Count the grow units and free space*/
lv_coord_t max_main_size = (row ? lv_obj_get_width_fit(cont) : lv_obj_get_height_fit(cont));
lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_left(cont);
lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_OBJ_PART_MAIN) - lv_obj_get_scroll_top(cont);
lv_coord_t place = lv_obj_get_flex_place(cont);
lv_ll_t * ll = _lv_obj_get_child_ll(cont);
lv_coord_t * cross_pos = (row ? &abs_y : &abs_x);
lv_coord_t place = cont->flex_cont.place;
if((row && cont->h_set == LV_SIZE_AUTO) ||
(!row && cont->w_set == LV_SIZE_AUTO))
{
@ -90,7 +126,7 @@ void _lv_flex_refresh(lv_obj_t * cont)
lv_coord_t track_size;
lv_obj_t * track_first_item;
lv_obj_t * next_track_first_item;
bool rev = cont->flex_cont.dir & LV_FLEX_REVERSE;
bool rev = lv_obj_get_flex_reverse(cont);
if(place != LV_FLEX_START) {
track_first_item = rev ? _lv_ll_get_head(ll) : _lv_ll_get_tail(ll);
@ -117,6 +153,8 @@ void _lv_flex_refresh(lv_obj_t * cont)
track_first_item = next_track_first_item;
*cross_pos += track_size + gap;
}
LV_ASSERT_MEM_INTEGRITY();
}
/**********************
@ -125,18 +163,18 @@ void _lv_flex_refresh(lv_obj_t * cont)
static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coord_t max_size, lv_coord_t * grow_unit, lv_coord_t * track_cross_size)
{
lv_flex_dir_t dir = cont->flex_cont.dir;
bool row = (dir & 0x3) == LV_FLEX_DIR_ROW ? true : false;
bool wrap = lv_obj_get_flex_wrap(cont);
bool rev = lv_obj_get_flex_reverse(cont);
lv_coord_t gap = lv_obj_get_flex_gap(cont);
bool row = lv_obj_get_flex_dir(cont) == LV_FLEX_DIR_ROW ? true : false;
lv_coord_t(*get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
lv_coord_t(*get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
bool wrap = dir & LV_FLEX_WRAP ? true : false;
void * (*ll_iter)(const lv_ll_t * , const void *) = rev ? _lv_ll_get_next : _lv_ll_get_prev;
lv_ll_t * ll = _lv_obj_get_child_ll(cont);
lv_coord_t grow_sum = 0;
lv_coord_t used_size = 0;
lv_coord_t gap = cont->flex_cont.gap;
uint32_t grow_item_cnt = 0;
*track_cross_size = 0;
*grow_unit = 0;
@ -186,18 +224,19 @@ static lv_obj_t * find_track_end(lv_obj_t * cont, lv_obj_t * item_start, lv_coor
static void children_repos(lv_obj_t * cont, lv_obj_t * item_first, lv_obj_t * item_last, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t track_size, lv_coord_t grow_unit)
{
lv_flex_dir_t dir = cont->flex_cont.dir;
bool row = (dir & 0x3) == LV_FLEX_DIR_ROW ? true : false;
bool rev = lv_obj_get_flex_reverse(cont);
lv_coord_t gap = lv_obj_get_flex_gap(cont);
bool row = lv_obj_get_flex_dir(cont) == LV_FLEX_DIR_ROW ? true : false;
lv_coord_t(*obj_get_main_size)(const lv_obj_t *) = (row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
lv_coord_t(*obj_get_cross_size)(const lv_obj_t *) = (!row ? lv_obj_get_width_margin : lv_obj_get_height_margin);
void (*area_set_main_size)(lv_area_t *, lv_coord_t) = (row ? lv_area_set_width : lv_area_set_height);
lv_coord_t (*area_get_main_size)(const lv_area_t *) = (!row ? lv_area_get_width : lv_area_get_height);
lv_style_int_t (*get_margin_start)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_left : lv_obj_get_style_margin_top);
lv_style_int_t (*get_margin_end)(const lv_obj_t *, uint8_t part) = (row ? lv_obj_get_style_margin_right : lv_obj_get_style_margin_bottom);
void * (*ll_iter)(const lv_ll_t * , const void *) = dir & LV_FLEX_REVERSE ? _lv_ll_get_next : _lv_ll_get_prev;
void * (*ll_iter)(const lv_ll_t * , const void *) = rev ? _lv_ll_get_next : _lv_ll_get_prev;
lv_ll_t * ll = _lv_obj_get_child_ll(cont);
lv_coord_t gap = cont->flex_cont.gap;
lv_coord_t main_pos = 0;
/*Reposition the children*/
lv_obj_t * item = item_first; /*Just to use a shorter name*/

12
src/lv_core/lv_flex.h
View File

@ -48,8 +48,10 @@ typedef enum {
typedef struct {
lv_coord_t gap;
uint32_t place :4;
uint32_t dir :4;
uint8_t dir :2;
uint8_t wrap :1;
uint8_t rev :1;
uint8_t place :3;
}lv_flex_cont_t;
/**********************
@ -59,6 +61,12 @@ typedef struct {
void lv_obj_set_flex_cont(lv_obj_t * obj, lv_flex_dir_t flex_dir, lv_flex_place_t flex_place);
void lv_obj_set_flex_gap(lv_obj_t * obj, lv_coord_t gap);
void lv_obj_set_flex_item(lv_obj_t * obj, lv_flex_place_t place);
lv_flex_dir_t lv_obj_get_flex_dir(const lv_obj_t * obj);
lv_flex_place_t lv_obj_get_flex_place(const lv_obj_t * obj);
bool lv_obj_get_flex_wrap(const lv_obj_t * obj);
bool lv_obj_get_flex_reverse(const lv_obj_t * obj);
lv_coord_t lv_obj_get_flex_gap(const lv_obj_t * obj);
void _lv_flex_refresh(lv_obj_t * cont);
/**********************

50
src/lv_core/lv_grid.c
View File

@ -53,7 +53,9 @@ void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
obj->grid = grid;
if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
obj->spec_attr->grid = grid;
_lv_grid_full_refresh(obj);
}
@ -62,11 +64,12 @@ void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid)
* @param obj pointer to an object
* @return the grid, NULL if no grid
*/
const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj, const lv_grid_t * grid)
const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
return obj->grid;
if(obj->spec_attr) return obj->spec_attr->grid;
return NULL;
}
@ -96,9 +99,10 @@ void lv_obj_report_grid_change(const lv_grid_t * grid)
*/
void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
{
if(cont->grid == NULL) return;
if(cont->grid->col_dsc == NULL || cont->grid->row_dsc == NULL) return;
if(cont->grid->col_dsc_len == 0 || cont->grid->row_dsc_len == 0) return;
lv_grid_t * g = lv_obj_get_grid(cont);
if(g == NULL) return;
if(g->col_dsc == NULL || g->row_dsc == NULL) return;
if(g->col_dsc_len == 0 || g->row_dsc_len == 0) return;
if(lv_obj_get_child(cont, NULL) == NULL) {
_lv_memset_00(calc_out, sizeof(_lv_grid_calc_t));
@ -111,11 +115,11 @@ void _lv_grid_calc(struct _lv_obj_t * cont, _lv_grid_calc_t * calc_out)
bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
lv_coord_t cont_w = lv_obj_get_width_fit(cont);
calc_out->grid_w = grid_place(cont_w, auto_w, cont->grid->col_place, cont->grid->col_gap, calc_out->col_num, calc_out->w, calc_out->x);
calc_out->grid_w = grid_place(cont_w, auto_w, g->col_place, g->col_gap, calc_out->col_num, calc_out->w, calc_out->x);
bool auto_h = cont->h_set == LV_SIZE_AUTO ? true : false;
lv_coord_t cont_h = lv_obj_get_height_fit(cont);
calc_out->grid_h = grid_place(cont_h, auto_h, cont->grid->row_place, cont->grid->row_gap, calc_out->row_num, calc_out->h, calc_out->y);
calc_out->grid_h = grid_place(cont_h, auto_h, g->row_place, g->row_gap, calc_out->row_num, calc_out->h, calc_out->y);
LV_ASSERT_MEM_INTEGRITY();
}
@ -139,12 +143,12 @@ void _lv_grid_calc_free(_lv_grid_calc_t * calc)
*/
bool _lv_grid_has_fr_col(struct _lv_obj_t * obj)
{
if(obj->grid == NULL) return false;
if(obj->grid->col_dsc == NULL) return false;
lv_grid_t * g = lv_obj_get_grid(obj);
if(g->col_dsc == NULL) return false;
uint32_t i;
for(i = 0; i < obj->grid->col_dsc_len; i++) {
if(LV_GRID_IS_FR(obj->grid->col_dsc[i])) return true;
for(i = 0; i < g->col_dsc_len; i++) {
if(LV_GRID_IS_FR(g->col_dsc[i])) return true;
}
return false;
@ -157,12 +161,13 @@ bool _lv_grid_has_fr_col(struct _lv_obj_t * obj)
*/
bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
{
if(obj->grid == NULL) return false;
if(obj->grid->row_dsc == NULL) return false;
lv_grid_t * g = lv_obj_get_grid(obj);
if(g == NULL) return false;
if(g->row_dsc == NULL) return false;
uint32_t i;
for(i = 0; i < obj->grid->row_dsc_len; i++) {
if(LV_GRID_IS_FR(obj->grid->row_dsc[i])) return true;
for(i = 0; i < g->row_dsc_len; i++) {
if(LV_GRID_IS_FR(g->row_dsc[i])) return true;
}
return false;
@ -175,7 +180,7 @@ bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
void _lv_grid_full_refresh(lv_obj_t * cont)
{
/*Calculate the grid*/
if(cont->grid == NULL) return;
if(lv_obj_get_grid(cont) == NULL) return;
_lv_grid_calc_t calc;
_lv_grid_calc(cont, &calc);
@ -213,7 +218,8 @@ void lv_grid_item_refr_pos(lv_obj_t * item)
/*Calculate the grid*/
lv_obj_t * cont = lv_obj_get_parent(item);
if(cont == NULL) return;
if(cont->grid == NULL) return;
if(cont->spec_attr == NULL) return;
if(cont->spec_attr->grid == NULL) return;
_lv_grid_calc_t calc;
_lv_grid_calc(cont, &calc);
@ -228,7 +234,7 @@ void lv_grid_item_refr_pos(lv_obj_t * item)
static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
{
const lv_grid_t * grid = cont->grid;
const lv_grid_t * grid = cont->spec_attr->grid;
uint32_t i;
lv_coord_t cont_w = lv_obj_get_width_fit(cont);
@ -267,7 +273,7 @@ static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
{
const lv_grid_t * grid = cont->grid;
const lv_grid_t * grid = cont->spec_attr->grid;
uint32_t i;
calc->row_num = grid->row_dsc_len;
@ -466,7 +472,9 @@ static lv_coord_t grid_place(lv_coord_t cont_size, bool auto_size, uint8_t plac
*/
static void report_grid_change_core(const lv_grid_t * grid, lv_obj_t * obj)
{
if(obj->grid == grid || (obj->grid && grid == NULL)) _lv_grid_full_refresh(obj);
if(obj->spec_attr) {
if(obj->spec_attr->grid == grid || (obj->spec_attr->grid && grid == NULL)) _lv_grid_full_refresh(obj);
}
lv_obj_t * child = lv_obj_get_child(obj, NULL);
while(child) {

2
src/lv_core/lv_grid.h
View File

@ -101,7 +101,7 @@ void lv_obj_set_grid(lv_obj_t * obj, const lv_grid_t * grid);
* @param obj pointer to an object
* @return the grid, NULL if no grid
*/
const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj, const lv_grid_t * grid);
const lv_grid_t * lv_obj_get_grid(lv_obj_t * obj);
/**

19
src/lv_core/lv_group.c
View File

@ -93,7 +93,7 @@ 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) {
(*obj)->group_p = NULL;
if((*obj)->spec_attr) (*obj)->spec_attr->group_p = NULL;
}
_lv_ll_clear(&(group->obj_ll));
@ -119,15 +119,18 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
}
/*If the object is already in a group and focused then defocus it*/
if(obj->group_p) {
lv_group_t * group_cur = lv_obj_get_group(obj);
if(group_cur) {
if(lv_obj_is_focused(obj)) {
lv_group_refocus(obj->group_p);
lv_group_refocus(group_cur);
LV_LOG_INFO("lv_group_add_obj: assign object to an other group");
}
}
obj->group_p = group;
if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
obj->spec_attr->group_p = group;
lv_obj_t ** next = _lv_ll_ins_tail(&group->obj_ll);
LV_ASSERT_MEM(next);
if(next == NULL) return;
@ -146,7 +149,7 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
*/
void lv_group_remove_obj(lv_obj_t * obj)
{
lv_group_t * g = obj->group_p;
lv_group_t * g = lv_obj_get_group(obj);
if(g == NULL) return;
if(g->obj_focus == NULL) return; /*Just to be sure (Not possible if there is at least one object in the group)*/
@ -177,7 +180,7 @@ void lv_group_remove_obj(lv_obj_t * obj)
if(*i == obj) {
_lv_ll_remove(&g->obj_ll, i);
lv_mem_free(i);
obj->group_p = NULL;
if(obj->spec_attr) obj->spec_attr->group_p = NULL;
break;
}
}
@ -199,7 +202,7 @@ 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) {
(*obj)->group_p = NULL;
if((*obj)->spec_attr) (*obj)->spec_attr->group_p = NULL;
}
_lv_ll_clear(&(group->obj_ll));
@ -212,7 +215,7 @@ void lv_group_remove_all_objs(lv_group_t * group)
void lv_group_focus_obj(lv_obj_t * obj)
{
if(obj == NULL) return;
lv_group_t * g = obj->group_p;
lv_group_t * g = lv_obj_get_group(obj);
if(g == NULL) return;
if(g->frozen != 0) return;

38
src/lv_core/lv_indev_scroll.c
View File

@ -81,10 +81,11 @@ void _lv_scroll_handler(lv_indev_proc_t * proc)
diff_y = elastic_diff(scroll_obj, proc->types.pointer.vect.y, st, sb);
}
if((scroll_obj->scroll_dir & LV_DIR_LEFT) == 0 && diff_x > 0) diff_x = 0;
if((scroll_obj->scroll_dir & LV_DIR_RIGHT) == 0 && diff_x < 0) diff_x = 0;
if((scroll_obj->scroll_dir & LV_DIR_TOP) == 0 && diff_y > 0) diff_y = 0;
if((scroll_obj->scroll_dir & LV_DIR_BOTTOM) == 0 && diff_y < 0) diff_y = 0;
lv_dir_t scroll_dir = lv_obj_get_scroll_dir(scroll_obj);
if((scroll_dir & LV_DIR_LEFT) == 0 && diff_x > 0) diff_x = 0;
if((scroll_dir & LV_DIR_RIGHT) == 0 && diff_x < 0) diff_x = 0;
if((scroll_dir & LV_DIR_TOP) == 0 && diff_y > 0) diff_y = 0;
if((scroll_dir & LV_DIR_BOTTOM) == 0 && diff_y < 0) diff_y = 0;
/*Respect the scroll limit area*/
scroll_limit_diff(proc, &diff_x, &diff_y);
@ -115,10 +116,13 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
proc->types.pointer.scroll_throw_vect.x = 0;
}
lv_scroll_snap_align_t align_x = lv_obj_get_snap_align_x(scroll_obj);
lv_scroll_snap_align_t align_y = lv_obj_get_snap_align_y(scroll_obj);
if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_VER) {
proc->types.pointer.scroll_throw_vect.x = 0;
/*If no snapping "throw"*/
if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
if(align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
proc->types.pointer.scroll_throw_vect.y =
proc->types.pointer.scroll_throw_vect.y * (100 - scroll_throw) / 100;
@ -141,7 +145,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
else if(proc->types.pointer.scroll_dir == LV_SCROLL_DIR_HOR) {
proc->types.pointer.scroll_throw_vect.y = 0;
/*If no snapping "throw"*/
if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
if(align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
proc->types.pointer.scroll_throw_vect.x =
proc->types.pointer.scroll_throw_vect.x * (100 - scroll_throw) / 100;
@ -166,7 +170,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
if(proc->types.pointer.scroll_throw_vect.x == 0 && proc->types.pointer.scroll_throw_vect.y == 0) {
/*Revert if scrolled in*/
/*If vertically scrollable and not controlled by snap*/
if(scroll_obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
if(align_y == LV_SCROLL_SNAP_ALIGN_NONE) {
lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
if(st > 0 || sb > 0) {
@ -180,7 +184,7 @@ void _lv_scroll_throw_handler(lv_indev_proc_t * proc)
}
/*If horizontally scrollable and not controlled by snap*/
if(scroll_obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
if(align_x == LV_SCROLL_SNAP_ALIGN_NONE) {
lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
if (sl > 0 || sr > 0) {
@ -276,7 +280,7 @@ static lv_obj_t * find_scroll_obj(lv_indev_proc_t * proc)
bool right_en = hor_en;
/*The object might have disabled some directions.*/
lv_dir_t scroll_dir = obj_act->scroll_dir;
lv_dir_t scroll_dir = lv_obj_get_scroll_dir(obj_act);
if((scroll_dir & LV_DIR_LEFT) == 0) left_en = false;
if((scroll_dir & LV_DIR_RIGHT) == 0) right_en = false;
if((scroll_dir & LV_DIR_TOP) == 0) up_en = false;
@ -347,7 +351,7 @@ static void init_scroll_limits(lv_indev_proc_t * proc)
}
/*With STOP limit the scrolling to the perv and next snap point*/
else {
switch(obj->snap_align_y) {
switch(lv_obj_get_snap_align_y(obj)) {
case LV_SCROLL_SNAP_ALIGN_START:
proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
@ -368,7 +372,7 @@ static void init_scroll_limits(lv_indev_proc_t * proc)
break;
}
switch(obj->snap_align_x) {
switch(lv_obj_get_snap_align_x(obj)) {
case LV_SCROLL_SNAP_ALIGN_START:
proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
@ -399,7 +403,8 @@ static void init_scroll_limits(lv_indev_proc_t * proc)
static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
{
if(obj->snap_align_x == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
lv_scroll_snap_align_t align = lv_obj_get_snap_align_x(obj);
if(align == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
lv_coord_t dist = LV_COORD_MAX;
@ -408,7 +413,7 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPABLE)) {
lv_coord_t x_child = 0;
lv_coord_t x_parent = 0;
switch(obj->snap_align_x) {
switch(align) {
case LV_SCROLL_SNAP_ALIGN_START:
x_child = child->coords.x1;
x_parent = obj->coords.x1;
@ -431,7 +436,6 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
child = lv_obj_get_child_back(obj, child);
}
LV_ASSERT_MEM_INTEGRITY();
return dist == LV_COORD_MAX ? 0: -dist;
}
@ -447,7 +451,8 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
*/
static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coord_t max, lv_coord_t ofs)
{
if(obj->snap_align_y == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
lv_scroll_snap_align_t align = lv_obj_get_snap_align_y(obj);
if(align == LV_SCROLL_SNAP_ALIGN_NONE) return 0;
lv_coord_t dist = LV_COORD_MAX;
@ -456,7 +461,7 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPABLE)) {
lv_coord_t y_child = 0;
lv_coord_t y_parent = 0;
switch(obj->snap_align_y) {
switch(align) {
case LV_SCROLL_SNAP_ALIGN_START:
y_child = child->coords.y1;
y_parent = obj->coords.y1;
@ -480,7 +485,6 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
child = lv_obj_get_child_back(obj, child);
}
LV_ASSERT_MEM_INTEGRITY();
return dist == LV_COORD_MAX ? 0 : -dist;
}

176
src/lv_core/lv_obj.c
View File

@ -204,16 +204,9 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
_lv_memset_00(new_obj, sizeof(lv_obj_t));
#if LV_USE_BIDI
new_obj->base_dir = LV_BIDI_BASE_DIR_DEF;
#else
new_obj->base_dir = LV_BIDI_DIR_LTR;
#endif
/*Set the callbacks*/
new_obj->signal_cb = lv_obj_signal;
new_obj->design_cb = lv_obj_design;
new_obj->event_cb = NULL;
/*Set coordinates to full screen size*/
new_obj->coords.x1 = 0;
@ -225,10 +218,10 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
else {
LV_LOG_TRACE("Object create started");
LV_ASSERT_OBJ(parent, LV_OBJX_NAME);
if(parent->rare_attr == NULL) {
parent->rare_attr = lv_obj_allocate_rare_attr(parent);
if(parent->spec_attr == NULL) {
parent->spec_attr = lv_obj_allocate_rare_attr(parent);
}
new_obj = _lv_ll_ins_head(&parent->rare_attr->child_ll);
new_obj = _lv_ll_ins_head(&parent->spec_attr->child_ll);
LV_ASSERT_MEM(new_obj);
if(new_obj == NULL) return NULL;
@ -236,16 +229,9 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
new_obj->parent = parent;
#if LV_USE_BIDI
new_obj->base_dir = LV_BIDI_DIR_INHERIT;
#else
new_obj->base_dir = LV_BIDI_DIR_LTR;
#endif
/*Set the callbacks (signal:cb is required in `lv_obj_get_base_dir` if `LV_USE_ASSERT_OBJ` is enabled)*/
new_obj->signal_cb = lv_obj_signal;
new_obj->design_cb = lv_obj_design;
new_obj->event_cb = NULL;
new_obj->coords.y1 = parent->coords.y1;
new_obj->coords.y2 = parent->coords.y1 + LV_OBJ_DEF_HEIGHT;
@ -264,25 +250,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
new_obj->ext_draw_pad = 0;
#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
_lv_memset_00(&new_obj->ext_click_pad, sizeof(new_obj->ext_click_pad));
#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
new_obj->ext_click_pad = 0;
#endif
/*Init. user date*/
#if LV_USE_USER_DATA
_lv_memset_00(&new_obj->user_data, sizeof(lv_obj_user_data_t));
#endif
#if LV_USE_GROUP
new_obj->group_p = NULL;
#endif
/*Set attributes*/
new_obj->scroll_mode = LV_SCROLL_MODE_AUTO;
new_obj->scroll_dir = LV_DIR_ALL;
new_obj->flags = LV_OBJ_FLAG_CLICKABLE;
new_obj->flags |= LV_OBJ_FLAG_SNAPABLE;
new_obj->flags |= LV_OBJ_FLAG_PRESS_LOCK;
@ -309,26 +277,12 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
lv_area_copy(&new_obj->coords, &copy->coords);
new_obj->ext_draw_pad = copy->ext_draw_pad;
#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
lv_area_copy(&new_obj->ext_click_pad, &copy->ext_click_pad);
#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
new_obj->ext_click_pad = copy->ext_click_pad;
#endif
/*Set user data*/
#if LV_USE_USER_DATA
_lv_memcpy(&new_obj->user_data, &copy->user_data, sizeof(lv_obj_user_data_t));
#endif
/*Only copy the `event_cb`. `signal_cb` and `design_cb` will be copied in the derived
* object type (e.g. `lv_btn`)*/
new_obj->event_cb = copy->event_cb;
new_obj->flags = copy->flags;
#if LV_USE_GROUP
/*Add to the same group*/
if(copy->group_p != NULL) {
lv_group_add_obj(copy->group_p, new_obj);
if(copy->spec_attr && copy->spec_attr->group_p) {
lv_group_add_obj(copy->spec_attr->group_p, new_obj);
}
#endif
@ -559,8 +513,8 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
lv_obj_invalidate(obj);
if(parent->rare_attr == NULL) {
parent->rare_attr = lv_obj_allocate_rare_attr(parent);
if(parent->spec_attr == NULL) {
parent->spec_attr = lv_obj_allocate_rare_attr(parent);
}
lv_obj_t * old_par = obj->parent;
@ -667,12 +621,14 @@ void lv_obj_set_ext_click_area(lv_obj_t * obj, lv_coord_t left, lv_coord_t right
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
obj->ext_click_pad.x1 = left;
obj->ext_click_pad.x2 = right;
obj->ext_click_pad.y1 = top;
obj->ext_click_pad.y2 = bottom;
if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
objrare_attr->->ext_click_pad.x1 = left;
objrare_attr->->ext_click_pad.x2 = right;
objrare_attr->->ext_click_pad.y1 = top;
objrare_attr->->ext_click_pad.y2 = bottom;
#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
obj->ext_click_pad = LV_MATH_MAX4(left, right, top, bottom);
if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
obj->spec_attr->ext_click_pad = LV_MATH_MAX4(left, right, top, bottom);
#else
LV_UNUSED(obj);
LV_UNUSED(left);
@ -704,7 +660,8 @@ void lv_obj_set_base_dir(lv_obj_t * obj, lv_bidi_dir_t dir)
return;
}
obj->base_dir = dir;
lv_obj_allocate_rare_attr(obj);
obj->spec_attr->base_dir = dir;
lv_signal_send(obj, LV_SIGNAL_BASE_DIR_CHG, NULL);
/* Notify the children about the parent base dir has changed.
@ -841,8 +798,9 @@ void lv_obj_clear_state(lv_obj_t * obj, lv_state_t state)
void lv_obj_set_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
if(obj->spec_attr == NULL) obj->spec_attr = lv_obj_allocate_rare_attr(obj);
obj->event_cb = event_cb;
obj->spec_attr->event_cb = event_cb;
}
/**
@ -859,7 +817,7 @@ lv_res_t lv_event_send(lv_obj_t * obj, lv_event_t event, const void * data)
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
lv_res_t res;
res = lv_event_send_func(obj->event_cb, obj, event, data);
res = lv_event_send_func(lv_obj_get_event_cb(obj), obj, event, data);
return res;
}
@ -1052,21 +1010,27 @@ void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size)
* @return pointer to the allocated ext.
* If out of memory NULL is returned and the original ext is preserved
*/
lv_obj_rare_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj)
lv_obj_spec_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
if(obj->rare_attr == NULL) {
obj->rare_attr = lv_mem_realloc(obj->ext_attr, sizeof(lv_obj_rare_attr_t));
LV_ASSERT_MEM(obj->rare_attr);
if(obj->rare_attr == NULL) return NULL;
if(obj->spec_attr == NULL) {
static uint32_t x = 0;
x++;
obj->spec_attr = lv_mem_alloc(sizeof(lv_obj_spec_attr_t));
LV_ASSERT_MEM(obj->spec_attr);
if(obj->spec_attr == NULL) return NULL;
_lv_memset_00(obj->rare_attr, sizeof(lv_obj_rare_attr_t));
_lv_ll_init(&(obj->rare_attr->child_ll), sizeof(lv_obj_t));
_lv_memset_00(obj->spec_attr, sizeof(lv_obj_spec_attr_t));
_lv_ll_init(&(obj->spec_attr->child_ll), sizeof(lv_obj_t));
obj->spec_attr->scroll_dir = LV_DIR_ALL;
obj->spec_attr->base_dir = LV_BIDI_DIR_INHERIT;
obj->spec_attr->scroll_mode = LV_SCROLL_MODE_AUTO;
}
return obj->rare_attr;
return obj->spec_attr;
}
@ -1272,7 +1236,8 @@ lv_coord_t lv_obj_get_ext_click_area(const lv_obj_t * obj, lv_dir_t dir)
return 0;
#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
LV_UNUSED(dir);
return obj->ext_click_pad;
if(obj->spec_attr) return obj->spec_attr->ext_click_pad;
else return 0;
#else
switch(dir) {
case LV_DIR_LEFT:
@ -1299,28 +1264,17 @@ lv_coord_t lv_obj_get_ext_click_area(const lv_obj_t * obj, lv_dir_t dir)
*/
bool _lv_obj_is_click_point_on(lv_obj_t * obj, const lv_point_t * point)
{
#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
lv_area_t ext_area;
ext_area.x1 = obj->coords.x1 - obj->ext_click_pad;
ext_area.x2 = obj->coords.x2 + obj->ext_click_pad;
ext_area.y1 = obj->coords.y1 - obj->ext_click_pad;
ext_area.y2 = obj->coords.y2 + obj->ext_click_pad;
if(!_lv_area_is_point_on(&ext_area, point, 0)) {
#elif LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_FULL
lv_area_t ext_area;
ext_area.x1 = obj->coords.x1 - obj->ext_click_pad.x1;
ext_area.x2 = obj->coords.x2 + obj->ext_click_pad.x2;
ext_area.y1 = obj->coords.y1 - obj->ext_click_pad.y1;
ext_area.y2 = obj->coords.y2 + obj->ext_click_pad.y2;
if(!_lv_area_is_point_on(&ext_area, point, 0)) {
#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_OFF
return _lv_area_is_point_on(&obj->coords, point, 0);
#else
if(!_lv_area_is_point_on(&obj->coords, point, 0)) {
lv_area_t ext_area;
ext_area.x1 = obj->coords.x1 - lv_obj_get_ext_click_area(obj, LV_DIR_LEFT);
ext_area.x2 = obj->coords.x2 + lv_obj_get_ext_click_area(obj, LV_DIR_RIGHT);
ext_area.y1 = obj->coords.y1 - lv_obj_get_ext_click_area(obj, LV_DIR_TOP);
ext_area.y2 = obj->coords.y2 + lv_obj_get_ext_click_area(obj, LV_DIR_BOTTOM);
return _lv_area_is_point_on(&ext_area, point, 0);
#endif
return false;
}
return true;
}
/**
@ -1362,11 +1316,15 @@ lv_bidi_dir_t lv_obj_get_base_dir(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
if(obj->spec_attr == NULL) return LV_BIDI_DIR_LTR;
#if LV_USE_BIDI
const lv_obj_t * parent = obj;
while(parent) {
if(parent->base_dir != LV_BIDI_DIR_INHERIT) return parent->base_dir;
/*If the base dir set use it. If not set assume INHERIT so got the next parent*/
if(parent->spec_attr) {
if(parent->spec_attr->base_dir != LV_BIDI_DIR_INHERIT) return parent->spec_attr->base_dir;
}
parent = lv_obj_get_parent(parent);
}
@ -1418,7 +1376,8 @@ lv_event_cb_t lv_obj_get_event_cb(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
return obj->event_cb;
if(obj->spec_attr) return obj->spec_attr->event_cb;
else return NULL;
}
/*------------------
@ -1477,9 +1436,10 @@ void lv_obj_get_type(const lv_obj_t * obj, lv_obj_type_t * buf)
*/
lv_obj_user_data_t lv_obj_get_user_data(const lv_obj_t * obj)
{
static lv_obj_user_data_t empty = {0};
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
return obj->user_data;
if(obj->spec_attr) return obj->spec_attr->user_data;
else return empty;
}
/**
@ -1491,7 +1451,8 @@ lv_obj_user_data_t * lv_obj_get_user_data_ptr(const lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
return (lv_obj_user_data_t *)&obj->user_data;
if(obj->spec_attr) return obj->spec_attr->user_data;
return &obj->spec_attr->user_data;
}
/**
@ -1503,7 +1464,8 @@ void lv_obj_set_user_data(lv_obj_t * obj, lv_obj_user_data_t data)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
_lv_memcpy(&obj->user_data, &data, sizeof(lv_obj_user_data_t));
if(obj->spec_attr == NULL) lv_obj_allocate_rare_attr(obj);
_lv_memcpy(&obj->spec_attr->user_data, &data, sizeof(lv_obj_user_data_t));
}
#endif
@ -1517,7 +1479,8 @@ void * lv_obj_get_group(const lv_obj_t * obj)
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
#if LV_USE_GROUP
return obj->group_p;
if(obj->spec_attr) return obj->spec_attr->group_p;
else return NULL;
#else
LV_UNUSED(obj);
return NULL;
@ -1534,8 +1497,9 @@ bool lv_obj_is_focused(const lv_obj_t * obj)
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
#if LV_USE_GROUP
if(obj->group_p) {
if(lv_group_get_focused(obj->group_p) == obj) return true;
lv_group_t * g = lv_obj_get_group(obj);
if(g) {
if(lv_group_get_focused(g) == obj) return true;
}
return false;
#else
@ -1565,7 +1529,7 @@ bool lv_obj_is_instance_of(lv_obj_t * obj, const char * type_str)
lv_ll_t * _lv_obj_get_child_ll(const lv_obj_t * obj)
{
if(obj->rare_attr) return &obj->rare_attr->child_ll;
if(obj->spec_attr) return &obj->spec_attr->child_ll;
else return NULL;
}
@ -1840,7 +1804,7 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
#if GRID_DEBUG
/*Draw the grid cells*/
if(obj->grid) {
if(lv_obj_get_grid(obj)) {
_lv_grid_calc_t calc;
_lv_grid_calc(obj, &calc);
@ -1887,7 +1851,7 @@ static void base_dir_refr_children(lv_obj_t * obj)
{
lv_obj_t * child;
_LV_LL_READ(_lv_obj_get_child_ll(obj), child) {
if(child->base_dir == LV_BIDI_DIR_INHERIT) {
if(lv_obj_get_base_dir(child) == LV_BIDI_DIR_INHERIT) {
lv_signal_send(child, LV_SIGNAL_BASE_DIR_CHG, NULL);
base_dir_refr_children(child);
}
@ -2006,8 +1970,8 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
lv_obj_set_size(child, child->w_set, child->h_set);
}
}
if(obj->grid) _lv_grid_full_refresh(obj);
if(obj->flex_cont.dir) _lv_flex_refresh(obj);
if(lv_obj_get_grid(obj)) _lv_grid_full_refresh(obj);
if(lv_obj_get_flex_dir(obj) != LV_FLEX_DIR_NONE) _lv_flex_refresh(obj);
}
}
else if(sign == LV_SIGNAL_CHILD_CHG) {
@ -2020,7 +1984,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
}
/*If the changed children was a grid item refresh this objects grid*/
if(obj->grid) {
if(lv_obj_get_grid(obj)) {
lv_obj_t * child = param;
if(child) {
if(_lv_obj_is_grid_item(child)) _lv_grid_full_refresh(obj);
@ -2046,7 +2010,7 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
else if(sign == LV_SIGNAL_STYLE_CHG) {
if(_lv_obj_is_grid_item(obj)) _lv_grid_full_refresh(obj);
if(obj->grid) _lv_grid_full_refresh(obj);
if(lv_obj_get_grid(obj)) _lv_grid_full_refresh(obj);
/*Reposition non grid objects on by one*/
lv_obj_t * child;

69
src/lv_core/lv_obj.h
View File

@ -169,20 +169,6 @@ enum {
typedef uint8_t lv_state_t;
enum {
LV_DIR_NONE = 0x00,
LV_DIR_LEFT = (1 << 0),
LV_DIR_RIGHT = (1 << 1),
LV_DIR_TOP = (1 << 2),
LV_DIR_BOTTOM = (1 << 3),
LV_DIR_HOR = LV_DIR_LEFT | LV_DIR_RIGHT,
LV_DIR_VER = LV_DIR_TOP | LV_DIR_BOTTOM,
LV_DIR_ALL = LV_DIR_HOR | LV_DIR_VER,
};
typedef uint8_t lv_dir_t;
enum {
LV_OBJ_FLAG_HIDDEN = (1 << 0),
LV_OBJ_FLAG_CLICKABLE = (1 << 1),
@ -210,22 +196,21 @@ typedef uint16_t lv_obj_flag_t;
typedef struct {
lv_ll_t child_ll; /**< Linked list to store the children objects*/
lv_point_t scroll; /**< The current X/Y scroll offset*/
}lv_obj_rare_attr_t;
#if LV_USE_GROUP != 0
void * group_p;
#endif
struct _lv_obj_t {
lv_obj_rare_attr_t * rare_attr;
struct _lv_obj_t * parent; /**< Pointer to the parent object*/
#if LV_USE_USER_DATA
lv_obj_user_data_t user_data; /**< Custom user data for object. */
#endif
lv_area_t coords; /**< Coordinates of the object (x1, y1, x2, y2)*/
const lv_grid_t * grid;
lv_event_cb_t event_cb; /**< Event callback function */
lv_signal_cb_t signal_cb; /**< Object type specific signal function*/
lv_design_cb_t design_cb; /**< Object type specific design function*/
void * ext_attr; /**< Object type specific extended data*/
lv_style_list_t style_list;
lv_flex_cont_t flex_cont;
lv_point_t scroll; /**< The current X/Y scroll offset*/
#if LV_USE_EXT_CLICK_AREA == LV_EXT_CLICK_AREA_TINY
uint8_t ext_click_pad; /**< Extra click padding in all direction */
@ -233,15 +218,28 @@ struct _lv_obj_t {
lv_area_t ext_click_pad; /**< Extra click padding area. */
#endif
lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
/*Attributes and states*/
lv_obj_flag_t flags;
lv_scroll_mode_t scroll_mode :2; /**< How to display scrollbars*/
lv_scroll_snap_align_t snap_align_x : 2;
lv_scroll_snap_align_t snap_align_y : 2;
lv_scroll_dir_t scroll_dir :4;
lv_bidi_dir_t base_dir : 2; /**< Base direction of texts related to this object */
}lv_obj_spec_attr_t;
struct _lv_obj_t {
lv_obj_spec_attr_t * spec_attr;
struct _lv_obj_t * parent; /**< Pointer to the parent object*/
lv_area_t coords; /**< Coordinates of the object (x1, y1, x2, y2)*/
lv_signal_cb_t signal_cb; /**< Object type specific signal function*/
lv_design_cb_t design_cb; /**< Object type specific design function*/
void * ext_attr; /**< Object type specific extended data*/
lv_style_list_t style_list;
/*Attributes and states*/
lv_obj_flag_t flags;
lv_state_t state;
@ -250,18 +248,7 @@ struct _lv_obj_t {
lv_coord_t w_set;
lv_coord_t h_set;
#if LV_USE_GROUP != 0
void * group_p;
#endif
#if LV_USE_USER_DATA
lv_obj_user_data_t user_data; /**< Custom user data for object. */
#endif
const lv_grid_t * grid;
lv_flex_cont_t flex_cont;
lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
};
enum {
@ -553,7 +540,7 @@ void lv_obj_set_design_cb(lv_obj_t * obj, lv_design_cb_t design_cb);
*/
void * lv_obj_allocate_ext_attr(lv_obj_t * obj, uint16_t ext_size);
lv_obj_rare_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj);
lv_obj_spec_attr_t * lv_obj_allocate_rare_attr(lv_obj_t * obj);
/*=======================
* Getter functions
*======================*/

6
src/lv_core/lv_obj_draw.c
View File

@ -437,8 +437,10 @@ void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
lv_coord_t obj_h = lv_obj_get_height(obj);
lv_coord_t obj_w = lv_obj_get_width(obj);
lv_scroll_dir_t dir = lv_obj_get_scroll_dir(obj);
bool ver_draw = false;
if((obj->scroll_dir & LV_DIR_VER) &&
if((dir & LV_DIR_VER) &&
((sm == LV_SCROLL_MODE_ON) ||
(sm == LV_SCROLL_MODE_AUTO && (st > 0 || sb > 0)) ||
(sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_VER))) {
@ -447,7 +449,7 @@ void _lv_obj_draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
bool hor_draw = false;
if((obj->scroll_dir & LV_DIR_HOR) &&
if((dir & LV_DIR_HOR) &&
((sm == LV_SCROLL_MODE_ON) ||
(sm == LV_SCROLL_MODE_AUTO && (sl > 0 || sr > 0)) ||
(sm == LV_SCROLL_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_SCROLL_DIR_HOR))) {

15
src/lv_core/lv_obj_pos.c
View File

@ -593,7 +593,7 @@ void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_o
/*Get the grid size of the object has a defined grid*/
lv_coord_t grid_w = 0;
lv_coord_t grid_h = 0;
if(obj->grid) {
if(lv_obj_get_grid(obj)) {
_lv_grid_calc_t calc;
_lv_grid_calc(obj, &calc);
grid_w = calc.grid_w + lv_obj_get_style_pad_left(obj, LV_OBJ_PART_MAIN) + lv_obj_get_style_pad_right(obj, LV_OBJ_PART_MAIN);
@ -714,11 +714,12 @@ bool _lv_obj_is_grid_item(lv_obj_t * obj)
{
lv_obj_t * cont = lv_obj_get_parent(obj);
if(cont == NULL) return false;
if(cont->grid == NULL) return false;
if(cont->grid->col_dsc == NULL) return false;
if(cont->grid->row_dsc == NULL) return false;
if(cont->grid->row_dsc_len == 0) return false;
if(cont->grid->col_dsc_len == 0) return false;
const lv_grid_t * g = lv_obj_get_grid(obj);
if(g == NULL) return false;
if(g->col_dsc == NULL) return false;
if(g->row_dsc == NULL) return false;
if(g->row_dsc_len == 0) return false;
if(g->col_dsc_len == 0) return false;
if(LV_COORD_IS_GRID(obj->x_set) == false || LV_COORD_IS_GRID(obj->y_set) == false) return false;
return true;
}
@ -733,7 +734,7 @@ bool _lv_obj_is_flex_item(struct _lv_obj_t * obj)
{
lv_obj_t * cont = lv_obj_get_parent(obj);
if(cont == NULL) return false;
if(cont->flex_cont.dir == LV_FLEX_DIR_NONE) return false;
if(lv_obj_get_flex_dir(cont) == LV_FLEX_DIR_NONE) return false;
if(LV_COORD_IS_FLEX(obj->x_set) == false || LV_COORD_IS_FLEX(obj->y_set) == false) return false;
return true;
}

80
src/lv_core/lv_obj_scroll.c
View File

@ -47,23 +47,13 @@ void lv_obj_set_scroll_mode(lv_obj_t * obj, lv_scroll_mode_t mode)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
if(obj->scroll_mode == mode) return;
obj->scroll_mode = mode;
lv_obj_allocate_rare_attr(obj);
if(obj->spec_attr->scroll_mode == mode) return;
obj->spec_attr->scroll_mode = mode;
lv_obj_invalidate(obj);
}
/**
* Get how the scrollbars should behave.
* @param obj pointer to an object
* @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
*/
lv_scroll_mode_t lv_obj_get_scroll_mode(lv_obj_t * obj)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
return obj->scroll_mode;
}
/**
* Moves all children with horizontally or vertically.
* It doesn't take into account any limits so any values are possible
@ -75,11 +65,11 @@ void _lv_obj_scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
{
if(x == 0 && y == 0) return;
if(obj->rare_attr == NULL) {
obj->rare_attr = lv_obj_allocate_rare_attr(obj);
if(obj->spec_attr == NULL) {
obj->spec_attr = lv_obj_allocate_rare_attr(obj);
}
obj->rare_attr->scroll.x += x;
obj->rare_attr->scroll.y += y;
obj->spec_attr->scroll.x += x;
obj->spec_attr->scroll.y += y;
_lv_obj_move_children_by(obj, x, y);
lv_res_t res = lv_signal_send(obj, LV_SIGNAL_SCROLL, NULL);
@ -177,8 +167,8 @@ void lv_obj_scroll_to_y(lv_obj_t * obj, lv_coord_t y, lv_anim_enable_t anim_en)
*/
lv_coord_t lv_obj_get_scroll_top(const lv_obj_t * obj)
{
if(obj->rare_attr == NULL) return 0;
return -obj->rare_attr->scroll.y;
if(obj->spec_attr == NULL) return 0;
return -obj->spec_attr->scroll.y;
}
/**
@ -226,8 +216,8 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
*/
lv_coord_t lv_obj_get_scroll_left(const lv_obj_t * obj)
{
if(obj->rare_attr == NULL) return 0;
return -obj->rare_attr->scroll.x;
if(obj->spec_attr == NULL) return 0;
return -obj->spec_attr->scroll.x;
}
/**
@ -281,6 +271,52 @@ void lv_obj_get_scroll_end(struct _lv_obj_t * obj, lv_point_t * end)
end->y = a ? -a->end : lv_obj_get_scroll_top(obj);
}
lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->scroll_dir;
else return LV_DIR_ALL;
}
void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir)
{
lv_obj_allocate_rare_attr(obj);
if(dir != obj->spec_attr->scroll_dir) {
obj->spec_attr->scroll_dir = dir;
lv_obj_invalidate(obj);
}
}
lv_scroll_mode_t lv_obj_get_scroll_mode(const struct _lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->scroll_mode;
else return LV_SCROLL_MODE_AUTO;
}
lv_scroll_snap_align_t lv_obj_get_snap_align_x(const struct _lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->snap_align_x;
else return LV_SCROLL_SNAP_ALIGN_NONE;
}
void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_scroll_snap_align_t align)
{
lv_obj_allocate_rare_attr(obj);
obj->spec_attr->snap_align_x = align;
}
lv_scroll_snap_align_t lv_obj_get_snap_align_y(const struct _lv_obj_t * obj)
{
if(obj->spec_attr) return obj->spec_attr->snap_align_y;
else return LV_SCROLL_SNAP_ALIGN_NONE;
}
void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_scroll_snap_align_t align)
{
lv_obj_allocate_rare_attr(obj);
obj->spec_attr->snap_align_y = align;
}
/**********************
* STATIC FUNCTIONS
**********************/

16
src/lv_core/lv_obj_scroll.h
View File

@ -55,12 +55,6 @@ typedef uint8_t lv_scroll_snap_align_t;
*/
void lv_obj_set_scroll_mode(struct _lv_obj_t * obj, lv_scroll_mode_t mode);
/**
* Get how the scrollbars should behave.
* @param obj pointer to an object
* @return mode: LV_SCROLL_MODE_ON/OFF/AUTO/ACTIVE
*/
lv_scroll_mode_t lv_obj_get_scroll_mode(struct _lv_obj_t * obj);
/**
* Moves all children with horizontally or vertically.
@ -148,6 +142,16 @@ lv_coord_t lv_obj_get_scroll_right(struct _lv_obj_t * obj);
*/
void lv_obj_get_scroll_end(struct _lv_obj_t * obj, lv_point_t * end);
lv_dir_t lv_obj_get_scroll_dir(const struct _lv_obj_t * obj);
void lv_obj_set_scroll_dir(struct _lv_obj_t * obj, lv_dir_t dir);
lv_scroll_mode_t lv_obj_get_scroll_mode(const struct _lv_obj_t * obj);
lv_scroll_snap_align_t lv_obj_get_snap_align_x(const struct _lv_obj_t * obj);
void lv_obj_set_snap_align_x(struct _lv_obj_t * obj, lv_scroll_snap_align_t align);
lv_scroll_snap_align_t lv_obj_get_snap_align_y(const struct _lv_obj_t * obj);
void lv_obj_set_snap_align_y(struct _lv_obj_t * obj, lv_scroll_snap_align_t align);
/**********************
* MACROS
**********************/

13
src/lv_misc/lv_area.h
View File

@ -78,6 +78,19 @@ enum {
};
typedef uint8_t lv_align_t;
enum {
LV_DIR_NONE = 0x00,
LV_DIR_LEFT = (1 << 0),
LV_DIR_RIGHT = (1 << 1),
LV_DIR_TOP = (1 << 2),
LV_DIR_BOTTOM = (1 << 3),
LV_DIR_HOR = LV_DIR_LEFT | LV_DIR_RIGHT,
LV_DIR_VER = LV_DIR_TOP | LV_DIR_BOTTOM,
LV_DIR_ALL = LV_DIR_HOR | LV_DIR_VER,
};
typedef uint8_t lv_dir_t;
/**********************
* GLOBAL PROTOTYPES

47
src/lv_misc/lv_mem.c
View File

@ -161,6 +161,11 @@ void * lv_mem_alloc(size_t size)
return &zero_mem;
}
// last_ent = NULL;
static uint32_t c = 0;
c++;
// if(c%10 == 0) printf("alloc:%d\n", c);
#ifdef LV_ARCH_64
/*Round the size up to 8*/
size = (size + 7) & (~0x7);
@ -171,27 +176,10 @@ void * lv_mem_alloc(size_t size)
void * alloc = NULL;
#if LV_MEM_CUSTOM == 0
static uint32_t defr = 0;
defr++;
if(defr > LV_MEM_FULL_DEFRAG_CNT) {
defr = 0;
lv_mem_defrag();
}
alloc = alloc_core(size);
if(alloc == NULL) {
LV_LOG_WARN("Perform defrag");
lv_mem_monitor_t mon;
lv_mem_monitor(&mon);
printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
(int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
(int)mon.free_biggest_size);
LV_LOG_TRACE("No more memory, try to defrag");
lv_mem_defrag();
lv_mem_monitor(&mon);
printf("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
(int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
(int)mon.free_biggest_size);
alloc = alloc_core(size);
}
@ -216,7 +204,12 @@ void * lv_mem_alloc(size_t size)
#endif
if(alloc == NULL) {
LV_LOG_WARN("Couldn't allocate memory");
LV_LOG_WARN("Couldn't allocate memory (%d bytes)", size);
lv_mem_monitor_t mon;
lv_mem_monitor(&mon);
LV_LOG_WARN("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d\n",
(int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
(int)mon.free_biggest_size);
}
else {
#if LV_MEM_CUSTOM == 0
@ -241,19 +234,23 @@ void lv_mem_free(const void * data)
if(data == &zero_mem) return;
if(data == NULL) return;
#if LV_MEM_ADD_JUNK
_lv_memset((void *)data, 0xbb, _lv_mem_get_size(data));
#endif
#if LV_ENABLE_GC == 0
/*e points to the header*/
lv_mem_ent_t * e = (lv_mem_ent_t *)((uint8_t *)data - sizeof(lv_mem_header_t));
# if LV_MEM_ADD_JUNK
_lv_memset((void *)data, 0xbb, _lv_mem_get_size(data));
# endif
#endif
/*Use custom, user defined free function*/
#if LV_MEM_CUSTOM == 0
e->header.s.used = 0;
static uint32_t defr = 0;
defr++;
if(defr > LV_MEM_FULL_DEFRAG_CNT) {
defr = 0;
lv_mem_defrag();
}
#else
#if LV_ENABLE_GC == 0
/*e points to the header*/

1
src/lv_misc/lv_task.c
View File

@ -407,6 +407,7 @@ static bool lv_task_exec(lv_task_t * task)
task_deleted = false;
task_created = false;
if(task->task_cb) task->task_cb(task);
LV_ASSERT_MEM_INTEGRITY();
/*Delete if it was a one shot lv_task*/
if(task_deleted == false) { /*The task might be deleted by itself as well*/