jeans/openHASP
jeans/openHASP
1
0
Fork 0
mirror of https://github.com/HASwitchPlate/openHASP.git synced 2025-07-27 05:06:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update local attribute parser

Browse Source
This commit is contained in:
fvanroie 2021-05-31 18:36:51 +02:00
parent a1b6150fa2
commit f9c87e294e
2 changed files with 128 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
src/hasp/hasp_attribute.cpp
View File

@ -366,8 +366,8 @@ static void hasp_attribute_get_part_state(lv_obj_t* obj, const char* attr_in, ch
* @param update bool: change/set the value if true, dispatch/get value if false * @param update bool: change/set the value if true, dispatch/get value if false
* @note setting a value won't return anything, getting will dispatch the value * @note setting a value won't return anything, getting will dispatch the value
*/ */
static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t attr_hash, const char* payload, static hasp_attribute_type_t hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t attr_hash,
bool update, bool& result) const char* payload, bool update, int32_t& val)
{ {
char attr[32]; char attr[32];
uint8_t part = LV_OBJ_PART_MAIN; uint8_t part = LV_OBJ_PART_MAIN;
@ -383,50 +383,49 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
* when using hasp_out use attr_p for the original attribute name * when using hasp_out use attr_p for the original attribute name
* *************************************************************** */ * *************************************************************** */
result = true; // default return
switch(attr_hash) { switch(attr_hash) {
/* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/ /* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
#if LV_USE_BLEND_MODES #if LV_USE_BLEND_MODES
case ATTR_BG_BLEND_MODE: case ATTR_BG_BLEND_MODE:
return attribute_bg_blend_mode(obj, part, state, update, attr_p, (lv_blend_mode_t)var); return attribute_bg_blend_mode(obj, part, state, update, (lv_blend_mode_t)var, val);
case ATTR_TEXT_BLEND_MODE: // case ATTR_TEXT_BLEND_MODE:
return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_BORDER_BLEND_MODE: // case ATTR_BORDER_BLEND_MODE:
return lv_obj_set_style_local_border_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_border_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_OUTLINE_BLEND_MODE: // case ATTR_OUTLINE_BLEND_MODE:
return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_SHADOW_BLEND_MODE: // case ATTR_SHADOW_BLEND_MODE:
return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_LINE_BLEND_MODE: // case ATTR_LINE_BLEND_MODE:
return lv_obj_set_style_local_line_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_line_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_VALUE_BLEND_MODE: // case ATTR_VALUE_BLEND_MODE:
return lv_obj_set_style_local_value_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_value_blend_mode(obj, part, state, (lv_blend_mode_t)var);
case ATTR_PATTERN_BLEND_MODE: // case ATTR_PATTERN_BLEND_MODE:
return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (lv_blend_mode_t)var); // return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (lv_blend_mode_t)var);
#endif #endif
case ATTR_SIZE: case ATTR_SIZE:
return attribute_size(obj, part, state, update, attr_p, var); return attribute_size(obj, part, state, update, var, val);
case ATTR_RADIUS: case ATTR_RADIUS:
return attribute_radius(obj, part, state, update, attr_p, var); return attribute_radius(obj, part, state, update, var, val);
case ATTR_CLIP_CORNER: case ATTR_CLIP_CORNER:
return attribute_clip_corner(obj, part, state, update, attr_p, var); return attribute_clip_corner(obj, part, state, update, var, val);
case ATTR_OPA_SCALE: case ATTR_OPA_SCALE:
return attribute_opa_scale(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_opa_scale(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_TRANSFORM_WIDTH: case ATTR_TRANSFORM_WIDTH:
return attribute_transform_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_transform_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_TRANSFORM_HEIGHT: case ATTR_TRANSFORM_HEIGHT:
return attribute_transform_height(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_transform_height(obj, part, state, update, (lv_style_int_t)var, val);
/* Background attributes */ /* Background attributes */
case ATTR_BG_MAIN_STOP: case ATTR_BG_MAIN_STOP:
return attribute_bg_main_stop(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_bg_main_stop(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_BG_GRAD_STOP: case ATTR_BG_GRAD_STOP:
return attribute_bg_grad_stop(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_bg_grad_stop(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_BG_GRAD_DIR: case ATTR_BG_GRAD_DIR:
return attribute_bg_grad_dir(obj, part, state, update, attr_p, (lv_grad_dir_t)var); return attribute_bg_grad_dir(obj, part, state, update, (lv_grad_dir_t)var, val);
case ATTR_BG_COLOR: { case ATTR_BG_COLOR: {
if(update) { if(update) {
lv_color32_t c; lv_color32_t c;
@ -435,7 +434,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_bg_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_bg_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_BG_GRAD_COLOR: case ATTR_BG_GRAD_COLOR:
if(update) { if(update) {
@ -446,33 +445,33 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_bg_grad_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_bg_grad_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
case ATTR_BG_OPA: case ATTR_BG_OPA:
return attribute_bg_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_bg_opa(obj, part, state, update, (lv_opa_t)var, val);
/* Margin attributes */ /* Margin attributes */
case ATTR_MARGIN_TOP: case ATTR_MARGIN_TOP:
return attribute_margin_top(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_margin_top(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_MARGIN_BOTTOM: case ATTR_MARGIN_BOTTOM:
return attribute_margin_bottom(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_margin_bottom(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_MARGIN_LEFT: case ATTR_MARGIN_LEFT:
return attribute_margin_left(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_margin_left(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_MARGIN_RIGHT: case ATTR_MARGIN_RIGHT:
return attribute_margin_right(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_margin_right(obj, part, state, update, (lv_style_int_t)var, val);
/* Padding attributes */ /* Padding attributes */
case ATTR_PAD_TOP: case ATTR_PAD_TOP:
return attribute_pad_top(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_pad_top(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_PAD_BOTTOM: case ATTR_PAD_BOTTOM:
return attribute_pad_bottom(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_pad_bottom(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_PAD_LEFT: case ATTR_PAD_LEFT:
return attribute_pad_left(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_pad_left(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_PAD_RIGHT: case ATTR_PAD_RIGHT:
return attribute_pad_right(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_pad_right(obj, part, state, update, (lv_style_int_t)var, val);
#if LVGL_VERSION_MAJOR == 7 #if LVGL_VERSION_MAJOR == 7
case ATTR_PAD_INNER: case ATTR_PAD_INNER:
return attribute_pad_inner(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_pad_inner(obj, part, state, update, (lv_style_int_t)var, val);
#endif #endif
/* Scale attributes */ /* Scale attributes */
@ -485,7 +484,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_scale_grad_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_scale_grad_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_SCALE_END_COLOR: case ATTR_SCALE_END_COLOR:
if(update) { if(update) {
@ -496,25 +495,25 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_scale_end_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_scale_end_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
case ATTR_SCALE_END_LINE_WIDTH: case ATTR_SCALE_END_LINE_WIDTH:
return attribute_scale_end_line_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_scale_end_line_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SCALE_END_BORDER_WIDTH: case ATTR_SCALE_END_BORDER_WIDTH:
return attribute_scale_end_border_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_scale_end_border_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SCALE_BORDER_WIDTH: case ATTR_SCALE_BORDER_WIDTH:
return attribute_scale_border_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_scale_border_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SCALE_WIDTH: case ATTR_SCALE_WIDTH:
return attribute_scale_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_scale_width(obj, part, state, update, (lv_style_int_t)var, val);
/* Text attributes */ /* Text attributes */
case ATTR_TEXT_LETTER_SPACE: case ATTR_TEXT_LETTER_SPACE:
return attribute_text_letter_space(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_text_letter_space(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_TEXT_LINE_SPACE: case ATTR_TEXT_LINE_SPACE:
return attribute_text_line_space(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_text_line_space(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_TEXT_DECOR: case ATTR_TEXT_DECOR:
return attribute_text_decor(obj, part, state, update, attr_p, (lv_text_decor_t)var); return attribute_text_decor(obj, part, state, update, (lv_text_decor_t)var, val);
case ATTR_TEXT_OPA: case ATTR_TEXT_OPA:
return attribute_text_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_text_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_TEXT_COLOR: { case ATTR_TEXT_COLOR: {
if(update) { if(update) {
lv_color32_t c; lv_color32_t c;
@ -523,7 +522,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_text_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_text_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_TEXT_SEL_COLOR: { case ATTR_TEXT_SEL_COLOR: {
if(update) { if(update) {
@ -534,7 +533,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_text_sel_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_text_sel_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_TEXT_FONT: { case ATTR_TEXT_FONT: {
lv_font_t* font = haspPayloadToFont(payload); lv_font_t* font = haspPayloadToFont(payload);
@ -555,18 +554,19 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), payload); LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), payload);
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Border attributes */ /* Border attributes */
case ATTR_BORDER_WIDTH: case ATTR_BORDER_WIDTH:
return attribute_border_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_border_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_BORDER_SIDE: case ATTR_BORDER_SIDE:
return attribute_border_side(obj, part, state, update, attr_p, (lv_border_side_t)var); return attribute_border_side(obj, part, state, update, (lv_border_side_t)var, val);
case ATTR_BORDER_POST: case ATTR_BORDER_POST:
return attribute_border_post(obj, part, state, update, attr_p, Parser::is_true(payload)); attribute_border_post(obj, part, state, update, Parser::is_true(payload), val);
return HASP_ATTR_TYPE_BOOL;
case ATTR_BORDER_OPA: case ATTR_BORDER_OPA:
return attribute_border_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_border_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_BORDER_COLOR: { case ATTR_BORDER_COLOR: {
if(update) { if(update) {
lv_color32_t c; lv_color32_t c;
@ -576,16 +576,16 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_border_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_border_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Outline attributes */ /* Outline attributes */
case ATTR_OUTLINE_WIDTH: case ATTR_OUTLINE_WIDTH:
return attribute_outline_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_outline_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_OUTLINE_PAD: case ATTR_OUTLINE_PAD:
return attribute_outline_pad(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_outline_pad(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_OUTLINE_OPA: case ATTR_OUTLINE_OPA:
return attribute_outline_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_outline_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_OUTLINE_COLOR: { case ATTR_OUTLINE_COLOR: {
if(update) { if(update) {
lv_color32_t c; lv_color32_t c;
@ -595,21 +595,21 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_outline_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_outline_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Shadow attributes */ /* Shadow attributes */
#if LV_USE_SHADOW #if LV_USE_SHADOW
case ATTR_SHADOW_WIDTH: case ATTR_SHADOW_WIDTH:
return attribute_shadow_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_shadow_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SHADOW_OFS_X: case ATTR_SHADOW_OFS_X:
return attribute_shadow_ofs_x(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_shadow_ofs_x(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SHADOW_OFS_Y: case ATTR_SHADOW_OFS_Y:
return attribute_shadow_ofs_y(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_shadow_ofs_y(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SHADOW_SPREAD: case ATTR_SHADOW_SPREAD:
return attribute_shadow_spread(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_shadow_spread(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_SHADOW_OPA: case ATTR_SHADOW_OPA:
return attribute_shadow_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_shadow_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_SHADOW_COLOR: { case ATTR_SHADOW_COLOR: {
if(update) { if(update) {
lv_color32_t c; lv_color32_t c;
@ -619,21 +619,22 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_shadow_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_shadow_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
#endif #endif
/* Line attributes */ /* Line attributes */
case ATTR_LINE_WIDTH: case ATTR_LINE_WIDTH:
return attribute_line_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_line_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_LINE_DASH_WIDTH: case ATTR_LINE_DASH_WIDTH:
return attribute_line_dash_width(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_line_dash_width(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_LINE_DASH_GAP: case ATTR_LINE_DASH_GAP:
return attribute_line_dash_gap(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_line_dash_gap(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_LINE_ROUNDED: case ATTR_LINE_ROUNDED:
return attribute_line_rounded(obj, part, state, update, attr_p, Parser::is_true(payload)); attribute_line_rounded(obj, part, state, update, Parser::is_true(payload), val);
return HASP_ATTR_TYPE_BOOL;
case ATTR_LINE_OPA: case ATTR_LINE_OPA:
return attribute_line_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_line_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_LINE_COLOR: { case ATTR_LINE_COLOR: {
if(update) { if(update) {
lv_color32_t c; lv_color32_t c;
@ -642,29 +643,29 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_line_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_line_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Value attributes */ /* Value attributes */
case ATTR_VALUE_LETTER_SPACE: case ATTR_VALUE_LETTER_SPACE:
return attribute_value_letter_space(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_value_letter_space(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_VALUE_LINE_SPACE: case ATTR_VALUE_LINE_SPACE:
return attribute_value_line_space(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_value_line_space(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_VALUE_OFS_X: case ATTR_VALUE_OFS_X:
return attribute_value_ofs_x(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_value_ofs_x(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_VALUE_OFS_Y: case ATTR_VALUE_OFS_Y:
return attribute_value_ofs_y(obj, part, state, update, attr_p, (lv_style_int_t)var); return attribute_value_ofs_y(obj, part, state, update, (lv_style_int_t)var, val);
case ATTR_VALUE_ALIGN: case ATTR_VALUE_ALIGN:
return attribute_value_align(obj, part, state, update, attr_p, (lv_align_t)var); return attribute_value_align(obj, part, state, update, (lv_align_t)var, val);
case ATTR_VALUE_OPA: case ATTR_VALUE_OPA:
return attribute_value_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_value_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_VALUE_STR: { case ATTR_VALUE_STR: {
if(update) { if(update) {
my_obj_set_value_str_text(obj, part, state, payload); my_obj_set_value_str_text(obj, part, state, payload);
} else { } else {
attr_out_str(obj, attr, lv_obj_get_style_value_str(obj, part)); attr_out_str(obj, attr, lv_obj_get_style_value_str(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_VALUE_COLOR: { case ATTR_VALUE_COLOR: {
if(update) { if(update) {
@ -675,25 +676,26 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_value_color(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_value_color(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_VALUE_FONT: { case ATTR_VALUE_FONT: {
lv_font_t* font = haspPayloadToFont(payload); lv_font_t* font = haspPayloadToFont(payload);
if(font) { if(font) {
return lv_obj_set_style_local_value_font(obj, part, state, font); lv_obj_set_style_local_value_font(obj, part, state, font);
} else { } else {
LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), attr_p); LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), attr_p);
return;
} }
return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Pattern attributes */ /* Pattern attributes */
case ATTR_PATTERN_REPEAT: case ATTR_PATTERN_REPEAT:
return attribute_pattern_repeat(obj, part, state, update, attr_p, Parser::is_true(payload)); attribute_pattern_repeat(obj, part, state, update, Parser::is_true(payload), val);
return HASP_ATTR_TYPE_BOOL;
case ATTR_PATTERN_OPA: case ATTR_PATTERN_OPA:
return attribute_pattern_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_pattern_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_PATTERN_RECOLOR_OPA: case ATTR_PATTERN_RECOLOR_OPA:
return attribute_pattern_recolor_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_pattern_recolor_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_PATTERN_RECOLOR: { case ATTR_PATTERN_RECOLOR: {
if(update) { if(update) {
lv_color32_t c; lv_color32_t c;
@ -703,7 +705,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_pattern_recolor(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_pattern_recolor(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
case ATTR_PATTERN_IMAGE: case ATTR_PATTERN_IMAGE:
@ -712,9 +714,9 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
/* Image attributes */ /* Image attributes */
case ATTR_IMAGE_RECOLOR_OPA: case ATTR_IMAGE_RECOLOR_OPA:
return attribute_image_recolor_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_image_recolor_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_IMAGE_OPA: case ATTR_IMAGE_OPA:
return attribute_image_opa(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_image_opa(obj, part, state, update, (lv_opa_t)var, val);
case ATTR_IMAGE_RECOLOR: { case ATTR_IMAGE_RECOLOR: {
if(update) { if(update) {
lv_color32_t c; lv_color32_t c;
@ -724,7 +726,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
} else { } else {
attr_out_color(obj, attr, lv_obj_get_style_image_recolor(obj, part)); attr_out_color(obj, attr, lv_obj_get_style_image_recolor(obj, part));
} }
return; return HASP_ATTR_TYPE_METHOD_OK;
} }
/* Transition attributes */ /* Transition attributes */
@ -734,8 +736,9 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
break; break;
} }
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash); // LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash);
result = false; // result = false;
return HASP_ATTR_TYPE_NOT_FOUND;
} }
static hasp_attribute_type_t hasp_process_arc_attribute(lv_obj_t* obj, uint16_t attr_hash, int32_t& val, bool update) static hasp_attribute_type_t hasp_process_arc_attribute(lv_obj_t* obj, uint16_t attr_hash, int32_t& val, bool update)
@ -2011,14 +2014,14 @@ void hasp_process_obj_attribute(lv_obj_t* obj, const char* attribute, const char
} }
if(ret == HASP_ATTR_TYPE_NOT_FOUND) { if(ret == HASP_ATTR_TYPE_NOT_FOUND) {
bool result; // bool result;
hasp_local_style_attr(obj, attribute, attr_hash, payload, update, result); ret = hasp_local_style_attr(obj, attribute, attr_hash, payload, update, val);
if(result) { // if(result) {
ret = HASP_ATTR_TYPE_METHOD_OK; // ret = HASP_ATTR_TYPE_METHOD_OK;
} else { // } else {
ret = HASP_ATTR_TYPE_NOT_FOUND; // ret = HASP_ATTR_TYPE_NOT_FOUND;
} // }
LOG_VERBOSE(TAG_ATTR, "%s %d ret:%d", __FILE__, __LINE__, ret); // LOG_VERBOSE(TAG_ATTR, "%s %d ret:%d", __FILE__, __LINE__, ret);
} }
// Positive return codes have returned a value, negative are warnings // Positive return codes have returned a value, negative are warnings

25
src/hasp/hasp_attribute.h
View File

@ -49,6 +49,20 @@ typedef enum {
HASP_ATTR_TYPE_METHOD_OK, HASP_ATTR_TYPE_METHOD_OK,
} hasp_attribute_type_t; } hasp_attribute_type_t;
struct hasp_attr_local_opa_t
{
uint16_t hash;
void (*set)(lv_obj_t*, uint8_t, lv_state_t, lv_opa_t);
lv_opa_t (*get)(const lv_obj_t*, uint8_t);
};
struct hasp_attr_local_int_t
{
uint16_t hash;
void (*set)(lv_obj_t*, uint8_t, lv_state_t, lv_style_int_t);
lv_style_int_t (*get)(const lv_obj_t*, uint8_t);
};
struct hasp_attr_update_bool_const_t struct hasp_attr_update_bool_const_t
{ {
lv_hasp_obj_type_t obj_type; lv_hasp_obj_type_t obj_type;
@ -129,7 +143,7 @@ struct hasp_attr_update_char_const_t
const char* (*get)(const lv_obj_t*); const char* (*get)(const lv_obj_t*);
}; };
#define _HASP_ATTRIBUTE(prop_name, func_name, value_type) \ #define _HASP_ATTRIBUTE_OLD(prop_name, func_name, value_type) \
static inline void attribute_##func_name(lv_obj_t* obj, uint8_t part, lv_state_t state, bool update, \ static inline void attribute_##func_name(lv_obj_t* obj, uint8_t part, lv_state_t state, bool update, \
const char* attr, value_type val) \ const char* attr, value_type val) \
{ \ { \
@ -142,6 +156,15 @@ struct hasp_attr_update_char_const_t
} \ } \
} }
#define _HASP_ATTRIBUTE(prop_name, func_name, value_type) \
static inline hasp_attribute_type_t attribute_##func_name(lv_obj_t* obj, uint8_t part, lv_state_t state, bool update, \
value_type val, int32_t& res) \
{ \
if(update) lv_obj_set_style_local_##func_name(obj, part, state, (value_type)val); \
res = (int32_t)lv_obj_get_style_##func_name(obj, part); \
return HASP_ATTR_TYPE_INT; \
}
_HASP_ATTRIBUTE(RADIUS, radius, lv_style_int_t) _HASP_ATTRIBUTE(RADIUS, radius, lv_style_int_t)
_HASP_ATTRIBUTE(CLIP_CORNER, clip_corner, bool) _HASP_ATTRIBUTE(CLIP_CORNER, clip_corner, bool)
_HASP_ATTRIBUTE(SIZE, size, lv_style_int_t) _HASP_ATTRIBUTE(SIZE, size, lv_style_int_t)