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

further api updates (begin to move signal function as static)

Browse Source
This commit is contained in:
Gabor Kiss-Vamosi 2017-11-05 00:48:57 +01:00
parent c517d73a71
commit 44818d3527
39 changed files with 1624 additions and 1369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lv_draw/lv_draw.c
View File

@ -245,13 +245,13 @@ void lv_draw_label(const area_t * coords,const area_t * mask, const lv_style_t *
w = area_get_width(coords); w = area_get_width(coords);
} else { } else {
point_t p; point_t p;
txt_get_size(&p, txt, style->text.font, style->text.space_letter, style->text.space_line, CORD_MAX, flag); txt_get_size(&p, txt, style->text.font, style->text.letter_space, style->text.line_space, CORD_MAX, flag);
w = p.x; w = p.x;
} }
/*Init variables for the first line*/ /*Init variables for the first line*/
cord_t line_length = 0; cord_t line_length = 0;
uint32_t line_start = 0; uint32_t line_start = 0;
uint32_t line_end = txt_get_next_line(txt, font, style->text.space_letter, w, flag); uint32_t line_end = txt_get_next_line(txt, font, style->text.letter_space, w, flag);
point_t pos; point_t pos;
pos.x = coords->x1; pos.x = coords->x1;
@ -260,7 +260,7 @@ void lv_draw_label(const area_t * coords,const area_t * mask, const lv_style_t *
/*Align the line to middle if enabled*/ /*Align the line to middle if enabled*/
if(flag & TXT_FLAG_CENTER) { if(flag & TXT_FLAG_CENTER) {
line_length = txt_get_width(&txt[line_start], line_end - line_start, line_length = txt_get_width(&txt[line_start], line_end - line_start,
font, style->text.space_letter, flag); font, style->text.letter_space, flag);
pos.x += (w - line_length) / 2; pos.x += (w - line_length) / 2;
} }
@ -322,25 +322,25 @@ void lv_draw_label(const area_t * coords,const area_t * mask, const lv_style_t *
color_t color = style->text.color; color_t color = style->text.color;
if(cmd_state == CMD_STATE_IN) color = recolor; if(cmd_state == CMD_STATE_IN) color = recolor;
letter_fp(&pos, mask, font, letter, color, style->body.opa); letter_fp(&pos, mask, font, letter, color, style->text.opa);
pos.x += (font_get_width(font, letter) >> FONT_ANTIALIAS) + style->text.space_letter; pos.x += (font_get_width(font, letter) >> FONT_ANTIALIAS) + style->text.letter_space;
} }
/*Go to next line*/ /*Go to next line*/
line_start = line_end; line_start = line_end;
line_end += txt_get_next_line(&txt[line_start], font, style->text.space_letter, w, flag); line_end += txt_get_next_line(&txt[line_start], font, style->text.letter_space, w, flag);
pos.x = coords->x1; pos.x = coords->x1;
/*Align to middle*/ /*Align to middle*/
if(flag & TXT_FLAG_CENTER) { if(flag & TXT_FLAG_CENTER) {
line_length = txt_get_width(&txt[line_start], line_end - line_start, line_length = txt_get_width(&txt[line_start], line_end - line_start,
font, style->text.space_letter, flag); font, style->text.letter_space, flag);
pos.x += (w - line_length) / 2; pos.x += (w - line_length) / 2;
} }
/*Go the next line position*/ /*Go the next line position*/
pos.y += font_get_height(font) >> FONT_ANTIALIAS; pos.y += font_get_height(font) >> FONT_ANTIALIAS;
pos.y += style->text.space_line; pos.y += style->text.line_space;
} }
} }
@ -395,7 +395,7 @@ void lv_draw_img(const area_t * coords, const area_t * mask,
const_data = true; const_data = true;
uint8_t * f_data = ((ufs_file_t*)file.file_d)->ent->data_d; uint8_t * f_data = ((ufs_file_t*)file.file_d)->ent->data_d;
f_data += sizeof(lv_img_raw_header_t); f_data += sizeof(lv_img_raw_header_t);
map_fp(coords, &mask_com, (void*)f_data , style->body.opa, header.transp, upscale, style->image.color, style->image.intense); map_fp(coords, &mask_com, (void*)f_data , style->image.opa, header.transp, upscale, style->image.color, style->image.intense);
} }
#endif #endif
@ -429,7 +429,7 @@ void lv_draw_img(const area_t * coords, const area_t * mask,
for(row = mask_com.y1; row <= mask_com.y2; row += us_val) { for(row = mask_com.y1; row <= mask_com.y2; row += us_val) {
res = fs_read(&file, buf, useful_data, &br); res = fs_read(&file, buf, useful_data, &br);
map_fp(&line, &mask_com, buf, style->body.opa, header.transp, upscale, map_fp(&line, &mask_com, buf, style->image.opa, header.transp, upscale,
style->image.color, style->image.intense); style->image.color, style->image.intense);
fs_tell(&file, &act_pos); fs_tell(&file, &act_pos);
@ -515,7 +515,7 @@ void lv_draw_line(const point_t * p1, const point_t * p2, const area_t * mask,
draw_area.x2 = MATH_MAX(act_area.x1, act_area.x2); draw_area.x2 = MATH_MAX(act_area.x1, act_area.x2);
draw_area.y1 = MATH_MIN(act_area.y1, act_area.y2); draw_area.y1 = MATH_MIN(act_area.y1, act_area.y2);
draw_area.y2 = MATH_MAX(act_area.y1, act_area.y2); draw_area.y2 = MATH_MAX(act_area.y1, act_area.y2);
fill_fp(&draw_area, mask, style->line.color, style->body.opa); fill_fp(&draw_area, mask, style->line.color, style->line.opa);
} }
if (hor == false && last_x != act_point.x) { if (hor == false && last_x != act_point.x) {
area_t act_area; area_t act_area;
@ -531,7 +531,7 @@ void lv_draw_line(const point_t * p1, const point_t * p2, const area_t * mask,
draw_area.x2 = MATH_MAX(act_area.x1, act_area.x2); draw_area.x2 = MATH_MAX(act_area.x1, act_area.x2);
draw_area.y1 = MATH_MIN(act_area.y1, act_area.y2); draw_area.y1 = MATH_MIN(act_area.y1, act_area.y2);
draw_area.y2 = MATH_MAX(act_area.y1, act_area.y2); draw_area.y2 = MATH_MAX(act_area.y1, act_area.y2);
fill_fp(&draw_area, mask, style->line.color, style->body.opa); fill_fp(&draw_area, mask, style->line.color, style->line.opa);
} }
/*Calc. the next point of the line*/ /*Calc. the next point of the line*/
@ -559,7 +559,7 @@ void lv_draw_line(const point_t * p1, const point_t * p2, const area_t * mask,
draw_area.x2 = MATH_MAX(act_area.x1, act_area.x2); draw_area.x2 = MATH_MAX(act_area.x1, act_area.x2);
draw_area.y1 = MATH_MIN(act_area.y1, act_area.y2); draw_area.y1 = MATH_MIN(act_area.y1, act_area.y2);
draw_area.y2 = MATH_MAX(act_area.y1, act_area.y2); draw_area.y2 = MATH_MAX(act_area.y1, act_area.y2);
fill_fp(&draw_area, mask, style->line.color, style->body.opa); fill_fp(&draw_area, mask, style->line.color, style->line.opa);
} }
if (hor == false) { if (hor == false) {
area_t act_area; area_t act_area;
@ -573,7 +573,7 @@ void lv_draw_line(const point_t * p1, const point_t * p2, const area_t * mask,
draw_area.x2 = MATH_MAX(act_area.x1, act_area.x2); draw_area.x2 = MATH_MAX(act_area.x1, act_area.x2);
draw_area.y1 = MATH_MIN(act_area.y1, act_area.y2); draw_area.y1 = MATH_MIN(act_area.y1, act_area.y2);
draw_area.y2 = MATH_MAX(act_area.y1, act_area.y2); draw_area.y2 = MATH_MAX(act_area.y1, act_area.y2);
fill_fp(&draw_area, mask, style->line.color, style->body.opa); fill_fp(&draw_area, mask, style->line.color, style->line.opa);
} }
} }

1
lv_obj/lv_indev.c
View File

@ -144,6 +144,7 @@ void lv_indev_get_point(lv_indev_t * indev, point_t * point)
*/ */
bool lv_indev_is_dragging(lv_indev_t * indev) bool lv_indev_is_dragging(lv_indev_t * indev)
{ {
if(indev == NULL) return false;
return indev->state.drag_in_prog == 0 ? false : true; return indev->state.drag_in_prog == 0 ? false : true;
} }

8
lv_obj/lv_indev.h
View File

@ -24,14 +24,6 @@ extern "C" {
* TYPEDEFS * TYPEDEFS
**********************/ **********************/
typedef enum
{
LV_RES_INV = 0, /*Typically indicates that the object is deleted (become invalid) in the action function*/
LV_RES_OK, /*The object is valid (no deleted) after the action*/
}lv_res_t;
typedef lv_res_t (*lv_action_t) (struct __LV_OBJ_T * obj);
/********************** /**********************
* GLOBAL PROTOTYPES * GLOBAL PROTOTYPES
**********************/ **********************/

8
lv_obj/lv_obj.h
View File

@ -134,6 +134,14 @@ typedef struct __LV_OBJ_T
#endif #endif
}lv_obj_t; }lv_obj_t;
typedef enum
{
LV_RES_INV = 0, /*Typically indicates that the object is deleted (become invalid) in the action function*/
LV_RES_OK, /*The object is valid (no deleted) after the action*/
}lv_res_t;
typedef lv_res_t (*lv_action_t) (struct __LV_OBJ_T * obj);
/*Protect some attributes (max. 8 bit)*/ /*Protect some attributes (max. 8 bit)*/
typedef enum typedef enum
{ {

11
lv_obj/lv_style.c
View File

@ -86,14 +86,17 @@ void lv_style_init (void)
lv_style_scr.body.shadow.type = LV_SHADOW_FULL; lv_style_scr.body.shadow.type = LV_SHADOW_FULL;
lv_style_scr.body.shadow.width = 0; lv_style_scr.body.shadow.width = 0;
lv_style_scr.text.opa = OPA_COVER;
lv_style_scr.text.color = COLOR_MAKE(0x20, 0x20, 0x20); lv_style_scr.text.color = COLOR_MAKE(0x20, 0x20, 0x20);
lv_style_scr.text.font = FONT_DEFAULT; lv_style_scr.text.font = FONT_DEFAULT;
lv_style_scr.text.space_letter = 1 << LV_ANTIALIAS; lv_style_scr.text.letter_space = 1 << LV_ANTIALIAS;
lv_style_scr.text.space_line = 2 << LV_ANTIALIAS; lv_style_scr.text.line_space = 2 << LV_ANTIALIAS;
lv_style_scr.image.opa = OPA_COVER;
lv_style_scr.image.color = COLOR_MAKE(0x20, 0x20, 0x20); lv_style_scr.image.color = COLOR_MAKE(0x20, 0x20, 0x20);
lv_style_scr.image.intense = OPA_TRANSP; lv_style_scr.image.intense = OPA_TRANSP;
lv_style_scr.line.opa = OPA_COVER;
lv_style_scr.line.color = COLOR_MAKE(0x20, 0x20, 0x20); lv_style_scr.line.color = COLOR_MAKE(0x20, 0x20, 0x20);
lv_style_scr.line.width = 1 << LV_ANTIALIAS; lv_style_scr.line.width = 1 << LV_ANTIALIAS;
@ -256,8 +259,8 @@ static void lv_style_aimator(lv_style_anim_dsc_t * dsc, int32_t val)
STYLE_ATTR_ANIM(body.padding.hor, val); STYLE_ATTR_ANIM(body.padding.hor, val);
STYLE_ATTR_ANIM(body.padding.ver, val); STYLE_ATTR_ANIM(body.padding.ver, val);
STYLE_ATTR_ANIM(body.padding.inner, val); STYLE_ATTR_ANIM(body.padding.inner, val);
STYLE_ATTR_ANIM(text.space_line, val); STYLE_ATTR_ANIM(text.line_space, val);
STYLE_ATTR_ANIM(text.space_letter, val); STYLE_ATTR_ANIM(text.letter_space, val);
STYLE_ATTR_ANIM(line.width, val); STYLE_ATTR_ANIM(line.width, val);
STYLE_ATTR_ANIM(image.intense, val); STYLE_ATTR_ANIM(image.intense, val);

7
lv_obj/lv_style.h
View File

@ -70,18 +70,21 @@ typedef struct
struct { struct {
color_t color; color_t color;
const font_t * font; const font_t * font;
cord_t space_letter; cord_t letter_space;
cord_t space_line; cord_t line_space;
opa_t opa;
}text; }text;
struct { struct {
color_t color; color_t color;
opa_t intense; opa_t intense;
opa_t opa;
}image; }image;
struct { struct {
color_t color; color_t color;
cord_t width; cord_t width;
opa_t opa;
}line; }line;
}lv_style_t; }lv_style_t;

34
lv_objx/lv_bar.c
View File

@ -63,7 +63,7 @@ lv_obj_t * lv_bar_create(lv_obj_t * par, lv_obj_t * copy)
dm_assert(ext); dm_assert(ext);
ext->min_value = 0; ext->min_value = 0;
ext->max_value = 100; ext->max_value = 100;
ext->act_value = 0; ext->cur_value = 0;
ext->style_inicator = &lv_style_pretty_color; ext->style_inicator = &lv_style_pretty_color;
/* Save the ancient design function. /* Save the ancient design function.
@ -78,17 +78,17 @@ lv_obj_t * lv_bar_create(lv_obj_t * par, lv_obj_t * copy)
lv_obj_set_click(new_bar, false); lv_obj_set_click(new_bar, false);
lv_obj_set_size(new_bar, LV_DPI * 2, LV_DPI / 3); lv_obj_set_size(new_bar, LV_DPI * 2, LV_DPI / 3);
lv_obj_set_style(new_bar, &lv_style_pretty); lv_obj_set_style(new_bar, &lv_style_pretty);
lv_bar_set_value(new_bar, ext->act_value); lv_bar_set_value(new_bar, ext->cur_value);
} else { } else {
lv_bar_ext_t * ext_copy = lv_obj_get_ext_attr(copy); lv_bar_ext_t * ext_copy = lv_obj_get_ext_attr(copy);
ext->min_value = ext_copy->min_value; ext->min_value = ext_copy->min_value;
ext->max_value = ext_copy->max_value; ext->max_value = ext_copy->max_value;
ext->act_value = ext_copy->act_value; ext->cur_value = ext_copy->cur_value;
ext->style_inicator = ext_copy->style_inicator; ext->style_inicator = ext_copy->style_inicator;
/*Refresh the style with new signal function*/ /*Refresh the style with new signal function*/
lv_obj_refresh_style(new_bar); lv_obj_refresh_style(new_bar);
lv_bar_set_value(new_bar, ext->act_value); lv_bar_set_value(new_bar, ext->cur_value);
} }
return new_bar; return new_bar;
} }
@ -131,8 +131,8 @@ bool lv_bar_signal(lv_obj_t * bar, lv_signal_t sign, void * param)
void lv_bar_set_value(lv_obj_t * bar, int16_t value) void lv_bar_set_value(lv_obj_t * bar, int16_t value)
{ {
lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar); lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
ext->act_value = value > ext->max_value ? ext->max_value : value; ext->cur_value = value > ext->max_value ? ext->max_value : value;
ext->act_value = ext->act_value < ext->min_value ? ext->min_value : ext->act_value; ext->cur_value = ext->cur_value < ext->min_value ? ext->min_value : ext->cur_value;
lv_obj_invalidate(bar); lv_obj_invalidate(bar);
} }
@ -152,7 +152,7 @@ void lv_bar_set_value_anim(lv_obj_t * bar, int16_t value, uint16_t anim_time)
anim_t a; anim_t a;
a.var = bar; a.var = bar;
a.start = ext->act_value; a.start = ext->cur_value;
a.end = new_value; a.end = new_value;
a.fp = (anim_fp_t)lv_bar_set_value; a.fp = (anim_fp_t)lv_bar_set_value;
a.path = anim_get_path(ANIM_PATH_LIN); a.path = anim_get_path(ANIM_PATH_LIN);
@ -180,13 +180,13 @@ void lv_bar_set_range(lv_obj_t * bar, int16_t min, int16_t max)
lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar); lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
ext->max_value = max; ext->max_value = max;
ext->min_value = min; ext->min_value = min;
if(ext->act_value > max) { if(ext->cur_value > max) {
ext->act_value = max; ext->cur_value = max;
lv_bar_set_value(bar, ext->act_value); lv_bar_set_value(bar, ext->cur_value);
} }
if(ext->act_value < min) { if(ext->cur_value < min) {
ext->act_value = min; ext->cur_value = min;
lv_bar_set_value(bar, ext->act_value); lv_bar_set_value(bar, ext->cur_value);
} }
lv_obj_invalidate(bar); lv_obj_invalidate(bar);
} }
@ -197,7 +197,7 @@ void lv_bar_set_range(lv_obj_t * bar, int16_t min, int16_t max)
* @param bg pointer to the background's style (NULL to leave unchanged) * @param bg pointer to the background's style (NULL to leave unchanged)
* @param indic pointer to the indicator's style (NULL to leave unchanged) * @param indic pointer to the indicator's style (NULL to leave unchanged)
*/ */
void lv_bar_set_styles(lv_obj_t * bar, lv_style_t * bg, lv_style_t * indic) void lv_bar_set_style(lv_obj_t * bar, lv_style_t * bg, lv_style_t * indic)
{ {
lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar); lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
@ -223,7 +223,7 @@ void lv_bar_set_styles(lv_obj_t * bar, lv_style_t * bg, lv_style_t * indic)
int16_t lv_bar_get_value(lv_obj_t * bar) int16_t lv_bar_get_value(lv_obj_t * bar)
{ {
lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar); lv_bar_ext_t * ext = lv_obj_get_ext_attr(bar);
return ext->act_value; return ext->cur_value;
} }
/** /**
@ -298,10 +298,10 @@ static bool lv_bar_design(lv_obj_t * bar, const area_t * mask, lv_design_mode_t
cord_t h = area_get_height(&indic_area); cord_t h = area_get_height(&indic_area);
if(w >= h) { if(w >= h) {
indic_area.x2 = (int32_t) ((int32_t)w * (ext->act_value - ext->min_value)) / (ext->max_value - ext->min_value); indic_area.x2 = (int32_t) ((int32_t)w * (ext->cur_value - ext->min_value)) / (ext->max_value - ext->min_value);
indic_area.x2 += indic_area.x1; indic_area.x2 += indic_area.x1;
} else { } else {
indic_area.y1 = (int32_t) ((int32_t)h * (ext->act_value - ext->min_value)) / (ext->max_value - ext->min_value); indic_area.y1 = (int32_t) ((int32_t)h * (ext->cur_value - ext->min_value)) / (ext->max_value - ext->min_value);
indic_area.y1 = indic_area.y2 - indic_area.y1; indic_area.y1 = indic_area.y2 - indic_area.y1;
} }

4
lv_objx/lv_bar.h
View File

@ -34,7 +34,7 @@ typedef struct
{ {
/*No inherited ext*/ /*Ext. of ancestor*/ /*No inherited ext*/ /*Ext. of ancestor*/
/*New data for this type */ /*New data for this type */
int16_t act_value; /*Current value of the bar*/ int16_t cur_value; /*Current value of the bar*/
int16_t min_value; /*Minimum value of the bar*/ int16_t min_value; /*Minimum value of the bar*/
int16_t max_value; /*Maximum value of the bar*/ int16_t max_value; /*Maximum value of the bar*/
lv_style_t *style_inicator; /*Style of the indicator*/ lv_style_t *style_inicator; /*Style of the indicator*/
@ -90,7 +90,7 @@ void lv_bar_set_range(lv_obj_t * bar, int16_t min, int16_t max);
* @param bg pointer to the background's style * @param bg pointer to the background's style
* @param indic pointer to the indicator's style * @param indic pointer to the indicator's style
*/ */
void lv_bar_set_styles(lv_obj_t * bar, lv_style_t * bg, lv_style_t * indic); void lv_bar_set_style(lv_obj_t * bar, lv_style_t * bg, lv_style_t * indic);
/** /**
* Get the value of a bar * Get the value of a bar

241
lv_objx/lv_btn.c
View File

@ -28,13 +28,12 @@
/********************** /**********************
* STATIC PROTOTYPES * STATIC PROTOTYPES
**********************/ **********************/
#if 0 static lv_signal_func_t ancestor_signal;
static bool lv_btn_design(lv_obj_t * btn, const area_t * mask, lv_design_mode_t mode);
#endif
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static lv_res_t lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param);
/********************** /**********************
* MACROS * MACROS
@ -56,6 +55,8 @@ lv_obj_t * lv_btn_create(lv_obj_t * par, lv_obj_t * copy)
new_btn = lv_cont_create(par, copy); new_btn = lv_cont_create(par, copy);
dm_assert(new_btn); dm_assert(new_btn);
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_btn);
/*Allocate the extended data*/ /*Allocate the extended data*/
lv_btn_ext_t * ext = lv_obj_allocate_ext_attr(new_btn, sizeof(lv_btn_ext_t)); lv_btn_ext_t * ext = lv_obj_allocate_ext_attr(new_btn, sizeof(lv_btn_ext_t));
dm_assert(ext); dm_assert(ext);
@ -79,7 +80,7 @@ lv_obj_t * lv_btn_create(lv_obj_t * par, lv_obj_t * copy)
/*If no copy do the basic initialization*/ /*If no copy do the basic initialization*/
if(copy == NULL) { if(copy == NULL) {
lv_cont_set_layout(new_btn, LV_CONT_LAYOUT_CENTER); lv_btn_set_layout(new_btn, LV_CONT_LAYOUT_CENTER);
lv_obj_set_style(new_btn, ext->styles[LV_BTN_STATE_RELEASED]); lv_obj_set_style(new_btn, ext->styles[LV_BTN_STATE_RELEASED]);
} }
/*Copy 'copy'*/ /*Copy 'copy'*/
@ -97,118 +98,6 @@ lv_obj_t * lv_btn_create(lv_obj_t * par, lv_obj_t * copy)
return new_btn; return new_btn;
} }
/**
* Signal function of the button
* @param btn pointer to a button object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
*/
bool lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
{
bool valid;
/* Include the ancient signal function */
valid = lv_cont_signal(btn, sign, param);
/* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(valid != false) {
lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
lv_btn_state_t state = lv_btn_get_state(btn);
bool tgl = lv_btn_get_toggle(btn);
if(sign == LV_SIGNAL_PRESSED) {
/*Refresh the state*/
if(ext->state == LV_BTN_STATE_RELEASED) {
lv_btn_set_state(btn, LV_BTN_STATE_PRESSED);
} else if(ext->state == LV_BTN_STATE_TGL_RELEASED) {
lv_btn_set_state(btn, LV_BTN_STATE_TGL_PRESSED);
}
ext->long_press_action_executed = 0;
/*Call the press action, 'param' is the caller indev_proc*/
if(ext->actions[LV_BTN_ACTION_PRESS] && state != LV_BTN_STATE_INACTIVE) {
valid = ext->actions[LV_BTN_ACTION_PRESS](btn);
}
}
else if(sign == LV_SIGNAL_PRESS_LOST) {
/*Refresh the state*/
if(ext->state == LV_BTN_STATE_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
else if(ext->state == LV_BTN_STATE_TGL_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
}
else if(sign == LV_SIGNAL_PRESSING) {
/*When the button begins to drag revert pressed states to released*/
if(lv_indev_is_dragging(param) != false) {
if(ext->state == LV_BTN_STATE_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
else if(ext->state == LV_BTN_STATE_TGL_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
}
}
else if(sign == LV_SIGNAL_RELEASED) {
/*If not dragged and it was not long press action then
*change state and run the action*/
if(lv_indev_is_dragging(param) == false && ext->long_press_action_executed == 0) {
if(ext->state == LV_BTN_STATE_PRESSED && tgl == false) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
} else if(ext->state == LV_BTN_STATE_TGL_PRESSED && tgl == false) {
lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
} else if(ext->state == LV_BTN_STATE_PRESSED && tgl == true) {
lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
} else if(ext->state == LV_BTN_STATE_TGL_PRESSED && tgl == true) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
}
if(ext->actions[LV_BTN_ACTION_RELEASE] && state != LV_BTN_STATE_INACTIVE) {
valid = ext->actions[LV_BTN_ACTION_RELEASE](btn);
}
} else { /*If dragged change back the state*/
if(ext->state == LV_BTN_STATE_PRESSED) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
} else if(ext->state == LV_BTN_STATE_TGL_PRESSED) {
lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
}
}
}
else if(sign == LV_SIGNAL_LONG_PRESS) {
if(ext->actions[LV_BTN_ACTION_LONG_PRESS] && state != LV_BTN_STATE_INACTIVE) {
ext->long_press_action_executed = 1;
valid = ext->actions[LV_BTN_ACTION_LONG_PRESS](btn);
}
}
else if(sign == LV_SIGNAL_LONG_PRESS_REP) {
if(ext->actions[LV_BTN_ACTION_LONG_PRESS_REPEATE] && state != LV_BTN_STATE_INACTIVE) {
valid = ext->actions[LV_BTN_ACTION_LONG_PRESS_REPEATE](btn);
}
}
else if(sign == LV_SIGNAL_CONTROLL) {
char c = *((char*)param);
if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_UP) {
if(lv_btn_get_toggle(btn) != false) lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
if(ext->actions[LV_BTN_ACTION_RELEASE] && lv_btn_get_state(btn) != LV_BTN_STATE_INACTIVE) {
valid = ext->actions[LV_BTN_ACTION_RELEASE];
}
} else if(c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_DOWN) {
if(lv_btn_get_toggle(btn) != false) lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
if(ext->actions[LV_BTN_ACTION_RELEASE] && lv_btn_get_state(btn) != LV_BTN_STATE_INACTIVE) {
valid = ext->actions[LV_BTN_ACTION_RELEASE](btn);
}
} else if(c == LV_GROUP_KEY_ENTER) {
if(lv_btn_get_toggle(btn) != false) {
lv_btn_state_t state = lv_btn_get_state(btn);
if(state == LV_BTN_STATE_RELEASED) lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
else if(state == LV_BTN_STATE_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_TGL_PRESSED);
else if(state == LV_BTN_STATE_TGL_RELEASED) lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
else if(state == LV_BTN_STATE_TGL_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_PRESSED);
}
if(ext->actions[LV_BTN_ACTION_RELEASE] && lv_btn_get_state(btn) != LV_BTN_STATE_INACTIVE) {
valid = ext->actions[LV_BTN_ACTION_RELEASE](btn);
}
}
}
}
return valid;
}
/*===================== /*=====================
* Setter functions * Setter functions
*====================*/ *====================*/
@ -354,28 +243,118 @@ lv_style_t * lv_btn_get_style(lv_obj_t * btn, lv_btn_state_t state)
* STATIC FUNCTIONS * STATIC FUNCTIONS
**********************/ **********************/
#if 0
/** /**
* Handle the drawing related tasks of the buttons * Signal function of the button
* @param btn pointer to a button object * @param btn pointer to a button object
* @param mask the object will be drawn only in this area * @param sign a signal type from lv_signal_t enum
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area * @param param pointer to a signal specific variable
* (return 'true' if yes) * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
* LV_DESIGN_DRAW: draw the object (always return 'true')
* LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @param return true/false, depends on 'mode'
*/ */
static bool lv_btn_design(lv_obj_t * btn, const area_t * mask, lv_design_mode_t mode) static lv_res_t lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
{ {
lv_res_t res;
/* Because of the radius it is not sure the area is covered*/ /* Include the ancient signal function */
if(mode == LV_DESIGN_COVER_CHK) { res = ancestor_signal(btn, sign, param);
return false;
} else if(mode == LV_DESIGN_DRAW_MAIN || mode == LV_DESIGN_DRAW_POST) { /* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(res == LV_RES_OK) {
lv_btn_ext_t * ext = lv_obj_get_ext_attr(btn);
lv_btn_state_t state = lv_btn_get_state(btn);
bool tgl = lv_btn_get_toggle(btn);
if(sign == LV_SIGNAL_PRESSED) {
/*Refresh the state*/
if(ext->state == LV_BTN_STATE_RELEASED) {
lv_btn_set_state(btn, LV_BTN_STATE_PRESSED);
} else if(ext->state == LV_BTN_STATE_TGL_RELEASED) {
lv_btn_set_state(btn, LV_BTN_STATE_TGL_PRESSED);
}
ext->long_press_action_executed = 0;
/*Call the press action, 'param' is the caller indev_proc*/
if(ext->actions[LV_BTN_ACTION_PRESS] && state != LV_BTN_STATE_INACTIVE) {
res = ext->actions[LV_BTN_ACTION_PRESS](btn);
}
}
else if(sign == LV_SIGNAL_PRESS_LOST) {
/*Refresh the state*/
if(ext->state == LV_BTN_STATE_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
else if(ext->state == LV_BTN_STATE_TGL_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
}
else if(sign == LV_SIGNAL_PRESSING) {
/*When the button begins to drag revert pressed states to released*/
if(lv_indev_is_dragging(param) != false) {
if(ext->state == LV_BTN_STATE_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
else if(ext->state == LV_BTN_STATE_TGL_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
}
}
else if(sign == LV_SIGNAL_RELEASED) {
/*If not dragged and it was not long press action then
*change state and run the action*/
if(lv_indev_is_dragging(param) == false && ext->long_press_action_executed == 0) {
if(ext->state == LV_BTN_STATE_PRESSED && tgl == false) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
} else if(ext->state == LV_BTN_STATE_TGL_PRESSED && tgl == false) {
lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
} else if(ext->state == LV_BTN_STATE_PRESSED && tgl == true) {
lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
} else if(ext->state == LV_BTN_STATE_TGL_PRESSED && tgl == true) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
}
if(ext->actions[LV_BTN_ACTION_RELEASE] && state != LV_BTN_STATE_INACTIVE) {
res = ext->actions[LV_BTN_ACTION_RELEASE](btn);
}
} else { /*If dragged change back the state*/
if(ext->state == LV_BTN_STATE_PRESSED) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
} else if(ext->state == LV_BTN_STATE_TGL_PRESSED) {
lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
}
}
}
else if(sign == LV_SIGNAL_LONG_PRESS) {
if(ext->actions[LV_BTN_ACTION_LONG_PRESS] && state != LV_BTN_STATE_INACTIVE) {
ext->long_press_action_executed = 1;
res = ext->actions[LV_BTN_ACTION_LONG_PRESS](btn);
}
}
else if(sign == LV_SIGNAL_LONG_PRESS_REP) {
if(ext->actions[LV_BTN_ACTION_LONG_PRESS_REPEATE] && state != LV_BTN_STATE_INACTIVE) {
res = ext->actions[LV_BTN_ACTION_LONG_PRESS_REPEATE](btn);
}
}
else if(sign == LV_SIGNAL_CONTROLL) {
char c = *((char*)param);
if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_UP) {
if(lv_btn_get_toggle(btn) != false) lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
if(ext->actions[LV_BTN_ACTION_RELEASE] && lv_btn_get_state(btn) != LV_BTN_STATE_INACTIVE) {
res = ext->actions[LV_BTN_ACTION_RELEASE](btn);
}
} else if(c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_DOWN) {
if(lv_btn_get_toggle(btn) != false) lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
if(ext->actions[LV_BTN_ACTION_RELEASE] && lv_btn_get_state(btn) != LV_BTN_STATE_INACTIVE) {
res = ext->actions[LV_BTN_ACTION_RELEASE](btn);
}
} else if(c == LV_GROUP_KEY_ENTER) {
if(lv_btn_get_toggle(btn) != false) {
lv_btn_state_t state = lv_btn_get_state(btn);
if(state == LV_BTN_STATE_RELEASED) lv_btn_set_state(btn, LV_BTN_STATE_TGL_RELEASED);
else if(state == LV_BTN_STATE_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_TGL_PRESSED);
else if(state == LV_BTN_STATE_TGL_RELEASED) lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
else if(state == LV_BTN_STATE_TGL_PRESSED) lv_btn_set_state(btn, LV_BTN_STATE_PRESSED);
}
if(ext->actions[LV_BTN_ACTION_RELEASE] && lv_btn_get_state(btn) != LV_BTN_STATE_INACTIVE) {
res = ext->actions[LV_BTN_ACTION_RELEASE](btn);
}
}
}
} }
return true;
return res;
} }
#endif
#endif #endif

