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

grid fuly works

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi 2020-08-30 20:05:50 +02:00
parent c801a2cfa2
commit 03fa6b492c
6 changed files with 466 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/lv_api_map.h
View File

@ -212,17 +212,17 @@ static inline void lv_chart_clear_serie(lv_obj_t * chart, lv_chart_series_t * se
static inline void lv_obj_align_origo(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs,
lv_coord_t y_ofs)
{
lv_obj_align_mid(obj, base, align, x_ofs, y_ofs);
// lv_obj_align_mid(obj, base, align, x_ofs, y_ofs);
}
static inline void lv_obj_align_origo_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs)
{
lv_obj_align_mid_y(obj, base, align, x_ofs);
// lv_obj_align_mid_y(obj, base, align, x_ofs);
}
static inline void lv_obj_align_origo_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs)
{
lv_obj_align_mid_y(obj, base, align, y_ofs);
// lv_obj_align_mid_y(obj, base, align, y_ofs);
}
#endif /*LV_USE_API_EXTENSION_V6*/

215
src/lv_core/lv_align.c
View File

@ -7,6 +7,7 @@
* INCLUDES
*********************/
#include "lv_align.h"
#include "lv_obj.h"
/*********************
* DEFINES
@ -19,6 +20,12 @@
/**********************
* STATIC PROTOTYPES
**********************/
static void calc_explicit(lv_obj_t * obj, _lv_grid_calc_t * calc);
static void calc_flow_row(lv_obj_t * obj, _lv_grid_calc_t * calc);
static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc);
static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc);
/**********************
* STATIC VARIABLES
@ -32,23 +39,17 @@
* GLOBAL FUNCTIONS
**********************/
void grid_calc(lv_grid_t * grid, _lv_grid_calc_t * calc)
void grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc)
{
calc->col_dsc_len = grid->col_dsc_len + 1;
calc->col_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_dsc_len);
calc->row_dsc_len = grid->row_dsc_len + 1;
calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
static uint32_t cnt = 0;
cnt++;
if(obj->grid == NULL) return;
calc->col_dsc[0] = 0;
calc->row_dsc[0] = 0;
printf("calc: %d (size: %d)\n", cnt, obj->grid->col_dsc_len);
if(obj->grid->col_dsc && obj->grid->row_dsc) calc_explicit(obj, calc);
else if(obj->grid->col_dsc && !obj->grid->row_dsc) calc_flow_row(obj, calc);
uint8_t i;
for(i = 0; i < grid->col_dsc_len; i++) {
calc->col_dsc[i + 1] = calc->col_dsc[i] + grid->col_dsc[i];
}
for(i = 0; i < grid->row_dsc_len; i++) {
calc->row_dsc[i + 1] = calc->row_dsc[i] + grid->row_dsc[i];
}
}
void grid_calc_free(_lv_grid_calc_t * calc)
@ -57,30 +58,182 @@ void grid_calc_free(_lv_grid_calc_t * calc)
_lv_mem_buf_release(calc->row_dsc);
}
uint8_t _lv_grid_get_col_type(lv_grid_t * grid, uint32_t col)
{
lv_coord_t x;
/*If explicitly defined get the column size else use the first column*/
if(col < grid->col_dsc_len) x = grid->col_dsc[col];
else x = grid->col_dsc[0];
if(_GRID_IS_FR(x)) return _GRID_CELL_SIZE_FR;
else if(_GRID_IS_AUTO(x)) return _GRID_CELL_SIZE_AUTO;
else return _GRID_CELL_SIZE_PX;
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;
uint32_t i;
for(i = 0; i < obj->grid->col_dsc_len; i++) {
if(_GRID_IS_FR(obj->grid->col_dsc[i])) return true;
}
return false;
}
uint8_t _lv_grid_get_row_type(lv_grid_t * grid, uint32_t row)
bool _lv_grid_has_fr_row(struct _lv_obj_t * obj)
{
lv_coord_t x;
/*If explicitly defined get the row size else use the first row*/
if(row < grid->row_dsc_len) x = grid->row_dsc[row];
else x = grid->row_dsc[0];
if(obj->grid == NULL) return false;
if(obj->grid->row_dsc == NULL) return false;
if(_GRID_IS_FR(x)) return _GRID_CELL_SIZE_FR;
else if(_GRID_IS_AUTO(x)) return _GRID_CELL_SIZE_AUTO;
else return _GRID_CELL_SIZE_PX;
uint32_t i;
for(i = 0; i < obj->grid->row_dsc_len; i++) {
if(_GRID_IS_FR(obj->grid->row_dsc[i])) return true;
}
return false;
}
/**********************
* STATIC FUNCTIONS
**********************/
static void calc_explicit(lv_obj_t * obj, _lv_grid_calc_t * calc)
{
calc_explicit_rows(obj, calc);
calc_explicit_cols(obj, calc);
}
static void calc_flow_row(lv_obj_t * obj, _lv_grid_calc_t * calc)
{
calc_explicit_cols(obj, calc);
calc_implicit_rows(obj, calc);
}
static void calc_explicit_cols(lv_obj_t * cont, _lv_grid_calc_t * calc)
{
lv_grid_t * grid = cont->grid;
uint32_t i;
lv_coord_t * cols_w = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->col_dsc_len);
uint32_t col_fr_cnt = 0;
lv_coord_t grid_w = 0;
bool auto_w = cont->w_set == LV_SIZE_AUTO ? true : false;
for(i = 0; i < grid->col_dsc_len; i++) {
lv_coord_t x = grid->col_dsc[i];
if(_GRID_IS_FR(x)) col_fr_cnt += _GRID_GET_FR(x);
else {
cols_w[i] = x;
grid_w += x;
}
}
lv_coord_t free_w = lv_obj_get_width_fit(cont) - grid_w;
for(i = 0; i < grid->col_dsc_len; i++) {
lv_coord_t x = grid->col_dsc[i];
if(_GRID_IS_FR(x)) {
if(auto_w) cols_w[i] = 0; /*Fr is considered zero if the cont has auto width*/
else {
lv_coord_t f = _GRID_GET_FR(x);
cols_w[i] = (free_w * f) / col_fr_cnt;
}
}
}
calc->col_dsc_len = grid->col_dsc_len + 1;
calc->col_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->col_dsc_len);
calc->col_dsc[0] = 0;
for(i = 0; i < grid->col_dsc_len; i++) {
calc->col_dsc[i + 1] = calc->col_dsc[i] + cols_w[i];
}
_lv_mem_buf_release(cols_w);
}
static void calc_explicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
{
lv_grid_t * grid = cont->grid;
uint32_t i;
calc_explicit_cols(cont, calc);
lv_coord_t * rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * grid->row_dsc_len);
uint32_t row_fr_cnt = 0;
lv_coord_t grid_h = 0;
bool auto_h = cont->h_set == LV_SIZE_AUTO ? true : false;
for(i = 0; i < grid->row_dsc_len; i++) {
lv_coord_t x = grid->row_dsc[i];
if(_GRID_IS_FR(x)) row_fr_cnt += _GRID_GET_FR(x);
else {
rows_h[i] = x;
grid_h += x;
}
}
lv_coord_t free_h = lv_obj_get_height_fit(cont) - grid_h;
for(i = 0; i < grid->row_dsc_len; i++) {
lv_coord_t x = grid->row_dsc[i];
if(_GRID_IS_FR(x)) {
if(auto_h) rows_h[i] = 0; /*Fr is considered zero if the obj has auto height*/
else {
lv_coord_t f = _GRID_GET_FR(x);
rows_h[i] = (free_h * f) / row_fr_cnt;
}
}
}
calc->row_dsc_len = grid->row_dsc_len + 1;
calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
calc->row_dsc[0] = 0;
for(i = 0; i < grid->row_dsc_len; i++) {
calc->row_dsc[i + 1] = calc->row_dsc[i] + rows_h[i];
}
_lv_mem_buf_release(rows_h);
}
static void calc_implicit_rows(lv_obj_t * cont, _lv_grid_calc_t * calc)
{
lv_grid_t * grid = cont->grid;
uint32_t child_cnt = lv_obj_count_children(cont);
uint32_t row_cnt = (child_cnt / grid->col_dsc_len) + 1;
/*At worst case all children is gird item prepare place for all of them*/
lv_coord_t * rows_h = _lv_mem_buf_get(sizeof(lv_coord_t) * row_cnt);
_lv_memset_00(rows_h, sizeof(lv_coord_t) * row_cnt);
uint32_t i;
lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
uint32_t col_i = 0;
uint32_t row_i = 0;
while(child) {
if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
rows_h[row_i] = LV_MATH_MAX(rows_h[row_i], lv_obj_get_height(child));
col_i++;
if(col_i == grid->col_dsc_len) {
col_i = 0;
row_i++;
}
}
child = lv_obj_get_child_back(cont, child);
}
calc->row_dsc_len = row_cnt + 1;
calc->row_dsc = _lv_mem_buf_get(sizeof(lv_coord_t) * calc->row_dsc_len);
calc->row_dsc[0] = 0;
for(i = 0; i < row_cnt; i++) {
calc->row_dsc[i + 1] = calc->row_dsc[i] + rows_h[i];
}
_lv_mem_buf_release(rows_h);
}

