diff --git a/src/hasp/hasp_attribute.cpp b/src/hasp/hasp_attribute.cpp
index f240349c..7a9e3265 100644
--- a/src/hasp/hasp_attribute.cpp
+++ b/src/hasp/hasp_attribute.cpp
@@ -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
  * @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,
-                                  bool update, bool& result)
+static hasp_attribute_type_t hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t attr_hash,
+                                                   const char* payload, bool update, int32_t& val)
 {
     char attr[32];
     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
      * *************************************************************** */
 
-    result = true; // default return
-
     switch(attr_hash) {
 
 /* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
 #if LV_USE_BLEND_MODES
         case ATTR_BG_BLEND_MODE:
-            return attribute_bg_blend_mode(obj, part, state, update, attr_p, (lv_blend_mode_t)var);
-        case ATTR_TEXT_BLEND_MODE:
-            return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var);
-        case ATTR_BORDER_BLEND_MODE:
-            return lv_obj_set_style_local_border_blend_mode(obj, part, state, (lv_blend_mode_t)var);
-        case ATTR_OUTLINE_BLEND_MODE:
-            return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var);
-        case ATTR_SHADOW_BLEND_MODE:
-            return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var);
-        case ATTR_LINE_BLEND_MODE:
-            return lv_obj_set_style_local_line_blend_mode(obj, part, state, (lv_blend_mode_t)var);
-        case ATTR_VALUE_BLEND_MODE:
-            return lv_obj_set_style_local_value_blend_mode(obj, part, state, (lv_blend_mode_t)var);
-        case ATTR_PATTERN_BLEND_MODE:
-            return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (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:
+            //     return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var);
+            // case ATTR_BORDER_BLEND_MODE:
+            //     return lv_obj_set_style_local_border_blend_mode(obj, part, state, (lv_blend_mode_t)var);
+            // case ATTR_OUTLINE_BLEND_MODE:
+            //     return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var);
+            // case ATTR_SHADOW_BLEND_MODE:
+            //     return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var);
+            // case ATTR_LINE_BLEND_MODE:
+            //     return lv_obj_set_style_local_line_blend_mode(obj, part, state, (lv_blend_mode_t)var);
+            // case ATTR_VALUE_BLEND_MODE:
+            //     return lv_obj_set_style_local_value_blend_mode(obj, part, state, (lv_blend_mode_t)var);
+            // case ATTR_PATTERN_BLEND_MODE:
+            //     return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (lv_blend_mode_t)var);
 #endif
 
         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:
-            return attribute_radius(obj, part, state, update, attr_p, var);
+            return attribute_radius(obj, part, state, update, var, val);
         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:
-            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:
-            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:
-            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 */
         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:
-            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:
-            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: {
             if(update) {
                 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 {
                 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:
             if(update) {
@@ -446,33 +445,33 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
             } else {
                 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:
-            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 */
         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:
-            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:
-            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:
-            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 */
         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:
-            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:
-            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:
-            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
         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
 
         /* Scale attributes */
@@ -485,7 +484,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
             } else {
                 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:
             if(update) {
@@ -496,25 +495,25 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
             } else {
                 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:
-            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:
-            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:
-            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:
-            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 */
         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:
-            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:
-            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:
-            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: {
             if(update) {
                 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 {
                 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: {
             if(update) {
@@ -534,7 +533,7 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
             } else {
                 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: {
             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 {
                 LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), payload);
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
 
         /* Border attributes */
         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:
-            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:
-            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:
-            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: {
             if(update) {
                 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 {
                 attr_out_color(obj, attr, lv_obj_get_style_border_color(obj, part));
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
 
         /* Outline attributes */
         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:
-            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:
-            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: {
             if(update) {
                 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 {
                 attr_out_color(obj, attr, lv_obj_get_style_outline_color(obj, part));
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
 
         /* Shadow attributes */
 #if LV_USE_SHADOW
         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:
-            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:
-            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:
-            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:
-            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: {
             if(update) {
                 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 {
                 attr_out_color(obj, attr, lv_obj_get_style_shadow_color(obj, part));
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
 #endif
 
         /* Line attributes */
         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:
-            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:
-            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:
-            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:
-            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: {
             if(update) {
                 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 {
                 attr_out_color(obj, attr, lv_obj_get_style_line_color(obj, part));
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
 
         /* Value attributes */
         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:
-            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:
-            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:
-            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:
-            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:
-            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: {
             if(update) {
                 my_obj_set_value_str_text(obj, part, state, payload);
             } else {
                 attr_out_str(obj, attr, lv_obj_get_style_value_str(obj, part));
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
         case ATTR_VALUE_COLOR: {
             if(update) {
@@ -675,25 +676,26 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
             } else {
                 attr_out_color(obj, attr, lv_obj_get_style_value_color(obj, part));
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
         case ATTR_VALUE_FONT: {
             lv_font_t* font = haspPayloadToFont(payload);
             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 {
                 LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), attr_p);
-                return;
             }
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
 
         /* Pattern attributes */
         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:
-            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:
-            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: {
             if(update) {
                 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 {
                 attr_out_color(obj, attr, lv_obj_get_style_pattern_recolor(obj, part));
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
 
         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 */
         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:
-            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: {
             if(update) {
                 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 {
                 attr_out_color(obj, attr, lv_obj_get_style_image_recolor(obj, part));
             }
-            return;
+            return HASP_ATTR_TYPE_METHOD_OK;
         }
 
             /* Transition attributes */
@@ -734,8 +736,9 @@ static void hasp_local_style_attr(lv_obj_t* obj, const char* attr_p, uint16_t at
             break;
     }
 
-    LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash);
-    result = false;
+    // LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash);
+    // 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)
@@ -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) {
-        bool result;
-        hasp_local_style_attr(obj, attribute, attr_hash, payload, update, result);
-        if(result) {
-            ret = HASP_ATTR_TYPE_METHOD_OK;
-        } else {
-            ret = HASP_ATTR_TYPE_NOT_FOUND;
-        }
-        LOG_VERBOSE(TAG_ATTR, "%s %d ret:%d", __FILE__, __LINE__, ret);
+        // bool result;
+        ret = hasp_local_style_attr(obj, attribute, attr_hash, payload, update, val);
+        // if(result) {
+        //     ret = HASP_ATTR_TYPE_METHOD_OK;
+        // } else {
+        //     ret = HASP_ATTR_TYPE_NOT_FOUND;
+        // }
+        // LOG_VERBOSE(TAG_ATTR, "%s %d ret:%d", __FILE__, __LINE__, ret);
     }
 
     // Positive return codes have returned a value, negative are warnings
diff --git a/src/hasp/hasp_attribute.h b/src/hasp/hasp_attribute.h
index 524b7701..74e38e29 100644
--- a/src/hasp/hasp_attribute.h
+++ b/src/hasp/hasp_attribute.h
@@ -49,6 +49,20 @@ typedef enum {
     HASP_ATTR_TYPE_METHOD_OK,
 } 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
 {
     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*);
 };
 
-#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,               \
                                              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(CLIP_CORNER, clip_corner, bool)
 _HASP_ATTRIBUTE(SIZE, size, lv_style_int_t)
diff --git a/src/hasp/hasp_dispatch.cpp b/src/hasp/hasp_dispatch.cpp
index 57820dbb..04aacbdc 100644
--- a/src/hasp/hasp_dispatch.cpp
+++ b/src/hasp/hasp_dispatch.cpp
@@ -75,21 +75,38 @@ void dispatch_state_subtopic(const char* subtopic, const char* payload)
 #endif
 }
 
-// Format filesystem and erase EEPROM
-bool dispatch_factory_reset()
+void dispatch_state_eventid(const char* topic, hasp_event_t eventid)
 {
-    bool formated = true;
-    bool erased   = true;
+    char payload[32];
+    char eventname[8];
 
-#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
-    formated = HASP_FS.format();
-#endif
+    Parser::get_event_name(eventid, eventname, sizeof(eventname));
+    if(eventid == HASP_EVENT_ON || eventid == HASP_EVENT_OFF) {
+        snprintf_P(payload, sizeof(payload), PSTR("{\"state\":\"%s\"}"), eventname);
+    } else {
+        snprintf_P(payload, sizeof(payload), PSTR("{\"event\":\"%s\"}"), eventname);
+    }
+    dispatch_state_subtopic(topic, payload);
+}
 
-#if HASP_USE_EEPROM > 0
-    erased = false;
-#endif
+void dispatch_state_brightness(const char* topic, hasp_event_t eventid, int32_t val)
+{
+    char payload[64];
+    char eventname[8];
 
-    return formated && erased;
+    Parser::get_event_name(eventid, eventname, sizeof(eventname));
+    snprintf_P(payload, sizeof(payload), PSTR("{\"state\":\"%s\",\"brightness\":%d}"), eventname, val);
+    dispatch_state_subtopic(topic, payload);
+}
+
+void dispatch_state_val(const char* topic, hasp_event_t eventid, int32_t val)
+{
+    char payload[64];
+    char eventname[8];
+
+    Parser::get_event_name(eventid, eventname, sizeof(eventname));
+    snprintf_P(payload, sizeof(payload), PSTR("{\"state\":\"%s\",\"val\":%d}"), eventname, val);
+    dispatch_state_subtopic(topic, payload);
 }
 
 void dispatch_json_error(uint8_t tag, DeserializationError& jsonError)
@@ -200,8 +217,9 @@ static void dispatch_output(const char* topic, const char* payload)
                 return;
             }
 
-            JsonVariant state = json[F("state")];
-            JsonVariant value = json[F("val")];
+            JsonVariant state      = json[F("state")];
+            JsonVariant value      = json[F("val")];
+            JsonVariant brightness = json[F("brightness")];
 
             // Check if the state needs to change
             if(!state.isNull() && power_state != state.as<bool>()) {
@@ -212,6 +230,9 @@ static void dispatch_output(const char* topic, const char* payload)
             if(!value.isNull() && state_value != value.as<int32_t>()) {
                 state_value = value.as<int32_t>();
                 updated     = true;
+            } else if(!brightness.isNull() && state_value != brightness.as<int32_t>()) {
+                state_value = brightness.as<int32_t>();
+                updated     = true;
             }
 
             // Set new state
@@ -800,11 +821,8 @@ void dispatch_backlight(const char*, const char* payload)
 
     // Return the current state
     char topic[10];
-    char buffer[64];
     memcpy_P(topic, PSTR("backlight"), 10);
-    snprintf_P(buffer, sizeof(buffer), PSTR("{\"state\":\"%s\",\"brightness\":%u}"),
-               haspDevice.get_backlight_power() ? "on" : "off", haspDevice.get_backlight_level());
-    dispatch_state_subtopic(topic, buffer);
+    dispatch_state_brightness(topic, (hasp_event_t)haspDevice.get_backlight_power(), haspDevice.get_backlight_level());
 }
 
 void dispatch_web_update(const char*, const char* espOtaUrl)
@@ -955,6 +973,23 @@ void dispatch_current_state()
     dispatch_send_discovery(NULL, NULL);
 }
 
+// Format filesystem and erase EEPROM
+bool dispatch_factory_reset()
+{
+    bool formated = true;
+    bool erased   = true;
+
+#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
+    formated = HASP_FS.format();
+#endif
+
+#if HASP_USE_EEPROM > 0
+    erased = false;
+#endif
+
+    return formated && erased;
+}
+
 void dispatch_calibrate(const char*, const char*)
 {
     guiCalibrate();
diff --git a/src/hasp/hasp_dispatch.h b/src/hasp/hasp_dispatch.h
index fb51d558..d0912870 100644
--- a/src/hasp/hasp_dispatch.h
+++ b/src/hasp/hasp_dispatch.h
@@ -74,11 +74,12 @@ void dispatch_idle(const char*, const char*);
 void dispatch_calibrate(const char*, const char*);
 void dispatch_wakeup(const char*, const char*);
 
-void dispatch_gpio_input_event(uint8_t pin, uint8_t group, uint8_t eventid);
-
 void dispatch_normalized_group_values(hasp_update_value_t& value);
 
 void dispatch_state_subtopic(const char* subtopic, const char* payload);
+void dispatch_state_eventid(const char* topic, hasp_event_t eventid);
+void dispatch_state_brightness(const char* topic, hasp_event_t eventid, int32_t val);
+void dispatch_state_val(const char* topic, hasp_event_t eventid, int32_t val);
 
 void dispatch_config(const char* topic, const char* payload);
 
diff --git a/src/hasp/hasp_event.cpp b/src/hasp/hasp_event.cpp
index 52f46eec..f7a8fb46 100644
--- a/src/hasp/hasp_event.cpp
+++ b/src/hasp/hasp_event.cpp
@@ -245,24 +245,6 @@ static inline void event_update_group(uint8_t group, lv_obj_t* obj, bool power,
     dispatch_normalized_group_values(value);
 }
 
-#if HASP_USE_GPIO > 0
-void event_gpio_input(uint8_t pin, uint8_t eventid)
-{
-    char payload[32];
-    char topic[10];
-    char eventname[8];
-
-    snprintf_P(topic, sizeof(topic), PSTR("input%d"), pin);
-    Parser::get_event_name(eventid, eventname, sizeof(eventname));
-    if(eventid == HASP_EVENT_ON || eventid == HASP_EVENT_OFF) {
-        snprintf_P(payload, sizeof(payload), PSTR("{\"state\":\"%s\"}"), eventname);
-    } else {
-        snprintf_P(payload, sizeof(payload), PSTR("{\"event\":\"%s\"}"), eventname);
-    }
-    dispatch_state_subtopic(topic, payload);
-}
-#endif
-
 static void log_event(const char* name, lv_event_t event)
 {
     return;
diff --git a/src/hasp/hasp_event.h b/src/hasp/hasp_event.h
index 517c83ea..a4c67928 100644
--- a/src/hasp/hasp_event.h
+++ b/src/hasp/hasp_event.h
@@ -26,9 +26,4 @@ void msgbox_event_handler(lv_obj_t* obj, lv_event_t event);
 void cpicker_event_handler(lv_obj_t* obj, lv_event_t event);
 void calendar_event_handler(lv_obj_t* obj, lv_event_t event);
 
-#if HASP_USE_GPIO > 0
-// GPIO event Handler
-void event_gpio_input(uint8_t pin, uint8_t eventid);
-#endif
-
 #endif // HASP_EVENT_H
\ No newline at end of file
diff --git a/src/hasp/lv_theme_hasp.c b/src/hasp/lv_theme_hasp.c
index dcd8211e..27a48adb 100644
--- a/src/hasp/lv_theme_hasp.c
+++ b/src/hasp/lv_theme_hasp.c
@@ -226,8 +226,6 @@ static lv_style_int_t hasp_dpx(lv_style_int_t n)
 static void basic_init(lv_style_int_t border_width, lv_style_int_t outline_width, lv_color_t value_color,
                        lv_color_t color_scr_text)
 {
-    sizeof(lv_style_t);
-
     // Objects with transparent background, like Checkbox, container
     style_init_reset(&styles->transparent);
     lv_style_set_bg_opa(&styles->transparent, LV_STATE_DEFAULT, LV_OPA_TRANSP);
diff --git a/src/sys/gpio/hasp_gpio.cpp b/src/sys/gpio/hasp_gpio.cpp
index dc24cc88..66e20cd0 100644
--- a/src/sys/gpio/hasp_gpio.cpp
+++ b/src/sys/gpio/hasp_gpio.cpp
@@ -38,6 +38,8 @@ hasp_gpio_config_t gpioConfig[HASP_NUM_GPIO_CONFIG] = {
 };
 uint8_t pwm_channel = 1; // Backlight has 0
 
+static inline void gpio_input_event(uint8_t pin, hasp_event_t eventid);
+
 static inline void gpio_update_group(uint8_t group, lv_obj_t* obj, bool power, int32_t val, int32_t min, int32_t max)
 {
     hasp_update_value_t value = {.obj = obj, .group = group, .min = min, .max = max, .val = val, .power = power};
@@ -87,7 +89,7 @@ void gpio_log_serial_dimmer(const char* command)
 static void gpio_event_handler(AceButton* button, uint8_t eventType, uint8_t buttonState)
 {
     uint8_t btnid = button->getId();
-    uint8_t eventid;
+    hasp_event_t eventid;
     bool state = false;
     switch(eventType) {
         case AceButton::kEventPressed:
@@ -125,7 +127,7 @@ static void gpio_event_handler(AceButton* button, uint8_t eventType, uint8_t but
     }
 
     gpioConfig[btnid].power = Parser::get_event_state(eventid);
-    event_gpio_input(gpioConfig[btnid].pin, eventid);
+    gpio_input_event(gpioConfig[btnid].pin, eventid);
 
     // update objects and gpios in this group
     if(gpioConfig[btnid].group && eventid != HASP_EVENT_LONG) // do not repeat DOWN + LONG
@@ -210,27 +212,30 @@ static void gpio_setup_pin(uint8_t index)
             break;
     }
 
-    gpio->power = 1; // on by default, value is set to 0
+    gpio->power = 0; // off by default, value is set to 0
     gpio->max   = 255;
     switch(gpio->type) {
         case hasp_gpio_type_t::SWITCH:
         case hasp_gpio_type_t::BATTERY... hasp_gpio_type_t::WINDOW:
             if(gpio->btn) delete gpio->btn;
-            gpio->btn = new AceButton(&switchConfig, gpio->pin, default_state, index);
-            pinMode(gpio->pin, INPUT_PULLUP);
+            gpio->btn   = new AceButton(&switchConfig, gpio->pin, default_state, index);
+            gpio->power = gpio->btn->isPressedRaw();
+            pinMode(gpio->pin, input_mode);
             gpio->max = 0;
             break;
         case hasp_gpio_type_t::BUTTON:
             if(gpio->btn) delete gpio->btn;
-            gpio->btn = new AceButton(&buttonConfig, gpio->pin, default_state, index);
-            pinMode(gpio->pin, INPUT_PULLUP);
+            gpio->btn   = new AceButton(&buttonConfig, gpio->pin, default_state, index);
+            gpio->power = gpio->btn->isPressedRaw();
+            pinMode(gpio->pin, input_mode);
             gpio->max = 0;
             break;
 #if defined(ARDUINO_ARCH_ESP32)
         case hasp_gpio_type_t::TOUCH:
             if(gpio->btn) delete gpio->btn;
-            gpio->btn = new AceButton(&touchConfig, gpio->pin, HIGH, index);
-            gpio->max = 0;
+            gpio->btn   = new AceButton(&touchConfig, gpio->pin, HIGH, index);
+            gpio->power = gpio->btn->isPressedRaw();
+            gpio->max   = 0;
             // touchAttachInterrupt(gpio->pin, gotTouch, 33);
             break;
 #endif
@@ -238,7 +243,9 @@ static void gpio_setup_pin(uint8_t index)
         case hasp_gpio_type_t::POWER_RELAY:
         case hasp_gpio_type_t::LIGHT_RELAY:
             pinMode(gpio->pin, OUTPUT);
-            gpio->max = 1; // on-off
+            gpio->power = gpio->inverted; // gpio is off, state is set to reflect the true output state of the gpio
+            gpio->max   = 1;              // on-off
+            gpio->val   = gpio->power;
             break;
 
         case hasp_gpio_type_t::PWM:
@@ -277,11 +284,8 @@ static void gpio_setup_pin(uint8_t index)
             Serial1.begin(115200UL, SERIAL_8N1, UART_PIN_NO_CHANGE, gpio->pin,
                           gpio->type == hasp_gpio_type_t::SERIAL_DIMMER_EU); // true = EU, false = AU
             Serial1.flush();
-            //delay(10);
-            //Serial1.print("  ");
             Serial1.write(0x20);
             Serial1.write(0x20);
-           // delay(10);
             Serial1.write((const uint8_t*)command, 8);
 #endif
             gpio_log_serial_dimmer(command);
@@ -353,7 +357,7 @@ void gpioEvery5Seconds(void)
     for(uint8_t i = 0; i < HASP_NUM_GPIO_CONFIG; i++) {
         if(gpio_is_input(&gpioConfig[i])) {
             gpioConfig[i].power = !gpioConfig[i].power;
-            event_gpio_input(gpioConfig[i].pin, gpioConfig[i].power);
+            gpio_input_event(gpioConfig[i].pin, (hasp_event_t)gpioConfig[i].power);
         }
     }
 }
@@ -372,19 +376,37 @@ bool gpio_get_pin_state(uint8_t pin, bool& power, int32_t& val)
     return false;
 }
 
+static inline void gpio_input_event(uint8_t pin, hasp_event_t eventid)
+{
+    char topic[10];
+    snprintf_P(topic, sizeof(topic), PSTR("input%d"), pin);
+    dispatch_state_eventid(topic, eventid);
+}
+
 static inline void gpio_input_state(hasp_gpio_config_t* gpio)
 {
-    event_gpio_input(gpio->pin, gpio->power);
+    gpio_input_event(gpio->pin, (hasp_event_t)gpio->power);
 }
 
 void gpio_output_state(hasp_gpio_config_t* gpio)
 {
-    char payload[32];
     char topic[12];
     snprintf_P(topic, sizeof(topic), PSTR("output%d"), gpio->pin);
-    snprintf_P(payload, sizeof(payload), PSTR("{\"state\":%d,\"val\":%d}"), gpio->power, gpio->val);
 
-    dispatch_state_subtopic(topic, payload);
+    switch(gpio->type) {
+        case LIGHT_RELAY:
+        case POWER_RELAY:
+            dispatch_state_eventid(topic, (hasp_event_t)gpio->power);
+            break;
+        case LED:
+        case SERIAL_DIMMER:
+        case SERIAL_DIMMER_AU:
+        case SERIAL_DIMMER_EU:
+            dispatch_state_brightness(topic, (hasp_event_t)gpio->power, gpio->val);
+            break;
+        default:
+            dispatch_state_val(topic, (hasp_event_t)gpio->power, gpio->val);
+    }
 }
 
 bool gpio_input_pin_state(uint8_t pin)
@@ -615,8 +637,8 @@ bool gpio_set_pin_state(uint8_t pin, bool power, int32_t val)
         return false;
     }
 
-    if(gpio->max == 1) {         // it's a relay
-        gpio->val = gpio->power; // val and power are equal
+    if(gpio->max == 1) { // it's a relay
+        val = power;     // val and power are equal
     }
 
     if(gpio->group) {
diff --git a/src/sys/svc/hasp_http.cpp b/src/sys/svc/hasp_http.cpp
index 0d67aa9b..1031a9e0 100644
--- a/src/sys/svc/hasp_http.cpp
+++ b/src/sys/svc/hasp_http.cpp
@@ -1652,7 +1652,7 @@ void webHandleGpioConfig()
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-void webHandleGpioOptions()
+void webHandleGpioOutput()
 { // http://plate01/config/gpio/options
     if(!httpIsAuthenticated(F("config/gpio/options"))) return;
 
@@ -1673,9 +1673,7 @@ void webHandleGpioOptions()
         httpMessage += config_id;
         httpMessage += F("'>");
 
-        httpMessage += F("<p><b>GPIO Options");
-        httpMessage += config_id;
-        httpMessage += F(" Options</b></p>");
+        httpMessage += F("<p><b>GPIO Output</b></p>");
 
         httpMessage += F("<p><b>" D_GPIO_PIN "</b> <select id='pin' name='pin'>");
         hasp_gpio_config_t conf = gpioGetPinConfig(config_id);
@@ -1782,9 +1780,7 @@ void webHandleGpioInput()
         httpMessage += config_id;
         httpMessage += F("'>");
 
-        httpMessage += F("<p><b>GPIO Options");
-        httpMessage += config_id;
-        httpMessage += F(" Options</b></p>");
+        httpMessage += F("<p><b>GPIO Input</b></p>");
 
         httpMessage += F("<p><b>" D_GPIO_PIN "</b> <select id='pin' name='pin'>");
         hasp_gpio_config_t conf = gpioGetPinConfig(config_id);
@@ -2343,7 +2339,7 @@ void httpSetup()
 #endif
 #if HASP_USE_GPIO > 0
     webServer.on(F("/config/gpio"), webHandleGpioConfig);
-    webServer.on(F("/config/gpio/options"), webHandleGpioOptions);
+    webServer.on(F("/config/gpio/options"), webHandleGpioOutput);
     webServer.on(F("/config/gpio/input"), webHandleGpioInput);
 #endif
     webServer.on(F("/saveConfig"), webHandleSaveConfig);
diff --git a/src/sys/svc/hasp_telnet.cpp b/src/sys/svc/hasp_telnet.cpp
index 523a0a51..dbcd773e 100644
--- a/src/sys/svc/hasp_telnet.cpp
+++ b/src/sys/svc/hasp_telnet.cpp
@@ -318,7 +318,7 @@ IRAM_ATTR void telnetLoop()
         if(telnetConsole) {
             while(telnetConsole->readKey()) {
                 if(!telnetConsole) return;                                        // the telnetConsole was destroyed
-                if(bufferedTelnetClient.peek() < 0) bufferedTelnetClient.flush(); // flush pending updates
+                if(bufferedTelnetClient.available() <= 0) bufferedTelnetClient.flush(); // flush pending updates
             };
 
         } else {