13
lv_objx/lv_btn.h
View File

@ -78,14 +78,6 @@ typedef struct
*/ */
lv_obj_t * lv_btn_create(lv_obj_t * par, lv_obj_t * copy); lv_obj_t * lv_btn_create(lv_obj_t * par, lv_obj_t * copy);
/**
* Signal function of the button
* @param btn pointer to a button object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
*/
bool lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param);
/** /**
* Enable the toggled states * Enable the toggled states
* @param btn pointer to a button object * @param btn pointer to a button object
@ -155,7 +147,6 @@ lv_action_t lv_btn_get_action(lv_obj_t * btn, lv_btn_action_t type);
*/ */
lv_style_t * lv_btn_get_style(lv_obj_t * btn, lv_btn_state_t state); lv_style_t * lv_btn_get_style(lv_obj_t * btn, lv_btn_state_t state);
/**************************** /****************************
* TRANSPARENT API FUNCTIONS * TRANSPARENT API FUNCTIONS
***************************/ ***************************/
@ -199,7 +190,7 @@ static inline lv_cont_layout_t lv_btn_get_layout(lv_obj_t * btn)
*/ */
static inline bool lv_btn_get_hor_fit(lv_obj_t * btn) static inline bool lv_btn_get_hor_fit(lv_obj_t * btn)
{ {
return lv_cont_get_fit_hor(btn); return lv_cont_get_hor_fit(btn);
} }
/** /**
@ -209,7 +200,7 @@ static inline bool lv_btn_get_hor_fit(lv_obj_t * btn)
*/ */
static inline bool lv_btn_get_ver_fit(lv_obj_t * btn) static inline bool lv_btn_get_ver_fit(lv_obj_t * btn)
{ {
return lv_cont_get_fit_ver(btn); return lv_cont_get_ver_fit(btn);
} }
/********************** /**********************

16
lv_objx/lv_btnm.c
View File

@ -383,7 +383,7 @@ void lv_btnm_set_toggle(lv_obj_t * btnm, bool en, uint16_t id)
* @param tgl_pr pointer to a style for toggled pressed state * @param tgl_pr pointer to a style for toggled pressed state
* @param ina pointer to a style for inactive state * @param ina pointer to a style for inactive state
*/ */
void lv_btnm_set_style(lv_obj_t *btnm, lv_style_t *rel, lv_style_t *pr, void lv_btnm_set_style_btn(lv_obj_t *btnm, lv_style_t *rel, lv_style_t *pr,
lv_style_t *tgl_rel, lv_style_t *tgl_pr, lv_style_t *tgl_rel, lv_style_t *tgl_pr,
lv_style_t *ina) lv_style_t *ina)
@ -431,7 +431,7 @@ lv_btnm_action_t lv_btnm_get_action(lv_obj_t * btnm)
* @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL) * @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL)
* @return pointer the button style in the given state * @return pointer the button style in the given state
*/ */
lv_style_t * lv_btnm_get_button_style(lv_obj_t * btnm, lv_btn_state_t state) lv_style_t * lv_btnm_get_style_btn(lv_obj_t * btnm, lv_btn_state_t state)
{ {
if(state >= LV_BTN_STATE_NUM) return lv_obj_get_style(btnm); if(state >= LV_BTN_STATE_NUM) return lv_obj_get_style(btnm);
@ -497,18 +497,18 @@ static bool lv_btnm_design(lv_obj_t * btnm, const area_t * mask, lv_design_mode_
btn_h = area_get_height(&area_tmp); btn_h = area_get_height(&area_tmp);
/*Load the style*/ /*Load the style*/
if(button_is_inactive(ext->map_p[txt_i])) btn_style = lv_btnm_get_button_style(btnm, LV_BTN_STATE_INACTIVE); if(button_is_inactive(ext->map_p[txt_i])) btn_style = lv_btnm_get_style_btn(btnm, LV_BTN_STATE_INACTIVE);
else if(btn_i != ext->button_id_pressed && btn_i != ext->button_id_toggled) btn_style = lv_btnm_get_button_style(btnm, LV_BTN_STATE_RELEASED); else if(btn_i != ext->button_id_pressed && btn_i != ext->button_id_toggled) btn_style = lv_btnm_get_style_btn(btnm, LV_BTN_STATE_RELEASED);
else if(btn_i == ext->button_id_pressed && btn_i != ext->button_id_toggled) btn_style = lv_btnm_get_button_style(btnm, LV_BTN_STATE_PRESSED); else if(btn_i == ext->button_id_pressed && btn_i != ext->button_id_toggled) btn_style = lv_btnm_get_style_btn(btnm, LV_BTN_STATE_PRESSED);
else if(btn_i != ext->button_id_pressed && btn_i == ext->button_id_toggled) btn_style = lv_btnm_get_button_style(btnm, LV_BTN_STATE_TGL_RELEASED); else if(btn_i != ext->button_id_pressed && btn_i == ext->button_id_toggled) btn_style = lv_btnm_get_style_btn(btnm, LV_BTN_STATE_TGL_RELEASED);
else if(btn_i == ext->button_id_pressed && btn_i == ext->button_id_toggled) btn_style = lv_btnm_get_button_style(btnm, LV_BTN_STATE_TGL_PRESSED); else if(btn_i == ext->button_id_pressed && btn_i == ext->button_id_toggled) btn_style = lv_btnm_get_style_btn(btnm, LV_BTN_STATE_TGL_PRESSED);
lv_draw_rect(&area_tmp, mask, btn_style); lv_draw_rect(&area_tmp, mask, btn_style);
/*Calculate the size of the text*/ /*Calculate the size of the text*/
const font_t * font = btn_style->text.font; const font_t * font = btn_style->text.font;
point_t txt_size; point_t txt_size;
txt_get_size(&txt_size, ext->map_p[txt_i], font, txt_get_size(&txt_size, ext->map_p[txt_i], font,
btn_style->text.space_letter, btn_style->text.space_line, btn_style->text.letter_space, btn_style->text.line_space,
area_get_width(&area_btnm), TXT_FLAG_NONE); area_get_width(&area_btnm), TXT_FLAG_NONE);
area_tmp.x1 += (btn_w - txt_size.x) / 2; area_tmp.x1 += (btn_w - txt_size.x) / 2;

29
lv_objx/lv_btnm.h
View File

@ -120,7 +120,7 @@ void lv_btnm_set_toggle(lv_obj_t * btnm, bool en, uint16_t id);
* @param tgl_pr_style pointer to a style for toggled pressed state * @param tgl_pr_style pointer to a style for toggled pressed state
* @param inactive_style pointer to a style for inactive state * @param inactive_style pointer to a style for inactive state
*/ */
void lv_btnm_set_style(lv_obj_t *btnm, lv_style_t *rel, lv_style_t *pr, void lv_btnm_set_style_btn(lv_obj_t *btnm, lv_style_t *rel, lv_style_t *pr,
lv_style_t *tgl_rel, lv_style_t *tgl_pr, lv_style_t *tgl_rel, lv_style_t *tgl_pr,
lv_style_t *ina); lv_style_t *ina);
/** /**
@ -143,7 +143,32 @@ lv_btnm_action_t lv_btnm_get_action(lv_obj_t * btnm);
* @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL) * @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL)
* @return pointer the button style in the given state * @return pointer the button style in the given state
*/ */
lv_style_t * lv_btnm_get_button_style(lv_obj_t * btnm, lv_btn_state_t state); lv_style_t * lv_btnm_get_style_btn(lv_obj_t * btnm, lv_btn_state_t state);
/****************************
* TRANSPARENT API FUNCTIONS
***************************/
/**
* Set the style of a button matrix's background
* @param btnm pointer to a button matrix object
* @param bg pointer to the background style
*/
static inline void lv_btnm_set_style_bg(lv_obj_t *btnm, lv_style_t * bg)
{
lv_obj_set_style(btnm, bg);
}
/**
* Get the style of a button matrix
* @param btnm pointer to a button matrix object
* @return pointer to the backgrond style
*/
static inline lv_style_t * lv_btnm_get_style_bg(lv_obj_t *btnm)
{
return lv_obj_get_style(btnm);
}
/********************** /**********************
* MACROS * MACROS

122
lv_objx/lv_cb.c
View File

@ -25,12 +25,14 @@
**********************/ **********************/
static bool lv_cb_design(lv_obj_t * cb, const area_t * mask, lv_design_mode_t mode); static bool lv_cb_design(lv_obj_t * cb, const area_t * mask, lv_design_mode_t mode);
static bool lv_bullet_design(lv_obj_t * bullet, const area_t * mask, lv_design_mode_t mode); static bool lv_bullet_design(lv_obj_t * bullet, const area_t * mask, lv_design_mode_t mode);
static lv_res_t lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static lv_design_func_t ancestor_bg_design_f; static lv_design_func_t ancestor_bg_design;
static lv_design_func_t ancestor_bullet_design_f; static lv_design_func_t ancestor_bullet_design;
static lv_signal_func_t ancestor_signal;
/********************** /**********************
* MACROS * MACROS
@ -55,30 +57,21 @@ lv_obj_t * lv_cb_create(lv_obj_t * par, lv_obj_t * copy)
/*Create the ancestor basic object*/ /*Create the ancestor basic object*/
lv_obj_t * new_cb = lv_btn_create(par, copy); lv_obj_t * new_cb = lv_btn_create(par, copy);
dm_assert(new_cb); dm_assert(new_cb);
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_cb);
if(ancestor_bg_design == NULL) ancestor_bg_design = lv_obj_get_design_func(new_cb);
lv_cb_ext_t * ext = lv_obj_allocate_ext_attr(new_cb, sizeof(lv_cb_ext_t)); lv_cb_ext_t * ext = lv_obj_allocate_ext_attr(new_cb, sizeof(lv_cb_ext_t));
dm_assert(ext); dm_assert(ext);
ext->bullet = NULL; ext->bullet = NULL;
ext->label = NULL; ext->label = NULL;
if(ancestor_bg_design_f == NULL) ancestor_bg_design_f = lv_obj_get_design_func(new_cb);
lv_obj_set_signal_func(new_cb, lv_cb_signal); lv_obj_set_signal_func(new_cb, lv_cb_signal);
lv_obj_set_design_func(new_cb, lv_cb_design); lv_obj_set_design_func(new_cb, lv_cb_design);
/*Init the new checkbox object*/ /*Init the new checkbox object*/
if(copy == NULL) { if(copy == NULL) {
ext->bullet = lv_btn_create(new_cb, NULL); ext->bullet = lv_btn_create(new_cb, NULL);
lv_btn_set_style(new_cb, &lv_style_transp, &lv_style_transp, if(ancestor_bullet_design == NULL) ancestor_bullet_design = lv_obj_get_design_func(ext->bullet);
&lv_style_transp, &lv_style_transp,
&lv_style_transp);
lv_cont_set_layout(new_cb, LV_CONT_LAYOUT_ROW_M);
lv_cont_set_fit(new_cb, true, true);
lv_btn_set_toggle(new_cb, true);
if(ancestor_bullet_design_f == NULL) ancestor_bullet_design_f = lv_obj_get_design_func(ext->bullet);
lv_obj_set_click(ext->bullet, false); lv_obj_set_click(ext->bullet, false);
lv_btn_set_style(ext->bullet, &lv_style_pretty, &lv_style_pretty_color, lv_btn_set_style(ext->bullet, &lv_style_pretty, &lv_style_pretty_color,
&lv_style_btn_on_released, &lv_style_btn_on_pressed, &lv_style_btn_on_released, &lv_style_btn_on_pressed,
@ -86,7 +79,12 @@ lv_obj_t * lv_cb_create(lv_obj_t * par, lv_obj_t * copy)
ext->label = lv_label_create(new_cb, NULL); ext->label = lv_label_create(new_cb, NULL);
lv_obj_set_style(ext->label, NULL); /*Inherit the style of the parent*/ lv_obj_set_style(ext->label, NULL); /*Inherit the style of the parent*/
lv_label_set_text(ext->label, "Check box");
lv_cb_set_style_bg(new_cb, &lv_style_transp);
lv_cb_set_text(new_cb, "Check box");
lv_cont_set_layout(new_cb, LV_CONT_LAYOUT_ROW_M);
lv_cont_set_fit(new_cb, true, true);
lv_btn_set_toggle(new_cb, true);
lv_obj_refresh_style(new_cb); lv_obj_refresh_style(new_cb);
} else { } else {
@ -103,47 +101,6 @@ lv_obj_t * lv_cb_create(lv_obj_t * par, lv_obj_t * copy)
return new_cb; return new_cb;
} }
/**
* Signal function of the check box
* @param cb pointer to a check box object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
*/
bool lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param)
{
bool valid;
/* Include the ancient signal function */
valid = lv_btn_signal(cb, sign, param);
lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);
lv_style_t * style = lv_obj_get_style(cb);
/* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(valid != false) {
if(sign == LV_SIGNAL_STYLE_CHG) {
lv_obj_set_size(ext->bullet, font_get_height(style->text.font), font_get_height(style->text.font));
lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
} else if(sign == LV_SIGNAL_PRESSED ||
sign == LV_SIGNAL_RELEASED ||
sign == LV_SIGNAL_PRESS_LOST) {
lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
} else if(sign == LV_SIGNAL_CONTROLL) {
char c = *((char*)param);
if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_DOWN ||
c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_UP ||
c == LV_GROUP_KEY_ENTER) {
lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
}
}
}
return valid;
}
/*===================== /*=====================
* Setter functions * Setter functions
*====================*/ *====================*/
@ -210,7 +167,7 @@ static bool lv_cb_design(lv_obj_t * cb, const area_t * mask, lv_design_mode_t mo
{ {
if(mode == LV_DESIGN_COVER_CHK) { if(mode == LV_DESIGN_COVER_CHK) {
/*Return false if the object is not covers the mask_p area*/ /*Return false if the object is not covers the mask_p area*/
return ancestor_bg_design_f(cb, mask, mode); return ancestor_bg_design(cb, mask, mode);
} else if(mode == LV_DESIGN_DRAW_MAIN || mode == LV_DESIGN_DRAW_POST) { } else if(mode == LV_DESIGN_DRAW_MAIN || mode == LV_DESIGN_DRAW_POST) {
lv_cb_ext_t * cb_ext = lv_obj_get_ext_attr(cb); lv_cb_ext_t * cb_ext = lv_obj_get_ext_attr(cb);
lv_btn_ext_t * bullet_ext = lv_obj_get_ext_attr(cb_ext->bullet); lv_btn_ext_t * bullet_ext = lv_obj_get_ext_attr(cb_ext->bullet);
@ -218,10 +175,10 @@ static bool lv_cb_design(lv_obj_t * cb, const area_t * mask, lv_design_mode_t mo
/*Be sure the state of the bullet is the same as the parent button*/ /*Be sure the state of the bullet is the same as the parent button*/
bullet_ext->state = cb_ext->bg_btn.state; bullet_ext->state = cb_ext->bg_btn.state;
return ancestor_bg_design_f(cb, mask, mode); return ancestor_bg_design(cb, mask, mode);
} else { } else {
return ancestor_bg_design_f(cb, mask, mode); return ancestor_bg_design(cb, mask, mode);
} }
return true; return true;
@ -240,7 +197,7 @@ static bool lv_cb_design(lv_obj_t * cb, const area_t * mask, lv_design_mode_t mo
static bool lv_bullet_design(lv_obj_t * bullet, const area_t * mask, lv_design_mode_t mode) static bool lv_bullet_design(lv_obj_t * bullet, const area_t * mask, lv_design_mode_t mode)
{ {
if(mode == LV_DESIGN_COVER_CHK) { if(mode == LV_DESIGN_COVER_CHK) {
return ancestor_bullet_design_f(bullet, mask, mode); return ancestor_bullet_design(bullet, mask, mode);
} else if(mode == LV_DESIGN_DRAW_MAIN) { } else if(mode == LV_DESIGN_DRAW_MAIN) {
#if LV_OBJ_GROUP != 0 #if LV_OBJ_GROUP != 0
/* If the check box is the active in a group and /* If the check box is the active in a group and
@ -258,16 +215,57 @@ static bool lv_bullet_design(lv_obj_t * bullet, const area_t * mask, lv_design_m
} }
} }
#endif #endif
ancestor_bullet_design_f(bullet, mask, mode); ancestor_bullet_design(bullet, mask, mode);
#if LV_OBJ_GROUP != 0 #if LV_OBJ_GROUP != 0
bullet->style_p = style_ori; /*Revert the style*/ bullet->style_p = style_ori; /*Revert the style*/
#endif #endif
} else if(mode == LV_DESIGN_DRAW_POST) { } else if(mode == LV_DESIGN_DRAW_POST) {
ancestor_bullet_design_f(bullet, mask, mode); ancestor_bullet_design(bullet, mask, mode);
} }
return true; return true;
} }
/**
* Signal function of the check box
* @param cb pointer to a check box object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
* @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
*/
static lv_res_t lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param)
{
lv_res_t res;
/* Include the ancient signal function */
res = ancestor_signal(cb, sign, param);
lv_cb_ext_t * ext = lv_obj_get_ext_attr(cb);
lv_style_t * style = lv_obj_get_style(cb);
/* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(res == LV_RES_OK) {
if(sign == LV_SIGNAL_STYLE_CHG) {
lv_obj_set_size(ext->bullet, font_get_height(style->text.font), font_get_height(style->text.font));
lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
} else if(sign == LV_SIGNAL_PRESSED ||
sign == LV_SIGNAL_RELEASED ||
sign == LV_SIGNAL_PRESS_LOST) {
lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
} else if(sign == LV_SIGNAL_CONTROLL) {
char c = *((char*)param);
if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_DOWN ||
c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_UP ||
c == LV_GROUP_KEY_ENTER) {
lv_btn_set_state(ext->bullet, lv_btn_get_state(cb));
}
}
}
return res;
}
#endif #endif

13
lv_objx/lv_cb.h
View File

@ -58,14 +58,6 @@ typedef struct
*/ */
lv_obj_t * lv_cb_create(lv_obj_t * par, lv_obj_t * copy); lv_obj_t * lv_cb_create(lv_obj_t * par, lv_obj_t * copy);
/**
* Signal function of the check box
* @param cb pointer to a check box object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
*/
bool lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param);
/** /**
* Set the text of a check box * Set the text of a check box
* @param cb pointer to a check box * @param cb pointer to a check box
@ -73,7 +65,6 @@ bool lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param);
*/ */
void lv_cb_set_text(lv_obj_t * cb, const char * txt); void lv_cb_set_text(lv_obj_t * cb, const char * txt);
/** /**
* Set styles of a checkbox's bullet is each state. Use NULL for any style to leave it unchanged * Set styles of a checkbox's bullet is each state. Use NULL for any style to leave it unchanged
* @param cb pointer to checkbox object * @param cb pointer to checkbox object
@ -140,14 +131,12 @@ static inline void lv_cb_set_style_bg(lv_obj_t *cb, lv_style_t *bg)
lv_btn_set_style(cb, bg, bg, bg, bg, bg); lv_btn_set_style(cb, bg, bg, bg, bg, bg);
} }
/** /**
* Get the current state of the check box * Get the current state of the check box
* @param cb pointer to a check box object * @param cb pointer to a check box object
* @return true: checked; false: not checked * @return true: checked; false: not checked
*/ */
static inline bool lv_cb_is_checked(lv_obj_t * cb) static inline bool lv_cb_get_checked(lv_obj_t * cb)
{ {
return lv_btn_get_state(cb) == LV_BTN_STATE_RELEASED ? true : false; return lv_btn_get_state(cb) == LV_BTN_STATE_RELEASED ? true : false;
} }

113
lv_objx/lv_cont.c
View File

@ -33,10 +33,7 @@
/********************** /**********************
* STATIC PROTOTYPES * STATIC PROTOTYPES
**********************/ **********************/
#if 0 static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param);
static bool lv_cont_design(lv_obj_t * cont, const area_t * mask, lv_design_mode_t mode);
#endif
static void lv_cont_refr_layout(lv_obj_t * cont); static void lv_cont_refr_layout(lv_obj_t * cont);
static void lv_cont_layout_col(lv_obj_t * cont); static void lv_cont_layout_col(lv_obj_t * cont);
static void lv_cont_layout_row(lv_obj_t * cont); static void lv_cont_layout_row(lv_obj_t * cont);
@ -48,6 +45,7 @@ static void lv_cont_refr_autofit(lv_obj_t * cont);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static lv_signal_func_t ancestor_signal;
/********************** /**********************
* MACROS * MACROS
@ -70,20 +68,22 @@ static void lv_cont_refr_autofit(lv_obj_t * cont);
lv_obj_t * lv_cont_create(lv_obj_t * par, lv_obj_t * copy) lv_obj_t * lv_cont_create(lv_obj_t * par, lv_obj_t * copy)
{ {
/*Create a basic object*/ /*Create a basic object*/
lv_obj_t * new_rect = lv_obj_create(par, copy); lv_obj_t * new_cont = lv_obj_create(par, copy);
dm_assert(new_rect); dm_assert(new_cont);
lv_obj_allocate_ext_attr(new_rect, sizeof(lv_cont_ext_t)); if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_cont);
lv_cont_ext_t * ext = lv_obj_get_ext_attr(new_rect);
lv_obj_allocate_ext_attr(new_cont, sizeof(lv_cont_ext_t));
lv_cont_ext_t * ext = lv_obj_get_ext_attr(new_cont);
dm_assert(ext); dm_assert(ext);
ext->hor_fit = 0; ext->hor_fit = 0;
ext->ver_fit = 0; ext->ver_fit = 0;
ext->layout = LV_CONT_LAYOUT_OFF; ext->layout = LV_CONT_LAYOUT_OFF;
lv_obj_set_signal_func(new_rect, lv_cont_signal); lv_obj_set_signal_func(new_cont, lv_cont_signal);
/*Init the new container*/ /*Init the new container*/
if(copy == NULL) { if(copy == NULL) {
lv_obj_set_style(new_rect, &lv_style_plain); lv_cont_set_style(new_cont, &lv_style_plain);
} }
/*Copy an existing object*/ /*Copy an existing object*/
else { else {
@ -93,45 +93,10 @@ lv_obj_t * lv_cont_create(lv_obj_t * par, lv_obj_t * copy)
ext->layout = copy_ext->layout; ext->layout = copy_ext->layout;
/*Refresh the style with new signal function*/ /*Refresh the style with new signal function*/
lv_obj_refresh_style(new_rect); lv_obj_refresh_style(new_cont);
} }
return new_rect; return new_cont;
}
/**
* Signal function of the container
* @param cont pointer to a container object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
*/
bool lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
{
bool valid;
/* Include the ancient signal function */
valid = lv_obj_signal(cont, sign, param);
/* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(valid != false) {
if(sign == LV_SIGNAL_STYLE_CHG) { /*Recalculate the padding if the style changed*/
lv_cont_refr_layout(cont);
lv_cont_refr_autofit(cont);
} else if(sign == LV_SIGNAL_CHILD_CHG) {
lv_cont_refr_layout(cont);
lv_cont_refr_autofit(cont);
} else if(sign == LV_SIGNAL_CORD_CHG) {
if(lv_obj_get_width(cont) != area_get_width(param) ||
lv_obj_get_height(cont) != area_get_height(param)) {
lv_cont_refr_layout(cont);
lv_cont_refr_autofit(cont);
}
}
}
return valid;
} }
/*===================== /*=====================
@ -139,7 +104,7 @@ bool lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
*====================*/ *====================*/
/** /**
* Set the layout on a container * Set a layout on a container
* @param cont pointer to a container object * @param cont pointer to a container object
* @param layout a layout from 'lv_cont_layout_t' * @param layout a layout from 'lv_cont_layout_t'
*/ */
@ -191,7 +156,7 @@ lv_cont_layout_t lv_cont_get_layout(lv_obj_t * cont)
* @param cont pointer to a container object * @param cont pointer to a container object
* @return true: horizontal fit is enabled; false: disabled * @return true: horizontal fit is enabled; false: disabled
*/ */
bool lv_cont_get_fit_hor(lv_obj_t * cont) bool lv_cont_get_hor_fit(lv_obj_t * cont)
{ {
lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont); lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
return ext->hor_fit == 0 ? false : true; return ext->hor_fit == 0 ? false : true;
@ -202,7 +167,7 @@ bool lv_cont_get_fit_hor(lv_obj_t * cont)
* @param cont pointer to a container object * @param cont pointer to a container object
* @return true: vertical fit is enabled; false: disabled * @return true: vertical fit is enabled; false: disabled
*/ */
bool lv_cont_get_fit_ver(lv_obj_t * cont) bool lv_cont_get_ver_fit(lv_obj_t * cont)
{ {
lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont); lv_cont_ext_t * ext = lv_obj_get_ext_attr(cont);
return ext->ver_fit == 0 ? false : true; return ext->ver_fit == 0 ? false : true;
@ -212,31 +177,41 @@ bool lv_cont_get_fit_ver(lv_obj_t * cont)
/********************** /**********************
* STATIC FUNCTIONS * STATIC FUNCTIONS
**********************/ **********************/
#if 0
/** /**
* Handle the drawing related tasks of the containers * Signal function of the container
* @param cont pointer to an object * @param cont pointer to a container object
* @param mask the object will be drawn only in this area * @param sign a signal type from lv_signal_t enum
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area * @param param pointer to a signal specific variable
* (return 'true' if yes) * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
* LV_DESIGN_DRAW: draw the object (always return 'true')
* LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @param return true/false, depends on 'mode'
*/ */
static bool lv_cont_design(lv_obj_t * cont, const area_t * mask, lv_design_mode_t mode) static lv_res_t lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
{ {
if(mode == LV_DESIGN_COVER_CHK) { lv_res_t res;
return false; /* Include the ancient signal function */
} else if(mode == LV_DESIGN_DRAW_MAIN) { res = ancestor_signal(cont, sign, param);
} else if(mode == LV_DESIGN_DRAW_POST) {
/* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(res == LV_RES_OK) {
if(sign == LV_SIGNAL_STYLE_CHG) { /*Recalculate the padding if the style changed*/
lv_cont_refr_layout(cont);
lv_cont_refr_autofit(cont);
} else if(sign == LV_SIGNAL_CHILD_CHG) {
lv_cont_refr_layout(cont);
lv_cont_refr_autofit(cont);
} else if(sign == LV_SIGNAL_CORD_CHG) {
if(lv_obj_get_width(cont) != area_get_width(param) ||
lv_obj_get_height(cont) != area_get_height(param)) {
lv_cont_refr_layout(cont);
lv_cont_refr_autofit(cont);
}
}
} }
return true;
return res;
} }
#endif
/** /**
@ -247,7 +222,7 @@ static void lv_cont_refr_layout(lv_obj_t * cont)
{ {
lv_cont_layout_t type = lv_cont_get_layout(cont); lv_cont_layout_t type = lv_cont_get_layout(cont);
/*'rect' has to be at least 1 child*/ /*'cont' has to be at least 1 child*/
if(lv_obj_get_child(cont, NULL) == NULL) return; if(lv_obj_get_child(cont, NULL) == NULL) return;
if(type == LV_CONT_LAYOUT_OFF) return; if(type == LV_CONT_LAYOUT_OFF) return;

37
lv_objx/lv_cont.h
View File

@ -54,7 +54,6 @@ typedef struct
* GLOBAL PROTOTYPES * GLOBAL PROTOTYPES
**********************/ **********************/
/** /**
* Create a container objects * Create a container objects
* @param par pointer to an object, it will be the parent of the new container * @param par pointer to an object, it will be the parent of the new container
@ -63,14 +62,6 @@ typedef struct
*/ */
lv_obj_t * lv_cont_create(lv_obj_t * par, lv_obj_t * copy); lv_obj_t * lv_cont_create(lv_obj_t * par, lv_obj_t * copy);
/**
* Signal function of the container
* @param cont pointer to a container object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
*/
bool lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param);
/** /**
* Set the layout on a container * Set the layout on a container
* @param cont pointer to a container object * @param cont pointer to a container object
@ -99,14 +90,38 @@ lv_cont_layout_t lv_cont_get_layout(lv_obj_t * cont);
* @param cont pointer to a container object * @param cont pointer to a container object
* @return true: horizontal fit is enabled; false: disabled * @return true: horizontal fit is enabled; false: disabled
*/ */
bool lv_cont_get_fit_hor(lv_obj_t * cont); bool lv_cont_get_hor_fit(lv_obj_t * cont);
/** /**
* Get vertical fit enable attribute of a button * Get vertical fit enable attribute of a button
* @param btn pointer to a button object * @param btn pointer to a button object
* @return true: vertical padding is enabled; false: disabled * @return true: vertical padding is enabled; false: disabled
*/ */
bool lv_cont_get_fit_ver(lv_obj_t * cont); bool lv_cont_get_ver_fit(lv_obj_t * cont);
/****************************
* TRANSPARENT API FUNCTIONS
***************************/
/**
* Set the style of a container
* @param cont pointer to a container object
* @param style pointer to the new style
*/
static inline void lv_cont_set_style(lv_obj_t *cont, lv_style_t * style)
{
lv_obj_set_style(cont, style);
}
/**
* Get the style of a container
* @param cont pointer to a container object
* @return pointer to the container's style
*/
static inline void lv_cont_get_style(lv_obj_t *cont, lv_style_t * style)
{
lv_obj_set_style(cont, style);
}
/********************** /**********************
* MACROS * MACROS

137
lv_objx/lv_ddlist.c
View File

@ -29,14 +29,17 @@
* STATIC PROTOTYPES * STATIC PROTOTYPES
**********************/ **********************/
static bool lv_ddlist_design(lv_obj_t * ddlist, const area_t * mask, lv_design_mode_t mode); static bool lv_ddlist_design(lv_obj_t * ddlist, const area_t * mask, lv_design_mode_t mode);
static bool lv_ddlist_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param);
static lv_res_t lv_ddlist_rel_action(lv_obj_t * ddlist); static lv_res_t lv_ddlist_rel_action(lv_obj_t * ddlist);
static void lv_ddlist_refr_size(lv_obj_t * ddlist, uint16_t anim_time); static void lv_ddlist_refr_size(lv_obj_t * ddlist, uint16_t anim_time);
static void lv_ddlist_pos_act_option(lv_obj_t * ddlist); static void lv_ddlist_pos_current_option(lv_obj_t * ddlist);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static lv_design_func_t ancestor_design_f; static lv_signal_func_t ancestor_signal;
static lv_signal_func_t ancestor_scrl_signal;
static lv_design_func_t ancestor_design;
static const char * def_options[] = {"Option 1", "Option 2", "Option 3", ""}; static const char * def_options[] = {"Option 1", "Option 2", "Option 3", ""};
/********************** /**********************
* MACROS * MACROS
@ -61,6 +64,9 @@ lv_obj_t * lv_ddlist_create(lv_obj_t * par, lv_obj_t * copy)
/*Create the ancestor drop down list*/ /*Create the ancestor drop down list*/
lv_obj_t * new_ddlist = lv_page_create(par, copy); lv_obj_t * new_ddlist = lv_page_create(par, copy);
dm_assert(new_ddlist); dm_assert(new_ddlist);
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_ddlist);
if(ancestor_scrl_signal == NULL) ancestor_scrl_signal = lv_obj_get_signal_func(lv_page_get_scrl(new_ddlist));
if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_func(new_ddlist);
/*Allocate the drop down list type specific extended data*/ /*Allocate the drop down list type specific extended data*/
lv_ddlist_ext_t * ext = lv_obj_allocate_ext_attr(new_ddlist, sizeof(lv_ddlist_ext_t)); lv_ddlist_ext_t * ext = lv_obj_allocate_ext_attr(new_ddlist, sizeof(lv_ddlist_ext_t));
@ -77,23 +83,21 @@ lv_obj_t * lv_ddlist_create(lv_obj_t * par, lv_obj_t * copy)
ext->selected_style = &lv_style_plain_color; ext->selected_style = &lv_style_plain_color;
/*The signal and design functions are not copied so set them here*/ /*The signal and design functions are not copied so set them here*/
if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_func(new_ddlist);
lv_obj_set_signal_func(new_ddlist, lv_ddlist_signal); lv_obj_set_signal_func(new_ddlist, lv_ddlist_signal);
lv_obj_set_signal_func(lv_page_get_scrl(new_ddlist), lv_ddlist_scrl_signal);
lv_obj_set_design_func(new_ddlist, lv_ddlist_design); lv_obj_set_design_func(new_ddlist, lv_ddlist_design);
/*Init the new drop down list drop down list*/ /*Init the new drop down list drop down list*/
if(copy == NULL) { if(copy == NULL) {
lv_obj_t * scrl = lv_page_get_scrl(new_ddlist); lv_obj_t * scrl = lv_page_get_scrl(new_ddlist);
lv_obj_set_drag(scrl, false); lv_obj_set_drag(scrl, false);
lv_obj_set_style(scrl, &lv_style_transp); lv_page_set_scrl_fit(new_ddlist, true, true);
lv_cont_set_fit(scrl, true, true);
ext->options_label = lv_label_create(new_ddlist, NULL); ext->options_label = lv_label_create(new_ddlist, NULL);
lv_cont_set_fit(new_ddlist, true, false); lv_cont_set_fit(new_ddlist, true, false);
lv_page_set_rel_action(new_ddlist, lv_ddlist_rel_action); lv_page_set_release_action(new_ddlist, lv_ddlist_rel_action);
lv_page_set_sb_mode(new_ddlist, LV_PAGE_SB_MODE_DRAG); lv_page_set_sb_mode(new_ddlist, LV_PAGE_SB_MODE_DRAG);
lv_obj_set_style(new_ddlist, &lv_style_pretty); lv_ddlist_set_style(new_ddlist, &lv_style_pretty, NULL, &lv_style_plain_color);
lv_ddlist_set_options(new_ddlist, def_options); lv_ddlist_set_options(new_ddlist, def_options);
} }
/*Copy an existing drop down list*/ /*Copy an existing drop down list*/
@ -127,20 +131,22 @@ bool lv_ddlist_signal(lv_obj_t * ddlist, lv_signal_t sign, void * param)
bool valid; bool valid;
/* Include the ancient signal function */ /* Include the ancient signal function */
valid = lv_page_signal(ddlist, sign, param); valid = ancestor_signal(ddlist, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */
if(valid != false) { if(valid != false) {
if(sign == LV_SIGNAL_STYLE_CHG) { if(sign == LV_SIGNAL_STYLE_CHG) {
lv_ddlist_refr_size(ddlist, 0); lv_ddlist_refr_size(ddlist, 0);
} else if(sign == LV_SIGNAL_FOCUS) { lv_obj_t *scrl = lv_page_get_scrl(ddlist);
lv_obj_refresh_ext_size(scrl); /*Because of the wider selected rectangle*/
} else if(sign == LV_SIGNAL_FOCUS) {
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist); lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
if(ext->opened == false) { if(ext->opened == false) {
ext->opened = true; ext->opened = true;
lv_ddlist_refr_size(ddlist, true); lv_ddlist_refr_size(ddlist, true);
} }
} else if(sign == LV_SIGNAL_DEFOCUS) { } else if(sign == LV_SIGNAL_DEFOCUS) {
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist); lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
if(ext->opened != false) { if(ext->opened != false) {
ext->opened = false; ext->opened = false;
@ -173,7 +179,7 @@ bool lv_ddlist_signal(lv_obj_t * ddlist, lv_signal_t sign, void * param)
} }
} }
} }
return valid; return valid;
} }
@ -239,7 +245,7 @@ void lv_ddlist_set_selected(lv_obj_t * ddlist, uint16_t sel_opt)
/*Move the list to show the current option*/ /*Move the list to show the current option*/
if(ext->opened == 0) { if(ext->opened == 0) {
lv_ddlist_pos_act_option(ddlist); lv_ddlist_pos_current_option(ddlist);
} else { } else {
lv_obj_invalidate(ddlist); lv_obj_invalidate(ddlist);
} }
@ -250,10 +256,10 @@ void lv_ddlist_set_selected(lv_obj_t * ddlist, uint16_t sel_opt)
* @param ddlist pointer to a drop down list * @param ddlist pointer to a drop down list
* @param cb pointer to a call back function * @param cb pointer to a call back function
*/ */
void lv_ddlist_set_action(lv_obj_t * ddlist, lv_action_t cb) void lv_ddlist_set_action(lv_obj_t * ddlist, lv_action_t action)
{ {
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist); lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
ext->callback = cb; ext->callback = action;
} }
/** /**
@ -280,18 +286,6 @@ void lv_ddlist_set_anim_time(lv_obj_t * ddlist, uint16_t anim_time)
ext->anim_time = anim_time; ext->anim_time = anim_time;
} }
/**
* Set the style of the rectangle on the selected option
* @param ddlist pointer to a drop down list object
* @param style pointer the new style of the select rectangle
*/
void lv_ddlist_set_selected_style(lv_obj_t * ddlist, lv_style_t * style)
{
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
ext->selected_style = style;
}
/** /**
* Open the drop down list with or without animation * Open the drop down list with or without animation
* @param ddlist pointer to drop down list object * @param ddlist pointer to drop down list object
@ -301,6 +295,7 @@ void lv_ddlist_open(lv_obj_t * ddlist, bool anim)
{ {
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist); lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
ext->opened = 1; ext->opened = 1;
lv_obj_set_drag(lv_page_get_scrl(ddlist), true);
lv_ddlist_refr_size(ddlist, anim ? ext->anim_time : 0); lv_ddlist_refr_size(ddlist, anim ? ext->anim_time : 0);
} }
@ -313,9 +308,27 @@ void lv_ddlist_close(lv_obj_t * ddlist, bool anim)
{ {
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist); lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
ext->opened = 0; ext->opened = 0;
lv_obj_set_drag(lv_page_get_scrl(ddlist), false);
lv_ddlist_refr_size(ddlist, anim ? ext->anim_time : 0); lv_ddlist_refr_size(ddlist, anim ? ext->anim_time : 0);
} }
/**
* Set the style of a drop down list
* @param ddlist pointer to a drop down list object
* @param bg pointer to the new style of the background
* @param sb pointer to the new style of the scrollbars (only visible with fix height)
* @param sel pointer to the new style of the select rectangle
*/
void lv_ddlist_set_style(lv_obj_t * ddlist, lv_style_t *bg, lv_style_t *sb, lv_style_t *sel)
{
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
ext->selected_style = sel;
lv_obj_set_style(ext->options_label, bg);
lv_page_set_style(ddlist, bg, &lv_style_transp_tight, sb);
}
/*===================== /*=====================
* Getter functions * Getter functions
*====================*/ *====================*/
@ -420,38 +433,68 @@ static bool lv_ddlist_design(lv_obj_t * ddlist, const area_t * mask, lv_design_m
{ {
/*Return false if the object is not covers the mask_p area*/ /*Return false if the object is not covers the mask_p area*/
if(mode == LV_DESIGN_COVER_CHK) { if(mode == LV_DESIGN_COVER_CHK) {
return ancestor_design_f(ddlist, mask, mode); return ancestor_design(ddlist, mask, mode);
} }
/*Draw the object*/ /*Draw the object*/
else if(mode == LV_DESIGN_DRAW_MAIN) { else if(mode == LV_DESIGN_DRAW_MAIN) {
ancestor_design_f(ddlist, mask, mode); ancestor_design(ddlist, mask, mode);
/*If the list is opened draw a rectangle below the selected item*/ /*If the list is opened draw a rectangle under the selected item*/
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist); lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
if(ext->opened != 0) { if(ext->opened != 0) {
lv_style_t * style = lv_obj_get_style(ddlist); lv_style_t *style = lv_ddlist_get_style_bg(ddlist);
lv_obj_t *scrl = lv_page_get_scrl(ddlist);
const font_t * font = style->text.font; const font_t * font = style->text.font;
cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS; cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS;
area_t rect_area; area_t rect_area;
rect_area.y1 = ext->options_label->coords.y1; rect_area.y1 = ext->options_label->coords.y1;
rect_area.y1 += ext->selected_option_id * (font_h + style->text.space_line); rect_area.y1 += ext->selected_option_id * (font_h + style->text.line_space);
rect_area.y1 -= style->text.space_line / 2; rect_area.y1 -= style->text.line_space / 2;
rect_area.y2 = rect_area.y1 + font_h + style->text.space_line; rect_area.y2 = rect_area.y1 + font_h + style->text.line_space;
rect_area.x1 = ext->options_label->coords.x1 - style->body.padding.hor; rect_area.x1 = scrl->coords.x1 - (style->body.padding.hor >> 1); /*Draw a littlebit wider rectangle then the text*/
rect_area.x2 = rect_area.x1 + lv_obj_get_width(lv_page_get_scrl(ddlist)); rect_area.x2 = scrl->coords.x2 + (style->body.padding.hor >> 1);
lv_draw_rect(&rect_area, mask, ext->selected_style); lv_draw_rect(&rect_area, mask, ext->selected_style);
} }
} }
/*Post draw when the children are drawn*/ /*Post draw when the children are drawn*/
else if(mode == LV_DESIGN_DRAW_POST) { else if(mode == LV_DESIGN_DRAW_POST) {
ancestor_design_f(ddlist, mask, mode); ancestor_design(ddlist, mask, mode);
} }
return true; return true;
} }
/**
* Signal function of the drop down list's scrollable part
* @param scrl pointer to a drop down list's scrollable part
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
* @return true: the object is still valid (not deleted), false: the object become invalid
*/
static bool lv_ddlist_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
{
bool valid;
/* Include the ancient signal function */
valid = ancestor_scrl_signal(scrl, sign, param);
/* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(valid != false) {
if(sign == LV_SIGNAL_REFR_EXT_SIZE) {
/* Because of the wider selected rectangle ext. size
* In this way by dragging the scrollable part the wider rectangle area will be redrawn too*/
lv_obj_t *ddlist = lv_obj_get_parent(scrl);
lv_style_t *style = lv_ddlist_get_style_bg(ddlist);
if(scrl->ext_size < (style->body.padding.hor >> 1)) scrl->ext_size = style->body.padding.hor >> 1;
}
}
return valid;
}
/** /**
* Called when a drop down list is released to open it or set new option * Called when a drop down list is released to open it or set new option
* @param ddlist pointer to a drop down list object * @param ddlist pointer to a drop down list object
@ -513,11 +556,11 @@ static void lv_ddlist_refr_size(lv_obj_t * ddlist, uint16_t anim_time)
const font_t * font = style->text.font; const font_t * font = style->text.font;
lv_style_t * label_style = lv_obj_get_style(ext->options_label); lv_style_t * label_style = lv_obj_get_style(ext->options_label);
cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS; cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS;
new_height = font_h + 2 * label_style->text.space_line; new_height = font_h + 2 * label_style->text.line_space;
} }
if(anim_time == 0) { if(anim_time == 0) {
lv_obj_set_height(ddlist, new_height); lv_obj_set_height(ddlist, new_height);
lv_ddlist_pos_act_option(ddlist); lv_ddlist_pos_current_option(ddlist);
} else { } else {
anim_t a; anim_t a;
a.var = ddlist; a.var = ddlist;
@ -525,7 +568,7 @@ static void lv_ddlist_refr_size(lv_obj_t * ddlist, uint16_t anim_time)
a.end = new_height; a.end = new_height;
a.fp = (anim_fp_t)lv_obj_set_height; a.fp = (anim_fp_t)lv_obj_set_height;
a.path = anim_get_path(ANIM_PATH_LIN); a.path = anim_get_path(ANIM_PATH_LIN);
a.end_cb = (anim_cb_t)lv_ddlist_pos_act_option; a.end_cb = (anim_cb_t)lv_ddlist_pos_current_option;
a.act_time = 0; a.act_time = 0;
a.time = ext->anim_time; a.time = ext->anim_time;
a.playback = 0; a.playback = 0;
@ -541,7 +584,7 @@ static void lv_ddlist_refr_size(lv_obj_t * ddlist, uint16_t anim_time)
* Set the position of list when it is closed to show the selected item * Set the position of list when it is closed to show the selected item
* @param ddlist pointer to a drop down list * @param ddlist pointer to a drop down list
*/ */
static void lv_ddlist_pos_act_option(lv_obj_t * ddlist) static void lv_ddlist_pos_current_option(lv_obj_t * ddlist)
{ {
lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist); lv_ddlist_ext_t * ext = lv_obj_get_ext_attr(ddlist);
lv_style_t * style = lv_obj_get_style(ddlist); lv_style_t * style = lv_obj_get_style(ddlist);
@ -551,7 +594,7 @@ static void lv_ddlist_pos_act_option(lv_obj_t * ddlist)
lv_obj_t * scrl = lv_page_get_scrl(ddlist); lv_obj_t * scrl = lv_page_get_scrl(ddlist);
cord_t h = lv_obj_get_height(ddlist); cord_t h = lv_obj_get_height(ddlist);
cord_t line_y1 = ext->selected_option_id * (font_h + label_style->text.space_line) + ext->options_label->coords.y1 - scrl->coords.y1; cord_t line_y1 = ext->selected_option_id * (font_h + label_style->text.line_space) + ext->options_label->coords.y1 - scrl->coords.y1;
lv_obj_set_y(scrl, - line_y1 + (h - font_h) / 2); lv_obj_set_y(scrl, - line_y1 + (h - font_h) / 2);

46
lv_objx/lv_ddlist.h
View File

@ -99,9 +99,9 @@ void lv_ddlist_set_selected(lv_obj_t * ddlist, uint16_t sel_opt);
/** /**
* Set a function to call when a new option is chosen * Set a function to call when a new option is chosen
* @param ddlist pointer to a drop down list * @param ddlist pointer to a drop down list
* @param cb pointer to a call back function * @param action pointer to a call back function
*/ */
void lv_ddlist_set_action(lv_obj_t * ddlist, lv_action_t cb); void lv_ddlist_set_action(lv_obj_t * ddlist, lv_action_t action);
/** /**
* Set the fix height value. * Set the fix height value.
@ -118,13 +118,6 @@ void lv_ddlist_set_fix_height(lv_obj_t * ddlist, cord_t h);
*/ */
void lv_ddlist_set_anim_time(lv_obj_t * ddlist, uint16_t anim_time); void lv_ddlist_set_anim_time(lv_obj_t * ddlist, uint16_t anim_time);
/**
* Set the style of the rectangle on the selected option
* @param ddlist pointer to a drop down list object
* @param style pointer the new style of the select rectangle
*/
void lv_ddlist_set_selected_style(lv_obj_t * ddlist, lv_style_t * style);
/** /**
* Open the drop down list with or without animation * Open the drop down list with or without animation
* @param ddlist pointer to drop down list object * @param ddlist pointer to drop down list object
@ -139,6 +132,15 @@ void lv_ddlist_open(lv_obj_t * ddlist, bool anim);
*/ */
void lv_ddlist_close(lv_obj_t * ddlist, bool anim); void lv_ddlist_close(lv_obj_t * ddlist, bool anim);
/**
* Set the style of a drop down list
* @param ddlist pointer to a drop down list object
* @param bg pointer to the new style of the background
* @param sb pointer to the new style of the scrollbars (only visible with fix height)
* @param sel pointer to the new style of the select rectangle
*/
void lv_ddlist_set_style(lv_obj_t * ddlist, lv_style_t * bg, lv_style_t * sb, lv_style_t * sel);
/** /**
* Get the options of a drop down list * Get the options of a drop down list
* @param ddlist pointer to drop down list object * @param ddlist pointer to drop down list object
@ -181,6 +183,32 @@ lv_style_t * lv_ddlist_get_style_select(lv_obj_t * ddlist);
*/ */
uint16_t lv_ddlist_get_anim_time(lv_obj_t * ddlist); uint16_t lv_ddlist_get_anim_time(lv_obj_t * ddlist);
/****************************
* TRANSPARENT API FUNCTIONS
***************************/
/**
* Get the style of the drop down list background
* @param ddlist pointer to a text area object
* @return pointer to the style of the background
*/
static inline lv_style_t * lv_ddlist_get_style_bg(lv_obj_t * ddlist)
{
return lv_page_get_style_bg(ddlist);
}
/**
* Get the style of the scrollbars of a drop down list
* @param ddlist pointer to a text area object
* @return pointer to the style of the scrollbars
*/
static inline lv_style_t * lv_ddlist_get_style_scrollbar(lv_obj_t * ddlist)
{
return lv_page_get_style_sb(ddlist);
}
/********************** /**********************
* MACROS * MACROS
**********************/ **********************/

104
lv_objx/lv_gauge.c
View File

@ -27,7 +27,7 @@
#define LV_GAUGE_DEF_NEEDLE_COLOR COLOR_RED #define LV_GAUGE_DEF_NEEDLE_COLOR COLOR_RED
#define LV_GAUGE_DEF_LABEL_COUNT 6 #define LV_GAUGE_DEF_LABEL_COUNT 6
#define LV_GAUGE_DEF_SCALE_LINE_COUNT 21 /*Should be: ((label_cnt - 1) * internal_lines) + 1*/ #define LV_GAUGE_DEF_LINE_COUNT 21 /*Should be: ((label_cnt - 1) * internal_lines) + 1*/
#define LV_GAUGE_DEF_ANGLE 220 #define LV_GAUGE_DEF_ANGLE 220
@ -88,15 +88,15 @@ lv_obj_t * lv_gauge_create(lv_obj_t * par, lv_obj_t * copy)
/*Init the new gauge gauge*/ /*Init the new gauge gauge*/
if(copy == NULL) { if(copy == NULL) {
lv_lmeter_set_scale(new_gauge, LV_GAUGE_DEF_ANGLE, LV_GAUGE_DEF_SCALE_LINE_COUNT); lv_gauge_set_scale(new_gauge, LV_GAUGE_DEF_ANGLE, LV_GAUGE_DEF_LINE_COUNT, LV_GAUGE_DEF_LABEL_COUNT);
lv_gauge_set_needle_num(new_gauge, 1, NULL); lv_gauge_set_needle_count(new_gauge, 1, NULL);
lv_obj_set_size(new_gauge, 2 * LV_DPI, 2 * LV_DPI); lv_obj_set_size(new_gauge, 2 * LV_DPI, 2 * LV_DPI);
lv_obj_set_style(new_gauge, &lv_style_pretty); lv_obj_set_style(new_gauge, &lv_style_pretty);
} }
/*Copy an existing gauge*/ /*Copy an existing gauge*/
else { else {
lv_gauge_ext_t * copy_ext = lv_obj_get_ext_attr(copy); lv_gauge_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
lv_gauge_set_needle_num(new_gauge, copy_ext->needle_count, copy_ext->needle_colors); lv_gauge_set_needle_count(new_gauge, copy_ext->needle_count, copy_ext->needle_colors);
uint8_t i; uint8_t i;
for(i = 0; i < ext->needle_count; i++) { for(i = 0; i < ext->needle_count; i++) {
@ -147,7 +147,7 @@ bool lv_gauge_signal(lv_obj_t * gauge, lv_signal_t sign, void * param)
* @param needle_cnt new count of needles * @param needle_cnt new count of needles
* @param colors an array of colors for needles (with 'num' elements) * @param colors an array of colors for needles (with 'num' elements)
*/ */
void lv_gauge_set_needle_num(lv_obj_t * gauge, uint8_t needle_cnt, color_t * colors) void lv_gauge_set_needle_count(lv_obj_t * gauge, uint8_t needle_cnt, color_t * colors)
{ {
lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge); lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
if(ext->values != NULL) { if(ext->values != NULL) {
@ -157,7 +157,7 @@ void lv_gauge_set_needle_num(lv_obj_t * gauge, uint8_t needle_cnt, color_t * col
ext->values = dm_realloc(ext->values, needle_cnt * sizeof(int16_t)); ext->values = dm_realloc(ext->values, needle_cnt * sizeof(int16_t));
int16_t min = lv_bar_get_min_value(gauge); int16_t min = lv_gauge_get_min_value(gauge);
uint8_t n; uint8_t n;
for(n = ext->needle_count; n < needle_cnt; n++) { for(n = ext->needle_count; n < needle_cnt; n++) {
ext->values[n] = min; ext->values[n] = min;
@ -168,17 +168,6 @@ void lv_gauge_set_needle_num(lv_obj_t * gauge, uint8_t needle_cnt, color_t * col
lv_obj_invalidate(gauge); lv_obj_invalidate(gauge);
} }
/**
* Set the number of labels (and the thicker lines too)
* @param gauge pointer to a gauge object
* @param label_cnt new count of labels
*/
void lv_gauge_set_label_count(lv_obj_t * gauge, uint8_t label_cnt)
{
lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
ext->label_count = label_cnt;
}
/** /**
* Set the value of a needle * Set the value of a needle
* @param gauge pointer to a gauge * @param gauge pointer to a gauge
@ -191,24 +180,53 @@ void lv_gauge_set_value(lv_obj_t * gauge, uint8_t needle_id, int16_t value)
if(needle_id >= ext->needle_count) return; if(needle_id >= ext->needle_count) return;
int16_t min = lv_bar_get_min_value(gauge); int16_t min = lv_gauge_get_min_value(gauge);
int16_t max = lv_bar_get_max_value(gauge); int16_t max = lv_gauge_get_max_value(gauge);
if(value > max) value = max; if(value > max) value = max;
else if(value < min) value = min; else if(value < min) value = min;
ext->values[needle_id] = value; ext->values[needle_id] = value;
/*To be consistent with bar set the first needle's value for the bar*/
if(needle_id == 0) lv_bar_set_value(gauge, value);
lv_obj_invalidate(gauge); lv_obj_invalidate(gauge);
} }
/**
* Set the scale settings of a gauge
* @param gauge pointer to a gauge object
* @param angle angle of the scale (0..360)
* @param line_cnt count of scale lines
* @param label_cnt count of scale labels
*/
void lv_gauge_set_scale(lv_obj_t * gauge, uint16_t angle, uint8_t line_cnt, uint8_t label_cnt)
{
lv_lmeter_set_scale(gauge, angle, line_cnt);
lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
ext->label_count = label_cnt;
}
/*===================== /*=====================
* Getter functions * Getter functions
*====================*/ *====================*/
/**
* Get the value of a needle
* @param gauge pointer to gauge object
* @param needle the id of the needle
* @return the value of the needle [min,max]
*/
int16_t lv_gauge_get_value(lv_obj_t * gauge, uint8_t needle)
{
lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
int16_t min = lv_gauge_get_min_value(gauge);
if(needle >= ext->needle_count) return min;
return ext->values[needle];
}
/** /**
* Get the count of needles on a gauge * Get the count of needles on a gauge
* @param gauge pointer to gauge * @param gauge pointer to gauge
@ -231,23 +249,6 @@ uint8_t lv_gauge_get_label_count(lv_obj_t * gauge)
return ext->label_count; return ext->label_count;
} }
/**
* Get the value of a needle
* @param gauge pointer to gauge object
* @param needle the id of the needle
* @return the value of the needle [min,max]
*/
int16_t lv_gauge_get_value(lv_obj_t * gauge, uint8_t needle)
{
lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
int16_t min = lv_bar_get_min_value(gauge);
if(needle >= ext->needle_count) return min;
return ext->values[needle];
}
/********************** /**********************
* STATIC FUNCTIONS * STATIC FUNCTIONS
**********************/ **********************/
@ -278,23 +279,23 @@ static bool lv_gauge_design(lv_obj_t * gauge, const area_t * mask, lv_design_mod
lv_gauge_draw_scale(gauge, mask); lv_gauge_draw_scale(gauge, mask);
/*Draw the ancestor line meter with max value to show the rainbow like line colors*/ /*Draw the ancestor line meter with max value to show the rainbow like line colors*/
uint16_t scale_num_tmp = ext->lmeter.scale_num; uint16_t line_cnt_tmp = ext->lmeter.line_cnt;
int16_t value_tmp = ext->lmeter.bar.act_value; int16_t value_tmp = ext->lmeter.cur_value;
ext->lmeter.bar.act_value = ext->lmeter.bar.max_value; ext->lmeter.cur_value = ext->lmeter.max_value;
ancestor_design_f(gauge, mask, mode); /*To draw lines*/ ancestor_design_f(gauge, mask, mode); /*To draw lines*/
/*Temporally modify the line meter to draw thicker and longer lines where labels are*/ /*Temporally modify the line meter to draw thicker and longer lines where labels are*/
lv_style_t style_tmp; lv_style_t style_tmp;
lv_style_copy(&style_tmp, style); lv_style_copy(&style_tmp, style);
ext->lmeter.scale_num = ext->label_count; /*Only to labels*/ ext->lmeter.line_cnt = ext->label_count; /*Only to labels*/
style_tmp.line.width = style_tmp.line.width * 2; /*Ticker lines*/ style_tmp.line.width = style_tmp.line.width * 2; /*Ticker lines*/
style_tmp.body.padding.hor = style_tmp.body.padding.hor * 2; /*Longer lines*/ style_tmp.body.padding.hor = style_tmp.body.padding.hor * 2; /*Longer lines*/
gauge->style_p = &style_tmp; gauge->style_p = &style_tmp;
ancestor_design_f(gauge, mask, mode); /*To draw lines*/ ancestor_design_f(gauge, mask, mode); /*To draw lines*/
ext->lmeter.scale_num = scale_num_tmp; /*Restore the parameters*/ ext->lmeter.line_cnt = line_cnt_tmp; /*Restore the parameters*/
ext->lmeter.bar.act_value = value_tmp; ext->lmeter.cur_value = value_tmp;
gauge->style_p = style; gauge->style_p = style;
@ -326,8 +327,8 @@ static void lv_gauge_draw_scale(lv_obj_t * gauge, const area_t * mask)
int16_t scale_angle = lv_lmeter_get_scale_angle(gauge); int16_t scale_angle = lv_lmeter_get_scale_angle(gauge);
uint16_t label_num = ext->label_count; uint16_t label_num = ext->label_count;
int16_t angle_ofs = 90 + (360 - scale_angle) / 2; int16_t angle_ofs = 90 + (360 - scale_angle) / 2;
int16_t min = lv_bar_get_min_value(gauge); int16_t min = lv_gauge_get_min_value(gauge);
int16_t max = lv_bar_get_max_value(gauge); int16_t max = lv_gauge_get_max_value(gauge);
uint8_t i; uint8_t i;
for(i = 0; i < label_num; i++) { for(i = 0; i < label_num; i++) {
@ -347,7 +348,7 @@ static void lv_gauge_draw_scale(lv_obj_t * gauge, const area_t * mask)
area_t label_cord; area_t label_cord;
point_t label_size; point_t label_size;
txt_get_size(&label_size, scale_txt, style->text.font, txt_get_size(&label_size, scale_txt, style->text.font,
style->text.space_letter, style->text.space_line, style->text.letter_space, style->text.line_space,
CORD_MAX, TXT_FLAG_NONE); CORD_MAX, TXT_FLAG_NONE);
/*Draw the label*/ /*Draw the label*/
@ -370,18 +371,13 @@ static void lv_gauge_draw_needle(lv_obj_t * gauge, const area_t * mask)
lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge); lv_gauge_ext_t * ext = lv_obj_get_ext_attr(gauge);
lv_style_t * style = lv_obj_get_style(gauge); lv_style_t * style = lv_obj_get_style(gauge);
/*To be consistent with bar use the bar value as the first needle*/
if(ext->needle_count != 0) {
ext->values[0] = lv_bar_get_value(gauge);
}
cord_t r = lv_obj_get_width(gauge) / 2 - style->body.padding.hor; cord_t r = lv_obj_get_width(gauge) / 2 - style->body.padding.hor;
cord_t x_ofs = lv_obj_get_width(gauge) / 2 + gauge->coords.x1; cord_t x_ofs = lv_obj_get_width(gauge) / 2 + gauge->coords.x1;
cord_t y_ofs = lv_obj_get_height(gauge) / 2 + gauge->coords.y1; cord_t y_ofs = lv_obj_get_height(gauge) / 2 + gauge->coords.y1;
uint16_t angle = lv_lmeter_get_scale_angle(gauge); uint16_t angle = lv_lmeter_get_scale_angle(gauge);
int16_t angle_ofs = 90 + (360 - angle) / 2; int16_t angle_ofs = 90 + (360 - angle) / 2;
int16_t min = lv_bar_get_min_value(gauge); int16_t min = lv_gauge_get_min_value(gauge);
int16_t max = lv_bar_get_max_value(gauge); int16_t max = lv_gauge_get_max_value(gauge);
point_t p_mid; point_t p_mid;
point_t p_end; point_t p_end;
uint8_t i; uint8_t i;

103
lv_objx/lv_gauge.h
View File

@ -75,41 +75,28 @@ bool lv_gauge_signal(lv_obj_t * gauge, lv_signal_t sign, void * param);
/** /**
* Set the number of needles * Set the number of needles
* @param gauge pointer to gauge object * @param gauge pointer to gauge object
* @param num number of needles * @param needle_cnt new count of needles
* @param colors an array of colors for needles (with 'num' elements) * @param colors an array of colors for needles (with 'num' elements)
*/ */
void lv_gauge_set_needle_num(lv_obj_t * gauge, uint8_t num, color_t * colors); void lv_gauge_set_needle_count(lv_obj_t * gauge, uint8_t needle_cnt, color_t * colors);
/** /**
* Set the value of a needle * Set the value of a needle
* @param gauge pointer to gauge * @param gauge pointer to a gauge
* @param needle the id of the needle * @param needle_id the id of the needle
* @param value the new value * @param value the new value
*/ */
void lv_gauge_set_value(lv_obj_t * gauge, uint8_t needle, int16_t value); void lv_gauge_set_value(lv_obj_t * gauge, uint8_t needle_id, int16_t value);
/** /**
* Set which value is more critical (lower or higher) * Set the scale settings of a gauge
* @param gauge pointer to a gauge object * @param gauge pointer to a gauge object
* @param low false: higher / true: lower value is more critical * @param angle angle of the scale (0..360)
* @param line_cnt count of scale lines
* @param label_cnt count of scale labels
*/ */
void lv_gauge_set_low_critical(lv_obj_t * gauge, bool low); void lv_gauge_set_scale(lv_obj_t * gauge, uint16_t angle, uint8_t line_cnt, uint8_t label_cnt);
/**
* Set the critical style of the gauge
* @param gauge pointer to a gauge object
* @param style pointer to the new critical style
*/
void lv_gauge_set_style_critical(lv_obj_t * gauge, lv_style_t * style);
/**
* Get the number of needles on a gauge
* @param gauge pointer to gauge
* @return number of needles
*/
uint8_t lv_gauge_get_needle_count(lv_obj_t * gauge);
uint8_t lv_gauge_get_label_count(lv_obj_t * gauge);
/** /**
* Get the value of a needle * Get the value of a needle
* @param gauge pointer to gauge object * @param gauge pointer to gauge object
@ -119,18 +106,74 @@ uint8_t lv_gauge_get_label_count(lv_obj_t * gauge);
int16_t lv_gauge_get_value(lv_obj_t * gauge, uint8_t needle); int16_t lv_gauge_get_value(lv_obj_t * gauge, uint8_t needle);
/** /**
* Get which value is more critical (lower or higher) * Get the count of needles on a gauge
* @param gauge pointer to a gauge object * @param gauge pointer to gauge
* @param low false: higher / true: lower value is more critical * @return count of needles
*/ */
bool lv_gauge_get_low_critical(lv_obj_t * gauge); uint8_t lv_gauge_get_needle_count(lv_obj_t * gauge);
/** /**
* Get the critical style of the gauge * Set the number of labels (and the thicker lines too)
* @param gauge pointer to a gauge object * @param gauge pointer to a gauge object
* @return pointer to the critical style * @return count of labels
*/ */
lv_style_t * lv_gauge_get_style_critical(lv_obj_t * gauge); uint8_t lv_gauge_get_label_count(lv_obj_t * gauge);
/****************************
* TRANSPARENT API FUNCTIONS
***************************/
/**
* Set minimum and the maximum values of a gauge
* @param gauge pointer to he gauge object
* @param min minimum value
* @param max maximum value
*/
static inline void lv_gauge_set_range(lv_obj_t *gauge, int16_t min, int16_t max)
{
lv_lmeter_set_range(gauge, min, max);
}
/**
* Get the minimum value of a gauge
* @param gauge pointer to a gauge object
* @return the minimum value of the gauge
*/
static inline int16_t lv_gauge_get_min_value(lv_obj_t * lmeter)
{
return lv_lmeter_get_min_value(lmeter);
}
/**
* Get the maximum value of a gauge
* @param gauge pointer to a gauge object
* @return the maximum value of the gauge
*/
static inline int16_t lv_gauge_get_max_value(lv_obj_t * lmeter)
{
return lv_lmeter_get_max_value(lmeter);
}
/**
* Get the scale number of a gauge
* @param gauge pointer to a gauge object
* @return number of the scale units
*/
static inline uint8_t lv_gauge_get_line_count(lv_obj_t * gauge)
{
return lv_lmeter_get_line_count(gauge);
}
/**
* Get the scale angle of a gauge
* @param gauge pointer to a gauge object
* @return angle of the scale
*/
static inline uint16_t lv_gauge_get_scale_angle(lv_obj_t * gauge)
{
return lv_lmeter_get_scale_angle(gauge);
}
/********************** /**********************
* MACROS * MACROS

2
lv_objx/lv_img.c
View File

@ -190,7 +190,7 @@ void lv_img_set_file(lv_obj_t * img, const char * fn)
else { else {
lv_style_t * style = lv_obj_get_style(img); lv_style_t * style = lv_obj_get_style(img);
point_t size; point_t size;
txt_get_size(&size, fn, style->text.font, style->text.space_letter, style->text.space_line, CORD_MAX, TXT_FLAG_NONE); txt_get_size(&size, fn, style->text.font, style->text.letter_space, style->text.line_space, CORD_MAX, TXT_FLAG_NONE);
ext->w = size.x; ext->w = size.x;
ext->h = size.y; ext->h = size.y;
ext->transp = 1; /*Symbols always have transparent parts*/ ext->transp = 1; /*Symbols always have transparent parts*/

7
lv_objx/lv_kb.c
View File

@ -16,6 +16,7 @@
/********************* /*********************
* DEFINES * DEFINES
*********************/ *********************/
/********************** /**********************
* TYPEDEFS * TYPEDEFS
**********************/ **********************/
@ -183,7 +184,7 @@ void lv_kb_set_mode(lv_obj_t * kb, lv_kb_mode_t mode)
* @param kb pointer to a Keyboard object * @param kb pointer to a Keyboard object
* @param en true: show cursor on the current text area, false: hide cursor * @param en true: show cursor on the current text area, false: hide cursor
*/ */
void lv_kb_set_cur_mng(lv_obj_t * kb, bool en) void lv_kb_set_cursor_manage(lv_obj_t * kb, bool en)
{ {
lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb); lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
ext->cur_mng = en == false? 0 : 1; ext->cur_mng = en == false? 0 : 1;
@ -246,7 +247,7 @@ lv_kb_mode_t lv_kb_get_mode(lv_obj_t * kb)
* @param kb pointer to a Keyboard object * @param kb pointer to a Keyboard object
* @return true: show cursor on the current text area, false: hide cursor * @return true: show cursor on the current text area, false: hide cursor
*/ */
bool lv_kb_get_cur_mng(lv_obj_t * kb, bool en) bool lv_kb_get_cursor_manage(lv_obj_t * kb, bool en)
{ {
lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb); lv_kb_ext_t * ext = lv_obj_get_ext_attr(kb);
return ext->cur_mng == 0 ? false : true; return ext->cur_mng == 0 ? false : true;
@ -337,7 +338,7 @@ static lv_res_t lv_app_kb_action(lv_obj_t * kb, const char * txt)
lv_ta_del(ext->ta); lv_ta_del(ext->ta);
} else if(strcmp(txt, "+/-") == 0) { } else if(strcmp(txt, "+/-") == 0) {
uint16_t cur = lv_ta_get_cursor_pos(ext->ta); uint16_t cur = lv_ta_get_cursor_pos(ext->ta);
const char * ta_txt = lv_ta_get_txt(ext->ta); const char * ta_txt = lv_ta_get_text(ext->ta);
if(ta_txt[0] == '-') { if(ta_txt[0] == '-') {
lv_ta_set_cursor_pos(ext->ta, 1); lv_ta_set_cursor_pos(ext->ta, 1);
lv_ta_del(ext->ta); lv_ta_del(ext->ta);

65
lv_objx/lv_kb.h
View File

@ -37,11 +37,11 @@ typedef enum {
typedef struct { typedef struct {
lv_btnm_ext_t btnm; /*Ext. of ancestor*/ lv_btnm_ext_t btnm; /*Ext. of ancestor*/
/*New data for this type */ /*New data for this type */
lv_obj_t * ta; lv_obj_t *ta; /*Pointer to the assigned text area*/
lv_kb_mode_t mode; lv_kb_mode_t mode; /*Key map type*/
uint8_t cur_mng :1; uint8_t cur_mng :1; /*1: automatically show/hide cursor when a text area is assigned or left*/
lv_action_t ok_action; lv_action_t ok_action; /*Called when the "Ok" button is clicked*/
lv_action_t close_action; lv_action_t close_action; /*Called when the "Hide" button is clicked*/
}lv_kb_ext_t; }lv_kb_ext_t;
/********************** /**********************
@ -84,7 +84,7 @@ void lv_kb_set_mode(lv_obj_t * kb, lv_kb_mode_t mode);
* @param kb pointer to a Keyboard object * @param kb pointer to a Keyboard object
* @param en true: show cursor on the current text area, false: hide cursor * @param en true: show cursor on the current text area, false: hide cursor
*/ */
void lv_kb_set_cur_mng(lv_obj_t * kb, bool en); void lv_kb_set_cursor_manage(lv_obj_t * kb, bool en);
/** /**
* Set call back to call when the "Ok" button is pressed * Set call back to call when the "Ok" button is pressed
@ -113,13 +113,12 @@ lv_obj_t * lv_kb_get_ta(lv_obj_t * kb);
*/ */
lv_kb_mode_t lv_kb_get_mode(lv_obj_t * kb); lv_kb_mode_t lv_kb_get_mode(lv_obj_t * kb);
/** /**
* Get the current cursor manage mode. * Get the current cursor manage mode.
* @param kb pointer to a Keyboard object * @param kb pointer to a Keyboard object
* @return true: show cursor on the current text area, false: hide cursor * @return true: show cursor on the current text area, false: hide cursor
*/ */
bool lv_kb_get_cur_mng(lv_obj_t * kb, bool en); bool lv_kb_get_cursor_manage(lv_obj_t * kb, bool en);
/** /**
* Get the callback to call when the "Ok" button is pressed * Get the callback to call when the "Ok" button is pressed
@ -135,6 +134,56 @@ lv_action_t lv_kb_get_ok_action(lv_obj_t * kb, lv_action_t action);
*/ */
lv_action_t lv_kb_get_close_action(lv_obj_t * kb, lv_action_t action); lv_action_t lv_kb_get_close_action(lv_obj_t * kb, lv_action_t action);
/****************************
* TRANSPARENT API FUNCTIONS
***************************/
/**
* Set styles of the buttons is each state. Use NULL for any style to leave it unchanged.
* @param kb pointer to keyboard object
* @param rel pointer to a style for releases state
* @param pr pointer to a style for pressed state
* @param tgl_rel pointer to a style for toggled releases state
* @param tgl_pr pointer to a style for toggled pressed state
* @param ina pointer to a style for inactive state
*/
static inline void lv_kb_set_style_btn(lv_obj_t *kb, lv_style_t *rel, lv_style_t *pr,
lv_style_t *tgl_rel, lv_style_t *tgl_pr,
lv_style_t *ina)
{
lv_btnm_set_style_btn(kb, rel, pr, tgl_rel, tgl_pr, ina);
}
/**
* Set the style of a keyboards's background
* @param kb pointer to a keyboard object
* @param bg pointer to the background style
*/
static inline void lv_kb_set_style_bg(lv_obj_t *kb, lv_style_t * bg)
{
lv_btnm_set_style_bg(kb, bg);
}
/**
* Get the style of the buttons of keyboard
* @param kb pointer to a keyboard object
* @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL)
* @return pointer the button style in the given state
*/
static inline lv_style_t * lv_kb_kb_style_btn(lv_obj_t *kb, lv_btn_state_t state)
{
return lv_btnm_get_style_btn(kb, state);
}
/**
* Get the style of a keyboard
* @param kb pointer to a keyboard object
* @return pointer to the background style
*/
static inline lv_style_t * lv_kb_get_style_bg(lv_obj_t *kb)
{
return lv_btnm_get_style_bg(kb);
}
/********************** /**********************
* MACROS * MACROS
**********************/ **********************/

22
lv_objx/lv_label.c
View File

@ -466,16 +466,16 @@ void lv_label_get_letter_pos(lv_obj_t * label, uint16_t index, point_t * pos)
/*Search the line of the index letter */; /*Search the line of the index letter */;
while (txt[new_line_start] != '\0') { while (txt[new_line_start] != '\0') {
new_line_start += txt_get_next_line(&txt[line_start], font, style->text.space_letter, max_w, flag); new_line_start += txt_get_next_line(&txt[line_start], font, style->text.letter_space, max_w, flag);
if(index < new_line_start || txt[new_line_start] == '\0') break; /*The line of 'index' letter begins at 'line_start'*/ if(index < new_line_start || txt[new_line_start] == '\0') break; /*The line of 'index' letter begins at 'line_start'*/
y += letter_height + style->text.space_line; y += letter_height + style->text.line_space;
line_start = new_line_start; line_start = new_line_start;
} }
/*If the last character is line break then go to the next line*/ /*If the last character is line break then go to the next line*/
if((txt[index - 1] == '\n' || txt[index - 1] == '\r') && txt[index] == '\0') { if((txt[index - 1] == '\n' || txt[index - 1] == '\r') && txt[index] == '\0') {
y += letter_height + style->text.space_line; y += letter_height + style->text.line_space;
line_start = index; line_start = index;
} }
@ -494,13 +494,13 @@ void lv_label_get_letter_pos(lv_obj_t * label, uint16_t index, point_t * pos)
continue; /*Skip the letter is it is part of a command*/ continue; /*Skip the letter is it is part of a command*/
} }
} }
x += (font_get_width(font, letter) >> FONT_ANTIALIAS) + style->text.space_letter; x += (font_get_width(font, letter) >> FONT_ANTIALIAS) + style->text.letter_space;
} }
if(ext->align == LV_LABEL_ALIGN_CENTER) { if(ext->align == LV_LABEL_ALIGN_CENTER) {
cord_t line_w; cord_t line_w;
line_w = txt_get_width(&txt[line_start], new_line_start - line_start, line_w = txt_get_width(&txt[line_start], new_line_start - line_start,
font, style->text.space_letter, flag); font, style->text.letter_space, flag);
x += lv_obj_get_width(label) / 2 - line_w / 2; x += lv_obj_get_width(label) / 2 - line_w / 2;
} }
@ -540,9 +540,9 @@ uint16_t lv_label_get_letter_on(lv_obj_t * label, point_t * pos)
/*Search the line of the index letter */; /*Search the line of the index letter */;
while (txt[line_start] != '\0') { while (txt[line_start] != '\0') {
new_line_start += txt_get_next_line(&txt[line_start], font, style->text.space_letter, max_w, flag); new_line_start += txt_get_next_line(&txt[line_start], font, style->text.letter_space, max_w, flag);
if(pos->y <= y + letter_height + style->text.space_line) break; /*The line is found ('line_start')*/ if(pos->y <= y + letter_height + style->text.line_space) break; /*The line is found ('line_start')*/
y += letter_height + style->text.space_line; y += letter_height + style->text.line_space;
line_start = new_line_start; line_start = new_line_start;
} }
@ -551,7 +551,7 @@ uint16_t lv_label_get_letter_on(lv_obj_t * label, point_t * pos)
if(ext->align == LV_LABEL_ALIGN_CENTER) { if(ext->align == LV_LABEL_ALIGN_CENTER) {
cord_t line_w; cord_t line_w;
line_w = txt_get_width(&txt[line_start], new_line_start - line_start, line_w = txt_get_width(&txt[line_start], new_line_start - line_start,
font, style->text.space_letter, flag); font, style->text.letter_space, flag);
x += lv_obj_get_width(label) / 2 - line_w / 2; x += lv_obj_get_width(label) / 2 - line_w / 2;
} }
@ -567,7 +567,7 @@ uint16_t lv_label_get_letter_on(lv_obj_t * label, point_t * pos)
} }
} }
x += (font_get_width(font, letter) >> FONT_ANTIALIAS) + style->text.space_letter; x += (font_get_width(font, letter) >> FONT_ANTIALIAS) + style->text.letter_space;
if(pos->x < x) break; /*Get the position*/ if(pos->x < x) break; /*Get the position*/
} }
@ -651,7 +651,7 @@ static void lv_label_refr_text(lv_obj_t * label)
if(ext->recolor != 0) flag |= TXT_FLAG_RECOLOR; if(ext->recolor != 0) flag |= TXT_FLAG_RECOLOR;
if(ext->expand != 0) flag |= TXT_FLAG_EXPAND; if(ext->expand != 0) flag |= TXT_FLAG_EXPAND;
if(ext->no_break != 0) flag |= TXT_FLAG_NO_BREAK; if(ext->no_break != 0) flag |= TXT_FLAG_NO_BREAK;
txt_get_size(&size, ext->txt, font, style->text.space_letter, style->text.space_line, max_w, flag); txt_get_size(&size, ext->txt, font, style->text.letter_space, style->text.line_space, max_w, flag);
/*Refresh the full size in expand mode*/ /*Refresh the full size in expand mode*/
if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) { if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) {

159
lv_objx/lv_list.c
View File

@ -11,7 +11,6 @@
#include "lv_list.h" #include "lv_list.h"
#include "../lv_obj/lv_group.h" #include "../lv_obj/lv_group.h"
#include "lv_cont.h"
#include "misc/gfx/anim.h" #include "misc/gfx/anim.h"
#include "misc/math/math_base.h" #include "misc/math/math_base.h"
@ -39,6 +38,10 @@ static lv_obj_t * lv_list_get_next_btn(lv_obj_t * list, lv_obj_t * prev_btn);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static lv_signal_func_t btn_signal;
static lv_signal_func_t img_signal;
static lv_signal_func_t label_signal;
static lv_signal_func_t ancestor_signal;
/********************** /**********************
* MACROS * MACROS
@ -63,10 +66,11 @@ lv_obj_t * lv_list_create(lv_obj_t * par, lv_obj_t * copy)
/*Create the ancestor basic object*/ /*Create the ancestor basic object*/
lv_obj_t * new_list = lv_page_create(par, copy); lv_obj_t * new_list = lv_page_create(par, copy);
dm_assert(new_list); dm_assert(new_list);
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_list);
lv_list_ext_t * ext = lv_obj_allocate_ext_attr(new_list, sizeof(lv_list_ext_t)); lv_list_ext_t * ext = lv_obj_allocate_ext_attr(new_list, sizeof(lv_list_ext_t));
dm_assert(ext); dm_assert(ext);
ext->sb_out = 0;
ext->style_img = NULL; ext->style_img = NULL;
ext->styles_btn[LV_BTN_STATE_RELEASED] = &lv_style_btn_off_released; ext->styles_btn[LV_BTN_STATE_RELEASED] = &lv_style_btn_off_released;
ext->styles_btn[LV_BTN_STATE_PRESSED] = &lv_style_btn_off_pressed; ext->styles_btn[LV_BTN_STATE_PRESSED] = &lv_style_btn_off_pressed;
@ -79,21 +83,17 @@ lv_obj_t * lv_list_create(lv_obj_t * par, lv_obj_t * copy)
/*Init the new list object*/ /*Init the new list object*/
if(copy == NULL) { if(copy == NULL) {
lv_obj_set_size(new_list, 2 * LV_DPI, 3 * LV_DPI); lv_obj_set_size(new_list, 2 * LV_DPI, 3 * LV_DPI);
lv_cont_set_layout(ext->page.scrl, LV_LIST_LAYOUT_DEF); lv_page_set_scrl_layout(new_list, LV_LIST_LAYOUT_DEF);
lv_obj_set_style(new_list, &lv_style_transp_fit); lv_list_set_style_bg(new_list, &lv_style_transp_fit, &lv_style_pretty, NULL);
lv_obj_set_style(lv_page_get_scrl(new_list), &lv_style_pretty); lv_page_set_sb_mode(new_list, LV_PAGE_SB_MODE_DRAG);
lv_page_set_sb_mode(new_list, LV_PAGE_SB_MODE_AUTO);
} else { } else {
lv_list_ext_t * copy_ext = lv_obj_get_ext_attr(copy); lv_list_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
lv_list_set_btn_styles(new_list, copy_ext->styles_btn[LV_BTN_STATE_RELEASED], lv_list_set_style_btn(new_list, copy_ext->styles_btn[LV_BTN_STATE_RELEASED],
copy_ext->styles_btn[LV_BTN_STATE_PRESSED], copy_ext->styles_btn[LV_BTN_STATE_PRESSED],
copy_ext->styles_btn[LV_BTN_STATE_TGL_RELEASED], copy_ext->styles_btn[LV_BTN_STATE_TGL_RELEASED],
copy_ext->styles_btn[LV_BTN_STATE_TGL_PRESSED], copy_ext->styles_btn[LV_BTN_STATE_TGL_PRESSED],
copy_ext->styles_btn[LV_BTN_STATE_INACTIVE]); copy_ext->styles_btn[LV_BTN_STATE_INACTIVE]);
lv_list_set_style_img(new_list, copy_ext->style_img);
lv_list_set_sb_out(new_list, copy_ext->sb_out);
/*Refresh the style with new signal function*/ /*Refresh the style with new signal function*/
lv_obj_refresh_style(new_list); lv_obj_refresh_style(new_list);
@ -113,7 +113,7 @@ bool lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
bool valid; bool valid;
/* Include the ancient signal function */ /* Include the ancient signal function */
valid = lv_page_signal(list, sign, param); valid = ancestor_signal(list, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */
@ -219,8 +219,9 @@ lv_obj_t * lv_list_add(lv_obj_t * list, const char * img_fn, const char * txt, l
lv_btn_set_action(liste, LV_BTN_ACTION_RELEASE, rel_action); lv_btn_set_action(liste, LV_BTN_ACTION_RELEASE, rel_action);
lv_page_glue_obj(liste, true); lv_page_glue_obj(liste, true);
lv_cont_set_layout(liste, LV_CONT_LAYOUT_ROW_M); lv_btn_set_layout(liste, LV_CONT_LAYOUT_ROW_M);
lv_cont_set_fit(liste, false, true); lv_btn_set_fit(liste, false, true);
if(btn_signal == NULL) btn_signal = lv_obj_get_signal_func(liste);
/*Make the size adjustment*/ /*Make the size adjustment*/
cord_t w = lv_obj_get_width(list); cord_t w = lv_obj_get_width(list);
@ -228,10 +229,6 @@ lv_obj_t * lv_list_add(lv_obj_t * list, const char * img_fn, const char * txt, l
cord_t pad_hor_tot = style->body.padding.hor + style_scrl->body.padding.hor; cord_t pad_hor_tot = style->body.padding.hor + style_scrl->body.padding.hor;
w -= pad_hor_tot * 2; w -= pad_hor_tot * 2;
/*Make place for the scrollbar if pad_hor_tot is too small*/
if(ext->sb_out != 0) {
if(pad_hor_tot < ext->page.sb_width) w -= ext->page.sb_width - pad_hor_tot;
}
lv_obj_set_width(liste, w); lv_obj_set_width(liste, w);
#if USE_LV_IMG != 0 && USE_FSINT != 0 #if USE_LV_IMG != 0 && USE_FSINT != 0
if(img_fn != NULL && img_fn[0] != '\0') { if(img_fn != NULL && img_fn[0] != '\0') {
@ -239,6 +236,7 @@ lv_obj_t * lv_list_add(lv_obj_t * list, const char * img_fn, const char * txt, l
lv_img_set_file(img, img_fn); lv_img_set_file(img, img_fn);
lv_obj_set_style(img, ext->style_img); lv_obj_set_style(img, ext->style_img);
lv_obj_set_click(img, false); lv_obj_set_click(img, false);
if(img_signal == NULL) img_signal = lv_obj_get_signal_func(img);
} }
#endif #endif
if(txt != NULL) { if(txt != NULL) {
@ -247,8 +245,11 @@ lv_obj_t * lv_list_add(lv_obj_t * list, const char * img_fn, const char * txt, l
lv_obj_set_click(label, false); lv_obj_set_click(label, false);
lv_label_set_long_mode(label, LV_LABEL_LONG_ROLL); lv_label_set_long_mode(label, LV_LABEL_LONG_ROLL);
lv_obj_set_width(label, liste->coords.x2 - label->coords.x1); lv_obj_set_width(label, liste->coords.x2 - label->coords.x1);
if(label_signal == NULL) label_signal = lv_obj_get_signal_func(label);
} }
return liste; return liste;
} }
@ -336,68 +337,32 @@ void lv_list_down(lv_obj_t * list)
* Setter functions * Setter functions
*====================*/ *====================*/
/**
* Enable/Disable to scrollbar outside attribute
* @param list pointer to list object
* @param out true: reduce the buttons width therefore scroll bar will be out of the buttons,
* false: keep button size and place scroll bar on the buttons
*/
void lv_list_set_sb_out(lv_obj_t * list, bool out)
{
lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
ext->sb_out = out == false ? 0 : 1;
}
/** /**
* Set styles of the list elements of a list in each state * Set styles of the list elements of a list in each state
* @param list pointer to list object * @param list pointer to list object
* @param rel pointer to a style for releases state * @param rel pointer to a style for releases state
* @param pr pointer to a style for pressed state * @param pr pointer to a style for pressed state
* @param trel pointer to a style for toggled releases state * @param tgl_rel pointer to a style for toggled releases state
* @param tpr pointer to a style for toggled pressed state * @param tgl_pr pointer to a style for toggled pressed state
* @param ina pointer to a style for inactive state * @param ina pointer to a style for inactive state
*/ */
void lv_list_set_btn_styles(lv_obj_t * list, lv_style_t * rel, lv_style_t * pr, void lv_list_set_style_btn(lv_obj_t * list, lv_style_t * rel, lv_style_t * pr,
lv_style_t * trel, lv_style_t * tpr, lv_style_t * tgl_rel, lv_style_t * tgl_pr,
lv_style_t * ina) lv_style_t * ina)
{ {
lv_list_ext_t * ext = lv_obj_get_ext_attr(list); lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
ext->styles_btn[LV_BTN_STATE_RELEASED] = rel; if(rel != NULL) ext->styles_btn[LV_BTN_STATE_RELEASED] = rel;
ext->styles_btn[LV_BTN_STATE_PRESSED] = pr; if(pr != NULL) ext->styles_btn[LV_BTN_STATE_PRESSED] = pr;
ext->styles_btn[LV_BTN_STATE_TGL_RELEASED] = trel; if(tgl_rel != NULL) ext->styles_btn[LV_BTN_STATE_TGL_RELEASED] = tgl_rel;
ext->styles_btn[LV_BTN_STATE_TGL_PRESSED] = tpr; if(tgl_pr != NULL) ext->styles_btn[LV_BTN_STATE_TGL_PRESSED] = tgl_pr;
ext->styles_btn[LV_BTN_STATE_INACTIVE] = ina; if(ina != NULL) ext->styles_btn[LV_BTN_STATE_INACTIVE] = ina;
/*Refresh all existing buttons*/
lv_obj_t * liste = lv_list_get_next_btn(list, NULL); lv_obj_t * liste = lv_list_get_next_btn(list, NULL);
while(liste != NULL) while(liste != NULL)
{ {
lv_btn_set_style(liste, rel, pr, trel, tpr, ina); lv_btn_set_style(liste, rel, pr, tgl_rel, tgl_pr, ina);
liste = lv_list_get_next_btn(list, liste);
}
}
/**
* Set the styles of the list element image (typically to set symbol font)
* @param list pointer to list object
* @param style pointer to the new style of the button images
*/
void lv_list_set_style_img(lv_obj_t * list, lv_style_t * style)
{
lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
ext->style_img = style;
lv_obj_t * liste = lv_list_get_next_btn(list, NULL);
lv_obj_t * img;
while(liste != NULL)
{
img = lv_list_get_element_img(liste);
if(img != NULL) lv_obj_set_style(img, style);
liste = lv_list_get_next_btn(list, liste); liste = lv_list_get_next_btn(list, liste);
} }
} }
@ -411,9 +376,9 @@ void lv_list_set_style_img(lv_obj_t * list, lv_style_t * style)
* @param liste pointer to list element * @param liste pointer to list element
* @return pointer to the text * @return pointer to the text
*/ */
const char * lv_list_get_element_text(lv_obj_t * liste) const char * lv_list_get_btn_text(lv_obj_t * liste)
{ {
lv_obj_t * label = lv_list_get_element_label(liste); lv_obj_t * label = lv_list_get_btn_label(liste);
if(label == NULL) return ""; if(label == NULL) return "";
return lv_label_get_text(label); return lv_label_get_text(label);
} }
@ -423,12 +388,12 @@ const char * lv_list_get_element_text(lv_obj_t * liste)
* @param liste pointer to a list element (button) * @param liste pointer to a list element (button)
* @return pointer to the label from the list element or NULL if not found * @return pointer to the label from the list element or NULL if not found
*/ */
lv_obj_t * lv_list_get_element_label(lv_obj_t * liste) lv_obj_t * lv_list_get_btn_label(lv_obj_t * liste)
{ {
lv_obj_t * label = lv_obj_get_child(liste, NULL); lv_obj_t * label = lv_obj_get_child(liste, NULL);
if(label == NULL) return NULL; if(label == NULL) return NULL;
while(label->signal_func != lv_label_signal) { while(label->signal_func != label_signal) {
label = lv_obj_get_child(liste, label); label = lv_obj_get_child(liste, label);
if(label == NULL) break; if(label == NULL) break;
} }
@ -441,13 +406,13 @@ lv_obj_t * lv_list_get_element_label(lv_obj_t * liste)
* @param liste pointer to a list element (button) * @param liste pointer to a list element (button)
* @return pointer to the image from the list element or NULL if not found * @return pointer to the image from the list element or NULL if not found
*/ */
lv_obj_t * lv_list_get_element_img(lv_obj_t * liste) lv_obj_t * lv_list_get_btn_img(lv_obj_t * liste)
{ {
#if USE_LV_IMG != 0 && USE_FSINT != 0 #if USE_LV_IMG != 0 && USE_FSINT != 0
lv_obj_t * img = lv_obj_get_child(liste, NULL); lv_obj_t * img = lv_obj_get_child(liste, NULL);
if(img == NULL) return NULL; if(img == NULL) return NULL;
while(img->signal_func != lv_img_signal) { while(img->signal_func != img_signal) {
img = lv_obj_get_child(liste, img); img = lv_obj_get_child(liste, img);
if(img == NULL) break; if(img == NULL) break;
} }
@ -458,24 +423,13 @@ lv_obj_t * lv_list_get_element_img(lv_obj_t * liste)
#endif #endif
} }
/**
* Get the scroll bar outside attribute
* @param list pointer to list object
* @param en true: scroll bar outside the buttons, false: scroll bar inside
*/
bool lv_list_get_sb_out(lv_obj_t * list, bool en)
{
lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
return ext->sb_out == 0 ? false : true;
}
/** /**
* Get the style of the list elements in a given state * Get the style of the list elements in a given state
* @param list pointer to a list object * @param list pointer to a list object
* @param state a state from 'lv_btn_state_t' in which style should be get * @param state a state from 'lv_btn_state_t' in which style should be get
* @return pointer to the style in the given state * @return pointer to the style in the given state
*/ */
lv_style_t * lv_list_get_style_liste(lv_obj_t * list, lv_btn_state_t state) lv_style_t * lv_list_get_style_btn(lv_obj_t * list, lv_btn_state_t state)
{ {
lv_list_ext_t * ext = lv_obj_get_ext_attr(list); lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
@ -484,49 +438,10 @@ lv_style_t * lv_list_get_style_liste(lv_obj_t * list, lv_btn_state_t state)
return ext->styles_btn[state]; return ext->styles_btn[state];
} }
/**
* Get the style of the list elements images
* @param list pointer to a list object
* @return pointer to the image style
*/
lv_style_t * lv_list_get_style_img(lv_obj_t * list, lv_btn_state_t state)
{
lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
if(ext->style_img == NULL) return lv_list_get_style_liste(list, LV_BTN_STATE_RELEASED);
return ext->style_img;
}
/********************** /**********************
* STATIC FUNCTIONS * STATIC FUNCTIONS
**********************/ **********************/
#if 0 /*A new design function is not necessary*/
/**
* Handle the drawing related tasks of the lists
* @param list pointer to an object
* @param mask the object will be drawn only in this area
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
* (return 'true' if yes)
* LV_DESIGN_DRAW: draw the object (always return 'true')
* LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @param return true/false, depends on 'mode'
*/
static bool lv_list_design(lv_obj_t * list, const area_t * mask, lv_design_mode_t mode)
{
if(mode == LV_DESIGN_COVER_CHK) {
/*Return false if the object is not covers the mask_p area*/
return false;
}
/*Draw the object*/
return true;
}
#endif
/** /**
* Get the next button from list * Get the next button from list
* @param list pointer to a list object * @param list pointer to a list object
@ -544,7 +459,7 @@ static lv_obj_t * lv_list_get_next_btn(lv_obj_t * list, lv_obj_t * prev_btn)
btn = lv_obj_get_child(scrl, prev_btn); btn = lv_obj_get_child(scrl, prev_btn);
if(btn == NULL) return NULL; if(btn == NULL) return NULL;
while(btn->signal_func != lv_btn_signal) { while(btn->signal_func != btn_signal) {
btn = lv_obj_get_child(scrl, prev_btn); btn = lv_obj_get_child(scrl, prev_btn);
if(btn == NULL) break; if(btn == NULL) break;
} }

33
lv_objx/lv_list.h
View File

@ -50,7 +50,6 @@ typedef struct
/*New data for this type */ /*New data for this type */
lv_style_t *styles_btn[LV_BTN_STATE_NUM]; /*Styles of the list element buttons*/ lv_style_t *styles_btn[LV_BTN_STATE_NUM]; /*Styles of the list element buttons*/
lv_style_t *style_img; /*Style of the list element images on buttons*/ lv_style_t *style_img; /*Style of the list element images on buttons*/
uint8_t sb_out :1; /*1: Keep space for the scrollbar*/
}lv_list_ext_t; }lv_list_ext_t;
/********************** /**********************
@ -101,7 +100,7 @@ void lv_list_down(lv_obj_t * list);
* @param out true: reduce the buttons width therefore scroll bar will be out of the buttons, * @param out true: reduce the buttons width therefore scroll bar will be out of the buttons,
* false: keep button size and place scroll bar on the buttons * false: keep button size and place scroll bar on the buttons
*/ */
void lv_list_set_sb_out(lv_obj_t * list, bool out); void lv_list_set_sscrollbar_out(lv_obj_t * list, bool out);
/** /**
* Set styles of the list elements of a list in each state * Set styles of the list elements of a list in each state
@ -112,17 +111,10 @@ void lv_list_set_sb_out(lv_obj_t * list, bool out);
* @param tpr pointer to a style for toggled pressed state * @param tpr pointer to a style for toggled pressed state
* @param ina pointer to a style for inactive state * @param ina pointer to a style for inactive state
*/ */
void lv_list_set_btn_styles(lv_obj_t * list, lv_style_t * rel, lv_style_t * pr, void lv_list_set_style_btn(lv_obj_t * list, lv_style_t * rel, lv_style_t * pr,
lv_style_t * trel, lv_style_t * tpr, lv_style_t * trel, lv_style_t * tpr,
lv_style_t * ina); lv_style_t * ina);
/**
* Set the styles of the list element image (typically to set symbol font)
* @param list pointer to list object
* @param style pointer to the new style of the button images
*/
void lv_list_set_style_img(lv_obj_t * list, lv_style_t * style);
/** /**
* Get the text of a list element * Get the text of a list element
* @param liste pointer to list element * @param liste pointer to list element
@ -135,14 +127,14 @@ const char * lv_list_get_element_text(lv_obj_t * liste);
* @param liste pointer to a list element (button) * @param liste pointer to a list element (button)
* @return pointer to the label from the list element or NULL if not found * @return pointer to the label from the list element or NULL if not found
*/ */
lv_obj_t * lv_list_get_element_label(lv_obj_t * liste); lv_obj_t * lv_list_get_btn_label(lv_obj_t * liste);
/** /**
* Get the image object from a list element * Get the image object from a list element
* @param liste pointer to a list element (button) * @param liste pointer to a list element (button)
* @return pointer to the image from the list element or NULL if not found * @return pointer to the image from the list element or NULL if not found
*/ */
lv_obj_t * lv_list_get_element_img(lv_obj_t * liste); lv_obj_t * lv_list_get_btn_img(lv_obj_t * liste);
/** /**
* Get the scroll bar outside attribute * Get the scroll bar outside attribute
@ -157,14 +149,23 @@ bool lv_list_get_sb_out(lv_obj_t * list, bool en);
* @param state a state from 'lv_btn_state_t' in which style should be get * @param state a state from 'lv_btn_state_t' in which style should be get
* @return pointer to the style in the given state * @return pointer to the style in the given state
*/ */
lv_style_t * lv_list_get_style_liste(lv_obj_t * list, lv_btn_state_t state); lv_style_t * lv_list_get_style_btne(lv_obj_t * list, lv_btn_state_t state);
/****************************
* TRANSPARENT API FUNCTIONS
***************************/
/** /**
* Get the style of the list elements images * Set a new styles for the list
* @param list pointer to a list object * @param list pointer to a list object
* @return pointer to the image style * @param bg pointer to a style for the background (typically transparent)
* @param scrl pointer to a style for the scrollable area
* @param sb pointer to a style for the scroll bars
*/ */
lv_style_t * lv_list_get_style_img(lv_obj_t * list, lv_btn_state_t state); static inline void lv_list_set_style_bg(lv_obj_t *list, lv_style_t *bg, lv_style_t *scrl, lv_style_t *sb)
{
lv_page_set_style(list, bg, scrl, sb);
}
/********************** /**********************
* MACROS * MACROS

103
lv_objx/lv_lmeter.c
View File

@ -51,7 +51,7 @@ static bool lv_lmeter_design(lv_obj_t * lmeter, const area_t * mask, lv_design_m
lv_obj_t * lv_lmeter_create(lv_obj_t * par, lv_obj_t * copy) lv_obj_t * lv_lmeter_create(lv_obj_t * par, lv_obj_t * copy)
{ {
/*Create the ancestor of line meter*/ /*Create the ancestor of line meter*/
lv_obj_t * new_lmeter = lv_bar_create(par, copy); lv_obj_t * new_lmeter = lv_obj_create(par, copy);
dm_assert(new_lmeter); dm_assert(new_lmeter);
/*Allocate the line meter type specific extended data*/ /*Allocate the line meter type specific extended data*/
@ -59,7 +59,10 @@ lv_obj_t * lv_lmeter_create(lv_obj_t * par, lv_obj_t * copy)
dm_assert(ext); dm_assert(ext);
/*Initialize the allocated 'ext' */ /*Initialize the allocated 'ext' */
ext->scale_num = 31; /*Odd scale number looks better*/ ext->min_value = 0;
ext->max_value = 100;
ext->cur_value = 0;
ext->line_cnt = 31; /*Odd scale number looks better*/
ext->scale_angle = 240; /*(scale_num - 1) * N looks better */ ext->scale_angle = 240; /*(scale_num - 1) * N looks better */
/*The signal and design functions are not copied so set them here*/ /*The signal and design functions are not copied so set them here*/
@ -75,8 +78,10 @@ lv_obj_t * lv_lmeter_create(lv_obj_t * par, lv_obj_t * copy)
else { else {
lv_lmeter_ext_t * copy_ext = lv_obj_get_ext_attr(copy); lv_lmeter_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
ext->scale_angle = copy_ext->scale_angle; ext->scale_angle = copy_ext->scale_angle;
ext->scale_num = copy_ext->scale_num; ext->line_cnt = copy_ext->line_cnt;
ext->min_value = copy_ext->min_value;
ext->max_value = copy_ext->max_value;
ext->cur_value = copy_ext->cur_value;
/*Refresh the style with new signal function*/ /*Refresh the style with new signal function*/
lv_obj_refresh_style(new_lmeter); lv_obj_refresh_style(new_lmeter);
@ -97,7 +102,7 @@ bool lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param)
bool valid; bool valid;
/* Include the ancient signal function */ /* Include the ancient signal function */
valid = lv_bar_signal(lmeter, sign, param); valid = lv_obj_signal(lmeter, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */
@ -114,17 +119,52 @@ bool lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param)
* Setter functions * Setter functions
*====================*/ *====================*/
/**
* Set a new value on the line meter
* @param lmeter pointer to a line meter object
* @param value new value
*/
void lv_lmeter_set_value(lv_obj_t *lmeter, int16_t value)
{
lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
ext->cur_value = value > ext->max_value ? ext->max_value : value;
ext->cur_value = ext->cur_value < ext->min_value ? ext->min_value : ext->cur_value;
lv_obj_invalidate(lmeter);
}
/**
* Set minimum and the maximum values of a line meter
* @param lmeter pointer to he line meter object
* @param min minimum value
* @param max maximum value
*/
void lv_lmeter_set_range(lv_obj_t *lmeter, int16_t min, int16_t max)
{
lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
ext->max_value = max;
ext->min_value = min;
if(ext->cur_value > max) {
ext->cur_value = max;
lv_lmeter_set_value(lmeter, ext->cur_value);
}
if(ext->cur_value < min) {
ext->cur_value = min;
lv_lmeter_set_value(lmeter, ext->cur_value);
}
lv_obj_invalidate(lmeter);
}
/** /**
* Set the scale settings of a line meter * Set the scale settings of a line meter
* @param lmeter pointer to a line meter object * @param lmeter pointer to a line meter object
* @param angle angle of the scale (0..360) * @param angle angle of the scale (0..360)
* @param num number of scale units * @param line_cnt number of lines
*/ */
void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t num) void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t line_cnt)
{ {
lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter); lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
ext->scale_angle = angle; ext->scale_angle = angle;
ext->scale_num = num; ext->line_cnt = line_cnt;
lv_obj_invalidate(lmeter); lv_obj_invalidate(lmeter);
} }
@ -134,15 +174,48 @@ void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t num)
* Getter functions * Getter functions
*====================*/ *====================*/
/**
* Get the value of a line meter
* @param lmeter pointer to a line meter object
* @return the value of the line meter
*/
int16_t lv_lmeter_get_value(lv_obj_t *lmeter)
{
lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
return ext->cur_value;
}
/**
* Get the minimum value of a line meter
* @param lmeter pointer to a line meter object
* @return the minimum value of the line meter
*/
int16_t lv_lmeter_get_min_value(lv_obj_t * lmeter)
{
lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
return ext->min_value;
}
/**
* Get the maximum value of a line meter
* @param lmeter pointer to a line meter object
* @return the maximum value of the line meter
*/
int16_t lv_lmeter_get_max_value(lv_obj_t * lmeter)
{
lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
return ext->max_value;
}
/** /**
* Get the scale number of a line meter * Get the scale number of a line meter
* @param lmeter pointer to a line meter object * @param lmeter pointer to a line meter object
* @return number of the scale units * @return number of the scale units
*/ */
uint8_t lv_lmeter_get_scale_num(lv_obj_t * lmeter) uint8_t lv_lmeter_get_line_count(lv_obj_t * lmeter)
{ {
lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter); lv_lmeter_ext_t * ext = lv_obj_get_ext_attr(lmeter);
return ext->scale_num ; return ext->line_cnt ;
} }
/** /**
@ -190,16 +263,14 @@ static bool lv_lmeter_design(lv_obj_t * lmeter, const area_t * mask, lv_design_m
cord_t x_ofs = lv_obj_get_width(lmeter) / 2 + lmeter->coords.x1; cord_t x_ofs = lv_obj_get_width(lmeter) / 2 + lmeter->coords.x1;
cord_t y_ofs = lv_obj_get_height(lmeter) / 2 + lmeter->coords.y1; cord_t y_ofs = lv_obj_get_height(lmeter) / 2 + lmeter->coords.y1;
int16_t angle_ofs = 90 + (360 - ext->scale_angle) / 2; int16_t angle_ofs = 90 + (360 - ext->scale_angle) / 2;
int16_t min = lv_bar_get_min_value(lmeter); int16_t level = (int32_t)((int32_t)(ext->cur_value - ext->min_value) * ext->line_cnt) / (ext->max_value - ext->min_value);
int16_t max = lv_bar_get_max_value(lmeter);
int16_t level = (int32_t)((int32_t)(lv_bar_get_value(lmeter) - min) * ext->scale_num) / (max - min);
uint8_t i; uint8_t i;
style_tmp.line.color = style->body.color_main; style_tmp.line.color = style->body.color_main;
for(i = 0; i < ext->scale_num; i++) { for(i = 0; i < ext->line_cnt; i++) {
/*Calculate the position a scale label*/ /*Calculate the position a scale label*/
int16_t angle = (i * ext->scale_angle) / (ext->scale_num - 1) + angle_ofs; int16_t angle = (i * ext->scale_angle) / (ext->line_cnt - 1) + angle_ofs;
cord_t y_out = (int32_t)((int32_t)trigo_sin(angle) * r_out) / TRIGO_SIN_MAX; cord_t y_out = (int32_t)((int32_t)trigo_sin(angle) * r_out) / TRIGO_SIN_MAX;
cord_t x_out = (int32_t)((int32_t)trigo_sin(angle + 90) * r_out) / TRIGO_SIN_MAX; cord_t x_out = (int32_t)((int32_t)trigo_sin(angle + 90) * r_out) / TRIGO_SIN_MAX;
@ -217,7 +288,7 @@ static bool lv_lmeter_design(lv_obj_t * lmeter, const area_t * mask, lv_design_m
if(i > level) style_tmp.line.color = style->line.color; if(i > level) style_tmp.line.color = style->line.color;
else { else {
style_tmp.line.color = color_mix(style->body.color_gradient, style->body.color_main, (255 * i) / ext->scale_num); style_tmp.line.color = color_mix(style->body.color_gradient, style->body.color_main, (255 * i) / ext->line_cnt);
} }
lv_draw_line(&p1, &p2, mask, &style_tmp); lv_draw_line(&p1, &p2, mask, &style_tmp);

76
lv_objx/lv_lmeter.h
View File

@ -18,17 +18,12 @@ extern "C" {
#if USE_LV_LMETER != 0 #if USE_LV_LMETER != 0
/*Testing of dependencies*/ /*Testing of dependencies*/
#if USE_LV_BAR == 0
#error "lv_lmeter: lv_bar is required. Enable it in lv_conf.h (USE_LV_BAR 1) "
#endif
#if USE_TRIGO == 0 #if USE_TRIGO == 0
#error "lv_lmeter: trigo is required. Enable it in misc_conf.h (USE_TRIGO 1) " #error "lv_lmeter: trigo is required. Enable it in misc_conf.h (USE_TRIGO 1) "
#endif #endif
#include "../lv_obj/lv_obj.h" #include "../lv_obj/lv_obj.h"
#include "lv_bar.h"
/********************* /*********************
* DEFINES * DEFINES
@ -40,10 +35,13 @@ extern "C" {
/*Data of line meter*/ /*Data of line meter*/
typedef struct typedef struct
{ {
lv_bar_ext_t bar; /*Ext. of ancestor*/ /*No inherited ext.*/ /*Ext. of ancestor*/
/*New data for this type */ /*New data for this type */
uint16_t scale_angle; /*Angle of the scale in deg. (0..360)*/ uint16_t scale_angle; /*Angle of the scale in deg. (0..360)*/
uint8_t scale_num; /*Number of scale units */ uint8_t line_cnt; /*Count of lines */
int16_t cur_value;
int16_t min_value;
int16_t max_value;
}lv_lmeter_ext_t; }lv_lmeter_ext_t;
/********************** /**********************
@ -67,6 +65,21 @@ lv_obj_t * lv_lmeter_create(lv_obj_t * par, lv_obj_t * copy);
*/ */
bool lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param); bool lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param);
/**
* Set a new value on the line meter
* @param lmeter pointer to a line meter object
* @param value new value
*/
void lv_lmeter_set_value(lv_obj_t *lmeter, int16_t value);
/**
* Set minimum and the maximum values of a line meter
* @param lmeter pointer to he line meter object
* @param min minimum value
* @param max maximum value
*/
void lv_lmeter_set_range(lv_obj_t *lmeter, int16_t min, int16_t max);
/** /**
* Set the scale settings of a line meter * Set the scale settings of a line meter
* @param lmeter pointer to a line meter object * @param lmeter pointer to a line meter object
@ -75,12 +88,33 @@ bool lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param);
*/ */
void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t num); void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t num);
/**
* Get the value of a line meter
* @param lmeter pointer to a line meter object
* @return the value of the line meter
*/
int16_t lv_lmeter_get_value(lv_obj_t *lmeter);
/**
* Get the minimum value of a line meter
* @param lmeter pointer to a line meter object
* @return the minimum value of the line meter
*/
int16_t lv_lmeter_get_min_value(lv_obj_t * lmeter);
/**
* Get the maximum value of a line meter
* @param lmeter pointer to a line meter object
* @return the maximum value of the line meter
*/
int16_t lv_lmeter_get_max_value(lv_obj_t * lmeter);
/** /**
* Get the scale number of a line meter * Get the scale number of a line meter
* @param lmeter pointer to a line meter object * @param lmeter pointer to a line meter object
* @return number of the scale units * @return number of the scale units
*/ */
uint8_t lv_lmeter_get_scale_num(lv_obj_t * lmeter); uint8_t lv_lmeter_get_line_count(lv_obj_t * lmeter);
/** /**
* Get the scale angle of a line meter * Get the scale angle of a line meter
@ -88,6 +122,32 @@ uint8_t lv_lmeter_get_scale_num(lv_obj_t * lmeter);
* @return angle of the scale * @return angle of the scale
*/ */
uint16_t lv_lmeter_get_scale_angle(lv_obj_t * lmeter); uint16_t lv_lmeter_get_scale_angle(lv_obj_t * lmeter);
/****************************
* TRANSPARENT API FUNCTIONS
***************************/
/**
* Set the styles of a line meter
* @param lmeter pointer to a line meter object
* @param style set the style of the line meter
* */
static inline void lv_lmeter_set_style(lv_obj_t *lmeter, lv_style_t *style)
{
lv_obj_set_style(lmeter, style);
}
/**
* Get the style of a line meter
* @param lmeter pointer to a line meter object
* @return pointer to the line meter's style
*/
static inline lv_style_t * lv_lmeter_get_style(lv_obj_t * lmeter)
{
return lv_obj_get_style(lmeter);
}
/********************** /**********************
* MACROS * MACROS
**********************/ **********************/

279
lv_objx/lv_mbox.c
View File

@ -27,15 +27,15 @@
/********************** /**********************
* STATIC PROTOTYPES * STATIC PROTOTYPES
**********************/ **********************/
#if 0 /*Unused*/ static lv_res_t lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param);
static bool lv_mbox_design(lv_obj_t * mbox, const area_t * mask, lv_design_mode_t mode);
#endif
static void lv_mbox_realign(lv_obj_t * mbox); static void lv_mbox_realign(lv_obj_t * mbox);
static void lv_mbox_disable_fit(lv_obj_t * mbox); static void lv_mbox_disable_fit(lv_obj_t * mbox);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static lv_signal_func_t ancestor_signal;
/********************** /**********************
* MACROS * MACROS
**********************/ **********************/
@ -59,6 +59,7 @@ lv_obj_t * lv_mbox_create(lv_obj_t * par, lv_obj_t * copy)
/*Create the ancestor message box*/ /*Create the ancestor message box*/
lv_obj_t * new_mbox = lv_cont_create(par, copy); lv_obj_t * new_mbox = lv_cont_create(par, copy);
dm_assert(new_mbox); dm_assert(new_mbox);
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_mbox);
/*Allocate the message box type specific extended data*/ /*Allocate the message box type specific extended data*/
lv_mbox_ext_t * ext = lv_obj_allocate_ext_attr(new_mbox, sizeof(lv_mbox_ext_t)); lv_mbox_ext_t * ext = lv_obj_allocate_ext_attr(new_mbox, sizeof(lv_mbox_ext_t));
@ -106,136 +107,6 @@ lv_obj_t * lv_mbox_create(lv_obj_t * par, lv_obj_t * copy)
return new_mbox; return new_mbox;
} }
/**
* Signal function of the message box
* @param mbox pointer to a message box object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
* @return true: the object is still valid (not deleted), false: the object become invalid
*/
bool lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param)
{
bool valid;
/* Include the ancient signal function */
valid = lv_cont_signal(mbox, sign, param);
/* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(valid != false) {
lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
if(sign == LV_SIGNAL_CORD_CHG) {
/*If the size is changed refresh the message box*/
if(area_get_width(param) != lv_obj_get_width(mbox) ||
area_get_height(param) != lv_obj_get_height(mbox)) {
lv_mbox_realign(mbox);
}
} else if(sign == LV_SIGNAL_LONG_PRESS) {
lv_mbox_start_auto_close(mbox, 0);
lv_indev_wait_release(param);
valid = false;
} else if(sign == LV_SIGNAL_STYLE_CHG) {
/*Refresh all the buttons*/
if(ext->btnh != NULL) {
lv_obj_t * btn;
btn = lv_obj_get_child(ext->btnh, NULL);
while(btn != NULL) {
/*Refresh the next button's style*/
lv_btn_set_style(btn, ext->style_btn_rel, ext->style_btn_pr, NULL, NULL, NULL);
btn = lv_obj_get_child(ext->btnh, btn);
}
}
} else if(sign == LV_SIGNAL_FOCUS) {
/*Get the first button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
lv_obj_t * btn_prev = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
btn_prev = btn;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn_prev != NULL) {
lv_btn_set_state(btn_prev, LV_BTN_STATE_PRESSED);
}
}
} else if(sign == LV_SIGNAL_DEFOCUS) {
/*Get the 'pressed' button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
if(lv_btn_get_state(btn) == LV_BTN_STATE_PRESSED) break;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn != NULL) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
}
}
} else if(sign == LV_SIGNAL_CONTROLL) {
lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
char c = *((char*)param);
if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_UP) {
/*Get the last pressed button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
lv_obj_t * btn_prev = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
if(lv_btn_get_state(btn) == LV_BTN_STATE_PRESSED) break;
btn_prev = btn;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn_prev != NULL && btn != NULL) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
lv_btn_set_state(btn_prev, LV_BTN_STATE_PRESSED);
}
}
} else if(c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_DOWN) {
/*Get the last pressed button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
if(lv_btn_get_state(btn) == LV_BTN_STATE_PRESSED) break;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn != NULL) {
lv_obj_t * btn_prev = lv_obj_get_child(ext->btnh, btn);
if(btn_prev != NULL) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
lv_btn_set_state(btn_prev, LV_BTN_STATE_PRESSED);
}
}
}
} else if(c == LV_GROUP_KEY_ENTER) {
/*Get the 'pressed' button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
if(lv_btn_get_state(btn) == LV_BTN_STATE_PRESSED) break;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn != NULL) {
lv_action_t rel_action;
rel_action = lv_btn_get_action(btn, LV_BTN_ACTION_RELEASE);
if(rel_action != NULL) rel_action(btn);
}
}
}
}
}
return valid;
}
/** /**
* A release action which can be assigned to a message box button to close it * A release action which can be assigned to a message box button to close it
* @param btn pointer to the released button * @param btn pointer to the released button
@ -428,30 +299,136 @@ lv_style_t * lv_mbox_get_style_btn(lv_obj_t * mbox, lv_btn_state_t state)
* STATIC FUNCTIONS * STATIC FUNCTIONS
**********************/ **********************/
#if 0 /*Not used*/
/** /**
* Handle the drawing related tasks of the message boxs * Signal function of the message box
* @param mbox pointer to an object * @param mbox pointer to a message box object
* @param mask the object will be drawn only in this area * @param sign a signal type from lv_signal_t enum
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area * @param param pointer to a signal specific variable
* (return 'true' if yes) * @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
* LV_DESIGN_DRAW: draw the object (always return 'true')
* LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @param return true/false, depends on 'mode'
*/ */
static bool lv_mbox_design(lv_obj_t * mbox, const area_t * mask, lv_design_mode_t mode) static lv_res_t lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param)
{ {
if(mode == LV_DESIGN_COVER_CHK) { lv_res_t res;
/*Return false if the object is not covers the mask_p area*/
return false; /* Include the ancient signal function */
res = ancestor_signal(mbox, sign, param);
/* The object can be deleted so check its validity and then
* make the object specific signal handling */
if(res == LV_RES_OK) {
lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
if(sign == LV_SIGNAL_CORD_CHG) {
/*If the size is changed refresh the message box*/
if(area_get_width(param) != lv_obj_get_width(mbox) ||
area_get_height(param) != lv_obj_get_height(mbox)) {
lv_mbox_realign(mbox);
}
} else if(sign == LV_SIGNAL_LONG_PRESS) {
lv_mbox_start_auto_close(mbox, 0);
lv_indev_wait_release(param);
res = LV_RES_INV;
} else if(sign == LV_SIGNAL_STYLE_CHG) {
/*Refresh all the buttons*/
if(ext->btnh != NULL) {
lv_obj_t * btn;
btn = lv_obj_get_child(ext->btnh, NULL);
while(btn != NULL) {
/*Refresh the next button's style*/
lv_btn_set_style(btn, ext->style_btn_rel, ext->style_btn_pr, NULL, NULL, NULL);
btn = lv_obj_get_child(ext->btnh, btn);
}
}
} else if(sign == LV_SIGNAL_FOCUS) {
/*Get the first button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
lv_obj_t * btn_prev = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
btn_prev = btn;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn_prev != NULL) {
lv_btn_set_state(btn_prev, LV_BTN_STATE_PRESSED);
}
}
} else if(sign == LV_SIGNAL_DEFOCUS) {
/*Get the 'pressed' button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
if(lv_btn_get_state(btn) == LV_BTN_STATE_PRESSED) break;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn != NULL) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
}
}
} else if(sign == LV_SIGNAL_CONTROLL) {
lv_mbox_ext_t * ext = lv_obj_get_ext_attr(mbox);
char c = *((char*)param);
if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_UP) {
/*Get the last pressed button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
lv_obj_t * btn_prev = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
if(lv_btn_get_state(btn) == LV_BTN_STATE_PRESSED) break;
btn_prev = btn;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn_prev != NULL && btn != NULL) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
lv_btn_set_state(btn_prev, LV_BTN_STATE_PRESSED);
}
}
} else if(c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_DOWN) {
/*Get the last pressed button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
if(lv_btn_get_state(btn) == LV_BTN_STATE_PRESSED) break;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn != NULL) {
lv_obj_t * btn_prev = lv_obj_get_child(ext->btnh, btn);
if(btn_prev != NULL) {
lv_btn_set_state(btn, LV_BTN_STATE_RELEASED);
lv_btn_set_state(btn_prev, LV_BTN_STATE_PRESSED);
}
}
}
} else if(c == LV_GROUP_KEY_ENTER) {
/*Get the 'pressed' button*/
if(ext->btnh != NULL) {
lv_obj_t * btn = NULL;
btn = lv_obj_get_child(ext->btnh, btn);
while(btn != NULL) {
if(lv_btn_get_state(btn) == LV_BTN_STATE_PRESSED) break;
btn = lv_obj_get_child(ext->btnh, btn);
}
if(btn != NULL) {
lv_action_t rel_action;
rel_action = lv_btn_get_action(btn, LV_BTN_ACTION_RELEASE);
if(rel_action != NULL) rel_action(btn);
}
}
}
}
} }
return res;
/*Draw the object*/
return true;
} }
#endif
/** /**
* Realign the elements of the message box * Realign the elements of the message box

9
lv_objx/lv_mbox.h
View File

@ -67,15 +67,6 @@ typedef struct
*/ */
lv_obj_t * lv_mbox_create(lv_obj_t * par, lv_obj_t * copy); lv_obj_t * lv_mbox_create(lv_obj_t * par, lv_obj_t * copy);
/**
* Signal function of the message box
* @param mbox pointer to a message box object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
* @return true: the object is still valid (not deleted), false: the object become invalid
*/
bool lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param);
/** /**
* A release action which can be assigned to a message box button to close it * A release action which can be assigned to a message box button to close it
* @param btn pointer to the released button * @param btn pointer to the released button

792
lv_objx/lv_page.c
View File

@ -12,7 +12,6 @@
#include "misc/math/math_base.h" #include "misc/math/math_base.h"
#include "../lv_obj/lv_group.h" #include "../lv_obj/lv_group.h"
#include "../lv_objx/lv_page.h" #include "../lv_objx/lv_page.h"
#include "../lv_objx/lv_cont.h"
#include "../lv_draw/lv_draw.h" #include "../lv_draw/lv_draw.h"
#include "../lv_obj/lv_refr.h" #include "../lv_obj/lv_refr.h"
#include "misc/gfx/anim.h" #include "misc/gfx/anim.h"
@ -20,6 +19,7 @@
/********************* /*********************
* DEFINES * DEFINES
*********************/ *********************/
#define LV_PAGE_SB_MIN_SIZE (LV_DPI / 8)
/********************** /**********************
* TYPEDEFS * TYPEDEFS
@ -31,12 +31,14 @@
static void lv_page_sb_refresh(lv_obj_t * main); static void lv_page_sb_refresh(lv_obj_t * main);
static bool lv_page_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode); static bool lv_page_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode);
static bool lv_scrl_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode); static bool lv_scrl_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode);
static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param);
static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static lv_design_func_t ancestor_page_design_f; static lv_signal_func_t ancestor_signal;
static lv_design_func_t ancestor_scrl_design_f; static lv_design_func_t ancestor_design;
/********************** /**********************
* MACROS * MACROS
@ -61,6 +63,8 @@ lv_obj_t * lv_page_create(lv_obj_t * par, lv_obj_t * copy)
/*Create the ancestor object*/ /*Create the ancestor object*/
lv_obj_t * new_page = lv_cont_create(par, copy); lv_obj_t * new_page = lv_cont_create(par, copy);
dm_assert(new_page); dm_assert(new_page);
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_page);
if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_func(new_page);
/*Allocate the object type specific extended data*/ /*Allocate the object type specific extended data*/
lv_page_ext_t * ext = lv_obj_allocate_ext_attr(new_page, sizeof(lv_page_ext_t)); lv_page_ext_t * ext = lv_obj_allocate_ext_attr(new_page, sizeof(lv_page_ext_t));
@ -68,46 +72,36 @@ lv_obj_t * lv_page_create(lv_obj_t * par, lv_obj_t * copy)
ext->scrl = NULL; ext->scrl = NULL;
ext->pr_action = NULL; ext->pr_action = NULL;
ext->rel_action = NULL; ext->rel_action = NULL;
ext->sbh_draw = 0; ext->sb.hor_draw = 0;
ext->sbv_draw = 0; ext->sb.ver_draw = 0;
ext->style_sb = &lv_style_pretty; ext->sb.style = &lv_style_pretty;
ext->sb_width = LV_DPI / 8; /*Will be modified later*/ ext->sb.mode = LV_PAGE_SB_MODE_AUTO;
ext->sb_mode = LV_PAGE_SB_MODE_ON;
if(ancestor_page_design_f == NULL) ancestor_page_design_f = lv_obj_get_design_func(new_page);
/*Init the new page object*/ /*Init the new page object*/
if(copy == NULL) { if(copy == NULL) {
lv_style_t * style = &lv_style_pretty_color;
ext->scrl = lv_cont_create(new_page, NULL); ext->scrl = lv_cont_create(new_page, NULL);
if(ancestor_scrl_design_f == NULL) ancestor_scrl_design_f = lv_obj_get_design_func(ext->scrl); lv_obj_set_signal_func(ext->scrl, lv_page_scrollable_signal);
lv_obj_set_signal_func(ext->scrl, lv_page_scrl_signal); lv_obj_set_design_func(ext->scrl, lv_scrl_design);
lv_obj_set_drag(ext->scrl, true); lv_obj_set_drag(ext->scrl, true);
lv_obj_set_drag_throw(ext->scrl, true); lv_obj_set_drag_throw(ext->scrl, true);
lv_obj_set_protect(ext->scrl, LV_PROTECT_PARENT); lv_obj_set_protect(ext->scrl, LV_PROTECT_PARENT);
lv_cont_set_fit(ext->scrl, false, true); lv_cont_set_fit(ext->scrl, false, true);
lv_obj_set_style(ext->scrl, &lv_style_pretty);
lv_obj_set_design_func(ext->scrl, lv_scrl_design);
lv_page_set_sb_width(new_page, style->body.padding.hor);
lv_page_set_sb_mode(new_page, ext->sb_mode);
lv_page_set_style_sb(new_page, ext->style_sb);
/* Add the signal function only if 'scrolling' is created /* Add the signal function only if 'scrolling' is created
* because everything has to be ready before any signal is received*/ * because everything has to be ready before any signal is received*/
lv_obj_set_signal_func(new_page, lv_page_signal); lv_obj_set_signal_func(new_page, lv_page_signal);
lv_obj_set_design_func(new_page, lv_page_design); lv_obj_set_design_func(new_page, lv_page_design);
lv_obj_set_style(new_page, style); lv_page_set_style(new_page, &lv_style_pretty_color, &lv_style_pretty, &lv_style_pretty_color);
lv_page_set_sb_mode(new_page, ext->sb.mode);
} else { } else {
lv_page_ext_t * copy_ext = lv_obj_get_ext_attr(copy); lv_page_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
ext->scrl = lv_cont_create(new_page, copy_ext->scrl); ext->scrl = lv_cont_create(new_page, copy_ext->scrl);
lv_obj_set_signal_func(ext->scrl, lv_page_scrl_signal); lv_obj_set_signal_func(ext->scrl, lv_page_scrollable_signal);
lv_page_set_pr_action(new_page, copy_ext->pr_action); lv_page_set_press_action(new_page, copy_ext->pr_action);
lv_page_set_rel_action(new_page, copy_ext->rel_action); lv_page_set_release_action(new_page, copy_ext->rel_action);
lv_page_set_sb_mode(new_page, copy_ext->sb_mode); lv_page_set_sb_mode(new_page, copy_ext->sb.mode);
lv_page_set_sb_width(new_page, copy_ext->sb_width); lv_page_set_style(new_page, lv_obj_get_style(copy), lv_obj_get_style(copy_ext->scrl), copy_ext->sb.style);
lv_page_set_style_sb(new_page, copy_ext->style_sb);
/* Add the signal function only if 'scrolling' is created /* Add the signal function only if 'scrolling' is created
* because everything has to be ready before any signal is received*/ * because everything has to be ready before any signal is received*/
@ -123,26 +117,302 @@ lv_obj_t * lv_page_create(lv_obj_t * par, lv_obj_t * copy)
return new_page; return new_page;
} }
/*=====================
* Setter functions
*====================*/
/**
* Set a release action for the page
* @param page pointer to a page object
* @param rel_action a function to call when the page is released
*/
void lv_page_set_release_action(lv_obj_t * page, lv_action_t rel_action)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
ext->rel_action = rel_action;
}
/**
* Set a press action for the page
* @param page pointer to a page object
* @param pr_action a function to call when the page is pressed
*/
void lv_page_set_press_action(lv_obj_t * page, lv_action_t pr_action)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
ext->pr_action = pr_action;
}
/**
* Set the scroll bar mode on a page
* @param page pointer to a page object
* @param sb.mode the new mode from 'lv_page_sb.mode_t' enum
*/
void lv_page_set_sb_mode(lv_obj_t * page, lv_page_sb_mode_t sb_mode)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
ext->sb.mode = sb_mode;
ext->sb.hor_draw = 0;
ext->sb.ver_draw = 0;
lv_page_sb_refresh(page);
lv_obj_invalidate(page);
}
/**
* Set a new styles for the page
* @param page pointer to a page object
* @param bg pointer to a style for the background
* @param scrl pointer to a style for the scrollable area
* @param sb pointer to a style for the scroll bars
*/
void lv_page_set_style(lv_obj_t *page, lv_style_t *bg, lv_style_t *scrl, lv_style_t *sb)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
if(sb != NULL) {
ext->sb.style = sb;
area_set_height(&ext->sb.hor_area, ext->sb.style->body.padding.inner);
area_set_width(&ext->sb.ver_area, ext->sb.style->body.padding.inner);
lv_page_sb_refresh(page);
lv_obj_invalidate(page);
}
if(scrl != NULL) lv_obj_set_style(ext->scrl, scrl);
if(bg != NULL) lv_obj_set_style(page, bg);
}
/**
* Glue the object to the page. After it the page can be moved (dragged) with this object too.
* @param obj pointer to an object on a page
* @param glue true: enable glue, false: disable glue
*/
void lv_page_glue_obj(lv_obj_t * obj, bool glue)
{
lv_obj_set_drag_parent(obj, glue);
lv_obj_set_drag(obj, glue);
}
/**
* Focus on an object. It ensures that the object will be visible on the page.
* @param page pointer to a page object
* @param obj pointer to an object to focus (must be on the page)
* @param anim_time scroll animation time in milliseconds (0: no animation)
*/
void lv_page_focus(lv_obj_t * page, lv_obj_t * obj, uint16_t anim_time)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
lv_style_t * style = lv_page_get_style_bg(page);
lv_style_t * style_scrl = lv_page_get_style_scrl(page);
cord_t obj_y = obj->coords.y1 - ext->scrl->coords.y1;
cord_t obj_h = lv_obj_get_height(obj);
cord_t scrlable_y = lv_obj_get_y(ext->scrl);
cord_t page_h = lv_obj_get_height(page);
cord_t top_err = -(scrlable_y + obj_y);
cord_t bot_err = scrlable_y + obj_y + obj_h - page_h;
/*If obj is higher then the page focus where the "error" is smaller*/
/*Out of the page on the top*/
if((obj_h <= page_h && top_err > 0) ||
(obj_h > page_h && top_err < bot_err)) {
/*Calculate a new position and let some space above*/
scrlable_y = -(obj_y - style_scrl->body.padding.ver - style->body.padding.ver);
scrlable_y += style_scrl->body.padding.ver;
}
/*Out of the page on the bottom*/
else if((obj_h <= page_h && bot_err > 0) ||
(obj_h > page_h && top_err >= bot_err)) {
/*Calculate a new position and let some space below*/
scrlable_y = -obj_y;
scrlable_y += page_h - obj_h;
scrlable_y -= style_scrl->body.padding.ver;
} else {
/*Already in focus*/
return;
}
if(anim_time == 0) {
lv_obj_set_y(ext->scrl, scrlable_y);
}
else {
anim_t a;
a.act_time = 0;
a.start = lv_obj_get_y(ext->scrl);
a.end = scrlable_y;
a.time = anim_time;
a.end_cb = NULL;
a.playback = 0;
a.repeat = 0;
a.var = ext->scrl;
a.path = anim_get_path(ANIM_PATH_LIN);
a.fp = (anim_fp_t) lv_obj_set_y;
anim_create(&a);
}
}
/*=====================
* Getter functions
*====================*/
/**
* Get the scrollable object of a page
* @param page pointer to a page object
* @return pointer to a container which is the scrollable part of the page
*/
lv_obj_t * lv_page_get_scrl(lv_obj_t * page)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
return ext->scrl;
}
/**
* Set the scroll bar mode on a page
* @param page pointer to a page object
* @return the mode from 'lv_page_sb.mode_t' enum
*/
lv_page_sb_mode_t lv_page_get_sb_mode(lv_obj_t * page)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
return ext->sb.mode;
}
/**
* Get the style of the scrollable part of a page
* @param page pointer to a page object
* @return pointer to the style of the scrollale part
*/
lv_style_t * lv_page_get_style_scrl(lv_obj_t * page)
{
return lv_obj_get_style(lv_page_get_scrl(page));
}
/**
* Get the style of the scrolbars of a page
* @param page pointer to a page object
* @return pointer to the style of the scrollbars
*/
lv_style_t * lv_page_get_style_sb(lv_obj_t * page)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
return ext->sb.style;
}
/**********************
* STATIC FUNCTIONS
**********************/
/**
* Handle the drawing related tasks of the pages
* @param page pointer to an object
* @param mask the object will be drawn only in this area
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
* (return 'true' if yes)
* LV_DESIGN_DRAW: draw the object (always return 'true')
* LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @param return true/false, depends on 'mode'
*/
static bool lv_page_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode)
{
if(mode == LV_DESIGN_COVER_CHK) {
return ancestor_design(scrl, mask, mode);
} else if(mode == LV_DESIGN_DRAW_MAIN) {
ancestor_design(scrl, mask, mode);
} else if(mode == LV_DESIGN_DRAW_POST) { /*Draw the scroll bars finally*/
ancestor_design(scrl, mask, mode);
lv_page_ext_t * ext = lv_obj_get_ext_attr(scrl);
/*Draw the scrollbars*/
area_t sb_area;
if(ext->sb.hor_draw) {
/*Convert the relative coordinates to absolute*/
area_cpy(&sb_area, &ext->sb.hor_area);
sb_area.x1 += scrl->coords.x1;
sb_area.y1 += scrl->coords.y1;
sb_area.x2 += scrl->coords.x1;
sb_area.y2 += scrl->coords.y1;
lv_draw_rect(&sb_area, mask, ext->sb.style);
}
if(ext->sb.ver_draw) {
/*Convert the relative coordinates to absolute*/
area_cpy(&sb_area, &ext->sb.ver_area);
sb_area.x1 += scrl->coords.x1;
sb_area.y1 += scrl->coords.y1;
sb_area.x2 += scrl->coords.x1;
sb_area.y2 += scrl->coords.y1;
lv_draw_rect(&sb_area, mask, ext->sb.style);
}
}
return true;
}
/**
* Handle the drawing related tasks of the scrollable object
* @param scrl pointer to an object
* @param mask the object will be drawn only in this area
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
* (return 'true' if yes)
* LV_DESIGN_DRAW: draw the object (always return 'true')
* LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @param return true/false, depends on 'mode'
*/
static bool lv_scrl_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode)
{
if(mode == LV_DESIGN_COVER_CHK) {
return ancestor_design(scrl, mask, mode);
} else if(mode == LV_DESIGN_DRAW_MAIN) {
#if LV_OBJ_GROUP != 0
/* If the page is the active in a group and
* the background (page) is not visible (transparent or empty)
* then activate the style of the scrollable*/
lv_style_t * style_ori = lv_obj_get_style(scrl);
lv_obj_t * page = lv_obj_get_parent(scrl);
lv_style_t * style_page = lv_obj_get_style(page);
lv_group_t * g = lv_obj_get_group(page);
if(style_page->body.empty != 0 || style_page->body.opa == OPA_TRANSP) { /*Background is visible?*/
if(lv_group_get_focused(g) == page) {
lv_style_t * style_mod;
style_mod = lv_group_mod_style(g, style_ori);
scrl->style_p = style_mod; /*Temporally change the style to the activated */
}
}
#endif
ancestor_design(scrl, mask, mode);
#if LV_OBJ_GROUP != 0
scrl->style_p = style_ori; /*Revert the style*/
#endif
} else if(mode == LV_DESIGN_DRAW_POST) {
ancestor_design(scrl, mask, mode);
}
return true;
}
/** /**
* Signal function of the page * Signal function of the page
* @param page pointer to a page object * @param page pointer to a page object
* @param sign a signal type from lv_signal_t enum * @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable * @param param pointer to a signal specific variable
* @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
*/ */
bool lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param) static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
{ {
bool obj_valid = true; lv_res_t res;
/* Include the ancient signal function */ /* Include the ancient signal function */
obj_valid = lv_cont_signal(page, sign, param); res = ancestor_signal(page, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */
if(obj_valid != false) { if(res == LV_RES_OK) {
lv_page_ext_t * ext = lv_obj_get_ext_attr(page); lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
lv_style_t * style = lv_obj_get_style(page);
lv_obj_t * child; lv_obj_t * child;
if(sign == LV_SIGNAL_CHILD_CHG) { /*Move children to the scrollable object*/ if(sign == LV_SIGNAL_CHILD_CHG) { /*Automatically move children to the scrollable object*/
child = lv_obj_get_child(page, NULL); child = lv_obj_get_child(page, NULL);
while(child != NULL) { while(child != NULL) {
if(lv_obj_is_protected(child, LV_PROTECT_PARENT) == false) { if(lv_obj_is_protected(child, LV_PROTECT_PARENT) == false) {
@ -153,46 +423,41 @@ bool lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
child = lv_obj_get_child(page, child); child = lv_obj_get_child(page, child);
} }
} }
} else if(sign == LV_SIGNAL_STYLE_CHG) { }
lv_style_t * style = lv_obj_get_style(page); else if(sign == LV_SIGNAL_STYLE_CHG) {
if(lv_cont_get_fit_hor(ext->scrl) == false) { /*If no hor_fit enabled set the scrollable's width to the page's width*/
if(lv_cont_get_hor_fit(ext->scrl) == false) {
lv_obj_set_width(ext->scrl, lv_obj_get_width(page) - 2 * style->body.padding.hor); lv_obj_set_width(ext->scrl, lv_obj_get_width(page) - 2 * style->body.padding.hor);
} else { } else {
ext->scrl->signal_func(ext->scrl, LV_SIGNAL_CORD_CHG, &ext->scrl->coords); ext->scrl->signal_func(ext->scrl, LV_SIGNAL_CORD_CHG, &ext->scrl->coords);
} }
if(ext->sb_mode == LV_PAGE_SB_MODE_ON) { /*The scrollbars are important only if they are visible now*/
ext->sbh_draw = 1; if(ext->sb.hor_draw || ext->sb.ver_draw) lv_page_sb_refresh(page);
ext->sbv_draw = 1;
} else {
ext->sbh_draw = 0;
ext->sbv_draw = 0;
}
lv_page_sb_refresh(page); }
} else if(sign == LV_SIGNAL_CORD_CHG) { else if(sign == LV_SIGNAL_CORD_CHG) {
lv_style_t * style = lv_obj_get_style(page);
/*Refresh the scrollbar and notify the scrl if the size is changed*/ /*Refresh the scrollbar and notify the scrl if the size is changed*/
if(ext->scrl != NULL && if(ext->scrl != NULL && (lv_obj_get_width(page) != area_get_width(param) ||
(lv_obj_get_width(page) != area_get_width(param) || lv_obj_get_height(page) != area_get_height(param)))
lv_obj_get_height(page) != area_get_height(param))) { {
/*If no hor_fit enabled set the scrollable's width to the page's width*/
if(lv_cont_get_fit_hor(ext->scrl) == false) { if(lv_cont_get_hor_fit(ext->scrl) == false) {
lv_obj_set_width(ext->scrl, lv_obj_get_width(page) - 2 * style->body.padding.hor); lv_obj_set_width(ext->scrl, lv_obj_get_width(page) - 2 * style->body.padding.hor);
} }
ext->scrl->signal_func(ext->scrl, LV_SIGNAL_CORD_CHG, &ext->scrl->coords); ext->scrl->signal_func(ext->scrl, LV_SIGNAL_CORD_CHG, &ext->scrl->coords);
/*The scrollbars are important only if they are visible now*/ /*The scrollbars are important only if they are visible now*/
if(ext->sbh_draw != 0 || ext->sbv_draw != 0) if(ext->sb.hor_draw || ext->sb.ver_draw) lv_page_sb_refresh(page);
lv_page_sb_refresh(page);
} }
} else if(sign == LV_SIGNAL_PRESSED) { }
else if(sign == LV_SIGNAL_PRESSED) {
if(ext->pr_action != NULL) { if(ext->pr_action != NULL) {
ext->pr_action(page); ext->pr_action(page);
} }
} else if(sign == LV_SIGNAL_RELEASED) { }
else if(sign == LV_SIGNAL_RELEASED) {
if(lv_indev_is_dragging(lv_indev_get_act()) == false) { if(lv_indev_is_dragging(lv_indev_get_act()) == false) {
if(ext->rel_action != NULL) { if(ext->rel_action != NULL) {
ext->rel_action(page); ext->rel_action(page);
@ -200,8 +465,8 @@ bool lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
} }
} }
} }
return obj_valid; return res;
} }
/** /**
@ -209,29 +474,31 @@ bool lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
* @param scrl pointer to the scrollable object * @param scrl pointer to the scrollable object
* @param sign a signal type from lv_signal_t enum * @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable * @param param pointer to a signal specific variable
* @return LV_RES_OK: the object is not deleted in the function; LV_RES_INV: the object is deleted
*/ */
bool lv_page_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param) static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
{ {
bool obj_valid = true; lv_res_t res;
/* Include the ancient signal function */ /* Include the ancient signal function */
obj_valid = lv_cont_signal(scrl, sign, param); res = ancestor_signal(scrl, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */
if(obj_valid != false) { if(res != false) {
lv_obj_t * page = lv_obj_get_parent(scrl); lv_obj_t * page = lv_obj_get_parent(scrl);
lv_style_t * page_style = lv_obj_get_style(page); lv_style_t * page_style = lv_obj_get_style(page);
lv_page_ext_t * page_ext = lv_obj_get_ext_attr(page); lv_page_ext_t * page_ext = lv_obj_get_ext_attr(page);
if(sign == LV_SIGNAL_CORD_CHG) { if(sign == LV_SIGNAL_CORD_CHG) {
/*Be sure the width of the scrollable is correct*/ /*Be sure the width of the scrollable is correct*/
if(lv_cont_get_fit_hor(scrl) == false) { if(lv_cont_get_hor_fit(scrl) == false) {
lv_obj_set_width(scrl, lv_obj_get_width(page) - 2 * page_style->body.padding.hor); lv_obj_set_width(scrl, lv_obj_get_width(page) - 2 * page_style->body.padding.hor);
} }
/*Limit the position of the scrollable object to be always visible
* (Do not let its edge inner then its parent respective edge)*/
cord_t new_x; cord_t new_x;
cord_t new_y; cord_t new_y;
bool refr_x = false; bool refr_x = false;
@ -286,44 +553,37 @@ bool lv_page_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
} }
lv_page_sb_refresh(page); lv_page_sb_refresh(page);
} else if(sign == LV_SIGNAL_DRAG_BEGIN) { }
if(page_ext->sb_mode == LV_PAGE_SB_MODE_DRAG ) { else if(sign == LV_SIGNAL_DRAG_END) {
cord_t sbh_pad = MATH_MAX(page_ext->sb_width, page_style->body.padding.hor); /*Hide scrollbars if required*/
cord_t sbv_pad = MATH_MAX(page_ext->sb_width, page_style->body.padding.ver); if(page_ext->sb.mode == LV_PAGE_SB_MODE_DRAG) {
if(area_get_height(&page_ext->sbv) < lv_obj_get_height(scrl) - 2 * sbv_pad) {
page_ext->sbv_draw = 1;
}
if(area_get_width(&page_ext->sbh) < lv_obj_get_width(scrl) - 2 * sbh_pad) {
page_ext->sbh_draw = 1;
}
}
} else if(sign == LV_SIGNAL_DRAG_END) {
if(page_ext->sb_mode == LV_PAGE_SB_MODE_DRAG) {
area_t sb_area_tmp; area_t sb_area_tmp;
if(page_ext->sbh_draw != 0) { if(page_ext->sb.hor_draw) {
area_cpy(&sb_area_tmp, &page_ext->sbh); area_cpy(&sb_area_tmp, &page_ext->sb.hor_area);
sb_area_tmp.x1 += page->coords.x1; sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2; sb_area_tmp.x2 += page->coords.x2;
sb_area_tmp.y2 += page->coords.y2; sb_area_tmp.y2 += page->coords.y2;
lv_inv_area(&sb_area_tmp); lv_inv_area(&sb_area_tmp);
page_ext->sbh_draw = 0; page_ext->sb.hor_draw = 0;
} }
if(page_ext->sbv_draw != 0) { if(page_ext->sb.ver_draw) {
area_cpy(&sb_area_tmp, &page_ext->sbv); area_cpy(&sb_area_tmp, &page_ext->sb.ver_area);
sb_area_tmp.x1 += page->coords.x1; sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2; sb_area_tmp.x2 += page->coords.x2;
sb_area_tmp.y2 += page->coords.y2; sb_area_tmp.y2 += page->coords.y2;
lv_inv_area(&sb_area_tmp); lv_inv_area(&sb_area_tmp);
page_ext->sbv_draw = 0; page_ext->sb.ver_draw = 0;
} }
} }
}else if(sign == LV_SIGNAL_PRESSED) { }
else if(sign == LV_SIGNAL_PRESSED) {
if(page_ext->pr_action != NULL) { if(page_ext->pr_action != NULL) {
page_ext->pr_action(page); page_ext->pr_action(page);
} }
} else if(sign == LV_SIGNAL_RELEASED) { }
else if(sign == LV_SIGNAL_RELEASED) {
if(lv_indev_is_dragging(lv_indev_get_act()) == false) { if(lv_indev_is_dragging(lv_indev_get_act()) == false) {
if(page_ext->rel_action != NULL) { if(page_ext->rel_action != NULL) {
page_ext->rel_action(page); page_ext->rel_action(page);
@ -332,289 +592,9 @@ bool lv_page_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
} }
} }
return obj_valid; return res;
} }
/*=====================
* Setter functions
*====================*/
/**
* Set a release action for the page
* @param page pointer to a page object
* @param rel_action a function to call when the page is released
*/
void lv_page_set_rel_action(lv_obj_t * page, lv_action_t rel_action)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
ext->rel_action = rel_action;
}
/**
* Set a press action for the page
* @param page pointer to a page object
* @param pr_action a function to call when the page is pressed
*/
void lv_page_set_pr_action(lv_obj_t * page, lv_action_t pr_action)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
ext->pr_action = pr_action;
}
/**
* Set the scroll bar width on a page
* @param page pointer to a page object
* @param sb_width the new scroll bar width in pixels
*/
void lv_page_set_sb_width(lv_obj_t * page, cord_t sb_width)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
ext->sb_width = sb_width;
area_set_height(&ext->sbh, ext->sb_width);
area_set_width(&ext->sbv, ext->sb_width);
lv_page_sb_refresh(page);
lv_obj_invalidate(page);
}
/**
* Set the scroll bar mode on a page
* @param page pointer to a page object
* @param sb_mode the new mode from 'lv_page_sb_mode_t' enum
*/
void lv_page_set_sb_mode(lv_obj_t * page, lv_page_sb_mode_t sb_mode)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
ext->sb_mode = sb_mode;
page->signal_func(page, LV_SIGNAL_STYLE_CHG, NULL);
lv_obj_invalidate(page);
}
/**
* Set a new style for the scroll bars object on the page
* @param page pointer to a page object
* @param style pointer to a style for the scroll bars
*/
void lv_page_set_style_sb(lv_obj_t * page, lv_style_t * style)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
ext->style_sb = style;
lv_obj_invalidate(page);
}
/**
* Glue the object to the page. After it the page can be moved (dragged) with this object too.
* @param obj pointer to an object on a page
* @param glue true: enable glue, false: disable glue
*/
void lv_page_glue_obj(lv_obj_t * obj, bool glue)
{
lv_obj_set_drag_parent(obj, glue);
lv_obj_set_drag(obj, glue);
}
/**
* Focus on an object. It ensures that the object will be visible on the page.
* @param page pointer to a page object
* @param obj pointer to an object to focus (must be on the page)
* @param anim_time scroll animation time in milliseconds (0: no animation)
*/
void lv_page_focus(lv_obj_t * page, lv_obj_t * obj, uint16_t anim_time)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
lv_style_t * style = lv_obj_get_style(page);
lv_obj_t * scrl = lv_page_get_scrl(page);
lv_style_t * style_scrl = lv_obj_get_style(scrl);
cord_t obj_y = obj->coords.y1 - ext->scrl->coords.y1;
cord_t obj_h = lv_obj_get_height(obj);
cord_t scrlable_y = lv_obj_get_y(ext->scrl);
cord_t page_h = lv_obj_get_height(page);
cord_t top_err = -(scrlable_y + obj_y);
cord_t bot_err = scrlable_y + obj_y + obj_h - page_h;
/*If obj is higher then the page focus where the "error" is smaller*/
/*Out of the page on the top*/
if((obj_h <= page_h && top_err > 0) ||
(obj_h > page_h && top_err < bot_err)) {
/*Calculate a new position and to let scrable_rects.vpad space above*/
scrlable_y = -(obj_y - style_scrl->body.padding.ver - style->body.padding.ver);
scrlable_y += style_scrl->body.padding.ver;
}
/*Out of the page on the bottom*/
else if((obj_h <= page_h && bot_err > 0) ||
(obj_h > page_h && top_err >= bot_err)) {
/*Calculate a new position and to let scrable_rects.vpad space below*/
scrlable_y = -obj_y;
scrlable_y += page_h - obj_h;
scrlable_y -= style_scrl->body.padding.ver;
} else {
/*Alraedy in focus*/
return;
}
if(anim_time == 0) {
lv_obj_set_y(ext->scrl, scrlable_y);
}
else {
anim_t a;
a.act_time = 0;
a.start = lv_obj_get_y(ext->scrl);
a.end = scrlable_y;
a.time = anim_time;
a.end_cb = NULL;
a.playback = 0;
a.repeat = 0;
a.var = ext->scrl;
a.path = anim_get_path(ANIM_PATH_LIN);
a.fp = (anim_fp_t) lv_obj_set_y;
anim_create(&a);
}
}
/*=====================
* Getter functions
*====================*/
/**
* Get the scrollable object of a page-
* @param page pointer to page object
* @return pointer to a container which is the scrollable part of the page
*/
lv_obj_t * lv_page_get_scrl(lv_obj_t * page)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
return ext->scrl;
}
/**
* Get the scroll bar width on a page
* @param page pointer to a page object
* @return the scroll bar width in pixels
*/
cord_t lv_page_get_sb_width(lv_obj_t * page)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
return ext->sb_width;
}
/**
* Set the scroll bar mode on a page
* @param page pointer to a page object
* @return the mode from 'lv_page_sb_mode_t' enum
*/
lv_page_sb_mode_t lv_page_get_sb_mode(lv_obj_t * page)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
return ext->sb_mode;
}
/**
* Set a new style for the scroll bars object on the page
* @param page pointer to a page object
* @return pointer to a style for the scroll bars
*/
lv_style_t * lv_page_get_style_sb(lv_obj_t * page)
{
lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
if(ext->style_sb == NULL) return lv_obj_get_style(page);
else return ext->style_sb;
}
/**********************
* STATIC FUNCTIONS
**********************/
/**
* Handle the drawing related tasks of the pages
* @param page pointer to an object
* @param mask the object will be drawn only in this area
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
* (return 'true' if yes)
* LV_DESIGN_DRAW: draw the object (always return 'true')
* LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @param return true/false, depends on 'mode'
*/
static bool lv_page_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode)
{
if(mode == LV_DESIGN_COVER_CHK) {
return ancestor_page_design_f(scrl, mask, mode);
} else if(mode == LV_DESIGN_DRAW_MAIN) {
ancestor_page_design_f(scrl, mask, mode);
} else if(mode == LV_DESIGN_DRAW_POST) { /*Draw the scroll bars finally*/
ancestor_page_design_f(scrl, mask, mode);
lv_page_ext_t * ext = lv_obj_get_ext_attr(scrl);
/*Draw the scrollbars*/
area_t sb_area;
if(ext->sbh_draw != 0) {
/*Convert the relative coordinates to absolute*/
area_cpy(&sb_area, &ext->sbh);
sb_area.x1 += scrl->coords.x1;
sb_area.y1 += scrl->coords.y1;
sb_area.x2 += scrl->coords.x1;
sb_area.y2 += scrl->coords.y1;
lv_draw_rect(&sb_area, mask, ext->style_sb);
}
if(ext->sbv_draw != 0) {
/*Convert the relative coordinates to absolute*/
area_cpy(&sb_area, &ext->sbv);
sb_area.x1 += scrl->coords.x1;
sb_area.y1 += scrl->coords.y1;
sb_area.x2 += scrl->coords.x1;
sb_area.y2 += scrl->coords.y1;
lv_draw_rect(&sb_area, mask, ext->style_sb);
}
}
return true;
}
/**
* Handle the drawing related tasks of the scrollable object
* @param scrl pointer to an object
* @param mask the object will be drawn only in this area
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
* (return 'true' if yes)
* LV_DESIGN_DRAW: draw the object (always return 'true')
* LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @param return true/false, depends on 'mode'
*/
static bool lv_scrl_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode)
{
if(mode == LV_DESIGN_COVER_CHK) {
return ancestor_page_design_f(scrl, mask, mode);
} else if(mode == LV_DESIGN_DRAW_MAIN) {
#if LV_OBJ_GROUP != 0
/* If the page is the active in a group and
* the background (page) is not visible (transparent or empty)
* then activate the style of the scrollable*/
lv_style_t * style_ori = lv_obj_get_style(scrl);
lv_obj_t * page = lv_obj_get_parent(scrl);
lv_style_t * style_page = lv_obj_get_style(page);
lv_group_t * g = lv_obj_get_group(page);
if(style_page->body.empty != 0 || style_page->body.opa == OPA_TRANSP) { /*Background is visible?*/
if(lv_group_get_focused(g) == page) {
lv_style_t * style_mod;
style_mod = lv_group_mod_style(g, style_ori);
scrl->style_p = style_mod; /*Temporally change the style to the activated */
}
}
#endif
ancestor_page_design_f(scrl, mask, mode);
#if LV_OBJ_GROUP != 0
scrl->style_p = style_ori; /*Revert the style*/
#endif
} else if(mode == LV_DESIGN_DRAW_POST) {
ancestor_page_design_f(scrl, mask, mode);
}
return true;
}
/** /**
* Refresh the position and size of the scroll bars. * Refresh the position and size of the scroll bars.
@ -622,10 +602,6 @@ static bool lv_scrl_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_
*/ */
static void lv_page_sb_refresh(lv_obj_t * page) static void lv_page_sb_refresh(lv_obj_t * page)
{ {
/*Always let sb_width padding above,under, left and right to the scrollbars
* else:
* - horizontal and vertical scrollbars can overlap on the corners
* - if the page has radius the scrollbar can be out of the radius */
lv_page_ext_t * ext = lv_obj_get_ext_attr(page); lv_page_ext_t * ext = lv_obj_get_ext_attr(page);
lv_style_t * style = lv_obj_get_style(page); lv_style_t * style = lv_obj_get_style(page);
@ -637,28 +613,33 @@ static void lv_page_sb_refresh(lv_obj_t * page)
cord_t vpad = style->body.padding.ver; cord_t vpad = style->body.padding.ver;
cord_t obj_w = lv_obj_get_width(page); cord_t obj_w = lv_obj_get_width(page);
cord_t obj_h = lv_obj_get_height(page); cord_t obj_h = lv_obj_get_height(page);
cord_t sbh_pad = MATH_MAX(ext->sb_width, style->body.padding.hor);
cord_t sbv_pad = MATH_MAX(ext->sb_width, style->body.padding.ver);
if(ext->sb_mode == LV_PAGE_SB_MODE_OFF) return; /*Always let 'scrollbar width' padding above, under, left and right to the scrollbars
* else:
* - horizontal and vertical scrollbars can overlap on the corners
* - if the page has radius the scrollbar can be out of the radius */
cord_t sb_hor_pad = MATH_MAX(ext->sb.style->body.padding.inner, style->body.padding.hor);
cord_t sb_ver_pad = MATH_MAX(ext->sb.style->body.padding.inner, style->body.padding.ver);
if(ext->sb_mode == LV_PAGE_SB_MODE_ON) { if(ext->sb.mode == LV_PAGE_SB_MODE_OFF) return;
ext->sbh_draw = 1;
ext->sbv_draw = 1; if(ext->sb.mode == LV_PAGE_SB_MODE_ON) {
ext->sb.hor_draw = 1;
ext->sb.ver_draw = 1;
} }
/*Invalidate the current (old) scrollbar areas*/ /*Invalidate the current (old) scrollbar areas*/
area_t sb_area_tmp; area_t sb_area_tmp;
if(ext->sbh_draw != 0) { if(ext->sb.hor_draw != 0) {
area_cpy(&sb_area_tmp, &ext->sbh); area_cpy(&sb_area_tmp, &ext->sb.hor_area);
sb_area_tmp.x1 += page->coords.x1; sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2; sb_area_tmp.x2 += page->coords.x2;
sb_area_tmp.y2 += page->coords.y2; sb_area_tmp.y2 += page->coords.y2;
lv_inv_area(&sb_area_tmp); lv_inv_area(&sb_area_tmp);
} }
if(ext->sbv_draw != 0) { if(ext->sb.ver_draw != 0) {
area_cpy(&sb_area_tmp, &ext->sbv); area_cpy(&sb_area_tmp, &ext->sb.ver_area);
sb_area_tmp.x1 += page->coords.x1; sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2; sb_area_tmp.x2 += page->coords.x2;
@ -666,50 +647,61 @@ static void lv_page_sb_refresh(lv_obj_t * page)
lv_inv_area(&sb_area_tmp); lv_inv_area(&sb_area_tmp);
} }
if(ext->sb.mode == LV_PAGE_SB_MODE_DRAG && lv_indev_is_dragging(lv_indev_get_act()) == false) {
ext->sb.hor_draw = 0;
ext->sb.ver_draw = 0;
return;
}
/*Horizontal scrollbar*/ /*Horizontal scrollbar*/
if(scrl_w <= obj_w - 2 * hpad) { /*Full sized scroll bar*/ if(scrl_w <= obj_w - 2 * hpad) { /*Full sized scroll bar*/
area_set_width(&ext->sbh, obj_w - 2 * sbh_pad); area_set_width(&ext->sb.hor_area, obj_w - 2 * sb_hor_pad);
area_set_pos(&ext->sbh, sbh_pad, obj_h - ext->sb_width); area_set_pos(&ext->sb.hor_area, sb_hor_pad, obj_h - ext->sb.style->body.padding.inner - ext->sb.style->body.padding.ver);
if(ext->sb_mode == LV_PAGE_SB_MODE_AUTO) ext->sbh_draw = 0; if(ext->sb.mode == LV_PAGE_SB_MODE_AUTO || ext->sb.mode == LV_PAGE_SB_MODE_DRAG) ext->sb.hor_draw = 0;
} else { } else {
size_tmp = (obj_w * (obj_w - (2 * sbh_pad))) / (scrl_w + 2 * hpad); size_tmp = (obj_w * (obj_w - (2 * sb_hor_pad))) / (scrl_w + 2 * hpad);
area_set_width(&ext->sbh, size_tmp); if(size_tmp < LV_PAGE_SB_MIN_SIZE) size_tmp = LV_PAGE_SB_MIN_SIZE;
area_set_width(&ext->sb.hor_area, size_tmp);
area_set_pos(&ext->sbh, sbh_pad + area_set_pos(&ext->sb.hor_area, sb_hor_pad +
(-(lv_obj_get_x(scrl) - hpad) * (obj_w - size_tmp - 2 * sbh_pad)) / (-(lv_obj_get_x(scrl) - hpad) * (obj_w - size_tmp - 2 * sb_hor_pad)) /
(scrl_w + 2 * hpad - obj_w ), obj_h - ext->sb_width); (scrl_w + 2 * hpad - obj_w ),
obj_h - ext->sb.style->body.padding.inner - ext->sb.style->body.padding.ver);
if(ext->sb_mode == LV_PAGE_SB_MODE_AUTO) ext->sbh_draw = 1; if(ext->sb.mode == LV_PAGE_SB_MODE_AUTO || ext->sb.mode == LV_PAGE_SB_MODE_DRAG) ext->sb.hor_draw = 1;
} }
/*Vertical scrollbar*/ /*Vertical scrollbar*/
if(scrl_h <= obj_h - 2 * vpad) { /*Full sized scroll bar*/ if(scrl_h <= obj_h - 2 * vpad) { /*Full sized scroll bar*/
area_set_height(&ext->sbv, obj_h - 2 * sbv_pad); area_set_height(&ext->sb.ver_area, obj_h - 2 * sb_ver_pad);
area_set_pos(&ext->sbv, obj_w - ext->sb_width, sbv_pad); area_set_pos(&ext->sb.ver_area, obj_w - ext->sb.style->body.padding.inner - ext->sb.style->body.padding.hor, sb_ver_pad);
if(ext->sb_mode == LV_PAGE_SB_MODE_AUTO) ext->sbv_draw = 0; if(ext->sb.mode == LV_PAGE_SB_MODE_AUTO || ext->sb.mode == LV_PAGE_SB_MODE_DRAG) ext->sb.ver_draw = 0;
} else { } else {
size_tmp = (obj_h * (obj_h - (2 * sbv_pad))) / (scrl_h + 2 * vpad); size_tmp = (obj_h * (obj_h - (2 * sb_ver_pad))) / (scrl_h + 2 * vpad);
area_set_height(&ext->sbv, size_tmp); if(size_tmp < LV_PAGE_SB_MIN_SIZE) size_tmp = LV_PAGE_SB_MIN_SIZE;
area_set_height(&ext->sb.ver_area, size_tmp);
area_set_pos(&ext->sbv, obj_w - ext->sb_width, area_set_pos(&ext->sb.ver_area, obj_w - ext->sb.style->body.padding.inner - ext->sb.style->body.padding.hor,
sbv_pad + sb_ver_pad +
(-(lv_obj_get_y(scrl) - vpad) * (obj_h - size_tmp - 2 * sbv_pad)) / (-(lv_obj_get_y(scrl) - vpad) * (obj_h - size_tmp - 2 * sb_ver_pad)) /
(scrl_h + 2 * vpad - obj_h )); (scrl_h + 2 * vpad - obj_h ));
if(ext->sb_mode == LV_PAGE_SB_MODE_AUTO) ext->sbv_draw = 1; if(ext->sb.mode == LV_PAGE_SB_MODE_AUTO || ext->sb.mode == LV_PAGE_SB_MODE_DRAG) ext->sb.ver_draw = 1;
} }
/*Invalidate the new scrollbar areas*/ /*Invalidate the new scrollbar areas*/
if(ext->sbh_draw != 0) { if(ext->sb.hor_draw != 0) {
area_cpy(&sb_area_tmp, &ext->sbh); area_cpy(&sb_area_tmp, &ext->sb.hor_area);
sb_area_tmp.x1 += page->coords.x1; sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2; sb_area_tmp.x2 += page->coords.x2;
sb_area_tmp.y2 += page->coords.y2; sb_area_tmp.y2 += page->coords.y2;
lv_inv_area(&sb_area_tmp); lv_inv_area(&sb_area_tmp);
} }
if(ext->sbv_draw != 0) { if(ext->sb.ver_draw != 0) {
area_cpy(&sb_area_tmp, &ext->sbv); area_cpy(&sb_area_tmp, &ext->sb.ver_area);
sb_area_tmp.x1 += page->coords.x1; sb_area_tmp.x1 += page->coords.x1;
sb_area_tmp.y1 += page->coords.y1; sb_area_tmp.y1 += page->coords.y1;
sb_area_tmp.x2 += page->coords.x2; sb_area_tmp.x2 += page->coords.x2;

182
lv_objx/lv_page.h
View File

@ -49,13 +49,14 @@ typedef struct
lv_obj_t * scrl; /*The scrollable object on the background*/ lv_obj_t * scrl; /*The scrollable object on the background*/
lv_action_t rel_action; /*Function to call when the page is released*/ lv_action_t rel_action; /*Function to call when the page is released*/
lv_action_t pr_action; /*Function to call when the page is pressed*/ lv_action_t pr_action; /*Function to call when the page is pressed*/
lv_style_t * style_sb; /*Style of scrollbars*/ struct {
cord_t sb_width; /*Width of the scrollbars*/ lv_style_t *style; /*Style of scrollbars*/
lv_page_sb_mode_t sb_mode; /*Scrollbar visibility from 'lv_page_sb_mode_t'*/ area_t hor_area; /*Horizontal scrollbar area relative to the page. (Handled by the library) */
area_t sbh; /*Horizontal scrollbar area relative to the page. (Handled by the library) */ area_t ver_area; /*Vertical scrollbar area relative to the page (Handled by the library)*/
area_t sbv; /*Vertical scrollbar area relative to the page (Handled by the library)*/ uint8_t hor_draw :1; /*1: horizontal scrollbar is visible now (Handled by the library)*/
uint8_t sbh_draw :1; /*1: horizontal scrollbar is visible now (Handled by the library)*/ uint8_t ver_draw :1; /*1: vertical scrollbar is visible now (Handled by the library)*/
uint8_t sbv_draw :1; /*1: vertical scrollbar is visible now (Handled by the library)*/ uint8_t mode :3; /*Scrollbar visibility from 'lv_page_sb_mode_t'*/
}sb;
}lv_page_ext_t; }lv_page_ext_t;
@ -71,42 +72,19 @@ typedef struct
*/ */
lv_obj_t * lv_page_create(lv_obj_t * par, lv_obj_t * copy); lv_obj_t * lv_page_create(lv_obj_t * par, lv_obj_t * copy);
/**
* Signal function of the page
* @param page pointer to a page object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
*/
bool lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param);
/**
* Signal function of the scrollable part of a page
* @param scrl pointer to the scrollable object
* @param sign a signal type from lv_signal_t enum
* @param param pointer to a signal specific variable
*/
bool lv_page_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param);
/** /**
* Set a release action for the page * Set a release action for the page
* @param page pointer to a page object * @param page pointer to a page object
* @param rel_action a function to call when the page is released * @param rel_action a function to call when the page is released
*/ */
void lv_page_set_rel_action(lv_obj_t * page, lv_action_t rel_action); void lv_page_set_release_action(lv_obj_t * page, lv_action_t rel_action);
/** /**
* Set a press action for the page * Set a press action for the page
* @param page pointer to a page object * @param page pointer to a page object
* @param pr_action a function to call when the page is pressed * @param pr_action a function to call when the page is pressed
*/ */
void lv_page_set_pr_action(lv_obj_t * page, lv_action_t pr_action); void lv_page_set_press_action(lv_obj_t * page, lv_action_t pr_action);
/**
* Set the scroll bar width on a page
* @param page pointer to a page object
* @param sb_width the new scroll bar width in pixels
*/
void lv_page_set_sb_width(lv_obj_t * page, cord_t sb_width);
/** /**
* Set the scroll bar mode on a page * Set the scroll bar mode on a page
@ -116,12 +94,13 @@ void lv_page_set_sb_width(lv_obj_t * page, cord_t sb_width);
void lv_page_set_sb_mode(lv_obj_t * page, lv_page_sb_mode_t sb_mode); void lv_page_set_sb_mode(lv_obj_t * page, lv_page_sb_mode_t sb_mode);
/** /**
* Set a new style for the scroll bars object on the page * Set a new styles for the page
* @param page pointer to a page object * @param page pointer to a page object
* @param style pointer to a style for the scroll bars * @param bg pointer to a style for the background
* @param scrl pointer to a style for the scrollable area
* @param sb pointer to a style for the scroll bars
*/ */
void lv_page_set_style_sb(lv_obj_t * page, lv_style_t * style); void lv_page_set_style(lv_obj_t *page, lv_style_t *bg, lv_style_t *scrl, lv_style_t *sb);
/** /**
* Glue the object to the page. After it the page can be moved (dragged) with this object too. * Glue the object to the page. After it the page can be moved (dragged) with this object too.
* @param obj pointer to an object on a page * @param obj pointer to an object on a page
@ -144,13 +123,6 @@ void lv_page_focus(lv_obj_t * page, lv_obj_t * obj, uint16_t anim_time);
*/ */
lv_obj_t * lv_page_get_scrl(lv_obj_t * page); lv_obj_t * lv_page_get_scrl(lv_obj_t * page);
/**
* Get the scroll bar width on a page
* @param page pointer to a page object
* @return the scroll bar width in pixels
*/
cord_t lv_page_get_sb_width(lv_obj_t * page);
/** /**
* Set the scroll bar mode on a page * Set the scroll bar mode on a page
* @param page pointer to a page object * @param page pointer to a page object
@ -159,12 +131,128 @@ cord_t lv_page_get_sb_width(lv_obj_t * page);
lv_page_sb_mode_t lv_page_get_sb_mode(lv_obj_t * page); lv_page_sb_mode_t lv_page_get_sb_mode(lv_obj_t * page);
/** /**
* Set a new style for the scroll bars object on the page * Get the style of the scrollable part of a page
* @param page pointer to a page object * @param page pointer to a page object
* @return pointer to a style for the scroll bars * @return pointer to the style of the scrollale part
*/ */
lv_style_t * lv_page_get_style_scrl(lv_obj_t * page);
/**
* Get the style of the scrolbars of a page
* @param page pointer to a page object
* @return pointer to the style of the scrollbars
*/
lv_style_t * lv_page_get_style_sb(lv_obj_t * page); lv_style_t * lv_page_get_style_sb(lv_obj_t * page);
/******************************
* TRANSPARENT API FUNCTIONS
******************************/
/**
* Set the fit attribute of the scrollable part of a page.
* It means it can set its size automatically to involve all children.
* (Can be set separately horizontally and vertically)
* @param page pointer to a page object
* @param hor_en true: enable horizontal fit
* @param ver_en true: enable vertical fit
*/
static inline void lv_page_set_scrl_fit(lv_obj_t *page, bool hor_en, bool ver_en)
{
lv_cont_set_fit(lv_page_get_scrl(page), hor_en, ver_en);
}
/**
* Set width of the scrollable part of a page
* @param page pointer to a page object
* @param w the new width of the scrollable (it ha no effect is horizontal fit is enabled)
*/
static inline void lv_page_set_scrl_width(lv_obj_t *page, cord_t w)
{
lv_obj_set_width(lv_page_get_scrl(page), w);
}
/**
* Set height of the scrollable part of a page
* @param page pointer to a page object
* @param h the new height of the scrollable (it ha no effect is vertical fit is enabled)
*/
static inline void lv_page_set_scrl_height(lv_obj_t *page, cord_t h)
{
lv_obj_set_height(lv_page_get_scrl(page), h);
}
/**
* Set the layout of the scrollable part of the page
* @param page pointer to a page object
* @param layout a layout from 'lv_cont_layout_t'
*/
static inline void lv_page_set_scrl_layout(lv_obj_t * page, lv_cont_layout_t layout)
{
lv_cont_set_layout(lv_page_get_scrl(page), layout);
}
/**
* Get width of the scrollable part of a page
* @param page pointer to a page object
* @return the width of the scrollable
*/
static inline cord_t lv_page_get_scrl_width(lv_obj_t *page)
{
return lv_obj_get_width(lv_page_get_scrl(page));
}
/**
* Get the style of page's background
* @param page pointer to a page object
* @return pointer to the style of background
*/
static inline lv_style_t * lv_page_get_style_bg(lv_obj_t * page)
{
return lv_obj_get_style(page);
}
/**
* Get height of the scrollable part of a page
* @param page pointer to a page object
* @return the height of the scrollable
*/
static inline cord_t lv_page_get_scrl_height(lv_obj_t *page)
{
return lv_obj_get_height(lv_page_get_scrl(page));
}
/**
* Get the layout of the scrollable part of a page
* @param page pointer to page object
* @return the layout from 'lv_cont_layout_t'
*/
static inline lv_cont_layout_t lv_page_get_scrl_layout(lv_obj_t * page)
{
return lv_cont_get_layout(lv_page_get_scrl(page));
}
/**
* Get horizontal fit attribute of the scrollable part of a page
* @param page pointer to a page object
* @return true: horizontal fit is enabled; false: disabled
*/
static inline bool lv_page_get_scrl_hor_fit(lv_obj_t * page)
{
return lv_cont_get_hor_fit(lv_page_get_scrl(page));
}
/**
* Get vertical fit attribute of the scrollable part of a page
* @param page pointer to a page object
* @return true: vertical fit is enabled; false: disabled
*/
static inline bool lv_page_get_scrl_fit_ver(lv_obj_t * page)
{
return lv_cont_get_ver_fit(lv_page_get_scrl(page));
}
/********************** /**********************
* MACROS * MACROS
**********************/ **********************/