17
src/lv_core/lv_align.h
View File

@ -44,14 +44,13 @@ extern "C" {
#define _GRID_CELL_SIZE_PX 0 /* The cell size is set in pixels*/
#define _GRID_CELL_SIZE_FR 1 /* The cell size is set in free units*/
#define _GRID_CELL_SIZE_AUTO 2 /* The cell size is automatically set to content*/
#define LV_GRID_FR(x) (LV_COORD_MAX + (x))
#define LV_GRID_AUTO LV_COORD_AUTO
#define _GRID_IS_PX(x) ((_GRID_IS_FR(x) == false) && (_GRID_IS_AUTO(x) == false) ? true : false)
#define _GRID_IS_FR(x) (x > LV_COORD_MAX ? true : false)
#define _GRID_IS_AUTO(x) (x == LV_GRID_AUTO ? true : false)
#define _GRID_GET_FR(x) ((x) - LV_COORD_MAX)
/**
@ -62,7 +61,6 @@ extern "C" {
#define LV_GRID_CELL_END(pos, span) ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_END))
#define LV_GRID_CELL_CENTER(pos, span) ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_CENTER))
#define LV_GRID_CELL_STRETCH(pos, span) ((LV_COORD_MAX + (pos) + (span << _GRID_CELL_SHIFT)) | _GRID_CELL_FLAG(LV_GRID_STRETCH))
/**
* Special LV_GRID_CELL position to flow the object automatically.
* Both X (column) and Y (row) value needs to be AUTO or explicitly specified*/
@ -75,6 +73,9 @@ extern "C" {
* TYPEDEFS
**********************/
/* Can't include lv_obj.h because it includes this header file */
struct _lv_obj_t;
/**
* Describe how to flow LV_GRID_POS_AUTO elements
*/
@ -97,8 +98,8 @@ typedef struct {
typedef struct {
lv_coord_t * col_dsc;
lv_coord_t * row_dsc;
uint8_t col_dsc_len;
uint8_t row_dsc_len;
uint32_t col_dsc_len;
uint32_t row_dsc_len;
}_lv_grid_calc_t;
/**********************
@ -111,13 +112,13 @@ void lv_grid_set_template(lv_grid_t * grid, const lv_coord_t * col_dsc, const lv
void lv_grid_set_place_content(lv_grid_t * grid, uint8_t col_place, uint8_t row_place);
void grid_calc(lv_grid_t * grid, _lv_grid_calc_t * calc);
void grid_calc(struct _lv_obj_t * obj, _lv_grid_calc_t * calc);
void grid_calc_free(_lv_grid_calc_t * calc);
uint8_t _lv_grid_get_col_type(lv_grid_t * grid, uint32_t row);
bool _lv_grid_has_fr_col(struct _lv_obj_t * obj);
uint8_t _lv_grid_get_row_type(lv_grid_t * grid, uint32_t col);
bool _lv_grid_has_fr_row(struct _lv_obj_t * obj);
/**********************
* MACROS

353
src/lv_core/lv_obj.c
View File

@ -295,6 +295,8 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
new_obj->coords.x1 = parent->coords.x1;
new_obj->coords.x2 = parent->coords.x1 + LV_OBJ_DEF_WIDTH;
}
new_obj->w_set = lv_area_get_width(&new_obj->coords);
new_obj->h_set = lv_area_get_height(&new_obj->coords);
}
@ -390,6 +392,8 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
}
}
lv_obj_set_pos(new_obj, 0, 0);
/*Send a signal to the parent to notify it about the new child*/
if(parent != NULL) {
parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, new_obj);
@ -641,7 +645,7 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
}
/*Notify the original parent because one of its children is lost*/
old_par->signal_cb(old_par, LV_SIGNAL_CHILD_CHG, NULL);
old_par->signal_cb(old_par, LV_SIGNAL_CHILD_CHG, obj);
/*Notify the new parent about the child*/
parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);
@ -699,17 +703,17 @@ void lv_obj_move_background(lv_obj_t * obj)
* Coordinate set
* ------------------*/
static void refr_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
static void move_obj_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, bool notify_parent)
{
/*Convert x and y to absolute coordinates*/
lv_obj_t * par = obj->parent;
lv_obj_t * parent = obj->parent;
if(par) {
lv_coord_t pad_left = lv_obj_get_style_pad_left(par, LV_OBJ_PART_MAIN);
lv_coord_t pad_top = lv_obj_get_style_pad_top(par, LV_OBJ_PART_MAIN);
if(parent) {
lv_coord_t pad_left = lv_obj_get_style_pad_left(parent, LV_OBJ_PART_MAIN);
lv_coord_t pad_top = lv_obj_get_style_pad_top(parent, LV_OBJ_PART_MAIN);
x += pad_left + par->coords.x1 - lv_obj_get_scroll_left(par);
y += pad_top + par->coords.y1 - lv_obj_get_scroll_top(par);
x += pad_left + parent->coords.x1 - lv_obj_get_scroll_left(parent);
y += pad_top + parent->coords.y1 - lv_obj_get_scroll_top(parent);
} else {
/*If no parent then it's screen but screen can't be on a grid*/
if(_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->x_set)) {
@ -748,7 +752,7 @@ static void refr_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
obj->signal_cb(obj, LV_SIGNAL_COORD_CHG, &ori);
/*Send a signal to the parent too*/
if(par) par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
if(parent && notify_parent) parent->signal_cb(parent, LV_SIGNAL_CHILD_CHG, obj);
/*Invalidate the new area*/
lv_obj_invalidate(obj);
@ -757,15 +761,12 @@ static void refr_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
{
/* Do nothing if the size is not changed */
/* It is very important else recursive resizing can
* occur without size change*/
if(lv_obj_get_width(obj) == w && lv_obj_get_height(obj) == h) {
return false;
}
/*Invalidate the original area*/
lv_obj_invalidate(obj);
@ -797,77 +798,165 @@ static bool refr_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
/*Invalidate the new area*/
lv_obj_invalidate(obj);
return true;
}
bool lv_obj_is_grid_item(lv_obj_t * obj);
static void lv_grid_full_refr(lv_obj_t * cont);
static void lv_grid_refresh_item_pos(lv_obj_t * obj)
static void _grid_item_repos(lv_obj_t * cont, lv_obj_t * item, _lv_grid_calc_t * calc)
{
/*Calculate the grid*/
lv_obj_t * parent = lv_obj_get_parent(obj);
lv_coord_t * col_dsc;
lv_coord_t * row_dsc;
uint8_t col_num;
uint8_t row_num;
_lv_grid_calc_t calc;
grid_calc(parent->grid, &calc);
if(lv_obj_is_grid_item(item) == false) return;
uint8_t col_pos = _GRID_GET_CELL_POS(obj->x_set);
uint8_t col_span = _GRID_GET_CELL_SPAN(obj->x_set);
uint8_t row_pos = _GRID_GET_CELL_POS(obj->y_set);
uint8_t row_span = _GRID_GET_CELL_SPAN(obj->y_set);
uint8_t col_pos;
uint8_t col_span;
uint8_t row_pos;
uint8_t row_span;
lv_coord_t col_w = calc.col_dsc[col_pos + col_span] - calc.col_dsc[col_pos];
lv_coord_t row_h = calc.row_dsc[row_pos + row_span] - calc.row_dsc[row_pos];
if(cont->grid->row_dsc && cont->grid->col_dsc) {
col_pos = _GRID_GET_CELL_POS(item->x_set);
col_span = _GRID_GET_CELL_SPAN(item->x_set);
row_pos = _GRID_GET_CELL_POS(item->y_set);
row_span = _GRID_GET_CELL_SPAN(item->y_set);
} else {
col_span = 1;
row_span = 1;
uint8_t x_flag = _GRID_GET_CELL_FLAG(obj->x_set);
uint8_t y_flag = _GRID_GET_CELL_FLAG(obj->y_set);
uint32_t child_id = 0;
lv_obj_t * child = lv_obj_get_child_back(cont, NULL);
while(child) {
if(child == item) break;
if(_GRID_IS_CELL(child->x_set) && _GRID_IS_CELL(child->y_set)) {
child_id++;
}
child = lv_obj_get_child_back(cont, child);
}
col_pos = child_id % cont->grid->col_dsc_len;
row_pos = child_id / cont->grid->col_dsc_len;
}
lv_coord_t col_w = calc->col_dsc[col_pos + col_span] - calc->col_dsc[col_pos];
lv_coord_t row_h = calc->row_dsc[row_pos + row_span] - calc->row_dsc[row_pos];
uint8_t x_flag = _GRID_GET_CELL_FLAG(item->x_set);
uint8_t y_flag = _GRID_GET_CELL_FLAG(item->y_set);
lv_coord_t x;
lv_coord_t y;
lv_coord_t w = lv_obj_get_width(obj);
lv_coord_t h = lv_obj_get_height(obj);
lv_coord_t w = lv_obj_get_width(item);
lv_coord_t h = lv_obj_get_height(item);
switch(x_flag) {
case LV_GRID_START:
x = calc.col_dsc[col_pos];
x = calc->col_dsc[col_pos];
break;
case LV_GRID_STRETCH:
x = calc.col_dsc[col_pos];
x = calc->col_dsc[col_pos];
w = col_w;
item->w_set = LV_SIZE_STRETCH;
break;
case LV_GRID_CENTER:
x = calc.col_dsc[col_pos] + (col_w - w) / 2;
x = calc->col_dsc[col_pos] + (col_w - w) / 2;
break;
case LV_GRID_END:
x = calc.col_dsc[col_pos + 1] - lv_obj_get_width(obj);
x = calc->col_dsc[col_pos + 1] - lv_obj_get_width(item);
break;
}
switch(y_flag) {
case LV_GRID_START:
y = calc.row_dsc[row_pos];
y = calc->row_dsc[row_pos];
break;
case LV_GRID_STRETCH:
y = calc.row_dsc[row_pos];
y = calc->row_dsc[row_pos];
item->h_set = LV_SIZE_STRETCH;
h = row_h;
break;
case LV_GRID_CENTER:
y = calc.row_dsc[row_pos] + (row_h - h) / 2;
y = calc->row_dsc[row_pos] + (row_h - h) / 2;
break;
case LV_GRID_END:
y = calc.row_dsc[row_pos + 1] - lv_obj_get_height(obj);
y = calc->row_dsc[row_pos + 1] - lv_obj_get_height(item);
break;
}
refr_pos(obj, x, y);
refr_size(obj, w, h);
/*Set a new size if required*/
if(lv_obj_get_width(item) != w || lv_obj_get_height(item) != h) {
lv_area_t old_coords;
lv_area_copy(&old_coords, &item->coords);
lv_obj_invalidate(item);
lv_area_set_width(&item->coords, w);
lv_area_set_height(&item->coords, h);
lv_obj_invalidate(item);
item->signal_cb(item, LV_SIGNAL_COORD_CHG, &old_coords);
/* If a children is a grid container and has an FR field it also needs to be updated
* because the FR cell size will change with child size change. */
lv_obj_t * child = lv_obj_get_child(item, NULL);
while(child) {
if(_lv_grid_has_fr_col(child) || _lv_grid_has_fr_row(child)) {
lv_grid_full_refr(child);
}
child = lv_obj_get_child(item, child);
}
}
move_obj_to(item, x, y, false);
}
bool lv_obj_is_content_sensitive(lv_obj_t * item)
{
if(lv_obj_is_grid_item(item) == false) return false;
lv_obj_t * cont = lv_obj_get_parent(item);
if(cont->grid->col_dsc == NULL && _GRID_GET_CELL_FLAG(item->x_set) == LV_GRID_STRETCH) return true;
if(cont->grid->row_dsc == NULL && _GRID_GET_CELL_FLAG(item->y_set) == LV_GRID_STRETCH) return true;
return false;
}
static void lv_grid_full_refr(lv_obj_t * cont)
{
/*Calculate the grid*/
if(cont->grid == NULL) return;
_lv_grid_calc_t calc;
grid_calc(cont, &calc);
lv_obj_t * item = lv_obj_get_child_back(cont, NULL);
while(item) {
_grid_item_repos(cont, item, &calc);
item = lv_obj_get_child_back(cont, item);
}
grid_calc_free(&calc);
if(cont->w_set == LV_SIZE_AUTO || cont->h_set == LV_SIZE_AUTO) {
lv_obj_set_size(cont, cont->w_set, cont->h_set);
}
}
static void lv_grid_item_refr_pos(lv_obj_t * item)
{
/*Calculate the grid*/
lv_obj_t * cont = lv_obj_get_parent(item);
if(cont->grid == NULL) return;
_lv_grid_calc_t calc;
grid_calc(cont, &calc);
_grid_item_repos(cont, item, &calc);
grid_calc_free(&calc);
}
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(_GRID_IS_CELL(obj->x_set) && _GRID_IS_CELL(obj->y_set)) return true;
return false;
}
/**
* Set relative the position of an object (relative to the parent)
@ -882,11 +971,34 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
obj->x_set = x;
obj->y_set = y;
/*If the object is on a grid item let grid to position it. */
if(_GRID_IS_CELL(obj->x_set) && _GRID_IS_CELL(obj->x_set)) {
lv_grid_refresh_item_pos(obj);
bool gi = lv_obj_is_grid_item(obj);
/*For consistency set the size to stretched if the objects is stretched on the grid*/
if(gi) {
if(_GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH) obj->w_set = LV_SIZE_STRETCH;
if(_GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH) obj->h_set = LV_SIZE_STRETCH;
}
/*If not grid item but has grid position set the position to 0*/
if(!gi) {
if(_GRID_IS_CELL(x)) {
obj->x_set = 0;
x = 0;
}
if(_GRID_IS_CELL(y)) {
obj->y_set = 0;
y = 0;
}
}
/*If the object is on a grid item let the grid to position it. */
if(gi) {
lv_obj_t * cont = lv_obj_get_parent(obj);
/*If added to a grid with auto flow refresh the whole grid else just this item*/
if(cont->grid->col_dsc == NULL || cont->grid->row_dsc == NULL) lv_grid_full_refr(cont);
else lv_grid_item_refr_pos(obj);
} else {
refr_pos(obj, x, y);
move_obj_to(obj, x, y, true);
}
}
@ -914,6 +1026,52 @@ void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
lv_obj_set_pos(obj, lv_obj_get_x(obj), y);
}
void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h)
{
if(!w && !h) return;
static uint32_t cnt = 0;
printf("auto_size: %d\n", cnt);
cnt++;
/*If no other effect the auto-size of zero by default*/
if(w) *w = 0;
if(h) *h = 0;
/*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) {
_lv_grid_calc_t calc;
grid_calc(obj, &calc);
grid_w = calc.col_dsc[calc.col_dsc_len - 1];
grid_h = calc.row_dsc[calc.row_dsc_len - 1];
grid_calc_free(&calc);
}
/*Get the children's most right and bottom position*/
lv_coord_t children_w = 0;
lv_coord_t children_h = 0;
if(w) {
lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
children_w = lv_obj_get_width(obj) + scroll_right;
}
if(h) {
static uint32_t cnt = 0;
// printf("auto_size_scrl: %d\n", cnt);
cnt++;
lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
children_h = lv_obj_get_height(obj) + scroll_bottom;
}
/*auto_size = max(gird_size, children_size)*/
if(w) *w = LV_MATH_MAX(children_w, grid_w);
if(h) *h = LV_MATH_MAX(children_h, grid_h);
}
/**
* Set the size of an object
* @param obj pointer to an object
@ -924,55 +1082,47 @@ void lv_obj_set_size(lv_obj_t * obj, lv_coord_t w, lv_coord_t h)
{
LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
bool gi = lv_obj_is_grid_item(obj);
bool x_stretch = false;
bool y_stretch = false;
if(gi) {
x_stretch = _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH ? true : false;
y_stretch = _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH ? true : false;
if(x_stretch) w = LV_SIZE_STRETCH;
if(y_stretch) h = LV_SIZE_STRETCH;
}
obj->w_set = w;
obj->h_set = h;
/*If the object is a grid element and stretched, prevent settings its size */
bool x_stretch = false;
bool y_stretch = false;
x_stretch = _GRID_GET_CELL_FLAG(obj->x_set) == LV_GRID_STRETCH ? true : false;
y_stretch = _GRID_GET_CELL_FLAG(obj->y_set) == LV_GRID_STRETCH ? true : false;
/*If both streched it was alraedy managed by the grid*/
if(x_stretch && y_stretch) return;
lv_coord_t grid_w = 0;
lv_coord_t grid_h = 0;
if(((LV_COORD_IS_AUTO(obj->w_set) && !x_stretch) ||
(LV_COORD_IS_AUTO(obj->h_set) && !y_stretch))) {
_lv_grid_calc_t calc;
grid_calc(obj->grid, &calc);
grid_w = calc.col_dsc[calc.col_dsc_len - 1];
grid_h = calc.row_dsc[calc.row_dsc_len - 1];
grid_calc_free(&calc);
}
if(x_stretch) w = lv_obj_get_width(obj);
else {
if(LV_COORD_IS_AUTO(obj->w_set)) {
lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
w = lv_obj_get_width(obj) + scroll_right;
w = LV_MATH_MAX(w, grid_w);
}
}
if(y_stretch) h = lv_obj_get_height(obj);
else {
if(LV_COORD_IS_AUTO(obj->h_set) && !x_stretch) {
lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
h = lv_obj_get_height(obj) + scroll_bottom;
h = LV_MATH_MAX(h, grid_h);
}
/*Calculate the required auto sizes*/
bool x_auto = obj->w_set == LV_SIZE_AUTO ? true : false;
bool y_auto = obj->h_set == LV_SIZE_AUTO ? true : false;
lv_coord_t auto_w;
lv_coord_t auto_h;
if(x_auto && y_auto) {
_lv_obj_calc_auto_size(obj, &auto_w, &auto_h);
w = auto_w;
h = auto_h;
}
else if(x_auto) {
_lv_obj_calc_auto_size(obj, &auto_w, NULL);
w = auto_w;
}
else if(y_auto) {
_lv_obj_calc_auto_size(obj, NULL, &auto_h);
h = auto_h;
}
bool chg = refr_size(obj, w, h);
/*Refresh the position in the grid item if required*/
if(chg && (_GRID_IS_CELL(obj->x_set) || _GRID_IS_CELL(obj->y_set))) {
lv_grid_refresh_item_pos(obj);
}
}
/**
@ -1528,7 +1678,7 @@ void lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t prop
case LV_STYLE_MARGIN_BOTTOM:
case LV_STYLE_MARGIN_LEFT:
case LV_STYLE_MARGIN_RIGHT:
if(obj->parent) obj->parent->signal_cb(obj->parent, LV_SIGNAL_CHILD_CHG, NULL);
if(obj->parent) obj->parent->signal_cb(obj->parent, LV_SIGNAL_CHILD_CHG, obj);
break;
}
@ -3909,8 +4059,6 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
}
}
else if(mode == LV_DESIGN_DRAW_POST) {
scrollbar_draw(obj, clip_area);
if(lv_obj_get_style_clip_corner(obj, LV_OBJ_PART_MAIN)) {
@ -3979,9 +4127,34 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
lv_res_t res = LV_RES_OK;
if(sign == LV_SIGNAL_CHILD_CHG) {
if(sign == LV_SIGNAL_COORD_CHG) {
if((lv_area_get_width(param) != lv_obj_get_width(obj) && _lv_grid_has_fr_col(obj)) ||
(lv_area_get_height(param) != lv_obj_get_height(obj) && _lv_grid_has_fr_row(obj)))
{
lv_grid_full_refr(obj);
}
}
else if(sign == LV_SIGNAL_CHILD_CHG) {
/*Return 'invalid' if the child change signal is not enabled*/
if(lv_obj_is_protected(obj, LV_PROTECT_CHILD_CHG) != false) res = LV_RES_INV;
if(obj->w_set == LV_SIZE_AUTO || obj->h_set == LV_SIZE_AUTO) {
lv_obj_set_size(obj, obj->w_set, obj->h_set);
}
if(obj->grid) {
lv_obj_t * child = param;
if(child) {
if(lv_obj_is_grid_item(child)) lv_grid_full_refr(obj);
} else {
lv_grid_full_refr(obj);
}
}
// else if(lv_obj_is_content_sensitive(obj)) {
// lv_grid_full_refr(lv_obj_get_parent(obj));
// }
}
else if(sign == LV_SIGNAL_SCROLL) {

3
src/lv_core/lv_obj.h
View File

@ -422,6 +422,9 @@ void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x);
*/
void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y);
void _lv_obj_calc_auto_size(lv_obj_t * obj, lv_coord_t * w, lv_coord_t * h);
/**
* Set the size of an object
* @param obj pointer to an object

7
src/lv_misc/lv_area.h
View File

@ -210,10 +210,11 @@ void _lv_area_align(const lv_area_t * base, const lv_area_t * to_align, lv_align
**********************/
#define LV_COORD_PX(x) (x)
#define LV_COORD_AUTO (LV_COORD_MAX - 1)
#define LV_SIZE_AUTO (LV_COORD_MAX - 1)
#define LV_SIZE_STRETCH (LV_COORD_MAX - 2)
#define LV_COORD_IS_PX(x) (((x) < LV_COORD_MAX) ? true : false)
#define LV_COORD_IS_AUTO(x) (((x) == LV_COORD_AUTO) ? true : false)
#define LV_COORD_IS_PX(x) (((x) < LV_COORD_MAX - 2) ? true : false)
#define LV_COORD_IS_AUTO(x) (((x) == LV_SIZE_AUTO) ? true : false)
#ifdef __cplusplus