jeans/openHASP
jeans/openHASP
1
0
Fork 0
mirror of https://github.com/HASwitchPlate/openHASP.git synced 2025-07-28 13:46:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update to lvgl 7.6.1

Browse Source
This commit is contained in:
fvanroie 2020-10-12 11:26:47 +02:00
parent c072e87f7e
commit 9e2795600c
14 changed files with 451 additions and 353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
esp32_partition_app1300k_spiffs1216k.csv Normal file
View File

@ -0,0 +1,6 @@
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x160000,
app1, app, ota_1, 0x170000, 0x160000,
spiffs, data, spiffs, 0x2D0000, 0x130000,
1 # Name Type SubType Offset Size Flags
2 nvs data nvs 0x9000 0x5000
3 otadata data ota 0xe000 0x2000
4 app0 app ota_0 0x10000 0x160000
5 app1 app ota_1 0x170000 0x160000
6 spiffs data spiffs 0x2D0000 0x130000

2
include/hasp_conf.h
View File

@ -94,7 +94,7 @@
#include "hasp_spiffs.h" #include "hasp_spiffs.h"
#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
//#include "lv_zifont.h" #include "lv_zifont.h"
#endif #endif
#endif // SPIFFS #endif // SPIFFS

24
lib/lv_lib_zifont/lv_zifont.cpp
View File