14
lv_objx/lv_roller.c
View File

@ -71,14 +71,14 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, lv_obj_t * copy)
if(copy == NULL) { if(copy == NULL) {
lv_obj_t * scrl = lv_page_get_scrl(new_roller); lv_obj_t * scrl = lv_page_get_scrl(new_roller);
lv_obj_set_drag(scrl, true); /*In ddlist is might be disabled*/ lv_obj_set_drag(scrl, true); /*In ddlist is might be disabled*/
lv_page_set_rel_action(new_roller, NULL); /*Handle roller specific actions*/ lv_page_set_release_action(new_roller, NULL); /*Handle roller specific actions*/
lv_cont_set_fit(lv_page_get_scrl(new_roller), true, false); /*Height is specified directly*/ lv_cont_set_fit(lv_page_get_scrl(new_roller), true, false); /*Height is specified directly*/
lv_obj_set_signal_func(scrl, roller_scrl_signal); lv_obj_set_signal_func(scrl, roller_scrl_signal);
lv_ddlist_open(new_roller, false); lv_ddlist_open(new_roller, false);
lv_style_t * style_label = lv_obj_get_style(ext->ddlist.options_label); lv_style_t * style_label = lv_obj_get_style(ext->ddlist.options_label);
lv_ddlist_set_fix_height(new_roller, (font_get_height(style_label->text.font) >> FONT_ANTIALIAS) * 3 lv_ddlist_set_fix_height(new_roller, (font_get_height(style_label->text.font) >> FONT_ANTIALIAS) * 3
+ style_label->text.space_line * 4); + style_label->text.line_space * 4);
lv_obj_refresh_style(new_roller); /*To set scrollable size automatically*/ lv_obj_refresh_style(new_roller); /*To set scrollable size automatically*/
} }
/*Copy an existing roller*/ /*Copy an existing roller*/
@ -191,8 +191,8 @@ static bool lv_roller_design(lv_obj_t * roller, const area_t * mask, lv_design_m
lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller); lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS; cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS;
area_t rect_area; area_t rect_area;
rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - font_h / 2 - style->text.space_line - 2; rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - font_h / 2 - style->text.line_space - 2;
rect_area.y2 = rect_area.y1 + font_h + style->text.space_line; rect_area.y2 = rect_area.y1 + font_h + style->text.line_space;
rect_area.x1 = ext->ddlist.options_label->coords.x1 - style->body.padding.hor; rect_area.x1 = ext->ddlist.options_label->coords.x1 - style->body.padding.hor;
rect_area.x2 = rect_area.x1 + lv_obj_get_width(lv_page_get_scrl(roller)); rect_area.x2 = rect_area.x1 + lv_obj_get_width(lv_page_get_scrl(roller));
@ -233,7 +233,7 @@ static bool roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign, void *
if(sign == LV_SIGNAL_DRAG_END) { if(sign == LV_SIGNAL_DRAG_END) {
/*If dragged then align the list to there be an element in the middle*/ /*If dragged then align the list to there be an element in the middle*/
cord_t label_y1 = ext->ddlist.options_label->coords.y1 - roller->coords.y1; cord_t label_y1 = ext->ddlist.options_label->coords.y1 - roller->coords.y1;
cord_t label_unit = (font_get_height(style_label->text.font) >> FONT_ANTIALIAS) + style_label->text.space_line / 2; cord_t label_unit = (font_get_height(style_label->text.font) >> FONT_ANTIALIAS) + style_label->text.line_space / 2;
cord_t mid = (roller->coords.y2 - roller->coords.y1) / 2; cord_t mid = (roller->coords.y2 - roller->coords.y1) / 2;
id = (mid - label_y1) / label_unit; id = (mid - label_y1) / label_unit;
if(id < 0) id = 0; if(id < 0) id = 0;
@ -246,7 +246,7 @@ static bool roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign, void *
point_t p; point_t p;
lv_indev_get_point(indev, &p); lv_indev_get_point(indev, &p);
p.y = p.y - ext->ddlist.options_label->coords.y1; p.y = p.y - ext->ddlist.options_label->coords.y1;
id = p.y / (font_h + style_label->text.space_line); id = p.y / (font_h + style_label->text.line_space);
if(id < 0) id = 0; if(id < 0) id = 0;
if(id >= ext->ddlist.option_cnt) id = ext->ddlist.option_cnt - 1; if(id >= ext->ddlist.option_cnt) id = ext->ddlist.option_cnt - 1;
ext->ddlist.selected_option_id = id; ext->ddlist.selected_option_id = id;
@ -256,7 +256,7 @@ static bool roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign, void *
/*Position the scrollable according to the new selected option*/ /*Position the scrollable according to the new selected option*/
if(id != -1) { if(id != -1) {
cord_t h = lv_obj_get_height(roller); cord_t h = lv_obj_get_height(roller);
cord_t line_y1 = id * (font_h + style_label->text.space_line) + ext->ddlist.options_label->coords.y1 - roller_scrl->coords.y1; cord_t line_y1 = id * (font_h + style_label->text.line_space) + ext->ddlist.options_label->coords.y1 - roller_scrl->coords.y1;
cord_t new_y = - line_y1 + (h - font_h) / 2; cord_t new_y = - line_y1 + (h - font_h) / 2;
if(ext->ddlist.anim_time == 0) { if(ext->ddlist.anim_time == 0) {

26
lv_objx/lv_slider.c
View File

@ -117,7 +117,7 @@ bool lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * param)
int16_t tmp; int16_t tmp;
if(sign == LV_SIGNAL_PRESSED) { if(sign == LV_SIGNAL_PRESSED) {
ext->tmp_value = lv_bar_get_value(slider); ext->tmp_value = lv_slider_get_value(slider);
} }
else if(sign == LV_SIGNAL_PRESSING) { else if(sign == LV_SIGNAL_PRESSING) {
lv_indev_get_point(param, &p); lv_indev_get_point(param, &p);
@ -132,14 +132,14 @@ bool lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * param)
tmp = ext->bar.max_value - tmp; /*Invert he value: small value means higher y*/ tmp = ext->bar.max_value - tmp; /*Invert he value: small value means higher y*/
} }
lv_bar_set_value(slider, tmp); lv_slider_set_value(slider, tmp);
} }
else if (sign == LV_SIGNAL_PRESS_LOST) { else if (sign == LV_SIGNAL_PRESS_LOST) {
lv_bar_set_value(slider, ext->tmp_value); lv_slider_set_value(slider, ext->tmp_value);
} }
else if (sign == LV_SIGNAL_RELEASED) { else if (sign == LV_SIGNAL_RELEASED) {
ext->tmp_value = lv_bar_get_value(slider); ext->tmp_value = lv_slider_get_value(slider);
lv_bar_set_value(slider, ext->tmp_value); lv_slider_set_value(slider, ext->tmp_value);
if(ext->action != NULL) ext->action(slider); if(ext->action != NULL) ext->action(slider);
} }
else if(sign == LV_SIGNAL_CORD_CHG) { else if(sign == LV_SIGNAL_CORD_CHG) {
@ -166,10 +166,10 @@ bool lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * param)
lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider); lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
char c = *((char*)param); char c = *((char*)param);
if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_UP) { if(c == LV_GROUP_KEY_RIGHT || c == LV_GROUP_KEY_UP) {
lv_bar_set_value(slider, lv_bar_get_value(slider) + 1); lv_slider_set_value(slider, lv_slider_get_value(slider) + 1);
if(ext->action != NULL) ext->action(slider); if(ext->action != NULL) ext->action(slider);
} else if(c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_DOWN) { } else if(c == LV_GROUP_KEY_LEFT || c == LV_GROUP_KEY_DOWN) {
lv_bar_set_value(slider, lv_bar_get_value(slider) - 1); lv_slider_set_value(slider, lv_slider_get_value(slider) - 1);
if(ext->action != NULL) ext->action(slider); if(ext->action != NULL) ext->action(slider);
} }
} }
@ -196,7 +196,7 @@ void lv_slider_set_action(lv_obj_t * slider, lv_action_t action)
/** /**
* Set the styles of a slider * Set the styles of a slider
* @param bar pointer to a bar object * @param slider pointer to a slider object
* @param bg pointer to the background's style (NULL to leave unchanged) * @param bg pointer to the background's style (NULL to leave unchanged)
* @param indic pointer to the indicator's style (NULL to leave unchanged) * @param indic pointer to the indicator's style (NULL to leave unchanged)
* @param knob pointer to the knob's style (NULL to leave unchanged) * @param knob pointer to the knob's style (NULL to leave unchanged)
@ -210,7 +210,7 @@ void lv_slider_set_style(lv_obj_t * slider, lv_style_t *bg, lv_style_t *indic, l
lv_obj_invalidate(slider); lv_obj_invalidate(slider);
} }
lv_bar_set_styles(slider, bg, indic); lv_bar_set_style(slider, bg, indic);
} }
/** /**
@ -242,7 +242,7 @@ lv_action_t lv_slider_get_action(lv_obj_t * slider)
/** /**
* Set the styles of a slider * Set the styles of a slider
* @param slider pointer to a bar object * @param slider pointer to a slider object
* @return pointer to the knob's style * @return pointer to the knob's style
*/ */
lv_style_t * lv_slider_get_style_knob(lv_obj_t * slider) lv_style_t * lv_slider_get_style_knob(lv_obj_t * slider)
@ -334,9 +334,9 @@ static bool lv_slider_design(lv_obj_t * slider, const area_t * mask, lv_design_m
cord_t slider_w = area_get_width(&slider->coords); cord_t slider_w = area_get_width(&slider->coords);
cord_t slider_h = area_get_height(&slider->coords); cord_t slider_h = area_get_height(&slider->coords);
cord_t act_value = lv_bar_get_value(slider); cord_t act_value = lv_slider_get_value(slider);
cord_t min_value = lv_bar_get_min_value(slider); cord_t min_value = lv_slider_get_min_value(slider);
cord_t max_value = lv_bar_get_max_value(slider); cord_t max_value = lv_slider_get_max_value(slider);
if(slider_w >= slider_h) { if(slider_w >= slider_h) {
area_indic.x2 = (int32_t) ((int32_t)area_get_width(&area_indic) * act_value) / (max_value - min_value); area_indic.x2 = (int32_t) ((int32_t)area_get_width(&area_indic) * act_value) / (max_value - min_value);

4
lv_objx/lv_slider.h
View File

@ -155,7 +155,7 @@ static inline void lv_slider_set_range(lv_obj_t *slider, int16_t min, int16_t ma
*/ */
static inline int16_t lv_slider_get_value(lv_obj_t * slider) static inline int16_t lv_slider_get_value(lv_obj_t * slider)
{ {
return lv_slider_get_value(slider); return lv_bar_get_value(slider);
} }
/** /**
@ -163,7 +163,7 @@ static inline int16_t lv_slider_get_value(lv_obj_t * slider)
* @param slider pointer to a slider object * @param slider pointer to a slider object
* @return the minimum value of the slider * @return the minimum value of the slider
*/ */
static inline int16_t lv_slider_slider_min_value(lv_obj_t * slider) static inline int16_t lv_slider_get_min_value(lv_obj_t * slider)
{ {
return lv_bar_get_min_value(slider); return lv_bar_get_min_value(slider);
} }

12
lv_objx/lv_sw.c
View File

@ -65,7 +65,7 @@ lv_obj_t * lv_sw_create(lv_obj_t * par, lv_obj_t * copy)
/*Init the new switch switch*/ /*Init the new switch switch*/
if(copy == NULL) { if(copy == NULL) {
lv_bar_set_range(new_sw, 0, 1); lv_slider_set_range(new_sw, 0, 1);
lv_obj_set_size(new_sw, 2 * LV_DPI / 3, LV_DPI / 3); lv_obj_set_size(new_sw, 2 * LV_DPI / 3, LV_DPI / 3);
lv_slider_set_knob_in(new_sw, true); lv_slider_set_knob_in(new_sw, true);
} }
@ -92,7 +92,7 @@ bool lv_sw_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
bool valid; bool valid;
lv_sw_ext_t * ext = lv_obj_get_ext_attr(sw); lv_sw_ext_t * ext = lv_obj_get_ext_attr(sw);
int16_t old_val = lv_bar_get_value(sw); int16_t old_val = lv_slider_get_value(sw);
lv_action_t slider_cb = ext->slider.action; lv_action_t slider_cb = ext->slider.action;
ext->slider.action = NULL; /*Do not let the slider to call the callback. The Switch will do it*/ ext->slider.action = NULL; /*Do not let the slider to call the callback. The Switch will do it*/
@ -107,7 +107,7 @@ bool lv_sw_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
/*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/ /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
} }
else if(sign == LV_SIGNAL_PRESSING) { else if(sign == LV_SIGNAL_PRESSING) {
int16_t act_val = lv_bar_get_value(sw); int16_t act_val = lv_slider_get_value(sw);
if(act_val != old_val) ext->changed = 1; if(act_val != old_val) ext->changed = 1;
} }
else if(sign == LV_SIGNAL_PRESS_LOST) { else if(sign == LV_SIGNAL_PRESS_LOST) {
@ -115,9 +115,9 @@ bool lv_sw_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
} }
else if(sign == LV_SIGNAL_RELEASED) { else if(sign == LV_SIGNAL_RELEASED) {
if(ext->changed == 0) { if(ext->changed == 0) {
int16_t v = lv_bar_get_value(sw); int16_t v = lv_slider_get_value(sw);
if(v == 0) lv_bar_set_value(sw, 1); if(v == 0) lv_slider_set_value(sw, 1);
else lv_bar_set_value(sw, 0); else lv_slider_set_value(sw, 0);
} }
if(slider_cb != NULL) slider_cb(sw); if(slider_cb != NULL) slider_cb(sw);

87
lv_objx/lv_ta.c
View File

@ -21,9 +21,6 @@
* DEFINES * DEFINES
*********************/ *********************/
/*Test configuration*/ /*Test configuration*/
#ifndef LV_TA_MAX_LENGTH
#define LV_TA_MAX_LENGTH 256
#endif
#ifndef LV_TA_CUR_BLINK_TIME #ifndef LV_TA_CUR_BLINK_TIME
#define LV_TA_CUR_BLINK_TIME 400 /*ms*/ #define LV_TA_CUR_BLINK_TIME 400 /*ms*/
@ -44,7 +41,7 @@
* STATIC PROTOTYPES * STATIC PROTOTYPES
**********************/ **********************/
static bool lv_ta_design(lv_obj_t * ta, const area_t * mask, lv_design_mode_t mode); static bool lv_ta_design(lv_obj_t * ta, const area_t * mask, lv_design_mode_t mode);
static bool lv_ta_scrling_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode); static bool lv_ta_scrollable_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode);
static void cursor_blink_anim(lv_obj_t * ta, uint8_t show); static void cursor_blink_anim(lv_obj_t * ta, uint8_t show);
static void pwd_char_hider_anim(lv_obj_t * ta, int32_t x); static void pwd_char_hider_anim(lv_obj_t * ta, int32_t x);
static void pwd_char_hider(lv_obj_t * ta); static void pwd_char_hider(lv_obj_t * ta);
@ -53,8 +50,10 @@ static void lv_ta_save_valid_cursor_x(lv_obj_t * ta);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
lv_design_func_t ancestor_design_f; static lv_design_func_t ancestor_design;
lv_design_func_t scrl_design_f; static lv_design_func_t scrl_design;
static lv_signal_func_t ancestor_signal;
static lv_signal_func_t scrl_signal;
/********************** /**********************
* MACROS * MACROS
@ -79,7 +78,10 @@ lv_obj_t * lv_ta_create(lv_obj_t * par, lv_obj_t * copy)
/*Create the ancestor object*/ /*Create the ancestor object*/
lv_obj_t * new_ta = lv_page_create(par, copy); lv_obj_t * new_ta = lv_page_create(par, copy);
dm_assert(new_ta); dm_assert(new_ta);
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_ta);
if(ancestor_design == NULL) ancestor_design = lv_obj_get_design_func(new_ta);
if(scrl_signal == NULL) scrl_signal = lv_obj_get_signal_func(lv_page_get_scrl(new_ta));
if(scrl_design == NULL) scrl_design = lv_obj_get_design_func(lv_page_get_scrl(new_ta));
/*Allocate the object type specific extended data*/ /*Allocate the object type specific extended data*/
lv_ta_ext_t * ext = lv_obj_allocate_ext_attr(new_ta, sizeof(lv_ta_ext_t)); lv_ta_ext_t * ext = lv_obj_allocate_ext_attr(new_ta, sizeof(lv_ta_ext_t));
dm_assert(ext); dm_assert(ext);
@ -93,30 +95,28 @@ lv_obj_t * lv_ta_create(lv_obj_t * par, lv_obj_t * copy)
ext->cursor_valid_x = 0; ext->cursor_valid_x = 0;
ext->label = NULL; ext->label = NULL;
if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_func(new_ta);
if(scrl_design_f == NULL) scrl_design_f = lv_obj_get_design_func(ext->page.scrl);
lv_obj_set_signal_func(new_ta, lv_ta_signal); lv_obj_set_signal_func(new_ta, lv_ta_signal);
lv_obj_set_signal_func(lv_page_get_scrl(new_ta), lv_ta_scrl_signal); lv_obj_set_signal_func(lv_page_get_scrl(new_ta), lv_ta_scrollable_signal);
lv_obj_set_design_func(new_ta, lv_ta_design); lv_obj_set_design_func(new_ta, lv_ta_design);
/*Init the new text area object*/ /*Init the new text area object*/
if(copy == NULL) { if(copy == NULL) {
ext->label = lv_label_create(new_ta, NULL); ext->label = lv_label_create(new_ta, NULL);
lv_obj_set_design_func(ext->page.scrl, lv_ta_scrling_design); lv_obj_set_design_func(ext->page.scrl, lv_ta_scrollable_design);
lv_label_set_long_mode(ext->label, LV_LABEL_LONG_BREAK); lv_label_set_long_mode(ext->label, LV_LABEL_LONG_BREAK);
lv_label_set_text(ext->label, "Text area"); lv_label_set_text(ext->label, "Text area");
lv_page_glue_obj(ext->label, true); lv_page_glue_obj(ext->label, true);
lv_obj_set_click(ext->label, false); lv_obj_set_click(ext->label, false);
lv_obj_set_style(new_ta, &lv_style_pretty); lv_obj_set_style(new_ta, &lv_style_pretty);
lv_page_set_sb_mode(new_ta, LV_PAGE_SB_MODE_AUTO); lv_page_set_sb_mode(new_ta, LV_PAGE_SB_MODE_DRAG);
lv_obj_set_style(lv_page_get_scrl(new_ta), &lv_style_transp_fit); lv_obj_set_style(lv_page_get_scrl(new_ta), &lv_style_transp_fit);
lv_obj_set_size(new_ta, LV_TA_DEF_WIDTH, LV_TA_DEF_HEIGHT); lv_obj_set_size(new_ta, LV_TA_DEF_WIDTH, LV_TA_DEF_HEIGHT);
} }
/*Copy an existing object*/ /*Copy an existing object*/
else { else {
lv_obj_set_design_func(ext->page.scrl, lv_ta_scrling_design); lv_obj_set_design_func(ext->page.scrl, lv_ta_scrollable_design);
lv_ta_ext_t * copy_ext = lv_obj_get_ext_attr(copy); lv_ta_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
ext->label = lv_label_create(new_ta, copy_ext->label); ext->label = lv_label_create(new_ta, copy_ext->label);
ext->cursor_show = copy_ext->cursor_show; ext->cursor_show = copy_ext->cursor_show;
@ -159,7 +159,7 @@ bool lv_ta_signal(lv_obj_t * ta, lv_signal_t sign, void * param)
bool valid; bool valid;
/* Include the ancient signal function */ /* Include the ancient signal function */
valid = lv_page_signal(ta, sign, param); valid = ancestor_signal(ta, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */
@ -222,12 +222,12 @@ bool lv_ta_signal(lv_obj_t * ta, lv_signal_t sign, void * param)
* @param param pointer to a signal specific variable * @param param pointer to a signal specific variable
* @return true: the object is still valid (not deleted), false: the object become invalid * @return true: the object is still valid (not deleted), false: the object become invalid
*/ */
bool lv_ta_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param) bool lv_ta_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
{ {
bool valid; bool valid;
/* Include the ancient signal function */ /* Include the ancient signal function */
valid = lv_page_scrl_signal(scrl, sign, param); valid = scrl_signal(scrl, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */
@ -238,7 +238,7 @@ bool lv_ta_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param)
lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta); lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
lv_style_t * style_label = lv_obj_get_style(ext->label); lv_style_t * style_label = lv_obj_get_style(ext->label);
scrl->ext_size = MATH_MAX(scrl->ext_size, style_label->text.space_line + font_get_height(style_label->text.font)); scrl->ext_size = MATH_MAX(scrl->ext_size, style_label->text.line_space + font_get_height(style_label->text.font));
} }
} }
return valid; return valid;
@ -316,7 +316,6 @@ void lv_ta_add_char(lv_obj_t * ta, uint32_t c)
void lv_ta_add_text(lv_obj_t * ta, const char * txt) void lv_ta_add_text(lv_obj_t * ta, const char * txt)
{ {
lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta); lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
const char * label_txt = lv_label_get_text(ext->label);
uint16_t txt_len = strlen(txt); uint16_t txt_len = strlen(txt);
if(ext->pwd_mode != 0) pwd_char_hider(ta); /*Make sure all the current text contains only '*'*/ if(ext->pwd_mode != 0) pwd_char_hider(ta); /*Make sure all the current text contains only '*'*/
@ -559,7 +558,7 @@ void lv_ta_cursor_down(lv_obj_t * ta)
lv_style_t * label_style = lv_obj_get_style(ext->label); lv_style_t * label_style = lv_obj_get_style(ext->label);
const font_t * font_p = label_style->text.font; const font_t * font_p = label_style->text.font;
cord_t font_h = font_get_height(font_p) >> FONT_ANTIALIAS; cord_t font_h = font_get_height(font_p) >> FONT_ANTIALIAS;
pos.y += font_h + label_style->text.space_line + 1; pos.y += font_h + label_style->text.line_space + 1;
pos.x = ext->cursor_valid_x; pos.x = ext->cursor_valid_x;
/*Do not go below he last line*/ /*Do not go below he last line*/
@ -586,7 +585,7 @@ void lv_ta_cursor_up(lv_obj_t * ta)
lv_style_t * label_style = lv_obj_get_style(ext->label); lv_style_t * label_style = lv_obj_get_style(ext->label);
const font_t * font = label_style->text.font; const font_t * font = label_style->text.font;
cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS; cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS;
pos.y -= font_h + label_style->text.space_line - 1; pos.y -= font_h + label_style->text.line_space - 1;
pos.x = ext->cursor_valid_x; pos.x = ext->cursor_valid_x;
/*Get the letter index on the new cursor position and set it*/ /*Get the letter index on the new cursor position and set it*/
@ -620,29 +619,31 @@ void lv_ta_set_cursor_type(lv_obj_t * ta, lv_ta_cursor_type_t cur_type)
} }
/** /**
* Set the style of the cursor (NULL to use label's style) * Set the style of the text area
* @param ta pointer to a text area object * @param ta pointer to a text area object
* @param style pointer to the new cursor style * @param bg pointer to the new background style (NULL to leave unchanged)
* @param sb pointer to the new scrollbar style (NULL to leave unchanged)
* @param cur pointer to the new cursor style (NULL to use the label's style)
*/ */
void lv_ta_set_cursor_style(lv_obj_t * ta, lv_style_t * style) void lv_ta_set_style(lv_obj_t * ta, lv_style_t *bg, lv_style_t *sb, lv_style_t *cur)
{ {
lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta); lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
ext->cursor_style = style; ext->cursor_style = cur;
lv_obj_invalidate(ta); lv_page_set_style(ta, bg, &lv_style_transp_tight, sb);
} }
/** /**
* Enable/Disable password mode * Enable/Disable password mode
* @param ta ointer to a text area object * @param ta pointer to a text area object
* @param en true: enable, false: disable * @param pwd_en true: enable, false: disable
*/ */
void lv_ta_set_pwd_mode(lv_obj_t * ta, bool en) void lv_ta_set_pwd_mode(lv_obj_t * ta, bool pwd_en)
{ {
lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta); lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
/*Pwd mode is now enabled*/ /*Pwd mode is now enabled*/
if(ext->pwd_mode == 0 && en != false) { if(ext->pwd_mode == 0 && pwd_en != false) {
char * txt = lv_label_get_text(ext->label); char * txt = lv_label_get_text(ext->label);
uint16_t len = strlen(txt); uint16_t len = strlen(txt);
ext->pwd_tmp = dm_alloc(len + 1); ext->pwd_tmp = dm_alloc(len + 1);
@ -657,13 +658,13 @@ void lv_ta_set_pwd_mode(lv_obj_t * ta, bool en)
lv_label_set_text(ext->label, NULL); lv_label_set_text(ext->label, NULL);
} }
/*Pwd mode is now disabled*/ /*Pwd mode is now disabled*/
else if(ext->pwd_mode == 1 && en == false) { else if(ext->pwd_mode == 1 && pwd_en == false) {
lv_label_set_text(ext->label, ext->pwd_tmp); lv_label_set_text(ext->label, ext->pwd_tmp);
dm_free(ext->pwd_tmp); dm_free(ext->pwd_tmp);
ext->pwd_tmp = NULL; ext->pwd_tmp = NULL;
} }
ext->pwd_mode = en == false ? 0 : 1; ext->pwd_mode = pwd_en == false ? 0 : 1;
} }
/** /**
@ -708,7 +709,7 @@ void lv_ta_set_one_line(lv_obj_t * ta, bool en)
* @param ta pointer to a text area object * @param ta pointer to a text area object
* @return pointer to the text * @return pointer to the text
*/ */
const char * lv_ta_get_txt(lv_obj_t * ta) const char * lv_ta_get_text(lv_obj_t * ta)
{ {
lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta); lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
@ -773,7 +774,7 @@ lv_ta_cursor_type_t lv_ta_get_cursor_type(lv_obj_t * ta)
* @param ta pointer to a text area object * @param ta pointer to a text area object
* @return style pointer to the new cursor style * @return style pointer to the new cursor style
*/ */
lv_style_t * lv_ta_get_cursor_style(lv_obj_t * ta) lv_style_t * lv_ta_get_style_cursor(lv_obj_t * ta)
{ {
lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta); lv_ta_ext_t * ext = lv_obj_get_ext_attr(ta);
return ext->cursor_style; return ext->cursor_style;
@ -808,24 +809,20 @@ static bool lv_ta_design(lv_obj_t * ta, const area_t * masp, lv_design_mode_t mo
{ {
if(mode == LV_DESIGN_COVER_CHK) { if(mode == LV_DESIGN_COVER_CHK) {
/*Return false if the object is not covers the mask_p area*/ /*Return false if the object is not covers the mask_p area*/
return ancestor_design_f(ta, masp, mode); return ancestor_design(ta, masp, mode);
} else if(mode == LV_DESIGN_DRAW_MAIN) { } else if(mode == LV_DESIGN_DRAW_MAIN) {
/*Draw the object*/ /*Draw the object*/
ancestor_design_f(ta, masp, mode); ancestor_design(ta, masp, mode);
} else if(mode == LV_DESIGN_DRAW_POST) { } else if(mode == LV_DESIGN_DRAW_POST) {
ancestor_design_f(ta, masp, mode); ancestor_design(ta, masp, mode);
} }
return true; return true;
} }
/** /**
* An extended scrollable design of the page. Calls the normal design function and draws a cursor. * An extended scrollable design of the page. Calls the normal design function and draws a cursor.
<<<<<<< HEAD
* @param scrl pointer to the scrollable part of the Text area * @param scrl pointer to the scrollable part of the Text area
=======
* @param scrl pointer to the scrollabla part of the Text area
>>>>>>> fc3b967f33a3af469bd1edbfdfa42d516dc58d20
* @param mask the object will be drawn only in this area * @param mask the object will be drawn only in this area
* @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
* (return 'true' if yes) * (return 'true' if yes)
@ -833,16 +830,16 @@ static bool lv_ta_design(lv_obj_t * ta, const area_t * masp, lv_design_mode_t mo
* LV_DESIGN_DRAW_POST: drawing after every children are drawn * LV_DESIGN_DRAW_POST: drawing after every children are drawn
* @return return true/false, depends on 'mode' * @return return true/false, depends on 'mode'
*/ */
static bool lv_ta_scrling_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode) static bool lv_ta_scrollable_design(lv_obj_t * scrl, const area_t * mask, lv_design_mode_t mode)
{ {
if(mode == LV_DESIGN_COVER_CHK) { if(mode == LV_DESIGN_COVER_CHK) {
/*Return false if the object is not covers the mask_p area*/ /*Return false if the object is not covers the mask_p area*/
return scrl_design_f(scrl, mask, mode); return scrl_design(scrl, mask, mode);
} else if(mode == LV_DESIGN_DRAW_MAIN) { } else if(mode == LV_DESIGN_DRAW_MAIN) {
/*Draw the object*/ /*Draw the object*/
scrl_design_f(scrl, mask, mode); scrl_design(scrl, mask, mode);
} else if(mode == LV_DESIGN_DRAW_POST) { } else if(mode == LV_DESIGN_DRAW_POST) {
scrl_design_f(scrl, mask, mode); scrl_design(scrl, mask, mode);
/*Draw the cursor too*/ /*Draw the cursor too*/
lv_obj_t * ta = lv_obj_get_parent(scrl); lv_obj_t * ta = lv_obj_get_parent(scrl);
@ -899,7 +896,7 @@ static bool lv_ta_scrling_design(lv_obj_t * scrl, const area_t * mask, lv_design
/*If the cursor is out of the text (most right) draw it to the next line*/ /*If the cursor is out of the text (most right) draw it to the next line*/
if(letter_pos.x + ta_ext->label->coords.x1 + letter_w > ta_ext->label->coords.x2 && ta_ext->one_line == 0) { if(letter_pos.x + ta_ext->label->coords.x1 + letter_w > ta_ext->label->coords.x2 && ta_ext->one_line == 0) {
letter_pos.x = 0; letter_pos.x = 0;
letter_pos.y += letter_h + label_style->text.space_line; letter_pos.y += letter_h + label_style->text.line_space;
if(letter != '\0'){ if(letter != '\0'){
byte_pos += txt_utf8_size(txt[byte_pos]); byte_pos += txt_utf8_size(txt[byte_pos]);

30
lv_objx/lv_ta.h
View File

@ -90,7 +90,7 @@ bool lv_ta_signal(lv_obj_t * ta, lv_signal_t sign, void * param);
* @param param pointer to a signal specific variable * @param param pointer to a signal specific variable
* @return true: the object is still valid (not deleted), false: the object become invalid * @return true: the object is still valid (not deleted), false: the object become invalid
*/ */
bool lv_ta_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void * param); bool lv_ta_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, void * param);
/** /**
* Insert a character to the current cursor position * Insert a character to the current cursor position
@ -192,7 +192,7 @@ void lv_ta_set_one_line(lv_obj_t * ta, bool en);
* @param ta obj pointer to a text area object * @param ta obj pointer to a text area object
* @return pointer to the text * @return pointer to the text
*/ */
const char * lv_ta_get_txt(lv_obj_t * ta); const char * lv_ta_get_text(lv_obj_t * ta);
/** /**
* Get the label of a text area * Get the label of a text area
@ -227,7 +227,7 @@ lv_ta_cursor_type_t lv_ta_get_cursor_type(lv_obj_t * ta);
* @param ta pointer to a text area object * @param ta pointer to a text area object
* @return style pointer to the new cursor style * @return style pointer to the new cursor style
*/ */
lv_style_t * lv_ta_get_cursor_style(lv_obj_t * ta); lv_style_t * lv_ta_get_style_cursor(lv_obj_t * ta);
/** /**
* Get the password mode * Get the password mode
@ -236,6 +236,30 @@ lv_style_t * lv_ta_get_cursor_style(lv_obj_t * ta);
*/ */
bool lv_ta_get_pwd_mode(lv_obj_t * ta); bool lv_ta_get_pwd_mode(lv_obj_t * ta);
/****************************
* TRANSPARENT API FUNCTIONS
***************************/
/**
* Get the style of the text area background
* @param ta pointer to a text area object
* @return pointer to the style of the background
*/
static inline lv_style_t * lv_ta_get_style_bg(lv_obj_t * ta)
{
return lv_page_get_style_bg(ta);
}
/**
* Get the style of the scrollbars of a text area
* @param ta pointer to a text area object
* @return pointer to the style of the scrollbars
*/
static inline lv_style_t * lv_ta_get_style_scrollbar(lv_obj_t * ta)
{
return lv_page_get_style_sb(ta);
}
/********************** /**********************
* MACROS * MACROS
**********************/ **********************/

16
lv_objx/lv_tabview.c
View File

@ -24,10 +24,6 @@
/********************** /**********************
* STATIC PROTOTYPES * STATIC PROTOTYPES
**********************/ **********************/
#if 0 /*Unused*/
static bool lv_tab_design(lv_obj_t * tab, const area_t * mask, lv_design_mode_t mode);
#endif
static bool tabpage_signal(lv_obj_t * tab_page, lv_signal_t sign, void * param); static bool tabpage_signal(lv_obj_t * tab_page, lv_signal_t sign, void * param);
static bool tabscrl_signal(lv_obj_t * tab_scrl, lv_signal_t sign, void * param); static bool tabscrl_signal(lv_obj_t * tab_scrl, lv_signal_t sign, void * param);
@ -39,6 +35,8 @@ static lv_res_t tab_btnm_action(lv_obj_t * tab_btnm, const char * tab_name);
/********************** /**********************
* STATIC VARIABLES * STATIC VARIABLES
**********************/ **********************/
static lv_signal_func_t ancestor_signal;
static lv_signal_func_t page_signal;
static lv_signal_func_t page_scrl_signal; static lv_signal_func_t page_scrl_signal;
static const char * tab_def[] = {""}; static const char * tab_def[] = {""};
/********************** /**********************
@ -64,6 +62,7 @@ lv_obj_t * lv_tabview_create(lv_obj_t * par, lv_obj_t * copy)
/*Create the ancestor of tab*/ /*Create the ancestor of tab*/
lv_obj_t * new_tabview = lv_obj_create(par, copy); lv_obj_t * new_tabview = lv_obj_create(par, copy);
dm_assert(new_tabview); dm_assert(new_tabview);
if(ancestor_signal == NULL) ancestor_signal = lv_obj_get_signal_func(new_tabview);
/*Allocate the tab type specific extended data*/ /*Allocate the tab type specific extended data*/
lv_tabview_ext_t * ext = lv_obj_allocate_ext_attr(new_tabview, sizeof(lv_tabview_ext_t)); lv_tabview_ext_t * ext = lv_obj_allocate_ext_attr(new_tabview, sizeof(lv_tabview_ext_t));
@ -99,7 +98,6 @@ lv_obj_t * lv_tabview_create(lv_obj_t * par, lv_obj_t * copy)
lv_btnm_set_toggle(ext->tabs, true, 0); lv_btnm_set_toggle(ext->tabs, true, 0);
ext->indic = lv_obj_create(ext->tabs, NULL); ext->indic = lv_obj_create(ext->tabs, NULL);
lv_style_t * style_indic = lv_obj_get_style(ext->indic);
lv_obj_set_size(ext->indic, LV_DPI, LV_DPI / 10); lv_obj_set_size(ext->indic, LV_DPI, LV_DPI / 10);
lv_obj_align(ext->indic, ext->tabs, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0); lv_obj_align(ext->indic, ext->tabs, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
lv_obj_set_click(ext->indic, false); lv_obj_set_click(ext->indic, false);
@ -151,7 +149,7 @@ bool lv_tabview_signal(lv_obj_t * tabview, lv_signal_t sign, void * param)
bool valid; bool valid;
/* Include the ancient signal function */ /* Include the ancient signal function */
valid = lv_obj_signal(tabview, sign, param); valid = ancestor_signal(tabview, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */
@ -192,9 +190,11 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name)
lv_obj_set_size(h, lv_obj_get_width(tabview), lv_obj_get_height(tabview) - lv_obj_get_height(ext->tabs)); lv_obj_set_size(h, lv_obj_get_width(tabview), lv_obj_get_height(tabview) - lv_obj_get_height(ext->tabs));
lv_obj_set_style(h, &lv_style_transp_fit); lv_obj_set_style(h, &lv_style_transp_fit);
lv_obj_set_style(lv_page_get_scrl(h), &lv_style_transp_fit); lv_obj_set_style(lv_page_get_scrl(h), &lv_style_transp_fit);
lv_obj_set_signal_func(h, tabpage_signal);
lv_page_set_sb_mode(h, LV_PAGE_SB_MODE_AUTO); lv_page_set_sb_mode(h, LV_PAGE_SB_MODE_AUTO);
if(page_signal == NULL) page_signal = lv_obj_get_signal_func(h);
if(page_scrl_signal == NULL) page_scrl_signal = lv_obj_get_signal_func(lv_page_get_scrl(h)); if(page_scrl_signal == NULL) page_scrl_signal = lv_obj_get_signal_func(lv_page_get_scrl(h));
lv_obj_set_signal_func(h, tabpage_signal);
lv_obj_set_signal_func(lv_page_get_scrl(h), tabscrl_signal); lv_obj_set_signal_func(lv_page_get_scrl(h), tabscrl_signal);
/*Extend the button matrix map with the new name*/ /*Extend the button matrix map with the new name*/
@ -483,7 +483,7 @@ static bool tabpage_signal(lv_obj_t * tab_page, lv_signal_t sign, void * param)
bool valid; bool valid;
/* Include the ancient signal function */ /* Include the ancient signal function */
valid = lv_page_signal(tab_page, sign, param); valid = page_signal(tab_page, sign, param);
/* The object can be deleted so check its validity and then /* The object can be deleted so check its validity and then
* make the object specific signal handling */ * make the object specific signal handling */