@ -78,15 +78,15 @@ static inline bool openFont(File & file, const char * filename)
file = SPIFFS.open(filename, "r"); file = SPIFFS.open(filename, "r");
if(!file) { if(!file) {
// Log.error(F("FONT: %sOpening font: %s"), filename); Log.error(F("FONT: %sOpening font: %s"), filename);
// return false; return false;
} }
return file; return file;
} }
static inline void initCharacterFrame(size_t size) static inline void initCharacterFrame(size_t size)
{ {
if(size > lv_mem_get_size(charBitmap_p)) { if(size > _lv_mem_get_size(charBitmap_p)) {
if(charBitmap_p) lv_mem_free(charBitmap_p); if(charBitmap_p) lv_mem_free(charBitmap_p);
charBitmap_p = (uint8_t *)lv_mem_alloc(size); charBitmap_p = (uint8_t *)lv_mem_alloc(size);
} }
@ -100,14 +100,14 @@ int lv_zifont_font_init(lv_font_t ** font, const char * font_path, uint16_t size
if(!*font) { if(!*font) {
*font = (lv_font_t *)lv_mem_alloc(sizeof(lv_font_t)); *font = (lv_font_t *)lv_mem_alloc(sizeof(lv_font_t));
LV_ASSERT_MEM(*font); LV_ASSERT_MEM(*font);
lv_memset(*font, 0x00, sizeof(lv_font_t)); // lv_mem_alloc might be dirty memset(*font, 0x00, sizeof(lv_font_t)); // lv_mem_alloc might be dirty
} }
lv_font_fmt_zifont_dsc_t * dsc; lv_font_fmt_zifont_dsc_t * dsc;
if(!(*font)->dsc) { if(!(*font)->dsc) {
dsc = (lv_font_fmt_zifont_dsc_t *)lv_mem_alloc(sizeof(lv_font_fmt_zifont_dsc_t)); dsc = (lv_font_fmt_zifont_dsc_t *)lv_mem_alloc(sizeof(lv_font_fmt_zifont_dsc_t));
LV_ASSERT_MEM(dsc); LV_ASSERT_MEM(dsc);
lv_memset(dsc, 0x00, sizeof(lv_font_fmt_zifont_dsc_t)); // lv_mem_alloc might be dirty memset(dsc, 0x00, sizeof(lv_font_fmt_zifont_dsc_t)); // lv_mem_alloc might be dirty
} else { } else {
dsc = (lv_font_fmt_zifont_dsc_t *)(*font)->dsc; dsc = (lv_font_fmt_zifont_dsc_t *)(*font)->dsc;
} }
@ -116,7 +116,7 @@ int lv_zifont_font_init(lv_font_t ** font, const char * font_path, uint16_t size
/* Initialize Last Glyph DSC */ /* Initialize Last Glyph DSC */
dsc->last_glyph_dsc = (lv_zifont_char_t *)lv_mem_alloc(sizeof(lv_zifont_char_t)); dsc->last_glyph_dsc = (lv_zifont_char_t *)lv_mem_alloc(sizeof(lv_zifont_char_t));
lv_memset(dsc->last_glyph_dsc, 0x00, sizeof(lv_zifont_char_t)); // lv_mem_alloc might be dirty memset(dsc->last_glyph_dsc, 0x00, sizeof(lv_zifont_char_t)); // lv_mem_alloc might be dirty
if(dsc->last_glyph_dsc == NULL) return ZIFONT_ERROR_OUT_OF_MEMORY; if(dsc->last_glyph_dsc == NULL) return ZIFONT_ERROR_OUT_OF_MEMORY;
dsc->last_glyph_dsc->width = 0; dsc->last_glyph_dsc->width = 0;
@ -155,8 +155,8 @@ int lv_zifont_font_init(lv_font_t ** font, const char * font_path, uint16_t size
if(!dsc->ascii_glyph_dsc) { if(!dsc->ascii_glyph_dsc) {
dsc->ascii_glyph_dsc = (lv_zifont_char_t *)lv_mem_alloc(sizeof(lv_zifont_char_t) * CHAR_CACHE_SIZE); dsc->ascii_glyph_dsc = (lv_zifont_char_t *)lv_mem_alloc(sizeof(lv_zifont_char_t) * CHAR_CACHE_SIZE);
LV_ASSERT_MEM(dsc->ascii_glyph_dsc); LV_ASSERT_MEM(dsc->ascii_glyph_dsc);
lv_memset(dsc->ascii_glyph_dsc, 0x00, memset(dsc->ascii_glyph_dsc, 0x00,
sizeof(lv_zifont_char_t) * CHAR_CACHE_SIZE); // lv_mem_alloc might be dirty sizeof(lv_zifont_char_t) * CHAR_CACHE_SIZE); // lv_mem_alloc might be dirty
} }
if(dsc->ascii_glyph_dsc == NULL) { if(dsc->ascii_glyph_dsc == NULL) {
file.close(); file.close();
@ -406,8 +406,10 @@ bool IRAM_ATTR lv_font_get_glyph_dsc_fmt_zifont(const lv_font_t * font, lv_font_
uint32_t unicode_letter, uint32_t unicode_letter_next) uint32_t unicode_letter, uint32_t unicode_letter_next)
{ {
/* Only ascii characteres supported for now */ /* Only ascii characteres supported for now */
if(unicode_letter < 0x20) return false; // returning true with a box_h of 0 does not display an error
if(unicode_letter > 0xff && unicode_letter < 0xf000) return false; dsc_out->box_w = dsc_out->box_h = 0; // Prevents glyph not found error messages when true is returned
if(unicode_letter < 0x20) return true;
if(unicode_letter > 0xff && unicode_letter < 0xf000) return true;
// if(unicode_letter > 0xff) Serial.printf("Char# %u\n", unicode_letter); // if(unicode_letter > 0xff) Serial.printf("Char# %u\n", unicode_letter);
// ulong startMillis = millis(); // ulong startMillis = millis();
@ -438,7 +440,7 @@ bool IRAM_ATTR lv_font_get_glyph_dsc_fmt_zifont(const lv_font_t * font, lv_font_
if(unicode_letter >= 0xF000) { if(unicode_letter >= 0xF000) {
char filename[32]; char filename[32];
sprintf_P(filename, PSTR("/fontawesome%u.zi"), fdsc->CharHeight); sprintf_P(filename, PSTR("/fontawesome%u.zi"), fdsc->CharHeight);
if(!openFont(file, filename)) return false; if(!openFont(file, filename)) return true; // suppress glyph not found errors for icon font
} else { } else {
if(!openFont(file, (char *)font->user_data)) return false; if(!openFont(file, (char *)font->user_data)) return false;
} }

2
lib/lvgl

@ -1 +1 @@
Subproject commit ecd0d4fb0907d73e07788283c16e5a4ab1e829b6 Subproject commit d01d1357ad28e10c606b9e426f7fdf0c23b1e5ac

29
platformio.ini
View File

@ -48,11 +48,11 @@ lib_deps =
https://github.com/netwizeBE/TFT_eSPI.git https://github.com/netwizeBE/TFT_eSPI.git
;TFT_eSPI@^2.2.2 ; Tft SPI drivers ;TFT_eSPI@^2.2.2 ; Tft SPI drivers
;TFT_eSPI@^1.4.20 ; Tft SPI drivers ;TFT_eSPI@^1.4.20 ; Tft SPI drivers
PubSubClient@^2.7.0 ; MQTT client PubSubClient@^2.8.0 ; MQTT client
ArduinoJson@^6.15.1,>6.15.0 ; needs at least 6.15.0 ArduinoJson@^6.16.1 ; JSON Parser
StreamUtils@^1.4.0 StreamUtils@^1.4.0
Syslog@^2.0.0 Syslog@^2.0.0
AceButton@^1.4.0 AceButton@^1.6.1
;AsyncTCP ;AsyncTCP
;https://github.com/me-no-dev/ESPAsyncWebServer/archive/master.zip ;https://github.com/me-no-dev/ESPAsyncWebServer/archive/master.zip
;https://github.com/me-no-dev/ESPAsyncTCP/archive/master.zip ;https://github.com/me-no-dev/ESPAsyncTCP/archive/master.zip
@ -129,27 +129,6 @@ hspi32 =
; 7 - mirror content, and rotate 90 deg anti-clockwise ; 7 - mirror content, and rotate 90 deg anti-clockwise
;***************************************************
; D1 Mini ESP32 with Lolin TFT 2.4"
;***************************************************
[env:d1mini32-lolintft24]
platform = espressif32@^1.12.0
board = wemos_d1_mini32
upload_port = COM5 ; To change the port, use platform_override.ini
monitor_port = COM5 ; To change the port, use platform_override.ini
board_build.partitions = default.csv
build_flags =
${flags.esp32_flags}
; -- TFT_eSPI build options ------------------------
${lcd.lolin24}
${pins.vspi32}
-D TFT_DC=5
-D TFT_CS=26
-D TFT_RST=-1 ; RST
-D TFT_BCKL=-1 ; None, configurable via web UI (e.g. 21)
-D TOUCH_CS=17 ; (can also be 22 or 16)
;*************************************************** ;***************************************************
; Lolin D32 Pro with Lolin TFT 2.4" ; Lolin D32 Pro with Lolin TFT 2.4"
;*************************************************** ;***************************************************
@ -159,7 +138,7 @@ platform = espressif32
board = lolin_d32_pro board = lolin_d32_pro
upload_port = COM6 ; To change the port, use platform_override.ini upload_port = COM6 ; To change the port, use platform_override.ini
monitor_port = COM6 ; To change the port, use platform_override.ini monitor_port = COM6 ; To change the port, use platform_override.ini
board_build.partitions = default.csv board_build.partitions = esp32_partition_app1300k_spiffs1216k.csv ; default.csv
build_flags = build_flags =
${flags.esp32_flags} ${flags.esp32_flags}
; -- TFT_eSPI build options ------------------------ ; -- TFT_eSPI build options ------------------------

40
src/hasp.cpp
View File

@ -362,12 +362,24 @@ void haspSetup()
/* ********** Font Initializations ********** */ /* ********** Font Initializations ********** */
defaultFont = LV_FONT_DEFAULT; // Use default font defaultFont = LV_FONT_DEFAULT; // Use default font
#if ESP32
lv_font_t * font_small = defaultFont;
lv_font_t * font_normal = &lv_font_montserrat_12;
lv_font_t * font_subtitle = &lv_font_montserrat_16;
lv_font_t * font_title = &lv_font_montserrat_22;
#else
lv_font_t * font_small = defaultFont;
lv_font_t * font_normal = defaultFont;
lv_font_t * font_subtitle = defaultFont;
lv_font_t * font_title = defaultFont;
#endif
#if HASP_USE_SPIFFS > 0 #if HASP_USE_SPIFFS > 0
#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
lv_zifont_init(); lv_zifont_init();
if(lv_zifont_font_init(&haspFonts[0], haspZiFontPath, 24) != 0) { if(lv_zifont_font_init(&haspFonts[0], haspZiFontPath, 24) != 0) {
Log.error(F("HASP: Failed to set the custom font to %s"), haspZiFontPath); Log.error(F("HASP: Failed to set font to %s"), haspZiFontPath);
} else { } else {
defaultFont = haspFonts[0]; defaultFont = haspFonts[0];
} }
@ -390,14 +402,20 @@ void haspSetup()
#endif #endif
#if(LV_USE_THEME_MONO == 1) || (LV_USE_THEME_EMPTY == 1) #if(LV_USE_THEME_MONO == 1) || (LV_USE_THEME_EMPTY == 1)
case 3: case 3:
th = lv_theme_empty_init(LV_COLOR_PURPLE, LV_COLOR_BLACK, LV_THEME_DEFAULT_FLAGS, defaultFont, defaultFont, th = lv_theme_mono_init(LV_COLOR_PURPLE, LV_COLOR_BLACK, LV_THEME_DEFAULT_FLAGS, font_small, font_normal,
defaultFont, defaultFont); font_subtitle, font_title);
break; break;
#endif #endif
#if LV_USE_THEME_MATERIAL == 1 #if LV_USE_THEME_MATERIAL == 1
case 4: case 4:
th = lv_theme_material_init(LV_COLOR_PURPLE, LV_COLOR_ORANGE, LV_THEME_DEFAULT_FLAGS, defaultFont, th = lv_theme_material_init(LV_COLOR_PURPLE, LV_COLOR_ORANGE,
defaultFont, defaultFont, defaultFont); LV_THEME_MATERIAL_FLAG_LIGHT + LV_THEME_MATERIAL_FLAG_NO_FOCUS, font_small,
font_normal, font_subtitle, font_title);
break;
case 9:
th = lv_theme_material_init(LV_COLOR_PURPLE, LV_COLOR_ORANGE,
LV_THEME_MATERIAL_FLAG_DARK + LV_THEME_MATERIAL_FLAG_NO_FOCUS, font_small,
font_normal, font_subtitle, font_title);
break; break;
#endif #endif
@ -418,8 +436,8 @@ void haspSetup()
#endif #endif
#if(LV_USE_THEME_HASP == 1) || (LV_USE_THEME_TEMPLATE == 1) #if(LV_USE_THEME_HASP == 1) || (LV_USE_THEME_TEMPLATE == 1)
case 8: case 8:
th = lv_theme_template_init(LV_COLOR_PURPLE, LV_COLOR_ORANGE, LV_THEME_DEFAULT_FLAGS, defaultFont, th = lv_theme_template_init(LV_COLOR_PURPLE, LV_COLOR_ORANGE, LV_THEME_DEFAULT_FLAGS, font_small,
defaultFont, defaultFont, defaultFont); font_normal, font_subtitle, font_title);
break; break;
#endif #endif
/* case 0: /* case 0:
@ -431,8 +449,8 @@ void haspSetup()
break; break;
*/ */
default: default:
th = lv_theme_material_init(LV_COLOR_PURPLE, LV_COLOR_ORANGE, LV_THEME_DEFAULT_FLAGS, defaultFont, th = lv_theme_template_init(LV_COLOR_PURPLE, LV_COLOR_ORANGE, LV_THEME_DEFAULT_FLAGS, font_small,
defaultFont, defaultFont, defaultFont); font_normal, font_subtitle, font_title);
Log.error(F("HASP: Unknown theme selected")); Log.error(F("HASP: Unknown theme selected"));
} }
@ -450,13 +468,13 @@ void haspSetup()
lv_style_set_text_font(&pagefont, LV_STATE_DEFAULT, defaultFont); lv_style_set_text_font(&pagefont, LV_STATE_DEFAULT, defaultFont);
list = lv_obj_get_style_list(lv_disp_get_layer_top(NULL), LV_OBJ_PART_MAIN); list = lv_obj_get_style_list(lv_disp_get_layer_top(NULL), LV_OBJ_PART_MAIN);
lv_style_list_add_style(list, &pagefont); _lv_style_list_add_style(list, &pagefont);
/* Create all screens using the theme */ /* Create all screens using the theme */
for(uint8_t i = 0; i < (sizeof pages / sizeof *pages); i++) { for(uint8_t i = 0; i < (sizeof pages / sizeof *pages); i++) {
pages[i] = lv_obj_create(NULL, NULL); pages[i] = lv_obj_create(NULL, NULL);
list = lv_obj_get_style_list(pages[i], LV_OBJ_PART_MAIN); list = lv_obj_get_style_list(pages[i], LV_OBJ_PART_MAIN);
lv_style_list_add_style(list, &pagefont); _lv_style_list_add_style(list, &pagefont);
// lv_obj_set_size(pages[0], hres, vres); // lv_obj_set_size(pages[0], hres, vres);
} }

485
src/hasp_attribute.cpp
View File

@ -11,7 +11,7 @@
LV_FONT_DECLARE(unscii_8_icon); LV_FONT_DECLARE(unscii_8_icon);
extern lv_font_t * haspFonts[8]; extern lv_font_t * haspFonts[8];
static inline bool is_true(const char * s); static bool is_true(const char * s);
static inline bool only_digits(const char * s); static inline bool only_digits(const char * s);
/* 16-bit hashing function http://www.cse.yorku.ca/~oz/hash.html */ /* 16-bit hashing function http://www.cse.yorku.ca/~oz/hash.html */
@ -57,32 +57,32 @@ static lv_color_t haspPayloadToColor(const char * payload)
{ {
switch(strlen(payload)) { switch(strlen(payload)) {
case 3: case 3:
if(!strcmp_P(payload, PSTR("red"))) return haspLogColor(LV_COLOR_RED); if(!strcasecmp_P(payload, PSTR("red"))) return haspLogColor(LV_COLOR_RED);
break; break;
case 4: case 4:
if(!strcmp_P(payload, PSTR("blue"))) return haspLogColor(LV_COLOR_BLUE); if(!strcasecmp_P(payload, PSTR("blue"))) return haspLogColor(LV_COLOR_BLUE);
if(!strcmp_P(payload, PSTR("cyan"))) return haspLogColor(LV_COLOR_CYAN); if(!strcasecmp_P(payload, PSTR("cyan"))) return haspLogColor(LV_COLOR_CYAN);
if(!strcmp_P(payload, PSTR("gray"))) return haspLogColor(LV_COLOR_GRAY); if(!strcasecmp_P(payload, PSTR("gray"))) return haspLogColor(LV_COLOR_GRAY);
/* if(!strcmp_P(payload, PSTR("aqua"))) return haspLogColor(LV_COLOR_AQUA); // if(!strcmp_P(payload, PSTR("aqua"))) return haspLogColor(LV_COLOR_AQUA);
if(!strcmp_P(payload, PSTR("lime"))) return haspLogColor(LV_COLOR_LIME); // if(!strcmp_P(payload, PSTR("lime"))) return haspLogColor(LV_COLOR_LIME);
if(!strcmp_P(payload, PSTR("teal"))) return haspLogColor(LV_COLOR_TEAL); // if(!strcmp_P(payload, PSTR("teal"))) return haspLogColor(LV_COLOR_TEAL);
if(!strcmp_P(payload, PSTR("navy"))) return haspLogColor(LV_COLOR_NAVY);*/ // if(!strcmp_P(payload, PSTR("navy"))) return haspLogColor(LV_COLOR_NAVY);
break; break;
case 5: case 5:
if(!strcmp_P(payload, PSTR("green"))) return haspLogColor(LV_COLOR_GREEN); if(!strcasecmp_P(payload, PSTR("green"))) return haspLogColor(LV_COLOR_GREEN);
if(!strcmp_P(payload, PSTR("white"))) return haspLogColor(LV_COLOR_WHITE); if(!strcasecmp_P(payload, PSTR("white"))) return haspLogColor(LV_COLOR_WHITE);
if(!strcmp_P(payload, PSTR("black"))) return haspLogColor(LV_COLOR_BLACK); if(!strcasecmp_P(payload, PSTR("black"))) return haspLogColor(LV_COLOR_BLACK);
// if(!strcmp_P(payload, PSTR("olive"))) return haspLogColor(LV_COLOR_OLIVE); // if(!strcmp_P(payload, PSTR("olive"))) return haspLogColor(LV_COLOR_OLIVE);
break; break;
case 6: case 6:
if(!strcmp_P(payload, PSTR("yellow"))) return haspLogColor(LV_COLOR_YELLOW); if(!strcasecmp_P(payload, PSTR("yellow"))) return haspLogColor(LV_COLOR_YELLOW);
if(!strcmp_P(payload, PSTR("orange"))) return haspLogColor(LV_COLOR_ORANGE); if(!strcasecmp_P(payload, PSTR("orange"))) return haspLogColor(LV_COLOR_ORANGE);
if(!strcmp_P(payload, PSTR("purple"))) return haspLogColor(LV_COLOR_PURPLE); if(!strcasecmp_P(payload, PSTR("purple"))) return haspLogColor(LV_COLOR_PURPLE);
if(!strcmp_P(payload, PSTR("silver"))) return haspLogColor(LV_COLOR_SILVER); if(!strcasecmp_P(payload, PSTR("silver"))) return haspLogColor(LV_COLOR_SILVER);
// if(!strcmp_P(payload, PSTR("maroon"))) return haspLogColor(LV_COLOR_MAROON); // if(!strcmp_P(payload, PSTR("maroon"))) return haspLogColor(LV_COLOR_MAROON);
break; break;
case 7: case 7:
if(!strcmp_P(payload, PSTR("magenta"))) return haspLogColor(LV_COLOR_MAGENTA); if(!strcasecmp_P(payload, PSTR("magenta"))) return haspLogColor(LV_COLOR_MAGENTA);
default: default:
// if(!strcmp_P(payload, PSTR("darkblue"))) return haspLogColor(LV_COLOR_MAKE(0, 51, 102)); // if(!strcmp_P(payload, PSTR("darkblue"))) return haspLogColor(LV_COLOR_MAKE(0, 51, 102));
@ -118,19 +118,43 @@ static lv_color_t haspPayloadToColor(const char * payload)
return LV_COLOR_BLACK; return LV_COLOR_BLACK;
} }
static lv_font_t * haspPayloadToFont(const char * payload)
{
int16_t var = atoi(payload);
switch(var) {
case 8:
return &unscii_8_icon;
#if ESP32
case 12:
return &lv_font_montserrat_12;
case 16:
return &lv_font_montserrat_16;
case 22:
return &lv_font_montserrat_22;
case 28:
return &lv_font_montserrat_28_compressed;
#endif
default:
return nullptr;
}
}
static void hasp_process_label_long_mode(lv_obj_t * obj, const char * payload, bool update) static void hasp_process_label_long_mode(lv_obj_t * obj, const char * payload, bool update)
{ {
if(update) { if(update) {
lv_label_long_mode_t mode = LV_LABEL_LONG_EXPAND; lv_label_long_mode_t mode = LV_LABEL_LONG_EXPAND;
if(!strcmp_P(payload, PSTR("expand"))) { if(!strcasecmp_P(payload, PSTR("expand"))) {
mode = LV_LABEL_LONG_EXPAND; mode = LV_LABEL_LONG_EXPAND;
} else if(!strcmp_P(payload, PSTR("break"))) { } else if(!strcasecmp_P(payload, PSTR("break"))) {
mode = LV_LABEL_LONG_BREAK; mode = LV_LABEL_LONG_BREAK;
} else if(!strcmp_P(payload, PSTR("dots"))) { } else if(!strcasecmp_P(payload, PSTR("dots"))) {
mode = LV_LABEL_LONG_DOT; mode = LV_LABEL_LONG_DOT;
} else if(!strcmp_P(payload, PSTR("scroll"))) { } else if(!strcasecmp_P(payload, PSTR("scroll"))) {
mode = LV_LABEL_LONG_SROLL; mode = LV_LABEL_LONG_SROLL;
} else if(!strcmp_P(payload, PSTR("loop"))) { } else if(!strcasecmp_P(payload, PSTR("loop"))) {
mode = LV_LABEL_LONG_SROLL_CIRC; mode = LV_LABEL_LONG_SROLL_CIRC;
} else { } else {
return Log.warning(F("Invalid long mode")); return Log.warning(F("Invalid long mode"));
@ -202,60 +226,142 @@ static void hasp_attribute_get_part_state(lv_obj_t * obj, const char * attr_in,
uint8_t & state) uint8_t & state)
{ {
int len = strlen(attr_in); int len = strlen(attr_in);
if(len > 0 && len < 32) { if(len <= 0 || len >= 32) {
// Check Trailing partnumber attr_out[0] = 0; // empty string
if(attr_in[len - 1] == '1') { part = LV_OBJ_PART_MAIN;
part = LV_TABLE_PART_CELL1; state = LV_STATE_DEFAULT;
} else if(attr_in[len - 1] == '2') { return;
part = LV_TABLE_PART_CELL2; }
} else if(attr_in[len - 1] == '3') { int index = atoi(&attr_in[len - 1]);
part = LV_TABLE_PART_CELL3;
} else if(attr_in[len - 1] == '4') {
part = LV_TABLE_PART_CELL4;
}
// Remove Trailing part digit // Drop Trailing partnumber
if(part != LV_TABLE_PART_BG && len > 0) { if(attr_in[len - 1] == '0' || index > 0) {
len--; part = LV_TABLE_PART_BG;
len--;
}
strncpy(attr_out, attr_in, len);
attr_out[len] = 0;
/* Attributes depending on objecttype */
lv_obj_type_t list;
lv_obj_get_type(obj, &list);
const char * objtype = list.type[0];
if(check_obj_type(objtype, LV_HASP_BUTTON)) {
switch(index) {
case 1:
state = LV_BTN_STATE_PRESSED;
break;
case 2:
state = LV_BTN_STATE_DISABLED;
break;
case 3:
state = LV_BTN_STATE_CHECKED_RELEASED;
break;
case 4:
state = LV_BTN_STATE_CHECKED_PRESSED;
break;
case 5:
state = LV_BTN_STATE_CHECKED_DISABLED;
break;
default:
state = LV_BTN_STATE_RELEASED;
} }
strncpy(attr_out, attr_in, len + 1); part = LV_BTN_PART_MAIN;
attr_out[len] = 0; return;
} else { }
attr_out[0] = 0;
if(check_obj_type(objtype, LV_HASP_BAR)) {
if(index == 1) {
part = LV_BAR_PART_INDIC;
} else {
part = LV_BAR_PART_BG;
}
state = LV_STATE_DEFAULT;
return;
}
if(check_obj_type(objtype, LV_HASP_CHECKBOX)) {
if(index == 1) {
part = LV_CHECKBOX_PART_BULLET;
} else {
part = LV_CHECKBOX_PART_BG;
}
state = LV_STATE_DEFAULT;
return;
}
if(check_obj_type(objtype, LV_HASP_CPICKER)) {
if(index == 1) {
part = LV_CPICKER_PART_KNOB;
} else {
part = LV_CPICKER_PART_MAIN;
}
state = LV_STATE_DEFAULT;
return;
} }
} }
/**
* Change or Retrieve the value of a local attribute of an object PART
* @param obj lv_obj_t*: the object to get/set the attribute
* @param attr_p char*: the attribute name (with or without leading ".")
* @param attr_hash uint16_t: the sbdm hash of the attribute name without leading "."
* @param payload char*: the new value of the attribute
* @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, static void hasp_local_style_attr(lv_obj_t * obj, const char * attr_p, uint16_t attr_hash, const char * payload,
bool update) bool update)
{ {
char attr[32]; char attr[32];
uint8_t part = LV_TABLE_PART_BG; uint8_t part = LV_OBJ_PART_MAIN;
uint8_t state = LV_STATE_DEFAULT; uint8_t state = LV_STATE_DEFAULT;
int16_t var = atoi(payload); int16_t var = atoi(payload);
hasp_attribute_get_part_state(obj, attr_p, attr, part, state); hasp_attribute_get_part_state(obj, attr_p, attr, part, state);
attr_hash = sdbm(attr); // attribute name without the index number
/* ***** WARNING **************************************************** /* ***** WARNING ****************************************************
* when using hasp_out use attr_p for the original attribute name * when using hasp_out use attr_p for the original attribute name
* *************************************************************** */ * *************************************************************** */
switch(attr_hash) { 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);
#endif
case ATTR_SIZE:
return attribute_size(obj, part, state, update, attr_p, var);
case ATTR_RADIUS: case ATTR_RADIUS:
return attribute_radius(obj, part, state, update, attr_p, var); return attribute_radius(obj, part, state, update, attr_p, var);
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, attr_p, var);
case ATTR_SIZE:
return attribute_size(obj, part, state, update, attr_p, var);
case ATTR_TRANSFORM_WIDTH:
return lv_obj_set_style_local_transform_width(obj, part, state, (lv_style_int_t)var);
case ATTR_TRANSFORM_HEIGHT:
return lv_obj_set_style_local_transform_height(obj, part, state, (lv_style_int_t)var);
case ATTR_OPA_SCALE: case ATTR_OPA_SCALE:
return lv_obj_set_style_local_opa_scale(obj, part, state, (lv_opa_t)var); return attribute_opa_scale(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_TRANSFORM_WIDTH:
return attribute_transform_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_TRANSFORM_HEIGHT:
return attribute_transform_height(obj, part, state, update, attr_p, (lv_style_int_t)var);
/* Background attributes */ /* Background attributes */
case ATTR_BG_BLEND_MODE:
return attribute_bg_blend_mode(obj, part, state, update, attr_p, (lv_blend_mode_t)var);
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, attr_p, (lv_style_int_t)var);
case ATTR_BG_GRAD_STOP: case ATTR_BG_GRAD_STOP:
@ -276,25 +382,25 @@ static void hasp_local_style_attr(lv_obj_t * obj, const char * attr_p, uint16_t
/* Padding attributes */ /* Padding attributes */
case ATTR_PAD_TOP: case ATTR_PAD_TOP:
return attribute_pad_top(obj, part, state, update, attr_p, (lv_blend_mode_t)var); return attribute_pad_top(obj, part, state, update, attr_p, (lv_style_int_t)var);
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, attr_p, (lv_style_int_t)var);
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, attr_p, (lv_style_int_t)var);
case ATTR_PAD_RIGHT: case ATTR_PAD_RIGHT:
return attribute_pad_right(obj, part, state, update, attr_p, (lv_grad_dir_t)var); return attribute_pad_right(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_PAD_INNER: case ATTR_PAD_INNER:
return attribute_pad_inner(obj, part, state, update, attr_p, (lv_opa_t)var); return attribute_pad_inner(obj, part, state, update, attr_p, (lv_style_int_t)var);
/* Text attributes */ /* Text attributes */
case ATTR_TEXT_LETTER_SPACE: case ATTR_TEXT_LETTER_SPACE:
return lv_obj_set_style_local_text_letter_space(obj, part, state, (lv_style_int_t)var); return attribute_text_letter_space(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_TEXT_LINE_SPACE: case ATTR_TEXT_LINE_SPACE:
return lv_obj_set_style_local_text_line_space(obj, part, state, (lv_style_int_t)var); return attribute_text_line_space(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_TEXT_DECOR: case ATTR_TEXT_DECOR:
return lv_obj_set_style_local_text_decor(obj, part, state, (lv_text_decor_t)var); return attribute_text_decor(obj, part, state, update, attr_p, (lv_text_decor_t)var);
case ATTR_TEXT_BLEND_MODE: case ATTR_TEXT_OPA:
return lv_obj_set_style_local_text_blend_mode(obj, part, state, (lv_blend_mode_t)var); return attribute_text_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_TEXT_COLOR: { case ATTR_TEXT_COLOR: {
lv_color_t color = haspPayloadToColor(payload); lv_color_t color = haspPayloadToColor(payload);
return lv_obj_set_style_local_text_color(obj, part, state, color); return lv_obj_set_style_local_text_color(obj, part, state, color);
@ -303,210 +409,149 @@ static void hasp_local_style_attr(lv_obj_t * obj, const char * attr_p, uint16_t
lv_color_t color = haspPayloadToColor(payload); lv_color_t color = haspPayloadToColor(payload);
return lv_obj_set_style_local_text_sel_color(obj, part, state, color); return lv_obj_set_style_local_text_sel_color(obj, part, state, color);
} }
case ATTR_TEXT_OPA: case ATTR_TEXT_FONT: {
return lv_obj_set_style_local_text_opa(obj, part, state, (lv_opa_t)var); lv_font_t * font = haspPayloadToFont(payload);
if(font) {
return lv_obj_set_style_local_text_font(obj, part, state, font);
} else {
return Log.warning(F("HASP: Unknown Font ID %s"), attr_p);
}
}
/* Border attributes */ /* Border attributes */
case ATTR_BORDER_WIDTH: case ATTR_BORDER_WIDTH:
return lv_obj_set_style_local_border_width(obj, part, state, (lv_style_int_t)var); return attribute_border_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_BORDER_SIDE: case ATTR_BORDER_SIDE:
return lv_obj_set_style_local_border_side(obj, part, state, (lv_border_side_t)var); return attribute_border_side(obj, part, state, update, attr_p, (lv_border_side_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_BORDER_POST: case ATTR_BORDER_POST:
return lv_obj_set_style_local_border_post(obj, part, state, (bool)var); return attribute_border_post(obj, part, state, update, attr_p, is_true(payload));
case ATTR_BORDER_OPA:
return attribute_border_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_BORDER_COLOR: { case ATTR_BORDER_COLOR: {
lv_color_t color = haspPayloadToColor(payload); lv_color_t color = haspPayloadToColor(payload);
return lv_obj_set_style_local_border_color(obj, part, state, color); return lv_obj_set_style_local_border_color(obj, part, state, color);
} }
case ATTR_BORDER_OPA: /* Outline attributes */
return lv_obj_set_style_local_border_opa(obj, part, state, (lv_opa_t)var);
/* Outline attributes */
case ATTR_OUTLINE_WIDTH: case ATTR_OUTLINE_WIDTH:
return lv_obj_set_style_local_outline_width(obj, part, state, (lv_style_int_t)var); return attribute_outline_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_OUTLINE_PAD: case ATTR_OUTLINE_PAD:
return lv_obj_set_style_local_outline_pad(obj, part, state, (lv_style_int_t)var); return attribute_outline_pad(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_OUTLINE_BLEND_MODE: case ATTR_OUTLINE_OPA:
return lv_obj_set_style_local_outline_blend_mode(obj, part, state, (lv_blend_mode_t)var); return attribute_outline_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_OUTLINE_COLOR: { case ATTR_OUTLINE_COLOR: {
lv_color_t color = haspPayloadToColor(payload); lv_color_t color = haspPayloadToColor(payload);
return lv_obj_set_style_local_outline_color(obj, part, state, color); return lv_obj_set_style_local_outline_color(obj, part, state, color);
} }
case ATTR_OUTLINE_OPA:
return lv_obj_set_style_local_outline_opa(obj, part, state, (lv_opa_t)var);
/* Shadow attributes */ /* Shadow attributes */
#if LV_USE_SHADOW
case ATTR_SHADOW_WIDTH: case ATTR_SHADOW_WIDTH:
return lv_obj_set_style_local_shadow_width(obj, part, state, (lv_style_int_t)var); return attribute_shadow_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_SHADOW_OFS_X: case ATTR_SHADOW_OFS_X:
return lv_obj_set_style_local_shadow_ofs_x(obj, part, state, (lv_style_int_t)var); return attribute_shadow_ofs_x(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_SHADOW_OFS_Y: case ATTR_SHADOW_OFS_Y:
return lv_obj_set_style_local_shadow_ofs_y(obj, part, state, (lv_style_int_t)var); return attribute_shadow_ofs_y(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_SHADOW_SPREAD: case ATTR_SHADOW_SPREAD:
return lv_obj_set_style_local_shadow_spread(obj, part, state, (lv_style_int_t)var); return attribute_shadow_spread(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_SHADOW_BLEND_MODE: case ATTR_SHADOW_OPA:
return lv_obj_set_style_local_shadow_blend_mode(obj, part, state, (lv_blend_mode_t)var); return attribute_shadow_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_SHADOW_COLOR: { case ATTR_SHADOW_COLOR: {
lv_color_t color = haspPayloadToColor(payload); lv_color_t color = haspPayloadToColor(payload);
return lv_obj_set_style_local_shadow_color(obj, part, state, color); return lv_obj_set_style_local_shadow_color(obj, part, state, color);
} }
case ATTR_SHADOW_OPA: #endif
return lv_obj_set_style_local_shadow_opa(obj, part, state, (lv_opa_t)var);
/* Line attributes */ /* Line attributes */
case ATTR_LINE_WIDTH: case ATTR_LINE_WIDTH:
return lv_obj_set_style_local_line_width(obj, part, state, (lv_style_int_t)var); return attribute_line_width(obj, part, state, update, attr_p, (lv_style_int_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_LINE_DASH_WIDTH: case ATTR_LINE_DASH_WIDTH:
return lv_obj_set_style_local_line_dash_width(obj, part, state, (lv_style_int_t)var); return attribute_line_dash_width(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_LINE_DASH_GAP: case ATTR_LINE_DASH_GAP:
return lv_obj_set_style_local_line_dash_gap(obj, part, state, (lv_style_int_t)var); return attribute_line_dash_gap(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_LINE_ROUNDED: case ATTR_LINE_ROUNDED:
return lv_obj_set_style_local_line_rounded(obj, part, state, (bool)var); return attribute_line_rounded(obj, part, state, update, attr_p, is_true(payload));
case ATTR_LINE_OPA:
return attribute_line_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_LINE_COLOR: { case ATTR_LINE_COLOR: {
lv_color_t color = haspPayloadToColor(payload); lv_color_t color = haspPayloadToColor(payload);
return lv_obj_set_style_local_line_color(obj, part, state, color); return lv_obj_set_style_local_line_color(obj, part, state, color);
} }
case ATTR_LINE_OPA:
return lv_obj_set_style_local_line_opa(obj, part, state, (lv_opa_t)var);
/* Value attributes */ /* Value attributes */
case ATTR_VALUE_LETTER_SPACE: case ATTR_VALUE_LETTER_SPACE:
return lv_obj_set_style_local_value_letter_space(obj, part, state, (lv_style_int_t)var); return attribute_value_letter_space(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_VALUE_LINE_SPACE: case ATTR_VALUE_LINE_SPACE:
return lv_obj_set_style_local_value_line_space(obj, part, state, (lv_style_int_t)var); return attribute_value_line_space(obj, part, state, update, attr_p, (lv_style_int_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_VALUE_OFS_X: case ATTR_VALUE_OFS_X:
return lv_obj_set_style_local_value_ofs_x(obj, part, state, (lv_style_int_t)var); return attribute_value_ofs_x(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_VALUE_OFS_Y: case ATTR_VALUE_OFS_Y:
return lv_obj_set_style_local_value_ofs_y(obj, part, state, (lv_style_int_t)var); return attribute_value_ofs_y(obj, part, state, update, attr_p, (lv_style_int_t)var);
case ATTR_VALUE_ALIGN: case ATTR_VALUE_ALIGN:
return lv_obj_set_style_local_value_align(obj, part, state, (lv_align_t)var); return attribute_value_align(obj, part, state, update, attr_p, (lv_align_t)var);
case ATTR_VALUE_OPA:
return attribute_value_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_VALUE_STR: {
if(update) {
// Free previous string
const char * str = lv_obj_get_style_value_str(obj, part);
lv_obj_set_style_local_value_str(obj, part, state, NULL);
lv_mem_free(str);
// Create new string
size_t len = strlen(payload);
if(len > 0) {
len++;
char * str_p = (char *)lv_mem_alloc(len);
memset(str_p, 0, len);
memccpy(str_p, payload, 0, len);
lv_obj_set_style_local_value_str(obj, part, state, str_p);
}
} else {
hasp_out_str(obj, attr, lv_obj_get_style_value_str(obj, part));
}
return;
}
case ATTR_VALUE_COLOR: { case ATTR_VALUE_COLOR: {
lv_color_t color = haspPayloadToColor(payload); lv_color_t color = haspPayloadToColor(payload);
return lv_obj_set_style_local_value_color(obj, part, state, color); return lv_obj_set_style_local_value_color(obj, part, state, color);
} }
case ATTR_VALUE_OPA: case ATTR_VALUE_FONT: {
return lv_obj_set_style_local_value_opa(obj, part, state, (lv_opa_t)var); lv_font_t * font = haspPayloadToFont(payload);
case ATTR_VALUE_STR: if(font) {
return lv_obj_set_style_local_value_str(obj, part, state, (const char *)payload); return lv_obj_set_style_local_value_font(obj, part, state, font);
} else {
return Log.warning(F("HASP: Unknown Font ID %s"), attr_p);
}
}
/* Pattern attributes */ /* Pattern attributes */
case ATTR_PATTERN_REPEAT: case ATTR_PATTERN_REPEAT:
return lv_obj_set_style_local_pattern_repeat(obj, part, state, (bool)var); return attribute_pattern_repeat(obj, part, state, update, attr_p, is_true(payload));
case ATTR_PATTERN_BLEND_MODE: case ATTR_PATTERN_OPA:
return lv_obj_set_style_local_pattern_blend_mode(obj, part, state, (lv_blend_mode_t)var); return attribute_pattern_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_PATTERN_RECOLOR_OPA:
return attribute_pattern_recolor_opa(obj, part, state, update, attr_p, (lv_opa_t)var);
case ATTR_PATTERN_IMAGE:
// return lv_obj_set_style_local_pattern_image(obj, part, state, (constvoid *)var);
break;
case ATTR_PATTERN_RECOLOR: { case ATTR_PATTERN_RECOLOR: {
lv_color_t color = haspPayloadToColor(payload); lv_color_t color = haspPayloadToColor(payload);
return lv_obj_set_style_local_pattern_recolor(obj, part, state, color); return lv_obj_set_style_local_pattern_recolor(obj, part, state, color);
} }
case ATTR_PATTERN_OPA:
return lv_obj_set_style_local_pattern_opa(obj, part, state, (lv_opa_t)var); /* Image attributes */
case ATTR_PATTERN_RECOLOR_OPA: // Todo
return lv_obj_set_style_local_pattern_recolor_opa(obj, part, state, (lv_opa_t)var);
case ATTR_PATTERN_IMAGE: /* Scale attributes */
// return lv_obj_set_style_local_pattern_image(obj, part, state, (constvoid *)var); // Todo
break;
/* Transition attributes */
// Todo
} }
Log.warning(F("HASP: Unknown property %s"), attr_p); Log.warning(F("HASP: Unknown property %s"), attr_p);
} }
static void hasp_local_style_attr_font(lv_obj_t * obj, const char * attr_p, uint16_t attr_hash, const char * payload,
bool update)
{
uint8_t part = LV_TABLE_PART_BG;
uint8_t state = LV_STATE_DEFAULT;
int16_t var = atoi(payload);
int len = strlen(attr_p);
if(len > 0 && len < 32) {
// Check Trailing partnumber
if(attr_p[len - 1] == '1') {
part = LV_TABLE_PART_CELL1;
} else if(attr_p[len - 1] == '2') {
part = LV_TABLE_PART_CELL2;
} else if(attr_p[len - 1] == '3') {
part = LV_TABLE_PART_CELL3;
} else if(attr_p[len - 1] == '4') {
part = LV_TABLE_PART_CELL4;
// } else if(attr[len - 1] == '9') {
// part = LV_PAGE_PART_SCROLLBAR;
}
// Remove Trailing part digit
char attr[32];
if(part != LV_TABLE_PART_BG && len > 0) {
len--;
}
strncpy(attr, attr_p, len + 1);
attr[len] = 0;
// debugPrintln(strAttr + "&" + part);
/* ***** WARNING ****************************************************
* when using hasp_out use attr_p for the original attribute name
* *************************************************************** */
if(!strcmp_P(attr, PSTR("value_font"))) {
#if ESP32
switch(var) {
case 8:
lv_obj_set_style_local_value_font(obj, part, state, &unscii_8_icon);
break;
case 12:
lv_obj_set_style_local_value_font(obj, part, state, &lv_font_montserrat_12);
break;
case 16:
lv_obj_set_style_local_value_font(obj, part, state, &lv_font_montserrat_16);
break;
case 22:
lv_obj_set_style_local_value_font(obj, part, state, &lv_font_montserrat_22);
break;
case 28:
lv_obj_set_style_local_value_font(obj, part, state, &lv_font_montserrat_28_compressed);
break;
}
return;
#endif
// return lv_obj_set_style_local_value_font(obj, part, state, (constlv_font_t *)var);
} else if(!strcmp_P(attr, PSTR("text_font"))) {
#if ESP32
switch(var) {
case 0:
lv_obj_set_style_local_text_font(obj, part, state, haspFonts[0]);
Log.verbose(F("Changing font to : %s"), (char *)haspFonts[0]->user_data);
break;
case 8:
lv_obj_set_style_local_text_font(obj, part, state, &unscii_8_icon);
break;
case 12:
lv_obj_set_style_local_text_font(obj, part, state, &lv_font_montserrat_12);
break;
case 16:
lv_obj_set_style_local_text_font(obj, part, state, &lv_font_montserrat_16);
break;
case 22:
lv_obj_set_style_local_text_font(obj, part, state, &lv_font_montserrat_22);
break;
case 28:
lv_obj_set_style_local_text_font(obj, part, state, &lv_font_montserrat_28_compressed);
break;
}
return;
#endif
// return lv_obj_set_style_local_text_font(obj, part, state, (constlv_font_t *)var);
}
}
Log.warning(F("HASP: Unknown property %s"), attr_p);
}
// OK // OK
static void hasp_process_obj_attribute_txt(lv_obj_t * obj, const char * attr, const char * payload, bool update) static void hasp_process_obj_attribute_txt(lv_obj_t * obj, const char * attr, const char * payload, bool update)
{ {
@ -640,8 +685,14 @@ static void hasp_process_obj_attribute_range(lv_obj_t * obj, const char * attr,
} }
} }
// OK /**
// @param update bool: change the value if true, dispatch value if false * Change or Retrieve the value of the attribute of an object
* @param obj lv_obj_t*: the object to get/set the attribute
* @param attr_p char*: the attribute name (with or without leading ".")
* @param payload char*: the new value of the attribute
* @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
*/
void hasp_process_obj_attribute(lv_obj_t * obj, const char * attr_p, const char * payload, bool update) void hasp_process_obj_attribute(lv_obj_t * obj, const char * attr_p, const char * payload, bool update)
{ {
unsigned long start = millis(); unsigned long start = millis();
@ -789,11 +840,9 @@ void hasp_process_obj_attribute(lv_obj_t * obj, const char * attr_p, const char
/* ************************** /* **************************
* Static Inline functions * Static Inline functions
* **************************/ * **************************/
static inline bool is_true(const char * s) static bool is_true(const char * s)
{ {
return (!strcmp_P(s, PSTR("true")) || !strcmp_P(s, PSTR("TRUE")) || !strcmp_P(s, PSTR("True")) || return (!strcasecmp_P(s, PSTR("true")) || !strcasecmp_P(s, PSTR("on")) || !strcasecmp_P(s, PSTR("yes")) ||
!strcmp_P(s, PSTR("on")) || !strcmp_P(s, PSTR("ON")) || !strcmp_P(s, PSTR("On")) ||
!strcmp_P(s, PSTR("yes")) || !strcmp_P(s, PSTR("YES")) || !strcmp_P(s, PSTR("Yes")) ||
!strcmp_P(s, PSTR("1"))); !strcmp_P(s, PSTR("1")));
} }
@ -821,6 +870,13 @@ void inline hasp_out_color(lv_obj_t * obj, const char * attr, lv_color_t color)
hasp_send_obj_attribute_color(obj, attr, color); hasp_send_obj_attribute_color(obj, attr, color);
} }
/**
* Check if an lvgl object typename corresponds to a given HASP object ID
* @param lvobjtype a char* to a string
* @param haspobjtype the HASP object ID to check against
* @return true or false wether the types match
* @note
*/
bool check_obj_type(const char * lvobjtype, lv_hasp_obj_type_t haspobjtype) bool check_obj_type(const char * lvobjtype, lv_hasp_obj_type_t haspobjtype)
{ {
lvobjtype += 3; // skip "lv_" lvobjtype += 3; // skip "lv_"
@ -869,6 +925,13 @@ bool check_obj_type(const char * lvobjtype, lv_hasp_obj_type_t haspobjtype)
} }
} }
/**
* Check if an lvgl objecttype name corresponds to a given HASP object ID
* @param obj an lv_obj_t* of the object to check its type
* @param haspobjtype the HASP object ID to check against
* @return true or false wether the types match
* @note
*/
bool check_obj_type(lv_obj_t * obj, lv_hasp_obj_type_t haspobjtype) bool check_obj_type(lv_obj_t * obj, lv_hasp_obj_type_t haspobjtype)
{ {
lv_obj_type_t list; lv_obj_type_t list;

176
src/hasp_attribute.h
View File

@ -28,8 +28,8 @@ bool check_obj_type(lv_obj_t * obj, lv_hasp_obj_type_t haspobjtype);
if(update) { \ if(update) { \
return lv_obj_set_style_local_##func_name(obj, part, state, (value_type)val); \ return lv_obj_set_style_local_##func_name(obj, part, state, (value_type)val); \
} else { \ } else { \
value_type temp; \ value_type temp = lv_obj_get_style_##func_name(obj, part); \
lv_obj_get_style_local_##func_name(obj, part, state, &temp); \ /*lv_obj_get_style_##func_name(obj, part, state, &temp);*/ \
return hasp_out_int(obj, attr, temp); \ return hasp_out_int(obj, attr, temp); \
} \ } \
} }
@ -45,7 +45,17 @@ _HASP_ATTRIBUTE(PAD_BOTTOM, pad_bottom, lv_style_int_t)
_HASP_ATTRIBUTE(PAD_LEFT, pad_left, lv_style_int_t) _HASP_ATTRIBUTE(PAD_LEFT, pad_left, lv_style_int_t)
_HASP_ATTRIBUTE(PAD_RIGHT, pad_right, lv_style_int_t) _HASP_ATTRIBUTE(PAD_RIGHT, pad_right, lv_style_int_t)
_HASP_ATTRIBUTE(PAD_INNER, pad_inner, lv_style_int_t) _HASP_ATTRIBUTE(PAD_INNER, pad_inner, lv_style_int_t)
#if LV_USE_BLEND_MODES
_HASP_ATTRIBUTE(BG_BLEND_MODE, bg_blend_mode, lv_blend_mode_t) _HASP_ATTRIBUTE(BG_BLEND_MODE, bg_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(BORDER_BLEND_MODE, border_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(OUTLINE_BLEND_MODE, outline_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(SHADOW_BLEND_MODE, shadow_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(PATTERN_BLEND_MODE, pattern_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(VALUE_BLEND_MODE, value_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(TEXT_BLEND_MODE, text_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(LINE_BLEND_MODE, line_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(IMAGE_BLEND_MODE, image_blend_mode, lv_blend_mode_t)
#endif
_HASP_ATTRIBUTE(BG_MAIN_STOP, bg_main_stop, lv_style_int_t) _HASP_ATTRIBUTE(BG_MAIN_STOP, bg_main_stop, lv_style_int_t)
_HASP_ATTRIBUTE(BG_GRAD_STOP, bg_grad_stop, lv_style_int_t) _HASP_ATTRIBUTE(BG_GRAD_STOP, bg_grad_stop, lv_style_int_t)
_HASP_ATTRIBUTE(BG_GRAD_DIR, bg_grad_dir, lv_grad_dir_t) _HASP_ATTRIBUTE(BG_GRAD_DIR, bg_grad_dir, lv_grad_dir_t)
@ -54,31 +64,28 @@ _HASP_ATTRIBUTE(BG_GRAD_DIR, bg_grad_dir, lv_grad_dir_t)
_HASP_ATTRIBUTE(BG_OPA, bg_opa, lv_opa_t) _HASP_ATTRIBUTE(BG_OPA, bg_opa, lv_opa_t)
_HASP_ATTRIBUTE(BORDER_WIDTH, border_width, lv_style_int_t) _HASP_ATTRIBUTE(BORDER_WIDTH, border_width, lv_style_int_t)
_HASP_ATTRIBUTE(BORDER_SIDE, border_side, lv_border_side_t) _HASP_ATTRIBUTE(BORDER_SIDE, border_side, lv_border_side_t)
_HASP_ATTRIBUTE(BORDER_BLEND_MODE, border_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(BORDER_POST, border_post, bool) _HASP_ATTRIBUTE(BORDER_POST, border_post, bool)
//_HASP_ATTRIBUTE(BORDER_COLOR, border_color, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(BORDER_COLOR, border_color, lv_color_t, _color, nonscalar)
_HASP_ATTRIBUTE(BORDER_OPA, border_opa, lv_opa_t) _HASP_ATTRIBUTE(BORDER_OPA, border_opa, lv_opa_t)
_HASP_ATTRIBUTE(OUTLINE_WIDTH, outline_width, lv_style_int_t) _HASP_ATTRIBUTE(OUTLINE_WIDTH, outline_width, lv_style_int_t)
_HASP_ATTRIBUTE(OUTLINE_PAD, outline_pad, lv_style_int_t) _HASP_ATTRIBUTE(OUTLINE_PAD, outline_pad, lv_style_int_t)
_HASP_ATTRIBUTE(OUTLINE_BLEND_MODE, outline_blend_mode, lv_blend_mode_t)
//_HASP_ATTRIBUTE(OUTLINE_COLOR, outline_color, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(OUTLINE_COLOR, outline_color, lv_color_t, _color, nonscalar)
_HASP_ATTRIBUTE(OUTLINE_OPA, outline_opa, lv_opa_t) _HASP_ATTRIBUTE(OUTLINE_OPA, outline_opa, lv_opa_t)
#if LV_USE_SHADOW
_HASP_ATTRIBUTE(SHADOW_WIDTH, shadow_width, lv_style_int_t) _HASP_ATTRIBUTE(SHADOW_WIDTH, shadow_width, lv_style_int_t)
_HASP_ATTRIBUTE(SHADOW_OFS_X, shadow_ofs_x, lv_style_int_t) _HASP_ATTRIBUTE(SHADOW_OFS_X, shadow_ofs_x, lv_style_int_t)
_HASP_ATTRIBUTE(SHADOW_OFS_Y, shadow_ofs_y, lv_style_int_t) _HASP_ATTRIBUTE(SHADOW_OFS_Y, shadow_ofs_y, lv_style_int_t)
_HASP_ATTRIBUTE(SHADOW_SPREAD, shadow_spread, lv_style_int_t) _HASP_ATTRIBUTE(SHADOW_SPREAD, shadow_spread, lv_style_int_t)
_HASP_ATTRIBUTE(SHADOW_BLEND_MODE, shadow_blend_mode, lv_blend_mode_t)
//_HASP_ATTRIBUTE(SHADOW_COLOR, shadow_color, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(SHADOW_COLOR, shadow_color, lv_color_t, _color, nonscalar)
_HASP_ATTRIBUTE(SHADOW_OPA, shadow_opa, lv_opa_t) _HASP_ATTRIBUTE(SHADOW_OPA, shadow_opa, lv_opa_t)
#endif
_HASP_ATTRIBUTE(PATTERN_REPEAT, pattern_repeat, bool) _HASP_ATTRIBUTE(PATTERN_REPEAT, pattern_repeat, bool)
_HASP_ATTRIBUTE(PATTERN_BLEND_MODE, pattern_blend_mode, lv_blend_mode_t)
//_HASP_ATTRIBUTE(PATTERN_RECOLOR, pattern_recolor, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(PATTERN_RECOLOR, pattern_recolor, lv_color_t, _color, nonscalar)
_HASP_ATTRIBUTE(PATTERN_OPA, pattern_opa, lv_opa_t) _HASP_ATTRIBUTE(PATTERN_OPA, pattern_opa, lv_opa_t)
_HASP_ATTRIBUTE(PATTERN_RECOLOR_OPA, pattern_recolor_opa, lv_opa_t) _HASP_ATTRIBUTE(PATTERN_RECOLOR_OPA, pattern_recolor_opa, lv_opa_t)
//_HASP_ATTRIBUTE(PATTERN_IMAGE, pattern_image, const void *, _data_ptr, scalar) //_HASP_ATTRIBUTE(PATTERN_IMAGE, pattern_image, const void *, _data_ptr, scalar)
_HASP_ATTRIBUTE(VALUE_LETTER_SPACE, value_letter_space, lv_style_int_t) _HASP_ATTRIBUTE(VALUE_LETTER_SPACE, value_letter_space, lv_style_int_t)
_HASP_ATTRIBUTE(VALUE_LINE_SPACE, value_line_space, lv_style_int_t) _HASP_ATTRIBUTE(VALUE_LINE_SPACE, value_line_space, lv_style_int_t)
_HASP_ATTRIBUTE(VALUE_BLEND_MODE, value_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(VALUE_OFS_X, value_ofs_x, lv_style_int_t) _HASP_ATTRIBUTE(VALUE_OFS_X, value_ofs_x, lv_style_int_t)
_HASP_ATTRIBUTE(VALUE_OFS_Y, value_ofs_y, lv_style_int_t) _HASP_ATTRIBUTE(VALUE_OFS_Y, value_ofs_y, lv_style_int_t)
_HASP_ATTRIBUTE(VALUE_ALIGN, value_align, lv_align_t) _HASP_ATTRIBUTE(VALUE_ALIGN, value_align, lv_align_t)
@ -89,19 +96,16 @@ _HASP_ATTRIBUTE(VALUE_OPA, value_opa, lv_opa_t)
_HASP_ATTRIBUTE(TEXT_LETTER_SPACE, text_letter_space, lv_style_int_t) _HASP_ATTRIBUTE(TEXT_LETTER_SPACE, text_letter_space, lv_style_int_t)
_HASP_ATTRIBUTE(TEXT_LINE_SPACE, text_line_space, lv_style_int_t) _HASP_ATTRIBUTE(TEXT_LINE_SPACE, text_line_space, lv_style_int_t)
_HASP_ATTRIBUTE(TEXT_DECOR, text_decor, lv_text_decor_t) _HASP_ATTRIBUTE(TEXT_DECOR, text_decor, lv_text_decor_t)
_HASP_ATTRIBUTE(TEXT_BLEND_MODE, text_blend_mode, lv_blend_mode_t)
//_HASP_ATTRIBUTE(TEXT_COLOR, text_color, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(TEXT_COLOR, text_color, lv_color_t, _color, nonscalar)
//_HASP_ATTRIBUTE(TEXT_SEL_COLOR, text_sel_color, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(TEXT_SEL_COLOR, text_sel_color, lv_color_t, _color, nonscalar)
_HASP_ATTRIBUTE(TEXT_OPA, text_opa, lv_opa_t) _HASP_ATTRIBUTE(TEXT_OPA, text_opa, lv_opa_t)
//_HASP_ATTRIBUTE(TEXT_FONT, text_font, const lv_font_t *, _data_ptr, scalar) //_HASP_ATTRIBUTE(TEXT_FONT, text_font, const lv_font_t *, _data_ptr, scalar)
_HASP_ATTRIBUTE(LINE_WIDTH, line_width, lv_style_int_t) _HASP_ATTRIBUTE(LINE_WIDTH, line_width, lv_style_int_t)
_HASP_ATTRIBUTE(LINE_BLEND_MODE, line_blend_mode, lv_blend_mode_t)
_HASP_ATTRIBUTE(LINE_DASH_WIDTH, line_dash_width, lv_style_int_t) _HASP_ATTRIBUTE(LINE_DASH_WIDTH, line_dash_width, lv_style_int_t)
_HASP_ATTRIBUTE(LINE_DASH_GAP, line_dash_gap, lv_style_int_t) _HASP_ATTRIBUTE(LINE_DASH_GAP, line_dash_gap, lv_style_int_t)
_HASP_ATTRIBUTE(LINE_ROUNDED, line_rounded, bool) _HASP_ATTRIBUTE(LINE_ROUNDED, line_rounded, bool)
//_HASP_ATTRIBUTE(LINE_COLOR, line_color, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(LINE_COLOR, line_color, lv_color_t, _color, nonscalar)
_HASP_ATTRIBUTE(LINE_OPA, line_opa, lv_opa_t) _HASP_ATTRIBUTE(LINE_OPA, line_opa, lv_opa_t)
_HASP_ATTRIBUTE(IMAGE_BLEND_MODE, image_blend_mode, lv_blend_mode_t)
//_HASP_ATTRIBUTE(IMAGE_RECOLOR, image_recolor, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(IMAGE_RECOLOR, image_recolor, lv_color_t, _color, nonscalar)
_HASP_ATTRIBUTE(IMAGE_OPA, image_opa, lv_opa_t) _HASP_ATTRIBUTE(IMAGE_OPA, image_opa, lv_opa_t)
_HASP_ATTRIBUTE(IMAGE_RECOLOR_OPA, image_recolor_opa, lv_opa_t) _HASP_ATTRIBUTE(IMAGE_RECOLOR_OPA, image_recolor_opa, lv_opa_t)
@ -122,92 +126,116 @@ _HASP_ATTRIBUTE(SCALE_END_LINE_WIDTH, scale_end_line_width, lv_style_int_t)
//_HASP_ATTRIBUTE(SCALE_END_COLOR, scale_end_color, lv_color_t, _color, nonscalar) //_HASP_ATTRIBUTE(SCALE_END_COLOR, scale_end_color, lv_color_t, _color, nonscalar)
/* attribute hashes */ /* attribute hashes */
/* Object Part Attributes */
#define ATTR_SIZE 16417 #define ATTR_SIZE 16417
#define ATTR_BG_OPA 48966
#define ATTR_RADIUS 20786 #define ATTR_RADIUS 20786
#define ATTR_PAD_TOP 59081
#define ATTR_LINE_OPA 24501
#define ATTR_BG_COLOR 64969
#define ATTR_PAD_LEFT 43123
#define ATTR_TEXT_OPA 37166
#define ATTR_IMAGE_OPA 58140
#define ATTR_OPA_SCALE 64875
#define ATTR_PAD_INNER 9930
#define ATTR_PAD_RIGHT 65104
#define ATTR_BORDER_OPA 2061
#define ATTR_VALUE_OPA 50482
#define ATTR_LINE_WIDTH 25467
#define ATTR_LINE_COLOR 22200
#define ATTR_PAD_BOTTOM 3767
#define ATTR_TEXT_FONT 22465
#define ATTR_VALUE_STR 1091
#define ATTR_SHADOW_OPA 38401
#define ATTR_TEXT_COLOR 23473
#define ATTR_TEXT_DECOR 1971
#define ATTR_BORDER_SIDE 53962
#define ATTR_VALUE_FONT 9405
#define ATTR_CLIP_CORNER 9188 #define ATTR_CLIP_CORNER 9188
#define ATTR_PATTERN_OPA 43633 #define ATTR_OPA_SCALE 64875
#define ATTR_OUTLINE_OPA 23011 #define ATTR_TRANSFORM_HEIGHT 55994
#define ATTR_BORDER_POST 49491 #define ATTR_TRANSFORM_WIDTH 48627
#define ATTR_OUTLINE_PAD 26038
#define ATTR_SCALE_WIDTH 36017 /* Background Attributes */
#define ATTR_BG_OPA 48966
#define ATTR_BG_COLOR 64969
#define ATTR_BG_GRAD_DIR 41782 #define ATTR_BG_GRAD_DIR 41782
#define ATTR_VALUE_ALIGN 27895
#define ATTR_VALUE_COLOR 52661
#define ATTR_BG_GRAD_STOP 4025 #define ATTR_BG_GRAD_STOP 4025
#define ATTR_VALUE_OFS_X 21415
#define ATTR_VALUE_OFS_Y 21416
#define ATTR_BG_MAIN_STOP 63118 #define ATTR_BG_MAIN_STOP 63118
#define ATTR_BORDER_WIDTH 24531
#define ATTR_LINE_ROUNDED 15042
#define ATTR_BORDER_COLOR 21264
#define ATTR_BG_BLEND_MODE 31147 #define ATTR_BG_BLEND_MODE 31147
#define ATTR_BG_GRAD_COLOR 44140 #define ATTR_BG_GRAD_COLOR 44140
#define ATTR_SHADOW_WIDTH 13255
#define ATTR_IMAGE_RECOLOR 52204 /* Padding Attributes */
#define ATTR_SHADOW_COLOR 9988 #define ATTR_PAD_TOP 59081
#define ATTR_LINE_DASH_GAP 49332 #define ATTR_PAD_LEFT 43123
#define ATTR_OUTLINE_WIDTH 9897 #define ATTR_PAD_INNER 9930
#define ATTR_SHADOW_OFS_X 44278 #define ATTR_PAD_RIGHT 65104
#define ATTR_SHADOW_OFS_Y 44279 #define ATTR_PAD_BOTTOM 3767
#define ATTR_PATTERN_IMAGE 61292
#define ATTR_SHADOW_SPREAD 21138 /* Text Attributes */
#define ATTR_OUTLINE_COLOR 6630 #define ATTR_TEXT_OPA 37166
#define ATTR_TEXT_FONT 22465
#define ATTR_TEXT_COLOR 23473
#define ATTR_TEXT_DECOR 1971
#define ATTR_TEXT_LETTER_SPACE 62079
#define ATTR_TEXT_SEL_COLOR 32076 #define ATTR_TEXT_SEL_COLOR 32076
#define ATTR_LINE_DASH_WIDTH 32676
#define ATTR_PATTERN_REPEAT 31338
#define ATTR_LINE_BLEND_MODE 60284
#define ATTR_TEXT_LINE_SPACE 54829 #define ATTR_TEXT_LINE_SPACE 54829
#define ATTR_TEXT_BLEND_MODE 32195 #define ATTR_TEXT_BLEND_MODE 32195
/* Border Attributes */
#define ATTR_BORDER_OPA 2061
#define ATTR_BORDER_SIDE 53962
#define ATTR_BORDER_POST 49491
#define ATTR_BORDER_BLEND_MODE 23844
#define ATTR_BORDER_WIDTH 24531
#define ATTR_BORDER_COLOR 21264
/* Outline Attributes */
#define ATTR_OUTLINE_OPA 23011
#define ATTR_OUTLINE_PAD 26038
#define ATTR_OUTLINE_COLOR 6630
#define ATTR_OUTLINE_BLEND_MODE 25038
#define ATTR_OUTLINE_WIDTH 9897
/* Shadow Attributes */
#define ATTR_SHADOW_OPA 38401
#define ATTR_SHADOW_WIDTH 13255
#define ATTR_SHADOW_OFS_X 44278
#define ATTR_SHADOW_OFS_Y 44279
#define ATTR_SHADOW_SPREAD 21138
#define ATTR_SHADOW_BLEND_MODE 64048
#define ATTR_SHADOW_COLOR 9988
/* Line Attributes */
#define ATTR_LINE_OPA 24501
#define ATTR_LINE_WIDTH 25467
#define ATTR_LINE_COLOR 22200
#define ATTR_LINE_DASH_WIDTH 32676
#define ATTR_LINE_ROUNDED 15042
#define ATTR_LINE_DASH_GAP 49332
#define ATTR_LINE_BLEND_MODE 60284
/* Value Attributes */
#define ATTR_VALUE_OPA 50482
#define ATTR_VALUE_STR 1091
#define ATTR_VALUE_FONT 9405
#define ATTR_VALUE_ALIGN 27895
#define ATTR_VALUE_COLOR 52661
#define ATTR_VALUE_OFS_X 21415
#define ATTR_VALUE_OFS_Y 21416
#define ATTR_VALUE_LINE_SPACE 26921
#define ATTR_VALUE_BLEND_MODE 4287
#define ATTR_VALUE_LETTER_SPACE 51067
/* Pattern attributes */
#define ATTR_PATTERN_BLEND_MODE 43456
#define ATTR_PATTERN_RECOLOR_OPA 35074
#define ATTR_PATTERN_RECOLOR 7745
#define ATTR_PATTERN_REPEAT 31338
#define ATTR_PATTERN_OPA 43633
#define ATTR_PATTERN_IMAGE 61292
#define ATTR_TRANSITION_PROP_1 49343 #define ATTR_TRANSITION_PROP_1 49343
#define ATTR_TRANSITION_PROP_2 49344 #define ATTR_TRANSITION_PROP_2 49344
#define ATTR_SCALE_END_COLOR 44074
#define ATTR_TRANSITION_PROP_3 49345 #define ATTR_TRANSITION_PROP_3 49345
#define ATTR_TRANSFORM_WIDTH 48627
#define ATTR_TRANSITION_PROP_4 49346 #define ATTR_TRANSITION_PROP_4 49346
#define ATTR_TRANSITION_PROP_5 49347 #define ATTR_TRANSITION_PROP_5 49347
#define ATTR_TRANSITION_PROP_6 49348 #define ATTR_TRANSITION_PROP_6 49348
#define ATTR_TRANSITION_TIME 26263 #define ATTR_TRANSITION_TIME 26263
#define ATTR_PATTERN_RECOLOR 7745
#define ATTR_TRANSITION_PATH 43343 #define ATTR_TRANSITION_PATH 43343
#define ATTR_IMAGE_BLEND_MODE 11349
#define ATTR_VALUE_LINE_SPACE 26921
#define ATTR_BORDER_BLEND_MODE 23844
#define ATTR_VALUE_BLEND_MODE 4287
#define ATTR_IMAGE_RECOLOR_OPA 43949
#define ATTR_TRANSITION_DELAY 64537 #define ATTR_TRANSITION_DELAY 64537
#define ATTR_SCALE_GRAD_COLOR 47239
#define ATTR_SHADOW_BLEND_MODE 64048 #define ATTR_IMAGE_OPA 58140
#define ATTR_TRANSFORM_HEIGHT 55994 #define ATTR_IMAGE_RECOLOR 52204
#define ATTR_TEXT_LETTER_SPACE 62079 #define ATTR_IMAGE_BLEND_MODE 11349
#define ATTR_OUTLINE_BLEND_MODE 25038 #define ATTR_IMAGE_RECOLOR_OPA 43949
#define ATTR_PATTERN_BLEND_MODE 43456
#define ATTR_SCALE_BORDER_WIDTH 2440
#define ATTR_VALUE_LETTER_SPACE 51067
#define ATTR_PATTERN_RECOLOR_OPA 35074
#define ATTR_SCALE_END_LINE_WIDTH 30324 #define ATTR_SCALE_END_LINE_WIDTH 30324
#define ATTR_SCALE_END_BORDER_WIDTH 34380 #define ATTR_SCALE_END_BORDER_WIDTH 34380
#define ATTR_SCALE_BORDER_WIDTH 2440
#define ATTR_SCALE_GRAD_COLOR 47239
#define ATTR_SCALE_WIDTH 36017
#define ATTR_SCALE_END_COLOR 44074
/* Object Attributes */
#define ATTR_X 120 #define ATTR_X 120
#define ATTR_Y 121 #define ATTR_Y 121
#define ATTR_W 119 #define ATTR_W 119

7
src/hasp_debug.cpp
View File

@ -71,7 +71,7 @@ Syslog * syslog;
#endif // USE_SYSLOG #endif // USE_SYSLOG
// Serial Settings // Serial Settings
uint8_t serialInputIndex = 0; // Empty buffer uint8_t serialInputIndex = 0; // Empty buffer
char serialInputBuffer[1024]; char serialInputBuffer[1024];
uint16_t debugSerialBaud = SERIAL_SPEED / 10; // Multiplied by 10 uint16_t debugSerialBaud = SERIAL_SPEED / 10; // Multiplied by 10
bool debugSerialStarted = false; bool debugSerialStarted = false;
@ -97,7 +97,8 @@ String debugHaspHeader()
String header((char *)0); String header((char *)0);
header.reserve(256); header.reserve(256);
if(debugAnsiCodes) header += TERM_COLOR_YELLOW; if(debugAnsiCodes) header += TERM_COLOR_YELLOW;
header += F(" _____ _____ _____ _____\r\n" header += F("\r\n"
" _____ _____ _____ _____\r\n"
" | | | _ | __| _ |\r\n" " | | | _ | __| _ |\r\n"
" | | |__ | __|\r\n" " | | |__ | __|\r\n"
" |__|__|__|__|_____|__|\r\n" " |__|__|__|__|_____|__|\r\n"
@ -381,7 +382,7 @@ void debugLvgl(lv_log_level_t level, const char * file, uint32_t line, const cha
void debugLoop() void debugLoop()
{ {
while(Serial.available()) { while(Serial.available()) {
char ch = Serial.read(); char ch = Serial.read();
Serial.print(ch); Serial.print(ch);
if(ch == 13 || ch == 10) { if(ch == 13 || ch == 10) {

18
src/hasp_dispatch.cpp
View File

@ -19,7 +19,7 @@ inline void dispatchPrintln(String header, String & data)
bool isON(const char * payload) bool isON(const char * payload)
{ {
return strcmp_P(payload, PSTR("ON")) == 0; return strcasecmp_P(payload, PSTR("ON")) == 0;
} }
String getOnOff(bool state) String getOnOff(bool state)
@ -362,21 +362,21 @@ void dispatchConfig(const char * topic, const char * payload)
update = true; update = true;
} }
if(strcmp_P(topic, PSTR("debug")) == 0) { if(strcasecmp_P(topic, PSTR("debug")) == 0) {
if(update) if(update)
debugSetConfig(settings); debugSetConfig(settings);
else else
debugGetConfig(settings); debugGetConfig(settings);
} }
else if(strcmp_P(topic, PSTR("gui")) == 0) { else if(strcasecmp_P(topic, PSTR("gui")) == 0) {
if(update) if(update)
guiSetConfig(settings); guiSetConfig(settings);
else else
guiGetConfig(settings); guiGetConfig(settings);
} }
else if(strcmp_P(topic, PSTR("hasp")) == 0) { else if(strcasecmp_P(topic, PSTR("hasp")) == 0) {
if(update) if(update)
haspSetConfig(settings); haspSetConfig(settings);
else else
@ -384,14 +384,14 @@ void dispatchConfig(const char * topic, const char * payload)
} }
#if HASP_USE_WIFI > 0 #if HASP_USE_WIFI > 0
else if(strcmp_P(topic, PSTR("wifi")) == 0) { else if(strcasecmp_P(topic, PSTR("wifi")) == 0) {
if(update) if(update)
wifiSetConfig(settings); wifiSetConfig(settings);
else else
wifiGetConfig(settings); wifiGetConfig(settings);
} }
#if HASP_USE_MQTT > 0 #if HASP_USE_MQTT > 0
else if(strcmp_P(topic, PSTR("mqtt")) == 0) { else if(strcasecmp_P(topic, PSTR("mqtt")) == 0) {
if(update) if(update)
mqttSetConfig(settings); mqttSetConfig(settings);
else else
@ -399,11 +399,11 @@ void dispatchConfig(const char * topic, const char * payload)
} }
#endif #endif
#if HASP_USE_TELNET > 0 #if HASP_USE_TELNET > 0
// else if(strcmp_P(topic, PSTR("telnet")) == 0) // else if(strcasecmp_P(topic, PSTR("telnet")) == 0)
// telnetGetConfig(settings[F("telnet")]); // telnetGetConfig(settings[F("telnet")]);
#endif #endif
#if HASP_USE_MDNS > 0 #if HASP_USE_MDNS > 0
else if(strcmp_P(topic, PSTR("mdns")) == 0) { else if(strcasecmp_P(topic, PSTR("mdns")) == 0) {
if(update) if(update)
mdnsSetConfig(settings); mdnsSetConfig(settings);
else else
@ -411,7 +411,7 @@ void dispatchConfig(const char * topic, const char * payload)
} }
#endif #endif
#if HASP_USE_HTTP > 0 #if HASP_USE_HTTP > 0
else if(strcmp_P(topic, PSTR("http")) == 0) { else if(strcasecmp_P(topic, PSTR("http")) == 0) {
if(update) if(update)
httpSetConfig(settings); httpSetConfig(settings);
else else

5
src/hasp_http.cpp
View File

@ -1286,10 +1286,11 @@ void webHandleHaspConfig()
httpMessage += getOption(3, F("Mono"), themeid == 3); httpMessage += getOption(3, F("Mono"), themeid == 3);
#endif #endif
#if LV_USE_THEME_MATERIAL == 1 #if LV_USE_THEME_MATERIAL == 1
httpMessage += getOption(4, F("Material"), themeid == 4); httpMessage += getOption(4, F("Material Light"), themeid == 4);
httpMessage += getOption(9, F("Material Dark"), themeid == 9);
#endif #endif
#if LV_USE_THEME_ZEN == 1 #if LV_USE_THEME_ZEN == 1
httpMessage += getOption(5, F("Zen"), themeid == 5); // httpMessage += getOption(5, F("Zen"), themeid == 5);
#endif #endif
#if LV_USE_THEME_NEMO == 1 #if LV_USE_THEME_NEMO == 1
httpMessage += getOption(6, F("Nemo"), themeid == 6); httpMessage += getOption(6, F("Nemo"), themeid == 6);

2
src/hasp_mqtt.cpp
View File

@ -303,7 +303,7 @@ static void mqtt_message_cb(char * topic_p, byte * payload, unsigned int length)
} }
// catch a dangling LWT from a previous connection if it appears // catch a dangling LWT from a previous connection if it appears
if(!strcmp_P(topic, PSTR("status")) && !strcmp_P((char *)payload, PSTR("OFF"))) { if(!strcmp_P(topic, PSTR("status")) && !strcasecmp_P((char *)payload, PSTR("OFF"))) {
char topicBuffer[128]; char topicBuffer[128];
snprintf_P(topicBuffer, sizeof(topicBuffer), PSTR("%sstatus"), mqttNodeTopic); snprintf_P(topicBuffer, sizeof(topicBuffer), PSTR("%sstatus"), mqttNodeTopic);
mqttClient.publish(topicBuffer, "ON", true); mqttClient.publish(topicBuffer, "ON", true);

2
src/hasp_telnet.cpp
View File

@ -146,7 +146,7 @@ static void telnetProcessLine()
} }
default: default:
if(telnetInputIndex > 0) { if(telnetInputIndex > 0) {
if(strcmp_P(telnetInputBuffer, PSTR("exit")) == 0) { if(strcasecmp_P(telnetInputBuffer, PSTR("exit")) == 0) {
telnetClientDisconnect(); telnetClientDisconnect();
} else { } else {
dispatchCommand(telnetInputBuffer); dispatchCommand(telnetInputBuffer);

6
user_setups/esp32/d1-mini-esp32_ili9341.ini
View File

@ -8,9 +8,9 @@
[env:d1mini32-lolintft24] [env:d1mini32-lolintft24]
platform = espressif32@^1.12.0 platform = espressif32@^1.12.0
board = wemos_d1_mini32 board = wemos_d1_mini32
upload_port = COM5 ; To change the port, use platform_override.ini upload_port = COM6 ; To change the port, use platform_override.ini
monitor_port = COM5 ; To change the port, use platform_override.ini monitor_port = COM6 ; To change the port, use platform_override.ini
board_build.partitions = default.csv board_build.partitions = esp32_partition_app1300k_spiffs1216k.csv ; default.csv
build_flags = build_flags =
${flags.esp32_flags} ${flags.esp32_flags}
; -- TFT_eSPI build options ------------------------ ; -- TFT_eSPI build options ------------------------