diff --git a/CHANGELOG.md b/CHANGELOG.md
index af9878076..bface1978 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,9 @@ All notable changes to this project will be documented in this file.
 ### Added
 - Command ``SSerialConfig <serialconfig>`` to change Serial Bridge configuration
 
+### Changed
+- LVGL update from 8.0.2 to 8.1.0
+
 ## [10.1.0.2] 20211225
 ### Changed
 - TasmotaSerial library from v3.3.0 to v3.4.0 - reverted (#14153)
diff --git a/lib/libesp32/berry/generate/be_const_strtab.h b/lib/libesp32/berry/generate/be_const_strtab.h
index f7526ea2b..cac9d30c2 100644
--- a/lib/libesp32/berry/generate/be_const_strtab.h
+++ b/lib/libesp32/berry/generate/be_const_strtab.h
@@ -489,6 +489,7 @@ extern const bcstring be_const_str_lv_obj;
 extern const bcstring be_const_str_lv_obj_class;
 extern const bcstring be_const_str_lv_signal_arcs;
 extern const bcstring be_const_str_lv_signal_bars;
+extern const bcstring be_const_str_lv_solidified;
 extern const bcstring be_const_str_lv_wifi_arcs;
 extern const bcstring be_const_str_lv_wifi_arcs_icon;
 extern const bcstring be_const_str_lv_wifi_bars;
diff --git a/lib/libesp32/berry/generate/be_const_strtab_def.h b/lib/libesp32/berry/generate/be_const_strtab_def.h
index f94c50ff5..0b5740a26 100644
--- a/lib/libesp32/berry/generate/be_const_strtab_def.h
+++ b/lib/libesp32/berry/generate/be_const_strtab_def.h
@@ -1,762 +1,763 @@
-be_define_const_str(, "", 2166136261u, 0, 0, &be_const_str_assert);
+be_define_const_str(, "", 2166136261u, 0, 0, NULL);
 be_define_const_str(_X0A, "\n", 252472541u, 0, 1, NULL);
-be_define_const_str(_X20, " ", 621580159u, 0, 1, &be_const_str_allocated);
-be_define_const_str(_X21_X3D, "!=", 2428715011u, 0, 2, NULL);
-be_define_const_str(_X21_X3D_X3D, "!==", 559817114u, 0, 3, &be_const_str_editable);
-be_define_const_str(_X23, "#", 638357778u, 0, 1, &be_const_str_has_arg);
-be_define_const_str(_X23autoexec_X2Ebat, "#autoexec.bat", 3382890497u, 0, 13, &be_const_str___lower__);
-be_define_const_str(_X23autoexec_X2Ebe, "#autoexec.be", 1181757091u, 0, 12, &be_const_str_enabled);
-be_define_const_str(_X23display_X2Eini, "#display.ini", 182218220u, 0, 12, &be_const_str_AudioGeneratorMP3);
-be_define_const_str(_X23init_X2Ebat, "#init.bat", 3297595077u, 0, 9, &be_const_str_set_text);
-be_define_const_str(_X23preinit_X2Ebe, "#preinit.be", 687035716u, 0, 11, &be_const_str_group_def);
-be_define_const_str(_X2502d_X25s_X2502d, "%02d%s%02d", 1587999717u, 0, 10, &be_const_str_is_running);
-be_define_const_str(_X2504d_X2D_X2502d_X2D_X2502dT_X2502d_X3A_X2502d_X3A_X2502d, "%04d-%02d-%02dT%02d:%02d:%02d", 3425528601u, 0, 29, NULL);
-be_define_const_str(_X25s_X2Eautoconf, "%s.autoconf", 3560383524u, 0, 11, &be_const_str_strptime);
-be_define_const_str(_X26lt_X3BError_X3A_X20apply_X20new_X20or_X20remove_X26gt_X3B, "&lt;Error: apply new or remove&gt;", 2855507949u, 0, 34, NULL);
-be_define_const_str(_X26lt_X3BNone_X26gt_X3B, "&lt;None&gt;", 2602165498u, 0, 12, &be_const_str_Restart_X201);
-be_define_const_str(_X28_X29, "()", 685372826u, 0, 2, NULL);
-be_define_const_str(_X2B, "+", 772578730u, 0, 1, &be_const_str_y1);
-be_define_const_str(_X2C, ",", 688690635u, 0, 1, &be_const_str_pc_abs);
-be_define_const_str(_X2D_X2D_X3A_X2D_X2D, "--:--", 1370615441u, 0, 5, &be_const_str_toptr);
-be_define_const_str(_X2E, ".", 722245873u, 0, 1, &be_const_str_collect);
-be_define_const_str(_X2E_X2E, "..", 2748622605u, 0, 2, &be_const_str_SERIAL_7O1);
-be_define_const_str(_X2Eautoconf, ".autoconf", 2524679088u, 0, 9, &be_const_str_get_alternate);
-be_define_const_str(_X2Ebe, ".be", 1325797348u, 0, 3, &be_const_str_height_def);
-be_define_const_str(_X2Ebec, ".bec", 3985273221u, 0, 4, &be_const_str_CFG_X3A_X20multiple_X20autoconf_X20files_X20found_X2C_X20aborting_X20_X28_X27_X25s_X27_X20_X2B_X20_X27_X25s_X27_X29);
-be_define_const_str(_X2Elen, ".len", 850842136u, 0, 4, &be_const_str_digital_write);
-be_define_const_str(_X2Ep, ".p", 1171526419u, 0, 2, NULL);
+be_define_const_str(_X20, " ", 621580159u, 0, 1, &be_const_str__settings_def);
+be_define_const_str(_X21_X3D, "!=", 2428715011u, 0, 2, &be_const_str_i2c_enabled);
+be_define_const_str(_X21_X3D_X3D, "!==", 559817114u, 0, 3, &be_const_str__X3Cfieldset_X3E_X3Cstyle_X3E_X2Ebdis_X7Bbackground_X3A_X23888_X3B_X7D_X2Ebdis_X3Ahover_X7Bbackground_X3A_X23888_X3B_X7D_X3C_X2Fstyle_X3E);
+be_define_const_str(_X23, "#", 638357778u, 0, 1, &be_const_str_cos);
+be_define_const_str(_X23autoexec_X2Ebat, "#autoexec.bat", 3382890497u, 0, 13, &be_const_str_constructor_cb);
+be_define_const_str(_X23autoexec_X2Ebe, "#autoexec.be", 1181757091u, 0, 12, NULL);
+be_define_const_str(_X23display_X2Eini, "#display.ini", 182218220u, 0, 12, &be_const_str__buffer);
+be_define_const_str(_X23init_X2Ebat, "#init.bat", 3297595077u, 0, 9, &be_const_str__X3C_X2Fform_X3E_X3C_X2Fp_X3E);
+be_define_const_str(_X23preinit_X2Ebe, "#preinit.be", 687035716u, 0, 11, &be_const_str_size);
+be_define_const_str(_X2502d_X25s_X2502d, "%02d%s%02d", 1587999717u, 0, 10, &be_const_str_get_option);
+be_define_const_str(_X2504d_X2D_X2502d_X2D_X2502dT_X2502d_X3A_X2502d_X3A_X2502d, "%04d-%02d-%02dT%02d:%02d:%02d", 3425528601u, 0, 29, &be_const_str_base_class);
+be_define_const_str(_X25s_X2Eautoconf, "%s.autoconf", 3560383524u, 0, 11, &be_const_str_CFG_X3A_X20ran_X20_X20);
+be_define_const_str(_X26lt_X3BError_X3A_X20apply_X20new_X20or_X20remove_X26gt_X3B, "&lt;Error: apply new or remove&gt;", 2855507949u, 0, 34, &be_const_str_Auto_X2Dconfiguration);
+be_define_const_str(_X26lt_X3BNone_X26gt_X3B, "&lt;None&gt;", 2602165498u, 0, 12, &be_const_str_remove_rule);
+be_define_const_str(_X28_X29, "()", 685372826u, 0, 2, &be_const_str_closure);
+be_define_const_str(_X2B, "+", 772578730u, 0, 1, &be_const_str_json_append);
+be_define_const_str(_X2C, ",", 688690635u, 0, 1, &be_const_str_begin_multicast);
+be_define_const_str(_X2D_X2D_X3A_X2D_X2D, "--:--", 1370615441u, 0, 5, &be_const_str__X3Cp_X3ECurrent_X20configuration_X3A_X20_X3C_X2Fp_X3E_X3Cp_X3E_X3Cb_X3E_X25s_X3C_X2Fb_X3E_X3C_X2Fp_X3E);
+be_define_const_str(_X2E, ".", 722245873u, 0, 1, NULL);
+be_define_const_str(_X2E_X2E, "..", 2748622605u, 0, 2, NULL);
+be_define_const_str(_X2Eautoconf, ".autoconf", 2524679088u, 0, 9, &be_const_str_CFG_X3A_X20return_code_X3D_X25i);
+be_define_const_str(_X2Ebe, ".be", 1325797348u, 0, 3, &be_const_str_RES_OK);
+be_define_const_str(_X2Ebec, ".bec", 3985273221u, 0, 4, &be_const_str_keys);
+be_define_const_str(_X2Elen, ".len", 850842136u, 0, 4, &be_const_str_send_multicast);
+be_define_const_str(_X2Ep, ".p", 1171526419u, 0, 2, &be_const_str_content_stop);
 be_define_const_str(_X2Ep1, ".p1", 249175686u, 0, 3, NULL);
-be_define_const_str(_X2Ep2, ".p2", 232398067u, 0, 3, &be_const_str__X3Clegend_X3E_X3Cb_X20title_X3D_X27New_X20autoconf_X27_X3E_X26nbsp_X3BSelect_X20new_X20auto_X2Dconfiguration_X3C_X2Fb_X3E_X3C_X2Flegend_X3E);
-be_define_const_str(_X2Esize, ".size", 1965188224u, 0, 5, &be_const_str_RES_OK);
-be_define_const_str(_X2Etapp, ".tapp", 1363391594u, 0, 5, NULL);
-be_define_const_str(_X2Ew, ".w", 1255414514u, 0, 2, &be_const_str_day);
-be_define_const_str(_X2F, "/", 705468254u, 0, 1, &be_const_str_arg_size);
-be_define_const_str(_X2F_X2Eautoconf, "/.autoconf", 2212074393u, 0, 10, &be_const_str_clock_icon);
-be_define_const_str(_X2F_X3Frst_X3D, "/?rst=", 580074707u, 0, 6, &be_const_str_CFG_X3A_X20loaded_X20_X27_X25s_X27);
-be_define_const_str(_X2Fac, "/ac", 3904651978u, 0, 3, &be_const_str_init);
-be_define_const_str(_X3A, ":", 1057798253u, 0, 1, &be_const_str_memory);
-be_define_const_str(_X3C, "<", 957132539u, 0, 1, &be_const_str_MD5);
-be_define_const_str(_X3C_X2Fform_X3E_X3C_X2Fp_X3E, "</form></p>", 3546571739u, 0, 11, &be_const_str_add_cmd);
-be_define_const_str(_X3C_X2Fselect_X3E_X3Cp_X3E_X3C_X2Fp_X3E, "</select><p></p>", 1863865923u, 0, 16, &be_const_str_content_send);
-be_define_const_str(_X3C_X3D, "<=", 2499223986u, 0, 2, &be_const_str__X3E);
-be_define_const_str(_X3Cbutton_X20name_X3D_X27reapply_X27_X20class_X3D_X27button_X20bgrn_X27_X3ERe_X2Dapply_X20current_X20configuration_X3C_X2Fbutton_X3E, "<button name='reapply' class='button bgrn'>Re-apply current configuration</button>", 3147934216u, 0, 82, &be_const_str_compile);
-be_define_const_str(_X3Cbutton_X20name_X3D_X27zipapply_X27_X20class_X3D_X27button_X20bgrn_X27_X3EApply_X20configuration_X3C_X2Fbutton_X3E, "<button name='zipapply' class='button bgrn'>Apply configuration</button>", 1205771629u, 0, 72, &be_const_str_Timer);
-be_define_const_str(_X3Cfieldset_X3E_X3Cstyle_X3E_X2Ebdis_X7Bbackground_X3A_X23888_X3B_X7D_X2Ebdis_X3Ahover_X7Bbackground_X3A_X23888_X3B_X7D_X3C_X2Fstyle_X3E, "<fieldset><style>.bdis{background:#888;}.bdis:hover{background:#888;}</style>", 842307168u, 0, 77, &be_const_str_pi);
-be_define_const_str(_X3Cinstance_X3A_X20_X25s_X28_X25s_X2C_X20_X25s_X2C_X20_X25s_X29, "<instance: %s(%s, %s, %s)", 257363333u, 0, 25, &be_const_str_cb_do_nothing);
-be_define_const_str(_X3Clabel_X3EChoose_X20a_X20device_X20configuration_X3A_X3C_X2Flabel_X3E_X3Cbr_X3E, "<label>Choose a device configuration:</label><br>", 1336654704u, 0, 49, &be_const_str__X3Cp_X3E_X3Csmall_X3E_X26nbsp_X3B_X28This_X20feature_X20requires_X20an_X20internet_X20connection_X29_X3C_X2Fsmall_X3E_X3C_X2Fp_X3E);
-be_define_const_str(_X3Clambda_X3E, "<lambda>", 607256038u, 0, 8, &be_const_str__read);
-be_define_const_str(_X3Clegend_X3E_X3Cb_X20title_X3D_X27Autoconfiguration_X27_X3E_X26nbsp_X3BCurrent_X20auto_X2Dconfiguration_X3C_X2Fb_X3E_X3C_X2Flegend_X3E, "<legend><b title='Autoconfiguration'>&nbsp;Current auto-configuration</b></legend>", 4212500780u, 0, 82, &be_const_str_code);
-be_define_const_str(_X3Clegend_X3E_X3Cb_X20title_X3D_X27New_X20autoconf_X27_X3E_X26nbsp_X3BSelect_X20new_X20auto_X2Dconfiguration_X3C_X2Fb_X3E_X3C_X2Flegend_X3E, "<legend><b title='New autoconf'>&nbsp;Select new auto-configuration</b></legend>", 1926223891u, 0, 80, &be_const_str__end_transmission);
-be_define_const_str(_X3Coption_X20value_X3D_X27_X25s_X27_X3E_X25s_X3C_X2Foption_X3E, "<option value='%s'>%s</option>", 510303524u, 0, 30, NULL);
-be_define_const_str(_X3Coption_X20value_X3D_X27reset_X27_X3E_X26lt_X3BRemove_X20autoconf_X26gt_X3B_X3C_X2Foption_X3E, "<option value='reset'>&lt;Remove autoconf&gt;</option>", 3994619755u, 0, 54, &be_const_str_event_cb);
-be_define_const_str(_X3Cp_X20style_X3D_X27width_X3A340px_X3B_X27_X3E_X3Cb_X3EException_X3A_X3C_X2Fb_X3E_X3Cbr_X3E_X27_X25s_X27_X3Cbr_X3E_X25s_X3C_X2Fp_X3E, "<p style='width:340px;'><b>Exception:</b><br>'%s'<br>%s</p>", 4252565082u, 0, 59, &be_const_str_width_def);
-be_define_const_str(_X3Cp_X3E_X3C_X2Fp_X3E_X3C_X2Ffieldset_X3E_X3Cp_X3E_X3C_X2Fp_X3E, "<p></p></fieldset><p></p>", 2052843416u, 0, 25, &be_const_str_Unknown_X20command);
-be_define_const_str(_X3Cp_X3E_X3Cform_X20id_X3Dac_X20action_X3D_X27ac_X27_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20method_X3D_X27get_X27_X3E_X3Cbutton_X3E_X26_X23129668_X3B_X20Auto_X2Dconfiguration_X3C_X2Fbutton_X3E_X3C_X2Fform_X3E_X3C_X2Fp_X3E, "<p><form id=ac action='ac' style='display: block;' method='get'><button>&#129668; Auto-configuration</button></form></p>", 452285201u, 0, 120, &be_const_str__energy);
-be_define_const_str(_X3Cp_X3E_X3Cform_X20id_X3Dreapply_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20action_X3D_X27_X2Fac_X27_X20method_X3D_X27post_X27_X20, "<p><form id=reapply style='display: block;' action='/ac' method='post' ", 546993478u, 0, 71, &be_const_str_concat);
-be_define_const_str(_X3Cp_X3E_X3Cform_X20id_X3Dzip_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20action_X3D_X27_X2Fac_X27_X20method_X3D_X27post_X27_X20, "<p><form id=zip style='display: block;' action='/ac' method='post' ", 4033622166u, 0, 67, NULL);
-be_define_const_str(_X3Cp_X3E_X3Csmall_X3E_X26nbsp_X3B_X28This_X20feature_X20requires_X20an_X20internet_X20connection_X29_X3C_X2Fsmall_X3E_X3C_X2Fp_X3E, "<p><small>&nbsp;(This feature requires an internet connection)</small></p>", 2719266486u, 0, 74, &be_const_str_color);
-be_define_const_str(_X3Cp_X3ECurrent_X20configuration_X3A_X20_X3C_X2Fp_X3E_X3Cp_X3E_X3Cb_X3E_X25s_X3C_X2Fb_X3E_X3C_X2Fp_X3E, "<p>Current configuration: </p><p><b>%s</b></p>", 4115655761u, 0, 46, &be_const_str_static);
-be_define_const_str(_X3Cselect_X20name_X3D_X27zip_X27_X3E, "<select name='zip'>", 4247924536u, 0, 19, &be_const_str_arg_X20must_X20be_X20a_X20subclass_X20of_X20lv_obj);
-be_define_const_str(_X3D, "=", 940354920u, 0, 1, &be_const_str_gamma);
-be_define_const_str(_X3D_X3C_X3E_X21, "=<>!", 2664470277u, 0, 4, &be_const_str_tcpclient);
-be_define_const_str(_X3D_X3D, "==", 2431966415u, 0, 2, &be_const_str__t);
-be_define_const_str(_X3E, ">", 990687777u, 0, 1, NULL);
-be_define_const_str(_X3E_X3D, ">=", 284975636u, 0, 2, &be_const_str_get_object_from_ptr);
-be_define_const_str(_X3F, "?", 973910158u, 0, 1, &be_const_str_I2C_Driver);
-be_define_const_str(AES_GCM, "AES_GCM", 3832208678u, 0, 7, &be_const_str_energy_struct);
-be_define_const_str(AXP192, "AXP192", 757230128u, 0, 6, &be_const_str_autoexec);
-be_define_const_str(Animate_X20pc_X20is_X20out_X20of_X20range, "Animate pc is out of range", 1854929421u, 0, 26, &be_const_str_signal_arcs);
-be_define_const_str(AudioFileSource, "AudioFileSource", 2959980058u, 0, 15, &be_const_str_tasmota_X2Eset_light_X28_X29_X20is_X20deprecated_X2C_X20use_X20light_X2Eset_X28_X29);
-be_define_const_str(AudioFileSourceFS, "AudioFileSourceFS", 1839147653u, 0, 17, NULL);
-be_define_const_str(AudioGenerator, "AudioGenerator", 1839297342u, 0, 14, &be_const_str_tomap);
-be_define_const_str(AudioGeneratorMP3, "AudioGeneratorMP3", 2199818488u, 0, 17, &be_const_str_gamma10);
-be_define_const_str(AudioGeneratorWAV, "AudioGeneratorWAV", 2746509368u, 0, 17, &be_const_str_exp);
-be_define_const_str(AudioOutput, "AudioOutput", 3257792048u, 0, 11, &be_const_str_set_timer);
-be_define_const_str(AudioOutputI2S, "AudioOutputI2S", 638031784u, 0, 14, &be_const_str__global_addr);
-be_define_const_str(Auto_X2Dconfiguration, "Auto-configuration", 1665006109u, 0, 18, &be_const_str_matrix);
-be_define_const_str(BRY_X3A_X20ERROR_X2C_X20bad_X20json_X3A_X20, "BRY: ERROR, bad json: ", 2715135809u, 0, 22, &be_const_str_delay);
-be_define_const_str(BRY_X3A_X20Exception_X3E_X20_X27_X25s_X27_X20_X2D_X20_X25s, "BRY: Exception> '%s' - %s", 2246990964u, 0, 25, NULL);
-be_define_const_str(BRY_X3A_X20could_X20not_X20save_X20compiled_X20file_X20_X25s_X20_X28_X25s_X29, "BRY: could not save compiled file %s (%s)", 736659787u, 0, 41, &be_const_str_CFG_X3A_X20downloading_X20_X27_X25s_X27);
-be_define_const_str(BRY_X3A_X20failed_X20to_X20load_X20_persist_X2Ejson, "BRY: failed to load _persist.json", 2991913445u, 0, 33, NULL);
-be_define_const_str(BUTTON_CONFIGURATION, "BUTTON_CONFIGURATION", 70820856u, 0, 20, &be_const_str_hour);
-be_define_const_str(CFG_X3A_X20_X27init_X2Ebat_X27_X20done_X2C_X20restarting, "CFG: 'init.bat' done, restarting", 1569670677u, 0, 32, &be_const_str__drivers);
-be_define_const_str(CFG_X3A_X20Exception_X3E_X20_X27_X25s_X27_X20_X2D_X20_X25s, "CFG: Exception> '%s' - %s", 1228874553u, 0, 25, &be_const_str_create_custom_widget);
-be_define_const_str(CFG_X3A_X20could_X20not_X20run_X20_X25s_X20_X28_X25s_X20_X2D_X20_X25s_X29, "CFG: could not run %s (%s - %s)", 1428829580u, 0, 31, &be_const_str_to_gamma);
-be_define_const_str(CFG_X3A_X20downloading_X20_X27_X25s_X27, "CFG: downloading '%s'", 589480701u, 0, 21, &be_const_str__debug_present);
-be_define_const_str(CFG_X3A_X20exception_X20_X27_X25s_X27_X20_X2D_X20_X27_X25s_X27, "CFG: exception '%s' - '%s'", 4095407913u, 0, 26, &be_const_str_is_dirty);
-be_define_const_str(CFG_X3A_X20loaded_X20_X20, "CFG: loaded  ", 3710273538u, 0, 13, &be_const_str_asin);
-be_define_const_str(CFG_X3A_X20loaded_X20_X27_X25s_X27, "CFG: loaded '%s'", 1699028828u, 0, 16, &be_const_str_clear_first_time);
-be_define_const_str(CFG_X3A_X20loading_X20, "CFG: loading ", 4010361503u, 0, 13, &be_const_str_point);
-be_define_const_str(CFG_X3A_X20loading_X20_X27_X25s_X27, "CFG: loading '%s'", 2285306097u, 0, 17, &be_const_str_get_width);
-be_define_const_str(CFG_X3A_X20multiple_X20autoconf_X20files_X20found_X2C_X20aborting_X20_X28_X27_X25s_X27_X20_X2B_X20_X27_X25s_X27_X29, "CFG: multiple autoconf files found, aborting ('%s' + '%s')", 197663371u, 0, 58, &be_const_str_line_dsc);
-be_define_const_str(CFG_X3A_X20no_X20_X27_X2A_X2Eautoconf_X27_X20file_X20found, "CFG: no '*.autoconf' file found", 127493957u, 0, 31, NULL);
-be_define_const_str(CFG_X3A_X20ran_X20_X20, "CFG: ran  ", 3579570472u, 0, 10, &be_const_str_web_add_main_button);
-be_define_const_str(CFG_X3A_X20removed_X20file_X20_X27_X25s_X27, "CFG: removed file '%s'", 2048602473u, 0, 22, &be_const_str_remove_cmd);
-be_define_const_str(CFG_X3A_X20removing_X20autoconf_X20files, "CFG: removing autoconf files", 4014704970u, 0, 28, &be_const_str_SERIAL_5N2);
-be_define_const_str(CFG_X3A_X20removing_X20first_X20time_X20marker, "CFG: removing first time marker", 2125556683u, 0, 31, &be_const_str_SK6812_GRBW);
-be_define_const_str(CFG_X3A_X20return_code_X3D_X25i, "CFG: return_code=%i", 2059897320u, 0, 19, &be_const_str_lv_module_init);
-be_define_const_str(CFG_X3A_X20running_X20, "CFG: running ", 2478334534u, 0, 13, &be_const_str__available);
-be_define_const_str(CFG_X3A_X20skipping_X20_X27display_X2Eini_X27_X20because_X20already_X20present_X20in_X20file_X2Dsystem, "CFG: skipping 'display.ini' because already present in file-system", 3965549264u, 0, 66, NULL);
-be_define_const_str(COLOR_BLACK, "COLOR_BLACK", 264427940u, 0, 11, &be_const_str_finish);
-be_define_const_str(COLOR_WHITE, "COLOR_WHITE", 2536871270u, 0, 11, &be_const_str_TAP_X3A_X20found_X20Tasmota_X20App_X20_X27_X25s_X27);
-be_define_const_str(EC_C25519, "EC_C25519", 95492591u, 0, 9, &be_const_str__filename);
-be_define_const_str(EVENT_DRAW_MAIN, "EVENT_DRAW_MAIN", 1955620614u, 0, 15, &be_const_str_False);
-be_define_const_str(EVENT_DRAW_PART_BEGIN, "EVENT_DRAW_PART_BEGIN", 3391865024u, 0, 21, &be_const_str__X7Bs_X7DBatt_X20Current_X7Bm_X7D_X25_X2E1f_X20mA_X7Be_X7D);
-be_define_const_str(EVENT_DRAW_PART_END, "EVENT_DRAW_PART_END", 3301625292u, 0, 19, &be_const_str_SERIAL_7E2);
-be_define_const_str(False, "False", 2541049336u, 0, 5, &be_const_str__lvgl);
-be_define_const_str(GET, "GET", 2531704439u, 0, 3, &be_const_str_classof);
-be_define_const_str(HTTP_GET, "HTTP_GET", 1722467738u, 0, 8, &be_const_str_SERIAL_7E1);
-be_define_const_str(HTTP_POST, "HTTP_POST", 1999554144u, 0, 9, &be_const_str_loop);
-be_define_const_str(I2C_X3A, "I2C:", 813483371u, 0, 4, NULL);
-be_define_const_str(I2C_Driver, "I2C_Driver", 1714501658u, 0, 10, &be_const_str_get_percentage);
-be_define_const_str(LVG_X3A_X20call_X20to_X20unsupported_X20callback, "LVG: call to unsupported callback", 504176819u, 0, 33, NULL);
-be_define_const_str(Leds, "Leds", 2709245275u, 0, 4, &be_const_str_map);
-be_define_const_str(MD5, "MD5", 1935726387u, 0, 3, &be_const_str_read_bytes);
-be_define_const_str(None, "None", 810547195u, 0, 4, NULL);
-be_define_const_str(OPTION_A, "OPTION_A", 1133299440u, 0, 8, &be_const_str_add);
-be_define_const_str(OneWire, "OneWire", 2298990722u, 0, 7, &be_const_str_bus);
-be_define_const_str(PART_MAIN, "PART_MAIN", 2473491508u, 0, 9, &be_const_str_persist_X2E_p_X20is_X20not_X20a_X20map);
-be_define_const_str(POST, "POST", 1929554311u, 0, 4, &be_const_str_add_header);
-be_define_const_str(Parameter_X20error, "Parameter error", 3840042038u, 0, 15, &be_const_str_super);
-be_define_const_str(RES_OK, "RES_OK", 1233817284u, 0, 6, &be_const_str_add_handler);
-be_define_const_str(Restart_X201, "Restart 1", 3504455855u, 0, 9, &be_const_str_def);
-be_define_const_str(SERIAL_5E1, "SERIAL_5E1", 1163775235u, 0, 10, NULL);
-be_define_const_str(SERIAL_5E2, "SERIAL_5E2", 1180552854u, 0, 10, &be_const_str_get_pixel_color);
-be_define_const_str(SERIAL_5N1, "SERIAL_5N1", 3313031680u, 0, 10, &be_const_str_exec_tele);
-be_define_const_str(SERIAL_5N2, "SERIAL_5N2", 3363364537u, 0, 10, &be_const_str_pc_rel);
-be_define_const_str(SERIAL_5O1, "SERIAL_5O1", 3782657917u, 0, 10, NULL);
+be_define_const_str(_X2Ep2, ".p2", 232398067u, 0, 3, &be_const_str_GET);
+be_define_const_str(_X2Esize, ".size", 1965188224u, 0, 5, &be_const_str__X3D);
+be_define_const_str(_X2Etapp, ".tapp", 1363391594u, 0, 5, &be_const_str__X3Clegend_X3E_X3Cb_X20title_X3D_X27Autoconfiguration_X27_X3E_X26nbsp_X3BCurrent_X20auto_X2Dconfiguration_X3C_X2Fb_X3E_X3C_X2Flegend_X3E);
+be_define_const_str(_X2Ew, ".w", 1255414514u, 0, 2, &be_const_str_event_send);
+be_define_const_str(_X2F, "/", 705468254u, 0, 1, &be_const_str_setitem);
+be_define_const_str(_X2F_X2Eautoconf, "/.autoconf", 2212074393u, 0, 10, &be_const_str_BRY_X3A_X20ERROR_X2C_X20bad_X20json_X3A_X20);
+be_define_const_str(_X2F_X3Frst_X3D, "/?rst=", 580074707u, 0, 6, &be_const_str_cb_event_closure);
+be_define_const_str(_X2Fac, "/ac", 3904651978u, 0, 3, &be_const_str__anonymous_);
+be_define_const_str(_X3A, ":", 1057798253u, 0, 1, &be_const_str_BRY_X3A_X20could_X20not_X20save_X20compiled_X20file_X20_X25s_X20_X28_X25s_X29);
+be_define_const_str(_X3C, "<", 957132539u, 0, 1, &be_const_str_readline);
+be_define_const_str(_X3C_X2Fform_X3E_X3C_X2Fp_X3E, "</form></p>", 3546571739u, 0, 11, &be_const_str_autorun);
+be_define_const_str(_X3C_X2Fselect_X3E_X3Cp_X3E_X3C_X2Fp_X3E, "</select><p></p>", 1863865923u, 0, 16, &be_const_str_add_rule);
+be_define_const_str(_X3C_X3D, "<=", 2499223986u, 0, 2, &be_const_str_asstring);
+be_define_const_str(_X3Cbutton_X20name_X3D_X27reapply_X27_X20class_X3D_X27button_X20bgrn_X27_X3ERe_X2Dapply_X20current_X20configuration_X3C_X2Fbutton_X3E, "<button name='reapply' class='button bgrn'>Re-apply current configuration</button>", 3147934216u, 0, 82, &be_const_str__X3Cp_X3E_X3Cform_X20id_X3Dreapply_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20action_X3D_X27_X2Fac_X27_X20method_X3D_X27post_X27_X20);
+be_define_const_str(_X3Cbutton_X20name_X3D_X27zipapply_X27_X20class_X3D_X27button_X20bgrn_X27_X3EApply_X20configuration_X3C_X2Fbutton_X3E, "<button name='zipapply' class='button bgrn'>Apply configuration</button>", 1205771629u, 0, 72, NULL);
+be_define_const_str(_X3Cfieldset_X3E_X3Cstyle_X3E_X2Ebdis_X7Bbackground_X3A_X23888_X3B_X7D_X2Ebdis_X3Ahover_X7Bbackground_X3A_X23888_X3B_X7D_X3C_X2Fstyle_X3E, "<fieldset><style>.bdis{background:#888;}.bdis:hover{background:#888;}</style>", 842307168u, 0, 77, &be_const_str_SERIAL_6E1);
+be_define_const_str(_X3Cinstance_X3A_X20_X25s_X28_X25s_X2C_X20_X25s_X2C_X20_X25s_X29, "<instance: %s(%s, %s, %s)", 257363333u, 0, 25, &be_const_str_editable);
+be_define_const_str(_X3Clabel_X3EChoose_X20a_X20device_X20configuration_X3A_X3C_X2Flabel_X3E_X3Cbr_X3E, "<label>Choose a device configuration:</label><br>", 1336654704u, 0, 49, &be_const_str_sys);
+be_define_const_str(_X3Clambda_X3E, "<lambda>", 607256038u, 0, 8, &be_const_str_SERIAL_7E2);
+be_define_const_str(_X3Clegend_X3E_X3Cb_X20title_X3D_X27Autoconfiguration_X27_X3E_X26nbsp_X3BCurrent_X20auto_X2Dconfiguration_X3C_X2Fb_X3E_X3C_X2Flegend_X3E, "<legend><b title='Autoconfiguration'>&nbsp;Current auto-configuration</b></legend>", 4212500780u, 0, 82, &be_const_str_Unknown_X20command);
+be_define_const_str(_X3Clegend_X3E_X3Cb_X20title_X3D_X27New_X20autoconf_X27_X3E_X26nbsp_X3BSelect_X20new_X20auto_X2Dconfiguration_X3C_X2Fb_X3E_X3C_X2Flegend_X3E, "<legend><b title='New autoconf'>&nbsp;Select new auto-configuration</b></legend>", 1926223891u, 0, 80, &be_const_str_SERIAL_6E2);
+be_define_const_str(_X3Coption_X20value_X3D_X27_X25s_X27_X3E_X25s_X3C_X2Foption_X3E, "<option value='%s'>%s</option>", 510303524u, 0, 30, &be_const_str_AudioOutput);
+be_define_const_str(_X3Coption_X20value_X3D_X27reset_X27_X3E_X26lt_X3BRemove_X20autoconf_X26gt_X3B_X3C_X2Foption_X3E, "<option value='reset'>&lt;Remove autoconf&gt;</option>", 3994619755u, 0, 54, &be_const_str_add_driver);
+be_define_const_str(_X3Cp_X20style_X3D_X27width_X3A340px_X3B_X27_X3E_X3Cb_X3EException_X3A_X3C_X2Fb_X3E_X3Cbr_X3E_X27_X25s_X27_X3Cbr_X3E_X25s_X3C_X2Fp_X3E, "<p style='width:340px;'><b>Exception:</b><br>'%s'<br>%s</p>", 4252565082u, 0, 59, &be_const_str_widget_width_def);
+be_define_const_str(_X3Cp_X3E_X3C_X2Fp_X3E_X3C_X2Ffieldset_X3E_X3Cp_X3E_X3C_X2Fp_X3E, "<p></p></fieldset><p></p>", 2052843416u, 0, 25, &be_const_str_find_op);
+be_define_const_str(_X3Cp_X3E_X3Cform_X20id_X3Dac_X20action_X3D_X27ac_X27_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20method_X3D_X27get_X27_X3E_X3Cbutton_X3E_X26_X23129668_X3B_X20Auto_X2Dconfiguration_X3C_X2Fbutton_X3E_X3C_X2Fform_X3E_X3C_X2Fp_X3E, "<p><form id=ac action='ac' style='display: block;' method='get'><button>&#129668; Auto-configuration</button></form></p>", 452285201u, 0, 120, &be_const_str_CFG_X3A_X20loading_X20);
+be_define_const_str(_X3Cp_X3E_X3Cform_X20id_X3Dreapply_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20action_X3D_X27_X2Fac_X27_X20method_X3D_X27post_X27_X20, "<p><form id=reapply style='display: block;' action='/ac' method='post' ", 546993478u, 0, 71, &be_const_str_OPTION_A);
+be_define_const_str(_X3Cp_X3E_X3Cform_X20id_X3Dzip_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20action_X3D_X27_X2Fac_X27_X20method_X3D_X27post_X27_X20, "<p><form id=zip style='display: block;' action='/ac' method='post' ", 4033622166u, 0, 67, &be_const_str__X3Cp_X3E_X3Csmall_X3E_X26nbsp_X3B_X28This_X20feature_X20requires_X20an_X20internet_X20connection_X29_X3C_X2Fsmall_X3E_X3C_X2Fp_X3E);
+be_define_const_str(_X3Cp_X3E_X3Csmall_X3E_X26nbsp_X3B_X28This_X20feature_X20requires_X20an_X20internet_X20connection_X29_X3C_X2Fsmall_X3E_X3C_X2Fp_X3E, "<p><small>&nbsp;(This feature requires an internet connection)</small></p>", 2719266486u, 0, 74, &be_const_str_count);
+be_define_const_str(_X3Cp_X3ECurrent_X20configuration_X3A_X20_X3C_X2Fp_X3E_X3Cp_X3E_X3Cb_X3E_X25s_X3C_X2Fb_X3E_X3C_X2Fp_X3E, "<p>Current configuration: </p><p><b>%s</b></p>", 4115655761u, 0, 46, &be_const_str_widget_dtor_cb);
+be_define_const_str(_X3Cselect_X20name_X3D_X27zip_X27_X3E, "<select name='zip'>", 4247924536u, 0, 19, &be_const_str_check_privileged_access);
+be_define_const_str(_X3D, "=", 940354920u, 0, 1, &be_const_str_WS2812_GRB);
+be_define_const_str(_X3D_X3C_X3E_X21, "=<>!", 2664470277u, 0, 4, &be_const_str_SERIAL_7E1);
+be_define_const_str(_X3D_X3D, "==", 2431966415u, 0, 2, &be_const_str_True);
+be_define_const_str(_X3E, ">", 990687777u, 0, 1, &be_const_str_arg_size);
+be_define_const_str(_X3E_X3D, ">=", 284975636u, 0, 2, &be_const_str_members);
+be_define_const_str(_X3F, "?", 973910158u, 0, 1, &be_const_str_SERIAL_6N2);
+be_define_const_str(AES_GCM, "AES_GCM", 3832208678u, 0, 7, &be_const_str_CFG_X3A_X20removing_X20autoconf_X20files);
+be_define_const_str(AXP192, "AXP192", 757230128u, 0, 6, &be_const_str__timers);
+be_define_const_str(Animate_X20pc_X20is_X20out_X20of_X20range, "Animate pc is out of range", 1854929421u, 0, 26, &be_const_str_depower);
+be_define_const_str(AudioFileSource, "AudioFileSource", 2959980058u, 0, 15, &be_const_str_digital_read);
+be_define_const_str(AudioFileSourceFS, "AudioFileSourceFS", 1839147653u, 0, 17, &be_const_str_arg_name);
+be_define_const_str(AudioGenerator, "AudioGenerator", 1839297342u, 0, 14, &be_const_str_cb);
+be_define_const_str(AudioGeneratorMP3, "AudioGeneratorMP3", 2199818488u, 0, 17, &be_const_str__request_from);
+be_define_const_str(AudioGeneratorWAV, "AudioGeneratorWAV", 2746509368u, 0, 17, &be_const_str_get_switch);
+be_define_const_str(AudioOutput, "AudioOutput", 3257792048u, 0, 11, &be_const_str_CFG_X3A_X20running_X20);
+be_define_const_str(AudioOutputI2S, "AudioOutputI2S", 638031784u, 0, 14, &be_const_str_gamma);
+be_define_const_str(Auto_X2Dconfiguration, "Auto-configuration", 1665006109u, 0, 18, &be_const_str_animators);
+be_define_const_str(BRY_X3A_X20ERROR_X2C_X20bad_X20json_X3A_X20, "BRY: ERROR, bad json: ", 2715135809u, 0, 22, &be_const_str_gc);
+be_define_const_str(BRY_X3A_X20Exception_X3E_X20_X27_X25s_X27_X20_X2D_X20_X25s, "BRY: Exception> '%s' - %s", 2246990964u, 0, 25, &be_const_str_encrypt);
+be_define_const_str(BRY_X3A_X20could_X20not_X20save_X20compiled_X20file_X20_X25s_X20_X28_X25s_X29, "BRY: could not save compiled file %s (%s)", 736659787u, 0, 41, &be_const_str_member);
+be_define_const_str(BRY_X3A_X20failed_X20to_X20load_X20_persist_X2Ejson, "BRY: failed to load _persist.json", 2991913445u, 0, 33, &be_const_str_atan);
+be_define_const_str(BUTTON_CONFIGURATION, "BUTTON_CONFIGURATION", 70820856u, 0, 20, &be_const_str_COLOR_BLACK);
+be_define_const_str(CFG_X3A_X20_X27init_X2Ebat_X27_X20done_X2C_X20restarting, "CFG: 'init.bat' done, restarting", 1569670677u, 0, 32, NULL);
+be_define_const_str(CFG_X3A_X20Exception_X3E_X20_X27_X25s_X27_X20_X2D_X20_X25s, "CFG: Exception> '%s' - %s", 1228874553u, 0, 25, &be_const_str_get_string);
+be_define_const_str(CFG_X3A_X20could_X20not_X20run_X20_X25s_X20_X28_X25s_X20_X2D_X20_X25s_X29, "CFG: could not run %s (%s - %s)", 1428829580u, 0, 31, &be_const_str_lv_event);
+be_define_const_str(CFG_X3A_X20downloading_X20_X27_X25s_X27, "CFG: downloading '%s'", 589480701u, 0, 21, &be_const_str__rules);
+be_define_const_str(CFG_X3A_X20exception_X20_X27_X25s_X27_X20_X2D_X20_X27_X25s_X27, "CFG: exception '%s' - '%s'", 4095407913u, 0, 26, &be_const_str_strftime);
+be_define_const_str(CFG_X3A_X20loaded_X20_X20, "CFG: loaded  ", 3710273538u, 0, 13, &be_const_str_get_light);
+be_define_const_str(CFG_X3A_X20loaded_X20_X27_X25s_X27, "CFG: loaded '%s'", 1699028828u, 0, 16, NULL);
+be_define_const_str(CFG_X3A_X20loading_X20, "CFG: loading ", 4010361503u, 0, 13, &be_const_str_CFG_X3A_X20removed_X20file_X20_X27_X25s_X27);
+be_define_const_str(CFG_X3A_X20loading_X20_X27_X25s_X27, "CFG: loading '%s'", 2285306097u, 0, 17, &be_const_str_has);
+be_define_const_str(CFG_X3A_X20multiple_X20autoconf_X20files_X20found_X2C_X20aborting_X20_X28_X27_X25s_X27_X20_X2B_X20_X27_X25s_X27_X29, "CFG: multiple autoconf files found, aborting ('%s' + '%s')", 197663371u, 0, 58, &be_const_str_SERIAL_6N1);
+be_define_const_str(CFG_X3A_X20no_X20_X27_X2A_X2Eautoconf_X27_X20file_X20found, "CFG: no '*.autoconf' file found", 127493957u, 0, 31, &be_const_str_acos);
+be_define_const_str(CFG_X3A_X20ran_X20_X20, "CFG: ran  ", 3579570472u, 0, 10, &be_const_str_ceil);
+be_define_const_str(CFG_X3A_X20removed_X20file_X20_X27_X25s_X27, "CFG: removed file '%s'", 2048602473u, 0, 22, &be_const_str_duration);
+be_define_const_str(CFG_X3A_X20removing_X20autoconf_X20files, "CFG: removing autoconf files", 4014704970u, 0, 28, &be_const_str_instance);
+be_define_const_str(CFG_X3A_X20removing_X20first_X20time_X20marker, "CFG: removing first time marker", 2125556683u, 0, 31, NULL);
+be_define_const_str(CFG_X3A_X20return_code_X3D_X25i, "CFG: return_code=%i", 2059897320u, 0, 19, &be_const_str_lv_signal_arcs);
+be_define_const_str(CFG_X3A_X20running_X20, "CFG: running ", 2478334534u, 0, 13, NULL);
+be_define_const_str(CFG_X3A_X20skipping_X20_X27display_X2Eini_X27_X20because_X20already_X20present_X20in_X20file_X2Dsystem, "CFG: skipping 'display.ini' because already present in file-system", 3965549264u, 0, 66, &be_const_str_k);
+be_define_const_str(COLOR_BLACK, "COLOR_BLACK", 264427940u, 0, 11, &be_const_str_isinstance);
+be_define_const_str(COLOR_WHITE, "COLOR_WHITE", 2536871270u, 0, 11, &be_const_str_is_dirty);
+be_define_const_str(EC_C25519, "EC_C25519", 95492591u, 0, 9, NULL);
+be_define_const_str(EVENT_DRAW_MAIN, "EVENT_DRAW_MAIN", 1955620614u, 0, 15, &be_const_str__energy);
+be_define_const_str(EVENT_DRAW_PART_BEGIN, "EVENT_DRAW_PART_BEGIN", 3391865024u, 0, 21, &be_const_str_SERIAL_7N1);
+be_define_const_str(EVENT_DRAW_PART_END, "EVENT_DRAW_PART_END", 3301625292u, 0, 19, &be_const_str_get_bat_charge_current);
+be_define_const_str(False, "False", 2541049336u, 0, 5, &be_const_str_codedump);
+be_define_const_str(GET, "GET", 2531704439u, 0, 3, NULL);
+be_define_const_str(HTTP_GET, "HTTP_GET", 1722467738u, 0, 8, &be_const_str_WS2812);
+be_define_const_str(HTTP_POST, "HTTP_POST", 1999554144u, 0, 9, &be_const_str_run);
+be_define_const_str(I2C_X3A, "I2C:", 813483371u, 0, 4, &be_const_str__available);
+be_define_const_str(I2C_Driver, "I2C_Driver", 1714501658u, 0, 10, &be_const_str_web_add_management_button);
+be_define_const_str(LVG_X3A_X20call_X20to_X20unsupported_X20callback, "LVG: call to unsupported callback", 504176819u, 0, 33, &be_const_str_flush);
+be_define_const_str(Leds, "Leds", 2709245275u, 0, 4, &be_const_str_content_start);
+be_define_const_str(MD5, "MD5", 1935726387u, 0, 3, &be_const_str_Tele);
+be_define_const_str(None, "None", 810547195u, 0, 4, &be_const_str_SERIAL_5E1);
+be_define_const_str(OPTION_A, "OPTION_A", 1133299440u, 0, 8, &be_const_str_clear);
+be_define_const_str(OneWire, "OneWire", 2298990722u, 0, 7, NULL);
+be_define_const_str(PART_MAIN, "PART_MAIN", 2473491508u, 0, 9, &be_const_str_create_custom_widget);
+be_define_const_str(POST, "POST", 1929554311u, 0, 4, NULL);
+be_define_const_str(Parameter_X20error, "Parameter error", 3840042038u, 0, 15, NULL);
+be_define_const_str(RES_OK, "RES_OK", 1233817284u, 0, 6, &be_const_str_widget_dtor_impl);
+be_define_const_str(Restart_X201, "Restart 1", 3504455855u, 0, 9, NULL);
+be_define_const_str(SERIAL_5E1, "SERIAL_5E1", 1163775235u, 0, 10, &be_const_str_draw_line_dsc);
+be_define_const_str(SERIAL_5E2, "SERIAL_5E2", 1180552854u, 0, 10, &be_const_str_no_X20GPIO_X20specified_X20for_X20neopixelbus);
+be_define_const_str(SERIAL_5N1, "SERIAL_5N1", 3313031680u, 0, 10, NULL);
+be_define_const_str(SERIAL_5N2, "SERIAL_5N2", 3363364537u, 0, 10, &be_const_str_stop);
+be_define_const_str(SERIAL_5O1, "SERIAL_5O1", 3782657917u, 0, 10, &be_const_str_upper);
 be_define_const_str(SERIAL_5O2, "SERIAL_5O2", 3732325060u, 0, 10, NULL);
-be_define_const_str(SERIAL_6E1, "SERIAL_6E1", 334249486u, 0, 10, NULL);
-be_define_const_str(SERIAL_6E2, "SERIAL_6E2", 317471867u, 0, 10, &be_const_str_can_show);
-be_define_const_str(SERIAL_6N1, "SERIAL_6N1", 198895701u, 0, 10, NULL);
-be_define_const_str(SERIAL_6N2, "SERIAL_6N2", 148562844u, 0, 10, &be_const_str_duration);
-be_define_const_str(SERIAL_6O1, "SERIAL_6O1", 266153272u, 0, 10, &be_const_str_get_current_module_path);
-be_define_const_str(SERIAL_6O2, "SERIAL_6O2", 316486129u, 0, 10, &be_const_str_find_op);
-be_define_const_str(SERIAL_7E1, "SERIAL_7E1", 147718061u, 0, 10, &be_const_str__cmd);
-be_define_const_str(SERIAL_7E2, "SERIAL_7E2", 97385204u, 0, 10, &be_const_str_fromptr);
-be_define_const_str(SERIAL_7N1, "SERIAL_7N1", 1891060246u, 0, 10, &be_const_str_class_init_obj);
-be_define_const_str(SERIAL_7N2, "SERIAL_7N2", 1874282627u, 0, 10, &be_const_str_instance_size);
-be_define_const_str(SERIAL_7O1, "SERIAL_7O1", 1823802675u, 0, 10, &be_const_str__ccmd);
-be_define_const_str(SERIAL_7O2, "SERIAL_7O2", 1840580294u, 0, 10, &be_const_str__write);
-be_define_const_str(SERIAL_8E1, "SERIAL_8E1", 2371121616u, 0, 10, &be_const_str_resp_cmnd_failed);
-be_define_const_str(SERIAL_8E2, "SERIAL_8E2", 2421454473u, 0, 10, &be_const_str_readline);
-be_define_const_str(SERIAL_8N1, "SERIAL_8N1", 2369297235u, 0, 10, &be_const_str_counters);
-be_define_const_str(SERIAL_8N2, "SERIAL_8N2", 2386074854u, 0, 10, &be_const_str_set_dc_voltage);
-be_define_const_str(SERIAL_8O1, "SERIAL_8O1", 289122742u, 0, 10, &be_const_str_classname);
-be_define_const_str(SERIAL_8O2, "SERIAL_8O2", 272345123u, 0, 10, &be_const_str_rule);
-be_define_const_str(SK6812_GRBW, "SK6812_GRBW", 81157857u, 0, 11, &be_const_str_atan2);
-be_define_const_str(STATE_DEFAULT, "STATE_DEFAULT", 712406428u, 0, 13, &be_const_str_isinstance);
-be_define_const_str(TAP_X3A_X20found_X20Tasmota_X20App_X20_X27_X25s_X27, "TAP: found Tasmota App '%s'", 2643152398u, 0, 27, &be_const_str_file_X20extension_X20is_X20not_X20_X27_X2Ebe_X27_X20or_X20_X27_X2Ebec_X27);
-be_define_const_str(Tasmota, "Tasmota", 4047617668u, 0, 7, NULL);
-be_define_const_str(Tele, "Tele", 1329980653u, 0, 4, &be_const_str_call_native);
-be_define_const_str(Timer, "Timer", 3948127682u, 0, 5, &be_const_str_set_useragent);
-be_define_const_str(True, "True", 3453902341u, 0, 4, &be_const_str_draw_line_dsc);
-be_define_const_str(Unknown_X20command, "Unknown command", 1830905432u, 0, 15, &be_const_str_set_power);
-be_define_const_str(WS2812, "WS2812", 3539741218u, 0, 6, &be_const_str_round_start);
-be_define_const_str(WS2812_GRB, "WS2812_GRB", 1736405692u, 0, 10, &be_const_str__class);
-be_define_const_str(Wire, "Wire", 1938276536u, 0, 4, &be_const_str_zip);
-be_define_const_str(_X5B, "[", 3725336506u, 0, 1, &be_const_str_content_stop);
-be_define_const_str(_X5D, "]", 3624670792u, 0, 1, NULL);
-be_define_const_str(_, "_", 3658226030u, 0, 1, NULL);
-be_define_const_str(__iterator__, "__iterator__", 3884039703u, 0, 12, &be_const_str_get_bat_power);
-be_define_const_str(__lower__, "__lower__", 123855590u, 0, 9, &be_const_str_resolvecmnd);
+be_define_const_str(SERIAL_6E1, "SERIAL_6E1", 334249486u, 0, 10, &be_const_str_is_first_time);
+be_define_const_str(SERIAL_6E2, "SERIAL_6E2", 317471867u, 0, 10, &be_const_str_rule);
+be_define_const_str(SERIAL_6N1, "SERIAL_6N1", 198895701u, 0, 10, &be_const_str_input);
+be_define_const_str(SERIAL_6N2, "SERIAL_6N2", 148562844u, 0, 10, &be_const_str_add_header);
+be_define_const_str(SERIAL_6O1, "SERIAL_6O1", 266153272u, 0, 10, &be_const_str_running);
+be_define_const_str(SERIAL_6O2, "SERIAL_6O2", 316486129u, 0, 10, &be_const_str_tostring);
+be_define_const_str(SERIAL_7E1, "SERIAL_7E1", 147718061u, 0, 10, &be_const_str_set_height);
+be_define_const_str(SERIAL_7E2, "SERIAL_7E2", 97385204u, 0, 10, &be_const_str_path);
+be_define_const_str(SERIAL_7N1, "SERIAL_7N1", 1891060246u, 0, 10, NULL);
+be_define_const_str(SERIAL_7N2, "SERIAL_7N2", 1874282627u, 0, 10, &be_const_str_call_native);
+be_define_const_str(SERIAL_7O1, "SERIAL_7O1", 1823802675u, 0, 10, &be_const_str_dirty);
+be_define_const_str(SERIAL_7O2, "SERIAL_7O2", 1840580294u, 0, 10, &be_const_str_var);
+be_define_const_str(SERIAL_8E1, "SERIAL_8E1", 2371121616u, 0, 10, NULL);
+be_define_const_str(SERIAL_8E2, "SERIAL_8E2", 2421454473u, 0, 10, &be_const_str_create_matrix);
+be_define_const_str(SERIAL_8N1, "SERIAL_8N1", 2369297235u, 0, 10, &be_const_str_remove);
+be_define_const_str(SERIAL_8N2, "SERIAL_8N2", 2386074854u, 0, 10, NULL);
+be_define_const_str(SERIAL_8O1, "SERIAL_8O1", 289122742u, 0, 10, &be_const_str_a);
+be_define_const_str(SERIAL_8O2, "SERIAL_8O2", 272345123u, 0, 10, &be_const_str_digital_write);
+be_define_const_str(SK6812_GRBW, "SK6812_GRBW", 81157857u, 0, 11, &be_const_str_v);
+be_define_const_str(STATE_DEFAULT, "STATE_DEFAULT", 712406428u, 0, 13, &be_const_str__);
+be_define_const_str(TAP_X3A_X20found_X20Tasmota_X20App_X20_X27_X25s_X27, "TAP: found Tasmota App '%s'", 2643152398u, 0, 27, &be_const_str_set_alternate);
+be_define_const_str(Tasmota, "Tasmota", 4047617668u, 0, 7, &be_const_str__X5D);
+be_define_const_str(Tele, "Tele", 1329980653u, 0, 4, &be_const_str_read13);
+be_define_const_str(Timer, "Timer", 3948127682u, 0, 5, &be_const_str_web_send_decimal);
+be_define_const_str(True, "True", 3453902341u, 0, 4, &be_const_str_ins_time);
+be_define_const_str(Unknown_X20command, "Unknown command", 1830905432u, 0, 15, &be_const_str_add_anim);
+be_define_const_str(WS2812, "WS2812", 3539741218u, 0, 6, &be_const_str_deinit);
+be_define_const_str(WS2812_GRB, "WS2812_GRB", 1736405692u, 0, 10, NULL);
+be_define_const_str(Wire, "Wire", 1938276536u, 0, 4, &be_const_str_bytes);
+be_define_const_str(_X5B, "[", 3725336506u, 0, 1, NULL);
+be_define_const_str(_X5D, "]", 3624670792u, 0, 1, &be_const_str_color);
+be_define_const_str(_, "_", 3658226030u, 0, 1, &be_const_str_files);
+be_define_const_str(__iterator__, "__iterator__", 3884039703u, 0, 12, NULL);
+be_define_const_str(__lower__, "__lower__", 123855590u, 0, 9, &be_const_str_counters);
 be_define_const_str(__upper__, "__upper__", 3612202883u, 0, 9, NULL);
 be_define_const_str(_anonymous_, "_anonymous_", 1957281476u, 0, 11, NULL);
-be_define_const_str(_archive, "_archive", 4004559404u, 0, 8, &be_const_str_getbits);
-be_define_const_str(_available, "_available", 1306196581u, 0, 10, NULL);
-be_define_const_str(_begin_transmission, "_begin_transmission", 2779461176u, 0, 19, &be_const_str_type);
-be_define_const_str(_buffer, "_buffer", 2044888568u, 0, 7, &be_const_str_animate);
-be_define_const_str(_ccmd, "_ccmd", 2163421413u, 0, 5, &be_const_str_arch);
-be_define_const_str(_class, "_class", 2732146350u, 0, 6, &be_const_str_udp);
-be_define_const_str(_cmd, "_cmd", 3419822142u, 0, 4, NULL);
-be_define_const_str(_debug_present, "_debug_present", 4063411725u, 0, 14, &be_const_str_asstring);
-be_define_const_str(_def, "_def", 1985022181u, 0, 4, &be_const_str_page_autoconf_ctl);
-be_define_const_str(_dirty, "_dirty", 283846766u, 0, 6, &be_const_str_find);
-be_define_const_str(_drivers, "_drivers", 3260328985u, 0, 8, &be_const_str_exec_rules);
-be_define_const_str(_end_transmission, "_end_transmission", 3237480400u, 0, 17, &be_const_str_obj_class_create_obj);
-be_define_const_str(_energy, "_energy", 535372070u, 0, 7, NULL);
-be_define_const_str(_error, "_error", 1132109656u, 0, 6, &be_const_str_ctypes_bytes_dyn);
-be_define_const_str(_filename, "_filename", 1430813195u, 0, 9, &be_const_str_leds);
-be_define_const_str(_global_addr, "_global_addr", 533766721u, 0, 12, NULL);
-be_define_const_str(_global_def, "_global_def", 646007001u, 0, 11, NULL);
-be_define_const_str(_lvgl, "_lvgl", 2689219483u, 0, 5, &be_const_str_set_style_bg_color);
-be_define_const_str(_p, "_p", 1594591802u, 0, 2, &be_const_str_pixel_size);
-be_define_const_str(_persist_X2Ejson, "_persist.json", 2008425138u, 0, 13, &be_const_str_path);
-be_define_const_str(_ptr, "_ptr", 306235816u, 0, 4, &be_const_str_arg);
-be_define_const_str(_read, "_read", 346717030u, 0, 5, &be_const_str_cb_event_closure);
+be_define_const_str(_archive, "_archive", 4004559404u, 0, 8, NULL);
+be_define_const_str(_available, "_available", 1306196581u, 0, 10, &be_const_str_srand);
+be_define_const_str(_begin_transmission, "_begin_transmission", 2779461176u, 0, 19, &be_const_str_cb_do_nothing);
+be_define_const_str(_buffer, "_buffer", 2044888568u, 0, 7, NULL);
+be_define_const_str(_ccmd, "_ccmd", 2163421413u, 0, 5, &be_const_str__debug_present);
+be_define_const_str(_class, "_class", 2732146350u, 0, 6, &be_const_str_item);
+be_define_const_str(_cmd, "_cmd", 3419822142u, 0, 4, &be_const_str_attrdump);
+be_define_const_str(_debug_present, "_debug_present", 4063411725u, 0, 14, NULL);
+be_define_const_str(_def, "_def", 1985022181u, 0, 4, NULL);
+be_define_const_str(_dirty, "_dirty", 283846766u, 0, 6, &be_const_str_load_freetype_font);
+be_define_const_str(_drivers, "_drivers", 3260328985u, 0, 8, &be_const_str_minute);
+be_define_const_str(_end_transmission, "_end_transmission", 3237480400u, 0, 17, &be_const_str_get_temp);
+be_define_const_str(_energy, "_energy", 535372070u, 0, 7, &be_const_str_contains);
+be_define_const_str(_error, "_error", 1132109656u, 0, 6, &be_const_str_connected);
+be_define_const_str(_filename, "_filename", 1430813195u, 0, 9, &be_const_str_valuer_error);
+be_define_const_str(_global_addr, "_global_addr", 533766721u, 0, 12, &be_const_str_get_bri);
+be_define_const_str(_global_def, "_global_def", 646007001u, 0, 11, &be_const_str_bool);
+be_define_const_str(_lvgl, "_lvgl", 2689219483u, 0, 5, &be_const_str_json_fdump_list);
+be_define_const_str(_p, "_p", 1594591802u, 0, 2, &be_const_str_exp);
+be_define_const_str(_persist_X2Ejson, "_persist.json", 2008425138u, 0, 13, &be_const_str_number);
+be_define_const_str(_ptr, "_ptr", 306235816u, 0, 4, NULL);
+be_define_const_str(_read, "_read", 346717030u, 0, 5, &be_const_str_round_start);
 be_define_const_str(_request_from, "_request_from", 3965148604u, 0, 13, NULL);
-be_define_const_str(_rules, "_rules", 4266217105u, 0, 6, &be_const_str_lv_event);
-be_define_const_str(_settings_def, "_settings_def", 3775560307u, 0, 13, &be_const_str_cb_obj);
-be_define_const_str(_settings_ptr, "_settings_ptr", 1825772182u, 0, 13, &be_const_str_number);
-be_define_const_str(_t, "_t", 1527481326u, 0, 2, &be_const_str_call);
-be_define_const_str(_timers, "_timers", 2600100916u, 0, 7, &be_const_str_signal_bars);
-be_define_const_str(_write, "_write", 2215462825u, 0, 6, NULL);
-be_define_const_str(a, "a", 3826002220u, 0, 1, &be_const_str_nil);
-be_define_const_str(abs, "abs", 709362235u, 0, 3, &be_const_str_run_deferred);
+be_define_const_str(_rules, "_rules", 4266217105u, 0, 6, &be_const_str_class);
+be_define_const_str(_settings_def, "_settings_def", 3775560307u, 0, 13, &be_const_str_arg_X20must_X20be_X20a_X20subclass_X20of_X20lv_obj);
+be_define_const_str(_settings_ptr, "_settings_ptr", 1825772182u, 0, 13, &be_const_str_save);
+be_define_const_str(_t, "_t", 1527481326u, 0, 2, &be_const_str_widget_constructor);
+be_define_const_str(_timers, "_timers", 2600100916u, 0, 7, &be_const_str_eth);
+be_define_const_str(_write, "_write", 2215462825u, 0, 6, &be_const_str_fromb64);
+be_define_const_str(a, "a", 3826002220u, 0, 1, &be_const_str_get_alternate);
+be_define_const_str(abs, "abs", 709362235u, 0, 3, &be_const_str_assert);
 be_define_const_str(acos, "acos", 1006755615u, 0, 4, NULL);
-be_define_const_str(add, "add", 993596020u, 0, 3, &be_const_str_digital_read);
-be_define_const_str(add_anim, "add_anim", 3980662668u, 0, 8, NULL);
-be_define_const_str(add_cmd, "add_cmd", 3361630879u, 0, 7, &be_const_str_set_y);
-be_define_const_str(add_driver, "add_driver", 1654458371u, 0, 10, &be_const_str_from_to);
-be_define_const_str(add_handler, "add_handler", 2055124119u, 0, 11, &be_const_str_event);
-be_define_const_str(add_header, "add_header", 927130612u, 0, 10, &be_const_str_resp_cmnd_done);
-be_define_const_str(add_rule, "add_rule", 596540743u, 0, 8, &be_const_str_connection_error);
-be_define_const_str(addr, "addr", 1087856498u, 0, 4, &be_const_str_hs2rgb);
-be_define_const_str(allocated, "allocated", 429986098u, 0, 9, NULL);
-be_define_const_str(alternate, "alternate", 1140253277u, 0, 9, &be_const_str_get_light);
-be_define_const_str(animate, "animate", 3885786800u, 0, 7, &be_const_str_stop_iteration);
-be_define_const_str(animators, "animators", 279858213u, 0, 9, &be_const_str_display);
-be_define_const_str(arch, "arch", 2952804297u, 0, 4, &be_const_str_search);
-be_define_const_str(area, "area", 2601460036u, 0, 4, &be_const_str_valuer_error);
-be_define_const_str(arg, "arg", 1047474471u, 0, 3, &be_const_str_constructor_cb);
-be_define_const_str(arg_X20must_X20be_X20a_X20subclass_X20of_X20lv_obj, "arg must be a subclass of lv_obj", 1641882079u, 0, 32, &be_const_str_connected);
-be_define_const_str(arg_name, "arg_name", 1345046155u, 0, 8, &be_const_str_ins_goto);
-be_define_const_str(arg_size, "arg_size", 3310243257u, 0, 8, &be_const_str_read12);
+be_define_const_str(add, "add", 993596020u, 0, 3, &be_const_str_begin);
+be_define_const_str(add_anim, "add_anim", 3980662668u, 0, 8, &be_const_str_get_current_module_path);
+be_define_const_str(add_cmd, "add_cmd", 3361630879u, 0, 7, &be_const_str_push_path);
+be_define_const_str(add_driver, "add_driver", 1654458371u, 0, 10, &be_const_str_content_button);
+be_define_const_str(add_handler, "add_handler", 2055124119u, 0, 11, &be_const_str_get_vbus_voltage);
+be_define_const_str(add_header, "add_header", 927130612u, 0, 10, &be_const_str_classof);
+be_define_const_str(add_rule, "add_rule", 596540743u, 0, 8, NULL);
+be_define_const_str(addr, "addr", 1087856498u, 0, 4, &be_const_str_length_X20in_X20bits_X20must_X20be_X20between_X200_X20and_X2032);
+be_define_const_str(allocated, "allocated", 429986098u, 0, 9, &be_const_str_fromstring);
+be_define_const_str(alternate, "alternate", 1140253277u, 0, 9, &be_const_str_bus);
+be_define_const_str(animate, "animate", 3885786800u, 0, 7, &be_const_str_get_cb_list);
+be_define_const_str(animators, "animators", 279858213u, 0, 9, NULL);
+be_define_const_str(arch, "arch", 2952804297u, 0, 4, &be_const_str_widget_ctor_impl);
+be_define_const_str(area, "area", 2601460036u, 0, 4, &be_const_str_montserrat_font);
+be_define_const_str(arg, "arg", 1047474471u, 0, 3, &be_const_str_event);
+be_define_const_str(arg_X20must_X20be_X20a_X20subclass_X20of_X20lv_obj, "arg must be a subclass of lv_obj", 1641882079u, 0, 32, &be_const_str_atan2);
+be_define_const_str(arg_name, "arg_name", 1345046155u, 0, 8, &be_const_str_screenshot);
+be_define_const_str(arg_size, "arg_size", 3310243257u, 0, 8, &be_const_str_set_ldo_enable);
 be_define_const_str(as, "as", 1579491469u, 67, 2, NULL);
-be_define_const_str(asin, "asin", 4272848550u, 0, 4, &be_const_str_every_second);
-be_define_const_str(assert, "assert", 2774883451u, 0, 6, &be_const_str_load);
-be_define_const_str(asstring, "asstring", 1298225088u, 0, 8, &be_const_str_reverse_gamma10);
-be_define_const_str(atan, "atan", 108579519u, 0, 4, &be_const_str_web_sensor);
-be_define_const_str(atan2, "atan2", 3173440503u, 0, 5, &be_const_str_cb);
+be_define_const_str(asin, "asin", 4272848550u, 0, 4, &be_const_str_break);
+be_define_const_str(assert, "assert", 2774883451u, 0, 6, &be_const_str_every_second);
+be_define_const_str(asstring, "asstring", 1298225088u, 0, 8, &be_const_str_local);
+be_define_const_str(atan, "atan", 108579519u, 0, 4, &be_const_str_time_dump);
+be_define_const_str(atan2, "atan2", 3173440503u, 0, 5, NULL);
 be_define_const_str(atleast1, "atleast1", 1956331672u, 0, 8, &be_const_str_c);
-be_define_const_str(attrdump, "attrdump", 1521571304u, 0, 8, &be_const_str_read_sensors);
-be_define_const_str(autoexec, "autoexec", 3676861891u, 0, 8, &be_const_str_range);
-be_define_const_str(autorun, "autorun", 1447527407u, 0, 7, &be_const_str_widget_instance_size);
-be_define_const_str(available, "available", 1727918744u, 0, 9, &be_const_str_get_current_module_name);
-be_define_const_str(b, "b", 3876335077u, 0, 1, &be_const_str_shared_key);
-be_define_const_str(back_forth, "back_forth", 2665042062u, 0, 10, NULL);
-be_define_const_str(base_class, "base_class", 1107737279u, 0, 10, &be_const_str_out_X20of_X20range);
-be_define_const_str(battery_present, "battery_present", 3588397058u, 0, 15, &be_const_str_load_freetype_font);
-be_define_const_str(begin, "begin", 1748273790u, 0, 5, NULL);
-be_define_const_str(begin_multicast, "begin_multicast", 57647915u, 0, 15, NULL);
-be_define_const_str(bool, "bool", 3365180733u, 0, 4, &be_const_str_check_privileged_access);
+be_define_const_str(attrdump, "attrdump", 1521571304u, 0, 8, &be_const_str_decrypt);
+be_define_const_str(autoexec, "autoexec", 3676861891u, 0, 8, &be_const_str_set_timer);
+be_define_const_str(autorun, "autorun", 1447527407u, 0, 7, &be_const_str_widget_group_def);
+be_define_const_str(available, "available", 1727918744u, 0, 9, &be_const_str_publish);
+be_define_const_str(b, "b", 3876335077u, 0, 1, &be_const_str_call);
+be_define_const_str(back_forth, "back_forth", 2665042062u, 0, 10, &be_const_str_rad);
+be_define_const_str(base_class, "base_class", 1107737279u, 0, 10, NULL);
+be_define_const_str(battery_present, "battery_present", 3588397058u, 0, 15, NULL);
+be_define_const_str(begin, "begin", 1748273790u, 0, 5, &be_const_str_find_key_i);
+be_define_const_str(begin_multicast, "begin_multicast", 57647915u, 0, 15, &be_const_str_file);
+be_define_const_str(bool, "bool", 3365180733u, 0, 4, &be_const_str_search);
 be_define_const_str(break, "break", 3378807160u, 58, 5, NULL);
-be_define_const_str(bri, "bri", 2112284244u, 0, 3, &be_const_str_copy);
-be_define_const_str(bus, "bus", 1607822841u, 0, 3, &be_const_str_lvgl_event_dispatch);
-be_define_const_str(button_pressed, "button_pressed", 1694209616u, 0, 14, &be_const_str_find_key_i);
-be_define_const_str(byte, "byte", 1683620383u, 0, 4, &be_const_str_get_warning_level);
-be_define_const_str(bytes, "bytes", 1706151940u, 0, 5, &be_const_str_i2c_enabled);
-be_define_const_str(c, "c", 3859557458u, 0, 1, &be_const_str_get_input_power_status);
+be_define_const_str(bri, "bri", 2112284244u, 0, 3, &be_const_str_get_coords);
+be_define_const_str(bus, "bus", 1607822841u, 0, 3, &be_const_str_display_X2Eini);
+be_define_const_str(button_pressed, "button_pressed", 1694209616u, 0, 14, NULL);
+be_define_const_str(byte, "byte", 1683620383u, 0, 4, NULL);
+be_define_const_str(bytes, "bytes", 1706151940u, 0, 5, &be_const_str_chars_in_string);
+be_define_const_str(c, "c", 3859557458u, 0, 1, NULL);
 be_define_const_str(call, "call", 3018949801u, 0, 4, NULL);
-be_define_const_str(call_native, "call_native", 1389147405u, 0, 11, &be_const_str_get_cb_list);
-be_define_const_str(calldepth, "calldepth", 3122364302u, 0, 9, NULL);
-be_define_const_str(can_show, "can_show", 960091187u, 0, 8, &be_const_str_push);
-be_define_const_str(cb, "cb", 1428787088u, 0, 2, &be_const_str_char);
-be_define_const_str(cb_do_nothing, "cb_do_nothing", 1488730702u, 0, 13, &be_const_str_del);
+be_define_const_str(call_native, "call_native", 1389147405u, 0, 11, NULL);
+be_define_const_str(calldepth, "calldepth", 3122364302u, 0, 9, &be_const_str_write_bytes);
+be_define_const_str(can_show, "can_show", 960091187u, 0, 8, NULL);
+be_define_const_str(cb, "cb", 1428787088u, 0, 2, &be_const_str_global);
+be_define_const_str(cb_do_nothing, "cb_do_nothing", 1488730702u, 0, 13, &be_const_str_imin);
 be_define_const_str(cb_event_closure, "cb_event_closure", 3828267325u, 0, 16, NULL);
-be_define_const_str(cb_obj, "cb_obj", 1195696482u, 0, 6, &be_const_str_running);
-be_define_const_str(ceil, "ceil", 1659167240u, 0, 4, &be_const_str_exists);
-be_define_const_str(char, "char", 2823553821u, 0, 4, &be_const_str_get_bat_charge_current);
-be_define_const_str(chars_in_string, "chars_in_string", 3148785132u, 0, 15, &be_const_str_detected_X20on_X20bus);
-be_define_const_str(check_privileged_access, "check_privileged_access", 3692933968u, 0, 23, &be_const_str_tasmota);
+be_define_const_str(cb_obj, "cb_obj", 1195696482u, 0, 6, &be_const_str_write);
+be_define_const_str(ceil, "ceil", 1659167240u, 0, 4, NULL);
+be_define_const_str(char, "char", 2823553821u, 0, 4, &be_const_str_get_battery_chargin_status);
+be_define_const_str(chars_in_string, "chars_in_string", 3148785132u, 0, 15, &be_const_str_else);
+be_define_const_str(check_privileged_access, "check_privileged_access", 3692933968u, 0, 23, &be_const_str_couldn_X27t_X20not_X20initialize_X20noepixelbus);
 be_define_const_str(class, "class", 2872970239u, 57, 5, NULL);
-be_define_const_str(class_init_obj, "class_init_obj", 178410604u, 0, 14, &be_const_str_event_send);
-be_define_const_str(classname, "classname", 1998589948u, 0, 9, &be_const_str_exec_cmd);
-be_define_const_str(classof, "classof", 1796577762u, 0, 7, &be_const_str_input);
-be_define_const_str(clear, "clear", 1550717474u, 0, 5, &be_const_str_get_vbus_voltage);
-be_define_const_str(clear_first_time, "clear_first_time", 632769909u, 0, 16, &be_const_str_get_height);
-be_define_const_str(clear_to, "clear_to", 3528002130u, 0, 8, &be_const_str_connect);
+be_define_const_str(class_init_obj, "class_init_obj", 178410604u, 0, 14, NULL);
+be_define_const_str(classname, "classname", 1998589948u, 0, 9, &be_const_str_set_matrix_pixel_color);
+be_define_const_str(classof, "classof", 1796577762u, 0, 7, &be_const_str_font_montserrat);
+be_define_const_str(clear, "clear", 1550717474u, 0, 5, &be_const_str_imax);
+be_define_const_str(clear_first_time, "clear_first_time", 632769909u, 0, 16, &be_const_str_get_warning_level);
+be_define_const_str(clear_to, "clear_to", 3528002130u, 0, 8, NULL);
 be_define_const_str(clock_icon, "clock_icon", 544669651u, 0, 10, NULL);
-be_define_const_str(close, "close", 667630371u, 0, 5, &be_const_str_create_segment);
-be_define_const_str(closure, "closure", 1548407746u, 0, 7, &be_const_str_content_button);
-be_define_const_str(cmd, "cmd", 4136785899u, 0, 3, &be_const_str_get_battery_chargin_status);
-be_define_const_str(cmd_res, "cmd_res", 921166762u, 0, 7, &be_const_str_set_matrix_pixel_color);
-be_define_const_str(code, "code", 4180765940u, 0, 4, &be_const_str_nan);
-be_define_const_str(codedump, "codedump", 1786337906u, 0, 8, &be_const_str_remove_timer);
-be_define_const_str(collect, "collect", 2399039025u, 0, 7, &be_const_str_last_modified);
-be_define_const_str(color, "color", 1031692888u, 0, 5, &be_const_str_kv);
-be_define_const_str(compile, "compile", 1000265118u, 0, 7, &be_const_str_null_cb);
-be_define_const_str(compress, "compress", 2818084237u, 0, 8, &be_const_str_lv_wifi_arcs_icon);
-be_define_const_str(concat, "concat", 4124019837u, 0, 6, &be_const_str_reverse);
-be_define_const_str(connect, "connect", 2866859257u, 0, 7, NULL);
-be_define_const_str(connected, "connected", 1424938192u, 0, 9, &be_const_str_ctypes_bytes);
-be_define_const_str(connection_error, "connection_error", 1358926260u, 0, 16, &be_const_str_every_50ms);
+be_define_const_str(close, "close", 667630371u, 0, 5, &be_const_str_percentage);
+be_define_const_str(closure, "closure", 1548407746u, 0, 7, &be_const_str_compile);
+be_define_const_str(cmd, "cmd", 4136785899u, 0, 3, &be_const_str_log);
+be_define_const_str(cmd_res, "cmd_res", 921166762u, 0, 7, &be_const_str_tanh);
+be_define_const_str(code, "code", 4180765940u, 0, 4, &be_const_str_enabled);
+be_define_const_str(codedump, "codedump", 1786337906u, 0, 8, &be_const_str_webserver);
+be_define_const_str(collect, "collect", 2399039025u, 0, 7, NULL);
+be_define_const_str(color, "color", 1031692888u, 0, 5, &be_const_str_lv_wifi_bars);
+be_define_const_str(compile, "compile", 1000265118u, 0, 7, NULL);
+be_define_const_str(compress, "compress", 2818084237u, 0, 8, &be_const_str_energy_struct);
+be_define_const_str(concat, "concat", 4124019837u, 0, 6, &be_const_str_list_handlers);
+be_define_const_str(connect, "connect", 2866859257u, 0, 7, &be_const_str_get_bat_current);
+be_define_const_str(connected, "connected", 1424938192u, 0, 9, &be_const_str_lv_);
+be_define_const_str(connection_error, "connection_error", 1358926260u, 0, 16, &be_const_str_target);
 be_define_const_str(constructor_cb, "constructor_cb", 2489105297u, 0, 14, NULL);
-be_define_const_str(contains, "contains", 1825239352u, 0, 8, &be_const_str_gc);
-be_define_const_str(content_button, "content_button", 1956476087u, 0, 14, &be_const_str_get_option);
+be_define_const_str(contains, "contains", 1825239352u, 0, 8, &be_const_str_escape);
+be_define_const_str(content_button, "content_button", 1956476087u, 0, 14, NULL);
 be_define_const_str(content_flush, "content_flush", 214922475u, 0, 13, NULL);
-be_define_const_str(content_send, "content_send", 1673733649u, 0, 12, &be_const_str_font_montserrat);
-be_define_const_str(content_send_style, "content_send_style", 1087907647u, 0, 18, NULL);
-be_define_const_str(content_start, "content_start", 2937509069u, 0, 13, NULL);
-be_define_const_str(content_stop, "content_stop", 658554751u, 0, 12, &be_const_str_widget_event);
+be_define_const_str(content_send, "content_send", 1673733649u, 0, 12, NULL);
+be_define_const_str(content_send_style, "content_send_style", 1087907647u, 0, 18, &be_const_str_lv_module_init);
+be_define_const_str(content_start, "content_start", 2937509069u, 0, 13, &be_const_str_zero);
+be_define_const_str(content_stop, "content_stop", 658554751u, 0, 12, NULL);
 be_define_const_str(continue, "continue", 2977070660u, 59, 8, NULL);
-be_define_const_str(copy, "copy", 3848464964u, 0, 4, NULL);
-be_define_const_str(cos, "cos", 4220379804u, 0, 3, &be_const_str_set_timeouts);
+be_define_const_str(copy, "copy", 3848464964u, 0, 4, &be_const_str_has_arg);
+be_define_const_str(cos, "cos", 4220379804u, 0, 3, &be_const_str_set_useragent);
 be_define_const_str(cosh, "cosh", 4099687964u, 0, 4, NULL);
-be_define_const_str(couldn_X27t_X20not_X20initialize_X20noepixelbus, "couldn't not initialize noepixelbus", 2536490812u, 0, 35, NULL);
-be_define_const_str(count, "count", 967958004u, 0, 5, &be_const_str_json_fdump_any);
-be_define_const_str(counters, "counters", 4095866864u, 0, 8, &be_const_str_imax);
-be_define_const_str(create_custom_widget, "create_custom_widget", 1140594778u, 0, 20, NULL);
-be_define_const_str(create_matrix, "create_matrix", 3528185923u, 0, 13, NULL);
+be_define_const_str(couldn_X27t_X20not_X20initialize_X20noepixelbus, "couldn't not initialize noepixelbus", 2536490812u, 0, 35, &be_const_str_reverse_gamma10);
+be_define_const_str(count, "count", 967958004u, 0, 5, NULL);
+be_define_const_str(counters, "counters", 4095866864u, 0, 8, &be_const_str_id);
+be_define_const_str(create_custom_widget, "create_custom_widget", 1140594778u, 0, 20, &be_const_str_pc_rel);
+be_define_const_str(create_matrix, "create_matrix", 3528185923u, 0, 13, &be_const_str_deregister_obj);
 be_define_const_str(create_segment, "create_segment", 3863522719u, 0, 14, NULL);
 be_define_const_str(ctor, "ctor", 375399343u, 0, 4, NULL);
-be_define_const_str(ctypes_bytes, "ctypes_bytes", 3879019703u, 0, 12, &be_const_str_r);
-be_define_const_str(ctypes_bytes_dyn, "ctypes_bytes_dyn", 915205307u, 0, 16, &be_const_str_keys);
-be_define_const_str(dac_voltage, "dac_voltage", 1552257222u, 0, 11, &be_const_str_h);
-be_define_const_str(day, "day", 3830391293u, 0, 3, &be_const_str_https_X3A_X2F_X2Fraw_X2Egithubusercontent_X2Ecom_X2Ftasmota_X2Fautoconf_X2Fmain_X2F_X25s_manifest_X2Ejson);
-be_define_const_str(debug, "debug", 1483009432u, 0, 5, &be_const_str_widget_editable);
-be_define_const_str(decompress, "decompress", 2887031650u, 0, 10, &be_const_str_get_free_heap);
-be_define_const_str(decrypt, "decrypt", 2886974618u, 0, 7, &be_const_str_log10);
+be_define_const_str(ctypes_bytes, "ctypes_bytes", 3879019703u, 0, 12, &be_const_str_reset_search);
+be_define_const_str(ctypes_bytes_dyn, "ctypes_bytes_dyn", 915205307u, 0, 16, &be_const_str_gen_cb);
+be_define_const_str(dac_voltage, "dac_voltage", 1552257222u, 0, 11, NULL);
+be_define_const_str(day, "day", 3830391293u, 0, 3, NULL);
+be_define_const_str(debug, "debug", 1483009432u, 0, 5, &be_const_str_reapply);
+be_define_const_str(decompress, "decompress", 2887031650u, 0, 10, &be_const_str_set_pixel_color);
+be_define_const_str(decrypt, "decrypt", 2886974618u, 0, 7, &be_const_str_get_current_module_name);
 be_define_const_str(def, "def", 3310976652u, 55, 3, NULL);
-be_define_const_str(deg, "deg", 3327754271u, 0, 3, NULL);
-be_define_const_str(deinit, "deinit", 2345559592u, 0, 6, &be_const_str_introspect);
-be_define_const_str(del, "del", 3478752842u, 0, 3, &be_const_str_widget_ctor_impl);
-be_define_const_str(delay, "delay", 1322381784u, 0, 5, &be_const_str_register_button_encoder);
+be_define_const_str(deg, "deg", 3327754271u, 0, 3, &be_const_str_list);
+be_define_const_str(deinit, "deinit", 2345559592u, 0, 6, NULL);
+be_define_const_str(del, "del", 3478752842u, 0, 3, &be_const_str_matrix);
+be_define_const_str(delay, "delay", 1322381784u, 0, 5, &be_const_str_resp_cmnd_str);
 be_define_const_str(delete_all_configs, "delete_all_configs", 2382067578u, 0, 18, NULL);
-be_define_const_str(depower, "depower", 3563819571u, 0, 7, &be_const_str_lv_wifi_bars);
-be_define_const_str(deregister_obj, "deregister_obj", 3909966993u, 0, 14, &be_const_str_get_coords);
-be_define_const_str(destructor_cb, "destructor_cb", 1930283190u, 0, 13, &be_const_str_fromb64);
-be_define_const_str(detect, "detect", 8884370u, 0, 6, &be_const_str_has);
-be_define_const_str(detected_X20on_X20bus, "detected on bus", 1432002650u, 0, 15, &be_const_str_real);
-be_define_const_str(digital_read, "digital_read", 3585496928u, 0, 12, &be_const_str_gpio);
-be_define_const_str(digital_write, "digital_write", 3435877979u, 0, 13, &be_const_str_remove_rule);
-be_define_const_str(dirty, "dirty", 2667581083u, 0, 5, &be_const_str_read32);
-be_define_const_str(display, "display", 1164572437u, 0, 7, &be_const_str_init_draw_line_dsc);
-be_define_const_str(display_X2Eini, "display.ini", 2646174001u, 0, 11, &be_const_str_hex);
+be_define_const_str(depower, "depower", 3563819571u, 0, 7, &be_const_str_tag);
+be_define_const_str(deregister_obj, "deregister_obj", 3909966993u, 0, 14, NULL);
+be_define_const_str(destructor_cb, "destructor_cb", 1930283190u, 0, 13, &be_const_str_detect);
+be_define_const_str(detect, "detect", 8884370u, 0, 6, &be_const_str__X7B);
+be_define_const_str(detected_X20on_X20bus, "detected on bus", 1432002650u, 0, 15, &be_const_str_pop_path);
+be_define_const_str(digital_read, "digital_read", 3585496928u, 0, 12, &be_const_str_try);
+be_define_const_str(digital_write, "digital_write", 3435877979u, 0, 13, &be_const_str_f);
+be_define_const_str(dirty, "dirty", 2667581083u, 0, 5, &be_const_str_stop_iteration);
+be_define_const_str(display, "display", 1164572437u, 0, 7, &be_const_str_sin);
+be_define_const_str(display_X2Eini, "display.ini", 2646174001u, 0, 11, &be_const_str_font_seg7);
 be_define_const_str(do, "do", 1646057492u, 65, 2, NULL);
-be_define_const_str(draw_arc, "draw_arc", 1828251676u, 0, 8, &be_const_str_public_key);
-be_define_const_str(draw_line, "draw_line", 1634465686u, 0, 9, &be_const_str_string);
-be_define_const_str(draw_line_dsc, "draw_line_dsc", 4220676203u, 0, 13, &be_const_str_p1);
-be_define_const_str(draw_line_dsc_init, "draw_line_dsc_init", 3866693646u, 0, 18, &be_const_str_get_style_pad_right);
+be_define_const_str(draw_arc, "draw_arc", 1828251676u, 0, 8, NULL);
+be_define_const_str(draw_line, "draw_line", 1634465686u, 0, 9, &be_const_str_set_dcdc_enable);
+be_define_const_str(draw_line_dsc, "draw_line_dsc", 4220676203u, 0, 13, &be_const_str_exists);
+be_define_const_str(draw_line_dsc_init, "draw_line_dsc_init", 3866693646u, 0, 18, &be_const_str_gpio);
 be_define_const_str(due, "due", 3895530293u, 0, 3, NULL);
-be_define_const_str(dump, "dump", 3663001223u, 0, 4, &be_const_str_erase);
-be_define_const_str(duration, "duration", 799079693u, 0, 8, &be_const_str_remote_ip);
+be_define_const_str(dump, "dump", 3663001223u, 0, 4, &be_const_str_get_power);
+be_define_const_str(duration, "duration", 799079693u, 0, 8, &be_const_str_event_cb);
 be_define_const_str(editable, "editable", 60532369u, 0, 8, NULL);
 be_define_const_str(elif, "elif", 3232090307u, 51, 4, NULL);
 be_define_const_str(else, "else", 3183434736u, 52, 4, NULL);
-be_define_const_str(enabled, "enabled", 49525662u, 0, 7, NULL);
-be_define_const_str(encrypt, "encrypt", 2194327650u, 0, 7, &be_const_str_list);
+be_define_const_str(enabled, "enabled", 49525662u, 0, 7, &be_const_str_ip);
+be_define_const_str(encrypt, "encrypt", 2194327650u, 0, 7, &be_const_str_zip);
 be_define_const_str(end, "end", 1787721130u, 56, 3, NULL);
 be_define_const_str(energy_struct, "energy_struct", 1655792843u, 0, 13, NULL);
-be_define_const_str(engine, "engine", 3993360443u, 0, 6, &be_const_str_get_bat_voltage);
+be_define_const_str(engine, "engine", 3993360443u, 0, 6, &be_const_str_set_power);
 be_define_const_str(erase, "erase", 1010949589u, 0, 5, NULL);
-be_define_const_str(escape, "escape", 2652972038u, 0, 6, &be_const_str_minute);
-be_define_const_str(eth, "eth", 2191266556u, 0, 3, &be_const_str_pixels_buffer);
-be_define_const_str(event, "event", 4264611999u, 0, 5, &be_const_str_lv_clock_icon);
-be_define_const_str(event_cb, "event_cb", 3128698017u, 0, 8, &be_const_str_int);
-be_define_const_str(event_send, "event_send", 598925582u, 0, 10, &be_const_str_month);
-be_define_const_str(every_100ms, "every_100ms", 1546407804u, 0, 11, &be_const_str_set_time);
-be_define_const_str(every_50ms, "every_50ms", 2383884008u, 0, 10, &be_const_str_tag);
-be_define_const_str(every_second, "every_second", 2075451465u, 0, 12, &be_const_str_end);
+be_define_const_str(escape, "escape", 2652972038u, 0, 6, &be_const_str_public_key);
+be_define_const_str(eth, "eth", 2191266556u, 0, 3, NULL);
+be_define_const_str(event, "event", 4264611999u, 0, 5, &be_const_str_ins_goto);
+be_define_const_str(event_cb, "event_cb", 3128698017u, 0, 8, &be_const_str_start);
+be_define_const_str(event_send, "event_send", 598925582u, 0, 10, &be_const_str_null_cb);
+be_define_const_str(every_100ms, "every_100ms", 1546407804u, 0, 11, &be_const_str_set_light);
+be_define_const_str(every_50ms, "every_50ms", 2383884008u, 0, 10, NULL);
+be_define_const_str(every_second, "every_second", 2075451465u, 0, 12, &be_const_str_make_cb);
 be_define_const_str(except, "except", 950914032u, 69, 6, NULL);
 be_define_const_str(exec_cmd, "exec_cmd", 493567399u, 0, 8, NULL);
-be_define_const_str(exec_rules, "exec_rules", 1445221092u, 0, 10, &be_const_str_sys);
-be_define_const_str(exec_tele, "exec_tele", 1020751601u, 0, 9, &be_const_str_elif);
-be_define_const_str(exists, "exists", 1002329533u, 0, 6, NULL);
+be_define_const_str(exec_rules, "exec_rules", 1445221092u, 0, 10, &be_const_str_get_style_pad_right);
+be_define_const_str(exec_tele, "exec_tele", 1020751601u, 0, 9, NULL);
+be_define_const_str(exists, "exists", 1002329533u, 0, 6, &be_const_str_get_input_power_status);
 be_define_const_str(exp, "exp", 1923516200u, 0, 3, NULL);
-be_define_const_str(f, "f", 3809224601u, 0, 1, &be_const_str_list_handlers);
+be_define_const_str(f, "f", 3809224601u, 0, 1, &be_const_str_hour);
 be_define_const_str(false, "false", 184981848u, 62, 5, NULL);
-be_define_const_str(file, "file", 2867484483u, 0, 4, &be_const_str_gen_cb);
-be_define_const_str(file_X20extension_X20is_X20not_X20_X27_X2Ebe_X27_X20or_X20_X27_X2Ebec_X27, "file extension is not '.be' or '.bec'", 3095719639u, 0, 37, &be_const_str_ins_time);
-be_define_const_str(files, "files", 1055342736u, 0, 5, &be_const_str_web_add_console_button);
-be_define_const_str(find, "find", 3186656602u, 0, 4, &be_const_str_top);
-be_define_const_str(find_key_i, "find_key_i", 850136726u, 0, 10, &be_const_str_lv_signal_arcs);
-be_define_const_str(find_op, "find_op", 3766713376u, 0, 7, &be_const_str_get);
-be_define_const_str(finish, "finish", 1494643858u, 0, 6, &be_const_str_persist);
-be_define_const_str(floor, "floor", 3102149661u, 0, 5, &be_const_str_insert);
-be_define_const_str(flush, "flush", 3002334877u, 0, 5, &be_const_str_get_bri);
-be_define_const_str(font_montserrat, "font_montserrat", 3790091262u, 0, 15, &be_const_str_pin);
-be_define_const_str(font_seg7, "font_seg7", 1551771835u, 0, 9, NULL);
+be_define_const_str(file, "file", 2867484483u, 0, 4, &be_const_str_floor);
+be_define_const_str(file_X20extension_X20is_X20not_X20_X27_X2Ebe_X27_X20or_X20_X27_X2Ebec_X27, "file extension is not '.be' or '.bec'", 3095719639u, 0, 37, &be_const_str_get_size);
+be_define_const_str(files, "files", 1055342736u, 0, 5, &be_const_str_end);
+be_define_const_str(find, "find", 3186656602u, 0, 4, NULL);
+be_define_const_str(find_key_i, "find_key_i", 850136726u, 0, 10, &be_const_str_preinit);
+be_define_const_str(find_op, "find_op", 3766713376u, 0, 7, NULL);
+be_define_const_str(finish, "finish", 1494643858u, 0, 6, &be_const_str_ins_ramp);
+be_define_const_str(floor, "floor", 3102149661u, 0, 5, &be_const_str_lv_wifi_arcs);
+be_define_const_str(flush, "flush", 3002334877u, 0, 5, NULL);
+be_define_const_str(font_montserrat, "font_montserrat", 3790091262u, 0, 15, &be_const_str_get_percentage);
+be_define_const_str(font_seg7, "font_seg7", 1551771835u, 0, 9, &be_const_str_lv_signal_bars);
 be_define_const_str(for, "for", 2901640080u, 54, 3, NULL);
-be_define_const_str(format, "format", 3114108242u, 0, 6, NULL);
-be_define_const_str(from_to, "from_to", 21625507u, 0, 7, &be_const_str_get_power);
-be_define_const_str(fromb64, "fromb64", 2717019639u, 0, 7, NULL);
-be_define_const_str(fromptr, "fromptr", 666189689u, 0, 7, &be_const_str_set_chg_current);
-be_define_const_str(fromstring, "fromstring", 610302344u, 0, 10, &be_const_str_lower);
-be_define_const_str(function, "function", 2664841801u, 0, 8, &be_const_str_invalidate);
-be_define_const_str(gamma, "gamma", 3492353034u, 0, 5, &be_const_str_widget_struct_default);
-be_define_const_str(gamma10, "gamma10", 3472052483u, 0, 7, NULL);
-be_define_const_str(gamma8, "gamma8", 3802843830u, 0, 6, NULL);
-be_define_const_str(gc, "gc", 1042313471u, 0, 2, &be_const_str_local);
-be_define_const_str(gen_cb, "gen_cb", 3245227551u, 0, 6, &be_const_str_lv_signal_bars);
-be_define_const_str(get, "get", 1410115415u, 0, 3, &be_const_str_quality);
-be_define_const_str(get_alternate, "get_alternate", 1450148894u, 0, 13, &be_const_str_reapply);
-be_define_const_str(get_aps_voltage, "get_aps_voltage", 2293036435u, 0, 15, &be_const_str_log);
-be_define_const_str(get_bat_charge_current, "get_bat_charge_current", 1385293050u, 0, 22, NULL);
-be_define_const_str(get_bat_current, "get_bat_current", 1912106073u, 0, 15, &be_const_str_name);
-be_define_const_str(get_bat_power, "get_bat_power", 3067374853u, 0, 13, NULL);
-be_define_const_str(get_bat_voltage, "get_bat_voltage", 706676538u, 0, 15, &be_const_str_get_string);
+be_define_const_str(format, "format", 3114108242u, 0, 6, &be_const_str_skip);
+be_define_const_str(from_to, "from_to", 21625507u, 0, 7, &be_const_str_leds);
+be_define_const_str(fromb64, "fromb64", 2717019639u, 0, 7, &be_const_str_r);
+be_define_const_str(fromptr, "fromptr", 666189689u, 0, 7, &be_const_str_issubclass);
+be_define_const_str(fromstring, "fromstring", 610302344u, 0, 10, NULL);
+be_define_const_str(function, "function", 2664841801u, 0, 8, &be_const_str_get_height);
+be_define_const_str(gamma, "gamma", 3492353034u, 0, 5, &be_const_str_init_draw_line_dsc);
+be_define_const_str(gamma10, "gamma10", 3472052483u, 0, 7, &be_const_str_tasmota_X2Eget_light_X28_X29_X20is_X20deprecated_X2C_X20use_X20light_X2Eget_X28_X29);
+be_define_const_str(gamma8, "gamma8", 3802843830u, 0, 6, &be_const_str_lv_event_cb);
+be_define_const_str(gc, "gc", 1042313471u, 0, 2, &be_const_str_hs2rgb);
+be_define_const_str(gen_cb, "gen_cb", 3245227551u, 0, 6, &be_const_str_widget_instance_size);
+be_define_const_str(get, "get", 1410115415u, 0, 3, NULL);
+be_define_const_str(get_alternate, "get_alternate", 1450148894u, 0, 13, &be_const_str_get_bat_voltage);
+be_define_const_str(get_aps_voltage, "get_aps_voltage", 2293036435u, 0, 15, NULL);
+be_define_const_str(get_bat_charge_current, "get_bat_charge_current", 1385293050u, 0, 22, &be_const_str_io_error);
+be_define_const_str(get_bat_current, "get_bat_current", 1912106073u, 0, 15, &be_const_str_obj_event_base);
+be_define_const_str(get_bat_power, "get_bat_power", 3067374853u, 0, 13, &be_const_str_persist);
+be_define_const_str(get_bat_voltage, "get_bat_voltage", 706676538u, 0, 15, &be_const_str_get_vbus_current);
 be_define_const_str(get_battery_chargin_status, "get_battery_chargin_status", 2233241571u, 0, 26, NULL);
-be_define_const_str(get_bri, "get_bri", 2041809895u, 0, 7, &be_const_str_preinit);
-be_define_const_str(get_cb_list, "get_cb_list", 1605319182u, 0, 11, NULL);
-be_define_const_str(get_coords, "get_coords", 1044089006u, 0, 10, &be_const_str_serial);
-be_define_const_str(get_current_module_name, "get_current_module_name", 2379270740u, 0, 23, &be_const_str_offset);
-be_define_const_str(get_current_module_path, "get_current_module_path", 3206673408u, 0, 23, &be_const_str_tasmota_X2Eget_light_X28_X29_X20is_X20deprecated_X2C_X20use_X20light_X2Eget_X28_X29);
-be_define_const_str(get_free_heap, "get_free_heap", 625069757u, 0, 13, &be_const_str_make_cb);
-be_define_const_str(get_height, "get_height", 3571755523u, 0, 10, &be_const_str_json_append);
-be_define_const_str(get_input_power_status, "get_input_power_status", 4102829177u, 0, 22, &be_const_str_wire);
-be_define_const_str(get_light, "get_light", 381930476u, 0, 9, NULL);
-be_define_const_str(get_object_from_ptr, "get_object_from_ptr", 2345019201u, 0, 19, NULL);
-be_define_const_str(get_option, "get_option", 2123730033u, 0, 10, NULL);
-be_define_const_str(get_percentage, "get_percentage", 2880483992u, 0, 14, &be_const_str_percentage);
-be_define_const_str(get_pixel_color, "get_pixel_color", 337490048u, 0, 15, &be_const_str_min);
-be_define_const_str(get_power, "get_power", 3009799377u, 0, 9, &be_const_str_srand);
-be_define_const_str(get_size, "get_size", 2803644713u, 0, 8, &be_const_str_id);
-be_define_const_str(get_string, "get_string", 4195847969u, 0, 10, NULL);
-be_define_const_str(get_style_bg_color, "get_style_bg_color", 964794381u, 0, 18, &be_const_str_ins_ramp);
-be_define_const_str(get_style_line_color, "get_style_line_color", 805371932u, 0, 20, &be_const_str_class);
-be_define_const_str(get_style_pad_right, "get_style_pad_right", 3150287466u, 0, 19, &be_const_str_save);
-be_define_const_str(get_switch, "get_switch", 164821028u, 0, 10, &be_const_str_pc);
-be_define_const_str(get_temp, "get_temp", 3370919486u, 0, 8, NULL);
-be_define_const_str(get_vbus_current, "get_vbus_current", 1205347942u, 0, 16, &be_const_str_isrunning);
-be_define_const_str(get_vbus_voltage, "get_vbus_voltage", 2398210401u, 0, 16, &be_const_str_read);
-be_define_const_str(get_warning_level, "get_warning_level", 1737834441u, 0, 17, &be_const_str_pow);
-be_define_const_str(get_width, "get_width", 3293417300u, 0, 9, &be_const_str_ip);
-be_define_const_str(getbits, "getbits", 3094168979u, 0, 7, NULL);
-be_define_const_str(geti, "geti", 2381006490u, 0, 4, &be_const_str_https_X3A_X2F_X2Fraw_X2Egithubusercontent_X2Ecom_X2Ftasmota_X2Fautoconf_X2Fmain_X2F_X25s_X2F_X25s_X2Eautoconf);
-be_define_const_str(global, "global", 503252654u, 0, 6, &be_const_str_json_fdump_list);
-be_define_const_str(gpio, "gpio", 2638155258u, 0, 4, &be_const_str_settings);
-be_define_const_str(group_def, "group_def", 1524213328u, 0, 9, &be_const_str_json_fdump_map);
+be_define_const_str(get_bri, "get_bri", 2041809895u, 0, 7, NULL);
+be_define_const_str(get_cb_list, "get_cb_list", 1605319182u, 0, 11, &be_const_str_toptr);
+be_define_const_str(get_coords, "get_coords", 1044089006u, 0, 10, &be_const_str_read12);
+be_define_const_str(get_current_module_name, "get_current_module_name", 2379270740u, 0, 23, &be_const_str_height_def);
+be_define_const_str(get_current_module_path, "get_current_module_path", 3206673408u, 0, 23, &be_const_str_obj_class_create_obj);
+be_define_const_str(get_free_heap, "get_free_heap", 625069757u, 0, 13, &be_const_str__X7Bs_X7DVBus_X20Current_X7Bm_X7D_X25_X2E1f_X20mA_X7Be_X7D);
+be_define_const_str(get_height, "get_height", 3571755523u, 0, 10, &be_const_str_widget_destructor);
+be_define_const_str(get_input_power_status, "get_input_power_status", 4102829177u, 0, 22, NULL);
+be_define_const_str(get_light, "get_light", 381930476u, 0, 9, &be_const_str_pop);
+be_define_const_str(get_object_from_ptr, "get_object_from_ptr", 2345019201u, 0, 19, &be_const_str_tele);
+be_define_const_str(get_option, "get_option", 2123730033u, 0, 10, &be_const_str_light);
+be_define_const_str(get_percentage, "get_percentage", 2880483992u, 0, 14, &be_const_str_json_fdump);
+be_define_const_str(get_pixel_color, "get_pixel_color", 337490048u, 0, 15, NULL);
+be_define_const_str(get_power, "get_power", 3009799377u, 0, 9, NULL);
+be_define_const_str(get_size, "get_size", 2803644713u, 0, 8, NULL);
+be_define_const_str(get_string, "get_string", 4195847969u, 0, 10, &be_const_str_read);
+be_define_const_str(get_style_bg_color, "get_style_bg_color", 964794381u, 0, 18, &be_const_str_remove_timer);
+be_define_const_str(get_style_line_color, "get_style_line_color", 805371932u, 0, 20, &be_const_str_param);
+be_define_const_str(get_style_pad_right, "get_style_pad_right", 3150287466u, 0, 19, &be_const_str_pin_used);
+be_define_const_str(get_switch, "get_switch", 164821028u, 0, 10, &be_const_str_lvgl_event_dispatch);
+be_define_const_str(get_temp, "get_temp", 3370919486u, 0, 8, &be_const_str_group_def);
+be_define_const_str(get_vbus_current, "get_vbus_current", 1205347942u, 0, 16, NULL);
+be_define_const_str(get_vbus_voltage, "get_vbus_voltage", 2398210401u, 0, 16, &be_const_str_select);
+be_define_const_str(get_warning_level, "get_warning_level", 1737834441u, 0, 17, &be_const_str_value_error);
+be_define_const_str(get_width, "get_width", 3293417300u, 0, 9, &be_const_str_pin);
+be_define_const_str(getbits, "getbits", 3094168979u, 0, 7, &be_const_str_pow);
+be_define_const_str(geti, "geti", 2381006490u, 0, 4, NULL);
+be_define_const_str(global, "global", 503252654u, 0, 6, &be_const_str_introspect);
+be_define_const_str(gpio, "gpio", 2638155258u, 0, 4, &be_const_str_register_button_encoder);
+be_define_const_str(group_def, "group_def", 1524213328u, 0, 9, &be_const_str_lower);
 be_define_const_str(h, "h", 3977000791u, 0, 1, &be_const_str_pixel_count);
-be_define_const_str(has, "has", 3988721635u, 0, 3, &be_const_str_reset_search);
-be_define_const_str(has_arg, "has_arg", 424878688u, 0, 7, &be_const_str_lv_);
+be_define_const_str(has, "has", 3988721635u, 0, 3, NULL);
+be_define_const_str(has_arg, "has_arg", 424878688u, 0, 7, NULL);
 be_define_const_str(height_def, "height_def", 2348238838u, 0, 10, NULL);
-be_define_const_str(hex, "hex", 4273249610u, 0, 3, &be_const_str_setmember);
-be_define_const_str(hour, "hour", 3053661199u, 0, 4, &be_const_str_set_first_time);
+be_define_const_str(hex, "hex", 4273249610u, 0, 3, NULL);
+be_define_const_str(hour, "hour", 3053661199u, 0, 4, &be_const_str__X7Bs_X7DTemp_X20AXP_X7Bm_X7D_X25_X2E1f_X20_X26deg_X3BC_X7Be_X7D);
 be_define_const_str(hs2rgb, "hs2rgb", 1040816349u, 0, 6, NULL);
-be_define_const_str(https_X3A_X2F_X2Fraw_X2Egithubusercontent_X2Ecom_X2Ftasmota_X2Fautoconf_X2Fmain_X2F_X25s_X2F_X25s_X2Eautoconf, "https://raw.githubusercontent.com/tasmota/autoconf/main/%s/%s.autoconf", 2743526309u, 0, 70, NULL);
-be_define_const_str(https_X3A_X2F_X2Fraw_X2Egithubusercontent_X2Ecom_X2Ftasmota_X2Fautoconf_X2Fmain_X2F_X25s_manifest_X2Ejson, "https://raw.githubusercontent.com/tasmota/autoconf/main/%s_manifest.json", 3657552045u, 0, 72, NULL);
-be_define_const_str(i2c_enabled, "i2c_enabled", 218388101u, 0, 11, &be_const_str_false);
+be_define_const_str(https_X3A_X2F_X2Fraw_X2Egithubusercontent_X2Ecom_X2Ftasmota_X2Fautoconf_X2Fmain_X2F_X25s_X2F_X25s_X2Eautoconf, "https://raw.githubusercontent.com/tasmota/autoconf/main/%s/%s.autoconf", 2743526309u, 0, 70, &be_const_str_set_bri);
+be_define_const_str(https_X3A_X2F_X2Fraw_X2Egithubusercontent_X2Ecom_X2Ftasmota_X2Fautoconf_X2Fmain_X2F_X25s_manifest_X2Ejson, "https://raw.githubusercontent.com/tasmota/autoconf/main/%s_manifest.json", 3657552045u, 0, 72, &be_const_str_reverse);
+be_define_const_str(i2c_enabled, "i2c_enabled", 218388101u, 0, 11, &be_const_str_load);
 be_define_const_str(id, "id", 926444256u, 0, 2, NULL);
 be_define_const_str(if, "if", 959999494u, 50, 2, NULL);
-be_define_const_str(imax, "imax", 3084515410u, 0, 4, &be_const_str_resp_cmnd_str);
-be_define_const_str(imin, "imin", 2714127864u, 0, 4, &be_const_str_montserrat_font);
+be_define_const_str(imax, "imax", 3084515410u, 0, 4, NULL);
+be_define_const_str(imin, "imin", 2714127864u, 0, 4, &be_const_str_kv);
 be_define_const_str(import, "import", 288002260u, 66, 6, NULL);
-be_define_const_str(init, "init", 380752755u, 0, 4, &be_const_str_onsubmit_X3D_X27return_X20confirm_X28_X22This_X20will_X20cause_X20a_X20restart_X2E_X22_X29_X3B_X27_X3E);
-be_define_const_str(init_draw_line_dsc, "init_draw_line_dsc", 2507936040u, 0, 18, &be_const_str_json);
-be_define_const_str(input, "input", 4191711099u, 0, 5, &be_const_str_solidified);
-be_define_const_str(ins_goto, "ins_goto", 1342843963u, 0, 8, &be_const_str_listdir);
+be_define_const_str(init, "init", 380752755u, 0, 4, &be_const_str_round_end);
+be_define_const_str(init_draw_line_dsc, "init_draw_line_dsc", 2507936040u, 0, 18, &be_const_str__X7D);
+be_define_const_str(input, "input", 4191711099u, 0, 5, &be_const_str_load_templates);
+be_define_const_str(ins_goto, "ins_goto", 1342843963u, 0, 8, NULL);
 be_define_const_str(ins_ramp, "ins_ramp", 1068049360u, 0, 8, NULL);
-be_define_const_str(ins_time, "ins_time", 2980245553u, 0, 8, &be_const_str_readbytes);
-be_define_const_str(insert, "insert", 3332609576u, 0, 6, &be_const_str_write_bytes);
-be_define_const_str(instance, "instance", 193386898u, 0, 8, &be_const_str_wire_scan);
-be_define_const_str(instance_size, "instance_size", 4280269518u, 0, 13, &be_const_str_pop_path);
+be_define_const_str(ins_time, "ins_time", 2980245553u, 0, 8, NULL);
+be_define_const_str(insert, "insert", 3332609576u, 0, 6, NULL);
+be_define_const_str(instance, "instance", 193386898u, 0, 8, &be_const_str__X7Bs_X7DBatt_X20Current_X7Bm_X7D_X25_X2E1f_X20mA_X7Be_X7D);
+be_define_const_str(instance_size, "instance_size", 4280269518u, 0, 13, &be_const_str_wifi);
 be_define_const_str(int, "int", 2515107422u, 0, 3, NULL);
 be_define_const_str(internal_error, "internal_error", 2519158169u, 0, 14, NULL);
-be_define_const_str(introspect, "introspect", 164638290u, 0, 10, NULL);
-be_define_const_str(invalidate, "invalidate", 2649734928u, 0, 10, &be_const_str_set_style_text_font);
-be_define_const_str(io_error, "io_error", 1970281036u, 0, 8, NULL);
-be_define_const_str(ip, "ip", 1261996636u, 0, 2, NULL);
-be_define_const_str(is_dirty, "is_dirty", 418034110u, 0, 8, NULL);
-be_define_const_str(is_first_time, "is_first_time", 275242384u, 0, 13, &be_const_str_param);
-be_define_const_str(is_running, "is_running", 2226847261u, 0, 10, &be_const_str_length_X20in_X20bits_X20must_X20be_X20between_X200_X20and_X2032);
-be_define_const_str(isinstance, "isinstance", 3669352738u, 0, 10, NULL);
-be_define_const_str(isnan, "isnan", 2981347434u, 0, 5, NULL);
-be_define_const_str(isrunning, "isrunning", 1688182268u, 0, 9, &be_const_str_members);
+be_define_const_str(introspect, "introspect", 164638290u, 0, 10, &be_const_str_isrunning);
+be_define_const_str(invalidate, "invalidate", 2649734928u, 0, 10, &be_const_str_persist_X2E_p_X20is_X20not_X20a_X20map);
+be_define_const_str(io_error, "io_error", 1970281036u, 0, 8, &be_const_str_y);
+be_define_const_str(ip, "ip", 1261996636u, 0, 2, &be_const_str_x1);
+be_define_const_str(is_dirty, "is_dirty", 418034110u, 0, 8, &be_const_str_lv_solidified);
+be_define_const_str(is_first_time, "is_first_time", 275242384u, 0, 13, &be_const_str_isnan);
+be_define_const_str(is_running, "is_running", 2226847261u, 0, 10, &be_const_str_solidified);
+be_define_const_str(isinstance, "isinstance", 3669352738u, 0, 10, &be_const_str_rtc);
+be_define_const_str(isnan, "isnan", 2981347434u, 0, 5, &be_const_str_set_style_pad_right);
+be_define_const_str(isrunning, "isrunning", 1688182268u, 0, 9, NULL);
 be_define_const_str(issubclass, "issubclass", 4078395519u, 0, 10, NULL);
-be_define_const_str(item, "item", 2671260646u, 0, 4, NULL);
-be_define_const_str(iter, "iter", 3124256359u, 0, 4, &be_const_str_widget_event_impl);
-be_define_const_str(json, "json", 916562499u, 0, 4, &be_const_str_read24);
-be_define_const_str(json_append, "json_append", 3002019284u, 0, 11, &be_const_str_refr_size);
+be_define_const_str(item, "item", 2671260646u, 0, 4, &be_const_str_readbytes);
+be_define_const_str(iter, "iter", 3124256359u, 0, 4, NULL);
+be_define_const_str(json, "json", 916562499u, 0, 4, NULL);
+be_define_const_str(json_append, "json_append", 3002019284u, 0, 11, &be_const_str_print);
 be_define_const_str(json_fdump, "json_fdump", 1694216580u, 0, 10, NULL);
-be_define_const_str(json_fdump_any, "json_fdump_any", 3348629385u, 0, 14, &be_const_str_lv_wifi_bars_icon);
-be_define_const_str(json_fdump_list, "json_fdump_list", 3903879853u, 0, 15, &be_const_str_tob64);
-be_define_const_str(json_fdump_map, "json_fdump_map", 4091954653u, 0, 14, NULL);
-be_define_const_str(k, "k", 3993778410u, 0, 1, NULL);
-be_define_const_str(keys, "keys", 4182378701u, 0, 4, NULL);
+be_define_const_str(json_fdump_any, "json_fdump_any", 3348629385u, 0, 14, &be_const_str_map);
+be_define_const_str(json_fdump_list, "json_fdump_list", 3903879853u, 0, 15, NULL);
+be_define_const_str(json_fdump_map, "json_fdump_map", 4091954653u, 0, 14, &be_const_str_url_encode);
+be_define_const_str(k, "k", 3993778410u, 0, 1, &be_const_str_run_bat);
+be_define_const_str(keys, "keys", 4182378701u, 0, 4, &be_const_str_lv);
 be_define_const_str(kv, "kv", 1497177492u, 0, 2, NULL);
-be_define_const_str(last_modified, "last_modified", 772177145u, 0, 13, &be_const_str_set_x);
-be_define_const_str(leds, "leds", 558858555u, 0, 4, NULL);
-be_define_const_str(length_X20in_X20bits_X20must_X20be_X20between_X200_X20and_X2032, "length in bits must be between 0 and 32", 2584509128u, 0, 39, &be_const_str_onsubmit_X3D_X27return_X20confirm_X28_X22This_X20will_X20change_X20the_X20current_X20configuration_X20and_X20cause_X20a_X20restart_X2E_X22_X29_X3B_X27_X3E);
+be_define_const_str(last_modified, "last_modified", 772177145u, 0, 13, NULL);
+be_define_const_str(leds, "leds", 558858555u, 0, 4, &be_const_str_set_time);
+be_define_const_str(length_X20in_X20bits_X20must_X20be_X20between_X200_X20and_X2032, "length in bits must be between 0 and 32", 2584509128u, 0, 39, &be_const_str_set_style_line_color);
 be_define_const_str(light, "light", 3801947695u, 0, 5, NULL);
-be_define_const_str(line_dsc, "line_dsc", 4094490978u, 0, 8, &be_const_str_widget_struct_by_class);
-be_define_const_str(list, "list", 217798785u, 0, 4, &be_const_str_set_style_line_color);
-be_define_const_str(list_handlers, "list_handlers", 593774371u, 0, 13, &be_const_str_lv_event_cb);
+be_define_const_str(line_dsc, "line_dsc", 4094490978u, 0, 8, &be_const_str_toupper);
+be_define_const_str(list, "list", 217798785u, 0, 4, &be_const_str_resp_cmnd_done);
+be_define_const_str(list_handlers, "list_handlers", 593774371u, 0, 13, &be_const_str_read8);
 be_define_const_str(listdir, "listdir", 2005220720u, 0, 7, NULL);
-be_define_const_str(load, "load", 3859241449u, 0, 4, &be_const_str_math);
-be_define_const_str(load_freetype_font, "load_freetype_font", 2368447592u, 0, 18, NULL);
+be_define_const_str(load, "load", 3859241449u, 0, 4, &be_const_str_redirect);
+be_define_const_str(load_freetype_font, "load_freetype_font", 2368447592u, 0, 18, &be_const_str_page_autoconf_ctl);
 be_define_const_str(load_templates, "load_templates", 3513870133u, 0, 14, NULL);
-be_define_const_str(local, "local", 2621662984u, 0, 5, &be_const_str_offseta);
-be_define_const_str(log, "log", 1062293841u, 0, 3, NULL);
-be_define_const_str(log10, "log10", 2346846000u, 0, 5, &be_const_str_redirect);
-be_define_const_str(loop, "loop", 3723446379u, 0, 4, NULL);
-be_define_const_str(lower, "lower", 3038577850u, 0, 5, NULL);
-be_define_const_str(lv, "lv", 1529997255u, 0, 2, &be_const_str_strftime);
-be_define_const_str(lv_, "lv_", 663721032u, 0, 3, &be_const_str_obj_event_base);
-be_define_const_str(lv_clock_icon, "lv_clock_icon", 3257216210u, 0, 13, NULL);
-be_define_const_str(lv_event, "lv_event", 2434089968u, 0, 8, NULL);
-be_define_const_str(lv_event_cb, "lv_event_cb", 2480731016u, 0, 11, &be_const_str_register_obj);
-be_define_const_str(lv_module_init, "lv_module_init", 1133027755u, 0, 14, &be_const_str_write);
-be_define_const_str(lv_obj, "lv_obj", 4257833149u, 0, 6, &be_const_str_target);
+be_define_const_str(local, "local", 2621662984u, 0, 5, NULL);
+be_define_const_str(log, "log", 1062293841u, 0, 3, &be_const_str_lv_wifi_arcs_icon);
+be_define_const_str(log10, "log10", 2346846000u, 0, 5, NULL);
+be_define_const_str(loop, "loop", 3723446379u, 0, 4, &be_const_str_millis);
+be_define_const_str(lower, "lower", 3038577850u, 0, 5, &be_const_str_run_deferred);
+be_define_const_str(lv, "lv", 1529997255u, 0, 2, &be_const_str_resolvecmnd);
+be_define_const_str(lv_, "lv_", 663721032u, 0, 3, &be_const_str_widget_struct_by_class);
+be_define_const_str(lv_clock_icon, "lv_clock_icon", 3257216210u, 0, 13, &be_const_str_quality);
+be_define_const_str(lv_event, "lv_event", 2434089968u, 0, 8, &be_const_str_widget_event);
+be_define_const_str(lv_event_cb, "lv_event_cb", 2480731016u, 0, 11, NULL);
+be_define_const_str(lv_module_init, "lv_module_init", 1133027755u, 0, 14, NULL);
+be_define_const_str(lv_obj, "lv_obj", 4257833149u, 0, 6, &be_const_str_push);
 be_define_const_str(lv_obj_class, "lv_obj_class", 4039656294u, 0, 12, NULL);
 be_define_const_str(lv_signal_arcs, "lv_signal_arcs", 2839156988u, 0, 14, NULL);
-be_define_const_str(lv_signal_bars, "lv_signal_bars", 3513972559u, 0, 14, NULL);
-be_define_const_str(lv_wifi_arcs, "lv_wifi_arcs", 2082091963u, 0, 12, &be_const_str_rad);
-be_define_const_str(lv_wifi_arcs_icon, "lv_wifi_arcs_icon", 1507982909u, 0, 17, &be_const_str_try_rule);
+be_define_const_str(lv_signal_bars, "lv_signal_bars", 3513972559u, 0, 14, &be_const_str_sinh);
+be_define_const_str(lv_solidified, "lv_solidified", 2274121310u, 0, 13, &be_const_str_tasmota);
+be_define_const_str(lv_wifi_arcs, "lv_wifi_arcs", 2082091963u, 0, 12, &be_const_str_seg7_font);
+be_define_const_str(lv_wifi_arcs_icon, "lv_wifi_arcs_icon", 1507982909u, 0, 17, &be_const_str_pc_abs);
 be_define_const_str(lv_wifi_bars, "lv_wifi_bars", 2109539196u, 0, 12, NULL);
-be_define_const_str(lv_wifi_bars_icon, "lv_wifi_bars_icon", 2805815540u, 0, 17, NULL);
-be_define_const_str(lvgl_event_dispatch, "lvgl_event_dispatch", 2104396622u, 0, 19, &be_const_str_set_alternate);
-be_define_const_str(make_cb, "make_cb", 71252785u, 0, 7, &be_const_str_millis);
-be_define_const_str(map, "map", 3751997361u, 0, 3, NULL);
-be_define_const_str(math, "math", 4001929615u, 0, 4, &be_const_str_scale_uint);
-be_define_const_str(matrix, "matrix", 365099244u, 0, 6, &be_const_str_skip);
+be_define_const_str(lv_wifi_bars_icon, "lv_wifi_bars_icon", 2805815540u, 0, 17, &be_const_str_set_chg_current);
+be_define_const_str(lvgl_event_dispatch, "lvgl_event_dispatch", 2104396622u, 0, 19, &be_const_str_for);
+be_define_const_str(make_cb, "make_cb", 71252785u, 0, 7, NULL);
+be_define_const_str(map, "map", 3751997361u, 0, 3, &be_const_str_serial);
+be_define_const_str(math, "math", 4001929615u, 0, 4, &be_const_str_month);
+be_define_const_str(matrix, "matrix", 365099244u, 0, 6, NULL);
 be_define_const_str(member, "member", 719708611u, 0, 6, NULL);
-be_define_const_str(members, "members", 937576464u, 0, 7, NULL);
-be_define_const_str(memory, "memory", 2229924270u, 0, 6, &be_const_str_resp_cmnd);
+be_define_const_str(members, "members", 937576464u, 0, 7, &be_const_str_range);
+be_define_const_str(memory, "memory", 2229924270u, 0, 6, NULL);
 be_define_const_str(millis, "millis", 1214679063u, 0, 6, NULL);
 be_define_const_str(min, "min", 3381609815u, 0, 3, NULL);
-be_define_const_str(minute, "minute", 954666857u, 0, 6, &be_const_str_remote_port);
+be_define_const_str(minute, "minute", 954666857u, 0, 6, NULL);
 be_define_const_str(module, "module", 3617558685u, 0, 6, NULL);
-be_define_const_str(month, "month", 3598321157u, 0, 5, &be_const_str_sinh);
-be_define_const_str(montserrat_font, "montserrat_font", 1819065874u, 0, 15, NULL);
-be_define_const_str(name, "name", 2369371622u, 0, 4, NULL);
-be_define_const_str(nan, "nan", 797905850u, 0, 3, NULL);
+be_define_const_str(month, "month", 3598321157u, 0, 5, NULL);
+be_define_const_str(montserrat_font, "montserrat_font", 1819065874u, 0, 15, &be_const_str_seti);
+be_define_const_str(name, "name", 2369371622u, 0, 4, &be_const_str_set_auth);
+be_define_const_str(nan, "nan", 797905850u, 0, 3, &be_const_str_top);
 be_define_const_str(nil, "nil", 228849900u, 63, 3, NULL);
-be_define_const_str(no_X20GPIO_X20specified_X20for_X20neopixelbus, "no GPIO specified for neopixelbus", 42078528u, 0, 33, &be_const_str_tanh);
-be_define_const_str(null_cb, "null_cb", 2333536460u, 0, 7, &be_const_str_screenshot);
-be_define_const_str(number, "number", 467038368u, 0, 6, &be_const_str_p2);
+be_define_const_str(no_X20GPIO_X20specified_X20for_X20neopixelbus, "no GPIO specified for neopixelbus", 42078528u, 0, 33, NULL);
+be_define_const_str(null_cb, "null_cb", 2333536460u, 0, 7, &be_const_str_set_dc_voltage);
+be_define_const_str(number, "number", 467038368u, 0, 6, &be_const_str_settings);
 be_define_const_str(obj_class_create_obj, "obj_class_create_obj", 3304390632u, 0, 20, NULL);
 be_define_const_str(obj_event_base, "obj_event_base", 1624064363u, 0, 14, NULL);
-be_define_const_str(offset, "offset", 348705738u, 0, 6, NULL);
+be_define_const_str(offset, "offset", 348705738u, 0, 6, &be_const_str_signal_bars);
 be_define_const_str(offseta, "offseta", 1663383089u, 0, 7, NULL);
-be_define_const_str(on, "on", 1630810064u, 0, 2, NULL);
+be_define_const_str(on, "on", 1630810064u, 0, 2, &be_const_str_set_first_time);
 be_define_const_str(onsubmit_X3D_X27return_X20confirm_X28_X22This_X20will_X20cause_X20a_X20restart_X2E_X22_X29_X3B_X27_X3E, "onsubmit='return confirm(\"This will cause a restart.\");'>", 232646018u, 0, 57, NULL);
 be_define_const_str(onsubmit_X3D_X27return_X20confirm_X28_X22This_X20will_X20change_X20the_X20current_X20configuration_X20and_X20cause_X20a_X20restart_X2E_X22_X29_X3B_X27_X3E, "onsubmit='return confirm(\"This will change the current configuration and cause a restart.\");'>", 3792412559u, 0, 94, NULL);
-be_define_const_str(open, "open", 3546203337u, 0, 4, NULL);
-be_define_const_str(out_X20of_X20range, "out of range", 2236631477u, 0, 12, &be_const_str_run);
-be_define_const_str(p1, "p1", 2689521274u, 0, 2, NULL);
+be_define_const_str(open, "open", 3546203337u, 0, 4, &be_const_str_traceback);
+be_define_const_str(out_X20of_X20range, "out of range", 2236631477u, 0, 12, NULL);
+be_define_const_str(p1, "p1", 2689521274u, 0, 2, &be_const_str_web_add_main_button);
 be_define_const_str(p2, "p2", 2672743655u, 0, 2, NULL);
 be_define_const_str(page_autoconf_ctl, "page_autoconf_ctl", 2453381496u, 0, 17, NULL);
-be_define_const_str(page_autoconf_mgr, "page_autoconf_mgr", 3643937031u, 0, 17, NULL);
-be_define_const_str(param, "param", 1309554226u, 0, 5, &be_const_str_set_bri);
+be_define_const_str(page_autoconf_mgr, "page_autoconf_mgr", 3643937031u, 0, 17, &be_const_str_tr);
+be_define_const_str(param, "param", 1309554226u, 0, 5, &be_const_str_set_percentage);
 be_define_const_str(path, "path", 2223459638u, 0, 4, NULL);
-be_define_const_str(pc, "pc", 1313756516u, 0, 2, &be_const_str_widget_constructor);
-be_define_const_str(pc_abs, "pc_abs", 920256495u, 0, 6, NULL);
-be_define_const_str(pc_rel, "pc_rel", 991921176u, 0, 6, &be_const_str_return_X20code_X3D_X25i);
+be_define_const_str(pc, "pc", 1313756516u, 0, 2, NULL);
+be_define_const_str(pc_abs, "pc_abs", 920256495u, 0, 6, &be_const_str_target_search);
+be_define_const_str(pc_rel, "pc_rel", 991921176u, 0, 6, NULL);
 be_define_const_str(percentage, "percentage", 2538831285u, 0, 10, NULL);
 be_define_const_str(persist, "persist", 3917083779u, 0, 7, &be_const_str__X7B_X7D);
-be_define_const_str(persist_X2E_p_X20is_X20not_X20a_X20map, "persist._p is not a map", 1176528732u, 0, 23, &be_const_str_set_width);
-be_define_const_str(pi, "pi", 1213090802u, 0, 2, &be_const_str_strip);
-be_define_const_str(pin, "pin", 1866532500u, 0, 3, &be_const_str_as);
+be_define_const_str(persist_X2E_p_X20is_X20not_X20a_X20map, "persist._p is not a map", 1176528732u, 0, 23, &be_const_str_scan);
+be_define_const_str(pi, "pi", 1213090802u, 0, 2, NULL);
+be_define_const_str(pin, "pin", 1866532500u, 0, 3, NULL);
 be_define_const_str(pin_mode, "pin_mode", 3258314030u, 0, 8, NULL);
-be_define_const_str(pin_used, "pin_used", 4033854612u, 0, 8, &be_const_str_resize);
-be_define_const_str(pixel_count, "pixel_count", 2439130743u, 0, 11, &be_const_str_web_send_decimal);
-be_define_const_str(pixel_size, "pixel_size", 2209135785u, 0, 10, &be_const_str_set_ldo_voltage);
-be_define_const_str(pixels_buffer, "pixels_buffer", 1229555807u, 0, 13, NULL);
-be_define_const_str(point, "point", 414084241u, 0, 5, &be_const_str_set_auth);
-be_define_const_str(pop, "pop", 1362321360u, 0, 3, NULL);
+be_define_const_str(pin_used, "pin_used", 4033854612u, 0, 8, &be_const_str_rand);
+be_define_const_str(pixel_count, "pixel_count", 2439130743u, 0, 11, &be_const_str_sqrt);
+be_define_const_str(pixel_size, "pixel_size", 2209135785u, 0, 10, NULL);
+be_define_const_str(pixels_buffer, "pixels_buffer", 1229555807u, 0, 13, &be_const_str_strip);
+be_define_const_str(point, "point", 414084241u, 0, 5, &be_const_str_write_file);
+be_define_const_str(pop, "pop", 1362321360u, 0, 3, &be_const_str_remove_driver);
 be_define_const_str(pop_path, "pop_path", 2403243998u, 0, 8, NULL);
-be_define_const_str(pow, "pow", 1479764693u, 0, 3, NULL);
-be_define_const_str(preinit, "preinit", 2722007100u, 0, 7, NULL);
-be_define_const_str(print, "print", 372738696u, 0, 5, &be_const_str_resp_cmnd_error);
+be_define_const_str(pow, "pow", 1479764693u, 0, 3, &be_const_str_resp_cmnd_error);
+be_define_const_str(preinit, "preinit", 2722007100u, 0, 7, &be_const_str_set_x);
+be_define_const_str(print, "print", 372738696u, 0, 5, NULL);
 be_define_const_str(public_key, "public_key", 4169142980u, 0, 10, NULL);
-be_define_const_str(publish, "publish", 264247304u, 0, 7, NULL);
+be_define_const_str(publish, "publish", 264247304u, 0, 7, &be_const_str_register_obj);
 be_define_const_str(publish_result, "publish_result", 2013351252u, 0, 14, NULL);
-be_define_const_str(push, "push", 2272264157u, 0, 4, &be_const_str_send_multicast);
+be_define_const_str(push, "push", 2272264157u, 0, 4, &be_const_str_signal_arcs);
 be_define_const_str(push_path, "push_path", 1155254157u, 0, 9, NULL);
-be_define_const_str(quality, "quality", 2597670950u, 0, 7, &be_const_str__X7Bs_X7DVBus_X20Voltage_X7Bm_X7D_X25_X2E3f_X20V_X7Be_X7D);
-be_define_const_str(r, "r", 4144776981u, 0, 1, &be_const_str_set_style_pad_right);
-be_define_const_str(rad, "rad", 1358899048u, 0, 3, &be_const_str_save_before_restart);
+be_define_const_str(quality, "quality", 2597670950u, 0, 7, &be_const_str_rotate);
+be_define_const_str(r, "r", 4144776981u, 0, 1, NULL);
+be_define_const_str(rad, "rad", 1358899048u, 0, 3, &be_const_str_sec);
 be_define_const_str(raise, "raise", 1593437475u, 70, 5, NULL);
-be_define_const_str(rand, "rand", 2711325910u, 0, 4, &be_const_str_return);
-be_define_const_str(range, "range", 4208725202u, 0, 5, NULL);
+be_define_const_str(rand, "rand", 2711325910u, 0, 4, &be_const_str_import);
+be_define_const_str(range, "range", 4208725202u, 0, 5, &be_const_str_resp_cmnd);
 be_define_const_str(read, "read", 3470762949u, 0, 4, NULL);
-be_define_const_str(read12, "read12", 4291076970u, 0, 6, &be_const_str_value);
+be_define_const_str(read12, "read12", 4291076970u, 0, 6, &be_const_str_tomap);
 be_define_const_str(read13, "read13", 12887293u, 0, 6, NULL);
-be_define_const_str(read24, "read24", 1808533811u, 0, 6, &be_const_str_wd);
+be_define_const_str(read24, "read24", 1808533811u, 0, 6, NULL);
 be_define_const_str(read32, "read32", 1741276240u, 0, 6, NULL);
-be_define_const_str(read8, "read8", 2802788167u, 0, 5, &be_const_str_round_end);
-be_define_const_str(read_bytes, "read_bytes", 3576733173u, 0, 10, &be_const_str_split);
-be_define_const_str(read_sensors, "read_sensors", 892689201u, 0, 12, &be_const_str_remove_driver);
+be_define_const_str(read8, "read8", 2802788167u, 0, 5, &be_const_str_raise);
+be_define_const_str(read_bytes, "read_bytes", 3576733173u, 0, 10, &be_const_str_response_append);
+be_define_const_str(read_sensors, "read_sensors", 892689201u, 0, 12, NULL);
 be_define_const_str(readbytes, "readbytes", 2716426756u, 0, 9, NULL);
 be_define_const_str(readline, "readline", 1212709927u, 0, 8, NULL);
 be_define_const_str(real, "real", 3604983901u, 0, 4, NULL);
 be_define_const_str(reapply, "reapply", 3778939332u, 0, 7, NULL);
-be_define_const_str(redirect, "redirect", 389758641u, 0, 8, &be_const_str_x1);
-be_define_const_str(refr_size, "refr_size", 1958144468u, 0, 9, NULL);
+be_define_const_str(redirect, "redirect", 389758641u, 0, 8, NULL);
+be_define_const_str(refr_size, "refr_size", 1958144468u, 0, 9, &be_const_str_wire);
 be_define_const_str(register_button_encoder, "register_button_encoder", 2811301550u, 0, 23, NULL);
 be_define_const_str(register_obj, "register_obj", 3982614770u, 0, 12, NULL);
 be_define_const_str(remote_ip, "remote_ip", 2953154693u, 0, 9, NULL);
-be_define_const_str(remote_port, "remote_port", 2163585967u, 0, 11, &be_const_str_w);
-be_define_const_str(remove, "remove", 3683784189u, 0, 6, &be_const_str_import);
+be_define_const_str(remote_port, "remote_port", 2163585967u, 0, 11, NULL);
+be_define_const_str(remove, "remove", 3683784189u, 0, 6, NULL);
 be_define_const_str(remove_cmd, "remove_cmd", 3832315702u, 0, 10, NULL);
 be_define_const_str(remove_driver, "remove_driver", 1030243768u, 0, 13, NULL);
-be_define_const_str(remove_rule, "remove_rule", 3456211328u, 0, 11, &be_const_str_set);
+be_define_const_str(remove_rule, "remove_rule", 3456211328u, 0, 11, &be_const_str_set_timeouts);
 be_define_const_str(remove_timer, "remove_timer", 4141472215u, 0, 12, NULL);
 be_define_const_str(reset, "reset", 1695364032u, 0, 5, NULL);
 be_define_const_str(reset_search, "reset_search", 1350414305u, 0, 12, NULL);
 be_define_const_str(resize, "resize", 3514612129u, 0, 6, NULL);
-be_define_const_str(resolvecmnd, "resolvecmnd", 993361485u, 0, 11, &be_const_str_unknown_X20instruction);
-be_define_const_str(resp_cmnd, "resp_cmnd", 2869459626u, 0, 9, NULL);
-be_define_const_str(resp_cmnd_done, "resp_cmnd_done", 2601874875u, 0, 14, NULL);
+be_define_const_str(resolvecmnd, "resolvecmnd", 993361485u, 0, 11, &be_const_str_return_X20code_X3D_X25i);
+be_define_const_str(resp_cmnd, "resp_cmnd", 2869459626u, 0, 9, &be_const_str_tan);
+be_define_const_str(resp_cmnd_done, "resp_cmnd_done", 2601874875u, 0, 14, &be_const_str_set_style_text_font);
 be_define_const_str(resp_cmnd_error, "resp_cmnd_error", 2404088863u, 0, 15, NULL);
-be_define_const_str(resp_cmnd_failed, "resp_cmnd_failed", 2136281562u, 0, 16, NULL);
+be_define_const_str(resp_cmnd_failed, "resp_cmnd_failed", 2136281562u, 0, 16, &be_const_str_scale_uint);
 be_define_const_str(resp_cmnd_str, "resp_cmnd_str", 737845590u, 0, 13, NULL);
-be_define_const_str(response_append, "response_append", 450346371u, 0, 15, &be_const_str_url_encode);
+be_define_const_str(response_append, "response_append", 450346371u, 0, 15, NULL);
 be_define_const_str(return, "return", 2246981567u, 60, 6, NULL);
 be_define_const_str(return_X20code_X3D_X25i, "return code=%i", 2127454401u, 0, 14, NULL);
 be_define_const_str(reverse, "reverse", 558918661u, 0, 7, NULL);
 be_define_const_str(reverse_gamma10, "reverse_gamma10", 739112262u, 0, 15, NULL);
 be_define_const_str(rotate, "rotate", 2784296202u, 0, 6, NULL);
 be_define_const_str(round_end, "round_end", 985288225u, 0, 9, NULL);
-be_define_const_str(round_start, "round_start", 2949484384u, 0, 11, NULL);
-be_define_const_str(rtc, "rtc", 1070575216u, 0, 3, &be_const_str__X7D);
-be_define_const_str(rule, "rule", 4230889683u, 0, 4, &be_const_str_sec);
-be_define_const_str(run, "run", 718098122u, 0, 3, &be_const_str_set_percentage);
-be_define_const_str(run_bat, "run_bat", 2536903298u, 0, 7, &be_const_str_set_ldo_enable);
+be_define_const_str(round_start, "round_start", 2949484384u, 0, 11, &be_const_str_shared_key);
+be_define_const_str(rtc, "rtc", 1070575216u, 0, 3, NULL);
+be_define_const_str(rule, "rule", 4230889683u, 0, 4, NULL);
+be_define_const_str(run, "run", 718098122u, 0, 3, &be_const_str_tob64);
+be_define_const_str(run_bat, "run_bat", 2536903298u, 0, 7, NULL);
 be_define_const_str(run_deferred, "run_deferred", 371594696u, 0, 12, NULL);
 be_define_const_str(running, "running", 343848780u, 0, 7, NULL);
-be_define_const_str(save, "save", 3439296072u, 0, 4, &be_const_str_x);
-be_define_const_str(save_before_restart, "save_before_restart", 1253239338u, 0, 19, NULL);
+be_define_const_str(save, "save", 3439296072u, 0, 4, NULL);
+be_define_const_str(save_before_restart, "save_before_restart", 1253239338u, 0, 19, &be_const_str_wd);
 be_define_const_str(scale_uint, "scale_uint", 3090811094u, 0, 10, NULL);
-be_define_const_str(scan, "scan", 3974641896u, 0, 4, &be_const_str_set_pixel_color);
-be_define_const_str(screenshot, "screenshot", 3894592561u, 0, 10, NULL);
+be_define_const_str(scan, "scan", 3974641896u, 0, 4, &be_const_str_def);
+be_define_const_str(screenshot, "screenshot", 3894592561u, 0, 10, &be_const_str_setbits);
 be_define_const_str(search, "search", 2150836393u, 0, 6, NULL);
-be_define_const_str(sec, "sec", 3139892658u, 0, 3, &be_const_str_v);
-be_define_const_str(seg7_font, "seg7_font", 4099690689u, 0, 9, &be_const_str_widget_cb);
+be_define_const_str(sec, "sec", 3139892658u, 0, 3, &be_const_str_setrange);
+be_define_const_str(seg7_font, "seg7_font", 4099690689u, 0, 9, NULL);
 be_define_const_str(select, "select", 297952813u, 0, 6, NULL);
 be_define_const_str(send, "send", 1919010991u, 0, 4, NULL);
 be_define_const_str(send_multicast, "send_multicast", 812185870u, 0, 14, NULL);
-be_define_const_str(serial, "serial", 3687697785u, 0, 6, &be_const_str_break);
-be_define_const_str(set, "set", 3324446467u, 0, 3, &be_const_str__X7B);
+be_define_const_str(serial, "serial", 3687697785u, 0, 6, &be_const_str_widget_cb);
+be_define_const_str(set, "set", 3324446467u, 0, 3, NULL);
 be_define_const_str(set_alternate, "set_alternate", 1709680562u, 0, 13, NULL);
-be_define_const_str(set_auth, "set_auth", 1057170930u, 0, 8, &be_const_str_set_dcdc_enable);
+be_define_const_str(set_auth, "set_auth", 1057170930u, 0, 8, &be_const_str_do);
 be_define_const_str(set_bri, "set_bri", 2789118779u, 0, 7, NULL);
-be_define_const_str(set_chg_current, "set_chg_current", 336304386u, 0, 15, &be_const_str_traceback);
-be_define_const_str(set_dc_voltage, "set_dc_voltage", 2181981936u, 0, 14, &be_const_str_tr);
-be_define_const_str(set_dcdc_enable, "set_dcdc_enable", 1594690786u, 0, 15, NULL);
-be_define_const_str(set_first_time, "set_first_time", 3111247550u, 0, 14, NULL);
+be_define_const_str(set_chg_current, "set_chg_current", 336304386u, 0, 15, &be_const_str_show);
+be_define_const_str(set_dc_voltage, "set_dc_voltage", 2181981936u, 0, 14, NULL);
+be_define_const_str(set_dcdc_enable, "set_dcdc_enable", 1594690786u, 0, 15, &be_const_str_state);
+be_define_const_str(set_first_time, "set_first_time", 3111247550u, 0, 14, &be_const_str_update);
 be_define_const_str(set_height, "set_height", 1080207399u, 0, 10, NULL);
-be_define_const_str(set_ldo_enable, "set_ldo_enable", 2916502041u, 0, 14, &be_const_str_the_X20second_X20argument_X20is_X20not_X20a_X20function);
-be_define_const_str(set_ldo_voltage, "set_ldo_voltage", 4090501160u, 0, 15, &be_const_str_sin);
-be_define_const_str(set_light, "set_light", 3176076152u, 0, 9, NULL);
+be_define_const_str(set_ldo_enable, "set_ldo_enable", 2916502041u, 0, 14, NULL);
+be_define_const_str(set_ldo_voltage, "set_ldo_voltage", 4090501160u, 0, 15, &be_const_str_wifi_arcs_icon);
+be_define_const_str(set_light, "set_light", 3176076152u, 0, 9, &be_const_str_set_width);
 be_define_const_str(set_matrix_pixel_color, "set_matrix_pixel_color", 1197149462u, 0, 22, NULL);
-be_define_const_str(set_percentage, "set_percentage", 2952022724u, 0, 14, NULL);
+be_define_const_str(set_percentage, "set_percentage", 2952022724u, 0, 14, &be_const_str_except);
 be_define_const_str(set_pixel_color, "set_pixel_color", 1275248356u, 0, 15, NULL);
 be_define_const_str(set_power, "set_power", 549820893u, 0, 9, NULL);
 be_define_const_str(set_style_bg_color, "set_style_bg_color", 1689513089u, 0, 18, NULL);
 be_define_const_str(set_style_line_color, "set_style_line_color", 3665238976u, 0, 20, NULL);
-be_define_const_str(set_style_pad_right, "set_style_pad_right", 3314069054u, 0, 19, NULL);
-be_define_const_str(set_style_text_font, "set_style_text_font", 1028590019u, 0, 19, &be_const_str_write_gpio);
-be_define_const_str(set_text, "set_text", 1849641155u, 0, 8, &be_const_str_webserver);
-be_define_const_str(set_time, "set_time", 900236405u, 0, 8, &be_const_str_value_error);
-be_define_const_str(set_timeouts, "set_timeouts", 3732850900u, 0, 12, NULL);
-be_define_const_str(set_timer, "set_timer", 2135414533u, 0, 9, NULL);
-be_define_const_str(set_useragent, "set_useragent", 612237244u, 0, 13, NULL);
+be_define_const_str(set_style_pad_right, "set_style_pad_right", 3314069054u, 0, 19, &be_const_str_super);
+be_define_const_str(set_style_text_font, "set_style_text_font", 1028590019u, 0, 19, &be_const_str_elif);
+be_define_const_str(set_text, "set_text", 1849641155u, 0, 8, NULL);
+be_define_const_str(set_time, "set_time", 900236405u, 0, 8, NULL);
+be_define_const_str(set_timeouts, "set_timeouts", 3732850900u, 0, 12, &be_const_str_value);
+be_define_const_str(set_timer, "set_timer", 2135414533u, 0, 9, &be_const_str_the_X20second_X20argument_X20is_X20not_X20a_X20function);
+be_define_const_str(set_useragent, "set_useragent", 612237244u, 0, 13, &be_const_str_web_add_button);
 be_define_const_str(set_width, "set_width", 484671920u, 0, 9, NULL);
-be_define_const_str(set_x, "set_x", 1849400772u, 0, 5, NULL);
+be_define_const_str(set_x, "set_x", 1849400772u, 0, 5, &be_const_str_web_send);
 be_define_const_str(set_y, "set_y", 1866178391u, 0, 5, NULL);
-be_define_const_str(setbits, "setbits", 2762408167u, 0, 7, &be_const_str_seti);
+be_define_const_str(setbits, "setbits", 2762408167u, 0, 7, NULL);
 be_define_const_str(seti, "seti", 1500556254u, 0, 4, NULL);
-be_define_const_str(setitem, "setitem", 1554834596u, 0, 7, NULL);
+be_define_const_str(setitem, "setitem", 1554834596u, 0, 7, &be_const_str_str);
 be_define_const_str(setmember, "setmember", 1432909441u, 0, 9, NULL);
-be_define_const_str(setrange, "setrange", 3794019032u, 0, 8, &be_const_str_str);
-be_define_const_str(settings, "settings", 1745255176u, 0, 8, &be_const_str_wifi_arcs_icon);
-be_define_const_str(shared_key, "shared_key", 2200833624u, 0, 10, NULL);
-be_define_const_str(show, "show", 2840060476u, 0, 4, &be_const_str_wire1);
+be_define_const_str(setrange, "setrange", 3794019032u, 0, 8, NULL);
+be_define_const_str(settings, "settings", 1745255176u, 0, 8, &be_const_str_write_bit);
+be_define_const_str(shared_key, "shared_key", 2200833624u, 0, 10, &be_const_str_time_str);
+be_define_const_str(show, "show", 2840060476u, 0, 4, &be_const_str_string);
 be_define_const_str(signal_arcs, "signal_arcs", 1505996127u, 0, 11, NULL);
 be_define_const_str(signal_bars, "signal_bars", 3181573600u, 0, 11, NULL);
-be_define_const_str(sin, "sin", 3761252941u, 0, 3, NULL);
+be_define_const_str(sin, "sin", 3761252941u, 0, 3, &be_const_str_time_reached);
 be_define_const_str(sinh, "sinh", 282220607u, 0, 4, NULL);
-be_define_const_str(size, "size", 597743964u, 0, 4, &be_const_str_wifi);
-be_define_const_str(skip, "skip", 1097563074u, 0, 4, NULL);
-be_define_const_str(solidified, "solidified", 3257553487u, 0, 10, &be_const_str_time_reached);
+be_define_const_str(size, "size", 597743964u, 0, 4, NULL);
+be_define_const_str(skip, "skip", 1097563074u, 0, 4, &be_const_str_widget_editable);
+be_define_const_str(solidified, "solidified", 3257553487u, 0, 10, &be_const_str_tasmota_X2Eset_light_X28_X29_X20is_X20deprecated_X2C_X20use_X20light_X2Eset_X28_X29);
 be_define_const_str(split, "split", 2276994531u, 0, 5, NULL);
-be_define_const_str(sqrt, "sqrt", 2112764879u, 0, 4, &be_const_str_web_add_handler);
+be_define_const_str(sqrt, "sqrt", 2112764879u, 0, 4, NULL);
 be_define_const_str(srand, "srand", 465518633u, 0, 5, NULL);
 be_define_const_str(start, "start", 1697318111u, 0, 5, NULL);
 be_define_const_str(state, "state", 2016490230u, 0, 5, NULL);
 be_define_const_str(static, "static", 3532702267u, 71, 6, NULL);
-be_define_const_str(stop, "stop", 3411225317u, 0, 4, &be_const_str_if);
+be_define_const_str(stop, "stop", 3411225317u, 0, 4, &be_const_str_type);
 be_define_const_str(stop_iteration, "stop_iteration", 4173793901u, 0, 14, NULL);
-be_define_const_str(str, "str", 3259748752u, 0, 3, &be_const_str_widget_event_cb);
+be_define_const_str(str, "str", 3259748752u, 0, 3, NULL);
 be_define_const_str(strftime, "strftime", 187738851u, 0, 8, NULL);
-be_define_const_str(string, "string", 398550328u, 0, 6, NULL);
+be_define_const_str(string, "string", 398550328u, 0, 6, &be_const_str_write_gpio);
 be_define_const_str(strip, "strip", 4246411473u, 0, 5, NULL);
-be_define_const_str(strptime, "strptime", 1277910361u, 0, 8, &be_const_str_time_dump);
-be_define_const_str(super, "super", 4152230356u, 0, 5, NULL);
-be_define_const_str(sys, "sys", 3277365014u, 0, 3, &be_const_str_except);
+be_define_const_str(strptime, "strptime", 1277910361u, 0, 8, NULL);
+be_define_const_str(super, "super", 4152230356u, 0, 5, &be_const_str_widget_ctor_cb);
+be_define_const_str(sys, "sys", 3277365014u, 0, 3, NULL);
 be_define_const_str(tag, "tag", 2516003219u, 0, 3, NULL);
-be_define_const_str(tan, "tan", 2633446552u, 0, 3, &be_const_str__X7Bs_X7DVBus_X20Current_X7Bm_X7D_X25_X2E1f_X20mA_X7Be_X7D);
+be_define_const_str(tan, "tan", 2633446552u, 0, 3, &be_const_str_udp);
 be_define_const_str(tanh, "tanh", 153638352u, 0, 4, NULL);
-be_define_const_str(target, "target", 845187144u, 0, 6, NULL);
+be_define_const_str(target, "target", 845187144u, 0, 6, &be_const_str_w);
 be_define_const_str(target_search, "target_search", 1947846553u, 0, 13, NULL);
-be_define_const_str(tasmota, "tasmota", 424643812u, 0, 7, &be_const_str_widget_height_def);
-be_define_const_str(tasmota_X2Eget_light_X28_X29_X20is_X20deprecated_X2C_X20use_X20light_X2Eget_X28_X29, "tasmota.get_light() is deprecated, use light.get()", 3525753647u, 0, 50, &be_const_str_year);
+be_define_const_str(tasmota, "tasmota", 424643812u, 0, 7, NULL);
+be_define_const_str(tasmota_X2Eget_light_X28_X29_X20is_X20deprecated_X2C_X20use_X20light_X2Eget_X28_X29, "tasmota.get_light() is deprecated, use light.get()", 3525753647u, 0, 50, NULL);
 be_define_const_str(tasmota_X2Eset_light_X28_X29_X20is_X20deprecated_X2C_X20use_X20light_X2Eset_X28_X29, "tasmota.set_light() is deprecated, use light.set()", 2124937871u, 0, 50, NULL);
-be_define_const_str(tcpclient, "tcpclient", 3828797983u, 0, 9, &be_const_str_true);
+be_define_const_str(tcpclient, "tcpclient", 3828797983u, 0, 9, &be_const_str_tolower);
 be_define_const_str(tele, "tele", 3474458061u, 0, 4, NULL);
 be_define_const_str(the_X20second_X20argument_X20is_X20not_X20a_X20function, "the second argument is not a function", 3954574469u, 0, 37, NULL);
 be_define_const_str(time_dump, "time_dump", 3330410747u, 0, 9, NULL);
-be_define_const_str(time_reached, "time_reached", 2075136773u, 0, 12, &be_const_str_wire2);
+be_define_const_str(time_reached, "time_reached", 2075136773u, 0, 12, &be_const_str_try_rule);
 be_define_const_str(time_str, "time_str", 2613827612u, 0, 8, NULL);
 be_define_const_str(to_gamma, "to_gamma", 1597139862u, 0, 8, NULL);
 be_define_const_str(tob64, "tob64", 373777640u, 0, 5, NULL);
 be_define_const_str(tolower, "tolower", 1042520049u, 0, 7, NULL);
-be_define_const_str(tomap, "tomap", 612167626u, 0, 5, &be_const_str_write8);
+be_define_const_str(tomap, "tomap", 612167626u, 0, 5, &be_const_str__X7Bs_X7DVBus_X20Voltage_X7Bm_X7D_X25_X2E3f_X20V_X7Be_X7D);
 be_define_const_str(top, "top", 2802900028u, 0, 3, NULL);
-be_define_const_str(toptr, "toptr", 3379847454u, 0, 5, &be_const_str_webclient);
-be_define_const_str(tostring, "tostring", 2299708645u, 0, 8, &be_const_str_web_add_button);
+be_define_const_str(toptr, "toptr", 3379847454u, 0, 5, NULL);
+be_define_const_str(tostring, "tostring", 2299708645u, 0, 8, NULL);
 be_define_const_str(toupper, "toupper", 3691983576u, 0, 7, NULL);
 be_define_const_str(tr, "tr", 1195724803u, 0, 2, NULL);
-be_define_const_str(traceback, "traceback", 3385188109u, 0, 9, NULL);
+be_define_const_str(traceback, "traceback", 3385188109u, 0, 9, &be_const_str_return);
 be_define_const_str(true, "true", 1303515621u, 61, 4, NULL);
 be_define_const_str(try, "try", 2887626766u, 68, 3, NULL);
-be_define_const_str(try_rule, "try_rule", 1986449405u, 0, 8, NULL);
+be_define_const_str(try_rule, "try_rule", 1986449405u, 0, 8, &be_const_str__X7Bs_X7DBatt_X20Voltage_X7Bm_X7D_X25_X2E3f_X20V_X7Be_X7D);
 be_define_const_str(type, "type", 1361572173u, 0, 4, NULL);
 be_define_const_str(udp, "udp", 1253872004u, 0, 3, NULL);
 be_define_const_str(unknown_X20instruction, "unknown instruction", 1093911841u, 0, 19, NULL);
 be_define_const_str(update, "update", 672109684u, 0, 6, NULL);
 be_define_const_str(upper, "upper", 176974407u, 0, 5, NULL);
-be_define_const_str(url_encode, "url_encode", 528392145u, 0, 10, &be_const_str_for);
+be_define_const_str(url_encode, "url_encode", 528392145u, 0, 10, &be_const_str_wire1);
 be_define_const_str(v, "v", 4077666505u, 0, 1, NULL);
 be_define_const_str(value, "value", 1113510858u, 0, 5, NULL);
-be_define_const_str(value_error, "value_error", 773297791u, 0, 11, &be_const_str__X7Bs_X7DTemp_X20AXP_X7Bm_X7D_X25_X2E1f_X20_X26deg_X3BC_X7Be_X7D);
-be_define_const_str(valuer_error, "valuer_error", 2567947105u, 0, 12, &be_const_str_y);
+be_define_const_str(value_error, "value_error", 773297791u, 0, 11, NULL);
+be_define_const_str(valuer_error, "valuer_error", 2567947105u, 0, 12, NULL);
 be_define_const_str(var, "var", 2317739966u, 64, 3, NULL);
-be_define_const_str(w, "w", 4060888886u, 0, 1, &be_const_str_web_add_config_button);
+be_define_const_str(w, "w", 4060888886u, 0, 1, NULL);
 be_define_const_str(wd, "wd", 1531424278u, 0, 2, NULL);
-be_define_const_str(web_add_button, "web_add_button", 3537875058u, 0, 14, NULL);
-be_define_const_str(web_add_config_button, "web_add_config_button", 639674325u, 0, 21, &be_const_str_widget_dtor_cb);
+be_define_const_str(web_add_button, "web_add_button", 3537875058u, 0, 14, &be_const_str_web_sensor);
+be_define_const_str(web_add_config_button, "web_add_config_button", 639674325u, 0, 21, NULL);
 be_define_const_str(web_add_console_button, "web_add_console_button", 3481436192u, 0, 22, NULL);
-be_define_const_str(web_add_handler, "web_add_handler", 3990174962u, 0, 15, NULL);
+be_define_const_str(web_add_handler, "web_add_handler", 3990174962u, 0, 15, &be_const_str_wifi_arcs);
 be_define_const_str(web_add_main_button, "web_add_main_button", 3960367664u, 0, 19, NULL);
 be_define_const_str(web_add_management_button, "web_add_management_button", 2738877186u, 0, 25, NULL);
 be_define_const_str(web_send, "web_send", 2989941448u, 0, 8, NULL);
-be_define_const_str(web_send_decimal, "web_send_decimal", 1407210204u, 0, 16, NULL);
-be_define_const_str(web_sensor, "web_sensor", 2900096972u, 0, 10, NULL);
+be_define_const_str(web_send_decimal, "web_send_decimal", 1407210204u, 0, 16, &be_const_str_nil);
+be_define_const_str(web_sensor, "web_sensor", 2900096972u, 0, 10, &be_const_str_continue);
 be_define_const_str(webclient, "webclient", 4076389146u, 0, 9, NULL);
 be_define_const_str(webserver, "webserver", 1572454038u, 0, 9, NULL);
 be_define_const_str(while, "while", 231090382u, 53, 5, NULL);
-be_define_const_str(widget_cb, "widget_cb", 2763583055u, 0, 9, &be_const_str_widget_group_def);
+be_define_const_str(widget_cb, "widget_cb", 2763583055u, 0, 9, NULL);
 be_define_const_str(widget_constructor, "widget_constructor", 2543785934u, 0, 18, NULL);
-be_define_const_str(widget_ctor_cb, "widget_ctor_cb", 876007560u, 0, 14, &be_const_str_zero);
+be_define_const_str(widget_ctor_cb, "widget_ctor_cb", 876007560u, 0, 14, NULL);
 be_define_const_str(widget_ctor_impl, "widget_ctor_impl", 194252479u, 0, 16, NULL);
 be_define_const_str(widget_destructor, "widget_destructor", 4207388345u, 0, 17, NULL);
 be_define_const_str(widget_dtor_cb, "widget_dtor_cb", 3151545845u, 0, 14, NULL);
 be_define_const_str(widget_dtor_impl, "widget_dtor_impl", 520430610u, 0, 16, NULL);
 be_define_const_str(widget_editable, "widget_editable", 3821793286u, 0, 15, NULL);
-be_define_const_str(widget_event, "widget_event", 1951408186u, 0, 12, &be_const_str_raise);
-be_define_const_str(widget_event_cb, "widget_event_cb", 1508466754u, 0, 15, NULL);
+be_define_const_str(widget_event, "widget_event", 1951408186u, 0, 12, NULL);
+be_define_const_str(widget_event_cb, "widget_event_cb", 1508466754u, 0, 15, &be_const_str_if);
 be_define_const_str(widget_event_impl, "widget_event_impl", 2178430561u, 0, 17, NULL);
 be_define_const_str(widget_group_def, "widget_group_def", 1246968785u, 0, 16, NULL);
-be_define_const_str(widget_height_def, "widget_height_def", 3131667813u, 0, 17, &be_const_str_while);
+be_define_const_str(widget_height_def, "widget_height_def", 3131667813u, 0, 17, NULL);
 be_define_const_str(widget_instance_size, "widget_instance_size", 2055354779u, 0, 20, NULL);
-be_define_const_str(widget_struct_by_class, "widget_struct_by_class", 3806373842u, 0, 22, NULL);
-be_define_const_str(widget_struct_default, "widget_struct_default", 781673633u, 0, 21, &be_const_str_do);
-be_define_const_str(widget_width_def, "widget_width_def", 3986078862u, 0, 16, NULL);
-be_define_const_str(width, "width", 2508680735u, 0, 5, &be_const_str_write_bit);
+be_define_const_str(widget_struct_by_class, "widget_struct_by_class", 3806373842u, 0, 22, &be_const_str_wire2);
+be_define_const_str(widget_struct_default, "widget_struct_default", 781673633u, 0, 21, NULL);
+be_define_const_str(widget_width_def, "widget_width_def", 3986078862u, 0, 16, &be_const_str_false);
+be_define_const_str(width, "width", 2508680735u, 0, 5, NULL);
 be_define_const_str(width_def, "width_def", 1143717879u, 0, 9, NULL);
 be_define_const_str(wifi, "wifi", 120087624u, 0, 4, NULL);
 be_define_const_str(wifi_arcs, "wifi_arcs", 3838492904u, 0, 9, NULL);
-be_define_const_str(wifi_arcs_icon, "wifi_arcs_icon", 767180544u, 0, 14, &be_const_str__X7Bs_X7DBatt_X20Voltage_X7Bm_X7D_X25_X2E3f_X20V_X7Be_X7D);
+be_define_const_str(wifi_arcs_icon, "wifi_arcs_icon", 767180544u, 0, 14, &be_const_str_wire_scan);
 be_define_const_str(wifi_bars, "wifi_bars", 653141243u, 0, 9, NULL);
 be_define_const_str(wifi_bars_icon, "wifi_bars_icon", 3641522557u, 0, 14, NULL);
 be_define_const_str(wire, "wire", 4082753944u, 0, 4, NULL);
-be_define_const_str(wire1, "wire1", 3212721419u, 0, 5, NULL);
-be_define_const_str(wire2, "wire2", 3229499038u, 0, 5, NULL);
+be_define_const_str(wire1, "wire1", 3212721419u, 0, 5, &be_const_str_as);
+be_define_const_str(wire2, "wire2", 3229499038u, 0, 5, &be_const_str_yield);
 be_define_const_str(wire_scan, "wire_scan", 2671275880u, 0, 9, NULL);
 be_define_const_str(write, "write", 3190202204u, 0, 5, NULL);
-be_define_const_str(write8, "write8", 3133991532u, 0, 6, &be_const_str_var);
+be_define_const_str(write8, "write8", 3133991532u, 0, 6, NULL);
 be_define_const_str(write_bit, "write_bit", 2660990436u, 0, 9, NULL);
 be_define_const_str(write_bytes, "write_bytes", 1227543792u, 0, 11, NULL);
-be_define_const_str(write_file, "write_file", 3177658879u, 0, 10, &be_const_str_yield);
+be_define_const_str(write_file, "write_file", 3177658879u, 0, 10, NULL);
 be_define_const_str(write_gpio, "write_gpio", 2267940334u, 0, 10, NULL);
 be_define_const_str(x, "x", 4245442695u, 0, 1, NULL);
 be_define_const_str(x1, "x1", 274927234u, 0, 2, NULL);
 be_define_const_str(y, "y", 4228665076u, 0, 1, NULL);
 be_define_const_str(y1, "y1", 2355101727u, 0, 2, NULL);
-be_define_const_str(year, "year", 2927578396u, 0, 4, NULL);
+be_define_const_str(year, "year", 2927578396u, 0, 4, &be_const_str_while);
 be_define_const_str(yield, "yield", 1821831854u, 0, 5, NULL);
 be_define_const_str(zero, "zero", 2339366755u, 0, 4, NULL);
 be_define_const_str(zip, "zip", 2877453236u, 0, 3, NULL);
@@ -770,383 +771,384 @@ be_define_const_str(_X7B_X7D, "{}", 1415952421u, 0, 2, NULL);
 be_define_const_str(_X7D, "}", 4161554600u, 0, 1, NULL);
 
 static const bstring* const m_string_table[] = {
+    (const bstring *)&be_const_str_destructor_cb,
+    (const bstring *)&be_const_str_MD5,
+    (const bstring *)&be_const_str__X3Cp_X3E_X3Cform_X20id_X3Dzip_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20action_X3D_X27_X2Fac_X27_X20method_X3D_X27post_X27_X20,
+    (const bstring *)&be_const_str_concat,
+    (const bstring *)&be_const_str_web_add_handler,
+    (const bstring *)&be_const_str_ctypes_bytes_dyn,
     (const bstring *)&be_const_str_OneWire,
     NULL,
-    (const bstring *)&be_const_str_sqrt,
-    (const bstring *)&be_const_str__X26lt_X3BNone_X26gt_X3B,
-    (const bstring *)&be_const_str_SERIAL_6E2,
-    (const bstring *)&be_const_str__X2E,
+    (const bstring *)&be_const_str_STATE_DEFAULT,
+    (const bstring *)&be_const_str_content_flush,
     NULL,
-    (const bstring *)&be_const_str_setbits,
-    (const bstring *)&be_const_str_remove,
-    (const bstring *)&be_const_str_draw_arc,
-    (const bstring *)&be_const_str_state,
-    (const bstring *)&be_const_str_atleast1,
+    (const bstring *)&be_const_str_internal_error,
+    (const bstring *)&be_const_str_I2C_Driver,
+    (const bstring *)&be_const_str__X20,
+    (const bstring *)&be_const_str_lv_obj_class,
+    (const bstring *)&be_const_str_get_bat_power,
+    (const bstring *)&be_const_str__X25s_X2Eautoconf,
+    (const bstring *)&be_const_str_display,
     NULL,
-    (const bstring *)&be_const_str___upper__,
-    (const bstring *)&be_const_str_base_class,
-    (const bstring *)&be_const_str_SERIAL_5O1,
-    (const bstring *)&be_const_str_CFG_X3A_X20loaded_X20_X20,
-    (const bstring *)&be_const_str__p,
-    (const bstring *)&be_const_str_SERIAL_8E2,
-    (const bstring *)&be_const_str_begin_multicast,
     NULL,
-    (const bstring *)&be_const_str_SERIAL_5E2,
-    (const bstring *)&be_const_str_wifi_bars_icon,
-    (const bstring *)&be_const_str_depower,
-    (const bstring *)&be_const_str__X5D,
-    (const bstring *)&be_const_str_no_X20GPIO_X20specified_X20for_X20neopixelbus,
-    (const bstring *)&be_const_str_AudioGenerator,
-    (const bstring *)&be_const_str__X2F_X3Frst_X3D,
-    (const bstring *)&be_const_str___iterator__,
-    (const bstring *)&be_const_str_rotate,
-    (const bstring *)&be_const_str_get_style_line_color,
-    (const bstring *)&be_const_str__X0A,
-    (const bstring *)&be_const_str_pop,
-    (const bstring *)&be_const_str_contains,
-    (const bstring *)&be_const_str_COLOR_BLACK,
-    (const bstring *)&be_const_str_files,
     NULL,
-    (const bstring *)&be_const_str_begin,
-    (const bstring *)&be_const_str_CFG_X3A_X20removing_X20autoconf_X20files,
+    (const bstring *)&be_const_str_x,
+    (const bstring *)&be_const_str__X3Clabel_X3EChoose_X20a_X20device_X20configuration_X3A_X3C_X2Flabel_X3E_X3Cbr_X3E,
+    (const bstring *)&be_const_str_is_running,
+    (const bstring *)&be_const_str_draw_line_dsc_init,
+    (const bstring *)&be_const_str_out_X20of_X20range,
+    (const bstring *)&be_const_str__X2Etapp,
+    (const bstring *)&be_const_str_get,
+    (const bstring *)&be_const_str__X3C_X3D,
+    (const bstring *)&be_const_str__X3D_X3C_X3E_X21,
+    (const bstring *)&be_const_str_Parameter_X20error,
+    (const bstring *)&be_const_str_connect,
+    (const bstring *)&be_const_str__archive,
+    (const bstring *)&be_const_str_getbits,
+    (const bstring *)&be_const_str_detected_X20on_X20bus,
+    (const bstring *)&be_const_str_AudioFileSourceFS,
+    (const bstring *)&be_const_str_hex,
     NULL,
-    (const bstring *)&be_const_str_select,
+    (const bstring *)&be_const_str_nan,
+    (const bstring *)&be_const_str_open,
+    (const bstring *)&be_const_str_draw_line,
+    (const bstring *)&be_const_str_CFG_X3A_X20loading_X20_X27_X25s_X27,
+    (const bstring *)&be_const_str_EVENT_DRAW_PART_END,
+    (const bstring *)&be_const_str_point,
+    (const bstring *)&be_const_str_publish_result,
     (const bstring *)&be_const_str_get_style_bg_color,
-    (const bstring *)&be_const_str__X2Elen,
-    (const bstring *)&be_const_str_animators,
+    (const bstring *)&be_const_str_EVENT_DRAW_MAIN,
+    (const bstring *)&be_const_str_POST,
+    (const bstring *)&be_const_str_Timer,
+    NULL,
+    (const bstring *)&be_const_str_Tasmota,
+    (const bstring *)&be_const_str__X23init_X2Ebat,
+    (const bstring *)&be_const_str__X3Cp_X3E_X3C_X2Fp_X3E_X3C_X2Ffieldset_X3E_X3Cp_X3E_X3C_X2Fp_X3E,
+    (const bstring *)&be_const_str_page_autoconf_mgr,
+    (const bstring *)&be_const_str__class,
+    (const bstring *)&be_const_str_char,
+    (const bstring *)&be_const_str__X2Ep1,
+    (const bstring *)&be_const_str_clear_first_time,
+    (const bstring *)&be_const_str_int,
+    (const bstring *)&be_const_str_web_add_config_button,
+    NULL,
+    NULL,
+    (const bstring *)&be_const_str__error,
+    (const bstring *)&be_const_str__X2D_X2D_X3A_X2D_X2D,
+    (const bstring *)&be_const_str_delay,
+    (const bstring *)&be_const_str_pixel_size,
+    (const bstring *)&be_const_str_onsubmit_X3D_X27return_X20confirm_X28_X22This_X20will_X20cause_X20a_X20restart_X2E_X22_X29_X3B_X27_X3E,
+    (const bstring *)&be_const_str__drivers,
+    (const bstring *)&be_const_str_AudioFileSource,
+    (const bstring *)&be_const_str_,
+    (const bstring *)&be_const_str_del,
+    NULL,
+    NULL,
+    (const bstring *)&be_const_str_width_def,
+    (const bstring *)&be_const_str_find,
+    (const bstring *)&be_const_str_SERIAL_8E2,
+    (const bstring *)&be_const_str__X21_X3D_X3D,
     (const bstring *)&be_const_str__X2Ep2,
     NULL,
-    (const bstring *)&be_const_str_floor,
-    (const bstring *)&be_const_str__X3Cinstance_X3A_X20_X25s_X28_X25s_X2C_X20_X25s_X2C_X20_X25s_X29,
-    (const bstring *)&be_const_str_Animate_X20pc_X20is_X20out_X20of_X20range,
-    (const bstring *)&be_const_str_push_path,
-    NULL,
-    (const bstring *)&be_const_str__X2Esize,
-    (const bstring *)&be_const_str__X25s_X2Eautoconf,
-    (const bstring *)&be_const_str_WS2812_GRB,
-    NULL,
-    NULL,
-    NULL,
-    (const bstring *)&be_const_str_show,
-    (const bstring *)&be_const_str_delete_all_configs,
-    (const bstring *)&be_const_str_Leds,
-    (const bstring *)&be_const_str__X3Cfieldset_X3E_X3Cstyle_X3E_X2Ebdis_X7Bbackground_X3A_X23888_X3B_X7D_X2Ebdis_X3Ahover_X7Bbackground_X3A_X23888_X3B_X7D_X3C_X2Fstyle_X3E,
-    (const bstring *)&be_const_str_cos,
-    (const bstring *)&be_const_str_flush,
-    (const bstring *)&be_const_str_engine,
-    (const bstring *)&be_const_str__X21_X3D_X3D,
-    NULL,
-    NULL,
-    (const bstring *)&be_const_str_page_autoconf_mgr,
-    NULL,
-    (const bstring *)&be_const_str_stop,
-    NULL,
-    (const bstring *)&be_const_str__X3F,
-    (const bstring *)&be_const_str__archive,
-    (const bstring *)&be_const_str_chars_in_string,
-    (const bstring *)&be_const_str__X3D_X3D,
-    (const bstring *)&be_const_str_closure,
-    NULL,
-    (const bstring *)&be_const_str_font_seg7,
-    (const bstring *)&be_const_str_imin,
-    (const bstring *)&be_const_str__request_from,
-    (const bstring *)&be_const_str_BRY_X3A_X20could_X20not_X20save_X20compiled_X20file_X20_X25s_X20_X28_X25s_X29,
-    (const bstring *)&be_const_str_upper,
-    (const bstring *)&be_const_str_deg,
-    (const bstring *)&be_const_str_SERIAL_6E1,
-    (const bstring *)&be_const_str__X3C_X2Fform_X3E_X3C_X2Fp_X3E,
-    (const bstring *)&be_const_str__X2D_X2D_X3A_X2D_X2D,
-    (const bstring *)&be_const_str_add_driver,
-    (const bstring *)&be_const_str_decompress,
-    (const bstring *)&be_const_str_deregister_obj,
-    (const bstring *)&be_const_str_is_first_time,
-    (const bstring *)&be_const_str_b,
-    (const bstring *)&be_const_str_issubclass,
-    (const bstring *)&be_const_str_BUTTON_CONFIGURATION,
-    (const bstring *)&be_const_str__X3A,
-    (const bstring *)&be_const_str_internal_error,
-    (const bstring *)&be_const_str__global_def,
-    NULL,
-    (const bstring *)&be_const_str_bool,
-    (const bstring *)&be_const_str_light,
-    (const bstring *)&be_const_str_eth,
-    (const bstring *)&be_const_str_rand,
-    (const bstring *)&be_const_str_display_X2Eini,
-    (const bstring *)&be_const_str__X3Clambda_X3E,
-    (const bstring *)&be_const_str_lv_obj,
-    (const bstring *)&be_const_str_web_add_management_button,
-    (const bstring *)&be_const_str_SERIAL_6O2,
-    (const bstring *)&be_const_str__def,
-    (const bstring *)&be_const_str__dirty,
-    (const bstring *)&be_const_str__X26lt_X3BError_X3A_X20apply_X20new_X20or_X20remove_X26gt_X3B,
-    (const bstring *)&be_const_str_toupper,
-    (const bstring *)&be_const_str_alternate,
-    (const bstring *)&be_const_str__X21_X3D,
-    (const bstring *)&be_const_str_OPTION_A,
-    NULL,
-    (const bstring *)&be_const_str_CFG_X3A_X20could_X20not_X20run_X20_X25s_X20_X28_X25s_X20_X2D_X20_X25s_X29,
-    (const bstring *)&be_const_str_EC_C25519,
-    (const bstring *)&be_const_str_SERIAL_8N1,
-    (const bstring *)&be_const_str_fromstring,
-    (const bstring *)&be_const_str_lv,
-    NULL,
-    NULL,
-    (const bstring *)&be_const_str_run_bat,
-    (const bstring *)&be_const_str_widget_dtor_impl,
-    (const bstring *)&be_const_str__X2Ep1,
-    (const bstring *)&be_const_str_decrypt,
-    (const bstring *)&be_const_str__X5B,
-    (const bstring *)&be_const_str_EVENT_DRAW_PART_END,
-    (const bstring *)&be_const_str__X3Coption_X20value_X3D_X27reset_X27_X3E_X26lt_X3BRemove_X20autoconf_X26gt_X3B_X3C_X2Foption_X3E,
-    NULL,
-    (const bstring *)&be_const_str__X2Etapp,
-    (const bstring *)&be_const_str_Auto_X2Dconfiguration,
-    (const bstring *)&be_const_str__X2F_X2Eautoconf,
-    (const bstring *)&be_const_str_pin_mode,
+    (const bstring *)&be_const_str_from_to,
     (const bstring *)&be_const_str_addr,
-    (const bstring *)&be_const_str_load_templates,
-    (const bstring *)&be_const_str_setitem,
-    (const bstring *)&be_const_str_GET,
-    (const bstring *)&be_const_str_CFG_X3A_X20skipping_X20_X27display_X2Eini_X27_X20because_X20already_X20present_X20in_X20file_X2Dsystem,
-    (const bstring *)&be_const_str__rules,
-    (const bstring *)&be_const_str_AudioFileSource,
-    NULL,
-    (const bstring *)&be_const_str_CFG_X3A_X20_X27init_X2Ebat_X27_X20done_X2C_X20restarting,
-    NULL,
-    (const bstring *)&be_const_str_read13,
-    (const bstring *)&be_const_str_CFG_X3A_X20removing_X20first_X20time_X20marker,
-    (const bstring *)&be_const_str_set_height,
-    (const bstring *)&be_const_str_read8,
-    (const bstring *)&be_const_str_f,
-    (const bstring *)&be_const_str_scan,
-    (const bstring *)&be_const_str_SERIAL_7N2,
-    (const bstring *)&be_const_str__X3C_X3D,
-    (const bstring *)&be_const_str_SERIAL_5O2,
-    (const bstring *)&be_const_str__X2E_X2E,
-    (const bstring *)&be_const_str_iter,
-    (const bstring *)&be_const_str_SERIAL_8E1,
-    (const bstring *)&be_const_str_geti,
-    (const bstring *)&be_const_str_CFG_X3A_X20loading_X20,
-    (const bstring *)&be_const_str__anonymous_,
-    (const bstring *)&be_const_str_tan,
+    (const bstring *)&be_const_str_remote_port,
+    (const bstring *)&be_const_str_webclient,
+    (const bstring *)&be_const_str_json_fdump_map,
     (const bstring *)&be_const_str_every_100ms,
-    (const bstring *)&be_const_str_abs,
-    (const bstring *)&be_const_str_get_switch,
-    (const bstring *)&be_const_str_content_start,
-    NULL,
-    (const bstring *)&be_const_str_bri,
-    (const bstring *)&be_const_str_SERIAL_6N1,
-    (const bstring *)&be_const_str__X3Cp_X3E_X3Cform_X20id_X3Dzip_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20action_X3D_X27_X2Fac_X27_X20method_X3D_X27post_X27_X20,
-    (const bstring *)&be_const_str_battery_present,
-    (const bstring *)&be_const_str__X3Cp_X3E_X3Cform_X20id_X3Dreapply_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20action_X3D_X27_X2Fac_X27_X20method_X3D_X27post_X27_X20,
-    (const bstring *)&be_const_str_print,
-    NULL,
-    (const bstring *)&be_const_str_COLOR_WHITE,
-    (const bstring *)&be_const_str_BRY_X3A_X20Exception_X3E_X20_X27_X25s_X27_X20_X2D_X20_X25s,
-    (const bstring *)&be_const_str_couldn_X27t_X20not_X20initialize_X20noepixelbus,
-    (const bstring *)&be_const_str_SERIAL_5N1,
-    (const bstring *)&be_const_str_set_light,
-    (const bstring *)&be_const_str__X23init_X2Ebat,
-    (const bstring *)&be_const_str_BRY_X3A_X20ERROR_X2C_X20bad_X20json_X3A_X20,
-    NULL,
-    (const bstring *)&be_const_str_LVG_X3A_X20call_X20to_X20unsupported_X20callback,
-    (const bstring *)&be_const_str__X2Ebe,
-    (const bstring *)&be_const_str_content_send_style,
-    (const bstring *)&be_const_str__,
-    NULL,
-    (const bstring *)&be_const_str_create_matrix,
-    NULL,
-    (const bstring *)&be_const_str__X2Ep,
-    (const bstring *)&be_const_str_clear,
-    (const bstring *)&be_const_str_widget_width_def,
-    NULL,
-    (const bstring *)&be_const_str_CFG_X3A_X20running_X20,
-    (const bstring *)&be_const_str_dac_voltage,
-    (const bstring *)&be_const_str_widget_destructor,
-    (const bstring *)&be_const_str_deinit,
-    (const bstring *)&be_const_str__X23autoexec_X2Ebat,
-    (const bstring *)&be_const_str_SERIAL_8N2,
-    (const bstring *)&be_const_str_PART_MAIN,
-    (const bstring *)&be_const_str_autorun,
-    (const bstring *)&be_const_str__error,
-    (const bstring *)&be_const_str_instance,
-    (const bstring *)&be_const_str_publish_result,
-    (const bstring *)&be_const_str_draw_line,
-    (const bstring *)&be_const_str__begin_transmission,
-    (const bstring *)&be_const_str_ceil,
-    (const bstring *)&be_const_str_cosh,
-    (const bstring *)&be_const_str__ptr,
-    (const bstring *)&be_const_str_open,
-    (const bstring *)&be_const_str_ctor,
-    (const bstring *)&be_const_str__X2Ew,
-    NULL,
-    (const bstring *)&be_const_str_isnan,
     (const bstring *)&be_const_str_I2C_X3A,
-    (const bstring *)&be_const_str_byte,
-    (const bstring *)&be_const_str_escape,
-    (const bstring *)&be_const_str__X23autoexec_X2Ebe,
-    (const bstring *)&be_const_str_else,
-    (const bstring *)&be_const_str__X3C_X2Fselect_X3E_X3Cp_X3E_X3C_X2Fp_X3E,
-    (const bstring *)&be_const_str_AXP192,
-    (const bstring *)&be_const_str_send,
-    (const bstring *)&be_const_str__settings_ptr,
-    (const bstring *)&be_const_str__X2C,
+    (const bstring *)&be_const_str_BRY_X3A_X20Exception_X3E_X20_X27_X25s_X27_X20_X2D_X20_X25s,
+    (const bstring *)&be_const_str__ccmd,
+    (const bstring *)&be_const_str_button_pressed,
+    (const bstring *)&be_const_str_file_X20extension_X20is_X20not_X20_X27_X2Ebe_X27_X20or_X20_X27_X2Ebec_X27,
+    (const bstring *)&be_const_str_name,
     NULL,
-    (const bstring *)&be_const_str__settings_def,
+    (const bstring *)&be_const_str__X3Clambda_X3E,
     NULL,
-    (const bstring *)&be_const_str_debug,
-    (const bstring *)&be_const_str_json_fdump,
-    (const bstring *)&be_const_str_a,
-    (const bstring *)&be_const_str__X2Ebec,
-    (const bstring *)&be_const_str_SERIAL_7N1,
-    (const bstring *)&be_const_str_dump,
-    (const bstring *)&be_const_str_width,
-    (const bstring *)&be_const_str_SERIAL_7O2,
-    (const bstring *)&be_const_str_compress,
-    (const bstring *)&be_const_str_pin_used,
+    (const bstring *)&be_const_str_lv_clock_icon,
+    (const bstring *)&be_const_str__X3Cinstance_X3A_X20_X25s_X28_X25s_X2C_X20_X25s_X2C_X20_X25s_X29,
     NULL,
-    (const bstring *)&be_const_str__X3Cselect_X20name_X3D_X27zip_X27_X3E,
+    (const bstring *)&be_const_str__X3Clegend_X3E_X3Cb_X20title_X3D_X27New_X20autoconf_X27_X3E_X26nbsp_X3BSelect_X20new_X20auto_X2Dconfiguration_X3C_X2Fb_X3E_X3C_X2Flegend_X3E,
+    (const bstring *)&be_const_str_COLOR_WHITE,
     NULL,
-    (const bstring *)&be_const_str_attrdump,
-    (const bstring *)&be_const_str_update,
+    (const bstring *)&be_const_str_AES_GCM,
+    (const bstring *)&be_const_str__X0A,
+    (const bstring *)&be_const_str_copy,
+    (const bstring *)&be_const_str_add_handler,
+    (const bstring *)&be_const_str_animate,
     NULL,
-    (const bstring *)&be_const_str__X2Eautoconf,
-    (const bstring *)&be_const_str_SERIAL_6O1,
-    (const bstring *)&be_const_str__X2B,
-    (const bstring *)&be_const_str__X3Cp_X3E_X3C_X2Fp_X3E_X3C_X2Ffieldset_X3E_X3Cp_X3E_X3C_X2Fp_X3E,
-    (const bstring *)&be_const_str__X3Cp_X3ECurrent_X20configuration_X3A_X20_X3C_X2Fp_X3E_X3Cp_X3E_X3Cb_X3E_X25s_X3C_X2Fb_X3E_X3C_X2Fp_X3E,
-    (const bstring *)&be_const_str_get_temp,
-    (const bstring *)&be_const_str__X28_X29,
-    (const bstring *)&be_const_str_format,
-    (const bstring *)&be_const_str_content_flush,
-    (const bstring *)&be_const_str_codedump,
-    (const bstring *)&be_const_str_BRY_X3A_X20failed_X20to_X20load_X20_persist_X2Ejson,
-    (const bstring *)&be_const_str_count,
-    (const bstring *)&be_const_str__X3Clabel_X3EChoose_X20a_X20device_X20configuration_X3A_X3C_X2Flabel_X3E_X3Cbr_X3E,
-    (const bstring *)&be_const_str_CFG_X3A_X20ran_X20_X20,
-    (const bstring *)&be_const_str_continue,
+    (const bstring *)&be_const_str_offset,
     NULL,
-    (const bstring *)&be_const_str_detect,
-    (const bstring *)&be_const_str_area,
-    (const bstring *)&be_const_str_item,
-    (const bstring *)&be_const_str_wifi_arcs,
-    (const bstring *)&be_const_str__X23display_X2Eini,
-    (const bstring *)&be_const_str_start,
-    (const bstring *)&be_const_str_member,
-    (const bstring *)&be_const_str_write_file,
-    (const bstring *)&be_const_str_EVENT_DRAW_MAIN,
+    (const bstring *)&be_const_str_SERIAL_8N2,
+    (const bstring *)&be_const_str_b,
+    (const bstring *)&be_const_str_pi,
+    (const bstring *)&be_const_str_set,
+    (const bstring *)&be_const_str__X2Ew,
+    (const bstring *)&be_const_str__X2E_X2E,
+    (const bstring *)&be_const_str_log10,
+    (const bstring *)&be_const_str_SERIAL_5N2,
     NULL,
     (const bstring *)&be_const_str__X3Cbutton_X20name_X3D_X27zipapply_X27_X20class_X3D_X27button_X20bgrn_X27_X3EApply_X20configuration_X3C_X2Fbutton_X3E,
-    (const bstring *)&be_const_str_acos,
-    (const bstring *)&be_const_str_try,
-    (const bstring *)&be_const_str_target_search,
-    (const bstring *)&be_const_str_k,
-    (const bstring *)&be_const_str_tostring,
-    (const bstring *)&be_const_str_time_str,
-    (const bstring *)&be_const_str_lv_obj_class,
-    (const bstring *)&be_const_str_size,
-    (const bstring *)&be_const_str_widget_ctor_cb,
-    (const bstring *)&be_const_str_get_bat_current,
-    (const bstring *)&be_const_str__X20,
     NULL,
-    (const bstring *)&be_const_str__X3E_X3D,
-    (const bstring *)&be_const_str_clear_to,
-    (const bstring *)&be_const_str_module,
-    (const bstring *)&be_const_str_close,
-    (const bstring *)&be_const_str_AudioFileSourceFS,
-    (const bstring *)&be_const_str_get_size,
-    (const bstring *)&be_const_str_get_aps_voltage,
-    (const bstring *)&be_const_str__X3D,
-    (const bstring *)&be_const_str_gamma8,
-    (const bstring *)&be_const_str__X3Cp_X20style_X3D_X27width_X3A340px_X3B_X27_X3E_X3Cb_X3EException_X3A_X3C_X2Fb_X3E_X3Cbr_X3E_X27_X25s_X27_X3Cbr_X3E_X25s_X3C_X2Fp_X3E,
-    (const bstring *)&be_const_str__X3Clegend_X3E_X3Cb_X20title_X3D_X27Autoconfiguration_X27_X3E_X26nbsp_X3BCurrent_X20auto_X2Dconfiguration_X3C_X2Fb_X3E_X3C_X2Flegend_X3E,
-    (const bstring *)&be_const_str_Tele,
-    (const bstring *)&be_const_str_None,
-    (const bstring *)&be_const_str_SERIAL_8O2,
+    (const bstring *)&be_const_str__X23autoexec_X2Ebe,
+    (const bstring *)&be_const_str_save_before_restart,
+    (const bstring *)&be_const_str_Leds,
     NULL,
-    (const bstring *)&be_const_str_io_error,
-    (const bstring *)&be_const_str__X2504d_X2D_X2502d_X2D_X2502dT_X2502d_X3A_X2502d_X3A_X2502d,
-    (const bstring *)&be_const_str_setrange,
-    (const bstring *)&be_const_str__persist_X2Ejson,
-    (const bstring *)&be_const_str_True,
-    (const bstring *)&be_const_str__X2F,
-    (const bstring *)&be_const_str_STATE_DEFAULT,
-    (const bstring *)&be_const_str_SERIAL_6N2,
-    (const bstring *)&be_const_str__X23preinit_X2Ebe,
-    (const bstring *)&be_const_str_publish,
-    (const bstring *)&be_const_str_web_send,
-    (const bstring *)&be_const_str_cmd,
-    (const bstring *)&be_const_str_,
-    (const bstring *)&be_const_str_get_vbus_current,
-    (const bstring *)&be_const_str_global,
-    NULL,
-    (const bstring *)&be_const_str_CFG_X3A_X20removed_X20file_X20_X27_X25s_X27,
-    NULL,
-    (const bstring *)&be_const_str_WS2812,
-    (const bstring *)&be_const_str_Wire,
-    (const bstring *)&be_const_str_rtc,
-    (const bstring *)&be_const_str_SERIAL_5E1,
-    (const bstring *)&be_const_str_CFG_X3A_X20Exception_X3E_X20_X27_X25s_X27_X20_X2D_X20_X25s,
-    NULL,
-    (const bstring *)&be_const_str_seg7_font,
-    (const bstring *)&be_const_str_CFG_X3A_X20no_X20_X27_X2A_X2Eautoconf_X27_X20file_X20found,
-    (const bstring *)&be_const_str_POST,
-    (const bstring *)&be_const_str__X3Cp_X3E_X3Cform_X20id_X3Dac_X20action_X3D_X27ac_X27_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20method_X3D_X27get_X27_X3E_X3Cbutton_X3E_X26_X23129668_X3B_X20Auto_X2Dconfiguration_X3C_X2Fbutton_X3E_X3C_X2Fform_X3E_X3C_X2Fp_X3E,
-    (const bstring *)&be_const_str_arg_name,
-    (const bstring *)&be_const_str__X2Fac,
-    (const bstring *)&be_const_str_Parameter_X20error,
-    (const bstring *)&be_const_str_calldepth,
-    NULL,
-    (const bstring *)&be_const_str_add_anim,
-    (const bstring *)&be_const_str_CFG_X3A_X20exception_X20_X27_X25s_X27_X20_X2D_X20_X27_X25s_X27,
-    (const bstring *)&be_const_str_reset,
-    (const bstring *)&be_const_str_back_forth,
-    (const bstring *)&be_const_str_bytes,
-    NULL,
-    (const bstring *)&be_const_str_AudioGeneratorWAV,
-    (const bstring *)&be_const_str__X2502d_X25s_X2502d,
-    (const bstring *)&be_const_str_Tasmota,
-    (const bstring *)&be_const_str_draw_line_dsc_init,
-    (const bstring *)&be_const_str_AES_GCM,
-    (const bstring *)&be_const_str_atan,
-    (const bstring *)&be_const_str_wifi_bars,
-    (const bstring *)&be_const_str_dirty,
-    (const bstring *)&be_const_str_EVENT_DRAW_PART_BEGIN,
-    (const bstring *)&be_const_str_tolower,
-    (const bstring *)&be_const_str__X3Cbutton_X20name_X3D_X27reapply_X27_X20class_X3D_X27button_X20bgrn_X27_X3ERe_X2Dapply_X20current_X20configuration_X3C_X2Fbutton_X3E,
-    (const bstring *)&be_const_str_CFG_X3A_X20return_code_X3D_X25i,
-    (const bstring *)&be_const_str_response_append,
-    NULL,
-    (const bstring *)&be_const_str_available,
-    (const bstring *)&be_const_str_button_pressed,
-    (const bstring *)&be_const_str__timers,
-    (const bstring *)&be_const_str_AudioOutput,
-    (const bstring *)&be_const_str_add_rule,
-    (const bstring *)&be_const_str_on,
-    (const bstring *)&be_const_str_due,
-    (const bstring *)&be_const_str__X3D_X3C_X3E_X21,
-    (const bstring *)&be_const_str_encrypt,
-    (const bstring *)&be_const_str__X23,
-    (const bstring *)&be_const_str_destructor_cb,
-    (const bstring *)&be_const_str_file,
-    (const bstring *)&be_const_str__X3Coption_X20value_X3D_X27_X25s_X27_X3E_X25s_X3C_X2Foption_X3E,
-    NULL,
-    (const bstring *)&be_const_str_tele,
-    (const bstring *)&be_const_str_HTTP_POST,
-    (const bstring *)&be_const_str_HTTP_GET,
+    (const bstring *)&be_const_str_wifi_bars_icon,
+    (const bstring *)&be_const_str_AudioGenerator,
+    (const bstring *)&be_const_str_Animate_X20pc_X20is_X20out_X20of_X20range,
     (const bstring *)&be_const_str_AudioOutputI2S,
-    (const bstring *)&be_const_str__X3C,
-    (const bstring *)&be_const_str__buffer,
-    (const bstring *)&be_const_str_cmd_res,
-    (const bstring *)&be_const_str_lv_wifi_arcs,
+    (const bstring *)&be_const_str_engine,
+    (const bstring *)&be_const_str__ptr,
+    (const bstring *)&be_const_str_SERIAL_8N1,
+    (const bstring *)&be_const_str_atleast1,
+    (const bstring *)&be_const_str_widget_height_def,
+    (const bstring *)&be_const_str_p1,
+    (const bstring *)&be_const_str_exec_tele,
+    (const bstring *)&be_const_str_memory,
+    (const bstring *)&be_const_str_LVG_X3A_X20call_X20to_X20unsupported_X20callback,
     NULL,
+    (const bstring *)&be_const_str_offseta,
+    (const bstring *)&be_const_str_SERIAL_8E1,
+    (const bstring *)&be_const_str_pixels_buffer,
+    (const bstring *)&be_const_str__begin_transmission,
+    NULL,
+    (const bstring *)&be_const_str_dac_voltage,
+    (const bstring *)&be_const_str__X2504d_X2D_X2502d_X2D_X2502dT_X2502d_X3A_X2502d_X3A_X2502d,
+    NULL,
+    (const bstring *)&be_const_str_real,
+    (const bstring *)&be_const_str_classname,
+    (const bstring *)&be_const_str__write,
+    (const bstring *)&be_const_str_refr_size,
+    (const bstring *)&be_const_str_due,
+    (const bstring *)&be_const_str_TAP_X3A_X20found_X20Tasmota_X20App_X20_X27_X25s_X27,
+    (const bstring *)&be_const_str__X21_X3D,
+    (const bstring *)&be_const_str__X3Cbutton_X20name_X3D_X27reapply_X27_X20class_X3D_X27button_X20bgrn_X27_X3ERe_X2Dapply_X20current_X20configuration_X3C_X2Fbutton_X3E,
+    (const bstring *)&be_const_str_p2,
+    (const bstring *)&be_const_str_every_50ms,
+    (const bstring *)&be_const_str__X2F_X2Eautoconf,
+    (const bstring *)&be_const_str_cb_obj,
+    (const bstring *)&be_const_str_CFG_X3A_X20_X27init_X2Ebat_X27_X20done_X2C_X20restarting,
+    NULL,
+    (const bstring *)&be_const_str__lvgl,
+    (const bstring *)&be_const_str_remove_cmd,
+    (const bstring *)&be_const_str_send,
+    (const bstring *)&be_const_str_SERIAL_5E2,
+    (const bstring *)&be_const_str_ctypes_bytes,
+    (const bstring *)&be_const_str_to_gamma,
+    (const bstring *)&be_const_str_y1,
+    (const bstring *)&be_const_str__p,
+    (const bstring *)&be_const_str__global_def,
+    (const bstring *)&be_const_str_allocated,
+    (const bstring *)&be_const_str_widget_struct_default,
+    (const bstring *)&be_const_str_HTTP_POST,
     (const bstring *)&be_const_str_function,
     (const bstring *)&be_const_str_SERIAL_8O1,
-    (const bstring *)&be_const_str_CFG_X3A_X20loading_X20_X27_X25s_X27
+    (const bstring *)&be_const_str_get_aps_voltage,
+    (const bstring *)&be_const_str_draw_arc,
+    (const bstring *)&be_const_str_abs,
+    (const bstring *)&be_const_str__cmd,
+    (const bstring *)&be_const_str_min,
+    (const bstring *)&be_const_str_SERIAL_5N1,
+    (const bstring *)&be_const_str___upper__,
+    (const bstring *)&be_const_str_CFG_X3A_X20loaded_X20_X20,
+    (const bstring *)&be_const_str__X3Coption_X20value_X3D_X27reset_X27_X3E_X26lt_X3BRemove_X20autoconf_X26gt_X3B_X3C_X2Foption_X3E,
+    (const bstring *)&be_const_str_AXP192,
+    (const bstring *)&be_const_str_None,
+    (const bstring *)&be_const_str__X23display_X2Eini,
+    (const bstring *)&be_const_str_init,
+    (const bstring *)&be_const_str_area,
+    (const bstring *)&be_const_str_width,
+    (const bstring *)&be_const_str_write8,
+    (const bstring *)&be_const_str_json_fdump_any,
+    NULL,
+    (const bstring *)&be_const_str_get_free_heap,
+    (const bstring *)&be_const_str_geti,
+    (const bstring *)&be_const_str_SERIAL_8O2,
+    (const bstring *)&be_const_str_exec_rules,
+    (const bstring *)&be_const_str_read_sensors,
+    (const bstring *)&be_const_str_cosh,
+    (const bstring *)&be_const_str_autoexec,
+    (const bstring *)&be_const_str__X2B,
+    (const bstring *)&be_const_str_onsubmit_X3D_X27return_X20confirm_X28_X22This_X20will_X20change_X20the_X20current_X20configuration_X20and_X20cause_X20a_X20restart_X2E_X22_X29_X3B_X27_X3E,
+    NULL,
+    (const bstring *)&be_const_str_CFG_X3A_X20exception_X20_X27_X25s_X27_X20_X2D_X20_X27_X25s_X27,
+    (const bstring *)&be_const_str_battery_present,
+    (const bstring *)&be_const_str_remote_ip,
+    NULL,
+    (const bstring *)&be_const_str__X2502d_X25s_X2502d,
+    NULL,
+    (const bstring *)&be_const_str_alternate,
+    (const bstring *)&be_const_str_code,
+    (const bstring *)&be_const_str_ctor,
+    (const bstring *)&be_const_str_False,
+    (const bstring *)&be_const_str_math,
+    (const bstring *)&be_const_str_widget_event_cb,
+    (const bstring *)&be_const_str_BRY_X3A_X20failed_X20to_X20load_X20_persist_X2Ejson,
+    (const bstring *)&be_const_str__dirty,
+    (const bstring *)&be_const_str__X3A,
+    (const bstring *)&be_const_str_BUTTON_CONFIGURATION,
+    (const bstring *)&be_const_str__X2Ep,
+    (const bstring *)&be_const_str_Wire,
+    (const bstring *)&be_const_str_set_text,
+    (const bstring *)&be_const_str_lv_wifi_bars_icon,
+    (const bstring *)&be_const_str_compress,
+    (const bstring *)&be_const_str_available,
+    (const bstring *)&be_const_str_SERIAL_6O2,
+    (const bstring *)&be_const_str_pin_mode,
+    (const bstring *)&be_const_str_SERIAL_5O1,
+    NULL,
+    (const bstring *)&be_const_str_CFG_X3A_X20downloading_X20_X27_X25s_X27,
+    (const bstring *)&be_const_str_get_width,
+    (const bstring *)&be_const_str_lv_obj,
+    (const bstring *)&be_const_str_AudioGeneratorMP3,
+    (const bstring *)&be_const_str_SK6812_GRBW,
+    NULL,
+    (const bstring *)&be_const_str_strptime,
+    (const bstring *)&be_const_str_format,
+    (const bstring *)&be_const_str_iter,
+    (const bstring *)&be_const_str_gamma8,
+    (const bstring *)&be_const_str_resize,
+    NULL,
+    (const bstring *)&be_const_str_CFG_X3A_X20removing_X20first_X20time_X20marker,
+    NULL,
+    (const bstring *)&be_const_str_widget_event_impl,
+    (const bstring *)&be_const_str_delete_all_configs,
+    (const bstring *)&be_const_str_create_segment,
+    (const bstring *)&be_const_str_calldepth,
+    (const bstring *)&be_const_str_arch,
+    (const bstring *)&be_const_str_PART_MAIN,
+    (const bstring *)&be_const_str_content_send,
+    (const bstring *)&be_const_str__X28_X29,
+    (const bstring *)&be_const_str_setmember,
+    (const bstring *)&be_const_str__t,
+    (const bstring *)&be_const_str_split,
+    (const bstring *)&be_const_str_connection_error,
+    (const bstring *)&be_const_str_set_style_bg_color,
+    (const bstring *)&be_const_str___lower__,
+    (const bstring *)&be_const_str_read_bytes,
+    (const bstring *)&be_const_str_SERIAL_7O2,
+    (const bstring *)&be_const_str_CFG_X3A_X20multiple_X20autoconf_X20files_X20found_X2C_X20aborting_X20_X28_X27_X25s_X27_X20_X2B_X20_X27_X25s_X27_X29,
+    (const bstring *)&be_const_str__persist_X2Ejson,
+    (const bstring *)&be_const_str_deg,
+    (const bstring *)&be_const_str__X2Ebe,
+    (const bstring *)&be_const_str__X2E,
+    (const bstring *)&be_const_str_class_init_obj,
+    NULL,
+    (const bstring *)&be_const_str__end_transmission,
+    NULL,
+    (const bstring *)&be_const_str_HTTP_GET,
+    NULL,
+    (const bstring *)&be_const_str_on,
+    (const bstring *)&be_const_str__X3Cp_X3E_X3Cform_X20id_X3Dac_X20action_X3D_X27ac_X27_X20style_X3D_X27display_X3A_X20block_X3B_X27_X20method_X3D_X27get_X27_X3E_X3Cbutton_X3E_X26_X23129668_X3B_X20Auto_X2Dconfiguration_X3C_X2Fbutton_X3E_X3C_X2Fform_X3E_X3C_X2Fp_X3E,
+    (const bstring *)&be_const_str_year,
+    (const bstring *)&be_const_str__X3C_X2Fselect_X3E_X3Cp_X3E_X3C_X2Fp_X3E,
+    (const bstring *)&be_const_str_listdir,
+    (const bstring *)&be_const_str__filename,
+    (const bstring *)&be_const_str_cmd_res,
+    (const bstring *)&be_const_str_can_show,
+    NULL,
+    (const bstring *)&be_const_str_SERIAL_7O1,
+    (const bstring *)&be_const_str_asin,
+    (const bstring *)&be_const_str__global_addr,
+    (const bstring *)&be_const_str_invalidate,
+    (const bstring *)&be_const_str__X2Ebec,
+    (const bstring *)&be_const_str__X2F,
+    (const bstring *)&be_const_str__X23autoexec_X2Ebat,
+    (const bstring *)&be_const_str__X26lt_X3BNone_X26gt_X3B,
+    (const bstring *)&be_const_str_tcpclient,
+    (const bstring *)&be_const_str_SERIAL_6O1,
+    (const bstring *)&be_const_str_erase,
+    (const bstring *)&be_const_str_SERIAL_5O2,
+    (const bstring *)&be_const_str_last_modified,
+    (const bstring *)&be_const_str_clear_to,
+    (const bstring *)&be_const_str_byte,
+    NULL,
+    (const bstring *)&be_const_str_EC_C25519,
+    (const bstring *)&be_const_str_resp_cmnd_failed,
+    (const bstring *)&be_const_str_gamma10,
+    (const bstring *)&be_const_str_insert,
+    (const bstring *)&be_const_str_set_y,
+    (const bstring *)&be_const_str__X5B,
+    (const bstring *)&be_const_str__X3E,
+    (const bstring *)&be_const_str__settings_ptr,
+    (const bstring *)&be_const_str_module,
+    (const bstring *)&be_const_str_get_pixel_color,
+    (const bstring *)&be_const_str__X2C,
+    NULL,
+    (const bstring *)&be_const_str_get_object_from_ptr,
+    (const bstring *)&be_const_str_EVENT_DRAW_PART_BEGIN,
+    (const bstring *)&be_const_str_Restart_X201,
+    (const bstring *)&be_const_str_read32,
+    NULL,
+    (const bstring *)&be_const_str_CFG_X3A_X20loaded_X20_X27_X25s_X27,
+    NULL,
+    (const bstring *)&be_const_str_bri,
+    (const bstring *)&be_const_str_CFG_X3A_X20Exception_X3E_X20_X27_X25s_X27_X20_X2D_X20_X25s,
+    (const bstring *)&be_const_str_line_dsc,
+    (const bstring *)&be_const_str_https_X3A_X2F_X2Fraw_X2Egithubusercontent_X2Ecom_X2Ftasmota_X2Fautoconf_X2Fmain_X2F_X25s_X2F_X25s_X2Eautoconf,
+    (const bstring *)&be_const_str__X2Eautoconf,
+    (const bstring *)&be_const_str_collect,
+    (const bstring *)&be_const_str_add,
+    (const bstring *)&be_const_str_fromptr,
+    (const bstring *)&be_const_str__X3F,
+    (const bstring *)&be_const_str_add_cmd,
+    (const bstring *)&be_const_str_debug,
+    (const bstring *)&be_const_str_cmd,
+    NULL,
+    (const bstring *)&be_const_str_json,
+    (const bstring *)&be_const_str__X3Cp_X20style_X3D_X27width_X3A340px_X3B_X27_X3E_X3Cb_X3EException_X3A_X3C_X2Fb_X3E_X3Cbr_X3E_X27_X25s_X27_X3Cbr_X3E_X25s_X3C_X2Fp_X3E,
+    (const bstring *)&be_const_str_SERIAL_7N2,
+    (const bstring *)&be_const_str_set_ldo_voltage,
+    (const bstring *)&be_const_str_arg,
+    (const bstring *)&be_const_str__read,
+    (const bstring *)&be_const_str_true,
+    (const bstring *)&be_const_str_get_style_line_color,
+    (const bstring *)&be_const_str__X2F_X3Frst_X3D,
+    (const bstring *)&be_const_str__X23preinit_X2Ebe,
+    (const bstring *)&be_const_str___iterator__,
+    (const bstring *)&be_const_str_CFG_X3A_X20skipping_X20_X27display_X2Eini_X27_X20because_X20already_X20present_X20in_X20file_X2Dsystem,
+    (const bstring *)&be_const_str_read24,
+    (const bstring *)&be_const_str_instance_size,
+    NULL,
+    (const bstring *)&be_const_str_reset,
+    (const bstring *)&be_const_str__X3C,
+    (const bstring *)&be_const_str_back_forth,
+    (const bstring *)&be_const_str_dump,
+    (const bstring *)&be_const_str_web_add_console_button,
+    (const bstring *)&be_const_str_https_X3A_X2F_X2Fraw_X2Egithubusercontent_X2Ecom_X2Ftasmota_X2Fautoconf_X2Fmain_X2F_X25s_manifest_X2Ejson,
+    (const bstring *)&be_const_str__X3Coption_X20value_X3D_X27_X25s_X27_X3E_X25s_X3C_X2Foption_X3E,
+    (const bstring *)&be_const_str_exec_cmd,
+    (const bstring *)&be_const_str__X2Fac,
+    (const bstring *)&be_const_str_CFG_X3A_X20no_X20_X27_X2A_X2Eautoconf_X27_X20file_X20found,
+    (const bstring *)&be_const_str_AudioGeneratorWAV,
+    (const bstring *)&be_const_str__def,
+    (const bstring *)&be_const_str__X3E_X3D,
+    (const bstring *)&be_const_str_close,
+    (const bstring *)&be_const_str_CFG_X3A_X20could_X20not_X20run_X20_X25s_X20_X28_X25s_X20_X2D_X20_X25s_X29,
+    (const bstring *)&be_const_str_day,
+    (const bstring *)&be_const_str_finish,
+    (const bstring *)&be_const_str_h,
+    (const bstring *)&be_const_str_pc,
+    (const bstring *)&be_const_str_wifi_bars,
+    (const bstring *)&be_const_str_decompress,
+    (const bstring *)&be_const_str_clock_icon,
+    (const bstring *)&be_const_str__X2Esize,
+    (const bstring *)&be_const_str_unknown_X20instruction,
+    (const bstring *)&be_const_str__X2Elen,
+    (const bstring *)&be_const_str_content_send_style,
+    (const bstring *)&be_const_str__X23,
+    (const bstring *)&be_const_str_loop,
+    NULL,
+    (const bstring *)&be_const_str_static,
+    NULL,
+    (const bstring *)&be_const_str__X26lt_X3BError_X3A_X20apply_X20new_X20or_X20remove_X26gt_X3B,
+    (const bstring *)&be_const_str__X3Cselect_X20name_X3D_X27zip_X27_X3E,
+    (const bstring *)&be_const_str__X3D_X3D
 };
 
 static const struct bconststrtab m_const_string_table = {
-    .size = 373,
-    .count = 770,
+    .size = 374,
+    .count = 771,
     .table = m_string_table
 };
diff --git a/lib/libesp32_lvgl/lv_berry/generate/be_lv_c_mapping.h b/lib/libesp32_lvgl/lv_berry/generate/be_lv_c_mapping.h
index 2fd213d96..230d9ef3e 100644
--- a/lib/libesp32_lvgl/lv_berry/generate/be_lv_c_mapping.h
+++ b/lib/libesp32_lvgl/lv_berry/generate/be_lv_c_mapping.h
@@ -19,7 +19,7 @@ const be_ntv_func_def_t lv_style_func[] = {
   { "set_arc_color_filtered", (void*) &lv_style_set_arc_color_filtered, "", "(lv.lv_style)(lv.lv_color)" },
   { "set_arc_img_src", (void*) &lv_style_set_arc_img_src, "", "(lv.lv_style)." },
   { "set_arc_opa", (void*) &lv_style_set_arc_opa, "", "(lv.lv_style)i" },
-  { "set_arc_rounded", (void*) &lv_style_set_arc_rounded, "", "(lv.lv_style)i" },
+  { "set_arc_rounded", (void*) &lv_style_set_arc_rounded, "", "(lv.lv_style)b" },
   { "set_arc_width", (void*) &lv_style_set_arc_width, "", "(lv.lv_style)i" },
   { "set_base_dir", (void*) &lv_style_set_base_dir, "", "(lv.lv_style)i" },
   { "set_bg_color", (void*) &lv_style_set_bg_color, "", "(lv.lv_style)(lv.lv_color)" },
@@ -57,7 +57,7 @@ const be_ntv_func_def_t lv_style_func[] = {
   { "set_line_dash_gap", (void*) &lv_style_set_line_dash_gap, "", "(lv.lv_style)i" },
   { "set_line_dash_width", (void*) &lv_style_set_line_dash_width, "", "(lv.lv_style)i" },
   { "set_line_opa", (void*) &lv_style_set_line_opa, "", "(lv.lv_style)i" },
-  { "set_line_rounded", (void*) &lv_style_set_line_rounded, "", "(lv.lv_style)i" },
+  { "set_line_rounded", (void*) &lv_style_set_line_rounded, "", "(lv.lv_style)b" },
   { "set_line_width", (void*) &lv_style_set_line_width, "", "(lv.lv_style)i" },
   { "set_max_height", (void*) &lv_style_set_max_height, "", "(lv.lv_style)i" },
   { "set_max_width", (void*) &lv_style_set_max_width, "", "(lv.lv_style)i" },
@@ -130,6 +130,7 @@ const be_ntv_func_def_t lv_img_func[] = {
   { "set_offset_x", (void*) &lv_img_set_offset_x, "", "(lv.lv_obj)i" },
   { "set_offset_y", (void*) &lv_img_set_offset_y, "", "(lv.lv_obj)i" },
   { "set_pivot", (void*) &lv_img_set_pivot, "", "(lv.lv_obj)ii" },
+  { "set_size_mode", (void*) &lv_img_set_size_mode, "", "(lv.lv_obj)(lv.lv_img_size_mode)" },
   { "set_src", (void*) &lv_img_set_src, "", "(lv.lv_obj)." },
   { "set_tasmota_logo", (void*) &lv_img_set_tasmota_logo, "", "(lv.lv_obj)" },
   { "set_zoom", (void*) &lv_img_set_zoom, "", "(lv.lv_obj)i" },
@@ -165,6 +166,7 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "allocate_spec_attr", (void*) &lv_obj_allocate_spec_attr, "", "(lv.lv_obj)" },
   { "area_is_visible", (void*) &lv_obj_area_is_visible, "b", "(lv.lv_obj)(lv.lv_area)" },
   { "calculate_ext_draw_size", (void*) &lv_obj_calculate_ext_draw_size, "i", "(lv.lv_obj)i" },
+  { "calculate_style_text_align", (void*) &lv_obj_calculate_style_text_align, "i", "(lv.lv_obj)is" },
   { "center", (void*) &lv_obj_center, "", "(lv.lv_obj)" },
   { "check_type", (void*) &lv_obj_check_type, "b", "(lv.lv_obj)(lv.lv_obj_class)" },
   { "class_init_obj", (void*) &lv_obj_class_init_obj, "", "(lv.lv_obj)" },
@@ -173,12 +175,12 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "clear_state", (void*) &lv_obj_clear_state, "", "(lv.lv_obj)i" },
   { "del", (void*) &lv_obj_del, "", "(lv.lv_obj)" },
   { "del_async", (void*) &lv_obj_del_async, "", "(lv.lv_obj)" },
+  { "del_delayed", (void*) &lv_obj_del_delayed, "", "(lv.lv_obj)i" },
   { "dpx", (void*) &lv_obj_dpx, "i", "(lv.lv_obj)i" },
   { "fade_in", (void*) &lv_obj_fade_in, "", "(lv.lv_obj)ii" },
   { "fade_out", (void*) &lv_obj_fade_out, "", "(lv.lv_obj)ii" },
   { "get_child", (void*) &lv_obj_get_child, "lv.lv_obj", "(lv.lv_obj)i" },
   { "get_child_cnt", (void*) &lv_obj_get_child_cnt, "i", "(lv.lv_obj)" },
-  { "get_child_id", (void*) &lv_obj_get_child_id, "i", "(lv.lv_obj)" },
   { "get_class", (void*) &lv_obj_get_class, "lv.lv_obj_class", "(lv.lv_obj)" },
   { "get_click_area", (void*) &lv_obj_get_click_area, "", "(lv.lv_obj)(lv.lv_area)" },
   { "get_content_coords", (void*) &lv_obj_get_content_coords, "", "(lv.lv_obj)(lv.lv_area)" },
@@ -188,6 +190,7 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "get_disp", (void*) &lv_obj_get_disp, "lv.lv_disp", "(lv.lv_obj)" },
   { "get_group", (void*) &lv_obj_get_group, ".", "(lv.lv_obj)" },
   { "get_height", (void*) &lv_obj_get_height, "i", "(lv.lv_obj)" },
+  { "get_index", (void*) &lv_obj_get_index, "i", "(lv.lv_obj)" },
   { "get_local_style_prop", (void*) &lv_obj_get_local_style_prop, "i", "(lv.lv_obj)(lv.lv_style_prop)(lv.lv_style_value)i" },
   { "get_parent", (void*) &lv_obj_get_parent, "lv.lv_obj", "(lv.lv_obj)" },
   { "get_screen", (void*) &lv_obj_get_screen, "lv.lv_obj", "(lv.lv_obj)" },
@@ -213,7 +216,7 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "get_style_arc_color_filtered", (void*) &lv_obj_get_style_arc_color_filtered, "lv.lv_color", "(lv.lv_obj)i" },
   { "get_style_arc_img_src", (void*) &lv_obj_get_style_arc_img_src, ".", "(lv.lv_obj)i" },
   { "get_style_arc_opa", (void*) &lv_obj_get_style_arc_opa, "i", "(lv.lv_obj)i" },
-  { "get_style_arc_rounded", (void*) &lv_obj_get_style_arc_rounded, "i", "(lv.lv_obj)i" },
+  { "get_style_arc_rounded", (void*) &lv_obj_get_style_arc_rounded, "b", "(lv.lv_obj)i" },
   { "get_style_arc_width", (void*) &lv_obj_get_style_arc_width, "i", "(lv.lv_obj)i" },
   { "get_style_base_dir", (void*) &lv_obj_get_style_base_dir, "i", "(lv.lv_obj)i" },
   { "get_style_bg_color", (void*) &lv_obj_get_style_bg_color, "lv.lv_color", "(lv.lv_obj)i" },
@@ -250,7 +253,7 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "get_style_line_dash_gap", (void*) &lv_obj_get_style_line_dash_gap, "i", "(lv.lv_obj)i" },
   { "get_style_line_dash_width", (void*) &lv_obj_get_style_line_dash_width, "i", "(lv.lv_obj)i" },
   { "get_style_line_opa", (void*) &lv_obj_get_style_line_opa, "i", "(lv.lv_obj)i" },
-  { "get_style_line_rounded", (void*) &lv_obj_get_style_line_rounded, "i", "(lv.lv_obj)i" },
+  { "get_style_line_rounded", (void*) &lv_obj_get_style_line_rounded, "b", "(lv.lv_obj)i" },
   { "get_style_line_width", (void*) &lv_obj_get_style_line_width, "i", "(lv.lv_obj)i" },
   { "get_style_max_height", (void*) &lv_obj_get_style_max_height, "i", "(lv.lv_obj)i" },
   { "get_style_max_width", (void*) &lv_obj_get_style_max_width, "i", "(lv.lv_obj)i" },
@@ -298,8 +301,10 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "get_width", (void*) &lv_obj_get_width, "i", "(lv.lv_obj)" },
   { "get_x", (void*) &lv_obj_get_x, "i", "(lv.lv_obj)" },
   { "get_x2", (void*) &lv_obj_get_x2, "i", "(lv.lv_obj)" },
+  { "get_x_aligned", (void*) &lv_obj_get_x_aligned, "i", "(lv.lv_obj)" },
   { "get_y", (void*) &lv_obj_get_y, "i", "(lv.lv_obj)" },
   { "get_y2", (void*) &lv_obj_get_y2, "i", "(lv.lv_obj)" },
+  { "get_y_aligned", (void*) &lv_obj_get_y_aligned, "i", "(lv.lv_obj)" },
   { "has_class", (void*) &lv_obj_has_class, "b", "(lv.lv_obj)(lv.lv_obj_class)" },
   { "has_flag", (void*) &lv_obj_has_flag, "b", "(lv.lv_obj)i" },
   { "has_flag_any", (void*) &lv_obj_has_flag_any, "b", "(lv.lv_obj)i" },
@@ -319,10 +324,9 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "is_valid", (void*) &lv_obj_is_valid, "b", "(lv.lv_obj)" },
   { "is_visible", (void*) &lv_obj_is_visible, "b", "(lv.lv_obj)" },
   { "mark_layout_as_dirty", (void*) &lv_obj_mark_layout_as_dirty, "", "(lv.lv_obj)" },
-  { "move_background", (void*) &lv_obj_move_background, "", "(lv.lv_obj)" },
   { "move_children_by", (void*) &lv_obj_move_children_by, "", "(lv.lv_obj)iib" },
-  { "move_foreground", (void*) &lv_obj_move_foreground, "", "(lv.lv_obj)" },
   { "move_to", (void*) &lv_obj_move_to, "", "(lv.lv_obj)ii" },
+  { "move_to_index", (void*) &lv_obj_move_to_index, "", "(lv.lv_obj)i" },
   { "readjust_scroll", (void*) &lv_obj_readjust_scroll, "", "(lv.lv_obj)(lv.lv_anim_enable)" },
   { "refr_pos", (void*) &lv_obj_refr_pos, "", "(lv.lv_obj)" },
   { "refr_size", (void*) &lv_obj_refr_size, "b", "(lv.lv_obj)" },
@@ -330,6 +334,7 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "refresh_self_size", (void*) &lv_obj_refresh_self_size, "b", "(lv.lv_obj)" },
   { "refresh_style", (void*) &lv_obj_refresh_style, "", "(lv.lv_obj)i(lv.lv_style_prop)" },
   { "remove_event_cb", (void*) &lv_obj_remove_event_cb, "b", "(lv.lv_obj)^lv_event_cb^" },
+  { "remove_event_cb_with_user_data", (void*) &lv_obj_remove_event_cb_with_user_data, "b", "(lv.lv_obj)^lv_event_cb^." },
   { "remove_event_dsc", (void*) &lv_obj_remove_event_dsc, "b", "(lv.lv_obj)i" },
   { "remove_local_style_prop", (void*) &lv_obj_remove_local_style_prop, "b", "(lv.lv_obj)(lv.lv_style_prop)i" },
   { "remove_style", (void*) &lv_obj_remove_style, "", "(lv.lv_obj)(lv.lv_style)i" },
@@ -362,7 +367,7 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "set_style_arc_color_filtered", (void*) &lv_obj_set_style_arc_color_filtered, "", "(lv.lv_obj)(lv.lv_color)i" },
   { "set_style_arc_img_src", (void*) &lv_obj_set_style_arc_img_src, "", "(lv.lv_obj).i" },
   { "set_style_arc_opa", (void*) &lv_obj_set_style_arc_opa, "", "(lv.lv_obj)ii" },
-  { "set_style_arc_rounded", (void*) &lv_obj_set_style_arc_rounded, "", "(lv.lv_obj)ii" },
+  { "set_style_arc_rounded", (void*) &lv_obj_set_style_arc_rounded, "", "(lv.lv_obj)bi" },
   { "set_style_arc_width", (void*) &lv_obj_set_style_arc_width, "", "(lv.lv_obj)ii" },
   { "set_style_base_dir", (void*) &lv_obj_set_style_base_dir, "", "(lv.lv_obj)ii" },
   { "set_style_bg_color", (void*) &lv_obj_set_style_bg_color, "", "(lv.lv_obj)(lv.lv_color)i" },
@@ -400,7 +405,7 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "set_style_line_dash_gap", (void*) &lv_obj_set_style_line_dash_gap, "", "(lv.lv_obj)ii" },
   { "set_style_line_dash_width", (void*) &lv_obj_set_style_line_dash_width, "", "(lv.lv_obj)ii" },
   { "set_style_line_opa", (void*) &lv_obj_set_style_line_opa, "", "(lv.lv_obj)ii" },
-  { "set_style_line_rounded", (void*) &lv_obj_set_style_line_rounded, "", "(lv.lv_obj)ii" },
+  { "set_style_line_rounded", (void*) &lv_obj_set_style_line_rounded, "", "(lv.lv_obj)bi" },
   { "set_style_line_width", (void*) &lv_obj_set_style_line_width, "", "(lv.lv_obj)ii" },
   { "set_style_max_height", (void*) &lv_obj_set_style_max_height, "", "(lv.lv_obj)ii" },
   { "set_style_max_width", (void*) &lv_obj_set_style_max_width, "", "(lv.lv_obj)ii" },
@@ -453,6 +458,7 @@ const be_ntv_func_def_t lv_obj_func[] = {
   { "set_width", (void*) &lv_obj_set_width, "", "(lv.lv_obj)i" },
   { "set_x", (void*) &lv_obj_set_x, "", "(lv.lv_obj)i" },
   { "set_y", (void*) &lv_obj_set_y, "", "(lv.lv_obj)i" },
+  { "swap", (void*) &lv_obj_swap, "", "(lv.lv_obj)(lv.lv_obj)" },
   { "tree_walk", (void*) &lv_obj_tree_walk, "", "(lv.lv_obj)^lv_obj_tree_walk_cb^." },
   { "update_layout", (void*) &lv_obj_update_layout, "", "(lv.lv_obj)" },
   { "update_snap", (void*) &lv_obj_update_snap, "", "(lv.lv_obj)(lv.lv_anim_enable)" },
@@ -479,6 +485,7 @@ const be_ntv_func_def_t lv_group_func[] = {
   { "set_focus_cb", (void*) &lv_group_set_focus_cb, "", "(lv.lv_group)^lv_group_focus_cb^" },
   { "set_refocus_policy", (void*) &lv_group_set_refocus_policy, "", "(lv.lv_group)(lv.lv_group_refocus_policy)" },
   { "set_wrap", (void*) &lv_group_set_wrap, "", "(lv.lv_group)b" },
+  { "swap_obj", (void*) &lv_group_swap_obj, "", "(lv.lv_obj)(lv.lv_obj)" },
 };
 
 /* `lv_indev` methods */
@@ -557,6 +564,7 @@ const be_ntv_func_def_t lv_colorwheel_func[] = {
 #ifdef BE_LV_WIDGET_IMGBTN
 const be_ntv_func_def_t lv_imgbtn_func[] = {
   { "set_src", (void*) &lv_imgbtn_set_src, "", "(lv.lv_obj)(lv.lv_imgbtn_state)..." },
+  { "set_state", (void*) &lv_imgbtn_set_state, "", "(lv.lv_obj)(lv.lv_imgbtn_state)" },
 };
 #endif // BE_LV_WIDGET_IMGBTN
 
@@ -593,9 +601,12 @@ const be_ntv_func_def_t lv_meter_func[] = {
 #ifdef BE_LV_WIDGET_MSGBOX
 const be_ntv_func_def_t lv_msgbox_func[] = {
   { "close", (void*) &lv_msgbox_close, "", "(lv.lv_obj)" },
+  { "close_async", (void*) &lv_msgbox_close_async, "", "(lv.lv_obj)" },
+  { "get_active_btn", (void*) &lv_msgbox_get_active_btn, "i", "(lv.lv_obj)" },
   { "get_active_btn_text", (void*) &lv_msgbox_get_active_btn_text, "s", "(lv.lv_obj)" },
   { "get_btns", (void*) &lv_msgbox_get_btns, "lv.lv_obj", "(lv.lv_obj)" },
   { "get_close_btn", (void*) &lv_msgbox_get_close_btn, "lv.lv_obj", "(lv.lv_obj)" },
+  { "get_content", (void*) &lv_msgbox_get_content, "lv.lv_obj", "(lv.lv_obj)" },
   { "get_text", (void*) &lv_msgbox_get_text, "lv.lv_obj", "(lv.lv_obj)" },
   { "get_title", (void*) &lv_msgbox_get_title, "lv.lv_obj", "(lv.lv_obj)" },
 };
@@ -610,6 +621,8 @@ const be_ntv_func_def_t lv_spinbox_func[] = {
   { "get_value", (void*) &lv_spinbox_get_value, "i", "(lv.lv_obj)" },
   { "increment", (void*) &lv_spinbox_increment, "", "(lv.lv_obj)" },
   { "set_digit_format", (void*) &lv_spinbox_set_digit_format, "", "(lv.lv_obj)ii" },
+  { "set_digit_step_direction", (void*) &lv_spinbox_set_digit_step_direction, "", "(lv.lv_obj)i" },
+  { "set_pos", (void*) &lv_spinbox_set_pos, "", "(lv.lv_obj)i" },
   { "set_range", (void*) &lv_spinbox_set_range, "", "(lv.lv_obj)ii" },
   { "set_rollover", (void*) &lv_spinbox_set_rollover, "", "(lv.lv_obj)b" },
   { "set_step", (void*) &lv_spinbox_set_step, "", "(lv.lv_obj)i" },
@@ -707,6 +720,8 @@ const be_ntv_func_def_t lv_canvas_func[] = {
   { "set_buffer", (void*) &lv_canvas_set_buffer, "", "(lv.lv_obj).iii" },
   { "set_palette", (void*) &lv_canvas_set_palette, "", "(lv.lv_obj)i(lv.lv_color)" },
   { "set_px", (void*) &lv_canvas_set_px, "", "(lv.lv_obj)ii(lv.lv_color)" },
+  { "set_px_color", (void*) &lv_canvas_set_px_color, "", "(lv.lv_obj)ii(lv.lv_color)" },
+  { "set_px_opa", (void*) &lv_canvas_set_px_opa, "", "(lv.lv_obj)iii" },
   { "transform", (void*) &lv_canvas_transform, "", "(lv.lv_obj)(lv.lv_img_dsc)iiiiiib" },
 };
 #endif // BE_LV_WIDGET_CANVAS
diff --git a/lib/libesp32_lvgl/lv_berry/generate/be_lvgl_module.c b/lib/libesp32_lvgl/lv_berry/generate/be_lvgl_module.c
index dbab0eca1..5cec00e46 100644
--- a/lib/libesp32_lvgl/lv_berry/generate/be_lvgl_module.c
+++ b/lib/libesp32_lvgl/lv_berry/generate/be_lvgl_module.c
@@ -41,7 +41,9 @@ const be_ntv_func_def_t lv_func[] = {
   { "draw_mask_add", (void*) &lv_draw_mask_add, "i", ".." },
   { "draw_mask_angle_init", (void*) &lv_draw_mask_angle_init, "", "(lv.lv_draw_mask_angle_param)iiii" },
   { "draw_mask_fade_init", (void*) &lv_draw_mask_fade_init, "", "(lv.lv_draw_mask_fade_param)(lv.lv_area)iiii" },
+  { "draw_mask_free_param", (void*) &lv_draw_mask_free_param, "", "." },
   { "draw_mask_get_cnt", (void*) &lv_draw_mask_get_cnt, "i", "" },
+  { "draw_mask_is_any", (void*) &lv_draw_mask_is_any, "b", "(lv.lv_area)" },
   { "draw_mask_line_angle_init", (void*) &lv_draw_mask_line_angle_init, "", "(lv.lv_draw_mask_line_param)iiii" },
   { "draw_mask_line_points_init", (void*) &lv_draw_mask_line_points_init, "", "(lv.lv_draw_mask_line_param)iiiii" },
   { "draw_mask_map_init", (void*) &lv_draw_mask_map_init, "", "(lv.lv_draw_mask_map_param)(lv.lv_area)(lv.lv_opa)" },
@@ -63,12 +65,14 @@ const be_ntv_func_def_t lv_func[] = {
   { "indev_get_act", (void*) &lv_indev_get_act, "lv.lv_indev", "" },
   { "indev_get_obj_act", (void*) &lv_indev_get_obj_act, "lv.lv_obj", "" },
   { "indev_read_timer_cb", (void*) &lv_indev_read_timer_cb, "", "(lv.lv_timer)" },
+  { "is_initialized", (void*) &lv_is_initialized, "b", "" },
   { "layer_sys", (void*) &lv_layer_sys, "lv.lv_obj", "" },
   { "layer_top", (void*) &lv_layer_top, "lv.lv_obj", "" },
   { "layout_register", (void*) &lv_layout_register, "i", "^lv_layout_update_cb^." },
   { "obj_class_create_obj", (void*) &lv_obj_class_create_obj, "lv.lv_obj", "(lv._lv_obj_class)(lv.lv_obj)" },
   { "obj_del_anim_ready_cb", (void*) &lv_obj_del_anim_ready_cb, "", "(lv.lv_anim)" },
   { "obj_draw_dsc_init", (void*) &lv_obj_draw_dsc_init, "", "(lv.lv_obj_draw_part_dsc)(lv.lv_area)" },
+  { "obj_draw_part_check_type", (void*) &lv_obj_draw_part_check_type, "b", "(lv.lv_obj_draw_part_dsc)(lv._lv_obj_class)i" },
   { "obj_enable_style_refresh", (void*) &lv_obj_enable_style_refresh, "", "b" },
   { "obj_event_base", (void*) &lv_obj_event_base, "i", "(lv.lv_obj_class)(lv.lv_event)" },
   { "obj_report_style_change", (void*) &lv_obj_report_style_change, "", "(lv.lv_style)" },
@@ -79,6 +83,7 @@ const be_ntv_func_def_t lv_func[] = {
   { "scr_load", (void*) &lv_scr_load, "", "(lv.lv_obj)" },
   { "scr_load_anim", (void*) &lv_scr_load_anim, "", "(lv.lv_obj)iiib" },
   { "theme_apply", (void*) &lv_theme_apply, "", "(lv.lv_obj)" },
+  { "theme_default_get", (void*) &lv_theme_default_get, "lv.lv_theme", "" },
   { "theme_default_init", (void*) &lv_theme_default_init, "lv.lv_theme", "(lv.lv_disp)(lv.lv_color)(lv.lv_color)b(lv.lv_font)" },
   { "theme_default_is_inited", (void*) &lv_theme_default_is_inited, "b", "" },
   { "theme_get_color_primary", (void*) &lv_theme_get_color_primary, "lv.lv_color", "(lv.lv_obj)" },
@@ -126,9 +131,13 @@ const be_const_member_t lv0_constants[] = {
     { "ANIM_IMG_PART_MAIN", LV_ANIM_IMG_PART_MAIN },
     { "ANIM_OFF", LV_ANIM_OFF },
     { "ANIM_ON", LV_ANIM_ON },
+    { "ARC_DRAW_PART_BACKGROUND", LV_ARC_DRAW_PART_BACKGROUND },
+    { "ARC_DRAW_PART_FOREGROUND", LV_ARC_DRAW_PART_FOREGROUND },
+    { "ARC_DRAW_PART_KNOB", LV_ARC_DRAW_PART_KNOB },
     { "ARC_MODE_NORMAL", LV_ARC_MODE_NORMAL },
     { "ARC_MODE_REVERSE", LV_ARC_MODE_REVERSE },
     { "ARC_MODE_SYMMETRICAL", LV_ARC_MODE_SYMMETRICAL },
+    { "BAR_DRAW_PART_INDICATOR", LV_BAR_DRAW_PART_INDICATOR },
     { "BAR_MODE_NORMAL", LV_BAR_MODE_NORMAL },
     { "BAR_MODE_RANGE", LV_BAR_MODE_RANGE },
     { "BAR_MODE_SYMMETRICAL", LV_BAR_MODE_SYMMETRICAL },
@@ -138,6 +147,7 @@ const be_const_member_t lv0_constants[] = {
     { "BASE_DIR_RTL", LV_BASE_DIR_RTL },
     { "BASE_DIR_WEAK", LV_BASE_DIR_WEAK },
     { "BLEND_MODE_ADDITIVE", LV_BLEND_MODE_ADDITIVE },
+    { "BLEND_MODE_MULTIPLY", LV_BLEND_MODE_MULTIPLY },
     { "BLEND_MODE_NORMAL", LV_BLEND_MODE_NORMAL },
     { "BLEND_MODE_SUBTRACTIVE", LV_BLEND_MODE_SUBTRACTIVE },
     { "BORDER_SIDE_BOTTOM", LV_BORDER_SIDE_BOTTOM },
@@ -155,17 +165,27 @@ const be_const_member_t lv0_constants[] = {
     { "BTNMATRIX_CTRL_DISABLED", LV_BTNMATRIX_CTRL_DISABLED },
     { "BTNMATRIX_CTRL_HIDDEN", LV_BTNMATRIX_CTRL_HIDDEN },
     { "BTNMATRIX_CTRL_NO_REPEAT", LV_BTNMATRIX_CTRL_NO_REPEAT },
+    { "BTNMATRIX_CTRL_POPOVER", LV_BTNMATRIX_CTRL_POPOVER },
     { "BTNMATRIX_CTRL_RECOLOR", LV_BTNMATRIX_CTRL_RECOLOR },
+    { "BTNMATRIX_DRAW_PART_BTN", LV_BTNMATRIX_DRAW_PART_BTN },
     { "CHART_AXIS_PRIMARY_X", LV_CHART_AXIS_PRIMARY_X },
     { "CHART_AXIS_PRIMARY_Y", LV_CHART_AXIS_PRIMARY_Y },
     { "CHART_AXIS_SECONDARY_X", LV_CHART_AXIS_SECONDARY_X },
     { "CHART_AXIS_SECONDARY_Y", LV_CHART_AXIS_SECONDARY_Y },
+    { "CHART_DRAW_PART_BAR", LV_CHART_DRAW_PART_BAR },
+    { "CHART_DRAW_PART_CURSOR", LV_CHART_DRAW_PART_CURSOR },
+    { "CHART_DRAW_PART_DIV_LINE_HOR", LV_CHART_DRAW_PART_DIV_LINE_HOR },
+    { "CHART_DRAW_PART_DIV_LINE_INIT", LV_CHART_DRAW_PART_DIV_LINE_INIT },
+    { "CHART_DRAW_PART_DIV_LINE_VER", LV_CHART_DRAW_PART_DIV_LINE_VER },
+    { "CHART_DRAW_PART_LINE_AND_POINT", LV_CHART_DRAW_PART_LINE_AND_POINT },
+    { "CHART_DRAW_PART_TICK_LABEL", LV_CHART_DRAW_PART_TICK_LABEL },
     { "CHART_TYPE_BAR", LV_CHART_TYPE_BAR },
     { "CHART_TYPE_LINE", LV_CHART_TYPE_LINE },
     { "CHART_TYPE_NONE", LV_CHART_TYPE_NONE },
     { "CHART_TYPE_SCATTER", LV_CHART_TYPE_SCATTER },
     { "CHART_UPDATE_MODE_CIRCULAR", LV_CHART_UPDATE_MODE_CIRCULAR },
     { "CHART_UPDATE_MODE_SHIFT", LV_CHART_UPDATE_MODE_SHIFT },
+    { "CHECKBOX_DRAW_PART_BOX", LV_CHECKBOX_DRAW_PART_BOX },
     { "COLORWHEEL_MODE_HUE", LV_COLORWHEEL_MODE_HUE },
     { "COLORWHEEL_MODE_SATURATION", LV_COLORWHEEL_MODE_SATURATION },
     { "COLORWHEEL_MODE_VALUE", LV_COLORWHEEL_MODE_VALUE },
@@ -217,6 +237,8 @@ const be_const_member_t lv0_constants[] = {
     { "EVENT_ALL", LV_EVENT_ALL },
     { "EVENT_CANCEL", LV_EVENT_CANCEL },
     { "EVENT_CHILD_CHANGED", LV_EVENT_CHILD_CHANGED },
+    { "EVENT_CHILD_CREATED", LV_EVENT_CHILD_CREATED },
+    { "EVENT_CHILD_DELETED", LV_EVENT_CHILD_DELETED },
     { "EVENT_CLICKED", LV_EVENT_CLICKED },
     { "EVENT_COVER_CHECK", LV_EVENT_COVER_CHECK },
     { "EVENT_DEFOCUSED", LV_EVENT_DEFOCUSED },
@@ -246,6 +268,10 @@ const be_const_member_t lv0_constants[] = {
     { "EVENT_REFRESH", LV_EVENT_REFRESH },
     { "EVENT_REFR_EXT_DRAW_SIZE", LV_EVENT_REFR_EXT_DRAW_SIZE },
     { "EVENT_RELEASED", LV_EVENT_RELEASED },
+    { "EVENT_SCREEN_LOADED", LV_EVENT_SCREEN_LOADED },
+    { "EVENT_SCREEN_LOAD_START", LV_EVENT_SCREEN_LOAD_START },
+    { "EVENT_SCREEN_UNLOADED", LV_EVENT_SCREEN_UNLOADED },
+    { "EVENT_SCREEN_UNLOAD_START", LV_EVENT_SCREEN_UNLOAD_START },
     { "EVENT_SCROLL", LV_EVENT_SCROLL },
     { "EVENT_SCROLL_BEGIN", LV_EVENT_SCROLL_BEGIN },
     { "EVENT_SCROLL_END", LV_EVENT_SCROLL_END },
@@ -253,20 +279,6 @@ const be_const_member_t lv0_constants[] = {
     { "EVENT_SIZE_CHANGED", LV_EVENT_SIZE_CHANGED },
     { "EVENT_STYLE_CHANGED", LV_EVENT_STYLE_CHANGED },
     { "EVENT_VALUE_CHANGED", LV_EVENT_VALUE_CHANGED },
-    { "FLEX_ALIGN_CENTER", LV_FLEX_ALIGN_CENTER },
-    { "FLEX_ALIGN_END", LV_FLEX_ALIGN_END },
-    { "FLEX_ALIGN_SPACE_AROUND", LV_FLEX_ALIGN_SPACE_AROUND },
-    { "FLEX_ALIGN_SPACE_BETWEEN", LV_FLEX_ALIGN_SPACE_BETWEEN },
-    { "FLEX_ALIGN_SPACE_EVENLY", LV_FLEX_ALIGN_SPACE_EVENLY },
-    { "FLEX_ALIGN_START", LV_FLEX_ALIGN_START },
-    { "FLEX_FLOW_COLUMN", LV_FLEX_FLOW_COLUMN },
-    { "FLEX_FLOW_COLUMN_REVERSE", LV_FLEX_FLOW_COLUMN_REVERSE },
-    { "FLEX_FLOW_COLUMN_WRAP", LV_FLEX_FLOW_COLUMN_WRAP },
-    { "FLEX_FLOW_COLUMN_WRAP_REVERSE", LV_FLEX_FLOW_COLUMN_WRAP_REVERSE },
-    { "FLEX_FLOW_ROW", LV_FLEX_FLOW_ROW },
-    { "FLEX_FLOW_ROW_REVERSE", LV_FLEX_FLOW_ROW_REVERSE },
-    { "FLEX_FLOW_ROW_WRAP", LV_FLEX_FLOW_ROW_WRAP },
-    { "FLEX_FLOW_ROW_WRAP_REVERSE", LV_FLEX_FLOW_ROW_WRAP_REVERSE },
     { "FS_MODE_RD", LV_FS_MODE_RD },
     { "FS_MODE_WR", LV_FS_MODE_WR },
     { "FS_RES_BUSY", LV_FS_RES_BUSY },
@@ -288,13 +300,6 @@ const be_const_member_t lv0_constants[] = {
     { "GRAD_DIR_HOR", LV_GRAD_DIR_HOR },
     { "GRAD_DIR_NONE", LV_GRAD_DIR_NONE },
     { "GRAD_DIR_VER", LV_GRAD_DIR_VER },
-    { "GRID_ALIGN_CENTER", LV_GRID_ALIGN_CENTER },
-    { "GRID_ALIGN_END", LV_GRID_ALIGN_END },
-    { "GRID_ALIGN_SPACE_AROUND", LV_GRID_ALIGN_SPACE_AROUND },
-    { "GRID_ALIGN_SPACE_BETWEEN", LV_GRID_ALIGN_SPACE_BETWEEN },
-    { "GRID_ALIGN_SPACE_EVENLY", LV_GRID_ALIGN_SPACE_EVENLY },
-    { "GRID_ALIGN_START", LV_GRID_ALIGN_START },
-    { "GRID_ALIGN_STRETCH", LV_GRID_ALIGN_STRETCH },
     { "GROUP_REFOCUS_POLICY_NEXT", LV_GROUP_REFOCUS_POLICY_NEXT },
     { "GROUP_REFOCUS_POLICY_PREV", LV_GROUP_REFOCUS_POLICY_PREV },
     { "IMGBTN_STATE_CHECKED_DISABLED", LV_IMGBTN_STATE_CHECKED_DISABLED },
@@ -318,6 +323,8 @@ const be_const_member_t lv0_constants[] = {
     { "IMG_CF_TRUE_COLOR_ALPHA", LV_IMG_CF_TRUE_COLOR_ALPHA },
     { "IMG_CF_TRUE_COLOR_CHROMA_KEYED", LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED },
     { "IMG_CF_UNKNOWN", LV_IMG_CF_UNKNOWN },
+    { "IMG_SIZE_MODE_REAL", LV_IMG_SIZE_MODE_REAL },
+    { "IMG_SIZE_MODE_VIRTUAL", LV_IMG_SIZE_MODE_VIRTUAL },
     { "IMG_SRC_FILE", LV_IMG_SRC_FILE },
     { "IMG_SRC_SYMBOL", LV_IMG_SRC_SYMBOL },
     { "IMG_SRC_UNKNOWN", LV_IMG_SRC_UNKNOWN },
@@ -346,6 +353,11 @@ const be_const_member_t lv0_constants[] = {
     { "LABEL_LONG_SCROLL", LV_LABEL_LONG_SCROLL },
     { "LABEL_LONG_SCROLL_CIRCULAR", LV_LABEL_LONG_SCROLL_CIRCULAR },
     { "LABEL_LONG_WRAP", LV_LABEL_LONG_WRAP },
+    { "LED_DRAW_PART_RECTANGLE", LV_LED_DRAW_PART_RECTANGLE },
+    { "METER_DRAW_PART_ARC", LV_METER_DRAW_PART_ARC },
+    { "METER_DRAW_PART_NEEDLE_IMG", LV_METER_DRAW_PART_NEEDLE_IMG },
+    { "METER_DRAW_PART_NEEDLE_LINE", LV_METER_DRAW_PART_NEEDLE_LINE },
+    { "METER_DRAW_PART_TICK", LV_METER_DRAW_PART_TICK },
     { "METER_INDICATOR_TYPE_ARC", LV_METER_INDICATOR_TYPE_ARC },
     { "METER_INDICATOR_TYPE_NEEDLE_IMG", LV_METER_INDICATOR_TYPE_NEEDLE_IMG },
     { "METER_INDICATOR_TYPE_NEEDLE_LINE", LV_METER_INDICATOR_TYPE_NEEDLE_LINE },
@@ -356,6 +368,9 @@ const be_const_member_t lv0_constants[] = {
     { "OBJ_CLASS_GROUP_DEF_FALSE", LV_OBJ_CLASS_GROUP_DEF_FALSE },
     { "OBJ_CLASS_GROUP_DEF_INHERIT", LV_OBJ_CLASS_GROUP_DEF_INHERIT },
     { "OBJ_CLASS_GROUP_DEF_TRUE", LV_OBJ_CLASS_GROUP_DEF_TRUE },
+    { "OBJ_DRAW_PART_BORDER_POST", LV_OBJ_DRAW_PART_BORDER_POST },
+    { "OBJ_DRAW_PART_RECTANGLE", LV_OBJ_DRAW_PART_RECTANGLE },
+    { "OBJ_DRAW_PART_SCROLLBAR", LV_OBJ_DRAW_PART_SCROLLBAR },
     { "OBJ_FLAG_ADV_HITTEST", LV_OBJ_FLAG_ADV_HITTEST },
     { "OBJ_FLAG_CHECKABLE", LV_OBJ_FLAG_CHECKABLE },
     { "OBJ_FLAG_CLICKABLE", LV_OBJ_FLAG_CLICKABLE },
@@ -374,7 +389,7 @@ const be_const_member_t lv0_constants[] = {
     { "OBJ_FLAG_SCROLL_MOMENTUM", LV_OBJ_FLAG_SCROLL_MOMENTUM },
     { "OBJ_FLAG_SCROLL_ONE", LV_OBJ_FLAG_SCROLL_ONE },
     { "OBJ_FLAG_SCROLL_ON_FOCUS", LV_OBJ_FLAG_SCROLL_ON_FOCUS },
-    { "OBJ_FLAG_SNAPABLE", LV_OBJ_FLAG_SNAPABLE },
+    { "OBJ_FLAG_SNAPPABLE", LV_OBJ_FLAG_SNAPPABLE },
     { "OBJ_FLAG_USER_1", LV_OBJ_FLAG_USER_1 },
     { "OBJ_FLAG_USER_2", LV_OBJ_FLAG_USER_2 },
     { "OBJ_FLAG_USER_3", LV_OBJ_FLAG_USER_3 },
@@ -452,6 +467,8 @@ const be_const_member_t lv0_constants[] = {
     { "SCR_LOAD_ANIM_OVER_RIGHT", LV_SCR_LOAD_ANIM_OVER_RIGHT },
     { "SCR_LOAD_ANIM_OVER_TOP", LV_SCR_LOAD_ANIM_OVER_TOP },
     { "SIZE_CONTENT", LV_SIZE_CONTENT },
+    { "SLIDER_DRAW_PART_KNOB", LV_SLIDER_DRAW_PART_KNOB },
+    { "SLIDER_DRAW_PART_KNOB_LEFT", LV_SLIDER_DRAW_PART_KNOB_LEFT },
     { "SLIDER_MODE_NORMAL", LV_SLIDER_MODE_NORMAL },
     { "SLIDER_MODE_RANGE", LV_SLIDER_MODE_RANGE },
     { "SLIDER_MODE_SYMMETRICAL", LV_SLIDER_MODE_SYMMETRICAL },
@@ -630,6 +647,7 @@ const be_const_member_t lv0_constants[] = {
     { "TABLE_CELL_CTRL_CUSTOM_4", LV_TABLE_CELL_CTRL_CUSTOM_4 },
     { "TABLE_CELL_CTRL_MERGE_RIGHT", LV_TABLE_CELL_CTRL_MERGE_RIGHT },
     { "TABLE_CELL_CTRL_TEXT_CROP", LV_TABLE_CELL_CTRL_TEXT_CROP },
+    { "TABLE_DRAW_PART_CELL", LV_TABLE_DRAW_PART_CELL },
     { "TEXTAREA_CURSOR_LAST", LV_TEXTAREA_CURSOR_LAST },
     { "TEXT_ALIGN_AUTO", LV_TEXT_ALIGN_AUTO },
     { "TEXT_ALIGN_CENTER", LV_TEXT_ALIGN_CENTER },
@@ -664,19 +682,21 @@ be_local_closure(lv_lv_module_init,   /* name */
     0,                          /* has sup protos */
     NULL,                       /* no sub protos */
     1,                          /* has constants */
-    ( &(const bvalue[ 2]) {     /* constants */
+    ( &(const bvalue[ 3]) {     /* constants */
     /* K0   */  be_nested_str(lv),
     /* K1   */  be_nested_str(member),
+    /* K2   */  be_nested_str(lv_solidified),
     }),
     &be_const_str_lv_module_init,
     &be_const_str_solidified,
-    ( &(const binstruction[ 6]) {  /* code */
+    ( &(const binstruction[ 7]) {  /* code */
       0x6004000B,  //  0000  GETGBL	R1	G11
       0x58080000,  //  0001  LDCONST	R2	K0
       0x7C040200,  //  0002  CALL	R1	1
       0x88080101,  //  0003  GETMBR	R2	R0	K1
       0x90060202,  //  0004  SETMBR	R1	K1	R2
-      0x80040200,  //  0005  RET	1	R1
+      0x90060400,  //  0005  SETMBR	R1	K2	R0
+      0x80040200,  //  0006  RET	1	R1
     })
   )
 );
@@ -696,3 +716,5 @@ be_local_module(lv,
 );
 BE_EXPORT_VARIABLE be_define_const_native_module(lv);
 /********************************************************************/
+
+/********************************************************************/
diff --git a/lib/libesp32_lvgl/lv_berry/generate/be_lvgl_widgets_lib.c b/lib/libesp32_lvgl/lv_berry/generate/be_lvgl_widgets_lib.c
index 274f7e0f3..17ebc5416 100644
--- a/lib/libesp32_lvgl/lv_berry/generate/be_lvgl_widgets_lib.c
+++ b/lib/libesp32_lvgl/lv_berry/generate/be_lvgl_widgets_lib.c
@@ -135,6 +135,7 @@ extern int lvbe_img_set_angle(bvm *vm);
 extern int lvbe_img_set_pivot(bvm *vm);
 extern int lvbe_img_set_zoom(bvm *vm);
 extern int lvbe_img_set_antialias(bvm *vm);
+extern int lvbe_img_set_size_mode(bvm *vm);
 extern int lvbe_img_get_src(bvm *vm);
 extern int lvbe_img_get_offset_x(bvm *vm);
 extern int lvbe_img_get_offset_y(bvm *vm);
@@ -162,6 +163,7 @@ extern int lvbe_disp_dpx(bvm *vm);
 /* `lv_obj` external functions definitions */
 extern int lvbe_obj_add_event_cb(bvm *vm);
 extern int lvbe_obj_remove_event_cb(bvm *vm);
+extern int lvbe_obj_remove_event_cb_with_user_data(bvm *vm);
 extern int lvbe_obj_remove_event_dsc(bvm *vm);
 extern int lvbe_obj_create(bvm *vm);
 extern int lvbe_obj_add_flag(bvm *vm);
@@ -272,6 +274,9 @@ extern int lvbe_obj_set_style_pad_hor(bvm *vm);
 extern int lvbe_obj_set_style_pad_ver(bvm *vm);
 extern int lvbe_obj_set_style_pad_gap(bvm *vm);
 extern int lvbe_obj_set_style_size(bvm *vm);
+extern int lvbe_obj_calculate_style_text_align(bvm *vm);
+extern int lvbe_obj_get_x_aligned(bvm *vm);
+extern int lvbe_obj_get_y_aligned(bvm *vm);
 extern int lvbe_obj_get_style_width(bvm *vm);
 extern int lvbe_obj_get_style_min_width(bvm *vm);
 extern int lvbe_obj_get_style_max_width(bvm *vm);
@@ -450,16 +455,17 @@ extern int lvbe_obj_set_style_arc_opa(bvm *vm);
 extern int lvbe_obj_set_style_arc_img_src(bvm *vm);
 extern int lvbe_obj_del(bvm *vm);
 extern int lvbe_obj_clean(bvm *vm);
+extern int lvbe_obj_del_delayed(bvm *vm);
 extern int lvbe_obj_del_async(bvm *vm);
 extern int lvbe_obj_set_parent(bvm *vm);
-extern int lvbe_obj_move_foreground(bvm *vm);
-extern int lvbe_obj_move_background(bvm *vm);
+extern int lvbe_obj_swap(bvm *vm);
+extern int lvbe_obj_move_to_index(bvm *vm);
 extern int lvbe_obj_get_screen(bvm *vm);
 extern int lvbe_obj_get_disp(bvm *vm);
 extern int lvbe_obj_get_parent(bvm *vm);
 extern int lvbe_obj_get_child(bvm *vm);
 extern int lvbe_obj_get_child_cnt(bvm *vm);
-extern int lvbe_obj_get_child_id(bvm *vm);
+extern int lvbe_obj_get_index(bvm *vm);
 extern int lvbe_obj_tree_walk(bvm *vm);
 
 /* `lv_group` external functions definitions */
@@ -467,6 +473,7 @@ extern int lvbe_group_create(bvm *vm);
 extern int lvbe_group_del(bvm *vm);
 extern int lvbe_group_set_default(bvm *vm);
 extern int lvbe_group_add_obj(bvm *vm);
+extern int lvbe_group_swap_obj(bvm *vm);
 extern int lvbe_group_remove_obj(bvm *vm);
 extern int lvbe_group_remove_all_objs(bvm *vm);
 extern int lvbe_group_focus_obj(bvm *vm);
@@ -551,6 +558,7 @@ extern int lvbe_colorwheel_get_color_mode_fixed(bvm *vm);
 /* `lv_imgbtn` external functions definitions */
 extern int lvbe_imgbtn_create(bvm *vm);
 extern int lvbe_imgbtn_set_src(bvm *vm);
+extern int lvbe_imgbtn_set_state(bvm *vm);
 
 /* `lv_led` external functions definitions */
 extern int lvbe_led_create(bvm *vm);
@@ -580,9 +588,12 @@ extern int lvbe_msgbox_create(bvm *vm);
 extern int lvbe_msgbox_get_title(bvm *vm);
 extern int lvbe_msgbox_get_close_btn(bvm *vm);
 extern int lvbe_msgbox_get_text(bvm *vm);
+extern int lvbe_msgbox_get_content(bvm *vm);
 extern int lvbe_msgbox_get_btns(bvm *vm);
+extern int lvbe_msgbox_get_active_btn(bvm *vm);
 extern int lvbe_msgbox_get_active_btn_text(bvm *vm);
 extern int lvbe_msgbox_close(bvm *vm);
+extern int lvbe_msgbox_close_async(bvm *vm);
 
 /* `lv_spinbox` external functions definitions */
 extern int lvbe_spinbox_create(bvm *vm);
@@ -591,6 +602,8 @@ extern int lvbe_spinbox_set_rollover(bvm *vm);
 extern int lvbe_spinbox_set_digit_format(bvm *vm);
 extern int lvbe_spinbox_set_step(bvm *vm);
 extern int lvbe_spinbox_set_range(bvm *vm);
+extern int lvbe_spinbox_set_pos(bvm *vm);
+extern int lvbe_spinbox_set_digit_step_direction(bvm *vm);
 extern int lvbe_spinbox_get_rollover(bvm *vm);
 extern int lvbe_spinbox_get_value(bvm *vm);
 extern int lvbe_spinbox_get_step(bvm *vm);
@@ -658,7 +671,9 @@ extern int lvbe_btnmatrix_get_one_checked(bvm *vm);
 /* `lv_canvas` external functions definitions */
 extern int lvbe_canvas_create(bvm *vm);
 extern int lvbe_canvas_set_buffer(bvm *vm);
+extern int lvbe_canvas_set_px_color(bvm *vm);
 extern int lvbe_canvas_set_px(bvm *vm);
+extern int lvbe_canvas_set_px_opa(bvm *vm);
 extern int lvbe_canvas_set_palette(bvm *vm);
 extern int lvbe_canvas_get_px(bvm *vm);
 extern int lvbe_canvas_copy_buf(bvm *vm);
diff --git a/lib/libesp32_lvgl/lv_berry/mapping/lv_enum.h b/lib/libesp32_lvgl/lv_berry/mapping/lv_enum.h
index 0d372b116..64f57a1d1 100644
--- a/lib/libesp32_lvgl/lv_berry/mapping/lv_enum.h
+++ b/lib/libesp32_lvgl/lv_berry/mapping/lv_enum.h
@@ -104,6 +104,7 @@ SYMBOL_BULLET="\xE2\x80\xA2"
 // Generated from headers
 // ======================================================================
 
+// File: ../../lvgl/src/core/lv_disp.h
 LV_SCR_LOAD_ANIM_NONE
 LV_SCR_LOAD_ANIM_OVER_LEFT
 LV_SCR_LOAD_ANIM_OVER_RIGHT
@@ -115,6 +116,7 @@ LV_SCR_LOAD_ANIM_MOVE_TOP
 LV_SCR_LOAD_ANIM_MOVE_BOTTOM
 LV_SCR_LOAD_ANIM_FADE_ON
 
+// File: ../../lvgl/src/core/lv_event.h
 LV_EVENT_ALL
 LV_EVENT_PRESSED
 LV_EVENT_PRESSING
@@ -150,10 +152,17 @@ LV_EVENT_READY
 LV_EVENT_CANCEL
 LV_EVENT_DELETE
 LV_EVENT_CHILD_CHANGED
+LV_EVENT_CHILD_CREATED
+LV_EVENT_CHILD_DELETED
+LV_EVENT_SCREEN_UNLOAD_START
+LV_EVENT_SCREEN_LOAD_START
+LV_EVENT_SCREEN_LOADED
+LV_EVENT_SCREEN_UNLOADED
 LV_EVENT_SIZE_CHANGED
 LV_EVENT_STYLE_CHANGED
 LV_EVENT_LAYOUT_CHANGED
 LV_EVENT_GET_SELF_SIZE
+// File: ../../lvgl/src/core/lv_group.h
 LV_KEY_UP
 LV_KEY_DOWN
 LV_KEY_RIGHT
@@ -169,6 +178,9 @@ LV_KEY_END
 
 LV_GROUP_REFOCUS_POLICY_NEXT
 LV_GROUP_REFOCUS_POLICY_PREV
+// File: ../../lvgl/src/core/lv_indev.h
+// File: ../../lvgl/src/core/lv_indev_scroll.h
+// File: ../../lvgl/src/core/lv_obj.h
 LV_STATE_DEFAULT
 LV_STATE_CHECKED
 LV_STATE_FOCUSED
@@ -205,7 +217,7 @@ LV_OBJ_FLAG_SCROLL_MOMENTUM
 LV_OBJ_FLAG_SCROLL_ONE
 LV_OBJ_FLAG_SCROLL_CHAIN
 LV_OBJ_FLAG_SCROLL_ON_FOCUS
-LV_OBJ_FLAG_SNAPABLE
+LV_OBJ_FLAG_SNAPPABLE
 LV_OBJ_FLAG_PRESS_LOCK
 LV_OBJ_FLAG_EVENT_BUBBLE
 LV_OBJ_FLAG_GESTURE_BUBBLE
@@ -221,6 +233,11 @@ LV_OBJ_FLAG_USER_2
 LV_OBJ_FLAG_USER_3
 LV_OBJ_FLAG_USER_4
 
+LV_OBJ_DRAW_PART_RECTANGLE
+LV_OBJ_DRAW_PART_BORDER_POST
+LV_OBJ_DRAW_PART_SCROLLBAR
+
+// File: ../../lvgl/src/core/lv_obj_class.h
 LV_OBJ_CLASS_EDITABLE_INHERIT
 LV_OBJ_CLASS_EDITABLE_TRUE
 LV_OBJ_CLASS_EDITABLE_FALSE
@@ -229,10 +246,13 @@ LV_OBJ_CLASS_GROUP_DEF_INHERIT
 LV_OBJ_CLASS_GROUP_DEF_TRUE
 LV_OBJ_CLASS_GROUP_DEF_FALSE
 
+// File: ../../lvgl/src/core/lv_obj_draw.h
 LV_COVER_RES_COVER
 LV_COVER_RES_NOT_COVER
 LV_COVER_RES_MASKED
 
+// File: ../../lvgl/src/core/lv_obj_pos.h
+// File: ../../lvgl/src/core/lv_obj_scroll.h
 LV_SCROLLBAR_MODE_OFF
 LV_SCROLLBAR_MODE_ON
 LV_SCROLLBAR_MODE_ACTIVE
@@ -242,11 +262,23 @@ LV_SCROLL_SNAP_NONE
 LV_SCROLL_SNAP_START
 LV_SCROLL_SNAP_END
 LV_SCROLL_SNAP_CENTER
+// File: ../../lvgl/src/core/lv_obj_style.h
 
+// File: ../../lvgl/src/core/lv_obj_style_gen.h
+// File: ../../lvgl/src/core/lv_obj_tree.h
 LV_OBJ_TREE_WALK_NEXT
 LV_OBJ_TREE_WALK_SKIP_CHILDREN
 LV_OBJ_TREE_WALK_END
 
+// File: ../../lvgl/src/core/lv_refr.h
+// File: ../../lvgl/src/core/lv_theme.h
+// File: ../../lvgl/src/draw/lv_draw.h
+// File: ../../lvgl/src/draw/lv_draw_arc.h
+// File: ../../lvgl/src/draw/lv_draw_blend.h
+// File: ../../lvgl/src/draw/lv_draw_img.h
+// File: ../../lvgl/src/draw/lv_draw_label.h
+// File: ../../lvgl/src/draw/lv_draw_line.h
+// File: ../../lvgl/src/draw/lv_draw_mask.h
 LV_DRAW_MASK_RES_TRANSP
 LV_DRAW_MASK_RES_FULL_COVER
 LV_DRAW_MASK_RES_CHANGED
@@ -262,6 +294,9 @@ LV_DRAW_MASK_LINE_SIDE_RIGHT
 LV_DRAW_MASK_LINE_SIDE_TOP
 LV_DRAW_MASK_LINE_SIDE_BOTTOM
 
+// File: ../../lvgl/src/draw/lv_draw_rect.h
+// File: ../../lvgl/src/draw/lv_draw_triangle.h
+// File: ../../lvgl/src/draw/lv_img_buf.h
 LV_IMG_CF_UNKNOWN
 LV_IMG_CF_RAW
 LV_IMG_CF_RAW_ALPHA
@@ -278,37 +313,20 @@ LV_IMG_CF_ALPHA_2BIT
 LV_IMG_CF_ALPHA_4BIT
 LV_IMG_CF_ALPHA_8BIT
 
+// File: ../../lvgl/src/draw/lv_img_cache.h
+// File: ../../lvgl/src/draw/lv_img_decoder.h
 LV_IMG_SRC_VARIABLE
 LV_IMG_SRC_FILE
 LV_IMG_SRC_SYMBOL
 LV_IMG_SRC_UNKNOWN
 
-LV_FLEX_ALIGN_START
-LV_FLEX_ALIGN_END
-LV_FLEX_ALIGN_CENTER
-LV_FLEX_ALIGN_SPACE_EVENLY
-LV_FLEX_ALIGN_SPACE_AROUND
-LV_FLEX_ALIGN_SPACE_BETWEEN
-
-LV_FLEX_FLOW_ROW
-LV_FLEX_FLOW_COLUMN
-LV_FLEX_FLOW_ROW_WRAP
-LV_FLEX_FLOW_ROW_REVERSE
-LV_FLEX_FLOW_ROW_WRAP_REVERSE
-LV_FLEX_FLOW_COLUMN_WRAP
-LV_FLEX_FLOW_COLUMN_REVERSE
-LV_FLEX_FLOW_COLUMN_WRAP_REVERSE
-
-LV_GRID_ALIGN_START
-LV_GRID_ALIGN_CENTER
-LV_GRID_ALIGN_END
-LV_GRID_ALIGN_STRETCH
-LV_GRID_ALIGN_SPACE_EVENLY
-LV_GRID_ALIGN_SPACE_AROUND
-LV_GRID_ALIGN_SPACE_BETWEEN
-
+// File: ../../lvgl/src/extra/widgets/animimg/lv_animimg.h
 LV_ANIM_IMG_PART_MAIN
 
+// File: ../../lvgl/src/extra/widgets/calendar/lv_calendar.h
+// File: ../../lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.h
+// File: ../../lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.h
+// File: ../../lvgl/src/extra/widgets/chart/lv_chart.h
 LV_CHART_TYPE_NONE
 LV_CHART_TYPE_LINE
 LV_CHART_TYPE_BAR
@@ -321,9 +339,19 @@ LV_CHART_AXIS_PRIMARY_Y
 LV_CHART_AXIS_SECONDARY_Y
 LV_CHART_AXIS_PRIMARY_X
 LV_CHART_AXIS_SECONDARY_X
+LV_CHART_DRAW_PART_DIV_LINE_INIT
+LV_CHART_DRAW_PART_DIV_LINE_HOR
+LV_CHART_DRAW_PART_DIV_LINE_VER
+LV_CHART_DRAW_PART_LINE_AND_POINT
+LV_CHART_DRAW_PART_BAR
+LV_CHART_DRAW_PART_CURSOR
+LV_CHART_DRAW_PART_TICK_LABEL
+
+// File: ../../lvgl/src/extra/widgets/colorwheel/lv_colorwheel.h
 LV_COLORWHEEL_MODE_HUE
 LV_COLORWHEEL_MODE_SATURATION
 LV_COLORWHEEL_MODE_VALUE
+// File: ../../lvgl/src/extra/widgets/imgbtn/lv_imgbtn.h
 LV_IMGBTN_STATE_RELEASED
 LV_IMGBTN_STATE_PRESSED
 LV_IMGBTN_STATE_DISABLED
@@ -331,12 +359,26 @@ LV_IMGBTN_STATE_CHECKED_RELEASED
 LV_IMGBTN_STATE_CHECKED_PRESSED
 LV_IMGBTN_STATE_CHECKED_DISABLED
 
+// File: ../../lvgl/src/extra/widgets/keyboard/lv_keyboard.h
 
+// File: ../../lvgl/src/extra/widgets/led/lv_led.h
+LV_LED_DRAW_PART_RECTANGLE
+
+// File: ../../lvgl/src/extra/widgets/list/lv_list.h
+// File: ../../lvgl/src/extra/widgets/lv_widgets.h
+// File: ../../lvgl/src/extra/widgets/meter/lv_meter.h
 LV_METER_INDICATOR_TYPE_NEEDLE_IMG
 LV_METER_INDICATOR_TYPE_NEEDLE_LINE
 LV_METER_INDICATOR_TYPE_SCALE_LINES
 LV_METER_INDICATOR_TYPE_ARC
 
+LV_METER_DRAW_PART_ARC
+LV_METER_DRAW_PART_NEEDLE_LINE
+LV_METER_DRAW_PART_NEEDLE_IMG
+LV_METER_DRAW_PART_TICK
+
+// File: ../../lvgl/src/extra/widgets/msgbox/lv_msgbox.h
+// File: ../../lvgl/src/extra/widgets/span/lv_span.h
 LV_SPAN_OVERFLOW_CLIP
 LV_SPAN_OVERFLOW_ELLIPSIS
 
@@ -344,14 +386,18 @@ LV_SPAN_MODE_FIXED
 LV_SPAN_MODE_EXPAND
 LV_SPAN_MODE_BREAK
 
-
-
-
-
+// File: ../../lvgl/src/extra/widgets/spinbox/lv_spinbox.h
+// File: ../../lvgl/src/extra/widgets/spinner/lv_spinner.h
+// File: ../../lvgl/src/extra/widgets/tabview/lv_tabview.h
+// File: ../../lvgl/src/extra/widgets/tileview/lv_tileview.h
+// File: ../../lvgl/src/extra/widgets/win/lv_win.h
+// File: ../../lvgl/src/hal/lv_hal.h
+// File: ../../lvgl/src/hal/lv_hal_disp.h
 LV_DISP_ROT_NONE
 LV_DISP_ROT_90
 LV_DISP_ROT_180
 LV_DISP_ROT_270
+// File: ../../lvgl/src/hal/lv_hal_indev.h
 LV_INDEV_TYPE_NONE
 LV_INDEV_TYPE_POINTER
 LV_INDEV_TYPE_KEYPAD
@@ -360,9 +406,13 @@ LV_INDEV_TYPE_ENCODER
 
 LV_INDEV_STATE_RELEASED
 LV_INDEV_STATE_PRESSED
+// File: ../../lvgl/src/hal/lv_hal_tick.h
+// File: ../../lvgl/src/misc/lv_anim.h
 LV_ANIM_OFF
 LV_ANIM_ON
 
+// File: ../../lvgl/src/misc/lv_anim_timeline.h
+// File: ../../lvgl/src/misc/lv_area.h
 LV_ALIGN_DEFAULT
 LV_ALIGN_TOP_LEFT
 LV_ALIGN_TOP_MID
@@ -395,12 +445,16 @@ LV_DIR_HOR
 LV_DIR_VER
 LV_DIR_ALL
 
+// File: ../../lvgl/src/misc/lv_assert.h
+// File: ../../lvgl/src/misc/lv_async.h
+// File: ../../lvgl/src/misc/lv_bidi.h
 LV_BASE_DIR_LTR
 LV_BASE_DIR_RTL
 LV_BASE_DIR_AUTO
 LV_BASE_DIR_NEUTRAL
 LV_BASE_DIR_WEAK
 
+// File: ../../lvgl/src/misc/lv_color.h
 LV_OPA_TRANSP
 LV_OPA_0
 LV_OPA_10
@@ -436,6 +490,7 @@ LV_PALETTE_BLUE_GREY
 LV_PALETTE_GREY
 LV_PALETTE_NONE
 
+// File: ../../lvgl/src/misc/lv_fs.h
 LV_FS_RES_OK
 LV_FS_RES_HW_ERR
 LV_FS_RES_FS_ERR
@@ -457,9 +512,17 @@ LV_FS_SEEK_SET
 LV_FS_SEEK_CUR
 LV_FS_SEEK_END
 
+// File: ../../lvgl/src/misc/lv_gc.h
+// File: ../../lvgl/src/misc/lv_ll.h
+// File: ../../lvgl/src/misc/lv_log.h
+// File: ../../lvgl/src/misc/lv_math.h
+// File: ../../lvgl/src/misc/lv_mem.h
+// File: ../../lvgl/src/misc/lv_printf.h
+// File: ../../lvgl/src/misc/lv_style.h
 LV_BLEND_MODE_NORMAL
 LV_BLEND_MODE_ADDITIVE
 LV_BLEND_MODE_SUBTRACTIVE
+LV_BLEND_MODE_MULTIPLY
 
 LV_TEXT_DECOR_NONE
 LV_TEXT_DECOR_UNDERLINE
@@ -568,6 +631,11 @@ LV_STYLE_BLEND_MODE
 LV_STYLE_LAYOUT
 LV_STYLE_BASE_DIR
 LV_STYLE_PROP_ANY
+// File: ../../lvgl/src/misc/lv_style_gen.h
+// File: ../../lvgl/src/misc/lv_templ.h
+// File: ../../lvgl/src/misc/lv_timer.h
+// File: ../../lvgl/src/misc/lv_tlsf.h
+// File: ../../lvgl/src/misc/lv_txt.h
 LV_TEXT_FLAG_NONE
 LV_TEXT_FLAG_RECOLOR
 LV_TEXT_FLAG_EXPAND
@@ -582,37 +650,72 @@ LV_TEXT_ALIGN_LEFT
 LV_TEXT_ALIGN_CENTER
 LV_TEXT_ALIGN_RIGHT
 
+// File: ../../lvgl/src/misc/lv_txt_ap.h
+// File: ../../lvgl/src/misc/lv_types.h
 LV_RES_INV
 LV_RES_OK
 
+// File: ../../lvgl/src/misc/lv_utils.h
+// File: ../../lvgl/src/widgets/lv_arc.h
 LV_ARC_MODE_NORMAL
 LV_ARC_MODE_SYMMETRICAL
 LV_ARC_MODE_REVERSE
+LV_ARC_DRAW_PART_BACKGROUND
+LV_ARC_DRAW_PART_FOREGROUND
+LV_ARC_DRAW_PART_KNOB
+
+// File: ../../lvgl/src/widgets/lv_bar.h
 LV_BAR_MODE_NORMAL
 LV_BAR_MODE_SYMMETRICAL
 LV_BAR_MODE_RANGE
+LV_BAR_DRAW_PART_INDICATOR
+
+// File: ../../lvgl/src/widgets/lv_btn.h
+// File: ../../lvgl/src/widgets/lv_btnmatrix.h
 LV_BTNMATRIX_CTRL_HIDDEN
 LV_BTNMATRIX_CTRL_NO_REPEAT
 LV_BTNMATRIX_CTRL_DISABLED
 LV_BTNMATRIX_CTRL_CHECKABLE
 LV_BTNMATRIX_CTRL_CHECKED
 LV_BTNMATRIX_CTRL_CLICK_TRIG
+LV_BTNMATRIX_CTRL_POPOVER
 LV_BTNMATRIX_CTRL_RECOLOR
 LV_BTNMATRIX_CTRL_CUSTOM_1
 LV_BTNMATRIX_CTRL_CUSTOM_2
 
+LV_BTNMATRIX_DRAW_PART_BTN
+
+// File: ../../lvgl/src/widgets/lv_canvas.h
+// File: ../../lvgl/src/widgets/lv_checkbox.h
+LV_CHECKBOX_DRAW_PART_BOX
+
+// File: ../../lvgl/src/widgets/lv_dropdown.h
+// File: ../../lvgl/src/widgets/lv_img.h
+LV_IMG_SIZE_MODE_VIRTUAL
+LV_IMG_SIZE_MODE_REAL
+
+// File: ../../lvgl/src/widgets/lv_label.h
 LV_LABEL_LONG_WRAP
 LV_LABEL_LONG_DOT
 LV_LABEL_LONG_SCROLL
 LV_LABEL_LONG_SCROLL_CIRCULAR
 LV_LABEL_LONG_CLIP
 
+// File: ../../lvgl/src/widgets/lv_line.h
+// File: ../../lvgl/src/widgets/lv_objx_templ.h
+// File: ../../lvgl/src/widgets/lv_roller.h
 LV_ROLLER_MODE_NORMAL
 LV_ROLLER_MODE_INFINITE
 
+// File: ../../lvgl/src/widgets/lv_slider.h
 LV_SLIDER_MODE_NORMAL
 LV_SLIDER_MODE_SYMMETRICAL
 LV_SLIDER_MODE_RANGE
+LV_SLIDER_DRAW_PART_KNOB
+LV_SLIDER_DRAW_PART_KNOB_LEFT
+
+// File: ../../lvgl/src/widgets/lv_switch.h
+// File: ../../lvgl/src/widgets/lv_table.h
 LV_TABLE_CELL_CTRL_MERGE_RIGHT
 LV_TABLE_CELL_CTRL_TEXT_CROP
 LV_TABLE_CELL_CTRL_CUSTOM_1
@@ -620,5 +723,8 @@ LV_TABLE_CELL_CTRL_CUSTOM_2
 LV_TABLE_CELL_CTRL_CUSTOM_3
 LV_TABLE_CELL_CTRL_CUSTOM_4
 
+LV_TABLE_DRAW_PART_CELL
+
+// File: ../../lvgl/src/widgets/lv_textarea.h
 LV_PART_TEXTAREA_PLACEHOLDER
 
diff --git a/lib/libesp32_lvgl/lv_berry/mapping/lv_funcs.h b/lib/libesp32_lvgl/lv_berry/mapping/lv_funcs.h
index 8531ba8ac..2645e3ab4 100644
--- a/lib/libesp32_lvgl/lv_berry/mapping/lv_funcs.h
+++ b/lib/libesp32_lvgl/lv_berry/mapping/lv_funcs.h
@@ -56,6 +56,7 @@ lv_res_t lv_obj_event_base(const lv_obj_class_t * class_p, lv_event_t * e)
 uint32_t lv_event_register_id(void)
 struct _lv_event_dsc_t * lv_obj_add_event_cb(struct _lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data)
 bool lv_obj_remove_event_cb(struct _lv_obj_t * obj, lv_event_cb_t event_cb)
+bool lv_obj_remove_event_cb_with_user_data(struct _lv_obj_t * obj, lv_event_cb_t event_cb, const void * event_user_data)
 bool lv_obj_remove_event_dsc(struct _lv_obj_t * obj, struct _lv_event_dsc_t * event_dsc)
 void lv_event_set_ext_draw_size(lv_event_t * e, lv_coord_t size)
 void lv_event_set_cover_res(lv_event_t * e, lv_cover_res_t res)
@@ -66,6 +67,7 @@ void lv_group_del(lv_group_t * group)
 void lv_group_set_default(lv_group_t * group)
 lv_group_t * lv_group_get_default(void)
 void lv_group_add_obj(lv_group_t * group, struct _lv_obj_t * obj)
+void lv_group_swap_obj(struct _lv_obj_t * obj1, struct _lv_obj_t * obj2)
 void lv_group_remove_obj(struct _lv_obj_t * obj)
 void lv_group_remove_all_objs(lv_group_t * group)
 void lv_group_focus_obj(struct _lv_obj_t * obj)
@@ -107,6 +109,7 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
 // ../../lvgl/src/core/lv_indev_scroll.h
 
 // ../../lvgl/src/core/lv_obj.h
+bool lv_is_initialized(void)
 lv_obj_t * lv_obj_create(lv_obj_t * parent)
 void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f)
 void lv_obj_clear_flag(lv_obj_t * obj, lv_obj_flag_t f)
@@ -140,6 +143,7 @@ void lv_obj_init_draw_line_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_li
 void lv_obj_init_draw_arc_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_arc_dsc_t * draw_dsc)
 lv_coord_t lv_obj_calculate_ext_draw_size(struct _lv_obj_t * obj, uint32_t part)
 void lv_obj_draw_dsc_init(lv_obj_draw_part_dsc_t * dsc, const lv_area_t * clip_area)
+bool lv_obj_draw_part_check_type(lv_obj_draw_part_dsc_t * dsc, const struct _lv_obj_class_t * class_p, uint32_t type)
 void lv_obj_refresh_ext_draw_size(struct _lv_obj_t * obj)
 
 // ../../lvgl/src/core/lv_obj_pos.h
@@ -235,6 +239,9 @@ static inline void lv_obj_set_style_pad_hor(struct _lv_obj_t * obj, lv_coord_t v
 static inline void lv_obj_set_style_pad_ver(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
 static inline void lv_obj_set_style_pad_gap(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
 static inline void lv_obj_set_style_size(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
+lv_text_align_t lv_obj_calculate_style_text_align(const struct _lv_obj_t * obj, lv_part_t part, const char * txt)
+static inline lv_coord_t lv_obj_get_x_aligned(const struct _lv_obj_t * obj)
+static inline lv_coord_t lv_obj_get_y_aligned(const struct _lv_obj_t * obj)
 
 // ../../lvgl/src/core/lv_obj_style_gen.h
 static inline lv_coord_t lv_obj_get_style_width(const struct _lv_obj_t * obj, uint32_t part)
@@ -316,12 +323,12 @@ static inline lv_opa_t lv_obj_get_style_shadow_opa(const struct _lv_obj_t * obj,
 static inline lv_coord_t lv_obj_get_style_line_width(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_coord_t lv_obj_get_style_line_dash_width(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_coord_t lv_obj_get_style_line_dash_gap(const struct _lv_obj_t * obj, uint32_t part)
-static inline lv_coord_t lv_obj_get_style_line_rounded(const struct _lv_obj_t * obj, uint32_t part)
+static inline bool lv_obj_get_style_line_rounded(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_color_t lv_obj_get_style_line_color(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_color_t lv_obj_get_style_line_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_opa_t lv_obj_get_style_line_opa(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_coord_t lv_obj_get_style_arc_width(const struct _lv_obj_t * obj, uint32_t part)
-static inline lv_coord_t lv_obj_get_style_arc_rounded(const struct _lv_obj_t * obj, uint32_t part)
+static inline bool lv_obj_get_style_arc_rounded(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_color_t lv_obj_get_style_arc_color(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_color_t lv_obj_get_style_arc_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
 static inline lv_opa_t lv_obj_get_style_arc_opa(const struct _lv_obj_t * obj, uint32_t part)
@@ -405,12 +412,12 @@ void lv_obj_set_style_shadow_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_styl
 void lv_obj_set_style_line_width(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
 void lv_obj_set_style_line_dash_width(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
 void lv_obj_set_style_line_dash_gap(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
-void lv_obj_set_style_line_rounded(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
+void lv_obj_set_style_line_rounded(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector)
 void lv_obj_set_style_line_color(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
 void lv_obj_set_style_line_color_filtered(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
 void lv_obj_set_style_line_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
 void lv_obj_set_style_arc_width(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
-void lv_obj_set_style_arc_rounded(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
+void lv_obj_set_style_arc_rounded(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector)
 void lv_obj_set_style_arc_color(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
 void lv_obj_set_style_arc_color_filtered(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector)
 void lv_obj_set_style_arc_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector)
@@ -419,17 +426,18 @@ void lv_obj_set_style_arc_img_src(struct _lv_obj_t * obj, const void * value, lv
 // ../../lvgl/src/core/lv_obj_tree.h
 void lv_obj_del(struct _lv_obj_t * obj)
 void lv_obj_clean(struct _lv_obj_t * obj)
+void lv_obj_del_delayed(struct _lv_obj_t * obj, uint32_t delay_ms)
 void lv_obj_del_anim_ready_cb(lv_anim_t * a)
 void lv_obj_del_async(struct _lv_obj_t * obj)
 void lv_obj_set_parent(struct _lv_obj_t * obj, struct _lv_obj_t * parent)
-void lv_obj_move_foreground(struct _lv_obj_t * obj)
-void lv_obj_move_background(struct _lv_obj_t * obj)
+void lv_obj_swap(struct _lv_obj_t * obj1, struct _lv_obj_t * obj2)
+void lv_obj_move_to_index(struct _lv_obj_t * obj, int32_t index)
 struct _lv_obj_t * lv_obj_get_screen(const struct _lv_obj_t * obj)
 lv_disp_t * lv_obj_get_disp(const struct _lv_obj_t * obj)
 struct _lv_obj_t * lv_obj_get_parent(const struct _lv_obj_t * obj)
 struct _lv_obj_t * lv_obj_get_child(const struct _lv_obj_t * obj, int32_t id)
 uint32_t lv_obj_get_child_cnt(const struct _lv_obj_t * obj)
-uint32_t lv_obj_get_child_id(const struct _lv_obj_t * obj)
+uint32_t lv_obj_get_index(const struct _lv_obj_t * obj)
 void lv_obj_tree_walk(struct _lv_obj_t * start_obj, lv_obj_tree_walk_cb_t cb, void * user_data)
 
 // ../../lvgl/src/core/lv_refr.h
@@ -471,11 +479,15 @@ void lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc)
 
 // ../../lvgl/src/draw/lv_draw_mask.h
 static inline uint8_t lv_draw_mask_get_cnt(void)
+static inline bool lv_draw_mask_is_any(const lv_area_t * a)
 int16_t lv_draw_mask_add(void * param, void * custom_id)
 lv_draw_mask_res_t lv_draw_mask_apply(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t len)
+lv_draw_mask_res_t lv_draw_mask_apply_ids(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t len, const int16_t *ids, int16_t ids_count)
 void * lv_draw_mask_remove_id(int16_t id)
 void * lv_draw_mask_remove_custom(void * custom_id)
+void lv_draw_mask_free_param(void * p)
 uint8_t lv_draw_mask_get_cnt(void)
+bool lv_draw_mask_is_any(const lv_area_t * a)
 void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t p1y, lv_coord_t p2x, lv_coord_t p2y, lv_draw_mask_line_side_t side)
 void lv_draw_mask_line_angle_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t py, int16_t angle, lv_draw_mask_line_side_t side)
 void lv_draw_mask_angle_init(lv_draw_mask_angle_param_t * param, lv_coord_t vertex_x, lv_coord_t vertex_y, lv_coord_t start_angle, lv_coord_t end_angle)
@@ -485,7 +497,7 @@ void lv_draw_mask_map_init(lv_draw_mask_map_param_t * param, const lv_area_t * c
 
 // ../../lvgl/src/draw/lv_draw_rect.h
 void lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc)
-void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, const lv_draw_rect_dsc_t * dsc)
+void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
 
 // ../../lvgl/src/draw/lv_draw_triangle.h
 void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip, const lv_draw_rect_dsc_t * draw_dsc)
@@ -499,6 +511,7 @@ void lv_draw_polygon(const lv_point_t points[], uint16_t point_cnt, const lv_are
 
 // ../../lvgl/src/extra/themes/default/lv_theme_default.h
 lv_theme_t * lv_theme_default_init(lv_disp_t * disp, lv_color_t color_primary, lv_color_t color_secondary, bool dark, const lv_font_t * font)
+lv_theme_t * lv_theme_default_get(void)
 bool lv_theme_default_is_inited(void)
 
 // ../../lvgl/src/extra/themes/mono/lv_theme_mono.h
@@ -556,6 +569,7 @@ bool lv_colorwheel_get_color_mode_fixed(lv_obj_t * obj)
 // ../../lvgl/src/extra/widgets/imgbtn/lv_imgbtn.h
 lv_obj_t * lv_imgbtn_create(lv_obj_t * parent)
 void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_imgbtn_state_t state, const void * src_left, const void * src_mid, const void * src_right)
+void lv_imgbtn_set_state(lv_obj_t * imgbtn, lv_imgbtn_state_t state)
 
 // ../../lvgl/src/extra/widgets/led/lv_led.h
 lv_obj_t * lv_led_create(lv_obj_t * parent)
@@ -582,12 +596,15 @@ void lv_meter_set_indicator_end_value(lv_obj_t * obj, lv_meter_indicator_t * ind
 
 // ../../lvgl/src/extra/widgets/msgbox/lv_msgbox.h
 lv_obj_t * lv_msgbox_create(lv_obj_t * parent, const char * title, const char * txt, const char * btn_txts[], bool add_close_btn)
-lv_obj_t * lv_msgbox_get_title(lv_obj_t * mbox)
-lv_obj_t * lv_msgbox_get_close_btn(lv_obj_t * mbox)
-lv_obj_t * lv_msgbox_get_text(lv_obj_t * mbox)
-lv_obj_t * lv_msgbox_get_btns(lv_obj_t * mbox)
+lv_obj_t * lv_msgbox_get_title(lv_obj_t * obj)
+lv_obj_t * lv_msgbox_get_close_btn(lv_obj_t * obj)
+lv_obj_t * lv_msgbox_get_text(lv_obj_t * obj)
+lv_obj_t * lv_msgbox_get_content(lv_obj_t * obj)
+lv_obj_t * lv_msgbox_get_btns(lv_obj_t * obj)
+uint16_t lv_msgbox_get_active_btn(lv_obj_t * mbox)
 const char * lv_msgbox_get_active_btn_text(lv_obj_t * mbox)
 void lv_msgbox_close(lv_obj_t * mbox)
+void lv_msgbox_close_async(lv_obj_t * mbox)
 
 // ../../lvgl/src/extra/widgets/spinbox/lv_spinbox.h
 lv_obj_t * lv_spinbox_create(lv_obj_t * parent)
@@ -596,7 +613,9 @@ void lv_spinbox_set_rollover(lv_obj_t * obj, bool b)
 void lv_spinbox_set_digit_format(lv_obj_t * obj, uint8_t digit_count, uint8_t separator_position)
 void lv_spinbox_set_step(lv_obj_t * obj, uint32_t step)
 void lv_spinbox_set_range(lv_obj_t * obj, int32_t range_min, int32_t range_max)
-bool lv_spinbox_get_rollover(lv_obj_t * obj)
+void lv_spinbox_set_pos(lv_obj_t * obj, uint8_t pos)
+void lv_spinbox_set_digit_step_direction(lv_obj_t * obj, lv_dir_t direction)
+bool lv_spinbox_get_rollover(lv_obj_t *obj)
 int32_t lv_spinbox_get_value(lv_obj_t * obj)
 int32_t lv_spinbox_get_step(lv_obj_t * obj)
 void lv_spinbox_step_next(lv_obj_t * obj)
@@ -687,12 +706,12 @@ void lv_style_set_shadow_opa(lv_style_t * style, lv_opa_t value)
 void lv_style_set_line_width(lv_style_t * style, lv_coord_t value)
 void lv_style_set_line_dash_width(lv_style_t * style, lv_coord_t value)
 void lv_style_set_line_dash_gap(lv_style_t * style, lv_coord_t value)
-void lv_style_set_line_rounded(lv_style_t * style, lv_coord_t value)
+void lv_style_set_line_rounded(lv_style_t * style, bool value)
 void lv_style_set_line_color(lv_style_t * style, lv_color_t value)
 void lv_style_set_line_color_filtered(lv_style_t * style, lv_color_t value)
 void lv_style_set_line_opa(lv_style_t * style, lv_opa_t value)
 void lv_style_set_arc_width(lv_style_t * style, lv_coord_t value)
-void lv_style_set_arc_rounded(lv_style_t * style, lv_coord_t value)
+void lv_style_set_arc_rounded(lv_style_t * style, bool value)
 void lv_style_set_arc_color(lv_style_t * style, lv_color_t value)
 void lv_style_set_arc_color_filtered(lv_style_t * style, lv_color_t value)
 void lv_style_set_arc_opa(lv_style_t * style, lv_opa_t value)
@@ -741,7 +760,7 @@ void lv_btnmatrix_set_map(lv_obj_t * obj, const char * map[])
 void lv_btnmatrix_set_ctrl_map(lv_obj_t * obj, const lv_btnmatrix_ctrl_t ctrl_map[])
 void lv_btnmatrix_set_selected_btn(lv_obj_t * obj, uint16_t btn_id)
 void lv_btnmatrix_set_btn_ctrl(lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl)
-void lv_btnmatrix_clear_btn_ctrl(const lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl)
+void lv_btnmatrix_clear_btn_ctrl(lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl)
 void lv_btnmatrix_set_btn_ctrl_all(lv_obj_t * obj, lv_btnmatrix_ctrl_t ctrl)
 void lv_btnmatrix_clear_btn_ctrl_all(lv_obj_t * obj, lv_btnmatrix_ctrl_t ctrl)
 void lv_btnmatrix_set_btn_width(lv_obj_t * obj, uint16_t btn_id, uint8_t width)
@@ -755,7 +774,9 @@ bool lv_btnmatrix_get_one_checked(const lv_obj_t * obj)
 // ../../lvgl/src/widgets/lv_canvas.h
 lv_obj_t * lv_canvas_create(lv_obj_t * parent)
 void lv_canvas_set_buffer(lv_obj_t * canvas, void * buf, lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
-void lv_canvas_set_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t c)
+void lv_canvas_set_px_color(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t c)
+static inline void lv_canvas_set_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t c)
+void lv_canvas_set_px_opa(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_opa_t opa)
 void lv_canvas_set_palette(lv_obj_t * canvas, uint8_t id, lv_color_t c)
 lv_color_t lv_canvas_get_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y)
 lv_img_dsc_t * lv_canvas_get_img(lv_obj_t * canvas)
@@ -809,6 +830,7 @@ void lv_img_set_angle(lv_obj_t * obj, int16_t angle)
 void lv_img_set_pivot(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 void lv_img_set_zoom(lv_obj_t * obj, uint16_t zoom)
 void lv_img_set_antialias(lv_obj_t * obj, bool antialias)
+void lv_img_set_size_mode(lv_obj_t * obj, lv_img_size_mode_t mode)
 const void * lv_img_get_src(lv_obj_t * obj)
 lv_coord_t lv_img_get_offset_x(lv_obj_t * obj)
 lv_coord_t lv_img_get_offset_y(lv_obj_t * obj)
@@ -816,6 +838,7 @@ uint16_t lv_img_get_angle(lv_obj_t * obj)
 void lv_img_get_pivot(lv_obj_t * obj, lv_point_t * pivot)
 uint16_t lv_img_get_zoom(lv_obj_t * obj)
 bool lv_img_get_antialias(lv_obj_t * obj)
+lv_img_size_mode_t lv_img_get_size_mode(lv_obj_t * obj)
 
 // ../../lvgl/src/widgets/lv_label.h
 lv_obj_t * lv_label_create(lv_obj_t * parent)
diff --git a/lib/libesp32_lvgl/lv_berry/tools/preprocessor.py b/lib/libesp32_lvgl/lv_berry/tools/preprocessor.py
index 5b30e8455..1c9209f8e 100644
--- a/lib/libesp32_lvgl/lv_berry/tools/preprocessor.py
+++ b/lib/libesp32_lvgl/lv_berry/tools/preprocessor.py
@@ -170,7 +170,14 @@ sys.stdout.close()
 # ################################################################################
 
 lv_src_prefix = "../../lvgl/src/"
-lv_fun_globs = [ "**/*.h" ]
+lv_fun_globs = [ 
+                  "core/*.h",
+                  "draw/*.h",
+                  "hal/*.h",
+                  "misc/*.h",
+                  "widgets/*.h",
+                  "extra/widgets/**/*.h",
+              ]
 headers_names = list_files(lv_src_prefix, lv_fun_globs)
 
 output_filename = "../mapping/lv_enum.h"
@@ -282,12 +289,11 @@ SYMBOL_BULLET="\\xE2\\x80\\xA2"
 // ======================================================================
 """)
 
-
-
 for header_name in headers_names:
   with open(header_name) as f:
     raw = clean_source(f.read())
 
+    print(f"// File: {header_name}")
     # extract enums
     enums = re.findall('enum\s+{(.*?)}', raw, flags=re.DOTALL)
     for enum in enums:  # iterate on all matches
diff --git a/lib/libesp32_lvgl/lvgl/LICENCE.txt b/lib/libesp32_lvgl/lvgl/LICENCE.txt
index a6f7f803e..f877abb18 100644
--- a/lib/libesp32_lvgl/lvgl/LICENCE.txt
+++ b/lib/libesp32_lvgl/lvgl/LICENCE.txt
@@ -1,5 +1,5 @@
 MIT licence
-Copyright (c) 2020 LVGL LLC
+Copyright (c) 2021 LVGL Kft
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
diff --git a/lib/libesp32_lvgl/lvgl/README.md b/lib/libesp32_lvgl/lvgl/README.md
index 340995a68..acc5c054a 100644
--- a/lib/libesp32_lvgl/lvgl/README.md
+++ b/lib/libesp32_lvgl/lvgl/README.md
@@ -1,46 +1,52 @@
-**The master branch now contains the test version of v8. For the last v7 version use the release/v7 branch.** 
-
-
 <h1 align="center"> LVGL - Light and Versatile Graphics Library</h1>
 
 <p align="center">
-<img src="https://lvgl.io/assets/images/img_1.png">
+<img src="https://lvgl.io/assets/images/lvgl_widgets_demo.gif">
 </p>
 
 <p align="center">
-LVGL provides everything you need to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint.
+LVGL provides everything you need to create an embedded GUI with easy-to-use graphical elements, beautiful visual effects and a low memory footprint.
 </p>
 
 <h4 align="center">
 <a href="https://lvgl.io">Website </a> &middot;
-<a href="https://lvgl.io/demos">Online demo</a> &middot;
-<a href="https://lvgl.github.io/lv_examples/">Nightly demos</a> &middot;
 <a href="https://docs.lvgl.io/">Docs</a> &middot;
-<a href="https://forum.lvgl.io">Forum</a>
+<a href="https://forum.lvgl.io">Forum</a>  &middot;
+<a href="https://lvgl.io/services">Services</a>  &middot;
+<a href="https://docs.lvgl.io/master/examples.html">Interactive examples</a>
 </h4>
 
 ---
 
-## Features
-* Powerful [building blocks](https://docs.lvgl.io/latest/en/html/widgets/index.html): buttons, charts, lists, sliders, images, etc.
-* Advanced graphics: animations, anti-aliasing, opacity, smooth scrolling
-* Use [various input devices](https://docs.lvgl.io/latest/en/html/overview/indev.html): touchscreen, mouse, keyboard, encoder, buttons, etc.
-* Use [multiple displays](https://docs.lvgl.io/latest/en/html/overview/display.html): e.g. monochrome and color display
-* Hardware independent to use with any microcontroller or display
-* Scalable to operate with little memory (64 kB Flash, 10 kB RAM)
-* Multi-language support with UTF-8 handling, Bidirectional and Arabic script support
-* Fully customizable graphical elements via [CSS-like styles](https://docs.lvgl.io/latest/en/html/overview/style.html)
-* OS, External memory and GPU are supported but not required
-* Smooth rendering even with a [single frame buffer](https://docs.lvgl.io/latest/en/html/porting/display.html)
-* Written in C for maximal compatibility (C++ compatible)
+#### Table of content
+- [Overview](#overview)
+- [Get started](#get-started)
+- [Examples](#examples)
+- [Services](#services)
+- [Contributing](#contributing)
+
+
+## Overview
+### Features
+* Powerful [building blocks](https://docs.lvgl.io/master/widgets/index.html): buttons, charts, lists, sliders, images, etc.
+* Advanced graphics engine: animations, anti-aliasing, opacity, smooth scrolling, blending modes, etc
+* Supports [various input devices](https://docs.lvgl.io/master/overview/indev.html): touchscreen, mouse, keyboard, encoder, buttons, etc.
+* Supports [multiple displays](https://docs.lvgl.io/master/overview/display.html)
+* Hardware independent, can be use with any microcontroller and display
+* Scalable to operate with little memory (64 kB Flash, 16 kB RAM)
+* Multi-language support with UTF-8 handling, CJK, Bidirectional and Arabic script support
+* Fully customizable graphical elements via [CSS-like styles](https://docs.lvgl.io/master/overview/style.html)
+* Powerful layouts inspired by CSS: [Flexbox](https://docs.lvgl.io/master/layouts/flex.html) and [Grid](https://docs.lvgl.io/master/layouts/grid.html)
+* OS, External memory and GPU are supported but not required. (built in support for STM32 DMA2D, and NXP PXP and VGLite)
+* Smooth rendering even with a [single frame buffer](https://docs.lvgl.io/master/porting/display.html)
+* Written in C and compatibile with C++
 * Micropython Binding exposes [LVGL API in Micropython](https://blog.lvgl.io/2019-02-20/micropython-bindings)
-* [Simulator](https://docs.lvgl.io/latest/en/html/get-started/pc-simulator.html) to develop on PC without embedded hardware
-* [Examples](lv_examples) and tutorials for rapid development
-* [Documentation](http://docs.lvgl.io/) and API references
+* [Simulator](https://docs.lvgl.io/master/get-started/pc-simulator.html) to develop on PC without embedded hardware
+* 100+ simple [Examples](https://github.com/lvgl/lvgl/tree/master/examples)
+* [Documentation](http://docs.lvgl.io/) and API references online and in PDF
 
-## Requirements
+### Requirements
 Basically, every modern controller (which is able to drive a display) is suitable to run LVGL. The minimal requirements are:
-
 <table>
   <tr>
     <td> <strong>Name</strong> </td>
@@ -65,26 +71,14 @@ Basically, every modern controller (which is able to drive a display) is suitabl
 
   <tr>
     <td> <strong>Static RAM</strong></td>
-    <td> &gt; 2 kB </td>
-    <td> &gt; 4 kB</td>
+    <td> &gt; 16 kB </td>
+    <td> &gt; 48 kB</td>
   </tr>
 
   <tr>
-    <td> <strong>Stack</strong></td>
-    <td> &gt; 2 kB </td>
-    <td> &gt; 8 kB</td>
-  </tr>
-
-  <tr>
-    <td> <strong>Heap</strong></td>
-    <td> &gt; 2 kB </td>
-    <td> &gt; 8 kB</td>
-  </tr>
-
-  <tr>
-    <td> <strong>Display buffer</strong></td>
+    <td> <strong>Draw buffer</strong></td>
     <td> &gt; 1 &times; <em>hor. res.</em> pixels </td>
-    <td> &gt; 10 &times; <em>hor. res.</em> pixels </td>
+    <td> &gt; 1/10 screen size </td>
   </tr>
 
   <tr>
@@ -95,10 +89,12 @@ Basically, every modern controller (which is able to drive a display) is suitabl
 
 *Note that the memory usage might vary depending on the architecture, compiler and build options.*
 
+### Supported platforms
+LVGL is completely platform independent and can be used with any MCU that fulfills the requirements. 
 Just to mention some platforms:
+- NXP: Kinetis, LPC, iMX, iMX RT
 - STM32F1, STM32F3, STM32F4, STM32F7, STM32L4, STM32L5, STM32H7
 - Microchip dsPIC33, PIC24, PIC32MX, PIC32MZ
-- NXP: Kinetis, LPC, iMX, iMX RT
 - [Linux frame buffer](https://blog.lvgl.io/2018-01-03/linux_fb) (/dev/fb)
 - [Raspberry Pi](http://www.vk3erw.com/index.php/16-software/63-raspberry-pi-official-7-touchscreen-and-littlevgl)
 - [Espressif ESP32](https://github.com/lvgl/lv_port_esp32)
@@ -106,60 +102,80 @@ Just to mention some platforms:
 - Nordic NRF52 Bluetooth modules
 - Quectel modems
 
+LVGL is also avaiable as:
+- [Arduino library](https://docs.lvgl.io/master/get-started/arduino.html)
+- [PlatformIO package](https://platformio.org/lib/show/12440/lvgl)
+- [Zephyr library](https://docs.zephyrproject.org/latest/reference/kconfig/CONFIG_LVGL.html)
+- [ESP32 component](https://docs.lvgl.io/master/get-started/espressif.html)
+- [NXP MCUXpresso component](https://www.nxp.com/design/software/embedded-software/lvgl-open-source-graphics-library:LITTLEVGL-OPEN-SOURCE-GRAPHICS-LIBRARY)
+- [NuttX library](https://docs.lvgl.io/master/get-started/nuttx.html)
+
+
 ## Get started
 This list shows the recommended way of learning the library:
 1. Check the [Online demos](https://lvgl.io/demos) to see LVGL in action (3 minutes)
-2. Read the [Introduction](https://docs.lvgl.io/latest/en/html/intro/index.html) page of the documentation (5 minutes)
-3. Get familiar with the basics on the [Quick overview](https://docs.lvgl.io/latest/en/html/get-started/quick-overview.html) page (15 minutes)
-4. Set up a [Simulator](https://docs.lvgl.io/latest/en/html/get-started/pc-simulator.html) (10 minutes)
-5. Try out some [Examples](https://github.com/lvgl/lv_examples/)
-6. Port LVGL to a board. See the [Porting](https://docs.lvgl.io/latest/en/html/porting/index.html) guide or check the ready to use [Projects](https://github.com/lvgl?q=lv_port_&type=&language=)
-7. Read the [Overview](https://docs.lvgl.io/latest/en/html/overview/index.html) page to get a better understanding of the library (2-3 hours)
-8. Check the documentation of the [Widgets](https://docs.lvgl.io/latest/en/html/widgets/index.html) to see their features and usage
+2. Read the [Introduction](https://docs.lvgl.io/master/intro/index.html) page of the documentation (5 minutes)
+3. Get familiar with the basics on the [Quick overview](https://docs.lvgl.io/master/get-started/quick-overview.html) page (15 minutes)
+4. Set up a [Simulator](https://docs.lvgl.io/master/get-started/pc-simulator.html) (10 minutes)
+5. Try out some [Examples](https://github.com/lvgl/lvgl/tree/master/examples)
+6. Port LVGL to a board. See the [Porting](https://docs.lvgl.io/master/porting/index.html) guide or check the ready to use [Projects](https://github.com/lvgl?q=lv_port_)
+7. Read the [Overview](https://docs.lvgl.io/master/overview/index.html) page to get a better understanding of the library (2-3 hours)
+8. Check the documentation of the [Widgets](https://docs.lvgl.io/master/widgets/index.html) to see their features and usage
 9. If you have questions go to the [Forum](http://forum.lvgl.io/)
-10. Read the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) guide to see how you can help to improve LVGL (15 minutes)
+10. Read the [Contributing](https://docs.lvgl.io/master/CONTRIBUTING.html) guide to see how you can help to improve LVGL (15 minutes)
 
 ## Examples
 
-For more examples see the [lv_examples](https://github.com/lvgl/lv_examples) repository.
+For more examples see the [examples](https://github.com/lvgl/lvgl/tree/master/examples) folder.
 
-### Button with label
+![LVGL button with label example](https://github.com/lvgl/lvgl/raw/master/docs/misc/btn_example.png)
+
+### C
 ```c
-lv_obj_t * btn = lv_btn_create(lv_scr_act(), NULL);     /*Add a button to the current screen*/
-lv_obj_set_pos(btn, 10, 10);                            /*Set its position*/
-lv_obj_set_size(btn, 100, 50);                          /*Set its size*/
-lv_obj_set_event_cb(btn, btn_event_cb);                 /*Assign a callback to the button*/
-
-lv_obj_t * label = lv_label_create(btn, NULL);          /*Add a label to the button*/
-lv_label_set_text(label, "Button");                     /*Set the labels text*/
+lv_obj_t * btn = lv_btn_create(lv_scr_act());                   /*Add a button to the current screen*/
+lv_obj_set_pos(btn, 10, 10);                                    /*Set its position*/
+lv_obj_set_size(btn, 100, 50);                                  /*Set its size*/
+lv_obj_add_event_cb(btn, btn_event_cb, LV_EVENT_CLICKED, NULL); /*Assign a callback to the button*/
 
+lv_obj_t * label = lv_label_create(btn);                        /*Add a label to the button*/
+lv_label_set_text(label, "Button");                             /*Set the labels text*/
+lv_obj_center(label);                                           /*Align the label to the center*/
 ...
 
-void btn_event_cb(lv_obj_t * btn, lv_event_t event)
+void btn_event_cb(lv_event_t * e)
 {
-    if(event == LV_EVENT_CLICKED) {
-        printf("Clicked\n");
-    }
+  printf("Clicked\n");
 }
 ```
-![LVGL button with label example](https://raw.githubusercontent.com/lvgl/docs/latest/misc/simple_button_example.gif)
-
-### LVGL from Micropython
-Learn more about [Micropython](https://docs.lvgl.io/latest/en/html/get-started/micropython.html).
+### Micropython
+Learn more about [Micropython](https://docs.lvgl.io/master/get-started/micropython.html).
 ```python
+def btn_event_cb(e):
+  print("Clicked")
+
 # Create a Button and a Label
-scr = lv.obj()
-btn = lv.btn(scr)
-btn.align(lv.scr_act(), lv.ALIGN.CENTER, 0, 0)
+btn = lv.btn(lv.scr_act())
+btn.set_pos(10, 10)
+btn.set_size(100, 50)
+btn.add_event_cb(btn_event_cb, lv.EVENT.CLICKED, None)
+
 label = lv.label(btn)
 label.set_text("Button")
-
-# Load the screen
-lv.scr_load(scr)
+label.center()
 ```
 
-## Contributing
-LVGL is an open project and contribution is very welcome. There are many ways to contribute from simply speaking about your project, through writing examples, improving the documentation, fixing bugs to hosing your own project under in LVGL.
+## Services
+LVGL Kft was established to provide a solid background for LVGL library. We offer several type of services to help you in UI development:
+- Graphics design
+- UI implementation
+- Consulting/Support
 
-For a detailed description of contribution opportunities visit the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) section of the documentation.
+For more information see https://lvgl.io/services
+Feel free to contact us if you have any questions.
+
+
+## Contributing
+LVGL is an open project and contribution is very welcome. There are many ways to contribute from simply speaking about your project, through writing examples, improving the documentation, fixing bugs to hosting your own project under the LVGL organization.
+
+For a detailed description of contribution opportunities visit the [Contributing](https://docs.lvgl.io/master/CONTRIBUTING.html) section of the documentation.
  
diff --git a/lib/libesp32_lvgl/lvgl/library.json b/lib/libesp32_lvgl/lvgl/library.json
index 441a52235..f42b43d6a 100644
--- a/lib/libesp32_lvgl/lvgl/library.json
+++ b/lib/libesp32_lvgl/lvgl/library.json
@@ -1,6 +1,6 @@
 {
-	"name": "lvgl8",
-	"version": "8.0.2",
+	"name": "lvgl",
+	"version": "8.1.0",
 	"keywords": "graphics, gui, embedded, tft, lvgl",
 	"description": "Graphics library to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint. It offers anti-aliasing, opacity, and animations using only one frame buffer.",
 	"repository": {
diff --git a/lib/libesp32_lvgl/lvgl/library.properties b/lib/libesp32_lvgl/lvgl/library.properties
index 45962cb2f..cefc1def8 100644
--- a/lib/libesp32_lvgl/lvgl/library.properties
+++ b/lib/libesp32_lvgl/lvgl/library.properties
@@ -1,5 +1,5 @@
 name=lvgl
-version=8.0.2
+version=8.1.0
 author=kisvegabor
 maintainer=kisvegabor,embeddedt,pete-pjb
 sentence=Full-featured Graphics Library for Embedded Systems
diff --git a/lib/libesp32_lvgl/lvgl/lv_conf_template.h b/lib/libesp32_lvgl/lvgl/lv_conf_template.h
index f7b96f182..8bdddb497 100644
--- a/lib/libesp32_lvgl/lvgl/lv_conf_template.h
+++ b/lib/libesp32_lvgl/lvgl/lv_conf_template.h
@@ -1,82 +1,99 @@
 /**
  * @file lv_conf.h
- * Configuration file for v8.0.2
+ * Configuration file for v8.1.0
  */
 
 /*
- * COPY THIS FILE AS `lv_conf.h` NEXT TO the `lvgl` FOLDER
+ * Copy this file as `lv_conf.h`
+ * 1. simply next to the `lvgl` folder
+ * 2. or any other places and
+ *    - define `LV_CONF_INCLUDE_SIMPLE`
+ *    - add the path as include path
  */
 
+/* clang-format off */
 #if 0 /*Set it to "1" to enable content*/
 
 #ifndef LV_CONF_H
 #define LV_CONF_H
-/*clang-format off*/
 
 #include <stdint.h>
 
-
 /*====================
    COLOR SETTINGS
  *====================*/
 
 /*Color depth: 1 (1 byte per pixel), 8 (RGB332), 16 (RGB565), 32 (ARGB8888)*/
-#define LV_COLOR_DEPTH     32
+#define LV_COLOR_DEPTH 16
 
-/*Swap the 2 bytes of RGB565 color. Useful if the display has a 8 bit interface (e.g. SPI)*/
-#define LV_COLOR_16_SWAP   0
+/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/
+#define LV_COLOR_16_SWAP 0
 
 /*Enable more complex drawing routines to manage screens transparency.
  *Can be used if the UI is above another layer, e.g. an OSD menu or video player.
  *Requires `LV_COLOR_DEPTH = 32` colors and the screen's `bg_opa` should be set to non LV_OPA_COVER value*/
-#define LV_COLOR_SCREEN_TRANSP    0
+#define LV_COLOR_SCREEN_TRANSP 0
 
-/*Images pixels with this color will not be drawn if they are  chroma keyed)*/
-#define LV_COLOR_CHROMA_KEY    lv_color_hex(0x00ff00)         /*pure green*/
+/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently.
+ * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */
+#define LV_COLOR_MIX_ROUND_OFS (LV_COLOR_DEPTH == 32 ? 0: 128)
+
+/*Images pixels with this color will not be drawn if they are chroma keyed)*/
+#define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00)         /*pure green*/
 
 /*=========================
    MEMORY SETTINGS
  *=========================*/
 
 /*1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()`*/
-#define LV_MEM_CUSTOM      0
+#define LV_MEM_CUSTOM 0
 #if LV_MEM_CUSTOM == 0
 /*Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/
-#  define LV_MEM_SIZE    (32U * 1024U)          /*[bytes]*/
+#  define LV_MEM_SIZE (32U * 1024U)          /*[bytes]*/
 
 /*Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too.*/
-#  define LV_MEM_ADR          0     /*0: unused*/
+#  define LV_MEM_ADR 0     /*0: unused*/
+/*Instead of an address give a memory allocator that will be called to get a memory pool for LVGL. E.g. my_malloc*/
+#if LV_MEM_ADR == 0
+//#define LV_MEM_POOL_INCLUDE your_alloc_library  /* Uncomment if using an external allocator*/
+//#define LV_MEM_POOL_ALLOC   your_alloc          /* Uncomment if using an external allocator*/
+#endif
+
 #else       /*LV_MEM_CUSTOM*/
 #  define LV_MEM_CUSTOM_INCLUDE <stdlib.h>   /*Header for the dynamic memory function*/
-#  define LV_MEM_CUSTOM_ALLOC     malloc
-#  define LV_MEM_CUSTOM_FREE      free
-#  define LV_MEM_CUSTOM_REALLOC   realloc
+#  define LV_MEM_CUSTOM_ALLOC   malloc
+#  define LV_MEM_CUSTOM_FREE    free
+#  define LV_MEM_CUSTOM_REALLOC realloc
 #endif     /*LV_MEM_CUSTOM*/
 
+/*Number of the intermediate memory buffer used during rendering and other internal processing mechanisms.
+ *You will see an error log message if there wasn't enough buffers. */
+#define LV_MEM_BUF_MAX_NUM 16
+
 /*Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster).*/
-#define LV_MEMCPY_MEMSET_STD    0
+#define LV_MEMCPY_MEMSET_STD 0
 
 /*====================
    HAL SETTINGS
  *====================*/
 
-/*Default display refresh period. LVG will redraw changed ares with this period time*/
-#define LV_DISP_DEF_REFR_PERIOD     30      /*[ms]*/
+/*Default display refresh period. LVG will redraw changed areas with this period time*/
+#define LV_DISP_DEF_REFR_PERIOD 30      /*[ms]*/
 
 /*Input device read period in milliseconds*/
-#define LV_INDEV_DEF_READ_PERIOD    30      /*[ms]*/
+#define LV_INDEV_DEF_READ_PERIOD 30     /*[ms]*/
 
 /*Use a custom tick source that tells the elapsed time in milliseconds.
  *It removes the need to manually update the tick with `lv_tick_inc()`)*/
-#define LV_TICK_CUSTOM     0
+#define LV_TICK_CUSTOM 0
 #if LV_TICK_CUSTOM
-#define LV_TICK_CUSTOM_INCLUDE  "Arduino.h"         /*Header for the system time function*/
-#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current system time in ms*/
+#define LV_TICK_CUSTOM_INCLUDE "Arduino.h"         /*Header for the system time function*/
+#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())    /*Expression evaluating to current system time in ms*/
 #endif   /*LV_TICK_CUSTOM*/
 
 /*Default Dot Per Inch. Used to initialize default sizes such as widgets sized, style paddings.
  *(Not so important, you can adjust it to modify default sizes and spaces)*/
-#define LV_DPI_DEF                  130     /*[px/inch]*/
+#define LV_DPI_DEF 130     /*[px/inch]*/
 
 /*=======================
  * FEATURE CONFIGURATION
@@ -94,7 +111,14 @@
 /*Allow buffering some shadow calculation.
  *LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius`
  *Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/
-#define LV_SHADOW_CACHE_SIZE    0
+#define LV_SHADOW_CACHE_SIZE 0
+
+/* Set number of maximally cached circle data.
+ * The circumference of 1/4 circle are saved for anti-aliasing
+ * radius * 4 bytes are used per circle (the most often used radiuses are saved)
+ * 0: to disable caching */
+#define LV_CIRCLE_CACHE_SIZE 4
+
 #endif /*LV_DRAW_COMPLEX*/
 
 /*Default image cache size. Image caching keeps the images opened.
@@ -102,16 +126,17 @@
  *With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images.
  *However the opened images might consume additional RAM.
  *0: to disable caching*/
-#define LV_IMG_CACHE_DEF_SIZE       0
+#define LV_IMG_CACHE_DEF_SIZE 0
 
 /*Maximum buffer size to allocate for rotation. Only used if software rotation is enabled in the display driver.*/
-#define LV_DISP_ROT_MAX_BUF         (10*1024)
+#define LV_DISP_ROT_MAX_BUF (10*1024)
+
 /*-------------
  * GPU
  *-----------*/
 
 /*Use STM32's DMA2D (aka Chrom Art) GPU*/
-#define LV_USE_GPU_STM32_DMA2D  0
+#define LV_USE_GPU_STM32_DMA2D 0
 #if LV_USE_GPU_STM32_DMA2D
 /*Must be defined to include path of CMSIS header of target processor
 e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
@@ -119,7 +144,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #endif
 
 /*Use NXP's PXP GPU iMX RTxxx platforms*/
-#define LV_USE_GPU_NXP_PXP      0
+#define LV_USE_GPU_NXP_PXP 0
 #if LV_USE_GPU_NXP_PXP
 /*1: Add default bare metal and FreeRTOS interrupt handling routines for PXP (lv_gpu_nxp_pxp_osa.c)
  *   and call lv_gpu_nxp_pxp_init() automatically during lv_init(). Note that symbol SDK_OS_FREE_RTOS
@@ -130,14 +155,23 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #endif
 
 /*Use NXP's VG-Lite GPU iMX RTxxx platforms*/
-#define LV_USE_GPU_NXP_VG_LITE   0
+#define LV_USE_GPU_NXP_VG_LITE 0
+
+/*Use exnternal renderer*/
+#define LV_USE_EXTERNAL_RENDERER 0
+
+/*Use SDL renderer API. Requires LV_USE_EXTERNAL_RENDERER*/
+#define LV_USE_GPU_SDL 0
+#if LV_USE_GPU_SDL
+#  define LV_GPU_SDL_INCLUDE_PATH <SDL2/SDL.h>
+#endif
 
 /*-------------
  * Logging
  *-----------*/
 
 /*Enable the log module*/
-#define LV_USE_LOG      0   // change to 0 in normal conditions
+#define LV_USE_LOG 0
 #if LV_USE_LOG
 
 /*How important log should be added:
@@ -147,21 +181,21 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
  *LV_LOG_LEVEL_ERROR       Only critical issue, when the system may fail
  *LV_LOG_LEVEL_USER        Only logs added by the user
  *LV_LOG_LEVEL_NONE        Do not log anything*/
-#  define LV_LOG_LEVEL    LV_LOG_LEVEL_WARN
+#  define LV_LOG_LEVEL LV_LOG_LEVEL_WARN
 
 /*1: Print the log with 'printf';
  *0: User need to register a callback with `lv_log_register_print_cb()`*/
-#  define LV_LOG_PRINTF   0
+#  define LV_LOG_PRINTF 0
 
 /*Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs*/
-#  define LV_LOG_TRACE_MEM            1
-#  define LV_LOG_TRACE_TIMER          1
-#  define LV_LOG_TRACE_INDEV          1
-#  define LV_LOG_TRACE_DISP_REFR      1
-#  define LV_LOG_TRACE_EVENT          1
-#  define LV_LOG_TRACE_OBJ_CREATE     1
-#  define LV_LOG_TRACE_LAYOUT         1
-#  define LV_LOG_TRACE_ANIM           1
+#  define LV_LOG_TRACE_MEM        1
+#  define LV_LOG_TRACE_TIMER      1
+#  define LV_LOG_TRACE_INDEV      1
+#  define LV_LOG_TRACE_DISP_REFR  1
+#  define LV_LOG_TRACE_EVENT      1
+#  define LV_LOG_TRACE_OBJ_CREATE 1
+#  define LV_LOG_TRACE_LAYOUT     1
+#  define LV_LOG_TRACE_ANIM       1
 
 #endif  /*LV_USE_LOG*/
 
@@ -178,37 +212,43 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #define LV_USE_ASSERT_OBJ           0   /*Check the object's type and existence (e.g. not deleted). (Slow)*/
 
 /*Add a custom handler when assert happens e.g. to restart the MCU*/
-#define LV_ASSERT_HANDLER_INCLUDE   <stdint.h>
-#define LV_ASSERT_HANDLER   while(1);   /*Halt by default*/
+#define LV_ASSERT_HANDLER_INCLUDE <stdint.h>
+#define LV_ASSERT_HANDLER while(1);   /*Halt by default*/
 
 /*-------------
  * Others
  *-----------*/
 
 /*1: Show CPU usage and FPS count in the right bottom corner*/
-#define LV_USE_PERF_MONITOR     0
+#define LV_USE_PERF_MONITOR 0
+#if LV_USE_PERF_MONITOR
+#define LV_USE_PERF_MONITOR_POS LV_ALIGN_BOTTOM_RIGHT
+#endif
 
-/*1: Show the used memory and the memory fragmentation  in the left bottom corner
+/*1: Show the used memory and the memory fragmentation in the left bottom corner
  * Requires LV_MEM_CUSTOM = 0*/
-#define LV_USE_MEM_MONITOR      0
+#define LV_USE_MEM_MONITOR 0
+#if LV_USE_PERF_MONITOR
+#define LV_USE_MEM_MONITOR_POS LV_ALIGN_BOTTOM_LEFT
+#endif
 
 /*1: Draw random colored rectangles over the redrawn areas*/
-#define LV_USE_REFR_DEBUG       0
+#define LV_USE_REFR_DEBUG 0
 
 /*Change the built in (v)snprintf functions*/
-#define LV_SPRINTF_CUSTOM   0
+#define LV_SPRINTF_CUSTOM 0
 #if LV_SPRINTF_CUSTOM
 #  define LV_SPRINTF_INCLUDE <stdio.h>
-#  define lv_snprintf     snprintf
-#  define lv_vsnprintf    vsnprintf
+#  define lv_snprintf  snprintf
+#  define lv_vsnprintf vsnprintf
 #else   /*LV_SPRINTF_CUSTOM*/
 #  define LV_SPRINTF_USE_FLOAT 0
 #endif  /*LV_SPRINTF_CUSTOM*/
 
-#define LV_USE_USER_DATA      1
+#define LV_USE_USER_DATA 1
 
 /*Garbage Collector settings
- *Used if lvgl is binded to higher level language and the memory is managed by that language*/
+ *Used if lvgl is bound to higher level language and the memory is managed by that language*/
 #define LV_ENABLE_GC 0
 #if LV_ENABLE_GC != 0
 #  define LV_GC_INCLUDE "gc.h"                           /*Include Garbage Collector related things*/
@@ -219,7 +259,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
  *====================*/
 
 /*For big endian systems set to 1*/
-#define LV_BIG_ENDIAN_SYSTEM    0
+#define LV_BIG_ENDIAN_SYSTEM 0
 
 /*Define a custom attribute to `lv_tick_inc` function*/
 #define LV_ATTRIBUTE_TICK_INC
@@ -231,7 +271,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #define LV_ATTRIBUTE_FLUSH_READY
 
 /*Required alignment size for buffers*/
-#define LV_ATTRIBUTE_MEM_ALIGN_SIZE
+#define LV_ATTRIBUTE_MEM_ALIGN_SIZE 1
 
 /*Will be added where memories needs to be aligned (with -Os data might not be aligned to boundary by default).
  * E.g. __attribute__((aligned(4)))*/
@@ -254,7 +294,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning /*The default value just prevents GCC warning*/
 
 /*Extend the default -32k..32k coordinate range to -4M..4M by using int32_t for coordinates instead of int16_t*/
-#define LV_USE_LARGE_COORD  0
+#define LV_USE_LARGE_COORD 0
 
 /*==================
  *   FONT USAGE
@@ -262,27 +302,27 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 
 /*Montserrat fonts with ASCII range and some symbols using bpp = 4
  *https://fonts.google.com/specimen/Montserrat*/
-#define LV_FONT_MONTSERRAT_8     0
-#define LV_FONT_MONTSERRAT_10    0
-#define LV_FONT_MONTSERRAT_12    0
-#define LV_FONT_MONTSERRAT_14    1
-#define LV_FONT_MONTSERRAT_16    0
-#define LV_FONT_MONTSERRAT_18    0
-#define LV_FONT_MONTSERRAT_20    0
-#define LV_FONT_MONTSERRAT_22    0
-#define LV_FONT_MONTSERRAT_24    0
-#define LV_FONT_MONTSERRAT_26    0
-#define LV_FONT_MONTSERRAT_28    0
-#define LV_FONT_MONTSERRAT_30    0
-#define LV_FONT_MONTSERRAT_32    0
-#define LV_FONT_MONTSERRAT_34    0
-#define LV_FONT_MONTSERRAT_36    0
-#define LV_FONT_MONTSERRAT_38    0
-#define LV_FONT_MONTSERRAT_40    0
-#define LV_FONT_MONTSERRAT_42    0
-#define LV_FONT_MONTSERRAT_44    0
-#define LV_FONT_MONTSERRAT_46    0
-#define LV_FONT_MONTSERRAT_48    0
+#define LV_FONT_MONTSERRAT_8  0
+#define LV_FONT_MONTSERRAT_10 0
+#define LV_FONT_MONTSERRAT_12 0
+#define LV_FONT_MONTSERRAT_14 1
+#define LV_FONT_MONTSERRAT_16 0
+#define LV_FONT_MONTSERRAT_18 0
+#define LV_FONT_MONTSERRAT_20 0
+#define LV_FONT_MONTSERRAT_22 0
+#define LV_FONT_MONTSERRAT_24 0
+#define LV_FONT_MONTSERRAT_26 0
+#define LV_FONT_MONTSERRAT_28 0
+#define LV_FONT_MONTSERRAT_30 0
+#define LV_FONT_MONTSERRAT_32 0
+#define LV_FONT_MONTSERRAT_34 0
+#define LV_FONT_MONTSERRAT_36 0
+#define LV_FONT_MONTSERRAT_38 0
+#define LV_FONT_MONTSERRAT_40 0
+#define LV_FONT_MONTSERRAT_42 0
+#define LV_FONT_MONTSERRAT_44 0
+#define LV_FONT_MONTSERRAT_46 0
+#define LV_FONT_MONTSERRAT_48 0
 
 /*Demonstrate special features*/
 #define LV_FONT_MONTSERRAT_12_SUBPX      0
@@ -291,8 +331,8 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #define LV_FONT_SIMSUN_16_CJK            0  /*1000 most common CJK radicals*/
 
 /*Pixel perfect monospace fonts*/
-#define LV_FONT_UNSCII_8        0
-#define LV_FONT_UNSCII_16       0
+#define LV_FONT_UNSCII_8  0
+#define LV_FONT_UNSCII_16 0
 
 /*Optionally declare custom fonts here.
  *You can use these fonts as default font too and they will be available globally.
@@ -305,16 +345,16 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 /*Enable handling large font and/or fonts with a lot of characters.
  *The limit depends on the font size, font face and bpp.
  *Compiler error will be triggered if a font needs it.*/
-#define LV_FONT_FMT_TXT_LARGE   0
+#define LV_FONT_FMT_TXT_LARGE 0
 
 /*Enables/disables support for compressed fonts.*/
-#define LV_USE_FONT_COMPRESSED  0
+#define LV_USE_FONT_COMPRESSED 0
 
 /*Enable subpixel rendering*/
-#define LV_USE_FONT_SUBPX       0
+#define LV_USE_FONT_SUBPX 0
 #if LV_USE_FONT_SUBPX
 /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/
-#define LV_FONT_SUBPX_BGR       0  /*0: RGB; 1:BGR order*/
+#define LV_FONT_SUBPX_BGR 0  /*0: RGB; 1:BGR order*/
 #endif
 
 /*=================
@@ -330,15 +370,15 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #define LV_TXT_ENC LV_TXT_ENC_UTF8
 
  /*Can break (wrap) texts on these chars*/
-#define LV_TXT_BREAK_CHARS                  " ,.;:-_"
+#define LV_TXT_BREAK_CHARS " ,.;:-_"
 
 /*If a word is at least this long, will break wherever "prettiest"
  *To disable, set to a value <= 0*/
-#define LV_TXT_LINE_BREAK_LONG_LEN          0
+#define LV_TXT_LINE_BREAK_LONG_LEN 0
 
 /*Minimum number of characters in a long word to put on a line before a break.
  *Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/
-#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN  3
+#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3
 
 /*Minimum number of characters in a long word to put on a line after a break.
  *Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/
@@ -348,15 +388,15 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #define LV_TXT_COLOR_CMD "#"
 
 /*Support bidirectional texts. Allows mixing Left-to-Right and Right-to-Left texts.
- *The direction will be processed according to the Unicode Bidirectioanl Algorithm:
+ *The direction will be processed according to the Unicode Bidirectional Algorithm:
  *https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/
-#define LV_USE_BIDI         0
+#define LV_USE_BIDI 0
 #if LV_USE_BIDI
 /*Set the default direction. Supported values:
  *`LV_BASE_DIR_LTR` Left-to-Right
  *`LV_BASE_DIR_RTL` Right-to-Left
  *`LV_BASE_DIR_AUTO` detect texts base direction*/
-#define LV_BIDI_BASE_DIR_DEF  LV_BASE_DIR_AUTO
+#define LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO
 #endif
 
 /*Enable Arabic/Persian processing
@@ -369,48 +409,47 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 
 /*Documentation of the widgets: https://docs.lvgl.io/latest/en/html/widgets/index.html*/
 
-#define LV_USE_ARC          1
+#define LV_USE_ARC        1
 
-#define LV_USE_ANIMIMG	    1
+#define LV_USE_ANIMIMG    1
 
-#define LV_USE_BAR          1
+#define LV_USE_BAR        1
 
-#define LV_USE_BTN          1
+#define LV_USE_BTN        1
 
-#define LV_USE_BTNMATRIX    1
+#define LV_USE_BTNMATRIX  1
 
-#define LV_USE_CANVAS       1
+#define LV_USE_CANVAS     1
 
-#define LV_USE_CHECKBOX     1
+#define LV_USE_CHECKBOX   1
 
+#define LV_USE_DROPDOWN   1   /*Requires: lv_label*/
 
-#define LV_USE_DROPDOWN     1   /*Requires: lv_label*/
+#define LV_USE_IMG        1   /*Requires: lv_label*/
 
-#define LV_USE_IMG          1   /*Requires: lv_label*/
-
-#define LV_USE_LABEL        1
+#define LV_USE_LABEL      1
 #if LV_USE_LABEL
-#  define LV_LABEL_TEXT_SELECTION         1   /*Enable selecting text of the label*/
-#  define LV_LABEL_LONG_TXT_HINT    1   /*Store some extra info in labels to speed up drawing of very long texts*/
+#  define LV_LABEL_TEXT_SELECTION 1 /*Enable selecting text of the label*/
+#  define LV_LABEL_LONG_TXT_HINT 1  /*Store some extra info in labels to speed up drawing of very long texts*/
 #endif
 
-#define LV_USE_LINE         1
+#define LV_USE_LINE       1
 
-#define LV_USE_ROLLER       1   /*Requires: lv_label*/
+#define LV_USE_ROLLER     1   /*Requires: lv_label*/
 #if LV_USE_ROLLER
-#  define LV_ROLLER_INF_PAGES       7   /*Number of extra "pages" when the roller is infinite*/
+#  define LV_ROLLER_INF_PAGES 7 /*Number of extra "pages" when the roller is infinite*/
 #endif
 
-#define LV_USE_SLIDER       1   /*Requires: lv_bar*/
+#define LV_USE_SLIDER     1   /*Requires: lv_bar*/
 
-#define LV_USE_SWITCH    1
+#define LV_USE_SWITCH     1
 
-#define LV_USE_TEXTAREA   1     /*Requires: lv_label*/
+#define LV_USE_TEXTAREA   1   /*Requires: lv_label*/
 #if LV_USE_TEXTAREA != 0
-#  define LV_TEXTAREA_DEF_PWD_SHOW_TIME     1500    /*ms*/
+#  define LV_TEXTAREA_DEF_PWD_SHOW_TIME 1500    /*ms*/
 #endif
 
-#define LV_USE_TABLE  1
+#define LV_USE_TABLE      1
 
 /*==================
  * EXTRA COMPONENTS
@@ -419,7 +458,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 /*-----------
  * Widgets
  *----------*/
-#define LV_USE_CALENDAR     1
+#define LV_USE_CALENDAR   1
 #if LV_USE_CALENDAR
 # define LV_CALENDAR_WEEK_STARTS_MONDAY 0
 # if LV_CALENDAR_WEEK_STARTS_MONDAY
@@ -429,81 +468,133 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 # endif
 
 # define LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March",  "April", "May",  "June", "July", "August", "September", "October", "November", "December"}
-# define LV_USE_CALENDAR_HEADER_ARROW       1
-# define LV_USE_CALENDAR_HEADER_DROPDOWN    1
+# define LV_USE_CALENDAR_HEADER_ARROW 1
+# define LV_USE_CALENDAR_HEADER_DROPDOWN 1
 #endif  /*LV_USE_CALENDAR*/
 
-#define LV_USE_CHART        1
+#define LV_USE_CHART      1
 
-#define LV_USE_COLORWHEEL   1
+#define LV_USE_COLORWHEEL 1
 
-#define LV_USE_IMGBTN       1
+#define LV_USE_IMGBTN     1
 
-#define LV_USE_KEYBOARD     1
+#define LV_USE_KEYBOARD   1
 
-#define LV_USE_LED          1
+#define LV_USE_LED        1
 
-#define LV_USE_LIST         1
+#define LV_USE_LIST       1
 
-#define LV_USE_METER        1
+#define LV_USE_METER      1
 
-#define LV_USE_MSGBOX       1
+#define LV_USE_MSGBOX     1
 
-#define LV_USE_SPINBOX      1
+#define LV_USE_SPINBOX    1
 
-#define LV_USE_SPINNER      1
+#define LV_USE_SPINNER    1
 
-#define LV_USE_TABVIEW      1
+#define LV_USE_TABVIEW    1
 
-#define LV_USE_TILEVIEW     1
+#define LV_USE_TILEVIEW   1
 
-#define LV_USE_WIN          1
+#define LV_USE_WIN        1
 
-#define LV_USE_SPAN         1
+#define LV_USE_SPAN       1
 #if LV_USE_SPAN
 /*A line text can contain maximum num of span descriptor */
-#  define LV_SPAN_SNIPPET_STACK_SIZE   64
+#  define LV_SPAN_SNIPPET_STACK_SIZE 64
 #endif
 
 /*-----------
  * Themes
  *----------*/
+
 /*A simple, impressive and very complete theme*/
-#define LV_USE_THEME_DEFAULT    1
+#define LV_USE_THEME_DEFAULT 1
 #if LV_USE_THEME_DEFAULT
 
 /*0: Light mode; 1: Dark mode*/
-# define LV_THEME_DEFAULT_DARK     0
+# define LV_THEME_DEFAULT_DARK 0
 
 /*1: Enable grow on press*/
-# define LV_THEME_DEFAULT_GROW              1
+# define LV_THEME_DEFAULT_GROW 1
 
 /*Default transition time in [ms]*/
-# define LV_THEME_DEFAULT_TRANSITON_TIME    80
+# define LV_THEME_DEFAULT_TRANSITION_TIME 80
 #endif /*LV_USE_THEME_DEFAULT*/
 
-/*An very simple them that is a good starting point for a custom theme*/
- #define LV_USE_THEME_BASIC    1
+/*A very simple theme that is a good starting point for a custom theme*/
+ #define LV_USE_THEME_BASIC 1
 
 /*A theme designed for monochrome displays*/
-#define LV_USE_THEME_MONO       1
+#define LV_USE_THEME_MONO 1
 
 /*-----------
  * Layouts
  *----------*/
 
 /*A layout similar to Flexbox in CSS.*/
-#define LV_USE_FLEX     1
+#define LV_USE_FLEX 1
 
 /*A layout similar to Grid in CSS.*/
-#define LV_USE_GRID     1
+#define LV_USE_GRID 1
+
+/*---------------------
+ * 3rd party libraries
+ *--------------------*/
+
+/*File system interfaces for common APIs
+ *To enable set a driver letter for that API*/
+#define LV_USE_FS_STDIO '\0'        /*Uses fopen, fread, etc*/
+//#define LV_FS_STDIO_PATH "/home/john/"    /*Set the working directory. If commented it will be "./" */
+
+#define LV_USE_FS_POSIX '\0'        /*Uses open, read, etc*/
+//#define LV_FS_POSIX_PATH "/home/john/"    /*Set the working directory. If commented it will be "./" */
+
+#define LV_USE_FS_WIN32 '\0'        /*Uses CreateFile, ReadFile, etc*/
+//#define LV_FS_WIN32_PATH "C:\\Users\\john\\"    /*Set the working directory. If commented it will be ".\\" */
+
+#define LV_USE_FS_FATFS '\0'        /*Uses f_open, f_read, etc*/
+
+/*PNG decoder library*/
+#define LV_USE_PNG 0
+
+/*BMP decoder library*/
+#define LV_USE_BMP 0
+
+/* JPG + split JPG decoder library.
+ * Split JPG is a custom format optimized for embedded systems. */
+#define LV_USE_SJPG 0
+
+/*GIF decoder library*/
+#define LV_USE_GIF 0
+
+/*QR code library*/
+#define LV_USE_QRCODE 0
+
+/*FreeType library*/
+#define LV_USE_FREETYPE 0
+#if LV_USE_FREETYPE
+/*Memory used by FreeType to cache characters [bytes] (-1: no caching)*/
+# define LV_FREETYPE_CACHE_SIZE (16 * 1024)
+#endif
+
+/*Rlottie library*/
+#define LV_USE_RLOTTIE 0
+
+/*-----------
+ * Others
+ *----------*/
+
+/*1: Enable API to take snapshot for object*/
+#define LV_USE_SNAPSHOT 1
+
 
 /*==================
 * EXAMPLES
 *==================*/
 
 /*Enable the examples to be built with the library*/
-#define LV_BUILD_EXAMPLES   1
+#define LV_BUILD_EXAMPLES 1
 
 /*--END OF LV_CONF_H--*/
 
diff --git a/lib/libesp32_lvgl/lvgl/lvgl.h b/lib/libesp32_lvgl/lvgl/lvgl.h
index 21de48a96..6717b4310 100644
--- a/lib/libesp32_lvgl/lvgl/lvgl.h
+++ b/lib/libesp32_lvgl/lvgl/lvgl.h
@@ -14,8 +14,8 @@ extern "C" {
  * CURRENT VERSION OF LVGL
  ***************************/
 #define LVGL_VERSION_MAJOR 8
-#define LVGL_VERSION_MINOR 0
-#define LVGL_VERSION_PATCH 2
+#define LVGL_VERSION_MINOR 1
+#define LVGL_VERSION_PATCH 0
 #define LVGL_VERSION_INFO ""
 
 /*********************
@@ -25,14 +25,16 @@ extern "C" {
 #include "src/misc/lv_log.h"
 #include "src/misc/lv_timer.h"
 #include "src/misc/lv_math.h"
+#include "src/misc/lv_mem.h"
 #include "src/misc/lv_async.h"
+#include "src/misc/lv_anim_timeline.h"
+#include "src/misc/lv_printf.h"
 
 #include "src/hal/lv_hal.h"
 
 #include "src/core/lv_obj.h"
 #include "src/core/lv_group.h"
 #include "src/core/lv_indev.h"
-
 #include "src/core/lv_refr.h"
 #include "src/core/lv_disp.h"
 #include "src/core/lv_theme.h"
@@ -40,7 +42,6 @@ extern "C" {
 #include "src/font/lv_font.h"
 #include "src/font/lv_font_loader.h"
 #include "src/font/lv_font_fmt_txt.h"
-#include "src/misc/lv_printf.h"
 
 #include "src/widgets/lv_arc.h"
 #include "src/widgets/lv_btn.h"
@@ -69,6 +70,8 @@ extern "C" {
 #include "src/extra/widgets/lv_widgets.h"
 #include "src/extra/layouts/lv_layouts.h"
 #include "src/extra/themes/lv_themes.h"
+#include "src/extra/others/lv_others.h"
+#include "src/extra/libs/lv_libs.h"
 
 /*********************
  *      DEFINES
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_disp.c b/lib/libesp32_lvgl/lvgl/src/core/lv_disp.c
index d8d9d9ae9..2806c4e7b 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_disp.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_disp.c
@@ -82,15 +82,24 @@ void lv_disp_load_scr(lv_obj_t * scr)
 {
     lv_disp_t * d = lv_obj_get_disp(scr);
     if(!d) return;  /*Shouldn't happen, just to be sure*/
+
+    lv_obj_t * old_scr = d->act_scr;
+
+    if(d->act_scr) lv_event_send(old_scr, LV_EVENT_SCREEN_UNLOAD_START, NULL);
+    if(d->act_scr) lv_event_send(scr, LV_EVENT_SCREEN_LOAD_START, NULL);
+
     d->act_scr = scr;
 
+    if(d->act_scr) lv_event_send(scr, LV_EVENT_SCREEN_LOADED, NULL);
+    if(d->act_scr) lv_event_send(old_scr, LV_EVENT_SCREEN_UNLOADED, NULL);
+
     lv_obj_invalidate(scr);
 }
 
 /**
  * Return with the top layer. (Same on every screen and it is above the normal screen layer)
  * @param disp pointer to display which top layer should be get. (NULL to use the default screen)
- * @return pointer to the top layer object  (transparent screen sized lv_obj)
+ * @return pointer to the top layer object (transparent screen sized lv_obj)
  */
 lv_obj_t * lv_disp_get_layer_top(lv_disp_t * disp)
 {
@@ -106,8 +115,8 @@ lv_obj_t * lv_disp_get_layer_top(lv_disp_t * disp)
 /**
  * Return with the sys. layer. (Same on every screen and it is above the normal screen and the top
  * layer)
- * @param disp pointer to display which sys. layer  should be get. (NULL to use the default screen)
- * @return pointer to the sys layer object  (transparent screen sized lv_obj)
+ * @param disp pointer to display which sys. layer should be retrieved. (NULL to use the default screen)
+ * @return pointer to the sys layer object (transparent screen sized lv_obj)
  */
 lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp)
 {
@@ -121,20 +130,18 @@ lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp)
 }
 
 /**
- * Get the theme of a display
+ * Set the theme of a display
  * @param disp pointer to a display
- * @return the display's theme (can be NULL)
  */
 void lv_disp_set_theme(lv_disp_t * disp, lv_theme_t * th)
 {
-	if(disp == NULL) disp = lv_disp_get_default();
+    if(disp == NULL) disp = lv_disp_get_default();
     disp->theme = th;
 
     if(disp->screen_cnt == 3 &&
-        lv_obj_get_child_cnt(disp->screens[0]) == 0 &&
-        lv_obj_get_child_cnt(disp->screens[1]) == 0 &&
-        lv_obj_get_child_cnt(disp->screens[2]) == 0)
-    {
+       lv_obj_get_child_cnt(disp->screens[0]) == 0 &&
+       lv_obj_get_child_cnt(disp->screens[1]) == 0 &&
+       lv_obj_get_child_cnt(disp->screens[2]) == 0) {
         lv_theme_apply(disp->screens[0]);
     }
 }
@@ -145,7 +152,7 @@ void lv_disp_set_theme(lv_disp_t * disp, lv_theme_t * th)
  */
 lv_theme_t * lv_disp_get_theme(lv_disp_t * disp)
 {
-	if(disp == NULL) disp = lv_disp_get_default();
+    if(disp == NULL) disp = lv_disp_get_default();
     return disp->theme;
 }
 
@@ -191,7 +198,7 @@ void lv_disp_set_bg_image(lv_disp_t * disp, const void  * img_src)
 }
 
 /**
- * Opacity of the background
+ * Set opacity of the background
  * @param disp pointer to a display
  * @param opa opacity (0..255)
  */
@@ -220,16 +227,21 @@ void lv_disp_set_bg_opa(lv_disp_t * disp, lv_opa_t opa)
  */
 void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t time, uint32_t delay, bool auto_del)
 {
+
     lv_disp_t * d = lv_obj_get_disp(new_scr);
     lv_obj_t * act_scr = lv_scr_act();
 
-    if(d->del_prev && act_scr != d->scr_to_load && d->scr_to_load) {
-        lv_obj_del(act_scr);
+    /*If an other screen load animation is in progress
+     *make target screen loaded immediately. */
+    if(d->scr_to_load && act_scr != d->scr_to_load) {
         lv_disp_load_scr(d->scr_to_load);
         lv_anim_del(d->scr_to_load, NULL);
         lv_obj_set_pos(d->scr_to_load, 0, 0);
         lv_obj_remove_local_style_prop(d->scr_to_load, LV_STYLE_OPA, 0);
 
+        if(d->del_prev) {
+            lv_obj_del(act_scr);
+        }
         act_scr = d->scr_to_load;
     }
 
@@ -323,13 +335,16 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
             break;
     }
 
+    lv_event_send(act_scr, LV_EVENT_SCREEN_UNLOAD_START, NULL);
+
     lv_anim_start(&a_new);
     lv_anim_start(&a_old);
+
 }
 
 /**
  * Get elapsed time since last user activity on a display (e.g. click)
- * @param disp pointer to an display (NULL to get the overall smallest inactivity)
+ * @param disp pointer to a display (NULL to get the overall smallest inactivity)
  * @return elapsed ticks (milliseconds) since the last activity
  */
 uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp)
@@ -350,7 +365,7 @@ uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp)
 
 /**
  * Manually trigger an activity on a display
- * @param disp pointer to an display (NULL to use the default display)
+ * @param disp pointer to a display (NULL to use the default display)
  */
 void lv_disp_trig_activity(lv_disp_t * disp)
 {
@@ -365,7 +380,7 @@ void lv_disp_trig_activity(lv_disp_t * disp)
 
 /**
  * Clean any CPU cache that is related to the display.
- * @param disp pointer to an display (NULL to use the default display)
+ * @param disp pointer to a display (NULL to use the default display)
  */
 void lv_disp_clean_dcache(lv_disp_t * disp)
 {
@@ -403,9 +418,11 @@ lv_timer_t * _lv_disp_get_refr_timer(lv_disp_t * disp)
 static void scr_load_anim_start(lv_anim_t * a)
 {
     lv_disp_t * d = lv_obj_get_disp(a->var);
-    d->prev_scr = lv_scr_act();
 
-    lv_disp_load_scr(a->var);
+    d->prev_scr = lv_scr_act();
+    d->act_scr = a->var;
+
+    lv_event_send(d->act_scr, LV_EVENT_SCREEN_LOAD_START, NULL);
 }
 
 static void opa_scale_anim(void * obj, int32_t v)
@@ -427,6 +444,9 @@ static void scr_anim_ready(lv_anim_t * a)
 {
     lv_disp_t * d = lv_obj_get_disp(a->var);
 
+    lv_event_send(d->act_scr, LV_EVENT_SCREEN_LOADED, NULL);
+    lv_event_send(d->prev_scr, LV_EVENT_SCREEN_UNLOADED, NULL);
+
     if(d->prev_scr && d->del_prev) lv_obj_del(d->prev_scr);
     d->prev_scr = NULL;
     d->scr_to_load = NULL;
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_disp.h b/lib/libesp32_lvgl/lvgl/src/core/lv_disp.h
index fdad3b7b7..01766b345 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_disp.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_disp.h
@@ -67,22 +67,21 @@ void lv_disp_load_scr(lv_obj_t * scr);
 /**
  * Return with the top layer. (Same on every screen and it is above the normal screen layer)
  * @param disp pointer to display which top layer should be get. (NULL to use the default screen)
- * @return pointer to the top layer object  (transparent screen sized lv_obj)
+ * @return pointer to the top layer object (transparent screen sized lv_obj)
  */
 lv_obj_t * lv_disp_get_layer_top(lv_disp_t * disp);
 
 /**
  * Return with the sys. layer. (Same on every screen and it is above the normal screen and the top
  * layer)
- * @param disp pointer to display which sys. layer  should be get. (NULL to use the default screen)
- * @return pointer to the sys layer object  (transparent screen sized lv_obj)
+ * @param disp pointer to display which sys. layer should be retrieved. (NULL to use the default screen)
+ * @return pointer to the sys layer object (transparent screen sized lv_obj)
  */
 lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp);
 
 /**
- * Get the theme of a display
+ * Set the theme of a display
  * @param disp pointer to a display
- * @return the display's theme (can be NULL)
  */
 void lv_disp_set_theme(lv_disp_t * disp, lv_theme_t * th);
 
@@ -108,7 +107,7 @@ void lv_disp_set_bg_color(lv_disp_t * disp, lv_color_t color);
 void lv_disp_set_bg_image(lv_disp_t * disp, const void  * img_src);
 
 /**
- * Opacity of the background
+ * Set opacity of the background
  * @param disp pointer to a display
  * @param opa opacity (0..255)
  */
@@ -126,20 +125,20 @@ void lv_scr_load_anim(lv_obj_t * scr, lv_scr_load_anim_t anim_type, uint32_t tim
 
 /**
  * Get elapsed time since last user activity on a display (e.g. click)
- * @param disp pointer to an display (NULL to get the overall smallest inactivity)
+ * @param disp pointer to a display (NULL to get the overall smallest inactivity)
  * @return elapsed ticks (milliseconds) since the last activity
  */
 uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp);
 
 /**
  * Manually trigger an activity on a display
- * @param disp pointer to an display (NULL to use the default display)
+ * @param disp pointer to a display (NULL to use the default display)
  */
 void lv_disp_trig_activity(lv_disp_t * disp);
 
 /**
  * Clean any CPU cache that is related to the display.
- * @param disp pointer to an display (NULL to use the default display)
+ * @param disp pointer to a display (NULL to use the default display)
  */
 void lv_disp_clean_dcache(lv_disp_t * disp);
 
@@ -229,7 +228,7 @@ static inline lv_coord_t lv_dpx(lv_coord_t n)
  * considering the DPI of the given display.
  * It ensures that e.g. `lv_dpx(100)` will have the same physical size regardless to the
  * DPI of the display.
- * @param obj   an display whose dpi should be considered
+ * @param obj   a display whose dpi should be considered
  * @param n     the number of pixels to scale
  * @return      `n x current_dpi/160`
  */
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_event.c b/lib/libesp32_lvgl/lvgl/src/core/lv_event.c
index 01cac5554..c9671fa8d 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_event.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_event.c
@@ -17,18 +17,19 @@
 /**********************
  *      TYPEDEFS
  **********************/
-typedef struct _lv_event_dsc_t{
+typedef struct _lv_event_dsc_t {
     lv_event_cb_t cb;
     void * user_data;
-    lv_event_code_t filter :8;
-}lv_event_dsc_t;
+    lv_event_code_t filter : 8;
+} lv_event_dsc_t;
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
 static lv_event_dsc_t * lv_obj_get_event_dsc(const lv_obj_t * obj, uint32_t id);
 static lv_res_t event_send_core(lv_event_t * e);
-static bool event_is_bubbled(lv_event_code_t e);
+static bool event_is_bubbled(lv_event_t * e);
+
 
 /**********************
  *  STATIC VARIABLES
@@ -39,9 +40,9 @@ static lv_event_t * event_head;
  *      MACROS
  **********************/
 #if LV_LOG_TRACE_EVENT
-#  define EVENT_TRACE(...) LV_LOG_TRACE( __VA_ARGS__)
+    #define EVENT_TRACE(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
-#  define EVENT_TRACE(...)
+    #define EVENT_TRACE(...)
 #endif
 
 /**********************
@@ -147,13 +148,15 @@ void _lv_event_mark_deleted(lv_obj_t * obj)
 }
 
 
-struct _lv_event_dsc_t * lv_obj_add_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data)
+struct _lv_event_dsc_t * lv_obj_add_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter,
+                                             void * user_data)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_obj_allocate_spec_attr(obj);
 
     obj->spec_attr->event_dsc_cnt++;
-    obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc, obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t));
+    obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc,
+                                               obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t));
     LV_ASSERT_MALLOC(obj->spec_attr->event_dsc);
 
     obj->spec_attr->event_dsc[obj->spec_attr->event_dsc_cnt - 1].cb = event_cb;
@@ -170,14 +173,14 @@ bool lv_obj_remove_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb)
 
     int32_t i = 0;
     for(i = 0; i < obj->spec_attr->event_dsc_cnt; i++) {
-        if(obj->spec_attr->event_dsc[i].cb == event_cb) {
+        if(event_cb == NULL || obj->spec_attr->event_dsc[i].cb == event_cb) {
             /*Shift the remaining event handlers forward*/
-            for(; i < (obj->spec_attr->event_dsc_cnt-1); i++) {
-                obj->spec_attr->event_dsc[i].cb = obj->spec_attr->event_dsc[i+1].cb;
-                obj->spec_attr->event_dsc[i].user_data = obj->spec_attr->event_dsc[i+1].user_data;
+            for(; i < (obj->spec_attr->event_dsc_cnt - 1); i++) {
+                obj->spec_attr->event_dsc[i] = obj->spec_attr->event_dsc[i + 1];
             }
             obj->spec_attr->event_dsc_cnt--;
-            obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc, obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t));
+            obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc,
+                                                       obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t));
             LV_ASSERT_MALLOC(obj->spec_attr->event_dsc);
             return true;
         }
@@ -187,6 +190,32 @@ bool lv_obj_remove_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb)
     return false;
 }
 
+bool lv_obj_remove_event_cb_with_user_data(lv_obj_t * obj, lv_event_cb_t event_cb, const void * user_data)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    if(obj->spec_attr == NULL) return false;
+
+    int32_t i = 0;
+    for(i = 0; i < obj->spec_attr->event_dsc_cnt; i++) {
+        if((event_cb == NULL || obj->spec_attr->event_dsc[i].cb) &&
+           obj->spec_attr->event_dsc[i].user_data == user_data) {
+            /*Shift the remaining event handlers forward*/
+            for(; i < (obj->spec_attr->event_dsc_cnt - 1); i++) {
+                obj->spec_attr->event_dsc[i] = obj->spec_attr->event_dsc[i + 1];
+            }
+            obj->spec_attr->event_dsc_cnt--;
+            obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc,
+                                                       obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t));
+            LV_ASSERT_MALLOC(obj->spec_attr->event_dsc);
+            return true;
+        }
+    }
+
+    /*No event handler found*/
+    return false;
+}
+
+
 bool lv_obj_remove_event_dsc(lv_obj_t * obj, struct _lv_event_dsc_t * event_dsc)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
@@ -196,12 +225,12 @@ bool lv_obj_remove_event_dsc(lv_obj_t * obj, struct _lv_event_dsc_t * event_dsc)
     for(i = 0; i < obj->spec_attr->event_dsc_cnt; i++) {
         if(&obj->spec_attr->event_dsc[i] == event_dsc) {
             /*Shift the remaining event handlers forward*/
-            for(; i < (obj->spec_attr->event_dsc_cnt-1); i++) {
-                obj->spec_attr->event_dsc[i].cb = obj->spec_attr->event_dsc[i+1].cb;
-                obj->spec_attr->event_dsc[i].user_data = obj->spec_attr->event_dsc[i+1].user_data;
+            for(; i < (obj->spec_attr->event_dsc_cnt - 1); i++) {
+                obj->spec_attr->event_dsc[i] = obj->spec_attr->event_dsc[i + 1];
             }
             obj->spec_attr->event_dsc_cnt--;
-            obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc, obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t));
+            obj->spec_attr->event_dsc = lv_mem_realloc(obj->spec_attr->event_dsc,
+                                                       obj->spec_attr->event_dsc_cnt * sizeof(lv_event_dsc_t));
             LV_ASSERT_MALLOC(obj->spec_attr->event_dsc);
             return true;
         }
@@ -215,24 +244,24 @@ lv_indev_t * lv_event_get_indev(lv_event_t * e)
 {
 
     if(e->code == LV_EVENT_PRESSED ||
-        e->code == LV_EVENT_PRESSING ||
-        e->code == LV_EVENT_PRESS_LOST ||
-        e->code == LV_EVENT_SHORT_CLICKED ||
-        e->code == LV_EVENT_LONG_PRESSED ||
-        e->code == LV_EVENT_LONG_PRESSED_REPEAT ||
-        e->code == LV_EVENT_CLICKED ||
-        e->code == LV_EVENT_RELEASED ||
-        e->code == LV_EVENT_SCROLL_BEGIN ||
-        e->code == LV_EVENT_SCROLL_END ||
-        e->code == LV_EVENT_SCROLL ||
-        e->code == LV_EVENT_GESTURE ||
-        e->code == LV_EVENT_KEY ||
-        e->code == LV_EVENT_FOCUSED ||
-        e->code == LV_EVENT_DEFOCUSED ||
-        e->code == LV_EVENT_LEAVE)
-    {
+       e->code == LV_EVENT_PRESSING ||
+       e->code == LV_EVENT_PRESS_LOST ||
+       e->code == LV_EVENT_SHORT_CLICKED ||
+       e->code == LV_EVENT_LONG_PRESSED ||
+       e->code == LV_EVENT_LONG_PRESSED_REPEAT ||
+       e->code == LV_EVENT_CLICKED ||
+       e->code == LV_EVENT_RELEASED ||
+       e->code == LV_EVENT_SCROLL_BEGIN ||
+       e->code == LV_EVENT_SCROLL_END ||
+       e->code == LV_EVENT_SCROLL ||
+       e->code == LV_EVENT_GESTURE ||
+       e->code == LV_EVENT_KEY ||
+       e->code == LV_EVENT_FOCUSED ||
+       e->code == LV_EVENT_DEFOCUSED ||
+       e->code == LV_EVENT_LEAVE) {
         return lv_event_get_param(e);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return NULL;
     }
@@ -240,11 +269,11 @@ lv_indev_t * lv_event_get_indev(lv_event_t * e)
 
 lv_obj_draw_part_dsc_t * lv_event_get_draw_part_dsc(lv_event_t * e)
 {
-    if(e->code == LV_EVENT_DRAW_PART_BEGIN||
-        e->code == LV_EVENT_DRAW_PART_END)
-    {
+    if(e->code == LV_EVENT_DRAW_PART_BEGIN ||
+       e->code == LV_EVENT_DRAW_PART_END) {
         return lv_event_get_param(e);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return NULL;
     }
@@ -253,14 +282,14 @@ lv_obj_draw_part_dsc_t * lv_event_get_draw_part_dsc(lv_event_t * e)
 const lv_area_t * lv_event_get_clip_area(lv_event_t * e)
 {
     if(e->code == LV_EVENT_DRAW_MAIN ||
-        e->code == LV_EVENT_DRAW_MAIN_BEGIN ||
-        e->code == LV_EVENT_DRAW_MAIN_END ||
-        e->code == LV_EVENT_DRAW_POST ||
-        e->code == LV_EVENT_DRAW_POST_BEGIN ||
-        e->code == LV_EVENT_DRAW_POST_END)
-    {
+       e->code == LV_EVENT_DRAW_MAIN_BEGIN ||
+       e->code == LV_EVENT_DRAW_MAIN_END ||
+       e->code == LV_EVENT_DRAW_POST ||
+       e->code == LV_EVENT_DRAW_POST_BEGIN ||
+       e->code == LV_EVENT_DRAW_POST_END) {
         return lv_event_get_param(e);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return NULL;
     }
@@ -270,7 +299,8 @@ const lv_area_t * lv_event_get_old_size(lv_event_t * e)
 {
     if(e->code == LV_EVENT_SIZE_CHANGED) {
         return lv_event_get_param(e);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return NULL;
     }
@@ -282,7 +312,8 @@ uint32_t lv_event_get_key(lv_event_t * e)
         uint32_t * k = lv_event_get_param(e);
         if(k) return *k;
         else return 0;
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return 0;
     }
@@ -292,7 +323,8 @@ lv_anim_t * lv_event_get_scroll_anim(lv_event_t * e)
 {
     if(e->code == LV_EVENT_SCROLL_BEGIN) {
         return lv_event_get_param(e);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return 0;
     }
@@ -303,7 +335,8 @@ void lv_event_set_ext_draw_size(lv_event_t * e, lv_coord_t size)
     if(e->code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
         lv_coord_t * cur_size = lv_event_get_param(e);
         *cur_size = LV_MAX(*cur_size, size);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
     }
 }
@@ -312,7 +345,8 @@ lv_point_t * lv_event_get_self_size_info(lv_event_t * e)
 {
     if(e->code == LV_EVENT_GET_SELF_SIZE) {
         return lv_event_get_param(e);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return 0;
     }
@@ -322,7 +356,8 @@ lv_hit_test_info_t * lv_event_get_hit_test_info(lv_event_t * e)
 {
     if(e->code == LV_EVENT_HIT_TEST) {
         return lv_event_get_param(e);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return 0;
     }
@@ -333,7 +368,8 @@ const lv_area_t * lv_event_get_cover_area(lv_event_t * e)
     if(e->code == LV_EVENT_COVER_CHECK) {
         lv_cover_check_info_t * p = lv_event_get_param(e);
         return p->area;
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
         return NULL;
     }
@@ -344,7 +380,8 @@ void lv_event_set_cover_res(lv_event_t * e, lv_cover_res_t res)
     if(e->code == LV_EVENT_COVER_CHECK) {
         lv_cover_check_info_t * p = lv_event_get_param(e);
         if(res > p->res) p->res = res;  /*Save only "stronger" results*/
-    } else {
+    }
+    else {
         LV_LOG_WARN("Not interpreted with this event code");
     }
 }
@@ -365,7 +402,7 @@ static lv_event_dsc_t * lv_obj_get_event_dsc(const lv_obj_t * obj, uint32_t id)
 
 static lv_res_t event_send_core(lv_event_t * e)
 {
-    EVENT_TRACE("Sending event %d to %p with %p param", e->code, e->current_target, e->param);
+    EVENT_TRACE("Sending event %d to %p with %p param", e->code, (void *)e->current_target, e->param);
 
     /*Call the input device's feedback callback if set*/
     lv_indev_t * indev_act = lv_indev_get_act();
@@ -391,39 +428,53 @@ static lv_res_t event_send_core(lv_event_t * e)
         event_dsc = lv_obj_get_event_dsc(e->current_target, i);
     }
 
-    if(res == LV_RES_OK && event_is_bubbled(e->code)) {
-        if(lv_obj_has_flag(e->current_target, LV_OBJ_FLAG_EVENT_BUBBLE) && e->current_target->parent) {
+    if(res == LV_RES_OK && e->current_target->parent && event_is_bubbled(e))
+    {
             e->current_target = e->current_target->parent;
             res = event_send_core(e);
             if(res != LV_RES_OK) return LV_RES_INV;
-        }
+
     }
 
     return res;
 }
 
-static bool event_is_bubbled(lv_event_code_t e)
+static bool event_is_bubbled(lv_event_t * e)
 {
-    switch(e) {
-    case LV_EVENT_HIT_TEST:
-    case LV_EVENT_COVER_CHECK:
-    case LV_EVENT_REFR_EXT_DRAW_SIZE:
-    case LV_EVENT_DRAW_MAIN_BEGIN:
-    case LV_EVENT_DRAW_MAIN:
-    case LV_EVENT_DRAW_MAIN_END:
-    case LV_EVENT_DRAW_POST_BEGIN:
-    case LV_EVENT_DRAW_POST:
-    case LV_EVENT_DRAW_POST_END:
-    case LV_EVENT_DRAW_PART_BEGIN:
-    case LV_EVENT_DRAW_PART_END:
-    case LV_EVENT_REFRESH:
-    case LV_EVENT_DELETE:
-    case LV_EVENT_CHILD_CHANGED:
-    case LV_EVENT_SIZE_CHANGED:
-    case LV_EVENT_STYLE_CHANGED:
-    case LV_EVENT_GET_SELF_SIZE:
-        return false;
-    default:
-        return true;
+    /*Event codes that always bubble*/
+    switch(e->code) {
+        case LV_EVENT_CHILD_CREATED:
+        case LV_EVENT_CHILD_DELETED:
+            return true;
+        default:
+            break;
+    }
+
+    /*Check other codes only if bubbling is enabled*/
+    if(lv_obj_has_flag(e->current_target, LV_OBJ_FLAG_EVENT_BUBBLE) == false) return false;
+
+    switch(e->code) {
+        case LV_EVENT_HIT_TEST:
+        case LV_EVENT_COVER_CHECK:
+        case LV_EVENT_REFR_EXT_DRAW_SIZE:
+        case LV_EVENT_DRAW_MAIN_BEGIN:
+        case LV_EVENT_DRAW_MAIN:
+        case LV_EVENT_DRAW_MAIN_END:
+        case LV_EVENT_DRAW_POST_BEGIN:
+        case LV_EVENT_DRAW_POST:
+        case LV_EVENT_DRAW_POST_END:
+        case LV_EVENT_DRAW_PART_BEGIN:
+        case LV_EVENT_DRAW_PART_END:
+        case LV_EVENT_REFRESH:
+        case LV_EVENT_DELETE:
+        case LV_EVENT_CHILD_CREATED:
+        case LV_EVENT_CHILD_DELETED:
+        case LV_EVENT_CHILD_CHANGED:
+        case LV_EVENT_SIZE_CHANGED:
+        case LV_EVENT_STYLE_CHANGED:
+        case LV_EVENT_GET_SELF_SIZE:
+            return false;
+        default:
+            return true;
     }
 }
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_event.h b/lib/libesp32_lvgl/lvgl/src/core/lv_event.h
index c8b60bb2f..dd425543b 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_event.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_event.h
@@ -72,14 +72,20 @@ typedef enum {
 
     /** Other events*/
     LV_EVENT_DELETE,              /**< Object is being deleted*/
-    LV_EVENT_CHILD_CHANGED,       /**< Child was removed/added*/
+    LV_EVENT_CHILD_CHANGED,       /**< Child was removed, added, or its size, position were changed */
+    LV_EVENT_CHILD_CREATED,       /**< Child was created, always bubbles up to all parents*/
+    LV_EVENT_CHILD_DELETED,       /**< Child was deleted, always bubbles up to all parents*/
+    LV_EVENT_SCREEN_UNLOAD_START, /**< A screen unload started, fired immediately when scr_load is called*/
+    LV_EVENT_SCREEN_LOAD_START,   /**< A screen load started, fired when the screen change delay is expired*/
+    LV_EVENT_SCREEN_LOADED,       /**< A screen was loaded*/
+    LV_EVENT_SCREEN_UNLOADED,     /**< A screen was unloaded*/
     LV_EVENT_SIZE_CHANGED,        /**< Object coordinates/size have changed*/
     LV_EVENT_STYLE_CHANGED,       /**< Object's style has changed*/
     LV_EVENT_LAYOUT_CHANGED,      /**< The children position has changed due to a layout recalculation*/
     LV_EVENT_GET_SELF_SIZE,       /**< Get the internal size of a widget*/
 
     _LV_EVENT_LAST                /** Number of default events*/
-}lv_event_code_t;
+} lv_event_code_t;
 
 typedef struct _lv_event_t {
     struct _lv_obj_t * target;
@@ -88,8 +94,8 @@ typedef struct _lv_event_t {
     void * user_data;
     void * param;
     struct _lv_event_t * prev;
-    uint8_t deleted :1;
-}lv_event_t;
+    uint8_t deleted : 1;
+} lv_event_t;
 
 /**
  * @brief Event callback.
@@ -193,8 +199,8 @@ uint32_t lv_event_register_id(void);
 
 /**
  * Nested events can be called and one of them might belong to an object that is being deleted.
- * Mark this object's `event_temp_data` deleted to know that it's `lv_event_send` should return `LV_RES_INV`
- * @param obj pointer to an obejct to mark as deleted
+ * Mark this object's `event_temp_data` deleted to know that its `lv_event_send` should return `LV_RES_INV`
+ * @param obj pointer to an object to mark as deleted
  */
 void _lv_event_mark_deleted(struct _lv_obj_t * obj);
 
@@ -209,17 +215,29 @@ void _lv_event_mark_deleted(struct _lv_obj_t * obj);
  * @param           user_data custom data data will be available in `event_cb`
  * @return          a pointer the event descriptor. Can be used in ::lv_obj_remove_event_dsc
  */
-struct _lv_event_dsc_t * lv_obj_add_event_cb(struct _lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter, void * user_data);
+struct _lv_event_dsc_t * lv_obj_add_event_cb(struct _lv_obj_t * obj, lv_event_cb_t event_cb, lv_event_code_t filter,
+                                             void * user_data);
 
 /**
  * Remove an event handler function for an object.
  * @param obj       pointer to an object
- * @param event_cb  the event function to remove
+ * @param event_cb  the event function to remove, or `NULL` to remove the the firstly added event callback
  * @return          true if any event handlers were removed
  */
 bool lv_obj_remove_event_cb(struct _lv_obj_t * obj, lv_event_cb_t event_cb);
 
 /**
+ * Remove an event handler function with a specific user_data from an object.
+ * @param obj               pointer to an object
+ * @param event_cb          the event function to remove, or `NULL` only `user_data` matters.
+ * @param event_user_data   the user_data specified in ::lv_obj_add_event_cb
+ * @return                  true if any event handlers were removed
+ */
+bool lv_obj_remove_event_cb_with_user_data(struct _lv_obj_t * obj, lv_event_cb_t event_cb,
+                                           const void * event_user_data);
+
+/**
+ * DEPRACTED because doesn't work if multiple event handlers are added to an object.
  * Remove an event handler function for an object.
  * @param obj       pointer to an object
  * @param event_dsc pointer to an event descriptor to remove (returned by ::lv_obj_add_event_cb)
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_group.c b/lib/libesp32_lvgl/lvgl/src/core/lv_group.c
index 7a9a2c846..9a1664672 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_group.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_group.c
@@ -79,7 +79,7 @@ void lv_group_del(lv_group_t * group)
     /*Remove the objects from the group*/
     lv_obj_t ** obj;
     _LV_LL_READ(&group->obj_ll, obj) {
-        if((*obj)->spec_attr) (*obj)->spec_attr->group_p = NULL;
+        if((*obj)->spec_attr)(*obj)->spec_attr->group_p = NULL;
     }
 
     _lv_ll_clear(&(group->obj_ll));
@@ -139,6 +139,25 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
     LV_LOG_TRACE("finished");
 }
 
+void lv_group_swap_obj(lv_obj_t * obj1, lv_obj_t * obj2)
+{
+    lv_group_t * g1 = lv_obj_get_group(obj1);
+    lv_group_t * g2 = lv_obj_get_group(obj2);
+    if(g1 != g2) return;
+    if(g1 == NULL) return;
+
+    /*Do not add the object twice*/
+    lv_obj_t ** obj_i;
+    _LV_LL_READ(&g1->obj_ll, obj_i) {
+        if((*obj_i) == obj1)(*obj_i) =  obj2;
+        else if((*obj_i) == obj2)(*obj_i) =  obj1;
+    }
+
+    if(*g1->obj_focus == obj1) lv_group_focus_obj(obj2);
+    else if(*g1->obj_focus == obj2) lv_group_focus_obj(obj1);
+
+}
+
 void lv_group_remove_obj(lv_obj_t * obj)
 {
     lv_group_t * g = lv_obj_get_group(obj);
@@ -192,7 +211,7 @@ void lv_group_remove_all_objs(lv_group_t * group)
     /*Remove the objects from the group*/
     lv_obj_t ** obj;
     _LV_LL_READ(&group->obj_ll, obj) {
-        if((*obj)->spec_attr) (*obj)->spec_attr->group_p = NULL;
+        if((*obj)->spec_attr)(*obj)->spec_attr->group_p = NULL;
     }
 
     _lv_ll_clear(&(group->obj_ll));
@@ -251,13 +270,7 @@ lv_res_t lv_group_send_data(lv_group_t * group, uint32_t c)
 {
     lv_obj_t * act = lv_group_get_focused(group);
     if(act == NULL) return LV_RES_OK;
-
-    lv_res_t res;
-
-    res = lv_event_send(act, LV_EVENT_KEY, &c);
-    if(res != LV_RES_OK) return res;
-
-    return res;
+    return lv_event_send(act, LV_EVENT_KEY, &c);
 }
 
 void lv_group_set_focus_cb(lv_group_t * group, lv_group_focus_cb_t focus_cb)
@@ -382,8 +395,18 @@ static void focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *)
         if(obj_next == NULL) continue;
         if(lv_obj_get_state(*obj_next) & LV_STATE_DISABLED) continue;
 
-        /*Hidden objects don't receive focus*/
-        if(lv_obj_has_flag(*obj_next, LV_OBJ_FLAG_HIDDEN) == false) break;
+        /*Hidden objects don't receive focus.
+         *If any parent is hidden, the object is also hidden)*/
+        lv_obj_t * parent = *obj_next;
+        while(parent) {
+            if(lv_obj_has_flag(parent, LV_OBJ_FLAG_HIDDEN)) break;
+            parent = lv_obj_get_parent(parent);
+        }
+
+        if(parent && lv_obj_has_flag(parent, LV_OBJ_FLAG_HIDDEN)) continue;
+
+        /*If we got her a good candidate is found*/
+        break;
     }
 
     if(obj_next == group->obj_focus) return; /*There's only one visible object and it's already focused*/
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_group.h b/lib/libesp32_lvgl/lvgl/src/core/lv_group.h
index 63dd37800..ecf88df6b 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_group.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_group.h
@@ -53,7 +53,7 @@ typedef void (*lv_group_focus_cb_t)(struct _lv_group_t *);
 
 /**
  * Groups can be used to logically hold objects so that they can be individually focused.
- * They are NOT for laying out objects on a screen (try `lv_cont` for that).
+ * They are NOT for laying out objects on a screen (try layouts for that).
  */
 typedef struct _lv_group_t {
     lv_ll_t obj_ll;        /**< Linked list to store the objects in the group*/
@@ -76,7 +76,7 @@ typedef struct _lv_group_t {
 typedef enum {
     LV_GROUP_REFOCUS_POLICY_NEXT = 0,
     LV_GROUP_REFOCUS_POLICY_PREV = 1
-}lv_group_refocus_policy_t;
+} lv_group_refocus_policy_t;
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -119,6 +119,13 @@ lv_group_t * lv_group_get_default(void);
  */
 void lv_group_add_obj(lv_group_t * group, struct _lv_obj_t * obj);
 
+/**
+ * Swap 2 object in a group. The object must be in the same group
+ * @param obj1  pointer to an object
+ * @param obj2  pointer to an other object
+ */
+void lv_group_swap_obj(struct _lv_obj_t * obj1, struct _lv_obj_t * obj2);
+
 /**
  * Remove an object from its group
  * @param obj       pointer to an object to remove
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_indev.c b/lib/libesp32_lvgl/lvgl/src/core/lv_indev.c
index 2e16b8e5f..02a65a28f 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_indev.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_indev.c
@@ -52,9 +52,9 @@ static lv_obj_t * indev_obj_act = NULL;
  *      MACROS
  **********************/
 #if LV_LOG_TRACE_INDEV
-#  define INDEV_TRACE(...) LV_LOG_TRACE( __VA_ARGS__)
+    #define INDEV_TRACE(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
-#  define INDEV_TRACE(...)
+    #define INDEV_TRACE(...)
 #endif
 
 /**********************
@@ -143,29 +143,32 @@ void lv_indev_reset(lv_indev_t * indev, lv_obj_t * obj)
     if(indev) {
         indev->proc.reset_query = 1;
         if(indev_act == indev) indev_obj_act = NULL;
-        if(obj == NULL || indev->proc.types.pointer.last_pressed == obj) {
-            indev->proc.types.pointer.last_pressed = NULL;
-        }
-        if(obj == NULL || indev->proc.types.pointer.act_obj == obj) {
-            indev->proc.types.pointer.act_obj = NULL;
-        }
-        if(obj == NULL || indev->proc.types.pointer.last_obj == obj) {
-            indev->proc.types.pointer.last_obj = NULL;
+        if(indev->driver->type == LV_INDEV_TYPE_POINTER || indev->driver->type == LV_INDEV_TYPE_KEYPAD) {
+            if(obj == NULL || indev->proc.types.pointer.last_pressed == obj) {
+                indev->proc.types.pointer.last_pressed = NULL;
+            }
+            if(obj == NULL || indev->proc.types.pointer.act_obj == obj) {
+                indev->proc.types.pointer.act_obj = NULL;
+            }
+            if(obj == NULL || indev->proc.types.pointer.last_obj == obj) {
+                indev->proc.types.pointer.last_obj = NULL;
+            }
         }
     }
     else {
         lv_indev_t * i = lv_indev_get_next(NULL);
         while(i) {
             i->proc.reset_query = 1;
-            if((i->driver->type == LV_INDEV_TYPE_POINTER || i->driver->type == LV_INDEV_TYPE_KEYPAD) &&
-               (obj == NULL || i->proc.types.pointer.last_pressed == obj)) {
-                i->proc.types.pointer.last_pressed = NULL;
-            }
-            if(obj == NULL || i->proc.types.pointer.act_obj == obj) {
-                i->proc.types.pointer.act_obj = NULL;
-            }
-            if(obj == NULL || i->proc.types.pointer.last_obj == obj) {
-                i->proc.types.pointer.last_obj = NULL;
+            if(i->driver->type == LV_INDEV_TYPE_POINTER || i->driver->type == LV_INDEV_TYPE_KEYPAD) {
+                if(obj == NULL || i->proc.types.pointer.last_pressed == obj) {
+                    i->proc.types.pointer.last_pressed = NULL;
+                }
+                if(obj == NULL || i->proc.types.pointer.act_obj == obj) {
+                    i->proc.types.pointer.act_obj = NULL;
+                }
+                if(obj == NULL || i->proc.types.pointer.last_obj == obj) {
+                    i->proc.types.pointer.last_obj = NULL;
+                }
             }
             i = lv_indev_get_next(i);
         }
@@ -290,8 +293,9 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
     /*If the point is on this object check its children too*/
     if(lv_obj_hit_test(obj, point)) {
         int32_t i;
-        for(i = lv_obj_get_child_cnt(obj) - 1; i >= 0; i--) {
-            lv_obj_t * child = lv_obj_get_child(obj, i);
+        uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+        for(i = child_cnt - 1; i >= 0; i--) {
+            lv_obj_t * child = obj->spec_attr->children[i];
             found_p = lv_indev_search_obj(child, point);
 
             /*If a child was found then break*/
@@ -325,7 +329,7 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
  */
 static void indev_pointer_proc(lv_indev_t * i, lv_indev_data_t * data)
 {
-    lv_disp_t *disp = i->driver->disp;
+    lv_disp_t * disp = i->driver->disp;
     /*Save the raw points so they can be used again in _lv_indev_read*/
     i->proc.types.pointer.last_raw_point.x = data->point.x;
     i->proc.types.pointer.last_raw_point.y = data->point.y;
@@ -342,9 +346,11 @@ static void indev_pointer_proc(lv_indev_t * i, lv_indev_data_t * data)
 
     /*Simple sanity check*/
     if(data->point.x < 0) LV_LOG_WARN("X is %d which is smaller than zero", data->point.x);
-    if(data->point.x >= lv_disp_get_hor_res(i->driver->disp)) LV_LOG_WARN("X is %d which is greater than hor. res", data->point.x);
+    if(data->point.x >= lv_disp_get_hor_res(i->driver->disp)) LV_LOG_WARN("X is %d which is greater than hor. res",
+                                                                              data->point.x);
     if(data->point.y < 0) LV_LOG_WARN("Y is %d which is smaller than zero", data->point.y);
-    if(data->point.y >= lv_disp_get_ver_res(i->driver->disp)) LV_LOG_WARN("Y is %d which is greater than hor. res", data->point.y);
+    if(data->point.y >= lv_disp_get_ver_res(i->driver->disp)) LV_LOG_WARN("Y is %d which is greater than hor. res",
+                                                                              data->point.y);
 
     /*Move the cursor if set and moved*/
     if(i->cursor != NULL &&
@@ -554,9 +560,9 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
         i->proc.pr_timestamp = lv_tick_get();
 
         if(data->key == LV_KEY_ENTER) {
-            bool editable = lv_obj_is_editable(indev_obj_act);
-
-            if(lv_group_get_editing(g) == true || editable == false) {
+            bool editable_or_scrollable = lv_obj_is_editable(indev_obj_act) ||
+                                          lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_SCROLLABLE);
+            if(lv_group_get_editing(g) == true || editable_or_scrollable == false) {
                 lv_event_send(indev_obj_act, LV_EVENT_PRESSED, indev_act);
                 if(indev_reset_check(&i->proc)) return;
             }
@@ -590,12 +596,14 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
             i->proc.longpr_rep_timestamp = lv_tick_get();
 
             if(data->key == LV_KEY_ENTER) {
-                bool editable = lv_obj_is_editable(indev_obj_act);
+                bool editable_or_scrollable = lv_obj_is_editable(indev_obj_act) ||
+                                              lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_SCROLLABLE);
 
                 /*On enter long press toggle edit mode.*/
-                if(editable) {
+                if(editable_or_scrollable) {
                     /*Don't leave edit mode if there is only one object (nowhere to navigate)*/
                     if(lv_group_get_obj_count(g) > 1) {
+                        LV_LOG_INFO("toggling edit mode");
                         lv_group_set_editing(g, lv_group_get_editing(g) ? false : true); /*Toggle edit mode on long press*/
                         lv_obj_clear_state(indev_obj_act, LV_STATE_PRESSED);    /*Remove the pressed state manually*/
                     }
@@ -639,10 +647,11 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
         LV_LOG_INFO("released");
 
         if(data->key == LV_KEY_ENTER) {
-            bool editable = lv_obj_is_editable(indev_obj_act);
+            bool editable_or_scrollable = lv_obj_is_editable(indev_obj_act) ||
+                                          lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_SCROLLABLE);
 
             /*The button was released on a non-editable object. Just send enter*/
-            if(editable == false) {
+            if(editable_or_scrollable == false) {
                 lv_event_send(indev_obj_act, LV_EVENT_RELEASED, indev_act);
                 if(indev_reset_check(&i->proc)) return;
 
@@ -668,13 +677,15 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
 
 
                     lv_group_send_data(g, LV_KEY_ENTER);
-                } else {
+                }
+                else {
                     lv_obj_clear_state(indev_obj_act, LV_STATE_PRESSED);    /*Remove the pressed state manually*/
                 }
             }
             /*If the focused object is editable and now in navigate mode then on enter switch edit
                mode*/
-            else if(editable && !lv_group_get_editing(g) && !i->proc.long_pr_sent) {
+            else if(!i->proc.long_pr_sent) {
+                LV_LOG_INFO("entering edit mode");
                 lv_group_set_editing(g, true); /*Set edit mode*/
             }
         }
@@ -686,9 +697,9 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
 
     /*if encoder steps or simulated steps via left/right keys*/
     if(data->enc_diff != 0) {
-        LV_LOG_INFO("rotated by %d", data->enc_diff);
         /*In edit mode send LEFT/RIGHT keys*/
         if(lv_group_get_editing(g)) {
+            LV_LOG_INFO("rotated by %+d (edit)", data->enc_diff);
             int32_t s;
             if(data->enc_diff < 0) {
                 for(s = 0; s < -data->enc_diff; s++) lv_group_send_data(g, LV_KEY_LEFT);
@@ -699,6 +710,7 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
         }
         /*In navigate mode focus on the next/prev objects*/
         else {
+            LV_LOG_INFO("rotated by %+d (nav)", data->enc_diff);
             int32_t s;
             if(data->enc_diff < 0) {
                 for(s = 0; s < -data->enc_diff; s++) lv_group_focus_prev(g);
@@ -981,66 +993,67 @@ static void indev_proc_reset_query_handler(lv_indev_t * indev)
 static void indev_click_focus(_lv_indev_proc_t * proc)
 {
     /*Handle click focus*/
-    lv_obj_t * obj_to_focus = indev_obj_act;
-    if(lv_obj_has_flag(obj_to_focus, LV_OBJ_FLAG_CLICK_FOCUSABLE) &&
-       proc->types.pointer.last_pressed != obj_to_focus) {
-        lv_group_t * g_act = lv_obj_get_group(obj_to_focus);
-        lv_group_t * g_prev = proc->types.pointer.last_pressed ? lv_obj_get_group(proc->types.pointer.last_pressed) : NULL;
+    if(lv_obj_has_flag(indev_obj_act, LV_OBJ_FLAG_CLICK_FOCUSABLE) == false ||
+       proc->types.pointer.last_pressed == indev_obj_act)
+    {
+        return;
+    }
 
-        /*If both the last and act. obj. are in the same group (or no group but it's also the same)*/
-        if(g_act == g_prev) {
-            /*The objects are in a group*/
-            if(g_act) {
-                lv_group_focus_obj(obj_to_focus);
-                if(indev_reset_check(proc)) return;
-            }
-            /*The object are not in group*/
-            else {
-                if(proc->types.pointer.last_pressed) {
-                    lv_event_send(proc->types.pointer.last_pressed, LV_EVENT_DEFOCUSED, indev_act);
-                    if(indev_reset_check(proc)) return;
-                }
+    lv_group_t * g_act = lv_obj_get_group(indev_obj_act);
+    lv_group_t * g_prev = proc->types.pointer.last_pressed ? lv_obj_get_group(proc->types.pointer.last_pressed) : NULL;
 
-                lv_event_send(obj_to_focus, LV_EVENT_FOCUSED, indev_act);
-                if(indev_reset_check(proc)) return;
-            }
+    /*If both the last and act. obj. are in the same group (or have no group)*/
+    if(g_act == g_prev) {
+        /*The objects are in a group*/
+        if(g_act) {
+            lv_group_focus_obj(indev_obj_act);
+            if(indev_reset_check(proc)) return;
         }
-        /*The object are not in the same group (in different group or one in not a group)*/
+        /*The object are not in group*/
         else {
-            /*If the prev. obj. is not in a group then defocus it.*/
-            if(g_prev == NULL && proc->types.pointer.last_pressed) {
+            if(proc->types.pointer.last_pressed) {
                 lv_event_send(proc->types.pointer.last_pressed, LV_EVENT_DEFOCUSED, indev_act);
                 if(indev_reset_check(proc)) return;
             }
-            /*Focus on a non-group object*/
-            else {
-                if(proc->types.pointer.last_pressed) {
-                    /*If the prev. object also wasn't in a group defocus it*/
-                    if(g_prev == NULL) {
-                        lv_event_send(proc->types.pointer.last_pressed, LV_EVENT_DEFOCUSED, indev_act);
-                        if(indev_reset_check(proc)) return;
-                    }
-                    /*If the prev. object also was in a group at least "LEAVE" it instead of defocus*/
-                    else {
-                        lv_event_send(proc->types.pointer.last_pressed, LV_EVENT_LEAVE, indev_act);
-                        if(indev_reset_check(proc)) return;
-                    }
+
+            lv_event_send(indev_obj_act, LV_EVENT_FOCUSED, indev_act);
+            if(indev_reset_check(proc)) return;
+        }
+    }
+    /*The object are not in the same group (in different groups or one has no group)*/
+    else {
+        /*If the prev. obj. is not in a group then defocus it.*/
+        if(g_prev == NULL && proc->types.pointer.last_pressed) {
+            lv_event_send(proc->types.pointer.last_pressed, LV_EVENT_DEFOCUSED, indev_act);
+            if(indev_reset_check(proc)) return;
+        }
+        /*Focus on a non-group object*/
+        else {
+            if(proc->types.pointer.last_pressed) {
+                /*If the prev. object also wasn't in a group defocus it*/
+                if(g_prev == NULL) {
+                    lv_event_send(proc->types.pointer.last_pressed, LV_EVENT_DEFOCUSED, indev_act);
+                    if(indev_reset_check(proc)) return;
+                }
+                /*If the prev. object also was in a group at least "LEAVE" it instead of defocus*/
+                else {
+                    lv_event_send(proc->types.pointer.last_pressed, LV_EVENT_LEAVE, indev_act);
+                    if(indev_reset_check(proc)) return;
                 }
             }
-
-            /*Focus to the act. in its group*/
-            if(g_act) {
-                lv_group_focus_obj(obj_to_focus);
-                if(indev_reset_check(proc)) return;
-            }
-            else {
-                lv_event_send(obj_to_focus, LV_EVENT_FOCUSED, indev_act);
-                if(indev_reset_check(proc)) return;
-            }
         }
-        proc->types.pointer.last_pressed = obj_to_focus;
-    }
 
+        /*Focus to the act. in its group*/
+        if(g_act) {
+            lv_group_focus_obj(indev_obj_act);
+            if(indev_reset_check(proc)) return;
+        }
+        else {
+            lv_event_send(indev_obj_act, LV_EVENT_FOCUSED, indev_act);
+            if(indev_reset_check(proc)) return;
+        }
+    }
+    proc->types.pointer.last_pressed = indev_obj_act;
 }
 
 /**
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_indev_scroll.c b/lib/libesp32_lvgl/lvgl/src/core/lv_indev_scroll.c
index ff386aefc..bf356a87b 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_indev_scroll.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_indev_scroll.c
@@ -28,7 +28,8 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
 static void scroll_limit_diff(_lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_coord_t * diff_y);
 static lv_coord_t scroll_throw_predict_y(_lv_indev_proc_t * proc);
 static lv_coord_t scroll_throw_predict_x(_lv_indev_proc_t * proc);
-static lv_coord_t elastic_diff(lv_obj_t * scroll_obj, lv_coord_t diff, lv_coord_t scroll_start, lv_coord_t scroll_end, lv_dir_t dir);
+static lv_coord_t elastic_diff(lv_obj_t * scroll_obj, lv_coord_t diff, lv_coord_t scroll_start, lv_coord_t scroll_end,
+                               lv_dir_t dir);
 
 /**********************
  *  STATIC VARIABLES
@@ -68,7 +69,8 @@ void _lv_indev_scroll_handler(_lv_indev_proc_t * proc)
             lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
             lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
             diff_x = elastic_diff(scroll_obj, proc->types.pointer.vect.x, sl, sr, LV_DIR_HOR);
-        } else {
+        }
+        else {
             lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
             lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
             diff_y = elastic_diff(scroll_obj, proc->types.pointer.vect.y, st, sb, LV_DIR_VER);
@@ -113,12 +115,13 @@ void _lv_indev_scroll_throw_handler(_lv_indev_proc_t * proc)
         /*If no snapping "throw"*/
         if(align_y == LV_SCROLL_SNAP_NONE) {
             proc->types.pointer.scroll_throw_vect.y =
-                    proc->types.pointer.scroll_throw_vect.y * (100 - scroll_throw) / 100;
+                proc->types.pointer.scroll_throw_vect.y * (100 - scroll_throw) / 100;
 
             lv_coord_t sb = lv_obj_get_scroll_bottom(scroll_obj);
             lv_coord_t st = lv_obj_get_scroll_top(scroll_obj);
 
-             proc->types.pointer.scroll_throw_vect.y = elastic_diff(scroll_obj, proc->types.pointer.scroll_throw_vect.y, st, sb, LV_DIR_VER);
+            proc->types.pointer.scroll_throw_vect.y = elastic_diff(scroll_obj, proc->types.pointer.scroll_throw_vect.y, st, sb,
+                                                                   LV_DIR_VER);
 
             lv_obj_scroll_by(scroll_obj, 0, proc->types.pointer.scroll_throw_vect.y, LV_ANIM_OFF);
         }
@@ -136,12 +139,13 @@ void _lv_indev_scroll_throw_handler(_lv_indev_proc_t * proc)
         /*If no snapping "throw"*/
         if(align_x == LV_SCROLL_SNAP_NONE) {
             proc->types.pointer.scroll_throw_vect.x =
-                    proc->types.pointer.scroll_throw_vect.x * (100 - scroll_throw) / 100;
+                proc->types.pointer.scroll_throw_vect.x * (100 - scroll_throw) / 100;
 
             lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
             lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
 
-            proc->types.pointer.scroll_throw_vect.x = elastic_diff(scroll_obj, proc->types.pointer.scroll_throw_vect.x, sl ,sr, LV_DIR_HOR);
+            proc->types.pointer.scroll_throw_vect.x = elastic_diff(scroll_obj, proc->types.pointer.scroll_throw_vect.x, sl, sr,
+                                                                   LV_DIR_HOR);
 
             lv_obj_scroll_by(scroll_obj, proc->types.pointer.scroll_throw_vect.x, 0, LV_ANIM_OFF);
         }
@@ -176,7 +180,7 @@ void _lv_indev_scroll_throw_handler(_lv_indev_proc_t * proc)
         if(align_x == LV_SCROLL_SNAP_NONE) {
             lv_coord_t sl = lv_obj_get_scroll_left(scroll_obj);
             lv_coord_t sr = lv_obj_get_scroll_right(scroll_obj);
-            if (sl > 0 || sr > 0) {
+            if(sl > 0 || sr > 0) {
                 if(sl < 0) {
                     lv_obj_scroll_by(scroll_obj, sl, 0, LV_ANIM_ON);
                 }
@@ -205,14 +209,14 @@ lv_coord_t lv_indev_scroll_throw_predict(lv_indev_t * indev, lv_dir_t dir)
     if(indev == NULL) return 0;
     lv_coord_t v;
     switch(dir) {
-    case LV_DIR_VER:
-        v = indev->proc.types.pointer.scroll_throw_vect_ori.y;
-        break;
-    case LV_DIR_HOR:
-        v = indev->proc.types.pointer.scroll_throw_vect_ori.x;
-        break;
-    default:
-        return 0;
+        case LV_DIR_VER:
+            v = indev->proc.types.pointer.scroll_throw_vect_ori.y;
+            break;
+        case LV_DIR_HOR:
+            v = indev->proc.types.pointer.scroll_throw_vect_ori.x;
+            break;
+        default:
+            return 0;
     }
 
     lv_coord_t scroll_throw = indev->driver->scroll_throw;
@@ -242,10 +246,10 @@ static lv_obj_t * find_scroll_obj(_lv_indev_proc_t * proc)
     lv_indev_t * indev_act = lv_indev_get_act();
     lv_coord_t scroll_limit =  indev_act->driver->scroll_limit;
 
-    /*Go until find an scrollable object in the current direction
+    /*Go until find a scrollable object in the current direction
      *More precisely:
      * 1. Check the pressed object and all of its ancestors and try to find an object which is scrollable
-     * 2. Scrollable means it has some content out of it's area
+     * 2. Scrollable means it has some content out of its area
      * 3. If an object can be scrolled into the current direction then use it ("real match"")
      * 4. If can be scrolled on the current axis (hor/ver) save it as candidate (at least show an elastic scroll effect)
      * 5. Use the last candidate. Always the "deepest" parent or the object from point 3*/
@@ -292,17 +296,15 @@ static lv_obj_t * find_scroll_obj(_lv_indev_proc_t * proc)
          *is propagated to this object it can show at least elastic scroll effect.
          *But if not hor/ver scrollable do not scroll it at all (so it's not a good candidate)*/
         if((st > 0 || sb > 0)  &&
-                ((up_en    && proc->types.pointer.scroll_sum.y >= scroll_limit) ||
-                        (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit)))
-        {
+           ((up_en    && proc->types.pointer.scroll_sum.y >= scroll_limit) ||
+            (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit))) {
             obj_candidate = obj_act;
             dir_candidate = LV_DIR_VER;
         }
 
         if((sl > 0 || sr > 0)  &&
-                ((left_en    && proc->types.pointer.scroll_sum.x >=  scroll_limit) ||
-                        (right_en  && proc->types.pointer.scroll_sum.x <= - scroll_limit)))
-        {
+           ((left_en    && proc->types.pointer.scroll_sum.x >=  scroll_limit) ||
+            (right_en  && proc->types.pointer.scroll_sum.x <= - scroll_limit))) {
             obj_candidate = obj_act;
             dir_candidate = LV_DIR_HOR;
         }
@@ -314,10 +316,9 @@ static lv_obj_t * find_scroll_obj(_lv_indev_proc_t * proc)
 
         /*If the object really can be scrolled into the current direction the use it.*/
         if((left_en  && proc->types.pointer.scroll_sum.x >=   scroll_limit) ||
-                (right_en && proc->types.pointer.scroll_sum.x <= - scroll_limit) ||
-                (up_en    && proc->types.pointer.scroll_sum.y >=   scroll_limit) ||
-                (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit))
-        {
+           (right_en && proc->types.pointer.scroll_sum.x <= - scroll_limit) ||
+           (up_en    && proc->types.pointer.scroll_sum.y >=   scroll_limit) ||
+           (down_en  && proc->types.pointer.scroll_sum.y <= - scroll_limit)) {
             proc->types.pointer.scroll_dir = hor_en ? LV_DIR_HOR : LV_DIR_VER;
             break;
         }
@@ -350,45 +351,45 @@ static void init_scroll_limits(_lv_indev_proc_t * proc)
     /*With STOP limit the scrolling to the perv and next snap point*/
     else {
         switch(lv_obj_get_scroll_snap_y(obj)) {
-        case LV_SCROLL_SNAP_START:
-            proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
-            proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
-            break;
-        case LV_SCROLL_SNAP_END:
-            proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y2, LV_COORD_MAX, 0);
-            proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y2, 0);
-            break;
-        case LV_SCROLL_SNAP_CENTER: {
-            lv_coord_t y_mid = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
-            proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, y_mid + 1, LV_COORD_MAX, 0);
-            proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, y_mid - 1, 0);
-            break;
-        }
-        default:
-            proc->types.pointer.scroll_area.y1 = LV_COORD_MIN;
-            proc->types.pointer.scroll_area.y2 = LV_COORD_MAX;
-            break;
+            case LV_SCROLL_SNAP_START:
+                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y1 + 1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y1 - 1, 0);
+                break;
+            case LV_SCROLL_SNAP_END:
+                proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, obj->coords.y2, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, obj->coords.y2, 0);
+                break;
+            case LV_SCROLL_SNAP_CENTER: {
+                    lv_coord_t y_mid = obj->coords.y1 + lv_area_get_height(&obj->coords) / 2;
+                    proc->types.pointer.scroll_area.y1 = find_snap_point_y(obj, y_mid + 1, LV_COORD_MAX, 0);
+                    proc->types.pointer.scroll_area.y2 = find_snap_point_y(obj, LV_COORD_MIN, y_mid - 1, 0);
+                    break;
+                }
+            default:
+                proc->types.pointer.scroll_area.y1 = LV_COORD_MIN;
+                proc->types.pointer.scroll_area.y2 = LV_COORD_MAX;
+                break;
         }
 
         switch(lv_obj_get_scroll_snap_x(obj)) {
-        case LV_SCROLL_SNAP_START:
-            proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
-            proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
-            break;
-        case LV_SCROLL_SNAP_END:
-            proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x2, LV_COORD_MAX, 0);
-            proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x2, 0);
-            break;
-        case LV_SCROLL_SNAP_CENTER: {
-            lv_coord_t x_mid = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
-            proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, x_mid + 1, LV_COORD_MAX, 0);
-            proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, x_mid - 1, 0);
-            break;
-        }
-        default:
-            proc->types.pointer.scroll_area.x1 = LV_COORD_MIN;
-            proc->types.pointer.scroll_area.x2 = LV_COORD_MAX;
-            break;
+            case LV_SCROLL_SNAP_START:
+                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x1, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x1, 0);
+                break;
+            case LV_SCROLL_SNAP_END:
+                proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, obj->coords.x2, LV_COORD_MAX, 0);
+                proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, obj->coords.x2, 0);
+                break;
+            case LV_SCROLL_SNAP_CENTER: {
+                    lv_coord_t x_mid = obj->coords.x1 + lv_area_get_width(&obj->coords) / 2;
+                    proc->types.pointer.scroll_area.x1 = find_snap_point_x(obj, x_mid + 1, LV_COORD_MAX, 0);
+                    proc->types.pointer.scroll_area.x2 = find_snap_point_x(obj, LV_COORD_MIN, x_mid - 1, 0);
+                    break;
+                }
+            default:
+                proc->types.pointer.scroll_area.x1 = LV_COORD_MIN;
+                proc->types.pointer.scroll_area.x2 = LV_COORD_MAX;
+                break;
         }
     }
 
@@ -402,8 +403,8 @@ static void init_scroll_limits(_lv_indev_proc_t * proc)
 /**
  * Search for snap point in the `min` - `max` range.
  * @param obj the object on which snap point should be found
- * @param min ignore snap points smaller then this. (Absolute coordinate)
- * @param max ignore snap points greater then this. (Absolute coordinate)
+ * @param min ignore snap points smaller than this. (Absolute coordinate)
+ * @param max ignore snap points greater than this. (Absolute coordinate)
  * @param ofs offset to snap points. Useful the get a snap point in an imagined case
  *            what if children are already moved by this value
  * @return the distance of the snap point.
@@ -419,27 +420,28 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
     lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_PART_MAIN);
 
     uint32_t i;
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-        lv_obj_t * child = lv_obj_get_child(obj, i);
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
         if(lv_obj_has_flag_any(child, LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
-        if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPABLE)) {
+        if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPPABLE)) {
             lv_coord_t x_child = 0;
             lv_coord_t x_parent = 0;
             switch(align) {
-            case LV_SCROLL_SNAP_START:
-                x_child = child->coords.x1;
-                x_parent = obj->coords.x1 + pad_left;
-                break;
-            case LV_SCROLL_SNAP_END:
-                x_child = child->coords.x2;
-                x_parent = obj->coords.x2 - pad_right;
-                break;
-            case LV_SCROLL_SNAP_CENTER:
-                x_child = child->coords.x1 + lv_area_get_width(&child->coords) / 2;
-                x_parent = obj->coords.x1 + pad_left + (lv_area_get_width(&obj->coords) - pad_left - pad_right) / 2;
-                break;
-            default:
-                continue;
+                case LV_SCROLL_SNAP_START:
+                    x_child = child->coords.x1;
+                    x_parent = obj->coords.x1 + pad_left;
+                    break;
+                case LV_SCROLL_SNAP_END:
+                    x_child = child->coords.x2;
+                    x_parent = obj->coords.x2 - pad_right;
+                    break;
+                case LV_SCROLL_SNAP_CENTER:
+                    x_child = child->coords.x1 + lv_area_get_width(&child->coords) / 2;
+                    x_parent = obj->coords.x1 + pad_left + (lv_area_get_width(&obj->coords) - pad_left - pad_right) / 2;
+                    break;
+                default:
+                    continue;
             }
 
             x_child += ofs;
@@ -450,15 +452,15 @@ static lv_coord_t find_snap_point_x(const lv_obj_t * obj, lv_coord_t min, lv_coo
         }
     }
 
-    return dist == LV_COORD_MAX ? 0: -dist;
+    return dist == LV_COORD_MAX ? 0 : -dist;
 }
 
 /**
  * Search for snap point in the `min` - `max` range.
  * @param obj the object on which snap point should be found
- * @param min ignore snap points smaller then this. (Absolute coordinate)
- * @param max ignore snap points greater then this. (Absolute coordinate)
- * @param ofs offset to snap points. Useful the get a snap point in an imagined case
+ * @param min ignore snap points smaller than this. (Absolute coordinate)
+ * @param max ignore snap points greater than this. (Absolute coordinate)
+ * @param ofs offset to snap points. Useful to get a snap point in an imagined case
  *            what if children are already moved by this value
  * @return the distance of the snap point.
  */
@@ -473,27 +475,28 @@ static lv_coord_t find_snap_point_y(const lv_obj_t * obj, lv_coord_t min, lv_coo
     lv_coord_t pad_bottom = lv_obj_get_style_pad_bottom(obj, LV_PART_MAIN);
 
     uint32_t i;
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-        lv_obj_t * child = lv_obj_get_child(obj, i);
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
         if(lv_obj_has_flag_any(child, LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
-        if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPABLE)) {
+        if(lv_obj_has_flag(child, LV_OBJ_FLAG_SNAPPABLE)) {
             lv_coord_t y_child = 0;
             lv_coord_t y_parent = 0;
             switch(align) {
-            case LV_SCROLL_SNAP_START:
-                y_child = child->coords.y1;
-                y_parent = obj->coords.y1 + pad_top;
-                break;
-            case LV_SCROLL_SNAP_END:
-                y_child = child->coords.y2;
-                y_parent = obj->coords.y2 - pad_bottom;
-                break;
-            case LV_SCROLL_SNAP_CENTER:
-                y_child = child->coords.y1 + lv_area_get_height(&child->coords) / 2;
-                y_parent = obj->coords.y1 + pad_top + (lv_area_get_height(&obj->coords) - pad_top - pad_bottom) / 2;
-                break;
-            default:
-                continue;
+                case LV_SCROLL_SNAP_START:
+                    y_child = child->coords.y1;
+                    y_parent = obj->coords.y1 + pad_top;
+                    break;
+                case LV_SCROLL_SNAP_END:
+                    y_child = child->coords.y2;
+                    y_parent = obj->coords.y2 - pad_bottom;
+                    break;
+                case LV_SCROLL_SNAP_CENTER:
+                    y_child = child->coords.y1 + lv_area_get_height(&child->coords) / 2;
+                    y_parent = obj->coords.y1 + pad_top + (lv_area_get_height(&obj->coords) - pad_top - pad_bottom) / 2;
+                    break;
+                default:
+                    continue;
             }
 
             y_child += ofs;
@@ -511,7 +514,7 @@ static void scroll_limit_diff(_lv_indev_proc_t * proc, lv_coord_t * diff_x, lv_c
 {
     if(diff_y) {
         if(proc->types.pointer.scroll_sum.y + *diff_y < proc->types.pointer.scroll_area.y1) {
-           *diff_y = proc->types.pointer.scroll_area.y1 - proc->types.pointer.scroll_sum.y;
+            *diff_y = proc->types.pointer.scroll_area.y1 - proc->types.pointer.scroll_sum.y;
         }
 
         if(proc->types.pointer.scroll_sum.y + *diff_y > proc->types.pointer.scroll_area.y2) {
@@ -563,7 +566,8 @@ static lv_coord_t scroll_throw_predict_x(_lv_indev_proc_t * proc)
     return move;
 }
 
-static lv_coord_t elastic_diff(lv_obj_t * scroll_obj, lv_coord_t diff, lv_coord_t scroll_start, lv_coord_t scroll_end, lv_dir_t dir)
+static lv_coord_t elastic_diff(lv_obj_t * scroll_obj, lv_coord_t diff, lv_coord_t scroll_start, lv_coord_t scroll_end,
+                               lv_dir_t dir)
 {
     if(lv_obj_has_flag(scroll_obj, LV_OBJ_FLAG_SCROLL_ELASTIC)) {
         /*If there is snapping in the current direction don't use the elastic factor because
@@ -580,36 +584,37 @@ static lv_coord_t elastic_diff(lv_obj_t * scroll_obj, lv_coord_t diff, lv_coord_
             lv_coord_t pad_right = lv_obj_get_style_pad_right(scroll_obj, LV_PART_MAIN);
 
             switch(snap) {
-            case LV_SCROLL_SNAP_CENTER:
-                snap_point = pad_left + (lv_area_get_width(&scroll_obj->coords) - pad_left - pad_right) / 2 + scroll_obj->coords.x1;
-                act_obj_point = lv_area_get_width(&act_obj->coords) / 2 + act_obj->coords.x1;
-                break;
-            case LV_SCROLL_SNAP_START:
-                snap_point = scroll_obj->coords.x1 + pad_left;
-                act_obj_point = act_obj->coords.x1;
-                break;
-            case LV_SCROLL_SNAP_END:
-                snap_point = scroll_obj->coords.x2 - pad_right;
-                act_obj_point = act_obj->coords.x2;
-                break;
+                case LV_SCROLL_SNAP_CENTER:
+                    snap_point = pad_left + (lv_area_get_width(&scroll_obj->coords) - pad_left - pad_right) / 2 + scroll_obj->coords.x1;
+                    act_obj_point = lv_area_get_width(&act_obj->coords) / 2 + act_obj->coords.x1;
+                    break;
+                case LV_SCROLL_SNAP_START:
+                    snap_point = scroll_obj->coords.x1 + pad_left;
+                    act_obj_point = act_obj->coords.x1;
+                    break;
+                case LV_SCROLL_SNAP_END:
+                    snap_point = scroll_obj->coords.x2 - pad_right;
+                    act_obj_point = act_obj->coords.x2;
+                    break;
             }
-        } else {
+        }
+        else {
             lv_coord_t pad_top = lv_obj_get_style_pad_top(scroll_obj, LV_PART_MAIN);
             lv_coord_t pad_bottom = lv_obj_get_style_pad_bottom(scroll_obj, LV_PART_MAIN);
 
             switch(snap) {
-            case LV_SCROLL_SNAP_CENTER:
-                snap_point = pad_top + (lv_area_get_height(&scroll_obj->coords) - pad_top - pad_bottom) / 2 + scroll_obj->coords.y1;
-                act_obj_point = lv_area_get_height(&act_obj->coords) / 2 + act_obj->coords.y1;
-                break;
-            case LV_SCROLL_SNAP_START:
-                snap_point = scroll_obj->coords.y1 + pad_top;
-                act_obj_point = act_obj->coords.y1;
-                break;
-            case LV_SCROLL_SNAP_END:
-                snap_point = scroll_obj->coords.y2 - pad_bottom;
-                act_obj_point = act_obj->coords.y2;
-                break;
+                case LV_SCROLL_SNAP_CENTER:
+                    snap_point = pad_top + (lv_area_get_height(&scroll_obj->coords) - pad_top - pad_bottom) / 2 + scroll_obj->coords.y1;
+                    act_obj_point = lv_area_get_height(&act_obj->coords) / 2 + act_obj->coords.y1;
+                    break;
+                case LV_SCROLL_SNAP_START:
+                    snap_point = scroll_obj->coords.y1 + pad_top;
+                    act_obj_point = act_obj->coords.y1;
+                    break;
+                case LV_SCROLL_SNAP_END:
+                    snap_point = scroll_obj->coords.y2 - pad_bottom;
+                    act_obj_point = act_obj->coords.y2;
+                    break;
             }
         }
 
@@ -629,7 +634,8 @@ static lv_coord_t elastic_diff(lv_obj_t * scroll_obj, lv_coord_t diff, lv_coord_
             if(diff > 0) diff += ELASTIC_SLOWNESS_FACTOR / 2;
             return diff / ELASTIC_SLOWNESS_FACTOR;
         }
-    } else {
+    }
+    else {
         /*Scroll back to the boundary if required*/
         if(scroll_end + diff < 0) diff = - scroll_end;
         if(scroll_start - diff < 0) diff = scroll_start;
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj.c b/lib/libesp32_lvgl/lvgl/src/core/lv_obj.c
index 5066456df..8acf874d1 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj.c
@@ -35,6 +35,10 @@
     #include "../gpu/lv_gpu_nxp_pxp_osa.h"
 #endif
 
+#if LV_USE_GPU_SDL
+    #include "../gpu/lv_gpu_sdl.h"
+#endif
+
 /*********************
  *      DEFINES
  *********************/
@@ -84,6 +88,11 @@ const lv_obj_class_t lv_obj_class = {
  *   GLOBAL FUNCTIONS
  **********************/
 
+bool lv_is_initialized(void)
+{
+    return lv_initialized;
+}
+
 void lv_init(void)
 {
     /*Do nothing if already initialized*/
@@ -116,6 +125,9 @@ void lv_init(void)
         for(; ;) ;
     }
 #endif
+#if LV_USE_GPU_SDL
+    lv_gpu_sdl_init();
+#endif
 
     _lv_obj_style_init();
     _lv_ll_init(&LV_GC_ROOT(_lv_disp_ll), sizeof(lv_disp_t));
@@ -133,29 +145,36 @@ void lv_init(void)
 
     uint8_t * txt_u8 = (uint8_t *)txt;
     if(txt_u8[0] != 0xc3 || txt_u8[1] != 0x81 || txt_u8[2] != 0x00) {
-        LV_LOG_WARN("The strings has no UTF-8 encoding. Non-ASCII characters won't be displayed.")
+        LV_LOG_WARN("The strings has no UTF-8 encoding. Non-ASCII characters won't be displayed.");
     }
 
     uint32_t endianess_test = 0x11223344;
-    uint8_t * endianess_test_p = (uint8_t*) &endianess_test;
+    uint8_t * endianess_test_p = (uint8_t *) &endianess_test;
     bool big_endian = endianess_test_p[0] == 0x11 ? true : false;
 
     if(big_endian) {
-        LV_ASSERT_MSG(LV_BIG_ENDIAN_SYSTEM == 1, "It's a big endian system but LV_BIG_ENDIAN_SYSTEM is not enabled in lv_conf.h");
-    } else {
-        LV_ASSERT_MSG(LV_BIG_ENDIAN_SYSTEM == 0, "It's a little endian system but LV_BIG_ENDIAN_SYSTEM is enabled in lv_conf.h");
+        LV_ASSERT_MSG(LV_BIG_ENDIAN_SYSTEM == 1,
+                      "It's a big endian system but LV_BIG_ENDIAN_SYSTEM is not enabled in lv_conf.h");
+    }
+    else {
+        LV_ASSERT_MSG(LV_BIG_ENDIAN_SYSTEM == 0,
+                      "It's a little endian system but LV_BIG_ENDIAN_SYSTEM is enabled in lv_conf.h");
     }
 
 #if LV_USE_ASSERT_MEM_INTEGRITY
-    LV_LOG_WARN("Memory integrity checks are enabled via LV_USE_ASSERT_MEM_INTEGRITY which makes LVGL much slower")
+    LV_LOG_WARN("Memory integrity checks are enabled via LV_USE_ASSERT_MEM_INTEGRITY which makes LVGL much slower");
 #endif
 
 #if LV_USE_ASSERT_OBJ
-    LV_LOG_WARN("Object sanity checks are enabled via LV_USE_ASSERT_OBJ which makes LVGL much slower")
+    LV_LOG_WARN("Object sanity checks are enabled via LV_USE_ASSERT_OBJ which makes LVGL much slower");
+#endif
+
+#if LV_USE_ASSERT_STYLE
+    LV_LOG_WARN("Style sanity checks are enabled that uses more RAM");
 #endif
 
 #if LV_LOG_LEVEL == LV_LOG_LEVEL_TRACE
-    LV_LOG_WARN("Log level is set the Trace which makes LVGL much slower")
+    LV_LOG_WARN("Log level is set the Trace which makes LVGL much slower");
 #endif
 
     lv_extra_init();
@@ -165,10 +184,13 @@ void lv_init(void)
     LV_LOG_TRACE("finished");
 }
 
-#if LV_ENABLE_GC || !LV_MEM_CUSTOM
+#if LV_ENABLE_GC || !LV_MEM_CUSTOM || LV_USE_GPU_SDL
 
 void lv_deinit(void)
 {
+#if LV_USE_GPU_SDL
+    lv_gpu_sdl_deinit();
+#endif
     _lv_gc_clear_roots();
 
     lv_disp_set_default(NULL);
@@ -185,7 +207,7 @@ void lv_deinit(void)
 
 lv_obj_t * lv_obj_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -216,6 +238,13 @@ void lv_obj_add_flag(lv_obj_t * obj, lv_obj_flag_t f)
     if((was_on_layout != lv_obj_is_layout_positioned(obj)) || (f & (LV_OBJ_FLAG_LAYOUT_1 |  LV_OBJ_FLAG_LAYOUT_2))) {
         lv_obj_mark_layout_as_dirty(lv_obj_get_parent(obj));
     }
+
+    if(f & LV_OBJ_FLAG_SCROLLABLE) {
+        lv_area_t hor_area, ver_area;
+        lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
+        lv_obj_invalidate_area(obj, &hor_area);
+        lv_obj_invalidate_area(obj, &ver_area);
+    }
 }
 
 void lv_obj_clear_flag(lv_obj_t * obj, lv_obj_flag_t f)
@@ -223,6 +252,12 @@ void lv_obj_clear_flag(lv_obj_t * obj, lv_obj_flag_t f)
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
     bool was_on_layout = lv_obj_is_layout_positioned(obj);
+    if(f & LV_OBJ_FLAG_SCROLLABLE) {
+        lv_area_t hor_area, ver_area;
+        lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
+        lv_obj_invalidate_area(obj, &hor_area);
+        lv_obj_invalidate_area(obj, &ver_area);
+    }
 
     obj->flags &= (~f);
 
@@ -381,7 +416,7 @@ static void lv_obj_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 
     /*Set attributes*/
     obj->flags = LV_OBJ_FLAG_CLICKABLE;
-    obj->flags |= LV_OBJ_FLAG_SNAPABLE;
+    obj->flags |= LV_OBJ_FLAG_SNAPPABLE;
     if(parent) obj->flags |= LV_OBJ_FLAG_PRESS_LOCK;
     if(parent) obj->flags |= LV_OBJ_FLAG_SCROLL_CHAIN;
     obj->flags |= LV_OBJ_FLAG_CLICK_FOCUSABLE;
@@ -451,7 +486,7 @@ static void lv_obj_draw(lv_event_t * e)
 
         if(_lv_area_is_in(info->area, &coords, r) == false) {
             info->res = LV_COVER_RES_NOT_COVER;
-           return;
+            return;
         }
 
         if(lv_obj_get_style_bg_opa(obj, LV_PART_MAIN) < LV_OPA_MAX) {
@@ -493,15 +528,29 @@ static void lv_obj_draw(lv_event_t * e)
         coords.y1 -= h;
         coords.y2 += h;
 
+        lv_obj_draw_part_dsc_t part_dsc;
+        lv_obj_draw_dsc_init(&part_dsc, clip_area);
+        part_dsc.class_p = MY_CLASS;
+        part_dsc.type = LV_OBJ_DRAW_PART_RECTANGLE;
+        part_dsc.rect_dsc = &draw_dsc;
+        part_dsc.draw_area = &coords;
+        part_dsc.part = LV_PART_MAIN;
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_dsc);
+
         lv_draw_rect(&coords, clip_area, &draw_dsc);
 
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_dsc);
+
 #if LV_DRAW_COMPLEX
         if(lv_obj_get_style_clip_corner(obj, LV_PART_MAIN)) {
-            lv_draw_mask_radius_param_t * mp = lv_mem_buf_get(sizeof(lv_draw_mask_radius_param_t));
+            /*If the radius is 0 the parent's coordinates will clip anyway*/
             lv_coord_t r = lv_obj_get_style_radius(obj, LV_PART_MAIN);
-            lv_draw_mask_radius_init(mp, &obj->coords, r, false);
-            /*Add the mask and use `obj+8` as custom id. Don't use `obj` directly because it might be used by the user*/
-            lv_draw_mask_add(mp, obj + 8);
+            if(r != 0) {
+                lv_draw_mask_radius_param_t * mp = lv_mem_buf_get(sizeof(lv_draw_mask_radius_param_t));
+                lv_draw_mask_radius_init(mp, &obj->coords, r, false);
+                /*Add the mask and use `obj+8` as custom id. Don't use `obj` directly because it might be used by the user*/
+                lv_draw_mask_add(mp, obj + 8);
+            }
         }
 #endif
     }
@@ -512,7 +561,10 @@ static void lv_obj_draw(lv_event_t * e)
 #if LV_DRAW_COMPLEX
         if(lv_obj_get_style_clip_corner(obj, LV_PART_MAIN)) {
             lv_draw_mask_radius_param_t * param = lv_draw_mask_remove_custom(obj + 8);
-            lv_mem_buf_release(param);
+            if(param) {
+                lv_draw_mask_free_param(param);
+                lv_mem_buf_release(param);
+            }
         }
 #endif
 
@@ -523,6 +575,7 @@ static void lv_obj_draw(lv_event_t * e)
             draw_dsc.bg_opa = LV_OPA_TRANSP;
             draw_dsc.outline_opa = LV_OPA_TRANSP;
             draw_dsc.shadow_opa = LV_OPA_TRANSP;
+            draw_dsc.bg_img_opa = LV_OPA_TRANSP;
             lv_obj_init_draw_rect_dsc(obj, LV_PART_MAIN, &draw_dsc);
 
             lv_coord_t w = lv_obj_get_style_transform_width(obj, LV_PART_MAIN);
@@ -533,7 +586,18 @@ static void lv_obj_draw(lv_event_t * e)
             coords.x2 += w;
             coords.y1 -= h;
             coords.y2 += h;
+
+            lv_obj_draw_part_dsc_t part_dsc;
+            lv_obj_draw_dsc_init(&part_dsc, clip_area);
+            part_dsc.class_p = MY_CLASS;
+            part_dsc.type = LV_OBJ_DRAW_PART_BORDER_POST;
+            part_dsc.rect_dsc = &draw_dsc;
+            part_dsc.draw_area = &coords;
+            part_dsc.part = LV_PART_MAIN;
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_dsc);
+
             lv_draw_rect(&coords, clip_area, &draw_dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_dsc);
         }
     }
 }
@@ -551,8 +615,25 @@ static void draw_scrollbar(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_res_t sb_res = scrollbar_init_draw_dsc(obj, &draw_dsc);
     if(sb_res != LV_RES_OK) return;
 
-    if(lv_area_get_size(&hor_area) > 0) lv_draw_rect(&hor_area, clip_area, &draw_dsc);
-    if(lv_area_get_size(&ver_area) > 0) lv_draw_rect(&ver_area, clip_area, &draw_dsc);
+    lv_obj_draw_part_dsc_t part_dsc;
+    lv_obj_draw_dsc_init(&part_dsc, clip_area);
+    part_dsc.class_p = MY_CLASS;
+    part_dsc.type = LV_OBJ_DRAW_PART_SCROLLBAR;
+    part_dsc.rect_dsc = &draw_dsc;
+    part_dsc.part = LV_PART_SCROLLBAR;
+
+    if(lv_area_get_size(&hor_area) > 0) {
+        part_dsc.draw_area = &hor_area;
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_dsc);
+        lv_draw_rect(&hor_area, clip_area, &draw_dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_dsc);
+    }
+    if(lv_area_get_size(&ver_area) > 0) {
+        part_dsc.draw_area = &ver_area;
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_dsc);
+        lv_draw_rect(&ver_area, clip_area, &draw_dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_dsc);
+    }
 }
 
 /**
@@ -574,7 +655,8 @@ static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc
         dsc->border_width = lv_obj_get_style_border_width(obj, LV_PART_SCROLLBAR);
         if(dsc->border_width > 0) {
             dsc->border_color = lv_obj_get_style_border_color(obj, LV_PART_SCROLLBAR);
-        } else {
+        }
+        else {
             dsc->border_opa = LV_OPA_TRANSP;
         }
     }
@@ -586,7 +668,8 @@ static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc
         if(dsc->shadow_width > 0) {
             dsc->shadow_spread = lv_obj_get_style_shadow_spread(obj, LV_PART_SCROLLBAR);
             dsc->shadow_color = lv_obj_get_style_shadow_color(obj, LV_PART_SCROLLBAR);
-        } else {
+        }
+        else {
             dsc->shadow_opa = LV_OPA_TRANSP;
         }
     }
@@ -598,10 +681,11 @@ static lv_res_t scrollbar_init_draw_dsc(lv_obj_t * obj, lv_draw_rect_dsc_t * dsc
         dsc->shadow_opa = (dsc->bg_opa * opa) >> 8;
     }
 
-    if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP || dsc->shadow_opa != LV_OPA_TRANSP ) {
+    if(dsc->bg_opa != LV_OPA_TRANSP || dsc->border_opa != LV_OPA_TRANSP || dsc->shadow_opa != LV_OPA_TRANSP) {
         dsc->radius = lv_obj_get_style_radius(obj, LV_PART_SCROLLBAR);
         return LV_RES_OK;
-    } else {
+    }
+    else {
         return LV_RES_INV;
     }
 #else
@@ -657,6 +741,34 @@ static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e)
                 if(res != LV_RES_OK) return;
             }
         }
+        else if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLLABLE) && !lv_obj_is_editable(obj)) {
+            /*scroll by keypad or encoder*/
+            lv_anim_enable_t anim_enable = LV_ANIM_OFF;
+            lv_coord_t sl = lv_obj_get_scroll_left(obj);
+            lv_coord_t sr = lv_obj_get_scroll_right(obj);
+            char c = *((char *)lv_event_get_param(e));
+            if(c == LV_KEY_DOWN) {
+                /*use scroll_to_x/y functions to enforce scroll limits*/
+                lv_obj_scroll_to_y(obj, lv_obj_get_scroll_y(obj) + lv_obj_get_height(obj) / 4, anim_enable);
+            }
+            else if(c == LV_KEY_UP) {
+                lv_obj_scroll_to_y(obj, lv_obj_get_scroll_y(obj) - lv_obj_get_height(obj) / 4, anim_enable);
+            }
+            else if(c == LV_KEY_RIGHT) {
+                /*If the object can't be scrolled horizontally then scroll it vertically*/
+                if(!((lv_obj_get_scroll_dir(obj) & LV_DIR_HOR) && (sl > 0 || sr > 0)))
+                    lv_obj_scroll_to_y(obj, lv_obj_get_scroll_y(obj) + lv_obj_get_height(obj) / 4, anim_enable);
+                else
+                    lv_obj_scroll_to_x(obj, lv_obj_get_scroll_x(obj) + lv_obj_get_width(obj) / 4, anim_enable);
+            }
+            else if(c == LV_KEY_LEFT) {
+                /*If the object can't be scrolled horizontally then scroll it vertically*/
+                if(!((lv_obj_get_scroll_dir(obj) & LV_DIR_HOR) && (sl > 0 || sr > 0)))
+                    lv_obj_scroll_to_y(obj, lv_obj_get_scroll_y(obj) - lv_obj_get_height(obj) / 4, anim_enable);
+                else
+                    lv_obj_scroll_to_x(obj, lv_obj_get_scroll_x(obj) - lv_obj_get_width(obj) / 4, anim_enable);
+            }
+        }
     }
     else if(code == LV_EVENT_FOCUSED) {
         if(lv_obj_has_flag(obj, LV_OBJ_FLAG_SCROLL_ON_FOCUS)) {
@@ -689,6 +801,12 @@ static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e)
     }
     else if(code == LV_EVENT_SCROLL_END) {
         lv_obj_clear_state(obj, LV_STATE_SCROLLED);
+        if(lv_obj_get_scrollbar_mode(obj) == LV_SCROLLBAR_MODE_ACTIVE) {
+            lv_area_t hor_area, ver_area;
+            lv_obj_get_scrollbar_area(obj, &hor_area, &ver_area);
+            lv_obj_invalidate_area(obj, &hor_area);
+            lv_obj_invalidate_area(obj, &ver_area);
+        }
     }
     else if(code == LV_EVENT_DEFOCUSED) {
         lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED | LV_STATE_FOCUS_KEY);
@@ -701,8 +819,9 @@ static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e)
         }
 
         uint32_t i;
-        for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-            lv_obj_t * child = lv_obj_get_child(obj, i);
+        uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+        for(i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = obj->spec_attr->children[i];
             lv_obj_mark_layout_as_dirty(child);
         }
     }
@@ -715,11 +834,6 @@ static void lv_obj_event(const lv_obj_class_t * class_p, lv_event_t * e)
             lv_obj_mark_layout_as_dirty(obj);
         }
     }
-    else if(code == LV_EVENT_SCROLL_END) {
-        if(lv_obj_get_scrollbar_mode(obj) == LV_SCROLLBAR_MODE_ACTIVE) {
-            lv_obj_invalidate(obj);
-        }
-    }
     else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
         lv_coord_t * s = lv_event_get_param(e);
         lv_coord_t d = lv_obj_calculate_ext_draw_size(obj, LV_PART_MAIN);
@@ -790,7 +904,7 @@ static void lv_obj_set_state(lv_obj_t * obj, lv_state_t new_state)
         }
     }
 
-    for(i = 0;i < tsi; i++) {
+    for(i = 0; i < tsi; i++) {
         lv_part_t part_act = lv_obj_style_get_selector_part(ts[i].selector);
         _lv_obj_style_create_transition(obj, part_act, prev_state, new_state, &ts[i]);
     }
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj.h b/lib/libesp32_lvgl/lvgl/src/core/lv_obj.h
index ccd0e5139..c92ffde8f 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj.h
@@ -71,7 +71,7 @@ enum {
     LV_PART_INDICATOR    = 0x020000,   /**< Indicator, e.g. for slider, bar, switch, or the tick box of the checkbox*/
     LV_PART_KNOB         = 0x030000,   /**< Like handle to grab to adjust the value*/
     LV_PART_SELECTED     = 0x040000,   /**< Indicate the currently selected option or section*/
-    LV_PART_ITEMS        = 0x050000,   /**< Used if the widget has multiple similar elements (e.g. tabel cells)*/
+    LV_PART_ITEMS        = 0x050000,   /**< Used if the widget has multiple similar elements (e.g. table cells)*/
     LV_PART_TICKS        = 0x060000,   /**< Ticks on scale e.g. for a chart or meter*/
     LV_PART_CURSOR       = 0x070000,   /**< Mark a specific place e.g. for text area's cursor or on a chart*/
 
@@ -87,37 +87,46 @@ typedef uint32_t lv_part_t;
  * OR-ed values are possible
  */
 enum {
-    LV_OBJ_FLAG_HIDDEN          = (1 << 0),  /**< Make the object hidden. (Like it wasn't there at all)*/
-    LV_OBJ_FLAG_CLICKABLE       = (1 << 1),  /**< Make the object clickable by the input devices*/
-    LV_OBJ_FLAG_CLICK_FOCUSABLE = (1 << 2),  /**< Add focused state to the object when clicked*/
-    LV_OBJ_FLAG_CHECKABLE       = (1 << 3),  /**< Toggle checked state when the object is clicked*/
-    LV_OBJ_FLAG_SCROLLABLE      = (1 << 4),  /**< Make the object scrollable*/
-    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1 << 5),  /**< Allow scrolling inside but with slower speed*/
-    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1 << 6),  /**< Make the object scroll further when "thrown"*/
-    LV_OBJ_FLAG_SCROLL_ONE      = (1 << 7),   /**< Allow scrolling only one snapable children*/
-    LV_OBJ_FLAG_SCROLL_CHAIN    = (1 << 8),  /**< Allow propagating the scroll to a parent*/
-    LV_OBJ_FLAG_SCROLL_ON_FOCUS = (1 << 9),  /**< Automatically scroll object to make it visible when focused*/
-    LV_OBJ_FLAG_SNAPABLE        = (1 << 10), /**< If scroll snap is enabled on the parent it can snap to this object*/
-    LV_OBJ_FLAG_PRESS_LOCK      = (1 << 11), /**< Keep the object pressed even if the press slid from the object*/
-    LV_OBJ_FLAG_EVENT_BUBBLE    = (1 << 12), /**< Propagate the events to the parent too*/
-    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1 << 13), /**< Propagate the gestures to the parent*/
-    LV_OBJ_FLAG_ADV_HITTEST     = (1 << 14), /**< Allow performing more accurate hit (click) test. E.g. consider rounded corners.*/
-    LV_OBJ_FLAG_IGNORE_LAYOUT   = (1 << 15), /**< Make the object position-able by the layouts*/
-    LV_OBJ_FLAG_FLOATING        = (1 << 16), /**< Do not scroll the object when the parent scrolls and ignore layout*/
+    LV_OBJ_FLAG_HIDDEN          = (1L << 0),  /**< Make the object hidden. (Like it wasn't there at all)*/
+    LV_OBJ_FLAG_CLICKABLE       = (1L << 1),  /**< Make the object clickable by the input devices*/
+    LV_OBJ_FLAG_CLICK_FOCUSABLE = (1L << 2),  /**< Add focused state to the object when clicked*/
+    LV_OBJ_FLAG_CHECKABLE       = (1L << 3),  /**< Toggle checked state when the object is clicked*/
+    LV_OBJ_FLAG_SCROLLABLE      = (1L << 4),  /**< Make the object scrollable*/
+    LV_OBJ_FLAG_SCROLL_ELASTIC  = (1L << 5),  /**< Allow scrolling inside but with slower speed*/
+    LV_OBJ_FLAG_SCROLL_MOMENTUM = (1L << 6),  /**< Make the object scroll further when "thrown"*/
+    LV_OBJ_FLAG_SCROLL_ONE      = (1L << 7),  /**< Allow scrolling only one snappable children*/
+    LV_OBJ_FLAG_SCROLL_CHAIN    = (1L << 8),  /**< Allow propagating the scroll to a parent*/
+    LV_OBJ_FLAG_SCROLL_ON_FOCUS = (1L << 9),  /**< Automatically scroll object to make it visible when focused*/
+    LV_OBJ_FLAG_SNAPPABLE       = (1L << 10), /**< If scroll snap is enabled on the parent it can snap to this object*/
+    LV_OBJ_FLAG_PRESS_LOCK      = (1L << 11), /**< Keep the object pressed even if the press slid from the object*/
+    LV_OBJ_FLAG_EVENT_BUBBLE    = (1L << 12), /**< Propagate the events to the parent too*/
+    LV_OBJ_FLAG_GESTURE_BUBBLE  = (1L << 13), /**< Propagate the gestures to the parent*/
+    LV_OBJ_FLAG_ADV_HITTEST     = (1L << 14), /**< Allow performing more accurate hit (click) test. E.g. consider rounded corners.*/
+    LV_OBJ_FLAG_IGNORE_LAYOUT   = (1L << 15), /**< Make the object position-able by the layouts*/
+    LV_OBJ_FLAG_FLOATING        = (1L << 16), /**< Do not scroll the object when the parent scrolls and ignore layout*/
 
-    LV_OBJ_FLAG_LAYOUT_1        = (1 << 23), /** Custom flag, free to use by layouts*/
-    LV_OBJ_FLAG_LAYOUT_2        = (1 << 24), /** Custom flag, free to use by layouts*/
+    LV_OBJ_FLAG_LAYOUT_1        = (1L << 23), /**< Custom flag, free to use by layouts*/
+    LV_OBJ_FLAG_LAYOUT_2        = (1L << 24), /**< Custom flag, free to use by layouts*/
 
-    LV_OBJ_FLAG_WIDGET_1        = (1 << 25), /** Custom flag, free to use by widget*/
-    LV_OBJ_FLAG_WIDGET_2        = (1 << 26), /** Custom flag, free to use by widget*/
-
-    LV_OBJ_FLAG_USER_1          = (1 << 27), /** Custom flag, free to use by user*/
-    LV_OBJ_FLAG_USER_2          = (1 << 28), /** Custom flag, free to use by user*/
-    LV_OBJ_FLAG_USER_3          = (1 << 29), /** Custom flag, free to use by user*/
-    LV_OBJ_FLAG_USER_4          = (1 << 30), /** Custom flag, free to use by user*/
+    LV_OBJ_FLAG_WIDGET_1        = (1L << 25), /**< Custom flag, free to use by widget*/
+    LV_OBJ_FLAG_WIDGET_2        = (1L << 26), /**< Custom flag, free to use by widget*/
+    LV_OBJ_FLAG_USER_1          = (1L << 27), /**< Custom flag, free to use by user*/
+    LV_OBJ_FLAG_USER_2          = (1L << 28), /**< Custom flag, free to use by user*/
+    LV_OBJ_FLAG_USER_3          = (1L << 29), /**< Custom flag, free to use by user*/
+    LV_OBJ_FLAG_USER_4          = (1L << 30), /**< Custom flag, free to use by user*/
 };
 typedef uint32_t lv_obj_flag_t;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_obj_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_OBJ_DRAW_PART_RECTANGLE,  /**< The main rectangle*/
+    LV_OBJ_DRAW_PART_BORDER_POST,/**< The border if style_border_post = true*/
+    LV_OBJ_DRAW_PART_SCROLLBAR,  /**< The scrollbar*/
+} lv_obj_draw_part_type_t;
+
 #include "lv_obj_tree.h"
 #include "lv_obj_pos.h"
 #include "lv_obj_scroll.h"
@@ -141,18 +150,18 @@ typedef struct {
     uint32_t child_cnt;                 /**< Number of children*/
     lv_group_t * group_p;
 
-    struct _lv_event_dsc_t * event_dsc;             /**< Dynamically allocated event callback and user data array*/
-    lv_point_t scroll;                      /**< The current X/Y scroll offset*/
+    struct _lv_event_dsc_t * event_dsc; /**< Dynamically allocated event callback and user data array*/
+    lv_point_t scroll;                  /**< The current X/Y scroll offset*/
 
-    lv_coord_t ext_click_pad;              /**< Extra click padding in all direction*/
+    lv_coord_t ext_click_pad;           /**< Extra click padding in all direction*/
     lv_coord_t ext_draw_size;           /**< EXTend the size in every direction for drawing.*/
 
-    lv_scrollbar_mode_t scrollbar_mode :2; /**< How to display scrollbars*/
-    lv_scroll_snap_t scroll_snap_x : 2;      /**< Where to align the snapable children horizontally*/
-    lv_scroll_snap_t scroll_snap_y : 2;      /**< Where to align the snapable children horizontally*/
-    lv_dir_t scroll_dir :4;                /**< The allowed scroll direction(s)*/
-    uint8_t event_dsc_cnt;           /**< Number of event callabcks stored in `event_cb` array*/
-}_lv_obj_spec_attr_t;
+    lv_scrollbar_mode_t scrollbar_mode : 2; /**< How to display scrollbars*/
+    lv_scroll_snap_t scroll_snap_x : 2;     /**< Where to align the snappable children horizontally*/
+    lv_scroll_snap_t scroll_snap_y : 2;     /**< Where to align the snappable children vertically*/
+    lv_dir_t scroll_dir : 4;                /**< The allowed scroll direction(s)*/
+    uint8_t event_dsc_cnt;                  /**< Number of event callbacks stored in `event_dsc` array*/
+} _lv_obj_spec_attr_t;
 
 typedef struct _lv_obj_t {
     const lv_obj_class_t * class_p;
@@ -165,13 +174,13 @@ typedef struct _lv_obj_t {
     lv_area_t coords;
     lv_obj_flag_t flags;
     lv_state_t state;
-    uint16_t layout_inv :1;
-    uint16_t scr_layout_inv :1;
-    uint16_t skip_trans :1;
-    uint16_t style_cnt  :6;
-    uint16_t h_layout   :1;
-    uint16_t w_layout   :1;
-}lv_obj_t;
+    uint16_t layout_inv : 1;
+    uint16_t scr_layout_inv : 1;
+    uint16_t skip_trans : 1;
+    uint16_t style_cnt  : 6;
+    uint16_t h_layout   : 1;
+    uint16_t w_layout   : 1;
+} lv_obj_t;
 
 
 /**********************
@@ -184,7 +193,7 @@ typedef struct _lv_obj_t {
  */
 void lv_init(void);
 
-#if LV_ENABLE_GC || !LV_MEM_CUSTOM
+#if LV_ENABLE_GC || !LV_MEM_CUSTOM || LV_USE_GPU_SDL
 
 /**
  * Deinit the 'lv' library
@@ -194,10 +203,15 @@ void lv_deinit(void);
 
 #endif
 
+/**
+ * Returns whether the 'lv' library is currently initialized
+ */
+bool lv_is_initialized(void);
+
 /**
  * Create a base object (a rectangle)
  * @param parent    pointer to a parent object. If NULL then a screen will be created.
- * @return pointer to the new object
+ * @return          pointer to the new object
  */
 lv_obj_t * lv_obj_create(lv_obj_t * parent);
 
@@ -314,10 +328,10 @@ static inline void * lv_obj_get_user_data(lv_obj_t * obj)
 void lv_obj_allocate_spec_attr(lv_obj_t * obj);
 
 /**
- * Get object's and its ancestors type. Put their name in `type_buf` starting with the current type.
- * E.g. buf.type[0]="lv_btn", buf.type[1]="lv_cont", buf.type[2]="lv_obj"
- * @param obj   pointer to an object which type should be get
- * @param buf   pointer to an `lv_obj_type_t` buffer to store the types
+ * Check the type of obj.
+ * @param obj       pointer to an object
+ * @param class_p   a class to check (e.g. `lv_slider_class`)
+ * @return          true: `class_p` is the `obj` class.
  */
 bool lv_obj_check_type(const lv_obj_t * obj, const lv_obj_class_t * class_p);
 
@@ -332,15 +346,14 @@ bool lv_obj_has_class(const lv_obj_t * obj, const lv_obj_class_t * class_p);
 
 /**
  * Get the class (type) of the object
- * @param obj       pointer to an object
- * @return the class (type) of the object
+ * @param obj   pointer to an object
+ * @return      the class (type) of the object
  */
 const lv_obj_class_t * lv_obj_get_class(const lv_obj_t * obj);
 
 /**
- * Check if any object is still "alive", and part of the hierarchy
+ * Check if any object is still "alive".
  * @param obj       pointer to an object
- * @param obj_type  type of the object. (e.g. "lv_btn")
  * @return          true: valid
  */
 bool lv_obj_is_valid(const lv_obj_t * obj);
@@ -365,16 +378,16 @@ static inline lv_coord_t lv_obj_dpx(const lv_obj_t * obj, lv_coord_t n)
 
 #if LV_USE_ASSERT_OBJ
 #  define LV_ASSERT_OBJ(obj_p, obj_class)                                    \
-            LV_ASSERT_MSG(obj_p != NULL, "The object is NULL");               \
-            LV_ASSERT_MSG(lv_obj_has_class(obj_p, obj_class) == true, "Incompatible object type."); \
-            LV_ASSERT_MSG(lv_obj_is_valid(obj_p)  == true, "The object is invalid, deleted or corrupted?");
+    LV_ASSERT_MSG(obj_p != NULL, "The object is NULL");               \
+    LV_ASSERT_MSG(lv_obj_has_class(obj_p, obj_class) == true, "Incompatible object type."); \
+    LV_ASSERT_MSG(lv_obj_is_valid(obj_p)  == true, "The object is invalid, deleted or corrupted?");
 
 # else
 # define LV_ASSERT_OBJ(obj_p, obj_class) do{}while(0)
 #endif
 
 #if LV_USE_LOG && LV_LOG_TRACE_OBJ_CREATE
-#  define LV_TRACE_OBJ_CREATE(...) LV_LOG_TRACE( __VA_ARGS__)
+#  define LV_TRACE_OBJ_CREATE(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
 #  define LV_TRACE_OBJ_CREATE(...)
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_class.c b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_class.c
index 3837639ff..40538e0f1 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_class.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_class.c
@@ -42,7 +42,7 @@ static uint32_t get_instance_size(const lv_obj_class_t * class_p);
 
 lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * parent)
 {
-    LV_TRACE_OBJ_CREATE("Creating object with %p class on %p parent", class_p, parent);
+    LV_TRACE_OBJ_CREATE("Creating object with %p class on %p parent", (void *)class_p, (void *)parent);
     uint32_t s = get_instance_size(class_p);
     lv_obj_t * obj = lv_mem_alloc(s);
     if(obj == NULL) return NULL;
@@ -63,7 +63,8 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa
             disp->screens = lv_mem_alloc(sizeof(lv_obj_t *));
             disp->screens[0] = obj;
             disp->screen_cnt = 1;
-        } else {
+        }
+        else {
             disp->screen_cnt++;
             disp->screens = lv_mem_realloc(disp->screens, sizeof(lv_obj_t *) * disp->screen_cnt);
             disp->screens[disp->screen_cnt - 1] = obj;
@@ -87,9 +88,11 @@ lv_obj_t * lv_obj_class_create_obj(const lv_obj_class_t * class_p, lv_obj_t * pa
             parent->spec_attr->children = lv_mem_alloc(sizeof(lv_obj_t *));
             parent->spec_attr->children[0] = obj;
             parent->spec_attr->child_cnt = 1;
-        } else {
+        }
+        else {
             parent->spec_attr->child_cnt++;
-            parent->spec_attr->children = lv_mem_realloc(parent->spec_attr->children, sizeof(lv_obj_t *) * parent->spec_attr->child_cnt);
+            parent->spec_attr->children = lv_mem_realloc(parent->spec_attr->children,
+                                                         sizeof(lv_obj_t *) * parent->spec_attr->child_cnt);
             parent->spec_attr->children[parent->spec_attr->child_cnt - 1] = obj;
         }
     }
@@ -120,6 +123,7 @@ void lv_obj_class_init_obj(lv_obj_t * obj)
         /*Call the ancestor's event handler to the parent to notify it about the new child.
          *Also triggers layout update*/
         lv_event_send(parent, LV_EVENT_CHILD_CHANGED, obj);
+        lv_event_send(parent, LV_EVENT_CHILD_CREATED, obj);
 
         /*Invalidate the area if not screen created*/
         lv_obj_invalidate(obj);
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_class.h b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_class.h
index 0bf0dad59..01a7248ba 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_class.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_class.h
@@ -33,13 +33,13 @@ typedef enum {
     LV_OBJ_CLASS_EDITABLE_INHERIT,      /**< Check the base class. Must have 0 value to let zero initialized class inherit*/
     LV_OBJ_CLASS_EDITABLE_TRUE,
     LV_OBJ_CLASS_EDITABLE_FALSE,
-}lv_obj_class_editable_t;
+} lv_obj_class_editable_t;
 
 typedef enum {
     LV_OBJ_CLASS_GROUP_DEF_INHERIT,      /**< Check the base class. Must have 0 value to let zero initialized class inherit*/
     LV_OBJ_CLASS_GROUP_DEF_TRUE,
     LV_OBJ_CLASS_GROUP_DEF_FALSE,
-}lv_obj_class_group_def_t;
+} lv_obj_class_group_def_t;
 
 typedef void (*lv_obj_class_event_cb_t)(struct _lv_obj_class_t * class_p, struct _lv_event_t * e);
 /**
@@ -53,13 +53,14 @@ typedef struct _lv_obj_class_t {
 #if LV_USE_USER_DATA
     void * user_data;
 #endif
-    void (*event_cb)(const struct _lv_obj_class_t * class_p, struct _lv_event_t * e);  /**< Widget type specific event function*/
+    void (*event_cb)(const struct _lv_obj_class_t * class_p,
+                     struct _lv_event_t * e);  /**< Widget type specific event function*/
     lv_coord_t width_def;
     lv_coord_t height_def;
     uint32_t editable : 2;             /**< Value from ::lv_obj_class_editable_t*/
     uint32_t group_def : 2;            /**< Value from ::lv_obj_class_group_def_t*/
     uint32_t instance_size : 16;
-}lv_obj_class_t;
+} lv_obj_class_t;
 
 /**********************
  * GLOBAL PROTOTYPES
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.c b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.c
index f0d50b60b..411135f30 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.c
@@ -84,7 +84,7 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint32_t part, lv_draw_rect_dsc_t
             draw_dsc->outline_opa = lv_obj_get_style_outline_opa(obj, part);
             if(draw_dsc->outline_opa > LV_OPA_MIN) {
                 draw_dsc->outline_pad = lv_obj_get_style_outline_pad(obj, part);
-                draw_dsc->outline_color = lv_obj_get_style_outline_color(obj, part);
+                draw_dsc->outline_color = lv_obj_get_style_outline_color_filtered(obj, part);
             }
         }
     }
@@ -95,10 +95,11 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint32_t part, lv_draw_rect_dsc_t
             draw_dsc->bg_img_opa = lv_obj_get_style_bg_img_opa(obj, part);
             if(draw_dsc->bg_img_opa > LV_OPA_MIN) {
                 if(lv_img_src_get_type(draw_dsc->bg_img_src) == LV_IMG_SRC_SYMBOL) {
-                    draw_dsc->bg_img_symbol_font= lv_obj_get_style_text_font(obj, part);
-                    draw_dsc->bg_img_recolor = lv_obj_get_style_text_color(obj, part);
-                } else {
-                    draw_dsc->bg_img_recolor = lv_obj_get_style_bg_img_recolor(obj, part);
+                    draw_dsc->bg_img_symbol_font = lv_obj_get_style_text_font(obj, part);
+                    draw_dsc->bg_img_recolor = lv_obj_get_style_text_color_filtered(obj, part);
+                }
+                else {
+                    draw_dsc->bg_img_recolor = lv_obj_get_style_bg_img_recolor_filtered(obj, part);
                     draw_dsc->bg_img_recolor_opa = lv_obj_get_style_bg_img_recolor_opa(obj, part);
                     draw_dsc->bg_img_tiled = lv_obj_get_style_bg_img_tiled(obj, part);
                 }
@@ -156,7 +157,7 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint32_t part, lv_draw_rect_dsc_t
             draw_dsc->outline_opa = lv_obj_get_style_outline_opa(obj, part);
             if(draw_dsc->outline_opa > LV_OPA_MIN) {
                 draw_dsc->outline_pad = lv_obj_get_style_outline_pad(obj, part);
-                draw_dsc->outline_color = lv_obj_get_style_outline_color(obj, part);
+                draw_dsc->outline_color = lv_obj_get_style_outline_color_filtered(obj, part);
             }
         }
     }
@@ -167,13 +168,14 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint32_t part, lv_draw_rect_dsc_t
             draw_dsc->bg_img_opa = lv_obj_get_style_bg_img_opa(obj, part);
             if(draw_dsc->bg_img_opa > LV_OPA_MIN) {
                 if(lv_img_src_get_type(draw_dsc->bg_img_src) == LV_IMG_SRC_SYMBOL) {
-                   draw_dsc->bg_img_symbol_font= lv_obj_get_style_text_font(obj, part);
-                   draw_dsc->bg_img_recolor = lv_obj_get_style_text_color(obj, part);
-               } else {
-                   draw_dsc->bg_img_recolor = lv_obj_get_style_bg_img_recolor(obj, part);
-                   draw_dsc->bg_img_recolor_opa = lv_obj_get_style_bg_img_recolor_opa(obj, part);
-                   draw_dsc->bg_img_tiled = lv_obj_get_style_bg_img_tiled(obj, part);
-               }
+                    draw_dsc->bg_img_symbol_font = lv_obj_get_style_text_font(obj, part);
+                    draw_dsc->bg_img_recolor = lv_obj_get_style_text_color_filtered(obj, part);
+                }
+                else {
+                    draw_dsc->bg_img_recolor = lv_obj_get_style_bg_img_recolor_filtered(obj, part);
+                    draw_dsc->bg_img_recolor_opa = lv_obj_get_style_bg_img_recolor_opa(obj, part);
+                    draw_dsc->bg_img_tiled = lv_obj_get_style_bg_img_tiled(obj, part);
+                }
             }
         }
     }
@@ -206,10 +208,6 @@ void lv_obj_init_draw_label_dsc(lv_obj_t * obj, uint32_t part, lv_draw_label_dsc
 #endif
 
     draw_dsc->align = lv_obj_get_style_text_align(obj, part);
-    if(draw_dsc->align == LV_TEXT_ALIGN_AUTO) {
-        if(draw_dsc->bidi_dir == LV_BASE_DIR_RTL) draw_dsc->align = LV_TEXT_ALIGN_RIGHT;
-        else draw_dsc->align = LV_TEXT_ALIGN_LEFT;
-    }
 }
 
 void lv_obj_init_draw_img_dsc(lv_obj_t * obj, uint32_t part, lv_draw_img_dsc_t * draw_dsc)
@@ -230,7 +228,7 @@ void lv_obj_init_draw_img_dsc(lv_obj_t * obj, uint32_t part, lv_draw_img_dsc_t *
 
     draw_dsc->recolor_opa = lv_obj_get_style_img_recolor_opa(obj, part);
     if(draw_dsc->recolor_opa > 0) {
-        draw_dsc->recolor = lv_obj_get_style_img_recolor(obj, part);
+        draw_dsc->recolor = lv_obj_get_style_img_recolor_filtered(obj, part);
     }
 #if LV_DRAW_COMPLEX
     draw_dsc->blend_mode = lv_obj_get_style_blend_mode(obj, part);
@@ -251,7 +249,7 @@ void lv_obj_init_draw_line_dsc(lv_obj_t * obj, uint32_t part, lv_draw_line_dsc_t
     }
     if(draw_dsc->opa <= LV_OPA_MIN)  return;
 
-    draw_dsc->color = lv_obj_get_style_line_color(obj, part);
+    draw_dsc->color = lv_obj_get_style_line_color_filtered(obj, part);
 
     draw_dsc->dash_width = lv_obj_get_style_line_dash_width(obj, part);
     if(draw_dsc->dash_width) {
@@ -280,7 +278,7 @@ void lv_obj_init_draw_arc_dsc(lv_obj_t * obj, uint32_t part, lv_draw_arc_dsc_t *
     }
     if(draw_dsc->opa <= LV_OPA_MIN)  return;
 
-    draw_dsc->color = lv_obj_get_style_arc_color(obj, part);
+    draw_dsc->color = lv_obj_get_style_arc_color_filtered(obj, part);
     draw_dsc->img_src = lv_obj_get_style_arc_img_src(obj, part);
 
     draw_dsc->rounded = lv_obj_get_style_arc_rounded(obj, part);
@@ -330,6 +328,12 @@ void lv_obj_draw_dsc_init(lv_obj_draw_part_dsc_t * dsc, const lv_area_t * clip_a
     dsc->clip_area = clip_area;
 }
 
+bool lv_obj_draw_part_check_type(lv_obj_draw_part_dsc_t * dsc, const lv_obj_class_t * class_p, uint32_t type)
+{
+    if(dsc->class_p == class_p && dsc->type == type) return true;
+    else return false;
+}
+
 void lv_obj_refresh_ext_draw_size(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.h b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.h
index 4858195e8..1a9e2e5c5 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.h
@@ -24,32 +24,41 @@ extern "C" {
  **********************/
 
 struct _lv_obj_t;
+struct _lv_obj_class_t;
 
 /** Cover check results.*/
 typedef enum {
     LV_COVER_RES_COVER      = 0,
     LV_COVER_RES_NOT_COVER  = 1,
     LV_COVER_RES_MASKED     = 2,
-}lv_cover_res_t;
+} lv_cover_res_t;
 
-typedef struct
-{
+typedef struct {
     const lv_area_t * clip_area;        /**< The current clip area, required if you need to draw something in the event*/
+    const struct _lv_obj_class_t * class_p;     /**< The class that sent the event */
+    uint32_t type;                      /**< The type if part being draw. Element of `lv_<name>_draw_part_type_t` */
     lv_area_t * draw_area;              /**< The area of the part being drawn*/
-    lv_draw_rect_dsc_t * rect_dsc;      /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for rectangle-like parts*/
-    lv_draw_label_dsc_t * label_dsc;    /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for text-like parts*/
-    lv_draw_line_dsc_t * line_dsc;      /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for line-like parts*/
-    lv_draw_img_dsc_t *  img_dsc;       /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for image-like parts*/
-    lv_draw_arc_dsc_t *  arc_dsc;       /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for arc-like parts*/
-    const lv_point_t * p1;              /**< A point calculated during drawing. E.g. a point of chart or the center of an arc.*/
+    lv_draw_rect_dsc_t *
+    rect_dsc;      /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for rectangle-like parts*/
+    lv_draw_label_dsc_t *
+    label_dsc;    /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for text-like parts*/
+    lv_draw_line_dsc_t *
+    line_dsc;      /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for line-like parts*/
+    lv_draw_img_dsc_t  *
+    img_dsc;       /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for image-like parts*/
+    lv_draw_arc_dsc_t  *
+    arc_dsc;       /**< A draw descriptor that can be modified to changed what LVGL will draw. Set only for arc-like parts*/
+    const lv_point_t *
+    p1;              /**< A point calculated during drawing. E.g. a point of chart or the center of an arc.*/
     const lv_point_t * p2;              /**< A point calculated during drawing. E.g. a point of chart.*/
-    char text[16];                      /**< A text calculated during drawing. Can be modified. E.g. tick labels on a chart axis.*/
+    char * text;                  /**< A text calculated during drawing. Can be modified. E.g. tick labels on a chart axis.*/
+    uint32_t text_length;               /**< Size of the text buffer containing null-terminated text string calculated during drawing.*/
     uint32_t part;                      /**< The current part for which the event is sent*/
     uint32_t id;                        /**< The index of the part. E.g. a button's index on button matrix or table cell index.*/
     lv_coord_t radius;                  /**< E.g. the radius of an arc (not the corner radius).*/
     int32_t value;                      /**< A value calculated during drawing. E.g. Chart's tick line value.*/
     const void * sub_part_ptr;          /**< A pointer the identifies something in the part. E.g. chart series. */
-}lv_obj_draw_part_dsc_t;
+} lv_obj_draw_part_dsc_t;
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -59,8 +68,8 @@ typedef struct
  * Initialize a rectangle draw descriptor from an object's styles in its current state
  * @param obj pointer to an object
  * @param part part of the object. E.g.  `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
- * @param draw_dsc the descriptor the initialize.
- *                 If an `..._opa` filed is set to `LV_OPA_TRANSP` the related properties won't be initialized.
+ * @param draw_dsc the descriptor to initialize.
+ *                 If an `..._opa` field is set to `LV_OPA_TRANSP` the related properties won't be initialized.
  *                 Should be initialized with `lv_draw_rect_dsc_init(draw_dsc)`.
  * @note Only the relevant fields will be set.
  *       E.g. if `border width == 0` the other border properties won't be evaluated.
@@ -71,8 +80,8 @@ void lv_obj_init_draw_rect_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_re
  * Initialize a label draw descriptor from an object's styles in its current state
  * @param obj pointer to an object
  * @param part part of the object. E.g.  `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
- * @param draw_dsc the descriptor the initialize.
- *                 If the `opa` filed is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
+ * @param draw_dsc the descriptor to initialize.
+ *                 If the `opa` field is set to or the property is equal to `LV_OPA_TRANSP` the rest won't be initialized.
  *                 Should be initialized with `lv_draw_label_dsc_init(draw_dsc)`.
  */
 void lv_obj_init_draw_label_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_label_dsc_t * draw_dsc);
@@ -81,7 +90,7 @@ void lv_obj_init_draw_label_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_l
  * Initialize an image draw descriptor from an object's styles in its current state
  * @param obj pointer to an object
  * @param part part of the object. E.g.  `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
- * @param draw_dsc the descriptor the initialize.
+ * @param draw_dsc the descriptor to initialize.
  *                 Should be initialized with `lv_draw_image_dsc_init(draw_dsc)`.
  */
 void lv_obj_init_draw_img_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_img_dsc_t * draw_dsc);
@@ -91,7 +100,7 @@ void lv_obj_init_draw_img_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_img
  * Initialize a line draw descriptor from an object's styles in its current state
  * @param obj pointer to an object
  * @param part part of the object. E.g.  `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
- * @param draw_dsc the descriptor the initialize.
+ * @param draw_dsc the descriptor to initialize.
  *                 Should be initialized with `lv_draw_line_dsc_init(draw_dsc)`.
  */
 void lv_obj_init_draw_line_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_line_dsc_t * draw_dsc);
@@ -100,7 +109,7 @@ void lv_obj_init_draw_line_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_li
  * Initialize an arc draw descriptor from an object's styles in its current state
  * @param obj pointer to an object
  * @param part part of the object. E.g.  `LV_PART_MAIN`, `LV_PART_SCROLLBAR`, `LV_PART_KNOB`, etc
- * @param draw_dsc the descriptor the initialize.
+ * @param draw_dsc the descriptor to initialize.
  *                 Should be initialized with `lv_draw_arc_dsc_init(draw_dsc)`.
  */
 void lv_obj_init_draw_arc_dsc(struct _lv_obj_t * obj, uint32_t part, lv_draw_arc_dsc_t * draw_dsc);
@@ -120,6 +129,15 @@ lv_coord_t lv_obj_calculate_ext_draw_size(struct _lv_obj_t * obj, uint32_t part)
  */
 void lv_obj_draw_dsc_init(lv_obj_draw_part_dsc_t * dsc, const lv_area_t * clip_area);
 
+/**
+ * Check the type obj a part draw descriptor
+ * @param dsc       the descriptor (normally the event parameter)
+ * @param class_p   pointer to class to which `type` is related
+ * @param type      element of `lv_<name>_draw_part_type_t`
+ * @return          true if ::dsc is related to ::class_p and ::type
+ */
+bool lv_obj_draw_part_check_type(lv_obj_draw_part_dsc_t * dsc, const struct _lv_obj_class_t * class_p, uint32_t type);
+
 /**
  * Send a 'LV_EVENT_REFR_EXT_DRAW_SIZE' Call the ancestor's event handler to the object to refresh the value of the extended draw size.
  * The result will be saved in `obj`.
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.c b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.c
index 50bbe41bb..4a8f23459 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.c
@@ -23,7 +23,8 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_out);
+static lv_coord_t calc_content_width(lv_obj_t * obj);
+static lv_coord_t calc_content_height(lv_obj_t * obj);
 static void layout_update_core(lv_obj_t * obj);
 
 /**********************
@@ -50,9 +51,6 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    if(lv_obj_is_layout_positioned(obj)) {
-        return;
-    }
 
     lv_res_t res_x;
     lv_style_value_t v_x;
@@ -66,9 +64,6 @@ void lv_obj_set_x(lv_obj_t * obj, lv_coord_t x)
 
 void lv_obj_set_y(lv_obj_t * obj, lv_coord_t y)
 {
-    if(lv_obj_is_layout_positioned(obj)) {
-        return;
-    }
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
     lv_res_t res_y;
@@ -91,51 +86,69 @@ bool lv_obj_refr_size(lv_obj_t * obj)
     lv_obj_t * parent = lv_obj_get_parent(obj);
     if(parent == NULL) return false;
 
-    lv_coord_t w;
     lv_coord_t sl_ori = lv_obj_get_scroll_left(obj);
-    bool w_content = false;
+    bool w_is_content = false;
+    bool w_is_pct = false;
+
+    lv_coord_t w;
     if(obj->w_layout) {
         w = lv_obj_get_width(obj);
-    } else {
+    }
+    else {
         w = lv_obj_get_style_width(obj, LV_PART_MAIN);
-        w_content = w == LV_SIZE_CONTENT ? true : false;
-
-        /*Be sure the object is not scrolled when it has auto size*/
-        if(w_content) {
-            lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
-            calc_auto_size(obj, &w, NULL);
-        }
-
-        /*Calculate the sizes in percentage*/
-        bool pct_w = LV_COORD_IS_PCT(w) ? true : false;
-
+        w_is_content = w == LV_SIZE_CONTENT ? true : false;
+        w_is_pct = LV_COORD_IS_PCT(w) ? true : false;
         lv_coord_t parent_w = lv_obj_get_content_width(parent);
-        if(pct_w) w = (LV_COORD_GET_PCT(w) * parent_w) / 100;
+
+        if(w_is_content) {
+            w = calc_content_width(obj);
+        }
+        else if(w_is_pct) {
+            /*If parent has content size and the child has pct size
+             *a circular dependency will occur. To solve it keep child size at zero */
+            if(parent->w_layout == 0 && lv_obj_get_style_width(parent, 0) == LV_SIZE_CONTENT) {
+                lv_coord_t border_w = lv_obj_get_style_border_width(obj, 0);
+                w = lv_obj_get_style_pad_left(obj, 0) + border_w;
+                w += lv_obj_get_style_pad_right(obj, 0) + border_w;
+            }
+            else {
+                w = (LV_COORD_GET_PCT(w) * parent_w) / 100;
+            }
+        }
 
         lv_coord_t minw = lv_obj_get_style_min_width(obj, LV_PART_MAIN);
         lv_coord_t maxw = lv_obj_get_style_max_width(obj, LV_PART_MAIN);
         w = lv_clamp_width(w, minw, maxw, parent_w);
     }
 
-    lv_coord_t h;
     lv_coord_t st_ori = lv_obj_get_scroll_top(obj);
-    bool h_content = false;
+    lv_coord_t h;
+    bool h_is_content = false;
+    bool h_is_pct = false;
     if(obj->h_layout) {
         h = lv_obj_get_height(obj);
-    } else {
+    }
+    else {
         h = lv_obj_get_style_height(obj, LV_PART_MAIN);
-        h_content = h == LV_SIZE_CONTENT ? true : false;
-
-        /*Be sure the object is not scrolled when it has auto size*/
-        if(h_content) {
-            lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
-            calc_auto_size(obj, NULL, &h);
-        }
-
-        /*Calculate the sizes in percentage*/
-        bool pct_h = LV_COORD_IS_PCT(h) ? true : false;
+        h_is_content = h == LV_SIZE_CONTENT ? true : false;
+        h_is_pct = LV_COORD_IS_PCT(h) ? true : false;
         lv_coord_t parent_h = lv_obj_get_content_height(parent);
-        if(pct_h) h = (LV_COORD_GET_PCT(h) * parent_h) / 100;
+
+        if(h_is_content) {
+            h = calc_content_height(obj);
+        }
+        else if(h_is_pct) {
+            /*If parent has content size and the child has pct size
+             *a circular dependency will occur. To solve it keep child size at zero */
+            if(parent->h_layout == 0 && lv_obj_get_style_height(parent, 0) == LV_SIZE_CONTENT) {
+                lv_coord_t border_w = lv_obj_get_style_border_width(obj, 0);
+                h = lv_obj_get_style_pad_top(obj, 0) + border_w;
+                h += lv_obj_get_style_pad_bottom(obj, 0) + border_w;
+            }
+            else {
+                h = (LV_COORD_GET_PCT(h) * parent_h) / 100;
+            }
+        }
 
         lv_coord_t minh = lv_obj_get_style_min_height(obj, LV_PART_MAIN);
         lv_coord_t maxh = lv_obj_get_style_max_height(obj, LV_PART_MAIN);
@@ -143,7 +156,7 @@ bool lv_obj_refr_size(lv_obj_t * obj)
     }
 
     /*calc_auto_size set the scroll x/y to 0 so revert the original value*/
-    if(w_content || h_content) {
+    if(w_is_content || h_is_content) {
         lv_obj_scroll_to(obj, sl_ori, st_ori, LV_ANIM_OFF);
     }
 
@@ -193,10 +206,6 @@ bool lv_obj_refr_size(lv_obj_t * obj)
     bool on2 = _lv_area_is_in(&obj->coords, &parent_fit_area, 0);
     if(on1 || (!on1 && on2)) lv_obj_scrollbar_invalidate(parent);
 
-
-
-
-
     return true;
 }
 
@@ -277,7 +286,7 @@ void lv_obj_mark_layout_as_dirty(lv_obj_t * obj)
 {
     obj->layout_inv = 1;
 
-    /*Mark the screen as dirty too to mark that there is an something to do on this screen*/
+    /*Mark the screen as dirty too to mark that there is something to do on this screen*/
     lv_obj_t * scr = lv_obj_get_screen(obj);
     scr->scr_layout_inv = 1;
 
@@ -290,7 +299,7 @@ void lv_obj_update_layout(const lv_obj_t * obj)
 {
     static bool mutex = false;
     if(mutex) {
-        LV_LOG_TRACE("Already running, returning")
+        LV_LOG_TRACE("Already running, returning");
         return;
     }
     mutex = true;
@@ -299,10 +308,10 @@ void lv_obj_update_layout(const lv_obj_t * obj)
 
     /*Repeat until there where layout invalidations*/
     while(scr->scr_layout_inv) {
-        LV_LOG_INFO("Layout update begin")
+        LV_LOG_INFO("Layout update begin");
         scr->scr_layout_inv = 0;
         layout_update_core(scr);
-        LV_LOG_TRACE("Layout update end")
+        LV_LOG_TRACE("Layout update end");
     }
 
     mutex = false;
@@ -357,110 +366,115 @@ void lv_obj_align_to(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv
     }
 
     switch(align) {
-    case LV_ALIGN_CENTER:
-        x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
-        y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
-        break;
-    case LV_ALIGN_TOP_LEFT:
-        x = bleft;
-        y = btop;
-        break;
-    case LV_ALIGN_TOP_MID:
-        x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
-        y = btop;
-        break;
+        case LV_ALIGN_CENTER:
+            x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
+            y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
+            break;
+        case LV_ALIGN_TOP_LEFT:
+            x = bleft;
+            y = btop;
+            break;
+        case LV_ALIGN_TOP_MID:
+            x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
+            y = btop;
+            break;
 
-    case LV_ALIGN_TOP_RIGHT:
-        x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
-        y = btop;
-        break;
+        case LV_ALIGN_TOP_RIGHT:
+            x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
+            y = btop;
+            break;
 
-    case LV_ALIGN_BOTTOM_LEFT:
-        x = bleft;
-        y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
-        break;
-    case LV_ALIGN_BOTTOM_MID:
-        x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
-        y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
-        break;
+        case LV_ALIGN_BOTTOM_LEFT:
+            x = bleft;
+            y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
+            break;
+        case LV_ALIGN_BOTTOM_MID:
+            x = lv_obj_get_content_width(base) / 2 - lv_obj_get_width(obj) / 2 + bleft;
+            y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
+            break;
 
-    case LV_ALIGN_BOTTOM_RIGHT:
-        x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
-        y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
-        break;
+        case LV_ALIGN_BOTTOM_RIGHT:
+            x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
+            y = lv_obj_get_content_height(base) - lv_obj_get_height(obj) + btop;
+            break;
 
-    case LV_ALIGN_LEFT_MID:
-        x = bleft;
-        y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
-        break;
+        case LV_ALIGN_LEFT_MID:
+            x = bleft;
+            y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
+            break;
 
-    case LV_ALIGN_RIGHT_MID:
-        x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
-        y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
-        break;
+        case LV_ALIGN_RIGHT_MID:
+            x = lv_obj_get_content_width(base) - lv_obj_get_width(obj) + bleft;
+            y = lv_obj_get_content_height(base) / 2 - lv_obj_get_height(obj) / 2 + btop;
+            break;
 
-    case LV_ALIGN_OUT_TOP_LEFT:
-        x = 0;
-        y = -lv_obj_get_height(obj);
-        break;
+        case LV_ALIGN_OUT_TOP_LEFT:
+            x = 0;
+            y = -lv_obj_get_height(obj);
+            break;
 
-    case LV_ALIGN_OUT_TOP_MID:
-        x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
-        y = -lv_obj_get_height(obj);
-        break;
+        case LV_ALIGN_OUT_TOP_MID:
+            x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
+            y = -lv_obj_get_height(obj);
+            break;
 
-    case LV_ALIGN_OUT_TOP_RIGHT:
-        x = lv_obj_get_width(base) - lv_obj_get_width(obj);
-        y = -lv_obj_get_height(obj);
-        break;
+        case LV_ALIGN_OUT_TOP_RIGHT:
+            x = lv_obj_get_width(base) - lv_obj_get_width(obj);
+            y = -lv_obj_get_height(obj);
+            break;
 
-    case LV_ALIGN_OUT_BOTTOM_LEFT:
-        x = 0;
-        y = lv_obj_get_height(base);
-        break;
+        case LV_ALIGN_OUT_BOTTOM_LEFT:
+            x = 0;
+            y = lv_obj_get_height(base);
+            break;
 
-    case LV_ALIGN_OUT_BOTTOM_MID:
-        x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
-        y = lv_obj_get_height(base);
-        break;
+        case LV_ALIGN_OUT_BOTTOM_MID:
+            x = lv_obj_get_width(base) / 2 - lv_obj_get_width(obj) / 2;
+            y = lv_obj_get_height(base);
+            break;
 
-    case LV_ALIGN_OUT_BOTTOM_RIGHT:
-        x = lv_obj_get_width(base) - lv_obj_get_width(obj);
-        y = lv_obj_get_height(base);
-        break;
+        case LV_ALIGN_OUT_BOTTOM_RIGHT:
+            x = lv_obj_get_width(base) - lv_obj_get_width(obj);
+            y = lv_obj_get_height(base);
+            break;
 
-    case LV_ALIGN_OUT_LEFT_TOP:
-        x = -lv_obj_get_width(obj);
-        y = 0;
-        break;
+        case LV_ALIGN_OUT_LEFT_TOP:
+            x = -lv_obj_get_width(obj);
+            y = 0;
+            break;
 
-    case LV_ALIGN_OUT_LEFT_MID:
-        x = -lv_obj_get_width(obj);
-        y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
-        break;
+        case LV_ALIGN_OUT_LEFT_MID:
+            x = -lv_obj_get_width(obj);
+            y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
+            break;
 
-    case LV_ALIGN_OUT_LEFT_BOTTOM:
-        x = -lv_obj_get_width(obj);
-        y = lv_obj_get_height(base) - lv_obj_get_height(obj);
-        break;
+        case LV_ALIGN_OUT_LEFT_BOTTOM:
+            x = -lv_obj_get_width(obj);
+            y = lv_obj_get_height(base) - lv_obj_get_height(obj);
+            break;
 
-    case LV_ALIGN_OUT_RIGHT_TOP:
-        x = lv_obj_get_width(base);
-        y = 0;
-        break;
+        case LV_ALIGN_OUT_RIGHT_TOP:
+            x = lv_obj_get_width(base);
+            y = 0;
+            break;
 
-    case LV_ALIGN_OUT_RIGHT_MID:
-        x = lv_obj_get_width(base);
-        y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
-        break;
+        case LV_ALIGN_OUT_RIGHT_MID:
+            x = lv_obj_get_width(base);
+            y = lv_obj_get_height(base) / 2 - lv_obj_get_height(obj) / 2;
+            break;
 
-    case LV_ALIGN_OUT_RIGHT_BOTTOM:
-        x = lv_obj_get_width(base);
-        y = lv_obj_get_height(base) - lv_obj_get_height(obj);
-        break;
+        case LV_ALIGN_OUT_RIGHT_BOTTOM:
+            x = lv_obj_get_width(base);
+            y = lv_obj_get_height(base) - lv_obj_get_height(obj);
+            break;
     }
 
-    x += x_ofs + base->coords.x1 - parent->coords.x1 + lv_obj_get_scroll_left(parent) - pleft;
+    if(lv_obj_get_style_base_dir(parent, LV_PART_MAIN) == LV_BASE_DIR_RTL) {
+        x += x_ofs + base->coords.x1 - parent->coords.x1 + lv_obj_get_scroll_right(parent) - pleft;
+    }
+    else {
+        x += x_ofs + base->coords.x1 - parent->coords.x1 + lv_obj_get_scroll_left(parent) - pleft;
+    }
     y += y_ofs + base->coords.y1 - parent->coords.y1 + lv_obj_get_scroll_top(parent) - ptop;
     lv_obj_set_style_align(obj, LV_ALIGN_TOP_LEFT, 0);
     lv_obj_set_pos(obj, x, y);
@@ -577,14 +591,14 @@ void lv_obj_get_content_coords(const lv_obj_t * obj, lv_area_t * area)
 lv_coord_t lv_obj_get_self_width(const lv_obj_t * obj)
 {
     lv_point_t p = {0, LV_COORD_MIN};
-    lv_event_send((lv_obj_t * )obj, LV_EVENT_GET_SELF_SIZE, &p);
+    lv_event_send((lv_obj_t *)obj, LV_EVENT_GET_SELF_SIZE, &p);
     return p.x;
 }
 
 lv_coord_t lv_obj_get_self_height(const lv_obj_t * obj)
 {
     lv_point_t p = {LV_COORD_MIN, 0};
-    lv_event_send((lv_obj_t * )obj, LV_EVENT_GET_SELF_SIZE, &p);
+    lv_event_send((lv_obj_t *)obj, LV_EVENT_GET_SELF_SIZE, &p);
     return p.y;
 }
 
@@ -642,36 +656,36 @@ void lv_obj_refr_pos(lv_obj_t * obj)
     else {
 
         switch(align) {
-        case LV_ALIGN_TOP_MID:
-            x += pw / 2 - w / 2;
-            break;
-        case LV_ALIGN_TOP_RIGHT:
-            x += pw - w;
-            break;
-        case LV_ALIGN_LEFT_MID:
-            y += ph / 2 - h / 2;
-            break;
-        case LV_ALIGN_BOTTOM_LEFT:
-            y += ph - h;
-            break;
-        case LV_ALIGN_BOTTOM_MID:
-            x += pw / 2 - w / 2;
-            y += ph - h;
-            break;
-        case LV_ALIGN_BOTTOM_RIGHT:
-            x += pw - w;
-            y += ph - h;
-            break;
-        case LV_ALIGN_RIGHT_MID:
-            x += pw - w;
-            y += ph / 2 - h / 2;
-            break;
-        case LV_ALIGN_CENTER:
-            x += pw / 2 - w / 2;
-            y += ph / 2 - h / 2;
-            break;
-        default:
-            break;
+            case LV_ALIGN_TOP_MID:
+                x += pw / 2 - w / 2;
+                break;
+            case LV_ALIGN_TOP_RIGHT:
+                x += pw - w;
+                break;
+            case LV_ALIGN_LEFT_MID:
+                y += ph / 2 - h / 2;
+                break;
+            case LV_ALIGN_BOTTOM_LEFT:
+                y += ph - h;
+                break;
+            case LV_ALIGN_BOTTOM_MID:
+                x += pw / 2 - w / 2;
+                y += ph - h;
+                break;
+            case LV_ALIGN_BOTTOM_RIGHT:
+                x += pw - w;
+                y += ph - h;
+                break;
+            case LV_ALIGN_RIGHT_MID:
+                x += pw - w;
+                y += ph / 2 - h / 2;
+                break;
+            case LV_ALIGN_CENTER:
+                x += pw / 2 - w / 2;
+                y += ph / 2 - h / 2;
+                break;
+            default:
+                break;
         }
         lv_obj_move_to(obj, x, y);
     }
@@ -689,7 +703,8 @@ void lv_obj_move_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
         if(lv_obj_has_flag(obj, LV_OBJ_FLAG_FLOATING)) {
             x += pad_left + parent->coords.x1;
             y += pad_top + parent->coords.y1;
-        } else {
+        }
+        else {
             x += pad_left + parent->coords.x1 - lv_obj_get_scroll_x(parent);
             y += pad_top + parent->coords.y1 - lv_obj_get_scroll_y(parent);
         }
@@ -752,8 +767,9 @@ void lv_obj_move_to(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 void lv_obj_move_children_by(lv_obj_t * obj, lv_coord_t x_diff, lv_coord_t y_diff, bool ignore_floating)
 {
     uint32_t i;
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-        lv_obj_t * child = lv_obj_get_child(obj, i);
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
         if(ignore_floating && lv_obj_has_flag(child, LV_OBJ_FLAG_FLOATING)) continue;
         child->coords.x1 += x_diff;
         child->coords.y1 += y_diff;
@@ -803,8 +819,7 @@ bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
     if(obj_scr != lv_disp_get_scr_act(disp) &&
        obj_scr != lv_disp_get_scr_prev(disp) &&
        obj_scr != lv_disp_get_layer_top(disp) &&
-       obj_scr != lv_disp_get_layer_sys(disp))
-    {
+       obj_scr != lv_disp_get_layer_sys(disp)) {
         return false;
     }
 
@@ -827,7 +842,8 @@ bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area)
     while(par != NULL) {
         is_common = _lv_area_intersect(area, area, &par->coords);
         if(is_common == false) return false;       /*If no common parts with parent break;*/
-        if(lv_obj_has_flag(par, LV_OBJ_FLAG_HIDDEN)) return false; /*If the parent is hidden then the child is hidden and won't be drawn*/
+        if(lv_obj_has_flag(par, LV_OBJ_FLAG_HIDDEN)) return
+                false; /*If the parent is hidden then the child is hidden and won't be drawn*/
 
         par = lv_obj_get_parent(par);
     }
@@ -908,34 +924,145 @@ lv_coord_t lv_clamp_height(lv_coord_t height, lv_coord_t min_height, lv_coord_t
  *   STATIC FUNCTIONS
  **********************/
 
-/**
- * Calculate the "auto size". It's `auto_size = max(children_size, self_size)`
- * @param obj pointer to an object
- * @param w_out store the width here. NULL to not calculate width
- * @param h_out store the height here. NULL to not calculate height
- */
-static void calc_auto_size(lv_obj_t * obj, lv_coord_t * w_out, lv_coord_t * h_out)
+static lv_coord_t calc_content_width(lv_obj_t * obj)
 {
-    if(!w_out && !h_out) return;
-    /*Get the bounding box of the children*/
-    if(w_out) {
-        lv_coord_t scroll_right = lv_obj_get_scroll_right(obj);
-        lv_coord_t scroll_left = lv_obj_get_scroll_left(obj);
-        *w_out = lv_obj_get_width(obj) + scroll_right + scroll_left;
+    lv_obj_scroll_to_x(obj, 0, LV_ANIM_OFF);
+
+    lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
+    lv_coord_t pad_right = lv_obj_get_style_pad_right(obj, LV_PART_MAIN) + border_width;
+    lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN) + border_width;
+
+    lv_coord_t self_w;
+    self_w = lv_obj_get_self_width(obj) +  pad_left + pad_right;
+
+    lv_coord_t child_res = LV_COORD_MIN;
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    /*With RTL find the left most coordinate*/
+    if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) {
+        for(i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = obj->spec_attr->children[i];
+            if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+            if(!lv_obj_is_layout_positioned(child)) {
+                lv_align_t align = lv_obj_get_style_align(child, 0);
+                switch(align) {
+                    case LV_ALIGN_DEFAULT:
+                    case LV_ALIGN_TOP_RIGHT:
+                    case LV_ALIGN_BOTTOM_RIGHT:
+                    case LV_ALIGN_RIGHT_MID:
+                        /*Normal right aligns. Other are ignored due to possible circular dependencies*/
+                        child_res = LV_MAX(child_res, obj->coords.x2 - child->coords.x1 + 1);
+                        break;
+                    default:
+                    	/* Consider other cases only if x=0 and use the width of the object.
+                    	 * With x!=0 circular dependency could occur. */
+                    	if(lv_obj_get_style_y(child, 0) == 0) {
+                    		child_res = LV_MAX(child_res, lv_area_get_width(&child->coords));
+                    	}
+                }
+            } else {
+                child_res = LV_MAX(child_res, obj->coords.x2 - child->coords.x1 + 1);
+            }
+        }
+        if(child_res != LV_COORD_MIN) {
+            child_res += pad_left;
+        }
+    }
+    /*Else find the right most coordinate*/
+    else {
+        for(i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = obj->spec_attr->children[i];
+            if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+            if(!lv_obj_is_layout_positioned(child)) {
+                lv_align_t align = lv_obj_get_style_align(child, 0);
+                switch(align) {
+                    case LV_ALIGN_DEFAULT:
+                    case LV_ALIGN_TOP_LEFT:
+                    case LV_ALIGN_BOTTOM_LEFT:
+                    case LV_ALIGN_LEFT_MID:
+                        /*Normal left aligns.*/
+                        child_res = LV_MAX(child_res, child->coords.x2 - obj->coords.x1 + 1);
+                        break;
+                    default:
+                    	/* Consider other cases only if x=0 and use the width of the object.
+                    	 * With x!=0 circular dependency could occur. */
+                    	if(lv_obj_get_style_y(child, 0) == 0) {
+                    		child_res = LV_MAX(child_res, lv_area_get_width(&child->coords));
+                    	}
+                }
+            } else {
+                child_res = LV_MAX(child_res, child->coords.x2 - obj->coords.x1 + 1);
+            }
+        }
+
+        if(child_res != LV_COORD_MIN) {
+            child_res += pad_right;
+        }
     }
 
-    if(h_out) {
-        lv_coord_t scroll_bottom = lv_obj_get_scroll_bottom(obj);
-        lv_coord_t scroll_top = lv_obj_get_scroll_top(obj);
-        *h_out = lv_obj_get_height(obj) + scroll_bottom + scroll_top;
+    if(child_res == LV_COORD_MIN) return self_w;
+    else return LV_MAX(child_res, self_w);
+}
+
+static lv_coord_t calc_content_height(lv_obj_t * obj)
+{
+    lv_obj_scroll_to_y(obj, 0, LV_ANIM_OFF);
+
+    lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
+    lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_PART_MAIN) + border_width;
+    lv_coord_t pad_bottom = lv_obj_get_style_pad_bottom(obj, LV_PART_MAIN) + border_width;
+
+    lv_coord_t self_h;
+    self_h = lv_obj_get_self_height(obj) + pad_top + pad_bottom;
+
+    lv_coord_t child_res = LV_COORD_MIN;
+    uint32_t i;
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
+        if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+
+
+        if(!lv_obj_is_layout_positioned(child)) {
+            lv_align_t align = lv_obj_get_style_align(child, 0);
+            switch(align) {
+                case LV_ALIGN_DEFAULT:
+                case LV_ALIGN_TOP_RIGHT:
+                case LV_ALIGN_TOP_MID:
+                case LV_ALIGN_TOP_LEFT:
+                    /*Normal top aligns. */
+                    child_res = LV_MAX(child_res, child->coords.y2 - obj->coords.y1 + 1);
+                    break;
+                default:
+                	/* Consider other cases only if y=0 and use the height of the object.
+                	 * With y!=0 circular dependency could occur. */
+                	if(lv_obj_get_style_y(child, 0) == 0) {
+                		child_res = LV_MAX(child_res, lv_area_get_height(&child->coords));
+                	}
+                	break;
+            }
+        } else {
+            child_res = LV_MAX(child_res, child->coords.y2 - obj->coords.y1 + 1);
+        }
     }
+
+    if(child_res != LV_COORD_MIN) {
+        child_res += pad_bottom;
+        return LV_MAX(child_res, self_h);
+    } else {
+        return self_h;
+    }
+
 }
 
 static void layout_update_core(lv_obj_t * obj)
 {
     uint32_t i;
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-        lv_obj_t * child = lv_obj_get_child(obj, i);
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
         layout_update_core(child);
     }
 
@@ -946,11 +1073,11 @@ static void layout_update_core(lv_obj_t * obj)
     lv_obj_refr_size(obj);
     lv_obj_refr_pos(obj);
 
-    if(lv_obj_get_child_cnt(obj) > 0) {
+    if(child_cnt > 0) {
         uint32_t layout_id = lv_obj_get_style_layout(obj, LV_PART_MAIN);
         if(layout_id > 0 && layout_id <= layout_cnt) {
-            void  * user_data = LV_GC_ROOT(_lv_layout_list)[layout_id -1].user_data;
-            LV_GC_ROOT(_lv_layout_list)[layout_id -1].cb(obj, user_data);
+            void  * user_data = LV_GC_ROOT(_lv_layout_list)[layout_id - 1].user_data;
+            LV_GC_ROOT(_lv_layout_list)[layout_id - 1].cb(obj, user_data);
         }
     }
 }
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.h b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.h
index 2034124bd..c73159ffd 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.h
@@ -28,7 +28,7 @@ typedef void (*lv_layout_update_cb_t)(struct _lv_obj_t *, void * user_data);
 typedef struct {
     lv_layout_update_cb_t cb;
     void * user_data;
-}lv_layout_dsc_t;
+} lv_layout_dsc_t;
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -176,7 +176,8 @@ void lv_obj_align(struct _lv_obj_t * obj, lv_align_t align, lv_coord_t x_ofs, lv
  * @param y_ofs     y coordinate offset after alignment
  * @note            if the position or size of `base` changes `obj` needs to be aligned manually again
  */
-void lv_obj_align_to(struct _lv_obj_t * obj, const struct _lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
+void lv_obj_align_to(struct _lv_obj_t * obj, const struct _lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs,
+                     lv_coord_t y_ofs);
 
 /**
  * Align an object to the center on its parent.
@@ -200,6 +201,8 @@ void lv_obj_get_coords(const struct _lv_obj_t * obj, lv_area_t * coords);
  * Get the x coordinate of object.
  * @param obj       pointer to an object
  * @return          distance of `obj` from the left side of its parent plus the parent's left padding
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @note            Zero return value means the object is on the left padding of the parent, and not on the left edge.
  * @note            Scrolling of the parent doesn't change the returned value.
  * @note            The returned value is always the distance from the parent even if `obj` is positioned by a layout.
@@ -210,6 +213,8 @@ lv_coord_t lv_obj_get_x(const struct _lv_obj_t * obj);
  * Get the x2 coordinate of object.
  * @param obj       pointer to an object
  * @return          distance of `obj` from the right side of its parent plus the parent's right padding
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @note            Zero return value means the object is on the right padding of the parent, and not on the right edge.
  * @note            Scrolling of the parent doesn't change the returned value.
  * @note            The returned value is always the distance from the parent even if `obj` is positioned by a layout.
@@ -220,6 +225,8 @@ lv_coord_t lv_obj_get_x2(const struct _lv_obj_t * obj);
  * Get the y coordinate of object.
  * @param obj       pointer to an object
  * @return          distance of `obj` from the top side of its parent plus the parent's top padding
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @note            Zero return value means the object is on the top padding of the parent, and not on the top edge.
  * @note            Scrolling of the parent doesn't change the returned value.
  * @note            The returned value is always the distance from the parent even if `obj` is positioned by a layout.
@@ -230,6 +237,8 @@ lv_coord_t lv_obj_get_y(const struct _lv_obj_t * obj);
  * Get the y2 coordinate of object.
  * @param obj       pointer to an object
  * @return          distance of `obj` from the bottom side of its parent plus the parent's bottom padding
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @note            Zero return value means the object is on the bottom padding of the parent, and not on the bottom edge.
  * @note            Scrolling of the parent doesn't change the returned value.
  * @note            The returned value is always the distance from the parent even if `obj` is positioned by a layout.
@@ -239,6 +248,8 @@ lv_coord_t lv_obj_get_y2(const struct _lv_obj_t * obj);
 /**
  * Get the width of an object
  * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @return          the width in pixels
  */
 lv_coord_t lv_obj_get_width(const struct _lv_obj_t * obj);
@@ -246,6 +257,8 @@ lv_coord_t lv_obj_get_width(const struct _lv_obj_t * obj);
 /**
  * Get the height of an object
  * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @return          the height in pixels
  */
 lv_coord_t lv_obj_get_height(const struct _lv_obj_t * obj);
@@ -253,13 +266,17 @@ lv_coord_t lv_obj_get_height(const struct _lv_obj_t * obj);
 /**
  * Get the width reduced by the left and right padding and the border width.
  * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @return          the width which still fits into its parent without causing overflow (making the parent scrollable)
  */
 lv_coord_t lv_obj_get_content_width(const struct _lv_obj_t * obj);
 
 /**
- * Get the height reduced by the top an bottom padding and the border width.
+ * Get the height reduced by the top and bottom padding and the border width.
  * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @return          the height which still fits into the parent without causing overflow (making the parent scrollable)
  */
 lv_coord_t lv_obj_get_content_height(const struct _lv_obj_t * obj);
@@ -267,6 +284,8 @@ lv_coord_t lv_obj_get_content_height(const struct _lv_obj_t * obj);
 /**
  * Get the area reduced by the paddings and the border width.
  * @param obj       pointer to an object
+ * @note            The position of the object is recalculated only on the next redraw. To force coordinate recalculation
+ *                  call `lv_obj_update_layout(obj)`.
  * @param area      the area which still fits into the parent without causing overflow (making the parent scrollable)
  */
 void lv_obj_get_content_coords(const struct _lv_obj_t * obj, lv_area_t * area);
@@ -361,7 +380,7 @@ bool lv_obj_hit_test(struct _lv_obj_t * obj, const lv_point_t * point);
  * @param min_width     the minimal width
  * @param max_width     the maximal width
  * @param ref_width     the reference width used when min/max width is in percentage
- * @return              the clampled width
+ * @return              the clamped width
  */
 lv_coord_t lv_clamp_width(lv_coord_t width, lv_coord_t min_width, lv_coord_t max_width, lv_coord_t ref_width);
 
@@ -371,7 +390,7 @@ lv_coord_t lv_clamp_width(lv_coord_t width, lv_coord_t min_width, lv_coord_t max
  * @param min_height     the minimal height
  * @param max_height     the maximal height
  * @param ref_height     the reference height used when min/max height is in percentage
- * @return              the clampled height
+ * @return              the clamped height
  */
 lv_coord_t lv_clamp_height(lv_coord_t height, lv_coord_t min_height, lv_coord_t max_height, lv_coord_t ref_height);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.c b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.c
index 8fafecf5e..0b2a5d26e 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.c
@@ -35,7 +35,8 @@ static void scroll_by_raw(lv_obj_t * obj, lv_coord_t x, lv_coord_t y);
 static void scroll_x_anim(void * obj, int32_t v);
 static void scroll_y_anim(void * obj, int32_t v);
 static void scroll_anim_ready_cb(lv_anim_t * a);
-static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_point_t * scroll_value, lv_anim_enable_t anim_en);
+static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_point_t * scroll_value,
+                                  lv_anim_enable_t anim_en);
 
 /**********************
  *  STATIC VARIABLES
@@ -137,8 +138,9 @@ lv_coord_t lv_obj_get_scroll_bottom(lv_obj_t * obj)
 
     lv_coord_t child_res = LV_COORD_MIN;
     uint32_t i;
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-        lv_obj_t * child = lv_obj_get_child(obj, i);
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
         if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
         child_res = LV_MAX(child_res, child->coords.y2);
     }
@@ -177,9 +179,10 @@ lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj)
 
     uint32_t i;
     lv_coord_t x1 = LV_COORD_MAX;
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-       lv_obj_t * child = lv_obj_get_child(obj, i);
-       if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
+        if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
         x1 = LV_MIN(x1, child->coords.x1);
 
     }
@@ -187,7 +190,8 @@ lv_coord_t lv_obj_get_scroll_left(lv_obj_t * obj)
     if(x1 != LV_COORD_MAX) {
         child_res = x1;
         child_res = (obj->coords.x1 + pad_left + border_width) - child_res;
-    } else {
+    }
+    else {
         child_res = LV_COORD_MIN;
     }
 
@@ -212,8 +216,9 @@ lv_coord_t lv_obj_get_scroll_right(lv_obj_t * obj)
     /*With other base direction (LTR) scrolling to the right is normal so find the right most coordinate*/
     lv_coord_t child_res = LV_COORD_MIN;
     uint32_t i;
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-        lv_obj_t * child = lv_obj_get_child(obj, i);
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
         if(lv_obj_has_flag_any(child,  LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) continue;
         child_res = LV_MAX(child_res, child->coords.x2);
     }
@@ -282,13 +287,14 @@ void lv_obj_scroll_by(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_anim_enable
             lv_anim_set_values(&a, -sy, -sy + y);
             lv_anim_set_exec_cb(&a,  scroll_y_anim);
             lv_anim_set_path_cb(&a, lv_anim_path_ease_out);
-            
+
             lv_res_t res;
             res = lv_event_send(obj, LV_EVENT_SCROLL_BEGIN, &a);
             if(res != LV_RES_OK) return;
             lv_anim_start(&a);
         }
-    } else {
+    }
+    else {
         /*Remove pending animations*/
         bool y_del = lv_anim_del(obj, scroll_y_anim);
         bool x_del = lv_anim_del(obj, scroll_x_anim);
@@ -320,7 +326,8 @@ void lv_obj_scroll_to_x(lv_obj_t * obj, lv_coord_t x, lv_anim_enable_t anim_en)
 
             if(x > scroll_max) x = scroll_max;
         }
-    } else {
+    }
+    else {
         if(x > 0) x = 0;
         if(x < 0) {
             lv_coord_t  scroll_max = lv_obj_get_scroll_left(obj) + lv_obj_get_scroll_right(obj);
@@ -426,23 +433,25 @@ void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor_area, lv_area_t *
 
     bool ver_draw = false;
     if((dir & LV_DIR_VER) &&
-            ((sm == LV_SCROLLBAR_MODE_ON) ||
-                    (sm == LV_SCROLLBAR_MODE_AUTO && (st > 0 || sb > 0)) ||
-                    (sm == LV_SCROLLBAR_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_DIR_VER))) {
+       ((sm == LV_SCROLLBAR_MODE_ON) ||
+        (sm == LV_SCROLLBAR_MODE_AUTO && (st > 0 || sb > 0)) ||
+        (sm == LV_SCROLLBAR_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_DIR_VER))) {
         ver_draw = true;
     }
 
 
     bool hor_draw = false;
     if((dir & LV_DIR_HOR) &&
-            ((sm == LV_SCROLLBAR_MODE_ON) ||
-                    (sm == LV_SCROLLBAR_MODE_AUTO && (sl > 0 || sr > 0)) ||
-                    (sm == LV_SCROLLBAR_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_DIR_HOR))) {
+       ((sm == LV_SCROLLBAR_MODE_ON) ||
+        (sm == LV_SCROLLBAR_MODE_AUTO && (sl > 0 || sr > 0)) ||
+        (sm == LV_SCROLLBAR_MODE_ACTIVE && lv_indev_get_scroll_dir(indev) == LV_DIR_HOR))) {
         hor_draw = true;
     }
 
     if(!hor_draw && !ver_draw) return;
 
+    bool rtl = lv_obj_get_style_base_dir(obj, LV_PART_SCROLLBAR) == LV_BASE_DIR_RTL ? true : false;
+
     lv_coord_t end_space = lv_obj_get_style_pad_top(obj, LV_PART_SCROLLBAR);
     lv_coord_t side_space = lv_obj_get_style_pad_right(obj, LV_PART_SCROLLBAR);
     lv_coord_t tickness = lv_obj_get_style_width(obj, LV_PART_SCROLLBAR);
@@ -462,35 +471,39 @@ void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor_area, lv_area_t *
     /*Draw horizontal scrollbar if the mode is ON or can be scrolled in this direction*/
     lv_coord_t content_h = obj_h + st + sb;
     if(ver_draw && content_h) {
-       ver_area->y1 = obj->coords.y1;
-       ver_area->y2 = obj->coords.y2;
-       ver_area->x2 = obj->coords.x2 - side_space;
-       ver_area->x1 =ver_area->x2 - tickness;
+        ver_area->y1 = obj->coords.y1;
+        ver_area->y2 = obj->coords.y2;
+        if(rtl) {
+            ver_area->x1 = obj->coords.x1 + side_space;
+            ver_area->x2 = ver_area->x1 + tickness - 1;
+        }
+        else {
+            ver_area->x2 = obj->coords.x2 - side_space;
+            ver_area->x1 = ver_area->x2 - tickness + 1;
+        }
 
         lv_coord_t sb_h = ((obj_h - end_space * 2 - hor_req_space) * obj_h) / content_h;
         sb_h = LV_MAX(sb_h, SCROLLBAR_MIN_SIZE);
-        rem = (obj_h - end_space * 2 - hor_req_space) - sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+        rem = (obj_h - end_space * 2 - hor_req_space) -
+              sb_h;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
         lv_coord_t scroll_h = content_h - obj_h; /*The size of the content which can be really scrolled*/
         if(scroll_h <= 0) {
-           ver_area->y1 = obj->coords.y1 + end_space;
-           ver_area->y2 = obj->coords.y2 - end_space - hor_req_space - 1;
-           ver_area->x2 = obj->coords.x2 - side_space;
-           ver_area->x1 =ver_area->x2 - tickness + 1;
-        } else {
+            ver_area->y1 = obj->coords.y1 + end_space;
+            ver_area->y2 = obj->coords.y2 - end_space - hor_req_space - 1;
+        }
+        else {
             lv_coord_t sb_y = (rem * sb) / scroll_h;
             sb_y = rem - sb_y;
 
-           ver_area->y1 = obj->coords.y1 + sb_y + end_space;
-           ver_area->y2 =ver_area->y1 + sb_h - 1;
-           ver_area->x2 = obj->coords.x2 - side_space;
-           ver_area->x1 =ver_area->x2 - tickness;
+            ver_area->y1 = obj->coords.y1 + sb_y + end_space;
+            ver_area->y2 = ver_area->y1 + sb_h - 1;
             if(ver_area->y1 < obj->coords.y1 + end_space) {
-               ver_area->y1 = obj->coords.y1 + end_space;
-                if(ver_area->y1 + SCROLLBAR_MIN_SIZE >ver_area->y2)ver_area->y2 =ver_area->y1 + SCROLLBAR_MIN_SIZE;
+                ver_area->y1 = obj->coords.y1 + end_space;
+                if(ver_area->y1 + SCROLLBAR_MIN_SIZE > ver_area->y2)ver_area->y2 = ver_area->y1 + SCROLLBAR_MIN_SIZE;
             }
             if(ver_area->y2 > obj->coords.y2 - hor_req_space - end_space) {
-               ver_area->y2 = obj->coords.y2 - hor_req_space - end_space;
-                if(ver_area->y2 - SCROLLBAR_MIN_SIZE <ver_area->y1)ver_area->y1 =ver_area->y2 - SCROLLBAR_MIN_SIZE;
+                ver_area->y2 = obj->coords.y2 - hor_req_space - end_space;
+                if(ver_area->y2 - SCROLLBAR_MIN_SIZE < ver_area->y1)ver_area->y1 = ver_area->y2 - SCROLLBAR_MIN_SIZE;
             }
         }
     }
@@ -499,34 +512,52 @@ void lv_obj_get_scrollbar_area(lv_obj_t * obj, lv_area_t * hor_area, lv_area_t *
     lv_coord_t content_w = obj_w + sl + sr;
     if(hor_draw && content_w) {
         hor_area->y2 = obj->coords.y2 - side_space;
-        hor_area->y1 = hor_area->y2 - tickness;
+        hor_area->y1 = hor_area->y2 - tickness + 1;
         hor_area->x1 = obj->coords.x1;
         hor_area->x2 = obj->coords.x2;
 
         lv_coord_t sb_w = ((obj_w - end_space * 2 - ver_reg_space) * obj_w) / content_w;
         sb_w = LV_MAX(sb_w, SCROLLBAR_MIN_SIZE);
-        rem = (obj_w - end_space * 2 - ver_reg_space) - sb_w;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
+        rem = (obj_w - end_space * 2 - ver_reg_space) -
+              sb_w;  /*Remaining size from the scrollbar track that is not the scrollbar itself*/
         lv_coord_t scroll_w = content_w - obj_w; /*The size of the content which can be really scrolled*/
         if(scroll_w <= 0) {
-            hor_area->y2 = obj->coords.y2 - side_space;
-            hor_area->y1 = hor_area->y2 - tickness + 1;
-            hor_area->x1 = obj->coords.x1 + end_space;
-            hor_area->x2 = obj->coords.x2 - end_space - ver_reg_space - 1;
-        } else {
+            if(rtl) {
+                hor_area->x1 = obj->coords.x1 + end_space + ver_reg_space - 1;
+                hor_area->x2 = obj->coords.x2 - end_space;
+            }
+            else {
+                hor_area->x1 = obj->coords.x1 + end_space;
+                hor_area->x2 = obj->coords.x2 - end_space - ver_reg_space - 1;
+            }
+        }
+        else {
             lv_coord_t sb_x = (rem * sr) / scroll_w;
             sb_x = rem - sb_x;
 
-            hor_area->x1 = obj->coords.x1 + sb_x + end_space;
-            hor_area->x2 = hor_area->x1 + sb_w - 1;
-            hor_area->y2 = obj->coords.y2 - side_space;
-            hor_area->y1 = hor_area->y2 - tickness;
-            if(hor_area->x1 < obj->coords.x1 + end_space) {
-                hor_area->x1 = obj->coords.x1 + end_space;
-                if(hor_area->x1 + SCROLLBAR_MIN_SIZE > hor_area->x2) hor_area->x2 = hor_area->x1 + SCROLLBAR_MIN_SIZE;
+            if(rtl) {
+                hor_area->x1 = obj->coords.x1 + sb_x + end_space + ver_reg_space;
+                hor_area->x2 = hor_area->x1 + sb_w - 1;
+                if(hor_area->x1 < obj->coords.x1 + end_space + ver_reg_space) {
+                    hor_area->x1 = obj->coords.x1 + end_space + ver_reg_space;
+                    if(hor_area->x1 + SCROLLBAR_MIN_SIZE > hor_area->x2) hor_area->x2 = hor_area->x1 + SCROLLBAR_MIN_SIZE;
+                }
+                if(hor_area->x2 > obj->coords.x2 - end_space) {
+                    hor_area->x2 = obj->coords.x2 - end_space;
+                    if(hor_area->x2 - SCROLLBAR_MIN_SIZE < hor_area->x1) hor_area->x1 = hor_area->x2 - SCROLLBAR_MIN_SIZE;
+                }
             }
-            if(hor_area->x2 > obj->coords.x2 - ver_reg_space - end_space) {
-                hor_area->x2 = obj->coords.x2 - ver_reg_space - end_space;
-                if(hor_area->x2 - SCROLLBAR_MIN_SIZE < hor_area->x1) hor_area->x1 = hor_area->x2 - SCROLLBAR_MIN_SIZE;
+            else {
+                hor_area->x1 = obj->coords.x1 + sb_x + end_space;
+                hor_area->x2 = hor_area->x1 + sb_w - 1;
+                if(hor_area->x1 < obj->coords.x1 + end_space) {
+                    hor_area->x1 = obj->coords.x1 + end_space;
+                    if(hor_area->x1 + SCROLLBAR_MIN_SIZE > hor_area->x2) hor_area->x2 = hor_area->x1 + SCROLLBAR_MIN_SIZE;
+                }
+                if(hor_area->x2 > obj->coords.x2 - ver_reg_space - end_space) {
+                    hor_area->x2 = obj->coords.x2 - ver_reg_space - end_space;
+                    if(hor_area->x2 - SCROLLBAR_MIN_SIZE < hor_area->x1) hor_area->x1 = hor_area->x2 - SCROLLBAR_MIN_SIZE;
+                }
             }
         }
     }
@@ -566,7 +597,8 @@ void lv_obj_readjust_scroll(lv_obj_t * obj, lv_anim_enable_t anim_en)
                 sr = LV_MIN(sl, -sr);
                 lv_obj_scroll_by(obj, sr, 0, anim_en);
             }
-        } else {
+        }
+        else {
             /*Be sure the right side is not remains scrolled in*/
             if(sl < 0 && sr > 0) {
                 sr = LV_MIN(sr, -sl);
@@ -610,9 +642,12 @@ static void scroll_anim_ready_cb(lv_anim_t * a)
     lv_event_send(a->var, LV_EVENT_SCROLL_END, NULL);
 }
 
-static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_point_t * scroll_value, lv_anim_enable_t anim_en)
+static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_point_t * scroll_value,
+                                  lv_anim_enable_t anim_en)
 {
     lv_obj_t * parent = lv_obj_get_parent(child);
+    if(!lv_obj_has_flag(parent, LV_OBJ_FLAG_SCROLLABLE)) return;
+
     lv_dir_t scroll_dir = lv_obj_get_scroll_dir(parent);
     lv_coord_t snap_goal = 0;
     lv_coord_t act = 0;
@@ -623,12 +658,13 @@ static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_p
     if(snap_y != LV_SCROLL_SNAP_NONE) area_tmp = &child->coords;
     else area_tmp = area;
 
-    lv_coord_t ptop = lv_obj_get_style_pad_top(parent, LV_PART_MAIN);
-    lv_coord_t pbottom = lv_obj_get_style_pad_bottom(parent, LV_PART_MAIN);
+    lv_coord_t border_width = lv_obj_get_style_border_width(parent, LV_PART_MAIN);
+    lv_coord_t ptop = lv_obj_get_style_pad_top(parent, LV_PART_MAIN) + border_width;
+    lv_coord_t pbottom = lv_obj_get_style_pad_bottom(parent, LV_PART_MAIN) + border_width;
     lv_coord_t top_diff = parent->coords.y1 + ptop - area_tmp->y1 - scroll_value->y;
     lv_coord_t bottom_diff = -(parent->coords.y2 - pbottom - area_tmp->y2 - scroll_value->y);
     lv_coord_t parent_h = lv_obj_get_height(parent) - ptop - pbottom;
-    if((top_diff > 0 && bottom_diff > 0)) y_scroll = 0;
+    if((top_diff >= 0 && bottom_diff >= 0)) y_scroll = 0;
     else if(top_diff > 0) {
         y_scroll = top_diff;
         /*Do not let scrolling in*/
@@ -643,21 +679,21 @@ static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_p
     }
 
     switch(snap_y) {
-    case LV_SCROLL_SNAP_START:
-        snap_goal = parent->coords.y1 + ptop;
-        act = area_tmp->y1 + y_scroll;
-        y_scroll += snap_goal - act;
-        break;
-    case LV_SCROLL_SNAP_END:
-        snap_goal = parent->coords.y2 - pbottom;
-        act = area_tmp->y2 + y_scroll;
-        y_scroll += snap_goal - act;
-        break;
-    case LV_SCROLL_SNAP_CENTER:
-        snap_goal = parent->coords.y1 + ptop + parent_h / 2;
-        act = lv_area_get_height(area_tmp) / 2 + area_tmp->y1 + y_scroll;
-        y_scroll += snap_goal - act;
-        break;
+        case LV_SCROLL_SNAP_START:
+            snap_goal = parent->coords.y1 + ptop;
+            act = area_tmp->y1 + y_scroll;
+            y_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_END:
+            snap_goal = parent->coords.y2 - pbottom;
+            act = area_tmp->y2 + y_scroll;
+            y_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_CENTER:
+            snap_goal = parent->coords.y1 + ptop + parent_h / 2;
+            act = lv_area_get_height(area_tmp) / 2 + area_tmp->y1 + y_scroll;
+            y_scroll += snap_goal - act;
+            break;
     }
 
     lv_coord_t x_scroll = 0;
@@ -665,11 +701,11 @@ static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_p
     if(snap_x != LV_SCROLL_SNAP_NONE) area_tmp = &child->coords;
     else area_tmp = area;
 
-    lv_coord_t pleft = lv_obj_get_style_pad_left(parent, LV_PART_MAIN);
-    lv_coord_t pright = lv_obj_get_style_pad_right(parent, LV_PART_MAIN);
+    lv_coord_t pleft = lv_obj_get_style_pad_left(parent, LV_PART_MAIN) + border_width;
+    lv_coord_t pright = lv_obj_get_style_pad_right(parent, LV_PART_MAIN) + border_width;
     lv_coord_t left_diff = parent->coords.x1 + pleft - area_tmp->x1 - scroll_value->x;
-    lv_coord_t right_diff = -(parent->coords.x2 - pright - area_tmp->x2- scroll_value->x);
-    if((left_diff > 0 && right_diff > 0)) x_scroll = 0;
+    lv_coord_t right_diff = -(parent->coords.x2 - pright - area_tmp->x2 - scroll_value->x);
+    if((left_diff >= 0 && right_diff >= 0)) x_scroll = 0;
     else if(left_diff > 0) {
         x_scroll = left_diff;
         /*Do not let scrolling in*/
@@ -685,21 +721,21 @@ static void scroll_area_into_view(const lv_area_t * area, lv_obj_t * child, lv_p
 
     lv_coord_t parent_w = lv_obj_get_width(parent) - pleft - pright;
     switch(snap_x) {
-    case LV_SCROLL_SNAP_START:
-        snap_goal = parent->coords.x1 + pleft;
-        act = area_tmp->x1 + x_scroll;
-        x_scroll += snap_goal - act;
-        break;
-    case LV_SCROLL_SNAP_END:
-        snap_goal = parent->coords.x2 - pright;
-        act = area_tmp->x2 + x_scroll;
-        x_scroll += snap_goal - act;
-        break;
-    case LV_SCROLL_SNAP_CENTER:
-        snap_goal = parent->coords.x1 + pleft + parent_w / 2;
-        act = lv_area_get_width(area_tmp) / 2 + area_tmp->x1 + x_scroll;
-        x_scroll += snap_goal - act;
-        break;
+        case LV_SCROLL_SNAP_START:
+            snap_goal = parent->coords.x1 + pleft;
+            act = area_tmp->x1 + x_scroll;
+            x_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_END:
+            snap_goal = parent->coords.x2 - pright;
+            act = area_tmp->x2 + x_scroll;
+            x_scroll += snap_goal - act;
+            break;
+        case LV_SCROLL_SNAP_CENTER:
+            snap_goal = parent->coords.x1 + pleft + parent_w / 2;
+            act = lv_area_get_width(area_tmp) / 2 + area_tmp->x1 + x_scroll;
+            x_scroll += snap_goal - act;
+            break;
     }
 
     /*Remove any pending scroll animations.*/
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.h b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.h
index ce813cee3..fc52e8eea 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.h
@@ -37,7 +37,7 @@ enum {
 typedef uint8_t lv_scrollbar_mode_t;
 
 
-/** Scroll span align options. Tells where to align the snapable children when scroll stops.*/
+/** Scroll span align options. Tells where to align the snappable children when scroll stops.*/
 enum {
     LV_SCROLL_SNAP_NONE,    /**< Do not align, leave where it is*/
     LV_SCROLL_SNAP_START,   /**< Align to the left/top*/
@@ -172,9 +172,9 @@ lv_coord_t lv_obj_get_scroll_right(struct _lv_obj_t * obj);
 
 /**
  * Get the X and Y coordinates where the scrolling will end for this object if a scrolling animation is in progress.
- * In no scrolling animation give the current `x` or `y` scroll position.
+ * If no scrolling animation, give the current `x` or `y` scroll position.
  * @param obj       pointer to an object
- * @param           end poinr to point to store the result
+ * @param end       pointer to store the result
  */
 void lv_obj_get_scroll_end(struct _lv_obj_t  * obj, lv_point_t * end);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style.c b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style.c
index dde2742c4..57566fd59 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style.c
@@ -33,7 +33,7 @@ typedef enum {
     CACHE_UNSET = 2,
     CACHE_255 = 3,
     CACHE_NEED_CHECK = 4,
-}cache_t;
+} cache_t;
 
 /**********************
  *  GLOBAL PROTOTYPES
@@ -117,8 +117,7 @@ void lv_obj_remove_style(lv_obj_t * obj, lv_style_t * style, lv_style_selector_t
         lv_part_t part_act = lv_obj_style_get_selector_part(obj->styles[i].selector);
         if((state != LV_STATE_ANY && state_act != state) ||
            (part != LV_PART_ANY && part_act != part) ||
-           (style != NULL && style != obj->styles[i].style))
-        {
+           (style != NULL && style != obj->styles[i].style)) {
             i++;
             continue;
         }
@@ -175,11 +174,17 @@ void lv_obj_refresh_style(lv_obj_t * obj, lv_style_selector_t selector, lv_style
 
     lv_part_t part = lv_obj_style_get_selector_part(selector);
 
-    if((part == LV_PART_ANY || part == LV_PART_MAIN) && (prop == LV_STYLE_PROP_ANY || (prop & LV_STYLE_PROP_LAYOUT_REFR))) {
-        lv_event_send(obj, LV_EVENT_STYLE_CHANGED, NULL);
-        lv_obj_mark_layout_as_dirty(obj);
+    if(prop & LV_STYLE_PROP_LAYOUT_REFR) {
+        if(part == LV_PART_ANY ||
+           part == LV_PART_MAIN ||
+           lv_obj_get_style_height(obj, 0) == LV_SIZE_CONTENT ||
+           lv_obj_get_style_width(obj, 0) == LV_SIZE_CONTENT) {
+            lv_event_send(obj, LV_EVENT_STYLE_CHANGED, NULL);
+            lv_obj_mark_layout_as_dirty(obj);
+        }
     }
-    if((part == LV_PART_ANY || part == LV_PART_MAIN) && (prop == LV_STYLE_PROP_ANY || (prop & LV_STYLE_PROP_PARENT_LAYOUT_REFR))) {
+    if((part == LV_PART_ANY || part == LV_PART_MAIN) && (prop == LV_STYLE_PROP_ANY ||
+                                                         (prop & LV_STYLE_PROP_PARENT_LAYOUT_REFR))) {
         lv_obj_t * parent = lv_obj_get_parent(obj);
         if(parent) lv_obj_mark_layout_as_dirty(parent);
     }
@@ -190,8 +195,7 @@ void lv_obj_refresh_style(lv_obj_t * obj, lv_style_selector_t selector, lv_style
     lv_obj_invalidate(obj);
 
     if(prop == LV_STYLE_PROP_ANY ||
-      ((prop & LV_STYLE_PROP_INHERIT) && ((prop & LV_STYLE_PROP_EXT_DRAW) || (prop & LV_STYLE_PROP_LAYOUT_REFR))))
-    {
+       ((prop & LV_STYLE_PROP_INHERIT) && ((prop & LV_STYLE_PROP_EXT_DRAW) || (prop & LV_STYLE_PROP_LAYOUT_REFR)))) {
         if(part != LV_PART_SCROLLBAR) {
             refresh_children_style(obj);
         }
@@ -233,14 +237,16 @@ lv_style_value_t lv_obj_get_style_prop(const lv_obj_t * obj, lv_part_t part, lv_
             while(cls) {
                 if(prop == LV_STYLE_WIDTH) {
                     if(cls->width_def != 0) break;
-                } else {
+                }
+                else {
                     if(cls->height_def != 0) break;
                 }
                 cls = cls->base_class;
             }
 
             value_act.num = prop == LV_STYLE_WIDTH ? cls->width_def : cls->height_def;
-        } else {
+        }
+        else {
             value_act = lv_style_prop_get_default(prop);
         }
     }
@@ -248,7 +254,8 @@ lv_style_value_t lv_obj_get_style_prop(const lv_obj_t * obj, lv_part_t part, lv_
     return value_act;
 }
 
-void lv_obj_set_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t value, lv_style_selector_t selector)
+void lv_obj_set_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t value,
+                                 lv_style_selector_t selector)
 {
     lv_style_t * style = get_local_style(obj, selector);
     lv_style_set_prop(style, prop, value);
@@ -256,13 +263,13 @@ void lv_obj_set_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_
 }
 
 
-lv_res_t lv_obj_get_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t * value, lv_style_selector_t selector)
+lv_res_t lv_obj_get_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t * value,
+                                     lv_style_selector_t selector)
 {
     uint32_t i;
     for(i = 0; i < obj->style_cnt; i++) {
         if(obj->styles[i].is_local &&
-           obj->styles[i].selector ==  selector)
-        {
+           obj->styles[i].selector ==  selector) {
             return lv_style_get_prop(obj->styles[i].style, prop, value);
         }
     }
@@ -289,7 +296,8 @@ bool lv_obj_remove_local_style_prop(lv_obj_t * obj, lv_style_prop_t prop, lv_sty
     return lv_style_remove_prop(obj->styles[i].style, prop);
 }
 
-void _lv_obj_style_create_transition(lv_obj_t * obj, lv_part_t part, lv_state_t prev_state, lv_state_t new_state, const _lv_obj_style_transition_dsc_t * tr_dsc)
+void _lv_obj_style_create_transition(lv_obj_t * obj, lv_part_t part, lv_state_t prev_state, lv_state_t new_state,
+                                     const _lv_obj_style_transition_dsc_t * tr_dsc)
 {
     trans_t * tr;
 
@@ -357,8 +365,7 @@ _lv_style_state_cmp_t _lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t sta
         if(obj->styles[i].is_trans) continue;
 
         lv_state_t state_act = lv_obj_style_get_selector_state(obj->styles[i].selector);
-        lv_part_t part_act = lv_obj_style_get_selector_part(obj->styles[i].selector);
-        /*The style is valid for a stat but not the other*/
+        /*The style is valid for a state but not the other*/
         bool valid1 = state_act & (~state1) ? false : true;
         bool valid2 = state_act & (~state2) ? false : true;
         if(valid1 != valid2) {
@@ -382,15 +389,11 @@ _lv_style_state_cmp_t _lv_obj_style_state_compare(lv_obj_t * obj, lv_state_t sta
             else if(lv_style_get_prop(style, LV_STYLE_MIN_HEIGHT, &v)) layout_diff = true;
             else if(lv_style_get_prop(style, LV_STYLE_MAX_HEIGHT, &v)) layout_diff = true;
             else if(lv_style_get_prop(style, LV_STYLE_BORDER_WIDTH, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ANGLE, &v)) layout_diff = true;
+            else if(lv_style_get_prop(style, LV_STYLE_TRANSFORM_ZOOM, &v)) layout_diff = true;
 
             if(layout_diff) {
-                if(part_act == LV_PART_MAIN) {
-                    return _LV_STYLE_STATE_CMP_DIFF_LAYOUT;
-                }
-                else {
-                    res = _LV_STYLE_STATE_CMP_DIFF_DRAW_PAD;
-                    continue;
-                }
+                return _LV_STYLE_STATE_CMP_DIFF_LAYOUT;
             }
 
             /*Check for draw pad changes*/
@@ -449,6 +452,15 @@ lv_part_t lv_obj_style_get_selector_part(lv_style_selector_t selector)
     return selector & 0xFF0000;
 }
 
+
+lv_text_align_t lv_obj_calculate_style_text_align(const struct _lv_obj_t * obj, lv_part_t part, const char * txt)
+{
+    lv_text_align_t align = lv_obj_get_style_text_align(obj, part);
+    lv_base_dir_t base_dir = lv_obj_get_style_base_dir(obj, part);
+    lv_bidi_calculate_align(&align, &base_dir, txt);
+    return align;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -466,8 +478,7 @@ static lv_style_t * get_local_style(lv_obj_t * obj,  lv_style_selector_t selecto
     uint32_t i;
     for(i = 0; i < obj->style_cnt; i++) {
         if(obj->styles[i].is_local &&
-           obj->styles[i].selector == selector)
-        {
+           obj->styles[i].selector == selector) {
             return obj->styles[i].style;
         }
     }
@@ -613,8 +624,9 @@ static void report_style_change_core(void * style, lv_obj_t * obj)
         }
     }
 
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-        report_style_change_core(style, lv_obj_get_child(obj, i));
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        report_style_change_core(style, obj->spec_attr->children[i]);
     }
 }
 
@@ -626,8 +638,9 @@ static void report_style_change_core(void * style, lv_obj_t * obj)
 static void refresh_children_style(lv_obj_t * obj)
 {
     uint32_t i;
-    for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-        lv_obj_t * child = lv_obj_get_child(obj, i);
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = obj->spec_attr->children[i];
         lv_obj_invalidate(child);
         lv_event_send(child, LV_EVENT_STYLE_CHANGED, NULL);
         lv_obj_invalidate(child);
@@ -687,7 +700,7 @@ static void trans_anim_cb(void * _tr, int32_t v)
         if(obj->styles[i].is_trans == 0 || obj->styles[i].selector != tr->selector) continue;
 
         lv_style_value_t value_final;
-        switch (tr->prop) {
+        switch(tr->prop) {
 
             case LV_STYLE_BORDER_SIDE:
             case LV_STYLE_BORDER_POST:
@@ -727,12 +740,13 @@ static void trans_anim_cb(void * _tr, int32_t v)
         lv_style_value_t old_value;
         bool refr = true;
         if(lv_style_get_prop(obj->styles[i].style, tr->prop, &old_value)) {
-            if(value_final.ptr == old_value.ptr && value_final.color.full == old_value.color.full && value_final.num == old_value.num) {
+            if(value_final.ptr == old_value.ptr && value_final.color.full == old_value.color.full &&
+               value_final.num == old_value.num) {
                 refr = false;
             }
         }
         lv_style_set_prop(obj->styles[i].style, tr->prop, value_final);
-        if (refr) lv_obj_refresh_style(tr->obj, tr->selector, tr->prop);
+        if(refr) lv_obj_refresh_style(tr->obj, tr->selector, tr->prop);
         break;
 
     }
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style.h b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style.h
index 0ccbb23f4..d21f40cec 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style.h
@@ -38,10 +38,10 @@ typedef uint32_t lv_style_selector_t;
 
 typedef struct {
     lv_style_t * style;
-    uint32_t selector :24;
-    uint32_t is_local :1;
-    uint32_t is_trans :1;
-}_lv_obj_style_t;
+    uint32_t selector : 24;
+    uint32_t is_local : 1;
+    uint32_t is_trans : 1;
+} _lv_obj_style_t;
 
 typedef struct {
     uint16_t time;
@@ -52,7 +52,7 @@ typedef struct {
 #if LV_USE_USER_DATA
     void * user_data;
 #endif
-}_lv_obj_style_transition_dsc_t;
+} _lv_obj_style_transition_dsc_t;
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -138,9 +138,11 @@ lv_style_value_t lv_obj_get_style_prop(const struct _lv_obj_t * obj, lv_part_t p
  * @param prop      the property
  * @param value     value of the property. The correct element should be set according to the type of the property
  */
-void lv_obj_set_local_style_prop(struct _lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t value, lv_style_selector_t selector);
+void lv_obj_set_local_style_prop(struct _lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t value,
+                                 lv_style_selector_t selector);
 
-lv_res_t lv_obj_get_local_style_prop(struct _lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t * value, lv_style_selector_t selector);
+lv_res_t lv_obj_get_local_style_prop(struct _lv_obj_t * obj, lv_style_prop_t prop, lv_style_value_t * value,
+                                     lv_style_selector_t selector);
 
 /**
  * Remove a local style property from a part of an object with a given state.
@@ -153,14 +155,15 @@ lv_res_t lv_obj_get_local_style_prop(struct _lv_obj_t * obj, lv_style_prop_t pro
 bool lv_obj_remove_local_style_prop(struct _lv_obj_t * obj, lv_style_prop_t prop, lv_style_selector_t selector);
 
 /**
- * Used internally to create a style tarnsition
+ * Used internally to create a style transition
  * @param obj
  * @param part
  * @param prev_state
  * @param new_state
  * @param tr
  */
-void _lv_obj_style_create_transition(struct _lv_obj_t * obj, lv_part_t part, lv_state_t prev_state, lv_state_t new_state, const _lv_obj_style_transition_dsc_t * tr);
+void _lv_obj_style_create_transition(struct _lv_obj_t * obj, lv_part_t part, lv_state_t prev_state,
+                                     lv_state_t new_state, const _lv_obj_style_transition_dsc_t * tr);
 
 /**
  * Used internally to compare the appearance of an object in 2 states
@@ -193,33 +196,50 @@ lv_part_t lv_obj_style_get_selector_part(lv_style_selector_t selector);
 
 #include "lv_obj_style_gen.h"
 
-static inline void lv_obj_set_style_pad_all(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector) {
+static inline void lv_obj_set_style_pad_all(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
+{
     lv_obj_set_style_pad_left(obj, value, selector);
     lv_obj_set_style_pad_right(obj, value, selector);
     lv_obj_set_style_pad_top(obj, value, selector);
     lv_obj_set_style_pad_bottom(obj, value, selector);
 }
 
-static inline void lv_obj_set_style_pad_hor(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector) {
+static inline void lv_obj_set_style_pad_hor(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
+{
     lv_obj_set_style_pad_left(obj, value, selector);
     lv_obj_set_style_pad_right(obj, value, selector);
 }
 
-static inline void lv_obj_set_style_pad_ver(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector) {
+static inline void lv_obj_set_style_pad_ver(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
+{
     lv_obj_set_style_pad_top(obj, value, selector);
     lv_obj_set_style_pad_bottom(obj, value, selector);
 }
 
-static inline void lv_obj_set_style_pad_gap(struct _lv_obj_t * obj,  lv_coord_t value, lv_style_selector_t selector) {
+static inline void lv_obj_set_style_pad_gap(struct _lv_obj_t * obj,  lv_coord_t value, lv_style_selector_t selector)
+{
     lv_obj_set_style_pad_row(obj, value, selector);
     lv_obj_set_style_pad_column(obj, value, selector);
 }
 
-static inline void lv_obj_set_style_size(struct _lv_obj_t * obj,  lv_coord_t value, lv_style_selector_t selector) {
+static inline void lv_obj_set_style_size(struct _lv_obj_t * obj,  lv_coord_t value, lv_style_selector_t selector)
+{
     lv_obj_set_style_width(obj, value, selector);
     lv_obj_set_style_height(obj, value, selector);
 }
 
+lv_text_align_t lv_obj_calculate_style_text_align(const struct _lv_obj_t * obj, lv_part_t part, const char * txt);
+
+static inline lv_coord_t lv_obj_get_x_aligned(const struct _lv_obj_t * obj)
+{
+    return lv_obj_get_style_x(obj, LV_PART_MAIN);
+}
+
+static inline lv_coord_t lv_obj_get_y_aligned(const struct _lv_obj_t * obj)
+{
+    return lv_obj_get_style_y(obj, LV_PART_MAIN);
+}
+
 /**********************
  *      MACROS
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.c b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.c
index 47038e1a0..4cf91b329 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.c
@@ -631,7 +631,7 @@ void lv_obj_set_style_line_dash_gap(struct _lv_obj_t * obj, lv_coord_t value, lv
     lv_obj_set_local_style_prop(obj, LV_STYLE_LINE_DASH_GAP, v, selector);
 }
 
-void lv_obj_set_style_line_rounded(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
+void lv_obj_set_style_line_rounded(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector)
 {
     lv_style_value_t v = {
         .num = (int32_t)value
@@ -671,7 +671,7 @@ void lv_obj_set_style_arc_width(struct _lv_obj_t * obj, lv_coord_t value, lv_sty
     lv_obj_set_local_style_prop(obj, LV_STYLE_ARC_WIDTH, v, selector);
 }
 
-void lv_obj_set_style_arc_rounded(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
+void lv_obj_set_style_arc_rounded(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector)
 {
     lv_style_value_t v = {
         .num = (int32_t)value
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.h b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.h
index a0c53525a..40e490ea0 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.h
@@ -472,10 +472,10 @@ static inline lv_coord_t lv_obj_get_style_line_dash_gap(const struct _lv_obj_t *
     return (lv_coord_t)v.num;
 }
 
-static inline lv_coord_t lv_obj_get_style_line_rounded(const struct _lv_obj_t * obj, uint32_t part)
+static inline bool lv_obj_get_style_line_rounded(const struct _lv_obj_t * obj, uint32_t part)
 {
     lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_LINE_ROUNDED);
-    return (lv_coord_t)v.num;
+    return (bool)v.num;
 }
 
 static inline lv_color_t lv_obj_get_style_line_color(const struct _lv_obj_t * obj, uint32_t part)
@@ -502,10 +502,10 @@ static inline lv_coord_t lv_obj_get_style_arc_width(const struct _lv_obj_t * obj
     return (lv_coord_t)v.num;
 }
 
-static inline lv_coord_t lv_obj_get_style_arc_rounded(const struct _lv_obj_t * obj, uint32_t part)
+static inline bool lv_obj_get_style_arc_rounded(const struct _lv_obj_t * obj, uint32_t part)
 {
     lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_ARC_ROUNDED);
-    return (lv_coord_t)v.num;
+    return (bool)v.num;
 }
 
 static inline lv_color_t lv_obj_get_style_arc_color(const struct _lv_obj_t * obj, uint32_t part)
@@ -611,12 +611,12 @@ void lv_obj_set_style_shadow_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_styl
 void lv_obj_set_style_line_width(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
 void lv_obj_set_style_line_dash_width(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
 void lv_obj_set_style_line_dash_gap(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
-void lv_obj_set_style_line_rounded(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
+void lv_obj_set_style_line_rounded(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector);
 void lv_obj_set_style_line_color(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
 void lv_obj_set_style_line_color_filtered(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
 void lv_obj_set_style_line_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
 void lv_obj_set_style_arc_width(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
-void lv_obj_set_style_arc_rounded(struct _lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector);
+void lv_obj_set_style_arc_rounded(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector);
 void lv_obj_set_style_arc_color(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
 void lv_obj_set_style_arc_color_filtered(struct _lv_obj_t * obj, lv_color_t value, lv_style_selector_t selector);
 void lv_obj_set_style_arc_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.c b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.c
index 4d3709aaa..3adf72183 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.c
@@ -6,6 +6,8 @@
 /*********************
  *      INCLUDES
  *********************/
+#include <stdlib.h>
+
 #include "lv_obj.h"
 #include "lv_indev.h"
 #include "../misc/lv_anim.h"
@@ -17,10 +19,6 @@
  *********************/
 #define MY_CLASS &lv_obj_class
 
-#if defined(LV_USER_DATA_FREE_INCLUDE)
-    #include LV_USER_DATA_FREE_INCLUDE
-#endif /*LV_USE_USER_DATA_FREE*/
-
 /**********************
  *      TYPEDEFS
  **********************/
@@ -46,7 +44,7 @@ static lv_obj_tree_walk_res_t walk_core(lv_obj_t * obj, lv_obj_tree_walk_cb_t cb
 
 void lv_obj_del(lv_obj_t * obj)
 {
-    LV_LOG_TRACE("begin (delete %p)", obj)
+    LV_LOG_TRACE("begin (delete %p)", (void *)obj);
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_obj_invalidate(obj);
 
@@ -70,21 +68,22 @@ void lv_obj_del(lv_obj_t * obj)
         lv_obj_readjust_scroll(par, LV_ANIM_OFF);
         lv_obj_scrollbar_invalidate(par);
         lv_event_send(par, LV_EVENT_CHILD_CHANGED, NULL);
+        lv_event_send(par, LV_EVENT_CHILD_DELETED, NULL);
     }
 
     /*Handle if the active screen was deleted*/
-    if(act_scr_del)  {
-        LV_LOG_WARN("the active screen was deleted")
+    if(act_scr_del) {
+        LV_LOG_WARN("the active screen was deleted");
         disp->act_scr = NULL;
     }
 
     LV_ASSERT_MEM_INTEGRITY();
-    LV_LOG_TRACE("finished (delete %p)", obj)
+    LV_LOG_TRACE("finished (delete %p)", (void *)obj);
 }
 
 void lv_obj_clean(lv_obj_t * obj)
 {
-    LV_LOG_TRACE("begin (delete %p)", obj)
+    LV_LOG_TRACE("begin (delete %p)", (void *)obj);
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
     lv_obj_invalidate(obj);
@@ -103,7 +102,19 @@ void lv_obj_clean(lv_obj_t * obj)
 
     LV_ASSERT_MEM_INTEGRITY();
 
-    LV_LOG_TRACE("finished (delete %p)", obj)
+    LV_LOG_TRACE("finished (delete %p)", (void *)obj);
+}
+
+void lv_obj_del_delayed(lv_obj_t * obj, uint32_t delay_ms)
+{
+    lv_anim_t a;
+    lv_anim_init(&a);
+    lv_anim_set_var(&a, obj);
+    lv_anim_set_exec_cb(&a, NULL);
+    lv_anim_set_time(&a, 1);
+    lv_anim_set_delay(&a, delay_ms);
+    lv_anim_set_ready_cb(&a, lv_obj_del_anim_ready_cb);
+    lv_anim_start(&a);
 }
 
 void lv_obj_del_anim_ready_cb(lv_anim_t * a)
@@ -137,90 +148,101 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
     lv_obj_allocate_spec_attr(parent);
 
     lv_obj_t * old_parent = obj->parent;
-    lv_point_t old_pos;
-    old_pos.y = lv_obj_get_y(obj);
-
-    lv_base_dir_t new_base_dir = lv_obj_get_style_base_dir(parent, LV_PART_MAIN);
-
-    if(new_base_dir != LV_BASE_DIR_RTL) old_pos.x = lv_obj_get_x(obj);
-    else  old_pos.x = old_parent->coords.x2 - obj->coords.x2;
-
     /*Remove the object from the old parent's child list*/
     int32_t i;
-    for(i = lv_obj_get_child_id(obj); i <= (int32_t)lv_obj_get_child_cnt(old_parent) - 2; i++) {
-        old_parent->spec_attr->children[i] = old_parent->spec_attr->children[i+1];
+    for(i = lv_obj_get_index(obj); i <= (int32_t)lv_obj_get_child_cnt(old_parent) - 2; i++) {
+        old_parent->spec_attr->children[i] = old_parent->spec_attr->children[i + 1];
     }
     old_parent->spec_attr->child_cnt--;
     if(old_parent->spec_attr->child_cnt) {
-        old_parent->spec_attr->children = lv_mem_realloc(old_parent->spec_attr->children, old_parent->spec_attr->child_cnt * (sizeof(lv_obj_t *)));
-    } else {
+        old_parent->spec_attr->children = lv_mem_realloc(old_parent->spec_attr->children,
+                                                         old_parent->spec_attr->child_cnt * (sizeof(lv_obj_t *)));
+    }
+    else {
         lv_mem_free(old_parent->spec_attr->children);
         old_parent->spec_attr->children = NULL;
     }
 
     /*Add the child to the new parent as the last (newest child)*/
     parent->spec_attr->child_cnt++;
-    parent->spec_attr->children = lv_mem_realloc(parent->spec_attr->children, parent->spec_attr->child_cnt * (sizeof(lv_obj_t *)));
+    parent->spec_attr->children = lv_mem_realloc(parent->spec_attr->children,
+                                                 parent->spec_attr->child_cnt * (sizeof(lv_obj_t *)));
     parent->spec_attr->children[lv_obj_get_child_cnt(parent) - 1] = obj;
 
     obj->parent = parent;
 
-    if(new_base_dir != LV_BASE_DIR_RTL) {
-        lv_obj_set_pos(obj, old_pos.x, old_pos.y);
-    }
-    else {
-        /*Align to the right in case of RTL base dir*/
-        lv_coord_t new_x = lv_obj_get_width(parent) - old_pos.x - lv_obj_get_width(obj);
-        lv_obj_set_pos(obj, new_x, old_pos.y);
-    }
-
     /*Notify the original parent because one of its children is lost*/
     lv_event_send(old_parent, LV_EVENT_CHILD_CHANGED, obj);
+    lv_event_send(old_parent, LV_EVENT_CHILD_DELETED, NULL);
 
     /*Notify the new parent about the child*/
     lv_event_send(parent, LV_EVENT_CHILD_CHANGED, obj);
+    lv_event_send(parent, LV_EVENT_CHILD_CREATED, NULL);
+
+    lv_obj_mark_layout_as_dirty(obj);
 
     lv_obj_invalidate(obj);
 }
 
-void lv_obj_move_foreground(lv_obj_t * obj)
+void lv_obj_move_to_index(lv_obj_t * obj, int32_t index)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
+    const int32_t old_index = lv_obj_get_index(obj);
+
     lv_obj_t * parent = lv_obj_get_parent(obj);
 
-    lv_obj_invalidate(parent);
+    if(index < 0) return;
+    if(index >= (int32_t) lv_obj_get_child_cnt(parent)) return;
+    if(index == old_index) return;
 
-    uint32_t i;
-    for(i = lv_obj_get_child_id(obj); i < lv_obj_get_child_cnt(parent) - 1; i++) {
-        parent->spec_attr->children[i] = parent->spec_attr->children[i + 1];
+    int32_t i = old_index;
+    if(index < old_index) {
+        while(i > index)  {
+            parent->spec_attr->children[i] = parent->spec_attr->children[i - 1];
+            i--;
+        }
+    }
+    else {
+        while(i < index) {
+            parent->spec_attr->children[i] = parent->spec_attr->children[i + 1];
+            i++;
+        }
     }
-    parent->spec_attr->children[lv_obj_get_child_cnt(parent) - 1] = obj;
-
-    /*Notify the new parent about the child*/
-    lv_event_send(parent, LV_EVENT_CHILD_CHANGED, obj);
 
+    parent->spec_attr->children[index] = obj;
+    lv_event_send(parent, LV_EVENT_CHILD_CHANGED, NULL);
     lv_obj_invalidate(parent);
 }
 
-void lv_obj_move_background(lv_obj_t * obj)
+void lv_obj_swap(lv_obj_t * obj1, lv_obj_t * obj2)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
+    LV_ASSERT_OBJ(obj1, MY_CLASS);
+    LV_ASSERT_OBJ(obj2, MY_CLASS);
 
-    lv_obj_t * parent = lv_obj_get_parent(obj);
+    lv_obj_t * parent = lv_obj_get_parent(obj1);
+    lv_obj_t * parent2 = lv_obj_get_parent(obj2);
+
+    uint_fast32_t index1 = lv_obj_get_index(obj1);
+    uint_fast32_t index2 = lv_obj_get_index(obj2);
+
+    lv_event_send(parent2, LV_EVENT_CHILD_DELETED, obj2);
+    lv_event_send(parent, LV_EVENT_CHILD_DELETED, obj1);
+
+    parent->spec_attr->children[index1] = obj2;
+    parent2->spec_attr->children[index2] = obj1;
+
+    lv_event_send(parent, LV_EVENT_CHILD_CHANGED, obj2);
+    lv_event_send(parent, LV_EVENT_CHILD_CREATED, obj2);
+    lv_event_send(parent2, LV_EVENT_CHILD_CHANGED, obj1);
+    lv_event_send(parent2, LV_EVENT_CHILD_CREATED, obj1);
 
     lv_obj_invalidate(parent);
 
-    int32_t i;
-    for(i = lv_obj_get_child_id(obj); i > 0; i--) {
-        parent->spec_attr->children[i] = parent->spec_attr->children[i-1];
+    if(parent != parent2) {
+        lv_obj_invalidate(parent2);
     }
-    parent->spec_attr->children[0] = obj;
-
-    /*Notify the new parent about the child*/
-    lv_event_send(parent, LV_EVENT_CHILD_CHANGED, obj);
-
-    lv_obj_invalidate(parent);
+    lv_group_swap_obj(obj1, obj2);
 }
 
 lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj)
@@ -232,10 +254,10 @@ lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj)
 
     do {
         act_par = par;
-        par   = lv_obj_get_parent(act_par);
+        par = lv_obj_get_parent(act_par);
     } while(par != NULL);
 
-    return (lv_obj_t*)act_par;
+    return (lv_obj_t *)act_par;
 }
 
 lv_disp_t * lv_obj_get_disp(const lv_obj_t * obj)
@@ -255,7 +277,7 @@ lv_disp_t * lv_obj_get_disp(const lv_obj_t * obj)
         }
     }
 
-    LV_LOG_WARN("No screen found")
+    LV_LOG_WARN("No screen found");
     return NULL;
 }
 
@@ -278,7 +300,8 @@ lv_obj_t * lv_obj_get_child(const lv_obj_t * obj, int32_t id)
         id = obj->spec_attr->child_cnt + id;
         if(id < 0) return NULL;
         idu = (uint32_t) id;
-    } else {
+    }
+    else {
         idu = id;
     }
 
@@ -293,7 +316,7 @@ uint32_t lv_obj_get_child_cnt(const lv_obj_t * obj)
     return obj->spec_attr->child_cnt;
 }
 
-uint32_t lv_obj_get_child_id(const lv_obj_t * obj)
+uint32_t lv_obj_get_index(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
@@ -308,7 +331,6 @@ uint32_t lv_obj_get_child_id(const lv_obj_t * obj)
     return 0xFFFFFFFF; /*Shouldn't happen*/
 }
 
-
 void lv_obj_tree_walk(lv_obj_t * start_obj, lv_obj_tree_walk_cb_t cb, void * user_data)
 {
     walk_core(start_obj, cb, user_data);
@@ -377,13 +399,14 @@ static void obj_del_core(lv_obj_t * obj)
     }
     /*Remove the object from the child list of its parent*/
     else {
-        uint32_t id = lv_obj_get_child_id(obj);
+        uint32_t id = lv_obj_get_index(obj);
         uint32_t i;
         for(i = id; i < obj->parent->spec_attr->child_cnt - 1; i++) {
             obj->parent->spec_attr->children[i] = obj->parent->spec_attr->children[i + 1];
         }
         obj->parent->spec_attr->child_cnt--;
-        obj->parent->spec_attr->children = lv_mem_realloc(obj->parent->spec_attr->children, obj->parent->spec_attr->child_cnt * sizeof(lv_obj_t *));
+        obj->parent->spec_attr->children = lv_mem_realloc(obj->parent->spec_attr->children,
+                                                          obj->parent->spec_attr->child_cnt * sizeof(lv_obj_t *));
     }
 
     /*Free the object itself*/
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.h b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.h
index 7cb241eaf..1c714c420 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.h
@@ -41,7 +41,7 @@ typedef lv_obj_tree_walk_res_t (*lv_obj_tree_walk_cb_t)(struct _lv_obj_t *, void
  **********************/
 
 /**
- * Delete an object and all of it's children.
+ * Delete an object and all of its children.
  * Also remove the objects from their group and remove all animations (if any).
  * Send `LV_EVENT_DELETED` to deleted objects.
  * @param obj       pointer to an object
@@ -56,6 +56,13 @@ void lv_obj_del(struct _lv_obj_t * obj);
  */
 void lv_obj_clean(struct _lv_obj_t * obj);
 
+/**
+ * Delete an object after some delay
+ * @param obj       pointer to an object
+ * @param delay_ms  time to wait before delete in milliseconds
+ */
+void lv_obj_del_delayed(struct _lv_obj_t * obj, uint32_t delay_ms);
+
 /**
  * A function to be easily used in animation ready callback to delete an object when the animation is ready
  * @param a         pointer to the animation
@@ -79,32 +86,34 @@ void lv_obj_del_async(struct _lv_obj_t * obj);
 void lv_obj_set_parent(struct _lv_obj_t * obj, struct _lv_obj_t * parent);
 
 /**
- * Move the object to the foreground.
- * It will look like if it was created as the last child of its parent.
- * It also means it can cover any of the siblings.
- * @param obj       pointer to an object
+ * Swap the positions of two objects.
+ * When used in listboxes, it can be used to sort the listbox items.
+ * @param obj1  pointer to the first object
+ * @param obj2  pointer to the second object
  */
-void lv_obj_move_foreground(struct _lv_obj_t * obj);
+void lv_obj_swap(struct _lv_obj_t * obj1, struct _lv_obj_t * obj2);
 
 /**
- * Move the object to the background.
- * It will look like if it was created as the first child of its parent.
- * It also means any of the siblings can cover the object.
- * @param obj       pointer to an object
+ * moves the object to the given index in its parent.
+ * When used in listboxes, it can be used to sort the listbox items.
+ * @param obj  pointer to the object to be moved.
+ * @param index  new index in parent.
+ * @note to move to the foreground: lv_obj_move_to_index(obj, 0)
+ * @note to move forward (up): lv_obj_move_to_index(obj, lv_obj_get_index(obj) - 1)
  */
-void lv_obj_move_background(struct _lv_obj_t * obj);
+void lv_obj_move_to_index(struct _lv_obj_t * obj, int32_t index);
 
 /**
  * Get the screen of an object
  * @param obj       pointer to an object
- * @return          pointer to the obejct's screen
+ * @return          pointer to the object's screen
  */
 struct _lv_obj_t * lv_obj_get_screen(const struct _lv_obj_t * obj);
 
 /**
  * Get the display of the object
  * @param obj       pointer to an object
- * @return          pointer to the obejct's display
+ * @return          pointer to the object's display
  */
 lv_disp_t * lv_obj_get_disp(const struct _lv_obj_t * obj);
 
@@ -137,11 +146,11 @@ uint32_t lv_obj_get_child_cnt(const struct _lv_obj_t * obj);
 
 /**
  * Get the index of a child.
- * @param obj       pointer to an obejct
+ * @param obj       pointer to an object
  * @return          the child index of the object.
  *                  E.g. 0: the oldest (firstly created child)
  */
-uint32_t lv_obj_get_child_id(const struct _lv_obj_t * obj);
+uint32_t lv_obj_get_index(const struct _lv_obj_t * obj);
 
 /**
  * Iterate through all children of any object.
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_refr.c b/lib/libesp32_lvgl/lvgl/src/core/lv_refr.c
index abd3976ad..a44060a5e 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_refr.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_refr.c
@@ -57,9 +57,9 @@ static lv_disp_t * disp_refr; /*Display being refreshed*/
  *      MACROS
  **********************/
 #if LV_LOG_TRACE_DISP_REFR
-#  define TRACE_REFR(...) LV_LOG_TRACE( __VA_ARGS__)
+    #define REFR_TRACE(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
-#  define TRACE_REFR(...)
+    #define REFR_TRACE(...)
 #endif
 
 /**********************
@@ -181,10 +181,10 @@ void _lv_refr_set_disp_refreshing(lv_disp_t * disp)
  */
 void _lv_disp_refr_timer(lv_timer_t * tmr)
 {
-    TRACE_REFR("begin");
+    REFR_TRACE("begin");
 
     uint32_t start = lv_tick_get();
-    uint32_t elaps = 0;
+    volatile uint32_t elaps = 0;
 
     disp_refr = tmr->user_data;
 
@@ -207,7 +207,7 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
     if(disp_refr->act_scr == NULL) {
         disp_refr->inv_p = 0;
         LV_LOG_WARN("there is no active screen");
-        TRACE_REFR("finished");
+        REFR_TRACE("finished");
         return;
     }
 
@@ -236,6 +236,10 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
     lv_mem_buf_free_all();
     _lv_font_clean_up_fmt_txt();
 
+#if LV_DRAW_COMPLEX
+    _lv_draw_mask_cleanup();
+#endif
+
 #if LV_USE_PERF_MONITOR && LV_USE_LABEL
     static lv_obj_t * perf_label = NULL;
     if(perf_label == NULL) {
@@ -249,7 +253,7 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
         lv_obj_set_style_pad_right(perf_label, 3, 0);
         lv_obj_set_style_text_align(perf_label, LV_TEXT_ALIGN_RIGHT, 0);
         lv_label_set_text(perf_label, "?");
-        lv_obj_align(perf_label, LV_ALIGN_BOTTOM_RIGHT, 0, 0);
+        lv_obj_align(perf_label, LV_USE_PERF_MONITOR_POS, 0, 0);
     }
 
     static uint32_t perf_last_time = 0;
@@ -264,7 +268,7 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
     else {
         perf_last_time = lv_tick_get();
         uint32_t fps_limit = 1000 / disp_refr->refr_timer->period;
-        uint32_t fps;
+        unsigned int fps;
 
         if(elaps_sum == 0) elaps_sum = 1;
         if(frame_cnt == 0) fps = fps_limit;
@@ -275,8 +279,8 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
 
         fps_sum_all += fps;
         fps_sum_cnt ++;
-        uint32_t cpu = 100 - lv_timer_get_idle();
-        lv_label_set_text_fmt(perf_label, "%d FPS\n%d%% CPU", fps, cpu);
+        unsigned int cpu = 100 - lv_timer_get_idle();
+        lv_label_set_text_fmt(perf_label, "%u FPS\n%u%% CPU", fps, cpu);
     }
 #endif
 
@@ -292,7 +296,7 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
         lv_obj_set_style_pad_left(mem_label, 3, 0);
         lv_obj_set_style_pad_right(mem_label, 3, 0);
         lv_label_set_text(mem_label, "?");
-        lv_obj_align(mem_label, LV_ALIGN_BOTTOM_LEFT, 0, 0);
+        lv_obj_align(mem_label, LV_USE_MEM_MONITOR_POS, 0, 0);
     }
 
     static uint32_t mem_last_time = 0;
@@ -303,11 +307,13 @@ void _lv_disp_refr_timer(lv_timer_t * tmr)
         uint32_t used_size = mon.total_size - mon.free_size;;
         uint32_t used_kb = used_size / 1024;
         uint32_t used_kb_tenth = (used_size - (used_kb * 1024)) / 102;
-        lv_label_set_text_fmt(mem_label, "%d.%d kB used (%d %%)\n%d%% frag.", used_kb,  used_kb_tenth, mon.used_pct, mon.frag_pct);
+        lv_label_set_text_fmt(mem_label, "%" LV_PRIu32 ".%" LV_PRIu32 " kB used (%d %%)\n" \
+                              "%d%% frag.", used_kb, used_kb_tenth, mon.used_pct,
+                              mon.frag_pct);
     }
 #endif
 
-    TRACE_REFR("finished");
+    REFR_TRACE("finished");
 }
 
 #if LV_USE_PERF_MONITOR
@@ -417,7 +423,7 @@ static void lv_refr_area(const lv_area_t * area_p)
     lv_coord_t w = lv_area_get_width(area_p);
     lv_coord_t h = lv_area_get_height(area_p);
     lv_coord_t y2 = area_p->y2 >= lv_disp_get_ver_res(disp_refr) ?
-                        lv_disp_get_ver_res(disp_refr) - 1 : area_p->y2;
+                    lv_disp_get_ver_res(disp_refr) - 1 : area_p->y2;
 
     int32_t max_row = (uint32_t)draw_buf->size / w;
 
@@ -452,31 +458,43 @@ static void lv_refr_area(const lv_area_t * area_p)
         }
     }
 
-    /*Always use the full row*/
-    lv_coord_t row;
-    lv_coord_t row_last = 0;
-    for(row = area_p->y1; row + max_row - 1 <= y2; row += max_row) {
-        /*Calc. the next y coordinates of draw_buf*/
-        draw_buf->area.x1 = area_p->x1;
-        draw_buf->area.x2 = area_p->x2;
-        draw_buf->area.y1 = row;
-        draw_buf->area.y2 = row + max_row - 1;
-        if(draw_buf->area.y2 > y2) draw_buf->area.y2 = y2;
-        row_last = draw_buf->area.y2;
-        if(y2 == row_last) disp_refr->driver->draw_buf->last_part = 1;
+    /*In direct mode draw directly on the absolute coordinates of the buffer*/
+    if(disp_refr->driver->direct_mode) {
+        draw_buf->area.x1 = 0;
+        draw_buf->area.x2 = lv_disp_get_hor_res(disp_refr) - 1;
+        draw_buf->area.y1 = 0;
+        draw_buf->area.y2 = lv_disp_get_ver_res(disp_refr) - 1;
+        disp_refr->driver->draw_buf->last_part = disp_refr->driver->draw_buf->last_area;
         lv_refr_area_part(area_p);
     }
+    /*Else assume the buffer starts at the given area*/
+    else {
+        /*Always use the full row*/
+        lv_coord_t row;
+        lv_coord_t row_last = 0;
+        for(row = area_p->y1; row + max_row - 1 <= y2; row += max_row) {
+            /*Calc. the next y coordinates of draw_buf*/
+            draw_buf->area.x1 = area_p->x1;
+            draw_buf->area.x2 = area_p->x2;
+            draw_buf->area.y1 = row;
+            draw_buf->area.y2 = row + max_row - 1;
+            if(draw_buf->area.y2 > y2) draw_buf->area.y2 = y2;
+            row_last = draw_buf->area.y2;
+            if(y2 == row_last) disp_refr->driver->draw_buf->last_part = 1;
+            lv_refr_area_part(area_p);
+        }
 
-    /*If the last y coordinates are not handled yet ...*/
-    if(y2 != row_last) {
-        /*Calc. the next y coordinates of draw_buf*/
-        draw_buf->area.x1 = area_p->x1;
-        draw_buf->area.x2 = area_p->x2;
-        draw_buf->area.y1 = row;
-        draw_buf->area.y2 = y2;
+        /*If the last y coordinates are not handled yet ...*/
+        if(y2 != row_last) {
+            /*Calc. the next y coordinates of draw_buf*/
+            draw_buf->area.x1 = area_p->x1;
+            draw_buf->area.x2 = area_p->x2;
+            draw_buf->area.y1 = row;
+            draw_buf->area.y2 = y2;
 
-        disp_refr->driver->draw_buf->last_part = 1;
-        lv_refr_area_part(area_p);
+            disp_refr->driver->draw_buf->last_part = 1;
+            lv_refr_area_part(area_p);
+        }
     }
 }
 
@@ -488,8 +506,12 @@ static void lv_refr_area_part(const lv_area_t * area_p)
 {
     lv_disp_draw_buf_t * draw_buf = lv_disp_get_draw_buf(disp_refr);
 
-    while(draw_buf->flushing) {
-        if(disp_refr->driver->wait_cb) disp_refr->driver->wait_cb(disp_refr->driver);
+    /* Below the `area_p` area will be redrawn into the draw buffer.
+     * In single buffered mode wait here until the buffer is freed.*/
+    if(draw_buf->buf1 && !draw_buf->buf2) {
+        while(draw_buf->flushing) {
+            if(disp_refr->driver->wait_cb) disp_refr->driver->wait_cb(disp_refr->driver);
+        }
     }
 
     lv_obj_t * top_act_scr = NULL;
@@ -508,7 +530,9 @@ static void lv_refr_area_part(const lv_area_t * area_p)
 
     /*Draw a display background if there is no top object*/
     if(top_act_scr == NULL && top_prev_scr == NULL) {
-        if(disp_refr->bg_img) {
+        if(disp_refr->bg_fn) {
+            disp_refr->bg_fn(&start_mask);
+        } else if(disp_refr->bg_img) {
             lv_draw_img_dsc_t dsc;
             lv_draw_img_dsc_init(&dsc);
             dsc.opa = disp_refr->bg_opa;
@@ -521,7 +545,7 @@ static void lv_refr_area_part(const lv_area_t * area_p)
                 lv_draw_img(&a, &start_mask, disp_refr->bg_img, &dsc);
             }
             else {
-                LV_LOG_WARN("Can't draw the background image")
+                LV_LOG_WARN("Can't draw the background image");
             }
         }
         else {
@@ -580,8 +604,9 @@ static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
         if(info.res == LV_COVER_RES_MASKED) return NULL;
 
         uint32_t i;
-        for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-            lv_obj_t * child = lv_obj_get_child(obj, i);
+        uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+        for(i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = obj->spec_attr->children[i];
             found_p = lv_refr_get_top_obj(area_p, child);
 
             /*If a children is ok then break*/
@@ -627,20 +652,22 @@ static void lv_refr_obj_and_children(lv_obj_t * top_p, const lv_area_t * mask_p)
     while(par != NULL) {
         bool go = false;
         uint32_t i;
-        for(i = 0; i < lv_obj_get_child_cnt(par); i++) {
-            lv_obj_t * child = lv_obj_get_child(par, i);
+        uint32_t child_cnt = lv_obj_get_child_cnt(par);
+        for(i = 0; i < child_cnt; i++) {
+            lv_obj_t * child = par->spec_attr->children[i];
             if(!go) {
                 if(child == border_p) go = true;
-            } else {
+            }
+            else {
                 /*Refresh the objects*/
                 lv_refr_obj(child, mask_p);
             }
         }
 
         /*Call the post draw draw function of the parents of the to object*/
-        lv_event_send(par, LV_EVENT_DRAW_POST_BEGIN, (void*)mask_p);
-        lv_event_send(par, LV_EVENT_DRAW_POST, (void*)mask_p);
-        lv_event_send(par, LV_EVENT_DRAW_POST_END, (void*)mask_p);
+        lv_event_send(par, LV_EVENT_DRAW_POST_BEGIN, (void *)mask_p);
+        lv_event_send(par, LV_EVENT_DRAW_POST, (void *)mask_p);
+        lv_event_send(par, LV_EVENT_DRAW_POST_END, (void *)mask_p);
 
         /*The new border will be the last parents,
          *so the 'younger' brothers of parent will be refreshed*/
@@ -699,8 +726,9 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
             lv_area_t mask_child; /*Mask from obj and its child*/
             lv_area_t child_area;
             uint32_t i;
-            for(i = 0; i < lv_obj_get_child_cnt(obj); i++) {
-                lv_obj_t * child = lv_obj_get_child(obj, i);
+            uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+            for(i = 0; i < child_cnt; i++) {
+                lv_obj_t * child = obj->spec_attr->children[i];
                 lv_obj_get_coords(child, &child_area);
                 ext_size = _lv_obj_get_ext_draw_size(child);
                 child_area.x1 -= ext_size;
@@ -726,7 +754,8 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
     }
 }
 
-static void draw_buf_rotate_180(lv_disp_drv_t *drv, lv_area_t *area, lv_color_t *color_p) {
+static void draw_buf_rotate_180(lv_disp_drv_t * drv, lv_area_t * area, lv_color_t * color_p)
+{
     lv_coord_t area_w = lv_area_get_width(area);
     lv_coord_t area_h = lv_area_get_height(area);
     uint32_t total = area_w * area_h;
@@ -749,7 +778,9 @@ static void draw_buf_rotate_180(lv_disp_drv_t *drv, lv_area_t *area, lv_color_t
     area->x1 = drv->hor_res - tmp_coord - 1;
 }
 
-static LV_ATTRIBUTE_FAST_MEM void draw_buf_rotate_90(bool invert_i, lv_coord_t area_w, lv_coord_t area_h, lv_color_t *orig_color_p, lv_color_t *rot_buf) {
+static LV_ATTRIBUTE_FAST_MEM void draw_buf_rotate_90(bool invert_i, lv_coord_t area_w, lv_coord_t area_h,
+                                                     lv_color_t * orig_color_p, lv_color_t * rot_buf)
+{
 
     uint32_t invert = (area_w * area_h) - 1;
     uint32_t initial_i = ((area_w - 1) * area_h);
@@ -770,7 +801,8 @@ static LV_ATTRIBUTE_FAST_MEM void draw_buf_rotate_90(bool invert_i, lv_coord_t a
 /**
  * Helper function for draw_buf_rotate_90_sqr. Given a list of four numbers, rotate the entire list to the left.
  */
-static inline void draw_buf_rotate4(lv_color_t *a, lv_color_t *b, lv_color_t * c, lv_color_t * d) {
+static inline void draw_buf_rotate4(lv_color_t * a, lv_color_t * b, lv_color_t * c, lv_color_t * d)
+{
     lv_color_t tmp;
     tmp = *a;
     *a = *b;
@@ -783,9 +815,10 @@ static inline void draw_buf_rotate4(lv_color_t *a, lv_color_t *b, lv_color_t * c
  * Rotate a square image 90/270 degrees in place.
  * @note inspired by https://stackoverflow.com/a/43694906
  */
-static void draw_buf_rotate_90_sqr(bool is_270, lv_coord_t w, lv_color_t * color_p) {
-    for(lv_coord_t i = 0; i < w/2; i++) {
-        for(lv_coord_t j = 0; j < (w + 1)/2; j++) {
+static void draw_buf_rotate_90_sqr(bool is_270, lv_coord_t w, lv_color_t * color_p)
+{
+    for(lv_coord_t i = 0; i < w / 2; i++) {
+        for(lv_coord_t j = 0; j < (w + 1) / 2; j++) {
             lv_coord_t inv_i = (w - 1) - i;
             lv_coord_t inv_j = (w - 1) - j;
             if(is_270) {
@@ -795,7 +828,8 @@ static void draw_buf_rotate_90_sqr(bool is_270, lv_coord_t w, lv_color_t * color
                     &color_p[inv_i * w + inv_j],
                     &color_p[j * w + inv_i]
                 );
-            } else {
+            }
+            else {
                 draw_buf_rotate4(
                     &color_p[i * w + j],
                     &color_p[j * w + inv_i],
@@ -811,7 +845,8 @@ static void draw_buf_rotate_90_sqr(bool is_270, lv_coord_t w, lv_color_t * color
 /**
  * Rotate the draw_buf to the display's native orientation.
  */
-static void draw_buf_rotate(lv_area_t *area, lv_color_t *color_p) {
+static void draw_buf_rotate(lv_area_t * area, lv_color_t * color_p)
+{
     lv_disp_drv_t * drv = disp_refr->driver;
     if(disp_refr->driver->full_refresh && drv->sw_rotate) {
         LV_LOG_ERROR("cannot rotate a full refreshed display!");
@@ -820,14 +855,15 @@ static void draw_buf_rotate(lv_area_t *area, lv_color_t *color_p) {
     if(drv->rotated == LV_DISP_ROT_180) {
         draw_buf_rotate_180(drv, area, color_p);
         call_flush_cb(drv, area, color_p);
-    } else if(drv->rotated == LV_DISP_ROT_90 || drv->rotated == LV_DISP_ROT_270) {
+    }
+    else if(drv->rotated == LV_DISP_ROT_90 || drv->rotated == LV_DISP_ROT_270) {
         /*Allocate a temporary buffer to store rotated image*/
         lv_color_t * rot_buf = NULL;
         lv_disp_draw_buf_t * draw_buf = lv_disp_get_draw_buf(disp_refr);
         lv_coord_t area_w = lv_area_get_width(area);
         lv_coord_t area_h = lv_area_get_height(area);
         /*Determine the maximum number of rows that can be rotated at a time*/
-        lv_coord_t max_row = LV_MIN((lv_coord_t)((LV_DISP_ROT_MAX_BUF/sizeof(lv_color_t)) / area_w), area_h);
+        lv_coord_t max_row = LV_MIN((lv_coord_t)((LV_DISP_ROT_MAX_BUF / sizeof(lv_color_t)) / area_w), area_h);
         lv_coord_t init_y_off;
         init_y_off = area->y1;
         if(drv->rotated == LV_DISP_ROT_90) {
@@ -838,11 +874,11 @@ static void draw_buf_rotate(lv_area_t *area, lv_color_t *color_p) {
             area->y1 = area->x1;
             area->y2 = area->y1 + area_w - 1;
         }
-        draw_buf->flushing = 0;
+
         /*Rotate the screen in chunks, flushing after each one*/
         lv_coord_t row = 0;
         while(row < area_h) {
-            lv_coord_t height = LV_MIN(max_row, area_h-row);
+            lv_coord_t height = LV_MIN(max_row, area_h - row);
             draw_buf->flushing = 1;
             if((row == 0) && (area_h >= area_w)) {
                 /*Rotate the initial area as a square*/
@@ -871,6 +907,16 @@ static void draw_buf_rotate(lv_area_t *area, lv_color_t *color_p) {
                     area->x1 = area->x2 - height + 1;
                 }
             }
+
+            /* The original part (chunk of the current area) were split into more parts here.
+             * Set the original last_part flag on the last part of rotation. */
+            if(row + height >= area_h && draw_buf->last_area && draw_buf->last_part) {
+                draw_buf->flushing_last = 1;
+            }
+            else {
+                draw_buf->flushing_last = 0;
+            }
+
             /*Flush the completed area to the display*/
             call_flush_cb(drv, area, rot_buf == NULL ? color_p : rot_buf);
             /*FIXME: Rotation forces legacy behavior where rendering and flushing are done serially*/
@@ -893,20 +939,29 @@ static void draw_buf_flush(void)
     lv_disp_draw_buf_t * draw_buf = lv_disp_get_draw_buf(disp_refr);
     lv_color_t * color_p = draw_buf->buf_act;
 
+    /*Flush the rendered content to the display*/
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    if(disp->driver->gpu_wait_cb) disp->driver->gpu_wait_cb(disp->driver);
+
+    /* In double buffered mode wait until the other buffer is freed
+     * and driver is ready to receive the new buffer */
+    if(draw_buf->buf1 && draw_buf->buf2) {
+        while(draw_buf->flushing) {
+            if(disp_refr->driver->wait_cb) disp_refr->driver->wait_cb(disp_refr->driver);
+        }
+    }
+
     draw_buf->flushing = 1;
 
     if(disp_refr->driver->draw_buf->last_area && disp_refr->driver->draw_buf->last_part) draw_buf->flushing_last = 1;
     else draw_buf->flushing_last = 0;
 
-    /*Flush the rendered content to the display*/
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    if(disp->driver->gpu_wait_cb) disp->driver->gpu_wait_cb(disp->driver);
-
     if(disp->driver->flush_cb) {
         /*Rotate the buffer to the display's native orientation if necessary*/
         if(disp->driver->rotated != LV_DISP_ROT_NONE && disp->driver->sw_rotate) {
             draw_buf_rotate(&draw_buf->area, draw_buf->buf_act);
-        } else {
+        }
+        else {
             call_flush_cb(disp->driver, &draw_buf->area, color_p);
         }
     }
@@ -920,6 +975,15 @@ static void draw_buf_flush(void)
 
 static void call_flush_cb(lv_disp_drv_t * drv, const lv_area_t * area, lv_color_t * color_p)
 {
-    TRACE_REFR("Calling flush_cb on (%d;%d)(%d;%d) area with %p image pointer", area->x1, area->y1, area->x2, area->y2, color_p);
-    drv->flush_cb(drv, area, color_p);
+    REFR_TRACE("Calling flush_cb on (%d;%d)(%d;%d) area with %p image pointer", area->x1, area->y1, area->x2, area->y2,
+               (void *)color_p);
+
+    lv_area_t offset_area = {
+        .x1 = area->x1 + drv->offset_x,
+        .y1 = area->y1 + drv->offset_y,
+        .x2 = area->x2 + drv->offset_x,
+        .y2 = area->y2 + drv->offset_y
+    };
+
+    drv->flush_cb(drv, &offset_area, color_p);
 }
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_theme.c b/lib/libesp32_lvgl/lvgl/src/core/lv_theme.c
index f8a0f50ae..b46cdcc4c 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_theme.c
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_theme.c
@@ -33,7 +33,7 @@ static void apply_theme(lv_theme_t * th, lv_obj_t * obj);
  *   GLOBAL FUNCTIONS
  **********************/
 
-lv_theme_t *  lv_theme_get_from_obj(lv_obj_t * obj)
+lv_theme_t  * lv_theme_get_from_obj(lv_obj_t * obj)
 {
     lv_disp_t * disp = obj ? lv_obj_get_disp(obj) : lv_disp_get_default();
     return lv_disp_get_theme(disp);
diff --git a/lib/libesp32_lvgl/lvgl/src/core/lv_theme.h b/lib/libesp32_lvgl/lvgl/src/core/lv_theme.h
index f287a2c61..f2f390728 100644
--- a/lib/libesp32_lvgl/lvgl/src/core/lv_theme.h
+++ b/lib/libesp32_lvgl/lvgl/src/core/lv_theme.h
@@ -50,7 +50,7 @@ typedef struct _lv_theme_t {
  * @param obj       pointer to object
  * @return          the theme of the object's display (can be NULL)
  */
-lv_theme_t *  lv_theme_get_from_obj(lv_obj_t * obj);
+lv_theme_t  * lv_theme_get_from_obj(lv_obj_t * obj);
 
 /**
  * Apply the active theme on an object
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_arc.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_arc.c
index b3c975a1b..44084f4d1 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_arc.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_arc.c
@@ -16,7 +16,7 @@
 /*********************
  *      DEFINES
  *********************/
-#define SPLIT_RADIUS_LIMIT 10  /*With radius greater then this the arc will drawn in quarters. A quarter is drawn only if there is arc in it*/
+#define SPLIT_RADIUS_LIMIT 10  /*With radius greater than this the arc will drawn in quarters. A quarter is drawn only if there is arc in it*/
 #define SPLIT_ANGLE_GAP_LIMIT 60  /*With small gaps in the arc don't bother with splitting because there is nothing to skip.*/
 
 /**********************
@@ -40,11 +40,11 @@ typedef struct {
  *  STATIC PROTOTYPES
  **********************/
 #if LV_DRAW_COMPLEX
-static void draw_quarter_0(quarter_draw_dsc_t * q);
-static void draw_quarter_1(quarter_draw_dsc_t * q);
-static void draw_quarter_2(quarter_draw_dsc_t * q);
-static void draw_quarter_3(quarter_draw_dsc_t * q);
-static void get_rounded_area(int16_t angle, lv_coord_t radius, uint8_t thickness, lv_area_t * res_area);
+    static void draw_quarter_0(quarter_draw_dsc_t * q);
+    static void draw_quarter_1(quarter_draw_dsc_t * q);
+    static void draw_quarter_2(quarter_draw_dsc_t * q);
+    static void draw_quarter_3(quarter_draw_dsc_t * q);
+    static void get_rounded_area(int16_t angle, lv_coord_t radius, uint8_t thickness, lv_area_t * res_area);
 #endif /*LV_DRAW_COMPLEX*/
 
 /**********************
@@ -85,7 +85,8 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
         cir_dsc.bg_opa = LV_OPA_TRANSP;
         cir_dsc.bg_img_src = dsc->img_src;
         cir_dsc.bg_img_opa = dsc->opa;
-    } else {
+    }
+    else {
         cir_dsc.bg_opa = dsc->opa;
         cir_dsc.bg_color = dsc->color;
     }
@@ -104,9 +105,12 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
     area_in.y2 -= dsc->width;
 
     /*Create inner the mask*/
+    int16_t mask_in_id = LV_MASK_ID_INV;
     lv_draw_mask_radius_param_t mask_in_param;
-    lv_draw_mask_radius_init(&mask_in_param, &area_in, LV_RADIUS_CIRCLE, true);
-    int16_t mask_in_id = lv_draw_mask_add(&mask_in_param, NULL);
+    if(lv_area_get_width(&area_in) > 0 && lv_area_get_height(&area_in) > 0) {
+        lv_draw_mask_radius_init(&mask_in_param, &area_in, LV_RADIUS_CIRCLE, true);
+        mask_in_id = lv_draw_mask_add(&mask_in_param, NULL);
+    }
 
     lv_draw_mask_radius_param_t mask_out_param;
     lv_draw_mask_radius_init(&mask_out_param, &area_out, LV_RADIUS_CIRCLE, false);
@@ -118,7 +122,7 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
         lv_draw_rect(&area_out, clip_area, &cir_dsc);
 
         lv_draw_mask_remove_id(mask_out_id);
-        lv_draw_mask_remove_id(mask_in_id);
+        if(mask_in_id != LV_MASK_ID_INV) lv_draw_mask_remove_id(mask_in_id);
         return;
     }
 
@@ -159,9 +163,14 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
     else {
         lv_draw_rect(&area_out, clip_area, &cir_dsc);
     }
+
+    lv_draw_mask_free_param(&mask_angle_param);
+    lv_draw_mask_free_param(&mask_out_param);
+    lv_draw_mask_free_param(&mask_in_param);
+
     lv_draw_mask_remove_id(mask_angle_id);
     lv_draw_mask_remove_id(mask_out_id);
-    lv_draw_mask_remove_id(mask_in_id);
+    if(mask_in_id != LV_MASK_ID_INV) lv_draw_mask_remove_id(mask_in_id);
 
     if(dsc->rounded) {
 
@@ -180,6 +189,7 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
 
             lv_draw_rect(&area_out, &clip_area2, &cir_dsc);
             lv_draw_mask_remove_id(mask_end_id);
+            lv_draw_mask_free_param(&mask_end_param);
         }
 
         get_rounded_area(end_angle, radius, width, &round_area);
@@ -193,6 +203,7 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
 
             lv_draw_rect(&area_out, &clip_area2, &cir_dsc);
             lv_draw_mask_remove_id(mask_end_id);
+            lv_draw_mask_free_param(&mask_end_param);
         }
     }
 #else
@@ -207,14 +218,31 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
 #endif /*LV_DRAW_COMPLEX*/
 }
 
-void lv_draw_arc_get_area(lv_coord_t x, lv_coord_t y, uint16_t radius,  uint16_t start_angle, uint16_t end_angle, lv_coord_t w, bool rounded, lv_area_t * area)
+void lv_draw_arc_get_area(lv_coord_t x, lv_coord_t y, uint16_t radius,  uint16_t start_angle, uint16_t end_angle,
+                          lv_coord_t w, bool rounded, lv_area_t * area)
 {
     lv_coord_t rout = radius;
+
+    /*Special case: full arc invalidation */
+    if(end_angle == start_angle + 360) {
+        area->x1 = x - rout;
+        area->y1 = y - rout;
+        area->x2 = x + rout;
+        area->y2 = y + rout;
+        return;
+    }
+
+    if(start_angle > 360) start_angle -= 360;
+    if(end_angle > 360) end_angle -= 360;
+
     lv_coord_t rin = radius - w;
-    lv_coord_t extra_area = rounded ? w : 0;
+    lv_coord_t extra_area = rounded ? w / 2 + 1 : 0;
     uint8_t start_quarter = start_angle / 90;
     uint8_t end_quarter = end_angle / 90;
 
+    /*360 deg still counts as quarter 3 (360 / 90 would be 4)*/
+    if(start_quarter == 4) start_quarter = 3;
+    if(end_quarter == 4) end_quarter = 3;
 
     if(start_quarter == end_quarter && start_angle <= end_angle) {
         if(start_quarter == 0) {
@@ -249,7 +277,7 @@ void lv_draw_arc_get_area(lv_coord_t x, lv_coord_t y, uint16_t radius,  uint16_t
     else if(start_quarter == 0 && end_quarter == 1) {
         area->x1 = x + ((lv_trigo_sin(end_angle + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
         area->y1 = y + ((LV_MIN(lv_trigo_sin(end_angle),
-                                        lv_trigo_sin(start_angle))  * rin) >> LV_TRIGO_SHIFT) - extra_area;
+                                lv_trigo_sin(start_angle))  * rin) >> LV_TRIGO_SHIFT) - extra_area;
         area->x2 = x + ((lv_trigo_sin(start_angle + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
         area->y2 = y + rout + extra_area;
     }
@@ -257,7 +285,7 @@ void lv_draw_arc_get_area(lv_coord_t x, lv_coord_t y, uint16_t radius,  uint16_t
         area->x1 = x - rout - extra_area;
         area->y1 = y + ((lv_trigo_sin(end_angle) * rout) >> LV_TRIGO_SHIFT) - extra_area;
         area->x2 = x + ((LV_MAX(lv_trigo_sin(start_angle + 90),
-                                        lv_trigo_sin(end_angle + 90)) * rin) >> LV_TRIGO_SHIFT) + extra_area;
+                                lv_trigo_sin(end_angle + 90)) * rin) >> LV_TRIGO_SHIFT) + extra_area;
         area->y2 = y + ((lv_trigo_sin(start_angle) * rout) >> LV_TRIGO_SHIFT) + extra_area;
     }
     else if(start_quarter == 2 && end_quarter == 3) {
@@ -265,11 +293,11 @@ void lv_draw_arc_get_area(lv_coord_t x, lv_coord_t y, uint16_t radius,  uint16_t
         area->y1 = y - rout - extra_area;
         area->x2 = x + ((lv_trigo_sin(end_angle + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
         area->y2 = y + (LV_MAX(lv_trigo_sin(end_angle) * rin,
-                                       lv_trigo_sin(start_angle) * rin) >> LV_TRIGO_SHIFT) + extra_area;
+                               lv_trigo_sin(start_angle) * rin) >> LV_TRIGO_SHIFT) + extra_area;
     }
     else if(start_quarter == 3 && end_quarter == 0) {
         area->x1 = x + ((LV_MIN(lv_trigo_sin(end_angle + 90),
-                                        lv_trigo_sin(start_angle + 90)) * rin) >> LV_TRIGO_SHIFT) - extra_area;
+                                lv_trigo_sin(start_angle + 90)) * rin) >> LV_TRIGO_SHIFT) - extra_area;
         area->y1 = y + ((lv_trigo_sin(start_angle) * rout) >> LV_TRIGO_SHIFT) - extra_area;
         area->x2 = x + rout + extra_area;
         area->y2 = y + ((lv_trigo_sin(end_angle) * rout) >> LV_TRIGO_SHIFT) + extra_area;
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_arc.h b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_arc.h
index ed8170936..8868b0fe9 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_arc.h
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_arc.h
@@ -62,7 +62,8 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
  * @param rounded       true: the arc is rounded
  * @param area          store the area to invalidate here
  */
-void lv_draw_arc_get_area(lv_coord_t x, lv_coord_t y, uint16_t radius,  uint16_t start_angle, uint16_t end_angle, lv_coord_t w, bool rounded, lv_area_t * area);
+void lv_draw_arc_get_area(lv_coord_t x, lv_coord_t y, uint16_t radius,  uint16_t start_angle, uint16_t end_angle,
+                          lv_coord_t w, bool rounded, lv_area_t * area);
 
 /**********************
  *      MACROS
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_blend.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_blend.c
index 46ba49891..4d26160e3 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_blend.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_blend.c
@@ -33,6 +33,7 @@
  *  STATIC PROTOTYPES
  **********************/
 
+#if LV_USE_EXTERNAL_RENDERER == 0
 static void fill_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  const lv_area_t * draw_area,
                         lv_color_t color, lv_opa_t opa,
                         const lv_opa_t * mask, lv_draw_mask_res_t mask_res);
@@ -64,7 +65,9 @@ static void map_blended(const lv_area_t * disp_area, lv_color_t * disp_buf,  con
 
 static inline lv_color_t color_blend_true_color_additive(lv_color_t fg, lv_color_t bg, lv_opa_t opa);
 static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_color_t bg, lv_opa_t opa);
+static inline lv_color_t color_blend_true_color_multiply(lv_color_t fg, lv_color_t bg, lv_opa_t opa);
 #endif
+#endif //LV_USE_GPU_SDL_RENDER
 
 /**********************
  *  STATIC VARIABLES
@@ -73,22 +76,21 @@ static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_co
 /**********************
  *      MACROS
  **********************/
+#if LV_COLOR_SCREEN_TRANSP == 0
+#define FILL_NORMAL_MASK_PX(color)                                                          \
+    if(*mask == LV_OPA_COVER) *disp_buf_first = color;                                 \
+    else *disp_buf_first = lv_color_mix(color, *disp_buf_first, *mask);            \
+    mask++;                                                         \
+    disp_buf_first++;
 
-#define FILL_NORMAL_MASK_PX(out_x,  color)                                                          \
-    if(*mask_tmp_x) {          \
-        if(*mask_tmp_x == LV_OPA_COVER) disp_buf_first[out_x] = color;                                 \
-        else disp_buf_first[out_x] = lv_color_mix(color, disp_buf_first[out_x], *mask_tmp_x);            \
-    }                                                                                               \
-    mask_tmp_x++;
-
-#define FILL_NORMAL_MASK_PX_SCR_TRANSP(out_x,  color)                                               \
-    if(*mask_tmp_x) {          \
-        if(*mask_tmp_x == LV_OPA_COVER) disp_buf_first[out_x] = color;                                 \
-        else if(disp->driver->screen_transp) lv_color_mix_with_alpha(disp_buf_first[out_x], disp_buf_first[out_x].ch.alpha,              \
-                                                                        color, *mask_tmp_x, &disp_buf_first[out_x], &disp_buf_first[out_x].ch.alpha);           \
-        else disp_buf_first[out_x] = lv_color_mix(color, disp_buf_first[out_x], *mask_tmp_x);            \
-    }                                                                                                      \
-    mask_tmp_x++;
+#else
+#define FILL_NORMAL_MASK_PX(color)                                               \
+    if(*mask == LV_OPA_COVER) *disp_buf_first = color;                                 \
+    else if(disp->driver->screen_transp) lv_color_mix_with_alpha(*disp_buf_first, disp_buf_first->ch.alpha, color, *mask, disp_buf_first, &disp_buf_first->ch.alpha);           \
+    else *disp_buf_first = lv_color_mix(color, *disp_buf_first, *mask);            \
+    mask++;                                                         \
+    disp_buf_first++;
+#endif
 
 #define MAP_NORMAL_MASK_PX(x)                                                          \
     if(*mask_tmp_x) {          \
@@ -101,7 +103,7 @@ static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_co
     if(*mask_tmp_x) {          \
         if(*mask_tmp_x == LV_OPA_COVER) disp_buf_first[x] = map_buf_first[x];                                 \
         else if(disp->driver->screen_transp) lv_color_mix_with_alpha(disp_buf_first[x], disp_buf_first[x].ch.alpha,              \
-                                                                        map_buf_first[x], *mask_tmp_x, &disp_buf_first[x], &disp_buf_first[x].ch.alpha);                  \
+                                                                         map_buf_first[x], *mask_tmp_x, &disp_buf_first[x], &disp_buf_first[x].ch.alpha);                  \
         else disp_buf_first[x] = lv_color_mix(map_buf_first[x], disp_buf_first[x], *mask_tmp_x);            \
     }                                                                                               \
     mask_tmp_x++;
@@ -110,6 +112,7 @@ static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_co
  *   GLOBAL FUNCTIONS
  **********************/
 
+#if LV_USE_EXTERNAL_RENDERER == 0
 /**
  * Fill and area in the display buffer.
  * @param clip_area clip the fill to this area  (absolute coordinates)
@@ -141,16 +144,11 @@ LV_ATTRIBUTE_FAST_MEM void _lv_blend_fill(const lv_area_t * clip_area, const lv_
     /*Get clipped fill area which is the real draw area.
      *It is always the same or inside `fill_area`*/
     lv_area_t draw_area;
-    bool is_common;
-    is_common = _lv_area_intersect(&draw_area, clip_area, fill_area);
-    if(!is_common) return;
+    if(!_lv_area_intersect(&draw_area, clip_area, fill_area)) return;
 
     /*Now `draw_area` has absolute coordinates.
-     *Make it relative to `disp_area` to simplify draw to `disp_buf`*/
-    draw_area.x1 -= disp_area->x1;
-    draw_area.y1 -= disp_area->y1;
-    draw_area.x2 -= disp_area->x1;
-    draw_area.y2 -= disp_area->y1;
+     *Make it relative to `disp_area` to simplify the drawing to `disp_buf`*/
+    lv_area_move(&draw_area, -disp_area->x1, -disp_area->y1);
 
     /*Round the values in the mask if anti-aliasing is disabled*/
     if(mask && disp->driver->antialiasing == 0 && mask) {
@@ -216,8 +214,7 @@ LV_ATTRIBUTE_FAST_MEM void _lv_blend_map(const lv_area_t * clip_area, const lv_a
     draw_area.y2 -= disp_area->y1;
 
     /*Round the values in the mask if anti-aliasing is disabled*/
-    if(mask && disp->driver->antialiasing == 0)
-    {
+    if(mask && disp->driver->antialiasing == 0) {
         int32_t mask_w = lv_area_get_width(&draw_area);
         int32_t i;
         for(i = 0; i < mask_w; i++)  mask[i] = mask[i] > 128 ? LV_OPA_COVER : LV_OPA_TRANSP;
@@ -272,7 +269,7 @@ static void fill_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  con
             for(x = draw_area->x1; x <= draw_area->x2; x++) {
                 if(mask_tmp[x]) {
                     disp->driver->set_px_cb(disp->driver, (void *)disp_buf, disp_w, x, y, color,
-                                           (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
+                                            (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
                 }
             }
             mask_tmp += draw_area_w;
@@ -280,6 +277,7 @@ static void fill_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  con
     }
 }
 
+#if LV_USE_EXTERNAL_RENDERER == 0
 /**
  * Fill an area with a color
  * @param disp_area the current display area (destination area)
@@ -326,7 +324,6 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(const lv_area_t * disp_area, lv_co
                 if(lv_gpu_nxp_vglite_fill(disp_buf, disp_w, lv_area_get_height(disp_area), draw_area, color, opa) == LV_RES_OK) {
                     return;
                 }
-                /*Fall down to SW render in case of error*/
             }
 #elif LV_USE_GPU_STM32_DMA2D
             if(lv_area_get_size(draw_area) >= 240) {
@@ -392,79 +389,71 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(const lv_area_t * disp_area, lv_co
     }
     /*Masked*/
     else {
-        /*Buffer the result color to avoid recalculating the same color*/
-        lv_color_t last_dest_color;
-        lv_color_t last_res_color;
-        lv_opa_t last_mask = LV_OPA_TRANSP;
-        last_dest_color.full = disp_buf_first[0].full;
-        last_res_color.full = disp_buf_first[0].full;
-
         int32_t x_end4 = draw_area_w - 4;
 
+#if LV_COLOR_DEPTH == 16
+        uint32_t c32 = color.full + ((uint32_t)color.full << 16);
+#endif
+
         /*Only the mask matters*/
         if(opa > LV_OPA_MAX) {
             for(y = 0; y < draw_area_h; y++) {
-                const lv_opa_t * mask_tmp_x = mask;
-#if 0
-                for(x = 0; x < draw_area_w; x++) {
-#if LV_COLOR_SCREEN_TRANSP
-                    FILL_NORMAL_MASK_PX_SCR_TRANSP(x, color)
-#else
-                    FILL_NORMAL_MASK_PX(x, color)
-#endif
-                }
-#else
-                for(x = 0; x < draw_area_w && ((lv_uintptr_t)mask_tmp_x & 0x3); x++) {
-#if LV_COLOR_SCREEN_TRANSP
-                    FILL_NORMAL_MASK_PX_SCR_TRANSP(x, color)
-#else
-                    FILL_NORMAL_MASK_PX(x, color)
-#endif
+                for(x = 0; x < draw_area_w && ((lv_uintptr_t)(mask) & 0x3); x++) {
+                    FILL_NORMAL_MASK_PX(color)
                 }
 
-                uint32_t * mask32 = (uint32_t *)mask_tmp_x;
                 for(; x <= x_end4; x += 4) {
-                    if(*mask32) {
-                        if((*mask32) == 0xFFFFFFFF) {
-                            disp_buf_first[x] = color;
-                            disp_buf_first[x + 1] = color;
-                            disp_buf_first[x + 2] = color;
-                            disp_buf_first[x + 3] = color;
+                    uint32_t mask32 = *((uint32_t *)mask);
+                    if(mask32 == 0xFFFFFFFF) {
+#if LV_COLOR_DEPTH == 16
+                        if((lv_uintptr_t)disp_buf_first & 0x3) {
+                            *(disp_buf_first + 0) = color;
+                            uint32_t * d = (uint32_t *)(disp_buf_first + 1);
+                            *d = c32;
+                            *(disp_buf_first + 3) = color;
                         }
                         else {
-                            mask_tmp_x = (const lv_opa_t *)mask32;
-#if LV_COLOR_SCREEN_TRANSP
-                            FILL_NORMAL_MASK_PX_SCR_TRANSP(x, color)
-                            FILL_NORMAL_MASK_PX_SCR_TRANSP(x + 1, color)
-                            FILL_NORMAL_MASK_PX_SCR_TRANSP(x + 2, color)
-                            FILL_NORMAL_MASK_PX_SCR_TRANSP(x + 3, color)
-#else
-                            FILL_NORMAL_MASK_PX(x, color)
-                            FILL_NORMAL_MASK_PX(x + 1, color)
-                            FILL_NORMAL_MASK_PX(x + 2, color)
-                            FILL_NORMAL_MASK_PX(x + 3, color)
-#endif
+                            uint32_t * d = (uint32_t *)disp_buf_first;
+                            *d = c32;
+                            *(d + 1) = c32;
                         }
+#else
+                        disp_buf_first[0] = color;
+                        disp_buf_first[1] = color;
+                        disp_buf_first[2] = color;
+                        disp_buf_first[3] = color;
+#endif
+                        disp_buf_first += 4;
+                        mask += 4;
+                    }
+                    else if(mask32) {
+                        FILL_NORMAL_MASK_PX(color)
+                        FILL_NORMAL_MASK_PX(color)
+                        FILL_NORMAL_MASK_PX(color)
+                        FILL_NORMAL_MASK_PX(color)
+                    }
+                    else {
+                        mask += 4;
+                        disp_buf_first += 4;
                     }
-                    mask32++;
                 }
 
-                mask_tmp_x = (const lv_opa_t *)mask32;
                 for(; x < draw_area_w ; x++) {
-#if LV_COLOR_SCREEN_TRANSP
-                    FILL_NORMAL_MASK_PX_SCR_TRANSP(x, color)
-#else
-                    FILL_NORMAL_MASK_PX(x, color)
-#endif
+                    FILL_NORMAL_MASK_PX(color)
                 }
-#endif
-                disp_buf_first += disp_w;
-                mask += draw_area_w;
+                disp_buf_first += (disp_w - draw_area_w);
             }
         }
         /*Handle opa and mask values too*/
         else {
+            /*Buffer the result color to avoid recalculating the same color*/
+            lv_color_t last_dest_color;
+            lv_color_t last_res_color;
+            lv_opa_t last_mask = LV_OPA_TRANSP;
+            last_dest_color.full = disp_buf_first[0].full;
+            last_res_color.full = disp_buf_first[0].full;
             lv_opa_t opa_tmp = LV_OPA_TRANSP;
+
             for(y = draw_area->y1; y <= draw_area->y2; y++) {
                 const lv_opa_t * mask_tmp_x = mask;
                 for(x = 0; x < draw_area_w; x++) {
@@ -530,6 +519,9 @@ static void fill_blended(const lv_area_t * disp_area, lv_color_t * disp_buf,  co
         case LV_BLEND_MODE_SUBTRACTIVE:
             blend_fp = color_blend_true_color_subtractive;
             break;
+        case LV_BLEND_MODE_MULTIPLY:
+            blend_fp = color_blend_true_color_multiply;
+            break;
         default:
             LV_LOG_WARN("fill_blended: unsupported blend mode");
             return;
@@ -588,6 +580,7 @@ static void fill_blended(const lv_area_t * disp_area, lv_color_t * disp_buf,  co
     }
 }
 #endif
+#endif // LV_USE_GPU_SDL_RENDER
 
 static void map_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  const lv_area_t * draw_area,
                        const lv_area_t * map_area, const lv_color_t * map_buf, lv_opa_t opa,
@@ -631,7 +624,7 @@ static void map_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  cons
             for(x = draw_area->x1; x <= draw_area->x2; x++) {
                 if(mask_tmp[x]) {
                     disp->driver->set_px_cb(disp->driver, (void *)disp_buf, disp_w, x, y, map_buf_tmp[x],
-                                           (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
+                                            (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
                 }
             }
             mask_tmp += draw_area_w;
@@ -701,8 +694,8 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(const lv_area_t * disp_area, lv_col
                 blit.src_stride = lv_area_get_width(map_area) * sizeof(lv_color_t);
                 blit.src_area.x1 = (draw_area->x1 - (map_area->x1 - disp_area->x1));
                 blit.src_area.y1 = (draw_area->y1 - (map_area->y1 - disp_area->y1));
-                blit.src_area.x2 = blit.src_area.x1 + draw_area_w - 1;
-                blit.src_area.y2 = blit.src_area.y1 + draw_area_h - 1;
+                blit.src_area.x2 = blit.src_area.x1 + draw_area_w;
+                blit.src_area.y2 = blit.src_area.y1 + draw_area_h;
 
                 blit.dst = disp_buf;
                 blit.dst_width = lv_area_get_width(disp_area);
@@ -710,8 +703,8 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(const lv_area_t * disp_area, lv_col
                 blit.dst_stride = lv_area_get_width(disp_area) * sizeof(lv_color_t);
                 blit.dst_area.x1 = draw_area->x1;
                 blit.dst_area.y1 = draw_area->y1;
-                blit.dst_area.x2 = blit.dst_area.x1 + draw_area_w - 1;
-                blit.dst_area.y2 = blit.dst_area.y1 + draw_area_h - 1;
+                blit.dst_area.x2 = blit.dst_area.x1 + draw_area_w;
+                blit.dst_area.y2 = blit.dst_area.y1 + draw_area_h;
 
                 blit.opa = opa;
 
@@ -751,8 +744,8 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(const lv_area_t * disp_area, lv_col
                 blit.src_stride = lv_area_get_width(map_area) * sizeof(lv_color_t);
                 blit.src_area.x1 = (draw_area->x1 - (map_area->x1 - disp_area->x1));
                 blit.src_area.y1 = (draw_area->y1 - (map_area->y1 - disp_area->y1));
-                blit.src_area.x2 = blit.src_area.x1 + draw_area_w - 1;
-                blit.src_area.y2 = blit.src_area.y1 + draw_area_h - 1;
+                blit.src_area.x2 = blit.src_area.x1 + draw_area_w;
+                blit.src_area.y2 = blit.src_area.y1 + draw_area_h;
 
                 blit.dst = disp_buf;
                 blit.dst_width = lv_area_get_width(disp_area);
@@ -760,8 +753,8 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(const lv_area_t * disp_area, lv_col
                 blit.dst_stride = lv_area_get_width(disp_area) * sizeof(lv_color_t);
                 blit.dst_area.x1 = draw_area->x1;
                 blit.dst_area.y1 = draw_area->y1;
-                blit.dst_area.x2 = blit.dst_area.x1 + draw_area_w - 1;
-                blit.dst_area.y2 = blit.dst_area.y1 + draw_area_h - 1;
+                blit.dst_area.x2 = blit.dst_area.x1 + draw_area_w;
+                blit.dst_area.y2 = blit.dst_area.y1 + draw_area_h;
 
                 blit.opa = opa;
 
@@ -915,6 +908,9 @@ static void map_blended(const lv_area_t * disp_area, lv_color_t * disp_buf,  con
         case LV_BLEND_MODE_SUBTRACTIVE:
             blend_fp = color_blend_true_color_subtractive;
             break;
+        case LV_BLEND_MODE_MULTIPLY:
+            blend_fp = color_blend_true_color_multiply;
+            break;
         default:
             LV_LOG_WARN("fill_blended: unsupported blend mode");
             return;
@@ -1015,7 +1011,6 @@ static inline lv_color_t color_blend_true_color_additive(lv_color_t fg, lv_color
 
 static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_color_t bg, lv_opa_t opa)
 {
-
     if(opa <= LV_OPA_MIN) return bg;
 
     int32_t tmp;
@@ -1039,4 +1034,30 @@ static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_co
 
     return lv_color_mix(fg, bg, opa);
 }
+
+static inline lv_color_t color_blend_true_color_multiply(lv_color_t fg, lv_color_t bg, lv_opa_t opa)
+{
+    if(opa <= LV_OPA_MIN) return bg;
+
+#if LV_COLOR_DEPTH == 32
+    fg.ch.red = (fg.ch.red * bg.ch.red) >> 8;
+    fg.ch.green = (fg.ch.green * bg.ch.green) >> 8;
+    fg.ch.blue = (fg.ch.blue * bg.ch.blue) >> 8;
+#elif LV_COLOR_DEPTH == 16
+    fg.ch.red = (fg.ch.red * bg.ch.red) >> 5;
+    fg.ch.blue = (fg.ch.blue * bg.ch.blue) >> 5;
+    LV_COLOR_SET_G(fg, (LV_COLOR_GET_G(fg) * LV_COLOR_GET_G(bg)) >> 6);
+#elif LV_COLOR_DEPTH == 8
+    fg.ch.red = (fg.ch.red * bg.ch.red) >> 3;
+    fg.ch.green = (fg.ch.green * bg.ch.green) >> 3;
+    fg.ch.blue = (fg.ch.blue * bg.ch.blue) >> 2;
 #endif
+
+    if(opa == LV_OPA_COVER) return fg;
+
+    return lv_color_mix(fg, bg, opa);
+}
+
+#endif
+
+#endif // LV_USE_GPU_SDL_RENDER
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_img.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_img.c
index ec5799e57..35ece92d1 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_img.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_img.c
@@ -30,6 +30,7 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
+#if LV_USE_EXTERNAL_RENDERER == 0
 LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * clip_area,
                                                        const void * src,
                                                        const lv_draw_img_dsc_t * draw_dsc);
@@ -41,6 +42,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
 
 static void show_error(const lv_area_t * coords, const lv_area_t * clip_area, const char * msg);
 static void draw_cleanup(_lv_img_cache_entry_t * cache);
+#endif
 
 /**********************
  *  STATIC VARIABLES
@@ -63,6 +65,7 @@ void lv_draw_img_dsc_init(lv_draw_img_dsc_t * dsc)
     dsc->antialias = LV_COLOR_DEPTH > 8 ? 1 : 0;
 }
 
+#if LV_USE_EXTERNAL_RENDERER == 0
 /**
  * Draw an image
  * @param coords the coordinates of the image
@@ -89,6 +92,7 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void *
         return;
     }
 }
+#endif //LV_USE_GPU_SDL_RENDER
 
 /**
  * Get the pixel size of a color format in bits
@@ -229,6 +233,7 @@ lv_img_src_t lv_img_src_get_type(const void * src)
  *   STATIC FUNCTIONS
  **********************/
 
+#if LV_USE_EXTERNAL_RENDERER == 0
 LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * clip_area,
                                                        const void * src,
                                                        const lv_draw_img_dsc_t * draw_dsc)
@@ -289,7 +294,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
         int32_t width = lv_area_get_width(&mask_com);
 
         uint8_t  * buf = lv_mem_buf_get(lv_area_get_width(&mask_com) *
-                                         LV_IMG_PX_SIZE_ALPHA_BYTE);  /*+1 because of the possible alpha byte*/
+                                        LV_IMG_PX_SIZE_ALPHA_BYTE);  /*+1 because of the possible alpha byte*/
 
         lv_area_t line;
         lv_area_copy(&line, &mask_com);
@@ -326,11 +331,11 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
 
 /**
  * Draw a color map to the display (image)
- * @param cords_p coordinates the color map
- * @param mask_p the map will drawn only on this area  (truncated to draw_buf area)
+ * @param map_area coordinates the color map
+ * @param clip_area the map will drawn only on this area  (truncated to draw_buf area)
  * @param map_p pointer to a lv_color_t array
  * @param draw_dsc pointer to an initialized `lv_draw_img_dsc_t` variable
- * @param chroma_keyed true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
+ * @param chroma_key true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
  * @param alpha_byte true: extra alpha byte is inserted for every pixel
  */
 LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const lv_area_t * clip_area,
@@ -353,10 +358,10 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
     draw_area.x2 -= disp_area->x1;
     draw_area.y2 -= disp_area->y1;
 
-    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
+    bool mask_any = lv_draw_mask_is_any(clip_area);
 
     /*The simplest case just copy the pixels into the draw_buf*/
-    if(other_mask_cnt == 0 && draw_dsc->angle == 0 && draw_dsc->zoom == LV_IMG_ZOOM_NONE &&
+    if(!mask_any && draw_dsc->angle == 0 && draw_dsc->zoom == LV_IMG_ZOOM_NONE &&
        chroma_key == false && alpha_byte == false && draw_dsc->recolor_opa == LV_OPA_TRANSP) {
         _lv_blend_map(clip_area, map_area, (lv_color_t *)map_p, NULL, LV_DRAW_MASK_RES_FULL_COVER, draw_dsc->opa,
                       draw_dsc->blend_mode);
@@ -364,14 +369,14 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
 
 #if LV_USE_GPU_NXP_PXP
     /*Simple case without masking and transformations*/
-    else if(other_mask_cnt == 0 && draw_dsc->angle == 0 && draw_dsc->zoom == LV_IMG_ZOOM_NONE && alpha_byte == false &&
+    else if(!mask_any && draw_dsc->angle == 0 && draw_dsc->zoom == LV_IMG_ZOOM_NONE && alpha_byte == false &&
             chroma_key == true && draw_dsc->recolor_opa == LV_OPA_TRANSP) { /*copy with color keying (+ alpha)*/
         lv_gpu_nxp_pxp_enable_color_key();
         _lv_blend_map(clip_area, map_area, (lv_color_t *)map_p, NULL, LV_DRAW_MASK_RES_FULL_COVER, draw_dsc->opa,
                       draw_dsc->blend_mode);
         lv_gpu_nxp_pxp_disable_color_key();
     }
-    else if(other_mask_cnt == 0 && draw_dsc->angle == 0 && draw_dsc->zoom == LV_IMG_ZOOM_NONE && alpha_byte == false &&
+    else if(!mask_any && draw_dsc->angle == 0 && draw_dsc->zoom == LV_IMG_ZOOM_NONE && alpha_byte == false &&
             chroma_key == false && draw_dsc->recolor_opa != LV_OPA_TRANSP) { /*copy with recolor (+ alpha)*/
         lv_gpu_nxp_pxp_enable_recolor(draw_dsc->recolor, draw_dsc->recolor_opa);
         _lv_blend_map(clip_area, map_area, (lv_color_t *)map_p, NULL, LV_DRAW_MASK_RES_FULL_COVER, draw_dsc->opa,
@@ -381,7 +386,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
 #endif
     /*In the other cases every pixel need to be checked one-by-one*/
     else {
-//#if LV_DRAW_COMPLEX
+        //#if LV_DRAW_COMPLEX
         /*The pixel size in byte is different if an alpha byte is added too*/
         uint8_t px_size_byte = alpha_byte ? LV_IMG_PX_SIZE_ALPHA_BYTE : sizeof(lv_color_t);
 
@@ -397,18 +402,18 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
 
         const uint8_t * map_px;
 
-        lv_area_t blend_area;
-        blend_area.x1 = draw_area.x1 + disp_area->x1;
-        blend_area.x2 = blend_area.x1 + lv_area_get_width(&draw_area) - 1;
-        blend_area.y1 = disp_area->y1 + draw_area.y1;
-        blend_area.y2 = blend_area.y1;
-
         lv_coord_t draw_area_h = lv_area_get_height(&draw_area);
         lv_coord_t draw_area_w = lv_area_get_width(&draw_area);
 
+        lv_area_t blend_area;
+        blend_area.x1 = draw_area.x1 + disp_area->x1;
+        blend_area.x2 = blend_area.x1 + draw_area_w - 1;
+        blend_area.y1 = disp_area->y1 + draw_area.y1;
+        blend_area.y2 = blend_area.y1;
+
         bool transform = draw_dsc->angle != 0 || draw_dsc->zoom != LV_IMG_ZOOM_NONE ? true : false;
         /*Simple ARGB image. Handle it as special case because it's very common*/
-        if(other_mask_cnt == 0 && !transform && !chroma_key && draw_dsc->recolor_opa == LV_OPA_TRANSP && alpha_byte) {
+        if(!mask_any && !transform && !chroma_key && draw_dsc->recolor_opa == LV_OPA_TRANSP && alpha_byte) {
 #if LV_USE_GPU_STM32_DMA2D && LV_COLOR_DEPTH == 32
             /*Blend ARGB images directly*/
             if(lv_area_get_size(&draw_area) > 240) {
@@ -447,7 +452,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
                 }
 
                 map_buf_tmp += map_w * px_size_byte;
-                if(px_i + lv_area_get_width(&draw_area) < mask_buf_size) {
+                if(px_i + draw_area_w < mask_buf_size) {
                     blend_area.y2 ++;
                 }
                 else {
@@ -509,7 +514,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
                         draw_dsc->zoom != LV_IMG_ZOOM_NONE) ? LV_DRAW_MASK_RES_CHANGED : LV_DRAW_MASK_RES_FULL_COVER;
 
             /*Prepare the `mask_buf`if there are other masks*/
-            if(other_mask_cnt) {
+            if(mask_any) {
                 lv_memset_ff(mask_buf, mask_buf_size);
             }
 
@@ -589,12 +594,13 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
                 }
 #if LV_DRAW_COMPLEX
                 /*Apply the masks if any*/
-                if(other_mask_cnt) {
+                if(mask_any) {
                     lv_draw_mask_res_t mask_res_sub;
-                    mask_res_sub = lv_draw_mask_apply(mask_buf + px_i_start, draw_area.x1 + draw_buf->area.x1, y + draw_area.y1 + draw_buf->area.y1,
-                                                      lv_area_get_width(&draw_area));
+                    mask_res_sub = lv_draw_mask_apply(mask_buf + px_i_start, draw_area.x1 + draw_buf->area.x1,
+                                                      y + draw_area.y1 + draw_buf->area.y1,
+                                                      draw_area_w);
                     if(mask_res_sub == LV_DRAW_MASK_RES_TRANSP) {
-                        lv_memset_00(mask_buf + px_i_start, lv_area_get_width(&draw_area));
+                        lv_memset_00(mask_buf + px_i_start, draw_area_w);
                         mask_res = LV_DRAW_MASK_RES_CHANGED;
                     }
                     else if(mask_res_sub == LV_DRAW_MASK_RES_CHANGED) {
@@ -604,7 +610,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
 #endif
 
                 map_buf_tmp += map_w * px_size_byte;
-                if(px_i + lv_area_get_width(&draw_area) < mask_buf_size) {
+                if(px_i + draw_area_w < mask_buf_size) {
                     blend_area.y2 ++;
                 }
                 else {
@@ -619,7 +625,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
                                 draw_dsc->zoom != LV_IMG_ZOOM_NONE) ? LV_DRAW_MASK_RES_CHANGED : LV_DRAW_MASK_RES_FULL_COVER;
 
                     /*Prepare the `mask_buf`if there are other masks*/
-                    if(other_mask_cnt) {
+                    if(mask_any) {
                         lv_memset_ff(mask_buf, mask_buf_size);
                     }
                 }
@@ -658,3 +664,5 @@ static void draw_cleanup(_lv_img_cache_entry_t * cache)
     LV_UNUSED(cache);
 #endif
 }
+
+#endif //LV_USE_GPU_SDL_RENDER
\ No newline at end of file
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_label.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_label.c
index 1c686e1e3..3ae4f0e5b 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_label.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_label.c
@@ -13,6 +13,9 @@
 #include "../misc/lv_bidi.h"
 #include "../misc/lv_assert.h"
 
+#if LV_USE_GPU_SDL
+    #include "../gpu/lv_gpu_sdl.h"
+#endif
 /*********************
  *      DEFINES
  *********************/
@@ -32,13 +35,18 @@ typedef uint8_t cmd_state_t;
 /**********************
  *  STATIC PROTOTYPES
  **********************/
+
+#if LV_USE_EXTERNAL_RENDERER == 0
 LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_dsc_t * g,
                                                      const lv_area_t * clip_area,
                                                      const uint8_t * map_p, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);
+
 #if LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX
 static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_dsc_t * g, const lv_area_t * clip_area,
                               const uint8_t * map_p, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);
-#endif
+#endif /*LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX*/
+#endif /*LV_USE_EXTERNAL_RENDERER*/
+
 static uint8_t hex_char_to_num(char hex);
 
 /**********************
@@ -121,13 +129,18 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
     int32_t w;
 
     /*No need to waste processor time if string is empty*/
-    if (txt == NULL || txt[0] == '\0')
+    if(txt == NULL || txt[0] == '\0')
         return;
 
     lv_area_t clipped_area;
     bool clip_ok = _lv_area_intersect(&clipped_area, coords, mask);
     if(!clip_ok) return;
 
+    lv_text_align_t align = dsc->align;
+    lv_base_dir_t base_dir = dsc->bidi_dir;
+
+    lv_bidi_calculate_align(&align, &base_dir, txt);
+
     if((dsc->flag & LV_TEXT_FLAG_EXPAND) == 0) {
         /*Normally use the label's width as width*/
         w = lv_area_get_width(coords);
@@ -136,7 +149,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
         /*If EXAPND is enabled then not limit the text's width to the object's width*/
         lv_point_t p;
         lv_txt_get_size(&p, txt, dsc->font, dsc->letter_space, dsc->line_space, LV_COORD_MAX,
-                         dsc->flag);
+                        dsc->flag);
         w = p.x;
     }
 
@@ -193,14 +206,14 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
     }
 
     /*Align to middle*/
-    if(dsc->align == LV_TEXT_ALIGN_CENTER) {
+    if(align == LV_TEXT_ALIGN_CENTER) {
         line_width = lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
 
         pos.x += (lv_area_get_width(coords) - line_width) / 2;
 
     }
     /*Align to the right*/
-    else if(dsc->align == LV_TEXT_ALIGN_RIGHT) {
+    else if(align == LV_TEXT_ALIGN_RIGHT) {
         line_width = lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
         pos.x += lv_area_get_width(coords) - line_width;
     }
@@ -244,7 +257,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
         i         = 0;
 #if LV_USE_BIDI
         char * bidi_txt = lv_mem_buf_get(line_end - line_start + 1);
-        _lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, dsc->bidi_dir, NULL, 0);
+        _lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, base_dir, NULL, 0);
 #else
         const char * bidi_txt = txt + line_start;
 #endif
@@ -255,7 +268,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
 #if LV_USE_BIDI
                 logical_char_pos = _lv_txt_encoded_get_char_id(txt, line_start);
                 uint32_t t = _lv_txt_encoded_get_char_id(bidi_txt, i);
-                logical_char_pos += _lv_bidi_get_logical_pos(bidi_txt, NULL, line_end - line_start, dsc->bidi_dir, t, NULL);
+                logical_char_pos += _lv_bidi_get_logical_pos(bidi_txt, NULL, line_end - line_start, base_dir, t, NULL);
 #else
                 logical_char_pos = _lv_txt_encoded_get_char_id(txt, line_start + i);
 #endif
@@ -359,7 +372,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
 
         pos.x = coords->x1;
         /*Align to middle*/
-        if(dsc->align == LV_TEXT_ALIGN_CENTER) {
+        if(align == LV_TEXT_ALIGN_CENTER) {
             line_width =
                 lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
 
@@ -367,7 +380,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
 
         }
         /*Align to the right*/
-        else if(dsc->align == LV_TEXT_ALIGN_RIGHT) {
+        else if(align == LV_TEXT_ALIGN_RIGHT) {
             line_width =
                 lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
             pos.x += lv_area_get_width(coords) - line_width;
@@ -382,6 +395,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
     LV_ASSERT_MEM_INTEGRITY();
 }
 
+#if LV_USE_EXTERNAL_RENDERER == 0
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -414,9 +428,9 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_letter(const lv_point_t * pos_p, const lv_are
         /*Add warning if the dsc is not found
          *but do not print warning for non printable ASCII chars (e.g. '\n')*/
         if(letter >= 0x20 &&
-            letter != 0xf8ff && /*LV_SYMBOL_DUMMY*/
-            letter != 0x200c) { /*ZERO WIDTH NON-JOINER*/
-            LV_LOG_WARN("lv_draw_letter: glyph dsc. not found for U+%X", letter);
+           letter != 0xf8ff && /*LV_SYMBOL_DUMMY*/
+           letter != 0x200c) { /*ZERO WIDTH NON-JOINER*/
+            LV_LOG_WARN("lv_draw_letter: glyph dsc. not found for U+%X", (unsigned int)letter);
         }
         return;
     }
@@ -443,11 +457,12 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_letter(const lv_point_t * pos_p, const lv_are
 
     if(font_p->subpx) {
 #if LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX
-    draw_letter_subpx(pos_x, pos_y, &g, clip_area, map_p, color, opa, blend_mode);
+        draw_letter_subpx(pos_x, pos_y, &g, clip_area, map_p, color, opa, blend_mode);
 #else
-    LV_LOG_WARN("Can't draw sub-pixel rendered letter because LV_USE_FONT_SUBPX == 0 in lv_conf.h");
+        LV_LOG_WARN("Can't draw sub-pixel rendered letter because LV_USE_FONT_SUBPX == 0 in lv_conf.h");
 #endif
-    } else {
+    }
+    else {
         draw_letter_normal(pos_x, pos_y, &g, clip_area, map_p, color, opa, blend_mode);
     }
 }
@@ -534,7 +549,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_coord_t pos_x, lv_coord_
     fill_area.y1 = row_start + pos_y;
     fill_area.y2 = fill_area.y1;
 #if LV_DRAW_COMPLEX
-    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
+    bool mask_any = lv_draw_mask_is_any(&fill_area);
 #endif
 
     uint32_t col_bit_max = 8 - bpp;
@@ -572,7 +587,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_coord_t pos_x, lv_coord_
 
 #if LV_DRAW_COMPLEX
         /*Apply masks if any*/
-        if(other_mask_cnt) {
+        if(mask_any) {
             lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf + mask_p_start, fill_area.x1, fill_area.y2,
                                                              lv_area_get_width(&fill_area));
             if(mask_res == LV_DRAW_MASK_RES_TRANSP) {
@@ -690,8 +705,7 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
     /*If the letter is partially out of mask the move there on draw_buf*/
     disp_buf_buf_tmp += (row_start * disp_buf_width) + col_start / 3;
 
-    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
-
+    bool mask_any = lv_draw_mask_is_any(&map_area);
     uint8_t font_rgb[3];
 
 #if LV_COLOR_16_SWAP == 0
@@ -779,7 +793,7 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
         }
 
         /*Apply masks if any*/
-        if(other_mask_cnt) {
+        if(mask_any) {
             lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf + mask_p_start, map_area.x1, map_area.y2,
                                                              lv_area_get_width(&map_area));
             if(mask_res == LV_DRAW_MASK_RES_TRANSP) {
@@ -816,8 +830,9 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
     lv_mem_buf_release(mask_buf);
     lv_mem_buf_release(color_buf);
 }
-#endif
+#endif /*LV_DRAW_COMPLEX && LV_USE_FONT_SUBPX*/
 
+#endif /*LV_USE_EXTERNAL_RENDERER*/
 /**
  * Convert a hexadecimal characters to a number (0..15)
  * @param hex Pointer to a hexadecimal character (0..9, A..F)
@@ -860,3 +875,4 @@ static uint8_t hex_char_to_num(char hex)
 
     return result;
 }
+
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_label.h b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_label.h
index fb71210d5..f4cc1fb88 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_label.h
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_label.h
@@ -40,8 +40,8 @@ typedef struct {
     lv_coord_t ofs_y;
     lv_opa_t opa;
     lv_base_dir_t bidi_dir;
+    lv_text_align_t align;
     lv_text_flag_t flag;
-    lv_text_align_t align :2;
     lv_text_decor_t decor : 3;
     lv_blend_mode_t blend_mode: 3;
 } lv_draw_label_dsc_t;
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_line.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_line.c
index ae0501544..407a280a7 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_line.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_line.c
@@ -34,7 +34,6 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
 LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const lv_point_t * point2,
                                                 const lv_area_t * clip,
                                                 const lv_draw_line_dsc_t * dsc);
-
 /**********************
  *  STATIC VARIABLES
  **********************/
@@ -117,6 +116,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_line(const lv_point_t * point1, const lv_poin
  *   STATIC FUNCTIONS
  **********************/
 
+
 LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const lv_point_t * point2,
                                                 const lv_area_t * clip,
                                                 const lv_draw_line_dsc_t * dsc)
@@ -127,11 +127,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
     int32_t w_half0 = w >> 1;
     int32_t w_half1 = w_half0 + (w & 0x1); /*Compensate rounding error*/
 
-    bool dashed = dsc->dash_gap && dsc->dash_width ? true : false;
 
-    bool simple_mode = true;
-    if(lv_draw_mask_get_cnt()) simple_mode = false;
-    else if(dashed) simple_mode = false;
 
     lv_area_t draw_area;
     draw_area.x1 = LV_MIN(point1->x, point2->x);
@@ -139,6 +135,11 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
     draw_area.y1 = point1->y - w_half1;
     draw_area.y2 = point1->y + w_half0;
 
+    bool dashed = dsc->dash_gap && dsc->dash_width ? true : false;
+    bool simple_mode = true;
+    if(lv_draw_mask_is_any(&draw_area)) simple_mode = false;
+    else if(dashed) simple_mode = false;
+
     /*If there is no mask then simply draw a rectangle*/
     if(simple_mode) {
         _lv_blend_fill(clip, &draw_area,
@@ -181,7 +182,8 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
         int32_t h;
         for(h = draw_area.y1; h <= draw_area.y2; h++) {
             lv_memset_ff(mask_buf, draw_area_w);
-            lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h, draw_area_w);
+            lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h,
+                                                             draw_area_w);
 
             if(dashed) {
                 if(mask_res != LV_DRAW_MASK_RES_TRANSP) {
@@ -227,18 +229,17 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
     int32_t w_half0 = w >> 1;
     int32_t w_half1 = w_half0 + (w & 0x1); /*Compensate rounding error*/
 
-    bool dashed = dsc->dash_gap && dsc->dash_width ? true : false;
-
-    bool simple_mode = true;
-    if(lv_draw_mask_get_cnt()) simple_mode = false;
-    else if(dashed) simple_mode = false;
-
     lv_area_t draw_area;
     draw_area.x1 = point1->x - w_half1;
     draw_area.x2 = point1->x + w_half0;
     draw_area.y1 = LV_MIN(point1->y, point2->y);
     draw_area.y2 = LV_MAX(point1->y, point2->y) - 1;
 
+    bool dashed = dsc->dash_gap && dsc->dash_width ? true : false;
+    bool simple_mode = true;
+    if(lv_draw_mask_is_any(&draw_area)) simple_mode = false;
+    else if(dashed) simple_mode = false;
+
     /*If there is no mask then simply draw a rectangle*/
     if(simple_mode) {
         _lv_blend_fill(clip, &draw_area,
@@ -285,7 +286,8 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
         int32_t h;
         for(h = draw_area.y1; h <= draw_area.y2; h++) {
             lv_memset_ff(mask_buf, draw_area_w);
-            lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h, draw_area_w);
+            lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h,
+                                                             draw_area_w);
 
             if(dashed) {
                 if(mask_res != LV_DRAW_MASK_RES_TRANSP) {
@@ -474,6 +476,10 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(const lv_point_t * point1, cons
 
     lv_mem_buf_release(mask_buf);
 
+    lv_draw_mask_free_param(&mask_left_param);
+    lv_draw_mask_free_param(&mask_right_param);
+    if(mask_top_id != LV_MASK_ID_INV) lv_draw_mask_free_param(&mask_top_param);
+    if(mask_bottom_id != LV_MASK_ID_INV) lv_draw_mask_free_param(&mask_bottom_param);
     lv_draw_mask_remove_id(mask_left_id);
     lv_draw_mask_remove_id(mask_right_id);
     lv_draw_mask_remove_id(mask_top_id);
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_line.h b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_line.h
index 660c765a6..111bced52 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_line.h
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_line.h
@@ -31,7 +31,7 @@ typedef struct {
     lv_blend_mode_t blend_mode  : 2;
     uint8_t round_start : 1;
     uint8_t round_end   : 1;
-    uint8_t raw_end     : 1;    /*Do not bother with perpendicular line ending is it's not visible for any reason*/
+    uint8_t raw_end     : 1;    /*Do not bother with perpendicular line ending if it's not visible for any reason*/
 } lv_draw_line_dsc_t;
 
 /**********************
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_mask.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_mask.c
index 2d8c862fe..0197f22d1 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_mask.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_mask.c
@@ -6,8 +6,6 @@
 /*********************
  *      INCLUDES
  *********************/
-
-
 #include "lv_draw_mask.h"
 #if LV_DRAW_COMPLEX
 #include "../misc/lv_math.h"
@@ -18,6 +16,8 @@
 /*********************
  *      DEFINES
  *********************/
+#define CIRCLE_CACHE_LIFE_MAX   1000
+#define CIRCLE_CACHE_AGING(life, r)   life = LV_MIN(life + (r < 16 ? 1 : (r >> 4)), 1000)
 
 /**********************
  *      TYPEDEFS
@@ -49,8 +49,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_
                                                                 lv_coord_t len,
                                                                 lv_draw_mask_line_param_t * p);
 
+static void circ_init(lv_point_t * c, lv_coord_t * tmp, lv_coord_t radius);
+static bool circ_cont(lv_point_t * c);
+static void circ_next(lv_point_t * c, lv_coord_t * tmp);
+static void circ_calc_aa4(_lv_draw_mask_radius_circle_dsc_t * c, lv_coord_t radius);
+static lv_opa_t * get_next_line(_lv_draw_mask_radius_circle_dsc_t * c, lv_coord_t y, lv_coord_t * len,
+                                lv_coord_t * x_start);
 LV_ATTRIBUTE_FAST_MEM static inline lv_opa_t mask_mix(lv_opa_t mask_act, lv_opa_t mask_new);
-LV_ATTRIBUTE_FAST_MEM static inline void sqrt_approx(lv_sqrt_res_t * q, lv_sqrt_res_t * ref, uint32_t x);
 
 /**********************
  *  STATIC VARIABLES
@@ -121,6 +126,39 @@ LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply(lv_opa_t * mask_buf,
     return changed ? LV_DRAW_MASK_RES_CHANGED : LV_DRAW_MASK_RES_FULL_COVER;
 }
 
+/**
+ * Apply the specified buffers on a line. Used internally by the library's drawing routines.
+ * @param mask_buf store the result mask here. Has to be `len` byte long. Should be initialized with `0xFF`.
+ * @param abs_x absolute X coordinate where the line to calculate start
+ * @param abs_y absolute Y coordinate where the line to calculate start
+ * @param len length of the line to calculate (in pixel count)
+ * @param ids ID array of added buffers
+ * @param ids_count number of ID array
+ * @return One of these values:
+ * - `LV_DRAW_MASK_RES_FULL_TRANSP`: the whole line is transparent. `mask_buf` is not set to zero
+ * - `LV_DRAW_MASK_RES_FULL_COVER`: the whole line is fully visible. `mask_buf` is unchanged
+ * - `LV_DRAW_MASK_RES_CHANGED`: `mask_buf` has changed, it shows the desired opacity of each pixel in the given line
+ */
+LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply_ids(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
+                                                                lv_coord_t len, const int16_t *ids, int16_t ids_count)
+{
+    bool changed = false;
+    _lv_draw_mask_common_dsc_t * dsc;
+
+    for (int i = 0; i < ids_count; i++) {
+        int16_t id = ids[i];
+        if (id == LV_MASK_ID_INV) continue;
+        dsc = LV_GC_ROOT(_lv_draw_mask_list[id]).param;
+        if (!dsc) continue;
+        lv_draw_mask_res_t res = LV_DRAW_MASK_RES_FULL_COVER;
+        res = dsc->cb(mask_buf, abs_x, abs_y, len, dsc);
+        if(res == LV_DRAW_MASK_RES_TRANSP) return LV_DRAW_MASK_RES_TRANSP;
+        else if(res == LV_DRAW_MASK_RES_CHANGED) changed = true;
+    }
+
+    return changed ? LV_DRAW_MASK_RES_CHANGED : LV_DRAW_MASK_RES_FULL_COVER;
+}
+
 /**
  * Remove a mask with a given ID
  * @param id the ID of the mask.  Returned by `lv_draw_mask_add`
@@ -129,7 +167,7 @@ LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply(lv_opa_t * mask_buf,
  */
 void * lv_draw_mask_remove_id(int16_t id)
 {
-    void * p = NULL;
+    _lv_draw_mask_common_dsc_t * p = NULL;
 
     if(id != LV_MASK_ID_INV) {
         p = LV_GC_ROOT(_lv_draw_mask_list[id]).param;
@@ -148,18 +186,52 @@ void * lv_draw_mask_remove_id(int16_t id)
  */
 void * lv_draw_mask_remove_custom(void * custom_id)
 {
-    void * p = NULL;
+    _lv_draw_mask_common_dsc_t * p = NULL;
     uint8_t i;
     for(i = 0; i < _LV_MASK_MAX_NUM; i++) {
         if(LV_GC_ROOT(_lv_draw_mask_list[i]).custom_id == custom_id) {
             p = LV_GC_ROOT(_lv_draw_mask_list[i]).param;
-            LV_GC_ROOT(_lv_draw_mask_list[i]).param = NULL;
-            LV_GC_ROOT(_lv_draw_mask_list[i]).custom_id = NULL;
+            lv_draw_mask_remove_id(i);
         }
     }
     return p;
 }
 
+/**
+ * Free the data from the parameter.
+ * It's called inside  `lv_draw_mask_remove_id` and `lv_draw_mask_remove_custom`
+ * Needs to be called only in special cases when the mask is not added by `lv_draw_mask_add`
+ * and not removed by `lv_draw_mask_remove_id` or `lv_draw_mask_remove_custom`
+ * @param p pointer to a mask parameter
+ */
+void lv_draw_mask_free_param(void * p)
+{
+    _lv_draw_mask_common_dsc_t * pdsc = p;
+    if(pdsc->type == LV_DRAW_MASK_TYPE_RADIUS) {
+        lv_draw_mask_radius_param_t * radius_p = (lv_draw_mask_radius_param_t *) p;
+        if(radius_p->circle) {
+            if(radius_p->circle->life < 0) {
+                lv_mem_free(radius_p->circle->cir_opa);
+                lv_mem_free(radius_p->circle);
+            }
+            else {
+                radius_p->circle->used_cnt--;
+            }
+        }
+    }
+}
+
+void _lv_draw_mask_cleanup(void)
+{
+    uint8_t i;
+    for(i = 0; i < LV_CIRCLE_CACHE_SIZE; i++) {
+        if(LV_GC_ROOT(_lv_circle_cache[i]).buf) {
+            lv_mem_free(LV_GC_ROOT(_lv_circle_cache[i]).buf);
+        }
+        lv_memset_00(&LV_GC_ROOT(_lv_circle_cache[i]), sizeof(LV_GC_ROOT(_lv_circle_cache[i])));
+    }
+}
+
 /**
  * Count the currently added masks
  * @return number of active masks
@@ -174,6 +246,32 @@ LV_ATTRIBUTE_FAST_MEM uint8_t lv_draw_mask_get_cnt(void)
     return cnt;
 }
 
+bool lv_draw_mask_is_any(const lv_area_t * a)
+{
+    if(a == NULL) return LV_GC_ROOT(_lv_draw_mask_list[0]).param ? true : false;
+
+    uint8_t i;
+    for(i = 0; i < _LV_MASK_MAX_NUM; i++) {
+        _lv_draw_mask_common_dsc_t * comm_param =  LV_GC_ROOT(_lv_draw_mask_list[i]).param;
+        if(comm_param == NULL) continue;
+        if(comm_param->type == LV_DRAW_MASK_TYPE_RADIUS) {
+            lv_draw_mask_radius_param_t * radius_param =  LV_GC_ROOT(_lv_draw_mask_list[i]).param;
+            if(radius_param->cfg.outer) {
+                if(!_lv_area_is_out(a, &radius_param->cfg.rect, radius_param->cfg.radius)) return true;
+            }
+            else {
+                if(!_lv_area_is_in(a, &radius_param->cfg.rect, radius_param->cfg.radius)) return true;
+            }
+        }
+        else {
+            return true;
+        }
+    }
+
+    return false;
+
+}
+
 /**
  *Initialize a line mask from two points.
  * @param param pointer to a `lv_draw_mask_param_t` to initialize
@@ -228,12 +326,12 @@ void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t
         int32_t m;
 
         if(dx) {
-            m = (1 << 20) / dx;  /*m is multiplier to normalize y (upscaled by 1024)*/
+            m = (1L << 20) / dx;  /*m is multiplier to normalize y (upscaled by 1024)*/
             param->yx_steep = (m * dy) >> 10;
         }
 
         if(dy) {
-            m = (1 << 20) / dy;  /*m is multiplier to normalize x (upscaled by 1024)*/
+            m = (1L << 20) / dy;  /*m is multiplier to normalize x (upscaled by 1024)*/
             param->xy_steep = (m * dx) >> 10;
         }
         param->steep = param->yx_steep;
@@ -243,12 +341,12 @@ void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t
         int32_t m;
 
         if(dy) {
-            m = (1 << 20) / dy;  /*m is multiplier to normalize x (upscaled by 1024)*/
+            m = (1L << 20) / dy;  /*m is multiplier to normalize x (upscaled by 1024)*/
             param->xy_steep = (m * dx) >> 10;
         }
 
         if(dx) {
-            m = (1 << 20) / dx;  /*m is multiplier to normalize x (upscaled by 1024)*/
+            m = (1L << 20) / dx;  /*m is multiplier to normalize x (upscaled by 1024)*/
             param->yx_steep = (m * dy) >> 10;
         }
         param->steep = param->xy_steep;
@@ -373,6 +471,7 @@ void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area
 {
     lv_coord_t w = lv_area_get_width(rect);
     lv_coord_t h = lv_area_get_height(rect);
+    if(radius < 0) radius = 0;
     int32_t short_side = LV_MIN(w, h);
     if(radius > short_side >> 1) radius = short_side >> 1;
 
@@ -381,9 +480,48 @@ void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area
     param->cfg.outer = inv ? 1 : 0;
     param->dsc.cb = (lv_draw_mask_xcb_t)lv_draw_mask_radius;
     param->dsc.type = LV_DRAW_MASK_TYPE_RADIUS;
-    param->y_prev = INT32_MIN;
-    param->y_prev_x.f = 0;
-    param->y_prev_x.i = 0;
+
+    if(radius == 0) {
+        param->circle = NULL;
+        return;
+    }
+
+    uint32_t i;
+
+    /*Try to reuse a circle cache entry*/
+    for(i = 0; i < LV_CIRCLE_CACHE_SIZE; i++) {
+        if(LV_GC_ROOT(_lv_circle_cache[i]).radius == radius) {
+            LV_GC_ROOT(_lv_circle_cache[i]).used_cnt++;
+            CIRCLE_CACHE_AGING(LV_GC_ROOT(_lv_circle_cache[i]).life, radius);
+            param->circle = &LV_GC_ROOT(_lv_circle_cache[i]);
+            return;
+        }
+    }
+
+    /*If not found find a free entry with lowest life*/
+    _lv_draw_mask_radius_circle_dsc_t * entry = NULL;
+    for(i = 0; i < LV_CIRCLE_CACHE_SIZE; i++) {
+        if(LV_GC_ROOT(_lv_circle_cache[i]).used_cnt == 0) {
+            if(!entry) entry = &LV_GC_ROOT(_lv_circle_cache[i]);
+            else if(LV_GC_ROOT(_lv_circle_cache[i]).life < entry->life) entry = &LV_GC_ROOT(_lv_circle_cache[i]);
+        }
+    }
+
+    if(!entry) {
+        entry = lv_mem_alloc(sizeof(_lv_draw_mask_radius_circle_dsc_t));
+        LV_ASSERT_MALLOC(entry);
+        lv_memset_00(entry, sizeof(_lv_draw_mask_radius_circle_dsc_t));
+        entry->life = -1;
+    }
+    else {
+        entry->used_cnt++;
+        entry->life = 0;
+        CIRCLE_CACHE_AGING(entry->life, radius);
+    }
+
+    param->circle = entry;
+
+    circ_calc_aa4(param->circle, radius);
 }
 
 /**
@@ -515,7 +653,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_flat(lv_opa_t * mask_b
         }
     }
 
-    /*At the end of the mask if the limit line is smaller then the mask's y.
+    /*At the end of the mask if the limit line is smaller than the mask's y.
      *Then the mask is in the "good" area*/
     y_at_x = (int32_t)((int32_t)p->yx_steep * (abs_x + len)) >> 10;
     if(p->yx_steep > 0) {
@@ -608,7 +746,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_
 {
     int32_t k;
     int32_t x_at_y;
-    /*At the beginning of the mask if the limit line is greater then the mask's y.
+    /*At the beginning of the mask if the limit line is greater than the mask's y.
      *Then the mask is in the "wrong" area*/
     x_at_y = (int32_t)((int32_t)p->xy_steep * abs_y) >> 10;
     if(p->xy_steep > 0) x_at_y++;
@@ -621,7 +759,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t line_mask_steep(lv_opa_t * mask_
         }
     }
 
-    /*At the end of the mask if the limit line is smaller then the mask's y.
+    /*At the end of the mask if the limit line is smaller than the mask's y.
      *Then the mask is in the "good" area*/
     x_at_y = (int32_t)((int32_t)p->xy_steep * (abs_y)) >> 10;
     if(x_at_y > abs_x + len) {
@@ -881,6 +1019,8 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_angle(lv_opa_t * ma
     }
 }
 
+
+
 LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * mask_buf, lv_coord_t abs_x,
                                                                     lv_coord_t abs_y, lv_coord_t len,
                                                                     lv_draw_mask_radius_param_t * p)
@@ -891,7 +1031,7 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
     lv_area_copy(&rect, &p->cfg.rect);
 
     if(outer == false) {
-        if(abs_y < rect.y1 || abs_y > rect.y2) {
+        if((abs_y < rect.y1 || abs_y > rect.y2)) {
             return LV_DRAW_MASK_RES_TRANSP;
         }
     }
@@ -932,6 +1072,13 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
         }
         return LV_DRAW_MASK_RES_CHANGED;
     }
+    //    printf("exec: x:%d.. %d, y:%d: r:%d, %s\n", abs_x, abs_x + len - 1, abs_y, p->cfg.radius, p->cfg.outer ? "inv" : "norm");
+
+
+    //    if( abs_x == 276 && abs_x + len - 1 == 479 && abs_y == 63 && p->cfg.radius == 5 && p->cfg.outer == 1) {
+    //        char x = 0;
+    //    }
+    //exec: x:276.. 479, y:63: r:5, inv)
 
     int32_t k = rect.x1 - abs_x; /*First relevant coordinate on the of the mask*/
     int32_t w = lv_area_get_width(&rect);
@@ -939,194 +1086,53 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_radius(lv_opa_t * m
     abs_x -= rect.x1;
     abs_y -= rect.y1;
 
-    uint32_t r2 = p->cfg.radius * p->cfg.radius;
+    lv_coord_t aa_len;
+    lv_coord_t x_start;
+    lv_coord_t cir_y;
+    if(abs_y < radius) {
+        cir_y = radius - abs_y - 1;
+    }
+    else {
+        cir_y = abs_y - (h - radius);
+    }
+    lv_opa_t * aa_opa = get_next_line(p->circle, cir_y, &aa_len, &x_start);
+    lv_coord_t cir_x_right = k + w - radius + x_start;
+    lv_coord_t cir_x_left = k + radius - x_start - 1;
+    lv_coord_t i;
 
-    /*Handle corner areas*/
-    if(abs_y < radius || abs_y > h - radius - 1) {
-
-        uint32_t sqrt_mask;
-        if(radius <= 32) sqrt_mask = 0x200;
-        if(radius <= 256) sqrt_mask = 0x800;
-        else sqrt_mask = 0x8000;
-
-        lv_sqrt_res_t x0;
-        lv_sqrt_res_t x1;
-        /*y = 0 should mean the top of the circle*/
-        int32_t y;
-        if(abs_y < radius) {
-            y = radius - abs_y;
-
-            /*Get the x intersection points for `abs_y` and `abs_y-1`
-             *Use the circle's equation x = sqrt(r^2 - y^2)
-             *Try to use the values from the previous run*/
-            if(y == p->y_prev) {
-                x0.f = p->y_prev_x.f;
-                x0.i = p->y_prev_x.i;
+    if(outer == false) {
+        for(i = 0; i < aa_len; i++) {
+            lv_opa_t opa = aa_opa[aa_len - i - 1];
+            if(cir_x_right + i >= 0 && cir_x_right + i < len) {
+                mask_buf[cir_x_right + i] = mask_mix(opa, mask_buf[cir_x_right + i]);
             }
-            else {
-                lv_sqrt(r2 - (y * y), &x0, sqrt_mask);
-            }
-            lv_sqrt(r2 - ((y - 1) * (y - 1)), &x1, sqrt_mask);
-            p->y_prev = y - 1;
-            p->y_prev_x.f = x1.f;
-            p->y_prev_x.i = x1.i;
-        }
-        else {
-            y = radius - (h - abs_y) + 1;
-
-            /*Get the x intersection points for `abs_y` and `abs_y-1`
-             *Use the circle's equation x = sqrt(r^2 - y^2)
-             *Try to use the values from the previous run*/
-            if((y - 1) == p->y_prev) {
-                x1.f = p->y_prev_x.f;
-                x1.i = p->y_prev_x.i;
-            }
-            else {
-                lv_sqrt(r2 - ((y - 1) * (y - 1)), &x1, sqrt_mask);
-            }
-
-            lv_sqrt(r2 - (y * y), &x0, sqrt_mask);
-            p->y_prev = y;
-            p->y_prev_x.f = x0.f;
-            p->y_prev_x.i = x0.i;
-        }
-
-        /*If x1 is on the next round coordinate (e.g. x0: 3.5, x1:4.0)
-         *then treat x1 as x1: 3.99 to handle them as they were on the same pixel*/
-        if(x0.i == x1.i - 1 && x1.f == 0) {
-            x1.i--;
-            x1.f = 0xFF;
-        }
-
-        /*If the two x intersections are on the same x then just get average of the fractions*/
-        if(x0.i == x1.i) {
-            lv_opa_t m = (x0.f + x1.f) >> 1;
-            if(outer) m = 255 - m;
-            int32_t ofs = radius - x0.i - 1;
-
-            /*Left corner*/
-            int32_t kl = k + ofs;
-
-            if(kl >= 0 && kl < len) {
-                mask_buf[kl] = mask_mix(mask_buf[kl], m);
-            }
-
-            /*Right corner*/
-            int32_t kr = k + (w - ofs - 1);
-            if(kr >= 0 && kr < len) {
-                mask_buf[kr] = mask_mix(mask_buf[kr], m);
-            }
-
-            /*Clear the unused parts*/
-            if(outer == false) {
-                kr++;
-                if(kl > len)  {
-                    return LV_DRAW_MASK_RES_TRANSP;
-                }
-                if(kl >= 0) {
-                    lv_memset_00(&mask_buf[0], kl);
-                }
-                if(kr < 0) {
-                    return LV_DRAW_MASK_RES_TRANSP;
-                }
-                if(kr <= len) {
-                    lv_memset_00(&mask_buf[kr], len - kr);
-                }
-            }
-            else {
-                kl++;
-                int32_t first = kl;
-                if(first < 0) first = 0;
-
-                int32_t len_tmp = kr - first;
-                if(len_tmp + first > len) len_tmp = len - first;
-                if(first < len && len_tmp >= 0) {
-                    lv_memset_00(&mask_buf[first], len_tmp);
-                }
+            if(cir_x_left - i >= 0 && cir_x_left - i < len) {
+                mask_buf[cir_x_left - i] = mask_mix(opa, mask_buf[cir_x_left - i]);
             }
         }
-        /*Multiple pixels are affected. Get y intersection of the pixels*/
-        else {
-            int32_t ofs = radius - (x0.i + 1);
-            int32_t kl = k + ofs;
-            int32_t kr = k + (w - ofs - 1);
 
-            if(outer) {
-                int32_t first = kl + 1;
-                if(first < 0) first = 0;
+        /*Clean the right side*/
+        cir_x_right = LV_CLAMP(0, cir_x_right + i, len);
+        lv_memset_00(&mask_buf[cir_x_right], len - cir_x_right);
 
-                int32_t len_tmp = kr - first;
-                if(len_tmp + first > len) len_tmp = len - first;
-                if(first < len && len_tmp >= 0) {
-                    lv_memset_00(&mask_buf[first], len_tmp);
-                }
+        /*Clean the left side*/
+        cir_x_left = LV_CLAMP(0, cir_x_left - aa_len + 1, len);
+        lv_memset_00(&mask_buf[0], cir_x_left);
+    }
+    else {
+        for(i = 0; i < aa_len; i++) {
+            lv_opa_t opa = 255 - (aa_opa[aa_len - 1 - i]);
+            if(cir_x_right + i >= 0 && cir_x_right + i < len) {
+                mask_buf[cir_x_right + i] = mask_mix(opa, mask_buf[cir_x_right + i]);
             }
-
-            uint32_t i = x0.i + 1;
-            lv_opa_t m;
-            lv_sqrt_res_t y_prev;
-            lv_sqrt_res_t y_next;
-
-            lv_sqrt(r2 - (x0.i * x0.i), &y_prev, sqrt_mask);
-
-            if(y_prev.f == 0) {
-                y_prev.i--;
-                y_prev.f = 0xFF;
-            }
-
-            /*The first y intersection is special as it might be in the previous line*/
-            if(y_prev.i >= y) {
-                lv_sqrt(r2 - (i * i), &y_next, sqrt_mask);
-                m = 255 - (((255 - x0.f) * (255 - y_next.f)) >> 9);
-
-                if(outer) m = 255 - m;
-                if(kl >= 0 && kl < len) mask_buf[kl] = mask_mix(mask_buf[kl], m);
-                if(kr >= 0 && kr < len) mask_buf[kr] = mask_mix(mask_buf[kr], m);
-                kl--;
-                kr++;
-                y_prev.f = y_next.f;
-                i++;
-            }
-
-            /*Set all points which are crossed by the circle*/
-            for(; i <= x1.i; i++) {
-                /*These values are very close to each other. It's enough to approximate sqrt
-                 *The non-approximated version is lv_sqrt(r2 - (i * i), &y_next, sqrt_mask);*/
-                sqrt_approx(&y_next, &y_prev, r2 - (i * i));
-
-                m = (y_prev.f + y_next.f) >> 1;
-                if(outer) m = 255 - m;
-                if(kl >= 0 && kl < len) mask_buf[kl] = mask_mix(mask_buf[kl], m);
-                if(kr >= 0 && kr < len) mask_buf[kr] = mask_mix(mask_buf[kr], m);
-                kl--;
-                kr++;
-                y_prev.f = y_next.f;
-            }
-
-            /*If the last pixel was left in its middle therefore
-             * the circle still has parts on the next one*/
-            if(y_prev.f) {
-                m = (y_prev.f * x1.f) >> 9;
-                if(outer) m = 255 - m;
-                if(kl >= 0 && kl < len) mask_buf[kl] = mask_mix(mask_buf[kl], m);
-                if(kr >= 0 && kr < len) mask_buf[kr] = mask_mix(mask_buf[kr], m);
-                kl--;
-                kr++;
-            }
-
-            if(outer == 0) {
-                kl++;
-                if(kl > len) {
-                    return LV_DRAW_MASK_RES_TRANSP;
-                }
-                if(kl >= 0) lv_memset_00(&mask_buf[0], kl);
-
-                if(kr < 0) {
-                    return LV_DRAW_MASK_RES_TRANSP;
-                }
-                if(kr < len) lv_memset_00(&mask_buf[kr], len - kr);
+            if(cir_x_left - i >= 0 && cir_x_left - i < len) {
+                mask_buf[cir_x_left - i] = mask_mix(opa, mask_buf[cir_x_left - i]);
             }
         }
+
+        lv_coord_t clr_start = LV_CLAMP(0, cir_x_left + 1, len);
+        lv_coord_t clr_len = LV_CLAMP(0, cir_x_right - clr_start, len - clr_start);
+        lv_memset_00(&mask_buf[clr_start], clr_len);
     }
 
     return LV_DRAW_MASK_RES_CHANGED;
@@ -1212,6 +1218,204 @@ LV_ATTRIBUTE_FAST_MEM static lv_draw_mask_res_t lv_draw_mask_map(lv_opa_t * mask
     return LV_DRAW_MASK_RES_CHANGED;
 }
 
+/**
+ * Initialize the circle drawing
+ * @param c pointer to a point. The coordinates will be calculated here
+ * @param tmp point to a variable. It will store temporary data
+ * @param radius radius of the circle
+ */
+static void circ_init(lv_point_t * c, lv_coord_t * tmp, lv_coord_t radius)
+{
+    c->x = radius;
+    c->y = 0;
+    *tmp = 1 - radius;
+}
+
+/**
+ * Test the circle drawing is ready or not
+ * @param c same as in circ_init
+ * @return true if the circle is not ready yet
+ */
+static bool circ_cont(lv_point_t * c)
+{
+    return c->y <= c->x ? true : false;
+}
+
+/**
+ * Get the next point from the circle
+ * @param c same as in circ_init. The next point stored here.
+ * @param tmp same as in circ_init.
+ */
+static void circ_next(lv_point_t * c, lv_coord_t * tmp)
+{
+
+    if(*tmp <= 0) {
+        (*tmp) += 2 * c->y + 3; /*Change in decision criterion for y -> y+1*/
+    }
+    else {
+        (*tmp) += 2 * (c->y - c->x) + 5; /*Change for y -> y+1, x -> x-1*/
+        c->x--;
+    }
+    c->y++;
+}
+
+static void circ_calc_aa4(_lv_draw_mask_radius_circle_dsc_t * c, lv_coord_t radius)
+{
+    if(radius == 0) return;
+    c->radius = radius;
+
+    /*Allocate buffers*/
+    if(c->buf) lv_mem_free(c->buf);
+
+    c->buf = lv_mem_alloc(radius * 6 + 6);  /*Use uint16_t for opa_start_on_y and x_start_on_y*/
+    LV_ASSERT_MALLOC(c->buf);
+    c->cir_opa = c->buf;
+    c->opa_start_on_y = (uint16_t *)(c->buf + 2 * radius + 2);
+    c->x_start_on_y = (uint16_t *)(c->buf + 4 * radius + 4);
+
+    /*Special case, handle manually*/
+    if(radius == 1) {
+        c->cir_opa[0] =  180;
+        c->opa_start_on_y[0] =  0;
+        c->opa_start_on_y[1] =  1;
+        c->x_start_on_y[0] =  0;
+        return;
+    }
+
+    lv_coord_t * cir_x = lv_mem_buf_get((radius + 1) * 2 * 2 * sizeof(lv_coord_t));
+    lv_coord_t * cir_y = &cir_x[(radius + 1) * 2];
+
+    uint32_t y_8th_cnt = 0;
+    lv_point_t cp;
+    lv_coord_t tmp;
+    circ_init(&cp, &tmp, radius * 4);    /*Upscale by 4*/
+    int32_t i;
+
+    uint32_t x_int[4];
+    uint32_t x_fract[4];
+    lv_coord_t cir_size = 0;
+    x_int[0] = cp.x >> 2;
+    x_fract[0] = 0;
+
+    /*Calculate an 1/8 circle*/
+    while(circ_cont(&cp)) {
+        /*Calculate 4 point of the circle */
+        for(i = 0; i < 4; i++) {
+            circ_next(&cp, &tmp);
+            if(circ_cont(&cp) == false) break;
+            x_int[i] = cp.x >> 2;
+            x_fract[i] = cp.x & 0x3;
+        }
+        if(i != 4) break;
+
+        /*All lines on the same x when downscaled*/
+        if(x_int[0] == x_int[3]) {
+            cir_x[cir_size] = x_int[0];
+            cir_y[cir_size] = y_8th_cnt;
+            c->cir_opa[cir_size] = x_fract[0] + x_fract[1] + x_fract[2] + x_fract[3];
+            c->cir_opa[cir_size] *= 16;
+            cir_size++;
+        }
+        /*Second line on new x when downscaled*/
+        else if(x_int[0] != x_int[1]) {
+            cir_x[cir_size] = x_int[0];
+            cir_y[cir_size] = y_8th_cnt;
+            c->cir_opa[cir_size] = x_fract[0];
+            c->cir_opa[cir_size] *= 16;
+            cir_size++;
+
+            cir_x[cir_size] = x_int[0] - 1;
+            cir_y[cir_size] = y_8th_cnt;
+            c->cir_opa[cir_size] = 1 * 4 + x_fract[1] + x_fract[2] + x_fract[3];;
+            c->cir_opa[cir_size] *= 16;
+            cir_size++;
+        }
+        /*Third line on new x when downscaled*/
+        else if(x_int[0] != x_int[2]) {
+            cir_x[cir_size] = x_int[0];
+            cir_y[cir_size] = y_8th_cnt;
+            c->cir_opa[cir_size] = x_fract[0] + x_fract[1];
+            c->cir_opa[cir_size] *= 16;
+            cir_size++;
+
+            cir_x[cir_size] = x_int[0] - 1;
+            cir_y[cir_size] = y_8th_cnt;
+            c->cir_opa[cir_size] = 2 * 4 + x_fract[2] + x_fract[3];;
+            c->cir_opa[cir_size] *= 16;
+            cir_size++;
+        }
+        /*Forth line on new x when downscaled*/
+        else {
+            cir_x[cir_size] = x_int[0];
+            cir_y[cir_size] = y_8th_cnt;
+            c->cir_opa[cir_size] = x_fract[0] + x_fract[1] + x_fract[2];
+            c->cir_opa[cir_size] *= 16;
+            cir_size++;
+
+            cir_x[cir_size] = x_int[0] - 1;
+            cir_y[cir_size] = y_8th_cnt;
+            c->cir_opa[cir_size] = 3 * 4 + x_fract[3];;
+            c->cir_opa[cir_size] *= 16;
+            cir_size++;
+        }
+
+        y_8th_cnt++;
+    }
+
+    /*The point on the 1/8 circle is special, calculate it manually*/
+    int32_t mid = radius * 723;
+    int32_t mid_int = mid >> 10;
+    if(cir_x[cir_size - 1] != mid_int || cir_y[cir_size - 1] != mid_int) {
+        int32_t tmp_val = mid - (mid_int << 10);
+        if(tmp_val <= 512) {
+            tmp_val = tmp_val * tmp_val * 2;
+            tmp_val = tmp_val >> (10 + 6);
+        }
+        else {
+            tmp_val = 1024 - tmp_val;
+            tmp_val = tmp_val * tmp_val * 2;
+            tmp_val = tmp_val >> (10 + 6);
+            tmp_val = 15 - tmp_val;
+        }
+
+        cir_x[cir_size] = mid_int;
+        cir_y[cir_size] = mid_int;
+        c->cir_opa[cir_size] = tmp_val;
+        c->cir_opa[cir_size] *= 16;
+        cir_size++;
+    }
+
+    /*Build the second octet by mirroring the first*/
+    for(i = cir_size - 2; i >= 0; i--, cir_size++) {
+        cir_x[cir_size] = cir_y[i];
+        cir_y[cir_size] = cir_x[i];
+        c->cir_opa[cir_size] = c->cir_opa[i];
+    }
+
+    lv_coord_t y = 0;
+    i = 0;
+    c->opa_start_on_y[0] = 0;
+    while(i < cir_size) {
+        c->opa_start_on_y[y] = i;
+        c->x_start_on_y[y] = cir_x[i];
+        for(; cir_y[i] == y && i < (int32_t)cir_size; i++) {
+            c->x_start_on_y[y] = LV_MIN(c->x_start_on_y[y], cir_x[i]);
+        }
+        y++;
+    }
+
+    lv_mem_buf_release(cir_x);
+}
+
+static lv_opa_t * get_next_line(_lv_draw_mask_radius_circle_dsc_t * c, lv_coord_t y, lv_coord_t * len,
+                                lv_coord_t * x_start)
+{
+    *len = c->opa_start_on_y[y + 1] - c->opa_start_on_y[y];
+    *x_start = c->x_start_on_y[y];
+    return &c->cir_opa[c->opa_start_on_y[y]];
+}
+
+
 LV_ATTRIBUTE_FAST_MEM static inline lv_opa_t mask_mix(lv_opa_t mask_act, lv_opa_t mask_new)
 {
     if(mask_new >= LV_OPA_MAX) return mask_act;
@@ -1220,24 +1424,5 @@ LV_ATTRIBUTE_FAST_MEM static inline lv_opa_t mask_mix(lv_opa_t mask_act, lv_opa_
     return LV_UDIV255(mask_act * mask_new);// >> 8);
 }
 
-/**
- * Approximate the sqrt near to an already calculated value
- * @param q store the result here
- * @param ref the reference point (already calculated sqrt)
- * @param x the value which sqrt should be approximated
- */
-LV_ATTRIBUTE_FAST_MEM static inline void sqrt_approx(lv_sqrt_res_t * q, lv_sqrt_res_t * ref, uint32_t x)
-{
-    x = x << 8; /*Upscale for extra precision*/
-
-    uint32_t raw = (ref->i << 4) + (ref->f >> 4);
-    uint32_t raw2 = raw * raw;
-
-    int32_t d = x - raw2;
-    d = (int32_t)d / (int32_t)(2 * raw) + raw;
-
-    q->i = d >> 4;
-    q->f = (d & 0xF) << 4;
-}
 
 #endif /*LV_DRAW_COMPLEX*/
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_mask.h b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_mask.h
index 893040494..123cd9163 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_mask.h
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_mask.h
@@ -55,9 +55,17 @@ typedef _lv_draw_mask_saved_t _lv_draw_mask_saved_arr_t[_LV_MASK_MAX_NUM];
 
 
 #if LV_DRAW_COMPLEX == 0
-static inline  uint8_t lv_draw_mask_get_cnt(void) {
+static inline  uint8_t lv_draw_mask_get_cnt(void)
+{
     return 0;
 }
+
+static inline bool lv_draw_mask_is_any(const lv_area_t * a)
+{
+    LV_UNUSED(a);
+    return false;
+}
+
 #endif
 
 #if LV_DRAW_COMPLEX
@@ -147,6 +155,18 @@ typedef struct {
     uint16_t delta_deg;
 } lv_draw_mask_angle_param_t;
 
+typedef struct  {
+    uint8_t * buf;
+    lv_opa_t * cir_opa;         /*Opacity of values on the circumference of an 1/4 circle*/
+    uint16_t * x_start_on_y;        /*The x coordinate of the circle for each y value*/
+    uint16_t * opa_start_on_y;      /*The index of `cir_opa` for each y value*/
+    int32_t life;               /*How many times the entry way used*/
+    uint32_t used_cnt;          /*Like a semaphore to count the referencing masks*/
+    lv_coord_t radius;          /*The radius of the entry*/
+} _lv_draw_mask_radius_circle_dsc_t;
+
+typedef _lv_draw_mask_radius_circle_dsc_t _lv_draw_mask_radius_circle_dsc_arr_t[LV_CIRCLE_CACHE_SIZE];
+
 typedef struct {
     /*The first element must be the common descriptor*/
     _lv_draw_mask_common_dsc_t dsc;
@@ -157,9 +177,8 @@ typedef struct {
         /*Invert the mask. 0: Keep the pixels inside.*/
         uint8_t outer: 1;
     } cfg;
-    int32_t y_prev;
-    lv_sqrt_res_t y_prev_x;
 
+    _lv_draw_mask_radius_circle_dsc_t * circle;
 } lv_draw_mask_radius_param_t;
 
 
@@ -217,6 +236,22 @@ int16_t lv_draw_mask_add(void * param, void * custom_id);
 LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
                                                             lv_coord_t len);
 
+/**
+ * Apply the specified buffers on a line. Used internally by the library's drawing routines.
+ * @param mask_buf store the result mask here. Has to be `len` byte long. Should be initialized with `0xFF`.
+ * @param abs_x absolute X coordinate where the line to calculate start
+ * @param abs_y absolute Y coordinate where the line to calculate start
+ * @param len length of the line to calculate (in pixel count)
+ * @param ids ID array of added buffers
+ * @param ids_count number of ID array
+ * @return One of these values:
+ * - `LV_DRAW_MASK_RES_FULL_TRANSP`: the whole line is transparent. `mask_buf` is not set to zero
+ * - `LV_DRAW_MASK_RES_FULL_COVER`: the whole line is fully visible. `mask_buf` is unchanged
+ * - `LV_DRAW_MASK_RES_CHANGED`: `mask_buf` has changed, it shows the desired opacity of each pixel in the given line
+ */
+LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply_ids(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
+                                                                lv_coord_t len, const int16_t *ids, int16_t ids_count);
+
 //! @endcond
 
 /**
@@ -235,6 +270,21 @@ void * lv_draw_mask_remove_id(int16_t id);
  */
 void * lv_draw_mask_remove_custom(void * custom_id);
 
+/**
+ * Free the data from the parameter.
+ * It's called inside  `lv_draw_mask_remove_id` and `lv_draw_mask_remove_custom`
+ * Needs to be called only in special cases when the mask is not added by `lv_draw_mask_add`
+ * and not removed by `lv_draw_mask_remove_id` or `lv_draw_mask_remove_custom`
+ * @param p pointer to a mask parameter
+ */
+void lv_draw_mask_free_param(void * p);
+
+/**
+ * Called by LVGL the rendering of a screen is ready to clean up
+ * the temporal (cache) data of the masks
+ */
+void _lv_draw_mask_cleanup(void);
+
 //! @cond Doxygen_Suppress
 
 /**
@@ -243,6 +293,14 @@ void * lv_draw_mask_remove_custom(void * custom_id);
  */
 LV_ATTRIBUTE_FAST_MEM uint8_t lv_draw_mask_get_cnt(void);
 
+
+/**
+ * Check if there is any added draw mask
+ * @param a     an area to test for affecting masks.
+ * @return true: there is t least 1 draw mask; false: there are no draw masks
+ */
+bool lv_draw_mask_is_any(const lv_area_t * a);
+
 //! @endcond
 
 /**
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_rect.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_rect.c
index 59953ac70..5778737fe 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_rect.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_rect.c
@@ -28,10 +28,11 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_area_t * clip,
+#if LV_USE_EXTERNAL_RENDERER == 0
+LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_area_t * clip_area,
                                           const lv_draw_rect_dsc_t * dsc);
 LV_ATTRIBUTE_FAST_MEM static void draw_bg_img(const lv_area_t * coords, const lv_area_t * clip,
-                                          const lv_draw_rect_dsc_t * dsc);
+                                              const lv_draw_rect_dsc_t * dsc);
 LV_ATTRIBUTE_FAST_MEM static void draw_border(const lv_area_t * coords, const lv_area_t * clip,
                                               const lv_draw_rect_dsc_t * dsc);
 
@@ -43,16 +44,17 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(const lv_area_t * coords, const lv
 LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coords,  uint16_t * sh_buf, lv_coord_t s,
                                                          lv_coord_t r);
 LV_ATTRIBUTE_FAST_MEM static void shadow_blur_corner(lv_coord_t size, lv_coord_t sw, uint16_t * sh_ups_buf);
-
-static void draw_full_border(const lv_area_t * area_inner, const lv_area_t * area_outer, const lv_area_t * clip,
-                             lv_coord_t radius, bool radius_is_in, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);
-#else
-static void draw_simple_border(const lv_area_t * clip, const lv_area_t * area_inner, const lv_area_t * area_outer,
-        lv_color_t color, lv_opa_t opa, lv_border_side_t side);
 #endif
 
+void draw_border_generic(const lv_area_t * clip_area, const lv_area_t * outer_area, const lv_area_t * inner_area,
+                         lv_coord_t rout, lv_coord_t rin, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);
+
+static void draw_border_simple(const lv_area_t * clip, const lv_area_t * outer_area, const lv_area_t * inner_area,
+                               lv_color_t color, lv_opa_t opa);
+
 #if LV_DRAW_COMPLEX
-LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(const lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i);
+    LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(const lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i);
+#endif
 #endif
 
 /**********************
@@ -89,6 +91,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc)
     dsc->border_side = LV_BORDER_SIDE_FULL;
 }
 
+#if LV_USE_EXTERNAL_RENDERER == 0
 /**
  * Draw a rectangle
  * @param coords the coordinates of the rectangle
@@ -116,7 +119,7 @@ void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_dra
  *   STATIC FUNCTIONS
  **********************/
 
-LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_area_t * clip,
+LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_area_t * clip_area,
                                           const lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->bg_opa <= LV_OPA_MIN) return;
@@ -132,210 +135,186 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
         coords_bg.y2 -= (dsc->border_side & LV_BORDER_SIDE_BOTTOM) ? 1 : 0;
     }
 
-    lv_opa_t opa = dsc->bg_opa;
-
-    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
-
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    lv_disp_draw_buf_t * draw_buf = lv_disp_get_draw_buf(disp);
-
-    /*Get clipped fill area which is the real draw area.
-     *It is always the same or inside `fill_area`*/
-    lv_area_t draw_area;
-    bool is_common;
-    is_common = _lv_area_intersect(&draw_area, &coords_bg, clip);
-    if(is_common == false) return;
-
-    const lv_area_t * disp_area = &draw_buf->area;
-
-    /*Now `draw_area` has absolute coordinates.
-     *Make it relative to `disp_area` to simplify draw to `disp_buf`*/
-    draw_area.x1 -= disp_area->x1;
-    draw_area.y1 -= disp_area->y1;
-    draw_area.x2 -= disp_area->x1;
-    draw_area.y2 -= disp_area->y1;
-
-
+    lv_opa_t opa = dsc->bg_opa >= LV_OPA_MAX ? LV_OPA_COVER : dsc->bg_opa;
     lv_grad_dir_t grad_dir = dsc->bg_grad_dir;
     if(dsc->bg_color.full == dsc->bg_grad_color.full) grad_dir = LV_GRAD_DIR_NONE;
 
-    uint16_t other_mask_cnt = lv_draw_mask_get_cnt();
-    bool simple_mode = true;
-    if(other_mask_cnt) simple_mode = false;
-    else if(grad_dir == LV_GRAD_DIR_HOR) simple_mode = false;
-
-
-    int32_t coords_w = lv_area_get_width(&coords_bg);
-    int32_t coords_h = lv_area_get_height(&coords_bg);
-
-    /*Get the real radius*/
-    int32_t rout = dsc->radius;
-    int32_t short_side = LV_MIN(coords_w, coords_h);
-    if(rout > short_side >> 1) rout = short_side >> 1;
+    bool mask_any = lv_draw_mask_is_any(&coords_bg);
 
     /*Most simple case: just a plain rectangle*/
-    if(simple_mode && rout == 0 && (grad_dir == LV_GRAD_DIR_NONE)) {
-        _lv_blend_fill(clip, &coords_bg,
-                       dsc->bg_color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa,
-                       dsc->blend_mode);
+    if(!mask_any && dsc->radius == 0 && (grad_dir == LV_GRAD_DIR_NONE)) {
+        _lv_blend_fill(clip_area, &coords_bg, dsc->bg_color, NULL,
+                       LV_DRAW_MASK_RES_FULL_COVER, opa, dsc->blend_mode);
+        return;
     }
 
-#if LV_DRAW_COMPLEX
-    /*More complex case: there is a radius, gradient or other mask.*/
-    else {
-        int32_t draw_area_w = lv_area_get_width(&draw_area);
-        int16_t mask_rout_id = LV_MASK_ID_INV;
-        lv_opa_t * mask_buf = lv_mem_buf_get(draw_area_w);
-        lv_draw_mask_radius_param_t mask_rout_param;
-        if(rout > 0) {
-            lv_draw_mask_radius_init(&mask_rout_param, &coords_bg, rout, false);
-            mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
+    /*Complex case: there is gradient, mask, or radius*/
+#if LV_DRAW_COMPLEX == 0
+    LV_LOG_WARN("Can't draw complex rectangle because LV_DRAW_COMPLEX = 0");
+#else
+    /*Get clipped fill area which is the real draw area.
+     *It is always the same or inside `fill_area`*/
+    lv_area_t draw_area;
+    if(!_lv_area_intersect(&draw_area, &coords_bg, clip_area)) return;
+
+    /*Get the real radius. Can't be larger than the half of the shortest side */
+    lv_coord_t coords_w = lv_area_get_width(&coords_bg);
+    lv_coord_t coords_h = lv_area_get_height(&coords_bg);
+    int32_t short_side = LV_MIN(coords_w, coords_h);
+    int32_t rout = LV_MIN(dsc->radius, short_side >> 1);
+
+    /*Add a radius mask if there is radius*/
+    int32_t draw_area_w = lv_area_get_width(&draw_area);
+    int16_t mask_rout_id = LV_MASK_ID_INV;
+    lv_opa_t * mask_buf = NULL;
+    lv_draw_mask_radius_param_t mask_rout_param;
+    if(rout > 0 || mask_any) {
+        mask_buf = lv_mem_buf_get(draw_area_w);
+        lv_draw_mask_radius_init(&mask_rout_param, &coords_bg, rout, false);
+        mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
+    }
+
+    /*In case of horizontal gradient pre-compute a line with a gradient*/
+    lv_color_t * grad_map = NULL;
+    lv_color_t * grad_map_ofs = NULL;
+    if(grad_dir == LV_GRAD_DIR_HOR) {
+        grad_map = lv_mem_buf_get(coords_w * sizeof(lv_color_t));
+        int32_t i;
+        for(i = 0; i < coords_w; i++) {
+            grad_map[i] = grad_get(dsc, coords_w, i);
         }
+        grad_map_ofs = grad_map;
+        if(dsc->bg_grad_dir == LV_GRAD_DIR_HOR) grad_map_ofs += draw_area.x1 - coords_bg.x1;
+    }
 
-        /*Draw the background line by line*/
-        int32_t h;
-        lv_draw_mask_res_t mask_res = LV_DRAW_MASK_RES_FULL_COVER;
-        lv_color_t grad_color = dsc->bg_color;
+    int32_t h;
+    lv_draw_mask_res_t mask_res;
+    lv_area_t blend_area;
+    blend_area.x1 = draw_area.x1;
+    blend_area.x2 = draw_area.x2;
 
-        /*In case of horizontal gradient pre-compute a line with a gradient*/
-        lv_color_t * grad_map = NULL;
-        if(grad_dir == LV_GRAD_DIR_HOR) {
-            grad_map = lv_mem_buf_get(coords_w * sizeof(lv_color_t));
-
-            int32_t i;
-            for(i = 0; i < coords_w; i++) {
-                grad_map[i] = grad_get(dsc, coords_w, i);
-            }
-        }
-
-        bool split = false;
-        if(lv_area_get_width(&coords_bg) - 2 * rout > SPLIT_LIMIT) split = true;
-
-        lv_opa_t opa2;
-
-        lv_area_t fill_area;
-        fill_area.x1 = coords_bg.x1;
-        fill_area.x2 = coords_bg.x2;
-        fill_area.y1 = disp_area->y1 + draw_area.y1;
-        fill_area.y2 = fill_area.y1;
+    /*There is another mask too. Draw line by line. */
+    if(mask_any) {
         for(h = draw_area.y1; h <= draw_area.y2; h++) {
-            int32_t y = h + draw_buf->area.y1;
+            blend_area.y1 = h;
+            blend_area.y2 = h;
 
-            opa2 = opa;
+            /* Initialize the mask to opa instead of 0xFF and blend with LV_OPA_COVER.
+             * It saves calculating the final opa in _lv_blend_fill*/
+            lv_memset(mask_buf, opa, draw_area_w);
+            mask_res = lv_draw_mask_apply(mask_buf, draw_area.x1, h, draw_area_w);
+            if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
 
-            /*In not corner areas apply the mask only if required*/
-            if(y > coords_bg.y1 + rout + 1 &&
-               y < coords_bg.y2 - rout - 1) {
-                mask_res = LV_DRAW_MASK_RES_FULL_COVER;
-                if(simple_mode == false) {
-                    lv_memset(mask_buf, opa, draw_area_w);
-                    mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h, draw_area_w);
-                }
+            if(grad_dir == LV_GRAD_DIR_NONE) {
+                _lv_blend_fill(clip_area, &blend_area, dsc->bg_color, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
             }
-            /*In corner areas apply the mask anyway*/
-            else {
-                lv_memset(mask_buf, opa, draw_area_w);
-                mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h, draw_area_w);
+            else if(grad_dir == LV_GRAD_DIR_HOR) {
+                _lv_blend_map(clip_area, &blend_area, grad_map_ofs, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
             }
-
-            /*If mask will taken into account its base opacity was already set by memset above*/
-            if(mask_res == LV_DRAW_MASK_RES_CHANGED) {
-                opa2 = LV_OPA_COVER;
+            else if(grad_dir == LV_GRAD_DIR_VER) {
+                lv_color_t c = grad_get(dsc, coords_h, h - coords_bg.y1);
+                _lv_blend_fill(clip_area, &blend_area, c, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
             }
+        }
+        goto bg_clean_up;
+    }
 
-            /*Get the current line color*/
-            if(grad_dir == LV_GRAD_DIR_VER) {
-                grad_color = grad_get(dsc, lv_area_get_height(&coords_bg), y - coords_bg.y1);
+
+    /* Draw the top of the rectangle line by line and mirror it to the bottom.
+     * If there is no radius this cycle won't run because `h` is always `>= h_end`*/
+    blend_area.x1 = draw_area.x1;
+    blend_area.x2 = draw_area.x2;
+    for(h = 0; h < rout; h++) {
+        lv_coord_t top_y = coords_bg.y1 + h;
+        lv_coord_t bottom_y = coords_bg.y2 - h;
+        if(top_y < draw_area.y1 && bottom_y > draw_area.y2) continue;   /*This line is clipped now*/
+
+        /* Initialize the mask to opa instead of 0xFF and blend with LV_OPA_COVER.
+         * It saves calculating the final opa in _lv_blend_fill*/
+        lv_memset(mask_buf, opa, draw_area_w);
+        mask_res = lv_draw_mask_apply(mask_buf, blend_area.x1, top_y, draw_area_w);
+
+        if(top_y >= draw_area.y1) {
+            blend_area.y1 = top_y;
+            blend_area.y2 = top_y;
+
+            if(grad_dir == LV_GRAD_DIR_NONE) {
+                _lv_blend_fill(clip_area, &blend_area, dsc->bg_color, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
             }
-
-            /*If there is not other mask and drawing the corner area split the drawing to corner and middle areas
-             *because it the middle mask shouldn't be taken into account (therefore its faster)*/
-            if(simple_mode && split &&
-               (y < coords_bg.y1 + rout + 1 ||
-                y > coords_bg.y2 - rout - 1)) {
-
-                /*Left part*/
-                lv_area_t fill_area2;
-                fill_area2.x1 = coords_bg.x1;
-                fill_area2.x2 = coords_bg.x1 + rout - 1;
-                fill_area2.y1 = fill_area.y1;
-                fill_area2.y2 = fill_area.y2;
-
-                _lv_blend_fill(clip, &fill_area2,
-                               grad_color, mask_buf, mask_res, opa2, dsc->blend_mode);
-
-                /*Center part*/
-                if(grad_dir == LV_GRAD_DIR_VER) {
-                    fill_area2.x1 = coords_bg.x1 + rout;
-                    fill_area2.x2 = coords_bg.x2 - rout;
-                    _lv_blend_fill(clip, &fill_area2,
-                                   grad_color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, dsc->blend_mode);
-                }
-
-                /*Right part*/
-                fill_area2.x1 = coords_bg.x2 - rout + 1;
-                fill_area2.x2 = coords_bg.x2;
-
-                int32_t mask_ofs = (coords_bg.x2 - rout + 1) - (draw_buf->area.x1 + draw_area.x1);
-                if(mask_ofs < 0) mask_ofs = 0;
-                _lv_blend_fill(clip, &fill_area2,
-                               grad_color, mask_buf + mask_ofs, mask_res, opa2, dsc->blend_mode);
-
+            else if(grad_dir == LV_GRAD_DIR_HOR) {
+                _lv_blend_map(clip_area, &blend_area, grad_map_ofs, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
             }
-            else {
-                if(grad_dir == LV_GRAD_DIR_HOR) {
-                    _lv_blend_map(clip, &fill_area, grad_map, mask_buf, mask_res, opa2, dsc->blend_mode);
-                }
-                else if(grad_dir == LV_GRAD_DIR_VER) {
-                    _lv_blend_fill(clip, &fill_area,
-                                   grad_color, mask_buf, mask_res, opa2, dsc->blend_mode);
-                }
-                else if(other_mask_cnt != 0 || !split) {
-                    _lv_blend_fill(clip, &fill_area,
-                                   grad_color, mask_buf, mask_res, opa2, dsc->blend_mode);
-                }
+            else if(grad_dir == LV_GRAD_DIR_VER) {
+                lv_color_t c = grad_get(dsc, coords_h, top_y - coords_bg.y1);
+                _lv_blend_fill(clip_area, &blend_area, c, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
             }
-            fill_area.y1++;
-            fill_area.y2++;
         }
 
-        if(grad_dir == LV_GRAD_DIR_NONE && other_mask_cnt == 0 && split) {
-            /*Central part*/
-            fill_area.x1 = coords_bg.x1 + rout;
-            fill_area.x2 = coords_bg.x2 - rout;
-            fill_area.y1 = coords_bg.y1;
-            fill_area.y2 = coords_bg.y1 + rout;
-
-            _lv_blend_fill(clip, &fill_area,
-                           dsc->bg_color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, dsc->blend_mode);
-
-            fill_area.y1 = coords_bg.y2 - rout;
-            if(fill_area.y1 <= fill_area.y2) fill_area.y1 = fill_area.y2 + 1;    /*Avoid overdrawing the last line*/
-            fill_area.y2 = coords_bg.y2;
-
-            _lv_blend_fill(clip, &fill_area,
-                           dsc->bg_color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, dsc->blend_mode);
-
-            fill_area.x1 = coords_bg.x1;
-            fill_area.x2 = coords_bg.x2;
-            fill_area.y1 = coords_bg.y1 + rout + 1;
-            fill_area.y2 = coords_bg.y2 - rout - 1;
-
-            _lv_blend_fill(clip, &fill_area,
-                           dsc->bg_color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, dsc->blend_mode);
+        if(bottom_y <= draw_area.y2) {
+            blend_area.y1 = bottom_y;
+            blend_area.y2 = bottom_y;
 
+            if(grad_dir == LV_GRAD_DIR_NONE) {
+                _lv_blend_fill(clip_area, &blend_area, dsc->bg_color, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
+            }
+            else if(grad_dir == LV_GRAD_DIR_HOR) {
+                _lv_blend_map(clip_area, &blend_area, grad_map_ofs, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
+            }
+            else if(grad_dir == LV_GRAD_DIR_VER) {
+                lv_color_t c = grad_get(dsc, coords_h, bottom_y - coords_bg.y1);
+                _lv_blend_fill(clip_area, &blend_area, c, mask_buf, mask_res, LV_OPA_COVER, dsc->blend_mode);
+            }
         }
+    }
 
-        if(grad_map) lv_mem_buf_release(grad_map);
-        if(mask_buf) lv_mem_buf_release(mask_buf);
+    /* Draw the center of the rectangle.*/
+
+    /*If no other masks and no gradient, the center is a simple rectangle*/
+    if(!mask_any && grad_dir == LV_GRAD_DIR_NONE) {
+        blend_area.y1 = coords_bg.y1 + rout;
+        blend_area.y2 = coords_bg.y2 - rout;
+        _lv_blend_fill(clip_area, &blend_area, dsc->bg_color, mask_buf, LV_DRAW_MASK_RES_FULL_COVER, opa, dsc->blend_mode);
+    }
+    /*With gradient and/or mask draw line by line*/
+    else {
+        mask_res = LV_DRAW_MASK_RES_FULL_COVER;
+        int32_t h_end = coords_bg.y2 - rout;
+        for(h = coords_bg.y1 + rout; h <= h_end; h++) {
+            /*If there is no other mask do not apply mask as in the center there is no radius to mask*/
+            if(mask_any) {
+                lv_memset_ff(mask_buf, draw_area_w);
+                mask_res = lv_draw_mask_apply(mask_buf, draw_area.x1, h, draw_area_w);
+            }
+
+            blend_area.y1 = h;
+            blend_area.y2 = h;
+            if(grad_dir == LV_GRAD_DIR_NONE) {
+                _lv_blend_fill(clip_area, &blend_area, dsc->bg_color, mask_buf, mask_res, opa, dsc->blend_mode);
+            }
+            else if(grad_dir == LV_GRAD_DIR_HOR) {
+                _lv_blend_map(clip_area, &blend_area, grad_map_ofs, mask_buf, mask_res, opa, dsc->blend_mode);
+            }
+            else if(grad_dir == LV_GRAD_DIR_VER) {
+                lv_color_t c = grad_get(dsc, coords_h, h - coords_bg.y1);
+                _lv_blend_fill(clip_area, &blend_area, c, mask_buf, mask_res, opa, dsc->blend_mode);
+            }
+        }
+    }
+
+
+bg_clean_up:
+    if(grad_map) lv_mem_buf_release(grad_map);
+    if(mask_buf) lv_mem_buf_release(mask_buf);
+    if(mask_rout_id != LV_MASK_ID_INV) {
         lv_draw_mask_remove_id(mask_rout_id);
+        lv_draw_mask_free_param(&mask_rout_param);
     }
 
 #endif
 }
 
 LV_ATTRIBUTE_FAST_MEM static void draw_bg_img(const lv_area_t * coords, const lv_area_t * clip,
-                                          const lv_draw_rect_dsc_t * dsc)
+                                              const lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->bg_img_src == NULL) return;
     if(dsc->bg_img_opa <= LV_OPA_MIN) return;
@@ -361,7 +340,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg_img(const lv_area_t * coords, const lv
         lv_img_header_t header;
         lv_res_t res = lv_img_decoder_get_info(dsc->bg_img_src, &header);
         if(res != LV_RES_OK) {
-            LV_LOG_WARN("Coudn't read the background image");
+            LV_LOG_WARN("Couldn't read the background image");
             return;
         }
 
@@ -381,7 +360,8 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg_img(const lv_area_t * coords, const lv
             area.y2 = area.y1 + header.h - 1;
 
             lv_draw_img(&area, clip, dsc->bg_img_src, &img_dsc);
-        } else {
+        }
+        else {
             lv_area_t area;
             area.y1 = coords->y1;
             area.y2 = area.y1 + header.h - 1;
@@ -408,8 +388,6 @@ LV_ATTRIBUTE_FAST_MEM static void draw_border(const lv_area_t * coords, const lv
 
     int32_t coords_w = lv_area_get_width(coords);
     int32_t coords_h = lv_area_get_height(coords);
-
-    /*Get the real radius*/
     int32_t rout = dsc->radius;
     int32_t short_side = LV_MIN(coords_w, coords_h);
     if(rout > short_side >> 1) rout = short_side >> 1;
@@ -422,102 +400,14 @@ LV_ATTRIBUTE_FAST_MEM static void draw_border(const lv_area_t * coords, const lv
     area_inner.y1 += ((dsc->border_side & LV_BORDER_SIDE_TOP) ? dsc->border_width : - (dsc->border_width + rout));
     area_inner.y2 -= ((dsc->border_side & LV_BORDER_SIDE_BOTTOM) ? dsc->border_width : - (dsc->border_width + rout));
 
-#if LV_DRAW_COMPLEX
-    if(dsc->border_side == LV_BORDER_SIDE_FULL) {
-        draw_full_border(&area_inner, coords, clip, dsc->radius, false, dsc->border_color, dsc->border_opa,
-                         dsc->blend_mode);
-    }
-    else {
-        lv_opa_t opa = dsc->border_opa;
-        if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+    lv_coord_t rin = rout - dsc->border_width;
+    if(rin < 0) rin = 0;
 
-        lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-        lv_disp_draw_buf_t * draw_buf = lv_disp_get_draw_buf(disp);
+    draw_border_generic(clip, coords, &area_inner, rout, rin, dsc->border_color, dsc->border_opa, dsc->blend_mode);
 
-        /*Get clipped fill area which is the real draw area.
-         *It is always the same or inside `fill_area`*/
-        lv_area_t draw_area;
-        bool is_common;
-        is_common = _lv_area_intersect(&draw_area, coords, clip);
-        if(is_common == false) return;
-
-        const lv_area_t * disp_area = &draw_buf->area;
-
-        /*Now `draw_area` has absolute coordinates.
-         *Make it relative to `disp_area` to simplify draw to `disp_buf`*/
-        draw_area.x1 -= disp_area->x1;
-        draw_area.y1 -= disp_area->y1;
-        draw_area.x2 -= disp_area->x1;
-        draw_area.y2 -= disp_area->y1;
-
-        int32_t draw_area_w = lv_area_get_width(&draw_area);
-
-        /*Create a mask if there is a radius*/
-        lv_opa_t * mask_buf = lv_mem_buf_get(draw_area_w);
-
-        /*Create mask for the outer area*/
-        int16_t mask_rout_id = LV_MASK_ID_INV;
-        lv_draw_mask_radius_param_t mask_rout_param;
-        if(rout > 0) {
-            lv_draw_mask_radius_init(&mask_rout_param, coords, rout, false);
-            mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
-        }
-
-        /*Create mask for the inner mask*/
-        int32_t rin = rout - dsc->border_width;
-        if(rin < 0) rin = 0;
-        lv_draw_mask_radius_param_t mask_rin_param;
-        lv_draw_mask_radius_init(&mask_rin_param, &area_inner, rout - dsc->border_width, true);
-        int16_t mask_rin_id = lv_draw_mask_add(&mask_rin_param, NULL);
-
-        int32_t corner_size = LV_MAX(rout, dsc->border_width - 1);
-
-        int32_t h;
-        lv_draw_mask_res_t mask_res;
-        lv_area_t fill_area;
-
-        lv_color_t color = dsc->border_color;
-        lv_blend_mode_t blend_mode = dsc->blend_mode;
-
-        fill_area.x1 = coords->x1;
-        fill_area.x2 = coords->x2;
-        fill_area.y1 = disp_area->y1 + draw_area.y1;
-        fill_area.y2 = fill_area.y1;
-
-        if(dsc->border_side == LV_BORDER_SIDE_LEFT) fill_area.x2 = coords->x1 + corner_size;
-
-        volatile bool top_only = false;
-        volatile bool bottom_only = false;
-        if(dsc->border_side == LV_BORDER_SIDE_TOP) top_only = true;
-        if(dsc->border_side == LV_BORDER_SIDE_BOTTOM) bottom_only = true;
-        if(dsc->border_side == (LV_BORDER_SIDE_TOP | LV_BORDER_SIDE_BOTTOM)) {
-            top_only = true;
-            bottom_only = true;
-        }
-
-        volatile bool normal = !top_only && !bottom_only ? true : false;
-
-        for(h = draw_area.y1; h <= draw_area.y2; h++) {
-            if(normal ||
-               (top_only && fill_area.y1 <= coords->y1 + corner_size) ||
-               (bottom_only && fill_area.y1 >= coords->y2 - corner_size)) {
-                lv_memset_ff(mask_buf, draw_area_w);
-                mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h, draw_area_w);
-                _lv_blend_fill(clip, &fill_area, color, mask_buf, mask_res, opa, blend_mode);
-            }
-            fill_area.y1++;
-            fill_area.y2++;
-
-        }
-        lv_draw_mask_remove_id(mask_rin_id);
-        lv_draw_mask_remove_id(mask_rout_id);
-        lv_mem_buf_release(mask_buf);
-    }
-#else /*LV_DRAW_COMPLEX*/
-    draw_simple_border(clip, &area_inner, coords, dsc->border_color, dsc->border_opa, dsc->border_side);
-#endif
 }
 
+
 #if LV_DRAW_COMPLEX
 LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(const lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i)
 {
@@ -541,66 +431,50 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(const lv_area_t * coords, const lv
     if(dsc->shadow_width == 0) return;
     if(dsc->shadow_opa <= LV_OPA_MIN) return;
 
-    if(dsc->shadow_width == 1 && dsc->shadow_ofs_x == 0 &&
-       dsc->shadow_ofs_y == 0 && dsc->shadow_spread <= 0) {
+    if(dsc->shadow_width == 1 && dsc->shadow_spread <= 0 &&
+       dsc->shadow_ofs_x == 0 && dsc->shadow_ofs_y == 0) {
         return;
     }
 
-    int32_t sw = dsc->shadow_width;
+    /*Calculate the rectangle which is blurred to get the shadow in `shadow_area`*/
+    lv_area_t core_area;
+    core_area.x1 = coords->x1  + dsc->shadow_ofs_x - dsc->shadow_spread;
+    core_area.x2 = coords->x2  + dsc->shadow_ofs_x + dsc->shadow_spread;
+    core_area.y1 = coords->y1  + dsc->shadow_ofs_y - dsc->shadow_spread;
+    core_area.y2 = coords->y2  + dsc->shadow_ofs_y + dsc->shadow_spread;
 
-    lv_area_t sh_rect_area;
-    sh_rect_area.x1 = coords->x1  + dsc->shadow_ofs_x - dsc->shadow_spread;
-    sh_rect_area.x2 = coords->x2  + dsc->shadow_ofs_x + dsc->shadow_spread;
-    sh_rect_area.y1 = coords->y1  + dsc->shadow_ofs_y - dsc->shadow_spread;
-    sh_rect_area.y2 = coords->y2  + dsc->shadow_ofs_y + dsc->shadow_spread;
-
-    lv_area_t sh_area;
-    sh_area.x1 = sh_rect_area.x1 - sw / 2 - 1;
-    sh_area.x2 = sh_rect_area.x2 + sw / 2 + 1;
-    sh_area.y1 = sh_rect_area.y1 - sw / 2 - 1;
-    sh_area.y2 = sh_rect_area.y2 + sw / 2 + 1;
+    /*Calculate the bounding box of the shadow*/
+    lv_area_t shadow_area;
+    shadow_area.x1 = core_area.x1 - dsc->shadow_width / 2 - 1;
+    shadow_area.x2 = core_area.x2 + dsc->shadow_width / 2 + 1;
+    shadow_area.y1 = core_area.y1 - dsc->shadow_width / 2 - 1;
+    shadow_area.y2 = core_area.y2 + dsc->shadow_width / 2 + 1;
 
     lv_opa_t opa = dsc->shadow_opa;
-
     if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
 
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    lv_disp_draw_buf_t * draw_buf = lv_disp_get_draw_buf(disp);
-
-    /*Get clipped fill area which is the real draw area.
-     *It is always the same or inside `fill_area`*/
+    /*Get clipped draw area which is the real draw area.
+     *It is always the same or inside `shadow_area`*/
     lv_area_t draw_area;
-    bool is_common;
-    is_common = _lv_area_intersect(&draw_area, &sh_area, clip);
-    if(is_common == false) return;
-
-    const lv_area_t * disp_area = &draw_buf->area;
-
-    /*Now `draw_area` has absolute coordinates.
-     *Make it relative to `disp_area` to simplify draw to `disp_buf`*/
-    draw_area.x1 -= disp_area->x1;
-    draw_area.y1 -= disp_area->y1;
-    draw_area.x2 -= disp_area->x1;
-    draw_area.y2 -= disp_area->y1;
+    if(!_lv_area_intersect(&draw_area, &shadow_area, clip)) return;
 
     /*Consider 1 px smaller bg to be sure the edge will be covered by the shadow*/
-    lv_area_t bg_coords;
-    lv_area_copy(&bg_coords, coords);
-    bg_coords.x1 += 1;
-    bg_coords.y1 += 1;
-    bg_coords.x2 -= 1;
-    bg_coords.y2 -= 1;
+    lv_area_t bg_area;
+    lv_area_copy(&bg_area, coords);
+    lv_area_increase(&bg_area, -1, -1);
 
-    /*Get the real radius*/
+    /*Get the clamped radius*/
     int32_t r_bg = dsc->radius;
-    int32_t short_side = LV_MIN(lv_area_get_width(&bg_coords), lv_area_get_height(&bg_coords));
+    lv_coord_t short_side = LV_MIN(lv_area_get_width(&bg_area), lv_area_get_height(&bg_area));
     if(r_bg > short_side >> 1) r_bg = short_side >> 1;
 
+    /*Get the clamped radius*/
     int32_t r_sh = dsc->radius;
-    short_side = LV_MIN(lv_area_get_width(&sh_rect_area), lv_area_get_height(&sh_rect_area));
+    short_side = LV_MIN(lv_area_get_width(&core_area), lv_area_get_height(&core_area));
     if(r_sh > short_side >> 1) r_sh = short_side >> 1;
 
-    int32_t corner_size = sw  + r_sh;
+    /*Get how many pixels are affected by the blur on the corners*/
+    int32_t corner_size = dsc->shadow_width  + r_sh;
 
     lv_opa_t * sh_buf;
 
@@ -613,7 +487,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(const lv_area_t * coords, const lv
     else {
         /*A larger buffer is required for calculation*/
         sh_buf = lv_mem_buf_get(corner_size * corner_size * sizeof(uint16_t));
-        shadow_draw_corner_buf(&sh_rect_area, (uint16_t *)sh_buf, dsc->shadow_width, r_sh);
+        shadow_draw_corner_buf(&core_area, (uint16_t *)sh_buf, dsc->shadow_width, r_sh);
 
         /*Cache the corner if it fits into the cache size*/
         if((uint32_t)corner_size * corner_size < sizeof(sh_cache)) {
@@ -624,398 +498,381 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(const lv_area_t * coords, const lv
     }
 #else
     sh_buf = lv_mem_buf_get(corner_size * corner_size * sizeof(uint16_t));
-    shadow_draw_corner_buf(&sh_rect_area, (uint16_t *)sh_buf, dsc->shadow_width, r_sh);
+    shadow_draw_corner_buf(&core_area, (uint16_t *)sh_buf, dsc->shadow_width, r_sh);
 #endif
 
-    lv_coord_t h_half = sh_area.y1 + lv_area_get_height(&sh_area) / 2;
-    lv_coord_t w_half = sh_area.x1 + lv_area_get_width(&sh_area) / 2;
+    /*Skip a lot of masking if the background will cover the shadow that would be masked out*/
+    bool mask_any = lv_draw_mask_is_any(&shadow_area);
+    bool simple = true;
+    if(mask_any || dsc->bg_opa < LV_OPA_COVER) simple = false;
 
-    bool simple_mode = true;
-    if(lv_draw_mask_get_cnt() > 0) simple_mode = false;
-    else if(dsc->shadow_ofs_x != 0 || dsc->shadow_ofs_y != 0) simple_mode = false;
-    else if(dsc->shadow_spread != 0) simple_mode = false;
-
-    /*Create a mask*/
+    /*Create a radius mask to clip remove shadow on the bg area*/
     lv_draw_mask_res_t mask_res;
-    lv_opa_t * mask_buf = lv_mem_buf_get(lv_area_get_width(&sh_area));
 
     lv_draw_mask_radius_param_t mask_rout_param;
-    lv_draw_mask_radius_init(&mask_rout_param, &bg_coords, r_bg, true);
-
-    int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
-
-    lv_area_t a;
-
-    /*Draw the top right corner*/
-    int32_t y;
+    int16_t mask_rout_id = LV_MASK_ID_INV;
+    if(!simple) {
+        lv_draw_mask_radius_init(&mask_rout_param, &bg_area, r_bg, true);
+        mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
+    }
+    lv_opa_t * mask_buf = lv_mem_buf_get(lv_area_get_width(&shadow_area));
+    lv_area_t blend_area;
+    lv_area_t clip_area_sub;
+    lv_opa_t ** mask_act;
     lv_opa_t * sh_buf_tmp;
-    a.x2 = sh_area.x2;
-    a.x1 = a.x2 - corner_size + 1;
-    a.y1 = sh_area.y1;
-    a.y2 = a.y1 + corner_size - 1;
+    lv_coord_t y;
+    bool simple_sub;
 
-    lv_area_t ca;
-    bool has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Avoid overlap in the middle with large radius*/
-        if(ca.y2 > h_half) ca.y2 = h_half;
-        if(ca.x1 <= w_half) ca.x1 = w_half + 1;
+    lv_coord_t w_half = shadow_area.x1 + lv_area_get_width(&shadow_area) / 2;
+    lv_coord_t h_half = shadow_area.y1 + lv_area_get_height(&shadow_area) / 2;
 
-        lv_coord_t h = lv_area_get_height(&ca);
-        lv_coord_t w = lv_area_get_width(&ca);
+    /*Draw the corners if they are on the current clip area and not fully covered by the bg*/
+
+    /*Top right corner*/
+    blend_area.x2 = shadow_area.x2;
+    blend_area.x1 = shadow_area.x2 - corner_size + 1;
+    blend_area.y1 = shadow_area.y1;
+    blend_area.y2 = shadow_area.y1 + corner_size - 1;
+    /*Do not overdraw the top other corners*/
+    blend_area.x1 = LV_MAX(blend_area.x1, w_half);
+    blend_area.y2 = LV_MIN(blend_area.y2, h_half);
+
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        sh_buf_tmp = sh_buf;
+        sh_buf_tmp += (clip_area_sub.y1 - shadow_area.y1) * corner_size;
+        sh_buf_tmp += clip_area_sub.x1 - (shadow_area.x2 - corner_size + 1);
+
+        /*Do not mask if out of the bg*/
+        if(simple && _lv_area_is_out(&clip_area_sub, &bg_area, r_bg)) simple_sub = true;
+        else simple_sub = simple;
+        mask_act = simple_sub ? &sh_buf_tmp : &mask_buf;
         if(w > 0) {
-            sh_buf_tmp = sh_buf + (ca.x1 - a.x1);
-            sh_buf_tmp += corner_size * (ca.y1 - a.y1);
+            mask_res = LV_DRAW_MASK_RES_CHANGED;    /*In simple mode it won't be overwritten*/
+            for(y = clip_area_sub.y1; y <= clip_area_sub.y2; y++) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
 
-            lv_area_t fa;
-            lv_area_copy(&fa, &ca);
-            fa.y2 = fa.y1;
-
-            for(y = 0; y < h; y++) {
-                lv_memcpy(mask_buf, sh_buf_tmp, w);
-                mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
-                if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
-
-                _lv_blend_fill(clip, &fa, dsc->shadow_color, mask_buf,
-                               mask_res, opa, dsc->blend_mode);
-                fa.y1++;
-                fa.y2++;
-                sh_buf_tmp += corner_size;
-            }
-        }
-    }
-
-    /*Draw the bottom right corner*/
-    a.x2 = sh_area.x2;
-    a.x1 = a.x2 - corner_size + 1;
-    a.y1 = sh_area.y2 - corner_size + 1;
-    a.y2 = sh_area.y2;
-
-    has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Avoid overlap in the middle with large radius*/
-        if(ca.y1 <= h_half) ca.y1 = h_half;
-        if(ca.x1 <= w_half) ca.x1 = w_half;
-
-        lv_coord_t h = lv_area_get_height(&ca);
-        lv_coord_t w = lv_area_get_width(&ca);
-
-        if(w > 0) {
-            sh_buf_tmp = sh_buf + (ca.x1 - a.x1);
-            sh_buf_tmp += corner_size * (a.y2 - ca.y2);
-
-            lv_area_t fa;
-            lv_area_copy(&fa, &ca);
-            fa.y1 = fa.y2;    /*Fill from bottom to top*/
-
-            for(y = 0; y < h; y++) {
-                lv_memcpy(mask_buf, sh_buf_tmp, w);
-                mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
-                if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
-
-                _lv_blend_fill(clip, &fa, dsc->shadow_color, mask_buf,
-                               mask_res, opa, dsc->blend_mode);
-                fa.y1--;
-                fa.y2--;
-                sh_buf_tmp += corner_size;
-            }
-        }
-    }
-
-    /*Fill the right side*/
-    a.x2 = sh_area.x2;
-    a.x1 = a.x2 - corner_size + 1;
-    a.y1 = sh_area.y1 + corner_size;
-    a.y2 = sh_area.y2 - corner_size;
-
-    has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Avoid overlap in the middle with large radius*/
-        if(ca.x1 <= w_half) ca.x1 = w_half + 1;
-
-        if(simple_mode) ca.x1 = LV_MAX(ca.x1, coords->x2);
-
-        /*Draw horizontal lines*/
-        lv_coord_t w = lv_area_get_width(&ca);
-        if(w > 0) {
-            lv_coord_t h = lv_area_get_height(&ca);
-
-            /*The last line of the shadow is repeated on the side*/
-            sh_buf_tmp = sh_buf + corner_size * (corner_size - 1);
-            sh_buf_tmp += ca.x1 - a.x1;
-
-            lv_area_t fa;
-            lv_area_copy(&fa, &ca);
-            fa.y2 = fa.y1;
-            mask_res = LV_DRAW_MASK_RES_FULL_COVER;
-            for(y = 0; y < h; y++) {
-                lv_memcpy(mask_buf, sh_buf_tmp, w);
-
-                if(simple_mode) {
-                    mask_res = LV_DRAW_MASK_RES_CHANGED;
-                }
-                else {
-                    mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
+                if(!simple_sub) {
+                    lv_memcpy(mask_buf, sh_buf_tmp, corner_size);
+                    mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
                     if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
                 }
-
-                _lv_blend_fill(clip, &fa,
-                               dsc->shadow_color, mask_buf, mask_res, dsc->shadow_opa, dsc->blend_mode);
-                fa.y1++;
-                fa.y2++;
+                _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, *mask_act, mask_res, dsc->shadow_opa, dsc->blend_mode);
+                sh_buf_tmp += corner_size;
             }
         }
     }
 
-    /*Invert the shadow corner buffer and draw the corners on the left*/
+    /*Bottom right corner.
+     *Almost the same as top right just read the lines of `sh_buf` from then end*/
+    blend_area.x2 = shadow_area.x2;
+    blend_area.x1 = shadow_area.x2 - corner_size + 1;
+    blend_area.y1 = shadow_area.y2 - corner_size + 1;
+    blend_area.y2 = shadow_area.y2;
+    /*Do not overdraw the other corners*/
+    blend_area.x1 = LV_MAX(blend_area.x1, w_half);
+    blend_area.y1 = LV_MAX(blend_area.y1, h_half + 1);
+
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        sh_buf_tmp = sh_buf;
+        sh_buf_tmp += (blend_area.y2 - clip_area_sub.y2) * corner_size;
+        sh_buf_tmp += clip_area_sub.x1 - (shadow_area.x2 - corner_size + 1);
+        /*Do not mask if out of the bg*/
+        if(simple && _lv_area_is_out(&clip_area_sub, &bg_area, r_bg)) simple_sub = true;
+        else simple_sub = simple;
+        mask_act = simple_sub ? &sh_buf_tmp : &mask_buf;
+
+        if(w > 0) {
+            mask_res = LV_DRAW_MASK_RES_CHANGED;    /*In simple mode it won't be overwritten*/
+            for(y = clip_area_sub.y2; y >= clip_area_sub.y1; y--) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
+
+                if(!simple_sub) {
+                    lv_memcpy(mask_buf, sh_buf_tmp, corner_size);
+                    mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
+                    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
+                }
+                _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, *mask_act, mask_res, dsc->shadow_opa, dsc->blend_mode);
+                sh_buf_tmp += corner_size;
+            }
+        }
+    }
+
+    /*Top side*/
+    blend_area.x1 = shadow_area.x1 + corner_size;
+    blend_area.x2 = shadow_area.x2 - corner_size;
+    blend_area.y1 = shadow_area.y1;
+    blend_area.y2 = shadow_area.y1 + corner_size - 1;
+    blend_area.y2 = LV_MIN(blend_area.y2, h_half);
+
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        sh_buf_tmp = sh_buf;
+        sh_buf_tmp += (clip_area_sub.y1 - blend_area.y1) * corner_size;
+
+        /*Do not mask if out of the bg*/
+        if(simple && _lv_area_is_out(&clip_area_sub, &bg_area, r_bg)) simple_sub = true;
+        else simple_sub = simple;
+
+        if(w > 0) {
+            mask_res = LV_DRAW_MASK_RES_CHANGED;    /*In simple mode it won't be overwritten*/
+            for(y = clip_area_sub.y1; y <= clip_area_sub.y2; y++) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
+
+                if(!simple_sub) {
+                    lv_memset(mask_buf, sh_buf_tmp[0], w);
+                    mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
+                    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
+                    _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, mask_buf, mask_res, dsc->shadow_opa, dsc->blend_mode);
+                }
+                else {
+                    lv_opa_t line_opa = opa == LV_OPA_COVER ? sh_buf_tmp[0] : (sh_buf_tmp[0] * dsc->shadow_opa) >> 8;
+                    _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, NULL, LV_DRAW_MASK_RES_FULL_COVER, line_opa,
+                                   dsc->blend_mode);
+                }
+                sh_buf_tmp += corner_size;
+            }
+        }
+    }
+
+    /*Bottom side*/
+    blend_area.x1 = shadow_area.x1 + corner_size;
+    blend_area.x2 = shadow_area.x2 - corner_size;
+    blend_area.y1 = shadow_area.y2 - corner_size + 1;
+    blend_area.y2 = shadow_area.y2;
+    blend_area.y1 = LV_MAX(blend_area.y1, h_half + 1);
+
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        sh_buf_tmp = sh_buf;
+        sh_buf_tmp += (blend_area.y2 - clip_area_sub.y2) * corner_size;
+        if(w > 0) {
+            mask_res = LV_DRAW_MASK_RES_CHANGED;    /*In simple mode it won't be overwritten*/
+            for(y = clip_area_sub.y2; y >= clip_area_sub.y1; y--) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
+
+                /*Do not mask if out of the bg*/
+                if(simple && _lv_area_is_out(&clip_area_sub, &bg_area, r_bg)) simple_sub = true;
+                else simple_sub = simple;
+
+                if(!simple_sub) {
+                    lv_memset(mask_buf, sh_buf_tmp[0], w);
+                    mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
+                    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
+                    _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, mask_buf, mask_res, dsc->shadow_opa, dsc->blend_mode);
+                }
+                else {
+                    lv_opa_t line_opa = opa == LV_OPA_COVER ? sh_buf_tmp[0] : (sh_buf_tmp[0] * dsc->shadow_opa) >> 8;
+                    _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, NULL, LV_DRAW_MASK_RES_FULL_COVER, line_opa,
+                                   dsc->blend_mode);
+
+                }
+                sh_buf_tmp += corner_size;
+            }
+        }
+    }
+
+    /*Right side*/
+    blend_area.x1 = shadow_area.x2 - corner_size + 1;
+    blend_area.x2 = shadow_area.x2;
+    blend_area.y1 = shadow_area.y1 + corner_size;
+    blend_area.y2 = shadow_area.y2 - corner_size;
+    /*Do not overdraw the other corners*/
+    blend_area.y1 = LV_MIN(blend_area.y1, h_half + 1);
+    blend_area.y2 = LV_MAX(blend_area.y2, h_half);
+    blend_area.x1 = LV_MAX(blend_area.x1, w_half);
+
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        sh_buf_tmp = sh_buf;
+        sh_buf_tmp += (corner_size - 1) * corner_size;
+        sh_buf_tmp += clip_area_sub.x1 - (shadow_area.x2 - corner_size + 1);
+
+        /*Do not mask if out of the bg*/
+        if(simple && _lv_area_is_out(&clip_area_sub, &bg_area, r_bg)) simple_sub = true;
+        else simple_sub = simple;
+        mask_act = simple_sub ? &sh_buf_tmp : &mask_buf;
+
+        if(w > 0) {
+            mask_res = LV_DRAW_MASK_RES_CHANGED;    /*In simple mode it won't be overwritten*/
+            for(y = clip_area_sub.y1; y <= clip_area_sub.y2; y++) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
+
+                if(!simple_sub) {
+                    lv_memcpy(mask_buf, sh_buf_tmp, w);
+                    mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
+                    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
+                }
+                _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, *mask_act, mask_res, dsc->shadow_opa, dsc->blend_mode);
+            }
+        }
+    }
+
+    /*Mirror the shadow corner buffer horizontally*/
     sh_buf_tmp = sh_buf ;
     for(y = 0; y < corner_size; y++) {
         int32_t x;
+        lv_opa_t * start = sh_buf_tmp;
+        lv_opa_t * end = sh_buf_tmp + corner_size - 1;
         for(x = 0; x < corner_size / 2; x++) {
-            lv_opa_t tmp = sh_buf_tmp[x];
-            sh_buf_tmp[x] = sh_buf_tmp[corner_size - x - 1];
-            sh_buf_tmp[corner_size - x - 1] = tmp;
+            lv_opa_t tmp = *start;
+            *start = *end;
+            *end = tmp;
+
+            start++;
+            end--;
         }
         sh_buf_tmp += corner_size;
     }
 
-    /*Draw the top left corner*/
-    a.x1 = sh_area.x1;
-    a.x2 = a.x1 + corner_size - 1;
-    a.y1 = sh_area.y1;
-    a.y2 = a.y1 + corner_size - 1;
+    /*Left side*/
+    blend_area.x1 = shadow_area.x1;
+    blend_area.x2 = shadow_area.x1 + corner_size - 1;
+    blend_area.y1 = shadow_area.y1 + corner_size;
+    blend_area.y2 = shadow_area.y2 - corner_size;
+    /*Do not overdraw the other corners*/
+    blend_area.y1 = LV_MIN(blend_area.y1, h_half + 1);
+    blend_area.y2 = LV_MAX(blend_area.y2, h_half);
+    blend_area.x2 = LV_MIN(blend_area.x2, w_half - 1);
 
-    has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Avoid overlap in the middle with large radius*/
-        if(ca.y2 > h_half) ca.y2 = h_half;
-        if(ca.x2 > w_half) ca.x2 = w_half;
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        sh_buf_tmp = sh_buf;
+        sh_buf_tmp += (corner_size - 1) * corner_size;
+        sh_buf_tmp += clip_area_sub.x1 - blend_area.x1;
 
-        lv_coord_t h = lv_area_get_height(&ca);
-        lv_coord_t w = lv_area_get_width(&ca);
+        /*Do not mask if out of the bg*/
+        if(simple && _lv_area_is_out(&clip_area_sub, &bg_area, r_bg)) simple_sub = true;
+        else simple_sub = simple;
+        mask_act = simple_sub ? &sh_buf_tmp : &mask_buf;
         if(w > 0) {
-            sh_buf_tmp = sh_buf + (ca.x1 - a.x1);
-            sh_buf_tmp += corner_size * (ca.y1 - a.y1);
+            mask_res = LV_DRAW_MASK_RES_CHANGED;    /*In simple mode it won't be overwritten*/
+            for(y = clip_area_sub.y1; y <= clip_area_sub.y2; y++) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
 
-            lv_area_t fa;
-            lv_area_copy(&fa, &ca);
-            fa.y2 = fa.y1;
-
-            for(y = 0; y < h; y++) {
-                lv_memcpy(mask_buf, sh_buf_tmp, w);
-                mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
-                if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
-
-                _lv_blend_fill(clip, &fa, dsc->shadow_color, mask_buf,
-                               mask_res, opa, dsc->blend_mode);
-                fa.y1++;
-                fa.y2++;
-                sh_buf_tmp += corner_size;
-            }
-        }
-    }
-
-    /*Draw the bottom left corner*/
-    a.x1 = sh_area.x1;
-    a.x2 = a.x1 + corner_size - 1;
-    a.y1 = sh_area.y2 - corner_size + 1;
-    a.y2 = sh_area.y2;
-
-    has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Avoid overlap in the middle with large radius*/
-        if(ca.y1 <= h_half) ca.y1 = h_half + 1;
-        if(ca.x2 > w_half) ca.x2 = w_half;
-        lv_coord_t h = lv_area_get_height(&ca);
-        lv_coord_t w = lv_area_get_width(&ca);
-
-        if(w > 0) {
-            sh_buf_tmp = sh_buf + (ca.x1 - a.x1);
-            sh_buf_tmp += corner_size * (a.y2 - ca.y2);
-
-            lv_area_t fa;
-            lv_area_copy(&fa, &ca);
-            fa.y1 = fa.y2;    /*Fill from bottom to top*/
-
-            for(y = 0; y < h; y++) {
-                lv_memcpy(mask_buf, sh_buf_tmp, w);
-                mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
-                if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
-
-                _lv_blend_fill(clip, &fa, dsc->shadow_color, mask_buf,
-                               mask_res, opa, dsc->blend_mode);
-                fa.y1--;
-                fa.y2--;
-                sh_buf_tmp += corner_size;
-            }
-        }
-    }
-
-    /*Fill the left side*/
-    a.x1 = sh_area.x1;
-    a.x2 = a.x1 + corner_size - 1;
-    a.y1 = sh_area.y1 + corner_size;
-    a.y2 = sh_area.y2 - corner_size;
-
-    has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Avoid overlap in the middle with large radius*/
-        if(ca.x2 > w_half) ca.x2 = w_half;
-
-        if(simple_mode) ca.x2 = LV_MIN(coords->x1, ca.x2);
-        /*Draw vertical lines*/
-        lv_coord_t w = lv_area_get_width(&ca);
-        if(w > 0) {
-            lv_coord_t h = lv_area_get_height(&ca);
-            /*The last line of the shadow is repeated on the side*/
-            sh_buf_tmp = sh_buf + corner_size * (corner_size - 1);
-            sh_buf_tmp += ca.x1 - a.x1;
-
-            lv_area_t fa;
-            lv_area_copy(&fa, &ca);
-            fa.y2 = fa.y1;
-            for(y = 0; y < h; y++) {
-                lv_memcpy(mask_buf, sh_buf_tmp, w);
-                if(simple_mode) {
-                    mask_res = LV_DRAW_MASK_RES_CHANGED;
-                }
-                else {
-                    mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
+                if(!simple_sub) {
+                    lv_memcpy(mask_buf, sh_buf_tmp, w);
+                    mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
                     if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
                 }
-
-                _lv_blend_fill(clip, &fa,
-                               dsc->shadow_color, mask_buf, mask_res, dsc->shadow_opa, dsc->blend_mode);
-                fa.y1++;
-                fa.y2++;
+                _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, *mask_act, mask_res, dsc->shadow_opa, dsc->blend_mode);
             }
         }
     }
 
-    /*Fill the top side*/
-    a.x1 = sh_area.x1 + corner_size;
-    a.x2 = sh_area.x2 - corner_size;
-    a.y1 = sh_area.y1;
-    a.y2 = sh_area.y1 + corner_size - 1;
+    /*Top left corner*/
+    blend_area.x1 = shadow_area.x1;
+    blend_area.x2 = shadow_area.x1 + corner_size - 1;
+    blend_area.y1 = shadow_area.y1;
+    blend_area.y2 = shadow_area.y1 + corner_size - 1;
+    /*Do not overdraw the other corners*/
+    blend_area.x2 = LV_MIN(blend_area.x2, w_half - 1);
+    blend_area.y2 = LV_MIN(blend_area.y2, h_half);
 
-    has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Avoid overlap in the middle with large radius*/
-        if(ca.y2 > h_half) ca.y2 = h_half;
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        sh_buf_tmp = sh_buf;
+        sh_buf_tmp += (clip_area_sub.y1 - blend_area.y1) * corner_size;
+        sh_buf_tmp += clip_area_sub.x1 - blend_area.x1;
 
-        if(simple_mode) ca.y2 = LV_MIN(ca.y2, coords->y1);
+        /*Do not mask if out of the bg*/
+        if(simple && _lv_area_is_out(&clip_area_sub, &bg_area, r_bg)) simple_sub = true;
+        else simple_sub = simple;
+        mask_act = simple_sub ? &sh_buf_tmp : &mask_buf;
 
-        /*Draw horizontal lines*/
-        lv_coord_t w = lv_area_get_width(&ca);
-        lv_coord_t h = lv_area_get_height(&ca);
-        sh_buf_tmp = sh_buf + corner_size - 1;
-        sh_buf_tmp += corner_size * (ca.y1 - a.y1);
+        if(w > 0) {
+            mask_res = LV_DRAW_MASK_RES_CHANGED;    /*In simple mode it won't be overwritten*/
+            for(y = clip_area_sub.y1; y <= clip_area_sub.y2; y++) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
 
-        lv_area_t fa;
-        lv_area_copy(&fa, &ca);
-        fa.y2 = fa.y1;
-        mask_res = LV_DRAW_MASK_RES_FULL_COVER;
-        for(y = 0; y < h; y++) {
-            lv_opa_t opa_tmp = sh_buf_tmp[0];
-            if(opa_tmp != LV_OPA_COVER || opa != LV_OPA_COVER) opa_tmp = (opa * opa_tmp) >> 8;
-
-            lv_memset(mask_buf, opa_tmp, w);
-
-            if(simple_mode) {
-                mask_res = LV_DRAW_MASK_RES_CHANGED;
+                if(!simple_sub) {
+                    lv_memcpy(mask_buf, sh_buf_tmp, corner_size);
+                    mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
+                    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
+                }
+                _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, *mask_act, mask_res, dsc->shadow_opa, dsc->blend_mode);
+                sh_buf_tmp += corner_size;
             }
-            else {
-                mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
-                if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
-            }
-
-            _lv_blend_fill(clip, &fa, dsc->shadow_color, mask_buf,
-                           mask_res, LV_OPA_COVER, dsc->blend_mode);
-            fa.y1++;
-            fa.y2++;
-            sh_buf_tmp += corner_size;
         }
     }
 
-    /*Fill the bottom side*/
-    a.x1 = sh_area.x1 + corner_size;
-    a.x2 = sh_area.x2 - corner_size;
-    a.y1 = sh_area.y2 - corner_size + 1;
-    a.y2 = sh_area.y2;
+    /*Bottom left corner.
+     *Almost the same as bottom right just read the lines of `sh_buf` from then end*/
+    blend_area.x1 = shadow_area.x1 ;
+    blend_area.x2 = shadow_area.x1 + corner_size - 1;
+    blend_area.y1 = shadow_area.y2 - corner_size + 1;
+    blend_area.y2 = shadow_area.y2;
+    /*Do not overdraw the other corners*/
+    blend_area.y1 = LV_MAX(blend_area.y1, h_half + 1);
+    blend_area.x2 = LV_MIN(blend_area.x2, w_half - 1);
 
-    has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Avoid overlap in the middle with large radius*/
-        if(ca.y1 <= h_half) ca.y1 = h_half + 1;
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        sh_buf_tmp = sh_buf;
+        sh_buf_tmp += (blend_area.y2 - clip_area_sub.y2) * corner_size;
+        sh_buf_tmp += clip_area_sub.x1 - blend_area.x1;
 
-        if(simple_mode) ca.y1 = LV_MAX(ca.y1, coords->y2);
+        /*Do not mask if out of the bg*/
+        if(simple && _lv_area_is_out(&clip_area_sub, &bg_area, r_bg)) simple_sub = true;
+        else simple_sub = simple;
+        mask_act = simple_sub ? &sh_buf_tmp : &mask_buf;
+        if(w > 0) {
+            mask_res = LV_DRAW_MASK_RES_CHANGED;    /*In simple mode it won't be overwritten*/
+            for(y = clip_area_sub.y2; y >= clip_area_sub.y1; y--) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
 
-        /*Draw horizontal lines*/
-        lv_coord_t w = lv_area_get_width(&ca);
-        lv_coord_t h = lv_area_get_height(&ca);
-        sh_buf_tmp = sh_buf + corner_size - 1;
-        sh_buf_tmp += corner_size * (a.y2 - ca.y2);
-
-        lv_area_t fa;
-        lv_area_copy(&fa, &ca);
-        fa.y1 = fa.y2;
-        for(y = 0; y < h; y++) {
-            lv_opa_t opa_tmp = sh_buf_tmp[0];
-            if(opa_tmp != LV_OPA_COVER || opa != LV_OPA_COVER) opa_tmp = (opa * opa_tmp) >> 8;
-
-            lv_memset(mask_buf, opa_tmp, w);
-            if(simple_mode) {
-                mask_res = LV_DRAW_MASK_RES_CHANGED;
+                if(!simple_sub) {
+                    lv_memcpy(mask_buf, sh_buf_tmp, corner_size);
+                    mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
+                    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
+                }
+                _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, *mask_act, mask_res, dsc->shadow_opa, dsc->blend_mode);
+                sh_buf_tmp += corner_size;
             }
-            else {
-                mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
-                if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
-            }
-
-            _lv_blend_fill(clip, &fa, dsc->shadow_color, mask_buf,
-                           mask_res, LV_OPA_COVER, dsc->blend_mode);
-            fa.y1--;
-            fa.y2--;
-            sh_buf_tmp += corner_size;
         }
     }
 
-    /*Draw the middle area*/
-    a.x1 = sh_area.x1 + corner_size;
-    a.x2 = sh_area.x2 - corner_size;
-    a.y1 = sh_area.y1 + corner_size;
-    a.y2 = sh_area.y2 - corner_size;
+    /*Draw the center rectangle.*/
+    blend_area.x1 = shadow_area.x1 + corner_size ;
+    blend_area.x2 = shadow_area.x2 - corner_size;
+    blend_area.y1 = shadow_area.y1 + corner_size;
+    blend_area.y2 = shadow_area.y2 - corner_size;
 
-    has_com = _lv_area_intersect(&ca, &a, clip);
-    if(has_com && simple_mode == false &&  _lv_area_is_in(&a, &bg_coords, r_bg) == false) {
-        /*Draw horizontal lines*/
-        lv_coord_t w = lv_area_get_width(&ca);
-        lv_coord_t h = lv_area_get_height(&ca);
+    if(_lv_area_intersect(&clip_area_sub, &blend_area, clip) && !_lv_area_is_in(&clip_area_sub, &bg_area, r_bg)) {
+        lv_coord_t w = lv_area_get_width(&clip_area_sub);
+        if(w > 0) {
+            for(y = clip_area_sub.y1; y <= clip_area_sub.y2; y++) {
+                blend_area.y1 = y;
+                blend_area.y2 = y;
 
-        lv_area_t fa;
-        lv_area_copy(&fa, &ca);
-        fa.y2 = fa.y1;
-        for(y = 0; y < h; y++) {
-            lv_memset(mask_buf, dsc->shadow_opa, w);
-            mask_res = lv_draw_mask_apply(mask_buf, fa.x1, fa.y1, w);
-            if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
-
-            _lv_blend_fill(clip, &fa, dsc->shadow_color, mask_buf,
-                           mask_res, LV_OPA_COVER, dsc->blend_mode);
-            fa.y1++;
-            fa.y2++;
+                lv_memset_ff(mask_buf, w);
+                mask_res = lv_draw_mask_apply(mask_buf, clip_area_sub.x1, y, w);
+                _lv_blend_fill(&clip_area_sub, &blend_area, dsc->shadow_color, mask_buf, mask_res, dsc->shadow_opa, dsc->blend_mode);
+            }
         }
     }
 
-    lv_draw_mask_remove_id(mask_rout_id);
-    lv_mem_buf_release(mask_buf);
+    if(!simple) {
+        lv_draw_mask_free_param(&mask_rout_param);
+        lv_draw_mask_remove_id(mask_rout_id);
+    }
     lv_mem_buf_release(sh_buf);
+    lv_mem_buf_release(mask_buf);
 }
 
 /**
  * Calculate a blurred corner
  * @param coords Coordinates of the shadow
- * @param sh_buf a buffer to store the result. It's size should be `(sw + r)^2 * 2`
+ * @param sh_buf a buffer to store the result. Its size should be `(sw + r)^2 * 2`
  * @param sw shadow width
  * @param r radius
  */
@@ -1064,6 +921,8 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coord
     }
     lv_mem_buf_release(mask_line);
 
+    lv_draw_mask_free_param(&mask_param);
+
     if(sw == 1) {
         int32_t i;
         lv_opa_t * res_buf = (lv_opa_t *)sh_buf;
@@ -1086,9 +945,10 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coord
     sw += sw_ori & 1;
     if(sw > 1) {
         uint32_t i;
-        sh_buf[0] = (sh_buf[0] << SHADOW_UPSCALE_SHIFT) / sw;
-        for(i = 1; i < (uint32_t) size * size; i++) {
-            if(sh_buf[i] == sh_buf[i - 1]) sh_buf[i] = sh_buf[i - 1];
+        uint32_t max_v_div = (LV_OPA_COVER << SHADOW_UPSCALE_SHIFT) / sw;
+        for(i = 0; i < (uint32_t)size * size; i++) {
+            if(sh_buf[i] == 0) continue;
+            else if(sh_buf[i] == LV_OPA_COVER) sh_buf[i] = max_v_div;
             else  sh_buf[i] = (sh_buf[i] << SHADOW_UPSCALE_SHIFT) / sw;
         }
 
@@ -1139,10 +999,12 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_blur_corner(lv_coord_t size, lv_coord_t
 
     /*Vertical blur*/
     uint32_t i;
-    sh_ups_buf[0] = sh_ups_buf[0] / sw;
-    for(i = 1; i < (uint32_t)size * size; i++) {
-        if(sh_ups_buf[i] == sh_ups_buf[i - 1]) sh_ups_buf[i] = sh_ups_buf[i - 1];
-        else  sh_ups_buf[i] = sh_ups_buf[i] / sw;
+    uint32_t max_v = LV_OPA_COVER << SHADOW_UPSCALE_SHIFT;
+    uint32_t max_v_div = max_v / sw;
+    for(i = 0; i < (uint32_t)size * size; i++) {
+        if(sh_ups_buf[i] == 0) continue;
+        else if(sh_ups_buf[i] == max_v) sh_ups_buf[i] = max_v_div;
+        else sh_ups_buf[i] = sh_ups_buf[i] / sw;
     }
 
     for(x = 0; x < size; x++) {
@@ -1204,238 +1066,276 @@ static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, const
     area_outer.y1 -= dsc->outline_width;
     area_outer.y2 += dsc->outline_width;
 
-#if LV_DRAW_COMPLEX
-    draw_full_border(&area_inner, &area_outer, clip, dsc->radius, true, dsc->outline_color, dsc->outline_opa,
-                     dsc->blend_mode);
-#else
-    draw_simple_border(clip, &area_inner, &area_outer, dsc->outline_color, dsc->outline_opa, LV_BORDER_SIDE_FULL);
-#endif
+
+    int32_t inner_w = lv_area_get_width(&area_inner);
+    int32_t inner_h = lv_area_get_height(&area_inner);
+    int32_t rin = dsc->radius;
+    int32_t short_side = LV_MIN(inner_w, inner_h);
+    if(rin > short_side >> 1) rin = short_side >> 1;
+
+    lv_coord_t rout = rin + dsc->outline_width;
+
+    draw_border_generic(clip, &area_outer, &area_inner, rout, rin, dsc->outline_color, dsc->outline_opa, dsc->blend_mode);
 }
 
-#if LV_DRAW_COMPLEX
-static void draw_full_border(const lv_area_t * area_inner, const lv_area_t * area_outer, const lv_area_t * clip,
-                             lv_coord_t radius, bool radius_is_in, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode)
+void draw_border_generic(const lv_area_t * clip_area, const lv_area_t * outer_area, const lv_area_t * inner_area,
+                         lv_coord_t rout, lv_coord_t rin, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode)
 {
+    opa = opa >= LV_OPA_COVER ? LV_OPA_COVER : opa;
 
-    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
-    bool simple_mode = true;
-    if(other_mask_cnt) simple_mode = false;
-
-    int32_t inner_w = lv_area_get_width(area_inner);
-    int32_t inner_h = lv_area_get_height(area_inner);
-    lv_coord_t border_width = area_outer->x2 - area_inner->x2;
-
-    int32_t coords_out_w = lv_area_get_width(area_outer);
-    int32_t coords_out_h = lv_area_get_height(area_outer);
-
-    int32_t rin;
-    int32_t rout;
-    if(radius_is_in) {
-        rin = radius;
-        int32_t short_side = LV_MIN(inner_w, inner_h);
-        if(rin > short_side >> 1) rin = short_side >> 1;
-
-        /*Get the outer area*/
-        rout = rin + border_width;
-    }
-    else {
-        rout = radius;
-        int32_t short_side = LV_MIN(coords_out_w, coords_out_h);
-        if(rout > short_side >> 1) rout = short_side >> 1;
-
-        /*Get the outer area*/
-        rin = rout - border_width;
-        if(rin < 0) rin = 0;
+    bool mask_any = lv_draw_mask_is_any(outer_area);
 
+    if(!mask_any && rout == 0 && rin == 0) {
+        draw_border_simple(clip_area, outer_area, inner_area, color, opa);
+        return;
     }
 
-    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    lv_disp_draw_buf_t * draw_buf = lv_disp_get_draw_buf(disp);
-
-    /*Get clipped fill area which is the real draw area.
-     *It is always the same or inside `fill_area`*/
+#if LV_DRAW_COMPLEX
+    /*Get clipped draw area which is the real draw area.
+     *It is always the same or inside `coords`*/
     lv_area_t draw_area;
-    bool is_common;
-    is_common = _lv_area_intersect(&draw_area, area_outer, clip);
-    if(is_common == false) return;
-
-    const lv_area_t * disp_area = &draw_buf->area;
-
-    /*Now `draw_area` has absolute coordinates.
-     *Make it relative to `disp_area` to simplify draw to `disp_buf`*/
-    draw_area.x1 -= disp_area->x1;
-    draw_area.y1 -= disp_area->y1;
-    draw_area.x2 -= disp_area->x1;
-    draw_area.y2 -= disp_area->y1;
-
+    if(!_lv_area_intersect(&draw_area, outer_area, clip_area)) return;
     int32_t draw_area_w = lv_area_get_width(&draw_area);
 
-    /*Create inner the mask*/
-    lv_draw_mask_radius_param_t mask_rin_param;
-    lv_draw_mask_radius_init(&mask_rin_param, area_inner, rin, true);
-    int16_t mask_rin_id = lv_draw_mask_add(&mask_rin_param, NULL);
-
-    lv_draw_mask_radius_param_t mask_rout_param;
-    lv_draw_mask_radius_init(&mask_rout_param, area_outer, rout, false);
-    int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
-
+    /*Create a mask if there is a radius*/
     lv_opa_t * mask_buf = lv_mem_buf_get(draw_area_w);
 
-    int32_t corner_size = LV_MAX(rout, border_width - 1);
+    /*Create mask for the outer area*/
+    int16_t mask_rout_id = LV_MASK_ID_INV;
+    lv_draw_mask_radius_param_t mask_rout_param;
+    if(rout > 0) {
+        lv_draw_mask_radius_init(&mask_rout_param, outer_area, rout, false);
+        mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
+    }
+
+    /*Create mask for the inner mask*/
+    lv_draw_mask_radius_param_t mask_rin_param;
+    lv_draw_mask_radius_init(&mask_rin_param, inner_area, rin, true);
+    int16_t mask_rin_id = lv_draw_mask_add(&mask_rin_param, NULL);
 
     int32_t h;
     lv_draw_mask_res_t mask_res;
-    lv_area_t fill_area;
+    lv_area_t blend_area;
 
-    /*Apply some optimization if there is no other mask*/
-    if(simple_mode) {
-        /*Draw the upper corner area*/
-        int32_t upper_corner_end = area_outer->y1 - disp_area->y1 + corner_size;
+    /*Calculate the x and y coordinates where the straight parts area*/
+    lv_area_t core_area;
+    core_area.x1 = LV_MAX(outer_area->x1 + rout, inner_area->x1);
+    core_area.x2 = LV_MIN(outer_area->x2 - rout, inner_area->x2);
+    core_area.y1 = LV_MAX(outer_area->y1 + rout, inner_area->y1);
+    core_area.y2 = LV_MIN(outer_area->y2 - rout, inner_area->y2);
+    lv_coord_t core_w = lv_area_get_width(&core_area);
 
-        fill_area.x1 = area_outer->x1;
-        fill_area.x2 = area_outer->x2;
-        fill_area.y1 = disp_area->y1 + draw_area.y1;
-        fill_area.y2 = fill_area.y1;
-        for(h = draw_area.y1; h <= upper_corner_end; h++) {
-            lv_memset_ff(mask_buf, draw_area_w);
-            mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h, draw_area_w);
-
-            lv_area_t fill_area2;
-            fill_area2.y1 = fill_area.y1;
-            fill_area2.y2 = fill_area.y2;
-
-            fill_area2.x1 = area_outer->x1;
-            fill_area2.x2 = area_outer->x1 + rout - 1;
-
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf, mask_res, opa, blend_mode);
-
-            /*Draw the top horizontal line*/
-            if(fill_area2.y2 < area_outer->y1 + border_width) {
-                fill_area2.x1 = area_outer->x1 + rout;
-                fill_area2.x2 = area_outer->x2 - rout;
-
-                _lv_blend_fill(clip, &fill_area2, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-            }
-
-            fill_area2.x1 = area_outer->x2 - rout + 1;
-            fill_area2.x2 = area_outer->x2;
-
-            int32_t mask_ofs = (area_outer->x2 - rout + 1) - (draw_buf->area.x1 + draw_area.x1);
-            if(mask_ofs < 0) mask_ofs = 0;
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf + mask_ofs, mask_res, opa, blend_mode);
-
-            fill_area.y1++;
-            fill_area.y2++;
-        }
-
-        /*Draw the lower corner area*/
-        int32_t lower_corner_end = area_outer->y2 - disp_area->y1 - corner_size;
-        if(lower_corner_end <= upper_corner_end) lower_corner_end = upper_corner_end + 1;
-        fill_area.y1 = disp_area->y1 + lower_corner_end;
-        fill_area.y2 = fill_area.y1;
-        for(h = lower_corner_end; h <= draw_area.y2; h++) {
-            lv_memset_ff(mask_buf, draw_area_w);
-            mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h, draw_area_w);
-
-            lv_area_t fill_area2;
-            fill_area2.x1 = area_outer->x1;
-            fill_area2.x2 = area_outer->x1 + rout - 1;
-            fill_area2.y1 = fill_area.y1;
-            fill_area2.y2 = fill_area.y2;
-
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf, mask_res, opa, blend_mode);
-
-            /*Draw the bottom horizontal line*/
-            if(fill_area2.y2 > area_outer->y2 - border_width) {
-                fill_area2.x1 = area_outer->x1 + rout;
-                fill_area2.x2 = area_outer->x2 - rout;
-
-                _lv_blend_fill(clip, &fill_area2, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-            }
-            fill_area2.x1 = area_outer->x2 - rout + 1;
-            fill_area2.x2 = area_outer->x2;
-
-            int32_t mask_ofs = (area_outer->x2 - rout + 1) - (draw_buf->area.x1 + draw_area.x1);
-            if(mask_ofs < 0) mask_ofs = 0;
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf + mask_ofs, mask_res, opa, blend_mode);
-
-            fill_area.y1++;
-            fill_area.y2++;
-        }
-
-        /*Draw the left vertical part*/
-        fill_area.y1 = area_outer->y1 + corner_size + 1;
-        fill_area.y2 = area_outer->y2 - corner_size - 1;
-
-        fill_area.x1 = area_outer->x1;
-        fill_area.x2 = area_outer->x1 + border_width - 1;
-        _lv_blend_fill(clip, &fill_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-
-        /*Draw the right vertical border*/
-        fill_area.x1 = area_outer->x2 - border_width + 1;
-        fill_area.x2 = area_outer->x2;
-
-        _lv_blend_fill(clip, &fill_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-    }
-    /*Process line by line if there is other mask too*/
-    else {
-        fill_area.x1 = area_outer->x1;
-        fill_area.x2 = area_outer->x2;
-        fill_area.y1 = disp_area->y1 + draw_area.y1;
-        fill_area.y2 = fill_area.y1;
+    bool top_side = outer_area->y1 <= inner_area->y1 ? true : false;
+    bool bottom_side = outer_area->y2 >= inner_area->y2 ? true : false;
 
+    /*If there is other masks, need to draw line by line*/
+    if(mask_any) {
+        blend_area.x1 = draw_area.x1;
+        blend_area.x2 = draw_area.x2;
         for(h = draw_area.y1; h <= draw_area.y2; h++) {
+            if(!top_side && h < core_area.y1) continue;
+            if(!bottom_side && h > core_area.y2) break;
+
+            blend_area.y1 = h;
+            blend_area.y2 = h;
+
             lv_memset_ff(mask_buf, draw_area_w);
-            mask_res = lv_draw_mask_apply(mask_buf, draw_buf->area.x1 + draw_area.x1, draw_buf->area.y1 + h, draw_area_w);
+            mask_res = lv_draw_mask_apply(mask_buf, draw_area.x1, h, draw_area_w);
+            _lv_blend_fill(clip_area, &blend_area, color, mask_buf, mask_res, opa, blend_mode);
+        }
 
-            _lv_blend_fill(clip, &fill_area, color, mask_buf, mask_res, opa, blend_mode);
-            fill_area.y1++;
-            fill_area.y2++;
+        lv_draw_mask_free_param(&mask_rin_param);
+        lv_draw_mask_remove_id(mask_rin_id);
+        lv_draw_mask_free_param(&mask_rout_param);
+        lv_draw_mask_remove_id(mask_rout_id);
+        lv_mem_buf_release(mask_buf);
+        return;
+    }
 
+    /*No masks*/
+    bool left_side = outer_area->x1 <= inner_area->x1 ? true : false;
+    bool right_side = outer_area->x2 >= inner_area->x2 ? true : false;
+
+    bool split_hor = true;
+    if(left_side && right_side && top_side && bottom_side &&
+       core_w < SPLIT_LIMIT) {
+        split_hor = false;
+    }
+
+    /*Draw the straight lines first if they are long enough*/
+    if(top_side && split_hor) {
+        blend_area.x1 = core_area.x1;
+        blend_area.x2 = core_area.x2;
+        blend_area.y1 = outer_area->y1;
+        blend_area.y2 = inner_area->y1 - 1;
+        _lv_blend_fill(clip_area, &blend_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+    }
+
+    if(bottom_side && split_hor) {
+        blend_area.x1 = core_area.x1;
+        blend_area.x2 = core_area.x2;
+        blend_area.y1 = inner_area->y2 + 1;
+        blend_area.y2 = outer_area->y2;
+        _lv_blend_fill(clip_area, &blend_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+    }
+
+    if(left_side) {
+        blend_area.x1 = outer_area->x1;
+        blend_area.x2 = inner_area->x1 - 1;
+        blend_area.y1 = core_area.y1;
+        blend_area.y2 = core_area.y2;
+        _lv_blend_fill(clip_area, &blend_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+    }
+
+    if(right_side) {
+        blend_area.x1 = inner_area->x2 + 1;
+        blend_area.x2 = outer_area->x2;
+        blend_area.y1 = core_area.y1;
+        blend_area.y2 = core_area.y2;
+        _lv_blend_fill(clip_area, &blend_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+    }
+
+    /*Draw the corners*/
+    lv_coord_t blend_w;
+
+    /*Left and right corner together is they close to eachother*/
+    if(!split_hor) {
+        /*Calculate the top corner and mirror it to the bottom*/
+        blend_area.x1 = draw_area.x1;
+        blend_area.x2 = draw_area.x2;
+        lv_coord_t max_h = LV_MAX(rout, outer_area->y1 - inner_area->y1);
+        for(h = 0; h < max_h; h++) {
+            lv_coord_t top_y = outer_area->y1 + h;
+            lv_coord_t bottom_y = outer_area->y2 - h;
+            if(top_y < draw_area.y1 && bottom_y > draw_area.y2) continue;   /*This line is clipped now*/
+
+            lv_memset_ff(mask_buf, draw_area_w);
+            mask_res = lv_draw_mask_apply(mask_buf, blend_area.x1, top_y, draw_area_w);
+
+            if(top_y >= draw_area.y1) {
+                blend_area.y1 = top_y;
+                blend_area.y2 = top_y;
+                _lv_blend_fill(clip_area, &blend_area, color, mask_buf, mask_res, opa, blend_mode);
+            }
+
+            if(bottom_y <= draw_area.y2) {
+                blend_area.y1 = bottom_y;
+                blend_area.y2 = bottom_y;
+                _lv_blend_fill(clip_area, &blend_area, color, mask_buf, mask_res, opa, blend_mode);
+            }
         }
     }
+    else {
+        /*Left corners*/
+        blend_area.x1 = draw_area.x1;
+        blend_area.x2 = LV_MIN(draw_area.x2, core_area.x1 - 1);
+        blend_w = lv_area_get_width(&blend_area);
+        if(blend_w > 0) {
+            if(left_side || top_side) {
+                for(h = draw_area.y1; h < core_area.y1; h++) {
+                    blend_area.y1 = h;
+                    blend_area.y2 = h;
+
+                    lv_memset_ff(mask_buf, blend_w);
+                    mask_res = lv_draw_mask_apply(mask_buf, blend_area.x1, h, blend_w);
+                    _lv_blend_fill(clip_area, &blend_area, color, mask_buf, mask_res, opa, blend_mode);
+                }
+            }
+
+            if(left_side || bottom_side) {
+                for(h = core_area.y2 + 1; h <= draw_area.y2; h++) {
+                    blend_area.y1 = h;
+                    blend_area.y2 = h;
+
+                    lv_memset_ff(mask_buf, blend_w);
+                    mask_res = lv_draw_mask_apply(mask_buf, blend_area.x1, h, blend_w);
+                    _lv_blend_fill(clip_area, &blend_area, color, mask_buf, mask_res, opa, blend_mode);
+                }
+            }
+        }
+
+        /*Right corners*/
+        blend_area.x1 = LV_MAX(draw_area.x1, core_area.x2 + 1);
+        blend_area.x2 = draw_area.x2;
+        blend_w = lv_area_get_width(&blend_area);
+
+        if(blend_w > 0) {
+            if(right_side || top_side) {
+                for(h = draw_area.y1; h < core_area.y1; h++) {
+                    blend_area.y1 = h;
+                    blend_area.y2 = h;
+
+                    lv_memset_ff(mask_buf, blend_w);
+                    mask_res = lv_draw_mask_apply(mask_buf, blend_area.x1, h, blend_w);
+                    _lv_blend_fill(clip_area, &blend_area, color, mask_buf, mask_res, opa, blend_mode);
+                }
+            }
+
+            if(right_side || bottom_side) {
+                for(h = core_area.y2 + 1; h <= draw_area.y2; h++) {
+                    blend_area.y1 = h;
+                    blend_area.y2 = h;
+
+                    lv_memset_ff(mask_buf, blend_w);
+                    mask_res = lv_draw_mask_apply(mask_buf, blend_area.x1, h, blend_w);
+                    _lv_blend_fill(clip_area, &blend_area, color, mask_buf, mask_res, opa, blend_mode);
+                }
+            }
+        }
+    }
+
+    lv_draw_mask_free_param(&mask_rin_param);
     lv_draw_mask_remove_id(mask_rin_id);
+    lv_draw_mask_free_param(&mask_rout_param);
     lv_draw_mask_remove_id(mask_rout_id);
     lv_mem_buf_release(mask_buf);
-}
-#else /*LV_DRAW_COMPLEX*/
 
-static void draw_simple_border(const lv_area_t * clip, const lv_area_t * area_inner, const lv_area_t * area_outer,
-        lv_color_t color, lv_opa_t opa, lv_border_side_t side)
+#else /*LV_DRAW_COMPLEX*/
+    LV_UNUSED(blend_mode);
+#endif /*LV_DRAW_COMPLEX*/
+}
+
+static void draw_border_simple(const lv_area_t * clip, const lv_area_t * outer_area, const lv_area_t * inner_area,
+                               lv_color_t color, lv_opa_t opa)
 {
+    bool top_side = outer_area->y1 <= inner_area->y1 ? true : false;
+    bool bottom_side = outer_area->y2 >= inner_area->y2 ? true : false;
+    bool left_side = outer_area->x1 <= inner_area->x1 ? true : false;
+    bool right_side = outer_area->x2 >= inner_area->x2 ? true : false;
+
     lv_area_t a;
     /*Top*/
-    a.x1 = area_outer->x1;
-    a.x2 = area_outer->x2;
-    a.y1 = area_outer->y1;
-    a.y2 = area_inner->y1;
-    if(side & LV_BORDER_SIDE_TOP) {
+    a.x1 = outer_area->x1;
+    a.x2 = outer_area->x2;
+    a.y1 = outer_area->y1;
+    a.y2 = inner_area->y1 - 1;
+    if(top_side) {
         _lv_blend_fill(clip, &a, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, LV_BLEND_MODE_NORMAL);
     }
 
     /*Bottom*/
-    a.y1 = area_inner->y2;
-    a.y2 = area_outer->y2;
-    if(side & LV_BORDER_SIDE_BOTTOM) {
+    a.y1 = inner_area->y2 + 1;
+    a.y2 = outer_area->y2;
+    if(bottom_side) {
         _lv_blend_fill(clip, &a, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, LV_BLEND_MODE_NORMAL);
     }
+
     /*Left*/
-    a.x1 = area_outer->x1;
-    a.x2 = area_inner->x1;
-    a.y1 = (side & LV_BORDER_SIDE_TOP) ? area_inner->y1 : area_outer->y1;
-    a.y2 = (side & LV_BORDER_SIDE_BOTTOM) ? area_inner->y2 : area_outer->y2;
-    if(side & LV_BORDER_SIDE_LEFT) {
+    a.x1 = outer_area->x1;
+    a.x2 = inner_area->x1 - 1;
+    a.y1 = (top_side) ? inner_area->y1 : outer_area->y1;
+    a.y2 = (bottom_side) ? inner_area->y2 : outer_area->y2;
+    if(left_side) {
         _lv_blend_fill(clip, &a, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, LV_BLEND_MODE_NORMAL);
     }
 
     /*Right*/
-    a.x1 = area_inner->x2;
-    a.x2 = area_outer->x2;
-    if(side & LV_BORDER_SIDE_RIGHT) {
+    a.x1 = inner_area->x2 + 1;
+    a.x2 = outer_area->x2;
+    if(right_side) {
         _lv_blend_fill(clip, &a, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, LV_BLEND_MODE_NORMAL);
     }
 
 }
 
 #endif
-
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_rect.h b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_rect.h
index f4d05922b..f43a0eafb 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_rect.h
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_draw_rect.h
@@ -37,7 +37,7 @@ typedef struct {
     uint8_t bg_main_color_stop;
     uint8_t bg_grad_color_stop;
     lv_opa_t bg_opa;
-    lv_grad_dir_t bg_grad_dir :3;
+    lv_grad_dir_t bg_grad_dir : 3;
 
     /*Background img*/
     const void * bg_img_src;
@@ -52,7 +52,7 @@ typedef struct {
     lv_coord_t border_width;
     lv_opa_t border_opa;
     uint8_t border_post : 1;        /*There is a border it will be drawn later.*/
-    lv_border_side_t border_side :5;
+    lv_border_side_t border_side : 5;
 
     /*Outline*/
     lv_color_t outline_color;
@@ -80,10 +80,10 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc);
 /**
  * Draw a rectangle
  * @param coords the coordinates of the rectangle
- * @param mask the rectangle will be drawn only in this mask
+ * @param clip the rectangle will be drawn only in this area
  * @param dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
-void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, const lv_draw_rect_dsc_t * dsc);
+void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc);
 
 /**
  * Draw a pixel
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_img_buf.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_img_buf.c
index e01c77313..07ea03c52 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_img_buf.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_img_buf.c
@@ -367,7 +367,7 @@ void lv_img_buf_free(lv_img_dsc_t * dsc)
 {
     if(dsc != NULL) {
         if(dsc->data != NULL)
-            lv_mem_free((void*)dsc->data);
+            lv_mem_free((void *)dsc->data);
 
         lv_mem_free(dsc);
     }
@@ -483,10 +483,10 @@ void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t
         return;
     }
 
-    res->x1 = (((-pivot->x) * zoom) >> 8) - 1;
-    res->y1 = (((-pivot->y) * zoom) >> 8) - 1;
-    res->x2 = (((w - pivot->x) * zoom) >> 8) + 2;
-    res->y2 = (((h - pivot->y) * zoom) >> 8) + 2;
+    res->x1 = (((int32_t)(-pivot->x) * zoom) >> 8) - 1;
+    res->y1 = (((int32_t)(-pivot->y) * zoom) >> 8) - 1;
+    res->x2 = (((int32_t)(w - pivot->x) * zoom) >> 8) + 2;
+    res->y2 = (((int32_t)(h - pivot->y) * zoom) >> 8) + 2;
 
     if(angle == 0) {
         res->x1 += pivot->x;
@@ -710,7 +710,7 @@ bool _lv_img_buf_transform_anti_alias(lv_img_transform_dsc_t * dsc)
         lv_memcpy_small(&c01, &src_u8[dsc->tmp.pxi + dsc->tmp.px_size * xn], sizeof(lv_color_t));
         lv_memcpy_small(&c10, &src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn], sizeof(lv_color_t));
         lv_memcpy_small(&c11, &src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn + dsc->tmp.px_size * xn],
-                         sizeof(lv_color_t));
+                        sizeof(lv_color_t));
         if(dsc->tmp.has_alpha) {
             a10 = src_u8[dsc->tmp.pxi + dsc->tmp.px_size * xn + dsc->tmp.px_size - 1];
             a01 = src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn + dsc->tmp.px_size - 1];
diff --git a/lib/libesp32_lvgl/lvgl/src/draw/lv_img_decoder.c b/lib/libesp32_lvgl/lvgl/src/draw/lv_img_decoder.c
index cb42c8fe6..3678a5712 100644
--- a/lib/libesp32_lvgl/lvgl/src/draw/lv_img_decoder.c
+++ b/lib/libesp32_lvgl/lvgl/src/draw/lv_img_decoder.c
@@ -82,7 +82,15 @@ void _lv_img_decoder_init(void)
  */
 lv_res_t lv_img_decoder_get_info(const void * src, lv_img_header_t * header)
 {
-   lv_memset_00(header, sizeof(lv_img_header_t));
+    lv_memset_00(header, sizeof(lv_img_header_t));
+
+    if(src == NULL) return LV_RES_INV;
+
+    lv_img_src_t src_type = lv_img_src_get_type(src);
+    if(src_type == LV_IMG_SRC_VARIABLE) {
+        const lv_img_dsc_t * img_dsc = src;
+        if(img_dsc->data == NULL) return LV_RES_INV;
+    }
 
     lv_res_t res = LV_RES_INV;
     lv_img_decoder_t * d;
@@ -100,8 +108,15 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co
 {
     lv_memset_00(dsc, sizeof(lv_img_decoder_dsc_t));
 
+    if(src == NULL) return LV_RES_INV;
+    lv_img_src_t src_type = lv_img_src_get_type(src);
+    if(src_type == LV_IMG_SRC_VARIABLE) {
+        const lv_img_dsc_t * img_dsc = src;
+        if(img_dsc->data == NULL) return LV_RES_INV;
+    }
+
     dsc->color    = color;
-    dsc->src_type = lv_img_src_get_type(src);
+    dsc->src_type = src_type;
     dsc->frame_id = frame_id;
 
     if(dsc->src_type == LV_IMG_SRC_FILE) {
@@ -144,7 +159,7 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co
     }
 
     if(dsc->src_type == LV_IMG_SRC_FILE)
-        lv_mem_free((void*)dsc->src);
+        lv_mem_free((void *)dsc->src);
 
     return res;
 }
@@ -176,7 +191,7 @@ void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc)
         if(dsc->decoder->close_cb) dsc->decoder->close_cb(dsc->decoder, dsc);
 
         if(dsc->src_type == LV_IMG_SRC_FILE) {
-            lv_mem_free((void*)dsc->src);
+            lv_mem_free((void *)dsc->src);
             dsc->src = NULL;
         }
     }
@@ -257,7 +272,7 @@ void lv_img_decoder_set_close_cb(lv_img_decoder_t * decoder, lv_img_decoder_clos
  */
 lv_res_t lv_img_decoder_built_in_info(lv_img_decoder_t * decoder, const void * src, lv_img_header_t * header)
 {
-    (void)decoder; /*Unused*/
+    LV_UNUSED(decoder); /*Unused*/
 
     lv_img_src_t src_type = lv_img_src_get_type(src);
     if(src_type == LV_IMG_SRC_VARIABLE) {
@@ -420,7 +435,7 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
         /*Free the potentially allocated memories*/
         lv_img_decoder_built_in_close(decoder, dsc);
 
-        LV_LOG_WARN("Image decoder open: unknown color format")
+        LV_LOG_WARN("Image decoder open: unknown color format");
         return LV_RES_INV;
     }
 }
@@ -439,7 +454,7 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
 lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc, lv_coord_t x,
                                            lv_coord_t y, lv_coord_t len, uint8_t * buf)
 {
-    (void)decoder; /*Unused*/
+    LV_UNUSED(decoder); /*Unused*/
 
     lv_res_t res = LV_RES_INV;
 
@@ -474,7 +489,7 @@ lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_de
  */
 void lv_img_decoder_built_in_close(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc)
 {
-    (void)decoder; /*Unused*/
+    LV_UNUSED(decoder); /*Unused*/
 
     lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
     if(user_data) {
@@ -579,7 +594,7 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
 
     lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
     uint8_t * fs_buf = lv_mem_buf_get(w);
-    if (fs_buf == NULL) return LV_RES_INV;
+    if(fs_buf == NULL) return LV_RES_INV;
 
     const uint8_t * data_tmp = NULL;
     if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
@@ -648,7 +663,7 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
     lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
 
     uint8_t * fs_buf = lv_mem_buf_get(w);
-    if (fs_buf == NULL) return LV_RES_INV;
+    if(fs_buf == NULL) return LV_RES_INV;
     const uint8_t * data_tmp = NULL;
     if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
         const lv_img_dsc_t * img_dsc = dsc->src;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/README.md b/lib/libesp32_lvgl/lvgl/src/extra/README.md
new file mode 100644
index 000000000..bd564a74c
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/README.md
@@ -0,0 +1,30 @@
+# Extra components
+
+This directory contains extra (optional) components to lvgl. 
+It's a good place for contributions as there are less strict expectations about the completeness and flexibility of the components here.
+
+In other words, if you have created a complex widget from other widgets, or modified an existing widget with special events, styles or animations, or have a new feature that could work as a plugin to lvgl feel free to the share it here.
+
+## How to contribute
+- Create a [Pull request](https://docs.lvgl.io/8.0/CONTRIBUTING.html#pull-request) with your new content
+- Please and follow the [Coding style](https://github.com/lvgl/lvgl/blob/master/docs/CODING_STYLE.md) of LVGL
+- Add setter/getter functions in pair
+- Update [lv_conf_template.h](https://github.com/lvgl/lvgl/blob/master/lv_conf_template.h)
+- Add description in the [docs](https://github.com/lvgl/lvgl/tree/master/docs) 
+- Add [examples](https://github.com/lvgl/lvgl/tree/master/examples)
+- Update the [changelog](https://github.com/lvgl/lvgl/tree/master/docs/CHANGELOG.md)
+- Add yourself to the [Contributors](#contributors) section below.
+
+## Ideas
+Here some ideas as inspiration feel free to contribute with ideas too. 
+- New [Calendar headers](https://github.com/lvgl/lvgl/tree/master/src/extra/widgets/calendar)
+- Color picker with RGB and or HSV bars
+- Ruler, horizontal or vertical with major and minor ticks and labels
+- New [List items types](https://github.com/lvgl/lvgl/tree/master/src/extra/widgets/list)
+- [Preloaders](https://www.google.com/search?q=preloader&sxsrf=ALeKk01ddA4YB0WEgLLN1bZNSm8YER7pkg:1623080551559&source=lnms&tbm=isch&sa=X&ved=2ahUKEwiwoN6d7oXxAhVuw4sKHVedBB4Q_AUoAXoECAEQAw&biw=952&bih=940)
+- Drop-down list with a container to which an content can be added
+- 9 patch button: Similar to [lv_imgbtn](https://docs.lvgl.io/8.0/widgets/extra/imgbtn.html) but 9 images for 4 corner, 4 sides and the center
+
+## Contributors
+- lv_animimg: @ZhaoQiang-b45475
+- lv_span: @guoweilkd 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/layouts/flex/lv_flex.c b/lib/libesp32_lvgl/lvgl/src/extra/layouts/flex/lv_flex.c
index c618d16f1..7538ae4ae 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/layouts/flex/lv_flex.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/layouts/flex/lv_flex.c
@@ -21,10 +21,10 @@ typedef struct {
     lv_flex_align_t main_place;
     lv_flex_align_t cross_place;
     lv_flex_align_t track_place;
-    uint8_t row :1;
-    uint8_t wrap :1;
-    uint8_t rev :1;
-}flex_t;
+    uint8_t row : 1;
+    uint8_t wrap : 1;
+    uint8_t rev : 1;
+} flex_t;
 
 typedef struct {
     lv_obj_t * item;
@@ -32,8 +32,8 @@ typedef struct {
     lv_coord_t max_size;
     lv_coord_t final_size;
     uint32_t grow_value;
-    uint32_t clamped :1;
-}grow_dsc_t;
+    uint32_t clamped : 1;
+} grow_dsc_t;
 
 typedef struct {
     lv_coord_t track_cross_size;
@@ -42,8 +42,8 @@ typedef struct {
     uint32_t item_cnt;
     grow_dsc_t * grow_dsc;
     uint32_t grow_item_cnt;
-    uint32_t grow_dsc_calc :1;
-}track_t;
+    uint32_t grow_dsc_calc : 1;
+} track_t;
 
 
 /**********************
@@ -54,9 +54,12 @@ typedef struct {
  *  STATIC PROTOTYPES
  **********************/
 static void flex_update(lv_obj_t * cont, void * user_data);
-static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id, lv_coord_t item_gap, lv_coord_t max_main_size, track_t * t);
-static void children_repos(lv_obj_t * cont, flex_t * f, int32_t item_first_id, int32_t item_last_id, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t max_main_size, lv_coord_t item_gap, track_t * t);
-static void place_content(lv_flex_align_t place, lv_coord_t max_size, lv_coord_t content_size, lv_coord_t item_cnt, lv_coord_t * start_pos, lv_coord_t * gap);
+static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id, lv_coord_t item_gap,
+                              lv_coord_t max_main_size, track_t * t);
+static void children_repos(lv_obj_t * cont, flex_t * f, int32_t item_first_id, int32_t item_last_id, lv_coord_t abs_x,
+                           lv_coord_t abs_y, lv_coord_t max_main_size, lv_coord_t item_gap, track_t * t);
+static void place_content(lv_flex_align_t place, lv_coord_t max_size, lv_coord_t content_size, lv_coord_t item_cnt,
+                          lv_coord_t * start_pos, lv_coord_t * gap);
 static lv_obj_t * get_next_item(lv_obj_t * cont, bool rev, int32_t * item_id);
 
 /**********************
@@ -102,7 +105,8 @@ void lv_obj_set_flex_flow(lv_obj_t * obj, lv_flex_flow_t flow)
     lv_obj_set_style_layout(obj, LV_LAYOUT_FLEX, 0);
 }
 
-void lv_obj_set_flex_align(lv_obj_t * obj, lv_flex_align_t main_place, lv_flex_align_t cross_place, lv_flex_align_t track_place)
+void lv_obj_set_flex_align(lv_obj_t * obj, lv_flex_align_t main_place, lv_flex_align_t cross_place,
+                           lv_flex_align_t track_place)
 {
     lv_obj_set_style_flex_main_place(obj, main_place, 0);
     lv_obj_set_style_flex_cross_place(obj, cross_place, 0);
@@ -152,7 +156,7 @@ void lv_style_set_flex_track_place(lv_style_t * style, lv_flex_align_t value)
 void lv_style_set_flex_grow(lv_style_t * style, uint8_t value)
 {
     lv_style_value_t v = {
-            .num = (int32_t)value
+        .num = (int32_t)value
     };
     lv_style_set_prop(style, LV_STYLE_FLEX_GROW, v);
 }
@@ -204,7 +208,7 @@ void lv_obj_set_style_flex_grow(lv_obj_t * obj, uint8_t value, lv_style_selector
 
 static void flex_update(lv_obj_t * cont, void * user_data)
 {
-    LV_LOG_INFO("update %p container", cont);
+    LV_LOG_INFO("update %p container", (void *)cont);
     LV_UNUSED(user_data);
 
     flex_t f;
@@ -217,12 +221,16 @@ static void flex_update(lv_obj_t * cont, void * user_data)
     f.track_place = lv_obj_get_style_flex_track_place(cont, LV_PART_MAIN);
 
     bool rtl = lv_obj_get_style_base_dir(cont, LV_PART_MAIN) == LV_BASE_DIR_RTL ? true : false;
-    lv_coord_t track_gap = !f.row ? lv_obj_get_style_pad_column(cont, LV_PART_MAIN) : lv_obj_get_style_pad_row(cont, LV_PART_MAIN);
-    lv_coord_t item_gap = f.row ? lv_obj_get_style_pad_column(cont, LV_PART_MAIN) : lv_obj_get_style_pad_row(cont, LV_PART_MAIN);
+    lv_coord_t track_gap = !f.row ? lv_obj_get_style_pad_column(cont, LV_PART_MAIN) : lv_obj_get_style_pad_row(cont,
+                                                                                                               LV_PART_MAIN);
+    lv_coord_t item_gap = f.row ? lv_obj_get_style_pad_column(cont, LV_PART_MAIN) : lv_obj_get_style_pad_row(cont,
+                                                                                                             LV_PART_MAIN);
     lv_coord_t max_main_size = (f.row ? lv_obj_get_content_width(cont) : lv_obj_get_content_height(cont));
-    lv_coord_t border_widt = lv_obj_get_style_border_width(cont, LV_PART_MAIN);
-    lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont, LV_PART_MAIN) + border_widt - lv_obj_get_scroll_y(cont);
-    lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont, LV_PART_MAIN) + border_widt - lv_obj_get_scroll_x(cont);
+    lv_coord_t border_width = lv_obj_get_style_border_width(cont, LV_PART_MAIN);
+    lv_coord_t abs_y = cont->coords.y1 + lv_obj_get_style_pad_top(cont,
+                                                                  LV_PART_MAIN) + border_width - lv_obj_get_scroll_y(cont);
+    lv_coord_t abs_x = cont->coords.x1 + lv_obj_get_style_pad_left(cont,
+                                                                   LV_PART_MAIN) + border_width - lv_obj_get_scroll_x(cont);
 
     lv_flex_align_t track_cross_place = f.track_place;
     lv_coord_t * cross_pos = (f.row ? &abs_y : &abs_x);
@@ -232,8 +240,7 @@ static void flex_update(lv_obj_t * cont, void * user_data)
 
     /*Content sized objects should squeezed the gap between the children, therefore any alignment will look like `START`*/
     if((f.row && h_set == LV_SIZE_CONTENT && cont->h_layout == 0) ||
-    	(!f.row && w_set == LV_SIZE_CONTENT && cont->w_layout == 0))
-    {
+       (!f.row && w_set == LV_SIZE_CONTENT && cont->w_layout == 0)) {
         track_cross_place = LV_FLEX_ALIGN_START;
     }
 
@@ -270,7 +277,7 @@ static void flex_update(lv_obj_t * cont, void * user_data)
     track_first_item =  f.rev ? cont->spec_attr->child_cnt - 1 : 0;
 
     if(rtl && !f.row) {
-         *cross_pos += total_track_cross_size;
+        *cross_pos += total_track_cross_size;
     }
 
     while(track_first_item < (int32_t)cont->spec_attr->child_cnt && track_first_item >= 0) {
@@ -288,7 +295,8 @@ static void flex_update(lv_obj_t * cont, void * user_data)
         t.grow_dsc = NULL;
         if(rtl && !f.row) {
             *cross_pos -= gap + track_gap;
-        } else {
+        }
+        else {
             *cross_pos += t.track_cross_size + gap + track_gap;
         }
     }
@@ -306,7 +314,8 @@ static void flex_update(lv_obj_t * cont, void * user_data)
 /**
  * Find the last item of a track
  */
-static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id, lv_coord_t max_main_size, lv_coord_t item_gap, track_t * t)
+static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id, lv_coord_t max_main_size,
+                              lv_coord_t item_gap, track_t * t)
 {
     lv_coord_t w_set = lv_obj_get_style_width(cont, LV_PART_MAIN);
     lv_coord_t h_set = lv_obj_get_style_height(cont, LV_PART_MAIN);
@@ -318,7 +327,6 @@ static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id
     lv_coord_t(*get_main_size)(const lv_obj_t *) = (f->row ? lv_obj_get_width : lv_obj_get_height);
     lv_coord_t(*get_cross_size)(const lv_obj_t *) = (!f->row ? lv_obj_get_width : lv_obj_get_height);
 
-    lv_coord_t grow_sum = 0;
     t->track_main_size = 0;
     t->track_fix_main_size = 0;
     t->grow_item_cnt = 0;
@@ -335,7 +343,6 @@ static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id
         if(!lv_obj_has_flag_any(item, LV_OBJ_FLAG_IGNORE_LAYOUT | LV_OBJ_FLAG_HIDDEN | LV_OBJ_FLAG_FLOATING)) {
             uint8_t grow_value = lv_obj_get_style_flex_grow(item, LV_PART_MAIN);
             if(grow_value) {
-                grow_sum += grow_value;
                 t->grow_item_cnt++;
                 t->track_fix_main_size += item_gap;
                 if(t->grow_dsc_calc) {
@@ -348,13 +355,16 @@ static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id
                         lv_mem_buf_release(t->grow_dsc);
                     }
                     new_dsc[t->grow_item_cnt - 1].item = item;
-                    new_dsc[t->grow_item_cnt - 1].min_size = f->row ? lv_obj_get_style_min_width(item, LV_PART_MAIN) : lv_obj_get_style_min_height(item, LV_PART_MAIN);
-                    new_dsc[t->grow_item_cnt - 1].max_size = f->row ? lv_obj_get_style_max_width(item, LV_PART_MAIN) : lv_obj_get_style_max_height(item, LV_PART_MAIN);
+                    new_dsc[t->grow_item_cnt - 1].min_size = f->row ? lv_obj_get_style_min_width(item,
+                                                                                                 LV_PART_MAIN) : lv_obj_get_style_min_height(item, LV_PART_MAIN);
+                    new_dsc[t->grow_item_cnt - 1].max_size = f->row ? lv_obj_get_style_max_width(item,
+                                                                                                 LV_PART_MAIN) : lv_obj_get_style_max_height(item, LV_PART_MAIN);
                     new_dsc[t->grow_item_cnt - 1].grow_value = grow_value;
                     new_dsc[t->grow_item_cnt - 1].clamped = 0;
                     t->grow_dsc = new_dsc;
                 }
-            } else {
+            }
+            else {
                 lv_coord_t item_size = get_main_size(item);
                 if(f->wrap && t->track_fix_main_size + item_size > max_main_size) break;
                 t->track_fix_main_size += item_size + item_gap;
@@ -392,7 +402,8 @@ static int32_t find_track_end(lv_obj_t * cont, flex_t * f, int32_t item_start_id
 /**
  * Position the children in the same track
  */
-static void children_repos(lv_obj_t * cont, flex_t * f, int32_t item_first_id, int32_t item_last_id, lv_coord_t abs_x, lv_coord_t abs_y, lv_coord_t max_main_size, lv_coord_t item_gap, track_t * t)
+static void children_repos(lv_obj_t * cont, flex_t * f, int32_t item_first_id, int32_t item_last_id, lv_coord_t abs_x,
+                           lv_coord_t abs_y, lv_coord_t max_main_size, lv_coord_t item_gap, track_t * t)
 {
     void (*area_set_main_size)(lv_area_t *, lv_coord_t) = (f->row ? lv_area_set_width : lv_area_set_height);
     lv_coord_t (*area_get_main_size)(const lv_area_t *) = (f->row ? lv_area_get_width : lv_area_get_height);
@@ -408,7 +419,8 @@ static void children_repos(lv_obj_t * cont, flex_t * f, int32_t item_first_id, i
         for(i = 0; i < t->grow_item_cnt; i++) {
             if(t->grow_dsc[i].clamped == 0) {
                 grow_value_sum += t->grow_dsc[i].grow_value;
-            } else {
+            }
+            else {
                 grow_max_size -= t->grow_dsc[i].final_size;
             }
         }
@@ -470,23 +482,24 @@ static void children_repos(lv_obj_t * cont, flex_t * f, int32_t item_first_id, i
                 lv_event_send(lv_obj_get_parent(item), LV_EVENT_CHILD_CHANGED, item);
                 lv_obj_invalidate(item);
             }
-        } else {
+        }
+        else {
             item->w_layout = 0;
             item->h_layout = 0;
         }
 
         lv_coord_t cross_pos = 0;
         switch(f->cross_place) {
-        case LV_FLEX_ALIGN_CENTER:
-            /*Round up the cross size to avoid rounding error when dividing by 2
-             *The issue comes up e,g, with column direction with center cross direction if an element's width changes*/
-            cross_pos = (((t->track_cross_size + 1) & (~1)) - area_get_cross_size(&item->coords)) / 2;
-            break;
-        case LV_FLEX_ALIGN_END:
-            cross_pos = t->track_cross_size - area_get_cross_size(&item->coords);
-            break;
-        default:
-            break;
+            case LV_FLEX_ALIGN_CENTER:
+                /*Round up the cross size to avoid rounding error when dividing by 2
+                 *The issue comes up e,g, with column direction with center cross direction if an element's width changes*/
+                cross_pos = (((t->track_cross_size + 1) & (~1)) - area_get_cross_size(&item->coords)) / 2;
+                break;
+            case LV_FLEX_ALIGN_END:
+                cross_pos = t->track_cross_size - area_get_cross_size(&item->coords);
+                break;
+            default:
+                break;
         }
 
         if(f->row && rtl) main_pos -= area_get_main_size(&item->coords);
@@ -525,7 +538,8 @@ static void children_repos(lv_obj_t * cont, flex_t * f, int32_t item_first_id, i
 /**
  * Tell a start coordinate and gap for a placement type.
  */
-static void place_content(lv_flex_align_t place, lv_coord_t max_size, lv_coord_t content_size, lv_coord_t item_cnt, lv_coord_t * start_pos, lv_coord_t * gap)
+static void place_content(lv_flex_align_t place, lv_coord_t max_size, lv_coord_t content_size, lv_coord_t item_cnt,
+                          lv_coord_t * start_pos, lv_coord_t * gap)
 {
     if(item_cnt <= 1) {
         switch(place) {
@@ -540,27 +554,27 @@ static void place_content(lv_flex_align_t place, lv_coord_t max_size, lv_coord_t
     }
 
     switch(place) {
-    case LV_FLEX_ALIGN_CENTER:
-        *gap = 0;
-        *start_pos += (max_size - content_size) / 2;
-        break;
-    case LV_FLEX_ALIGN_END:
-        *gap = 0;
-        *start_pos += max_size - content_size;
-        break;
-    case LV_FLEX_ALIGN_SPACE_BETWEEN:
-       *gap = (lv_coord_t)(max_size - content_size) / (lv_coord_t)(item_cnt - 1);
-       break;
-   case LV_FLEX_ALIGN_SPACE_AROUND:
-       *gap += (lv_coord_t)(max_size - content_size) / (lv_coord_t)(item_cnt);
-       *start_pos += *gap / 2;
-       break;
-   case LV_FLEX_ALIGN_SPACE_EVENLY:
-       *gap = (lv_coord_t)(max_size - content_size) / (lv_coord_t)(item_cnt + 1);
-       *start_pos += *gap;
-       break;
-   default:
-       *gap = 0;
+        case LV_FLEX_ALIGN_CENTER:
+            *gap = 0;
+            *start_pos += (max_size - content_size) / 2;
+            break;
+        case LV_FLEX_ALIGN_END:
+            *gap = 0;
+            *start_pos += max_size - content_size;
+            break;
+        case LV_FLEX_ALIGN_SPACE_BETWEEN:
+            *gap = (lv_coord_t)(max_size - content_size) / (lv_coord_t)(item_cnt - 1);
+            break;
+        case LV_FLEX_ALIGN_SPACE_AROUND:
+            *gap += (lv_coord_t)(max_size - content_size) / (lv_coord_t)(item_cnt);
+            *start_pos += *gap / 2;
+            break;
+        case LV_FLEX_ALIGN_SPACE_EVENLY:
+            *gap = (lv_coord_t)(max_size - content_size) / (lv_coord_t)(item_cnt + 1);
+            *start_pos += *gap;
+            break;
+        default:
+            *gap = 0;
     }
 }
 
@@ -570,7 +584,8 @@ static lv_obj_t * get_next_item(lv_obj_t * cont, bool rev, int32_t * item_id)
         (*item_id)--;
         if(*item_id >= 0) return cont->spec_attr->children[*item_id];
         else return NULL;
-    } else {
+    }
+    else {
         (*item_id)++;
         if((*item_id) < (int32_t)cont->spec_attr->child_cnt) return cont->spec_attr->children[*item_id];
         else return NULL;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/layouts/flex/lv_flex.h b/lib/libesp32_lvgl/lvgl/src/extra/layouts/flex/lv_flex.h
index 62d3e7f80..139fd4810 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/layouts/flex/lv_flex.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/layouts/flex/lv_flex.h
@@ -41,7 +41,7 @@ typedef enum {
     LV_FLEX_ALIGN_SPACE_EVENLY,
     LV_FLEX_ALIGN_SPACE_AROUND,
     LV_FLEX_ALIGN_SPACE_BETWEEN,
-}lv_flex_align_t;
+} lv_flex_align_t;
 
 typedef enum {
     LV_FLEX_FLOW_ROW                 = 0x00,
@@ -52,7 +52,7 @@ typedef enum {
     LV_FLEX_FLOW_COLUMN_WRAP         = LV_FLEX_FLOW_COLUMN | _LV_FLEX_WRAP,
     LV_FLEX_FLOW_COLUMN_REVERSE      = LV_FLEX_FLOW_COLUMN | _LV_FLEX_REVERSE,
     LV_FLEX_FLOW_COLUMN_WRAP_REVERSE = LV_FLEX_FLOW_COLUMN | _LV_FLEX_WRAP | _LV_FLEX_REVERSE,
-}lv_flex_flow_t;
+} lv_flex_flow_t;
 
 /**********************
  * GLOBAL VARIABLES
@@ -69,7 +69,7 @@ extern lv_style_prop_t LV_STYLE_FLEX_GROW;
  **********************/
 
 /**
- * Initialize a felx layout the default values
+ * Initialize a flex layout the default values
  * @param flex pointer to a flex layout descriptor
  */
 void lv_flex_init(void);
@@ -82,13 +82,14 @@ void lv_flex_init(void);
 void lv_obj_set_flex_flow(lv_obj_t * obj, lv_flex_flow_t flow);
 
 /**
- * Set how to place (where to align) the items an tracks
+ * Set how to place (where to align) the items and tracks
  * @param flex pointer: to a flex layout descriptor
  * @param main_place where to place the items on main axis (in their track). Any value of `lv_flex_align_t`.
  * @param cross_place where to place the item in their track on the cross axis. `LV_FLEX_ALIGN_START/END/CENTER`
  * @param track_place where to place the tracks in the cross direction. Any value of `lv_flex_align_t`.
  */
-void lv_obj_set_flex_align(lv_obj_t * obj, lv_flex_align_t main_place, lv_flex_align_t cross_place, lv_flex_align_t track_cross_place);
+void lv_obj_set_flex_align(lv_obj_t * obj, lv_flex_align_t main_place, lv_flex_align_t cross_place,
+                           lv_flex_align_t track_cross_place);
 
 /**
  * Sets the width or height (on main axis) to grow the object in order fill the free space
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/layouts/grid/lv_grid.c b/lib/libesp32_lvgl/lvgl/src/extra/layouts/grid/lv_grid.c
index 3cd7c689f..027f6af31 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/layouts/grid/lv_grid.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/layouts/grid/lv_grid.c
@@ -27,7 +27,7 @@ typedef struct {
     uint32_t col;
     uint32_t row;
     lv_point_t grid_abs;
-}item_repos_hint_t;
+} item_repos_hint_t;
 
 typedef struct {
     lv_coord_t * x;
@@ -38,7 +38,7 @@ typedef struct {
     uint32_t row_num;
     lv_coord_t grid_w;
     lv_coord_t grid_h;
-}_lv_grid_calc_t;
+} _lv_grid_calc_t;
 
 
 /**********************
@@ -54,19 +54,50 @@ static void calc_free(_lv_grid_calc_t * calc);
 static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * c);
 static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * c);
 static void item_repos(lv_obj_t * item, _lv_grid_calc_t * c, item_repos_hint_t * hint);
-static lv_coord_t grid_align(lv_coord_t cont_size,  bool auto_size, uint8_t align, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array, bool reverse);
+static lv_coord_t grid_align(lv_coord_t cont_size,  bool auto_size, uint8_t align, lv_coord_t gap, uint32_t track_num,
+                             lv_coord_t * size_array, lv_coord_t * pos_array, bool reverse);
 static uint32_t count_tracks(const lv_coord_t * templ);
 
-static inline const lv_coord_t * get_col_dsc(lv_obj_t * obj) {return lv_obj_get_style_grid_column_dsc_array(obj, 0); }
-static inline const lv_coord_t * get_row_dsc(lv_obj_t * obj) {return lv_obj_get_style_grid_row_dsc_array(obj, 0); }
-static inline uint8_t get_col_pos(lv_obj_t * obj) {return lv_obj_get_style_grid_cell_column_pos(obj, 0); }
-static inline uint8_t get_row_pos(lv_obj_t * obj) {return lv_obj_get_style_grid_cell_row_pos(obj, 0); }
-static inline uint8_t get_col_span(lv_obj_t * obj) {return lv_obj_get_style_grid_cell_column_span(obj, 0); }
-static inline uint8_t get_row_span(lv_obj_t * obj) {return lv_obj_get_style_grid_cell_row_span(obj, 0); }
-static inline uint8_t get_cell_col_align(lv_obj_t * obj) {return lv_obj_get_style_grid_cell_x_align(obj, 0); }
-static inline uint8_t get_cell_row_align(lv_obj_t * obj) {return lv_obj_get_style_grid_cell_y_align(obj, 0); }
-static inline uint8_t get_grid_col_align(lv_obj_t * obj) {return lv_obj_get_style_grid_column_align(obj, 0); }
-static inline uint8_t get_grid_row_align(lv_obj_t * obj) {return lv_obj_get_style_grid_row_align(obj, 0); }
+static inline const lv_coord_t * get_col_dsc(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_column_dsc_array(obj, 0);
+}
+static inline const lv_coord_t * get_row_dsc(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_row_dsc_array(obj, 0);
+}
+static inline uint8_t get_col_pos(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_cell_column_pos(obj, 0);
+}
+static inline uint8_t get_row_pos(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_cell_row_pos(obj, 0);
+}
+static inline uint8_t get_col_span(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_cell_column_span(obj, 0);
+}
+static inline uint8_t get_row_span(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_cell_row_span(obj, 0);
+}
+static inline uint8_t get_cell_col_align(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_cell_x_align(obj, 0);
+}
+static inline uint8_t get_cell_row_align(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_cell_y_align(obj, 0);
+}
+static inline uint8_t get_grid_col_align(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_column_align(obj, 0);
+}
+static inline uint8_t get_grid_row_align(lv_obj_t * obj)
+{
+    return lv_obj_get_style_grid_row_align(obj, 0);
+}
 
 /**********************
  *  GLOBAL VARIABLES
@@ -128,7 +159,7 @@ void lv_obj_set_grid_align(lv_obj_t * obj, lv_grid_align_t column_align, lv_grid
 }
 
 void lv_obj_set_grid_cell(lv_obj_t * obj, lv_grid_align_t x_align, uint8_t col_pos, uint8_t col_span,
-                                          lv_grid_align_t y_align, uint8_t row_pos, uint8_t row_span)
+                          lv_grid_align_t y_align, uint8_t row_pos, uint8_t row_span)
 
 {
     lv_obj_set_style_grid_cell_column_pos(obj, col_pos, 0);
@@ -228,7 +259,7 @@ void lv_obj_set_style_grid_row_dsc_array(lv_obj_t * obj, const lv_coord_t value[
     lv_style_value_t v = {
         .ptr = (const void *)value
     };
-    lv_obj_set_local_style_prop(obj,LV_STYLE_GRID_ROW_DSC_ARRAY, v, selector);
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_ROW_DSC_ARRAY, v, selector);
 }
 
 void lv_obj_set_style_grid_column_dsc_array(lv_obj_t * obj, const lv_coord_t value[], lv_style_selector_t selector)
@@ -262,7 +293,7 @@ void lv_obj_set_style_grid_cell_column_pos(lv_obj_t * obj, lv_coord_t value, lv_
     lv_style_value_t v = {
         .num = value
     };
-    lv_obj_set_local_style_prop(obj,LV_STYLE_GRID_CELL_COLUMN_POS, v, selector);
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_COLUMN_POS, v, selector);
 }
 
 void lv_obj_set_style_grid_cell_column_span(lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
@@ -270,7 +301,7 @@ void lv_obj_set_style_grid_cell_column_span(lv_obj_t * obj, lv_coord_t value, lv
     lv_style_value_t v = {
         .num = value
     };
-    lv_obj_set_local_style_prop(obj,LV_STYLE_GRID_CELL_COLUMN_SPAN, v, selector);
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_COLUMN_SPAN, v, selector);
 }
 
 void lv_obj_set_style_grid_cell_row_pos(lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
@@ -278,7 +309,7 @@ void lv_obj_set_style_grid_cell_row_pos(lv_obj_t * obj, lv_coord_t value, lv_sty
     lv_style_value_t v = {
         .num = value
     };
-    lv_obj_set_local_style_prop(obj,LV_STYLE_GRID_CELL_ROW_POS, v, selector);
+    lv_obj_set_local_style_prop(obj, LV_STYLE_GRID_CELL_ROW_POS, v, selector);
 }
 
 void lv_obj_set_style_grid_cell_row_span(lv_obj_t * obj, lv_coord_t value, lv_style_selector_t selector)
@@ -312,7 +343,7 @@ void lv_obj_set_style_grid_cell_y_align(lv_obj_t * obj, lv_coord_t value, lv_sty
 
 static void grid_update(lv_obj_t * cont, void * user_data)
 {
-    LV_LOG_INFO("update %p container", cont);
+    LV_LOG_INFO("update %p container", (void *)cont);
     LV_UNUSED(user_data);
 
     const lv_coord_t * col_templ = get_col_dsc(cont);
@@ -376,11 +407,13 @@ static void calc(lv_obj_t * cont, _lv_grid_calc_t * calc_out)
     lv_coord_t h_set = lv_obj_get_style_height(cont, LV_PART_MAIN);
     bool auto_w = (w_set == LV_SIZE_CONTENT && !cont->w_layout) ? true : false;
     lv_coord_t cont_w = lv_obj_get_content_width(cont);
-    calc_out->grid_w = grid_align(cont_w, auto_w, get_grid_col_align(cont), col_gap, calc_out->col_num, calc_out->w, calc_out->x, rev);
+    calc_out->grid_w = grid_align(cont_w, auto_w, get_grid_col_align(cont), col_gap, calc_out->col_num, calc_out->w,
+                                  calc_out->x, rev);
 
     bool auto_h = (h_set == LV_SIZE_CONTENT && !cont->h_layout) ? true : false;
     lv_coord_t cont_h = lv_obj_get_content_height(cont);
-    calc_out->grid_h = grid_align(cont_h, auto_h, get_grid_row_align(cont), row_gap, calc_out->row_num, calc_out->h, calc_out->y, false);
+    calc_out->grid_h = grid_align(cont_h, auto_h, get_grid_row_align(cont), row_gap, calc_out->row_num, calc_out->h,
+                                  calc_out->y, false);
 
     LV_ASSERT_MEM_INTEGRITY();
 }
@@ -437,7 +470,7 @@ static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * c)
         if(IS_FR(x)) {
             col_fr_cnt += GET_FR(x);
         }
-        else if (IS_CONTENT(x)) {
+        else if(IS_CONTENT(x)) {
             grid_w += c->w[i];
         }
         else {
@@ -465,7 +498,7 @@ static void calc_cols(lv_obj_t * cont, _lv_grid_calc_t * c)
 
     /*To avoid rounding errors set the last FR track to the remaining size */
     if(last_fr_i >= 0) {
-    	c->w[last_fr_i] = free_w - ((free_w * (col_fr_cnt - last_fr_x)) / col_fr_cnt);
+        c->w[last_fr_i] = free_w - ((free_w * (col_fr_cnt - last_fr_x)) / col_fr_cnt);
     }
 }
 
@@ -505,9 +538,11 @@ static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * c)
         lv_coord_t x = row_templ[i];
         if(IS_FR(x)) {
             row_fr_cnt += GET_FR(x);
-        } else if (IS_CONTENT(x)) {
+        }
+        else if(IS_CONTENT(x)) {
             grid_h += c->h[i];
-        } else {
+        }
+        else {
             c->h[i] = x;
             grid_h += x;
         }
@@ -531,7 +566,7 @@ static void calc_rows(lv_obj_t * cont, _lv_grid_calc_t * c)
 
     /*To avoid rounding errors set the last FR track to the remaining size */
     if(last_fr_i >= 0) {
-    	c->h[last_fr_i] = free_h - ((free_h * (row_fr_cnt - last_fr_x)) / row_fr_cnt);
+        c->h[last_fr_i] = free_h - ((free_h * (row_fr_cnt - last_fr_x)) / row_fr_cnt);
     }
 }
 
@@ -666,14 +701,16 @@ static void item_repos(lv_obj_t * item, _lv_grid_calc_t * c, item_repos_hint_t *
  * @param pos_array write the positions of the tracks here
  * @return the total size of the grid
  */
-static lv_coord_t grid_align(lv_coord_t cont_size,  bool auto_size, uint8_t align, lv_coord_t gap, uint32_t track_num, lv_coord_t * size_array, lv_coord_t * pos_array, bool reverse)
+static lv_coord_t grid_align(lv_coord_t cont_size,  bool auto_size, uint8_t align, lv_coord_t gap, uint32_t track_num,
+                             lv_coord_t * size_array, lv_coord_t * pos_array, bool reverse)
 {
     lv_coord_t grid_size = 0;
     uint32_t i;
 
     if(auto_size) {
         pos_array[0] = 0;
-    } else {
+    }
+    else {
         /*With spaced alignment gap will be calculated from the remaining space*/
         if(align == LV_GRID_ALIGN_SPACE_AROUND || align == LV_GRID_ALIGN_SPACE_BETWEEN || align == LV_GRID_ALIGN_SPACE_EVENLY) {
             gap = 0;
@@ -688,27 +725,27 @@ static lv_coord_t grid_align(lv_coord_t cont_size,  bool auto_size, uint8_t alig
 
         /*Calculate the position of the first item and set gap is necessary*/
         switch(align) {
-        case LV_GRID_ALIGN_START:
-            pos_array[0] = 0;
-            break;
-        case LV_GRID_ALIGN_CENTER:
-            pos_array[0] = (cont_size - grid_size) / 2;
-            break;
-        case LV_GRID_ALIGN_END:
-            pos_array[0] = cont_size - grid_size;
-            break;
-        case LV_GRID_ALIGN_SPACE_BETWEEN:
-            pos_array[0] = 0;
-            gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num - 1);
-            break;
-        case LV_GRID_ALIGN_SPACE_AROUND:
-            gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num);
-            pos_array[0] = gap / 2;
-            break;
-        case LV_GRID_ALIGN_SPACE_EVENLY:
-            gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num + 1);
-            pos_array[0] = gap;
-            break;
+            case LV_GRID_ALIGN_START:
+                pos_array[0] = 0;
+                break;
+            case LV_GRID_ALIGN_CENTER:
+                pos_array[0] = (cont_size - grid_size) / 2;
+                break;
+            case LV_GRID_ALIGN_END:
+                pos_array[0] = cont_size - grid_size;
+                break;
+            case LV_GRID_ALIGN_SPACE_BETWEEN:
+                pos_array[0] = 0;
+                gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num - 1);
+                break;
+            case LV_GRID_ALIGN_SPACE_AROUND:
+                gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num);
+                pos_array[0] = gap / 2;
+                break;
+            case LV_GRID_ALIGN_SPACE_EVENLY:
+                gap = (lv_coord_t)(cont_size - grid_size) / (lv_coord_t)(track_num + 1);
+                pos_array[0] = gap;
+                break;
 
         }
     }
@@ -734,7 +771,7 @@ static lv_coord_t grid_align(lv_coord_t cont_size,  bool auto_size, uint8_t alig
 static uint32_t count_tracks(const lv_coord_t * templ)
 {
     uint32_t i;
-    for(i = 0; templ[i] != LV_COORD_MAX; i++);
+    for(i = 0; templ[i] != LV_GRID_TEMPLATE_LAST; i++);
 
     return i;
 }
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/layouts/grid/lv_grid.h b/lib/libesp32_lvgl/lvgl/src/extra/layouts/grid/lv_grid.h
index f2966d0d9..cd2510ec0 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/layouts/grid/lv_grid.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/layouts/grid/lv_grid.h
@@ -47,7 +47,7 @@ typedef enum {
     LV_GRID_ALIGN_SPACE_EVENLY,
     LV_GRID_ALIGN_SPACE_AROUND,
     LV_GRID_ALIGN_SPACE_BETWEEN,
-}lv_grid_align_t;
+} lv_grid_align_t;
 
 /**********************
  * GLOBAL VARIABLES
@@ -78,15 +78,15 @@ void lv_obj_set_grid_align(lv_obj_t * obj, lv_grid_align_t column_align, lv_grid
 /**
  * Set the cell of an object. The object's parent needs to have grid layout, else nothing will happen
  * @param obj pointer to an object
- * @param hor_place the vertical alignment in the cell. `LV_GRID_START/END/CENTER/STRETCH`
+ * @param column_align the vertical alignment in the cell. `LV_GRID_START/END/CENTER/STRETCH`
  * @param col_pos column ID
  * @param col_span number of columns to take (>= 1)
- * @param ver_place the horizontal alignment in the cell. `LV_GRID_START/END/CENTER/STRETCH`
+ * @param row_align the horizontal alignment in the cell. `LV_GRID_START/END/CENTER/STRETCH`
  * @param row_pos row ID
  * @param row_span number of rows to take (>= 1)
  */
 void lv_obj_set_grid_cell(lv_obj_t * obj, lv_grid_align_t column_align, uint8_t col_pos, uint8_t col_span,
-                                          lv_grid_align_t row_align, uint8_t row_pos, uint8_t row_span);
+                          lv_grid_align_t row_align, uint8_t row_pos, uint8_t row_span);
 
 /**
  * Just a wrapper to `LV_GRID_FR` for bindings.
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/layouts/lv_layouts.h b/lib/libesp32_lvgl/lvgl/src/extra/layouts/lv_layouts.h
index 0ad7b75b3..9c1e958d6 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/layouts/lv_layouts.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/layouts/lv_layouts.h
@@ -32,7 +32,7 @@ extern "C" {
  *      MACROS
  **********************/
 #if LV_USE_LOG && LV_LOG_TRACE_LAYOUT
-#  define LV_TRACE_LAYOUT(...) LV_LOG_TRACE( __VA_ARGS__)
+#  define LV_TRACE_LAYOUT(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
 #  define LV_TRACE_LAYOUT(...)
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_fatfs.c b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_fatfs.c
new file mode 100644
index 000000000..157a778ed
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_fatfs.c
@@ -0,0 +1,276 @@
+/**
+ * @file lv_fs_fatfs.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lvgl.h"
+
+#if LV_USE_FS_FATFS != '\0'
+#include "ff.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void fs_init(void);
+
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_fs_fatfs_init(void)
+{
+    /*----------------------------------------------------
+     * Initialize your storage device and File System
+     * -------------------------------------------------*/
+    fs_init();
+
+    /*---------------------------------------------------
+     * Register the file system interface in LittlevGL
+     *--------------------------------------------------*/
+
+    /*Add a simple drive to open images*/
+    static lv_fs_drv_t fs_drv; /*A driver descriptor*/
+    lv_fs_drv_init(&fs_drv);
+
+    /*Set up fields...*/
+    fs_drv.letter = LV_USE_FS_FATFS;
+    fs_drv.open_cb = fs_open;
+    fs_drv.close_cb = fs_close;
+    fs_drv.read_cb = fs_read;
+    fs_drv.write_cb = fs_write;
+    fs_drv.seek_cb = fs_seek;
+    fs_drv.tell_cb = fs_tell;
+
+    fs_drv.dir_close_cb = fs_dir_close;
+    fs_drv.dir_open_cb = fs_dir_open;
+    fs_drv.dir_read_cb = fs_dir_read;
+
+    lv_fs_drv_register(&fs_drv);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/*Initialize your Storage device and File system.*/
+static void fs_init(void)
+{
+    /*Initialize the SD card and FatFS itself.
+     *Better to do it in your code to keep this library untouched for easy updating*/
+}
+
+/**
+ * Open a file
+ * @param drv pointer to a driver where this function belongs
+ * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return pointer to FIL struct or NULL in case of fail
+ */
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
+{
+    LV_UNUSED(drv);
+    uint8_t flags = 0;
+
+    if(mode == LV_FS_MODE_WR) flags = FA_WRITE | FA_OPEN_ALWAYS;
+    else if(mode == LV_FS_MODE_RD) flags = FA_READ;
+    else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = FA_READ | FA_WRITE | FA_OPEN_ALWAYS;
+
+    FIL * f = lv_mem_alloc(sizeof(FIL));
+    if(f == NULL) return NULL;
+
+    FRESULT res = f_open(f, path, flags);
+    if(res == FR_OK) {
+        return f;
+    } else {
+        lv_mem_free(f);
+        return NULL;
+    }
+}
+
+/**
+ * Close an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FIL variable. (opened with fs_open)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
+{
+    LV_UNUSED(drv);
+    f_close(file_p);
+    lv_mem_free(file_p);
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Read data from an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FIL variable.
+ * @param buf pointer to a memory block where to store the read data
+ * @param btr number of Bytes To Read
+ * @param br the real number of read bytes (Byte Read)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
+{
+    LV_UNUSED(drv);
+    FRESULT res = f_read(file_p, buf, btr, (UINT *)br);
+    if(res == FR_OK) return LV_FS_RES_OK;
+    else return LV_FS_RES_UNKNOWN;
+}
+
+/**
+ * Write into a file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FIL variable
+ * @param buf pointer to a buffer with the bytes to write
+ * @param btr Bytes To Write
+ * @param br the number of real written bytes (Bytes Written). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+{
+    LV_UNUSED(drv);
+    FRESULT res = f_write(file_p, buf, btw, (UINT *)bw);
+    if(res == FR_OK) return LV_FS_RES_OK;
+    else return LV_FS_RES_UNKNOWN;
+}
+
+/**
+ * Set the read write pointer. Also expand the file size if necessary.
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FIL variable. (opened with fs_open )
+ * @param pos the new position of read write pointer
+ * @param whence only LV_SEEK_SET is supported
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
+{
+    LV_UNUSED(drv);
+    switch (whence) {
+    case LV_FS_SEEK_SET:
+        f_lseek(file_p, pos);
+        break;
+    case LV_FS_SEEK_CUR:
+        f_lseek(file_p, f_tell(file_p) + pos);
+        break;
+    case LV_FS_SEEK_END:
+        f_lseek(file_p, f_size(file_p) + pos);
+        break;
+    default:
+        break;
+    }
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Give the position of the read write pointer
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FIL variable.
+ * @param pos_p pointer to to store the result
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
+{
+    LV_UNUSED(drv);
+    *pos_p = f_tell(file_p);
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Initialize a 'DIR' variable for directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param path path to a directory
+ * @return pointer to an initialized 'DIR' variable
+ */
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
+{
+    LV_UNUSED(drv);
+    DIR * d = lv_mem_alloc(sizeof(DIR));
+    if(d == NULL) return NULL;
+
+    FRESULT res = f_opendir(d, path);
+    if(res != FR_OK) {
+        lv_mem_free(d);
+        d = NULL;
+    }
+    return d;
+}
+
+/**
+ * Read the next filename from a directory.
+ * The name of the directories will begin with '/'
+ * @param drv pointer to a driver where this function belongs
+ * @param dir_p pointer to an initialized 'DIR' variable
+ * @param fn pointer to a buffer to store the filename
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn)
+{
+    LV_UNUSED(drv);
+    FRESULT res;
+    FILINFO fno;
+    fn[0] = '\0';
+
+    do {
+        res = f_readdir(dir_p, &fno);
+        if(res != FR_OK) return LV_FS_RES_UNKNOWN;
+
+        if(fno.fattrib & AM_DIR) {
+            fn[0] = '/';
+            strcpy(&fn[1], fno.fname);
+        }
+        else strcpy(fn, fno.fname);
+
+    } while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Close the directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param dir_p pointer to an initialized 'DIR' variable
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p)
+{
+    LV_UNUSED(drv);
+    f_closedir(dir_p);
+    lv_mem_free(dir_p);
+    return LV_FS_RES_OK;
+}
+
+#endif  /*LV_USE_FS_FATFS*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_posix.c b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_posix.c
new file mode 100644
index 000000000..85985bcb0
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_posix.c
@@ -0,0 +1,313 @@
+/**
+ * @file lv_fs_posix.c
+ *
+ */
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lvgl.h"
+#if LV_USE_FS_POSIX != '\0'
+
+#include <fcntl.h>
+#include <stdio.h>
+#ifndef WIN32
+#include <dirent.h>
+#include <unistd.h>
+#else
+#include <windows.h>
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Register a driver for the File system interface
+ */
+void lv_fs_posix_init(void)
+{
+    /*---------------------------------------------------
+     * Register the file system interface in LittlevGL
+     *--------------------------------------------------*/
+
+    /*Add a simple drive to open images*/
+    static lv_fs_drv_t fs_drv; /*A driver descriptor*/
+    lv_fs_drv_init(&fs_drv);
+
+    /*Set up fields...*/
+    fs_drv.letter = LV_USE_FS_POSIX;
+    fs_drv.open_cb = fs_open;
+    fs_drv.close_cb = fs_close;
+    fs_drv.read_cb = fs_read;
+    fs_drv.write_cb = fs_write;
+    fs_drv.seek_cb = fs_seek;
+    fs_drv.tell_cb = fs_tell;
+
+    fs_drv.dir_close_cb = fs_dir_close;
+    fs_drv.dir_open_cb = fs_dir_open;
+    fs_drv.dir_read_cb = fs_dir_read;
+
+    lv_fs_drv_register(&fs_drv);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Open a file
+ * @param drv pointer to a driver where this function belongs
+ * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return a file handle or -1 in case of fail
+ */
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
+{
+    LV_UNUSED(drv);
+
+    uint32_t flags = 0;
+    if(mode == LV_FS_MODE_WR) flags = O_WRONLY;
+    else if(mode == LV_FS_MODE_RD) flags = O_RDONLY;
+    else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = O_RDWR;
+
+#ifdef LV_FS_POSIX_PATH
+    /*Make the path relative to the current directory (the projects root folder)*/
+    char buf[256];
+    sprintf(buf, LV_FS_POSIX_PATH "%s", path);
+
+    int f = open(buf, flags);
+#else
+    int f = open(path, flags);
+#endif
+    if(f < 0) return NULL;
+
+    return (void *)(lv_uintptr_t)f;
+}
+
+/**
+ * Close an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p a file handle. (opened with fs_open)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
+{
+    LV_UNUSED(drv);
+    close((lv_uintptr_t)file_p);
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Read data from an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p a file handle variable.
+ * @param buf pointer to a memory block where to store the read data
+ * @param btr number of Bytes To Read
+ * @param br the real number of read bytes (Byte Read)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
+{
+    LV_UNUSED(drv);
+    *br = read((lv_uintptr_t)file_p, buf, btr);
+    return (int32_t)*br < 0 ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
+}
+
+/**
+ * Write into a file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p a file handle variable
+ * @param buf pointer to a buffer with the bytes to write
+ * @param btr Bytes To Write
+ * @param br the number of real written bytes (Bytes Written). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+{
+    LV_UNUSED(drv);
+    *bw = write((lv_uintptr_t)file_p, buf, btw);
+    return (int32_t)*bw < 0 ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
+}
+
+/**
+ * Set the read write pointer. Also expand the file size if necessary.
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p a file handle variable. (opened with fs_open )
+ * @param pos the new position of read write pointer
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
+{
+    LV_UNUSED(drv);
+    lseek((lv_uintptr_t)file_p, pos, whence);
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Give the position of the read write pointer
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p a file handle variable.
+ * @param pos_p pointer to to store the result
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
+{
+    LV_UNUSED(drv);
+    *pos_p = lseek((lv_uintptr_t)file_p, 0, SEEK_CUR);
+    return LV_FS_RES_OK;
+}
+
+#ifdef WIN32
+static char next_fn[256];
+#endif
+
+/**
+ * Initialize a 'fs_read_dir_t' variable for directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param path path to a directory
+ * @return pointer to an initialized 'DIR' or 'HANDLE' variable
+ */
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
+{
+    LV_UNUSED(drv);
+
+#ifndef WIN32
+# ifdef LV_FS_POSIX_PATH
+    /*Make the path relative to the current directory (the projects root folder)*/
+    char buf[256];
+    sprintf(buf, LV_FS_POSIX_PATH "%s", path);
+    return opendir(buf);
+# else
+    return opendir(path);
+# endif
+#else
+    HANDLE d = INVALID_HANDLE_VALUE;
+    WIN32_FIND_DATA fdata;
+
+    /*Make the path relative to the current directory (the projects root folder)*/
+    char buf[256];
+# ifdef LV_FS_POSIX_PATH
+    sprintf(buf, LV_FS_POSIX_PATH "%s\\*", path);
+# else
+    sprintf(buf, "%s\\*", path);
+# endif
+
+    strcpy(next_fn, "");
+    d = FindFirstFile(buf, &fdata);
+    do {
+        if (strcmp(fdata.cFileName, ".") == 0 || strcmp(fdata.cFileName, "..") == 0) {
+            continue;
+        } else {
+            if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+                sprintf(next_fn, "/%s", fdata.cFileName);
+            } else {
+                sprintf(next_fn, "%s", fdata.cFileName);
+            }
+            break;
+        }
+    } while(FindNextFileA(d, &fdata));
+
+    return d;
+#endif
+}
+
+/**
+ * Read the next filename from a directory.
+ * The name of the directories will begin with '/'
+ * @param drv pointer to a driver where this function belongs
+ * @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
+ * @param fn pointer to a buffer to store the filename
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn)
+{
+    LV_UNUSED(drv);
+
+#ifndef WIN32
+    struct dirent *entry;
+    do {
+        entry = readdir(dir_p);
+        if(entry) {
+            if(entry->d_type == DT_DIR) sprintf(fn, "/%s", entry->d_name);
+            else strcpy(fn, entry->d_name);
+        } else {
+            strcpy(fn, "");
+        }
+    } while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);
+#else
+    strcpy(fn, next_fn);
+
+    strcpy(next_fn, "");
+    WIN32_FIND_DATA fdata;
+
+    if(FindNextFile(dir_p, &fdata) == false) return LV_FS_RES_OK;
+    do {
+        if (strcmp(fdata.cFileName, ".") == 0 || strcmp(fdata.cFileName, "..") == 0) {
+            continue;
+        } else {
+            if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+                sprintf(next_fn, "/%s", fdata.cFileName);
+            } else {
+                sprintf(next_fn, "%s", fdata.cFileName);
+            }
+            break;
+        }
+    } while(FindNextFile(dir_p, &fdata));
+
+#endif
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Close the directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p)
+{
+    LV_UNUSED(drv);
+#ifndef WIN32
+    closedir(dir_p);
+#else
+    FindClose(dir_p);
+#endif
+    return LV_FS_RES_OK;
+}
+
+#endif /*LV_USE_FS_POSIX*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_stdio.c b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_stdio.c
new file mode 100644
index 000000000..193741b20
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_stdio.c
@@ -0,0 +1,310 @@
+/**
+ * @file lv_fs_stdio.c
+ *
+ */
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lvgl.h"
+#if LV_USE_FS_STDIO != '\0'
+
+#include <stdio.h>
+#ifndef WIN32
+#include <dirent.h>
+#include <unistd.h>
+#else
+#include <windows.h>
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Register a driver for the File system interface
+ */
+void lv_fs_stdio_init(void)
+{
+    /*---------------------------------------------------
+     * Register the file system interface in LittlevGL
+     *--------------------------------------------------*/
+
+    /*Add a simple drive to open images*/
+    static lv_fs_drv_t fs_drv; /*A driver descriptor*/
+    lv_fs_drv_init(&fs_drv);
+
+    /*Set up fields...*/
+    fs_drv.letter = LV_USE_FS_STDIO;
+    fs_drv.open_cb = fs_open;
+    fs_drv.close_cb = fs_close;
+    fs_drv.read_cb = fs_read;
+    fs_drv.write_cb = fs_write;
+    fs_drv.seek_cb = fs_seek;
+    fs_drv.tell_cb = fs_tell;
+
+    fs_drv.dir_close_cb = fs_dir_close;
+    fs_drv.dir_open_cb = fs_dir_open;
+    fs_drv.dir_read_cb = fs_dir_read;
+
+    lv_fs_drv_register(&fs_drv);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Open a file
+ * @param drv pointer to a driver where this function belongs
+ * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return pointer to FIL struct or NULL in case of fail
+ */
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
+{
+    LV_UNUSED(drv);
+
+    const char * flags = "";
+
+    if(mode == LV_FS_MODE_WR) flags = "wb";
+    else if(mode == LV_FS_MODE_RD) flags = "rb";
+    else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = "rb+";
+
+#ifdef LV_FS_STDIO_PATH
+    /*Make the path relative to the current directory (the projects root folder)*/
+
+    char buf[256];
+    sprintf(buf, LV_FS_STDIO_PATH "%s", path);
+
+    return fopen(buf, flags);
+#else
+    return fopen(path, flags);
+#endif
+}
+
+/**
+ * Close an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable. (opened with fs_open)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
+{
+    LV_UNUSED(drv);
+    fclose(file_p);
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Read data from an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable.
+ * @param buf pointer to a memory block where to store the read data
+ * @param btr number of Bytes To Read
+ * @param br the real number of read bytes (Byte Read)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
+{
+    LV_UNUSED(drv);
+    *br = fread(buf, 1, btr, file_p);
+    return (int32_t)*br < 0 ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
+}
+
+/**
+ * Write into a file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable
+ * @param buf pointer to a buffer with the bytes to write
+ * @param btr Bytes To Write
+ * @param br the number of real written bytes (Bytes Written). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+{
+    LV_UNUSED(drv);
+    *bw = fwrite(buf, 1, btw, file_p);
+    return (int32_t)*bw < 0 ? LV_FS_RES_UNKNOWN : LV_FS_RES_OK;
+}
+
+/**
+ * Set the read write pointer. Also expand the file size if necessary.
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable. (opened with fs_open )
+ * @param pos the new position of read write pointer
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
+{
+    LV_UNUSED(drv);
+    fseek(file_p, pos, whence);
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Give the position of the read write pointer
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable.
+ * @param pos_p pointer to to store the result
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
+{
+    LV_UNUSED(drv);
+    *pos_p = ftell(file_p);
+    return LV_FS_RES_OK;
+}
+
+#ifdef WIN32
+static char next_fn[256];
+#endif
+
+/**
+ * Initialize a 'DIR' or 'HANDLE' variable for directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param path path to a directory
+ * @return pointer to an initialized 'DIR' or 'HANDLE' variable
+ */
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
+{
+    LV_UNUSED(drv);
+#ifndef WIN32
+# ifdef LV_FS_STDIO_PATH
+    /*Make the path relative to the current directory (the projects root folder)*/
+    char buf[256];
+    sprintf(buf, LV_FS_STDIO_PATH "%s", path);
+    return opendir(buf);
+# else
+    return opendir(path);
+# endif
+#else
+    HANDLE d = INVALID_HANDLE_VALUE;
+    WIN32_FIND_DATA fdata;
+
+    /*Make the path relative to the current directory (the projects root folder)*/
+    char buf[256];
+# ifdef LV_FS_STDIO_PATH
+    sprintf(buf, LV_FS_STDIO_PATH "%s\\*", path);
+# else
+    sprintf(buf, "%s\\*", path);
+# endif
+
+    strcpy(next_fn, "");
+    d = FindFirstFile(buf, &fdata);
+    do {
+        if (strcmp(fdata.cFileName, ".") == 0 || strcmp(fdata.cFileName, "..") == 0) {
+            continue;
+        } else {
+            if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+                sprintf(next_fn, "/%s", fdata.cFileName);
+            } else {
+                sprintf(next_fn, "%s", fdata.cFileName);
+            }
+            break;
+        }
+    } while(FindNextFileA(d, &fdata));
+
+    return d;
+#endif
+}
+
+/**
+ * Read the next filename form a directory.
+ * The name of the directories will begin with '/'
+ * @param drv pointer to a driver where this function belongs
+ * @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
+ * @param fn pointer to a buffer to store the filename
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn)
+{
+    LV_UNUSED(drv);
+
+#ifndef WIN32
+    struct dirent *entry;
+    do {
+        entry = readdir(dir_p);
+        if(entry) {
+            if(entry->d_type == DT_DIR) sprintf(fn, "/%s", entry->d_name);
+            else strcpy(fn, entry->d_name);
+        } else {
+            strcpy(fn, "");
+        }
+    } while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);
+#else
+    strcpy(fn, next_fn);
+
+    strcpy(next_fn, "");
+    WIN32_FIND_DATA fdata;
+
+    if(FindNextFile(dir_p, &fdata) == false) return LV_FS_RES_OK;
+    do {
+        if (strcmp(fdata.cFileName, ".") == 0 || strcmp(fdata.cFileName, "..") == 0) {
+            continue;
+        } else {
+            if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+                sprintf(next_fn, "/%s", fdata.cFileName);
+            } else {
+                sprintf(next_fn, "%s", fdata.cFileName);
+            }
+            break;
+        }
+    } while(FindNextFile(dir_p, &fdata));
+
+#endif
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Close the directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p)
+{
+    LV_UNUSED(drv);
+#ifndef WIN32
+    closedir(dir_p);
+#else
+    FindClose(dir_p);
+#endif
+    return LV_FS_RES_OK;
+}
+
+#endif /*LV_USE_FS_STDIO*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_win32.c b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_win32.c
new file mode 100644
index 000000000..72ef22a70
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_win32.c
@@ -0,0 +1,451 @@
+/**
+ * @file lv_fs_win32.c
+ *
+ */
+
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lvgl.h"
+#if LV_USE_FS_WIN32 != '\0'
+
+#include <windows.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static bool is_dots_name(const char * name);
+static lv_fs_res_t fs_error_from_win32(DWORD error);
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p);
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence);
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path);
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn);
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Register a driver for the File system interface
+ */
+void lv_fs_win32_init(void)
+{
+    /*---------------------------------------------------
+     * Register the file system interface in LittlevGL
+     *--------------------------------------------------*/
+
+    /*Add a simple drive to open images*/
+    static lv_fs_drv_t fs_drv; /*A driver descriptor*/
+    lv_fs_drv_init(&fs_drv);
+
+    /*Set up fields...*/
+    fs_drv.letter = LV_USE_FS_WIN32;
+    fs_drv.open_cb = fs_open;
+    fs_drv.close_cb = fs_close;
+    fs_drv.read_cb = fs_read;
+    fs_drv.write_cb = fs_write;
+    fs_drv.seek_cb = fs_seek;
+    fs_drv.tell_cb = fs_tell;
+
+    fs_drv.dir_close_cb = fs_dir_close;
+    fs_drv.dir_open_cb = fs_dir_open;
+    fs_drv.dir_read_cb = fs_dir_read;
+
+    lv_fs_drv_register(&fs_drv);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/**
+ * Check the dots name
+ * @param name file or dir name
+ * @return true if the name is dots name
+ */
+static bool is_dots_name(const char * name)
+{
+    return name[0] == '.' && (!name[1] || (name[1] == '.' && !name[2]));
+}
+
+/**
+ * Convert Win32 error code to error from lv_fs_res_t enum
+ * @param error Win32 error code
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_error_from_win32(DWORD error)
+{
+    lv_fs_res_t res;
+
+    switch (error) {
+        case ERROR_SUCCESS:
+            res = LV_FS_RES_OK;
+            break;
+        case ERROR_BAD_UNIT:
+        case ERROR_NOT_READY:
+        case ERROR_CRC:
+        case ERROR_SEEK:
+        case ERROR_NOT_DOS_DISK:
+        case ERROR_WRITE_FAULT:
+        case ERROR_READ_FAULT:
+        case ERROR_GEN_FAILURE:
+        case ERROR_WRONG_DISK:
+            res = LV_FS_RES_HW_ERR;
+            break;
+        case ERROR_INVALID_HANDLE:
+        case ERROR_INVALID_TARGET_HANDLE:
+            res = LV_FS_RES_FS_ERR;
+            break;
+        case ERROR_FILE_NOT_FOUND:
+        case ERROR_PATH_NOT_FOUND:
+        case ERROR_INVALID_DRIVE:
+        case ERROR_NO_MORE_FILES:
+        case ERROR_SECTOR_NOT_FOUND:
+        case ERROR_BAD_NETPATH:
+        case ERROR_BAD_NET_NAME:
+        case ERROR_BAD_PATHNAME:
+        case ERROR_FILENAME_EXCED_RANGE:
+            res = LV_FS_RES_NOT_EX;
+            break;
+        case ERROR_DISK_FULL:
+            res = LV_FS_RES_FULL;
+            break;
+        case ERROR_SHARING_VIOLATION:
+        case ERROR_LOCK_VIOLATION:
+        case ERROR_DRIVE_LOCKED:
+            res = LV_FS_RES_LOCKED;
+            break;
+        case ERROR_ACCESS_DENIED:
+        case ERROR_CURRENT_DIRECTORY:
+        case ERROR_WRITE_PROTECT:
+        case ERROR_NETWORK_ACCESS_DENIED:
+        case ERROR_CANNOT_MAKE:
+        case ERROR_FAIL_I24:
+        case ERROR_SEEK_ON_DEVICE:
+        case ERROR_NOT_LOCKED:
+        case ERROR_LOCK_FAILED:
+            res = LV_FS_RES_DENIED;
+            break;
+        case ERROR_BUSY:
+            res = LV_FS_RES_BUSY;
+            break;
+        case ERROR_TIMEOUT:
+            res = LV_FS_RES_TOUT;
+            break;
+        case ERROR_NOT_SAME_DEVICE:
+        case ERROR_DIRECT_ACCESS_HANDLE:
+            res = LV_FS_RES_NOT_IMP;
+            break;
+        case ERROR_TOO_MANY_OPEN_FILES:
+        case ERROR_ARENA_TRASHED:
+        case ERROR_NOT_ENOUGH_MEMORY:
+        case ERROR_INVALID_BLOCK:
+        case ERROR_OUT_OF_PAPER:
+        case ERROR_SHARING_BUFFER_EXCEEDED:
+        case ERROR_NOT_ENOUGH_QUOTA:
+            res = LV_FS_RES_OUT_OF_MEM;
+            break;
+        case ERROR_INVALID_FUNCTION:
+        case ERROR_INVALID_ACCESS:
+        case ERROR_INVALID_DATA:
+        case ERROR_BAD_COMMAND:
+        case ERROR_BAD_LENGTH:
+        case ERROR_INVALID_PARAMETER:
+        case ERROR_NEGATIVE_SEEK:
+            res = LV_FS_RES_INV_PARAM;
+            break;
+        default:
+            res = LV_FS_RES_UNKNOWN;
+            break;
+    }
+
+    return res;
+}
+
+/**
+ * Open a file
+ * @param drv pointer to a driver where this function belongs
+ * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return pointer to FIL struct or NULL in case of fail
+ */
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
+{
+    LV_UNUSED(drv);
+
+    DWORD desired_access = 0;
+
+    if (mode & LV_FS_MODE_RD) {
+        desired_access |= GENERIC_READ;
+    }
+
+    if (mode & LV_FS_MODE_WR) {
+        desired_access |= GENERIC_WRITE;
+    }
+
+#ifdef LV_FS_WIN32_PATH
+    /*Make the path relative to the current directory (the projects root folder)*/
+
+    char buf[MAX_PATH];
+    sprintf(buf, LV_FS_WIN32_PATH "%s", path);
+#endif
+
+    return (void*)CreateFileA(
+#ifdef LV_FS_WIN32_PATH
+        buf,
+#else
+        path,
+#endif
+        desired_access,
+        FILE_SHARE_READ,
+        NULL,
+        OPEN_EXISTING,
+        FILE_ATTRIBUTE_NORMAL,
+        NULL);
+}
+
+/**
+ * Close an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable. (opened with fs_open)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
+{
+    LV_UNUSED(drv);
+    return CloseHandle((HANDLE)file_p)
+        ? LV_FS_RES_OK
+        : fs_error_from_win32(GetLastError());
+}
+
+/**
+ * Read data from an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable.
+ * @param buf pointer to a memory block where to store the read data
+ * @param btr number of Bytes To Read
+ * @param br the real number of read bytes (Byte Read)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
+{
+    LV_UNUSED(drv);
+    return ReadFile((HANDLE)file_p, buf, btr, (LPDWORD)br, NULL)
+        ? LV_FS_RES_OK
+        : fs_error_from_win32(GetLastError());
+}
+
+/**
+ * Write into a file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable
+ * @param buf pointer to a buffer with the bytes to write
+ * @param btr Bytes To Write
+ * @param br the number of real written bytes (Bytes Written). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+{
+    LV_UNUSED(drv);
+    return WriteFile((HANDLE)file_p, buf, btw, (LPDWORD)bw, NULL)
+        ? LV_FS_RES_OK
+        : fs_error_from_win32(GetLastError());
+}
+
+/**
+ * Set the read write pointer. Also expand the file size if necessary.
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable. (opened with fs_open )
+ * @param pos the new position of read write pointer
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, lv_fs_whence_t whence)
+{
+    LV_UNUSED(drv);
+
+    DWORD move_method = (DWORD)-1;
+    if (whence == LV_FS_SEEK_SET) {
+        move_method = FILE_BEGIN;
+    }
+    else if(whence == LV_FS_SEEK_CUR) {
+        move_method = FILE_CURRENT;
+    }
+    else if(whence == LV_FS_SEEK_END) {
+        move_method = FILE_END;
+    }
+
+    LARGE_INTEGER distance_to_move;
+    distance_to_move.QuadPart = pos;
+    return SetFilePointerEx((HANDLE)file_p, distance_to_move, NULL, move_method)
+        ? LV_FS_RES_OK
+        : fs_error_from_win32(GetLastError());
+}
+
+/**
+ * Give the position of the read write pointer
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a FILE variable.
+ * @param pos_p pointer to to store the result
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
+{
+    LV_UNUSED(drv);
+
+    if (!pos_p) {
+        return LV_FS_RES_INV_PARAM;
+    }
+
+    LARGE_INTEGER file_pointer;
+    file_pointer.QuadPart = 0;
+
+    LARGE_INTEGER distance_to_move;
+    distance_to_move.QuadPart = 0;
+    if (SetFilePointerEx(
+        (HANDLE)file_p,
+        distance_to_move,
+        &file_pointer,
+        FILE_CURRENT)) {
+        if (file_pointer.QuadPart > LONG_MAX) {
+            return LV_FS_RES_INV_PARAM;
+        }
+        else {
+            *pos_p = file_pointer.LowPart;
+            return LV_FS_RES_OK;
+        }
+    }
+    else {
+        return fs_error_from_win32(GetLastError());
+    }
+}
+
+static char next_fn[256];
+static lv_fs_res_t next_error = LV_FS_RES_OK;
+
+/**
+ * Initialize a 'DIR' or 'HANDLE' variable for directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param path path to a directory
+ * @return pointer to an initialized 'DIR' or 'HANDLE' variable
+ */
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
+{
+    LV_UNUSED(drv);
+
+    HANDLE d = INVALID_HANDLE_VALUE;
+    WIN32_FIND_DATAA fdata;
+
+    /*Make the path relative to the current directory (the projects root folder)*/
+    char buf[256];
+#ifdef LV_FS_WIN32_PATH
+    sprintf(buf, LV_FS_WIN32_PATH "%s\\*", path);
+#else
+    sprintf(buf, "%s\\*", path);
+#endif
+
+    strcpy(next_fn, "");
+    d = FindFirstFileA(buf, &fdata);
+    do {
+        if (is_dots_name(fdata.cFileName)) {
+            continue;
+        }
+        else {
+            if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+                sprintf(next_fn, "/%s", fdata.cFileName);
+            }
+            else {
+                sprintf(next_fn, "%s", fdata.cFileName);
+            }
+            break;
+        }
+
+    } while (FindNextFileA(d, &fdata));
+
+    next_error = fs_error_from_win32(GetLastError());
+    return d;
+}
+
+/**
+ * Read the next filename from a directory.
+ * The name of the directories will begin with '/'
+ * @param drv pointer to a driver where this function belongs
+ * @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
+ * @param fn pointer to a buffer to store the filename
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * dir_p, char * fn)
+{
+    LV_UNUSED(drv);
+
+    strcpy(fn, next_fn);
+    lv_fs_res_t current_error = next_error;
+    next_error = LV_FS_RES_OK;
+
+    strcpy(next_fn, "");
+    WIN32_FIND_DATAA fdata;
+
+    while (FindNextFileA(dir_p, &fdata)) {
+        if (is_dots_name(fdata.cFileName)) {
+            continue;
+        }
+        else {
+            if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+                sprintf(next_fn, "/%s", fdata.cFileName);
+            }
+            else {
+                sprintf(next_fn, "%s", fdata.cFileName);
+            }
+            break;
+        }
+    }
+
+    if (next_fn[0] == '\0') {
+        next_error = fs_error_from_win32(GetLastError());
+    }
+
+    return current_error;
+}
+
+/**
+ * Close the directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param dir_p pointer to an initialized 'DIR' or 'HANDLE' variable
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * dir_p)
+{
+    LV_UNUSED(drv);
+    return FindClose((HANDLE)dir_p)
+        ? LV_FS_RES_OK
+        : fs_error_from_win32(GetLastError());
+}
+
+#endif /*LV_USE_FS_WIN32*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fsdrv.h b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fsdrv.h
new file mode 100644
index 000000000..c7ca8df1b
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fsdrv.h
@@ -0,0 +1,55 @@
+/**
+ * @file lv_fsdrv.h
+ *
+ */
+
+#ifndef LV_FSDRV_H
+#define LV_FSDRV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lv_conf_internal.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+#if LV_USE_FS_FATFS != '\0'
+	void lv_fs_fatfs_init(void);
+#endif
+
+#if LV_USE_FS_STDIO != '\0'
+	void lv_fs_stdio_init(void);
+#endif
+
+#if LV_USE_FS_POSIX != '\0'
+	void lv_fs_posix_init(void);
+#endif
+
+#if LV_USE_FS_WIN32 != '\0'
+	void lv_fs_win32_init(void);
+#endif
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_FSDRV_H*/
+
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/libs/lv_libs.h b/lib/libesp32_lvgl/lvgl/src/extra/libs/lv_libs.h
new file mode 100644
index 000000000..2e87b4320
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/libs/lv_libs.h
@@ -0,0 +1,46 @@
+/**
+ * @file lv_libs.h
+ *
+ */
+
+#ifndef LV_LIBS_H
+#define LV_LIBS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+// TODO Tasmota
+// #include "bmp/lv_bmp.h"
+// #include "fsdrv/lv_fsdrv.h"
+// #include "png/lv_png.h"
+// #include "gif/lv_gif.h"
+// #include "qrcode/lv_qrcode.h"
+// #include "sjpg/lv_sjpg.h"
+// #include "freetype/lv_freetype.h"
+// #include "rlottie/lv_rlottie.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_LAYOUTS_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/lv_extra.c b/lib/libesp32_lvgl/lvgl/src/extra/lv_extra.c
index 1de4df29f..1f5765b8a 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/lv_extra.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/lv_extra.c
@@ -41,6 +41,40 @@ void lv_extra_init(void)
 #if LV_USE_GRID
     lv_grid_init();
 #endif
+
+#if LV_USE_FS_FATFS != '\0'
+    lv_fs_fatfs_init();
+#endif
+
+#if LV_USE_FS_STDIO != '\0'
+    lv_fs_stdio_init();
+#endif
+
+#if LV_USE_FS_POSIX != '\0'
+    lv_fs_posix_init();
+#endif
+
+#if LV_USE_FS_WIN32 != '\0'
+    lv_fs_win32_init();
+#endif
+
+#if LV_USE_PNG
+    lv_png_init();
+#endif
+
+#if LV_USE_SJPG
+    lv_split_jpeg_init();
+#endif
+
+#if LV_USE_BMP
+    lv_bmp_init();
+#endif
+
+#if LV_USE_FREETYPE
+    /*Init freetype library
+     *Cache max 64 faces and 1 size*/
+    lv_freetype_init(0, 0, LV_FREETYPE_CACHE_SIZE);
+#endif
 }
 
 /**********************
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/others/lv_others.h b/lib/libesp32_lvgl/lvgl/src/extra/others/lv_others.h
new file mode 100644
index 000000000..a95727146
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/others/lv_others.h
@@ -0,0 +1,38 @@
+/**
+ * @file lv_others.h
+ *
+ */
+
+#ifndef LV_OTHERS_H
+#define LV_OTHERS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "snapshot/lv_snapshot.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OTHERS_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/others/snapshot/lv_snapshot.c b/lib/libesp32_lvgl/lvgl/src/extra/others/snapshot/lv_snapshot.c
new file mode 100644
index 000000000..4575539c7
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/others/snapshot/lv_snapshot.c
@@ -0,0 +1,228 @@
+/**
+ * @file lv_snapshot.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_snapshot.h"
+#if LV_USE_SNAPSHOT
+
+#include <stdbool.h>
+#include "../../../core/lv_disp.h"
+#include "../../../core/lv_refr.h"
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/** Get the buffer needed for object snapshot image.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ *
+ * @return the buffer size needed in bytes
+ */
+uint32_t lv_snapshot_buf_size_needed(lv_obj_t * obj, lv_img_cf_t cf)
+{
+    switch(cf) {
+        case LV_IMG_CF_TRUE_COLOR_ALPHA:
+        case LV_IMG_CF_ALPHA_1BIT:
+        case LV_IMG_CF_ALPHA_2BIT:
+        case LV_IMG_CF_ALPHA_4BIT:
+        case LV_IMG_CF_ALPHA_8BIT:
+            break;
+        default:
+            return 0;
+    }
+
+    lv_obj_update_layout(obj);
+
+    /*Width and height determine snapshot image size.*/
+    lv_coord_t w = lv_obj_get_width(obj);
+    lv_coord_t h = lv_obj_get_height(obj);
+    lv_coord_t ext_size = _lv_obj_get_ext_draw_size(obj);
+    w += ext_size * 2;
+    h += ext_size * 2;
+
+    uint8_t px_size = lv_img_cf_get_px_size(cf);
+    return w * h * ((px_size + 7) >> 3);
+}
+
+/** Take snapshot for object with its children, save image info to provided buffer.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ * @param dsc    image descriptor to store the image result.
+ * @param buf    the buffer to store image data.
+ * @param buff_size provided buffer size in bytes.
+ *
+ * @return LV_RES_OK on success, LV_RES_INV on error.
+ */
+lv_res_t lv_snapshot_take_to_buf(lv_obj_t * obj, lv_img_cf_t cf, lv_img_dsc_t * dsc, void * buf, uint32_t buff_size)
+{
+    LV_ASSERT(dsc);
+    LV_ASSERT(buf);
+
+    switch(cf) {
+        case LV_IMG_CF_TRUE_COLOR_ALPHA:
+        case LV_IMG_CF_ALPHA_1BIT:
+        case LV_IMG_CF_ALPHA_2BIT:
+        case LV_IMG_CF_ALPHA_4BIT:
+        case LV_IMG_CF_ALPHA_8BIT:
+            break;
+        default:
+            return LV_RES_INV;
+    }
+
+    if(lv_snapshot_buf_size_needed(obj, cf) > buff_size)
+        return LV_RES_INV;
+
+    /*Width and height determine snapshot image size.*/
+    lv_coord_t w = lv_obj_get_width(obj);
+    lv_coord_t h = lv_obj_get_height(obj);
+    lv_coord_t ext_size = _lv_obj_get_ext_draw_size(obj);
+    w += ext_size * 2;
+    h += ext_size * 2;
+
+    /*Backup obj original info.*/
+    lv_obj_t * parent_old = lv_obj_get_parent(obj);
+    lv_area_t coords_bkp;
+    lv_area_copy(&coords_bkp, &obj->coords);
+
+    lv_memset(buf, 0x00, buff_size);
+    lv_memset_00(dsc, sizeof(lv_img_dsc_t));
+
+    /*We are safe to use stack for below variables since disp will be
+     * unregistered when function returns. */
+    lv_disp_t * disp;
+    lv_disp_drv_t driver;
+    lv_disp_draw_buf_t draw_buf;
+
+    lv_disp_draw_buf_init(&draw_buf, buf, NULL, w * h);
+
+    lv_disp_drv_init(&driver);
+    driver.draw_buf = &draw_buf;
+    driver.hor_res = w;
+    driver.ver_res = h;
+    lv_disp_drv_use_generic_set_px_cb(&driver, cf);
+
+    disp = lv_disp_drv_register(&driver);
+    if(disp == NULL) {
+        return LV_RES_INV;
+    }
+
+    /*Make background transparent */
+    lv_disp_set_bg_opa(disp, LV_OPA_TRANSP);
+
+    /*Move obj to newly created disp and refresh it. */
+    lv_obj_t * screen = lv_disp_get_scr_act(disp);
+    lv_obj_remove_style_all(screen);
+    lv_obj_allocate_spec_attr(screen);
+    screen->spec_attr->child_cnt = 1;
+    screen->spec_attr->children = &obj;
+
+    obj->parent = screen;
+
+    disp->inv_p = 0;
+
+    obj->coords.x2 = w - ext_size - 1;
+    obj->coords.x1 = ext_size;
+    obj->coords.y2 = h - ext_size - 1;
+    obj->coords.y1 = ext_size;
+
+    lv_obj_invalidate(obj);
+
+    /*Don't call lv_refr_now to avoid animation disruption */
+    _lv_disp_refr_timer(disp->refr_timer);
+
+    /*Restore obj original parameters and clean up*/
+    obj->parent = parent_old;
+    screen->spec_attr->child_cnt = 0;
+    screen->spec_attr->children = NULL;
+
+    lv_disp_remove(disp);
+
+    lv_area_copy(&obj->coords, &coords_bkp);
+
+    dsc->data = buf;
+    dsc->header.w = lv_area_get_width(&draw_buf.area);
+    dsc->header.h = lv_area_get_height(&draw_buf.area);
+    dsc->header.cf = cf;
+    return LV_RES_OK;
+}
+
+/** Take snapshot for object with its children, alloc the memory needed.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ *
+ * @return a pointer to a image descriptor, or NULL if failed.
+ */
+lv_img_dsc_t * lv_snapshot_take(lv_obj_t * obj, lv_img_cf_t cf)
+{
+    uint32_t buff_size = lv_snapshot_buf_size_needed(obj, cf);
+
+    void * buf = lv_mem_alloc(buff_size);
+    if(buf == NULL) {
+        return NULL;
+    }
+
+    lv_img_dsc_t * dsc = lv_mem_alloc(sizeof(lv_img_dsc_t));
+    if(dsc == NULL) {
+        lv_mem_free(buf);
+        return NULL;
+    }
+
+    if(lv_snapshot_take_to_buf(obj, cf, dsc, buf, buff_size) == LV_RES_INV) {
+        lv_mem_free(buf);
+        lv_mem_free(dsc);
+        return NULL;
+    }
+
+    return dsc;
+}
+
+/** Free the snapshot image returned by @ref lv_snapshot_take
+ *
+ * It will firstly free the data image takes, then the image descriptor.
+ *
+ * @param dsc    The image descriptor generated by lv_snapshot_take.
+ *
+ */
+void lv_snapshot_free(lv_img_dsc_t * dsc)
+{
+    if(!dsc)
+        return;
+
+    if(dsc->data)
+        lv_mem_free((void *)dsc->data);
+
+    lv_mem_free(dsc);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_SNAPSHOT*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/others/snapshot/lv_snapshot.h b/lib/libesp32_lvgl/lvgl/src/extra/others/snapshot/lv_snapshot.h
new file mode 100644
index 000000000..b84973317
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/extra/others/snapshot/lv_snapshot.h
@@ -0,0 +1,84 @@
+/**
+ * @file lv_snapshot.h
+ *
+ */
+
+#ifndef LV_SNAPSHOT_H
+#define LV_SNAPSHOT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdint.h>
+#include <stddef.h>
+
+#include "../../../lv_conf_internal.h"
+#include "../../../core/lv_obj.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#if LV_USE_SNAPSHOT
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/** Take snapshot for object with its children.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ *
+ * @return a pointer to a image descriptor, or NULL if failed.
+ */
+lv_img_dsc_t * lv_snapshot_take(lv_obj_t * obj, lv_img_cf_t cf);
+
+/** Free the snapshot image returned by @ref lv_snapshot_take
+ *
+ * It will firstly free the data image takes, then the image descriptor.
+ *
+ * @param dsc    The image descriptor generated by lv_snapshot_take.
+ *
+ */
+void lv_snapshot_free(lv_img_dsc_t * dsc);
+
+/** Get the buffer needed for object snapshot image.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ *
+ * @return the buffer size needed in bytes
+ */
+uint32_t lv_snapshot_buf_size_needed(lv_obj_t * obj, lv_img_cf_t cf);
+
+/** Take snapshot for object with its children, save image info to provided buffer.
+ *
+ * @param obj    The object to generate snapshot.
+ * @param cf     color format for generated image.
+ * @param dsc    image descriptor to store the image result.
+ * @param buff   the buffer to store image data.
+ * @param buff_size provided buffer size in bytes.
+ *
+ * @return LV_RES_OK on success, LV_RES_INV on error.
+ */
+lv_res_t lv_snapshot_take_to_buf(lv_obj_t * obj, lv_img_cf_t cf, lv_img_dsc_t * dsc, void * buf, uint32_t buff_size);
+
+
+/**********************
+ *      MACROS
+ **********************/
+#endif /*LV_USE_SNAPSHOT*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/themes/basic/lv_theme_basic.c b/lib/libesp32_lvgl/lvgl/src/extra/themes/basic/lv_theme_basic.c
index 9231e79a0..fd5bc2d02 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/themes/basic/lv_theme_basic.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/themes/basic/lv_theme_basic.c
@@ -201,12 +201,12 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
 
 #if LV_USE_WIN
         /*Header*/
-        if(lv_obj_get_child_id(obj) == 0 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
+        if(lv_obj_get_index(obj) == 0 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
             lv_obj_add_style(obj, &styles->light, 0);
             return;
         }
         /*Content*/
-        else if(lv_obj_get_child_id(obj) == 1 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
+        else if(lv_obj_get_index(obj) == 1 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
             lv_obj_add_style(obj, &styles->light, 0);
             lv_obj_add_style(obj, &styles->scrollbar, LV_PART_SCROLLBAR);
             return;
@@ -406,8 +406,8 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
 
 #if LV_USE_LED
     else if(lv_obj_check_type(obj, &lv_led_class)) {
-            lv_obj_add_style(obj, &styles->light, 0);
-        }
+        lv_obj_add_style(obj, &styles->light, 0);
+    }
 #endif
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/themes/default/lv_theme_default.c b/lib/libesp32_lvgl/lvgl/src/extra/themes/default/lv_theme_default.c
index 977ad1ff1..479dba47f 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/themes/default/lv_theme_default.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/themes/default/lv_theme_default.c
@@ -1,5 +1,5 @@
 /**
- * @file lv_theme_defau.c
+ * @file lv_theme_default.c
  *
  */
 
@@ -29,7 +29,7 @@
 #define DARK_COLOR_TEXT        lv_palette_lighten(LV_PALETTE_GREY, 5)
 #define DARK_COLOR_GREY        lv_color_hex(0x2f3237)
 
-#define TRANSITION_TIME         LV_THEME_DEFAULT_TRANSITON_TIME
+#define TRANSITION_TIME         LV_THEME_DEFAULT_TRANSITION_TIME
 #define BORDER_WIDTH            lv_disp_dpx(theme.disp, 2)
 #define OUTLINE_WIDTH           lv_disp_dpx(theme.disp, 3)
 
@@ -74,6 +74,7 @@ typedef struct {
     lv_style_t transition_delayed;
     lv_style_t transition_normal;
     lv_style_t anim;
+    lv_style_t anim_fast;
 
     /*Parts*/
     lv_style_t knob;
@@ -117,7 +118,7 @@ typedef struct {
 #endif
 
 #if LV_USE_CALENDAR
-    lv_style_t calendar_bg, calendar_day;
+    lv_style_t calendar_btnm_bg, calendar_btnm_day, calendar_header;
 #endif
 
 #if LV_USE_COLORWHEEL
@@ -125,7 +126,7 @@ typedef struct {
 #endif
 
 #if LV_USE_MSGBOX
-    lv_style_t msgbox_bg, msgbox_btn_bg;
+    lv_style_t msgbox_bg, msgbox_btn_bg, msgbox_backdrop_bg;
 #endif
 
 #if LV_USE_KEYBOARD
@@ -146,14 +147,14 @@ typedef struct {
 
 typedef struct {
     lv_theme_t base;
-    uint8_t light :1;
-}my_theme_t;
+    uint8_t light : 1;
+} my_theme_t;
 
 typedef enum {
     DISP_SMALL = 3,
     DISP_MEDIUM = 2,
     DISP_LARGE = 1,
-}disp_size_t;
+} disp_size_t;
 
 /**********************
  *  STATIC PROTOTYPES
@@ -199,12 +200,12 @@ static lv_color_t grey_filter_cb(const lv_color_filter_dsc_t * f, lv_color_t col
 static void style_init(void)
 {
     static const lv_style_prop_t trans_props[] = {
-            LV_STYLE_BG_OPA, LV_STYLE_BG_COLOR,
-            LV_STYLE_TRANSFORM_WIDTH, LV_STYLE_TRANSFORM_HEIGHT,
-            LV_STYLE_TRANSLATE_Y, LV_STYLE_TRANSLATE_X,
-            LV_STYLE_TRANSFORM_ZOOM, LV_STYLE_TRANSFORM_ANGLE,
-            LV_STYLE_COLOR_FILTER_OPA, LV_STYLE_COLOR_FILTER_DSC,
-            0
+        LV_STYLE_BG_OPA, LV_STYLE_BG_COLOR,
+        LV_STYLE_TRANSFORM_WIDTH, LV_STYLE_TRANSFORM_HEIGHT,
+        LV_STYLE_TRANSLATE_Y, LV_STYLE_TRANSLATE_X,
+        LV_STYLE_TRANSFORM_ZOOM, LV_STYLE_TRANSFORM_ANGLE,
+        LV_STYLE_COLOR_FILTER_OPA, LV_STYLE_COLOR_FILTER_DSC,
+        0
     };
 
     color_scr = theme.flags & MODE_DARK ? DARK_COLOR_SCR : LIGHT_COLOR_SCR;
@@ -225,7 +226,8 @@ static void style_init(void)
     lv_style_set_transition(&styles->transition_normal, &trans_normal); /*Go back to default state with delay*/
 
     style_init_reset(&styles->scrollbar);
-    lv_style_set_bg_color(&styles->scrollbar, (theme.flags & MODE_DARK) ? lv_palette_darken(LV_PALETTE_GREY, 2) : lv_palette_main(LV_PALETTE_GREY));
+    lv_style_set_bg_color(&styles->scrollbar, (theme.flags & MODE_DARK) ? lv_palette_darken(LV_PALETTE_GREY,
+                                                                                            2) : lv_palette_main(LV_PALETTE_GREY));
     lv_style_set_radius(&styles->scrollbar, LV_RADIUS_CIRCLE);
     lv_style_set_pad_right(&styles->scrollbar, lv_disp_dpx(theme.disp, 7));
     lv_style_set_pad_top(&styles->scrollbar,  lv_disp_dpx(theme.disp, 7));
@@ -269,13 +271,15 @@ static void style_init(void)
     lv_style_set_outline_opa(&styles->outline_secondary, LV_OPA_50);
 
     style_init_reset(&styles->btn);
-    lv_style_set_radius(&styles->btn, (disp_size == DISP_LARGE ? lv_disp_dpx(theme.disp, 16) : disp_size == DISP_MEDIUM ? lv_disp_dpx(theme.disp, 12) : lv_disp_dpx(theme.disp, 8)));
+    lv_style_set_radius(&styles->btn, (disp_size == DISP_LARGE ? lv_disp_dpx(theme.disp,
+                                                                             16) : disp_size == DISP_MEDIUM ? lv_disp_dpx(theme.disp, 12) : lv_disp_dpx(theme.disp, 8)));
     lv_style_set_bg_opa(&styles->btn, LV_OPA_COVER);
     lv_style_set_bg_color(&styles->btn, color_grey);
     if(!(theme.flags & MODE_DARK)) {
-        lv_style_set_shadow_color(&styles->btn, lv_palette_lighten(LV_PALETTE_GREY, 3));
-        lv_style_set_shadow_width(&styles->btn, 1);
-        lv_style_set_shadow_ofs_y(&styles->btn, lv_disp_dpx(theme.disp, 4));
+        lv_style_set_shadow_color(&styles->btn, lv_palette_main(LV_PALETTE_GREY));
+        lv_style_set_shadow_width(&styles->btn, LV_DPX(3));
+        lv_style_set_shadow_opa(&styles->btn, LV_OPA_50);
+        lv_style_set_shadow_ofs_y(&styles->btn, lv_disp_dpx(theme.disp, LV_DPX(4)));
     }
     lv_style_set_text_color(&styles->btn, color_text);
     lv_style_set_pad_hor(&styles->btn, PAD_DEF);
@@ -299,6 +303,7 @@ static void style_init(void)
 
     style_init_reset(&styles->clip_corner);
     lv_style_set_clip_corner(&styles->clip_corner, true);
+    lv_style_set_border_post(&styles->clip_corner, true);
 
     style_init_reset(&styles->pad_normal);
     lv_style_set_pad_all(&styles->pad_normal, PAD_DEF);
@@ -380,6 +385,9 @@ static void style_init(void)
     style_init_reset(&styles->anim);
     lv_style_set_anim_time(&styles->anim, 200);
 
+    style_init_reset(&styles->anim_fast);
+    lv_style_set_anim_time(&styles->anim_fast, 120);
+
 #if LV_USE_ARC
     style_init_reset(&styles->arc_indic);
     lv_style_set_arc_color(&styles->arc_indic, color_grey);
@@ -434,7 +442,7 @@ static void style_init(void)
     lv_style_set_pad_column(&styles->chart_series, lv_disp_dpx(theme.disp, 2));
 
     style_init_reset(&styles->chart_indic);
-    lv_style_set_radius(&styles->chart_indic,LV_RADIUS_CIRCLE);
+    lv_style_set_radius(&styles->chart_indic, LV_RADIUS_CIRCLE);
     lv_style_set_size(&styles->chart_indic, lv_disp_dpx(theme.disp, 8));
     lv_style_set_bg_color(&styles->chart_indic, theme.color_primary);
     lv_style_set_bg_opa(&styles->chart_indic, LV_OPA_COVER);
@@ -464,32 +472,38 @@ static void style_init(void)
     style_init_reset(&styles->table_cell);
     lv_style_set_border_width(&styles->table_cell, lv_disp_dpx(theme.disp, 1));
     lv_style_set_border_color(&styles->table_cell, color_grey);
-    lv_style_set_border_side(&styles->table_cell, LV_BORDER_SIDE_TOP | LV_BORDER_SIDE_BOTTOM );
+    lv_style_set_border_side(&styles->table_cell, LV_BORDER_SIDE_TOP | LV_BORDER_SIDE_BOTTOM);
 #endif
 
 #if LV_USE_TEXTAREA
     style_init_reset(&styles->ta_cursor);
     lv_style_set_border_color(&styles->ta_cursor, color_text);
     lv_style_set_border_width(&styles->ta_cursor, lv_disp_dpx(theme.disp, 2));
-    lv_style_set_pad_left(&styles->ta_cursor, lv_disp_dpx(theme.disp, 1));
+    lv_style_set_pad_left(&styles->ta_cursor, - lv_disp_dpx(theme.disp, 1));
     lv_style_set_border_side(&styles->ta_cursor, LV_BORDER_SIDE_LEFT);
     lv_style_set_anim_time(&styles->ta_cursor, 400);
 
     style_init_reset(&styles->ta_placeholder);
-    lv_style_set_text_color(&styles->ta_placeholder, (theme.flags & MODE_DARK) ? lv_palette_darken(LV_PALETTE_GREY, 2) : lv_palette_lighten(LV_PALETTE_GREY, 1));
+    lv_style_set_text_color(&styles->ta_placeholder, (theme.flags & MODE_DARK) ? lv_palette_darken(LV_PALETTE_GREY,
+                                                                                                   2) : lv_palette_lighten(LV_PALETTE_GREY, 1));
 #endif
 
 #if LV_USE_CALENDAR
-    style_init_reset(&styles->calendar_bg);
-    lv_style_set_pad_all(&styles->calendar_bg, PAD_SMALL);
-    lv_style_set_pad_gap(&styles->calendar_bg, PAD_SMALL / 2);
-    lv_style_set_radius(&styles->calendar_bg, 0);
+    style_init_reset(&styles->calendar_btnm_bg);
+    lv_style_set_pad_all(&styles->calendar_btnm_bg, PAD_SMALL);
+    lv_style_set_pad_gap(&styles->calendar_btnm_bg, PAD_SMALL / 2);
 
-    style_init_reset(&styles->calendar_day);
-    lv_style_set_border_width(&styles->calendar_day, lv_disp_dpx(theme.disp, 1));
-    lv_style_set_border_color(&styles->calendar_day, color_grey);
-    lv_style_set_bg_color(&styles->calendar_day, color_card);
-    lv_style_set_bg_opa(&styles->calendar_day, LV_OPA_20);
+    style_init_reset(&styles->calendar_btnm_day);
+    lv_style_set_border_width(&styles->calendar_btnm_day, lv_disp_dpx(theme.disp, 1));
+    lv_style_set_border_color(&styles->calendar_btnm_day, color_grey);
+    lv_style_set_bg_color(&styles->calendar_btnm_day, color_card);
+    lv_style_set_bg_opa(&styles->calendar_btnm_day, LV_OPA_20);
+
+    style_init_reset(&styles->calendar_header);
+    lv_style_set_pad_hor(&styles->calendar_header, PAD_SMALL);
+    lv_style_set_pad_top(&styles->calendar_header, PAD_SMALL);
+    lv_style_set_pad_bottom(&styles->calendar_header, PAD_TINY);
+    lv_style_set_pad_gap(&styles->calendar_header, PAD_SMALL);
 #endif
 
 #if LV_USE_COLORWHEEL
@@ -504,6 +518,10 @@ static void style_init(void)
 
     style_init_reset(&styles->msgbox_bg);
     lv_style_set_max_width(&styles->msgbox_bg, lv_pct(100));
+
+    style_init_reset(&styles->msgbox_backdrop_bg);
+    lv_style_set_bg_color(&styles->msgbox_backdrop_bg, lv_palette_main(LV_PALETTE_GREY));
+    lv_style_set_bg_opa(&styles->msgbox_backdrop_bg, LV_OPA_50);
 #endif
 #if LV_USE_KEYBOARD
     style_init_reset(&styles->keyboard_btn_bg);
@@ -556,7 +574,8 @@ static void style_init(void)
  *   GLOBAL FUNCTIONS
  **********************/
 
-lv_theme_t * lv_theme_default_init(lv_disp_t * disp, lv_color_t color_primary, lv_color_t color_secondary, bool dark, const lv_font_t * font)
+lv_theme_t * lv_theme_default_init(lv_disp_t * disp, lv_color_t color_primary, lv_color_t color_secondary, bool dark,
+                                   const lv_font_t * font)
 {
 
     /*This trick is required only to avoid the garbage collection of
@@ -589,6 +608,13 @@ lv_theme_t * lv_theme_default_init(lv_disp_t * disp, lv_color_t color_primary, l
     return (lv_theme_t *)&theme;
 }
 
+lv_theme_t * lv_theme_default_get(void)
+{
+    if(!inited) return NULL;
+
+    return (lv_theme_t *)&theme;
+}
+
 bool lv_theme_default_is_inited(void)
 {
     return inited;
@@ -624,13 +650,13 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
 
 #if LV_USE_WIN
         /*Header*/
-        if(lv_obj_get_child_id(obj) == 0 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
+        if(lv_obj_get_index(obj) == 0 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
             lv_obj_add_style(obj, &styles->bg_color_grey, 0);
             lv_obj_add_style(obj, &styles->pad_tiny, 0);
             return;
         }
         /*Content*/
-        else if(lv_obj_get_child_id(obj) == 1 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
+        else if(lv_obj_get_index(obj) == 1 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
             lv_obj_add_style(obj, &styles->scr, 0);
             lv_obj_add_style(obj, &styles->pad_normal, 0);
             lv_obj_add_style(obj, &styles->scrollbar, LV_PART_SCROLLBAR);
@@ -638,11 +664,20 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
             return;
         }
 #endif
+
+
+#if LV_USE_CALENDAR
+    else if(lv_obj_check_type(lv_obj_get_parent(obj), &lv_calendar_class)) {
+        /*No style*/
+        return;
+    }
+#endif
+
         lv_obj_add_style(obj, &styles->card, 0);
         lv_obj_add_style(obj, &styles->scrollbar, LV_PART_SCROLLBAR);
         lv_obj_add_style(obj, &styles->scrollbar_scrolled, LV_PART_SCROLLBAR | LV_STATE_SCROLLED);
     }
-    #if LV_USE_BTN
+#if LV_USE_BTN
     else if(lv_obj_check_type(obj, &lv_btn_class)) {
         lv_obj_add_style(obj, &styles->btn, 0);
         lv_obj_add_style(obj, &styles->bg_color_primary, 0);
@@ -693,6 +728,20 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
             return;
         }
 #endif
+
+#if LV_USE_CALENDAR
+        if(lv_obj_check_type(lv_obj_get_parent(obj), &lv_calendar_class)) {
+            lv_obj_add_style(obj, &styles->calendar_btnm_bg, 0);
+            lv_obj_add_style(obj, &styles->outline_primary, LV_STATE_FOCUS_KEY);
+            lv_obj_add_style(obj, &styles->outline_secondary, LV_STATE_EDITED);
+            lv_obj_add_style(obj, &styles->calendar_btnm_day, LV_PART_ITEMS);
+            lv_obj_add_style(obj, &styles->pressed, LV_PART_ITEMS | LV_STATE_PRESSED);
+            lv_obj_add_style(obj, &styles->disabled, LV_PART_ITEMS | LV_STATE_DISABLED);
+            lv_obj_add_style(obj, &styles->outline_primary, LV_PART_ITEMS | LV_STATE_FOCUS_KEY);
+            lv_obj_add_style(obj, &styles->outline_secondary, LV_PART_ITEMS | LV_STATE_EDITED);
+            return;
+        }
+#endif
         lv_obj_add_style(obj, &styles->card, 0);
         lv_obj_add_style(obj, &styles->outline_primary, LV_STATE_FOCUS_KEY);
         lv_obj_add_style(obj, &styles->outline_secondary, LV_STATE_EDITED);
@@ -772,6 +821,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
     else if(lv_obj_check_type(obj, &lv_switch_class)) {
         lv_obj_add_style(obj, &styles->bg_color_grey, 0);
         lv_obj_add_style(obj, &styles->circle, 0);
+        lv_obj_add_style(obj, &styles->anim_fast, 0);
         lv_obj_add_style(obj, &styles->disabled, LV_STATE_DISABLED);
         lv_obj_add_style(obj, &styles->outline_primary, LV_STATE_FOCUS_KEY);
         lv_obj_add_style(obj, &styles->bg_color_primary, LV_PART_INDICATOR | LV_STATE_CHECKED);
@@ -781,6 +831,9 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
         lv_obj_add_style(obj, &styles->bg_color_white, LV_PART_KNOB);
         lv_obj_add_style(obj, &styles->switch_knob, LV_PART_KNOB);
         lv_obj_add_style(obj, &styles->disabled, LV_PART_KNOB | LV_STATE_DISABLED);
+
+        lv_obj_add_style(obj, &styles->transition_normal, LV_PART_INDICATOR | LV_STATE_CHECKED);
+        lv_obj_add_style(obj, &styles->transition_normal, LV_PART_INDICATOR);
     }
 #endif
 
@@ -876,26 +929,19 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
 #if LV_USE_CALENDAR
     else if(lv_obj_check_type(obj, &lv_calendar_class)) {
         lv_obj_add_style(obj, &styles->card, 0);
-        lv_obj_add_style(obj, &styles->calendar_bg, 0);
-        lv_obj_add_style(obj, &styles->outline_primary, LV_STATE_FOCUS_KEY);
-        lv_obj_add_style(obj, &styles->outline_secondary, LV_STATE_EDITED);
-        lv_obj_add_style(obj, &styles->calendar_day, LV_PART_ITEMS);
-        lv_obj_add_style(obj, &styles->pressed, LV_PART_ITEMS | LV_STATE_PRESSED);
-        lv_obj_add_style(obj, &styles->disabled, LV_PART_ITEMS | LV_STATE_DISABLED);
-        lv_obj_add_style(obj, &styles->outline_primary, LV_PART_ITEMS | LV_STATE_FOCUS_KEY);
-        lv_obj_add_style(obj, &styles->outline_secondary, LV_PART_ITEMS | LV_STATE_EDITED);
+        lv_obj_add_style(obj, &styles->pad_zero, 0);
     }
 #endif
 
 #if LV_USE_CALENDAR_HEADER_ARROW
     else if(lv_obj_check_type(obj, &lv_calendar_header_arrow_class)) {
-        lv_obj_add_style(obj, &styles->card, 0);
+        lv_obj_add_style(obj, &styles->calendar_header, 0);
     }
 #endif
 
 #if LV_USE_CALENDAR_HEADER_DROPDOWN
     else if(lv_obj_check_type(obj, &lv_calendar_header_dropdown_class)) {
-        lv_obj_add_style(obj, &styles->card, 0);
+        lv_obj_add_style(obj, &styles->calendar_header, 0);
     }
 #endif
 
@@ -943,6 +989,9 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
         lv_obj_add_style(obj, &styles->msgbox_bg, 0);
         return;
     }
+    else if(lv_obj_check_type(obj, &lv_msgbox_backdrop_class)) {
+        lv_obj_add_style(obj, &styles->msgbox_backdrop_bg, 0);
+    }
 #endif
 #if LV_USE_SPINBOX
     else if(lv_obj_check_type(obj, &lv_spinbox_class)) {
@@ -966,10 +1015,15 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
 #endif
 
 #if LV_USE_TABVIEW
-    if(lv_obj_check_type(obj, &lv_tabview_class)) {
+    else if(lv_obj_check_type(obj, &lv_tabview_class)) {
         lv_obj_add_style(obj, &styles->scr, 0);
         lv_obj_add_style(obj, &styles->pad_zero, 0);
-        return;
+    }
+#endif
+
+#if LV_USE_WIN
+    else if(lv_obj_check_type(obj, &lv_win_class)) {
+        lv_obj_add_style(obj, &styles->clip_corner, 0);
     }
 #endif
 
@@ -984,8 +1038,8 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
 
 #if LV_USE_LED
     else if(lv_obj_check_type(obj, &lv_led_class)) {
-            lv_obj_add_style(obj, &styles->led, 0);
-        }
+        lv_obj_add_style(obj, &styles->led, 0);
+    }
 #endif
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/themes/default/lv_theme_default.h b/lib/libesp32_lvgl/lvgl/src/extra/themes/default/lv_theme_default.h
index ef8502622..5b1fd9186 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/themes/default/lv_theme_default.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/themes/default/lv_theme_default.h
@@ -36,9 +36,19 @@ extern "C" {
  * @param font pointer to a font to use.
  * @return a pointer to reference this theme later
  */
-lv_theme_t * lv_theme_default_init(lv_disp_t * disp, lv_color_t color_primary, lv_color_t color_secondary, bool dark, const lv_font_t * font);
+lv_theme_t * lv_theme_default_init(lv_disp_t * disp, lv_color_t color_primary, lv_color_t color_secondary, bool dark,
+                                   const lv_font_t * font);
 
+/**
+ * Get default theme
+ * @return a pointer to default theme, or NULL if this is not initialized
+ */
+lv_theme_t * lv_theme_default_get(void);
 
+/**
+ * Check if default theme is initialized
+ * @return true if default theme is initialized, false otherwise
+ */
 bool lv_theme_default_is_inited(void);
 
 /**********************
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/themes/mono/lv_theme_mono.c b/lib/libesp32_lvgl/lvgl/src/extra/themes/mono/lv_theme_mono.c
index 7abb0a4b3..637564274 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/themes/mono/lv_theme_mono.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/themes/mono/lv_theme_mono.c
@@ -78,7 +78,7 @@ static void style_init(bool dark_bg, const lv_font_t * font)
 {
     style_init_reset(&styles->scrollbar);
     lv_style_set_bg_opa(&styles->scrollbar, LV_OPA_COVER);
-    lv_style_set_bg_color(&styles->scrollbar,COLOR_FG);
+    lv_style_set_bg_color(&styles->scrollbar, COLOR_FG);
     lv_style_set_width(&styles->scrollbar,  PAD_DEF);
 
     style_init_reset(&styles->scr);
@@ -219,13 +219,13 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
 
 #if LV_USE_WIN
         /*Header*/
-        if(lv_obj_get_child_id(obj) == 0 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
+        if(lv_obj_get_index(obj) == 0 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
             lv_obj_add_style(obj, &styles->card, 0);
             lv_obj_add_style(obj, &styles->no_radius, 0);
             return;
         }
         /*Content*/
-        else if(lv_obj_get_child_id(obj) == 1 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
+        else if(lv_obj_get_index(obj) == 1 && lv_obj_check_type(lv_obj_get_parent(obj), &lv_win_class)) {
             lv_obj_add_style(obj, &styles->card, 0);
             lv_obj_add_style(obj, &styles->no_radius, 0);
             lv_obj_add_style(obj, &styles->scrollbar, LV_PART_SCROLLBAR);
@@ -279,7 +279,7 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
         lv_obj_add_style(obj, &styles->inv, LV_PART_ITEMS | LV_STATE_CHECKED);
         lv_obj_add_style(obj, &styles->disabled, LV_PART_ITEMS | LV_STATE_DISABLED);
         lv_obj_add_style(obj, &styles->underline, LV_PART_ITEMS | LV_STATE_FOCUS_KEY);
-            lv_obj_add_style(obj, &styles->large_border, LV_PART_ITEMS | LV_STATE_FOCUS_KEY);
+        lv_obj_add_style(obj, &styles->large_border, LV_PART_ITEMS | LV_STATE_FOCUS_KEY);
     }
 #endif
 
@@ -476,8 +476,8 @@ static void theme_apply(lv_theme_t * th, lv_obj_t * obj)
 
 #if LV_USE_LED
     else if(lv_obj_check_type(obj, &lv_led_class)) {
-            lv_obj_add_style(obj, &styles->card, 0);
-        }
+        lv_obj_add_style(obj, &styles->card, 0);
+    }
 #endif
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/animimg/lv_animimg.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/animimg/lv_animimg.c
index 7d7cdfe65..135a8a4ba 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/animimg/lv_animimg.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/animimg/lv_animimg.c
@@ -27,6 +27,8 @@
  *********************/
 #define LV_OBJX_NAME "lv_animimg"
 
+#define MY_CLASS &lv_animimg_class
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -56,7 +58,7 @@ const lv_obj_class_t lv_animimg_class = {
 
 lv_obj_t * lv_animimg_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_animimg_class, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -64,14 +66,16 @@ lv_obj_t * lv_animimg_create(lv_obj_t * parent)
 
 void lv_animimg_set_src(lv_obj_t * obj,  lv_img_dsc_t * dsc[], uint8_t num)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     animimg->dsc = dsc;
     animimg->pic_count = num;
-    lv_anim_set_values(&animimg->anim, 0 , num);
+    lv_anim_set_values(&animimg->anim, 0, num);
 }
 
 void lv_animimg_start(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_start(&animimg->anim);
 }
@@ -82,6 +86,7 @@ void lv_animimg_start(lv_obj_t * obj)
 
 void lv_animimg_set_duration(lv_obj_t * obj, uint32_t duration)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_set_time(&animimg->anim, duration);
     lv_anim_set_playback_delay(&animimg->anim, duration);
@@ -89,6 +94,7 @@ void lv_animimg_set_duration(lv_obj_t * obj, uint32_t duration)
 
 void lv_animimg_set_repeat_count(lv_obj_t * obj, uint16_t count)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_animimg_t * animimg = (lv_animimg_t *)obj;
     lv_anim_set_repeat_count(&animimg->anim, count);
 }
@@ -115,7 +121,7 @@ static void lv_animimg_constructor(const lv_obj_class_t * class_p, lv_obj_t * ob
     lv_anim_set_var(&animimg->anim, obj);
     lv_anim_set_time(&animimg->anim, 30);
     lv_anim_set_exec_cb(&animimg->anim, (lv_anim_exec_xcb_t)index_change);
-    lv_anim_set_values(&animimg->anim, 0 , 1);
+    lv_anim_set_values(&animimg->anim, 0, 1);
     lv_anim_set_repeat_count(&animimg->anim, LV_ANIM_REPEAT_INFINITE);
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/animimg/lv_animimg.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/animimg/lv_animimg.h
index 28d10896a..a61da3539 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/animimg/lv_animimg.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/animimg/lv_animimg.h
@@ -19,7 +19,7 @@ extern "C" {
 
 /*Testing of dependencies*/
 #if LV_USE_IMG == 0
-#error "lv_animing: lv_img is required. Enable it in lv_conf.h (LV_USE_IMG 1)"
+#error "lv_animimg: lv_img is required. Enable it in lv_conf.h (LV_USE_IMG 1)"
 #endif
 
 /*********************
@@ -37,8 +37,8 @@ typedef struct {
     lv_img_t img;
     lv_anim_t anim;
     /*picture sequence */
-    lv_img_dsc_t **dsc;
-    int8_t	pic_count;
+    lv_img_dsc_t ** dsc;
+    int8_t  pic_count;
 } lv_animimg_t;
 
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar.c
index 52012acb1..3ba73ea30 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar.c
@@ -10,12 +10,16 @@
 #include "../../../lvgl.h"
 #if LV_USE_CALENDAR
 
+#include "../../../misc/lv_assert.h"
+
 /*********************
  *      DEFINES
  *********************/
 #define LV_CALENDAR_CTRL_TODAY      LV_BTNMATRIX_CTRL_CUSTOM_1
 #define LV_CALENDAR_CTRL_HIGHLIGHT  LV_BTNMATRIX_CTRL_CUSTOM_2
 
+#define MY_CLASS &lv_calendar_class
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -37,13 +41,12 @@ static void highlight_update(lv_obj_t * calendar);
 const lv_obj_class_t lv_calendar_class = {
     .constructor_cb = lv_calendar_constructor,
     .width_def = (LV_DPI_DEF * 3) / 2,
-    .height_def =(LV_DPI_DEF * 3) / 2,
+    .height_def = (LV_DPI_DEF * 3) / 2,
     .group_def = LV_OBJ_CLASS_GROUP_DEF_TRUE,
     .instance_size = sizeof(lv_calendar_t),
-    .base_class = &lv_btnmatrix_class
+    .base_class = &lv_obj_class
 };
 
-
 static const char * day_names_def[7] = LV_CALENDAR_DEFAULT_DAY_NAMES;
 
 /**********************
@@ -56,7 +59,7 @@ static const char * day_names_def[7] = LV_CALENDAR_DEFAULT_DAY_NAMES;
 
 lv_obj_t * lv_calendar_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_calendar_class, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -68,16 +71,21 @@ lv_obj_t * lv_calendar_create(lv_obj_t * parent)
 
 void lv_calendar_set_day_names(lv_obj_t * obj, const char * day_names[])
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
+
     uint32_t i;
     for(i = 0; i < 7; i++) {
         calendar->map[i] = day_names[i];
     }
+    lv_obj_invalidate(obj);
 }
 
 void lv_calendar_set_today_date(lv_obj_t * obj, uint32_t year, uint32_t month, uint32_t day)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
+
     calendar->today.year         = year;
     calendar->today.month        = month;
     calendar->today.day          = day;
@@ -89,7 +97,9 @@ void lv_calendar_set_highlighted_dates(lv_obj_t * obj, lv_calendar_date_t highli
 {
     LV_ASSERT_NULL(highlighted);
 
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
+
     calendar->highlighted_dates     = highlighted;
     calendar->highlighted_dates_num = date_num;
 
@@ -98,7 +108,9 @@ void lv_calendar_set_highlighted_dates(lv_obj_t * obj, lv_calendar_date_t highli
 
 void lv_calendar_set_showed_date(lv_obj_t * obj, uint32_t year, uint32_t month)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
+
     calendar->showed_date.year   = year;
     calendar->showed_date.month  = month;
     calendar->showed_date.day    = 1;
@@ -111,9 +123,9 @@ void lv_calendar_set_showed_date(lv_obj_t * obj, uint32_t year, uint32_t month)
     uint8_t i;
 
     /*Remove the disabled state but revert it for day names*/
-    lv_btnmatrix_clear_btn_ctrl_all(obj, LV_BTNMATRIX_CTRL_DISABLED);
+    lv_btnmatrix_clear_btn_ctrl_all(calendar->btnm, LV_BTNMATRIX_CTRL_DISABLED);
     for(i = 0; i < 7; i++) {
-        lv_btnmatrix_set_btn_ctrl(obj, i, LV_BTNMATRIX_CTRL_DISABLED);
+        lv_btnmatrix_set_btn_ctrl(calendar->btnm, i, LV_BTNMATRIX_CTRL_DISABLED);
     }
 
     uint8_t act_mo_len = get_month_length(d.year, d.month);
@@ -126,65 +138,82 @@ void lv_calendar_set_showed_date(lv_obj_t * obj, uint32_t year, uint32_t month)
     uint8_t prev_mo_len = get_month_length(d.year, d.month - 1);
     for(i = 0, c = prev_mo_len - day_first + 1; i < day_first; i++, c++) {
         lv_snprintf(calendar->nums[i], sizeof(calendar->nums[0]), "%d", c);
-        lv_btnmatrix_set_btn_ctrl(obj, i + 7, LV_BTNMATRIX_CTRL_DISABLED);
+        lv_btnmatrix_set_btn_ctrl(calendar->btnm, i + 7, LV_BTNMATRIX_CTRL_DISABLED);
     }
 
     for(i = day_first + act_mo_len, c = 1; i < 6 * 7; i++, c++) {
         lv_snprintf(calendar->nums[i], sizeof(calendar->nums[0]), "%d", c);
-        lv_btnmatrix_set_btn_ctrl(obj, i + 7, LV_BTNMATRIX_CTRL_DISABLED);
+        lv_btnmatrix_set_btn_ctrl(calendar->btnm, i + 7, LV_BTNMATRIX_CTRL_DISABLED);
     }
 
     highlight_update(obj);
+
+    /*Reset the focused button if the days changes*/
+    if(lv_btnmatrix_get_selected_btn(calendar->btnm) != LV_BTNMATRIX_BTN_NONE) {
+        lv_btnmatrix_set_selected_btn(calendar->btnm, day_first + 7);
+    }
+
     lv_obj_invalidate(obj);
+
+    /* The children of the calendar are probably headers.
+     * Notify them to let the headers updated to the new date*/
+    uint32_t child_cnt = lv_obj_get_child_cnt(obj);
+    for(i = 0; i < child_cnt; i++) {
+        lv_obj_t * child = lv_obj_get_child(obj, i);
+        if(child == calendar->btnm) continue;
+        lv_event_send(child, LV_EVENT_VALUE_CHANGED, obj);
+    }
 }
 
 /*=====================
  * Getter functions
  *====================*/
 
-/**
- * Get the today's date
- * @param calendar pointer to a calendar object
- * @return return pointer to an `lv_calendar_date_t` variable containing the date of today.
- */
+lv_obj_t * lv_calendar_get_btnmatrix(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    const lv_calendar_t * calendar = (lv_calendar_t *)obj;
+    return calendar->btnm;
+}
+
 const lv_calendar_date_t * lv_calendar_get_today_date(const lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     const lv_calendar_t * calendar = (lv_calendar_t *)obj;
+
     return &calendar->today;
 }
 
-/**
- * Get the currently showed
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` variable containing the date is being shown.
- */
 const lv_calendar_date_t * lv_calendar_get_showed_date(const lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     const lv_calendar_t * calendar = (lv_calendar_t *)obj;
+
     return &calendar->showed_date;
 }
 
-/**
- * Get the the highlighted dates
- * @param calendar pointer to a calendar object
- * @return pointer to an `lv_calendar_date_t` array containing the dates.
- */
 lv_calendar_date_t * lv_calendar_get_highlighted_dates(const lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
+
     return calendar->highlighted_dates;
 }
 
 uint16_t lv_calendar_get_highlighted_dates_num(const lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
+
     return calendar->highlighted_dates_num;
 }
 
 lv_res_t lv_calendar_get_pressed_date(const lv_obj_t * obj, lv_calendar_date_t * date)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_calendar_t * calendar = (lv_calendar_t *)obj;
-    uint16_t d = lv_btnmatrix_get_selected_btn(obj);
+
+    uint16_t d = lv_btnmatrix_get_selected_btn(calendar->btnm);
     if(d == LV_BTNMATRIX_BTN_NONE) {
         date->year = 0;
         date->month = 0;
@@ -192,7 +221,7 @@ lv_res_t lv_calendar_get_pressed_date(const lv_obj_t * obj, lv_calendar_date_t *
         return LV_RES_INV;
     }
 
-    const char * txt = lv_btnmatrix_get_btn_text(obj, lv_btnmatrix_get_selected_btn(obj));
+    const char * txt = lv_btnmatrix_get_btn_text(calendar->btnm, lv_btnmatrix_get_selected_btn(calendar->btnm));
 
     if(txt[1] == 0) date->day = txt[0] - '0';
     else date->day = (txt[0] - '0') * 10 + (txt[1] - '0');
@@ -232,9 +261,11 @@ static void lv_calendar_constructor(const lv_obj_class_t * class_p, lv_obj_t * o
         /*Every 8th string is "\n"*/
         if(i != 0 && (i + 1) % 8 == 0) {
             calendar->map[i] = "\n";
-        } else if(i < 8){
+        }
+        else if(i < 8) {
             calendar->map[i] = day_names_def[i];
-        } else {
+        }
+        else {
             calendar->nums[j][0] = 'x';
             calendar->map[i] = calendar->nums[j];
             j++;
@@ -242,14 +273,19 @@ static void lv_calendar_constructor(const lv_obj_class_t * class_p, lv_obj_t * o
     }
     calendar->map[8 * 7 - 1] = "";
 
-    lv_btnmatrix_set_map(obj, calendar->map);
-    lv_btnmatrix_set_btn_ctrl_all(obj, LV_BTNMATRIX_CTRL_CLICK_TRIG | LV_BTNMATRIX_CTRL_NO_REPEAT);
+    calendar->btnm = lv_btnmatrix_create(obj);
+    lv_btnmatrix_set_map(calendar->btnm, calendar->map);
+    lv_btnmatrix_set_btn_ctrl_all(calendar->btnm, LV_BTNMATRIX_CTRL_CLICK_TRIG | LV_BTNMATRIX_CTRL_NO_REPEAT);
+    lv_obj_add_event_cb(calendar->btnm, draw_part_begin_event_cb, LV_EVENT_DRAW_PART_BEGIN, NULL);
+    lv_obj_set_width(calendar->btnm, lv_pct(100));
 
+    lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_grow(calendar->btnm, 1);
 
     lv_calendar_set_showed_date(obj, calendar->showed_date.year, calendar->showed_date.month);
     lv_calendar_set_today_date(obj, calendar->today.year, calendar->today.month, calendar->today.day);
 
-    lv_obj_add_event_cb(obj, draw_part_begin_event_cb, LV_EVENT_DRAW_PART_BEGIN, NULL);
+    lv_obj_add_flag(calendar->btnm, LV_OBJ_FLAG_EVENT_BUBBLE);
 }
 
 static void draw_part_begin_event_cb(lv_event_t * e)
@@ -285,9 +321,6 @@ static void draw_part_begin_event_cb(lv_event_t * e)
     }
 }
 
-
-
-
 /**
  * Get the number of days in a month
  * @param year a year
@@ -339,7 +372,7 @@ static uint8_t get_day_of_week(uint32_t year, uint32_t month, uint32_t day)
     uint32_t day_of_week = (day + (31 * (month - 2 + 12 * a) / 12) + b + (b / 4) - (b / 100) + (b / 400)) % 7;
 #endif
 
-    return day_of_week;
+    return day_of_week  ;
 }
 
 static void highlight_update(lv_obj_t * obj)
@@ -348,19 +381,20 @@ static void highlight_update(lv_obj_t * obj)
     uint16_t i;
 
     /*Clear all kind of selection*/
-    lv_btnmatrix_clear_btn_ctrl_all(obj, LV_CALENDAR_CTRL_TODAY | LV_CALENDAR_CTRL_HIGHLIGHT);
+    lv_btnmatrix_clear_btn_ctrl_all(calendar->btnm, LV_CALENDAR_CTRL_TODAY | LV_CALENDAR_CTRL_HIGHLIGHT);
 
+    uint8_t day_first = get_day_of_week(calendar->showed_date.year, calendar->showed_date.month, 1);
     if(calendar->highlighted_dates) {
         for(i = 0; i < calendar->highlighted_dates_num; i++) {
-            if(calendar->highlighted_dates[i].year == calendar->today.year && calendar->highlighted_dates[i].month == calendar->showed_date.month) {
-                lv_btnmatrix_set_btn_ctrl(obj, calendar->highlighted_dates[i].day + 7, LV_CALENDAR_CTRL_HIGHLIGHT);
+            if(calendar->highlighted_dates[i].year == calendar->showed_date.year &&
+               calendar->highlighted_dates[i].month == calendar->showed_date.month) {
+                lv_btnmatrix_set_btn_ctrl(calendar->btnm, calendar->highlighted_dates[i].day - 1 + day_first + 7, LV_CALENDAR_CTRL_HIGHLIGHT);
             }
         }
     }
 
     if(calendar->showed_date.year == calendar->today.year && calendar->showed_date.month == calendar->today.month) {
-        uint8_t day_first = get_day_of_week(calendar->today.year, calendar->today.month, 0);
-        lv_btnmatrix_set_btn_ctrl(obj, calendar->today.day + day_first + 7, LV_CALENDAR_CTRL_TODAY);
+        lv_btnmatrix_set_btn_ctrl(calendar->btnm, calendar->today.day - 1 + day_first + 7, LV_CALENDAR_CTRL_TODAY);
     }
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar.h
index 1fe0c4654..a91ce4b22 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar.h
@@ -36,11 +36,13 @@ typedef struct {
 
 /*Data of calendar*/
 typedef struct {
-    lv_btnmatrix_t btnm;
+    lv_obj_t obj;
+    lv_obj_t * btnm;
     /*New data for this type*/
     lv_calendar_date_t today;               /*Date of today*/
     lv_calendar_date_t showed_date;         /*Currently visible month (day is ignored)*/
-    lv_calendar_date_t * highlighted_dates; /*Apply different style on these days (pointer to an array defined by the user)*/
+    lv_calendar_date_t *
+    highlighted_dates; /*Apply different style on these days (pointer to an array defined by the user)*/
     uint16_t highlighted_dates_num;          /*Number of elements in `highlighted_days`*/
     const char * map[8 * 7];
     char nums [7 * 6][4];
@@ -101,6 +103,14 @@ void lv_calendar_set_day_names(lv_obj_t * obj, const char ** day_names);
  * Getter functions
  *====================*/
 
+/**
+ * Get the button matrix object of the calendar.
+ * It shows the dates and day names.
+ * @param obj   pointer to a calendar object
+ * @return      pointer to a the button matrix
+ */
+lv_obj_t * lv_calendar_get_btnmatrix(const lv_obj_t * obj);
+
 /**
  * Get the today's date
  * @param calendar pointer to a calendar object
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.c
index c38e09e89..fecb1392e 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.c
@@ -27,18 +27,19 @@
  **********************/
 static void my_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
 static void month_event_cb(lv_event_t * e);
+static void value_changed_event_cb(lv_event_t * e);
 
 /**********************
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_calendar_header_arrow_class = {
-     .base_class = &lv_obj_class,
-     .constructor_cb = my_constructor
+    .base_class = &lv_obj_class,
+    .constructor_cb = my_constructor,
+    .width_def = LV_PCT(100),
+    .height_def = LV_DPI_DEF / 3
 };
 
 static const char * month_names_def[12] = LV_CALENDAR_DEFAULT_MONTH_NAMES;
-static lv_obj_t * calendar_param;
-static lv_coord_t btn_size_param;
 
 /**********************
  *      MACROS
@@ -48,10 +49,8 @@ static lv_coord_t btn_size_param;
  *   GLOBAL FUNCTIONS
  **********************/
 
-lv_obj_t * lv_calendar_header_arrow_create(lv_obj_t * parent, lv_obj_t * calendar, lv_coord_t btn_size)
+lv_obj_t * lv_calendar_header_arrow_create(lv_obj_t * parent)
 {
-    calendar_param = calendar;
-    btn_size_param = btn_size;
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_calendar_header_arrow_class, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -67,41 +66,36 @@ static void my_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 
     LV_UNUSED(class_p);
 
-    /*Use the same paddings as the calendar_param*/
-    lv_obj_set_style_pad_left(obj, lv_obj_get_style_pad_left(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_pad_right(obj, lv_obj_get_style_pad_right(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_pad_top(obj, lv_obj_get_style_pad_top(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_pad_bottom(obj, lv_obj_get_style_pad_bottom(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_pad_column(obj, lv_obj_get_style_pad_column(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_radius(obj, lv_obj_get_style_radius(calendar_param, LV_PART_MAIN), 0);
+    lv_obj_move_to_index(obj, 0);
 
-    const lv_calendar_date_t * cur_date = lv_calendar_get_showed_date(calendar_param);
-
-    lv_obj_update_layout(calendar_param);
-    lv_coord_t w = lv_obj_get_width(calendar_param);
-    lv_obj_set_size(obj,  w, LV_SIZE_CONTENT);
     lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_ROW);
     lv_obj_set_flex_align(obj, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_START);
 
     lv_obj_t * mo_prev = lv_btn_create(obj);
     lv_obj_set_style_bg_img_src(mo_prev, LV_SYMBOL_LEFT, 0);
-    lv_obj_set_size(mo_prev, btn_size_param, btn_size_param);
-    lv_obj_add_event_cb(mo_prev, month_event_cb, LV_EVENT_CLICKED, calendar_param);
+    lv_obj_set_height(mo_prev, lv_pct(100));
+    lv_obj_update_layout(mo_prev);
+    lv_coord_t btn_size = lv_obj_get_height(mo_prev);
+    lv_obj_set_width(mo_prev, btn_size);
+
+    lv_obj_add_event_cb(mo_prev, month_event_cb, LV_EVENT_CLICKED, NULL);
     lv_obj_clear_flag(mo_prev, LV_OBJ_FLAG_CLICK_FOCUSABLE);
 
     lv_obj_t * label = lv_label_create(obj);
     lv_label_set_long_mode(label, LV_LABEL_LONG_SCROLL_CIRCULAR);
     lv_obj_set_style_text_align(label, LV_TEXT_ALIGN_CENTER, 0);
     lv_obj_set_flex_grow(label, 1);
-    lv_label_set_text_fmt(label, "%d %s", cur_date->year, month_names_def[cur_date->month - 1]);
 
     lv_obj_t * mo_next = lv_btn_create(obj);
     lv_obj_set_style_bg_img_src(mo_next, LV_SYMBOL_RIGHT, 0);
-    lv_obj_set_size(mo_next, btn_size_param, btn_size_param);
-    lv_obj_add_event_cb(mo_next, month_event_cb, LV_EVENT_CLICKED, calendar_param);
+    lv_obj_set_size(mo_next, btn_size, btn_size);
+
+    lv_obj_add_event_cb(mo_next, month_event_cb, LV_EVENT_CLICKED, NULL);
     lv_obj_clear_flag(mo_next, LV_OBJ_FLAG_CLICK_FOCUSABLE);
 
-    lv_obj_align_to(obj, calendar_param, LV_ALIGN_OUT_TOP_MID, 0, 0);
+    lv_obj_add_event_cb(obj, value_changed_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
+    /*Refresh the drop downs*/
+    lv_event_send(obj, LV_EVENT_VALUE_CHANGED, NULL);
 }
 
 static void month_event_cb(lv_event_t * e)
@@ -109,7 +103,7 @@ static void month_event_cb(lv_event_t * e)
     lv_obj_t * btn = lv_event_get_target(e);
 
     lv_obj_t * header = lv_obj_get_parent(btn);
-    lv_obj_t * calendar = lv_event_get_user_data(e);
+    lv_obj_t * calendar = lv_obj_get_parent(header);
 
     const lv_calendar_date_t * d;
     d = lv_calendar_get_showed_date(calendar);
@@ -120,14 +114,17 @@ static void month_event_cb(lv_event_t * e)
         if(newd.month == 1) {
             newd.month = 12;
             newd.year --;
-        } else {
+        }
+        else {
             newd.month --;
         }
-    } else {
+    }
+    else {
         if(newd.month == 12) {
             newd.month = 1;
             newd.year ++;
-        } else {
+        }
+        else {
             newd.month ++;
         }
     }
@@ -138,5 +135,15 @@ static void month_event_cb(lv_event_t * e)
     lv_label_set_text_fmt(label, "%d %s", newd.year, month_names_def[newd.month - 1]);
 }
 
+static void value_changed_event_cb(lv_event_t * e)
+{
+    lv_obj_t * header = lv_event_get_target(e);
+    lv_obj_t * calendar = lv_obj_get_parent(header);
+
+    const lv_calendar_date_t * cur_date = lv_calendar_get_showed_date(calendar);
+    lv_obj_t * label = lv_obj_get_child(header, 1);
+    lv_label_set_text_fmt(label, "%d %s", cur_date->year, month_names_def[cur_date->month - 1]);
+}
+
 #endif /*LV_USE_CALENDAR_HEADER_ARROW*/
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.h
index b4e3b52e3..f33ef7dc8 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_arrow.h
@@ -30,11 +30,11 @@ extern const lv_obj_class_t lv_calendar_header_arrow_class;
  **********************/
 
 /**
- * Create a calendar objects
- * @param par pointer to an object, it will be the parent of the new calendar
- * @return pointer to the created calendar
+ * Create a calendar header with drop-drowns to select the year and month
+ * @param parent    pointer to a calendar object.
+ * @return          the created header
  */
-lv_obj_t * lv_calendar_header_arrow_create(lv_obj_t * parent, lv_obj_t * calendar, lv_coord_t btn_size);
+lv_obj_t * lv_calendar_header_arrow_create(lv_obj_t * parent);
 
 /**********************
  *      MACROS
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.c
index 18af0d94a..5e8f90d4a 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.c
@@ -27,28 +27,29 @@
 static void my_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
 static void year_event_cb(lv_event_t * e);
 static void month_event_cb(lv_event_t * e);
+static void value_changed_event_cb(lv_event_t * e);
 
 /**********************
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_calendar_header_dropdown_class = {
-     .base_class = &lv_obj_class,
-     .constructor_cb = my_constructor
- };
+    .base_class = &lv_obj_class,
+    .width_def = LV_PCT(100),
+    .height_def = LV_SIZE_CONTENT,
+    .constructor_cb = my_constructor
+};
 
 static const char * month_list = "01\n02\n03\n04\n05\n06\n07\n08\n09\n10\n11\n12";
 static const char * year_list = {
-        "2023\n2022\n2021\n"
-        "2020\n2019\n2018\n2017\n2016\n2015\n2014\n2013\n2012\n2011\n2010\n2009\n2008\n2007\n2006\n2005\n2004\n2003\n2002\n2001\n"
-        "2000\n1999\n1998\n1997\n1996\n1995\n1994\n1993\n1992\n1991\n1990\n1989\n1988\n1987\n1986\n1985\n1984\n1983\n1982\n1981\n"
-        "1980\n1979\n1978\n1977\n1976\n1975\n1974\n1973\n1972\n1971\n1970\n1969\n1968\n1967\n1966\n1965\n1964\n1963\n1962\n1961\n"
-        "1960\n1959\n1958\n1957\n1956\n1955\n1954\n1953\n1952\n1951\n1950\n1949\n1948\n1947\n1946\n1945\n1944\n1943\n1942\n1941\n"
-        "1940\n1939\n1938\n1937\n1936\n1935\n1934\n1933\n1932\n1931\n1930\n1929\n1928\n1927\n1926\n1925\n1924\n1923\n1922\n1921\n"
-        "1920\n1919\n1918\n1917\n1916\n1915\n1914\n1913\n1912\n1911\n1910\n1909\n1908\n1907\n1906\n1905\n1904\n1903\n1902\n1901"
+    "2023\n2022\n2021\n"
+    "2020\n2019\n2018\n2017\n2016\n2015\n2014\n2013\n2012\n2011\n2010\n2009\n2008\n2007\n2006\n2005\n2004\n2003\n2002\n2001\n"
+    "2000\n1999\n1998\n1997\n1996\n1995\n1994\n1993\n1992\n1991\n1990\n1989\n1988\n1987\n1986\n1985\n1984\n1983\n1982\n1981\n"
+    "1980\n1979\n1978\n1977\n1976\n1975\n1974\n1973\n1972\n1971\n1970\n1969\n1968\n1967\n1966\n1965\n1964\n1963\n1962\n1961\n"
+    "1960\n1959\n1958\n1957\n1956\n1955\n1954\n1953\n1952\n1951\n1950\n1949\n1948\n1947\n1946\n1945\n1944\n1943\n1942\n1941\n"
+    "1940\n1939\n1938\n1937\n1936\n1935\n1934\n1933\n1932\n1931\n1930\n1929\n1928\n1927\n1926\n1925\n1924\n1923\n1922\n1921\n"
+    "1920\n1919\n1918\n1917\n1916\n1915\n1914\n1913\n1912\n1911\n1910\n1909\n1908\n1907\n1906\n1905\n1904\n1903\n1902\n1901"
 };
 
-static lv_obj_t * calendar_param;
-
 /**********************
  *      MACROS
  **********************/
@@ -57,9 +58,8 @@ static lv_obj_t * calendar_param;
  *   GLOBAL FUNCTIONS
  **********************/
 
-lv_obj_t * lv_calendar_header_dropdown_create(lv_obj_t * parent, lv_obj_t * calendar)
+lv_obj_t * lv_calendar_header_dropdown_create(lv_obj_t * parent)
 {
-    calendar_param = calendar;
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_calendar_header_dropdown_class, parent);
     lv_obj_class_init_obj(obj);
 
@@ -76,36 +76,23 @@ static void my_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 
     LV_UNUSED(class_p);
 
-    /*Use the same paddings as the calendar_param*/
-    lv_obj_set_style_pad_left(obj,lv_obj_get_style_pad_left(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_pad_right(obj,lv_obj_get_style_pad_right(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_pad_top(obj,lv_obj_get_style_pad_top(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_pad_bottom(obj,lv_obj_get_style_pad_bottom(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_pad_column(obj,lv_obj_get_style_pad_column(calendar_param, LV_PART_MAIN), 0);
-    lv_obj_set_style_radius(obj,lv_obj_get_style_radius(calendar_param, LV_PART_MAIN), 0);
-
-    const lv_calendar_date_t * cur_date = lv_calendar_get_showed_date(calendar_param);
-
-    lv_obj_update_layout(calendar_param);
-    lv_coord_t w = lv_obj_get_width(calendar_param);
-    lv_obj_set_size(obj,  w, LV_SIZE_CONTENT);
+    lv_obj_t * calendar = lv_obj_get_parent(obj);
+    lv_obj_move_to_index(obj, 0);
     lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_ROW);
-    lv_obj_set_flex_align(obj, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_START);
 
     lv_obj_t * year_dd = lv_dropdown_create(obj);
     lv_dropdown_set_options(year_dd, year_list);
-    lv_dropdown_set_selected(year_dd, 2023 - cur_date->year);
-    lv_obj_add_event_cb(year_dd, year_event_cb, LV_EVENT_VALUE_CHANGED, calendar_param);
+    lv_obj_add_event_cb(year_dd, year_event_cb, LV_EVENT_VALUE_CHANGED, calendar);
     lv_obj_set_flex_grow(year_dd, 1);
 
     lv_obj_t * month_dd = lv_dropdown_create(obj);
     lv_dropdown_set_options(month_dd, month_list);
-    lv_dropdown_set_selected(month_dd, cur_date->month - 1);
-    lv_obj_add_event_cb(month_dd, month_event_cb, LV_EVENT_VALUE_CHANGED, calendar_param);
+    lv_obj_add_event_cb(month_dd, month_event_cb, LV_EVENT_VALUE_CHANGED, calendar);
     lv_obj_set_flex_grow(month_dd, 1);
 
-    lv_obj_align_to(obj, calendar_param, LV_ALIGN_OUT_TOP_MID, 0, 0);
-
+    lv_obj_add_event_cb(obj, value_changed_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
+    /*Refresh the drop downs*/
+    lv_event_send(obj, LV_EVENT_VALUE_CHANGED, NULL);
 }
 
 static void month_event_cb(lv_event_t * e)
@@ -122,6 +109,7 @@ static void month_event_cb(lv_event_t * e)
 
     lv_calendar_set_showed_date(calendar, newd.year, newd.month);
 }
+
 static void year_event_cb(lv_event_t * e)
 {
     lv_obj_t * dropdown = lv_event_get_target(e);
@@ -137,5 +125,18 @@ static void year_event_cb(lv_event_t * e)
     lv_calendar_set_showed_date(calendar, newd.year, newd.month);
 }
 
+static void value_changed_event_cb(lv_event_t * e)
+{
+    lv_obj_t * header = lv_event_get_target(e);
+    lv_obj_t * calendar = lv_obj_get_parent(header);
+    const lv_calendar_date_t * cur_date = lv_calendar_get_showed_date(calendar);
+
+    lv_obj_t * year_dd = lv_obj_get_child(header, 0);
+    lv_dropdown_set_selected(year_dd, 2023 - cur_date->year);
+
+    lv_obj_t * month_dd = lv_obj_get_child(header, 1);
+    lv_dropdown_set_selected(month_dd, cur_date->month - 1);
+}
+
 #endif /*LV_USE_CALENDAR_HEADER_ARROW*/
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.h
index 8d6333d9d..7ce924e94 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/calendar/lv_calendar_header_dropdown.h
@@ -30,11 +30,11 @@ extern const lv_obj_class_t lv_calendar_header_dropdown_class;
  **********************/
 
 /**
- * Create a calendar objects
- * @param par pointer to an object, it will be the parent of the new calendar
- * @return pointer to the created calendar
+ * Create a calendar header with drop-drowns to select the year and month
+ * @param parent    pointer to a calendar object.
+ * @return          the created header
  */
-lv_obj_t * lv_calendar_header_dropdown_create(lv_obj_t * parent, lv_obj_t * calendar);
+lv_obj_t * lv_calendar_header_dropdown_create(lv_obj_t * parent);
 
 /**********************
  *      MACROS
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/chart/lv_chart.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/chart/lv_chart.c
index 6face3dba..12c05b338 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/chart/lv_chart.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/chart/lv_chart.c
@@ -9,6 +9,8 @@
 #include "lv_chart.h"
 #if LV_USE_CHART != 0
 
+#include "../../../misc/lv_assert.h"
+
 /*********************
  *      DEFINES
  *********************/
@@ -17,6 +19,7 @@
 #define LV_CHART_HDIV_DEF 3
 #define LV_CHART_VDIV_DEF 5
 #define LV_CHART_POINT_CNT_DEF 10
+#define LV_CHART_LABEL_MAX_TEXT_LENGTH 16
 
 /**********************
  *      TYPEDEFS
@@ -29,7 +32,7 @@ static void lv_chart_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 static void lv_chart_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
 static void lv_chart_event(const lv_obj_class_t * class_p, lv_event_t * e);
 
-static void draw_div_lines(lv_obj_t * obj , const lv_area_t * mask);
+static void draw_div_lines(lv_obj_t * obj, const lv_area_t * mask);
 static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area);
 static void draw_series_bar(lv_obj_t * obj, const lv_area_t * clip_area);
 static void draw_series_scatter(lv_obj_t * obj, const lv_area_t * clip_area);
@@ -63,7 +66,7 @@ const lv_obj_class_t lv_chart_class = {
 
 lv_obj_t * lv_chart_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -130,25 +133,25 @@ void lv_chart_set_range(lv_obj_t * obj, lv_chart_axis_t axis, lv_coord_t min, lv
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     switch(axis) {
-    case LV_CHART_AXIS_PRIMARY_Y:
-        chart->ymin[0] = min;
-        chart->ymax[0] = max;
-        break;
-    case LV_CHART_AXIS_SECONDARY_Y:
-        chart->ymin[1] = min;
-        chart->ymax[1] = max;
-        break;
-    case LV_CHART_AXIS_PRIMARY_X:
-        chart->xmin[0] = min;
-        chart->xmax[0] = max;
-        break;
-    case LV_CHART_AXIS_SECONDARY_X:
-        chart->xmin[1] = min;
-        chart->xmax[1] = max;
-        break;
-    default:
-        LV_LOG_WARN("Invalid axis: %d", axis);
-        return;
+        case LV_CHART_AXIS_PRIMARY_Y:
+            chart->ymin[0] = min;
+            chart->ymax[0] = max;
+            break;
+        case LV_CHART_AXIS_SECONDARY_Y:
+            chart->ymin[1] = min;
+            chart->ymax[1] = max;
+            break;
+        case LV_CHART_AXIS_PRIMARY_X:
+            chart->xmin[0] = min;
+            chart->xmax[0] = max;
+            break;
+        case LV_CHART_AXIS_SECONDARY_X:
+            chart->xmin[1] = min;
+            chart->xmax[1] = max;
+            break;
+        default:
+            LV_LOG_WARN("Invalid axis: %d", axis);
+            return;
     }
 
     lv_chart_refresh(obj);
@@ -188,6 +191,8 @@ void lv_chart_set_zoom_x(lv_obj_t * obj, uint16_t zoom_x)
 
     chart->zoom_x = zoom_x;
     lv_obj_refresh_self_size(obj);
+    /*Be the chart doesn't remain scrolled out*/
+    lv_obj_readjust_scroll(obj, LV_ANIM_OFF);
     lv_obj_invalidate(obj);
 }
 
@@ -200,6 +205,8 @@ void lv_chart_set_zoom_y(lv_obj_t * obj, uint16_t zoom_y)
 
     chart->zoom_y = zoom_y;
     lv_obj_refresh_self_size(obj);
+    /*Be the chart doesn't remain scrolled out*/
+    lv_obj_readjust_scroll(obj, LV_ANIM_OFF);
     lv_obj_invalidate(obj);
 }
 
@@ -219,7 +226,8 @@ uint16_t lv_chart_get_zoom_y(const lv_obj_t * obj)
     return chart->zoom_y;
 }
 
-void lv_chart_set_axis_tick(lv_obj_t * obj, lv_chart_axis_t axis, lv_coord_t major_len, lv_coord_t minor_len, lv_coord_t major_cnt, lv_coord_t minor_cnt, bool label_en, lv_coord_t draw_size)
+void lv_chart_set_axis_tick(lv_obj_t * obj, lv_chart_axis_t axis, lv_coord_t major_len, lv_coord_t minor_len,
+                            lv_coord_t major_cnt, lv_coord_t minor_cnt, bool label_en, lv_coord_t draw_size)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
@@ -263,6 +271,7 @@ void lv_chart_get_point_pos_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint1
 {
     LV_ASSERT_NULL(obj);
     LV_ASSERT_NULL(ser);
+    LV_ASSERT_OBJ(obj, MY_CLASS);
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(id >= chart->point_cnt) {
@@ -272,8 +281,8 @@ void lv_chart_get_point_pos_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint1
         return;
     }
 
-    lv_coord_t w = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
-    lv_coord_t h = (lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
+    lv_coord_t w = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+    lv_coord_t h = ((int32_t)lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
 
     if(chart->type == LV_CHART_TYPE_LINE) {
         p_out->x = (w * id) / (chart->point_cnt - 1);
@@ -283,8 +292,10 @@ void lv_chart_get_point_pos_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint1
     }
     else if(chart->type == LV_CHART_TYPE_BAR) {
         uint32_t ser_cnt = _lv_ll_get_len(&chart->series_ll);
-        int32_t ser_gap = (lv_obj_get_style_pad_column(obj, LV_PART_ITEMS) * chart->zoom_x) >> 8; /*Gap between the column on the ~same X*/
-        int32_t block_gap = (lv_obj_get_style_pad_column(obj, LV_PART_MAIN) * chart->zoom_x) >> 8;  /*Gap between the column on ~adjacent X*/
+        int32_t ser_gap = ((int32_t)lv_obj_get_style_pad_column(obj,
+                                                                LV_PART_ITEMS) * chart->zoom_x) >> 8; /*Gap between the column on the ~same X*/
+        int32_t block_gap = ((int32_t)lv_obj_get_style_pad_column(obj,
+                                                                  LV_PART_MAIN) * chart->zoom_x) >> 8;  /*Gap between the column on ~adjacent X*/
         lv_coord_t block_w = (w - ((chart->point_cnt - 1) * block_gap)) / chart->point_cnt;
         lv_coord_t col_w = block_w / ser_cnt;
 
@@ -303,11 +314,12 @@ void lv_chart_get_point_pos_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint1
     p_out->x += lv_obj_get_style_pad_left(obj, LV_PART_MAIN) + border_width;
     p_out->x -= lv_obj_get_scroll_left(obj);
 
-    p_out->y = (int32_t)((int32_t)ser->y_points[id] - chart->ymin[ser->y_axis_sec]) * h;
-    p_out->y = p_out->y / (chart->ymax[ser->y_axis_sec] - chart->ymin[ser->y_axis_sec]);
-    p_out->y = h - p_out->y;
+    int32_t temp_y = 0;
+    temp_y = (int32_t)((int32_t)ser->y_points[id] - chart->ymin[ser->y_axis_sec]) * h;
+    temp_y = temp_y / (chart->ymax[ser->y_axis_sec] - chart->ymin[ser->y_axis_sec]);
+    p_out->y = h - temp_y;
     p_out->y += lv_obj_get_style_pad_top(obj, LV_PART_MAIN) + border_width;
-
+    p_out->y -= lv_obj_get_scroll_top(obj);
 }
 
 void lv_chart_refresh(lv_obj_t * obj)
@@ -323,7 +335,7 @@ void lv_chart_refresh(lv_obj_t * obj)
 
 lv_chart_series_t * lv_chart_add_series(lv_obj_t * obj, lv_color_t color, lv_chart_axis_t axis)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
 
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
@@ -560,7 +572,8 @@ void lv_chart_set_value_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t
     ser->y_points[id] = value;
 }
 
-void lv_chart_set_value_by_id2(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t id, lv_coord_t x_value, lv_coord_t y_value)
+void lv_chart_set_value_by_id2(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t id, lv_coord_t x_value,
+                               lv_coord_t y_value)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
     LV_ASSERT_NULL(ser);
@@ -702,18 +715,24 @@ static void lv_chart_event(const lv_obj_class_t * class_p, lv_event_t * e)
             chart->pressed_point_id = id;
             lv_event_send(obj, LV_EVENT_VALUE_CHANGED, NULL);
         }
-    } else if(code == LV_EVENT_RELEASED) {
+    }
+    else if(code == LV_EVENT_RELEASED) {
         invalidate_point(obj, chart->pressed_point_id);
         chart->pressed_point_id = LV_CHART_POINT_NONE;
-    } else if(code == LV_EVENT_SIZE_CHANGED) {
+    }
+    else if(code == LV_EVENT_SIZE_CHANGED) {
         lv_obj_refresh_self_size(obj);
-    } else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
-        lv_event_set_ext_draw_size(e, LV_MAX4(chart->tick[0].draw_size, chart->tick[1].draw_size, chart->tick[2].draw_size, chart->tick[3].draw_size));
-    } else if(code == LV_EVENT_GET_SELF_SIZE) {
+    }
+    else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
+        lv_event_set_ext_draw_size(e, LV_MAX4(chart->tick[0].draw_size, chart->tick[1].draw_size, chart->tick[2].draw_size,
+                                              chart->tick[3].draw_size));
+    }
+    else if(code == LV_EVENT_GET_SELF_SIZE) {
         lv_point_t * p = lv_event_get_param(e);
-        p->x = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
-        p->y = (lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
-    } else if(code == LV_EVENT_DRAW_MAIN) {
+        p->x = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+        p->y = ((int32_t)lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
         const lv_area_t * clip_area = lv_event_get_param(e);
         draw_div_lines(obj, clip_area);
         draw_axes(obj, clip_area);
@@ -744,17 +763,23 @@ static void draw_div_lines(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
     lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN) + border_width;
     lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_PART_MAIN) + border_width;
-    lv_coord_t w     = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
-    lv_coord_t h     = (lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
+    lv_coord_t w     = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+    lv_coord_t h     = ((int32_t)lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
 
     lv_draw_line_dsc_t line_dsc;
     lv_draw_line_dsc_init(&line_dsc);
     lv_obj_init_draw_line_dsc(obj, LV_PART_MAIN, &line_dsc);
 
-    lv_obj_draw_part_dsc_t obj_draw_dsc;
-    lv_obj_draw_dsc_init(&obj_draw_dsc, clip_area);
-    obj_draw_dsc.line_dsc = &line_dsc;
-    obj_draw_dsc.part = LV_PART_MAIN;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.part = LV_PART_MAIN;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_CHART_DRAW_PART_DIV_LINE_INIT;
+    part_draw_dsc.line_dsc = &line_dsc;
+    part_draw_dsc.id = 0xFFFFFFFF;
+    part_draw_dsc.p1 = NULL;
+    part_draw_dsc.p2 = NULL;
+    lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
     lv_opa_t border_opa = lv_obj_get_style_border_opa(obj, LV_PART_MAIN);
     lv_coord_t border_w = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
@@ -775,17 +800,19 @@ static void draw_div_lines(lv_obj_t * obj, const lv_area_t * clip_area)
         }
 
         for(i = i_start; i < i_end; i++) {
-            p1.y = (int32_t)((int32_t)(h - line_dsc.width) * i) / (chart->hdiv_cnt - 1);
+            p1.y = (int32_t)((int32_t)h * i) / (chart->hdiv_cnt - 1);
             p1.y += y_ofs;
             p2.y = p1.y;
 
-            obj_draw_dsc.p1 = &p1;
-            obj_draw_dsc.p2 = &p2;
-            obj_draw_dsc.id = i;
+            part_draw_dsc.class_p = MY_CLASS;
+            part_draw_dsc.type = LV_CHART_DRAW_PART_DIV_LINE_HOR;
+            part_draw_dsc.p1 = &p1;
+            part_draw_dsc.p2 = &p2;
+            part_draw_dsc.id = i;
 
-            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &obj_draw_dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
             lv_draw_line(&p1, &p2, &series_mask, &line_dsc);
-            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &obj_draw_dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
         }
     }
 
@@ -801,19 +828,27 @@ static void draw_div_lines(lv_obj_t * obj, const lv_area_t * clip_area)
         }
 
         for(i = i_start; i < i_end; i++) {
-            p1.x = (int32_t)((int32_t)(w - line_dsc.width) * i) / (chart->vdiv_cnt - 1);
+            p1.x = (int32_t)((int32_t)w * i) / (chart->vdiv_cnt - 1);
             p1.x += x_ofs;
             p2.x = p1.x;
 
-            obj_draw_dsc.p1 = &p1;
-            obj_draw_dsc.p2 = &p2;
-            obj_draw_dsc.id = i;
+            part_draw_dsc.class_p = MY_CLASS;
+            part_draw_dsc.type = LV_CHART_DRAW_PART_DIV_LINE_VER;
+            part_draw_dsc.p1 = &p1;
+            part_draw_dsc.p2 = &p2;
+            part_draw_dsc.id = i;
 
-            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &obj_draw_dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
             lv_draw_line(&p1, &p2, &series_mask, &line_dsc);
-            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &obj_draw_dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
         }
     }
+
+    part_draw_dsc.id = 0xFFFFFFFF;
+    part_draw_dsc.p1 = NULL;
+    part_draw_dsc.p2 = NULL;
+    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
+
 }
 
 static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area)
@@ -822,6 +857,7 @@ static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area)
     if(_lv_area_intersect(&com_area, &obj->coords, clip_area) == false) return;
 
     lv_chart_t * chart  = (lv_chart_t *)obj;
+    if(chart->point_cnt < 2) return;
 
     uint16_t i;
     lv_point_t p1;
@@ -829,8 +865,8 @@ static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
     lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN) + border_width;
     lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_PART_MAIN) + border_width;
-    lv_coord_t w     = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
-    lv_coord_t h     = (lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
+    lv_coord_t w     = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+    lv_coord_t h     = ((int32_t)lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
     lv_coord_t x_ofs = obj->coords.x1 + pad_left - lv_obj_get_scroll_left(obj);
     lv_coord_t y_ofs = obj->coords.y1 + pad_top - lv_obj_get_scroll_top(obj);
     lv_chart_series_t * ser;
@@ -859,7 +895,7 @@ static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area)
 
     /*Go through all data lines*/
     _LV_LL_READ_BACK(&chart->series_ll, ser) {
-        if (ser->hidden) continue;
+        if(ser->hidden) continue;
         line_dsc_default.color = ser->color;
         point_dsc_default.bg_color = ser->color;
 
@@ -874,12 +910,14 @@ static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area)
         y_tmp  = y_tmp / (chart->ymax[ser->y_axis_sec] - chart->ymin[ser->y_axis_sec]);
         p2.y   = h - y_tmp + y_ofs;
 
-        lv_obj_draw_part_dsc_t dsc;
-        lv_obj_draw_dsc_init(&dsc, clip_area);
-        dsc.part = LV_PART_ITEMS;
-        dsc.line_dsc = &line_dsc_default;
-        dsc.rect_dsc = &point_dsc_default;
-        dsc.sub_part_ptr = ser;
+        lv_obj_draw_part_dsc_t part_draw_dsc;
+        lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+        part_draw_dsc.class_p = MY_CLASS;
+        part_draw_dsc.type = LV_CHART_DRAW_PART_LINE_AND_POINT;
+        part_draw_dsc.part = LV_PART_ITEMS;
+        part_draw_dsc.line_dsc = &line_dsc_default;
+        part_draw_dsc.rect_dsc = &point_dsc_default;
+        part_draw_dsc.sub_part_ptr = ser;
 
         lv_coord_t y_min = p2.y;
         lv_coord_t y_max = p2.y;
@@ -906,7 +944,7 @@ static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area)
             if(i != 0) {
                 if(crowded_mode) {
                     if(ser->y_points[p_prev] != LV_CHART_POINT_NONE && ser->y_points[p_act] != LV_CHART_POINT_NONE) {
-                        /*Draw only one vertical line between the min an max y values on the same x value*/
+                        /*Draw only one vertical line between the min and max y-values on the same x-value*/
                         y_max = LV_MAX(y_max, p2.y);
                         y_min = LV_MIN(y_min, p2.y);
                         if(p1.x != p2.x) {
@@ -922,30 +960,31 @@ static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area)
                             y_max = y_cur;
                         }
                     }
-                } else {
+                }
+                else {
                     lv_area_t point_area;
                     point_area.x1 = p1.x - point_w;
                     point_area.x2 = p1.x + point_w;
                     point_area.y1 = p1.y - point_h;
                     point_area.y2 = p1.y + point_h;
 
-                    dsc.id = i - 1;
-                    dsc.p1 = ser->y_points[p_prev] != LV_CHART_POINT_NONE ? &p1 : NULL;
-                    dsc.p2 = ser->y_points[p_act] != LV_CHART_POINT_NONE ? &p2 : NULL;
-                    dsc.draw_area = &point_area;
-                    dsc.value = ser->y_points[p_prev];
+                    part_draw_dsc.id = i - 1;
+                    part_draw_dsc.p1 = ser->y_points[p_prev] != LV_CHART_POINT_NONE ? &p1 : NULL;
+                    part_draw_dsc.p2 = ser->y_points[p_act] != LV_CHART_POINT_NONE ? &p2 : NULL;
+                    part_draw_dsc.draw_area = &point_area;
+                    part_draw_dsc.value = ser->y_points[p_prev];
 
-                    lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+                    lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
                     if(ser->y_points[p_prev] != LV_CHART_POINT_NONE && ser->y_points[p_act] != LV_CHART_POINT_NONE) {
                         lv_draw_line(&p1, &p2, &series_mask, &line_dsc_default);
                     }
 
-                    if(point_w && point_h && ser->y_points[p_act] != LV_CHART_POINT_NONE) {
+                    if(point_w && point_h && ser->y_points[p_prev] != LV_CHART_POINT_NONE) {
                         lv_draw_rect(&point_area, &series_mask, &point_dsc_default);
                     }
 
-                    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+                    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
                 }
 
             }
@@ -962,14 +1001,14 @@ static void draw_series_line(lv_obj_t * obj, const lv_area_t * clip_area)
                 point_area.y1 = p2.y - point_h;
                 point_area.y2 = p2.y + point_h;
 
-                dsc.id = i - 1;
-                dsc.p1 = NULL;
-                dsc.p2 = NULL;
-                dsc.draw_area = &point_area;
-                dsc.value = ser->y_points[p_act];
-                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+                part_draw_dsc.id = i - 1;
+                part_draw_dsc.p1 = NULL;
+                part_draw_dsc.p2 = NULL;
+                part_draw_dsc.draw_area = &point_area;
+                part_draw_dsc.value = ser->y_points[p_act];
+                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
                 lv_draw_rect(&point_area, &series_mask, &point_dsc_default);
-                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
             }
         }
     }
@@ -989,8 +1028,8 @@ static void draw_series_scatter(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
     lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN);
     lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_PART_MAIN);
-    lv_coord_t w     = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
-    lv_coord_t h     = (lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
+    lv_coord_t w     = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+    lv_coord_t h     = ((int32_t)lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
     lv_coord_t x_ofs = obj->coords.x1 + pad_left + border_width - lv_obj_get_scroll_left(obj);
     lv_coord_t y_ofs = obj->coords.y1 + pad_top + border_width - lv_obj_get_scroll_top(obj);
     lv_chart_series_t * ser;
@@ -1016,7 +1055,7 @@ static void draw_series_scatter(lv_obj_t * obj, const lv_area_t * clip_area)
 
     /*Go through all data lines*/
     _LV_LL_READ_BACK(&chart->series_ll, ser) {
-        if (ser->hidden) continue;
+        if(ser->hidden) continue;
         line_dsc_default.color = ser->color;
         point_dsc_default.bg_color = ser->color;
 
@@ -1034,17 +1073,20 @@ static void draw_series_scatter(lv_obj_t * obj, const lv_area_t * clip_area)
             p2.y = lv_map(ser->y_points[p_act], chart->ymin[ser->y_axis_sec], chart->ymax[ser->y_axis_sec], 0, h);
             p2.y = h - p2.y;
             p2.y += y_ofs;
-        } else {
+        }
+        else {
             p2.x = LV_COORD_MIN;
             p2.y = LV_COORD_MIN;
         }
 
-        lv_obj_draw_part_dsc_t dsc;
-        lv_obj_draw_dsc_init(&dsc, clip_area);
-        dsc.part = LV_PART_ITEMS;
-        dsc.line_dsc = &line_dsc_default;
-        dsc.rect_dsc = &point_dsc_default;
-        dsc.sub_part_ptr = ser;
+        lv_obj_draw_part_dsc_t part_draw_dsc;
+        lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+        part_draw_dsc.part = LV_PART_ITEMS;
+        part_draw_dsc.class_p = MY_CLASS;
+        part_draw_dsc.type = LV_CHART_DRAW_PART_LINE_AND_POINT;
+        part_draw_dsc.line_dsc = &line_dsc_default;
+        part_draw_dsc.rect_dsc = &point_dsc_default;
+        part_draw_dsc.sub_part_ptr = ser;
 
         for(i = 0; i < chart->point_cnt; i++) {
             p1.x = p2.x;
@@ -1058,7 +1100,8 @@ static void draw_series_scatter(lv_obj_t * obj, const lv_area_t * clip_area)
 
                 p2.x = lv_map(ser->x_points[p_act], chart->xmin[ser->x_axis_sec], chart->xmax[ser->x_axis_sec], 0, w);
                 p2.x += x_ofs;
-            } else {
+            }
+            else {
                 p_prev = p_act;
                 continue;
             }
@@ -1071,13 +1114,13 @@ static void draw_series_scatter(lv_obj_t * obj, const lv_area_t * clip_area)
                 point_area.y1 = p1.y - point_h;
                 point_area.y2 = p1.y + point_h;
 
-                dsc.id = i - 1;
-                dsc.p1 = ser->y_points[p_prev] != LV_CHART_POINT_NONE ? &p1 : NULL;
-                dsc.p2 = ser->y_points[p_act] != LV_CHART_POINT_NONE ? &p2 : NULL;
-                dsc.draw_area = &point_area;
-                dsc.value = ser->y_points[p_prev];
+                part_draw_dsc.id = i - 1;
+                part_draw_dsc.p1 = ser->y_points[p_prev] != LV_CHART_POINT_NONE ? &p1 : NULL;
+                part_draw_dsc.p2 = ser->y_points[p_act] != LV_CHART_POINT_NONE ? &p2 : NULL;
+                part_draw_dsc.draw_area = &point_area;
+                part_draw_dsc.value = ser->y_points[p_prev];
 
-                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
                 if(ser->y_points[p_prev] != LV_CHART_POINT_NONE && ser->y_points[p_act] != LV_CHART_POINT_NONE) {
                     lv_draw_line(&p1, &p2, &series_mask, &line_dsc_default);
@@ -1086,7 +1129,7 @@ static void draw_series_scatter(lv_obj_t * obj, const lv_area_t * clip_area)
                     }
                 }
 
-                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
             }
             p_prev = p_act;
         }
@@ -1101,14 +1144,14 @@ static void draw_series_scatter(lv_obj_t * obj, const lv_area_t * clip_area)
                 point_area.y1 = p2.y - point_h;
                 point_area.y2 = p2.y + point_h;
 
-                dsc.id = i - 1;
-                dsc.p1 = NULL;
-                dsc.p2 = NULL;
-                dsc.draw_area = &point_area;
-                dsc.value = ser->y_points[p_act];
-                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+                part_draw_dsc.id = i - 1;
+                part_draw_dsc.p1 = NULL;
+                part_draw_dsc.p2 = NULL;
+                part_draw_dsc.draw_area = &point_area;
+                part_draw_dsc.value = ser->y_points[p_act];
+                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
                 lv_draw_rect(&point_area, &series_mask, &point_dsc_default);
-                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
             }
         }
     }
@@ -1125,15 +1168,17 @@ static void draw_series_bar(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_area_t col_a;
     lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN);
     lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_PART_MAIN);
-    lv_coord_t w     = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
-    lv_coord_t h     = (lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
+    lv_coord_t w     = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+    lv_coord_t h     = ((int32_t)lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
     int32_t y_tmp;
     lv_chart_series_t * ser;
     uint32_t ser_cnt = _lv_ll_get_len(&chart->series_ll);
-    int32_t block_gap = (lv_obj_get_style_pad_column(obj, LV_PART_MAIN) * chart->zoom_x) >> 8;  /*Gap between the column on ~adjacent X*/
+    int32_t block_gap = ((int32_t)lv_obj_get_style_pad_column(obj,
+                                                              LV_PART_MAIN) * chart->zoom_x) >> 8;  /*Gap between the column on ~adjacent X*/
     lv_coord_t block_w = (w - ((chart->point_cnt - 1) * block_gap)) / chart->point_cnt;
     lv_coord_t col_w = block_w / ser_cnt;
-    int32_t ser_gap = (lv_obj_get_style_pad_column(obj, LV_PART_ITEMS) * chart->zoom_x) >> 8; /*Gap between the column on the ~same X*/
+    int32_t ser_gap = ((int32_t)lv_obj_get_style_pad_column(obj,
+                                                            LV_PART_ITEMS) * chart->zoom_x) >> 8; /*Gap between the column on the ~same X*/
     lv_coord_t x_ofs = pad_left - lv_obj_get_scroll_left(obj);
     lv_coord_t y_ofs = pad_top - lv_obj_get_scroll_top(obj);
 
@@ -1150,19 +1195,21 @@ static void draw_series_bar(lv_obj_t * obj, const lv_area_t * clip_area)
     bool mask_ret = _lv_area_intersect(&series_mask, &obj->coords, clip_area);
     if(mask_ret == false) return;
 
-    lv_obj_draw_part_dsc_t dsc;
-    lv_obj_draw_dsc_init(&dsc, &series_mask);
-    dsc.part = LV_PART_ITEMS;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, &series_mask);
+    part_draw_dsc.part = LV_PART_ITEMS;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_CHART_DRAW_PART_BAR;
 
     /*Go through all points*/
     for(i = 0; i < chart->point_cnt; i++) {
         lv_coord_t x_act = (int32_t)((int32_t)(w + block_gap) * i) / (chart->point_cnt) + obj->coords.x1 + x_ofs;
 
-        dsc.id = i;
+        part_draw_dsc.id = i;
 
         /*Draw the current point of all data line*/
         _LV_LL_READ_BACK(&chart->series_ll, ser) {
-            if (ser->hidden) continue;
+            if(ser->hidden) continue;
             lv_coord_t start_point = chart->update_mode == LV_CHART_UPDATE_MODE_SHIFT ? ser->start_point : 0;
 
             col_a.x1 = x_act;
@@ -1180,13 +1227,13 @@ static void draw_series_bar(lv_obj_t * obj, const lv_area_t * clip_area)
             col_a.y1         = h - y_tmp + obj->coords.y1 + y_ofs;
 
             if(ser->y_points[p_act] != LV_CHART_POINT_NONE) {
-                dsc.draw_area = &col_a;
-                dsc.rect_dsc = &col_dsc;
-                dsc.sub_part_ptr = ser;
-                dsc.value = ser->y_points[p_act];
-                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+                part_draw_dsc.draw_area = &col_a;
+                part_draw_dsc.rect_dsc = &col_dsc;
+                part_draw_dsc.sub_part_ptr = ser;
+                part_draw_dsc.value = ser->y_points[p_act];
+                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
                 lv_draw_rect(&col_a, &series_mask, &col_dsc);
-                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
             }
         }
     }
@@ -1218,11 +1265,13 @@ static void draw_cursors(lv_obj_t * obj, const lv_area_t * clip_area)
     lv_coord_t point_w = lv_obj_get_style_width(obj, LV_PART_CURSOR) / 2;
     lv_coord_t point_h = lv_obj_get_style_width(obj, LV_PART_CURSOR) / 2;
 
-    lv_obj_draw_part_dsc_t dsc;
-    lv_obj_draw_dsc_init(&dsc, clip_area);
-    dsc.line_dsc = &line_dsc_tmp;
-    dsc.rect_dsc = &point_dsc_tmp;
-    dsc.part = LV_PART_CURSOR;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.line_dsc = &line_dsc_tmp;
+    part_draw_dsc.rect_dsc = &point_dsc_tmp;
+    part_draw_dsc.part = LV_PART_CURSOR;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_CHART_DRAW_PART_CURSOR;
 
     lv_area_t clip_area2;
     _lv_area_intersect(&clip_area2, clip_area, &obj->coords);
@@ -1234,15 +1283,16 @@ static void draw_cursors(lv_obj_t * obj, const lv_area_t * clip_area)
         line_dsc_tmp.color = cursor->color;
         point_dsc_tmp.bg_color = cursor->color;
 
-        dsc.p1 = &p1;
-        dsc.p2 = &p2;
+        part_draw_dsc.p1 = &p1;
+        part_draw_dsc.p2 = &p2;
 
         lv_coord_t cx;
         lv_coord_t cy;
         if(cursor->pos_set) {
             cx = cursor->pos.x;
             cy = cursor->pos.y;
-        } else {
+        }
+        else {
             if(cursor->point_id == LV_CHART_POINT_NONE) continue;
             lv_point_t p;
             lv_chart_get_point_pos_by_id(obj, cursor->ser, cursor->point_id, &p);
@@ -1253,15 +1303,29 @@ static void draw_cursors(lv_obj_t * obj, const lv_area_t * clip_area)
         cx += obj->coords.x1;
         cy += obj->coords.y1;
 
+        lv_area_t point_area;
+        if(point_w && point_h) {
+            point_area.x1 = cx - point_w;
+            point_area.x2 = cx + point_w;
+            point_area.y1 = cy - point_h;
+            point_area.y2 = cy + point_h;
+
+            part_draw_dsc.draw_area = &point_area;
+        }
+        else {
+            part_draw_dsc.draw_area = NULL;
+        }
+
         if(cursor->dir & LV_DIR_HOR) {
             p1.x = cursor->dir & LV_DIR_LEFT ? obj->coords.x1 : cx;
             p1.y = cy;
             p2.x = cursor->dir & LV_DIR_RIGHT ? obj->coords.x2 : cx;
             p2.y = p1.y;
 
-            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
             lv_draw_line(&p1, &p2, &clip_area2, &line_dsc_tmp);
-            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+            lv_draw_rect(&point_area, &clip_area2, &point_dsc_tmp);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
         }
 
         if(cursor->dir & LV_DIR_VER) {
@@ -1270,27 +1334,12 @@ static void draw_cursors(lv_obj_t * obj, const lv_area_t * clip_area)
             p2.x = p1.x;
             p2.y = cursor->dir & LV_DIR_BOTTOM ? obj->coords.y2 : cy;
 
-            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
             lv_draw_line(&p1, &p2, &clip_area2, &line_dsc_tmp);
-            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
-        }
-
-        if(point_w && point_h) {
-            lv_area_t point_area;
-
-            point_area.x1 = cx - point_w;
-            point_area.x2 = cx + point_w;
-            point_area.y1 = cy - point_h;
-            point_area.y2 = cy + point_h;
-
-            dsc.draw_area = &point_area;
-            dsc.p1 = NULL;
-            dsc.p2 = NULL;
-
-            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
             lv_draw_rect(&point_area, &clip_area2, &point_dsc_tmp);
-            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
         }
+
     }
 }
 
@@ -1312,7 +1361,7 @@ static void draw_y_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
 
     lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
     lv_coord_t pad_top = lv_obj_get_style_pad_top(obj, LV_PART_MAIN);
-    lv_coord_t h     = (lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
+    lv_coord_t h     = ((int32_t)lv_obj_get_content_height(obj) * chart->zoom_y) >> 8;
     lv_coord_t y_ofs = obj->coords.y1 + pad_top + border_width - lv_obj_get_scroll_top(obj);
 
     lv_coord_t label_gap;
@@ -1320,7 +1369,8 @@ static void draw_y_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
     if(axis == LV_CHART_AXIS_PRIMARY_Y) {
         label_gap = lv_obj_get_style_pad_left(obj, LV_PART_TICKS);
         x_ofs = obj->coords.x1;
-    } else {
+    }
+    else {
         label_gap = lv_obj_get_style_pad_right(obj, LV_PART_TICKS);
         x_ofs = obj->coords.x2;
     }
@@ -1341,12 +1391,14 @@ static void draw_y_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
     lv_draw_label_dsc_init(&label_dsc);
     lv_obj_init_draw_label_dsc(obj, LV_PART_TICKS, &label_dsc);
 
-    lv_obj_draw_part_dsc_t dsc;
-    lv_obj_draw_dsc_init(&dsc, clip_area);
-    dsc.id = axis;
-    dsc.part = LV_PART_TICKS;
-    dsc.line_dsc = &line_dsc;
-    dsc.label_dsc = &label_dsc;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_CHART_DRAW_PART_TICK_LABEL;
+    part_draw_dsc.id = axis;
+    part_draw_dsc.part = LV_PART_TICKS;
+    part_draw_dsc.line_dsc = &line_dsc;
+    part_draw_dsc.label_dsc = &label_dsc;
 
     uint32_t total_tick_num = (t->major_cnt - 1) * (t->minor_cnt);
     for(i = 0; i <= total_tick_num; i++) {
@@ -1367,22 +1419,25 @@ static void draw_y_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
         if(major) p2.x = p1.x - major_len; /*major tick*/
         else p2.x = p1.x - minor_len; /*minor tick*/
 
-        if(p1.y + line_dsc.width / 2  >= obj->coords.y1 &&
-           p2.y - line_dsc.width / 2  <= obj->coords.y2)
-        {
-            lv_draw_line(&p1, &p2, clip_area, &line_dsc);
-        }
+        part_draw_dsc.p1 = &p1;
+        part_draw_dsc.p2 = &p2;
+
+        int32_t tick_value = lv_map(total_tick_num - i, 0, total_tick_num, chart->ymin[sec_axis], chart->ymax[sec_axis]);
+        part_draw_dsc.value = tick_value;
 
         /*add text only to major tick*/
-        if(major  && t->label_en)  {
-            int32_t tick_value = lv_map(total_tick_num - i, 0, total_tick_num, chart->ymin[sec_axis], chart->ymax[sec_axis]);
-            lv_snprintf(dsc.text, sizeof(dsc.text), "%d", tick_value);
-            dsc.value = tick_value;
-            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+        if(major && t->label_en)  {
+            char buf[LV_CHART_LABEL_MAX_TEXT_LENGTH];
+            lv_snprintf(buf, sizeof(buf), "%" LV_PRId32, tick_value);
+            part_draw_dsc.label_dsc = &label_dsc;
+            part_draw_dsc.text = buf;
+            part_draw_dsc.text_length = LV_CHART_LABEL_MAX_TEXT_LENGTH;
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
             /*reserve appropriate area*/
             lv_point_t size;
-            lv_txt_get_size(&size, dsc.text, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
+            lv_txt_get_size(&size, part_draw_dsc.text, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
+                            LV_TEXT_FLAG_NONE);
 
             /*set the area at some distance of the major tick len left of the tick*/
             lv_area_t a;
@@ -1399,12 +1454,23 @@ static void draw_y_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
             }
 
             if(a.y2 >= obj->coords.y1 &&
-               a.y1  <= obj->coords.y2)
-            {
-                lv_draw_label(&a, clip_area, &label_dsc, dsc.text, NULL);
+               a.y1  <= obj->coords.y2) {
+                lv_draw_label(&a, clip_area, &label_dsc, part_draw_dsc.text, NULL);
             }
-            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
         }
+        else {
+            part_draw_dsc.label_dsc = NULL;
+            part_draw_dsc.text = NULL;
+            part_draw_dsc.text_length = 0;
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
+        }
+
+        if(p1.y + line_dsc.width / 2  >= obj->coords.y1 &&
+           p2.y - line_dsc.width / 2  <= obj->coords.y2) {
+            lv_draw_line(&p1, &p2, clip_area, &line_dsc);
+        }
+
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
     }
 }
 
@@ -1421,7 +1487,7 @@ static void draw_x_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
     lv_point_t p2;
 
     lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN) + lv_obj_get_style_border_width(obj, LV_PART_MAIN);
-    lv_coord_t w     = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+    lv_coord_t w     = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
 
 
     lv_draw_label_dsc_t label_dsc;
@@ -1434,7 +1500,8 @@ static void draw_x_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
     if(axis == LV_CHART_AXIS_PRIMARY_X) {
         label_gap = t->label_en ? lv_obj_get_style_pad_bottom(obj, LV_PART_TICKS) : 0;
         y_ofs = obj->coords.y2;
-    } else {
+    }
+    else {
         label_gap = t->label_en ? lv_obj_get_style_pad_top(obj, LV_PART_TICKS) : 0;
         y_ofs = obj->coords.y1;
     }
@@ -1450,18 +1517,21 @@ static void draw_x_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
     line_dsc.dash_gap = 0;
     line_dsc.dash_width = 0;
 
-    lv_obj_draw_part_dsc_t dsc;
-    lv_obj_draw_dsc_init(&dsc, clip_area);
-    dsc.id = LV_CHART_AXIS_PRIMARY_X;
-    dsc.part = LV_PART_TICKS;
-    dsc.label_dsc = &label_dsc;
-    dsc.line_dsc = &line_dsc;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_CHART_DRAW_PART_TICK_LABEL;
+    part_draw_dsc.id = LV_CHART_AXIS_PRIMARY_X;
+    part_draw_dsc.part = LV_PART_TICKS;
+    part_draw_dsc.label_dsc = &label_dsc;
+    part_draw_dsc.line_dsc = &line_dsc;
 
     uint8_t sec_axis = axis == LV_CHART_AXIS_PRIMARY_X ? 0 : 1;
 
     /*The columns ticks should be aligned to the center of blocks*/
     if(chart->type == LV_CHART_TYPE_BAR) {
-        int32_t block_gap = (lv_obj_get_style_pad_column(obj, LV_PART_MAIN) * chart->zoom_x) >> 8;  /*Gap between the columns on ~adjacent X*/
+        int32_t block_gap = ((int32_t)lv_obj_get_style_pad_column(obj,
+                                                                  LV_PART_MAIN) * chart->zoom_x) >> 8;  /*Gap between the columns on ~adjacent X*/
         lv_coord_t block_w = (w + block_gap) / (chart->point_cnt);
         x_ofs += (block_w - block_gap) / 2;
         w -= block_w - block_gap;
@@ -1479,49 +1549,65 @@ static void draw_x_ticks(lv_obj_t * obj, const lv_area_t * clip_area, lv_chart_a
         if(sec_axis) p2.y = p1.y - (major ? t->major_len : t->minor_len);
         else p2.y = p1.y + (major ? t->major_len : t->minor_len);
 
-        if(p1.x + line_dsc.width / 2  >= obj->coords.x1 &&
-           p2.x - line_dsc.width / 2  <= obj->coords.x2)
-        {
-            lv_draw_line(&p1, &p2, clip_area, &line_dsc);
-        }
+        part_draw_dsc.p1 = &p1;
+        part_draw_dsc.p2 = &p2;
 
         /*add text only to major tick*/
-        if(!major || !t->label_en) continue;
-
         int32_t tick_value;
         if(chart->type == LV_CHART_TYPE_SCATTER) {
             tick_value = lv_map(i, 0, total_tick_num, chart->xmin[sec_axis], chart->xmax[sec_axis]);
-        } else {
-            tick_value = i / t->minor_cnt;
-        }
-
-        lv_snprintf(dsc.text, sizeof(dsc.text), "%d", tick_value);
-        dsc.value = tick_value;
-        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
-
-        /*reserve appropriate area*/
-        lv_point_t size;
-        lv_txt_get_size(&size, dsc.text, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
-
-        /*set the area at some distance of the major tick len under of the tick*/
-        lv_area_t a;
-        a.x1 = (p2.x - size.x / 2);
-        a.x2 = (p2.x + size.x / 2);
-        if(sec_axis) {
-            a.y2 = p2.y - label_gap;
-            a.y1 = a.y2 - size.y;
         }
         else {
-            a.y1 = p2.y + label_gap;
-            a.y2 = a.y1 + size.y;
+            tick_value = i / t->minor_cnt;
+        }
+        part_draw_dsc.value = tick_value;
+
+        if(major && t->label_en) {
+            char buf[LV_CHART_LABEL_MAX_TEXT_LENGTH];
+            lv_snprintf(buf, sizeof(buf), "%" LV_PRId32, tick_value);
+            part_draw_dsc.label_dsc = &label_dsc;
+            part_draw_dsc.text = buf;
+            part_draw_dsc.text_length = LV_CHART_LABEL_MAX_TEXT_LENGTH;
+
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
+
+            /*reserve appropriate area*/
+            lv_point_t size;
+            lv_txt_get_size(&size, part_draw_dsc.text, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
+                            LV_TEXT_FLAG_NONE);
+
+            /*set the area at some distance of the major tick len under of the tick*/
+            lv_area_t a;
+            a.x1 = (p2.x - size.x / 2);
+            a.x2 = (p2.x + size.x / 2);
+            if(sec_axis) {
+                a.y2 = p2.y - label_gap;
+                a.y1 = a.y2 - size.y;
+            }
+            else {
+                a.y1 = p2.y + label_gap;
+                a.y2 = a.y1 + size.y;
+            }
+
+            if(a.x2 >= obj->coords.x1 &&
+               a.x1 <= obj->coords.x2) {
+                lv_draw_label(&a, clip_area, &label_dsc, part_draw_dsc.text, NULL);
+            }
+        }
+        else {
+            part_draw_dsc.label_dsc = NULL;
+            part_draw_dsc.text = NULL;
+            part_draw_dsc.text_length = 0;
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
         }
 
-        if(a.x2 >= obj->coords.x1 &&
-           a.x1 <= obj->coords.x2)
-        {
-            lv_draw_label(&a, clip_area, &label_dsc, dsc.text, NULL);
+
+        if(p1.x + line_dsc.width / 2  >= obj->coords.x1 &&
+           p2.x - line_dsc.width / 2  <= obj->coords.x2) {
+            lv_draw_line(&p1, &p2, clip_area, &line_dsc);
         }
-        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
     }
 }
 
@@ -1542,9 +1628,9 @@ static void draw_axes(lv_obj_t * obj, const lv_area_t * mask)
 static uint32_t get_index_from_x(lv_obj_t * obj, lv_coord_t x)
 {
     lv_chart_t * chart  = (lv_chart_t *)obj;
-    lv_coord_t w = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+    lv_coord_t w = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
     lv_coord_t pad_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN);
-    x-= pad_left;
+    x -= pad_left;
 
     if(x < 0) return 0;
     if(x > w) return chart->point_cnt - 1;
@@ -1559,7 +1645,7 @@ static void invalidate_point(lv_obj_t * obj, uint16_t i)
     lv_chart_t * chart  = (lv_chart_t *)obj;
     if(i >= chart->point_cnt) return;
 
-    lv_coord_t w  = (lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
+    lv_coord_t w  = ((int32_t)lv_obj_get_content_width(obj) * chart->zoom_x) >> 8;
     lv_coord_t scroll_left = lv_obj_get_scroll_left(obj);
 
     /*In shift mode the whole chart changes so the whole object*/
@@ -1594,7 +1680,8 @@ static void invalidate_point(lv_obj_t * obj, uint16_t i)
     }
     else if(chart->type == LV_CHART_TYPE_BAR) {
         lv_area_t col_a;
-        int32_t block_gap = (lv_obj_get_style_pad_column(obj, LV_PART_MAIN) * chart->zoom_x) >> 8;  /*Gap between the column on ~adjacent X*/
+        int32_t block_gap = ((int32_t)lv_obj_get_style_pad_column(obj,
+                                                                  LV_PART_MAIN) * chart->zoom_x) >> 8;  /*Gap between the column on ~adjacent X*/
         lv_coord_t block_w = (w + block_gap) / chart->point_cnt;
 
         lv_coord_t x_act;
@@ -1620,7 +1707,7 @@ static void new_points_alloc(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t c
 {
     if((*a) == NULL) return;
 
-    lv_chart_t * chart = (lv_chart_t*) obj;
+    lv_chart_t * chart = (lv_chart_t *) obj;
     uint32_t point_cnt_old = chart->point_cnt;
     uint32_t i;
 
@@ -1632,7 +1719,7 @@ static void new_points_alloc(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t c
         if(cnt >= point_cnt_old) {
             for(i = 0; i < point_cnt_old; i++) {
                 new_points[i] =
-                        (*a)[(i + ser->start_point) % point_cnt_old]; /*Copy old contents to new array*/
+                    (*a)[(i + ser->start_point) % point_cnt_old]; /*Copy old contents to new array*/
             }
             for(i = point_cnt_old; i < cnt; i++) {
                 new_points[i] = LV_CHART_POINT_NONE; /*Fill up the rest with default value*/
@@ -1641,7 +1728,7 @@ static void new_points_alloc(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t c
         else {
             for(i = 0; i < cnt; i++) {
                 new_points[i] =
-                        (*a)[(i + ser->start_point) % point_cnt_old]; /*Copy old contents to new array*/
+                    (*a)[(i + ser->start_point) % point_cnt_old]; /*Copy old contents to new array*/
             }
         }
 
@@ -1664,13 +1751,18 @@ static void new_points_alloc(lv_obj_t * obj, lv_chart_series_t * ser, uint32_t c
 
 lv_chart_tick_dsc_t * get_tick_gsc(lv_obj_t * obj, lv_chart_axis_t axis)
 {
-    lv_chart_t * chart = (lv_chart_t*) obj;
+    lv_chart_t * chart = (lv_chart_t *) obj;
     switch(axis) {
-        case LV_CHART_AXIS_PRIMARY_Y: return &chart->tick[0];
-        case LV_CHART_AXIS_PRIMARY_X: return &chart->tick[1];
-        case LV_CHART_AXIS_SECONDARY_Y: return &chart->tick[2];
-        case LV_CHART_AXIS_SECONDARY_X: return &chart->tick[3];
-        default: return NULL;
+        case LV_CHART_AXIS_PRIMARY_Y:
+            return &chart->tick[0];
+        case LV_CHART_AXIS_PRIMARY_X:
+            return &chart->tick[1];
+        case LV_CHART_AXIS_SECONDARY_Y:
+            return &chart->tick[2];
+        case LV_CHART_AXIS_SECONDARY_X:
+            return &chart->tick[3];
+        default:
+            return NULL;
     }
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/chart/lv_chart.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/chart/lv_chart.h
index 03b85e7d9..364c58d2d 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/chart/lv_chart.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/chart/lv_chart.h
@@ -82,17 +82,17 @@ typedef struct {
     lv_color_t color;
     lv_chart_series_t * ser;
     lv_dir_t dir;
-    uint8_t pos_set:1;  /*1: pos is set; 0: point_id is set*/
+    uint8_t pos_set: 1; /*1: pos is set; 0: point_id is set*/
 } lv_chart_cursor_t;
 
 typedef struct {
     lv_coord_t major_len;
     lv_coord_t minor_len;
     lv_coord_t draw_size;
-    uint32_t minor_cnt :15;
-    uint32_t major_cnt :15;
-    uint32_t label_en  :1;
-}lv_chart_tick_dsc_t;
+    uint32_t minor_cnt : 15;
+    uint32_t major_cnt : 15;
+    uint32_t label_en  : 1;
+} lv_chart_tick_dsc_t;
 
 
 typedef struct {
@@ -110,12 +110,26 @@ typedef struct {
     uint16_t point_cnt;    /**< Point number in a data line*/
     uint16_t zoom_x;
     uint16_t zoom_y;
-    lv_chart_type_t type  :3; /**< Line or column chart*/
+    lv_chart_type_t type  : 3; /**< Line or column chart*/
     lv_chart_update_mode_t update_mode : 1;
-}lv_chart_t;
+} lv_chart_t;
 
 extern const lv_obj_class_t lv_chart_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_chart_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_CHART_DRAW_PART_DIV_LINE_INIT,    /**< Used before/after drawn the div lines*/
+    LV_CHART_DRAW_PART_DIV_LINE_HOR,     /**< Used for each horizontal division lines*/
+    LV_CHART_DRAW_PART_DIV_LINE_VER,     /**< Used for each vertical division lines*/
+    LV_CHART_DRAW_PART_LINE_AND_POINT,   /**< Used on line and scatter charts for lines and points*/
+    LV_CHART_DRAW_PART_BAR,              /**< Used on bar charts for the rectangles*/
+    LV_CHART_DRAW_PART_CURSOR,           /**< Used on cursor lines and points*/
+    LV_CHART_DRAW_PART_TICK_LABEL,       /**< Used on tick lines and labels*/
+} lv_chart_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
@@ -204,7 +218,8 @@ uint16_t lv_chart_get_zoom_y(const lv_obj_t * obj);
  * @param draw_size     extra size required to draw the tick and labels
  *                      (start with 20 px and increase if the ticks/labels are clipped)
  */
-void lv_chart_set_axis_tick(lv_obj_t * obj, lv_chart_axis_t axis, lv_coord_t major_len, lv_coord_t minor_len, lv_coord_t major_cnt, lv_coord_t minor_cnt, bool label_en, lv_coord_t draw_size);
+void lv_chart_set_axis_tick(lv_obj_t * obj, lv_chart_axis_t axis, lv_coord_t major_len, lv_coord_t minor_len,
+                            lv_coord_t major_cnt, lv_coord_t minor_cnt, bool label_en, lv_coord_t draw_size);
 
 /**
  * Get the type of a chart
@@ -292,7 +307,7 @@ void lv_chart_set_x_start_point(lv_obj_t * obj, lv_chart_series_t * ser, uint16_
  * Get the next series.
  * @param chart     pointer to a chart
  * @param ser      the previous series or NULL to get the first
- * @return          the next series or NULL if thre is no more.
+ * @return          the next series or NULL if there is no more.
  */
 lv_chart_series_t * lv_chart_get_series_next(const lv_obj_t * chart, const lv_chart_series_t * ser);
 
@@ -326,7 +341,8 @@ void lv_chart_set_cursor_pos(lv_obj_t * chart, lv_chart_cursor_t * cursor, lv_po
  * @param ser       pointer to a series
  * @param point_id  the point's index or  `LV_CHART_POINT_NONE` to not assign to any points.
  */
-void lv_chart_set_cursor_point(lv_obj_t * chart, lv_chart_cursor_t * cursor, lv_chart_series_t * ser, uint16_t point_id);
+void lv_chart_set_cursor_point(lv_obj_t * chart, lv_chart_cursor_t * cursor, lv_chart_series_t * ser,
+                               uint16_t point_id);
 
 /**
  * Get the coordinate of the cursor with respect to the paddings
@@ -344,7 +360,7 @@ lv_point_t lv_chart_get_cursor_point(lv_obj_t * chart, lv_chart_cursor_t * curso
  * Initialize all data points of a series with a value
  * @param obj       pointer to chart object
  * @param ser       pointer to a data series on 'chart'
- * @param value     the new value for all points. `LV_CHART_POINT_DEF` can be used to hide the points.
+ * @param value     the new value for all points. `LV_CHART_POINT_NONE` can be used to hide the points.
  */
 void lv_chart_set_all_value(lv_obj_t * obj, lv_chart_series_t * ser, lv_coord_t value);
 
@@ -383,7 +399,8 @@ void lv_chart_set_value_by_id(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t
  * @param x_value   the new X value of the next data
  * @param y_value   the new Y value of the next data
  */
-void lv_chart_set_value_by_id2(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t id, lv_coord_t x_value, lv_coord_t y_value);
+void lv_chart_set_value_by_id2(lv_obj_t * obj, lv_chart_series_t * ser, uint16_t id, lv_coord_t x_value,
+                               lv_coord_t y_value);
 
 /**
  * Set an external array for the y data points to use for the chart
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/colorwheel/lv_colorwheel.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/colorwheel/lv_colorwheel.c
index 4d2853745..633ede7d1 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/colorwheel/lv_colorwheel.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/colorwheel/lv_colorwheel.c
@@ -10,6 +10,8 @@
 #include "lv_colorwheel.h"
 #if LV_USE_COLORWHEEL
 
+#include "../../../misc/lv_assert.h"
+
 /*********************
  *      DEFINES
  *********************/
@@ -50,12 +52,12 @@ static uint16_t get_angle(lv_obj_t * obj);
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_colorwheel_class = {.instance_size = sizeof(lv_colorwheel_t), .base_class = &lv_obj_class,
-        .constructor_cb = lv_colorwheel_constructor,
-        .event_cb = lv_colorwheel_event,
-        .width_def = LV_DPI_DEF * 2,
-        .height_def = LV_DPI_DEF * 2,
-        .editable = LV_OBJ_CLASS_EDITABLE_TRUE,
-};
+                                            .constructor_cb = lv_colorwheel_constructor,
+                                            .event_cb = lv_colorwheel_event,
+                                            .width_def = LV_DPI_DEF * 2,
+                                            .height_def = LV_DPI_DEF * 2,
+                                            .editable = LV_OBJ_CLASS_EDITABLE_TRUE,
+                                           };
 
 static bool create_knob_recolor;
 
@@ -74,7 +76,7 @@ static bool create_knob_recolor;
  */
 lv_obj_t * lv_colorwheel_create(lv_obj_t * parent, bool knob_recolor)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     create_knob_recolor = knob_recolor;
 
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
@@ -98,6 +100,7 @@ bool lv_colorwheel_set_hsv(lv_obj_t * obj, lv_color_hsv_t hsv)
     if(hsv.s > 100) hsv.s = 100;
     if(hsv.v > 100) hsv.v = 100;
 
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_colorwheel_t * colorwheel = (lv_colorwheel_t *)obj;
 
     if(colorwheel->hsv.h == hsv.h && colorwheel->hsv.s == hsv.s && colorwheel->hsv.v == hsv.v) return false;
@@ -132,6 +135,7 @@ bool lv_colorwheel_set_rgb(lv_obj_t * obj, lv_color_t color)
  */
 void lv_colorwheel_set_mode(lv_obj_t * obj, lv_colorwheel_mode_t mode)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_colorwheel_t * colorwheel = (lv_colorwheel_t *)obj;
 
     colorwheel->mode = mode;
@@ -146,6 +150,7 @@ void lv_colorwheel_set_mode(lv_obj_t * obj, lv_colorwheel_mode_t mode)
  */
 void lv_colorwheel_set_mode_fixed(lv_obj_t * obj, bool fixed)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_colorwheel_t * colorwheel = (lv_colorwheel_t *)obj;
 
     colorwheel->mode_fixed = fixed;
@@ -163,6 +168,7 @@ void lv_colorwheel_set_mode_fixed(lv_obj_t * obj, bool fixed)
  */
 lv_color_hsv_t lv_colorwheel_get_hsv(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_colorwheel_t * colorwheel = (lv_colorwheel_t *)obj;
 
     return colorwheel->hsv;
@@ -175,6 +181,7 @@ lv_color_hsv_t lv_colorwheel_get_hsv(lv_obj_t * obj)
  */
 lv_color_t lv_colorwheel_get_rgb(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_colorwheel_t * colorwheel = (lv_colorwheel_t *)obj;
 
     return lv_color_hsv_to_rgb(colorwheel->hsv.h, colorwheel->hsv.s, colorwheel->hsv.v);
@@ -187,6 +194,7 @@ lv_color_t lv_colorwheel_get_rgb(lv_obj_t * obj)
  */
 lv_colorwheel_mode_t lv_colorwheel_get_color_mode(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_colorwheel_t * colorwheel = (lv_colorwheel_t *)obj;
 
     return colorwheel->mode;
@@ -199,6 +207,7 @@ lv_colorwheel_mode_t lv_colorwheel_get_color_mode(lv_obj_t * obj)
  */
 bool lv_colorwheel_get_color_mode_fixed(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_colorwheel_t * colorwheel = (lv_colorwheel_t *)obj;
 
     return colorwheel->mode_fixed;
@@ -287,6 +296,8 @@ static void draw_disc_grad(lv_event_t * e)
     }
 
 #if LV_DRAW_COMPLEX
+    lv_draw_mask_free_param(&mask_out_param);
+    lv_draw_mask_free_param(&mask_in_param);
     lv_draw_mask_remove_id(mask_out_id);
     lv_draw_mask_remove_id(mask_in_id);
 #endif
@@ -588,7 +599,7 @@ static lv_res_t double_click_reset(lv_obj_t * obj)
 
 #define SWAPPTR(A, B) do { uint8_t * t = A; A = B; B = t; } while(0)
 #define HSV_PTR_SWAP(sextant,r,g,b)     if((sextant) & 2) { SWAPPTR((r), (b)); } if((sextant) & 4) { SWAPPTR((g), (b)); } if(!((sextant) & 6)) { \
-                                                if(!((sextant) & 1)) { SWAPPTR((r), (g)); } } else { if((sextant) & 1) { SWAPPTR((r), (g)); } }
+        if(!((sextant) & 1)) { SWAPPTR((r), (g)); } } else { if((sextant) & 1) { SWAPPTR((r), (g)); } }
 
 /**
  * Based on the idea from https://www.vagrearg.org/content/hsvrgb
@@ -602,10 +613,13 @@ static lv_res_t double_click_reset(lv_obj_t * obj)
  * We replace division by 255 by a division by 256, a.k.a a shift right by 8 bits.
  * This is wrong, but since this is only used to compute the pixels on the screen and not the final color, it's ok.
  */
-static void fast_hsv2rgb(uint16_t h, uint8_t s, uint8_t v, uint8_t *r, uint8_t *g , uint8_t *b);
-static void fast_hsv2rgb(uint16_t h, uint8_t s, uint8_t v, uint8_t *r, uint8_t *g , uint8_t *b)
+static void fast_hsv2rgb(uint16_t h, uint8_t s, uint8_t v, uint8_t * r, uint8_t * g, uint8_t * b);
+static void fast_hsv2rgb(uint16_t h, uint8_t s, uint8_t v, uint8_t * r, uint8_t * g, uint8_t * b)
 {
-    if (!s) { *r = *g = *b = v; return; }
+    if(!s) {
+        *r = *g = *b = v;
+        return;
+    }
 
     uint8_t sextant = h >> 8;
     HSV_PTR_SWAP(sextant, r, g, b); /*Swap pointers so the conversion code is the same*/
@@ -621,7 +635,8 @@ static void fast_hsv2rgb(uint16_t h, uint8_t s, uint8_t v, uint8_t *r, uint8_t *
     if(!(sextant & 1)) {
         /*Up slope*/
         ww = !h_frac ? ((uint16_t)s << 8) : (s * (uint8_t)(-h_frac)); /*Skip multiply if not required*/
-    } else {
+    }
+    else {
         /*Down slope*/
         ww = s * h_frac;
     }
@@ -633,7 +648,7 @@ static void fast_hsv2rgb(uint16_t h, uint8_t s, uint8_t v, uint8_t *r, uint8_t *
 
 static lv_color_t angle_to_mode_color_fast(lv_obj_t * obj, uint16_t angle)
 {
-    lv_colorwheel_t * ext = (lv_colorwheel_t*)obj;
+    lv_colorwheel_t * ext = (lv_colorwheel_t *)obj;
     uint8_t r = 0, g = 0, b = 0;
     static uint16_t h = 0;
     static uint8_t s = 0, v = 0, m = 255;
@@ -642,25 +657,29 @@ static lv_color_t angle_to_mode_color_fast(lv_obj_t * obj, uint16_t angle)
         default:
         case LV_COLORWHEEL_MODE_HUE:
             /*Don't recompute costly scaling if it does not change*/
-            if (m != ext->mode) {
-              s = (uint8_t)(((uint16_t)ext->hsv.s * 51) / 20); v = (uint8_t)(((uint16_t)ext->hsv.v * 51) / 20);
-              m = ext->mode;
+            if(m != ext->mode) {
+                s = (uint8_t)(((uint16_t)ext->hsv.s * 51) / 20);
+                v = (uint8_t)(((uint16_t)ext->hsv.v * 51) / 20);
+                m = ext->mode;
             }
-            fast_hsv2rgb(angle * 6, s, v, &r, &g, &b); /*A smart compiler will replace x * 6 by (x << 2) + (x << 1) if it's more efficient*/
+            fast_hsv2rgb(angle * 6, s, v, &r, &g,
+                         &b); /*A smart compiler will replace x * 6 by (x << 2) + (x << 1) if it's more efficient*/
             break;
         case LV_COLORWHEEL_MODE_SATURATION:
             /*Don't recompute costly scaling if it does not change*/
-            if (m != ext->mode) {
-              h = (uint16_t)(((uint32_t)ext->hsv.h * 6 * 256) / 360); v = (uint8_t)(((uint16_t)ext->hsv.v * 51) / 20);
-              m = ext->mode;
+            if(m != ext->mode) {
+                h = (uint16_t)(((uint32_t)ext->hsv.h * 6 * 256) / 360);
+                v = (uint8_t)(((uint16_t)ext->hsv.v * 51) / 20);
+                m = ext->mode;
             }
             fast_hsv2rgb(h, angle, v, &r, &g, &b);
             break;
         case LV_COLORWHEEL_MODE_VALUE:
             /*Don't recompute costly scaling if it does not change*/
-            if (m != ext->mode) {
-              h = (uint16_t)(((uint32_t)ext->hsv.h * 6 * 256) / 360); s = (uint8_t)(((uint16_t)ext->hsv.s * 51) / 20);
-              m = ext->mode;
+            if(m != ext->mode) {
+                h = (uint16_t)(((uint32_t)ext->hsv.h * 6 * 256) / 360);
+                s = (uint8_t)(((uint16_t)ext->hsv.s * 51) / 20);
+                m = ext->mode;
             }
             fast_hsv2rgb(h, s, angle, &r, &g, &b);
             break;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/imgbtn/lv_imgbtn.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/imgbtn/lv_imgbtn.c
index eaabade2b..964801f7c 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/imgbtn/lv_imgbtn.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/imgbtn/lv_imgbtn.c
@@ -34,10 +34,10 @@ lv_imgbtn_state_t get_state(const lv_obj_t * imgbtn);
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_imgbtn_class = {
-        .base_class = &lv_obj_class,
-        .instance_size = sizeof(lv_imgbtn_t),
-        .constructor_cb = lv_imgbtn_constructor,
-        .event_cb = lv_imgbtn_event,
+    .base_class = &lv_obj_class,
+    .instance_size = sizeof(lv_imgbtn_t),
+    .constructor_cb = lv_imgbtn_constructor,
+    .event_cb = lv_imgbtn_event,
 };
 
 /**********************
@@ -55,7 +55,7 @@ const lv_obj_class_t lv_imgbtn_class = {
  */
 lv_obj_t * lv_imgbtn_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -77,7 +77,7 @@ lv_obj_t * lv_imgbtn_create(lv_obj_t * parent)
  * to a file)
  */
 void lv_imgbtn_set_src(lv_obj_t * obj, lv_imgbtn_state_t state, const void * src_left, const void * src_mid,
-                             const void * src_right)
+                       const void * src_right)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
@@ -90,6 +90,23 @@ void lv_imgbtn_set_src(lv_obj_t * obj, lv_imgbtn_state_t state, const void * src
     refr_img(obj);
 }
 
+void lv_imgbtn_set_state(lv_obj_t * obj, lv_imgbtn_state_t state)
+{
+	LV_ASSERT_OBJ(obj, MY_CLASS);
+
+	lv_state_t obj_state = LV_STATE_DEFAULT;
+	if(state == LV_IMGBTN_STATE_PRESSED || state == LV_IMGBTN_STATE_CHECKED_PRESSED) obj_state |= LV_STATE_PRESSED;
+	if(state == LV_IMGBTN_STATE_DISABLED || state == LV_IMGBTN_STATE_CHECKED_DISABLED) obj_state |= LV_STATE_DISABLED;
+	if(state == LV_IMGBTN_STATE_CHECKED_DISABLED || state == LV_IMGBTN_STATE_CHECKED_PRESSED || state == LV_IMGBTN_STATE_CHECKED_RELEASED) {
+		obj_state |= LV_STATE_CHECKED;
+	}
+
+	lv_obj_clear_state(obj, LV_STATE_CHECKED | LV_STATE_PRESSED | LV_STATE_DISABLED);
+	lv_obj_add_state(obj, obj_state);
+
+	refr_img(obj);
+}
+
 /*=====================
  * Getter functions
  *====================*/
@@ -146,13 +163,13 @@ const void * lv_imgbtn_get_src_right(lv_obj_t * obj, lv_imgbtn_state_t state)
 static void lv_imgbtn_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 {
     LV_UNUSED(class_p);
-   lv_imgbtn_t * imgbtn = (lv_imgbtn_t *)obj;
-   /*Initialize the allocated 'ext'*/
-   lv_memset_00((void *)imgbtn->img_src_mid, sizeof(imgbtn->img_src_mid));
-   lv_memset_00(imgbtn->img_src_left, sizeof(imgbtn->img_src_left));
-   lv_memset_00(imgbtn->img_src_right, sizeof(imgbtn->img_src_right));
+    lv_imgbtn_t * imgbtn = (lv_imgbtn_t *)obj;
+    /*Initialize the allocated 'ext'*/
+    lv_memset_00((void *)imgbtn->img_src_mid, sizeof(imgbtn->img_src_mid));
+    lv_memset_00(imgbtn->img_src_left, sizeof(imgbtn->img_src_left));
+    lv_memset_00(imgbtn->img_src_right, sizeof(imgbtn->img_src_right));
 
-   imgbtn->act_cf = LV_IMG_CF_UNKNOWN;
+    imgbtn->act_cf = LV_IMG_CF_UNKNOWN;
 }
 
 
@@ -181,8 +198,7 @@ static void lv_imgbtn_event(const lv_obj_class_t * class_p, lv_event_t * e)
         lv_imgbtn_state_t state  = suggest_state(obj, get_state(obj));
         if(imgbtn->img_src_left[state] == NULL &&
            imgbtn->img_src_mid[state] != NULL &&
-           imgbtn->img_src_right[state] == NULL)
-        {
+           imgbtn->img_src_right[state] == NULL) {
             lv_img_header_t header;
             lv_img_decoder_get_info(imgbtn->img_src_mid[state], &header);
             p->x = LV_MAX(p->x, header.w);
@@ -260,8 +276,7 @@ static void draw_main(lv_event_t * e)
             coords_part.x2 = coords_part.x1 + header.w - 1;
             coords_part.y2 = coords_part.y1 + header.h - 1;
 
-            for(i = 0; i < clip_center_area.x2 + header.w - 1; i += header.w) {
-
+            for(i = coords_part.x1; i < (lv_coord_t)(clip_center_area.x2 + header.w - 1); i += header.w) {
                 lv_draw_img(&coords_part, &clip_center_area, src, &img_dsc);
                 coords_part.x1 = coords_part.x2 + 1;
                 coords_part.x2 += header.w;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/imgbtn/lv_imgbtn.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/imgbtn/lv_imgbtn.h
index 20eee9ce2..b8e2c8a2a 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/imgbtn/lv_imgbtn.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/imgbtn/lv_imgbtn.h
@@ -28,7 +28,7 @@ typedef enum {
     LV_IMGBTN_STATE_CHECKED_PRESSED,
     LV_IMGBTN_STATE_CHECKED_DISABLED,
     _LV_IMGBTN_STATE_NUM,
-}lv_imgbtn_state_t;
+} lv_imgbtn_state_t;
 
 /**********************
  *      TYPEDEFS
@@ -75,9 +75,16 @@ lv_obj_t * lv_imgbtn_create(lv_obj_t * parent);
  * to a file)
  */
 void lv_imgbtn_set_src(lv_obj_t * imgbtn, lv_imgbtn_state_t state, const void * src_left, const void * src_mid,
-                             const void * src_right);
+                       const void * src_right);
 
 
+/**
+ * Use this function instead of `lv_obj_add/clear_state` to set a state manually
+ * @param imgbtn pointer to an image button object
+ * @param state  the new state
+ */
+void lv_imgbtn_set_state(lv_obj_t * imgbtn, lv_imgbtn_state_t state);
+
 /*=====================
  * Getter functions
  *====================*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.c
index 45434f8fd..09cb0c875 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.c
@@ -11,10 +11,15 @@
 #if LV_USE_KEYBOARD
 
 #include "../../../widgets/lv_textarea.h"
+#include "../../../misc/lv_assert.h"
+
+#include <stdlib.h>
 
 /*********************
  *      DEFINES
  *********************/
+#define MY_CLASS    &lv_keyboard_class
+#define LV_KB_BTN(width) LV_BTNMATRIX_CTRL_POPOVER | width
 
 /**********************
  *      TYPEDEFS
@@ -27,6 +32,8 @@ static void lv_keyboard_constructor(const lv_obj_class_t * class_p, lv_obj_t * o
 
 static void lv_keyboard_update_map(lv_obj_t * obj);
 
+static void lv_keyboard_update_ctrl_map(lv_obj_t * obj);
+
 /**********************
  *  STATIC VARIABLES
  **********************/
@@ -46,9 +53,9 @@ static const char * const default_kb_map_lc[] = {"1#", "q", "w", "e", "r", "t",
                                                 };
 
 static const lv_btnmatrix_ctrl_t default_kb_ctrl_lc_map[] = {
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, LV_BTNMATRIX_CTRL_CHECKED | 7,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, LV_BTNMATRIX_CTRL_CHECKED | 7,
-    LV_BTNMATRIX_CTRL_CHECKED | 1, LV_BTNMATRIX_CTRL_CHECKED | 1,  1, 1, 1, 1, 1, 1, 1, LV_BTNMATRIX_CTRL_CHECKED | 1, LV_BTNMATRIX_CTRL_CHECKED | 1, LV_BTNMATRIX_CTRL_CHECKED | 1,
+    LV_KEYBOARD_CTRL_BTN_FLAGS | 5, LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_BTNMATRIX_CTRL_CHECKED | 7,
+    LV_KEYBOARD_CTRL_BTN_FLAGS | 6, LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_BTNMATRIX_CTRL_CHECKED | 7,
+    LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1),
     LV_KEYBOARD_CTRL_BTN_FLAGS | 2, LV_BTNMATRIX_CTRL_CHECKED | 2, 6, LV_BTNMATRIX_CTRL_CHECKED | 2, LV_KEYBOARD_CTRL_BTN_FLAGS | 2
 };
 
@@ -59,9 +66,9 @@ static const char * const default_kb_map_uc[] = {"1#", "Q", "W", "E", "R", "T",
                                                 };
 
 static const lv_btnmatrix_ctrl_t default_kb_ctrl_uc_map[] = {
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, LV_BTNMATRIX_CTRL_CHECKED | 7,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, LV_BTNMATRIX_CTRL_CHECKED | 7,
-    LV_BTNMATRIX_CTRL_CHECKED | 1, LV_BTNMATRIX_CTRL_CHECKED | 1, 1, 1, 1, 1, 1, 1,  1, LV_BTNMATRIX_CTRL_CHECKED | 1, LV_BTNMATRIX_CTRL_CHECKED | 1, LV_BTNMATRIX_CTRL_CHECKED | 1,
+    LV_KEYBOARD_CTRL_BTN_FLAGS | 5, LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_KB_BTN(4), LV_BTNMATRIX_CTRL_CHECKED | 7,
+    LV_KEYBOARD_CTRL_BTN_FLAGS | 6, LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_KB_BTN(3), LV_BTNMATRIX_CTRL_CHECKED | 7,
+    LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | LV_KB_BTN(1),
     LV_KEYBOARD_CTRL_BTN_FLAGS | 2, LV_BTNMATRIX_CTRL_CHECKED | 2, 6, LV_BTNMATRIX_CTRL_CHECKED | 2, LV_KEYBOARD_CTRL_BTN_FLAGS | 2
 };
 
@@ -72,9 +79,9 @@ static const char * const default_kb_map_spec[] = {"1", "2", "3", "4", "5", "6",
                                                   };
 
 static const lv_btnmatrix_ctrl_t default_kb_ctrl_spec_map[] = {
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, LV_BTNMATRIX_CTRL_CHECKED | 2,
-    LV_KEYBOARD_CTRL_BTN_FLAGS | 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_BTNMATRIX_CTRL_CHECKED | 2,
+    LV_KEYBOARD_CTRL_BTN_FLAGS | 2, LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1),
+    LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1), LV_KB_BTN(1),
     LV_KEYBOARD_CTRL_BTN_FLAGS | 2, LV_BTNMATRIX_CTRL_CHECKED | 2, 6, LV_BTNMATRIX_CTRL_CHECKED | 2, LV_KEYBOARD_CTRL_BTN_FLAGS | 2
 };
 
@@ -91,18 +98,26 @@ static const lv_btnmatrix_ctrl_t default_kb_ctrl_num_map[] = {
     1, 1, 1, 1, 1
 };
 
-static const char * * kb_map[5] = {
+static const char * * kb_map[9] = {
     (const char * *)default_kb_map_lc,
     (const char * *)default_kb_map_uc,
     (const char * *)default_kb_map_spec,
     (const char * *)default_kb_map_num,
+    (const char * *)default_kb_map_lc,
+    (const char * *)default_kb_map_lc,
+    (const char * *)default_kb_map_lc,
+    (const char * *)default_kb_map_lc,
     (const char * *)NULL,
 };
-static const lv_btnmatrix_ctrl_t * kb_ctrl[5] = {
+static const lv_btnmatrix_ctrl_t * kb_ctrl[9] = {
     default_kb_ctrl_lc_map,
     default_kb_ctrl_uc_map,
     default_kb_ctrl_spec_map,
     default_kb_ctrl_num_map,
+    default_kb_ctrl_lc_map,
+    default_kb_ctrl_lc_map,
+    default_kb_ctrl_lc_map,
+    default_kb_ctrl_lc_map,
     NULL,
 };
 
@@ -121,7 +136,7 @@ static const lv_btnmatrix_ctrl_t * kb_ctrl[5] = {
  */
 lv_obj_t * lv_keyboard_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_keyboard_class, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -142,6 +157,7 @@ void lv_keyboard_set_textarea(lv_obj_t * obj, lv_obj_t * ta)
         LV_ASSERT_OBJ(ta, &lv_textarea_class);
     }
 
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
 
     /*Hide the cursor of the old Text area if cursor management is enabled*/
@@ -164,12 +180,29 @@ void lv_keyboard_set_textarea(lv_obj_t * obj, lv_obj_t * ta)
  */
 void lv_keyboard_set_mode(lv_obj_t * obj, lv_keyboard_mode_t mode)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     if(keyboard->mode == mode) return;
 
     keyboard->mode = mode;
-    lv_btnmatrix_set_map(obj, kb_map[mode]);
-    lv_btnmatrix_set_ctrl_map(obj, kb_ctrl[mode]);
+    lv_keyboard_update_map(obj);
+}
+
+/**
+ * Show the button title in a popover when pressed.
+ * @param kb pointer to a Keyboard object
+ * @param en whether "popovers" mode is enabled
+ */
+void lv_keyboard_set_popovers(lv_obj_t * obj, bool en)
+{
+    lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
+
+    if (keyboard->popovers == en) {
+        return;
+    }
+
+    keyboard->popovers = en;
+    lv_keyboard_update_ctrl_map(obj);
 }
 
 /**
@@ -179,7 +212,8 @@ void lv_keyboard_set_mode(lv_obj_t * obj, lv_keyboard_mode_t mode)
  * @param map pointer to a string array to describe the map.
  *            See 'lv_btnmatrix_set_map()' for more info.
  */
-void lv_keyboard_set_map(lv_obj_t * obj, lv_keyboard_mode_t mode, const char * map[], const lv_btnmatrix_ctrl_t ctrl_map[])
+void lv_keyboard_set_map(lv_obj_t * obj, lv_keyboard_mode_t mode, const char * map[],
+                         const lv_btnmatrix_ctrl_t ctrl_map[])
 {
     kb_map[mode] = map;
     kb_ctrl[mode] = ctrl_map;
@@ -197,6 +231,7 @@ void lv_keyboard_set_map(lv_obj_t * obj, lv_keyboard_mode_t mode, const char * m
  */
 lv_obj_t * lv_keyboard_get_textarea(const lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     return keyboard->ta;
 }
@@ -208,25 +243,38 @@ lv_obj_t * lv_keyboard_get_textarea(const lv_obj_t * obj)
  */
 lv_keyboard_mode_t lv_keyboard_get_mode(const lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     return keyboard->mode;
 }
 
+/**
+ * Tell whether "popovers" mode is enabled or not.
+ * @param kb pointer to a Keyboard object
+ * @return true: "popovers" mode is enabled; false: disabled
+ */
+bool lv_btnmatrix_get_popovers(const lv_obj_t * obj)
+{
+    lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
+    return keyboard->popovers;
+}
+
 /*=====================
  * Other functions
  *====================*/
 
 /**
  * Default keyboard event to add characters to the Text area and change the map.
- * If a custom `event_cb` is added to the keyboard this function be called from it to handle the
+ * If a custom `event_cb` is added to the keyboard this function can be called from it to handle the
  * button clicks
- * @param kb pointer to a  keyboard
+ * @param kb pointer to a keyboard
  * @param event the triggering event
  */
 void lv_keyboard_def_event_cb(lv_event_t * e)
 {
     lv_obj_t * obj = lv_event_get_target(e);
 
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     uint16_t btn_id   = lv_btnmatrix_get_selected_btn(obj);
     if(btn_id == LV_BTNMATRIX_BTN_NONE) return;
@@ -282,13 +330,17 @@ void lv_keyboard_def_event_cb(lv_event_t * e)
             lv_res_t res = lv_event_send(keyboard->ta, LV_EVENT_READY, NULL);
             if(res != LV_RES_OK) return;
         }
-    } else if(strcmp(txt, LV_SYMBOL_LEFT) == 0) {
+    }
+    else if(strcmp(txt, LV_SYMBOL_LEFT) == 0) {
         lv_textarea_cursor_left(keyboard->ta);
-    } else if(strcmp(txt, LV_SYMBOL_RIGHT) == 0) {
+    }
+    else if(strcmp(txt, LV_SYMBOL_RIGHT) == 0) {
         lv_textarea_cursor_right(keyboard->ta);
-    } else if(strcmp(txt, LV_SYMBOL_BACKSPACE) == 0) {
+    }
+    else if(strcmp(txt, LV_SYMBOL_BACKSPACE) == 0) {
         lv_textarea_del_char(keyboard->ta);
-    } else if(strcmp(txt, "+/-") == 0) {
+    }
+    else if(strcmp(txt, "+/-") == 0) {
         uint16_t cur        = lv_textarea_get_cursor_pos(keyboard->ta);
         const char * ta_txt = lv_textarea_get_text(keyboard->ta);
         if(ta_txt[0] == '-') {
@@ -326,24 +378,52 @@ static void lv_keyboard_constructor(const lv_obj_class_t * class_p, lv_obj_t * o
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     keyboard->ta         = NULL;
     keyboard->mode       = LV_KEYBOARD_MODE_TEXT_LOWER;
+    keyboard->popovers   = 0;
 
     lv_obj_align(obj, LV_ALIGN_BOTTOM_MID, 0, 0);
     lv_obj_add_event_cb(obj, lv_keyboard_def_event_cb, LV_EVENT_VALUE_CHANGED, NULL);
     lv_obj_set_style_base_dir(obj, LV_BASE_DIR_LTR, 0);
 
-    lv_btnmatrix_set_map(obj, kb_map[keyboard->mode]);
-    lv_btnmatrix_set_ctrl_map(obj, kb_ctrl[keyboard->mode]);
+    lv_keyboard_update_map(obj);
 }
 
 /**
- * Update the key map for the current mode
- * @param kb pointer to a keyboard object
+ * Update the key and control map for the current mode
+ * @param obj pointer to a keyboard object
  */
 static void lv_keyboard_update_map(lv_obj_t * obj)
 {
     lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
     lv_btnmatrix_set_map(obj, kb_map[keyboard->mode]);
-    lv_btnmatrix_set_ctrl_map(obj, kb_ctrl[keyboard->mode]);
+    lv_keyboard_update_ctrl_map(obj);
+}
+
+/**
+ * Update the control map for the current mode
+ * @param obj pointer to a keyboard object
+ */
+static void lv_keyboard_update_ctrl_map(lv_obj_t * obj)
+{
+    lv_keyboard_t * keyboard = (lv_keyboard_t *)obj;
+
+    if (keyboard->popovers) {
+        /*Apply the current control map (already includes LV_BTNMATRIX_CTRL_POPOVER flags)*/
+        lv_btnmatrix_set_ctrl_map(obj, kb_ctrl[keyboard->mode]);
+    } else {
+        /*Make a copy of the current control map*/
+        lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;
+        lv_btnmatrix_ctrl_t * ctrl_map = lv_mem_alloc(btnm->btn_cnt * sizeof(lv_btnmatrix_ctrl_t));
+        lv_memcpy(ctrl_map, kb_ctrl[keyboard->mode], sizeof(lv_btnmatrix_ctrl_t) * btnm->btn_cnt);
+
+        /*Remove all LV_BTNMATRIX_CTRL_POPOVER flags*/
+        for(uint16_t i = 0; i < btnm->btn_cnt; i++) {
+            ctrl_map[i] &= (~LV_BTNMATRIX_CTRL_POPOVER);
+        }
+
+        /*Apply new control map and clean up*/
+        lv_btnmatrix_set_ctrl_map(obj, ctrl_map);
+        lv_mem_free(ctrl_map);
+    }
 }
 
 #endif  /*LV_USE_KEYBOARD*/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.h
index 2aa2f3d11..4b867c282 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.h
@@ -41,6 +41,10 @@ enum {
     LV_KEYBOARD_MODE_TEXT_UPPER,
     LV_KEYBOARD_MODE_SPECIAL,
     LV_KEYBOARD_MODE_NUMBER,
+    LV_KEYBOARD_MODE_USER_1,
+    LV_KEYBOARD_MODE_USER_2,
+    LV_KEYBOARD_MODE_USER_3,
+    LV_KEYBOARD_MODE_USER_4,
 };
 typedef uint8_t lv_keyboard_mode_t;
 
@@ -49,6 +53,7 @@ typedef struct {
     lv_btnmatrix_t btnm;
     lv_obj_t * ta;              /*Pointer to the assigned text area*/
     lv_keyboard_mode_t mode;    /*Key map type*/
+    uint8_t popovers : 1;       /*Show button titles in popovers on press*/
 } lv_keyboard_t;
 
 extern const lv_obj_class_t lv_keyboard_class;
@@ -82,6 +87,13 @@ void lv_keyboard_set_textarea(lv_obj_t * kb, lv_obj_t * ta);
  */
 void lv_keyboard_set_mode(lv_obj_t * kb, lv_keyboard_mode_t mode);
 
+/**
+ * Show the button title in a popover when pressed.
+ * @param kb pointer to a Keyboard object
+ * @param en whether "popovers" mode is enabled
+ */
+void lv_keyboard_set_popovers(lv_obj_t * kb, bool en);
+
 /**
  * Set a new map for the keyboard
  * @param kb pointer to a Keyboard object
@@ -89,7 +101,8 @@ void lv_keyboard_set_mode(lv_obj_t * kb, lv_keyboard_mode_t mode);
  * @param map pointer to a string array to describe the map.
  *            See 'lv_btnmatrix_set_map()' for more info.
  */
-void lv_keyboard_set_map(lv_obj_t * kb, lv_keyboard_mode_t mode, const char * map[], const lv_btnmatrix_ctrl_t ctrl_map[]);
+void lv_keyboard_set_map(lv_obj_t * kb, lv_keyboard_mode_t mode, const char * map[],
+                         const lv_btnmatrix_ctrl_t ctrl_map[]);
 
 /*=====================
  * Getter functions
@@ -109,6 +122,13 @@ lv_obj_t * lv_keyboard_get_textarea(const lv_obj_t * kb);
  */
 lv_keyboard_mode_t lv_keyboard_get_mode(const lv_obj_t * kb);
 
+/**
+ * Tell whether "popovers" mode is enabled or not.
+ * @param kb pointer to a Keyboard object
+ * @return true: "popovers" mode is enabled; false: disabled
+ */
+bool lv_btnmatrix_get_popovers(const lv_obj_t * obj);
+
 /**
  * Get the current map of a keyboard
  * @param kb pointer to a keyboard object
@@ -125,9 +145,9 @@ static inline const char ** lv_keyboard_get_map_array(const lv_obj_t * kb)
 
 /**
  * Default keyboard event to add characters to the Text area and change the map.
- * If a custom `event_cb` is added to the keyboard this function be called from it to handle the
+ * If a custom `event_cb` is added to the keyboard this function can be called from it to handle the
  * button clicks
- * @param kb pointer to a  keyboard
+ * @param kb pointer to a keyboard
  * @param event the triggering event
  */
 void lv_keyboard_def_event_cb(lv_event_t * e);
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/led/lv_led.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/led/lv_led.c
index 297912b50..443d325ef 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/led/lv_led.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/led/lv_led.c
@@ -9,19 +9,13 @@
 #include "lv_led.h"
 #if LV_USE_LED
 
+#include "../../../misc/lv_assert.h"
+
 /*********************
  *      DEFINES
  *********************/
 #define MY_CLASS &lv_led_class
 
-#ifndef LV_LED_BRIGHT_MIN
-# define LV_LED_BRIGHT_MIN 80
-#endif
-
-#ifndef LV_LED_BRIGHT_MAX
-# define LV_LED_BRIGHT_MAX 255
-#endif
-
 /**********************
  *      TYPEDEFS
  **********************/
@@ -36,12 +30,12 @@ static void lv_led_event(const lv_obj_class_t * class_p, lv_event_t * e);
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_led_class  = {
-        .base_class = &lv_obj_class,
-        .constructor_cb = lv_led_constructor,
-        .width_def = LV_DPI_DEF / 5,
-        .height_def = LV_DPI_DEF / 5,
-        .event_cb = lv_led_event,
-        .instance_size = sizeof(lv_led_t),
+    .base_class = &lv_obj_class,
+    .constructor_cb = lv_led_constructor,
+    .width_def = LV_DPI_DEF / 5,
+    .height_def = LV_DPI_DEF / 5,
+    .event_cb = lv_led_event,
+    .instance_size = sizeof(lv_led_t),
 };
 
 /**********************
@@ -59,7 +53,7 @@ const lv_obj_class_t lv_led_class  = {
  */
 lv_obj_t * lv_led_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -76,6 +70,8 @@ lv_obj_t * lv_led_create(lv_obj_t * parent)
  */
 void lv_led_set_color(lv_obj_t * obj, lv_color_t color)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
     lv_led_t * led = (lv_led_t *)obj;
     led->color = color;
     lv_obj_invalidate(obj);
@@ -88,13 +84,12 @@ void lv_led_set_color(lv_obj_t * obj, lv_color_t color)
  */
 void lv_led_set_brightness(lv_obj_t * obj, uint8_t bright)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
     lv_led_t * led = (lv_led_t *)obj;
     if(led->bright == bright) return;
 
-    if(bright <= LV_LED_BRIGHT_MIN) bright = LV_LED_BRIGHT_MIN;
-    if(bright >= LV_LED_BRIGHT_MAX) bright = LV_LED_BRIGHT_MAX;
-
-    led->bright = bright;
+    led->bright = LV_CLAMP(LV_LED_BRIGHT_MIN, bright, LV_LED_BRIGHT_MAX);
 
     /*Invalidate the object there fore it will be redrawn*/
     lv_obj_invalidate(obj);
@@ -142,6 +137,8 @@ void lv_led_toggle(lv_obj_t * obj)
  */
 uint8_t lv_led_get_brightness(const lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
     lv_led_t * led = (lv_led_t *)obj;
     return led->bright;
 }
@@ -165,10 +162,12 @@ static void lv_led_event(const lv_obj_class_t * class_p, lv_event_t * e)
     lv_res_t res;
 
     /* Call the ancestor's event handler */
-    res = lv_obj_event_base(MY_CLASS, e);
-    if(res != LV_RES_OK) return;
-
     lv_event_code_t code = lv_event_get_code(e);
+    if(code != LV_EVENT_DRAW_MAIN && code != LV_EVENT_DRAW_MAIN_END) {
+        res = lv_obj_event_base(MY_CLASS, e);
+        if(res != LV_RES_OK) return;
+    }
+
     lv_obj_t * obj = lv_event_get_target(e);
     if(code == LV_EVENT_DRAW_MAIN) {
         /*Make darker colors in a temporary style according to the brightness*/
@@ -195,12 +194,23 @@ static void lv_led_event(const lv_obj_class_t * class_p, lv_event_t * e)
         /*Set the current shadow width according to brightness proportionally between LV_LED_BRIGHT_OFF
          * and LV_LED_BRIGHT_ON*/
         rect_dsc.shadow_width = ((led->bright - LV_LED_BRIGHT_MIN) * rect_dsc.shadow_width) /
-                (LV_LED_BRIGHT_MAX - LV_LED_BRIGHT_MIN);
+                                (LV_LED_BRIGHT_MAX - LV_LED_BRIGHT_MIN);
         rect_dsc.shadow_spread = ((led->bright - LV_LED_BRIGHT_MIN) * rect_dsc.shadow_spread) /
-                (LV_LED_BRIGHT_MAX - LV_LED_BRIGHT_MIN);
+                                 (LV_LED_BRIGHT_MAX - LV_LED_BRIGHT_MIN);
 
         const lv_area_t * clip_area = lv_event_get_param(e);
+
+        lv_obj_draw_part_dsc_t  part_draw_dsc;
+        lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+        part_draw_dsc.draw_area = &obj->coords;
+        part_draw_dsc.class_p = MY_CLASS;
+        part_draw_dsc.type = LV_LED_DRAW_PART_RECTANGLE;
+        part_draw_dsc.rect_dsc = &rect_dsc;
+        part_draw_dsc.part = LV_PART_MAIN;
+
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
         lv_draw_rect(&obj->coords, clip_area, &rect_dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
     }
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/led/lv_led.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/led/lv_led.h
index 7c9b350cb..0bc4aaa71 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/led/lv_led.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/led/lv_led.h
@@ -21,6 +21,15 @@ extern "C" {
 /*********************
  *      DEFINES
  *********************/
+/** Brightness when the LED if OFF */
+#ifndef LV_LED_BRIGHT_MIN
+# define LV_LED_BRIGHT_MIN 80
+#endif
+
+/** Brightness when the LED if ON */
+#ifndef LV_LED_BRIGHT_MAX
+# define LV_LED_BRIGHT_MAX 255
+#endif
 
 /**********************
  *      TYPEDEFS
@@ -35,6 +44,14 @@ typedef struct {
 
 extern const lv_obj_class_t lv_led_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_led_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_LED_DRAW_PART_RECTANGLE,    /**< The main rectangle*/
+} lv_led_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/list/lv_list.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/list/lv_list.c
index 07d62689d..798fb708a 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/list/lv_list.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/list/lv_list.c
@@ -55,7 +55,7 @@ const lv_obj_class_t lv_list_text_class = {
 
 lv_obj_t * lv_list_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_list_class, parent);
     lv_obj_class_init_obj(obj);
     lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_COLUMN);
@@ -64,7 +64,7 @@ lv_obj_t * lv_list_create(lv_obj_t * parent)
 
 lv_obj_t * lv_list_add_text(lv_obj_t * list, const char * txt)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_list_text_class, list);
     lv_obj_class_init_obj(obj);
     lv_label_set_text(obj, txt);
@@ -75,7 +75,7 @@ lv_obj_t * lv_list_add_text(lv_obj_t * list, const char * txt)
 
 lv_obj_t * lv_list_add_btn(lv_obj_t * list, const char * icon, const char * txt)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_list_btn_class, list);
     lv_obj_class_init_obj(obj);
     lv_obj_set_size(obj, LV_PCT(100), LV_SIZE_CONTENT);
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.c
index ff175404a..0932ecec7 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.c
@@ -9,6 +9,8 @@
 #include "lv_meter.h"
 #if LV_USE_METER != 0
 
+#include "../../../misc/lv_assert.h"
+
 /*********************
  *      DEFINES
  *********************/
@@ -51,7 +53,7 @@ const lv_obj_class_t lv_meter_class = {
 
 lv_obj_t * lv_meter_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -63,6 +65,7 @@ lv_obj_t * lv_meter_create(lv_obj_t * parent)
 
 lv_meter_scale_t * lv_meter_add_scale(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_meter_t * meter = (lv_meter_t *)obj;
 
     lv_meter_scale_t * scale = _lv_ll_ins_head(&meter->scale_ll);
@@ -81,7 +84,8 @@ lv_meter_scale_t * lv_meter_add_scale(lv_obj_t * obj)
     return scale;
 }
 
-void lv_meter_set_scale_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t cnt, uint16_t width, uint16_t len, lv_color_t color)
+void lv_meter_set_scale_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t cnt, uint16_t width, uint16_t len,
+                              lv_color_t color)
 {
     scale->tick_cnt = cnt;
     scale->tick_width = width;
@@ -90,7 +94,8 @@ void lv_meter_set_scale_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t
     lv_obj_invalidate(obj);
 }
 
-void lv_meter_set_scale_major_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t nth, uint16_t width, uint16_t len, lv_color_t color, int16_t label_gap)
+void lv_meter_set_scale_major_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t nth, uint16_t width,
+                                    uint16_t len, lv_color_t color, int16_t label_gap)
 {
     scale->tick_major_nth = nth;
     scale->tick_major_width = width;
@@ -100,7 +105,8 @@ void lv_meter_set_scale_major_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, ui
     lv_obj_invalidate(obj);
 }
 
-void lv_meter_set_scale_range(lv_obj_t * obj, lv_meter_scale_t * scale, int32_t min, int32_t max, uint32_t angle_range, uint32_t rotation)
+void lv_meter_set_scale_range(lv_obj_t * obj, lv_meter_scale_t * scale, int32_t min, int32_t max, uint32_t angle_range,
+                              uint32_t rotation)
 {
     scale->min = min;
     scale->max = max;
@@ -113,8 +119,10 @@ void lv_meter_set_scale_range(lv_obj_t * obj, lv_meter_scale_t * scale, int32_t
  * Add indicator
  *====================*/
 
-lv_meter_indicator_t * lv_meter_add_needle_line(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width, lv_color_t color, int16_t r_mod)
+lv_meter_indicator_t * lv_meter_add_needle_line(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width,
+                                                lv_color_t color, int16_t r_mod)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_meter_t * meter = (lv_meter_t *)obj;
     lv_meter_indicator_t * indic = _lv_ll_ins_head(&meter->indicator_ll);
     LV_ASSERT_MALLOC(indic);
@@ -131,8 +139,10 @@ lv_meter_indicator_t * lv_meter_add_needle_line(lv_obj_t * obj, lv_meter_scale_t
     return indic;
 }
 
-lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t * obj, lv_meter_scale_t * scale, const void * src, lv_coord_t pivot_x, lv_coord_t pivot_y)
+lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t * obj, lv_meter_scale_t * scale, const void * src,
+                                               lv_coord_t pivot_x, lv_coord_t pivot_y)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_meter_t * meter = (lv_meter_t *)obj;
     lv_meter_indicator_t * indic = _lv_ll_ins_head(&meter->indicator_ll);
     LV_ASSERT_MALLOC(indic);
@@ -149,8 +159,10 @@ lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t * obj, lv_meter_scale_t
     return indic;
 }
 
-lv_meter_indicator_t * lv_meter_add_arc(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width, lv_color_t color, int16_t r_mod)
+lv_meter_indicator_t * lv_meter_add_arc(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width, lv_color_t color,
+                                        int16_t r_mod)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_meter_t * meter = (lv_meter_t *)obj;
     lv_meter_indicator_t * indic = _lv_ll_ins_head(&meter->indicator_ll);
     LV_ASSERT_MALLOC(indic);
@@ -167,8 +179,10 @@ lv_meter_indicator_t * lv_meter_add_arc(lv_obj_t * obj, lv_meter_scale_t * scale
     return indic;
 }
 
-lv_meter_indicator_t * lv_meter_add_scale_lines(lv_obj_t * obj, lv_meter_scale_t * scale, lv_color_t color_start, lv_color_t color_end, bool local, int16_t width_mod)
+lv_meter_indicator_t * lv_meter_add_scale_lines(lv_obj_t * obj, lv_meter_scale_t * scale, lv_color_t color_start,
+                                                lv_color_t color_end, bool local, int16_t width_mod)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_meter_t * meter = (lv_meter_t *)obj;
     lv_meter_indicator_t * indic = _lv_ll_ins_head(&meter->indicator_ll);
     LV_ASSERT_MALLOC(indic);
@@ -205,7 +219,8 @@ void lv_meter_set_indicator_value(lv_obj_t * obj, lv_meter_indicator_t * indic,
         inv_line(obj, indic, old_start);
         inv_line(obj, indic, old_end);
         inv_line(obj, indic, value);
-    } else {
+    }
+    else {
         lv_obj_invalidate(obj);
     }
 }
@@ -264,6 +279,7 @@ static void lv_meter_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 static void lv_meter_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 {
     LV_UNUSED(class_p);
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_meter_t * meter = (lv_meter_t *)obj;
     _lv_ll_clear(&meter->indicator_ll);
     _lv_ll_clear(&meter->scale_ll);
@@ -322,6 +338,14 @@ static void draw_arcs(lv_obj_t * obj, const lv_area_t * clip_area, const lv_area
 
     lv_opa_t opa_main = lv_obj_get_style_opa(obj, LV_PART_MAIN);
     lv_meter_indicator_t * indic;
+
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.arc_dsc = &arc_dsc;
+    part_draw_dsc.part = LV_PART_INDICATOR;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_METER_DRAW_PART_ARC;
+
     _LV_LL_READ_BACK(&meter->indicator_ll, indic) {
         if(indic->type != LV_METER_INDICATOR_TYPE_ARC) continue;
 
@@ -331,9 +355,18 @@ static void draw_arcs(lv_obj_t * obj, const lv_area_t * clip_area, const lv_area
 
         lv_meter_scale_t * scale = indic->scale;
 
-        int32_t start_angle = lv_map(indic->start_value, scale->min, scale->max, scale->rotation, scale->rotation + scale->angle_range);
-        int32_t end_angle = lv_map(indic->end_value, scale->min, scale->max, scale->rotation, scale->rotation + scale->angle_range);
-        lv_draw_arc(scale_center.x, scale_center.y, r_out + indic->type_data.arc.r_mod, start_angle, end_angle, clip_area, &arc_dsc);
+        int32_t start_angle = lv_map(indic->start_value, scale->min, scale->max, scale->rotation,
+                                     scale->rotation + scale->angle_range);
+        int32_t end_angle = lv_map(indic->end_value, scale->min, scale->max, scale->rotation,
+                                   scale->rotation + scale->angle_range);
+
+        part_draw_dsc.radius = r_out + indic->type_data.arc.r_mod;
+        part_draw_dsc.sub_part_ptr = indic;
+        part_draw_dsc.p1 = &scale_center;
+
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
+        lv_draw_arc(scale_center.x, scale_center.y, part_draw_dsc.radius, start_angle, end_angle, clip_area, &arc_dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
     }
 }
 
@@ -359,22 +392,24 @@ static void draw_ticks_and_labels(lv_obj_t * obj, const lv_area_t * clip_area, c
 
     lv_meter_scale_t * scale;
 
-    lv_obj_draw_part_dsc_t dsc;
-    lv_obj_draw_dsc_init(&dsc, clip_area);
-
-#if LV_DRAW_COMPLEX
     lv_draw_mask_radius_param_t inner_minor_mask;
     lv_draw_mask_radius_param_t inner_major_mask;
     lv_draw_mask_radius_param_t outer_mask;
-#endif
+
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.part = LV_PART_TICKS;
+    part_draw_dsc.type = LV_METER_DRAW_PART_TICK;
+    part_draw_dsc.line_dsc = &line_dsc;
 
     _LV_LL_READ_BACK(&meter->scale_ll, scale) {
+        part_draw_dsc.sub_part_ptr = scale;
 
         lv_coord_t r_out = r_edge + scale->r_mod;
         lv_coord_t r_in_minor = r_out - scale->tick_length;
         lv_coord_t r_in_major = r_out - scale->tick_major_length;
 
-#if LV_DRAW_COMPLEX
         lv_area_t area_inner_minor;
         area_inner_minor.x1 = p_center.x - r_in_minor;
         area_inner_minor.y1 = p_center.y - r_in_minor;
@@ -397,8 +432,7 @@ static void draw_ticks_and_labels(lv_obj_t * obj, const lv_area_t * clip_area, c
         lv_draw_mask_radius_init(&outer_mask, &area_outer, LV_RADIUS_CIRCLE, false);
         int16_t outer_mask_id = lv_draw_mask_add(&outer_mask, NULL);
 
-        int16_t inner_act_mask_id = -1; /*Will be added later*/
-#endif
+        int16_t inner_act_mask_id = LV_MASK_ID_INV; /*Will be added later*/
 
         uint32_t minor_cnt = scale->tick_major_nth ? scale->tick_major_nth - 1 : 0xFFFF;
         for(i = 0; i < scale->tick_cnt; i++) {
@@ -409,11 +443,8 @@ static void draw_ticks_and_labels(lv_obj_t * obj, const lv_area_t * clip_area, c
                 major = true;
             }
 
-#if LV_DRAW_COMPLEX
-            inner_act_mask_id = lv_draw_mask_add(major ? &inner_major_mask : &inner_minor_mask, NULL);
-#endif
-
             int32_t value_of_line = lv_map(i, 0, scale->tick_cnt - 1, scale->min, scale->max);
+            part_draw_dsc.value = value_of_line;
 
             lv_color_t line_color = major ? scale->tick_major_color : scale->tick_color;
             lv_color_t line_color_ori = line_color;
@@ -429,11 +460,13 @@ static void draw_ticks_and_labels(lv_obj_t * obj, const lv_area_t * clip_area, c
 
                     if(indic->type_data.scale_lines.color_start.full == indic->type_data.scale_lines.color_end.full) {
                         line_color = indic->type_data.scale_lines.color_start;
-                    } else {
+                    }
+                    else {
                         lv_opa_t ratio;
                         if(indic->type_data.scale_lines.local_grad) {
                             ratio = lv_map(value_of_line, indic->start_value, indic->end_value, LV_OPA_TRANSP, LV_OPA_COVER);
-                        } else {
+                        }
+                        else {
                             ratio = lv_map(value_of_line, scale->min, scale->max, LV_OPA_TRANSP, LV_OPA_COVER);
                         }
                         line_color = lv_color_mix(indic->type_data.scale_lines.color_end, indic->type_data.scale_lines.color_start, ratio);
@@ -457,40 +490,22 @@ static void draw_ticks_and_labels(lv_obj_t * obj, const lv_area_t * clip_area, c
             int32_t cos_high = lv_trigo_cos(angle_high + scale->rotation);
             int32_t cos_mid = (cos_low * (256 - angle_rem) + cos_high * angle_rem) >> 8;
 
-
             line_dsc.color = line_color;
             line_dsc.width = line_width;
-#if LV_DRAW_COMPLEX
             /*Use the interpolated angle to get the outer x and y coordinates.
              *Draw a little bit longer lines to be sure the mask will clip them correctly*/
             lv_point_t p_outer;
             p_outer.x = (int32_t)(((int32_t)cos_mid * (r_out + line_width) + 127) >> (LV_TRIGO_SHIFT)) + p_center.x;
             p_outer.y = (int32_t)(((int32_t)sin_mid * (r_out + line_width) + 127) >> (LV_TRIGO_SHIFT)) + p_center.y;
-            lv_draw_line(&p_outer, &p_center, clip_area, &line_dsc);
-#else
-            /*Use the interpolated angle to get the outer and inner x and y coordinates.*/
-            lv_point_t p_outer;
-            p_outer.x = (int32_t)(((int32_t)cos_mid * (r_out) + 127) >> (LV_TRIGO_SHIFT)) + p_center.x;
-            p_outer.y = (int32_t)(((int32_t)sin_mid * (r_out) + 127) >> (LV_TRIGO_SHIFT)) + p_center.y;
-            lv_point_t p_inner;
-            lv_coord_t r_in = major ? r_in_major : r_in_minor;
-            p_inner.x = (int32_t)(((int32_t)cos_mid * (r_in) + 127) >> (LV_TRIGO_SHIFT)) + p_center.x;
-            p_inner.y = (int32_t)(((int32_t)sin_mid * (r_in) + 127) >> (LV_TRIGO_SHIFT)) + p_center.y;
-            lv_draw_line(&p_outer, &p_inner, clip_area, &line_dsc);
-#endif
 
-            line_dsc.color = line_color_ori;
-            line_dsc.width = line_width_ori;
-
-#if LV_DRAW_COMPLEX
-            lv_draw_mask_remove_id(inner_act_mask_id);
-#endif
+            part_draw_dsc.p1 = &p_outer;
+            part_draw_dsc.p1 = &p_center;
+            part_draw_dsc.id = i;
+            part_draw_dsc.label_dsc = &label_dsc;
 
             /*Draw the text*/
             if(major) {
-#if LV_DRAW_COMPLEX
                 lv_draw_mask_remove_id(outer_mask_id);
-#endif
                 uint32_t r_text = r_in_major - scale->label_gap;
                 lv_point_t p;
                 p.x = (int32_t)((int32_t)((int32_t)cos_mid * r_text + 127) >> LV_TRIGO_SHIFT) + p_center.x;
@@ -499,15 +514,17 @@ static void draw_ticks_and_labels(lv_obj_t * obj, const lv_area_t * clip_area, c
                 lv_draw_label_dsc_t label_dsc_tmp;
                 lv_memcpy(&label_dsc_tmp, &label_dsc, sizeof(label_dsc_tmp));
 
-                dsc.id = i / scale->tick_major_nth;
-                dsc.value = value_of_line;
-                dsc.label_dsc = &label_dsc_tmp;
-                lv_snprintf(dsc.text, sizeof(dsc.text), "%d", value_of_line);
-                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+                part_draw_dsc.label_dsc = &label_dsc_tmp;
+                char buf[16];
+
+                lv_snprintf(buf, sizeof(buf), "%" LV_PRId32, value_of_line);
+                part_draw_dsc.text = buf;
+
+                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
                 lv_point_t label_size;
-                lv_txt_get_size(&label_size, dsc.text, label_dsc.font, label_dsc.letter_space, label_dsc.line_space,
-                        LV_COORD_MAX, LV_TEXT_FLAG_NONE);
+                lv_txt_get_size(&label_size, part_draw_dsc.text, label_dsc.font, label_dsc.letter_space, label_dsc.line_space,
+                                LV_COORD_MAX, LV_TEXT_FLAG_NONE);
 
                 lv_area_t label_cord;
                 label_cord.x1 = p.x - label_size.x / 2;
@@ -515,18 +532,29 @@ static void draw_ticks_and_labels(lv_obj_t * obj, const lv_area_t * clip_area, c
                 label_cord.x2 = label_cord.x1 + label_size.x;
                 label_cord.y2 = label_cord.y1 + label_size.y;
 
-                lv_draw_label(&label_cord, clip_area, &label_dsc, dsc.text, NULL);
-                lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+                lv_draw_label(&label_cord, clip_area, &label_dsc, part_draw_dsc.text, NULL);
 
-#if LV_DRAW_COMPLEX
                 outer_mask_id = lv_draw_mask_add(&outer_mask, NULL);
-#endif
+            }
+            else {
+                part_draw_dsc.label_dsc = NULL;
+                part_draw_dsc.text = NULL;
+                lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
             }
 
+            inner_act_mask_id = lv_draw_mask_add(major ? &inner_major_mask : &inner_minor_mask, NULL);
+            lv_draw_line(&p_outer, &p_center, clip_area, &line_dsc);
+            lv_draw_mask_remove_id(inner_act_mask_id);
+            lv_event_send(obj, LV_EVENT_DRAW_MAIN_END, &part_draw_dsc);
+
+            line_dsc.color = line_color_ori;
+            line_dsc.width = line_width_ori;
+
         }
-#if LV_DRAW_COMPLEX
+        lv_draw_mask_free_param(&inner_minor_mask);
+        lv_draw_mask_free_param(&inner_major_mask);
+        lv_draw_mask_free_param(&outer_mask);
         lv_draw_mask_remove_id(outer_mask_id);
-#endif
     }
 }
 
@@ -542,17 +570,23 @@ static void draw_needles(lv_obj_t * obj, const lv_area_t * clip_area, const lv_a
 
     lv_draw_line_dsc_t line_dsc;
     lv_draw_line_dsc_init(&line_dsc);
-    lv_obj_init_draw_line_dsc(obj, LV_PART_INDICATOR, &line_dsc);
+    lv_obj_init_draw_line_dsc(obj, LV_PART_ITEMS, &line_dsc);
 
     lv_draw_img_dsc_t img_dsc;
     lv_draw_img_dsc_init(&img_dsc);
-    lv_obj_init_draw_img_dsc(obj, LV_PART_INDICATOR, &img_dsc);
-    img_dsc.antialias = 1;
+    lv_obj_init_draw_img_dsc(obj, LV_PART_ITEMS, &img_dsc);
     lv_opa_t opa_main = lv_obj_get_style_opa(obj, LV_PART_MAIN);
 
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.p1 = &scale_center;
+
     lv_meter_indicator_t * indic;
     _LV_LL_READ_BACK(&meter->indicator_ll, indic) {
         lv_meter_scale_t * scale = indic->scale;
+        part_draw_dsc.sub_part_ptr = indic;
+
         if(indic->type == LV_METER_INDICATOR_TYPE_NEEDLE_LINE) {
             int32_t angle = lv_map(indic->end_value, scale->min, scale->max, scale->rotation, scale->rotation + scale->angle_range);
             lv_coord_t r_out = r_edge + scale->r_mod + indic->type_data.needle_line.r_mod;
@@ -562,7 +596,14 @@ static void draw_needles(lv_obj_t * obj, const lv_area_t * clip_area, const lv_a
             line_dsc.color = indic->type_data.needle_line.color;
             line_dsc.width = indic->type_data.needle_line.width;
             line_dsc.opa = indic->opa > LV_OPA_MAX ? opa_main : (opa_main * indic->opa) >> 8;
+
+            part_draw_dsc.id = LV_METER_DRAW_PART_NEEDLE_LINE;
+            part_draw_dsc.line_dsc = &line_dsc;
+            part_draw_dsc.p2 = &p_end;
+
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
             lv_draw_line(&scale_center, &p_end, clip_area, &line_dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
         }
         else if(indic->type == LV_METER_INDICATOR_TYPE_NEEDLE_IMG) {
             if(indic->type_data.needle_img.src == NULL) continue;
@@ -582,7 +623,12 @@ static void draw_needles(lv_obj_t * obj, const lv_area_t * clip_area, const lv_a
             angle = angle * 10;
             if(angle > 3600) angle -= 3600;
             img_dsc.angle = angle;
+
+            part_draw_dsc.img_dsc = &img_dsc;
+
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
             lv_draw_img(&a, clip_area, indic->type_data.needle_img.src, &img_dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
         }
     }
 }
@@ -605,8 +651,10 @@ static void inv_arc(lv_obj_t * obj, lv_meter_indicator_t * indic, int32_t old_va
 
     int32_t start_angle = lv_map(old_value, scale->min, scale->max, scale->rotation, scale->angle_range + scale->rotation);
     int32_t end_angle = lv_map(new_value, scale->min, scale->max, scale->rotation, scale->angle_range + scale->rotation);
+
     lv_area_t a;
-    lv_draw_arc_get_area(scale_center.x, scale_center.y, r_out, LV_MIN(start_angle, end_angle), LV_MAX(start_angle, end_angle), indic->type_data.arc.width, rounded, &a);
+    lv_draw_arc_get_area(scale_center.x, scale_center.y, r_out, LV_MIN(start_angle, end_angle), LV_MAX(start_angle,
+                                                                                                       end_angle), indic->type_data.arc.width, rounded, &a);
     lv_obj_invalidate_area(obj, &a);
 }
 
@@ -656,6 +704,6 @@ static void inv_line(lv_obj_t * obj, lv_meter_indicator_t * indic, int32_t value
         a.y2 += scale_center.y + 2;
 
         lv_obj_invalidate_area(obj, &a);
-         }
+    }
 }
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.h
index ccf9a1624..3626fbad1 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.h
@@ -17,6 +17,11 @@ extern "C" {
 
 #if LV_USE_METER != 0
 
+/*Testing of dependencies*/
+#if LV_DRAW_COMPLEX == 0
+#error "lv_meter: Complex drawing is required. Enable it in lv_conf.h (LV_DRAW_COMPLEX 1)"
+#endif
+
 /*********************
  *      DEFINES
  *********************/
@@ -44,7 +49,7 @@ typedef struct {
     int16_t r_mod;
     uint16_t angle_range;
     int16_t rotation;
-}lv_meter_scale_t;
+} lv_meter_scale_t;
 
 enum {
     LV_METER_INDICATOR_TYPE_NEEDLE_IMG,
@@ -64,26 +69,26 @@ typedef struct {
         struct {
             const void * src;
             lv_point_t pivot;
-        }needle_img;
+        } needle_img;
         struct {
             uint16_t width;
             int16_t r_mod;
             lv_color_t color;
-        }needle_line;
+        } needle_line;
         struct {
             uint16_t width;
             const void * src;
             lv_color_t color;
             int16_t r_mod;
-        }arc;
+        } arc;
         struct {
             int16_t width_mod;
             lv_color_t color_start;
             lv_color_t color_end;
-            uint8_t local_grad  :1;
-        }scale_lines;
+            uint8_t local_grad  : 1;
+        } scale_lines;
     } type_data;
-}lv_meter_indicator_t;
+} lv_meter_indicator_t;
 
 /*Data of line meter*/
 typedef struct {
@@ -94,6 +99,17 @@ typedef struct {
 
 extern const lv_obj_class_t lv_meter_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_meter_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_METER_DRAW_PART_ARC,             /**< The arc indicator*/
+    LV_METER_DRAW_PART_NEEDLE_LINE,     /**< The needle lines*/
+    LV_METER_DRAW_PART_NEEDLE_IMG,      /**< The needle images*/
+    LV_METER_DRAW_PART_TICK,            /**< The tick lines and labels*/
+} lv_meter_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
@@ -126,7 +142,8 @@ lv_meter_scale_t * lv_meter_add_scale(lv_obj_t * obj);
  * @param len       length of tick lines
  * @param color     color of tick lines
  */
-void lv_meter_set_scale_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t cnt, uint16_t width, uint16_t len, lv_color_t color);
+void lv_meter_set_scale_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t cnt, uint16_t width, uint16_t len,
+                              lv_color_t color);
 
 /**
  * Make some "normal" ticks major ticks and set their attributes.
@@ -139,7 +156,8 @@ void lv_meter_set_scale_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t
  * @param color         color of the major ticks
  * @param label_gap     gap between the major ticks and the labels
  */
-void lv_meter_set_scale_major_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t nth, uint16_t width, uint16_t len, lv_color_t color, int16_t label_gap);
+void lv_meter_set_scale_major_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t nth, uint16_t width,
+                                    uint16_t len, lv_color_t color, int16_t label_gap);
 
 /**
  * Set the value and angular range of a scale.
@@ -150,7 +168,8 @@ void lv_meter_set_scale_major_ticks(lv_obj_t * obj, lv_meter_scale_t * scale, ui
  * @param angle_range   the angular range of the scale
  * @param rotation      the angular offset from the 3 o'clock position (clock-wise)
  */
-void lv_meter_set_scale_range(lv_obj_t * obj, lv_meter_scale_t * scale, int32_t min, int32_t max, uint32_t angle_range, uint32_t rotation);
+void lv_meter_set_scale_range(lv_obj_t * obj, lv_meter_scale_t * scale, int32_t min, int32_t max, uint32_t angle_range,
+                              uint32_t rotation);
 
 /*=====================
  * Add indicator
@@ -165,7 +184,8 @@ void lv_meter_set_scale_range(lv_obj_t * obj, lv_meter_scale_t * scale, int32_t
  * @param r_mod         the radius modifier (added to the scale's radius) to get the lines length
  * @return              the new indicator
  */
-lv_meter_indicator_t * lv_meter_add_needle_line(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width, lv_color_t color, int16_t r_mod);
+lv_meter_indicator_t * lv_meter_add_needle_line(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width,
+                                                lv_color_t color, int16_t r_mod);
 
 /**
  * Add a needle image indicator the scale
@@ -177,7 +197,8 @@ lv_meter_indicator_t * lv_meter_add_needle_line(lv_obj_t * obj, lv_meter_scale_t
  * @return              the new indicator
  * @note                the needle image should point to the right, like -O----->
  */
-lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t * obj, lv_meter_scale_t * scale, const void * src, lv_coord_t pivot_x, lv_coord_t pivot_y);
+lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t * obj, lv_meter_scale_t * scale, const void * src,
+                                               lv_coord_t pivot_x, lv_coord_t pivot_y);
 
 /**
  * Add an arc indicator the scale
@@ -188,7 +209,8 @@ lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t * obj, lv_meter_scale_t
  * @param r_mod         the radius modifier (added to the scale's radius) to get the outer radius of the arc
  * @return              the new indicator
  */
-lv_meter_indicator_t * lv_meter_add_arc(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width, lv_color_t color, int16_t r_mod);
+lv_meter_indicator_t * lv_meter_add_arc(lv_obj_t * obj, lv_meter_scale_t * scale, uint16_t width, lv_color_t color,
+                                        int16_t r_mod);
 
 
 /**
@@ -201,7 +223,8 @@ lv_meter_indicator_t * lv_meter_add_arc(lv_obj_t * obj, lv_meter_scale_t * scale
  * @param width_mod     add this the affected tick's width
  * @return              the new indicator
  */
-lv_meter_indicator_t * lv_meter_add_scale_lines(lv_obj_t * obj, lv_meter_scale_t * scale, lv_color_t color_start, lv_color_t color_end, bool local, int16_t width_mod);
+lv_meter_indicator_t * lv_meter_add_scale_lines(lv_obj_t * obj, lv_meter_scale_t * scale, lv_color_t color_start,
+                                                lv_color_t color_end, bool local, int16_t width_mod);
 
 /*=====================
  * Set indicator value
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/msgbox/lv_msgbox.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/msgbox/lv_msgbox.c
index 01db38985..d8a6817e2 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/msgbox/lv_msgbox.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/msgbox/lv_msgbox.c
@@ -9,11 +9,13 @@
 #include "lv_msgbox.h"
 #if LV_USE_MSGBOX
 
+#include "../../../misc/lv_assert.h"
 
 /*********************
  *      DEFINES
  *********************/
 #define LV_MSGBOX_FLAG_AUTO_PARENT  LV_OBJ_FLAG_WIDGET_1        /*Mark that the parent was automatically created*/
+#define MY_CLASS    &lv_msgbox_class
 
 /**********************
  *      TYPEDEFS
@@ -27,7 +29,26 @@ static void msgbox_close_click_event_cb(lv_event_t * e);
 /**********************
  *  STATIC VARIABLES
  **********************/
-const lv_obj_class_t lv_msgbox_class = {.base_class = &lv_obj_class};
+const lv_obj_class_t lv_msgbox_class = {
+        .base_class = &lv_obj_class,
+        .width_def = LV_DPI_DEF * 2,
+        .height_def = LV_SIZE_CONTENT,
+        .instance_size = sizeof(lv_msgbox_t)
+};
+
+const lv_obj_class_t lv_msgbox_content_class = {
+        .base_class = &lv_obj_class,
+        .width_def = LV_PCT(100),
+        .height_def = LV_SIZE_CONTENT,
+        .instance_size = sizeof(lv_obj_t)
+};
+
+const lv_obj_class_t lv_msgbox_backdrop_class = {
+        .base_class = &lv_obj_class,
+        .width_def = LV_PCT(100),
+        .height_def = LV_PCT(100),
+        .instance_size = sizeof(lv_obj_t)
+};
 
 /**********************
  *      MACROS
@@ -37,95 +58,123 @@ const lv_obj_class_t lv_msgbox_class = {.base_class = &lv_obj_class};
  *   GLOBAL FUNCTIONS
  **********************/
 
-lv_obj_t * lv_msgbox_create(lv_obj_t * parent, const char * title, const char * txt, const char * btn_txts[], bool add_close_btn)
+lv_obj_t * lv_msgbox_create(lv_obj_t * parent, const char * title, const char * txt, const char * btn_txts[],
+                            bool add_close_btn)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     bool auto_parent = false;
     if(parent == NULL) {
         auto_parent = true;
-        parent = lv_obj_create(lv_layer_top());
-        lv_obj_remove_style_all(parent);
+        parent = lv_obj_class_create_obj(&lv_msgbox_backdrop_class, lv_layer_top());
+        LV_ASSERT_MALLOC(parent);
+        lv_obj_class_init_obj(parent);
         lv_obj_clear_flag(parent, LV_OBJ_FLAG_IGNORE_LAYOUT);
-        lv_obj_set_style_bg_color(parent, lv_palette_main(LV_PALETTE_GREY), 0);
-        lv_obj_set_style_bg_opa(parent, LV_OPA_50, 0);
         lv_obj_set_size(parent, LV_PCT(100), LV_PCT(100));
     }
 
-    lv_obj_t * mbox = lv_obj_class_create_obj(&lv_msgbox_class, parent);
-    lv_obj_class_init_obj(mbox);
-    LV_ASSERT_MALLOC(mbox);
-    if(mbox == NULL) return NULL;
+    lv_obj_t * obj = lv_obj_class_create_obj(&lv_msgbox_class, parent);
+    LV_ASSERT_MALLOC(obj);
+    lv_obj_class_init_obj(obj);
+    if(obj == NULL) return NULL;
+    lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
 
-    if(auto_parent) lv_obj_add_flag(mbox, LV_MSGBOX_FLAG_AUTO_PARENT);
+    if(auto_parent) lv_obj_add_flag(obj, LV_MSGBOX_FLAG_AUTO_PARENT);
 
-    lv_obj_set_size(mbox, LV_DPI_DEF * 2, LV_SIZE_CONTENT);
-    lv_obj_set_flex_flow(mbox, LV_FLEX_FLOW_ROW_WRAP);
-    lv_obj_set_flex_align(mbox, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_START);
+    lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_ROW_WRAP);
 
-    lv_obj_t * label;
-    label = lv_label_create(mbox);
-    lv_label_set_text(label, title);
-    lv_label_set_long_mode(label, LV_LABEL_LONG_SCROLL_CIRCULAR);
-    if(add_close_btn) lv_obj_set_flex_grow(label, 1);
-    else lv_obj_set_width(label, LV_PCT(100));
+    bool has_title = title && strlen(title) > 0;
+
+    /*When a close button is required, we need the empty label as spacer to push the button to the right*/
+    if (add_close_btn || has_title) {
+        mbox->title = lv_label_create(obj);
+        lv_label_set_text(mbox->title, has_title ? title : "");
+        lv_label_set_long_mode(mbox->title, LV_LABEL_LONG_SCROLL_CIRCULAR);
+        if(add_close_btn) lv_obj_set_flex_grow(mbox->title, 1);
+        else lv_obj_set_width(mbox->title, LV_PCT(100));
+    }
 
     if(add_close_btn) {
-        lv_obj_t * close_btn = lv_btn_create(mbox);
-        lv_obj_set_ext_click_area(close_btn, LV_DPX(10));
-        lv_obj_add_event_cb(close_btn, msgbox_close_click_event_cb, LV_EVENT_CLICKED, NULL);
-        label = lv_label_create(close_btn);
+        mbox->close_btn = lv_btn_create(obj);
+        lv_obj_set_ext_click_area(mbox->close_btn, LV_DPX(10));
+        lv_obj_add_event_cb(mbox->close_btn, msgbox_close_click_event_cb, LV_EVENT_CLICKED, NULL);
+        lv_obj_t * label = lv_label_create(mbox->close_btn);
         lv_label_set_text(label, LV_SYMBOL_CLOSE);
-        const lv_font_t * font = lv_obj_get_style_text_font(close_btn, LV_PART_MAIN);
+        const lv_font_t * font = lv_obj_get_style_text_font(mbox->close_btn, LV_PART_MAIN);
         lv_coord_t close_btn_size = lv_font_get_line_height(font) + LV_DPX(10);
-        lv_obj_set_size(close_btn, close_btn_size, close_btn_size);
+        lv_obj_set_size(mbox->close_btn, close_btn_size, close_btn_size);
         lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
     }
 
-    label = lv_label_create(mbox);
-    lv_label_set_text(label, txt);
-    lv_label_set_long_mode(label, LV_LABEL_LONG_WRAP);
-    lv_obj_set_width(label, LV_PCT(100));
+    mbox->content = lv_obj_class_create_obj(&lv_msgbox_content_class, obj);
+
+    bool has_txt = txt && strlen(txt) > 0;
+    if (has_txt) {
+        mbox->text = lv_label_create(mbox->content);
+        lv_label_set_text(mbox->text, txt);
+        lv_label_set_long_mode(mbox->text, LV_LABEL_LONG_WRAP);
+        lv_obj_set_width(mbox->text, lv_pct(100));
+    }
 
     if(btn_txts) {
-        lv_obj_t * btns = lv_btnmatrix_create(mbox);
-        lv_btnmatrix_set_map(btns, btn_txts);
-        lv_btnmatrix_set_btn_ctrl_all(btns, LV_BTNMATRIX_CTRL_CLICK_TRIG | LV_BTNMATRIX_CTRL_NO_REPEAT);
+        mbox->btns = lv_btnmatrix_create(obj);
+        lv_btnmatrix_set_map(mbox->btns, btn_txts);
+        lv_btnmatrix_set_btn_ctrl_all(mbox->btns, LV_BTNMATRIX_CTRL_CLICK_TRIG | LV_BTNMATRIX_CTRL_NO_REPEAT);
 
         uint32_t btn_cnt = 0;
         while(btn_txts[btn_cnt] && btn_txts[btn_cnt][0] != '\0') {
             btn_cnt++;
         }
 
-        const lv_font_t * font = lv_obj_get_style_text_font(btns, LV_PART_ITEMS);
+        const lv_font_t * font = lv_obj_get_style_text_font(mbox->btns, LV_PART_ITEMS);
         lv_coord_t btn_h = lv_font_get_line_height(font) + LV_DPI_DEF / 10;
-        lv_obj_set_size(btns, btn_cnt * (2 * LV_DPI_DEF / 3), btn_h);
-        lv_obj_add_flag(btns, LV_OBJ_FLAG_EVENT_BUBBLE);    /*To see the event directly on the message box*/
+        lv_obj_set_size(mbox->btns, btn_cnt * (2 * LV_DPI_DEF / 3), btn_h);
+        lv_obj_set_style_max_width(mbox->btns, lv_pct(100), 0);
+        lv_obj_add_flag(mbox->btns, LV_OBJ_FLAG_EVENT_BUBBLE);    /*To see the event directly on the message box*/
     }
 
-    return mbox;
+    return obj;
 }
 
 
-lv_obj_t * lv_msgbox_get_title(lv_obj_t * mbox)
+lv_obj_t * lv_msgbox_get_title(lv_obj_t * obj)
 {
-    return lv_obj_get_child(mbox, 0);
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
+    return mbox->title;
 }
 
-lv_obj_t * lv_msgbox_get_close_btn(lv_obj_t * mbox)
+lv_obj_t * lv_msgbox_get_close_btn(lv_obj_t * obj)
 {
-    lv_obj_t * obj = lv_obj_get_child(mbox, 1);
-    if(lv_obj_check_type(obj, &lv_btn_class)) return obj;
-    else return NULL;
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
+    return mbox->close_btn;
 }
 
-lv_obj_t * lv_msgbox_get_text(lv_obj_t * mbox)
+lv_obj_t * lv_msgbox_get_text(lv_obj_t * obj)
 {
-    return lv_obj_get_child(mbox, lv_obj_get_child_cnt(mbox) - 2);
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
+    return mbox->text;
 }
 
-lv_obj_t * lv_msgbox_get_btns(lv_obj_t * mbox)
+lv_obj_t * lv_msgbox_get_content(lv_obj_t * obj)
 {
-    return lv_obj_get_child(mbox, lv_obj_get_child_cnt(mbox) - 1);
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
+    return mbox->content;
+}
+
+lv_obj_t * lv_msgbox_get_btns(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_msgbox_t * mbox = (lv_msgbox_t *)obj;
+    return mbox->btns;
+}
+
+uint16_t lv_msgbox_get_active_btn(lv_obj_t * mbox)
+{
+    lv_obj_t * btnm = lv_msgbox_get_btns(mbox);
+    return lv_btnmatrix_get_selected_btn(btnm);
 }
 
 const char * lv_msgbox_get_active_btn_text(lv_obj_t * mbox)
@@ -140,6 +189,11 @@ void lv_msgbox_close(lv_obj_t * mbox)
     else lv_obj_del(mbox);
 }
 
+void lv_msgbox_close_async(lv_obj_t * dialog)
+{
+    if(lv_obj_has_flag(dialog, LV_MSGBOX_FLAG_AUTO_PARENT)) lv_obj_del_async(lv_obj_get_parent(dialog));
+    else lv_obj_del_async(dialog);
+}
 
 /**********************
  *   STATIC FUNCTIONS
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/msgbox/lv_msgbox.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/msgbox/lv_msgbox.h
index 6a54f85fa..2eaf0d399 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/msgbox/lv_msgbox.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/msgbox/lv_msgbox.h
@@ -33,14 +33,26 @@ extern "C" {
 /**********************
  *      TYPEDEFS
  **********************/
+
+typedef struct {
+    lv_obj_t obj;
+    lv_obj_t * title;
+    lv_obj_t * close_btn;
+    lv_obj_t * content;
+    lv_obj_t * text;
+    lv_obj_t * btns;
+} lv_msgbox_t;
+
 extern const lv_obj_class_t lv_msgbox_class;
+extern const lv_obj_class_t lv_msgbox_content_class;
+extern const lv_obj_class_t lv_msgbox_backdrop_class;
 
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
 /**
- * Create a message box objects
+ * Create a message box object
  * @param parent        pointer to parent or NULL to create a full screen modal message box
  * @param title         the title of the message box
  * @param txt           the text of the message box
@@ -48,20 +60,32 @@ extern const lv_obj_class_t lv_msgbox_class;
  * @param add_close_btn true: add a close button
  * @return              pointer to the message box object
  */
-lv_obj_t * lv_msgbox_create(lv_obj_t * parent, const char * title, const char * txt, const char * btn_txts[], bool add_close_btn);
+lv_obj_t * lv_msgbox_create(lv_obj_t * parent, const char * title, const char * txt, const char * btn_txts[],
+                            bool add_close_btn);
 
-lv_obj_t * lv_msgbox_get_title(lv_obj_t * mbox);
+lv_obj_t * lv_msgbox_get_title(lv_obj_t * obj);
 
-lv_obj_t * lv_msgbox_get_close_btn(lv_obj_t * mbox);
+lv_obj_t * lv_msgbox_get_close_btn(lv_obj_t * obj);
 
-lv_obj_t * lv_msgbox_get_text(lv_obj_t * mbox);
+lv_obj_t * lv_msgbox_get_text(lv_obj_t * obj);
 
-lv_obj_t * lv_msgbox_get_btns(lv_obj_t * mbox);
+lv_obj_t * lv_msgbox_get_content(lv_obj_t * obj);
+
+lv_obj_t * lv_msgbox_get_btns(lv_obj_t * obj);
+
+/**
+ * Get the index of the selected button
+ * @param mbox message box object
+ * @return     index of the button (LV_BTNMATRIX_BTN_NONE: if unset)
+ */
+uint16_t lv_msgbox_get_active_btn(lv_obj_t * mbox);
 
 const char * lv_msgbox_get_active_btn_text(lv_obj_t * mbox);
 
 void lv_msgbox_close(lv_obj_t * mbox);
 
+void lv_msgbox_close_async(lv_obj_t * mbox);
+
 /**********************
  *      MACROS
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/span/lv_span.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/span/lv_span.c
index d9e4a6426..4e2f9f7bc 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/span/lv_span.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/span/lv_span.c
@@ -10,6 +10,8 @@
 
 #if LV_USE_SPAN != 0
 
+#include "../../../misc/lv_assert.h"
+
 /*********************
  *      DEFINES
  *********************/
@@ -45,7 +47,6 @@ static void refresh_self_size(lv_obj_t * obj);
 static const lv_font_t * lv_span_get_style_text_font(lv_obj_t * par, lv_span_t * span);
 static lv_coord_t lv_span_get_style_text_letter_space(lv_obj_t * par, lv_span_t * span);
 static lv_color_t lv_span_get_style_text_color(lv_obj_t * par, lv_span_t * span);
-static lv_color_t lv_span_get_style_text_color(lv_obj_t * par, lv_span_t * span);
 static lv_opa_t lv_span_get_style_text_opa(lv_obj_t * par, lv_span_t * span);
 static lv_opa_t lv_span_get_style_text_blend_mode(lv_obj_t * par, lv_span_t * span);
 static int32_t lv_span_get_style_text_decor(lv_obj_t * par, lv_span_t * span);
@@ -57,9 +58,10 @@ static bool lv_txt_get_snippet(const char * txt, const lv_font_t * font, lv_coor
                                uint32_t * end_ofs);
 
 static void lv_snippet_clear(void);
-static uint16_t lv_get_snippet_cnt();
+static uint16_t lv_get_snippet_cnt(void);
 static void lv_snippet_push(lv_snippet_t * item);
 static lv_snippet_t * lv_get_snippet(uint16_t index);
+static lv_coord_t convert_indent_pct(lv_obj_t * spans, lv_coord_t width);
 
 /**********************
  *  STATIC VARIABLES
@@ -107,6 +109,7 @@ lv_span_t * lv_spangroup_new_span(lv_obj_t * obj)
         return NULL;
     }
 
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     lv_span_t * span = _lv_ll_ins_tail(&spans->child_ll);
     LV_ASSERT_MALLOC(span);
@@ -132,6 +135,7 @@ void lv_spangroup_del_span(lv_obj_t * obj, lv_span_t * span)
         return;
     }
 
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     lv_span_t * cur_span;
     _LV_LL_READ(&spans->child_ll, cur_span) {
@@ -214,6 +218,7 @@ void lv_spangroup_set_align(lv_obj_t * obj, lv_text_align_t align)
  */
 void lv_spangroup_set_overflow(lv_obj_t * obj, lv_span_overflow_t overflow)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     if(spans->overflow == overflow) return;
 
@@ -224,10 +229,12 @@ void lv_spangroup_set_overflow(lv_obj_t * obj, lv_span_overflow_t overflow)
 /**
  * Set the indent of the spangroup.
  * @param obj pointer to a spangroup object.
- * @param indent The first line indentation
+ * @param indent The first line indentation, support percent
+ *               for LV_SPAN_MODE_FIXED and LV_SPAN_MODE_BREAK mode.
  */
 void lv_spangroup_set_indent(lv_obj_t * obj, lv_coord_t indent)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     if(spans->indent == indent) return;
 
@@ -243,9 +250,8 @@ void lv_spangroup_set_indent(lv_obj_t * obj, lv_coord_t indent)
  */
 void lv_spangroup_set_mode(lv_obj_t * obj, lv_span_mode_t mode)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
-    if(spans->mode == mode) return;
-
     spans->mode = mode;
     lv_spangroup_refr_mode(obj);
 }
@@ -254,6 +260,73 @@ void lv_spangroup_set_mode(lv_obj_t * obj, lv_span_mode_t mode)
  * Getter functions
  *====================*/
 
+/**
+ * Get a spangroup child by its index.
+ *
+ * @param obj   The spangroup object
+ * @param id    the index of the child.
+ *              0: the oldest (firstly created) child
+ *              1: the second oldest
+ *              child count-1: the youngest
+ *              -1: the youngest
+ *              -2: the second youngest
+ * @return      The child span at index `id`, or NULL if the ID does not exist
+ */
+lv_span_t * lv_spangroup_get_child(const lv_obj_t * obj, int32_t id)
+{
+    if(obj == NULL) {
+        return NULL;
+    }
+
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_spangroup_t * spans = (lv_spangroup_t *)obj;
+    lv_ll_t * linked_list = &spans->child_ll;
+
+    bool traverse_forwards = (id >= 0);
+    int32_t cur_idx = 0;
+    lv_ll_node_t * cur_node = linked_list->head;
+
+    /*If using a negative index, start from the tail and use cur -1 to indicate the end*/
+    if(!traverse_forwards) {
+        cur_idx = -1;
+        cur_node = linked_list->tail;
+    }
+
+    while(cur_node != NULL) {
+        if(cur_idx == id) {
+            return (lv_span_t *) cur_node;
+        }
+        if(traverse_forwards) {
+            cur_node = (lv_ll_node_t *) _lv_ll_get_next(linked_list, cur_node);
+            cur_idx++;
+        }
+        else {
+            cur_node = (lv_ll_node_t *) _lv_ll_get_prev(linked_list, cur_node);
+            cur_idx--;
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ *
+ * @param obj   The spangroup object to get the child count of.
+ * @return      The span count of the spangroup.
+ */
+uint32_t lv_spangroup_get_child_cnt(const lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    if(obj == NULL) {
+        return 0;
+    }
+
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_spangroup_t * spans = (lv_spangroup_t *)obj;
+    return _lv_ll_get_len(&(spans->child_ll));
+}
+
 /**
  * get the align of the spangroup.
  * @param obj pointer to a spangroup object.
@@ -271,6 +344,7 @@ lv_text_align_t lv_spangroup_get_align(lv_obj_t * obj)
  */
 lv_span_overflow_t lv_spangroup_get_overflow(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     return spans->overflow;
 }
@@ -282,6 +356,7 @@ lv_span_overflow_t lv_spangroup_get_overflow(lv_obj_t * obj)
  */
 lv_coord_t lv_spangroup_get_indent(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     return spans->indent;
 }
@@ -293,6 +368,7 @@ lv_coord_t lv_spangroup_get_indent(lv_obj_t * obj)
  */
 lv_span_mode_t lv_spangroup_get_mode(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     return spans->mode;
 }
@@ -303,6 +379,7 @@ lv_span_mode_t lv_spangroup_get_mode(lv_obj_t * obj)
  */
 void lv_spangroup_refr_mode(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
 
     if(spans->mode == LV_SPAN_MODE_EXPAND) {
@@ -340,6 +417,7 @@ void lv_spangroup_refr_mode(lv_obj_t * obj)
  */
 lv_coord_t lv_spangroup_get_max_line_h(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
 
     lv_coord_t max_line_h = 0;
@@ -361,21 +439,23 @@ lv_coord_t lv_spangroup_get_max_line_h(lv_obj_t * obj)
  */
 lv_coord_t lv_spangroup_get_expand_width(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
 
     if(_lv_ll_get_head(&spans->child_ll) == NULL) {
         return 0;
     }
 
-    lv_coord_t width = 0;
+    lv_coord_t width = LV_COORD_IS_PCT(spans->indent) ? 0 : spans->indent;
     lv_span_t * cur_span;
+    lv_coord_t letter_space = 0;
     _LV_LL_READ(&spans->child_ll, cur_span) {
         const lv_font_t * font = lv_span_get_style_text_font(obj, cur_span);
-        lv_coord_t letter_space = lv_span_get_style_text_letter_space(obj, cur_span);
+        letter_space = lv_span_get_style_text_letter_space(obj, cur_span);
         uint32_t j = 0;
         const char * cur_txt = cur_span->txt;
         span_text_check(&cur_txt);
-        while(cur_txt[j] != 0) {
+        while(cur_txt[j] != '\0') {
             uint32_t letter      = _lv_txt_encoded_next(cur_txt, &j);
             uint32_t letter_next = _lv_txt_encoded_next(&cur_txt[j], NULL);
             int32_t letter_w = lv_font_get_glyph_width(font, letter, letter_next);
@@ -383,7 +463,7 @@ lv_coord_t lv_spangroup_get_expand_width(lv_obj_t * obj)
         }
     }
 
-    return width;
+    return width - letter_space;
 }
 
 /**
@@ -392,6 +472,7 @@ lv_coord_t lv_spangroup_get_expand_width(lv_obj_t * obj)
  */
 lv_coord_t lv_spangroup_get_expand_height(lv_obj_t * obj, lv_coord_t width)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spangroup_t * spans = (lv_spangroup_t *)obj;
     if(_lv_ll_get_head(&spans->child_ll) == NULL || width <= 0) {
         return 0;
@@ -401,12 +482,13 @@ lv_coord_t lv_spangroup_get_expand_height(lv_obj_t * obj, lv_coord_t width)
     lv_text_flag_t txt_flag = LV_TEXT_FLAG_NONE;
     lv_coord_t line_space = lv_obj_get_style_text_line_space(obj, LV_PART_MAIN);
     lv_coord_t max_width = width;
-    lv_coord_t max_w  = max_width - spans->indent; /* first line need minus indent */
+    lv_coord_t indent = convert_indent_pct(obj, max_width);
+    lv_coord_t max_w  = max_width - indent; /* first line need minus indent */
 
     /* coords of draw span-txt */
     lv_point_t txt_pos;
     txt_pos.y = 0;
-    txt_pos.x = 0 + spans->indent; /* first line need add indent */
+    txt_pos.x = 0 + indent; /* first line need add indent */
 
     lv_span_t * cur_span = _lv_ll_get_head(&spans->child_ll);
     const char * cur_txt = cur_span->txt;
@@ -429,6 +511,8 @@ lv_coord_t lv_spangroup_get_expand_height(lv_obj_t * obj, lv_coord_t width)
                 cur_txt = cur_span->txt;
                 span_text_check(&cur_txt);
                 cur_txt_ofs = 0;
+                /* maybe also cur_txt[cur_txt_ofs] == '\0' */
+                continue;
             }
 
             /* init span info to snippet. */
@@ -475,6 +559,7 @@ lv_coord_t lv_spangroup_get_expand_height(lv_obj_t * obj, lv_coord_t width)
         txt_pos.y += max_line_h;
         max_w = max_width;
     }
+    txt_pos.y -= line_space;
 
     return txt_pos.y;
 }
@@ -587,6 +672,12 @@ static bool lv_txt_get_snippet(const char * txt, const lv_font_t * font,
                                lv_coord_t letter_space, lv_coord_t max_width, lv_text_flag_t flag,
                                lv_coord_t * use_width, uint32_t * end_ofs)
 {
+    if(txt == NULL || txt[0] == '\0') {
+        *end_ofs = 0;
+        *use_width = 0;
+        return false;
+    }
+
     uint32_t ofs = _lv_txt_get_next_line(txt, font, letter_space, max_width, flag);
     lv_coord_t width = lv_txt_get_width(txt, ofs, font, letter_space, flag);
     *end_ofs = ofs;
@@ -611,7 +702,7 @@ static void lv_snippet_push(lv_snippet_t * item)
     }
 }
 
-static uint16_t lv_get_snippet_cnt()
+static uint16_t lv_get_snippet_cnt(void)
 {
     return snippet_stack.index;
 }
@@ -694,13 +785,11 @@ static lv_blend_mode_t lv_span_get_style_text_blend_mode(lv_obj_t * par, lv_span
 
 static int32_t lv_span_get_style_text_decor(lv_obj_t * par, lv_span_t * span)
 {
-    LV_UNUSED(par);
-
     int32_t decor;
     lv_style_value_t value;
     lv_res_t res = lv_style_get_prop(&span->style, LV_STYLE_TEXT_DECOR, &value);
     if(res != LV_RES_OK) {
-        decor = LV_TEXT_DECOR_NONE;
+        decor = (lv_text_decor_t)lv_obj_get_style_text_decor(par, LV_PART_MAIN);;
     }
     else {
         decor = (int32_t)value.num;
@@ -716,6 +805,23 @@ static inline void span_text_check(const char ** text)
     }
 }
 
+static lv_coord_t convert_indent_pct(lv_obj_t * obj, lv_coord_t width)
+{
+    lv_spangroup_t * spans = (lv_spangroup_t *)obj;
+
+    lv_coord_t indent = spans->indent;
+    if(LV_COORD_IS_PCT(spans->indent)) {
+        if(spans->mode == LV_SPAN_MODE_EXPAND) {
+            indent = 0;
+        }
+        else {
+            indent = (width * LV_COORD_GET_PCT(spans->indent)) / 100;
+        }
+    }
+
+    return indent;
+}
+
 /**
  * draw span group
  * @param spans obj handle
@@ -740,12 +846,14 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
     lv_text_flag_t txt_flag = LV_TEXT_FLAG_NONE;
     lv_coord_t line_space = lv_obj_get_style_text_line_space(obj, LV_PART_MAIN);;
     lv_coord_t max_width = lv_area_get_width(coords);
-    lv_coord_t max_w  = max_width - spans->indent; /* first line need minus indent */
+    lv_coord_t indent = convert_indent_pct(obj, max_width);
+    lv_coord_t max_w  = max_width - indent; /* first line need minus indent */
+    lv_opa_t obj_opa = lv_obj_get_style_opa(obj, LV_PART_MAIN);
 
     /* coords of draw span-txt */
     lv_point_t txt_pos;
     txt_pos.y = coords->y1;
-    txt_pos.x = coords->x1 + spans->indent; /* first line need add indent */
+    txt_pos.x = coords->x1 + indent; /* first line need add indent */
 
     lv_span_t * cur_span = _lv_ll_get_head(&spans->child_ll);
     const char * cur_txt = cur_span->txt;
@@ -754,8 +862,11 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
     lv_snippet_t snippet;   /* use to save cur_span info and push it to stack */
     memset(&snippet, 0, sizeof(snippet));
 
+    bool is_first_line = true;
     /* the loop control how many lines need to draw */
     while(cur_span) {
+        bool is_end_line = false;
+        bool ellipsis_valid = false;
         lv_coord_t max_line_h = 0;  /* the max height of span-font when a line have a lot of span */
         lv_snippet_clear();
 
@@ -768,6 +879,8 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
                 cur_txt = cur_span->txt;
                 span_text_check(&cur_txt);
                 cur_txt_ofs = 0;
+                /* maybe also cur_txt[cur_txt_ofs] == '\0' */
+                continue;
             }
 
             /* init span info to snippet. */
@@ -779,8 +892,10 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
             }
 
             if(spans->overflow == LV_SPAN_OVERFLOW_ELLIPSIS) {
-                /* span txt overflow, don't push */
+                /* curretn line span txt overflow, don't push */
                 if(txt_pos.y + snippet.line_h - line_space > coords->y2 + 1) {
+                    ellipsis_valid = true;
+                    is_end_line = true;
                     break;
                 }
             }
@@ -791,13 +906,32 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
             bool isfill = lv_txt_get_snippet(&cur_txt[cur_txt_ofs], snippet.font, snippet.letter_space,
                                              max_w, txt_flag, &use_width, &next_ofs);
 
-            /* break word deal width */
-            if(isfill && next_ofs > 0 && lv_get_snippet_cnt() > 0) {
-                uint32_t letter = (uint32_t)cur_txt[cur_txt_ofs + next_ofs - 1];
-                if(!(letter == '\0' || letter == '\n' || letter == '\r' || _lv_txt_is_break_char(letter))) {
-                    letter = (uint32_t)cur_txt[cur_txt_ofs + next_ofs];
-                    if(!(letter == '\0' || letter == '\n'  || letter == '\r' || _lv_txt_is_break_char(letter))) {
-                        break;
+            if(isfill) {
+                lv_coord_t next_line_h = snippet.line_h;
+                if(cur_txt[cur_txt_ofs + next_ofs] == '\0') {
+                    next_line_h = 0;
+                    lv_span_t * next_span = _lv_ll_get_next(&spans->child_ll, cur_span);
+                    if(next_span) { /* have the next line */
+                        next_line_h = lv_font_get_line_height(lv_span_get_style_text_font(obj, next_span)) + line_space;
+                    }
+                }
+                lv_coord_t cur_line_h = max_line_h < snippet.line_h ? snippet.line_h : max_line_h;
+                if(txt_pos.y + cur_line_h + next_line_h - line_space > coords->y2 + 1) { /* for overflow if is end line. */
+                    if(cur_txt[cur_txt_ofs + next_ofs] != '\0') {
+                        next_ofs = strlen(&cur_txt[cur_txt_ofs]);
+                        use_width = lv_txt_get_width(&cur_txt[cur_txt_ofs], next_ofs, snippet.font, snippet.letter_space, txt_flag);
+                        ellipsis_valid = spans->overflow == LV_SPAN_OVERFLOW_ELLIPSIS ? true : false;
+                        is_end_line = true;
+                    }
+                }
+                else if(next_ofs > 0 && lv_get_snippet_cnt() > 0) {
+                    /* break word deal width */
+                    uint32_t letter = (uint32_t)cur_txt[cur_txt_ofs + next_ofs - 1];
+                    if(!(letter == '\0' || letter == '\n' || letter == '\r' || _lv_txt_is_break_char(letter))) {
+                        letter = (uint32_t)cur_txt[cur_txt_ofs + next_ofs];
+                        if(!(letter == '\0' || letter == '\n'  || letter == '\r' || _lv_txt_is_break_char(letter))) {
+                            break;
+                        }
                     }
                 }
             }
@@ -811,10 +945,10 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
             }
 
             lv_snippet_push(&snippet);
-            if(isfill) {
+            max_w = max_w - use_width - snippet.letter_space;
+            if(isfill || max_w <= 0) {
                 break;
             }
-            max_w -= use_width;
         }
 
         /* start current line deal width */
@@ -829,38 +963,19 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
             goto Next_line_init;
         }
 
-        /* overflow deal width */
-        bool ellipsis_valid = false;
-        if(spans->overflow == LV_SPAN_OVERFLOW_ELLIPSIS) {
-            lv_coord_t next_line_h = snippet.line_h;
-            if(cur_txt[cur_txt_ofs] == '\0') {  /* current span deal with ok, need get next line first line height */
-                next_line_h = 0;
-                if(cur_span) {
-                    lv_span_t * next_span = _lv_ll_get_next(&spans->child_ll, cur_span);
-                    if(next_span) { /* have the next line */
-                        next_line_h = lv_font_get_line_height(lv_span_get_style_text_font(obj, next_span)) + line_space;
-                    }
-                }
-            }
-            if(txt_pos.y + max_line_h + next_line_h > coords->y2  + 1) {
-                ellipsis_valid = true;
-            }
-        }
-
         /* align deal with */
         lv_text_align_t align = lv_obj_get_style_text_align(obj, LV_PART_MAIN);
         if(align != LV_TEXT_ALIGN_LEFT) {
             lv_coord_t align_ofs = 0;
-            lv_coord_t txts_w = 0;
+            lv_coord_t txts_w = is_first_line ? indent : 0;
             for(int i = 0; i < item_cnt; i++) {
                 lv_snippet_t * pinfo = lv_get_snippet(i);
-                txts_w += pinfo->txt_w;
+                txts_w = txts_w + pinfo->txt_w + pinfo->letter_space;
             }
+            txts_w -= lv_get_snippet(item_cnt - 1)->letter_space;
+            align_ofs = max_width > txts_w ? max_width - txts_w : 0;
             if(align == LV_TEXT_ALIGN_CENTER) {
-                align_ofs = (max_width - txts_w) / 2;
-            }
-            else if(align == LV_TEXT_ALIGN_RIGHT) {
-                align_ofs = max_width - txts_w;
+                align_ofs = align_ofs >> 1;
             }
             txt_pos.x += align_ofs;
         }
@@ -877,6 +992,9 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
             pos.y = txt_pos.y + max_line_h - pinfo->line_h;
             lv_color_t letter_color = lv_span_get_style_text_color(obj, pinfo->span);
             lv_opa_t letter_opa = lv_span_get_style_text_opa(obj, pinfo->span);
+            if(obj_opa < LV_OPA_MAX) {
+                letter_opa = (uint16_t)((uint16_t)letter_opa * obj_opa) >> 8;
+            }
             lv_blend_mode_t blend_mode = lv_span_get_style_text_blend_mode(obj, pinfo->span);
             uint32_t txt_bytes = pinfo->bytes;
 
@@ -884,7 +1002,6 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
             uint16_t dot_letter_w = 0;
             uint16_t dot_width = 0;
             if(ellipsis_valid) {
-                txt_bytes = strlen(bidi_txt);
                 dot_letter_w = lv_font_get_glyph_width(pinfo->font, '.', '.');
                 dot_width = dot_letter_w * 3;
             }
@@ -913,6 +1030,9 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
                         lv_draw_letter(&pos, &clipped_area, pinfo->font, '.', letter_color, letter_opa, blend_mode);
                         pos.x = pos.x + dot_letter_w + pinfo->letter_space;
                     }
+                    if(pos.x <= ellipsis_width) {
+                        pos.x = ellipsis_width + 1;
+                    }
                     break;
                 }
                 else {
@@ -944,7 +1064,7 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
                     lv_point_t p1;
                     lv_point_t p2;
                     p1.x = txt_pos.x;
-                    p1.y = pos.y + (pinfo->line_h / 2)  + line_dsc.width / 2;
+                    p1.y = pos.y + ((pinfo->line_h - line_space) >> 1)  + (line_dsc.width >> 1);
                     p2.x = pos.x;
                     p2.y = p1.y;
                     lv_draw_line(&p1, &p2, mask, &line_dsc);
@@ -954,7 +1074,7 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
                     lv_point_t p1;
                     lv_point_t p2;
                     p1.x = txt_pos.x;
-                    p1.y = pos.y + pinfo->line_h + line_dsc.width / 2;
+                    p1.y = pos.y + pinfo->line_h - line_space - pinfo->font->base_line - pinfo->font->underline_position;
                     p2.x = pos.x;
                     p2.y = p1.y;
                     lv_draw_line(&p1, &p2, &clipped_area, &line_dsc);
@@ -965,9 +1085,10 @@ static void lv_draw_span(lv_obj_t * obj, const lv_area_t * coords, const lv_area
 
 Next_line_init:
         /* next line init */
+        is_first_line = false;
         txt_pos.x = coords->x1;
         txt_pos.y += max_line_h;
-        if(txt_pos.y > clipped_area.y2 + 1) {
+        if(is_end_line || txt_pos.y > clipped_area.y2 + 1) {
             return;
         }
         max_w = max_width;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/span/lv_span.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/span/lv_span.h
index 4f7613de3..c130465ea 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/span/lv_span.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/span/lv_span.h
@@ -137,6 +137,27 @@ void lv_spangroup_set_mode(lv_obj_t * obj, lv_span_mode_t mode);
  * Getter functions
  *====================*/
 
+/**
+ * Get a spangroup child by its index.
+ *
+ * @param obj   The spangroup object
+ * @param id    the index of the child.
+ *              0: the oldest (firstly created) child
+ *              1: the second oldest
+ *              child count-1: the youngest
+ *              -1: the youngest
+ *              -2: the second youngest
+ * @return      The child span at index `id`, or NULL if the ID does not exist
+ */
+lv_span_t * lv_spangroup_get_child(const lv_obj_t * obj, int32_t id);
+
+/**
+ *
+ * @param obj   The spangroup object to get the child count of.
+ * @return      The span count of the spangroup.
+ */
+uint32_t lv_spangroup_get_child_cnt(const lv_obj_t * obj);
+
 /**
  * get the align of the spangroup.
  * @param obj pointer to a spangroup object.
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinbox/lv_spinbox.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinbox/lv_spinbox.c
index 66bfdd0e6..97d00404e 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinbox/lv_spinbox.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinbox/lv_spinbox.c
@@ -9,6 +9,8 @@
 #include "lv_spinbox.h"
 #if LV_USE_SPINBOX
 
+#include "../../../misc/lv_assert.h"
+
 /*********************
  *      DEFINES
  *********************/
@@ -46,7 +48,7 @@ const lv_obj_class_t lv_spinbox_class = {
 
 lv_obj_t * lv_spinbox_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -63,6 +65,7 @@ lv_obj_t * lv_spinbox_create(lv_obj_t * parent)
  */
 void lv_spinbox_set_value(lv_obj_t * obj, int32_t i)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     if(i > spinbox->range_max) i = spinbox->range_max;
@@ -80,6 +83,7 @@ void lv_spinbox_set_value(lv_obj_t * obj, int32_t i)
  */
 void lv_spinbox_set_rollover(lv_obj_t * obj, bool b)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->rollover = b;
@@ -94,6 +98,7 @@ void lv_spinbox_set_rollover(lv_obj_t * obj, bool b)
  */
 void lv_spinbox_set_digit_format(lv_obj_t * obj, uint8_t digit_count, uint8_t separator_position)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     if(digit_count > LV_SPINBOX_MAX_DIGIT_COUNT) digit_count = LV_SPINBOX_MAX_DIGIT_COUNT;
@@ -120,6 +125,7 @@ void lv_spinbox_set_digit_format(lv_obj_t * obj, uint8_t digit_count, uint8_t se
  */
 void lv_spinbox_set_step(lv_obj_t * obj, uint32_t step)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->step = step;
@@ -134,6 +140,7 @@ void lv_spinbox_set_step(lv_obj_t * obj, uint32_t step)
  */
 void lv_spinbox_set_range(lv_obj_t * obj, int32_t range_min, int32_t range_max)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     spinbox->range_max = range_max;
@@ -145,6 +152,37 @@ void lv_spinbox_set_range(lv_obj_t * obj, int32_t range_min, int32_t range_max)
     lv_spinbox_updatevalue(obj);
 }
 
+/**
+ * Set cursor position to a specific digit for edition
+ * @param spinbox pointer to spinbox
+ * @param pos selected position in spinbox
+ */
+void lv_spinbox_set_pos(lv_obj_t * obj, uint8_t pos)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
+    int32_t step_limit;
+    step_limit       = LV_MAX(spinbox->range_max, (spinbox->range_min < 0 ? (-spinbox->range_min) : spinbox->range_min));
+    int32_t new_step = spinbox->step * lv_pow(10, pos);
+    if(pos <= 0) spinbox->step = 1;
+    else if(new_step <= step_limit) spinbox->step = new_step;
+
+    lv_spinbox_updatevalue(obj);
+}
+
+/**
+ * Set direction of digit step when clicking an encoder button while in editing mode
+ * @param spinbox pointer to spinbox
+ * @param direction the direction (LV_DIR_RIGHT or LV_DIR_LEFT)
+ */
+void lv_spinbox_set_digit_step_direction(lv_obj_t *obj, lv_dir_t direction)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
+    spinbox->digit_step_dir = direction;
+
+    lv_spinbox_updatevalue(obj);
+}
 /*=====================
  * Getter functions
  *====================*/
@@ -156,6 +194,7 @@ void lv_spinbox_set_range(lv_obj_t * obj, int32_t range_min, int32_t range_max)
  */
 int32_t lv_spinbox_get_value(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     return spinbox->value;
@@ -167,6 +206,7 @@ int32_t lv_spinbox_get_value(lv_obj_t * obj)
  */
 int32_t lv_spinbox_get_step(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     return spinbox->step;
@@ -182,6 +222,7 @@ int32_t lv_spinbox_get_step(lv_obj_t * obj)
  */
 void lv_spinbox_step_next(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     int32_t new_step = spinbox->step / 10;
@@ -199,6 +240,7 @@ void lv_spinbox_step_next(lv_obj_t * obj)
  */
 void lv_spinbox_step_prev(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
     int32_t step_limit;
     step_limit       = LV_MAX(spinbox->range_max, (spinbox->range_min < 0 ? (-spinbox->range_min) : spinbox->range_min));
@@ -214,6 +256,7 @@ void lv_spinbox_step_prev(lv_obj_t * obj)
  */
 bool lv_spinbox_get_rollover(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     return spinbox->rollover;
@@ -225,6 +268,7 @@ bool lv_spinbox_get_rollover(lv_obj_t * obj)
  */
 void lv_spinbox_increment(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     if(spinbox->value + spinbox->step <= spinbox->range_max) {
@@ -250,6 +294,7 @@ void lv_spinbox_increment(lv_obj_t * obj)
  */
 void lv_spinbox_decrement(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_spinbox_t * spinbox = (lv_spinbox_t *)obj;
 
     if(spinbox->value - spinbox->step >= spinbox->range_min) {
@@ -287,6 +332,7 @@ static void lv_spinbox_constructor(const lv_obj_class_t * class_p, lv_obj_t * ob
     spinbox->range_max          = 99999;
     spinbox->range_min          = -99999;
     spinbox->rollover           = false;
+    spinbox->digit_step_dir     = LV_DIR_RIGHT;
 
     lv_textarea_set_one_line(obj, true);
     lv_textarea_set_cursor_click_pos(obj, true);
@@ -314,19 +360,27 @@ static void lv_spinbox_event(const lv_obj_class_t * class_p, lv_event_t * e)
         lv_indev_t * indev = lv_indev_get_act();
         if(lv_indev_get_type(indev) == LV_INDEV_TYPE_ENCODER) {
             if(lv_group_get_editing(lv_obj_get_group(obj))) {
-                if(spinbox->step > 1) {
-                    lv_spinbox_step_next(obj);
-                }
-                else {
-                    /*Restart from the MSB*/
-                    spinbox->step = 1;
-                    uint32_t i;
-                    for(i = 0; i < spinbox->digit_count; i++) {
-                        int32_t new_step = spinbox->step * 10;
-                        if(new_step >= spinbox->range_max) break;
-                        spinbox->step = new_step;
+                if (spinbox->digit_count > 1) {
+                    if (spinbox->digit_step_dir == LV_DIR_RIGHT) {
+                        if(spinbox->step > 1) {
+                           lv_spinbox_step_next(obj);
+                        }
+                        else {
+                            /*Restart from the MSB*/
+                            spinbox->step = lv_pow(10, spinbox->digit_count - 2);
+                            lv_spinbox_step_prev(obj);
+                        }
+                    }
+                    else {
+                        if(spinbox->step < lv_pow(10, spinbox->digit_count - 1)) {
+                            lv_spinbox_step_prev(obj);
+                        }
+                        else {
+                            /*Restart from the LSB*/
+                            spinbox->step = 10;
+                            lv_spinbox_step_next(obj);
+                        }
                     }
-                    lv_spinbox_step_prev(obj);
                 }
             }
         }
@@ -409,7 +463,7 @@ static void lv_spinbox_updatevalue(lv_obj_t * obj)
     int32_t i;
     char digits[LV_SPINBOX_MAX_DIGIT_COUNT + 4];
     /*Convert the numbers to string (the sign is already handled so always covert positive number)*/
-    lv_snprintf(digits, sizeof(digits), "%d", LV_ABS(spinbox->value));
+    lv_snprintf(digits, sizeof(digits), "%" LV_PRId32, LV_ABS(spinbox->value));
 
     /*Add leading zeros*/
     int lz_cnt = spinbox->digit_count - (int)strlen(digits);
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinbox/lv_spinbox.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinbox/lv_spinbox.h
index 92000a042..71856c917 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinbox/lv_spinbox.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinbox/lv_spinbox.h
@@ -42,6 +42,7 @@ typedef struct {
     uint16_t digit_count : 4;
     uint16_t dec_point_pos : 4; /*if 0, there is no separator and the number is an integer*/
     uint16_t rollover : 1;   // Set to true for rollover functionality
+    uint16_t digit_step_dir : 2; // the direction the digit will step on encoder button press when editing
 } lv_spinbox_t;
 
 extern const lv_obj_class_t lv_spinbox_class;
@@ -99,6 +100,20 @@ void lv_spinbox_set_step(lv_obj_t * obj, uint32_t step);
  */
 void lv_spinbox_set_range(lv_obj_t * obj, int32_t range_min, int32_t range_max);
 
+/**
+ * Set cursor position to a specific digit for edition
+ * @param spinbox pointer to spinbox
+ * @param pos selected position in spinbox
+ */
+void lv_spinbox_set_pos(lv_obj_t * obj, uint8_t pos);
+
+/**
+ * Set direction of digit step when clicking an encoder button while in editing mode
+ * @param spinbox pointer to spinbox
+ * @param direction the direction (LV_DIR_RIGHT or LV_DIR_LEFT)
+ */
+void lv_spinbox_set_digit_step_direction(lv_obj_t * obj, lv_dir_t direction);
+
 /*=====================
  * Getter functions
  *====================*/
@@ -107,7 +122,7 @@ void lv_spinbox_set_range(lv_obj_t * obj, int32_t range_min, int32_t range_max);
  * Get spinbox rollover function status
  * @param spinbox pointer to spinbox
  */
-bool lv_spinbox_get_rollover(lv_obj_t * obj);
+bool lv_spinbox_get_rollover(lv_obj_t *obj);
 
 /**
  * Get the spinbox numeral value (user has to convert to float according to its digit format)
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinner/lv_spinner.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinner/lv_spinner.c
index 98bbca49e..65b6b046a 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinner/lv_spinner.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/spinner/lv_spinner.c
@@ -28,8 +28,8 @@ static void arc_anim_end_angle(void * obj, int32_t v);
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_spinner_class = {
-        .base_class = &lv_arc_class,
-        .constructor_cb = lv_spinner_constructor
+    .base_class = &lv_arc_class,
+    .constructor_cb = lv_spinner_constructor
 };
 
 static uint32_t time_param;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/tabview/lv_tabview.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/tabview/lv_tabview.c
index 1fff72625..8ccd143e1 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/tabview/lv_tabview.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/tabview/lv_tabview.c
@@ -9,9 +9,12 @@
 #include "lv_tabview.h"
 #if LV_USE_TABVIEW
 
+#include "../../../misc/lv_assert.h"
+
 /*********************
  *      DEFINES
  *********************/
+#define MY_CLASS    &lv_tabview_class
 
 /**********************
  *      TYPEDEFS
@@ -30,13 +33,14 @@ static void cont_scroll_end_event_cb(lv_event_t * e);
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_tabview_class = {
-        .constructor_cb = lv_tabview_constructor,
-        .destructor_cb = lv_tabview_destructor,
-        .event_cb = lv_tabview_event,
-        .width_def = LV_PCT(100),
-        .height_def = LV_PCT(100),
-        .base_class = &lv_obj_class,
-        .instance_size = sizeof(lv_tabview_t)};
+    .constructor_cb = lv_tabview_constructor,
+    .destructor_cb = lv_tabview_destructor,
+    .event_cb = lv_tabview_event,
+    .width_def = LV_PCT(100),
+    .height_def = LV_PCT(100),
+    .base_class = &lv_obj_class,
+    .instance_size = sizeof(lv_tabview_t)
+};
 
 static lv_dir_t tabpos_create;
 static lv_coord_t tabsize_create;
@@ -51,7 +55,7 @@ static lv_coord_t tabsize_create;
 
 lv_obj_t * lv_tabview_create(lv_obj_t * parent, lv_dir_t tab_pos, lv_coord_t tab_size)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     tabpos_create = tab_pos;
     tabsize_create = tab_size;
 
@@ -62,6 +66,7 @@ lv_obj_t * lv_tabview_create(lv_obj_t * parent, lv_dir_t tab_pos, lv_coord_t tab
 
 lv_obj_t * lv_tabview_add_tab(lv_obj_t * obj, const char * name)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_tabview_t * tabview = (lv_tabview_t *)obj;
     lv_obj_t * cont = lv_tabview_get_content(obj);
 
@@ -91,7 +96,8 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * obj, const char * name)
             new_map[0] = lv_mem_alloc(strlen(name) + 1);
             strcpy((char *)new_map[0], name);
             new_map[1] = "";
-        } else {
+        }
+        else {
             new_map[tab_id * 2 - 3] = "\n";
             new_map[tab_id * 2 - 2] = lv_mem_alloc(strlen(name) + 1);
             new_map[tab_id * 2 - 1] = "";
@@ -102,7 +108,8 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * obj, const char * name)
     lv_btnmatrix_set_map(btns, (const char **)new_map);
     lv_mem_free(old_map);
 
-    lv_btnmatrix_set_btn_ctrl_all(btns, LV_BTNMATRIX_CTRL_CHECKABLE | LV_BTNMATRIX_CTRL_CLICK_TRIG | LV_BTNMATRIX_CTRL_NO_REPEAT);
+    lv_btnmatrix_set_btn_ctrl_all(btns, LV_BTNMATRIX_CTRL_CHECKABLE | LV_BTNMATRIX_CTRL_CLICK_TRIG |
+                                  LV_BTNMATRIX_CTRL_NO_REPEAT);
 
     tabview->tab_cnt++;
     if(tabview->tab_cnt == 1) {
@@ -116,6 +123,7 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * obj, const char * name)
 
 void lv_tabview_set_act(lv_obj_t * obj, uint32_t id, lv_anim_enable_t anim_en)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_tabview_t * tabview = (lv_tabview_t *)obj;
 
     if(id >= tabview->tab_cnt) {
@@ -131,7 +139,8 @@ void lv_tabview_set_act(lv_obj_t * obj, uint32_t id, lv_anim_enable_t anim_en)
     lv_coord_t w = lv_obj_get_content_width(cont);
     if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) != LV_BASE_DIR_RTL) {
         lv_obj_scroll_to_x(cont, id * (gap + w), anim_en);
-    } else {
+    }
+    else {
         int32_t id_rtl = -(int32_t)id;
         lv_obj_scroll_to_x(cont, (gap + w) * id_rtl, anim_en);
     }
@@ -143,6 +152,7 @@ void lv_tabview_set_act(lv_obj_t * obj, uint32_t id, lv_anim_enable_t anim_en)
 
 uint16_t lv_tabview_get_tab_act(lv_obj_t * obj)
 {
+    LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_tabview_t * tabview = (lv_tabview_t *)obj;
     return tabview->tab_cur;
 }
@@ -169,18 +179,18 @@ static void lv_tabview_constructor(const lv_obj_class_t * class_p, lv_obj_t * ob
     tabview->tab_pos = tabpos_create;
 
     switch(tabview->tab_pos) {
-    case LV_DIR_TOP:
-        lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_COLUMN);
-        break;
-    case LV_DIR_BOTTOM:
-        lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_COLUMN_REVERSE);
-        break;
-    case LV_DIR_LEFT:
-        lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_ROW);
-        break;
-    case LV_DIR_RIGHT:
-        lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_ROW_REVERSE);
-        break;
+        case LV_DIR_TOP:
+            lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_COLUMN);
+            break;
+        case LV_DIR_BOTTOM:
+            lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_COLUMN_REVERSE);
+            break;
+        case LV_DIR_LEFT:
+            lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_ROW);
+            break;
+        case LV_DIR_RIGHT:
+            lv_obj_set_flex_flow(obj, LV_FLEX_FLOW_ROW_REVERSE);
+            break;
     }
 
     lv_obj_set_size(obj, LV_PCT(100), LV_PCT(100));
@@ -202,19 +212,19 @@ static void lv_tabview_constructor(const lv_obj_class_t * class_p, lv_obj_t * ob
     lv_obj_set_scrollbar_mode(cont, LV_SCROLLBAR_MODE_OFF);
 
     switch(tabview->tab_pos) {
-     case LV_DIR_TOP:
-     case LV_DIR_BOTTOM:
-         lv_obj_set_size(btnm, LV_PCT(100), tabsize_create);
-         lv_obj_set_width(cont, LV_PCT(100));
-         lv_obj_set_flex_grow(cont, 1);
-         break;
-     case LV_DIR_LEFT:
-     case LV_DIR_RIGHT:
-         lv_obj_set_size(btnm, tabsize_create, LV_PCT(100));
-         lv_obj_set_height(cont, LV_PCT(100));
-         lv_obj_set_flex_grow(cont, 1);
-         break;
-     }
+        case LV_DIR_TOP:
+        case LV_DIR_BOTTOM:
+            lv_obj_set_size(btnm, LV_PCT(100), tabsize_create);
+            lv_obj_set_width(cont, LV_PCT(100));
+            lv_obj_set_flex_grow(cont, 1);
+            break;
+        case LV_DIR_LEFT:
+        case LV_DIR_RIGHT:
+            lv_obj_set_size(btnm, tabsize_create, LV_PCT(100));
+            lv_obj_set_height(cont, LV_PCT(100));
+            lv_obj_set_flex_grow(cont, 1);
+            break;
+    }
 
     lv_group_t * g = lv_group_get_default();
     if(g) lv_group_add_obj(g, btnm);
@@ -289,8 +299,8 @@ static void cont_scroll_end_event_cb(lv_event_t * e)
         lv_coord_t w = lv_obj_get_content_width(cont);
         lv_coord_t t;
 
-        if(lv_obj_get_style_base_dir(tv, LV_PART_MAIN) == LV_BASE_DIR_RTL)  t = -(p.x - w/ 2) / w;
-        else t = (p.x + w/ 2) / w;
+        if(lv_obj_get_style_base_dir(tv, LV_PART_MAIN) == LV_BASE_DIR_RTL)  t = -(p.x - w / 2) / w;
+        else t = (p.x + w / 2) / w;
 
         if(t < 0) t = 0;
         bool new_tab = false;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/tabview/lv_tabview.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/tabview/lv_tabview.h
index 4cfc4971b..a01c6b9ba 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/tabview/lv_tabview.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/tabview/lv_tabview.h
@@ -25,14 +25,13 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
-typedef struct
-{
+typedef struct {
     lv_obj_t obj;
     char ** map;
     uint16_t tab_cnt;
     uint16_t tab_cur;
     lv_dir_t tab_pos;
-}lv_tabview_t;
+} lv_tabview_t;
 
 extern const lv_obj_class_t lv_tabview_class;
 
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/tileview/lv_tileview.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/tileview/lv_tileview.c
index 1bbe110ac..8f8f3c4d2 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/tileview/lv_tileview.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/tileview/lv_tileview.c
@@ -29,12 +29,14 @@ static void tileview_event_cb(lv_event_t * e);
  **********************/
 
 const lv_obj_class_t lv_tileview_class = {.constructor_cb = lv_tileview_constructor,
-                                    .base_class = &lv_obj_class,
-                                    .instance_size = sizeof(lv_tileview_t)};
+                                          .base_class = &lv_obj_class,
+                                          .instance_size = sizeof(lv_tileview_t)
+                                         };
 
 const lv_obj_class_t lv_tileview_tile_class = {.constructor_cb = lv_tileview_tile_constructor,
-                                         .base_class = &lv_obj_class,
-                                         .instance_size = sizeof(lv_tileview_tile_t)};
+                                               .base_class = &lv_obj_class,
+                                               .instance_size = sizeof(lv_tileview_tile_t)
+                                              };
 
 static lv_dir_t create_dir;
 static uint32_t create_col_id;
@@ -50,7 +52,7 @@ static uint32_t create_row_id;
 
 lv_obj_t * lv_tileview_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_tileview_class, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -62,7 +64,7 @@ lv_obj_t * lv_tileview_create(lv_obj_t * parent)
 
 lv_obj_t * lv_tileview_add_tile(lv_obj_t * tv, uint8_t col_id, uint8_t row_id, lv_dir_t dir)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     create_dir = dir;
     create_col_id = col_id;
     create_row_id = row_id;
@@ -104,7 +106,7 @@ void lv_obj_set_tile_id(lv_obj_t * tv, uint32_t col_id, uint32_t row_id, lv_anim
         }
     }
 
-    LV_LOG_WARN("No tile found with at (%d,%d) index", col_id, row_id);
+    LV_LOG_WARN("No tile found with at (%d,%d) index", (int)col_id, (int)row_id);
 }
 
 lv_obj_t * lv_tileview_get_tile_act(lv_obj_t * obj)
@@ -135,7 +137,8 @@ static void lv_tileview_tile_constructor(const lv_obj_class_t * class_p, lv_obj_
     lv_obj_t * parent = lv_obj_get_parent(obj);
     lv_obj_set_size(obj, LV_PCT(100), LV_PCT(100));
     lv_obj_update_layout(obj);  /*Be sure the size is correct*/
-    lv_obj_set_pos(obj, create_col_id * lv_obj_get_content_width(parent),  create_row_id * lv_obj_get_content_height(parent));
+    lv_obj_set_pos(obj, create_col_id * lv_obj_get_content_width(parent),
+                   create_row_id * lv_obj_get_content_height(parent));
 
     lv_tileview_tile_t * tile = (lv_tileview_tile_t *)obj;
     tile->dir = create_dir;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/tileview/lv_tileview.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/tileview/lv_tileview.h
index 79f1acd46..172338196 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/tileview/lv_tileview.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/tileview/lv_tileview.h
@@ -27,12 +27,12 @@ extern "C" {
 typedef struct {
     lv_obj_t obj;
     lv_obj_t * tile_act;
-}lv_tileview_t;
+} lv_tileview_t;
 
 typedef struct {
     lv_obj_t obj;
     lv_dir_t dir;
-}lv_tileview_tile_t;
+} lv_tileview_tile_t;
 
 extern const lv_obj_class_t lv_tileview_class;
 extern const lv_obj_class_t lv_tileview_tile_class;
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/win/lv_win.c b/lib/libesp32_lvgl/lvgl/src/extra/widgets/win/lv_win.c
index eb9eb8eb6..92c3b8baa 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/win/lv_win.c
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/win/lv_win.c
@@ -27,11 +27,11 @@ static void lv_win_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_win_class = {
-        .constructor_cb = lv_win_constructor,
-        .width_def = LV_PCT(100),
-        .height_def = LV_PCT(100),
-        .base_class = &lv_obj_class,
-        .instance_size = sizeof(lv_win_t)
+    .constructor_cb = lv_win_constructor,
+    .width_def = LV_PCT(100),
+    .height_def = LV_PCT(100),
+    .base_class = &lv_obj_class,
+    .instance_size = sizeof(lv_win_t)
 };
 static lv_coord_t create_header_height;
 /**********************
@@ -44,7 +44,7 @@ static lv_coord_t create_header_height;
 
 lv_obj_t * lv_win_create(lv_obj_t * parent, lv_coord_t header_height)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     create_header_height = header_height;
 
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_win_class, parent);
diff --git a/lib/libesp32_lvgl/lvgl/src/extra/widgets/win/lv_win.h b/lib/libesp32_lvgl/lvgl/src/extra/widgets/win/lv_win.h
index 524596339..4342b3104 100644
--- a/lib/libesp32_lvgl/lvgl/src/extra/widgets/win/lv_win.h
+++ b/lib/libesp32_lvgl/lvgl/src/extra/widgets/win/lv_win.h
@@ -24,7 +24,7 @@ extern "C" {
  **********************/
 typedef struct {
     lv_obj_t obj;
-}lv_win_t;
+} lv_win_t;
 
 extern const lv_obj_class_t lv_win_class;
 
diff --git a/lib/libesp32_lvgl/lvgl/src/font/lv_font.c b/lib/libesp32_lvgl/lvgl/src/font/lv_font.c
index 5af902c57..cf3d374f4 100644
--- a/lib/libesp32_lvgl/lvgl/src/font/lv_font.c
+++ b/lib/libesp32_lvgl/lvgl/src/font/lv_font.c
@@ -10,6 +10,7 @@
 #include "lv_font.h"
 #include "../misc/lv_utils.h"
 #include "../misc/lv_log.h"
+#include "../misc/lv_assert.h"
 
 /*********************
  *      DEFINES
@@ -47,6 +48,7 @@
  */
 const uint8_t * lv_font_get_glyph_bitmap(const lv_font_t * font_p, uint32_t letter)
 {
+    LV_ASSERT_NULL(font_p);
     return font_p->get_glyph_bitmap(font_p, letter);
 }
 
@@ -61,6 +63,7 @@ const uint8_t * lv_font_get_glyph_bitmap(const lv_font_t * font_p, uint32_t lett
 bool lv_font_get_glyph_dsc(const lv_font_t * font_p, lv_font_glyph_dsc_t * dsc_out, uint32_t letter,
                            uint32_t letter_next)
 {
+    LV_ASSERT_NULL(font_p);
     return font_p->get_glyph_dsc(font_p, dsc_out, letter, letter_next);
 }
 
@@ -73,6 +76,7 @@ bool lv_font_get_glyph_dsc(const lv_font_t * font_p, lv_font_glyph_dsc_t * dsc_o
  */
 uint16_t lv_font_get_glyph_width(const lv_font_t * font, uint32_t letter, uint32_t letter_next)
 {
+    LV_ASSERT_NULL(font);
     lv_font_glyph_dsc_t g;
     bool ret;
     ret = lv_font_get_glyph_dsc(font, &g, letter, letter_next);
diff --git a/lib/libesp32_lvgl/lvgl/src/font/lv_font_fmt_txt.c b/lib/libesp32_lvgl/lvgl/src/font/lv_font_fmt_txt.c
index d83235b22..991b23e6d 100644
--- a/lib/libesp32_lvgl/lvgl/src/font/lv_font_fmt_txt.c
+++ b/lib/libesp32_lvgl/lvgl/src/font/lv_font_fmt_txt.c
@@ -128,7 +128,7 @@ const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t unic
                    (uint8_t)fdsc->bpp, prefilter);
         return LV_GC_ROOT(_lv_font_decompr_buf);
 #else /*!LV_USE_FONT_COMPRESSED*/
-//        LV_LOG_WARN("Compressed fonts is used but LV_USE_FONT_COMPRESSED is not enabled in lv_conf.h")
+        LV_LOG_WARN("Compressed fonts is used but LV_USE_FONT_COMPRESSED is not enabled in lv_conf.h");
         return NULL;
 #endif
     }
diff --git a/lib/libesp32_lvgl/lvgl/src/font/lv_font_loader.c b/lib/libesp32_lvgl/lvgl/src/font/lv_font_loader.c
index 54e53c607..f7c061bbe 100644
--- a/lib/libesp32_lvgl/lvgl/src/font/lv_font_loader.c
+++ b/lib/libesp32_lvgl/lvgl/src/font/lv_font_loader.c
@@ -457,6 +457,10 @@ static int32_t load_glyph(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc,
             if(res != LV_FS_RES_OK) {
                 return -1;
             }
+
+            /*The last fragment should be on the MSB but read_bits() will place it to the LSB*/
+            glyph_bmp[cur_bmp_size + bmp_size - 1] = glyph_bmp[cur_bmp_size + bmp_size - 1] << (nbits % 8);
+
         }
 
         cur_bmp_size += bmp_size;
diff --git a/lib/libesp32_lvgl/lvgl/src/font/lv_font_montserrat_10.c b/lib/libesp32_lvgl/lvgl/src/font/lv_font_montserrat_10.c
index b6a806d5a..54f9f98e7 100644
--- a/lib/libesp32_lvgl/lvgl/src/font/lv_font_montserrat_10.c
+++ b/lib/libesp32_lvgl/lvgl/src/font/lv_font_montserrat_10.c
@@ -5,13 +5,13 @@
  ******************************************************************************/
 
 #ifdef LV_LVGL_H_INCLUDE_SIMPLE
-#include "lvgl.h"
+    #include "lvgl.h"
 #else
-#include "../../lvgl.h"
+    #include "../../lvgl.h"
 #endif
 
 #ifndef LV_FONT_MONTSERRAT_10
-#define LV_FONT_MONTSERRAT_10 1
+    #define LV_FONT_MONTSERRAT_10 1
 #endif
 
 #if LV_FONT_MONTSERRAT_10
@@ -1155,8 +1155,7 @@ static const uint16_t unicode_list_1[] = {
 };
 
 /*Collect the unicode lists and glyph_id offsets*/
-static const lv_font_fmt_txt_cmap_t cmaps[] =
-{
+static const lv_font_fmt_txt_cmap_t cmaps[] = {
     {
         .range_start = 32, .range_length = 95, .glyph_id_start = 1,
         .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY
@@ -1173,8 +1172,7 @@ static const lv_font_fmt_txt_cmap_t cmaps[] =
 
 
 /*Map glyph_ids to kern left classes*/
-static const uint8_t kern_left_class_mapping[] =
-{
+static const uint8_t kern_left_class_mapping[] = {
     0, 0, 1, 2, 0, 3, 4, 5,
     2, 6, 7, 8, 9, 10, 9, 10,
     11, 12, 0, 13, 14, 15, 16, 17,
@@ -1198,8 +1196,7 @@ static const uint8_t kern_left_class_mapping[] =
 };
 
 /*Map glyph_ids to kern right classes*/
-static const uint8_t kern_right_class_mapping[] =
-{
+static const uint8_t kern_right_class_mapping[] = {
     0, 0, 1, 2, 0, 3, 4, 5,
     2, 6, 7, 8, 9, 10, 9, 10,
     11, 12, 13, 14, 15, 16, 17, 12,
@@ -1223,8 +1220,7 @@ static const uint8_t kern_right_class_mapping[] =
 };
 
 /*Kern values between classes*/
-static const int8_t kern_class_values[] =
-{
+static const int8_t kern_class_values[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 2, 0, 0, 0,
     0, 1, 0, 0, 0, 0, 0, 0,
@@ -1603,8 +1599,7 @@ static const int8_t kern_class_values[] =
 
 
 /*Collect the kern class' data in one place*/
-static const lv_font_fmt_txt_kern_classes_t kern_classes =
-{
+static const lv_font_fmt_txt_kern_classes_t kern_classes = {
     .class_pair_values   = kern_class_values,
     .left_class_mapping  = kern_left_class_mapping,
     .right_class_mapping = kern_right_class_mapping,
diff --git a/lib/libesp32_lvgl/lvgl/src/font/lv_font_montserrat_8.c b/lib/libesp32_lvgl/lvgl/src/font/lv_font_montserrat_8.c
index 8cd303f69..9d8b154b6 100644
--- a/lib/libesp32_lvgl/lvgl/src/font/lv_font_montserrat_8.c
+++ b/lib/libesp32_lvgl/lvgl/src/font/lv_font_montserrat_8.c
@@ -5,13 +5,13 @@
  ******************************************************************************/
 
 #ifdef LV_LVGL_H_INCLUDE_SIMPLE
-#include "lvgl.h"
+    #include "lvgl.h"
 #else
-#include "../../lvgl.h"
+    #include "../../lvgl.h"
 #endif
 
 #ifndef LV_FONT_MONTSERRAT_8
-#define LV_FONT_MONTSERRAT_8 1
+    #define LV_FONT_MONTSERRAT_8 1
 #endif
 
 #if LV_FONT_MONTSERRAT_8
@@ -941,8 +941,7 @@ static const uint16_t unicode_list_1[] = {
 };
 
 /*Collect the unicode lists and glyph_id offsets*/
-static const lv_font_fmt_txt_cmap_t cmaps[] =
-{
+static const lv_font_fmt_txt_cmap_t cmaps[] = {
     {
         .range_start = 32, .range_length = 95, .glyph_id_start = 1,
         .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY
@@ -959,8 +958,7 @@ static const lv_font_fmt_txt_cmap_t cmaps[] =
 
 
 /*Map glyph_ids to kern left classes*/
-static const uint8_t kern_left_class_mapping[] =
-{
+static const uint8_t kern_left_class_mapping[] = {
     0, 0, 1, 2, 0, 3, 4, 5,
     2, 6, 7, 8, 9, 10, 9, 10,
     11, 12, 0, 13, 14, 15, 16, 17,
@@ -984,8 +982,7 @@ static const uint8_t kern_left_class_mapping[] =
 };
 
 /*Map glyph_ids to kern right classes*/
-static const uint8_t kern_right_class_mapping[] =
-{
+static const uint8_t kern_right_class_mapping[] = {
     0, 0, 1, 2, 0, 3, 4, 5,
     2, 6, 7, 8, 9, 10, 9, 10,
     11, 12, 13, 14, 15, 16, 17, 12,
@@ -1009,8 +1006,7 @@ static const uint8_t kern_right_class_mapping[] =
 };
 
 /*Kern values between classes*/
-static const int8_t kern_class_values[] =
-{
+static const int8_t kern_class_values[] = {
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 1, 0, 0, 0,
     0, 1, 0, 0, 0, 0, 0, 0,
@@ -1389,8 +1385,7 @@ static const int8_t kern_class_values[] =
 
 
 /*Collect the kern class' data in one place*/
-static const lv_font_fmt_txt_kern_classes_t kern_classes =
-{
+static const lv_font_fmt_txt_kern_classes_t kern_classes = {
     .class_pair_values   = kern_class_values,
     .left_class_mapping  = kern_left_class_mapping,
     .right_class_mapping = kern_right_class_mapping,
diff --git a/lib/libesp32_lvgl/lvgl/src/font/lv_font_unscii_16.c b/lib/libesp32_lvgl/lvgl/src/font/lv_font_unscii_16.c
index 451cd1ea3..104bc2bce 100644
--- a/lib/libesp32_lvgl/lvgl/src/font/lv_font_unscii_16.c
+++ b/lib/libesp32_lvgl/lvgl/src/font/lv_font_unscii_16.c
@@ -5,13 +5,13 @@
  ******************************************************************************/
 
 #ifdef LV_LVGL_H_INCLUDE_SIMPLE
-#include "lvgl.h"
+    #include "lvgl.h"
 #else
-#include "../../lvgl.h"
+    #include "../../lvgl.h"
 #endif
 
 #ifndef LV_FONT_UNSCII_16
-#define LV_FONT_UNSCII_16 1
+    #define LV_FONT_UNSCII_16 1
 #endif
 
 #if LV_FONT_UNSCII_16
@@ -587,8 +587,7 @@ static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = {
 
 
 /*Collect the unicode lists and glyph_id offsets*/
-static const lv_font_fmt_txt_cmap_t cmaps[] =
-{
+static const lv_font_fmt_txt_cmap_t cmaps[] = {
     {
         .range_start = 32, .range_length = 96, .glyph_id_start = 1,
         .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY
diff --git a/lib/libesp32_lvgl/lvgl/src/font/lv_font_unscii_8.c b/lib/libesp32_lvgl/lvgl/src/font/lv_font_unscii_8.c
index 49ea8394a..e67c5166d 100644
--- a/lib/libesp32_lvgl/lvgl/src/font/lv_font_unscii_8.c
+++ b/lib/libesp32_lvgl/lvgl/src/font/lv_font_unscii_8.c
@@ -5,13 +5,13 @@
  ******************************************************************************/
 
 #ifdef LV_LVGL_H_INCLUDE_SIMPLE
-#include "lvgl.h"
+    #include "lvgl.h"
 #else
-#include "../../lvgl.h"
+    #include "../../lvgl.h"
 #endif
 
 #ifndef LV_FONT_UNSCII_8
-#define LV_FONT_UNSCII_8 1
+    #define LV_FONT_UNSCII_8 1
 #endif
 
 #if LV_FONT_UNSCII_8
@@ -423,8 +423,7 @@ static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = {
 
 
 /*Collect the unicode lists and glyph_id offsets*/
-static const lv_font_fmt_txt_cmap_t cmaps[] =
-{
+static const lv_font_fmt_txt_cmap_t cmaps[] = {
     {
         .range_start = 32, .range_length = 96, .glyph_id_start = 1,
         .unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY
diff --git a/lib/libesp32_lvgl/lvgl/src/font/lv_symbol_def.h b/lib/libesp32_lvgl/lvgl/src/font/lv_symbol_def.h
index 0e619e74b..75fd80b58 100644
--- a/lib/libesp32_lvgl/lvgl/src/font/lv_symbol_def.h
+++ b/lib/libesp32_lvgl/lvgl/src/font/lv_symbol_def.h
@@ -1,6 +1,5 @@
 #ifndef LV_SYMBOL_DEF_H
 #define LV_SYMBOL_DEF_H
-/*clang-format off*/
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu.mk b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu.mk
index d909b0335..e162d79f6 100644
--- a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu.mk
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu.mk
@@ -2,8 +2,11 @@ CSRCS += lv_gpu_nxp_pxp.c
 CSRCS += lv_gpu_nxp_pxp_osa.c
 CSRCS += lv_gpu_nxp_vglite.c
 CSRCS += lv_gpu_stm32_dma2d.c
+CSRCS += lv_gpu_sdl.c
 
 DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu
 VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu
 
 CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu"
+
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl/lv_gpu_sdl.mk
\ No newline at end of file
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_nxp_vglite.c b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_nxp_vglite.c
index 6021300e7..8e6ee193d 100644
--- a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_nxp_vglite.c
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_nxp_vglite.c
@@ -79,9 +79,9 @@
     defined(CPU_MIMXRT595SFFOC) || defined(CPU_MIMXRT595SFFOC_cm33)) && \
     ((LV_HOR_RES_MAX > RT595_BLIT_WRKRND_THR) || (LV_VER_RES_MAX > RT595_BLIT_WRKRND_THR)) && \
     RT595_BLIT_WRKRND_ENABLED
-    #define _BLIT_SPLIT_ENABLED 1
+#define _BLIT_SPLIT_ENABLED 1
 #else
-    #define _BLIT_SPLIT_ENABLED 0
+#define _BLIT_SPLIT_ENABLED 0
 #endif
 
 /* BLIT split threshold - BLITs with width or height higher than this value will be done
@@ -153,7 +153,8 @@ lv_res_t lv_gpu_nxp_vglite_fill(lv_color_t * dest_buf, lv_coord_t dest_width, lv
     lv_color32_t col32 = {.full = lv_color_to32(color)}; /*Convert color to RGBA8888*/
     lv_disp_t * disp = _lv_refr_get_disp_refreshing();
 
-    if(_init_vg_buf(&rt, (uint32_t) dest_width, (uint32_t) dest_height, (uint32_t) dest_width * sizeof(lv_color_t), (const lv_color_t *) dest_buf, false) != LV_RES_OK) {
+    if(_init_vg_buf(&rt, (uint32_t) dest_width, (uint32_t) dest_height, (uint32_t) dest_width * sizeof(lv_color_t),
+                    (const lv_color_t *) dest_buf, false) != LV_RES_OK) {
 #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
         LV_LOG_ERROR("init_vg_buf reported error. Fill failed.");
 #endif
@@ -171,17 +172,17 @@ lv_res_t lv_gpu_nxp_vglite_fill(lv_color_t * dest_buf, lv_coord_t dest_width, lv
         }
 
         err = vg_lite_clear(&rt, &rect, col32.full);
-        if (err != VG_LITE_SUCCESS) {
-    #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
+        if(err != VG_LITE_SUCCESS) {
+#if LV_GPU_NXP_VG_LITE_LOG_ERRORS
             LV_LOG_ERROR("vg_lite_clear reported error. Fill failed.");
-    #endif
+#endif
             return LV_RES_INV;
         }
         err = vg_lite_finish();
-        if (err != VG_LITE_SUCCESS) {
-    #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
+        if(err != VG_LITE_SUCCESS) {
+#if LV_GPU_NXP_VG_LITE_LOG_ERRORS
             LV_LOG_ERROR("vg_lite_finish reported error. Fill failed.");
-    #endif
+#endif
             return LV_RES_INV;
         }
     }
@@ -199,7 +200,8 @@ lv_res_t lv_gpu_nxp_vglite_fill(lv_color_t * dest_buf, lv_coord_t dest_width, lv
         };
 
         err = vg_lite_init_path(&path, VG_LITE_S16, VG_LITE_LOW, sizeof(path_data), path_data,
-                (vg_lite_float_t) fill_area->x1, (vg_lite_float_t) fill_area->y1, ((vg_lite_float_t) fill_area->x2) + 1.0f, ((vg_lite_float_t) fill_area->y2) + 1.0f);
+                                (vg_lite_float_t) fill_area->x1, (vg_lite_float_t) fill_area->y1, ((vg_lite_float_t) fill_area->x2) + 1.0f,
+                                ((vg_lite_float_t) fill_area->y2) + 1.0f);
         if(err != VG_LITE_SUCCESS)  {
 #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
             LV_LOG_ERROR("vg_lite_init_path() failed.");
@@ -449,8 +451,8 @@ static lv_res_t _lv_gpu_nxp_vglite_blit_single(lv_gpu_nxp_vglite_blit_info_t * b
     lv_disp_t * disp = _lv_refr_get_disp_refreshing();
 
     if(blit == NULL) {
-            /*Wrong parameter*/
-            return LV_RES_INV;
+        /*Wrong parameter*/
+        return LV_RES_INV;
     }
 
     if(blit->opa < (lv_opa_t) LV_OPA_MIN) {
@@ -458,14 +460,16 @@ static lv_res_t _lv_gpu_nxp_vglite_blit_single(lv_gpu_nxp_vglite_blit_info_t * b
     }
 
     /*Wrap src/dst buffer into VG-Lite buffer*/
-    if(_init_vg_buf(&src_vgbuf, (uint32_t) blit->src_width, (uint32_t) blit->src_height, (uint32_t) blit->src_stride, blit->src, true) != LV_RES_OK) {
+    if(_init_vg_buf(&src_vgbuf, (uint32_t) blit->src_width, (uint32_t) blit->src_height, (uint32_t) blit->src_stride,
+                    blit->src, true) != LV_RES_OK) {
 #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
         LV_LOG_ERROR("init_vg_buf reported error. BLIT failed.");
 #endif
         return LV_RES_INV;
     }
 
-    if(_init_vg_buf(&dst_vgbuf, (uint32_t) blit->dst_width, (uint32_t) blit->dst_height, (uint32_t) blit->dst_stride, blit->dst, false) != LV_RES_OK) {
+    if(_init_vg_buf(&dst_vgbuf, (uint32_t) blit->dst_width, (uint32_t) blit->dst_height, (uint32_t) blit->dst_stride,
+                    blit->dst, false) != LV_RES_OK) {
 #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
         LV_LOG_ERROR("init_vg_buf reported error. BLIT failed.");
 #endif
@@ -543,9 +547,11 @@ static lv_res_t _init_vg_buf(vg_lite_buffer_t * dst, uint32_t width, uint32_t he
         return LV_RES_INV;
     }
 
-    if(source && (stride % (LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX * sizeof(lv_color_t))) != 0x0U) {  /*Test for stride alignment*/
+    if(source &&
+       (stride % (LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX * sizeof(lv_color_t))) != 0x0U) {  /*Test for stride alignment*/
 #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
-        LV_LOG_ERROR("Buffer stride (%d px) not aligned to %d bytes.", stride, LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX * sizeof(lv_color_t));
+        LV_LOG_ERROR("Buffer stride (%d px) not aligned to %d bytes.", stride,
+                     LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX * sizeof(lv_color_t));
 #endif
         return LV_RES_INV;
     }
@@ -559,8 +565,8 @@ static lv_res_t _init_vg_buf(vg_lite_buffer_t * dst, uint32_t width, uint32_t he
     dst->height = (int32_t) height;
     dst->stride = (int32_t) stride;
 
-    void *r_ptr = memset(&dst->yuv, 0, sizeof(dst->yuv));
-    if (r_ptr == NULL) {
+    void * r_ptr = memset(&dst->yuv, 0, sizeof(dst->yuv));
+    if(r_ptr == NULL) {
         return LV_RES_INV;
     }
 
@@ -642,16 +648,20 @@ static lv_res_t _lv_gpu_nxp_vglite_check_blit(lv_gpu_nxp_vglite_blit_info_t * bl
     }
     /* No alignment requirement for destination pixel buffer when using mode VG_LITE_LINEAR */
 
-    if((blit->src_stride % (LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX * LV_COLOR_DEPTH / 8)) != 0x0) {  /* Test for stride alignment */
+    if((blit->src_stride % (LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX * LV_COLOR_DEPTH / 8)) !=
+       0x0) {  /* Test for stride alignment */
 #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
-        LV_LOG_ERROR("source buffer stride (%d px) not aligned to %d px.", blit->src_stride, LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX);
+        LV_LOG_ERROR("source buffer stride (%d px) not aligned to %d px.", blit->src_stride,
+                     LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX);
 #endif
         return LV_RES_INV;
     }
 
-    if((blit->dst_stride % (LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX * LV_COLOR_DEPTH / 8)) != 0x0) {  /* Test for stride alignment */
+    if((blit->dst_stride % (LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX * LV_COLOR_DEPTH / 8)) !=
+       0x0) {  /* Test for stride alignment */
 #if LV_GPU_NXP_VG_LITE_LOG_ERRORS
-        LV_LOG_ERROR("destination buffer stride (%d px) not aligned to %d px.", blit->dst_stride, LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX);
+        LV_LOG_ERROR("destination buffer stride (%d px) not aligned to %d px.", blit->dst_stride,
+                     LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX);
 #endif
         return LV_RES_INV;
     }
@@ -675,7 +685,7 @@ static lv_res_t _lv_gpu_nxp_vglite_check_blit(lv_gpu_nxp_vglite_blit_info_t * bl
 static void _align_x(lv_area_t * area, lv_color_t ** buf)
 {
 
-    int alignedAreaStartPx = area->x1 - (area->x1 % (LV_ATTRIBUTE_MEM_ALIGN_SIZE * 8 / LV_COLOR_DEPTH) );
+    int alignedAreaStartPx = area->x1 - (area->x1 % (LV_ATTRIBUTE_MEM_ALIGN_SIZE * 8 / LV_COLOR_DEPTH));
     CHECK(alignedAreaStartPx < 0, "Should never happen.");
 
     area->x1 -= alignedAreaStartPx;
@@ -696,9 +706,11 @@ static void _align_y(lv_area_t * area, lv_color_t ** buf, uint32_t stridePx)
     /* find how many lines of pixels will respect memory alignment requirement */
     if(stridePx % LV_ATTRIBUTE_MEM_ALIGN_SIZE == 0) {
         alignedAreaStartPy = area->y1;
-    } else {
+    }
+    else {
         LineToAlignMem = LV_ATTRIBUTE_MEM_ALIGN_SIZE / (sizeof(lv_color_t) * LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX);
-        CHECK(LV_ATTRIBUTE_MEM_ALIGN_SIZE % (sizeof(lv_color_t) * LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX) != 0, "Complex case: need gcd function.");
+        CHECK(LV_ATTRIBUTE_MEM_ALIGN_SIZE % (sizeof(lv_color_t) * LV_GPU_NXP_VG_LITE_STRIDE_ALIGN_PX) != 0,
+              "Complex case: need gcd function.");
         alignedAreaStartPy = area->y1 - (area->y1 % LineToAlignMem);
         CHECK(alignedAreaStartPy < 0, "Should never happen.");
     }
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_sdl.c b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_sdl.c
new file mode 100644
index 000000000..2b46d87c9
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_sdl.c
@@ -0,0 +1,59 @@
+/**
+ * @file lv_gpu_sdl.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+
+#include "../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "lv_gpu_sdl.h"
+#include "sdl/lv_gpu_sdl_utils.h"
+#include "sdl/lv_gpu_sdl_texture_cache.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_gpu_sdl_init()
+{
+    _lv_gpu_sdl_utils_init();
+    _lv_gpu_sdl_texture_cache_init();
+}
+
+void lv_gpu_sdl_deinit()
+{
+    _lv_gpu_sdl_texture_cache_deinit();
+    _lv_gpu_sdl_utils_deinit();
+}
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_sdl.h b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_sdl.h
new file mode 100644
index 000000000..d5c22b3fc
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_sdl.h
@@ -0,0 +1,73 @@
+/**
+ * @file lv_gpu_sdl.h
+ *
+ */
+
+#ifndef LV_GPU_SDL_H
+#define LV_GPU_SDL_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#if LV_USE_EXTERNAL_RENDERER == 0
+#error "SDL GPU requires LV_USE_EXTERNAL_RENDERER 1. Enable it in lv_conf.h"
+#endif
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_gpu_sdl_init();
+
+/**
+ * @brief Free caches
+ * 
+ */
+void lv_gpu_sdl_deinit();
+
+/*======================
+ * Add/remove functions
+ *=====================*/
+
+/*=====================
+ * Setter functions
+ *====================*/
+
+/*=====================
+ * Getter functions
+ *====================*/
+
+/*=====================
+ * Other functions
+ *====================*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_SDL_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_stm32_dma2d.c b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_stm32_dma2d.c
index e988589dc..9653e4121 100644
--- a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_stm32_dma2d.c
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_stm32_dma2d.c
@@ -76,6 +76,7 @@ void lv_gpu_stm32_dma2d_init(void)
 
     /*Delay after setting peripheral clock*/
     volatile uint32_t temp = RCC->AHB1ENR;
+    LV_UNUSED(temp);
 
     /*set output colour mode*/
     DMA2D->OPFCCR = LV_DMA2D_COLOR_FORMAT;
@@ -112,7 +113,7 @@ void lv_gpu_stm32_dma2d_fill(lv_color_t * buf, lv_coord_t buf_w, lv_color_t colo
  * @param buf a buffer which should be filled using a mask
  * @param buf_w width of the buffer in pixels
  * @param color fill color
- * @param mask 0..255 values describing the opacity of the corresponding pixel. It's width is `fill_w`
+ * @param mask 0..255 values describing the opacity of the corresponding pixel. Its width is `fill_w`
  * @param opa overall opacity. 255 in `mask` should mean this opacity.
  * @param fill_w width to fill in pixels (<= buf_w)
  * @param fill_h height to fill in pixels
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_stm32_dma2d.h b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_stm32_dma2d.h
index 82e66646d..014093cec 100644
--- a/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_stm32_dma2d.h
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/lv_gpu_stm32_dma2d.h
@@ -57,7 +57,7 @@ void lv_gpu_stm32_dma2d_fill(lv_color_t * buf, lv_coord_t buf_w, lv_color_t colo
  * @param buf a buffer which should be filled using a mask
  * @param buf_w width of the buffer in pixels
  * @param color fill color
- * @param mask 0..255 values describing the opacity of the corresponding pixel. It's width is `fill_w`
+ * @param mask 0..255 values describing the opacity of the corresponding pixel. Its width is `fill_w`
  * @param opa overall opacity. 255 in `mask` should mean this opacity.
  * @param fill_w width to fill in pixels (<= buf_w)
  * @param fill_h height to fill in pixels
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/README.md b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/README.md
new file mode 100644
index 000000000..289fc04e4
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/README.md
@@ -0,0 +1,28 @@
+# SDL_Renderer Based Drawing Functions
+
+In LVGL, drawing was performed by CPU. To improve drawing performance on platforms with GPU,
+we should perform drawing operations on GPU if possible.
+
+This implementation has moved most bitmap blending and drawing procedures to utilize SDL_Renderer,
+which takes advantages of hardware acceleration APIs like DirectX or OpenGL.
+
+This implementation can be also considered as a reference implementation, for contributors wants to
+develop accelerated drawing functions with other APIs such as OpenGL/OpenGL ES.
+
+## Caveats
+`lv_draw_arc`, `lv_draw_line` is not enabled, due to incomplete implementation. So lines and arcs will
+have significant impact to drawing performances.
+
+Performance of this implementation still has room to improve. Or we should use more powerful APIs
+such as OpenGL.
+
+## Notices for files
+
+### `lv_gpu_sdl_stack_blur.c`
+
+Contains modified code from [android-stackblur](https://github.com/kikoso/android-stackblur) project.
+Apache License 2.0
+
+### `lv_gpu_sdl_lru.c`/`lv_gpu_sdl_lru.h`
+
+Contains modified code from [C-LRU-Cache](https://github.com/willcannings/C-LRU-Cache) project. No license defined.
\ No newline at end of file
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl.mk b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl.mk
new file mode 100644
index 000000000..f258c8ba6
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl.mk
@@ -0,0 +1,16 @@
+CSRCS += lv_gpu_sdl_draw_arc.c
+CSRCS += lv_gpu_sdl_draw_blend.c
+CSRCS += lv_gpu_sdl_draw_img.c
+CSRCS += lv_gpu_sdl_draw_label.c
+CSRCS += lv_gpu_sdl_draw_line.c
+CSRCS += lv_gpu_sdl_draw_rect.c
+CSRCS += lv_gpu_sdl_lru.c
+CSRCS += lv_gpu_sdl_mask.c
+CSRCS += lv_gpu_sdl_stack_blur.c
+CSRCS += lv_gpu_sdl_texture_cache.c
+CSRCS += lv_gpu_sdl_utils.c
+
+DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
+VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl
+
+CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/gpu/sdl"
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_arc.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_arc.c
new file mode 100644
index 000000000..21bf9d8fa
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_arc.c
@@ -0,0 +1,163 @@
+/**
+ * @file lv_gpu_sdl_draw_arc.c
+ *
+ * This implementation does not functioning properly so it's not enabled
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "../../hal/lv_hal_disp.h"
+#include "../../core/lv_refr.h"
+#include "../../draw/lv_draw_arc.h"
+#include "lv_gpu_sdl_utils.h"
+#include "lv_gpu_sdl_lru.h"
+#include "lv_gpu_sdl_texture_cache.h"
+#include "lv_gpu_sdl_mask.h"
+
+#ifndef M_PI
+    #include <math.h>
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_gpu_cache_key_magic_t magic;
+    uint16_t radius;
+    uint16_t angle;
+    lv_coord_t width;
+    uint8_t rounded;
+} lv_draw_arc_key_t;
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_arc2(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius, uint16_t start_angle, uint16_t end_angle,
+                  const lv_area_t * clip_area, const lv_draw_arc_dsc_t * dsc)
+{
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_disp_drv_t * driver = disp->driver;
+    SDL_Renderer * renderer = (SDL_Renderer *) driver->user_data;
+
+    lv_area_t area_out;
+    area_out.x1 = center_x - radius;
+    area_out.y1 = center_y - radius;
+    area_out.x2 = center_x + radius - 1;  /*-1 because the center already belongs to the left/bottom part*/
+    area_out.y2 = center_y + radius - 1;
+
+    lv_area_t area_in;
+    lv_area_copy(&area_in, &area_out);
+    area_in.x1 += dsc->width;
+    area_in.y1 += dsc->width;
+    area_in.x2 -= dsc->width;
+    area_in.y2 -= dsc->width;
+
+    /*Increase 1 px each side to texture, to have better rotation result*/
+    lv_area_t texture_area_out;
+    lv_area_copy(&texture_area_out, &area_out);
+    lv_area_increase(&texture_area_out, 1, 1);
+
+    SDL_Rect area_out_rect, clip_rect;
+    lv_area_to_sdl_rect(&texture_area_out, &area_out_rect);
+    lv_area_to_sdl_rect(clip_area, &clip_rect);
+
+    lv_draw_arc_key_t key = {
+        .magic = LV_GPU_CACHE_KEY_MAGIC_ARC,
+        .radius = radius,
+        .angle = ((end_angle - start_angle) % 360 + 360) % 360,
+        .width = dsc->width,
+        .rounded = dsc->rounded,
+    };
+    //    SDL_Texture *texture = lv_gpu_draw_cache_get(&key, sizeof(key));
+    SDL_Texture * texture = NULL;
+    if(texture == NULL) {
+        /*Create inner the mask*/
+        lv_draw_mask_radius_param_t mask_in_param;
+        lv_draw_mask_radius_init(&mask_in_param, &area_in, LV_RADIUS_CIRCLE, true);
+        int16_t mask_in_id = lv_draw_mask_add(&mask_in_param, NULL);
+
+        lv_draw_mask_radius_param_t mask_out_param;
+        lv_draw_mask_radius_init(&mask_out_param, &area_out, LV_RADIUS_CIRCLE, false);
+        int16_t mask_out_id = lv_draw_mask_add(&mask_out_param, NULL);
+
+        SDL_Surface * ark_mask;
+        if(key.angle < 360) {
+            while(start_angle >= 360) start_angle -= 360;
+            while(end_angle >= 360) end_angle -= 360;
+            lv_draw_mask_angle_param_t mask_angle_param;
+            lv_draw_mask_angle_init(&mask_angle_param, center_x, center_y, 0, key.angle);
+            int16_t mask_angle_id = lv_draw_mask_add(&mask_angle_param, NULL);
+            ark_mask = lv_sdl_apply_mask_surface(&texture_area_out, NULL, 0);
+            lv_draw_mask_remove_id(mask_angle_id);
+        }
+        else {
+            ark_mask = lv_sdl_apply_mask_surface(&texture_area_out, NULL, 0);
+        }
+        lv_draw_mask_remove_id(mask_out_id);
+        lv_draw_mask_remove_id(mask_in_id);
+
+        if(dsc->rounded) {
+            SDL_Renderer * mask_renderer = SDL_CreateSoftwareRenderer(ark_mask);
+            lv_area_t cap_area = {.x1 = 0, .y1 = 0};
+            lv_area_set_width(&cap_area, dsc->width);
+            lv_area_set_height(&cap_area, dsc->width);
+
+            lv_draw_mask_radius_param_t mask_rout_param;
+            lv_draw_mask_radius_init(&mask_rout_param, &cap_area, LV_RADIUS_CIRCLE, false);
+            int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
+            SDL_Texture * round_texture = lv_sdl_gen_mask_texture(mask_renderer, &cap_area, &mask_rout_id, 1);
+            lv_draw_mask_remove_id(mask_rout_id);
+
+            SDL_SetTextureBlendMode(round_texture, SDL_BLENDMODE_BLEND);
+            float mid_point = radius - key.width / 2.0f;
+            SDL_Rect cap_dst;
+            cap_dst.w = lv_area_get_width(&cap_area);
+            cap_dst.h = lv_area_get_height(&cap_area);
+            cap_dst.x = mid_point + lv_sdl_round(SDL_cos(0) * mid_point);
+            cap_dst.y = mid_point + lv_sdl_round(SDL_sin(0) * mid_point);
+            SDL_RenderCopy(mask_renderer, round_texture, NULL, &cap_dst);
+            cap_dst.x = mid_point + lv_sdl_round(SDL_cos(key.angle * M_PI / 180.0f) * mid_point);
+            cap_dst.y = mid_point + lv_sdl_round(SDL_sin(key.angle * M_PI / 180.0f) * mid_point);
+            SDL_RenderCopy(mask_renderer, round_texture, NULL, &cap_dst);
+            SDL_DestroyTexture(round_texture);
+            SDL_DestroyRenderer(mask_renderer);
+        }
+        texture = SDL_CreateTextureFromSurface(renderer, ark_mask);
+        SDL_FreeSurface(ark_mask);
+
+        SDL_assert(texture);
+        //        lv_gpu_draw_cache_put(&key, sizeof(key), texture);
+    }
+
+    SDL_Color arc_color;
+    lv_color_to_sdl_color(&dsc->color, &arc_color);
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureAlphaMod(texture, dsc->opa);
+    SDL_SetTextureColorMod(texture, arc_color.r, arc_color.g, arc_color.b);
+    SDL_RenderSetClipRect(renderer, &clip_rect);
+    SDL_RenderCopyEx(renderer, texture, NULL, &area_out_rect, start_angle, NULL, SDL_FLIP_NONE);
+    SDL_DestroyTexture(texture);
+}
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_blend.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_blend.c
new file mode 100644
index 000000000..f45ae118e
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_blend.c
@@ -0,0 +1,102 @@
+/**
+ * @file lv_gpu_sdl_draw_blend.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "../../draw/lv_draw_blend.h"
+#include "../../core/lv_refr.h"
+#include "lv_gpu_sdl_texture_cache.h"
+#include "lv_gpu_sdl_utils.h"
+#include "lv_gpu_sdl_mask.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void _lv_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area, lv_color_t color,
+                    lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa, lv_blend_mode_t mode)
+{
+    /*Do not draw transparent things*/
+    if(opa < LV_OPA_MIN) return;
+    if(mask_res == LV_DRAW_MASK_RES_TRANSP) return;
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+    /*Get clipped fill area which is the real draw area.
+     *It is always the same or inside `fill_area`*/
+    lv_area_t draw_area;
+    if(!_lv_area_intersect(&draw_area, clip_area, fill_area)) return;
+
+    SDL_Rect draw_area_rect;
+    lv_area_to_sdl_rect(&draw_area, &draw_area_rect);
+    if(mask) {
+        SDL_Surface * mask_surface = lv_sdl_create_mask_surface(mask, lv_area_get_width(&draw_area),
+                                                                lv_area_get_height(&draw_area),
+                                                                lv_area_get_width(&draw_area));
+        SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, mask_surface);
+        SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+        SDL_SetTextureAlphaMod(texture, opa);
+        SDL_SetTextureColorMod(texture, color.ch.red, color.ch.green, color.ch.blue);
+        SDL_RenderSetClipRect(renderer, &draw_area_rect);
+        SDL_RenderCopy(renderer, texture, NULL, &draw_area_rect);
+        SDL_DestroyTexture(texture);
+        SDL_FreeSurface(mask_surface);
+    }
+    else {
+        SDL_SetRenderDrawColor(renderer, color.ch.red, color.ch.green, color.ch.blue, opa);
+        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+        SDL_RenderSetClipRect(renderer, &draw_area_rect);
+        SDL_RenderFillRect(renderer, &draw_area_rect);
+    }
+}
+
+void _lv_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
+                   const lv_color_t * map_buf, lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa,
+                   lv_blend_mode_t mode)
+{
+    LV_UNUSED(clip_area);
+    LV_UNUSED(map_area);
+    LV_UNUSED(map_buf);
+    LV_UNUSED(mask);
+    LV_UNUSED(mask_res);
+    LV_UNUSED(opa);
+    LV_UNUSED(mode);
+
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_img.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_img.c
new file mode 100644
index 000000000..d777b42d1
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_img.c
@@ -0,0 +1,171 @@
+/**
+ * @file lv_gpu_sdl_draw_img.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "../../core/lv_refr.h"
+#include "lv_gpu_sdl_utils.h"
+#include "lv_gpu_sdl_lru.h"
+#include "lv_gpu_sdl_texture_cache.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static SDL_Texture * upload_img_texture(SDL_Renderer * renderer, lv_img_decoder_dsc_t * dsc);
+
+static SDL_Texture * upload_img_texture_fallback(SDL_Renderer * renderer, lv_img_decoder_dsc_t * dsc);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src,
+                 const lv_draw_img_dsc_t * draw_dsc)
+{
+    if(draw_dsc->opa <= LV_OPA_MIN) return;
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+    size_t key_size;
+    lv_gpu_sdl_cache_key_head_img_t * key = lv_gpu_sdl_img_cache_key_create(src, draw_dsc->frame_id, &key_size);
+    bool texture_found = false;
+    SDL_Texture * texture = lv_gpu_draw_cache_get(key, key_size, &texture_found);
+    if(!texture_found) {
+        _lv_img_cache_entry_t * cdsc = _lv_img_cache_open(src, draw_dsc->recolor, draw_dsc->frame_id);
+        lv_gpu_sdl_cache_flag_t tex_flags = 0;
+        if(cdsc) {
+            lv_img_decoder_dsc_t * dsc = &cdsc->dec_dsc;
+            if(dsc->user_data && SDL_memcmp(dsc->user_data, LV_GPU_SDL_DEC_DSC_TEXTURE_HEAD, 8) == 0) {
+                texture = ((lv_gpu_sdl_dec_dsc_userdata_t *) dsc->user_data)->texture;
+                tex_flags |= LV_GPU_SDL_CACHE_FLAG_MANAGED;
+            }
+            else {
+                texture = upload_img_texture(renderer, dsc);
+            }
+#if LV_IMG_CACHE_DEF_SIZE == 0
+            lv_img_decoder_close(dsc);
+#endif
+        }
+        if(texture && cdsc) {
+            lv_img_header_t * header = SDL_malloc(sizeof(lv_img_header_t));
+            SDL_memcpy(header, &cdsc->dec_dsc.header, sizeof(lv_img_header_t));
+            lv_gpu_draw_cache_put_advanced(key, key_size, texture, header, SDL_free, tex_flags);
+        }
+        else {
+            lv_gpu_draw_cache_put(key, key_size, NULL);
+        }
+    }
+    SDL_free(key);
+    if(!texture) {
+        return;
+    }
+
+    SDL_Rect mask_rect, coords_rect;
+    lv_area_to_sdl_rect(mask, &mask_rect);
+    lv_area_to_sdl_rect(coords, &coords_rect);
+    lv_area_zoom_to_sdl_rect(coords, &coords_rect, draw_dsc->zoom, &draw_dsc->pivot);
+
+    SDL_Point pivot = {.x = draw_dsc->pivot.x, .y = draw_dsc->pivot.y};
+    SDL_SetTextureAlphaMod(texture, draw_dsc->opa);
+    SDL_SetTextureColorMod(texture, 0xFF, 0xFF, 0xFF);
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+    SDL_RenderSetClipRect(renderer, &mask_rect);
+
+    SDL_Color recolor;
+    lv_color_to_sdl_color(&draw_dsc->recolor, &recolor);
+    /*Draw original image if not fully recolored*/
+    /*TODO: what if the image is translucent as well?*/
+    if(draw_dsc->recolor_opa < LV_OPA_MAX) {
+        SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
+    }
+
+    SDL_SetTextureColorMod(texture, recolor.r, recolor.g, recolor.b);
+    if(draw_dsc->recolor_opa >= LV_OPA_MAX) {
+        /*Draw fully colored image*/
+        SDL_SetTextureAlphaMod(texture, draw_dsc->opa);
+        SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
+    }
+    else if(draw_dsc->recolor_opa >= LV_OPA_MIN) {
+        SDL_SetTextureAlphaMod(texture, draw_dsc->recolor_opa);
+        SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, draw_dsc->angle, &pivot, SDL_FLIP_NONE);
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static SDL_Texture * upload_img_texture(SDL_Renderer * renderer, lv_img_decoder_dsc_t * dsc)
+{
+    if(!dsc->img_data) {
+        return upload_img_texture_fallback(renderer, dsc);
+    }
+    bool chroma_keyed = dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED;
+    uint32_t h = dsc->header.h;
+    uint32_t w = dsc->header.w;
+    void * data = (void *) dsc->img_data;
+    Uint32 rmask = 0x00FF0000;
+    Uint32 gmask = 0x0000FF00;
+    Uint32 bmask = 0x000000FF;
+    Uint32 amask = 0xFF000000;
+    if(chroma_keyed) {
+        amask = 0x00;
+    }
+    SDL_Surface * surface = SDL_CreateRGBSurfaceFrom(data, w, h, LV_COLOR_DEPTH, w * LV_COLOR_DEPTH / 8,
+                                                     rmask, gmask, bmask, amask);
+    SDL_SetColorKey(surface, chroma_keyed, lv_color_to32(LV_COLOR_CHROMA_KEY));
+    SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
+    SDL_FreeSurface(surface);
+    return texture;
+}
+
+static SDL_Texture * upload_img_texture_fallback(SDL_Renderer * renderer, lv_img_decoder_dsc_t * dsc)
+{
+    lv_coord_t h = dsc->header.h;
+    lv_coord_t w = dsc->header.w;
+    uint8_t * data = lv_mem_buf_get(w * h * sizeof(lv_color_t));
+    for(lv_coord_t y = 0; y < h; y++) {
+        lv_img_decoder_read_line(dsc, 0, y, w, &data[y * w * sizeof(lv_color_t)]);
+    }
+    Uint32 rmask = 0x00FF0000;
+    Uint32 gmask = 0x0000FF00;
+    Uint32 bmask = 0x000000FF;
+    Uint32 amask = 0xFF000000;
+    SDL_Surface * surface = SDL_CreateRGBSurfaceFrom(data, w, h, LV_COLOR_DEPTH, w * LV_COLOR_DEPTH / 8,
+                                                     rmask, gmask, bmask, amask);
+    SDL_SetColorKey(surface, SDL_TRUE, lv_color_to32(LV_COLOR_CHROMA_KEY));
+    SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, surface);
+    SDL_FreeSurface(surface);
+    lv_mem_buf_release(data);
+    return texture;
+}
+
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_label.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_label.c
new file mode 100644
index 000000000..e87773e53
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_label.c
@@ -0,0 +1,332 @@
+/**
+ * @file lv_gpu_sdl_draw_label.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "../../draw/lv_draw_label.h"
+#include "../../font/lv_font_fmt_txt.h"
+#include "../../core/lv_refr.h"
+#include "../../misc/lv_utils.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include "lv_gpu_sdl_utils.h"
+#include "lv_gpu_sdl_texture_cache.h"
+#include "lv_gpu_sdl_mask.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct lv_sdl_font_atlas_t {
+    SDL_Rect * pos;
+} lv_sdl_font_atlas_t;
+
+typedef struct {
+    lv_gpu_cache_key_magic_t magic;
+    const lv_font_t * font_p;
+    uint32_t cmap_index;
+} lv_font_key_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void draw_letter_masked(SDL_Renderer * renderer, SDL_Texture * atlas, SDL_Rect * src, SDL_Rect * dst,
+                               SDL_Rect * clip, lv_color_t color, lv_opa_t opa);
+
+static void font_atlas_free(lv_sdl_font_atlas_t * atlas);
+
+static SDL_Texture * font_atlas_bake(SDL_Renderer * renderer, const lv_font_t * font_p, uint32_t cmap_idx,
+                                     lv_sdl_font_atlas_t * atlas);
+
+static int32_t unicode_list_compare(const void * ref, const void * element);
+
+static bool font_cmap_find_index(const lv_font_fmt_txt_dsc_t * dsc, uint32_t letter, uint32_t * cmap_index,
+                                 uint32_t * char_index);
+
+static lv_font_key_t font_key_create(const lv_font_t * font_p, uint32_t cmap_index);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
+                    const lv_font_t * font_p, uint32_t letter, lv_color_t color, lv_opa_t opa,
+                    lv_blend_mode_t blend_mode)
+{
+    if(opa < LV_OPA_MIN) return;
+    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+    if(font_p == NULL) {
+        LV_LOG_WARN("lv_draw_letter: font is NULL");
+        return;
+    }
+
+    lv_font_glyph_dsc_t g;
+    bool g_ret = lv_font_get_glyph_dsc(font_p, &g, letter, '\0');
+    if(g_ret == false) {
+        /*Add warning if the dsc is not found
+         *but do not print warning for non printable ASCII chars (e.g. '\n')*/
+        if(letter >= 0x20 &&
+           letter != 0xf8ff && /*LV_SYMBOL_DUMMY*/
+           letter != 0x200c) { /*ZERO WIDTH NON-JOINER*/
+            LV_LOG_WARN("lv_draw_letter: glyph dsc. not found for U+%X", letter);
+        }
+        return;
+    }
+
+    /*Don't draw anything if the character is empty. E.g. space*/
+    if((g.box_h == 0) || (g.box_w == 0)) return;
+
+    int32_t pos_x = pos_p->x + g.ofs_x;
+    int32_t pos_y = pos_p->y + (font_p->line_height - font_p->base_line) - g.box_h - g.ofs_y;
+
+    /*If the letter is completely out of mask don't draw it*/
+    if(pos_x + g.box_w < clip_area->x1 ||
+       pos_x > clip_area->x2 ||
+       pos_y + g.box_h < clip_area->y1 ||
+       pos_y > clip_area->y2) {
+        return;
+    }
+    lv_area_t dst = {pos_x, pos_y, pos_x + g.box_w - 1, pos_y + g.box_h - 1};
+    uint32_t atlas_index;
+    uint32_t cmap_index;
+    if(!font_cmap_find_index(font_p->dsc, letter, &cmap_index, &atlas_index)) {
+        return;
+    }
+    lv_font_key_t key = font_key_create(font_p, cmap_index);
+    lv_sdl_font_atlas_t * atlas = NULL;
+    bool found = false;
+    SDL_Texture * texture = lv_gpu_draw_cache_get_with_userdata(&key, sizeof(key), &found, (void **) &atlas);
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+    if(!found) {
+        atlas = SDL_malloc(sizeof(lv_sdl_font_atlas_t));
+        texture = font_atlas_bake(renderer, font_p, cmap_index, atlas);
+        lv_gpu_draw_cache_put_advanced(&key, sizeof(key), texture, atlas, (lv_lru_free_t *) font_atlas_free, 0);
+    }
+    if(texture == NULL) return;
+    SDL_Rect dstrect = {.x = pos_x, .y = pos_y, .w = g.box_w, .h = g.box_h};
+
+    SDL_Rect clip_area_rect;
+    lv_area_to_sdl_rect(clip_area, &clip_area_rect);
+
+    if(lv_draw_mask_is_any(&dst)) {
+        draw_letter_masked(renderer, texture, &atlas->pos[atlas_index], &dstrect, &clip_area_rect, color, opa);
+        return;
+    }
+
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureAlphaMod(texture, opa);
+    SDL_SetTextureColorMod(texture, color.ch.red, color.ch.green, color.ch.blue);
+    SDL_RenderSetClipRect(renderer, &clip_area_rect);
+    SDL_RenderCopy(renderer, texture, &atlas->pos[atlas_index], &dstrect);
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void draw_letter_masked(SDL_Renderer * renderer, SDL_Texture * atlas, SDL_Rect * src, SDL_Rect * dst,
+                               SDL_Rect * clip, lv_color_t color, lv_opa_t opa)
+{
+    SDL_Texture * screen = SDL_GetRenderTarget(renderer);
+
+    lv_area_t mask_area = {.x1 = dst->x, .x2 = dst->x + dst->w - 1, .y1 = dst->y, .y2 = dst->y + dst->h - 1};
+    SDL_Texture * content = lv_gpu_temp_texture_obtain(renderer, dst->w, dst->h);
+    SDL_SetTextureBlendMode(content, SDL_BLENDMODE_NONE);
+    SDL_SetRenderTarget(renderer, content);
+    SDL_RenderSetClipRect(renderer, NULL);
+
+    /* Replace texture with clip mask */
+    SDL_Rect mask_rect = {.w = dst->w, .h = dst->h, .x = 0, .y = 0};
+    SDL_Texture * mask = lv_sdl_gen_mask_texture(renderer, &mask_area, NULL, 0);
+    SDL_SetTextureBlendMode(mask, SDL_BLENDMODE_NONE);
+    SDL_RenderCopy(renderer, mask, NULL, &mask_rect);
+
+    /* Multiply with font atlas */
+    SDL_SetTextureAlphaMod(atlas, 0xFF);
+    SDL_SetTextureColorMod(atlas, 0xFF, 0xFF, 0xFF);
+#if SDL_VERSION_ATLEAST(2, 0, 6)
+    SDL_BlendMode mode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO,
+                                                    SDL_BLENDOPERATION_ADD, SDL_BLENDFACTOR_ZERO,
+                                                    SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD);
+    SDL_SetTextureBlendMode(atlas, mode);
+#else
+    SDL_SetTextureBlendMode(atlas, SDL_BLENDMODE_BLEND);
+#endif
+    SDL_RenderCopy(renderer, atlas, src, &mask_rect);
+
+    /* Draw composited part on screen */
+    SDL_SetTextureBlendMode(content, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureAlphaMod(content, opa);
+    SDL_SetTextureColorMod(content, color.ch.red, color.ch.green, color.ch.blue);
+
+    SDL_SetRenderTarget(renderer, screen);
+    SDL_RenderSetClipRect(renderer, clip);
+    SDL_RenderCopy(renderer, content, &mask_rect, dst);
+    SDL_DestroyTexture(mask);
+}
+
+SDL_Texture * font_atlas_bake(SDL_Renderer * renderer, const lv_font_t * font_p, uint32_t cmap_idx,
+                              lv_sdl_font_atlas_t * atlas)
+{
+    /* Clear atlas struct */
+    SDL_memset(atlas, 0, sizeof(lv_sdl_font_atlas_t));
+    const lv_font_fmt_txt_dsc_t * dsc = (lv_font_fmt_txt_dsc_t *) font_p->dsc;
+    if(dsc->bitmap_format != LV_FONT_FMT_TXT_PLAIN) {
+        /* we don't support compressed font at this moment */
+        return NULL;
+    }
+    const lv_font_fmt_txt_cmap_t * cmap = &dsc->cmaps[cmap_idx];
+    int glyph_count = cmap->type == LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY ? cmap->range_length : cmap->list_length;
+    int atlas_size = 0;
+    while(atlas_size * atlas_size < glyph_count) {
+        atlas_size++;
+    }
+    int atlas_w = font_p->line_height * atlas_size;
+    int atlas_h = font_p->line_height * (glyph_count / atlas_size + 1);
+    if(atlas_w > 2048 || atlas_h > 2048) {
+        /*This atlas texture will be too large to load*/
+        return NULL;
+    }
+    lv_opa_t * s1 = lv_mem_buf_get(atlas_w * atlas_h * sizeof(lv_opa_t));
+    atlas->pos = SDL_malloc(sizeof(SDL_Rect) * glyph_count);
+    int atlas_y = 0;
+    int atlas_x = 0;
+    for(int i = 0; i < glyph_count; i++) {
+        int glyph_idx = cmap->glyph_id_start + i;
+        switch(cmap->type) {
+            case LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL: {
+                    const uint8_t * gid_ofs_8 = cmap->glyph_id_ofs_list;
+                    glyph_idx = gid_ofs_8[i];
+                    break;
+                }
+            case LV_FONT_FMT_TXT_CMAP_SPARSE_FULL: {
+                    const uint16_t * gid_ofs_16 = cmap->glyph_id_ofs_list;
+                    glyph_idx = gid_ofs_16[i];
+                    break;
+                }
+        }
+        const lv_font_fmt_txt_glyph_dsc_t * gd = &dsc->glyph_dsc[glyph_idx];
+        if(atlas_x + gd->box_w >= atlas_w) {
+            atlas_x = 0;
+            atlas_y += font_p->line_height;
+        }
+        SDL_Rect * rect = &atlas->pos[i];
+        rect->x = atlas_x;
+        rect->y = atlas_y;
+        rect->w = gd->box_w;
+        rect->h = gd->box_h;
+        if(gd->box_w <= 0 || gd->box_h <= 0) {
+            continue;
+        }
+        lv_sdl_to_8bpp(&s1[rect->y * atlas_w + rect->x], &dsc->glyph_bitmap[gd->bitmap_index], rect->w,
+                       rect->h, atlas_w, dsc->bpp);
+        atlas_x += gd->box_w;
+    }
+    SDL_Surface * mask = lv_sdl_create_mask_surface(s1, atlas_w, atlas_h, atlas_w);
+    SDL_Texture * result = SDL_CreateTextureFromSurface(renderer, mask);
+    SDL_FreeSurface(mask);
+    lv_mem_buf_release(s1);
+
+    if(!result) {
+        if(atlas->pos) {
+            SDL_free(atlas->pos);
+        }
+        SDL_memset(atlas, 0, sizeof(lv_sdl_font_atlas_t));
+    }
+    return result;
+}
+
+static void font_atlas_free(lv_sdl_font_atlas_t * atlas)
+{
+    if(atlas->pos) {
+        SDL_free(atlas->pos);
+    }
+    SDL_free(atlas);
+}
+
+static bool font_cmap_find_index(const lv_font_fmt_txt_dsc_t * dsc, uint32_t letter, uint32_t * cmap_index,
+                                 uint32_t * char_index)
+{
+    for(int i = 0; i < dsc->cmap_num; i++) {
+        const lv_font_fmt_txt_cmap_t * cmap = &dsc->cmaps[i];
+        /*Relative code point*/
+        uint32_t rcp = letter - cmap->range_start;
+        if(rcp > cmap->range_length) continue;
+        if(cmap->type == LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY) {
+            *cmap_index = i;
+            *char_index = rcp;
+            return true;
+        }
+        else if(cmap->type == LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL) {
+            *cmap_index = i;
+            *char_index = rcp;
+            return true;
+        }
+        else if(cmap->type == LV_FONT_FMT_TXT_CMAP_SPARSE_TINY) {
+            uint16_t key = rcp;
+            uint16_t * p = _lv_utils_bsearch(&key, cmap->unicode_list, cmap->list_length,
+                                             sizeof(cmap->unicode_list[0]), unicode_list_compare);
+            if(!p) continue;
+
+            *cmap_index = i;
+            *char_index = p - cmap->unicode_list;
+            return true;
+        }
+        else if(cmap->type == LV_FONT_FMT_TXT_CMAP_SPARSE_FULL) {
+            uint16_t key = rcp;
+            uint16_t * p = _lv_utils_bsearch(&key, cmap->unicode_list, cmap->list_length,
+                                             sizeof(cmap->unicode_list[0]), unicode_list_compare);
+            if(!p) continue;
+
+            *cmap_index = i;
+            *char_index = p - cmap->unicode_list;
+            return true;
+        }
+    }
+    return 0;
+}
+
+static int32_t unicode_list_compare(const void * ref, const void * element)
+{
+    return ((int32_t)(*(uint16_t *) ref)) - ((int32_t)(*(uint16_t *) element));
+}
+
+static lv_font_key_t font_key_create(const lv_font_t * font_p, uint32_t cmap_index)
+{
+    lv_font_key_t key;
+    /* VERY IMPORTANT! Padding between members is uninitialized, so we have to wipe them manually */
+    SDL_memset(&key, 0, sizeof(key));
+    key.magic = LV_GPU_CACHE_KEY_MAGIC_FONT;
+    key.font_p = font_p;
+    key.cmap_index = cmap_index;
+    return key;
+}
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_line.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_line.c
new file mode 100644
index 000000000..d1b3f362a
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_line.c
@@ -0,0 +1,158 @@
+/**
+ * @file lv_gpu_sdl_draw_line.c
+ *
+ * This implementation does not functioning properly so it's not enabled
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include LV_GPU_SDL_INCLUDE_PATH
+#include "../../core/lv_refr.h"
+#include "lv_gpu_sdl_utils.h"
+#include "lv_gpu_sdl_lru.h"
+#include "lv_gpu_sdl_texture_cache.h"
+#include "lv_gpu_sdl_mask.h"
+
+#ifndef M_PI
+    #include <math.h>
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_gpu_cache_key_magic_t magic;
+    lv_coord_t length;
+    lv_coord_t thickness;
+} lv_draw_line_key_t;
+
+static lv_draw_line_key_t line_key_create(lv_coord_t length, lv_coord_t thickness);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_line2(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * clip,
+                   const lv_draw_line_dsc_t * dsc)
+{
+    if(dsc->width == 0) return;
+    if(dsc->opa <= LV_OPA_MIN) return;
+
+    if(point1->x == point2->x && point1->y == point2->y) return;
+
+    lv_area_t clip_line;
+    clip_line.x1 = LV_MIN(point1->x, point2->x) - dsc->width / 2;
+    clip_line.x2 = LV_MAX(point1->x, point2->x) + dsc->width / 2;
+    clip_line.y1 = LV_MIN(point1->y, point2->y) - dsc->width / 2;
+    clip_line.y2 = LV_MAX(point1->y, point2->y) + dsc->width / 2;
+
+    if(!_lv_area_intersect(&clip_line, &clip_line, clip)) return;
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+    SDL_Color line_color;
+    lv_color_to_sdl_color(&dsc->color, &line_color);
+
+    int length = lv_sdl_round(SDL_sqrt(SDL_pow(point2->y - point1->y + 1, 2) + SDL_pow(point2->x - point1->x + 1, 2)));
+    lv_coord_t thickness = dsc->width;
+    lv_draw_line_key_t key = line_key_create(length, thickness);
+    lv_area_t coords = {1, 1, length, dsc->width};
+    lv_area_t tex_coords;
+    lv_area_copy(&tex_coords, &coords);
+    lv_area_increase(&tex_coords, 1, 1);
+
+    SDL_Texture * texture = lv_gpu_draw_cache_get(&key, sizeof(key), NULL);
+
+    if(texture == NULL) {
+        lv_draw_mask_radius_param_t mask_rout_param;
+        lv_draw_mask_radius_init(&mask_rout_param, &coords, 0, false);
+        int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
+        texture = lv_sdl_gen_mask_texture(renderer, &tex_coords, &mask_rout_id, 1);
+        lv_draw_mask_remove_id(mask_rout_id);
+        SDL_assert(texture);
+        lv_gpu_draw_cache_put(&key, sizeof(key), texture);
+    }
+    double angle = SDL_atan2(point2->y - point1->y, point2->x - point1->x) * 180 / M_PI;
+
+    SDL_Rect clip_rect;
+    lv_area_to_sdl_rect(&clip_line, &clip_rect);
+
+
+    SDL_Texture * screen = SDL_GetRenderTarget(renderer);
+
+    SDL_Texture * content = lv_gpu_temp_texture_obtain(renderer, clip_rect.w, clip_rect.h);
+    SDL_SetTextureBlendMode(content, SDL_BLENDMODE_BLEND);
+    SDL_SetRenderTarget(renderer, content);
+    SDL_RenderSetClipRect(renderer, NULL);
+
+    //    /* Replace texture with clip mask */
+    SDL_Rect mask_rect = {.w = clip_rect.w, .h = clip_rect.h, .x = 0, .y = 0};
+    //    SDL_Texture *mask = lv_sdl_gen_mask_texture(renderer, &clip_line, NULL, 0);
+    //    SDL_SetTextureBlendMode(mask, SDL_BLENDMODE_NONE);
+    ////    SDL_RenderCopy(renderer, mask, NULL, &mask_rect);
+    //
+    //    SDL_SetTextureAlphaMod(texture, 0xFF);
+    //    SDL_SetTextureColorMod(texture, 0xFF, 0xFF, 0xFF);
+    //#if SDL_VERSION_ATLEAST(2, 0, 6)
+    //    SDL_BlendMode mode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_ONE, SDL_BLENDFACTOR_ZERO,
+    //                                                    SDL_BLENDOPERATION_ADD, SDL_BLENDFACTOR_ZERO,
+    //                                                    SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD);
+    //    SDL_SetTextureBlendMode(texture, mode);
+    //    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_NONE);
+    //#else
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_NONE);
+    //#endif
+
+    SDL_Rect coords_rect;
+    lv_area_to_sdl_rect(&tex_coords, &coords_rect);
+    coords_rect.x = 0 - coords_rect.h / 2;
+    coords_rect.y = 0 - coords_rect.h / 2;
+    SDL_Point center = {coords_rect.h / 2, coords_rect.h / 2};
+    SDL_RenderCopyEx(renderer, texture, NULL, &coords_rect, angle, &center, SDL_FLIP_NONE);
+    //
+    //    /* Draw composited part on screen */
+    SDL_SetTextureBlendMode(content, SDL_BLENDMODE_NONE);
+    SDL_SetTextureAlphaMod(content, dsc->opa);
+    SDL_SetTextureColorMod(content, line_color.r, line_color.g, line_color.b);
+    //
+    SDL_SetRenderTarget(renderer, screen);
+    //    SDL_RenderSetClipRect(renderer, &clip_rect);
+    SDL_RenderSetClipRect(renderer, NULL);
+    SDL_RenderCopy(renderer, content, &mask_rect, &clip_rect);
+    //    SDL_DestroyTexture(mask);
+}
+
+static lv_draw_line_key_t line_key_create(lv_coord_t length, lv_coord_t thickness)
+{
+    lv_draw_line_key_t key;
+    /* VERY IMPORTANT! Padding between members is uninitialized, so we have to wipe them manually */
+    SDL_memset(&key, 0, sizeof(key));
+    key.magic = LV_GPU_CACHE_KEY_MAGIC_LINE;
+    key.length = length;
+    key.thickness = thickness;
+    return key;
+}
+
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_rect.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_rect.c
new file mode 100644
index 000000000..689fb3d73
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_draw_rect.c
@@ -0,0 +1,733 @@
+/**
+ * @file lv_gpu_sdl_draw_rect.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "../../draw/lv_draw_rect.h"
+#include "../../hal/lv_hal_disp.h"
+#include "../../core/lv_refr.h"
+#include "lv_gpu_sdl_utils.h"
+#include "lv_gpu_sdl_lru.h"
+#include "lv_gpu_sdl_texture_cache.h"
+#include "lv_gpu_sdl_mask.h"
+#include "lv_gpu_sdl_stack_blur.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    lv_gpu_cache_key_magic_t magic;
+    lv_coord_t radius;
+    lv_coord_t size;
+} lv_draw_rect_bg_key_t;
+
+typedef struct {
+    lv_gpu_cache_key_magic_t magic;
+    lv_coord_t radius;
+    lv_coord_t size;
+    lv_coord_t blur;
+} lv_draw_rect_shadow_key_t;
+
+typedef struct {
+    lv_gpu_cache_key_magic_t magic;
+    lv_coord_t rout, rin;
+    lv_coord_t thickness;
+    lv_coord_t size;
+    lv_border_side_t side;
+} lv_draw_rect_border_key_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void draw_bg_color(SDL_Renderer * renderer, const lv_area_t * coords, const lv_draw_rect_dsc_t * dsc);
+
+static void draw_bg_img(const lv_area_t * coords, const lv_area_t * clip,
+                        const lv_draw_rect_dsc_t * dsc);
+
+static void draw_border(SDL_Renderer * renderer, const lv_area_t * coords, const lv_draw_rect_dsc_t * dsc);
+
+static void draw_shadow(SDL_Renderer * renderer, const lv_area_t * coords, const lv_area_t * clip,
+                        const lv_draw_rect_dsc_t * dsc);
+
+static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc);
+
+static void draw_border_generic(const lv_area_t * outer_area, const lv_area_t * inner_area, lv_coord_t rout,
+                                lv_coord_t rin, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);
+
+static void draw_border_simple(const lv_area_t * outer_area, const lv_area_t * inner_area, lv_color_t color,
+                               lv_opa_t opa);
+
+static void draw_rect_masked(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc);
+
+static void draw_rect_masked_simple(const lv_area_t * coords, const lv_area_t * mask, const lv_draw_rect_dsc_t * dsc);
+
+static void frag_render_corners(SDL_Renderer * renderer, SDL_Texture * frag, lv_coord_t frag_size,
+                                const lv_area_t * coords);
+
+static void frag_render_borders(SDL_Renderer * renderer, SDL_Texture * frag, lv_coord_t frag_size,
+                                const lv_area_t * coords);
+
+static void frag_render_center(SDL_Renderer * renderer, SDL_Texture * frag, lv_coord_t frag_size,
+                               const lv_area_t * coords);
+
+static lv_draw_rect_bg_key_t rect_bg_key_create(lv_coord_t radius, lv_coord_t size);
+
+static lv_draw_rect_shadow_key_t rect_shadow_key_create(lv_coord_t radius, lv_coord_t size, lv_coord_t blur);
+
+static lv_draw_rect_border_key_t rect_border_key_create(lv_coord_t rout, lv_coord_t rin, lv_coord_t thickness,
+                                                        lv_coord_t size, lv_border_side_t side);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+#define SKIP_BORDER(dsc) ((dsc)->border_opa <= LV_OPA_MIN || (dsc)->border_width == 0 || (dsc)->border_side == LV_BORDER_SIDE_NONE || (dsc)->border_post)
+#define SKIP_SHADOW(dsc) ((dsc)->shadow_width == 0 || (dsc)->shadow_opa <= LV_OPA_MIN || ((dsc)->shadow_width == 1 && (dsc)->shadow_spread <= 0 && (dsc)->shadow_ofs_x == 0 && (dsc)->shadow_ofs_y == 0))
+#define SKIP_IMAGE(dsc) ((dsc)->bg_img_src == NULL || (dsc)->bg_img_opa <= LV_OPA_MIN)
+#define SKIP_OUTLINE(dsc) ((dsc)->outline_opa <= LV_OPA_MIN || (dsc)->outline_width == 0)
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
+{
+    lv_area_t draw_area;
+    bool has_draw_content = _lv_area_intersect(&draw_area, coords, clip);
+
+    if(lv_draw_mask_is_any(&draw_area)) {
+        draw_rect_masked(coords, clip, dsc);
+        return;
+    }
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+
+    SDL_Rect clip_rect;
+    lv_area_to_sdl_rect(clip, &clip_rect);
+    SDL_RenderSetClipRect(renderer, &clip_rect);
+    draw_shadow(renderer, coords, clip, dsc);
+    /* Shadows and outlines will also draw in extended area */
+    if(has_draw_content) {
+        draw_bg_color(renderer, coords, dsc);
+        draw_bg_img(coords, clip, dsc);
+        draw_border(renderer, coords, dsc);
+    }
+    draw_outline(coords, clip, dsc);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void draw_bg_color(SDL_Renderer * renderer, const lv_area_t * coords, const lv_draw_rect_dsc_t * dsc)
+{
+    SDL_Color bg_color;
+    lv_color_to_sdl_color(&dsc->bg_color, &bg_color);
+    lv_coord_t radius = dsc->radius;
+    if(radius > 0) {
+        /*A small texture with a quarter of the rect is enough*/
+        lv_coord_t bg_w = lv_area_get_width(coords), bg_h = lv_area_get_height(coords), bg_min = LV_MIN(bg_w, bg_h);
+        /* If size isn't times of 2, increase 1 px */
+        lv_coord_t min_half = bg_min % 2 == 0 ? bg_min / 2 : bg_min / 2 + 1;
+        lv_coord_t frag_size = radius == LV_RADIUS_CIRCLE ? min_half : LV_MIN(radius + 1, min_half);
+        lv_draw_rect_bg_key_t key = rect_bg_key_create(radius, frag_size);
+        lv_area_t coords_frag;
+        lv_area_copy(&coords_frag, coords);
+        lv_area_set_width(&coords_frag, frag_size);
+        lv_area_set_height(&coords_frag, frag_size);
+        SDL_Texture * texture = lv_gpu_draw_cache_get(&key, sizeof(key), NULL);
+        if(texture == NULL) {
+            lv_draw_mask_radius_param_t mask_rout_param;
+            lv_draw_mask_radius_init(&mask_rout_param, coords, radius, false);
+            int16_t mask_id = lv_draw_mask_add(&mask_rout_param, NULL);
+            texture = lv_sdl_gen_mask_texture(renderer, &coords_frag, &mask_id, 1);
+            lv_draw_mask_remove_id(mask_id);
+            SDL_assert(texture);
+            lv_gpu_draw_cache_put(&key, sizeof(key), texture);
+        }
+
+        SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+        SDL_SetTextureAlphaMod(texture, dsc->bg_opa);
+        SDL_SetTextureColorMod(texture, bg_color.r, bg_color.g, bg_color.b);
+        frag_render_corners(renderer, texture, frag_size, coords);
+        frag_render_borders(renderer, texture, frag_size, coords);
+        frag_render_center(renderer, texture, frag_size, coords);
+    }
+    else {
+        SDL_Rect coords_rect;
+        lv_area_to_sdl_rect(coords, &coords_rect);
+        SDL_SetRenderDrawColor(renderer, bg_color.r, bg_color.g, bg_color.b, dsc->bg_opa);
+        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+        SDL_RenderFillRect(renderer, &coords_rect);
+    }
+}
+
+static void draw_bg_img(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
+{
+    if(SKIP_IMAGE(dsc)) return;
+
+    lv_img_src_t src_type = lv_img_src_get_type(dsc->bg_img_src);
+    if(src_type == LV_IMG_SRC_SYMBOL) {
+        lv_point_t size;
+        lv_txt_get_size(&size, dsc->bg_img_src, dsc->bg_img_symbol_font, 0, 0, LV_COORD_MAX, LV_TEXT_FLAG_NONE);
+        lv_area_t a;
+        a.x1 = coords->x1 + lv_area_get_width(coords) / 2 - size.x / 2;
+        a.x2 = a.x1 + size.x - 1;
+        a.y1 = coords->y1 + lv_area_get_height(coords) / 2 - size.y / 2;
+        a.y2 = a.y1 + size.y - 1;
+
+        lv_draw_label_dsc_t label_draw_dsc;
+        lv_draw_label_dsc_init(&label_draw_dsc);
+        label_draw_dsc.font = dsc->bg_img_symbol_font;
+        label_draw_dsc.color = dsc->bg_img_recolor;
+        label_draw_dsc.opa = dsc->bg_img_opa;
+        lv_draw_label(&a, clip, &label_draw_dsc, dsc->bg_img_src, NULL);
+    }
+    else {
+        lv_img_header_t header;
+        size_t key_size;
+        lv_gpu_sdl_cache_key_head_img_t * key = lv_gpu_sdl_img_cache_key_create(dsc->bg_img_src, 0, &key_size);
+        bool key_found;
+        lv_img_header_t * cache_header = NULL;
+        SDL_Texture * texture = lv_gpu_draw_cache_get_with_userdata(key, key_size, &key_found, (void **) &cache_header);
+        SDL_free(key);
+        if(texture) {
+            header = *cache_header;
+        }
+        else if(key_found || lv_img_decoder_get_info(dsc->bg_img_src, &header) != LV_RES_OK) {
+            /* When cache hit but with negative result, use default decoder. If still fail, return.*/
+            LV_LOG_WARN("Couldn't read the background image");
+            return;
+        }
+
+        lv_draw_img_dsc_t img_dsc;
+        lv_draw_img_dsc_init(&img_dsc);
+        img_dsc.blend_mode = dsc->blend_mode;
+        img_dsc.recolor = dsc->bg_img_recolor;
+        img_dsc.recolor_opa = dsc->bg_img_recolor_opa;
+        img_dsc.opa = dsc->bg_img_opa;
+
+        /*Center align*/
+        if(dsc->bg_img_tiled == false) {
+            lv_area_t area;
+            area.x1 = coords->x1 + lv_area_get_width(coords) / 2 - header.w / 2;
+            area.y1 = coords->y1 + lv_area_get_height(coords) / 2 - header.h / 2;
+            area.x2 = area.x1 + header.w - 1;
+            area.y2 = area.y1 + header.h - 1;
+
+            lv_draw_img(&area, clip, dsc->bg_img_src, &img_dsc);
+        }
+        else {
+            lv_area_t area;
+            area.y1 = coords->y1;
+            area.y2 = area.y1 + header.h - 1;
+
+            for(; area.y1 <= coords->y2; area.y1 += header.h, area.y2 += header.h) {
+
+                area.x1 = coords->x1;
+                area.x2 = area.x1 + header.w - 1;
+                for(; area.x1 <= coords->x2; area.x1 += header.w, area.x2 += header.w) {
+                    lv_draw_img(&area, clip, dsc->bg_img_src, &img_dsc);
+                }
+            }
+        }
+    }
+}
+
+static void draw_shadow(SDL_Renderer * renderer, const lv_area_t * coords, const lv_area_t * clip,
+                        const lv_draw_rect_dsc_t * dsc)
+{
+    /*Check whether the shadow is visible*/
+    if(SKIP_SHADOW(dsc)) return;
+
+    lv_coord_t sw = dsc->shadow_width;
+
+    lv_area_t core_area;
+    core_area.x1 = coords->x1 + dsc->shadow_ofs_x - dsc->shadow_spread;
+    core_area.x2 = coords->x2 + dsc->shadow_ofs_x + dsc->shadow_spread;
+    core_area.y1 = coords->y1 + dsc->shadow_ofs_y - dsc->shadow_spread;
+    core_area.y2 = coords->y2 + dsc->shadow_ofs_y + dsc->shadow_spread;
+
+    lv_area_t shadow_area;
+    shadow_area.x1 = core_area.x1 - sw / 2 - 1;
+    shadow_area.x2 = core_area.x2 + sw / 2 + 1;
+    shadow_area.y1 = core_area.y1 - sw / 2 - 1;
+    shadow_area.y2 = core_area.y2 + sw / 2 + 1;
+
+    lv_opa_t opa = dsc->shadow_opa;
+
+    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+    /*Get clipped draw area which is the real draw area.
+     *It is always the same or inside `shadow_area`*/
+    lv_area_t draw_area;
+    if(!_lv_area_intersect(&draw_area, &shadow_area, clip)) return;
+
+    SDL_Rect core_area_rect;
+    lv_area_to_sdl_rect(&shadow_area, &core_area_rect);
+
+    lv_coord_t radius = dsc->radius;
+    lv_coord_t sh_width = lv_area_get_width(&core_area);
+    lv_coord_t sh_height = lv_area_get_height(&core_area);
+    lv_coord_t sh_min = LV_MIN(sh_width, sh_height);
+    /* If size isn't times of 2, increase 1 px */
+    lv_coord_t min_half = sh_min % 2 == 0 ? sh_min / 2 : sh_min / 2 + 1;
+    /* No matter how big the shadow is, what we need is just a corner */
+    lv_coord_t frag_size = radius == LV_RADIUS_CIRCLE ? min_half : LV_MIN(radius + 1, min_half);
+    /* This is how big the corner is after blurring */
+    lv_coord_t blur_frag_size = frag_size + sw + 2;
+
+    lv_draw_rect_shadow_key_t key = rect_shadow_key_create(radius, frag_size, sw);
+
+    lv_area_t blur_frag;
+    lv_area_copy(&blur_frag, &shadow_area);
+    lv_area_set_width(&blur_frag, blur_frag_size * 2);
+    lv_area_set_height(&blur_frag, blur_frag_size * 2);
+    SDL_Texture * texture = lv_gpu_draw_cache_get(&key, sizeof(key), NULL);
+    if(texture == NULL) {
+        lv_draw_mask_radius_param_t mask_rout_param;
+        lv_draw_mask_radius_init(&mask_rout_param, &core_area, radius, false);
+        int16_t mask_id = lv_draw_mask_add(&mask_rout_param, NULL);
+        lv_opa_t * mask_buf = lv_draw_mask_dump(&blur_frag, &mask_id, 1);
+        lv_stack_blur_grayscale(mask_buf, lv_area_get_width(&blur_frag), lv_area_get_height(&blur_frag), sw / 2 + 1);
+        texture = lv_sdl_create_mask_texture(renderer, mask_buf, blur_frag_size, blur_frag_size,
+                                             lv_area_get_width(&blur_frag));
+        lv_mem_buf_release(mask_buf);
+        lv_draw_mask_remove_id(mask_id);
+        SDL_assert(texture);
+        lv_gpu_draw_cache_put(&key, sizeof(key), texture);
+    }
+
+    SDL_Color shadow_color;
+    lv_color_to_sdl_color(&dsc->shadow_color, &shadow_color);
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureAlphaMod(texture, opa);
+    SDL_SetTextureColorMod(texture, shadow_color.r, shadow_color.g, shadow_color.b);
+
+    frag_render_corners(renderer, texture, blur_frag_size, &shadow_area);
+    frag_render_borders(renderer, texture, blur_frag_size, &shadow_area);
+    frag_render_center(renderer, texture, blur_frag_size, &shadow_area);
+}
+
+
+static void draw_border(SDL_Renderer * renderer, const lv_area_t * coords, const lv_draw_rect_dsc_t * dsc)
+{
+    if(SKIP_BORDER(dsc)) return;
+
+    SDL_Color border_color;
+    lv_color_to_sdl_color(&dsc->border_color, &border_color);
+
+
+    if(dsc->border_side != LV_BORDER_SIDE_FULL) {
+        SDL_SetRenderDrawColor(renderer, border_color.r, border_color.g, border_color.b, dsc->border_opa);
+        SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+        for(int w = 0; w <= dsc->border_width; w++) {
+            if(dsc->border_side & LV_BORDER_SIDE_TOP) {
+                SDL_RenderDrawLine(renderer, coords->x1, coords->y1 + w, coords->x2, coords->y1 + w);
+            }
+            if(dsc->border_side & LV_BORDER_SIDE_BOTTOM) {
+                SDL_RenderDrawLine(renderer, coords->x1, coords->y2 - w, coords->x2, coords->y2 - w);
+            }
+            if(dsc->border_side & LV_BORDER_SIDE_LEFT) {
+                SDL_RenderDrawLine(renderer, coords->x1 + w, coords->y1, coords->x1 + w, coords->y2);
+            }
+            if(dsc->border_side & LV_BORDER_SIDE_RIGHT) {
+                SDL_RenderDrawLine(renderer, coords->x2 - w, coords->y1, coords->x2 - w, coords->y2);
+            }
+        }
+    }
+    else {
+        int32_t coords_w = lv_area_get_width(coords);
+        int32_t coords_h = lv_area_get_height(coords);
+        int32_t rout = dsc->radius;
+        int32_t short_side = LV_MIN(coords_w, coords_h);
+        if(rout > short_side >> 1) rout = short_side >> 1;
+
+        /*Get the inner area*/
+        lv_area_t area_inner;
+        lv_area_copy(&area_inner, coords);
+        area_inner.x1 += ((dsc->border_side & LV_BORDER_SIDE_LEFT) ? dsc->border_width : -(dsc->border_width + rout));
+        area_inner.x2 -= ((dsc->border_side & LV_BORDER_SIDE_RIGHT) ? dsc->border_width : -(dsc->border_width + rout));
+        area_inner.y1 += ((dsc->border_side & LV_BORDER_SIDE_TOP) ? dsc->border_width : -(dsc->border_width + rout));
+        area_inner.y2 -= ((dsc->border_side & LV_BORDER_SIDE_BOTTOM) ? dsc->border_width : -(dsc->border_width + rout));
+
+        lv_coord_t rin = rout - dsc->border_width;
+        if(rin < 0) rin = 0;
+        draw_border_generic(coords, &area_inner, rout, rin, dsc->border_color, dsc->border_opa,
+                            dsc->blend_mode);
+    }
+}
+
+static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
+{
+    if(SKIP_OUTLINE(dsc)) return;
+
+    lv_opa_t opa = dsc->outline_opa;
+
+    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+    /*Get the inner radius*/
+    lv_area_t area_inner;
+    lv_area_copy(&area_inner, coords);
+
+    /*Extend the outline into the background area if it's overlapping the edge*/
+    lv_coord_t pad = (dsc->outline_pad == 0 ? (dsc->outline_pad - 1) : dsc->outline_pad);
+    area_inner.x1 -= pad;
+    area_inner.y1 -= pad;
+    area_inner.x2 += pad;
+    area_inner.y2 += pad;
+
+    lv_area_t area_outer;
+    lv_area_copy(&area_outer, &area_inner);
+
+    area_outer.x1 -= dsc->outline_width;
+    area_outer.x2 += dsc->outline_width;
+    area_outer.y1 -= dsc->outline_width;
+    area_outer.y2 += dsc->outline_width;
+
+    lv_area_t draw_area;
+    if(!_lv_area_intersect(&draw_area, &area_outer, clip)) return;
+
+    int32_t inner_w = lv_area_get_width(&area_inner);
+    int32_t inner_h = lv_area_get_height(&area_inner);
+    int32_t rin = dsc->radius;
+    int32_t short_side = LV_MIN(inner_w, inner_h);
+    if(rin > short_side >> 1) rin = short_side >> 1;
+
+    lv_coord_t rout = rin + dsc->outline_width;
+
+    draw_border_generic(&area_outer, &area_inner, rout, rin, dsc->outline_color, dsc->outline_opa,
+                        dsc->blend_mode);
+}
+
+static void draw_border_generic(const lv_area_t * outer_area, const lv_area_t * inner_area, lv_coord_t rout,
+                                lv_coord_t rin, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode)
+{
+    opa = opa >= LV_OPA_COVER ? LV_OPA_COVER : opa;
+
+    if(rout == 0 || rin == 0) {
+        draw_border_simple(outer_area, inner_area, color, opa);
+        return;
+    }
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+    lv_coord_t border_width = lv_area_get_width(outer_area);
+    lv_coord_t border_height = lv_area_get_height(outer_area);
+    lv_coord_t border_min = LV_MIN(border_width, border_height);
+    lv_coord_t min_half = border_min % 2 == 0 ? border_min / 2 : border_min / 2 + 1;
+    lv_coord_t frag_size = rout == LV_RADIUS_CIRCLE ? min_half : LV_MIN(rout + 1, min_half);
+    lv_draw_rect_border_key_t key = rect_border_key_create(rout, rin, inner_area->x1 - outer_area->x1 + 1,
+                                                           frag_size, LV_BORDER_SIDE_FULL);
+    SDL_Texture * texture = lv_gpu_draw_cache_get(&key, sizeof(key), NULL);
+    if(texture == NULL) {
+        /*Create mask for the outer area*/
+        int16_t mask_ids[2] = {LV_MASK_ID_INV, LV_MASK_ID_INV};
+        lv_draw_mask_radius_param_t mask_rout_param;
+        if(rout > 0) {
+            lv_draw_mask_radius_init(&mask_rout_param, outer_area, rout, false);
+            mask_ids[0] = lv_draw_mask_add(&mask_rout_param, NULL);
+        }
+
+        /*Create mask for the inner mask*/
+        if(rin < 0) rin = 0;
+        lv_draw_mask_radius_param_t mask_rin_param;
+        lv_draw_mask_radius_init(&mask_rin_param, inner_area, rin, true);
+        mask_ids[1] = lv_draw_mask_add(&mask_rin_param, NULL);
+
+        lv_area_t frag_area;
+        lv_area_copy(&frag_area, outer_area);
+        lv_area_set_width(&frag_area, frag_size);
+        lv_area_set_height(&frag_area, frag_size);
+
+        texture = lv_sdl_gen_mask_texture(renderer, &frag_area, mask_ids, 2);
+
+        lv_draw_mask_remove_id(mask_ids[1]);
+        lv_draw_mask_remove_id(mask_ids[0]);
+        SDL_assert(texture);
+        lv_gpu_draw_cache_put(&key, sizeof(key), texture);
+    }
+
+    SDL_Rect outer_rect;
+    lv_area_to_sdl_rect(outer_area, &outer_rect);
+    SDL_Color color_sdl;
+    lv_color_to_sdl_color(&color, &color_sdl);
+
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureAlphaMod(texture, opa);
+    SDL_SetTextureColorMod(texture, color_sdl.r, color_sdl.g, color_sdl.b);
+
+    frag_render_corners(renderer, texture, frag_size, outer_area);
+    frag_render_borders(renderer, texture, frag_size, outer_area);
+}
+
+static void draw_border_simple(const lv_area_t * outer_area, const lv_area_t * inner_area, lv_color_t color,
+                               lv_opa_t opa)
+{
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+    SDL_Color color_sdl;
+    lv_color_to_sdl_color(&color, &color_sdl);
+
+    SDL_SetRenderDrawColor(renderer, color_sdl.r, color_sdl.g, color_sdl.b, opa);
+    SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
+    SDL_Rect simple_rect;
+    simple_rect.w = inner_area->x2 - outer_area->x1 + 1;
+    simple_rect.h = inner_area->y1 - outer_area->y1 + 1;
+    /*Top border*/
+    simple_rect.x = outer_area->x1;
+    simple_rect.y = outer_area->y1;
+    SDL_RenderFillRect(renderer, &simple_rect);
+    /*Bottom border*/
+    simple_rect.x = inner_area->x1;
+    simple_rect.y = inner_area->y2;
+    SDL_RenderFillRect(renderer, &simple_rect);
+
+    simple_rect.w = inner_area->x1 - outer_area->x1 + 1;
+    simple_rect.h = inner_area->y2 - outer_area->y1 + 1;
+    /*Left border*/
+    simple_rect.x = outer_area->x1;
+    simple_rect.y = inner_area->y1;
+    SDL_RenderFillRect(renderer, &simple_rect);
+    /*Right border*/
+    simple_rect.x = inner_area->x2;
+    simple_rect.y = outer_area->y1;
+    SDL_RenderFillRect(renderer, &simple_rect);
+
+}
+
+static void frag_render_corners(SDL_Renderer * renderer, SDL_Texture * frag, lv_coord_t frag_size,
+                                const lv_area_t * coords)
+{
+    lv_coord_t bg_w = lv_area_get_width(coords);
+    lv_coord_t bg_h = lv_area_get_height(coords);
+    SDL_Rect srcrect = {0, 0, frag_size, frag_size};
+    SDL_Rect dstrect = {.x = coords->x1, .y = coords->y1, .w = frag_size, .h = frag_size};
+    /* Upper left */
+    SDL_RenderCopyEx(renderer, frag, &srcrect, &dstrect, 0, NULL, SDL_FLIP_NONE);
+    /* Upper right, clip right edge if too big */
+    srcrect.w = dstrect.w = LV_MIN(frag_size, bg_w - frag_size);
+    dstrect.x = coords->x2 - srcrect.w + 1;
+    SDL_RenderCopyEx(renderer, frag, &srcrect, &dstrect, 0, NULL, SDL_FLIP_HORIZONTAL);
+    /* Lower right, clip bottom edge if too big */
+    srcrect.h = dstrect.h = LV_MIN(frag_size, bg_h - frag_size);
+    dstrect.y = coords->y2 - srcrect.h + 1;
+    SDL_RenderCopyEx(renderer, frag, &srcrect, &dstrect, 0, NULL, SDL_FLIP_HORIZONTAL | SDL_FLIP_VERTICAL);
+    /* Lower left, right edge should not be clipped */
+    srcrect.w = dstrect.w = frag_size;
+    dstrect.x = coords->x1;
+    SDL_RenderCopyEx(renderer, frag, &srcrect, &dstrect, 0, NULL, SDL_FLIP_VERTICAL);
+}
+
+static void frag_render_borders(SDL_Renderer * renderer, SDL_Texture * frag, lv_coord_t frag_size,
+                                const lv_area_t * coords)
+{
+    lv_coord_t bg_w = lv_area_get_width(coords);
+    lv_coord_t bg_h = lv_area_get_height(coords);
+    SDL_Rect srcrect;
+    SDL_Rect dstrect;
+    /* For top/bottom edges, stretch pixels on the right */
+    srcrect.h = dstrect.h = frag_size;
+    dstrect.w = bg_w - frag_size * 2;
+    /* Has space to fill */
+    if(dstrect.w > 0 && dstrect.h > 0) {
+        srcrect.w = 1;
+        srcrect.y = 0;
+        srcrect.x = frag_size - 1;
+        dstrect.x = coords->x1 + frag_size;
+        /* Top edge */
+        dstrect.y = coords->y1;
+        SDL_RenderCopy(renderer, frag, &srcrect, &dstrect);
+        /* Bottom edge */
+        dstrect.y = coords->y2 - frag_size + 1;
+        if(bg_h < frag_size * 2) {
+            /* Bottom edge will overlap with top, so decrease it by 1 px */
+            srcrect.h = dstrect.h = frag_size - 1;
+            dstrect.y += 1;
+        }
+        if(srcrect.h > 0) {
+            SDL_RenderCopyEx(renderer, frag, &srcrect, &dstrect, 0, NULL, SDL_FLIP_VERTICAL);
+        }
+    }
+    /* For left/right edges, stretch pixels on the bottom */
+    srcrect.w = dstrect.w = frag_size;
+    dstrect.h = bg_h - frag_size * 2;
+    if(dstrect.w > 0 && dstrect.h > 0) {
+        srcrect.h = 1;
+        srcrect.x = 0;
+        srcrect.y = frag_size - 1;
+        dstrect.y = coords->y1 + frag_size;
+        /* Left edge */
+        dstrect.x = coords->x1;
+        SDL_RenderCopy(renderer, frag, &srcrect, &dstrect);
+        /* Right edge */
+        dstrect.x = coords->x2 - frag_size + 1;
+        if(bg_w < frag_size * 2) {
+            /* Right edge will overlap with left, so decrease it by 1 px */
+            srcrect.w = dstrect.w = frag_size - 1;
+            dstrect.x += 1;
+        }
+        if(srcrect.w > 0) {
+            SDL_RenderCopyEx(renderer, frag, &srcrect, &dstrect, 0, NULL, SDL_FLIP_HORIZONTAL);
+        }
+    }
+}
+
+static void
+frag_render_center(SDL_Renderer * renderer, SDL_Texture * frag, lv_coord_t frag_size, const lv_area_t * coords)
+{
+    lv_coord_t bg_w = lv_area_get_width(coords);
+    lv_coord_t bg_h = lv_area_get_height(coords);
+    SDL_Rect dstrect = {coords->x1 + frag_size, coords->y1 + frag_size, bg_w - frag_size * 2, bg_h - frag_size * 2};
+    if(dstrect.w > 0 && dstrect.h > 0) {
+        SDL_Rect srcrect = {frag_size - 1, frag_size - 1, 1, 1};
+        SDL_RenderCopy(renderer, frag, &srcrect, &dstrect);
+    }
+}
+
+static void draw_rect_masked(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
+{
+    if(dsc->radius <= 0 && SKIP_BORDER(dsc) && SKIP_SHADOW(dsc) && SKIP_IMAGE(dsc) && SKIP_OUTLINE(dsc)) {
+        draw_rect_masked_simple(coords, clip, dsc);
+        return;
+    }
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+    SDL_Texture * screen = SDL_GetRenderTarget(renderer);
+
+    lv_coord_t sw = dsc->shadow_width;
+
+    lv_area_t sh_area = *coords;
+    lv_area_increase(&sh_area, dsc->shadow_spread + sw / 2 + 1, dsc->shadow_spread + sw / 2 + 1);
+    lv_area_move(&sh_area, dsc->shadow_ofs_x, dsc->shadow_ofs_y);
+
+    lv_coord_t draw_w = lv_area_get_width(&sh_area);
+    lv_coord_t draw_h = lv_area_get_height(&sh_area);
+    /* Render drawing area to an offscreen texture */
+    SDL_Texture * content = lv_gpu_temp_texture_obtain(renderer, draw_w, draw_h);
+    SDL_assert(content);
+    SDL_SetTextureColorMod(content, 0xFF, 0xFF, 0xFF);
+    SDL_SetTextureAlphaMod(content, 0xFF);
+    SDL_SetTextureBlendMode(content, SDL_BLENDMODE_BLEND);
+
+    SDL_SetRenderTarget(renderer, content);
+    SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0x00);
+    SDL_RenderClear(renderer);
+    SDL_RenderSetClipRect(renderer, NULL);
+    lv_area_t content_coords;
+    lv_area_copy(&content_coords, coords);
+    lv_area_move(&content_coords, -sh_area.x1, -sh_area.y1);
+
+    draw_shadow(renderer, &content_coords, clip, dsc);
+    draw_bg_color(renderer, &content_coords, dsc);
+    draw_bg_img(&content_coords, clip, dsc);
+    draw_border(renderer, &content_coords, dsc);
+    draw_outline(&content_coords, clip, dsc);
+
+    SDL_Texture * clip_mask = lv_sdl_gen_mask_texture(renderer, &sh_area, NULL, 0);
+    SDL_Rect src_rect = {.w = draw_w, .h = draw_h, .x = 0, .y = 0};
+#if SDL_VERSION_ATLEAST(2, 0, 6)
+    SDL_BlendMode mode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE,
+                                                    SDL_BLENDOPERATION_ADD, SDL_BLENDFACTOR_ZERO,
+                                                    SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDOPERATION_ADD);
+    SDL_SetTextureBlendMode(clip_mask, mode);
+    SDL_RenderCopy(renderer, clip_mask, NULL, &src_rect);
+#endif
+
+    SDL_Rect mask_rect;
+    SDL_Rect draw_rect;
+    lv_area_to_sdl_rect(&sh_area, &draw_rect);
+    lv_area_to_sdl_rect(clip, &mask_rect);
+
+    SDL_SetRenderTarget(renderer, screen);
+    SDL_RenderSetClipRect(renderer, &mask_rect);
+    SDL_RenderCopy(renderer, content, &src_rect, &draw_rect);
+    SDL_DestroyTexture(clip_mask);
+}
+
+static void draw_rect_masked_simple(const lv_area_t * coords, const lv_area_t * mask, const lv_draw_rect_dsc_t * dsc)
+{
+    SDL_Color bg_color;
+    lv_color_to_sdl_color(&dsc->bg_color, &bg_color);
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    SDL_Renderer * renderer = (SDL_Renderer *) disp->driver->user_data;
+
+    SDL_Surface * indexed = lv_sdl_apply_mask_surface(coords, NULL, 0);
+    SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, indexed);
+
+    SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+    SDL_SetTextureAlphaMod(texture, dsc->bg_opa);
+    SDL_SetTextureColorMod(texture, bg_color.r, bg_color.g, bg_color.b);
+
+    SDL_Rect coords_rect, mask_rect;
+    lv_area_to_sdl_rect(coords, &coords_rect);
+    lv_area_to_sdl_rect(mask, &mask_rect);
+
+    SDL_RenderSetClipRect(renderer, &mask_rect);
+    SDL_RenderCopy(renderer, texture, NULL, &coords_rect);
+
+    SDL_DestroyTexture(texture);
+    SDL_FreeSurface(indexed);
+}
+
+static lv_draw_rect_bg_key_t rect_bg_key_create(lv_coord_t radius, lv_coord_t size)
+{
+    lv_draw_rect_bg_key_t key;
+    SDL_memset(&key, 0, sizeof(key));
+    key.magic = LV_GPU_CACHE_KEY_MAGIC_RECT_BG;
+    key.radius = radius;
+    key.size = size;
+    return key;
+}
+
+static lv_draw_rect_shadow_key_t rect_shadow_key_create(lv_coord_t radius, lv_coord_t size, lv_coord_t blur)
+{
+    lv_draw_rect_shadow_key_t key;
+    SDL_memset(&key, 0, sizeof(key));
+    key.magic = LV_GPU_CACHE_KEY_MAGIC_RECT_SHADOW;
+    key.radius = radius;
+    key.size = size;
+    key.blur = blur;
+    return key;
+}
+
+static lv_draw_rect_border_key_t rect_border_key_create(lv_coord_t rout, lv_coord_t rin, lv_coord_t thickness,
+                                                        lv_coord_t size, lv_border_side_t side)
+{
+    lv_draw_rect_border_key_t key;
+    /* VERY IMPORTANT! Padding between members is uninitialized, so we have to wipe them manually */
+    SDL_memset(&key, 0, sizeof(key));
+    key.magic = LV_GPU_CACHE_KEY_MAGIC_RECT_BORDER;
+    key.rout = rout;
+    key.rin = rin;
+    key.thickness = thickness;
+    key.size = size;
+    key.side = side;
+    return key;
+}
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_lru.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_lru.c
new file mode 100644
index 000000000..5e67e8a17
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_lru.c
@@ -0,0 +1,375 @@
+/**
+ * @file lv_gpu_sdl_lru.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+#include "../../misc/lv_log.h"
+#include "lv_gpu_sdl_lru.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**
+ * MurmurHash2
+ * @author Austin Appleby
+ * @see http://sites.google.com/site/murmurhash/
+ */
+static uint32_t lv_lru_hash(lv_lru_t * cache, const void * key, uint32_t key_length);
+
+/** compare a key against an existing item's key */
+static int lv_lru_cmp_keys(lruc_item * item, const void * key, uint32_t key_length);
+
+/** remove an item and push it to the free items queue */
+static void lv_lru_remove_item(lv_lru_t * cache, lruc_item * prev, lruc_item * item, uint32_t hash_index);
+
+/**
+ * remove the least recently used item
+ *
+ * @todo we can optimise this by finding the n lru items, where n = required_space / average_length
+ */
+static void lv_lru_remove_lru_item(lv_lru_t * cache);
+
+/** pop an existing item off the free queue, or create a new one */
+static lruc_item * lv_lru_pop_or_create_item(lv_lru_t * cache);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/* error helpers */
+#define error_for(conditions, error)  if(conditions) {return error;}
+#define test_for_missing_cache()      error_for(!cache, LV_LRU_MISSING_CACHE)
+#define test_for_missing_key()        error_for(!key, LV_LRU_MISSING_KEY)
+#define test_for_missing_value()      error_for(!value || value_length == 0, LV_LRU_MISSING_VALUE)
+#define test_for_value_too_large()    error_for(value_length > cache->total_memory, LV_LRU_VALUE_TOO_LARGE)
+
+/* lock helpers */
+#define lock_cache()    if(SDL_LockMutex(cache->mutex)) {\
+        LV_LOG_WARN("LRU Cache unable to obtain mutex lock");\
+        return LV_LRU_LOCK_ERROR;\
+    }
+
+#define unlock_cache()  if(SDL_UnlockMutex(cache->mutex)) {\
+        LV_LOG_WARN("LRU Cache unable to release mutex lock");\
+        return LV_LRU_LOCK_ERROR;\
+    }
+
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_lru_t * lv_lru_new(uint64_t cache_size, uint32_t average_length, lv_lru_free_t * value_free,
+                      lv_lru_free_t * key_free)
+{
+    // create the cache
+    lv_lru_t * cache = (lv_lru_t *) calloc(sizeof(lv_lru_t), 1);
+    if(!cache) {
+        LV_LOG_WARN("LRU Cache unable to create cache object");
+        return NULL;
+    }
+    cache->hash_table_size = cache_size / average_length;
+    cache->average_item_length = average_length;
+    cache->free_memory = cache_size;
+    cache->total_memory = cache_size;
+    cache->seed = time(NULL);
+    cache->value_free = value_free ? value_free : free;
+    cache->key_free = key_free ? key_free : free;
+
+    // size the hash table to a guestimate of the number of slots required (assuming a perfect hash)
+    cache->items = (lruc_item **) calloc(sizeof(lruc_item *), cache->hash_table_size);
+    if(!cache->items) {
+        LV_LOG_WARN("LRU Cache unable to create cache hash table");
+        free(cache);
+        return NULL;
+    }
+
+    // all cache calls are guarded by a mutex
+    cache->mutex = SDL_CreateMutex();
+    if(!cache->mutex) {
+        LV_LOG_WARN("LRU Cache unable to initialise mutex");
+        free(cache->items);
+        free(cache);
+        return NULL;
+    }
+    return cache;
+}
+
+
+lruc_error lv_lru_free(lv_lru_t * cache)
+{
+    test_for_missing_cache();
+
+    // free each of the cached items, and the hash table
+    lruc_item * item = NULL, *next = NULL;
+    uint32_t i = 0;
+    if(cache->items) {
+        for(; i < cache->hash_table_size; i++) {
+            item = cache->items[i];
+            while(item) {
+                next = (lruc_item *) item->next;
+                cache->value_free(item->value);
+                cache->key_free(item->key);
+                cache->free_memory += item->value_length;
+                free(item);
+                item = next;
+            }
+        }
+        free(cache->items);
+    }
+
+    if(cache->free_items) {
+        item = cache->free_items;
+        while(item) {
+            next = (lruc_item *) item->next;
+            free(item);
+            item = next;
+        }
+    }
+
+    // free the cache
+    if(cache->mutex) {
+        SDL_DestroyMutex(cache->mutex);
+    }
+    free(cache);
+
+    return LV_LRU_NO_ERROR;
+}
+
+
+lruc_error lv_lru_set(lv_lru_t * cache, const void * key, size_t key_length, void * value, size_t value_length)
+{
+    test_for_missing_cache();
+    test_for_missing_key();
+    test_for_missing_value();
+    test_for_value_too_large();
+    lock_cache();
+
+    // see if the key already exists
+    uint32_t hash_index = lv_lru_hash(cache, key, key_length);
+    int64_t required = 0;
+    lruc_item * item = NULL, *prev = NULL;
+    item = cache->items[hash_index];
+
+    while(item && lv_lru_cmp_keys(item, key, key_length)) {
+        prev = item;
+        item = (lruc_item *) item->next;
+    }
+
+    if(item) {
+        // update the value and value_lengths
+        required = (int)(value_length - item->value_length);
+        cache->value_free(item->value);
+        item->value = value;
+        item->value_length = value_length;
+
+    }
+    else {
+        // insert a new item
+        item = lv_lru_pop_or_create_item(cache);
+        item->value = value;
+        item->key = malloc(key_length);
+        memcpy(item->key, key, key_length);
+        item->value_length = value_length;
+        item->key_length = key_length;
+        required = value_length;
+
+        if(prev)
+            prev->next = item;
+        else
+            cache->items[hash_index] = item;
+    }
+    item->access_count = ++cache->access_count;
+
+    // remove as many items as necessary to free enough space
+    if(required > 0 && required > cache->free_memory) {
+        while(cache->free_memory < required)
+            lv_lru_remove_lru_item(cache);
+    }
+    cache->free_memory -= required;
+    unlock_cache();
+    return LV_LRU_NO_ERROR;
+}
+
+
+lruc_error lv_lru_get(lv_lru_t * cache, const void * key, size_t key_size, void ** value)
+{
+    test_for_missing_cache();
+    test_for_missing_key();
+    lock_cache();
+
+    // loop until we find the item, or hit the end of a chain
+    uint32_t hash_index = lv_lru_hash(cache, key, key_size);
+    lruc_item * item = cache->items[hash_index];
+
+    while(item && lv_lru_cmp_keys(item, key, key_size))
+        item = (lruc_item *) item->next;
+
+    if(item) {
+        *value = item->value;
+        item->access_count = ++cache->access_count;
+    }
+    else {
+        *value = NULL;
+    }
+
+    unlock_cache();
+    return LV_LRU_NO_ERROR;
+}
+
+lruc_error lv_lru_delete(lv_lru_t * cache, const void * key, size_t key_size)
+{
+    test_for_missing_cache();
+    test_for_missing_key();
+    lock_cache();
+
+    // loop until we find the item, or hit the end of a chain
+    lruc_item * item = NULL, *prev = NULL;
+    uint32_t hash_index = lv_lru_hash(cache, key, key_size);
+    item = cache->items[hash_index];
+
+    while(item && lv_lru_cmp_keys(item, key, key_size)) {
+        prev = item;
+        item = (lruc_item *) item->next;
+    }
+
+    if(item) {
+        lv_lru_remove_item(cache, prev, item, hash_index);
+    }
+
+    unlock_cache();
+    return LV_LRU_NO_ERROR;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static uint32_t lv_lru_hash(lv_lru_t * cache, const void * key, uint32_t key_length)
+{
+    uint32_t m = 0x5bd1e995;
+    uint32_t r = 24;
+    uint32_t h = cache->seed ^ key_length;
+    char * data = (char *) key;
+
+    while(key_length >= 4) {
+        uint32_t k = *(uint32_t *) data;
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+        h *= m;
+        h ^= k;
+        data += 4;
+        key_length -= 4;
+    }
+
+    switch(key_length) {
+        case 3:
+            h ^= data[2] << 16;
+        case 2:
+            h ^= data[1] << 8;
+        case 1:
+            h ^= data[0];
+            h *= m;
+        break;
+    };
+
+    h ^= h >> 13;
+    h *= m;
+    h ^= h >> 15;
+    return h % cache->hash_table_size;
+}
+
+static int lv_lru_cmp_keys(lruc_item * item, const void * key, uint32_t key_length)
+{
+    if(key_length != item->key_length)
+        return 1;
+    else
+        return memcmp(key, item->key, key_length);
+}
+
+static void lv_lru_remove_item(lv_lru_t * cache, lruc_item * prev, lruc_item * item, uint32_t hash_index)
+{
+    if(prev)
+        prev->next = item->next;
+    else
+        cache->items[hash_index] = (lruc_item *) item->next;
+
+    // free memory and update the free memory counter
+    cache->free_memory += item->value_length;
+    cache->value_free(item->value);
+    cache->key_free(item->key);
+
+    // push the item to the free items queue
+    memset(item, 0, sizeof(lruc_item));
+    item->next = cache->free_items;
+    cache->free_items = item;
+}
+
+static void lv_lru_remove_lru_item(lv_lru_t * cache)
+{
+    lruc_item * min_item = NULL, *min_prev = NULL;
+    lruc_item * item = NULL, *prev = NULL;
+    uint32_t i = 0, min_index = -1;
+    uint64_t min_access_count = -1;
+
+    for(; i < cache->hash_table_size; i++) {
+        item = cache->items[i];
+        prev = NULL;
+
+        while(item) {
+            if(item->access_count < min_access_count || min_access_count == -1) {
+                min_access_count = item->access_count;
+                min_item = item;
+                min_prev = prev;
+                min_index = i;
+            }
+            prev = item;
+            item = item->next;
+        }
+    }
+
+    if(min_item)
+        lv_lru_remove_item(cache, min_prev, min_item, min_index);
+}
+
+static lruc_item * lv_lru_pop_or_create_item(lv_lru_t * cache)
+{
+    lruc_item * item = NULL;
+
+    if(cache->free_items) {
+        item = cache->free_items;
+        cache->free_items = item->next;
+        memset(item, 0, sizeof(lruc_item));
+    }
+    else {
+        item = (lruc_item *) calloc(sizeof(lruc_item), 1);
+    }
+
+    return item;
+}
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_lru.h b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_lru.h
new file mode 100644
index 000000000..a74e9eeac
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_lru.h
@@ -0,0 +1,90 @@
+/**
+ * @file lv_gpu_sdl_lru.h
+ *
+ */
+
+#ifndef LV_LRU_H
+#define LV_LRU_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include <stdint.h>
+#include <time.h>
+
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_LRU_NO_ERROR = 0,
+    LV_LRU_MISSING_CACHE,
+    LV_LRU_MISSING_KEY,
+    LV_LRU_MISSING_VALUE,
+    LV_LRU_LOCK_ERROR,
+    LV_LRU_VALUE_TOO_LARGE
+} lruc_error;
+
+typedef void (lv_lru_free_t)(void * v);
+
+typedef struct lruc_item {
+    void * value;
+    void * key;
+    size_t value_length;
+    size_t key_length;
+    uint64_t access_count;
+    struct lruc_item * next;
+} lruc_item;
+
+typedef struct {
+    lruc_item ** items;
+    uint64_t access_count;
+    uint64_t free_memory;
+    uint64_t total_memory;
+    uint64_t average_item_length;
+    uint32_t hash_table_size;
+    time_t seed;
+    lv_lru_free_t * value_free;
+    lv_lru_free_t * key_free;
+    lruc_item * free_items;
+    SDL_mutex * mutex;
+} lv_lru_t;
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_lru_t * lv_lru_new(uint64_t cache_size, uint32_t average_length, lv_lru_free_t * value_free,
+                      lv_lru_free_t * key_free);
+
+lruc_error lv_lru_free(lv_lru_t * cache);
+
+lruc_error lv_lru_set(lv_lru_t * cache, const void * key, size_t key_length, void * value, size_t value_length);
+
+lruc_error lv_lru_get(lv_lru_t * cache, const void * key, size_t key_size, void ** value);
+
+lruc_error lv_lru_delete(lv_lru_t * cache, const void * key, size_t key_size);
+
+/**********************
+ *      MACROS
+ **********************/
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_LRU_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_mask.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_mask.c
new file mode 100644
index 000000000..263c457c5
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_mask.c
@@ -0,0 +1,110 @@
+/**
+ * @file lv_gpu_sdl_mask.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "../../draw/lv_draw_mask.h"
+#include "../../misc/lv_mem.h"
+#include "lv_gpu_sdl_mask.h"
+#include "lv_gpu_sdl_utils.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+
+SDL_Surface * lv_sdl_create_mask_surface(lv_opa_t * pixels, lv_coord_t width, lv_coord_t height, lv_coord_t stride)
+{
+    SDL_Surface * indexed = SDL_CreateRGBSurfaceFrom(pixels, width, height, 8, stride, 0, 0, 0, 0);
+    SDL_SetSurfacePalette(indexed, lv_sdl_get_grayscale_palette(8));
+    SDL_Surface * converted = SDL_ConvertSurfaceFormat(indexed, SDL_PIXELFORMAT_ARGB8888, 0);
+    SDL_FreeSurface(indexed);
+    return converted;
+}
+
+SDL_Texture * lv_sdl_create_mask_texture(SDL_Renderer * renderer, lv_opa_t * pixels, lv_coord_t width,
+                                         lv_coord_t height, lv_coord_t stride)
+{
+    SDL_Surface * indexed = lv_sdl_create_mask_surface(pixels, width, height, stride);
+    SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, indexed);
+    SDL_FreeSurface(indexed);
+    return texture;
+}
+
+lv_opa_t * lv_draw_mask_dump(const lv_area_t * coords, const int16_t * ids, int16_t ids_count)
+{
+    SDL_assert(coords->x2 >= coords->x1);
+    SDL_assert(coords->y2 >= coords->y1);
+    lv_coord_t w = lv_area_get_width(coords), h = lv_area_get_height(coords);
+    lv_opa_t * mask_buf = lv_mem_buf_get(w * h);
+    for(lv_coord_t y = 0; y < h; y++) {
+        lv_opa_t * line_buf = &mask_buf[y * w];
+        lv_memset_ff(line_buf, w);
+        lv_coord_t abs_x = (lv_coord_t) coords->x1, abs_y = (lv_coord_t)(y + coords->y1), len = (lv_coord_t) w;
+        lv_draw_mask_res_t res;
+        if(ids) {
+            res = lv_draw_mask_apply_ids(line_buf, abs_x, abs_y, len, ids, ids_count);
+        }
+        else {
+            res = lv_draw_mask_apply(line_buf, abs_x, abs_y, len);
+        }
+        if(res == LV_DRAW_MASK_RES_TRANSP) {
+            lv_memset_00(line_buf, w);
+        }
+    }
+    return mask_buf;
+}
+
+SDL_Surface * lv_sdl_apply_mask_surface(const lv_area_t * coords, const int16_t * ids, int16_t ids_count)
+{
+    lv_coord_t w = lv_area_get_width(coords), h = lv_area_get_height(coords);
+
+    lv_opa_t * mask_buf = lv_draw_mask_dump(coords, ids, ids_count);
+    lv_mem_buf_release(mask_buf);
+    return lv_sdl_create_mask_surface(mask_buf, w, h, w);
+}
+
+SDL_Texture * lv_sdl_gen_mask_texture(SDL_Renderer * renderer, const lv_area_t * coords, const int16_t * ids,
+                                      int16_t ids_count)
+{
+    SDL_Surface * indexed = lv_sdl_apply_mask_surface(coords, ids, ids_count);
+    SDL_Texture * texture = SDL_CreateTextureFromSurface(renderer, indexed);
+    SDL_FreeSurface(indexed);
+    return texture;
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_mask.h b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_mask.h
new file mode 100644
index 000000000..6dbd73b7d
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_mask.h
@@ -0,0 +1,57 @@
+/**
+ * @file lv_gpu_sdl_mask.h
+ *
+ */
+
+#ifndef LV_GPU_SDL_MASK_H
+#define LV_GPU_SDL_MASK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+#include "../../misc/lv_area.h"
+#include "../../misc/lv_color.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+
+lv_opa_t * lv_draw_mask_dump(const lv_area_t * coords, const int16_t * ids, int16_t ids_count);
+
+SDL_Surface * lv_sdl_create_mask_surface(lv_opa_t * pixels, lv_coord_t width, lv_coord_t height, lv_coord_t stride);
+
+SDL_Texture * lv_sdl_create_mask_texture(SDL_Renderer * renderer, lv_opa_t * pixels, lv_coord_t width,
+                                         lv_coord_t height, lv_coord_t stride);
+
+SDL_Surface * lv_sdl_apply_mask_surface(const lv_area_t * coords, const int16_t * ids, int16_t ids_count);
+
+SDL_Texture *
+lv_sdl_gen_mask_texture(SDL_Renderer * renderer, const lv_area_t * coords, const int16_t * ids, int16_t ids_count);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_SDL_MASK_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_stack_blur.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_stack_blur.c
new file mode 100644
index 000000000..6d68294c9
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_stack_blur.c
@@ -0,0 +1,247 @@
+/**
+ * @file lv_gpu_sdl_stack_blur.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_gpu_sdl_stack_blur.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void
+stack_blur_job(lv_opa_t * src, unsigned int w, unsigned int h, unsigned int radius, int cores, int core, int step);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+// Based heavily on http://vitiy.info/Code/stackblur.cpp
+// See http://vitiy.info/stackblur-algorithm-multi-threaded-blur-for-cpp/
+// Stack Blur Algorithm by Mario Klingemann <mario@quasimondo.com>
+
+static unsigned short const stackblur_mul[255] = {
+    512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512,
+    454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292, 273, 512,
+    482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456,
+    437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512,
+    497, 482, 468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328,
+    320, 312, 305, 298, 291, 284, 278, 271, 265, 259, 507, 496, 485, 475, 465, 456,
+    446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347, 341, 335,
+    329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512,
+    505, 497, 489, 482, 475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405,
+    399, 394, 389, 383, 378, 373, 368, 364, 359, 354, 350, 345, 341, 337, 332, 328,
+    324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271,
+    268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456,
+    451, 446, 442, 437, 433, 428, 424, 420, 416, 412, 408, 404, 400, 396, 392, 388,
+    385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335,
+    332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292,
+    289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259
+};
+
+static unsigned char const stackblur_shr[255] = {
+    9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17,
+    17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19,
+    19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,
+    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24
+};
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_stack_blur_grayscale(lv_opa_t * buf, uint16_t w, uint16_t h, uint16_t r)
+{
+    stack_blur_job(buf, w, h, r, 1, 0, 1);
+    stack_blur_job(buf, w, h, r, 1, 0, 2);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void stack_blur_job(lv_opa_t * src, unsigned int w, unsigned int h, unsigned int radius, int cores, int core,
+                           int step)
+{
+    if(radius < 2 || radius > 254) {
+        /* Silently ignore bad radius */
+        return;
+    }
+
+    unsigned int x, y, xp, yp, i;
+    unsigned int sp;
+    unsigned int stack_start;
+    unsigned char * stack_ptr;
+
+    lv_opa_t * src_ptr;
+    lv_opa_t * dst_ptr;
+
+    unsigned long sum_r;
+    unsigned long sum_in_r;
+    unsigned long sum_out_r;
+
+    unsigned int wm = w - 1;
+    unsigned int hm = h - 1;
+    unsigned int stride = w;
+    unsigned int div = (radius * 2) + 1;
+    unsigned int mul_sum = stackblur_mul[radius];
+    unsigned char shr_sum = stackblur_shr[radius];
+    unsigned char stack[254 * 2 + 1];
+
+    if(step == 1) {
+        unsigned int minY = core * h / cores;
+        unsigned int maxY = (core + 1) * h / cores;
+
+        for(y = minY; y < maxY; y++) {
+            sum_r =
+                sum_in_r =
+                    sum_out_r = 0;
+
+            src_ptr = src + stride * y; // start of line (0,y)
+
+            for(i = 0; i <= radius; i++) {
+                stack_ptr = &stack[i];
+                stack_ptr[0] = src_ptr[0];
+                sum_r += src_ptr[0] * (i + 1);
+                sum_out_r += src_ptr[0];
+            }
+
+
+            for(i = 1; i <= radius; i++) {
+                if(i <= wm) src_ptr += 1;
+                stack_ptr = &stack[i + radius];
+                stack_ptr[0] = src_ptr[0];
+                sum_r += src_ptr[0] * (radius + 1 - i);
+                sum_in_r += src_ptr[0];
+            }
+
+
+            sp = radius;
+            xp = radius;
+            if(xp > wm) xp = wm;
+            src_ptr = src + (xp + y * w); //   img.pix_ptr(xp, y);
+            dst_ptr = src + y * stride; // img.pix_ptr(0, y);
+            for(x = 0; x < w; x++) {
+                dst_ptr[0] = LV_CLAMP((sum_r * mul_sum) >> shr_sum, 0, 255);
+                dst_ptr += 1;
+
+                sum_r -= sum_out_r;
+
+                stack_start = sp + div - radius;
+                if(stack_start >= div) stack_start -= div;
+                stack_ptr = &stack[stack_start];
+
+                sum_out_r -= stack_ptr[0];
+
+                if(xp < wm) {
+                    src_ptr += 1;
+                    ++xp;
+                }
+
+                stack_ptr[0] = src_ptr[0];
+
+                sum_in_r += src_ptr[0];
+                sum_r += sum_in_r;
+
+                ++sp;
+                if(sp >= div) sp = 0;
+                stack_ptr = &stack[sp];
+
+                sum_out_r += stack_ptr[0];
+                sum_in_r -= stack_ptr[0];
+            }
+
+        }
+    }
+
+    // step 2
+    if(step == 2) {
+        unsigned int minX = core * w / cores;
+        unsigned int maxX = (core + 1) * w / cores;
+
+        for(x = minX; x < maxX; x++) {
+            sum_r =
+                sum_in_r =
+                    sum_out_r = 0;
+
+            src_ptr = src + x; // x,0
+            for(i = 0; i <= radius; i++) {
+                stack_ptr = &stack[i];
+                stack_ptr[0] = src_ptr[0];
+                sum_r += src_ptr[0] * (i + 1);
+                sum_out_r += src_ptr[0];
+            }
+            for(i = 1; i <= radius; i++) {
+                if(i <= hm) src_ptr += stride;  // +stride
+
+                stack_ptr = &stack[i + radius];
+                stack_ptr[0] = src_ptr[0];
+                sum_r += src_ptr[0] * (radius + 1 - i);
+                sum_in_r += src_ptr[0];
+            }
+
+            sp = radius;
+            yp = radius;
+            if(yp > hm) yp = hm;
+            src_ptr = src + (x + yp * w); // img.pix_ptr(x, yp);
+            dst_ptr = src + x;               // img.pix_ptr(x, 0);
+            for(y = 0; y < h; y++) {
+                dst_ptr[0] = LV_CLAMP((sum_r * mul_sum) >> shr_sum, 0, 255);
+                dst_ptr += stride;
+
+                sum_r -= sum_out_r;
+
+                stack_start = sp + div - radius;
+                if(stack_start >= div) stack_start -= div;
+                stack_ptr = &stack[stack_start];
+
+                sum_out_r -= stack_ptr[0];
+
+                if(yp < hm) {
+                    src_ptr += stride; // stride
+                    ++yp;
+                }
+
+                stack_ptr[0] = src_ptr[0];
+
+                sum_in_r += src_ptr[0];
+                sum_r += sum_in_r;
+
+                ++sp;
+                if(sp >= div) sp = 0;
+                stack_ptr = &stack[sp];
+
+                sum_out_r += stack_ptr[0];
+                sum_in_r -= stack_ptr[0];
+            }
+        }
+    }
+}
+
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_stack_blur.h b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_stack_blur.h
new file mode 100644
index 000000000..5e13192a1
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_stack_blur.h
@@ -0,0 +1,42 @@
+/**
+ * @file lv_gpu_sdl_stack_blur.h
+ *
+ */
+#ifndef LV_GPU_SDL_STACK_BLUR_H
+#define LV_GPU_SDL_STACK_BLUR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#include "../../misc/lv_color.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_stack_blur_grayscale(lv_opa_t * buf, uint16_t w, uint16_t h, uint16_t r);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_SDL_STACK_BLUR_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_texture_cache.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_texture_cache.c
new file mode 100644
index 000000000..96f7d2d5a
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_texture_cache.c
@@ -0,0 +1,197 @@
+/**
+ * @file lv_gpu_sdl_texture_cache.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "lv_gpu_sdl_texture_cache.h"
+
+#include "../../misc/lv_log.h"
+#include "../../draw/lv_draw_label.h"
+#include "../../draw/lv_draw_img.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    SDL_Texture * texture;
+    void * userdata;
+    lv_lru_free_t * userdata_free;
+    lv_gpu_sdl_cache_flag_t flags;
+} draw_cache_value_t;
+
+typedef struct {
+    lv_gpu_cache_key_magic_t magic;
+} temp_texture_key_t;
+
+typedef struct {
+    lv_coord_t width, height;
+} temp_texture_userdata_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void draw_cache_free_value(draw_cache_value_t *);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+static lv_lru_t * lv_sdl_texture_cache;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void _lv_gpu_sdl_texture_cache_init()
+{
+    lv_sdl_texture_cache = lv_lru_new(1024 * 1024 * 8, 65536, (lv_lru_free_t *) draw_cache_free_value,
+                                      NULL);
+}
+
+void _lv_gpu_sdl_texture_cache_deinit()
+{
+    lv_lru_free(lv_sdl_texture_cache);
+}
+
+SDL_Texture * lv_gpu_draw_cache_get(const void * key, size_t key_length, bool * found)
+{
+    return lv_gpu_draw_cache_get_with_userdata(key, key_length, found, NULL);
+}
+
+SDL_Texture * lv_gpu_draw_cache_get_with_userdata(const void * key, size_t key_length, bool * found, void ** userdata)
+{
+    draw_cache_value_t * value = NULL;
+    lv_lru_get(lv_sdl_texture_cache, key, key_length, (void **) &value);
+    if(!value) {
+        if(found) {
+            *found = false;
+        }
+        return NULL;
+    }
+    else {
+        if(userdata) {
+            *userdata = value->userdata;
+        }
+    }
+    if(found) {
+        *found = true;
+    }
+    return value->texture;
+}
+
+void lv_gpu_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture)
+{
+    lv_gpu_draw_cache_put_advanced(key, key_length, texture, NULL, NULL, 0);
+}
+
+void lv_gpu_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
+                                    lv_lru_free_t userdata_free, lv_gpu_sdl_cache_flag_t flags)
+{
+    draw_cache_value_t * value = SDL_malloc(sizeof(draw_cache_value_t));
+    value->texture = texture;
+    value->userdata = userdata;
+    value->userdata_free = userdata_free;
+    value->flags = flags;
+    if(!texture) {
+        lv_lru_set(lv_sdl_texture_cache, key, key_length, value, 1);
+        return;
+    }
+    if(flags & LV_GPU_SDL_CACHE_FLAG_MANAGED) {
+        /* Managed texture doesn't count into cache size */
+        LV_LOG_INFO("cache texture %p, %d*%d@%dbpp", texture, width, height, SDL_BITSPERPIXEL(format));
+        lv_lru_set(lv_sdl_texture_cache, key, key_length, value, 1);
+        return;
+    }
+    Uint32 format;
+    int access, width, height;
+    if(SDL_QueryTexture(texture, &format, &access, &width, &height) != 0) {
+        return;
+    }
+    LV_LOG_INFO("cache texture %p, %d*%d@%dbpp", texture, width, height, SDL_BITSPERPIXEL(format));
+    lv_lru_set(lv_sdl_texture_cache, key, key_length, value, width * height * SDL_BITSPERPIXEL(format) / 8);
+}
+
+SDL_Texture * lv_gpu_temp_texture_obtain(SDL_Renderer * renderer, lv_coord_t width, lv_coord_t height)
+{
+    temp_texture_key_t key;
+    SDL_memset(&key, 0, sizeof(key));
+    key.magic = LV_GPU_CACHE_KEY_TEMP;
+    temp_texture_userdata_t * userdata = NULL;
+    SDL_Texture * texture = lv_gpu_draw_cache_get_with_userdata(&key, sizeof(key), NULL, (void **) &userdata);
+    if(texture && userdata->width >= width && userdata->height >= height) {
+        return texture;
+    }
+    texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, width, height);
+    userdata = SDL_malloc(sizeof(temp_texture_userdata_t));
+    userdata->width = width;
+    userdata->height = height;
+    lv_gpu_draw_cache_put_advanced(&key, sizeof(key), texture, userdata, SDL_free, 0);
+    return texture;
+}
+
+lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size)
+{
+    lv_gpu_sdl_cache_key_head_img_t header;
+    /* VERY IMPORTANT! Padding between members is uninitialized, so we have to wipe them manually */
+    SDL_memset(&header, 0, sizeof(header));
+    header.magic = LV_GPU_CACHE_KEY_MAGIC_IMG;
+    header.type = lv_img_src_get_type(src);
+    header.frame_id = frame_id;
+    void * key;
+    size_t key_size;
+    if(header.type == LV_IMG_SRC_FILE || header.type == LV_IMG_SRC_SYMBOL) {
+        size_t srclen = SDL_strlen(src);
+        key_size = sizeof(header) + srclen;
+        key = SDL_malloc(key_size);
+        SDL_memcpy(key, &header, sizeof(header));
+        /*Copy string content as key value*/
+        SDL_memcpy(key + sizeof(header), src, srclen);
+    }
+    else {
+        key_size = sizeof(header) + sizeof(void *);
+        key = SDL_malloc(key_size);
+        SDL_memcpy(key, &header, sizeof(header));
+        /*Copy address number as key value*/
+        SDL_memcpy(key + sizeof(header), &src, sizeof(void *));
+    }
+    *size = key_size;
+    return (lv_gpu_sdl_cache_key_head_img_t *) key;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void draw_cache_free_value(draw_cache_value_t * value)
+{
+    if(value->texture && !(value->flags & LV_GPU_SDL_CACHE_FLAG_MANAGED)) {
+        LV_LOG_INFO("destroy texture %p", value->texture);
+        SDL_DestroyTexture(value->texture);
+    }
+    if(value->userdata_free) {
+        value->userdata_free(value->userdata);
+    }
+    SDL_free(value);
+}
+
+
+#endif /*LV_USE_GPU_SDL*/
+
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_texture_cache.h b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_texture_cache.h
new file mode 100644
index 000000000..5a20d542d
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_texture_cache.h
@@ -0,0 +1,90 @@
+/**
+ * @file lv_gpu_sdl_texture_cache.h
+ *
+ */
+
+#ifndef LV_GPU_SDL_TEXTURE_CACHE_H
+#define LV_GPU_SDL_TEXTURE_CACHE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+#include "../../draw/lv_img_decoder.h"
+#include "../../misc/lv_area.h"
+#include "lv_gpu_sdl_lru.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#define LV_GPU_SDL_DEC_DSC_TEXTURE_HEAD "@LVSDLTex"
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    char head[8];
+    SDL_Texture * texture;
+} lv_gpu_sdl_dec_dsc_userdata_t;
+
+typedef enum {
+    LV_GPU_CACHE_KEY_MAGIC_ARC = 0x01,
+    LV_GPU_CACHE_KEY_MAGIC_IMG = 0x11,
+    LV_GPU_CACHE_KEY_MAGIC_LINE = 0x21,
+    LV_GPU_CACHE_KEY_MAGIC_RECT_BG = 0x31,
+    LV_GPU_CACHE_KEY_MAGIC_RECT_SHADOW = 0x32,
+    LV_GPU_CACHE_KEY_MAGIC_RECT_BORDER = 0x33,
+    LV_GPU_CACHE_KEY_MAGIC_FONT = 0x41,
+    LV_GPU_CACHE_KEY_TEMP = 0xFF,
+} lv_gpu_cache_key_magic_t;
+
+typedef enum {
+    LV_GPU_SDL_CACHE_FLAG_NONE = 0,
+    LV_GPU_SDL_CACHE_FLAG_MANAGED = 1,
+} lv_gpu_sdl_cache_flag_t;
+
+typedef struct {
+    lv_gpu_cache_key_magic_t magic;
+    lv_img_src_t type;
+    int32_t frame_id;
+} lv_gpu_sdl_cache_key_head_img_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void _lv_gpu_sdl_texture_cache_init();
+
+void _lv_gpu_sdl_texture_cache_deinit();
+
+SDL_Texture * lv_gpu_draw_cache_get(const void * key, size_t key_length, bool * found);
+
+SDL_Texture * lv_gpu_draw_cache_get_with_userdata(const void * key, size_t key_length, bool * found, void ** userdata);
+
+void lv_gpu_draw_cache_put(const void * key, size_t key_length, SDL_Texture * texture);
+
+void lv_gpu_draw_cache_put_advanced(const void * key, size_t key_length, SDL_Texture * texture, void * userdata,
+                                    lv_lru_free_t userdata_free, lv_gpu_sdl_cache_flag_t flags);
+
+SDL_Texture * lv_gpu_temp_texture_obtain(SDL_Renderer * renderer, lv_coord_t width, lv_coord_t height);
+
+lv_gpu_sdl_cache_key_head_img_t * lv_gpu_sdl_img_cache_key_create(const void * src, int32_t frame_id, size_t * size);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_SDL_TEXTURE_CACHE_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_utils.c b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_utils.c
new file mode 100644
index 000000000..d6486014a
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_utils.c
@@ -0,0 +1,179 @@
+/**
+ * @file lv_gpu_sdl_utils.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../lv_conf_internal.h"
+
+#if LV_USE_GPU_SDL
+
+#include "lv_gpu_sdl_utils.h"
+
+#include "../../draw/lv_draw_label.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+static SDL_Palette * lv_sdl_palette_grayscale1 = NULL;
+static SDL_Palette * lv_sdl_palette_grayscale2 = NULL;
+static SDL_Palette * lv_sdl_palette_grayscale3 = NULL;
+static SDL_Palette * lv_sdl_palette_grayscale4 = NULL;
+static SDL_Palette * lv_sdl_palette_grayscale8 = NULL;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void _lv_gpu_sdl_utils_init()
+{
+    lv_sdl_palette_grayscale1 = lv_sdl_alloc_palette_for_bpp(_lv_bpp1_opa_table, 1);
+    lv_sdl_palette_grayscale2 = lv_sdl_alloc_palette_for_bpp(_lv_bpp2_opa_table, 2);
+    lv_sdl_palette_grayscale3 = lv_sdl_alloc_palette_for_bpp(_lv_bpp3_opa_table, 3);
+    lv_sdl_palette_grayscale4 = lv_sdl_alloc_palette_for_bpp(_lv_bpp4_opa_table, 4);
+    lv_sdl_palette_grayscale8 = lv_sdl_alloc_palette_for_bpp(_lv_bpp8_opa_table, 8);
+}
+
+void _lv_gpu_sdl_utils_deinit()
+{
+    SDL_FreePalette(lv_sdl_palette_grayscale1);
+    SDL_FreePalette(lv_sdl_palette_grayscale2);
+    SDL_FreePalette(lv_sdl_palette_grayscale3);
+    SDL_FreePalette(lv_sdl_palette_grayscale4);
+    SDL_FreePalette(lv_sdl_palette_grayscale8);
+}
+
+void lv_area_to_sdl_rect(const lv_area_t * in, SDL_Rect * out)
+{
+    out->x = in->x1;
+    out->y = in->y1;
+    out->w = in->x2 - in->x1 + 1;
+    out->h = in->y2 - in->y1 + 1;
+}
+
+void lv_color_to_sdl_color(const lv_color_t * in, SDL_Color * out)
+{
+    uint32_t color32 = lv_color_to32(*in);
+    lv_color32_t * color32_t = (lv_color32_t *) &color32;
+    out->a = color32_t->ch.alpha;
+    out->r = color32_t->ch.red;
+    out->g = color32_t->ch.green;
+    out->b = color32_t->ch.blue;
+}
+
+void lv_area_zoom_to_sdl_rect(const lv_area_t * in, SDL_Rect * out, uint16_t zoom, const lv_point_t * pivot)
+{
+    if(zoom == LV_IMG_ZOOM_NONE) {
+        lv_area_to_sdl_rect(in, out);
+        return;
+    }
+    int h = in->y2 - in->y1 + 1;
+    int w = in->x2 - in->x1 + 1;
+    int sh = h * zoom >> 8;
+    int sw = w * zoom >> 8;
+    out->x = in->x1 - (sw / 2 - pivot->x);
+    out->y = in->y1 - (sh / 2 - pivot->y);
+    out->w = sw;
+    out->h = sh;
+}
+
+double lv_sdl_round(double d)
+{
+    return (d - (long) d) < 0.5 ? SDL_floor(d) : SDL_ceil(d);
+}
+
+SDL_Palette * lv_sdl_alloc_palette_for_bpp(const uint8_t * mapping, uint8_t bpp)
+{
+    SDL_assert(bpp >= 1 && bpp <= 8);
+    int color_cnt = 1 << bpp;
+    SDL_Palette * result = SDL_AllocPalette(color_cnt);
+    SDL_Color palette[256];
+    for(int i = 0; i < color_cnt; i++) {
+        palette[i].r = palette[i].g = palette[i].b = 0xFF;
+        palette[i].a = mapping ? mapping[i] : i;
+    }
+    SDL_SetPaletteColors(result, palette, 0, color_cnt);
+    return result;
+}
+
+SDL_Palette * lv_sdl_get_grayscale_palette(uint8_t bpp)
+{
+    switch(bpp) {
+        case 1:
+            return lv_sdl_palette_grayscale1;
+        case 2:
+            return lv_sdl_palette_grayscale2;
+        case 3:
+            return lv_sdl_palette_grayscale3;
+        case 4:
+            return lv_sdl_palette_grayscale4;
+        case 8:
+            return lv_sdl_palette_grayscale8;
+    }
+    return NULL;
+}
+
+void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, int stride, uint8_t bpp)
+{
+    int src_len = width * height;
+    int cur = 0;
+    int curbit;
+    uint8_t opa_mask;
+    const uint8_t * opa_table;
+    switch(bpp) {
+        case 1:
+            opa_mask = 0x1;
+            opa_table = _lv_bpp1_opa_table;
+            break;
+        case 2:
+            opa_mask = 0x4;
+            opa_table = _lv_bpp2_opa_table;
+            break;
+        case 4:
+            opa_mask = 0xF;
+            opa_table = _lv_bpp4_opa_table;
+            break;
+        case 8:
+            opa_mask = 0xFF;
+            opa_table = _lv_bpp8_opa_table;
+            break;
+        default:
+            return;
+    }
+    /* Does this work well on big endian systems? */
+    while(cur < src_len) {
+        curbit = 8 - bpp;
+        uint8_t src_byte = src[cur * bpp / 8];
+        while(curbit >= 0) {
+            uint8_t src_bits = opa_mask & (src_byte >> curbit);
+            dest[(cur / width * stride) + (cur % width)] = opa_table[src_bits];
+            curbit -= bpp;
+            cur++;
+        }
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /*LV_USE_GPU_SDL*/
diff --git a/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_utils.h b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_utils.h
new file mode 100644
index 000000000..c2daeb79b
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/gpu/sdl/lv_gpu_sdl_utils.h
@@ -0,0 +1,61 @@
+/**
+ * @file lv_gpu_sdl_utils.h
+ *
+ */
+#ifndef LV_GPU_SDL_UTILS_H
+#define LV_GPU_SDL_UTILS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../../lv_conf_internal.h"
+
+#include "../../misc/lv_color.h"
+#include "../../misc/lv_area.h"
+
+#include LV_GPU_SDL_INCLUDE_PATH
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void _lv_gpu_sdl_utils_init();
+
+void _lv_gpu_sdl_utils_deinit();
+
+void lv_area_to_sdl_rect(const lv_area_t * in, SDL_Rect * out);
+
+void lv_color_to_sdl_color(const lv_color_t * in, SDL_Color * out);
+
+void lv_area_zoom_to_sdl_rect(const lv_area_t * in, SDL_Rect * out, uint16_t zoom, const lv_point_t * pivot);
+
+double lv_sdl_round(double d);
+
+SDL_Palette * lv_sdl_alloc_palette_for_bpp(const uint8_t * mapping, uint8_t bpp);
+
+SDL_Palette * lv_sdl_get_grayscale_palette(uint8_t bpp);
+
+void lv_sdl_to_8bpp(uint8_t * dest, const uint8_t * src, int width, int height, int stride, uint8_t bpp);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_GPU_SDL_UTILS_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_disp.c b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_disp.c
index dc658c035..43b7f4367 100644
--- a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_disp.c
+++ b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_disp.c
@@ -18,7 +18,7 @@
 #include "../core/lv_refr.h"
 #include "../core/lv_theme.h"
 #if LV_USE_THEME_DEFAULT
-#include "../extra/themes/default/lv_theme_default.h"
+    #include "../extra/themes/default/lv_theme_default.h"
 #endif
 
 /*********************
@@ -34,6 +34,24 @@
  **********************/
 static lv_obj_tree_walk_res_t invalidate_layout_cb(lv_obj_t * obj, void * user_data);
 
+static void set_px_true_color_alpha(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x,
+                                    lv_coord_t y,
+                                    lv_color_t color, lv_opa_t opa);
+
+static void set_px_cb_alpha1(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
+                             lv_color_t color, lv_opa_t opa);
+
+static void set_px_cb_alpha2(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
+                             lv_color_t color, lv_opa_t opa);
+
+static void set_px_cb_alpha4(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
+                             lv_color_t color, lv_opa_t opa);
+
+static void set_px_cb_alpha8(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
+                             lv_color_t color, lv_opa_t opa);
+
+static void set_px_alpha_generic(lv_img_dsc_t * d, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa);
+
 /**********************
  *  STATIC VARIABLES
  **********************/
@@ -59,7 +77,11 @@ void lv_disp_drv_init(lv_disp_drv_t * driver)
 
     driver->hor_res          = 320;
     driver->ver_res          = 240;
-    driver->antialiasing     = LV_COLOR_DEPTH > 8 ? 1: 0;
+    driver->physical_hor_res = -1;
+    driver->physical_ver_res = -1;
+    driver->offset_x         = 0;
+    driver->offset_y         = 0;
+    driver->antialiasing     = LV_COLOR_DEPTH > 8 ? 1 : 0;
     driver->screen_transp    = LV_COLOR_SCREEN_TRANSP;
     driver->dpi              = LV_DPI_DEF;
     driver->color_chroma_key = LV_COLOR_CHROMA_KEY;
@@ -121,7 +143,7 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
 
     if(driver->full_refresh && driver->draw_buf->size < (uint32_t)driver->hor_res * driver->ver_res) {
         driver->full_refresh = 0;
-        LV_LOG_WARN("full_refresh requires at least screen sized draw buffer(s)")
+        LV_LOG_WARN("full_refresh requires at least screen sized draw buffer(s)");
     }
 
     disp->bg_color = lv_color_white();
@@ -133,7 +155,10 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
 
 #if LV_USE_THEME_DEFAULT
     if(lv_theme_default_is_inited() == false) {
-        disp->theme = lv_theme_default_init(disp, lv_palette_main(LV_PALETTE_BLUE), lv_palette_main(LV_PALETTE_RED), LV_THEME_DEFAULT_DARK, LV_FONT_DEFAULT);
+        disp->theme = lv_theme_default_init(disp, lv_palette_main(LV_PALETTE_BLUE), lv_palette_main(LV_PALETTE_RED),
+                                            LV_THEME_DEFAULT_DARK, LV_FONT_DEFAULT);
+    } else {
+        disp->theme = lv_theme_default_get();
     }
 #endif
 
@@ -167,9 +192,10 @@ void lv_disp_drv_update(lv_disp_t * disp, lv_disp_drv_t * new_drv)
 {
     disp->driver = new_drv;
 
-    if(disp->driver->full_refresh && disp->driver->draw_buf->size < (uint32_t)disp->driver->hor_res * disp->driver->ver_res) {
+    if(disp->driver->full_refresh &&
+       disp->driver->draw_buf->size < (uint32_t)disp->driver->hor_res * disp->driver->ver_res) {
         disp->driver->full_refresh = 0;
-        LV_LOG_WARN("full_refresh requires at least screen sized draw buffer(s)")
+        LV_LOG_WARN("full_refresh requires at least screen sized draw buffer(s)");
     }
 
     lv_coord_t w = lv_disp_get_hor_res(disp);
@@ -218,22 +244,22 @@ void lv_disp_remove(lv_disp_t * disp)
         indev = lv_indev_get_next(indev);
     }
 
-    _lv_ll_remove(&LV_GC_ROOT(_lv_disp_ll), disp);
-    lv_timer_del(disp->refr_timer);
-
     /** delete screen and other obj */
-    if (disp->sys_layer) {
+    if(disp->sys_layer) {
         lv_obj_del(disp->sys_layer);
         disp->sys_layer = NULL;
     }
-    if (disp->top_layer) {
+    if(disp->top_layer) {
         lv_obj_del(disp->top_layer);
         disp->top_layer = NULL;
     }
-    while (disp->screen_cnt != 0) {
+    while(disp->screen_cnt != 0) {
         /*Delete the screenst*/
         lv_obj_del(disp->screens[0]);
     }
+
+    _lv_ll_remove(&LV_GC_ROOT(_lv_disp_ll), disp);
+    lv_timer_del(disp->refr_timer);
     lv_mem_free(disp);
 
     if(was_default) lv_disp_set_default(_lv_ll_get_head(&LV_GC_ROOT(_lv_disp_ll)));
@@ -268,7 +294,8 @@ lv_coord_t lv_disp_get_hor_res(lv_disp_t * disp)
 
     if(disp == NULL) {
         return 0;
-    } else {
+    }
+    else {
         switch(disp->driver->rotated) {
             case LV_DISP_ROT_90:
             case LV_DISP_ROT_270:
@@ -290,7 +317,8 @@ lv_coord_t lv_disp_get_ver_res(lv_disp_t * disp)
 
     if(disp == NULL) {
         return 0;
-    } else {
+    }
+    else {
         switch(disp->driver->rotated) {
             case LV_DISP_ROT_90:
             case LV_DISP_ROT_270:
@@ -301,6 +329,104 @@ lv_coord_t lv_disp_get_ver_res(lv_disp_t * disp)
     }
 }
 
+/**
+ * Get the full / physical horizontal resolution of a display
+ * @param disp pointer to a display (NULL to use the default display)
+ * @return the full / physical horizontal resolution of the display
+ */
+lv_coord_t lv_disp_get_physical_hor_res(lv_disp_t * disp)
+{
+    if(disp == NULL) disp = lv_disp_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->driver->rotated) {
+            case LV_DISP_ROT_90:
+            case LV_DISP_ROT_270:
+                return disp->driver->physical_ver_res > 0 ? disp->driver->physical_ver_res : disp->driver->ver_res;
+            default:
+                return disp->driver->physical_hor_res > 0 ? disp->driver->physical_hor_res : disp->driver->hor_res;
+        }
+    }
+}
+
+/**
+ * Get the full / physical vertical resolution of a display
+ * @param disp pointer to a display (NULL to use the default display)
+ * @return the full / physical vertical resolution of the display
+ */
+lv_coord_t lv_disp_get_physical_ver_res(lv_disp_t * disp)
+{
+    if(disp == NULL) disp = lv_disp_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->driver->rotated) {
+            case LV_DISP_ROT_90:
+            case LV_DISP_ROT_270:
+                return disp->driver->physical_hor_res > 0 ? disp->driver->physical_hor_res : disp->driver->hor_res;
+            default:
+                return disp->driver->physical_ver_res > 0 ? disp->driver->physical_ver_res : disp->driver->ver_res;
+        }
+    }
+}
+
+/**
+ * Get the horizontal offset from the full / physical display
+ * @param disp pointer to a display (NULL to use the default display)
+ * @return the horizontal offset from the full / physical display
+ */
+lv_coord_t lv_disp_get_offset_x(lv_disp_t * disp)
+{
+    if(disp == NULL) disp = lv_disp_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->driver->rotated) {
+            case LV_DISP_ROT_90:
+                return disp->driver->offset_y;
+            case LV_DISP_ROT_180:
+                return lv_disp_get_physical_hor_res(disp) - disp->driver->offset_x;
+            case LV_DISP_ROT_270:
+                return lv_disp_get_physical_hor_res(disp) - disp->driver->offset_y;
+            default:
+                return disp->driver->offset_x;
+        }
+    }
+}
+
+/**
+ * Get the vertical offset from the full / physical display
+ * @param disp pointer to a display (NULL to use the default display)
+ * @return the horizontal offset from the full / physical display
+ */
+lv_coord_t lv_disp_get_offset_y(lv_disp_t * disp)
+{
+    if(disp == NULL) disp = lv_disp_get_default();
+
+    if(disp == NULL) {
+        return 0;
+    }
+    else {
+        switch(disp->driver->rotated) {
+            case LV_DISP_ROT_90:
+                return disp->driver->offset_x;
+            case LV_DISP_ROT_180:
+                return lv_disp_get_physical_ver_res(disp) - disp->driver->offset_y;
+            case LV_DISP_ROT_270:
+                return lv_disp_get_physical_ver_res(disp) - disp->driver->offset_x;
+            default:
+                return disp->driver->offset_y;
+        }
+    }
+}
+
 /**
  * Get if anti-aliasing is enabled for a display or not
  * @param disp pointer to a display (NULL to use the default display)
@@ -403,6 +529,29 @@ lv_disp_rot_t lv_disp_get_rotation(lv_disp_t * disp)
     return disp->driver->rotated;
 }
 
+void lv_disp_drv_use_generic_set_px_cb(lv_disp_drv_t * disp_drv, lv_img_cf_t cf)
+{
+    switch(cf) {
+        case LV_IMG_CF_TRUE_COLOR_ALPHA:
+            disp_drv->set_px_cb = set_px_true_color_alpha;
+            break;
+        case LV_IMG_CF_ALPHA_1BIT:
+            disp_drv->set_px_cb = set_px_cb_alpha1;
+            break;
+        case LV_IMG_CF_ALPHA_2BIT:
+            disp_drv->set_px_cb = set_px_cb_alpha2;
+            break;
+        case LV_IMG_CF_ALPHA_4BIT:
+            disp_drv->set_px_cb = set_px_cb_alpha4;
+            break;
+        case LV_IMG_CF_ALPHA_8BIT:
+            disp_drv->set_px_cb = set_px_cb_alpha8;
+            break;
+        default:
+            disp_drv->set_px_cb = NULL;
+    }
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -413,3 +562,99 @@ static lv_obj_tree_walk_res_t invalidate_layout_cb(lv_obj_t * obj, void * user_d
     lv_obj_mark_layout_as_dirty(obj);
     return LV_OBJ_TREE_WALK_NEXT;
 }
+
+static void set_px_cb_alpha1(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
+                             lv_color_t color, lv_opa_t opa)
+{
+    (void) disp_drv; /*Unused*/
+
+    if(opa <= LV_OPA_MIN) return;
+    lv_img_dsc_t d;
+    d.data = buf;
+    d.header.w = buf_w;
+    d.header.cf = LV_IMG_CF_ALPHA_1BIT;
+
+    set_px_alpha_generic(&d, x, y, color, opa);
+}
+
+static void set_px_cb_alpha2(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
+                             lv_color_t color, lv_opa_t opa)
+{
+    (void) disp_drv; /*Unused*/
+
+    if(opa <= LV_OPA_MIN) return;
+    lv_img_dsc_t d;
+    d.data = buf;
+    d.header.w = buf_w;
+    d.header.cf = LV_IMG_CF_ALPHA_2BIT;
+
+    set_px_alpha_generic(&d, x, y, color, opa);
+}
+
+static void set_px_cb_alpha4(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
+                             lv_color_t color, lv_opa_t opa)
+{
+    (void) disp_drv; /*Unused*/
+
+    if(opa <= LV_OPA_MIN) return;
+    lv_img_dsc_t d;
+    d.data = buf;
+    d.header.w = buf_w;
+    d.header.cf = LV_IMG_CF_ALPHA_4BIT;
+
+    set_px_alpha_generic(&d, x, y, color, opa);
+}
+
+static void set_px_cb_alpha8(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
+                             lv_color_t color, lv_opa_t opa)
+{
+    (void) disp_drv; /*Unused*/
+
+    if(opa <= LV_OPA_MIN) return;
+    lv_img_dsc_t d;
+    d.data = buf;
+    d.header.w = buf_w;
+    d.header.cf = LV_IMG_CF_ALPHA_8BIT;
+
+    set_px_alpha_generic(&d, x, y, color, opa);
+}
+
+static void set_px_alpha_generic(lv_img_dsc_t * d, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa)
+{
+    d->header.always_zero = 0;
+    d->header.h = 1;    /*Doesn't matter*/
+
+    uint8_t br = lv_color_brightness(color);
+    if(opa < LV_OPA_MAX) {
+        uint8_t bg = lv_img_buf_get_px_alpha(d, x, y);
+        br = (uint16_t)((uint16_t)br * opa + (bg * (255 - opa))) >> 8;
+    }
+
+    lv_img_buf_set_px_alpha(d, x, y, br);
+}
+
+static void set_px_true_color_alpha(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x,
+                                    lv_coord_t y,
+                                    lv_color_t color, lv_opa_t opa)
+{
+    (void) disp_drv; /*Unused*/
+
+    if(opa <= LV_OPA_MIN) return;
+    lv_img_dsc_t d;
+    d.data = buf;
+    d.header.always_zero = 0;
+    d.header.h = 1;    /*Doesn't matter*/;
+    d.header.w = buf_w;
+    d.header.cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
+
+    lv_color_t bg_color = lv_img_buf_get_px_color(&d, x, y, lv_color_black());
+    lv_opa_t bg_opa = lv_img_buf_get_px_alpha(&d, x, y);
+
+    lv_opa_t res_opa;
+    lv_color_t res_color;
+
+    lv_color_mix_with_alpha(bg_color, bg_opa, color, opa, &res_color, &res_opa);
+
+    lv_img_buf_set_px_alpha(&d, x, y, res_opa);
+    lv_img_buf_set_px_color(&d, x, y, res_color);
+}
diff --git a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_disp.h b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_disp.h
index 9a6315320..3626a34ef 100644
--- a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_disp.h
+++ b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_disp.h
@@ -18,6 +18,7 @@ extern "C" {
 #include <stdint.h>
 #include <stdbool.h>
 #include "lv_hal.h"
+#include "../draw/lv_img_buf.h"
 #include "../misc/lv_color.h"
 #include "../misc/lv_area.h"
 #include "../misc/lv_ll.h"
@@ -46,7 +47,7 @@ struct _lv_theme_t;
 /**
  * Structure for holding display buffer information.
  */
-typedef struct _lv_disp_draw_buf_t{
+typedef struct _lv_disp_draw_buf_t {
     void * buf1; /**< First display buffer.*/
     void * buf2; /**< Second display buffer.*/
 
@@ -79,10 +80,16 @@ typedef struct _lv_disp_drv_t {
     lv_coord_t hor_res;         /**< Horizontal resolution.*/
     lv_coord_t ver_res;         /**< Vertical resolution.*/
 
+    lv_coord_t physical_hor_res;     /**< Horizontal resolution of the full / physical display. Set to -1 for fullscreen mode.*/
+    lv_coord_t physical_ver_res;     /**< Vertical resolution of the full / physical display. Set to -1 for fullscreen mode.*/
+    lv_coord_t offset_x;             /**< Horizontal offset from the full / physical display. Set to 0 for fullscreen mode.*/
+    lv_coord_t offset_y;             /**< Vertical offset from the full / physical display. Set to 0 for fullscreen mode.*/
+
     /** Pointer to a buffer initialized with `lv_disp_draw_buf_init()`.
      * LVGL will use this buffer(s) to draw the screens contents*/
     lv_disp_draw_buf_t * draw_buf;
 
+    uint32_t direct_mode : 1;        /**< 1: Use screen-sized buffers and draw to absolute coordinates*/
     uint32_t full_refresh : 1;       /**< 1: Always make the whole screen redrawn*/
     uint32_t sw_rotate : 1;          /**< 1: use software rotation (slower)*/
     uint32_t antialiasing : 1;       /**< 1: anti-aliasing is enabled on this display.*/
@@ -160,11 +167,13 @@ typedef struct _lv_disp_t {
     struct _lv_obj_t * top_layer;   /**< @see lv_disp_get_layer_top*/
     struct _lv_obj_t * sys_layer;   /**< @see lv_disp_get_layer_sys*/
     uint32_t screen_cnt;
-    uint8_t del_prev  : 1;          /**< 1: Automatically delete the previous screen when the screen load animation is ready*/
+uint8_t del_prev  :
+    1;          /**< 1: Automatically delete the previous screen when the screen load animation is ready*/
 
     lv_opa_t bg_opa;                /**<Opacity of the background color or wallpaper*/
     lv_color_t bg_color;            /**< Default display color when screens are transparent*/
     const void * bg_img;            /**< An image source to display as wallpaper*/
+    void (*bg_fn)(lv_area_t*);/**< A function to handle drawing*/
 
     /** Invalidated (marked to redraw) areas*/
     lv_area_t inv_areas[LV_INV_BUF_SIZE];
@@ -251,6 +260,34 @@ lv_coord_t lv_disp_get_hor_res(lv_disp_t * disp);
  */
 lv_coord_t lv_disp_get_ver_res(lv_disp_t * disp);
 
+/**
+ * Get the full / physical horizontal resolution of a display
+ * @param disp pointer to a display (NULL to use the default display)
+ * @return the full / physical horizontal resolution of the display
+ */
+lv_coord_t lv_disp_get_physical_hor_res(lv_disp_t * disp);
+
+/**
+ * Get the full / physical vertical resolution of a display
+ * @param disp pointer to a display (NULL to use the default display)
+ * @return the full / physical vertical resolution of the display
+ */
+lv_coord_t lv_disp_get_physical_ver_res(lv_disp_t * disp);
+
+/**
+ * Get the horizontal offset from the full / physical display
+ * @param disp pointer to a display (NULL to use the default display)
+ * @return the horizontal offset from the full / physical display
+ */
+lv_coord_t lv_disp_get_offset_x(lv_disp_t * disp);
+
+/**
+ * Get the vertical offset from the full / physical display
+ * @param disp pointer to a display (NULL to use the default display)
+ * @return the horizontal offset from the full / physical display
+ */
+lv_coord_t lv_disp_get_offset_y(lv_disp_t * disp);
+
 /**
  * Get if anti-aliasing is enabled for a display or not
  * @param disp pointer to a display (NULL to use the default display)
@@ -312,6 +349,8 @@ lv_disp_t * lv_disp_get_next(lv_disp_t * disp);
  */
 lv_disp_draw_buf_t * lv_disp_get_draw_buf(lv_disp_t * disp);
 
+void lv_disp_drv_use_generic_set_px_cb(lv_disp_drv_t * disp_drv, lv_img_cf_t cf);
+
 /**********************
  *      MACROS
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_indev.c b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_indev.c
index 72464f863..76b02cec7 100644
--- a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_indev.c
+++ b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_indev.c
@@ -39,9 +39,9 @@
  *      MACROS
  **********************/
 #if LV_LOG_TRACE_INDEV
-#  define INDEV_TRACE(...) LV_LOG_TRACE( __VA_ARGS__)
+    #define INDEV_TRACE(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
-#  define INDEV_TRACE(...)
+    #define INDEV_TRACE(...)
 #endif
 
 /**********************
diff --git a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_indev.h b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_indev.h
index 7aae53ae4..fcda8f9f6 100644
--- a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_indev.h
+++ b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_indev.h
@@ -81,7 +81,7 @@ typedef struct {
     int16_t enc_diff; /**< For LV_INDEV_TYPE_ENCODER number of steps since the previous read*/
 
     lv_indev_state_t state; /**< LV_INDEV_STATE_REL or LV_INDEV_STATE_PR*/
-    bool continue_reading;  /**< Call the read callback until it's set to true*/
+    bool continue_reading;  /**< If set to true, the read callback is invoked again*/
 } lv_indev_data_t;
 
 /** Initialized by the user and registered by 'lv_indev_add()'*/
@@ -113,7 +113,7 @@ typedef struct _lv_indev_drv_t {
     /**< Drag throw slow-down in [%]. Greater value means faster slow-down*/
     uint8_t scroll_throw;
 
-    /**< At least this difference should between two points to evaluate as gesture*/
+    /**< At least this difference should be between two points to evaluate as gesture*/
     uint8_t gesture_min_velocity;
 
     /**< At least this difference should be to send a gesture*/
@@ -187,7 +187,7 @@ typedef struct _lv_indev_t {
 
 /**
  * Initialize an input device driver with default values.
- * It is used to surly have known values in the fields ant not memory junk.
+ * It is used to surely have known values in the fields and not memory junk.
  * After it you can set the fields.
  * @param driver pointer to driver variable to initialize
  */
@@ -202,7 +202,7 @@ lv_indev_t * lv_indev_drv_register(struct _lv_indev_drv_t * driver);
 
 /**
  * Update the driver in run time.
- * @param indev pointer to a input device. (return value of `lv_indev_drv_register`)
+ * @param indev pointer to an input device. (return value of `lv_indev_drv_register`)
  * @param new_drv pointer to the new driver
  */
 void lv_indev_drv_update(lv_indev_t * indev, struct _lv_indev_drv_t * new_drv);
@@ -210,8 +210,8 @@ void lv_indev_drv_update(lv_indev_t * indev, struct _lv_indev_drv_t * new_drv);
 /**
  * Get the next input device.
  * @param indev pointer to the current input device. NULL to initialize.
- * @return the next input devise or NULL if no more. Give the first input device when the parameter
- * is NULL
+ * @return the next input device or NULL if there are no more. Provide the first input device when
+ * the parameter is NULL
  */
 lv_indev_t * lv_indev_get_next(lv_indev_t * indev);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_tick.c b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_tick.c
index 1430b6fb3..e109835ce 100644
--- a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_tick.c
+++ b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_tick.c
@@ -28,8 +28,10 @@
 /**********************
  *  STATIC VARIABLES
  **********************/
+#if !LV_TICK_CUSTOM
 static uint32_t sys_time = 0;
 static volatile uint8_t tick_irq_flag;
+#endif
 
 /**********************
  *      MACROS
@@ -39,6 +41,7 @@ static volatile uint8_t tick_irq_flag;
  *   GLOBAL FUNCTIONS
  **********************/
 
+#if !LV_TICK_CUSTOM
 /**
  * You have to call this function periodically
  * @param tick_period the call period of this function in milliseconds
@@ -48,6 +51,7 @@ LV_ATTRIBUTE_TICK_INC void lv_tick_inc(uint32_t tick_period)
     tick_irq_flag = 0;
     sys_time += tick_period;
 }
+#endif
 
 /**
  * Get the elapsed milliseconds since start up
diff --git a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_tick.h b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_tick.h
index f6986bd66..949f56b83 100644
--- a/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_tick.h
+++ b/lib/libesp32_lvgl/lvgl/src/hal/lv_hal_tick.h
@@ -35,11 +35,13 @@ extern "C" {
 
 //! @cond Doxygen_Suppress
 
+#if !LV_TICK_CUSTOM
 /**
  * You have to call this function periodically
  * @param tick_period the call period of this function in milliseconds
  */
 LV_ATTRIBUTE_TICK_INC void lv_tick_inc(uint32_t tick_period);
+#endif
 
 //! @endcond
 
diff --git a/lib/libesp32_lvgl/lvgl/src/lv_api_map.h b/lib/libesp32_lvgl/lvgl/src/lv_api_map.h
index 2f3c811e8..f2b640a4a 100644
--- a/lib/libesp32_lvgl/lvgl/src/lv_api_map.h
+++ b/lib/libesp32_lvgl/lvgl/src/lv_api_map.h
@@ -19,9 +19,10 @@ extern "C" {
  *      DEFINES
  *********************/
 
-#define LV_NO_TASK_READY LV_NO_TIMER_READY
-#define LV_INDEV_STATE_REL LV_INDEV_STATE_RELEASED
-#define LV_INDEV_STATE_PR LV_INDEV_STATE_PRESSED
+#define LV_NO_TASK_READY        LV_NO_TIMER_READY
+#define LV_INDEV_STATE_REL      LV_INDEV_STATE_RELEASED
+#define LV_INDEV_STATE_PR       LV_INDEV_STATE_PRESSED
+#define LV_OBJ_FLAG_SNAPABLE    LV_OBJ_FLAG_SNAPPABLE   /*Fixed typo*/
 
 /**********************
  *      TYPEDEFS
@@ -40,6 +41,46 @@ static inline LV_ATTRIBUTE_TIMER_HANDLER uint32_t lv_task_handler(void)
  *      MACROS
  **********************/
 
+
+/**********************
+ * INLINE FUNCTIONS
+ **********************/
+
+/**
+ * Move the object to the foreground.
+ * It will look like if it was created as the last child of its parent.
+ * It also means it can cover any of the siblings.
+ * @param obj       pointer to an object
+ */
+static inline void lv_obj_move_foreground(lv_obj_t * obj)
+{
+    lv_obj_t * parent = lv_obj_get_parent(obj);
+    lv_obj_move_to_index(obj, lv_obj_get_child_cnt(parent) - 1);
+}
+
+/**
+ * Move the object to the background.
+ * It will look like if it was created as the first child of its parent.
+ * It also means any of the siblings can cover the object.
+ * @param obj       pointer to an object
+ */
+static inline void lv_obj_move_background(lv_obj_t * obj)
+{
+    lv_obj_move_to_index(obj, 0);
+}
+
+
+
+/**********************
+ * DEPRECATED FUNCTIONS
+ **********************/
+
+static inline uint32_t lv_obj_get_child_id(const struct _lv_obj_t * obj)
+{
+    LV_LOG_WARN("lv_obj_get_child_id(obj) is deprecated, please use lv_obj_get_index(obj).");
+    return lv_obj_get_index(obj);
+}
+
 #ifdef __cplusplus
 } /*extern "C"*/
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/lv_conf_internal.h b/lib/libesp32_lvgl/lvgl/src/lv_conf_internal.h
index 6abd8bdc6..b3e6748bb 100644
--- a/lib/libesp32_lvgl/lvgl/src/lv_conf_internal.h
+++ b/lib/libesp32_lvgl/lvgl/src/lv_conf_internal.h
@@ -6,30 +6,30 @@
 
 #ifndef LV_CONF_INTERNAL_H
 #define LV_CONF_INTERNAL_H
-/*clang-format off*/
+/* clang-format off */
 
 #include <stdint.h>
 
 /* Handle special Kconfig options */
 #ifndef LV_KCONFIG_IGNORE
-#   include "lv_conf_kconfig.h"
-#   ifdef CONFIG_LV_CONF_SKIP
-#       define LV_CONF_SKIP
-#   endif
+#  include "lv_conf_kconfig.h"
+#  ifdef CONFIG_LV_CONF_SKIP
+#    define LV_CONF_SKIP
+#  endif
 #endif
 
 /*If "lv_conf.h" is available from here try to use it later.*/
-#if defined __has_include
+#ifdef __has_include
 #  if __has_include("lv_conf.h")
-#   ifndef LV_CONF_INCLUDE_SIMPLE
-#    define LV_CONF_INCLUDE_SIMPLE
-#   endif
+#    ifndef LV_CONF_INCLUDE_SIMPLE
+#      define LV_CONF_INCLUDE_SIMPLE
+#    endif
 #  endif
 #endif
 
 /*If lv_conf.h is not skipped include it*/
-#if !defined(LV_CONF_SKIP)
-#  if defined(LV_CONF_PATH)											/*If there is a path defined for lv_conf.h use it*/
+#ifndef LV_CONF_SKIP
+#  ifdef LV_CONF_PATH                           /*If there is a path defined for lv_conf.h use it*/
 #    define __LV_TO_STR_AUX(x) #x
 #    define __LV_TO_STR(x) __LV_TO_STR_AUX(x)
 #    include __LV_TO_STR(LV_CONF_PATH)
@@ -42,15 +42,16 @@
 #  endif
 #endif
 
+#ifdef CONFIG_LV_COLOR_DEPTH
+#  define _LV_KCONFIG_PRESENT
+#endif
 
 /*----------------------------------
  * Start parsing lv_conf_template.h
  -----------------------------------*/
-/*clang-format off*/
 
 #include <stdint.h>
 
-
 /*====================
    COLOR SETTINGS
  *====================*/
@@ -60,36 +61,46 @@
 #  ifdef CONFIG_LV_COLOR_DEPTH
 #    define LV_COLOR_DEPTH CONFIG_LV_COLOR_DEPTH
 #  else
-#    define  LV_COLOR_DEPTH     32
+#    define LV_COLOR_DEPTH 16
 #  endif
 #endif
 
-/*Swap the 2 bytes of RGB565 color. Useful if the display has a 8 bit interface (e.g. SPI)*/
+/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/
 #ifndef LV_COLOR_16_SWAP
 #  ifdef CONFIG_LV_COLOR_16_SWAP
 #    define LV_COLOR_16_SWAP CONFIG_LV_COLOR_16_SWAP
 #  else
-#    define  LV_COLOR_16_SWAP   0
+#    define LV_COLOR_16_SWAP 0
 #  endif
 #endif
 
 /*Enable more complex drawing routines to manage screens transparency.
- *Can be used if the UI is above an other layer, e.g. an OSD menu or video player.
+ *Can be used if the UI is above another layer, e.g. an OSD menu or video player.
  *Requires `LV_COLOR_DEPTH = 32` colors and the screen's `bg_opa` should be set to non LV_OPA_COVER value*/
 #ifndef LV_COLOR_SCREEN_TRANSP
 #  ifdef CONFIG_LV_COLOR_SCREEN_TRANSP
 #    define LV_COLOR_SCREEN_TRANSP CONFIG_LV_COLOR_SCREEN_TRANSP
 #  else
-#    define  LV_COLOR_SCREEN_TRANSP    0
+#    define LV_COLOR_SCREEN_TRANSP 0
 #  endif
 #endif
 
-/*Images pixels with this color will not be drawn if they are  chroma keyed)*/
+/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently.
+ * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */
+#ifndef LV_COLOR_MIX_ROUND_OFS
+#  ifdef CONFIG_LV_COLOR_MIX_ROUND_OFS
+#    define LV_COLOR_MIX_ROUND_OFS CONFIG_LV_COLOR_MIX_ROUND_OFS
+#  else
+#    define LV_COLOR_MIX_ROUND_OFS (LV_COLOR_DEPTH == 32 ? 0: 128)
+#  endif
+#endif
+
+/*Images pixels with this color will not be drawn if they are chroma keyed)*/
 #ifndef LV_COLOR_CHROMA_KEY
 #  ifdef CONFIG_LV_COLOR_CHROMA_KEY
 #    define LV_COLOR_CHROMA_KEY CONFIG_LV_COLOR_CHROMA_KEY
 #  else
-#    define  LV_COLOR_CHROMA_KEY    lv_color_hex(0x00ff00)         /*pure green*/
+#    define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00)         /*pure green*/
 #  endif
 #endif
 
@@ -102,7 +113,7 @@
 #  ifdef CONFIG_LV_MEM_CUSTOM
 #    define LV_MEM_CUSTOM CONFIG_LV_MEM_CUSTOM
 #  else
-#    define  LV_MEM_CUSTOM      0
+#    define LV_MEM_CUSTOM 0
 #  endif
 #endif
 #if LV_MEM_CUSTOM == 0
@@ -111,7 +122,7 @@
 #  ifdef CONFIG_LV_MEM_SIZE
 #    define LV_MEM_SIZE CONFIG_LV_MEM_SIZE
 #  else
-#    define  LV_MEM_SIZE    (32U * 1024U)          /*[bytes]*/
+#    define LV_MEM_SIZE (32U * 1024U)          /*[bytes]*/
 #  endif
 #endif
 
@@ -120,46 +131,62 @@
 #  ifdef CONFIG_LV_MEM_ADR
 #    define LV_MEM_ADR CONFIG_LV_MEM_ADR
 #  else
-#    define  LV_MEM_ADR          0     /*0: unused*/
+#    define LV_MEM_ADR 0     /*0: unused*/
 #  endif
 #endif
+/*Instead of an address give a memory allocator that will be called to get a memory pool for LVGL. E.g. my_malloc*/
+#if LV_MEM_ADR == 0
+//#define LV_MEM_POOL_INCLUDE your_alloc_library  /* Uncomment if using an external allocator*/
+//#define LV_MEM_POOL_ALLOC   your_alloc          /* Uncomment if using an external allocator*/
+#endif
+
 #else       /*LV_MEM_CUSTOM*/
 #ifndef LV_MEM_CUSTOM_INCLUDE
 #  ifdef CONFIG_LV_MEM_CUSTOM_INCLUDE
 #    define LV_MEM_CUSTOM_INCLUDE CONFIG_LV_MEM_CUSTOM_INCLUDE
 #  else
-#    define  LV_MEM_CUSTOM_INCLUDE <stdlib.h>   /*Header for the dynamic memory function*/
+#    define LV_MEM_CUSTOM_INCLUDE <stdlib.h>   /*Header for the dynamic memory function*/
 #  endif
 #endif
 #ifndef LV_MEM_CUSTOM_ALLOC
 #  ifdef CONFIG_LV_MEM_CUSTOM_ALLOC
 #    define LV_MEM_CUSTOM_ALLOC CONFIG_LV_MEM_CUSTOM_ALLOC
 #  else
-#    define  LV_MEM_CUSTOM_ALLOC     malloc
+#    define LV_MEM_CUSTOM_ALLOC   malloc
 #  endif
 #endif
 #ifndef LV_MEM_CUSTOM_FREE
 #  ifdef CONFIG_LV_MEM_CUSTOM_FREE
 #    define LV_MEM_CUSTOM_FREE CONFIG_LV_MEM_CUSTOM_FREE
 #  else
-#    define  LV_MEM_CUSTOM_FREE      free
+#    define LV_MEM_CUSTOM_FREE    free
 #  endif
 #endif
 #ifndef LV_MEM_CUSTOM_REALLOC
 #  ifdef CONFIG_LV_MEM_CUSTOM_REALLOC
 #    define LV_MEM_CUSTOM_REALLOC CONFIG_LV_MEM_CUSTOM_REALLOC
 #  else
-#    define  LV_MEM_CUSTOM_REALLOC   realloc
+#    define LV_MEM_CUSTOM_REALLOC realloc
 #  endif
 #endif
 #endif     /*LV_MEM_CUSTOM*/
 
+/*Number of the intermediate memory buffer used during rendering and other internal processing mechanisms.
+ *You will see an error log message if there wasn't enough buffers. */
+#ifndef LV_MEM_BUF_MAX_NUM
+#  ifdef CONFIG_LV_MEM_BUF_MAX_NUM
+#    define LV_MEM_BUF_MAX_NUM CONFIG_LV_MEM_BUF_MAX_NUM
+#  else
+#    define LV_MEM_BUF_MAX_NUM 16
+#  endif
+#endif
+
 /*Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster).*/
 #ifndef LV_MEMCPY_MEMSET_STD
 #  ifdef CONFIG_LV_MEMCPY_MEMSET_STD
 #    define LV_MEMCPY_MEMSET_STD CONFIG_LV_MEMCPY_MEMSET_STD
 #  else
-#    define  LV_MEMCPY_MEMSET_STD    0
+#    define LV_MEMCPY_MEMSET_STD 0
 #  endif
 #endif
 
@@ -167,12 +194,12 @@
    HAL SETTINGS
  *====================*/
 
-/*Default display refresh period. LVG will redraw changed ares with this period time*/
+/*Default display refresh period. LVG will redraw changed areas with this period time*/
 #ifndef LV_DISP_DEF_REFR_PERIOD
 #  ifdef CONFIG_LV_DISP_DEF_REFR_PERIOD
 #    define LV_DISP_DEF_REFR_PERIOD CONFIG_LV_DISP_DEF_REFR_PERIOD
 #  else
-#    define  LV_DISP_DEF_REFR_PERIOD     30      /*[ms]*/
+#    define LV_DISP_DEF_REFR_PERIOD 30      /*[ms]*/
 #  endif
 #endif
 
@@ -181,7 +208,7 @@
 #  ifdef CONFIG_LV_INDEV_DEF_READ_PERIOD
 #    define LV_INDEV_DEF_READ_PERIOD CONFIG_LV_INDEV_DEF_READ_PERIOD
 #  else
-#    define  LV_INDEV_DEF_READ_PERIOD    30      /*[ms]*/
+#    define LV_INDEV_DEF_READ_PERIOD 30     /*[ms]*/
 #  endif
 #endif
 
@@ -191,7 +218,7 @@
 #  ifdef CONFIG_LV_TICK_CUSTOM
 #    define LV_TICK_CUSTOM CONFIG_LV_TICK_CUSTOM
 #  else
-#    define  LV_TICK_CUSTOM     0
+#    define LV_TICK_CUSTOM 0
 #  endif
 #endif
 #if LV_TICK_CUSTOM
@@ -199,14 +226,14 @@
 #  ifdef CONFIG_LV_TICK_CUSTOM_INCLUDE
 #    define LV_TICK_CUSTOM_INCLUDE CONFIG_LV_TICK_CUSTOM_INCLUDE
 #  else
-#    define  LV_TICK_CUSTOM_INCLUDE  "Arduino.h"         /*Header for the system time function*/
+#    define LV_TICK_CUSTOM_INCLUDE "Arduino.h"         /*Header for the system time function*/
 #  endif
 #endif
 #ifndef LV_TICK_CUSTOM_SYS_TIME_EXPR
 #  ifdef CONFIG_LV_TICK_CUSTOM_SYS_TIME_EXPR
 #    define LV_TICK_CUSTOM_SYS_TIME_EXPR CONFIG_LV_TICK_CUSTOM_SYS_TIME_EXPR
 #  else
-#    define  LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current system time in ms*/
+#    define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())    /*Expression evaluating to current system time in ms*/
 #  endif
 #endif
 #endif   /*LV_TICK_CUSTOM*/
@@ -217,7 +244,7 @@
 #  ifdef CONFIG_LV_DPI_DEF
 #    define LV_DPI_DEF CONFIG_LV_DPI_DEF
 #  else
-#    define  LV_DPI_DEF                  130     /*[px/inch]*/
+#    define LV_DPI_DEF 130     /*[px/inch]*/
 #  endif
 #endif
 
@@ -232,10 +259,14 @@
 /*Enable complex draw engine.
  *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/
 #ifndef LV_DRAW_COMPLEX
-#  ifdef CONFIG_LV_DRAW_COMPLEX
-#    define LV_DRAW_COMPLEX CONFIG_LV_DRAW_COMPLEX
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_DRAW_COMPLEX
+#      define LV_DRAW_COMPLEX CONFIG_LV_DRAW_COMPLEX
+#    else
+#      define LV_DRAW_COMPLEX 0
+#    endif
 #  else
-#    define  LV_DRAW_COMPLEX 1
+#    define LV_DRAW_COMPLEX 1
 #  endif
 #endif
 #if LV_DRAW_COMPLEX != 0
@@ -247,9 +278,22 @@
 #  ifdef CONFIG_LV_SHADOW_CACHE_SIZE
 #    define LV_SHADOW_CACHE_SIZE CONFIG_LV_SHADOW_CACHE_SIZE
 #  else
-#    define  LV_SHADOW_CACHE_SIZE    0
+#    define LV_SHADOW_CACHE_SIZE 0
 #  endif
 #endif
+
+/* Set number of maximally cached circle data.
+ * The circumference of 1/4 circle are saved for anti-aliasing
+ * radius * 4 bytes are used per circle (the most often used radiuses are saved)
+ * 0: to disable caching */
+#ifndef LV_CIRCLE_CACHE_SIZE
+#  ifdef CONFIG_LV_CIRCLE_CACHE_SIZE
+#    define LV_CIRCLE_CACHE_SIZE CONFIG_LV_CIRCLE_CACHE_SIZE
+#  else
+#    define LV_CIRCLE_CACHE_SIZE 4
+#  endif
+#endif
+
 #endif /*LV_DRAW_COMPLEX*/
 
 /*Default image cache size. Image caching keeps the images opened.
@@ -261,7 +305,7 @@
 #  ifdef CONFIG_LV_IMG_CACHE_DEF_SIZE
 #    define LV_IMG_CACHE_DEF_SIZE CONFIG_LV_IMG_CACHE_DEF_SIZE
 #  else
-#    define  LV_IMG_CACHE_DEF_SIZE       0
+#    define LV_IMG_CACHE_DEF_SIZE 0
 #  endif
 #endif
 
@@ -270,9 +314,10 @@
 #  ifdef CONFIG_LV_DISP_ROT_MAX_BUF
 #    define LV_DISP_ROT_MAX_BUF CONFIG_LV_DISP_ROT_MAX_BUF
 #  else
-#    define  LV_DISP_ROT_MAX_BUF         (10*1024)
+#    define LV_DISP_ROT_MAX_BUF (10*1024)
 #  endif
 #endif
+
 /*-------------
  * GPU
  *-----------*/
@@ -282,7 +327,7 @@
 #  ifdef CONFIG_LV_USE_GPU_STM32_DMA2D
 #    define LV_USE_GPU_STM32_DMA2D CONFIG_LV_USE_GPU_STM32_DMA2D
 #  else
-#    define  LV_USE_GPU_STM32_DMA2D  0
+#    define LV_USE_GPU_STM32_DMA2D 0
 #  endif
 #endif
 #if LV_USE_GPU_STM32_DMA2D
@@ -292,7 +337,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_GPU_DMA2D_CMSIS_INCLUDE
 #    define LV_GPU_DMA2D_CMSIS_INCLUDE CONFIG_LV_GPU_DMA2D_CMSIS_INCLUDE
 #  else
-#    define  LV_GPU_DMA2D_CMSIS_INCLUDE
+#    define LV_GPU_DMA2D_CMSIS_INCLUDE
 #  endif
 #endif
 #endif
@@ -302,7 +347,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_GPU_NXP_PXP
 #    define LV_USE_GPU_NXP_PXP CONFIG_LV_USE_GPU_NXP_PXP
 #  else
-#    define  LV_USE_GPU_NXP_PXP      0
+#    define LV_USE_GPU_NXP_PXP 0
 #  endif
 #endif
 #if LV_USE_GPU_NXP_PXP
@@ -315,7 +360,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_GPU_NXP_PXP_AUTO_INIT
 #    define LV_USE_GPU_NXP_PXP_AUTO_INIT CONFIG_LV_USE_GPU_NXP_PXP_AUTO_INIT
 #  else
-#    define  LV_USE_GPU_NXP_PXP_AUTO_INIT 0
+#    define LV_USE_GPU_NXP_PXP_AUTO_INIT 0
 #  endif
 #endif
 #endif
@@ -325,10 +370,37 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_GPU_NXP_VG_LITE
 #    define LV_USE_GPU_NXP_VG_LITE CONFIG_LV_USE_GPU_NXP_VG_LITE
 #  else
-#    define  LV_USE_GPU_NXP_VG_LITE   0
+#    define LV_USE_GPU_NXP_VG_LITE 0
 #  endif
 #endif
 
+/*Use exnternal renderer*/
+#ifndef LV_USE_EXTERNAL_RENDERER
+#  ifdef CONFIG_LV_USE_EXTERNAL_RENDERER
+#    define LV_USE_EXTERNAL_RENDERER CONFIG_LV_USE_EXTERNAL_RENDERER
+#  else
+#    define LV_USE_EXTERNAL_RENDERER 0
+#  endif
+#endif
+
+/*Use SDL renderer API. Requires LV_USE_EXTERNAL_RENDERER*/
+#ifndef LV_USE_GPU_SDL
+#  ifdef CONFIG_LV_USE_GPU_SDL
+#    define LV_USE_GPU_SDL CONFIG_LV_USE_GPU_SDL
+#  else
+#    define LV_USE_GPU_SDL 0
+#  endif
+#endif
+#if LV_USE_GPU_SDL
+#ifndef LV_GPU_SDL_INCLUDE_PATH
+#  ifdef CONFIG_LV_GPU_SDL_INCLUDE_PATH
+#    define LV_GPU_SDL_INCLUDE_PATH CONFIG_LV_GPU_SDL_INCLUDE_PATH
+#  else
+#    define LV_GPU_SDL_INCLUDE_PATH <SDL2/SDL.h>
+#  endif
+#endif
+#endif
+
 /*-------------
  * Logging
  *-----------*/
@@ -338,7 +410,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_LOG
 #    define LV_USE_LOG CONFIG_LV_USE_LOG
 #  else
-#    define  LV_USE_LOG      0
+#    define LV_USE_LOG 0
 #  endif
 #endif
 #if LV_USE_LOG
@@ -354,7 +426,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_LOG_LEVEL
 #    define LV_LOG_LEVEL CONFIG_LV_LOG_LEVEL
 #  else
-#    define  LV_LOG_LEVEL    LV_LOG_LEVEL_WARN
+#    define LV_LOG_LEVEL LV_LOG_LEVEL_WARN
 #  endif
 #endif
 
@@ -364,65 +436,97 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_LOG_PRINTF
 #    define LV_LOG_PRINTF CONFIG_LV_LOG_PRINTF
 #  else
-#    define  LV_LOG_PRINTF   0
+#    define LV_LOG_PRINTF 0
 #  endif
 #endif
 
 /*Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs*/
 #ifndef LV_LOG_TRACE_MEM
-#  ifdef CONFIG_LV_LOG_TRACE_MEM
-#    define LV_LOG_TRACE_MEM CONFIG_LV_LOG_TRACE_MEM
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_LOG_TRACE_MEM
+#      define LV_LOG_TRACE_MEM CONFIG_LV_LOG_TRACE_MEM
+#    else
+#      define LV_LOG_TRACE_MEM 0
+#    endif
 #  else
-#    define  LV_LOG_TRACE_MEM            1
+#    define LV_LOG_TRACE_MEM        1
 #  endif
 #endif
 #ifndef LV_LOG_TRACE_TIMER
-#  ifdef CONFIG_LV_LOG_TRACE_TIMER
-#    define LV_LOG_TRACE_TIMER CONFIG_LV_LOG_TRACE_TIMER
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_LOG_TRACE_TIMER
+#      define LV_LOG_TRACE_TIMER CONFIG_LV_LOG_TRACE_TIMER
+#    else
+#      define LV_LOG_TRACE_TIMER 0
+#    endif
 #  else
-#    define  LV_LOG_TRACE_TIMER          1
+#    define LV_LOG_TRACE_TIMER      1
 #  endif
 #endif
 #ifndef LV_LOG_TRACE_INDEV
-#  ifdef CONFIG_LV_LOG_TRACE_INDEV
-#    define LV_LOG_TRACE_INDEV CONFIG_LV_LOG_TRACE_INDEV
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_LOG_TRACE_INDEV
+#      define LV_LOG_TRACE_INDEV CONFIG_LV_LOG_TRACE_INDEV
+#    else
+#      define LV_LOG_TRACE_INDEV 0
+#    endif
 #  else
-#    define  LV_LOG_TRACE_INDEV          1
+#    define LV_LOG_TRACE_INDEV      1
 #  endif
 #endif
 #ifndef LV_LOG_TRACE_DISP_REFR
-#  ifdef CONFIG_LV_LOG_TRACE_DISP_REFR
-#    define LV_LOG_TRACE_DISP_REFR CONFIG_LV_LOG_TRACE_DISP_REFR
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_LOG_TRACE_DISP_REFR
+#      define LV_LOG_TRACE_DISP_REFR CONFIG_LV_LOG_TRACE_DISP_REFR
+#    else
+#      define LV_LOG_TRACE_DISP_REFR 0
+#    endif
 #  else
-#    define  LV_LOG_TRACE_DISP_REFR      1
+#    define LV_LOG_TRACE_DISP_REFR  1
 #  endif
 #endif
 #ifndef LV_LOG_TRACE_EVENT
-#  ifdef CONFIG_LV_LOG_TRACE_EVENT
-#    define LV_LOG_TRACE_EVENT CONFIG_LV_LOG_TRACE_EVENT
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_LOG_TRACE_EVENT
+#      define LV_LOG_TRACE_EVENT CONFIG_LV_LOG_TRACE_EVENT
+#    else
+#      define LV_LOG_TRACE_EVENT 0
+#    endif
 #  else
-#    define  LV_LOG_TRACE_EVENT          1
+#    define LV_LOG_TRACE_EVENT      1
 #  endif
 #endif
 #ifndef LV_LOG_TRACE_OBJ_CREATE
-#  ifdef CONFIG_LV_LOG_TRACE_OBJ_CREATE
-#    define LV_LOG_TRACE_OBJ_CREATE CONFIG_LV_LOG_TRACE_OBJ_CREATE
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_LOG_TRACE_OBJ_CREATE
+#      define LV_LOG_TRACE_OBJ_CREATE CONFIG_LV_LOG_TRACE_OBJ_CREATE
+#    else
+#      define LV_LOG_TRACE_OBJ_CREATE 0
+#    endif
 #  else
-#    define  LV_LOG_TRACE_OBJ_CREATE     1
+#    define LV_LOG_TRACE_OBJ_CREATE 1
 #  endif
 #endif
 #ifndef LV_LOG_TRACE_LAYOUT
-#  ifdef CONFIG_LV_LOG_TRACE_LAYOUT
-#    define LV_LOG_TRACE_LAYOUT CONFIG_LV_LOG_TRACE_LAYOUT
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_LOG_TRACE_LAYOUT
+#      define LV_LOG_TRACE_LAYOUT CONFIG_LV_LOG_TRACE_LAYOUT
+#    else
+#      define LV_LOG_TRACE_LAYOUT 0
+#    endif
 #  else
-#    define  LV_LOG_TRACE_LAYOUT         1
+#    define LV_LOG_TRACE_LAYOUT     1
 #  endif
 #endif
 #ifndef LV_LOG_TRACE_ANIM
-#  ifdef CONFIG_LV_LOG_TRACE_ANIM
-#    define LV_LOG_TRACE_ANIM CONFIG_LV_LOG_TRACE_ANIM
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_LOG_TRACE_ANIM
+#      define LV_LOG_TRACE_ANIM CONFIG_LV_LOG_TRACE_ANIM
+#    else
+#      define LV_LOG_TRACE_ANIM 0
+#    endif
 #  else
-#    define  LV_LOG_TRACE_ANIM           1
+#    define LV_LOG_TRACE_ANIM       1
 #  endif
 #endif
 
@@ -438,35 +542,35 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_ASSERT_NULL
 #    define LV_USE_ASSERT_NULL CONFIG_LV_USE_ASSERT_NULL
 #  else
-#    define  LV_USE_ASSERT_NULL          1   /*Check if the parameter is NULL. (Very fast, recommended)*/
+#    define LV_USE_ASSERT_NULL          1   /*Check if the parameter is NULL. (Very fast, recommended)*/
 #  endif
 #endif
 #ifndef LV_USE_ASSERT_MALLOC
 #  ifdef CONFIG_LV_USE_ASSERT_MALLOC
 #    define LV_USE_ASSERT_MALLOC CONFIG_LV_USE_ASSERT_MALLOC
 #  else
-#    define  LV_USE_ASSERT_MALLOC        1   /*Checks is the memory is successfully allocated or no. (Very fast, recommended)*/
+#    define LV_USE_ASSERT_MALLOC        1   /*Checks is the memory is successfully allocated or no. (Very fast, recommended)*/
 #  endif
 #endif
 #ifndef LV_USE_ASSERT_STYLE
 #  ifdef CONFIG_LV_USE_ASSERT_STYLE
 #    define LV_USE_ASSERT_STYLE CONFIG_LV_USE_ASSERT_STYLE
 #  else
-#    define  LV_USE_ASSERT_STYLE         0   /*Check if the styles are properly initialized. (Very fast, recommended)*/
+#    define LV_USE_ASSERT_STYLE         0   /*Check if the styles are properly initialized. (Very fast, recommended)*/
 #  endif
 #endif
 #ifndef LV_USE_ASSERT_MEM_INTEGRITY
 #  ifdef CONFIG_LV_USE_ASSERT_MEM_INTEGRITY
 #    define LV_USE_ASSERT_MEM_INTEGRITY CONFIG_LV_USE_ASSERT_MEM_INTEGRITY
 #  else
-#    define  LV_USE_ASSERT_MEM_INTEGRITY 0   /*Check the integrity of `lv_mem` after critical operations. (Slow)*/
+#    define LV_USE_ASSERT_MEM_INTEGRITY 0   /*Check the integrity of `lv_mem` after critical operations. (Slow)*/
 #  endif
 #endif
 #ifndef LV_USE_ASSERT_OBJ
 #  ifdef CONFIG_LV_USE_ASSERT_OBJ
 #    define LV_USE_ASSERT_OBJ CONFIG_LV_USE_ASSERT_OBJ
 #  else
-#    define  LV_USE_ASSERT_OBJ           0   /*Check the object's type and existence (e.g. not deleted). (Slow)*/
+#    define LV_USE_ASSERT_OBJ           0   /*Check the object's type and existence (e.g. not deleted). (Slow)*/
 #  endif
 #endif
 
@@ -475,14 +579,14 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ASSERT_HANDLER_INCLUDE
 #    define LV_ASSERT_HANDLER_INCLUDE CONFIG_LV_ASSERT_HANDLER_INCLUDE
 #  else
-#    define  LV_ASSERT_HANDLER_INCLUDE   <stdint.h>
+#    define LV_ASSERT_HANDLER_INCLUDE <stdint.h>
 #  endif
 #endif
 #ifndef LV_ASSERT_HANDLER
 #  ifdef CONFIG_LV_ASSERT_HANDLER
 #    define LV_ASSERT_HANDLER CONFIG_LV_ASSERT_HANDLER
 #  else
-#    define  LV_ASSERT_HANDLER   while(1);   /*Halt by default*/
+#    define LV_ASSERT_HANDLER while(1);   /*Halt by default*/
 #  endif
 #endif
 
@@ -495,26 +599,44 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_PERF_MONITOR
 #    define LV_USE_PERF_MONITOR CONFIG_LV_USE_PERF_MONITOR
 #  else
-#    define  LV_USE_PERF_MONITOR     0
+#    define LV_USE_PERF_MONITOR 0
 #  endif
 #endif
+#if LV_USE_PERF_MONITOR
+#ifndef LV_USE_PERF_MONITOR_POS
+#  ifdef CONFIG_LV_USE_PERF_MONITOR_POS
+#    define LV_USE_PERF_MONITOR_POS CONFIG_LV_USE_PERF_MONITOR_POS
+#  else
+#    define LV_USE_PERF_MONITOR_POS LV_ALIGN_BOTTOM_RIGHT
+#  endif
+#endif
+#endif
 
-/*1: Show the used memory and the memory fragmentation  in the left bottom corner
+/*1: Show the used memory and the memory fragmentation in the left bottom corner
  * Requires LV_MEM_CUSTOM = 0*/
 #ifndef LV_USE_MEM_MONITOR
 #  ifdef CONFIG_LV_USE_MEM_MONITOR
 #    define LV_USE_MEM_MONITOR CONFIG_LV_USE_MEM_MONITOR
 #  else
-#    define  LV_USE_MEM_MONITOR      0
+#    define LV_USE_MEM_MONITOR 0
 #  endif
 #endif
+#if LV_USE_PERF_MONITOR
+#ifndef LV_USE_MEM_MONITOR_POS
+#  ifdef CONFIG_LV_USE_MEM_MONITOR_POS
+#    define LV_USE_MEM_MONITOR_POS CONFIG_LV_USE_MEM_MONITOR_POS
+#  else
+#    define LV_USE_MEM_MONITOR_POS LV_ALIGN_BOTTOM_LEFT
+#  endif
+#endif
+#endif
 
 /*1: Draw random colored rectangles over the redrawn areas*/
 #ifndef LV_USE_REFR_DEBUG
 #  ifdef CONFIG_LV_USE_REFR_DEBUG
 #    define LV_USE_REFR_DEBUG CONFIG_LV_USE_REFR_DEBUG
 #  else
-#    define  LV_USE_REFR_DEBUG       0
+#    define LV_USE_REFR_DEBUG 0
 #  endif
 #endif
 
@@ -523,7 +645,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_SPRINTF_CUSTOM
 #    define LV_SPRINTF_CUSTOM CONFIG_LV_SPRINTF_CUSTOM
 #  else
-#    define  LV_SPRINTF_CUSTOM   0
+#    define LV_SPRINTF_CUSTOM 0
 #  endif
 #endif
 #if LV_SPRINTF_CUSTOM
@@ -531,21 +653,21 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_SPRINTF_INCLUDE
 #    define LV_SPRINTF_INCLUDE CONFIG_LV_SPRINTF_INCLUDE
 #  else
-#    define  LV_SPRINTF_INCLUDE <stdio.h>
+#    define LV_SPRINTF_INCLUDE <stdio.h>
 #  endif
 #endif
 #ifndef lv_snprintf
 #  ifdef CONFIG_LV_SNPRINTF
 #    define lv_snprintf CONFIG_LV_SNPRINTF
 #  else
-#    define  lv_snprintf     snprintf
+#    define lv_snprintf  snprintf
 #  endif
 #endif
 #ifndef lv_vsnprintf
 #  ifdef CONFIG_LV_VSNPRINTF
 #    define lv_vsnprintf CONFIG_LV_VSNPRINTF
 #  else
-#    define  lv_vsnprintf    vsnprintf
+#    define lv_vsnprintf vsnprintf
 #  endif
 #endif
 #else   /*LV_SPRINTF_CUSTOM*/
@@ -553,26 +675,30 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_SPRINTF_USE_FLOAT
 #    define LV_SPRINTF_USE_FLOAT CONFIG_LV_SPRINTF_USE_FLOAT
 #  else
-#    define  LV_SPRINTF_USE_FLOAT 0
+#    define LV_SPRINTF_USE_FLOAT 0
 #  endif
 #endif
 #endif  /*LV_SPRINTF_CUSTOM*/
 
 #ifndef LV_USE_USER_DATA
-#  ifdef CONFIG_LV_USE_USER_DATA
-#    define LV_USE_USER_DATA CONFIG_LV_USE_USER_DATA
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_USER_DATA
+#      define LV_USE_USER_DATA CONFIG_LV_USE_USER_DATA
+#    else
+#      define LV_USE_USER_DATA 0
+#    endif
 #  else
-#    define  LV_USE_USER_DATA      1
+#    define LV_USE_USER_DATA 1
 #  endif
 #endif
 
 /*Garbage Collector settings
- *Used if lvgl is binded to higher level language and the memory is managed by that language*/
+ *Used if lvgl is bound to higher level language and the memory is managed by that language*/
 #ifndef LV_ENABLE_GC
 #  ifdef CONFIG_LV_ENABLE_GC
 #    define LV_ENABLE_GC CONFIG_LV_ENABLE_GC
 #  else
-#    define  LV_ENABLE_GC 0
+#    define LV_ENABLE_GC 0
 #  endif
 #endif
 #if LV_ENABLE_GC != 0
@@ -580,7 +706,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_GC_INCLUDE
 #    define LV_GC_INCLUDE CONFIG_LV_GC_INCLUDE
 #  else
-#    define  LV_GC_INCLUDE "gc.h"                           /*Include Garbage Collector related things*/
+#    define LV_GC_INCLUDE "gc.h"                           /*Include Garbage Collector related things*/
 #  endif
 #endif
 #endif /*LV_ENABLE_GC*/
@@ -594,7 +720,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_BIG_ENDIAN_SYSTEM
 #    define LV_BIG_ENDIAN_SYSTEM CONFIG_LV_BIG_ENDIAN_SYSTEM
 #  else
-#    define  LV_BIG_ENDIAN_SYSTEM    0
+#    define LV_BIG_ENDIAN_SYSTEM 0
 #  endif
 #endif
 
@@ -603,7 +729,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ATTRIBUTE_TICK_INC
 #    define LV_ATTRIBUTE_TICK_INC CONFIG_LV_ATTRIBUTE_TICK_INC
 #  else
-#    define  LV_ATTRIBUTE_TICK_INC
+#    define LV_ATTRIBUTE_TICK_INC
 #  endif
 #endif
 
@@ -612,7 +738,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ATTRIBUTE_TIMER_HANDLER
 #    define LV_ATTRIBUTE_TIMER_HANDLER CONFIG_LV_ATTRIBUTE_TIMER_HANDLER
 #  else
-#    define  LV_ATTRIBUTE_TIMER_HANDLER
+#    define LV_ATTRIBUTE_TIMER_HANDLER
 #  endif
 #endif
 
@@ -621,16 +747,20 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ATTRIBUTE_FLUSH_READY
 #    define LV_ATTRIBUTE_FLUSH_READY CONFIG_LV_ATTRIBUTE_FLUSH_READY
 #  else
-#    define  LV_ATTRIBUTE_FLUSH_READY
+#    define LV_ATTRIBUTE_FLUSH_READY
 #  endif
 #endif
 
 /*Required alignment size for buffers*/
 #ifndef LV_ATTRIBUTE_MEM_ALIGN_SIZE
-#  ifdef CONFIG_LV_ATTRIBUTE_MEM_ALIGN_SIZE
-#    define LV_ATTRIBUTE_MEM_ALIGN_SIZE CONFIG_LV_ATTRIBUTE_MEM_ALIGN_SIZE
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_ATTRIBUTE_MEM_ALIGN_SIZE
+#      define LV_ATTRIBUTE_MEM_ALIGN_SIZE CONFIG_LV_ATTRIBUTE_MEM_ALIGN_SIZE
+#    else
+#      define LV_ATTRIBUTE_MEM_ALIGN_SIZE 0
+#    endif
 #  else
-#    define  LV_ATTRIBUTE_MEM_ALIGN_SIZE
+#    define LV_ATTRIBUTE_MEM_ALIGN_SIZE 1
 #  endif
 #endif
 
@@ -640,7 +770,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ATTRIBUTE_MEM_ALIGN
 #    define LV_ATTRIBUTE_MEM_ALIGN CONFIG_LV_ATTRIBUTE_MEM_ALIGN
 #  else
-#    define  LV_ATTRIBUTE_MEM_ALIGN
+#    define LV_ATTRIBUTE_MEM_ALIGN
 #  endif
 #endif
 
@@ -649,7 +779,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ATTRIBUTE_LARGE_CONST
 #    define LV_ATTRIBUTE_LARGE_CONST CONFIG_LV_ATTRIBUTE_LARGE_CONST
 #  else
-#    define  LV_ATTRIBUTE_LARGE_CONST
+#    define LV_ATTRIBUTE_LARGE_CONST
 #  endif
 #endif
 
@@ -658,7 +788,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ATTRIBUTE_LARGE_RAM_ARRAY
 #    define LV_ATTRIBUTE_LARGE_RAM_ARRAY CONFIG_LV_ATTRIBUTE_LARGE_RAM_ARRAY
 #  else
-#    define  LV_ATTRIBUTE_LARGE_RAM_ARRAY
+#    define LV_ATTRIBUTE_LARGE_RAM_ARRAY
 #  endif
 #endif
 
@@ -667,7 +797,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ATTRIBUTE_FAST_MEM
 #    define LV_ATTRIBUTE_FAST_MEM CONFIG_LV_ATTRIBUTE_FAST_MEM
 #  else
-#    define  LV_ATTRIBUTE_FAST_MEM
+#    define LV_ATTRIBUTE_FAST_MEM
 #  endif
 #endif
 
@@ -676,7 +806,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ATTRIBUTE_DMA
 #    define LV_ATTRIBUTE_DMA CONFIG_LV_ATTRIBUTE_DMA
 #  else
-#    define  LV_ATTRIBUTE_DMA
+#    define LV_ATTRIBUTE_DMA
 #  endif
 #endif
 
@@ -686,7 +816,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_EXPORT_CONST_INT
 #    define LV_EXPORT_CONST_INT CONFIG_LV_EXPORT_CONST_INT
 #  else
-#    define  LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning /*The default value just prevents GCC warning*/
+#    define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning /*The default value just prevents GCC warning*/
 #  endif
 #endif
 
@@ -695,7 +825,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_LARGE_COORD
 #    define LV_USE_LARGE_COORD CONFIG_LV_USE_LARGE_COORD
 #  else
-#    define  LV_USE_LARGE_COORD  0
+#    define LV_USE_LARGE_COORD 0
 #  endif
 #endif
 
@@ -709,147 +839,151 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_8
 #    define LV_FONT_MONTSERRAT_8 CONFIG_LV_FONT_MONTSERRAT_8
 #  else
-#    define  LV_FONT_MONTSERRAT_8     0
+#    define LV_FONT_MONTSERRAT_8  0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_10
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_10
 #    define LV_FONT_MONTSERRAT_10 CONFIG_LV_FONT_MONTSERRAT_10
 #  else
-#    define  LV_FONT_MONTSERRAT_10    0
+#    define LV_FONT_MONTSERRAT_10 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_12
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_12
 #    define LV_FONT_MONTSERRAT_12 CONFIG_LV_FONT_MONTSERRAT_12
 #  else
-#    define  LV_FONT_MONTSERRAT_12    0
+#    define LV_FONT_MONTSERRAT_12 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_14
-#  ifdef CONFIG_LV_FONT_MONTSERRAT_14
-#    define LV_FONT_MONTSERRAT_14 CONFIG_LV_FONT_MONTSERRAT_14
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_FONT_MONTSERRAT_14
+#      define LV_FONT_MONTSERRAT_14 CONFIG_LV_FONT_MONTSERRAT_14
+#    else
+#      define LV_FONT_MONTSERRAT_14 0
+#    endif
 #  else
-#    define  LV_FONT_MONTSERRAT_14    1
+#    define LV_FONT_MONTSERRAT_14 1
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_16
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_16
 #    define LV_FONT_MONTSERRAT_16 CONFIG_LV_FONT_MONTSERRAT_16
 #  else
-#    define  LV_FONT_MONTSERRAT_16    0
+#    define LV_FONT_MONTSERRAT_16 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_18
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_18
 #    define LV_FONT_MONTSERRAT_18 CONFIG_LV_FONT_MONTSERRAT_18
 #  else
-#    define  LV_FONT_MONTSERRAT_18    0
+#    define LV_FONT_MONTSERRAT_18 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_20
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_20
 #    define LV_FONT_MONTSERRAT_20 CONFIG_LV_FONT_MONTSERRAT_20
 #  else
-#    define  LV_FONT_MONTSERRAT_20    0
+#    define LV_FONT_MONTSERRAT_20 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_22
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_22
 #    define LV_FONT_MONTSERRAT_22 CONFIG_LV_FONT_MONTSERRAT_22
 #  else
-#    define  LV_FONT_MONTSERRAT_22    0
+#    define LV_FONT_MONTSERRAT_22 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_24
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_24
 #    define LV_FONT_MONTSERRAT_24 CONFIG_LV_FONT_MONTSERRAT_24
 #  else
-#    define  LV_FONT_MONTSERRAT_24    0
+#    define LV_FONT_MONTSERRAT_24 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_26
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_26
 #    define LV_FONT_MONTSERRAT_26 CONFIG_LV_FONT_MONTSERRAT_26
 #  else
-#    define  LV_FONT_MONTSERRAT_26    0
+#    define LV_FONT_MONTSERRAT_26 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_28
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_28
 #    define LV_FONT_MONTSERRAT_28 CONFIG_LV_FONT_MONTSERRAT_28
 #  else
-#    define  LV_FONT_MONTSERRAT_28    0
+#    define LV_FONT_MONTSERRAT_28 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_30
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_30
 #    define LV_FONT_MONTSERRAT_30 CONFIG_LV_FONT_MONTSERRAT_30
 #  else
-#    define  LV_FONT_MONTSERRAT_30    0
+#    define LV_FONT_MONTSERRAT_30 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_32
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_32
 #    define LV_FONT_MONTSERRAT_32 CONFIG_LV_FONT_MONTSERRAT_32
 #  else
-#    define  LV_FONT_MONTSERRAT_32    0
+#    define LV_FONT_MONTSERRAT_32 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_34
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_34
 #    define LV_FONT_MONTSERRAT_34 CONFIG_LV_FONT_MONTSERRAT_34
 #  else
-#    define  LV_FONT_MONTSERRAT_34    0
+#    define LV_FONT_MONTSERRAT_34 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_36
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_36
 #    define LV_FONT_MONTSERRAT_36 CONFIG_LV_FONT_MONTSERRAT_36
 #  else
-#    define  LV_FONT_MONTSERRAT_36    0
+#    define LV_FONT_MONTSERRAT_36 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_38
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_38
 #    define LV_FONT_MONTSERRAT_38 CONFIG_LV_FONT_MONTSERRAT_38
 #  else
-#    define  LV_FONT_MONTSERRAT_38    0
+#    define LV_FONT_MONTSERRAT_38 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_40
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_40
 #    define LV_FONT_MONTSERRAT_40 CONFIG_LV_FONT_MONTSERRAT_40
 #  else
-#    define  LV_FONT_MONTSERRAT_40    0
+#    define LV_FONT_MONTSERRAT_40 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_42
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_42
 #    define LV_FONT_MONTSERRAT_42 CONFIG_LV_FONT_MONTSERRAT_42
 #  else
-#    define  LV_FONT_MONTSERRAT_42    0
+#    define LV_FONT_MONTSERRAT_42 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_44
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_44
 #    define LV_FONT_MONTSERRAT_44 CONFIG_LV_FONT_MONTSERRAT_44
 #  else
-#    define  LV_FONT_MONTSERRAT_44    0
+#    define LV_FONT_MONTSERRAT_44 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_46
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_46
 #    define LV_FONT_MONTSERRAT_46 CONFIG_LV_FONT_MONTSERRAT_46
 #  else
-#    define  LV_FONT_MONTSERRAT_46    0
+#    define LV_FONT_MONTSERRAT_46 0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_48
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_48
 #    define LV_FONT_MONTSERRAT_48 CONFIG_LV_FONT_MONTSERRAT_48
 #  else
-#    define  LV_FONT_MONTSERRAT_48    0
+#    define LV_FONT_MONTSERRAT_48 0
 #  endif
 #endif
 
@@ -858,28 +992,28 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_12_SUBPX
 #    define LV_FONT_MONTSERRAT_12_SUBPX CONFIG_LV_FONT_MONTSERRAT_12_SUBPX
 #  else
-#    define  LV_FONT_MONTSERRAT_12_SUBPX      0
+#    define LV_FONT_MONTSERRAT_12_SUBPX      0
 #  endif
 #endif
 #ifndef LV_FONT_MONTSERRAT_28_COMPRESSED
 #  ifdef CONFIG_LV_FONT_MONTSERRAT_28_COMPRESSED
 #    define LV_FONT_MONTSERRAT_28_COMPRESSED CONFIG_LV_FONT_MONTSERRAT_28_COMPRESSED
 #  else
-#    define  LV_FONT_MONTSERRAT_28_COMPRESSED 0  /*bpp = 3*/
+#    define LV_FONT_MONTSERRAT_28_COMPRESSED 0  /*bpp = 3*/
 #  endif
 #endif
 #ifndef LV_FONT_DEJAVU_16_PERSIAN_HEBREW
 #  ifdef CONFIG_LV_FONT_DEJAVU_16_PERSIAN_HEBREW
 #    define LV_FONT_DEJAVU_16_PERSIAN_HEBREW CONFIG_LV_FONT_DEJAVU_16_PERSIAN_HEBREW
 #  else
-#    define  LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0  /*Hebrew, Arabic, Perisan letters and all their forms*/
+#    define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0  /*Hebrew, Arabic, Perisan letters and all their forms*/
 #  endif
 #endif
 #ifndef LV_FONT_SIMSUN_16_CJK
 #  ifdef CONFIG_LV_FONT_SIMSUN_16_CJK
 #    define LV_FONT_SIMSUN_16_CJK CONFIG_LV_FONT_SIMSUN_16_CJK
 #  else
-#    define  LV_FONT_SIMSUN_16_CJK            0  /*1000 most common CJK radicals*/
+#    define LV_FONT_SIMSUN_16_CJK            0  /*1000 most common CJK radicals*/
 #  endif
 #endif
 
@@ -888,14 +1022,14 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_FONT_UNSCII_8
 #    define LV_FONT_UNSCII_8 CONFIG_LV_FONT_UNSCII_8
 #  else
-#    define  LV_FONT_UNSCII_8        0
+#    define LV_FONT_UNSCII_8  0
 #  endif
 #endif
 #ifndef LV_FONT_UNSCII_16
 #  ifdef CONFIG_LV_FONT_UNSCII_16
 #    define LV_FONT_UNSCII_16 CONFIG_LV_FONT_UNSCII_16
 #  else
-#    define  LV_FONT_UNSCII_16       0
+#    define LV_FONT_UNSCII_16 0
 #  endif
 #endif
 
@@ -906,7 +1040,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_FONT_CUSTOM_DECLARE
 #    define LV_FONT_CUSTOM_DECLARE CONFIG_LV_FONT_CUSTOM_DECLARE
 #  else
-#    define  LV_FONT_CUSTOM_DECLARE
+#    define LV_FONT_CUSTOM_DECLARE
 #  endif
 #endif
 
@@ -915,7 +1049,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_FONT_DEFAULT
 #    define LV_FONT_DEFAULT CONFIG_LV_FONT_DEFAULT
 #  else
-#    define  LV_FONT_DEFAULT &lv_font_montserrat_14
+#    define LV_FONT_DEFAULT &lv_font_montserrat_14
 #  endif
 #endif
 
@@ -926,7 +1060,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_FONT_FMT_TXT_LARGE
 #    define LV_FONT_FMT_TXT_LARGE CONFIG_LV_FONT_FMT_TXT_LARGE
 #  else
-#    define  LV_FONT_FMT_TXT_LARGE   0
+#    define LV_FONT_FMT_TXT_LARGE 0
 #  endif
 #endif
 
@@ -935,7 +1069,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_FONT_COMPRESSED
 #    define LV_USE_FONT_COMPRESSED CONFIG_LV_USE_FONT_COMPRESSED
 #  else
-#    define  LV_USE_FONT_COMPRESSED  0
+#    define LV_USE_FONT_COMPRESSED 0
 #  endif
 #endif
 
@@ -944,7 +1078,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_FONT_SUBPX
 #    define LV_USE_FONT_SUBPX CONFIG_LV_USE_FONT_SUBPX
 #  else
-#    define  LV_USE_FONT_SUBPX       0
+#    define LV_USE_FONT_SUBPX 0
 #  endif
 #endif
 #if LV_USE_FONT_SUBPX
@@ -953,7 +1087,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_FONT_SUBPX_BGR
 #    define LV_FONT_SUBPX_BGR CONFIG_LV_FONT_SUBPX_BGR
 #  else
-#    define  LV_FONT_SUBPX_BGR       0  /*0: RGB; 1:BGR order*/
+#    define LV_FONT_SUBPX_BGR 0  /*0: RGB; 1:BGR order*/
 #  endif
 #endif
 #endif
@@ -972,7 +1106,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_TXT_ENC
 #    define LV_TXT_ENC CONFIG_LV_TXT_ENC
 #  else
-#    define  LV_TXT_ENC LV_TXT_ENC_UTF8
+#    define LV_TXT_ENC LV_TXT_ENC_UTF8
 #  endif
 #endif
 
@@ -981,7 +1115,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_TXT_BREAK_CHARS
 #    define LV_TXT_BREAK_CHARS CONFIG_LV_TXT_BREAK_CHARS
 #  else
-#    define  LV_TXT_BREAK_CHARS                  " ,.;:-_"
+#    define LV_TXT_BREAK_CHARS " ,.;:-_"
 #  endif
 #endif
 
@@ -991,7 +1125,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_TXT_LINE_BREAK_LONG_LEN
 #    define LV_TXT_LINE_BREAK_LONG_LEN CONFIG_LV_TXT_LINE_BREAK_LONG_LEN
 #  else
-#    define  LV_TXT_LINE_BREAK_LONG_LEN          0
+#    define LV_TXT_LINE_BREAK_LONG_LEN 0
 #  endif
 #endif
 
@@ -1001,7 +1135,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN
 #    define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN CONFIG_LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN
 #  else
-#    define  LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN  3
+#    define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3
 #  endif
 #endif
 
@@ -1011,7 +1145,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN
 #    define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN CONFIG_LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN
 #  else
-#    define  LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3
+#    define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3
 #  endif
 #endif
 
@@ -1020,18 +1154,18 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_TXT_COLOR_CMD
 #    define LV_TXT_COLOR_CMD CONFIG_LV_TXT_COLOR_CMD
 #  else
-#    define  LV_TXT_COLOR_CMD "#"
+#    define LV_TXT_COLOR_CMD "#"
 #  endif
 #endif
 
 /*Support bidirectional texts. Allows mixing Left-to-Right and Right-to-Left texts.
- *The direction will be processed according to the Unicode Bidirectioanl Algorithm:
+ *The direction will be processed according to the Unicode Bidirectional Algorithm:
  *https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/
 #ifndef LV_USE_BIDI
 #  ifdef CONFIG_LV_USE_BIDI
 #    define LV_USE_BIDI CONFIG_LV_USE_BIDI
 #  else
-#    define  LV_USE_BIDI         0
+#    define LV_USE_BIDI 0
 #  endif
 #endif
 #if LV_USE_BIDI
@@ -1043,7 +1177,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_BIDI_BASE_DIR_DEF
 #    define LV_BIDI_BASE_DIR_DEF CONFIG_LV_BIDI_BASE_DIR_DEF
 #  else
-#    define  LV_BIDI_BASE_DIR_DEF  LV_BASE_DIR_AUTO
+#    define LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO
 #  endif
 #endif
 #endif
@@ -1054,7 +1188,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_ARABIC_PERSIAN_CHARS
 #    define LV_USE_ARABIC_PERSIAN_CHARS CONFIG_LV_USE_ARABIC_PERSIAN_CHARS
 #  else
-#    define  LV_USE_ARABIC_PERSIAN_CHARS 0
+#    define LV_USE_ARABIC_PERSIAN_CHARS 0
 #  endif
 #endif
 
@@ -1065,67 +1199,94 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 /*Documentation of the widgets: https://docs.lvgl.io/latest/en/html/widgets/index.html*/
 
 #ifndef LV_USE_ARC
-#  ifdef CONFIG_LV_USE_ARC
-#    define LV_USE_ARC CONFIG_LV_USE_ARC
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_ARC
+#      define LV_USE_ARC CONFIG_LV_USE_ARC
+#    else
+#      define LV_USE_ARC 0
+#    endif
 #  else
-#    define  LV_USE_ARC          1
+#    define LV_USE_ARC        1
 #  endif
 #endif
 
 #ifndef LV_USE_ANIMIMG
-#  ifdef CONFIG_LV_USE_ANIMIMG
-#    define LV_USE_ANIMIMG CONFIG_LV_USE_ANIMIMG
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_ANIMIMG
+#      define LV_USE_ANIMIMG CONFIG_LV_USE_ANIMIMG
+#    else
+#      define LV_USE_ANIMIMG 0
+#    endif
 #  else
-#    define  LV_USE_ANIMIMG	    1
+#    define LV_USE_ANIMIMG    1
 #  endif
 #endif
 
 #ifndef LV_USE_BAR
-#  ifdef CONFIG_LV_USE_BAR
-#    define LV_USE_BAR CONFIG_LV_USE_BAR
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_BAR
+#      define LV_USE_BAR CONFIG_LV_USE_BAR
+#    else
+#      define LV_USE_BAR 0
+#    endif
 #  else
-#    define  LV_USE_BAR          1
+#    define LV_USE_BAR        1
 #  endif
 #endif
 
 #ifndef LV_USE_BTN
-#  ifdef CONFIG_LV_USE_BTN
-#    define LV_USE_BTN CONFIG_LV_USE_BTN
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_BTN
+#      define LV_USE_BTN CONFIG_LV_USE_BTN
+#    else
+#      define LV_USE_BTN 0
+#    endif
 #  else
-#    define  LV_USE_BTN          1
+#    define LV_USE_BTN        1
 #  endif
 #endif
 
 #ifndef LV_USE_BTNMATRIX
-#  ifdef CONFIG_LV_USE_BTNMATRIX
-#    define LV_USE_BTNMATRIX CONFIG_LV_USE_BTNMATRIX
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_BTNMATRIX
+#      define LV_USE_BTNMATRIX CONFIG_LV_USE_BTNMATRIX
+#    else
+#      define LV_USE_BTNMATRIX 0
+#    endif
 #  else
-#    define  LV_USE_BTNMATRIX    1
+#    define LV_USE_BTNMATRIX  1
 #  endif
 #endif
 
 #ifndef LV_USE_CANVAS
-#  ifdef CONFIG_LV_USE_CANVAS
-#    define LV_USE_CANVAS CONFIG_LV_USE_CANVAS
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_CANVAS
+#      define LV_USE_CANVAS CONFIG_LV_USE_CANVAS
+#    else
+#      define LV_USE_CANVAS 0
+#    endif
 #  else
-#    define  LV_USE_CANVAS       1
+#    define LV_USE_CANVAS     1
 #  endif
 #endif
 
 #ifndef LV_USE_CHECKBOX
-#  ifdef CONFIG_LV_USE_CHECKBOX
-#    define LV_USE_CHECKBOX CONFIG_LV_USE_CHECKBOX
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_CHECKBOX
+#      define LV_USE_CHECKBOX CONFIG_LV_USE_CHECKBOX
+#    else
+#      define LV_USE_CHECKBOX 0
+#    endif
 #  else
-#    define  LV_USE_CHECKBOX     1
+#    define LV_USE_CHECKBOX   1
 #  endif
 #endif
 
-
 #ifndef LV_USE_DROPDOWN
 #  ifdef CONFIG_LV_USE_DROPDOWN
 #    define LV_USE_DROPDOWN CONFIG_LV_USE_DROPDOWN
 #  else
-#    define  LV_USE_DROPDOWN     1   /*Requires: lv_label*/
+#    define LV_USE_DROPDOWN   1   /*Requires: lv_label*/
 #  endif
 #endif
 
@@ -1133,15 +1294,19 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_IMG
 #    define LV_USE_IMG CONFIG_LV_USE_IMG
 #  else
-#    define  LV_USE_IMG          1   /*Requires: lv_label*/
+#    define LV_USE_IMG        1   /*Requires: lv_label*/
 #  endif
 #endif
 
 #ifndef LV_USE_LABEL
-#  ifdef CONFIG_LV_USE_LABEL
-#    define LV_USE_LABEL CONFIG_LV_USE_LABEL
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_LABEL
+#      define LV_USE_LABEL CONFIG_LV_USE_LABEL
+#    else
+#      define LV_USE_LABEL 0
+#    endif
 #  else
-#    define  LV_USE_LABEL        1
+#    define LV_USE_LABEL      1
 #  endif
 #endif
 #if LV_USE_LABEL
@@ -1149,23 +1314,27 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_LABEL_TEXT_SELECTION
 #    define LV_LABEL_TEXT_SELECTION CONFIG_LV_LABEL_TEXT_SELECTION
 #  else
-#    define  LV_LABEL_TEXT_SELECTION         1   /*Enable selecting text of the label*/
+#    define LV_LABEL_TEXT_SELECTION 1 /*Enable selecting text of the label*/
 #  endif
 #endif
 #ifndef LV_LABEL_LONG_TXT_HINT
 #  ifdef CONFIG_LV_LABEL_LONG_TXT_HINT
 #    define LV_LABEL_LONG_TXT_HINT CONFIG_LV_LABEL_LONG_TXT_HINT
 #  else
-#    define  LV_LABEL_LONG_TXT_HINT    1   /*Store some extra info in labels to speed up drawing of very long texts*/
+#    define LV_LABEL_LONG_TXT_HINT 1  /*Store some extra info in labels to speed up drawing of very long texts*/
 #  endif
 #endif
 #endif
 
 #ifndef LV_USE_LINE
-#  ifdef CONFIG_LV_USE_LINE
-#    define LV_USE_LINE CONFIG_LV_USE_LINE
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_LINE
+#      define LV_USE_LINE CONFIG_LV_USE_LINE
+#    else
+#      define LV_USE_LINE 0
+#    endif
 #  else
-#    define  LV_USE_LINE         1
+#    define LV_USE_LINE       1
 #  endif
 #endif
 
@@ -1173,7 +1342,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_ROLLER
 #    define LV_USE_ROLLER CONFIG_LV_USE_ROLLER
 #  else
-#    define  LV_USE_ROLLER       1   /*Requires: lv_label*/
+#    define LV_USE_ROLLER     1   /*Requires: lv_label*/
 #  endif
 #endif
 #if LV_USE_ROLLER
@@ -1181,7 +1350,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_ROLLER_INF_PAGES
 #    define LV_ROLLER_INF_PAGES CONFIG_LV_ROLLER_INF_PAGES
 #  else
-#    define  LV_ROLLER_INF_PAGES       7   /*Number of extra "pages" when the roller is infinite*/
+#    define LV_ROLLER_INF_PAGES 7 /*Number of extra "pages" when the roller is infinite*/
 #  endif
 #endif
 #endif
@@ -1190,15 +1359,19 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_SLIDER
 #    define LV_USE_SLIDER CONFIG_LV_USE_SLIDER
 #  else
-#    define  LV_USE_SLIDER       1   /*Requires: lv_bar*/
+#    define LV_USE_SLIDER     1   /*Requires: lv_bar*/
 #  endif
 #endif
 
 #ifndef LV_USE_SWITCH
-#  ifdef CONFIG_LV_USE_SWITCH
-#    define LV_USE_SWITCH CONFIG_LV_USE_SWITCH
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_SWITCH
+#      define LV_USE_SWITCH CONFIG_LV_USE_SWITCH
+#    else
+#      define LV_USE_SWITCH 0
+#    endif
 #  else
-#    define  LV_USE_SWITCH    1
+#    define LV_USE_SWITCH     1
 #  endif
 #endif
 
@@ -1206,7 +1379,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_USE_TEXTAREA
 #    define LV_USE_TEXTAREA CONFIG_LV_USE_TEXTAREA
 #  else
-#    define  LV_USE_TEXTAREA   1     /*Requires: lv_label*/
+#    define LV_USE_TEXTAREA   1   /*Requires: lv_label*/
 #  endif
 #endif
 #if LV_USE_TEXTAREA != 0
@@ -1214,16 +1387,20 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_TEXTAREA_DEF_PWD_SHOW_TIME
 #    define LV_TEXTAREA_DEF_PWD_SHOW_TIME CONFIG_LV_TEXTAREA_DEF_PWD_SHOW_TIME
 #  else
-#    define  LV_TEXTAREA_DEF_PWD_SHOW_TIME     1500    /*ms*/
+#    define LV_TEXTAREA_DEF_PWD_SHOW_TIME 1500    /*ms*/
 #  endif
 #endif
 #endif
 
 #ifndef LV_USE_TABLE
-#  ifdef CONFIG_LV_USE_TABLE
-#    define LV_USE_TABLE CONFIG_LV_USE_TABLE
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_TABLE
+#      define LV_USE_TABLE CONFIG_LV_USE_TABLE
+#    else
+#      define LV_USE_TABLE 0
+#    endif
 #  else
-#    define  LV_USE_TABLE  1
+#    define LV_USE_TABLE      1
 #  endif
 #endif
 
@@ -1235,10 +1412,14 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
  * Widgets
  *----------*/
 #ifndef LV_USE_CALENDAR
-#  ifdef CONFIG_LV_USE_CALENDAR
-#    define LV_USE_CALENDAR CONFIG_LV_USE_CALENDAR
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_CALENDAR
+#      define LV_USE_CALENDAR CONFIG_LV_USE_CALENDAR
+#    else
+#      define LV_USE_CALENDAR 0
+#    endif
 #  else
-#    define  LV_USE_CALENDAR     1
+#    define LV_USE_CALENDAR   1
 #  endif
 #endif
 #if LV_USE_CALENDAR
@@ -1246,7 +1427,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_CALENDAR_WEEK_STARTS_MONDAY
 #    define LV_CALENDAR_WEEK_STARTS_MONDAY CONFIG_LV_CALENDAR_WEEK_STARTS_MONDAY
 #  else
-#    define  LV_CALENDAR_WEEK_STARTS_MONDAY 0
+#    define LV_CALENDAR_WEEK_STARTS_MONDAY 0
 #  endif
 #endif
 # if LV_CALENDAR_WEEK_STARTS_MONDAY
@@ -1254,7 +1435,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_CALENDAR_DEFAULT_DAY_NAMES
 #    define LV_CALENDAR_DEFAULT_DAY_NAMES CONFIG_LV_CALENDAR_DEFAULT_DAY_NAMES
 #  else
-#    define  LV_CALENDAR_DEFAULT_DAY_NAMES {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"}
+#    define LV_CALENDAR_DEFAULT_DAY_NAMES {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"}
 #  endif
 #endif
 # else
@@ -1262,7 +1443,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_CALENDAR_DEFAULT_DAY_NAMES
 #    define LV_CALENDAR_DEFAULT_DAY_NAMES CONFIG_LV_CALENDAR_DEFAULT_DAY_NAMES
 #  else
-#    define  LV_CALENDAR_DEFAULT_DAY_NAMES {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
+#    define LV_CALENDAR_DEFAULT_DAY_NAMES {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"}
 #  endif
 #endif
 # endif
@@ -1271,134 +1452,198 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_CALENDAR_DEFAULT_MONTH_NAMES
 #    define LV_CALENDAR_DEFAULT_MONTH_NAMES CONFIG_LV_CALENDAR_DEFAULT_MONTH_NAMES
 #  else
-#    define  LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March",  "April", "May",  "June", "July", "August", "September", "October", "November", "December"}
+#    define LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March",  "April", "May",  "June", "July", "August", "September", "October", "November", "December"}
 #  endif
 #endif
 #ifndef LV_USE_CALENDAR_HEADER_ARROW
-#  ifdef CONFIG_LV_USE_CALENDAR_HEADER_ARROW
-#    define LV_USE_CALENDAR_HEADER_ARROW CONFIG_LV_USE_CALENDAR_HEADER_ARROW
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_CALENDAR_HEADER_ARROW
+#      define LV_USE_CALENDAR_HEADER_ARROW CONFIG_LV_USE_CALENDAR_HEADER_ARROW
+#    else
+#      define LV_USE_CALENDAR_HEADER_ARROW 0
+#    endif
 #  else
-#    define  LV_USE_CALENDAR_HEADER_ARROW       1
+#    define LV_USE_CALENDAR_HEADER_ARROW 1
 #  endif
 #endif
 #ifndef LV_USE_CALENDAR_HEADER_DROPDOWN
-#  ifdef CONFIG_LV_USE_CALENDAR_HEADER_DROPDOWN
-#    define LV_USE_CALENDAR_HEADER_DROPDOWN CONFIG_LV_USE_CALENDAR_HEADER_DROPDOWN
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_CALENDAR_HEADER_DROPDOWN
+#      define LV_USE_CALENDAR_HEADER_DROPDOWN CONFIG_LV_USE_CALENDAR_HEADER_DROPDOWN
+#    else
+#      define LV_USE_CALENDAR_HEADER_DROPDOWN 0
+#    endif
 #  else
-#    define  LV_USE_CALENDAR_HEADER_DROPDOWN    1
+#    define LV_USE_CALENDAR_HEADER_DROPDOWN 1
 #  endif
 #endif
 #endif  /*LV_USE_CALENDAR*/
 
 #ifndef LV_USE_CHART
-#  ifdef CONFIG_LV_USE_CHART
-#    define LV_USE_CHART CONFIG_LV_USE_CHART
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_CHART
+#      define LV_USE_CHART CONFIG_LV_USE_CHART
+#    else
+#      define LV_USE_CHART 0
+#    endif
 #  else
-#    define  LV_USE_CHART        1
+#    define LV_USE_CHART      1
 #  endif
 #endif
 
 #ifndef LV_USE_COLORWHEEL
-#  ifdef CONFIG_LV_USE_COLORWHEEL
-#    define LV_USE_COLORWHEEL CONFIG_LV_USE_COLORWHEEL
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_COLORWHEEL
+#      define LV_USE_COLORWHEEL CONFIG_LV_USE_COLORWHEEL
+#    else
+#      define LV_USE_COLORWHEEL 0
+#    endif
 #  else
-#    define  LV_USE_COLORWHEEL   1
+#    define LV_USE_COLORWHEEL 1
 #  endif
 #endif
 
 #ifndef LV_USE_IMGBTN
-#  ifdef CONFIG_LV_USE_IMGBTN
-#    define LV_USE_IMGBTN CONFIG_LV_USE_IMGBTN
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_IMGBTN
+#      define LV_USE_IMGBTN CONFIG_LV_USE_IMGBTN
+#    else
+#      define LV_USE_IMGBTN 0
+#    endif
 #  else
-#    define  LV_USE_IMGBTN       1
+#    define LV_USE_IMGBTN     1
 #  endif
 #endif
 
 #ifndef LV_USE_KEYBOARD
-#  ifdef CONFIG_LV_USE_KEYBOARD
-#    define LV_USE_KEYBOARD CONFIG_LV_USE_KEYBOARD
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_KEYBOARD
+#      define LV_USE_KEYBOARD CONFIG_LV_USE_KEYBOARD
+#    else
+#      define LV_USE_KEYBOARD 0
+#    endif
 #  else
-#    define  LV_USE_KEYBOARD     1
+#    define LV_USE_KEYBOARD   1
 #  endif
 #endif
 
 #ifndef LV_USE_LED
-#  ifdef CONFIG_LV_USE_LED
-#    define LV_USE_LED CONFIG_LV_USE_LED
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_LED
+#      define LV_USE_LED CONFIG_LV_USE_LED
+#    else
+#      define LV_USE_LED 0
+#    endif
 #  else
-#    define  LV_USE_LED          1
+#    define LV_USE_LED        1
 #  endif
 #endif
 
 #ifndef LV_USE_LIST
-#  ifdef CONFIG_LV_USE_LIST
-#    define LV_USE_LIST CONFIG_LV_USE_LIST
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_LIST
+#      define LV_USE_LIST CONFIG_LV_USE_LIST
+#    else
+#      define LV_USE_LIST 0
+#    endif
 #  else
-#    define  LV_USE_LIST         1
+#    define LV_USE_LIST       1
 #  endif
 #endif
 
 #ifndef LV_USE_METER
-#  ifdef CONFIG_LV_USE_METER
-#    define LV_USE_METER CONFIG_LV_USE_METER
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_METER
+#      define LV_USE_METER CONFIG_LV_USE_METER
+#    else
+#      define LV_USE_METER 0
+#    endif
 #  else
-#    define  LV_USE_METER        1
+#    define LV_USE_METER      1
 #  endif
 #endif
 
 #ifndef LV_USE_MSGBOX
-#  ifdef CONFIG_LV_USE_MSGBOX
-#    define LV_USE_MSGBOX CONFIG_LV_USE_MSGBOX
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_MSGBOX
+#      define LV_USE_MSGBOX CONFIG_LV_USE_MSGBOX
+#    else
+#      define LV_USE_MSGBOX 0
+#    endif
 #  else
-#    define  LV_USE_MSGBOX       1
+#    define LV_USE_MSGBOX     1
 #  endif
 #endif
 
 #ifndef LV_USE_SPINBOX
-#  ifdef CONFIG_LV_USE_SPINBOX
-#    define LV_USE_SPINBOX CONFIG_LV_USE_SPINBOX
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_SPINBOX
+#      define LV_USE_SPINBOX CONFIG_LV_USE_SPINBOX
+#    else
+#      define LV_USE_SPINBOX 0
+#    endif
 #  else
-#    define  LV_USE_SPINBOX      1
+#    define LV_USE_SPINBOX    1
 #  endif
 #endif
 
 #ifndef LV_USE_SPINNER
-#  ifdef CONFIG_LV_USE_SPINNER
-#    define LV_USE_SPINNER CONFIG_LV_USE_SPINNER
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_SPINNER
+#      define LV_USE_SPINNER CONFIG_LV_USE_SPINNER
+#    else
+#      define LV_USE_SPINNER 0
+#    endif
 #  else
-#    define  LV_USE_SPINNER      1
+#    define LV_USE_SPINNER    1
 #  endif
 #endif
 
 #ifndef LV_USE_TABVIEW
-#  ifdef CONFIG_LV_USE_TABVIEW
-#    define LV_USE_TABVIEW CONFIG_LV_USE_TABVIEW
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_TABVIEW
+#      define LV_USE_TABVIEW CONFIG_LV_USE_TABVIEW
+#    else
+#      define LV_USE_TABVIEW 0
+#    endif
 #  else
-#    define  LV_USE_TABVIEW      1
+#    define LV_USE_TABVIEW    1
 #  endif
 #endif
 
 #ifndef LV_USE_TILEVIEW
-#  ifdef CONFIG_LV_USE_TILEVIEW
-#    define LV_USE_TILEVIEW CONFIG_LV_USE_TILEVIEW
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_TILEVIEW
+#      define LV_USE_TILEVIEW CONFIG_LV_USE_TILEVIEW
+#    else
+#      define LV_USE_TILEVIEW 0
+#    endif
 #  else
-#    define  LV_USE_TILEVIEW     1
+#    define LV_USE_TILEVIEW   1
 #  endif
 #endif
 
 #ifndef LV_USE_WIN
-#  ifdef CONFIG_LV_USE_WIN
-#    define LV_USE_WIN CONFIG_LV_USE_WIN
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_WIN
+#      define LV_USE_WIN CONFIG_LV_USE_WIN
+#    else
+#      define LV_USE_WIN 0
+#    endif
 #  else
-#    define  LV_USE_WIN          1
+#    define LV_USE_WIN        1
 #  endif
 #endif
 
 #ifndef LV_USE_SPAN
-#  ifdef CONFIG_LV_USE_SPAN
-#    define LV_USE_SPAN CONFIG_LV_USE_SPAN
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_SPAN
+#      define LV_USE_SPAN CONFIG_LV_USE_SPAN
+#    else
+#      define LV_USE_SPAN 0
+#    endif
 #  else
-#    define  LV_USE_SPAN         1
+#    define LV_USE_SPAN       1
 #  endif
 #endif
 #if LV_USE_SPAN
@@ -1407,7 +1652,7 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_SPAN_SNIPPET_STACK_SIZE
 #    define LV_SPAN_SNIPPET_STACK_SIZE CONFIG_LV_SPAN_SNIPPET_STACK_SIZE
 #  else
-#    define  LV_SPAN_SNIPPET_STACK_SIZE   64
+#    define LV_SPAN_SNIPPET_STACK_SIZE 64
 #  endif
 #endif
 #endif
@@ -1415,12 +1660,17 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 /*-----------
  * Themes
  *----------*/
+
 /*A simple, impressive and very complete theme*/
 #ifndef LV_USE_THEME_DEFAULT
-#  ifdef CONFIG_LV_USE_THEME_DEFAULT
-#    define LV_USE_THEME_DEFAULT CONFIG_LV_USE_THEME_DEFAULT
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_THEME_DEFAULT
+#      define LV_USE_THEME_DEFAULT CONFIG_LV_USE_THEME_DEFAULT
+#    else
+#      define LV_USE_THEME_DEFAULT 0
+#    endif
 #  else
-#    define  LV_USE_THEME_DEFAULT    1
+#    define LV_USE_THEME_DEFAULT 1
 #  endif
 #endif
 #if LV_USE_THEME_DEFAULT
@@ -1430,44 +1680,56 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 #  ifdef CONFIG_LV_THEME_DEFAULT_DARK
 #    define LV_THEME_DEFAULT_DARK CONFIG_LV_THEME_DEFAULT_DARK
 #  else
-#    define  LV_THEME_DEFAULT_DARK     0
+#    define LV_THEME_DEFAULT_DARK 0
 #  endif
 #endif
 
 /*1: Enable grow on press*/
 #ifndef LV_THEME_DEFAULT_GROW
-#  ifdef CONFIG_LV_THEME_DEFAULT_GROW
-#    define LV_THEME_DEFAULT_GROW CONFIG_LV_THEME_DEFAULT_GROW
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_THEME_DEFAULT_GROW
+#      define LV_THEME_DEFAULT_GROW CONFIG_LV_THEME_DEFAULT_GROW
+#    else
+#      define LV_THEME_DEFAULT_GROW 0
+#    endif
 #  else
-#    define  LV_THEME_DEFAULT_GROW              1
+#    define LV_THEME_DEFAULT_GROW 1
 #  endif
 #endif
 
 /*Default transition time in [ms]*/
-#ifndef LV_THEME_DEFAULT_TRANSITON_TIME
-#  ifdef CONFIG_LV_THEME_DEFAULT_TRANSITON_TIME
-#    define LV_THEME_DEFAULT_TRANSITON_TIME CONFIG_LV_THEME_DEFAULT_TRANSITON_TIME
+#ifndef LV_THEME_DEFAULT_TRANSITION_TIME
+#  ifdef CONFIG_LV_THEME_DEFAULT_TRANSITION_TIME
+#    define LV_THEME_DEFAULT_TRANSITION_TIME CONFIG_LV_THEME_DEFAULT_TRANSITION_TIME
 #  else
-#    define  LV_THEME_DEFAULT_TRANSITON_TIME    80
+#    define LV_THEME_DEFAULT_TRANSITION_TIME 80
 #  endif
 #endif
 #endif /*LV_USE_THEME_DEFAULT*/
 
-/*An very simple them that is a good starting point for a custom theme*/
+/*A very simple theme that is a good starting point for a custom theme*/
 #ifndef LV_USE_THEME_BASIC
-#  ifdef CONFIG_LV_USE_THEME_BASIC
-#    define LV_USE_THEME_BASIC CONFIG_LV_USE_THEME_BASIC
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_THEME_BASIC
+#      define LV_USE_THEME_BASIC CONFIG_LV_USE_THEME_BASIC
+#    else
+#      define LV_USE_THEME_BASIC 0
+#    endif
 #  else
-#    define  LV_USE_THEME_BASIC    1
+#    define LV_USE_THEME_BASIC 1
 #  endif
 #endif
 
 /*A theme designed for monochrome displays*/
 #ifndef LV_USE_THEME_MONO
-#  ifdef CONFIG_LV_USE_THEME_MONO
-#    define LV_USE_THEME_MONO CONFIG_LV_USE_THEME_MONO
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_THEME_MONO
+#      define LV_USE_THEME_MONO CONFIG_LV_USE_THEME_MONO
+#    else
+#      define LV_USE_THEME_MONO 0
+#    endif
 #  else
-#    define  LV_USE_THEME_MONO       1
+#    define LV_USE_THEME_MONO 1
 #  endif
 #endif
 
@@ -1477,32 +1739,177 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 
 /*A layout similar to Flexbox in CSS.*/
 #ifndef LV_USE_FLEX
-#  ifdef CONFIG_LV_USE_FLEX
-#    define LV_USE_FLEX CONFIG_LV_USE_FLEX
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_FLEX
+#      define LV_USE_FLEX CONFIG_LV_USE_FLEX
+#    else
+#      define LV_USE_FLEX 0
+#    endif
 #  else
-#    define  LV_USE_FLEX     1
+#    define LV_USE_FLEX 1
 #  endif
 #endif
 
 /*A layout similar to Grid in CSS.*/
 #ifndef LV_USE_GRID
-#  ifdef CONFIG_LV_USE_GRID
-#    define LV_USE_GRID CONFIG_LV_USE_GRID
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_GRID
+#      define LV_USE_GRID CONFIG_LV_USE_GRID
+#    else
+#      define LV_USE_GRID 0
+#    endif
 #  else
-#    define  LV_USE_GRID     1
+#    define LV_USE_GRID 1
 #  endif
 #endif
 
+/*---------------------
+ * 3rd party libraries
+ *--------------------*/
+
+/*File system interfaces for common APIs
+ *To enable set a driver letter for that API*/
+#ifndef LV_USE_FS_STDIO
+#  ifdef CONFIG_LV_USE_FS_STDIO
+#    define LV_USE_FS_STDIO CONFIG_LV_USE_FS_STDIO
+#  else
+#    define LV_USE_FS_STDIO '\0'        /*Uses fopen, fread, etc*/
+#  endif
+#endif
+//#define LV_FS_STDIO_PATH "/home/john/"    /*Set the working directory. If commented it will be "./" */
+
+#ifndef LV_USE_FS_POSIX
+#  ifdef CONFIG_LV_USE_FS_POSIX
+#    define LV_USE_FS_POSIX CONFIG_LV_USE_FS_POSIX
+#  else
+#    define LV_USE_FS_POSIX '\0'        /*Uses open, read, etc*/
+#  endif
+#endif
+//#define LV_FS_POSIX_PATH "/home/john/"    /*Set the working directory. If commented it will be "./" */
+
+#ifndef LV_USE_FS_WIN32
+#  ifdef CONFIG_LV_USE_FS_WIN32
+#    define LV_USE_FS_WIN32 CONFIG_LV_USE_FS_WIN32
+#  else
+#    define LV_USE_FS_WIN32 '\0'        /*Uses CreateFile, ReadFile, etc*/
+#  endif
+#endif
+//#define LV_FS_WIN32_PATH "C:\\Users\\john\\"    /*Set the working directory. If commented it will be ".\\" */
+
+#ifndef LV_USE_FS_FATFS
+#  ifdef CONFIG_LV_USE_FS_FATFS
+#    define LV_USE_FS_FATFS CONFIG_LV_USE_FS_FATFS
+#  else
+#    define LV_USE_FS_FATFS '\0'        /*Uses f_open, f_read, etc*/
+#  endif
+#endif
+
+/*PNG decoder library*/
+#ifndef LV_USE_PNG
+#  ifdef CONFIG_LV_USE_PNG
+#    define LV_USE_PNG CONFIG_LV_USE_PNG
+#  else
+#    define LV_USE_PNG 0
+#  endif
+#endif
+
+/*BMP decoder library*/
+#ifndef LV_USE_BMP
+#  ifdef CONFIG_LV_USE_BMP
+#    define LV_USE_BMP CONFIG_LV_USE_BMP
+#  else
+#    define LV_USE_BMP 0
+#  endif
+#endif
+
+/* JPG + split JPG decoder library.
+ * Split JPG is a custom format optimized for embedded systems. */
+#ifndef LV_USE_SJPG
+#  ifdef CONFIG_LV_USE_SJPG
+#    define LV_USE_SJPG CONFIG_LV_USE_SJPG
+#  else
+#    define LV_USE_SJPG 0
+#  endif
+#endif
+
+/*GIF decoder library*/
+#ifndef LV_USE_GIF
+#  ifdef CONFIG_LV_USE_GIF
+#    define LV_USE_GIF CONFIG_LV_USE_GIF
+#  else
+#    define LV_USE_GIF 0
+#  endif
+#endif
+
+/*QR code library*/
+#ifndef LV_USE_QRCODE
+#  ifdef CONFIG_LV_USE_QRCODE
+#    define LV_USE_QRCODE CONFIG_LV_USE_QRCODE
+#  else
+#    define LV_USE_QRCODE 0
+#  endif
+#endif
+
+/*FreeType library*/
+#ifndef LV_USE_FREETYPE
+#  ifdef CONFIG_LV_USE_FREETYPE
+#    define LV_USE_FREETYPE CONFIG_LV_USE_FREETYPE
+#  else
+#    define LV_USE_FREETYPE 0
+#  endif
+#endif
+#if LV_USE_FREETYPE
+/*Memory used by FreeType to cache characters [bytes] (-1: no caching)*/
+#ifndef LV_FREETYPE_CACHE_SIZE
+#  ifdef CONFIG_LV_FREETYPE_CACHE_SIZE
+#    define LV_FREETYPE_CACHE_SIZE CONFIG_LV_FREETYPE_CACHE_SIZE
+#  else
+#    define LV_FREETYPE_CACHE_SIZE (16 * 1024)
+#  endif
+#endif
+#endif
+
+/*Rlottie library*/
+#ifndef LV_USE_RLOTTIE
+#  ifdef CONFIG_LV_USE_RLOTTIE
+#    define LV_USE_RLOTTIE CONFIG_LV_USE_RLOTTIE
+#  else
+#    define LV_USE_RLOTTIE 0
+#  endif
+#endif
+
+/*-----------
+ * Others
+ *----------*/
+
+/*1: Enable API to take snapshot for object*/
+#ifndef LV_USE_SNAPSHOT
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_USE_SNAPSHOT
+#      define LV_USE_SNAPSHOT CONFIG_LV_USE_SNAPSHOT
+#    else
+#      define LV_USE_SNAPSHOT 0
+#    endif
+#  else
+#    define LV_USE_SNAPSHOT 1
+#  endif
+#endif
+
+
 /*==================
 * EXAMPLES
 *==================*/
 
 /*Enable the examples to be built with the library*/
 #ifndef LV_BUILD_EXAMPLES
-#  ifdef CONFIG_LV_BUILD_EXAMPLES
-#    define LV_BUILD_EXAMPLES CONFIG_LV_BUILD_EXAMPLES
+#  ifdef _LV_KCONFIG_PRESENT
+#    ifdef CONFIG_LV_BUILD_EXAMPLES
+#      define LV_BUILD_EXAMPLES CONFIG_LV_BUILD_EXAMPLES
+#    else
+#      define LV_BUILD_EXAMPLES 0
+#    endif
 #  else
-#    define  LV_BUILD_EXAMPLES   1
+#    define LV_BUILD_EXAMPLES 1
 #  endif
 #endif
 
@@ -1514,13 +1921,13 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 
 LV_EXPORT_CONST_INT(LV_DPI_DEF);
 
+#undef _LV_KCONFIG_PRESENT
+
 /*If running without lv_conf.h add typdesf with default value*/
-#if defined(LV_CONF_SKIP)
-
-# if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)    /*Disable warnings for Visual Studio*/
-#  define _CRT_SECURE_NO_WARNINGS
-# endif
-
+#ifdef LV_CONF_SKIP
+#  if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)    /*Disable warnings for Visual Studio*/
+#    define _CRT_SECURE_NO_WARNINGS
+#  endif
 #endif  /*defined(LV_CONF_SKIP)*/
 
 #endif  /*LV_CONF_INTERNAL_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/lv_conf_kconfig.h b/lib/libesp32_lvgl/lvgl/src/lv_conf_kconfig.h
index 1881b0ac4..d12803875 100644
--- a/lib/libesp32_lvgl/lvgl/src/lv_conf_kconfig.h
+++ b/lib/libesp32_lvgl/lvgl/src/lv_conf_kconfig.h
@@ -1,4 +1,4 @@
-/** * @file lv_conf_kconfig.h * Configs that needs special handling when LVGL is used with Kconfig */
+/** * @file lv_conf_kconfig.h * Configs that need special handling when LVGL is used with Kconfig */
 
 #ifndef LV_CONF_KCONFIG_H
 #define LV_CONF_KCONFIG_H
@@ -11,37 +11,34 @@ extern "C" {
 #  include LV_CONF_KCONFIG_EXTERNAL_INCLUDE
 #else
 
-#  if defined ESP_PLATFORM
+#  ifdef ESP_PLATFORM
 #    include "sdkconfig.h"
 #    include "esp_attr.h"
 #  endif
 
 #  ifdef __NuttX__
 #    include <nuttx/config.h>
+#  elif defined(__RTTHREAD__)
+#    define LV_CONF_INCLUDE_SIMPLE
+#    include <lv_rt_thread_conf.h>
 #  endif
 
 #endif /*LV_CONF_KCONFIG_EXTERNAL_INCLUDE*/
 
-/*******************
- * LV_MEM_SIZE
- *******************/
-
-#ifndef LV_MEM_SIZE
-#if defined (CONFIG_LV_MEM_SIZE_KILOBYTES)
-#define CONFIG_LV_MEM_SIZE    (CONFIG_LV_MEM_SIZE_KILOBYTES * 1024U)
-#endif
-#endif
-
 /*******************
  * LV COLOR CHROMA KEY
  *******************/
 
-#ifndef LV_COLOR_CHROMA_KEY
-#if defined (CONFIG_LV_COLOR_CHROMA_KEY_HEX)
-#define CONFIG_LV_COLOR_CHROMA_KEY  lv_color_hex(CONFIG_LV_COLOR_CHROMA_KEY_HEX)
-#else
-#define CONFIG_LV_COLOR_CHROMA_KEY  lv_color_hex(0x00ff00)  /* pure green */
+#ifdef CONFIG_LV_COLOR_CHROMA_KEY_HEX
+#  define CONFIG_LV_COLOR_CHROMA_KEY lv_color_hex(CONFIG_LV_COLOR_CHROMA_KEY_HEX)
 #endif
+
+/*******************
+ * LV_MEM_SIZE
+ *******************/
+
+#ifdef CONFIG_LV_MEM_SIZE_KILOBYTES
+#  define CONFIG_LV_MEM_SIZE (CONFIG_LV_MEM_SIZE_KILOBYTES * 1024U)
 #endif
 
 /********************
@@ -49,95 +46,89 @@ extern "C" {
  *******************/
 
 /**
- * NOTE: In Kconfig instead of `LV_THEME_DEFAULT_FONT`
- *       `CONFIG_LV_THEME_DEFAULT_FONT_<font_name>` is defined
+ * NOTE: In Kconfig instead of `LV_DEFAULT_FONT`
+ *       `CONFIG_LV_FONT_DEFAULT_<font_name>` is defined
  *       hence the large selection with if-s
  */
 
 /*------------------
  * DEFAULT FONT
  *-----------------*/
-#ifndef LV_THEME_DEFAULT_FONT
-#if defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_8
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_8
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_10
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_10
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_12
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_12
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_14
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_14
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_16
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_16
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_18
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_18
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_20
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_20
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_22
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_22
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_24
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_24
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_26
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_26
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_28
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_28
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_30
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_30
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_32
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_32
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_34
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_34
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_36
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_36
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_38
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_38
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_40
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_40
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_42
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_42
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_44
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_44
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_46
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_46
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT_48
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_48
-#elif defined CONFIG_LV_FONT_DEFAULT_UNSCII_8
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_unscii_8
-#elif defined CONFIG_LV_FONT_DEFAULT_UNSCII_16
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_unscii_16
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT12SUBPX
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_12_subpx
-#elif defined CONFIG_LV_FONT_DEFAULT_MONTSERRAT28COMPRESSED
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_montserrat_28_compressed
-#elif defined CONFIG_LV_FONT_DEFAULT_DEJAVU_16_PERSIAN_HEBREW
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_dejavu_16_persian_hebrew
-#elif defined CONFIG_LV_FONT_DEFAULT_SIMSUN_16_CJK
-#define CONFIG_LV_THEME_DEFAULT_FONT         &lv_font_simsun_16_cjk
-#endif
+#ifdef CONFIG_LV_FONT_DEFAULT_MONTSERRAT_8
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_8
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_10)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_10
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_12)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_12
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_14)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_14
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_16)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_16
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_18)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_18
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_20)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_20
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_22)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_22
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_24)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_24
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_26)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_26
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_28)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_28
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_30)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_30
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_32)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_32
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_34)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_34
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_36)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_36
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_38)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_38
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_40)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_40
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_42)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_42
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_44)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_44
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_46)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_46
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_48)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_48
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_12_SUBPX)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_12_subpx
+#elif defined(CONFIG_LV_FONT_DEFAULT_MONTSERRAT_28_COMPRESSED)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_montserrat_28_compressed
+#elif defined(CONFIG_LV_FONT_DEFAULT_DEJAVU_16_PERSIAN_HEBREW)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_dejavu_16_persian_hebrew
+#elif defined(CONFIG_LV_FONT_DEFAULT_SIMSUN_16_CJK)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_simsun_16_cjk
+#elif defined(CONFIG_LV_FONT_DEFAULT_UNSCII_8)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_unscii_8
+#elif defined(CONFIG_LV_FONT_DEFAULT_UNSCII_16)
+#  define CONFIG_LV_FONT_DEFAULT &lv_font_unscii_16
 #endif
 
 /*------------------
  * TEXT ENCODING
  *-----------------*/
-#ifndef LV_TEXT_ENC
 #ifdef CONFIG_LV_TXT_ENC_UTF8
-#define CONFIG_LV_TXT_ENC LV_TXT_ENC_UTF8
-#elif defined CONFIG_LV_TXT_ENC_ASCII
-#define CONFIG_LV_TXT_ENC LV_TXT_ENC_ASCII
-#endif
+#  define CONFIG_LV_TXT_ENC LV_TXT_ENC_UTF8
+#elif defined(CONFIG_LV_TXT_ENC_ASCII)
+#  define CONFIG_LV_TXT_ENC LV_TXT_ENC_ASCII
 #endif
 
 /*------------------
  * BIDI DIRECTION
  *-----------------*/
 
-#ifndef LV_BIDI_BASE_DIR_DEF
 #ifdef CONFIG_LV_BASE_DIR_LTR
-#define CONFIG_LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_LTR
-#elif defined CONFIG_LV_BASE_DIR_RTL
-#define CONFIG_LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_RTL
-#elif defined CONFIG_LV_BASE_DIR_AUTO
-#define CONFIG_LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO
-#endif
+#  define CONFIG_LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_LTR
+#elif defined(CONFIG_LV_BASE_DIR_RTL)
+#  define CONFIG_LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_RTL
+#elif defined(CONFIG_LV_BASE_DIR_AUTO)
+#  define CONFIG_LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO
 #endif
 
 #ifdef __cplusplus
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_anim.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_anim.c
index e46ec8a99..ecb95840d 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_anim.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_anim.c
@@ -8,10 +8,8 @@
  *********************/
 #include "lv_anim.h"
 
-#include <stddef.h>
-#include <string.h>
-#include "../misc/lv_assert.h"
 #include "../hal/lv_hal_tick.h"
+#include "lv_assert.h"
 #include "lv_timer.h"
 #include "lv_math.h"
 #include "lv_mem.h"
@@ -46,9 +44,9 @@ static lv_timer_t * _lv_anim_tmr;
  *      MACROS
  **********************/
 #if LV_LOG_TRACE_ANIM
-#  define TRACE_ANIM(...) LV_LOG_TRACE( __VA_ARGS__)
+    #define TRACE_ANIM(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
-#  define TRACE_ANIM(...)
+    #define TRACE_ANIM(...)
 #endif
 
 
@@ -67,9 +65,9 @@ void _lv_anim_core_init(void)
 void lv_anim_init(lv_anim_t * a)
 {
     lv_memset_00(a, sizeof(lv_anim_t));
-    a->time    = 500;
-    a->start_value   = 0;
-    a->end_value     = 100;
+    a->time = 500;
+    a->start_value = 0;
+    a->end_value = 100;
     a->repeat_cnt = 1;
     a->path_cb = lv_anim_path_linear;
     a->early_apply = 1;
@@ -95,13 +93,12 @@ lv_anim_t * lv_anim_start(const lv_anim_t * a)
     /*Initialize the animation descriptor*/
     lv_memcpy(new_anim, a, sizeof(lv_anim_t));
     if(a->var == a) new_anim->var = new_anim;
-    new_anim->time_orig = a->time;
     new_anim->run_round = anim_run_round;
 
     /*Set the start value*/
     if(new_anim->early_apply) {
         if(new_anim->get_value_cb) {
-            int32_t v_ofs  = new_anim->get_value_cb(new_anim);
+            int32_t v_ofs = new_anim->get_value_cb(new_anim);
             new_anim->start_value += v_ofs;
             new_anim->end_value += v_ofs;
         }
@@ -117,6 +114,27 @@ lv_anim_t * lv_anim_start(const lv_anim_t * a)
     return new_anim;
 }
 
+uint32_t lv_anim_get_playtime(lv_anim_t * a)
+{
+    uint32_t playtime = LV_ANIM_PLAYTIME_INFINITE;
+
+    if(a->repeat_cnt == LV_ANIM_REPEAT_INFINITE)
+        return playtime;
+
+    playtime = a->time - a->act_time;
+    if(a->playback_now == 0)
+        playtime += a->playback_delay + a->playback_time;
+
+    if(a->repeat_cnt <= 1)
+        return playtime;
+
+    playtime += (a->repeat_delay + a->time +
+                 a->playback_delay + a->playback_time) *
+                (a->repeat_cnt - 1);
+
+    return playtime;
+}
+
 bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb)
 {
     lv_anim_t * a;
@@ -131,7 +149,7 @@ bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb)
             _lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a);
             lv_mem_free(a);
             anim_mark_list_change(); /*Read by `anim_timer`. It need to know if a delete occurred in
-                                         the linked list*/
+                                       the linked list*/
             del = true;
         }
 
@@ -151,7 +169,7 @@ lv_anim_t * lv_anim_get(void * var, lv_anim_exec_xcb_t exec_cb)
 {
     lv_anim_t * a;
     _LV_LL_READ(&LV_GC_ROOT(_lv_anim_ll), a) {
-        if(a->var == var && a->exec_cb == exec_cb) {
+        if(a->var == var && (a->exec_cb == exec_cb || exec_cb == NULL)) {
             return a;
         }
     }
@@ -203,12 +221,12 @@ int32_t lv_anim_path_linear(const lv_anim_t * a)
 int32_t lv_anim_path_ease_in(const lv_anim_t * a)
 {
     /*Calculate the current step*/
-    uint32_t t = lv_map(a->act_time, 0, a->time, 0, 1024);
-    int32_t step = lv_bezier3(t, 0, 50, 100, 1024);
+    uint32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX);
+    int32_t step = lv_bezier3(t, 0, 50, 100, LV_BEZIER_VAL_MAX);
 
     int32_t new_value;
     new_value = step * (a->end_value - a->start_value);
-    new_value = new_value >> 10;
+    new_value = new_value >> LV_BEZIER_VAL_SHIFT;
     new_value += a->start_value;
 
     return new_value;
@@ -217,12 +235,12 @@ int32_t lv_anim_path_ease_in(const lv_anim_t * a)
 int32_t lv_anim_path_ease_out(const lv_anim_t * a)
 {
     /*Calculate the current step*/
-    uint32_t t = lv_map(a->act_time, 0, a->time, 0, 1024);
-    int32_t step = lv_bezier3(t, 0, 900, 950, 1024);
+    uint32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX);
+    int32_t step = lv_bezier3(t, 0, 900, 950, LV_BEZIER_VAL_MAX);
 
     int32_t new_value;
     new_value = step * (a->end_value - a->start_value);
-    new_value = new_value >> 10;
+    new_value = new_value >> LV_BEZIER_VAL_SHIFT;
     new_value += a->start_value;
 
     return new_value;
@@ -231,12 +249,12 @@ int32_t lv_anim_path_ease_out(const lv_anim_t * a)
 int32_t lv_anim_path_ease_in_out(const lv_anim_t * a)
 {
     /*Calculate the current step*/
-    uint32_t t = lv_map(a->act_time, 0, a->time, 0, 1024);
-    int32_t step = lv_bezier3(t, 0, 50, 952, 1024);
+    uint32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX);
+    int32_t step = lv_bezier3(t, 0, 50, 952, LV_BEZIER_VAL_MAX);
 
     int32_t new_value;
     new_value = step * (a->end_value - a->start_value);
-    new_value = new_value >> 10;
+    new_value = new_value >> LV_BEZIER_VAL_SHIFT;
     new_value += a->start_value;
 
     return new_value;
@@ -245,12 +263,12 @@ int32_t lv_anim_path_ease_in_out(const lv_anim_t * a)
 int32_t lv_anim_path_overshoot(const lv_anim_t * a)
 {
     /*Calculate the current step*/
-    uint32_t t = lv_map(a->act_time, 0, a->time, 0, 1024);
-    int32_t step = lv_bezier3(t, 0, 1000, 1300, 1024);
+    uint32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX);
+    int32_t step = lv_bezier3(t, 0, 1000, 1300, LV_BEZIER_VAL_MAX);
 
     int32_t new_value;
     new_value = step * (a->end_value - a->start_value);
-    new_value = new_value >> 10;
+    new_value = new_value >> LV_BEZIER_VAL_SHIFT;
     new_value += a->start_value;
 
     return new_value;
@@ -259,20 +277,20 @@ int32_t lv_anim_path_overshoot(const lv_anim_t * a)
 int32_t lv_anim_path_bounce(const lv_anim_t * a)
 {
     /*Calculate the current step*/
-    int32_t t = lv_map(a->act_time, 0, a->time, 0, 1024);
+    int32_t t = lv_map(a->act_time, 0, a->time, 0, LV_BEZIER_VAL_MAX);
     int32_t diff = (a->end_value - a->start_value);
 
     /*3 bounces has 5 parts: 3 down and 2 up. One part is t / 5 long*/
 
     if(t < 408) {
         /*Go down*/
-        t = (t * 2500) >> 10; /*[0..1024] range*/
+        t = (t * 2500) >> LV_BEZIER_VAL_SHIFT; /*[0..1024] range*/
     }
     else if(t >= 408 && t < 614) {
         /*First bounce back*/
         t -= 408;
         t    = t * 5; /*to [0..1024] range*/
-        t    = 1024 - t;
+        t    = LV_BEZIER_VAL_MAX - t;
         diff = diff / 20;
     }
     else if(t >= 614 && t < 819) {
@@ -285,23 +303,23 @@ int32_t lv_anim_path_bounce(const lv_anim_t * a)
         /*Second bounce back*/
         t -= 819;
         t    = t * 10; /*to [0..1024] range*/
-        t    = 1024 - t;
+        t    = LV_BEZIER_VAL_MAX - t;
         diff = diff / 40;
     }
-    else if(t >= 921 && t <= 1024) {
+    else if(t >= 921 && t <= LV_BEZIER_VAL_MAX) {
         /*Fall back*/
         t -= 921;
         t    = t * 10; /*to [0..1024] range*/
         diff = diff / 40;
     }
 
-    if(t > 1024) t = 1024;
+    if(t > LV_BEZIER_VAL_MAX) t = LV_BEZIER_VAL_MAX;
     if(t < 0) t = 0;
-    int32_t step = lv_bezier3(t, 1024, 800, 500, 0);
+    int32_t step = lv_bezier3(t, LV_BEZIER_VAL_MAX, 800, 500, 0);
 
     int32_t new_value;
     new_value = step * diff;
-    new_value = new_value >> 10;
+    new_value = new_value >> LV_BEZIER_VAL_SHIFT;
     new_value = a->end_value - new_value;
 
     return new_value;
@@ -325,7 +343,7 @@ int32_t lv_anim_path_step(const lv_anim_t * a)
  */
 static void anim_timer(lv_timer_t * param)
 {
-    (void)param;
+    LV_UNUSED(param);
 
     uint32_t elaps = lv_tick_elaps(last_timer_run);
 
@@ -348,7 +366,7 @@ static void anim_timer(lv_timer_t * param)
             int32_t new_act_time = a->act_time + elaps;
             if(!a->start_cb_called && a->act_time <= 0 && new_act_time >= 0) {
                 if(a->early_apply == 0 && a->get_value_cb) {
-                    int32_t v_ofs  = a->get_value_cb(a);
+                    int32_t v_ofs = a->get_value_cb(a);
                     a->start_value += v_ofs;
                     a->end_value += v_ofs;
                 }
@@ -401,19 +419,17 @@ static void anim_ready_handler(lv_anim_t * a)
     /*Delete the animation if
      * - no repeat left and no play back (simple one shot animation)
      * - no repeat, play back is enabled and play back is ready*/
-    if(a->repeat_cnt == 0 && ((a->playback_time == 0) || (a->playback_time && a->playback_now == 1))) {
+    if(a->repeat_cnt == 0 && (a->playback_time == 0 || a->playback_now == 1)) {
 
-        /*Create copy from the animation and delete the animation from the list.
+        /*Delete the animation from the list.
          * This way the `ready_cb` will see the animations like it's animation is ready deleted*/
-        lv_anim_t a_tmp;
-        lv_memcpy(&a_tmp, a, sizeof(lv_anim_t));
         _lv_ll_remove(&LV_GC_ROOT(_lv_anim_ll), a);
-        lv_mem_free(a);
         /*Flag that the list has changed*/
         anim_mark_list_change();
 
         /*Call the callback function at the end*/
-        if(a_tmp.ready_cb != NULL) a_tmp.ready_cb(&a_tmp);
+        if(a->ready_cb != NULL) a->ready_cb(a);
+        lv_mem_free(a);
     }
     /*If the animation is not deleted then restart it*/
     else {
@@ -426,15 +442,17 @@ static void anim_ready_handler(lv_anim_t * a)
             /*Toggle the play back state*/
             a->playback_now = a->playback_now == 0 ? 1 : 0;
             /*Swap the start and end values*/
-            int32_t tmp;
-            tmp      = a->start_value;
+            int32_t tmp    = a->start_value;
             a->start_value = a->end_value;
             a->end_value   = tmp;
-
-            a->time = a->playback_now == 0 ? a->time_orig : a->playback_time;
+            /*Swap the time and playback_time*/
+            tmp = a->time;
+            a->time = a->playback_time;
+            a->playback_time = tmp;
         }
     }
 }
+
 static void anim_mark_list_change(void)
 {
     anim_list_changed = true;
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_anim.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_anim.h
index e97fbc5c1..6f51bf001 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_anim.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_anim.h
@@ -17,12 +17,18 @@ extern "C" {
 
 #include <stdint.h>
 #include <stdbool.h>
-#include <string.h>
+#include <stddef.h>
 
 /*********************
  *      DEFINES
  *********************/
 
+#define LV_ANIM_REPEAT_INFINITE      0xFFFF
+#define LV_ANIM_PLAYTIME_INFINITE    0xFFFFFFFF
+
+LV_EXPORT_CONST_INT(LV_ANIM_REPEAT_INFINITE);
+LV_EXPORT_CONST_INT(LV_ANIM_PLAYTIME_INFINITE);
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -31,10 +37,7 @@ extern "C" {
 typedef enum {
     LV_ANIM_OFF,
     LV_ANIM_ON,
-}lv_anim_enable_t;
-
-#define LV_ANIM_REPEAT_INFINITE      0xFFFF
-LV_EXPORT_CONST_INT(LV_ANIM_REPEAT_INFINITE);
+} lv_anim_enable_t;
 
 struct _lv_anim_t;
 
@@ -45,7 +48,7 @@ typedef int32_t (*lv_anim_path_cb_t)(const struct _lv_anim_t *);
  * First parameter is the variable to animate.
  * Second parameter is the value to set.
  * Compatible with `lv_xxx_set_yyy(obj, value)` functions
- * The `x` in `_xcb_t` means its not a fully generic prototype because
+ * The `x` in `_xcb_t` means it's not a fully generic prototype because
  * it doesn't receive `lv_anim_t *` as its first argument*/
 typedef void (*lv_anim_exec_xcb_t)(void *, int32_t);
 
@@ -88,7 +91,6 @@ typedef struct _lv_anim_t {
     uint8_t playback_now : 1; /**< Play back is in progress*/
     uint8_t run_round : 1;    /**< Indicates the animation has run in this round*/
     uint8_t start_cb_called : 1;    /**< Indicates that the `start_cb` was already called*/
-    uint32_t time_orig;
 } lv_anim_t;
 
 /**********************
@@ -169,9 +171,9 @@ static inline void lv_anim_set_values(lv_anim_t * a, int32_t start, int32_t end)
 /**
  * Similar to `lv_anim_set_exec_cb` but `lv_anim_custom_exec_cb_t` receives
  * `lv_anim_t * ` as its first parameter instead of `void *`.
- * This function might be used when LVGL is binded to other languages because
+ * This function might be used when LVGL is bound to other languages because
  * it's more consistent to have `lv_anim_t *` as first parameter.
- * The variable to animate can be stored in the animation's `user_sata`
+ * The variable to animate can be stored in the animation's `user_data`
  * @param a         pointer to an initialized `lv_anim_t` variable
  * @param exec_cb   a function to execute.
  */
@@ -184,7 +186,7 @@ static inline void lv_anim_set_custom_exec_cb(lv_anim_t * a, lv_anim_custom_exec
 /**
  * Set the path (curve) of the animation.
  * @param a         pointer to an initialized `lv_anim_t` variable
- * @param path_cb a function the get the current value of the animation.
+ * @param path_cb a function to set the current value of the animation.
  */
 static inline void lv_anim_set_path_cb(lv_anim_t * a, lv_anim_path_cb_t path_cb)
 {
@@ -196,7 +198,7 @@ static inline void lv_anim_set_path_cb(lv_anim_t * a, lv_anim_path_cb_t path_cb)
  * @param a         pointer to an initialized `lv_anim_t` variable
  * @param start_cb  a function call when the animation starts
  */
-static inline void lv_anim_set_start_cb(lv_anim_t * a, lv_anim_ready_cb_t start_cb)
+static inline void lv_anim_set_start_cb(lv_anim_t * a, lv_anim_start_cb_t start_cb)
 {
     a->start_cb = start_cb;
 }
@@ -221,10 +223,11 @@ static inline void lv_anim_set_ready_cb(lv_anim_t * a, lv_anim_ready_cb_t ready_
 {
     a->ready_cb = ready_cb;
 }
+
 /**
  * Make the animation to play back to when the forward direction is ready
  * @param a         pointer to an initialized `lv_anim_t` variable
- * @param time      the duration of the playback animation in in milliseconds. 0: disable playback
+ * @param time      the duration of the playback animation in milliseconds. 0: disable playback
  */
 static inline void lv_anim_set_playback_time(lv_anim_t * a, uint32_t time)
 {
@@ -272,6 +275,18 @@ static inline void lv_anim_set_early_apply(lv_anim_t * a, bool en)
     a->early_apply = en;
 }
 
+/**
+ * Set the custom user data field of the animation.
+ * @param a           pointer to an initialized `lv_anim_t` variable
+ * @param user_data   pointer to the new user_data.
+ */
+#if LV_USE_USER_DATA
+static inline void lv_anim_set_user_data(lv_anim_t * a, void * user_data)
+{
+    a->user_data = user_data;
+}
+#endif
+
 /**
  * Create an animation
  * @param a         an initialized 'anim_t' variable. Not required after call.
@@ -289,6 +304,25 @@ static inline uint32_t lv_anim_get_delay(lv_anim_t * a)
     return -a->act_time;
 }
 
+/**
+ * Get the time used to play the animation.
+ * @param a pointer to an animation.
+ * @return the play time in milliseconds.
+ */
+uint32_t lv_anim_get_playtime(lv_anim_t * a);
+
+/**
+ * Get the user_data field of the animation
+ * @param   a pointer to an initialized `lv_anim_t` variable
+ * @return  the pointer to the custom user_data of the animation
+ */
+#if LV_USE_USER_DATA
+static inline void * lv_anim_get_user_data(lv_anim_t * a)
+{
+    return a->user_data;
+}
+#endif
+
 /**
  * Delete an animation of a variable with a given animator function
  * @param var       pointer to variable
@@ -299,7 +333,7 @@ static inline uint32_t lv_anim_get_delay(lv_anim_t * a)
 bool lv_anim_del(void * var, lv_anim_exec_xcb_t exec_cb);
 
 /**
- * Delete all the animations animation
+ * Delete all the animations
  */
 void lv_anim_del_all(void);
 
@@ -320,13 +354,27 @@ lv_anim_t * lv_anim_get(void * var, lv_anim_exec_xcb_t exec_cb);
  * @param a         pointer to an animation.
  * @param exec_cb   a function pointer which is animating 'var',
  *                  or NULL to ignore it and delete all the animations of 'var
- * @return           true: at least 1 animation is deleted, false: no animation is deleted
+ * @return          true: at least 1 animation is deleted, false: no animation is deleted
  */
 static inline bool lv_anim_custom_del(lv_anim_t * a, lv_anim_custom_exec_cb_t exec_cb)
 {
     return lv_anim_del(a ? a->var : NULL, (lv_anim_exec_xcb_t)exec_cb);
 }
 
+/**
+ * Get the animation of a variable and its `exec_cb`.
+ * This function exists because it's logical that all anim. functions receives an
+ * `lv_anim_t` as their first parameter. It's not practical in C but might make
+ * the API more consequent and makes easier to generate bindings.
+ * @param a         pointer to an animation.
+ * @param exec_cb   a function pointer which is animating 'var', or NULL to return first matching 'var'
+ * @return          pointer to the animation.
+ */
+static inline lv_anim_t * lv_anim_custom_get(lv_anim_t * a, lv_anim_custom_exec_cb_t exec_cb)
+{
+    return lv_anim_get(a ? a->var : NULL, (lv_anim_exec_xcb_t)exec_cb);
+}
+
 /**
  * Get the number of currently running animations
  * @return      the number of running animations
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_anim_timeline.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_anim_timeline.c
new file mode 100644
index 000000000..930b6952c
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_anim_timeline.c
@@ -0,0 +1,198 @@
+/**
+ * @file lv_anim_timeline.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_anim_timeline.h"
+#include "lv_mem.h"
+#include "lv_assert.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*Data of anim_timeline_dsc*/
+typedef struct {
+    lv_anim_t anim;
+    uint32_t start_time;
+} lv_anim_timeline_dsc_t;
+
+/*Data of anim_timeline*/
+struct _lv_anim_timeline_t {
+    lv_anim_timeline_dsc_t * anim_dsc;  /**< Dynamically allocated anim dsc array*/
+    uint32_t anim_dsc_cnt;              /**< The length of anim dsc array*/
+    bool reverse;                       /**< Reverse playback*/
+};
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void lv_anim_timeline_virtual_exec_cb(void * var, int32_t v);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_anim_timeline_t * lv_anim_timeline_create(void)
+{
+    lv_anim_timeline_t * at = (lv_anim_timeline_t *)lv_mem_alloc(sizeof(lv_anim_timeline_t));
+
+    LV_ASSERT_MALLOC(at);
+
+    if(at) lv_memset_00(at, sizeof(lv_anim_timeline_t));
+
+    return at;
+}
+
+void lv_anim_timeline_del(lv_anim_timeline_t * at)
+{
+    LV_ASSERT_NULL(at);
+
+    lv_anim_timeline_stop(at);
+
+    lv_mem_free(at->anim_dsc);
+    lv_mem_free(at);
+}
+
+void lv_anim_timeline_add(lv_anim_timeline_t * at, uint32_t start_time, lv_anim_t * a)
+{
+    LV_ASSERT_NULL(at);
+
+    at->anim_dsc_cnt++;
+    at->anim_dsc = lv_mem_realloc(at->anim_dsc, at->anim_dsc_cnt * sizeof(lv_anim_timeline_dsc_t));
+
+    LV_ASSERT_MALLOC(at->anim_dsc);
+
+    at->anim_dsc[at->anim_dsc_cnt - 1].anim = *a;
+    at->anim_dsc[at->anim_dsc_cnt - 1].start_time = start_time;
+
+    /*Add default var and virtual exec_cb, used to delete animation.*/
+    if(a->var == NULL && a->exec_cb == NULL) {
+        at->anim_dsc[at->anim_dsc_cnt - 1].anim.var = at;
+        at->anim_dsc[at->anim_dsc_cnt - 1].anim.exec_cb = lv_anim_timeline_virtual_exec_cb;
+    }
+}
+
+uint32_t lv_anim_timeline_start(lv_anim_timeline_t * at)
+{
+    LV_ASSERT_NULL(at);
+
+    const uint32_t playtime = lv_anim_timeline_get_playtime(at);
+    bool reverse = at->reverse;
+
+    for(uint32_t i = 0; i < at->anim_dsc_cnt; i++) {
+        lv_anim_t a = at->anim_dsc[i].anim;
+        uint32_t start_time = at->anim_dsc[i].start_time;
+
+        if(reverse) {
+            int32_t temp = a.start_value;
+            a.start_value = a.end_value;
+            a.end_value = temp;
+            lv_anim_set_delay(&a, playtime - (start_time + a.time));
+        }
+        else {
+            lv_anim_set_delay(&a, start_time);
+        }
+
+        lv_anim_start(&a);
+    }
+
+    return playtime;
+}
+
+void lv_anim_timeline_stop(lv_anim_timeline_t * at)
+{
+    LV_ASSERT_NULL(at);
+
+    for(uint32_t i = 0; i < at->anim_dsc_cnt; i++) {
+        lv_anim_t * a = &(at->anim_dsc[i].anim);
+        lv_anim_del(a->var, a->exec_cb);
+    }
+}
+
+void lv_anim_timeline_set_reverse(lv_anim_timeline_t * at, bool reverse)
+{
+    LV_ASSERT_NULL(at);
+    at->reverse = reverse;
+}
+
+void lv_anim_timeline_set_progress(lv_anim_timeline_t * at, uint16_t progress)
+{
+    LV_ASSERT_NULL(at);
+
+    const uint32_t playtime = lv_anim_timeline_get_playtime(at);
+    const uint32_t act_time = progress * playtime / 0xFFFF;
+
+    for(uint32_t i = 0; i < at->anim_dsc_cnt; i++) {
+        lv_anim_t * a = &(at->anim_dsc[i].anim);
+
+        if(a->exec_cb == NULL) {
+            continue;
+        }
+
+        uint32_t start_time = at->anim_dsc[i].start_time;
+        int32_t value = 0;
+
+        if(act_time < start_time) {
+            value = a->start_value;
+        }
+        else if(act_time < (start_time + a->time)) {
+            a->act_time = act_time - start_time;
+            value = a->path_cb(a);
+        }
+        else {
+            value = a->end_value;
+        }
+
+        a->exec_cb(a->var, value);
+    }
+}
+
+uint32_t lv_anim_timeline_get_playtime(lv_anim_timeline_t * at)
+{
+    LV_ASSERT_NULL(at);
+
+    uint32_t playtime = 0;
+    for(uint32_t i = 0; i < at->anim_dsc_cnt; i++) {
+        uint32_t end = lv_anim_get_playtime(&at->anim_dsc[i].anim);
+        if (end == LV_ANIM_PLAYTIME_INFINITE)
+            return end;
+        end += at->anim_dsc[i].start_time;
+        if(end > playtime) {
+            playtime = end;
+        }
+    }
+
+    return playtime;
+}
+
+bool lv_anim_timeline_get_reverse(lv_anim_timeline_t * at)
+{
+    LV_ASSERT_NULL(at);
+    return at->reverse;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void lv_anim_timeline_virtual_exec_cb(void * var, int32_t v)
+{
+    LV_UNUSED(var);
+    LV_UNUSED(v);
+}
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_anim_timeline.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_anim_timeline.h
new file mode 100644
index 000000000..ed8782e19
--- /dev/null
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_anim_timeline.h
@@ -0,0 +1,103 @@
+/**
+ * @file lv_anim_timeline.h
+ *
+ */
+
+#ifndef LV_ANIM_TIMELINE_H
+#define LV_ANIM_TIMELINE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_anim.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+struct _lv_anim_timeline_t;
+
+typedef struct _lv_anim_timeline_t lv_anim_timeline_t;
+
+/**********************
+* GLOBAL PROTOTYPES
+**********************/
+
+/**
+ * Create a animation timeline.
+ * @return pointer to the animation timeline.
+ */
+lv_anim_timeline_t * lv_anim_timeline_create(void);
+
+/**
+ * Delete animation timeline.
+ * @param at    pointer to the animation timeline.
+ */
+void lv_anim_timeline_del(lv_anim_timeline_t * at);
+
+/**
+ * Add animation to the animation timeline.
+ * @param at            pointer to the animation timeline.
+ * @param start_time    the time the animation started on the timeline, note that start_time will override the value of delay.
+ * @param a             pointer to an animation.
+ */
+void lv_anim_timeline_add(lv_anim_timeline_t * at, uint32_t start_time, lv_anim_t * a);
+
+/**
+ * Start the animation timeline.
+ * @param at    pointer to the animation timeline.
+ * @return total time spent in animation timeline.
+ */
+uint32_t lv_anim_timeline_start(lv_anim_timeline_t * at);
+
+/**
+ * Stop the animation timeline.
+ * @param at    pointer to the animation timeline.
+ */
+void lv_anim_timeline_stop(lv_anim_timeline_t * at);
+
+/**
+ * Set the playback direction of the animation timeline.
+ * @param at        pointer to the animation timeline.
+ * @param reverse   whether to play in reverse.
+ */
+void lv_anim_timeline_set_reverse(lv_anim_timeline_t * at, bool reverse);
+
+/**
+ * Set the progress of the animation timeline.
+ * @param at        pointer to the animation timeline.
+ * @param progress  set value 0~65535 to map 0~100% animation progress.
+ */
+void lv_anim_timeline_set_progress(lv_anim_timeline_t * at, uint16_t progress);
+
+/**
+ * Get the time used to play the animation timeline.
+ * @param at    pointer to the animation timeline.
+ * @return total time spent in animation timeline.
+ */
+uint32_t lv_anim_timeline_get_playtime(lv_anim_timeline_t * at);
+
+/**
+ * Get whether the animation timeline is played in reverse.
+ * @param at    pointer to the animation timeline.
+ * @return return true if it is reverse playback.
+ */
+bool lv_anim_timeline_get_reverse(lv_anim_timeline_t * at);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_ANIM_TIMELINE_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_area.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_area.c
index aef222f3e..08a8f16e1 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_area.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_area.c
@@ -134,7 +134,7 @@ bool _lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area
     res_p->x2 = LV_MIN(a1_p->x2, a2_p->x2);
     res_p->y2 = LV_MIN(a1_p->y2, a2_p->y2);
 
-    /*If x1 or y1 greater then x2 or y2 then the areas union is empty*/
+    /*If x1 or y1 greater than x2 or y2 then the areas union is empty*/
     bool union_ok = true;
     if((res_p->x1 > res_p->x2) || (res_p->y1 > res_p->y2)) {
         union_ok = false;
@@ -142,6 +142,7 @@ bool _lv_area_intersect(lv_area_t * res_p, const lv_area_t * a1_p, const lv_area
 
     return union_ok;
 }
+
 /**
  * Join two areas into a third which involves the other two
  * @param res_p pointer to an area, the result will be stored here
@@ -280,6 +281,44 @@ bool _lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p, lv_coo
     return true;
 }
 
+/**
+ * Check if an area is fully out of an other
+ * @param aout_p pointer to an area which could be in 'aholder_p'
+ * @param aholder_p pointer to an area which could involve 'ain_p'
+ * @param radius radius of `aholder_p` (e.g. for rounded rectangle)
+ * @return true: `aout_p` is fully outside `aholder_p`
+ */
+bool _lv_area_is_out(const lv_area_t * aout_p, const lv_area_t * aholder_p, lv_coord_t radius)
+{
+    if(aout_p->x2 < aholder_p->x1 || aout_p->y2 < aholder_p->y1 || aout_p->x1 > aholder_p->x2 ||
+       aout_p->y1 > aholder_p->y2) {
+        return true;
+    }
+
+    if(radius == 0) return false;
+
+    /*Check if the corner points are outside the radius or not*/
+    lv_point_t p;
+
+    p.x = aout_p->x1;
+    p.y = aout_p->y1;
+    if(_lv_area_is_point_on(aholder_p, &p, radius)) return false;
+
+    p.x = aout_p->x2;
+    p.y = aout_p->y1;
+    if(_lv_area_is_point_on(aholder_p, &p, radius)) return false;
+
+    p.x = aout_p->x1;
+    p.y = aout_p->y2;
+    if(_lv_area_is_point_on(aholder_p, &p, radius)) return false;
+
+    p.x = aout_p->x2;
+    p.y = aout_p->y2;
+    if(_lv_area_is_point_on(aholder_p, &p, radius)) return false;
+
+    return true;
+}
+
 /**
  * Align an area to an other
  * @param base an are where the other will be aligned
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_area.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_area.h
index 9bf3e6ec2..e2a70eb4c 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_area.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_area.h
@@ -14,7 +14,6 @@ extern "C" {
  *      INCLUDES
  *********************/
 #include "../lv_conf_internal.h"
-#include <string.h>
 #include <stdbool.h>
 #include <stdint.h>
 
@@ -22,21 +21,12 @@ extern "C" {
  *      DEFINES
  *********************/
 
-#define _LV_COORD_MAX_REDUCE    8192
-
 #if LV_USE_LARGE_COORD
 typedef int32_t lv_coord_t;
 #else
 typedef int16_t lv_coord_t;
 #endif
 
-/*To allow some special values in the end reduce the max value*/
-#define LV_COORD_MAX ((lv_coord_t)((uint32_t)((uint32_t)1 << (8 * sizeof(lv_coord_t) - 1)) - _LV_COORD_MAX_REDUCE))
-#define LV_COORD_MIN (-LV_COORD_MAX)
-
-LV_EXPORT_CONST_INT(LV_COORD_MAX);
-LV_EXPORT_CONST_INT(LV_COORD_MIN);
-
 /**********************
  *      TYPEDEFS
  **********************/
@@ -221,6 +211,16 @@ bool _lv_area_is_on(const lv_area_t * a1_p, const lv_area_t * a2_p);
  */
 bool _lv_area_is_in(const lv_area_t * ain_p, const lv_area_t * aholder_p, lv_coord_t radius);
 
+
+/**
+ * Check if an area is fully out of an other
+ * @param aout_p pointer to an area which could be in 'aholder_p'
+ * @param aholder_p pointer to an area which could involve 'ain_p'
+ * @param radius radius of `aholder_p` (e.g. for rounded rectangle)
+ * @return true: `aout_p` is fully outside `aholder_p`
+ */
+bool _lv_area_is_out(const lv_area_t * aout_p, const lv_area_t * aholder_p, lv_coord_t radius);
+
 /**
  * Align an area to an other
  * @param base an are where the other will be aligned
@@ -240,16 +240,18 @@ void lv_area_align(const lv_area_t * base, lv_area_t * to_align, lv_align_t alig
 #endif
 
 #define _LV_COORD_TYPE_MASK     (3 << _LV_COORD_TYPE_SHIFT)
-#define _LV_COORD_PLAIN(x)      ((x) & (~_LV_COORD_TYPE_MASK))  /*Remove type specifiers*/
+#define _LV_COORD_TYPE(x)       ((x) & _LV_COORD_TYPE_MASK)  /*Extract type specifiers*/
+#define _LV_COORD_PLAIN(x)      ((x) & ~_LV_COORD_TYPE_MASK) /*Remove type specifiers*/
 
 #define _LV_COORD_TYPE_PX       (0 << _LV_COORD_TYPE_SHIFT)
 #define _LV_COORD_TYPE_SPEC     (1 << _LV_COORD_TYPE_SHIFT)
-#define _LV_COORD_TYPE_RESERVED (3 << _LV_COORD_TYPE_SHIFT)
+#define _LV_COORD_TYPE_PX_NEG   (3 << _LV_COORD_TYPE_SHIFT)
 
-#define LV_COORD_IS_PX(x)     ((((x) & _LV_COORD_TYPE_MASK) == _LV_COORD_TYPE_PX) ? true : false)
-#define LV_COORD_IS_SPEC(x)   ((((x) & _LV_COORD_TYPE_MASK) == _LV_COORD_TYPE_SPEC) ? true : false)
+#define LV_COORD_IS_PX(x)       (_LV_COORD_TYPE(x) == _LV_COORD_TYPE_PX) || \
+                                 _LV_COORD_TYPE(x) == _LV_COORD_TYPE_PX_NEG ? true : false)
+#define LV_COORD_IS_SPEC(x)     (_LV_COORD_TYPE(x) == _LV_COORD_TYPE_SPEC ? true : false)
 
-#define LV_COORD_SET_SPEC(x)   ((x) | _LV_COORD_TYPE_SPEC)
+#define LV_COORD_SET_SPEC(x)    ((x) | _LV_COORD_TYPE_SPEC)
 
 /*Special coordinates*/
 #define LV_PCT(x)               (x < 0 ? LV_COORD_SET_SPEC(1000 - (x)) : LV_COORD_SET_SPEC(x))
@@ -259,6 +261,13 @@ void lv_area_align(const lv_area_t * base, lv_area_t * to_align, lv_align_t alig
 
 LV_EXPORT_CONST_INT(LV_SIZE_CONTENT);
 
+/*Max coordinate value*/
+#define LV_COORD_MAX            ((1 << _LV_COORD_TYPE_SHIFT) - 1)
+#define LV_COORD_MIN            (-LV_COORD_MAX)
+
+LV_EXPORT_CONST_INT(LV_COORD_MAX);
+LV_EXPORT_CONST_INT(LV_COORD_MIN);
+
 /**
  * Convert a percentage value to `lv_coord_t`.
  * Percentage values are stored in special range
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_assert.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_assert.h
index 0132ac4d5..48db7443c 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_assert.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_assert.h
@@ -14,7 +14,8 @@ extern "C" {
  *      INCLUDES
  *********************/
 #include "../lv_conf_internal.h"
-#include <stdbool.h>
+#include "lv_log.h"
+#include "lv_mem.h"
 #include LV_ASSERT_HANDLER_INCLUDE
 
 /*********************
@@ -33,20 +34,20 @@ extern "C" {
  *      MACROS
  **********************/
 
-#define LV_ASSERT(expr)              \
-    do {                             \
-        if(!(expr)) {                \
-            LV_LOG_ERROR("Asserted at expression: %s", #expr);     \
-            LV_ASSERT_HANDLER        \
-        }                            \
+#define LV_ASSERT(expr)                                        \
+    do {                                                       \
+        if(!(expr)) {                                          \
+            LV_LOG_ERROR("Asserted at expression: %s", #expr); \
+            LV_ASSERT_HANDLER                                  \
+        }                                                      \
     } while(0)
 
-#define LV_ASSERT_MSG(expr, msg)                     \
-    do {                                             \
-        if(!(expr)) {                                \
-            LV_LOG_ERROR("Asserted at expression: %s (%s)", #expr, msg);     \
-            LV_ASSERT_HANDLER                        \
-        }                                            \
+#define LV_ASSERT_MSG(expr, msg)                                         \
+    do {                                                                 \
+        if(!(expr)) {                                                    \
+            LV_LOG_ERROR("Asserted at expression: %s (%s)", #expr, msg); \
+            LV_ASSERT_HANDLER                                            \
+        }                                                                \
     } while(0)
 
 /*-----------------
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_async.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_async.c
index d2324406a..45a043154 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_async.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_async.c
@@ -8,6 +8,8 @@
  *********************/
 
 #include "lv_async.h"
+#include "lv_mem.h"
+#include "lv_timer.h"
 
 /*********************
  *      DEFINES
@@ -49,7 +51,6 @@ lv_res_t lv_async_call(lv_async_cb_t async_xcb, void * user_data)
         return LV_RES_INV;
 
     /*Create a new timer*/
-    /*Use highest priority so that it will run before a refresh*/
     lv_timer_t * timer = lv_timer_create(lv_async_timer_cb, 0, info);
 
     if(timer == NULL) {
@@ -73,6 +74,5 @@ static void lv_async_timer_cb(lv_timer_t * timer)
     lv_async_info_t * info = (lv_async_info_t *)timer->user_data;
 
     info->cb(info->user_data);
-
     lv_mem_free(info);
 }
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_async.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_async.h
index 2a687cde1..3e6cb638d 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_async.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_async.h
@@ -14,7 +14,6 @@ extern "C" {
  *      INCLUDES
  *********************/
 
-#include "lv_timer.h"
 #include "lv_types.h"
 
 /*********************
@@ -38,7 +37,7 @@ typedef void (*lv_async_cb_t)(void *);
  * Call an asynchronous function the next time lv_timer_handler() is run. This function is likely to return
  * **before** the call actually happens!
  * @param async_xcb a callback which is the task itself.
- *                 (the 'x' in the argument name indicates that its not a fully generic function because it not follows
+ *                 (the 'x' in the argument name indicates that it's not a fully generic function because it not follows
  *                  the `func_name(object, callback, ...)` convention)
  * @param user_data custom parameter
  */
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_bidi.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_bidi.c
index 906338348..3b084d3d7 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_bidi.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_bidi.c
@@ -305,6 +305,16 @@ void _lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t le
     }
 }
 
+void lv_bidi_calculate_align(lv_text_align_t * align, lv_base_dir_t * base_dir, const char * txt)
+{
+    if(*base_dir == LV_BASE_DIR_AUTO) *base_dir = _lv_bidi_detect_base_dir(txt);
+
+    if(*align == LV_TEXT_ALIGN_AUTO) {
+        if(*base_dir == LV_BASE_DIR_RTL) *align = LV_TEXT_ALIGN_RIGHT;
+        else *align = LV_TEXT_ALIGN_LEFT;
+    }
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -430,10 +440,13 @@ static lv_base_dir_t get_next_run(const char * txt, lv_base_dir_t base_dir, uint
     /*Find the first strong char. Skip the neutrals*/
     while(dir == LV_BASE_DIR_NEUTRAL || dir == LV_BASE_DIR_WEAK) {
         letter = _lv_txt_encoded_next(txt, &i);
+        
         pos_conv_i++;
         dir = lv_bidi_get_letter_dir(letter);
         if(dir == LV_BASE_DIR_NEUTRAL)  dir = bracket_process(txt, i, max_len, letter, base_dir);
-
+ 
+        if(dir==LV_BASE_DIR_LTR || dir==LV_BASE_DIR_RTL)  break;
+         
         if(i >= max_len || txt[i] == '\0' || txt[i] == '\n' || txt[i] == '\r') {
             *len = i;
             *pos_conv_len = pos_conv_i;
@@ -455,6 +468,14 @@ static lv_base_dir_t get_next_run(const char * txt, lv_base_dir_t base_dir, uint
         pos_conv_i++;
         next_dir  = lv_bidi_get_letter_dir(letter);
         if(next_dir == LV_BASE_DIR_NEUTRAL)  next_dir = bracket_process(txt, i, max_len, letter, base_dir);
+   
+        if(next_dir == LV_BASE_DIR_WEAK){
+             if(run_dir == LV_BASE_DIR_RTL){
+                 if(base_dir == LV_BASE_DIR_RTL){
+                     next_dir = LV_BASE_DIR_LTR;
+                 }
+             }
+         }
 
         /*New dir found?*/
         if((next_dir == LV_BASE_DIR_RTL || next_dir == LV_BASE_DIR_LTR) && next_dir != run_dir) {
@@ -589,7 +610,7 @@ static lv_base_dir_t bracket_process(const char * txt, uint32_t next_pos, uint32
     /*Is the letter an opening bracket?*/
     for(i = 0; bracket_left[i] != '\0'; i++) {
         if(bracket_left[i] == letter) {
-            /*If so find it's matching closing bracket.
+            /*If so find its matching closing bracket.
              *If a char with base dir. direction is found then the brackets will have `base_dir` direction*/
             uint32_t txt_i = next_pos;
             while(txt_i < len) {
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_bidi.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_bidi.h
index d3a646e7d..a27b58086 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_bidi.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_bidi.h
@@ -17,6 +17,7 @@ extern "C" {
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "lv_txt.h"
 
 /*********************
  *      DEFINES
@@ -104,10 +105,33 @@ uint16_t _lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t
 void _lv_bidi_process_paragraph(const char * str_in, char * str_out, uint32_t len, lv_base_dir_t base_dir,
                                 uint16_t * pos_conv_out, uint16_t pos_conv_len);
 
+/**
+ * Get the real text alignment from the a text alignment, base direction and a text.
+ * @param align     LV_TEXT_ALIGN_..., write back the calculated align here (LV_TEXT_ALIGN_LEFT/RIGHT/CENTER)
+ * @param base_dir  LV_BASE_DIR_..., write the calculated base dir here (LV_BASE_DIR_LTR/RTL)
+ * @param txt       a text, used with LV_BASE_DIR_AUTO to determine the base direction
+ */
+void lv_bidi_calculate_align(lv_text_align_t * align, lv_base_dir_t * base_dir, const char * txt);
+
+
 /**********************
  *      MACROS
  **********************/
 
+#else /*LV_USE_BIDI*/
+/**
+ * For compatibility if LV_USE_BIDI = 0
+ * Get the real text alignment from the a text alignment, base direction and a text.
+ * @param align     For LV_TEXT_ALIGN_AUTO give LV_TEXT_ALIGN_LEFT else leave unchanged, write back the calculated align here
+ * @param base_dir  Unused
+ * @param txt       Unused
+ */
+static inline void lv_bidi_calculate_align(lv_text_align_t * align, lv_base_dir_t * base_dir, const char * txt)
+{
+    LV_UNUSED(txt);
+    LV_UNUSED(base_dir);
+    if(*align == LV_TEXT_ALIGN_AUTO) * align = LV_TEXT_ALIGN_LEFT;
+}
 #endif /*LV_USE_BIDI*/
 
 #ifdef __cplusplus
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_color.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_color.c
index 7ec8c7196..0e26624fb 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_color.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_color.c
@@ -36,7 +36,7 @@
 LV_ATTRIBUTE_FAST_MEM void lv_color_fill(lv_color_t * buf, lv_color_t color, uint32_t px_num)
 {
 #if LV_COLOR_DEPTH == 16
-    uintptr_t buf_int = (uintptr_t) buf;
+    uintptr_t buf_int = (uintptr_t)buf;
     if(buf_int & 0x3) {
         *buf = color;
         buf++;
@@ -73,7 +73,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_color_fill(lv_color_t * buf, lv_color_t color, uin
     while(px_num) {
         *buf = color;
         buf++;
-        px_num --;
+        px_num--;
     }
 #else
     while(px_num > 16) {
@@ -118,7 +118,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_color_fill(lv_color_t * buf, lv_color_t color, uin
     while(px_num) {
         *buf = color;
         buf++;
-        px_num --;
+        px_num--;
     }
 #endif
 }
@@ -293,79 +293,77 @@ lv_color_t lv_palette_main(lv_palette_t p)
 lv_color_t lv_palette_lighten(lv_palette_t p, uint8_t lvl)
 {
     static const lv_color_t colors[][5] = {
-            {LV_COLOR_MAKE(0xEF, 0x53, 0x50), LV_COLOR_MAKE(0xE5, 0x73, 0x73), LV_COLOR_MAKE(0xEF, 0x9A, 0x9A), LV_COLOR_MAKE(0xFF, 0xCD, 0xD2), LV_COLOR_MAKE(0xFF, 0xEB, 0xEE)},
-            {LV_COLOR_MAKE(0xEC, 0x40, 0x7A), LV_COLOR_MAKE(0xF0, 0x62, 0x92), LV_COLOR_MAKE(0xF4, 0x8F, 0xB1), LV_COLOR_MAKE(0xF8, 0xBB, 0xD0), LV_COLOR_MAKE(0xFC, 0xE4, 0xEC)},
-            {LV_COLOR_MAKE(0xAB, 0x47, 0xBC), LV_COLOR_MAKE(0xBA, 0x68, 0xC8), LV_COLOR_MAKE(0xCE, 0x93, 0xD8), LV_COLOR_MAKE(0xE1, 0xBE, 0xE7), LV_COLOR_MAKE(0xF3, 0xE5, 0xF5)},
-            {LV_COLOR_MAKE(0x7E, 0x57, 0xC2), LV_COLOR_MAKE(0x95, 0x75, 0xCD), LV_COLOR_MAKE(0xB3, 0x9D, 0xDB), LV_COLOR_MAKE(0xD1, 0xC4, 0xE9), LV_COLOR_MAKE(0xED, 0xE7, 0xF6)},
-            {LV_COLOR_MAKE(0x5C, 0x6B, 0xC0), LV_COLOR_MAKE(0x79, 0x86, 0xCB), LV_COLOR_MAKE(0x9F, 0xA8, 0xDA), LV_COLOR_MAKE(0xC5, 0xCA, 0xE9), LV_COLOR_MAKE(0xE8, 0xEA, 0xF6)},
-            {LV_COLOR_MAKE(0x42, 0xA5, 0xF5), LV_COLOR_MAKE(0x64, 0xB5, 0xF6), LV_COLOR_MAKE(0x90, 0xCA, 0xF9), LV_COLOR_MAKE(0xBB, 0xDE, 0xFB), LV_COLOR_MAKE(0xE3, 0xF2, 0xFD)},
-            {LV_COLOR_MAKE(0x29, 0xB6, 0xF6), LV_COLOR_MAKE(0x4F, 0xC3, 0xF7), LV_COLOR_MAKE(0x81, 0xD4, 0xFA), LV_COLOR_MAKE(0xB3, 0xE5, 0xFC), LV_COLOR_MAKE(0xE1, 0xF5, 0xFE)},
-            {LV_COLOR_MAKE(0x26, 0xC6, 0xDA), LV_COLOR_MAKE(0x4D, 0xD0, 0xE1), LV_COLOR_MAKE(0x80, 0xDE, 0xEA), LV_COLOR_MAKE(0xB2, 0xEB, 0xF2), LV_COLOR_MAKE(0xE0, 0xF7, 0xFA)},
-            {LV_COLOR_MAKE(0x26, 0xA6, 0x9A), LV_COLOR_MAKE(0x4D, 0xB6, 0xAC), LV_COLOR_MAKE(0x80, 0xCB, 0xC4), LV_COLOR_MAKE(0xB2, 0xDF, 0xDB), LV_COLOR_MAKE(0xE0, 0xF2, 0xF1)},
-            {LV_COLOR_MAKE(0x66, 0xBB, 0x6A), LV_COLOR_MAKE(0x81, 0xC7, 0x84), LV_COLOR_MAKE(0xA5, 0xD6, 0xA7), LV_COLOR_MAKE(0xC8, 0xE6, 0xC9), LV_COLOR_MAKE(0xE8, 0xF5, 0xE9)},
-            {LV_COLOR_MAKE(0x9C, 0xCC, 0x65), LV_COLOR_MAKE(0xAE, 0xD5, 0x81), LV_COLOR_MAKE(0xC5, 0xE1, 0xA5), LV_COLOR_MAKE(0xDC, 0xED, 0xC8), LV_COLOR_MAKE(0xF1, 0xF8, 0xE9)},
-            {LV_COLOR_MAKE(0xD4, 0xE1, 0x57), LV_COLOR_MAKE(0xDC, 0xE7, 0x75), LV_COLOR_MAKE(0xE6, 0xEE, 0x9C), LV_COLOR_MAKE(0xF0, 0xF4, 0xC3), LV_COLOR_MAKE(0xF9, 0xFB, 0xE7)},
-            {LV_COLOR_MAKE(0xFF, 0xEE, 0x58), LV_COLOR_MAKE(0xFF, 0xF1, 0x76), LV_COLOR_MAKE(0xFF, 0xF5, 0x9D), LV_COLOR_MAKE(0xFF, 0xF9, 0xC4), LV_COLOR_MAKE(0xFF, 0xFD, 0xE7)},
-            {LV_COLOR_MAKE(0xFF, 0xCA, 0x28), LV_COLOR_MAKE(0xFF, 0xD5, 0x4F), LV_COLOR_MAKE(0xFF, 0xE0, 0x82), LV_COLOR_MAKE(0xFF, 0xEC, 0xB3), LV_COLOR_MAKE(0xFF, 0xF8, 0xE1)},
-            {LV_COLOR_MAKE(0xFF, 0xA7, 0x26), LV_COLOR_MAKE(0xFF, 0xB7, 0x4D), LV_COLOR_MAKE(0xFF, 0xCC, 0x80), LV_COLOR_MAKE(0xFF, 0xE0, 0xB2), LV_COLOR_MAKE(0xFF, 0xF3, 0xE0)},
-            {LV_COLOR_MAKE(0xFF, 0x70, 0x43), LV_COLOR_MAKE(0xFF, 0x8A, 0x65), LV_COLOR_MAKE(0xFF, 0xAB, 0x91), LV_COLOR_MAKE(0xFF, 0xCC, 0xBC), LV_COLOR_MAKE(0xFB, 0xE9, 0xE7)},
-            {LV_COLOR_MAKE(0x8D, 0x6E, 0x63), LV_COLOR_MAKE(0xA1, 0x88, 0x7F), LV_COLOR_MAKE(0xBC, 0xAA, 0xA4), LV_COLOR_MAKE(0xD7, 0xCC, 0xC8), LV_COLOR_MAKE(0xEF, 0xEB, 0xE9)},
-            {LV_COLOR_MAKE(0x78, 0x90, 0x9C), LV_COLOR_MAKE(0x90, 0xA4, 0xAE), LV_COLOR_MAKE(0xB0, 0xBE, 0xC5), LV_COLOR_MAKE(0xCF, 0xD8, 0xDC), LV_COLOR_MAKE(0xEC, 0xEF, 0xF1)},
-            {LV_COLOR_MAKE(0xBD, 0xBD, 0xBD), LV_COLOR_MAKE(0xE0, 0xE0, 0xE0), LV_COLOR_MAKE(0xEE, 0xEE, 0xEE), LV_COLOR_MAKE(0xF5, 0xF5, 0xF5), LV_COLOR_MAKE(0xFA, 0xFA, 0xFA)},
+        {LV_COLOR_MAKE(0xEF, 0x53, 0x50), LV_COLOR_MAKE(0xE5, 0x73, 0x73), LV_COLOR_MAKE(0xEF, 0x9A, 0x9A), LV_COLOR_MAKE(0xFF, 0xCD, 0xD2), LV_COLOR_MAKE(0xFF, 0xEB, 0xEE)},
+        {LV_COLOR_MAKE(0xEC, 0x40, 0x7A), LV_COLOR_MAKE(0xF0, 0x62, 0x92), LV_COLOR_MAKE(0xF4, 0x8F, 0xB1), LV_COLOR_MAKE(0xF8, 0xBB, 0xD0), LV_COLOR_MAKE(0xFC, 0xE4, 0xEC)},
+        {LV_COLOR_MAKE(0xAB, 0x47, 0xBC), LV_COLOR_MAKE(0xBA, 0x68, 0xC8), LV_COLOR_MAKE(0xCE, 0x93, 0xD8), LV_COLOR_MAKE(0xE1, 0xBE, 0xE7), LV_COLOR_MAKE(0xF3, 0xE5, 0xF5)},
+        {LV_COLOR_MAKE(0x7E, 0x57, 0xC2), LV_COLOR_MAKE(0x95, 0x75, 0xCD), LV_COLOR_MAKE(0xB3, 0x9D, 0xDB), LV_COLOR_MAKE(0xD1, 0xC4, 0xE9), LV_COLOR_MAKE(0xED, 0xE7, 0xF6)},
+        {LV_COLOR_MAKE(0x5C, 0x6B, 0xC0), LV_COLOR_MAKE(0x79, 0x86, 0xCB), LV_COLOR_MAKE(0x9F, 0xA8, 0xDA), LV_COLOR_MAKE(0xC5, 0xCA, 0xE9), LV_COLOR_MAKE(0xE8, 0xEA, 0xF6)},
+        {LV_COLOR_MAKE(0x42, 0xA5, 0xF5), LV_COLOR_MAKE(0x64, 0xB5, 0xF6), LV_COLOR_MAKE(0x90, 0xCA, 0xF9), LV_COLOR_MAKE(0xBB, 0xDE, 0xFB), LV_COLOR_MAKE(0xE3, 0xF2, 0xFD)},
+        {LV_COLOR_MAKE(0x29, 0xB6, 0xF6), LV_COLOR_MAKE(0x4F, 0xC3, 0xF7), LV_COLOR_MAKE(0x81, 0xD4, 0xFA), LV_COLOR_MAKE(0xB3, 0xE5, 0xFC), LV_COLOR_MAKE(0xE1, 0xF5, 0xFE)},
+        {LV_COLOR_MAKE(0x26, 0xC6, 0xDA), LV_COLOR_MAKE(0x4D, 0xD0, 0xE1), LV_COLOR_MAKE(0x80, 0xDE, 0xEA), LV_COLOR_MAKE(0xB2, 0xEB, 0xF2), LV_COLOR_MAKE(0xE0, 0xF7, 0xFA)},
+        {LV_COLOR_MAKE(0x26, 0xA6, 0x9A), LV_COLOR_MAKE(0x4D, 0xB6, 0xAC), LV_COLOR_MAKE(0x80, 0xCB, 0xC4), LV_COLOR_MAKE(0xB2, 0xDF, 0xDB), LV_COLOR_MAKE(0xE0, 0xF2, 0xF1)},
+        {LV_COLOR_MAKE(0x66, 0xBB, 0x6A), LV_COLOR_MAKE(0x81, 0xC7, 0x84), LV_COLOR_MAKE(0xA5, 0xD6, 0xA7), LV_COLOR_MAKE(0xC8, 0xE6, 0xC9), LV_COLOR_MAKE(0xE8, 0xF5, 0xE9)},
+        {LV_COLOR_MAKE(0x9C, 0xCC, 0x65), LV_COLOR_MAKE(0xAE, 0xD5, 0x81), LV_COLOR_MAKE(0xC5, 0xE1, 0xA5), LV_COLOR_MAKE(0xDC, 0xED, 0xC8), LV_COLOR_MAKE(0xF1, 0xF8, 0xE9)},
+        {LV_COLOR_MAKE(0xD4, 0xE1, 0x57), LV_COLOR_MAKE(0xDC, 0xE7, 0x75), LV_COLOR_MAKE(0xE6, 0xEE, 0x9C), LV_COLOR_MAKE(0xF0, 0xF4, 0xC3), LV_COLOR_MAKE(0xF9, 0xFB, 0xE7)},
+        {LV_COLOR_MAKE(0xFF, 0xEE, 0x58), LV_COLOR_MAKE(0xFF, 0xF1, 0x76), LV_COLOR_MAKE(0xFF, 0xF5, 0x9D), LV_COLOR_MAKE(0xFF, 0xF9, 0xC4), LV_COLOR_MAKE(0xFF, 0xFD, 0xE7)},
+        {LV_COLOR_MAKE(0xFF, 0xCA, 0x28), LV_COLOR_MAKE(0xFF, 0xD5, 0x4F), LV_COLOR_MAKE(0xFF, 0xE0, 0x82), LV_COLOR_MAKE(0xFF, 0xEC, 0xB3), LV_COLOR_MAKE(0xFF, 0xF8, 0xE1)},
+        {LV_COLOR_MAKE(0xFF, 0xA7, 0x26), LV_COLOR_MAKE(0xFF, 0xB7, 0x4D), LV_COLOR_MAKE(0xFF, 0xCC, 0x80), LV_COLOR_MAKE(0xFF, 0xE0, 0xB2), LV_COLOR_MAKE(0xFF, 0xF3, 0xE0)},
+        {LV_COLOR_MAKE(0xFF, 0x70, 0x43), LV_COLOR_MAKE(0xFF, 0x8A, 0x65), LV_COLOR_MAKE(0xFF, 0xAB, 0x91), LV_COLOR_MAKE(0xFF, 0xCC, 0xBC), LV_COLOR_MAKE(0xFB, 0xE9, 0xE7)},
+        {LV_COLOR_MAKE(0x8D, 0x6E, 0x63), LV_COLOR_MAKE(0xA1, 0x88, 0x7F), LV_COLOR_MAKE(0xBC, 0xAA, 0xA4), LV_COLOR_MAKE(0xD7, 0xCC, 0xC8), LV_COLOR_MAKE(0xEF, 0xEB, 0xE9)},
+        {LV_COLOR_MAKE(0x78, 0x90, 0x9C), LV_COLOR_MAKE(0x90, 0xA4, 0xAE), LV_COLOR_MAKE(0xB0, 0xBE, 0xC5), LV_COLOR_MAKE(0xCF, 0xD8, 0xDC), LV_COLOR_MAKE(0xEC, 0xEF, 0xF1)},
+        {LV_COLOR_MAKE(0xBD, 0xBD, 0xBD), LV_COLOR_MAKE(0xE0, 0xE0, 0xE0), LV_COLOR_MAKE(0xEE, 0xEE, 0xEE), LV_COLOR_MAKE(0xF5, 0xF5, 0xF5), LV_COLOR_MAKE(0xFA, 0xFA, 0xFA)},
     };
 
-     if(p >= _LV_PALETTE_LAST) {
-         LV_LOG_WARN("Invalid palette: %d", p);
-         return lv_color_black();
-     }
+    if(p >= _LV_PALETTE_LAST) {
+        LV_LOG_WARN("Invalid palette: %d", p);
+        return lv_color_black();
+    }
 
-     if(lvl == 0 || lvl > 5) {
-         LV_LOG_WARN("Invalid level: %d. Must be 1..5", lvl);
-         return lv_color_black();
-     }
+    if(lvl == 0 || lvl > 5) {
+        LV_LOG_WARN("Invalid level: %d. Must be 1..5", lvl);
+        return lv_color_black();
+    }
 
-     lvl--;
+    lvl--;
 
-     return colors[p][lvl];
+    return colors[p][lvl];
 }
 
 lv_color_t lv_palette_darken(lv_palette_t p, uint8_t lvl)
 {
     static const lv_color_t colors[][4] = {
-            {LV_COLOR_MAKE(0xE5, 0x39, 0x35), LV_COLOR_MAKE(0xD3, 0x2F, 0x2F), LV_COLOR_MAKE(0xC6, 0x28, 0x28), LV_COLOR_MAKE(0xB7, 0x1C, 0x1C)},
-            {LV_COLOR_MAKE(0xD8, 0x1B, 0x60), LV_COLOR_MAKE(0xC2, 0x18, 0x5B), LV_COLOR_MAKE(0xAD, 0x14, 0x57), LV_COLOR_MAKE(0x88, 0x0E, 0x4F)},
-            {LV_COLOR_MAKE(0x8E, 0x24, 0xAA), LV_COLOR_MAKE(0x7B, 0x1F, 0xA2), LV_COLOR_MAKE(0x6A, 0x1B, 0x9A), LV_COLOR_MAKE(0x4A, 0x14, 0x8C)},
-            {LV_COLOR_MAKE(0x5E, 0x35, 0xB1), LV_COLOR_MAKE(0x51, 0x2D, 0xA8), LV_COLOR_MAKE(0x45, 0x27, 0xA0), LV_COLOR_MAKE(0x31, 0x1B, 0x92)},
-            {LV_COLOR_MAKE(0x39, 0x49, 0xAB), LV_COLOR_MAKE(0x30, 0x3F, 0x9F), LV_COLOR_MAKE(0x28, 0x35, 0x93), LV_COLOR_MAKE(0x1A, 0x23, 0x7E)},
-            {LV_COLOR_MAKE(0x1E, 0x88, 0xE5), LV_COLOR_MAKE(0x19, 0x76, 0xD2), LV_COLOR_MAKE(0x15, 0x65, 0xC0), LV_COLOR_MAKE(0x0D, 0x47, 0xA1)},
-            {LV_COLOR_MAKE(0x03, 0x9B, 0xE5), LV_COLOR_MAKE(0x02, 0x88, 0xD1), LV_COLOR_MAKE(0x02, 0x77, 0xBD), LV_COLOR_MAKE(0x01, 0x57, 0x9B)},
-            {LV_COLOR_MAKE(0x00, 0xAC, 0xC1), LV_COLOR_MAKE(0x00, 0x97, 0xA7), LV_COLOR_MAKE(0x00, 0x83, 0x8F), LV_COLOR_MAKE(0x00, 0x60, 0x64)},
-            {LV_COLOR_MAKE(0x00, 0x89, 0x7B), LV_COLOR_MAKE(0x00, 0x79, 0x6B), LV_COLOR_MAKE(0x00, 0x69, 0x5C), LV_COLOR_MAKE(0x00, 0x4D, 0x40)},
-            {LV_COLOR_MAKE(0x43, 0xA0, 0x47), LV_COLOR_MAKE(0x38, 0x8E, 0x3C), LV_COLOR_MAKE(0x2E, 0x7D, 0x32), LV_COLOR_MAKE(0x1B, 0x5E, 0x20)},
-            {LV_COLOR_MAKE(0x7C, 0xB3, 0x42), LV_COLOR_MAKE(0x68, 0x9F, 0x38), LV_COLOR_MAKE(0x55, 0x8B, 0x2F), LV_COLOR_MAKE(0x33, 0x69, 0x1E)},
-            {LV_COLOR_MAKE(0xC0, 0xCA, 0x33), LV_COLOR_MAKE(0xAF, 0xB4, 0x2B), LV_COLOR_MAKE(0x9E, 0x9D, 0x24), LV_COLOR_MAKE(0x82, 0x77, 0x17)},
-            {LV_COLOR_MAKE(0xFD, 0xD8, 0x35), LV_COLOR_MAKE(0xFB, 0xC0, 0x2D), LV_COLOR_MAKE(0xF9, 0xA8, 0x25), LV_COLOR_MAKE(0xF5, 0x7F, 0x17)},
-            {LV_COLOR_MAKE(0xFF, 0xB3, 0x00), LV_COLOR_MAKE(0xFF, 0xA0, 0x00), LV_COLOR_MAKE(0xFF, 0x8F, 0x00), LV_COLOR_MAKE(0xFF, 0x6F, 0x00)},
-            {LV_COLOR_MAKE(0xFB, 0x8C, 0x00), LV_COLOR_MAKE(0xF5, 0x7C, 0x00), LV_COLOR_MAKE(0xEF, 0x6C, 0x00), LV_COLOR_MAKE(0xE6, 0x51, 0x00)},
-            {LV_COLOR_MAKE(0xF4, 0x51, 0x1E), LV_COLOR_MAKE(0xE6, 0x4A, 0x19), LV_COLOR_MAKE(0xD8, 0x43, 0x15), LV_COLOR_MAKE(0xBF, 0x36, 0x0C)},
-            {LV_COLOR_MAKE(0x6D, 0x4C, 0x41), LV_COLOR_MAKE(0x5D, 0x40, 0x37), LV_COLOR_MAKE(0x4E, 0x34, 0x2E), LV_COLOR_MAKE(0x3E, 0x27, 0x23)},
-            {LV_COLOR_MAKE(0x54, 0x6E, 0x7A), LV_COLOR_MAKE(0x45, 0x5A, 0x64), LV_COLOR_MAKE(0x37, 0x47, 0x4F), LV_COLOR_MAKE(0x26, 0x32, 0x38)},
-            {LV_COLOR_MAKE(0x75, 0x75, 0x75), LV_COLOR_MAKE(0x61, 0x61, 0x61), LV_COLOR_MAKE(0x42, 0x42, 0x42), LV_COLOR_MAKE(0x21, 0x21, 0x21)},
+        {LV_COLOR_MAKE(0xE5, 0x39, 0x35), LV_COLOR_MAKE(0xD3, 0x2F, 0x2F), LV_COLOR_MAKE(0xC6, 0x28, 0x28), LV_COLOR_MAKE(0xB7, 0x1C, 0x1C)},
+        {LV_COLOR_MAKE(0xD8, 0x1B, 0x60), LV_COLOR_MAKE(0xC2, 0x18, 0x5B), LV_COLOR_MAKE(0xAD, 0x14, 0x57), LV_COLOR_MAKE(0x88, 0x0E, 0x4F)},
+        {LV_COLOR_MAKE(0x8E, 0x24, 0xAA), LV_COLOR_MAKE(0x7B, 0x1F, 0xA2), LV_COLOR_MAKE(0x6A, 0x1B, 0x9A), LV_COLOR_MAKE(0x4A, 0x14, 0x8C)},
+        {LV_COLOR_MAKE(0x5E, 0x35, 0xB1), LV_COLOR_MAKE(0x51, 0x2D, 0xA8), LV_COLOR_MAKE(0x45, 0x27, 0xA0), LV_COLOR_MAKE(0x31, 0x1B, 0x92)},
+        {LV_COLOR_MAKE(0x39, 0x49, 0xAB), LV_COLOR_MAKE(0x30, 0x3F, 0x9F), LV_COLOR_MAKE(0x28, 0x35, 0x93), LV_COLOR_MAKE(0x1A, 0x23, 0x7E)},
+        {LV_COLOR_MAKE(0x1E, 0x88, 0xE5), LV_COLOR_MAKE(0x19, 0x76, 0xD2), LV_COLOR_MAKE(0x15, 0x65, 0xC0), LV_COLOR_MAKE(0x0D, 0x47, 0xA1)},
+        {LV_COLOR_MAKE(0x03, 0x9B, 0xE5), LV_COLOR_MAKE(0x02, 0x88, 0xD1), LV_COLOR_MAKE(0x02, 0x77, 0xBD), LV_COLOR_MAKE(0x01, 0x57, 0x9B)},
+        {LV_COLOR_MAKE(0x00, 0xAC, 0xC1), LV_COLOR_MAKE(0x00, 0x97, 0xA7), LV_COLOR_MAKE(0x00, 0x83, 0x8F), LV_COLOR_MAKE(0x00, 0x60, 0x64)},
+        {LV_COLOR_MAKE(0x00, 0x89, 0x7B), LV_COLOR_MAKE(0x00, 0x79, 0x6B), LV_COLOR_MAKE(0x00, 0x69, 0x5C), LV_COLOR_MAKE(0x00, 0x4D, 0x40)},
+        {LV_COLOR_MAKE(0x43, 0xA0, 0x47), LV_COLOR_MAKE(0x38, 0x8E, 0x3C), LV_COLOR_MAKE(0x2E, 0x7D, 0x32), LV_COLOR_MAKE(0x1B, 0x5E, 0x20)},
+        {LV_COLOR_MAKE(0x7C, 0xB3, 0x42), LV_COLOR_MAKE(0x68, 0x9F, 0x38), LV_COLOR_MAKE(0x55, 0x8B, 0x2F), LV_COLOR_MAKE(0x33, 0x69, 0x1E)},
+        {LV_COLOR_MAKE(0xC0, 0xCA, 0x33), LV_COLOR_MAKE(0xAF, 0xB4, 0x2B), LV_COLOR_MAKE(0x9E, 0x9D, 0x24), LV_COLOR_MAKE(0x82, 0x77, 0x17)},
+        {LV_COLOR_MAKE(0xFD, 0xD8, 0x35), LV_COLOR_MAKE(0xFB, 0xC0, 0x2D), LV_COLOR_MAKE(0xF9, 0xA8, 0x25), LV_COLOR_MAKE(0xF5, 0x7F, 0x17)},
+        {LV_COLOR_MAKE(0xFF, 0xB3, 0x00), LV_COLOR_MAKE(0xFF, 0xA0, 0x00), LV_COLOR_MAKE(0xFF, 0x8F, 0x00), LV_COLOR_MAKE(0xFF, 0x6F, 0x00)},
+        {LV_COLOR_MAKE(0xFB, 0x8C, 0x00), LV_COLOR_MAKE(0xF5, 0x7C, 0x00), LV_COLOR_MAKE(0xEF, 0x6C, 0x00), LV_COLOR_MAKE(0xE6, 0x51, 0x00)},
+        {LV_COLOR_MAKE(0xF4, 0x51, 0x1E), LV_COLOR_MAKE(0xE6, 0x4A, 0x19), LV_COLOR_MAKE(0xD8, 0x43, 0x15), LV_COLOR_MAKE(0xBF, 0x36, 0x0C)},
+        {LV_COLOR_MAKE(0x6D, 0x4C, 0x41), LV_COLOR_MAKE(0x5D, 0x40, 0x37), LV_COLOR_MAKE(0x4E, 0x34, 0x2E), LV_COLOR_MAKE(0x3E, 0x27, 0x23)},
+        {LV_COLOR_MAKE(0x54, 0x6E, 0x7A), LV_COLOR_MAKE(0x45, 0x5A, 0x64), LV_COLOR_MAKE(0x37, 0x47, 0x4F), LV_COLOR_MAKE(0x26, 0x32, 0x38)},
+        {LV_COLOR_MAKE(0x75, 0x75, 0x75), LV_COLOR_MAKE(0x61, 0x61, 0x61), LV_COLOR_MAKE(0x42, 0x42, 0x42), LV_COLOR_MAKE(0x21, 0x21, 0x21)},
     };
 
-     if(p >= _LV_PALETTE_LAST) {
-         LV_LOG_WARN("Invalid palette: %d", p);
-         return lv_color_black();
-     }
+    if(p >= _LV_PALETTE_LAST) {
+        LV_LOG_WARN("Invalid palette: %d", p);
+        return lv_color_black();
+    }
 
-     if(lvl == 0 || lvl > 4) {
-         LV_LOG_WARN("Invalid level: %d. Must be 1..4", lvl);
-         return lv_color_black();
-     }
+    if(lvl == 0 || lvl > 4) {
+        LV_LOG_WARN("Invalid level: %d. Must be 1..4", lvl);
+        return lv_color_black();
+    }
 
-     lvl--;
+    lvl--;
 
-     return colors[p][lvl];
+    return colors[p][lvl];
 }
-
-
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_color.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_color.h
index fffd7dabd..ca226102a 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_color.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_color.h
@@ -14,6 +14,7 @@ extern "C" {
  *      INCLUDES
  *********************/
 #include "../lv_conf_internal.h"
+#include "lv_assert.h"
 #include "lv_math.h"
 #include "lv_types.h"
 
@@ -35,6 +36,8 @@ extern "C" {
 /*********************
  *      DEFINES
  *********************/
+LV_EXPORT_CONST_INT(LV_COLOR_DEPTH);
+LV_EXPORT_CONST_INT(LV_COLOR_16_SWAP);
 
 /**
  * Opacity percentages.
@@ -70,23 +73,6 @@ enum {
 #error "Invalid LV_COLOR_DEPTH in lv_conf.h! Set it to 1, 8, 16 or 32!"
 #endif
 
-/**
- * Adjust color mix functions rounding.
- * GPUs might calculate color mix (blending) differently.
- * Should be in range of 0..254
- * 0: no adjustment, get the integer part of the result (round down)
- * 64: round up from x.75
- * 128: round up from half
- * 192: round up from x.25
- * 254: round up*/
-#ifndef LV_COLOR_MIX_ROUND_OFS
-#if LV_COLOR_DEPTH == 32
-#define LV_COLOR_MIX_ROUND_OFS 0
-#else
-#define LV_COLOR_MIX_ROUND_OFS 128
-#endif
-#endif
-
 #if defined(__cplusplus) && !defined(_LV_COLOR_HAS_MODERN_CPP)
 /**
 * MSVC compiler's definition of the __cplusplus indicating 199711L regardless to C++ standard version
@@ -201,8 +187,6 @@ enum {
 #define _LV_COLOR_ZERO_INITIALIZER LV_CONCAT(_LV_COLOR_ZERO_INITIALIZER, LV_COLOR_DEPTH)
 #define LV_COLOR_MAKE(r8, g8, b8) LV_CONCAT(LV_COLOR_MAKE, LV_COLOR_DEPTH)(r8, g8, b8)
 
-#define LV_UDIV255(x) ((uint32_t)((uint32_t) (x) * 0x8081) >> 0x17)
-
 /**********************
  *      TYPEDEFS
  **********************/
@@ -272,7 +256,7 @@ typedef lv_color_t (*lv_color_filter_cb_t)(const struct _lv_color_filter_dsc_t *
 typedef struct _lv_color_filter_dsc_t {
     lv_color_filter_cb_t filter_cb;
     void * user_data;
-}lv_color_filter_dsc_t;
+} lv_color_filter_dsc_t;
 
 
 typedef enum {
@@ -297,7 +281,7 @@ typedef enum {
     LV_PALETTE_GREY,
     _LV_PALETTE_LAST,
     LV_PALETTE_NONE = 0xff,
-}lv_palette_t;
+} lv_palette_t;
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -459,14 +443,23 @@ static inline uint32_t lv_color_to32(lv_color_t color)
 LV_ATTRIBUTE_FAST_MEM static inline lv_color_t lv_color_mix(lv_color_t c1, lv_color_t c2, uint8_t mix)
 {
     lv_color_t ret;
-#if LV_COLOR_DEPTH != 1
+
+#if LV_COLOR_DEPTH == 16 && LV_COLOR_16_SWAP == 0
+    /*Source: https://stackoverflow.com/a/50012418/1999969*/
+    mix = (mix + 4) >> 3;
+    uint32_t bg = (uint32_t)((uint32_t)c2.full | ((uint32_t)c2.full << 16)) &
+                  0x7E0F81F; /*0b00000111111000001111100000011111*/
+    uint32_t fg = (uint32_t)((uint32_t)c1.full | ((uint32_t)c1.full << 16)) & 0x7E0F81F;
+    uint32_t result = ((((fg - bg) * mix) >> 5) + bg) & 0x7E0F81F;
+    ret.full = (uint16_t)((result >> 16) | result);
+#elif LV_COLOR_DEPTH != 1
     /*LV_COLOR_DEPTH == 8, 16 or 32*/
-    LV_COLOR_SET_R(ret, LV_UDIV255((uint16_t) LV_COLOR_GET_R(c1) * mix + LV_COLOR_GET_R(c2) *
-                                        (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
-    LV_COLOR_SET_G(ret, LV_UDIV255((uint16_t) LV_COLOR_GET_G(c1) * mix + LV_COLOR_GET_G(c2) *
-                                        (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
-    LV_COLOR_SET_B(ret, LV_UDIV255((uint16_t) LV_COLOR_GET_B(c1) * mix + LV_COLOR_GET_B(c2) *
-                                        (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
+    LV_COLOR_SET_R(ret, LV_UDIV255((uint16_t)LV_COLOR_GET_R(c1) * mix + LV_COLOR_GET_R(c2) *
+                                   (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
+    LV_COLOR_SET_G(ret, LV_UDIV255((uint16_t)LV_COLOR_GET_G(c1) * mix + LV_COLOR_GET_G(c2) *
+                                   (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
+    LV_COLOR_SET_B(ret, LV_UDIV255((uint16_t)LV_COLOR_GET_B(c1) * mix + LV_COLOR_GET_B(c2) *
+                                   (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
     LV_COLOR_SET_A(ret, 0xFF);
 #else
     /*LV_COLOR_DEPTH == 1*/
@@ -479,9 +472,9 @@ LV_ATTRIBUTE_FAST_MEM static inline lv_color_t lv_color_mix(lv_color_t c1, lv_co
 LV_ATTRIBUTE_FAST_MEM static inline void lv_color_premult(lv_color_t c, uint8_t mix, uint16_t * out)
 {
 #if LV_COLOR_DEPTH != 1
-    out[0] = (uint16_t) LV_COLOR_GET_R(c) * mix;
-    out[1] = (uint16_t) LV_COLOR_GET_G(c) * mix;
-    out[2] = (uint16_t) LV_COLOR_GET_B(c) * mix;
+    out[0] = (uint16_t)LV_COLOR_GET_R(c) * mix;
+    out[1] = (uint16_t)LV_COLOR_GET_G(c) * mix;
+    out[2] = (uint16_t)LV_COLOR_GET_B(c) * mix;
 #else
     (void) mix;
     /*Pre-multiplication can't be used with 1 bpp*/
@@ -505,7 +498,7 @@ LV_ATTRIBUTE_FAST_MEM static inline lv_color_t lv_color_mix_premult(uint16_t * p
 {
     lv_color_t ret;
 #if LV_COLOR_DEPTH != 1
-    /*LV_COLOR_DEPTH == 8, 16 or 32*/
+    /*LV_COLOR_DEPTH == 8 or 32*/
     LV_COLOR_SET_R(ret, LV_UDIV255(premult_c1[0] + LV_COLOR_GET_R(c2) * mix + LV_COLOR_MIX_ROUND_OFS));
     LV_COLOR_SET_G(ret, LV_UDIV255(premult_c1[1] + LV_COLOR_GET_G(c2) * mix + LV_COLOR_MIX_ROUND_OFS));
     LV_COLOR_SET_B(ret, LV_UDIV255(premult_c1[2] + LV_COLOR_GET_B(c2) * mix + LV_COLOR_MIX_ROUND_OFS));
@@ -570,10 +563,7 @@ LV_ATTRIBUTE_FAST_MEM static inline void lv_color_mix_with_alpha(lv_color_t bg_c
             /*Info:
              * https://en.wikipedia.org/wiki/Alpha_compositing#Analytical_derivation_of_the_over_operator*/
             res_opa_saved = 255 - ((uint16_t)((uint16_t)(255 - fg_opa) * (255 - bg_opa)) >> 8);
-            if(res_opa_saved == 0) {
-                while(1)
-                    ;
-            }
+            LV_ASSERT(res_opa_saved != 0);
             lv_opa_t ratio = (uint16_t)((uint16_t)fg_opa * 255) / res_opa_saved;
             res_color_saved = lv_color_mix(fg_color, bg_color, ratio);
 
@@ -671,8 +661,14 @@ static inline lv_color_t lv_color_chroma_key(void)
 /*Source: https://vuetifyjs.com/en/styles/colors/#material-colors*/
 
 lv_color_t lv_palette_main(lv_palette_t p);
-static inline lv_color_t lv_color_white(void) { return lv_color_make(0xff, 0xff, 0xff);}
-static inline lv_color_t lv_color_black(void) { return lv_color_make(0x00, 0x0, 0x00);}
+static inline lv_color_t lv_color_white(void)
+{
+    return lv_color_make(0xff, 0xff, 0xff);
+}
+static inline lv_color_t lv_color_black(void)
+{
+    return lv_color_make(0x00, 0x0, 0x00);
+}
 lv_color_t lv_palette_lighten(lv_palette_t p, uint8_t lvl);
 lv_color_t lv_palette_darken(lv_palette_t p, uint8_t lvl);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_fs.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_fs.c
index 6d6444331..8011b4cf4 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_fs.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_fs.c
@@ -8,9 +8,9 @@
  *********************/
 #include "lv_fs.h"
 
-#include "../misc/lv_assert.h"
-#include "lv_ll.h"
 #include <string.h>
+#include "lv_assert.h"
+#include "lv_ll.h"
 #include "lv_gc.h"
 
 /*********************
@@ -91,9 +91,9 @@ lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mo
     }
 
     const char * real_path = lv_fs_get_real_path(path);
-    void *file_d = drv->open_cb(drv, real_path, mode);
+    void * file_d = drv->open_cb(drv, real_path, mode);
 
-    if(file_d == NULL || file_d == (void*)(-1)) {
+    if(file_d == NULL || file_d == (void *)(-1)) {
         return LV_FS_RES_UNKNOWN;
     }
 
@@ -163,26 +163,22 @@ lv_fs_res_t lv_fs_seek(lv_fs_file_t * file_p, uint32_t pos, lv_fs_whence_t whenc
         return LV_FS_RES_NOT_IMP;
     }
 
-    lv_fs_res_t res = file_p->drv->seek_cb(file_p->drv, file_p->file_d, pos, whence);
-
-    return res;
+    return file_p->drv->seek_cb(file_p->drv, file_p->file_d, pos, whence);
 }
 
 lv_fs_res_t lv_fs_tell(lv_fs_file_t * file_p, uint32_t * pos)
 {
+    *pos = 0;
+
     if(file_p->drv == NULL) {
-        *pos = 0;
         return LV_FS_RES_INV_PARAM;
     }
 
     if(file_p->drv->tell_cb == NULL) {
-        *pos = 0;
         return LV_FS_RES_NOT_IMP;
     }
 
-    lv_fs_res_t res = file_p->drv->tell_cb(file_p->drv, file_p->file_d, pos);
-
-    return res;
+    return file_p->drv->tell_cb(file_p->drv, file_p->file_d, pos);
 }
 
 lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path)
@@ -207,9 +203,9 @@ lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path)
     }
 
     const char * real_path = lv_fs_get_real_path(path);
-    void *dir_d = drv->dir_open_cb(drv, real_path);
+    void * dir_d = drv->dir_open_cb(drv, real_path);
 
-    if(dir_d == NULL || dir_d == (void*)(-1)) {
+    if(dir_d == NULL || dir_d == (void *)(-1)) {
         return LV_FS_RES_UNKNOWN;
     }
 
@@ -221,19 +217,17 @@ lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path)
 
 lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t * rddir_p, char * fn)
 {
+    fn[0] = '\0';
+
     if(rddir_p->drv == NULL || rddir_p->dir_d == NULL) {
-        fn[0] = '\0';
         return LV_FS_RES_INV_PARAM;
     }
 
     if(rddir_p->drv->dir_read_cb == NULL) {
-        fn[0] = '\0';
         return LV_FS_RES_NOT_IMP;
     }
 
-    lv_fs_res_t res = rddir_p->drv->dir_read_cb(rddir_p->drv, rddir_p->dir_d, fn);
-
-    return res;
+    return rddir_p->drv->dir_read_cb(rddir_p->drv, rddir_p->dir_d, fn);
 }
 
 lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t * rddir_p)
@@ -302,10 +296,10 @@ const char * lv_fs_get_ext(const char * fn)
 {
     size_t i;
     for(i = strlen(fn); i > 0; i--) {
-        if(fn[i] == '.') {
-            return &fn[i + 1];
+        if(fn[i - 1] == '.') {
+            return &fn[i];
         }
-        else if(fn[i] == '/' || fn[i] == '\\') {
+        else if(fn[i - 1] == '/' || fn[i - 1] == '\\') {
             return ""; /*No extension if a '\' or '/' found*/
         }
     }
@@ -331,11 +325,12 @@ char * lv_fs_up(char * path)
 
     size_t i;
     for(i = len; i > 0; i--) {
-        if(path[i] == '/' || path[i] == '\\') break;
+        if(path[i - 1] == '/' || path[i - 1] == '\\') {
+            path[i - 1] = '\0';
+            break;
+        }
     }
 
-    if(i > 0) path[i] = '\0';
-
     return path;
 }
 
@@ -356,14 +351,12 @@ const char * lv_fs_get_last(const char * path)
 
     size_t i;
     for(i = len; i > 0; i--) {
-        if(path[i] == '/' || path[i] == '\\') break;
+        if(path[i - 1] == '/' || path[i - 1] == '\\') break;
     }
 
-    /*No '/' or '\' in the path so return with path itself*/
-    if(i == 0) return path;
-
-    return &path[i + 1];
+    return &path[i];
 }
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_fs.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_fs.h
index 85c1e33f3..9afc2bf57 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_fs.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_fs.h
@@ -65,7 +65,7 @@ typedef enum {
     LV_FS_SEEK_SET = 0x00,      /**< Set the position from absolutely (from the start of file)*/
     LV_FS_SEEK_CUR = 0x01,      /**< Set the position from the current position*/
     LV_FS_SEEK_END = 0x02,      /**< Set the position from the end of the file*/
-}lv_fs_whence_t;
+} lv_fs_whence_t;
 
 typedef struct _lv_fs_drv_t {
     char letter;
@@ -110,134 +110,135 @@ void _lv_fs_init(void);
  * Initialize a file system driver with default values.
  * It is used to surly have known values in the fields ant not memory junk.
  * After it you can set the fields.
- * @param drv pointer to driver variable to initialize
+ * @param drv     pointer to driver variable to initialize
  */
 void lv_fs_drv_init(lv_fs_drv_t * drv);
 
 /**
  * Add a new drive
- * @param drv_p pointer to an lv_fs_drv_t structure which is inited with the
- * corresponding function pointers.
- * Only pointer is saved, so the driver should be static or dynamically allocated.
+ * @param drv       pointer to an lv_fs_drv_t structure which is inited with the
+ *                  corresponding function pointers. Only pointer is saved, so the
+ *                  driver should be static or dynamically allocated.
  */
-void lv_fs_drv_register(lv_fs_drv_t * drv_p);
+void lv_fs_drv_register(lv_fs_drv_t * drv);
 
 /**
  * Give a pointer to a driver from its letter
- * @param letter the driver letter
- * @return pointer to a driver or NULL if not found
+ * @param letter    the driver letter
+ * @return          pointer to a driver or NULL if not found
  */
 lv_fs_drv_t * lv_fs_get_drv(char letter);
 
 /**
  * Test if a drive is ready or not. If the `ready` function was not initialized `true` will be
  * returned.
- * @param letter letter of the drive
- * @return true: drive is ready; false: drive is not ready
+ * @param letter    letter of the drive
+ * @return          true: drive is ready; false: drive is not ready
  */
 bool lv_fs_is_ready(char letter);
 
 /**
  * Open a file
- * @param file_p pointer to a lv_fs_file_t variable
- * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
- * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
- * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @param file_p    pointer to a lv_fs_file_t variable
+ * @param path      path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode      read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return          LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mode);
 
 /**
  * Close an already opened file
- * @param file_p pointer to a lv_fs_file_t variable
- * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @param file_p    pointer to a lv_fs_file_t variable
+ * @return          LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p);
 
 /**
  * Read from a file
- * @param file_p pointer to a lv_fs_file_t variable
- * @param buf pointer to a buffer where the read bytes are stored
- * @param btr Bytes To Read
- * @param br the number of real read bytes (Bytes Read). NULL if unused.
- * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @param file_p    pointer to a lv_fs_file_t variable
+ * @param buf       pointer to a buffer where the read bytes are stored
+ * @param btr       Bytes To Read
+ * @param br        the number of real read bytes (Bytes Read). NULL if unused.
+ * @return          LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_read(lv_fs_file_t * file_p, void * buf, uint32_t btr, uint32_t * br);
 
 /**
  * Write into a file
- * @param file_p pointer to a lv_fs_file_t variable
- * @param buf pointer to a buffer with the bytes to write
- * @param btr Bytes To Write
- * @param br the number of real written bytes (Bytes Written). NULL if unused.
- * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @param file_p    pointer to a lv_fs_file_t variable
+ * @param buf       pointer to a buffer with the bytes to write
+ * @param btr       Bytes To Write
+ * @param br        the number of real written bytes (Bytes Written). NULL if unused.
+ * @return          LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_write(lv_fs_file_t * file_p, const void * buf, uint32_t btw, uint32_t * bw);
 
 /**
  * Set the position of the 'cursor' (read write pointer) in a file
- * @param file_p pointer to a lv_fs_file_t variable
- * @param pos the new position expressed in bytes index (0: start of file)
- * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @param file_p    pointer to a lv_fs_file_t variable
+ * @param pos       the new position expressed in bytes index (0: start of file)
+ * @param whence    tells from where set the position. See @lv_fs_whence_t
+ * @return          LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_seek(lv_fs_file_t * file_p, uint32_t pos, lv_fs_whence_t whence);
 
 /**
  * Give the position of the read write pointer
- * @param file_p pointer to a lv_fs_file_t variable
- * @param pos_p pointer to store the position of the read write pointer
- * @return LV_FS_RES_OK or any error from 'fs_res_t'
+ * @param file_p    pointer to a lv_fs_file_t variable
+ * @param pos_p     pointer to store the position of the read write pointer
+ * @return          LV_FS_RES_OK or any error from 'fs_res_t'
  */
 lv_fs_res_t lv_fs_tell(lv_fs_file_t * file_p, uint32_t * pos);
 
 /**
  * Initialize a 'fs_dir_t' variable for directory reading
- * @param rddir_p pointer to a 'lv_fs_dir_t' variable
- * @param path path to a directory
- * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @param rddir_p   pointer to a 'lv_fs_dir_t' variable
+ * @param path      path to a directory
+ * @return          LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path);
 
 /**
  * Read the next filename form a directory.
  * The name of the directories will begin with '/'
- * @param rddir_p pointer to an initialized 'fs_dir_t' variable
- * @param fn pointer to a buffer to store the filename
- * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @param rddir_p   pointer to an initialized 'fs_dir_t' variable
+ * @param fn        pointer to a buffer to store the filename
+ * @return          LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t * rddir_p, char * fn);
 
 /**
  * Close the directory reading
- * @param rddir_p pointer to an initialized 'fs_dir_t' variable
- * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @param rddir_p   pointer to an initialized 'fs_dir_t' variable
+ * @return          LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t * rddir_p);
 
 /**
  * Fill a buffer with the letters of existing drivers
- * @param buf buffer to store the letters ('\0' added after the last letter)
- * @return the buffer
+ * @param buf       buffer to store the letters ('\0' added after the last letter)
+ * @return          the buffer
  */
 char * lv_fs_get_letters(char * buf);
 
 /**
  * Return with the extension of the filename
- * @param fn string with a filename
- * @return pointer to the beginning extension or empty string if no extension
+ * @param fn        string with a filename
+ * @return          pointer to the beginning extension or empty string if no extension
  */
 const char * lv_fs_get_ext(const char * fn);
 
 /**
  * Step up one level
- * @param path pointer to a file name
- * @return the truncated file name
+ * @param path      pointer to a file name
+ * @return          the truncated file name
  */
 char * lv_fs_up(char * path);
 
 /**
  * Get the last element of a path (e.g. U:/folder/file -> file)
- * @param path pointer to a file name
- * @return pointer to the beginning of the last element in the path
+ * @param path      pointer to a file name
+ * @return          pointer to the beginning of the last element in the path
  */
 const char * lv_fs_get_last(const char * path);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_gc.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_gc.c
index ca163fee0..95bb5499a 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_gc.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_gc.c
@@ -6,9 +6,7 @@
 /*********************
  *      INCLUDES
  *********************/
-
 #include "lv_gc.h"
-#include "string.h"
 
 /*********************
  *      DEFINES
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_gc.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_gc.h
index 00b5fee7d..dac62be26 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_gc.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_gc.h
@@ -13,11 +13,12 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
+#include "../lv_conf_internal.h"
 #include <stdint.h>
-#include <stdbool.h>
 #include "lv_mem.h"
 #include "lv_ll.h"
 #include "lv_timer.h"
+#include "lv_types.h"
 #include "../draw/lv_img_cache.h"
 #include "../draw/lv_draw_mask.h"
 #include "../core/lv_obj_pos.h"
@@ -39,22 +40,23 @@ extern "C" {
 #define LV_DISPATCH10(f, t, n)
 #define LV_DISPATCH11(f, t, n)          LV_DISPATCH(f, t, n)
 
-#define LV_ITERATE_ROOTS(f)                                                                 \
-    LV_DISPATCH(f, lv_ll_t, _lv_timer_ll) /*Linked list to store the lv_timers*/            \
-    LV_DISPATCH(f, lv_ll_t, _lv_disp_ll)  /*Linked list of display device*/                 \
-    LV_DISPATCH(f, lv_ll_t, _lv_indev_ll) /*Linked list of input device*/                   \
-    LV_DISPATCH(f, lv_ll_t, _lv_fsdrv_ll)                                                   \
-    LV_DISPATCH(f, lv_ll_t, _lv_anim_ll)                                                    \
-    LV_DISPATCH(f, lv_ll_t, _lv_group_ll)                                                   \
-    LV_DISPATCH(f, lv_ll_t, _lv_img_decoder_ll)                                             \
-    LV_DISPATCH(f, lv_ll_t, _lv_obj_style_trans_ll)                                         \
-    LV_DISPATCH(f, lv_layout_dsc_t *, _lv_layout_list)      \
-    LV_DISPATCH_COND(f, _lv_img_cache_entry_t*, _lv_img_cache_array, LV_IMG_CACHE_DEF, 1)    \
-    LV_DISPATCH_COND(f, _lv_img_cache_entry_t, _lv_img_cache_single, LV_IMG_CACHE_DEF, 0)    \
-    LV_DISPATCH(f, lv_timer_t*, _lv_timer_act)                                              \
-    LV_DISPATCH(f, lv_mem_buf_arr_t , lv_mem_buf)                                           \
-    LV_DISPATCH_COND(f, _lv_draw_mask_saved_arr_t , _lv_draw_mask_list, LV_DRAW_COMPLEX, 1) \
-    LV_DISPATCH(f, void * , _lv_theme_default_styles)                                       \
+#define LV_ITERATE_ROOTS(f)                                                                            \
+    LV_DISPATCH(f, lv_ll_t, _lv_timer_ll) /*Linked list to store the lv_timers*/                       \
+    LV_DISPATCH(f, lv_ll_t, _lv_disp_ll)  /*Linked list of display device*/                            \
+    LV_DISPATCH(f, lv_ll_t, _lv_indev_ll) /*Linked list of input device*/                              \
+    LV_DISPATCH(f, lv_ll_t, _lv_fsdrv_ll)                                                              \
+    LV_DISPATCH(f, lv_ll_t, _lv_anim_ll)                                                               \
+    LV_DISPATCH(f, lv_ll_t, _lv_group_ll)                                                              \
+    LV_DISPATCH(f, lv_ll_t, _lv_img_decoder_ll)                                                        \
+    LV_DISPATCH(f, lv_ll_t, _lv_obj_style_trans_ll)                                                    \
+    LV_DISPATCH(f, lv_layout_dsc_t *, _lv_layout_list)                                                 \
+    LV_DISPATCH_COND(f, _lv_img_cache_entry_t*, _lv_img_cache_array, LV_IMG_CACHE_DEF, 1)              \
+    LV_DISPATCH_COND(f, _lv_img_cache_entry_t, _lv_img_cache_single, LV_IMG_CACHE_DEF, 0)              \
+    LV_DISPATCH(f, lv_timer_t*, _lv_timer_act)                                                         \
+    LV_DISPATCH(f, lv_mem_buf_arr_t , lv_mem_buf)                                                      \
+    LV_DISPATCH_COND(f, _lv_draw_mask_radius_circle_dsc_arr_t , _lv_circle_cache, LV_DRAW_COMPLEX, 1)  \
+    LV_DISPATCH_COND(f, _lv_draw_mask_saved_arr_t , _lv_draw_mask_list, LV_DRAW_COMPLEX, 1)            \
+    LV_DISPATCH(f, void * , _lv_theme_default_styles)                                                  \
     LV_DISPATCH_COND(f, uint8_t *, _lv_font_decompr_buf, LV_USE_FONT_COMPRESSED, 1)
 
 #define LV_DEFINE_ROOT(root_type, root_name) root_type root_name;
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_ll.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_ll.c
index 30fb329a6..c84647ccf 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_ll.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_ll.c
@@ -7,9 +7,6 @@
 /*********************
  *      INCLUDES
  *********************/
-#include <stdint.h>
-#include <string.h>
-
 #include "lv_ll.h"
 #include "lv_mem.h"
 
@@ -44,7 +41,7 @@ static void node_set_next(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * nex
 
 /**
  * Initialize linked list
- * @param ll_dsc pointer to ll_dsc variable
+ * @param ll_p pointer to lv_ll_t variable
  * @param node_size the size of 1 node in bytes
  */
 void _lv_ll_init(lv_ll_t * ll_p, uint32_t node_size)
@@ -94,7 +91,7 @@ void * _lv_ll_ins_head(lv_ll_t * ll_p)
  * Insert a new node in front of the n_act node
  * @param ll_p pointer to linked list
  * @param n_act pointer a node
- * @return pointer to the new head
+ * @return pointer to the new node
  */
 void * _lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act)
 {
@@ -215,7 +212,7 @@ void _lv_ll_clear(lv_ll_t * ll_p)
  * @param ll_new_p pointer to the new linked list
  * @param node pointer to a node
  * @param head true: be the head in the new list
- *             false be the head in the new list
+ *             false be the tail in the new list
  */
 void _lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool head)
 {
@@ -265,7 +262,7 @@ void * _lv_ll_get_head(const lv_ll_t * ll_p)
 /**
  * Return with tail node of the linked list
  * @param ll_p pointer to linked list
- * @return pointer to the head of 'll_p'
+ * @return pointer to the tail of 'll_p'
  */
 void * _lv_ll_get_tail(const lv_ll_t * ll_p)
 {
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_ll.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_ll.h
index f5ce966a6..d38f69285 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_ll.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_ll.h
@@ -41,7 +41,7 @@ typedef struct {
 
 /**
  * Initialize linked list
- * @param ll_dsc pointer to ll_dsc variable
+ * @param ll_p pointer to lv_ll_t variable
  * @param node_size the size of 1 node in bytes
  */
 void _lv_ll_init(lv_ll_t * ll_p, uint32_t node_size);
@@ -57,7 +57,7 @@ void * _lv_ll_ins_head(lv_ll_t * ll_p);
  * Insert a new node in front of the n_act node
  * @param ll_p pointer to linked list
  * @param n_act pointer a node
- * @return pointer to the new head
+ * @return pointer to the new node
  */
 void * _lv_ll_ins_prev(lv_ll_t * ll_p, void * n_act);
 
@@ -88,7 +88,7 @@ void _lv_ll_clear(lv_ll_t * ll_p);
  * @param ll_new_p pointer to the new linked list
  * @param node pointer to a node
  * @param head true: be the head in the new list
- *             false be the head in the new list
+ *             false be the tail in the new list
  */
 void _lv_ll_chg_list(lv_ll_t * ll_ori_p, lv_ll_t * ll_new_p, void * node, bool head);
 
@@ -102,7 +102,7 @@ void * _lv_ll_get_head(const lv_ll_t * ll_p);
 /**
  * Return with tail node of the linked list
  * @param ll_p pointer to linked list
- * @return pointer to the head of 'll_p'
+ * @return pointer to the tail of 'll_p'
  */
 void * _lv_ll_get_tail(const lv_ll_t * ll_p);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_log.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_log.c
index 7e8661482..777849f9b 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_log.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_log.c
@@ -72,9 +72,6 @@ void _lv_log_add(lv_log_level_t level, const char * file, int line, const char *
     if(level >= LV_LOG_LEVEL) {
         va_list args;
         va_start(args, format);
-        char msg[256];
-        lv_vsnprintf(msg, sizeof(msg), format, args);
-        va_end(args);
 
         /*Use only the file name not the path*/
         size_t p;
@@ -85,22 +82,43 @@ void _lv_log_add(lv_log_level_t level, const char * file, int line, const char *
             }
         }
 
-        char buf[512];
         uint32_t t = lv_tick_get();
         static const char * lvl_prefix[] = {"Trace", "Info", "Warn", "Error", "User"};
-        lv_snprintf(buf, sizeof(buf), "[%s]\t(%d.%03d, +%d)\t %s: %s \t(in %s line #%d)\n", lvl_prefix[level], t / 1000, t % 1000, t - last_log_time, func, msg, &file[p], line);
+
+#if LV_LOG_PRINTF
+        printf("[%s]\t(%" LV_PRId32 ".%03" LV_PRId32 ", +%" LV_PRId32 ")\t %s: ",
+               lvl_prefix[level], t / 1000, t % 1000, t - last_log_time, func);
+        vprintf(format, args);
+        printf(" \t(in %s line #%d)\n", &file[p], line);
+#else
+        if (custom_print_cb) {
+            char buf[512];
+#if LV_SPRINTF_CUSTOM
+            char msg[256];
+            lv_vsnprintf(msg, sizeof(msg), format, args);
+            lv_snprintf(buf, sizeof(buf), "[%s]\t(%" LV_PRId32 ".%03" LV_PRId32 ", +%" LV_PRId32 ")\t %s: %s \t(in %s line #%d)\n",
+                        lvl_prefix[level], t / 1000, t % 1000, t - last_log_time, func, msg, &file[p], line);
+#else
+            lv_vaformat_t vaf = {format, &args};
+            lv_snprintf(buf, sizeof(buf), "[%s]\t(%" LV_PRId32 ".%03" LV_PRId32 ", +%" LV_PRId32 ")\t %s: %pV \t(in %s line #%d)\n",
+                        lvl_prefix[level], t / 1000, t % 1000, t - last_log_time, func, (void *)&vaf, &file[p], line);
+#endif
+            custom_print_cb(buf);
+        }
+#endif
+
         last_log_time = t;
-        lv_log(buf);
+        va_end(args);
     }
 }
 
 void lv_log(const char * buf)
 {
 #if LV_LOG_PRINTF
-    printf("%s", buf);
-#endif
+    puts(buf);
+#else
     if(custom_print_cb) custom_print_cb(buf);
-
+#endif
 }
 
 /**********************
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_log.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_log.h
index 7fd4b5e3e..fa6f5ac6b 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_log.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_log.h
@@ -16,6 +16,8 @@ extern "C" {
 #include "../lv_conf_internal.h"
 #include <stdint.h>
 
+#include "lv_types.h"
+
 /*********************
  *      DEFINES
  *********************/
@@ -47,7 +49,7 @@ typedef int8_t lv_log_level_t;
 /**
  * Log print function. Receives a string buffer to print".
  */
-typedef void (*lv_log_print_g_cb_t)(const char *buf);
+typedef void (*lv_log_print_g_cb_t)(const char * buf);
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -77,51 +79,61 @@ void lv_log(const char * buf);
  * @param format    printf-like format string
  * @param ...       parameters for `format`
  */
-void _lv_log_add(lv_log_level_t level, const char * file, int line, const char * func, const char * format, ...);
+void _lv_log_add(lv_log_level_t level, const char * file, int line,
+                 const char * func, const char * format, ...) LV_FORMAT_ATTRIBUTE(5, 6);
 
 /**********************
  *      MACROS
  **********************/
-
-#if LV_LOG_LEVEL <= LV_LOG_LEVEL_TRACE
-#define LV_LOG_TRACE(...) _lv_log_add(LV_LOG_LEVEL_TRACE, __FILE__, __LINE__, __func__, __VA_ARGS__);
-#else
-#define LV_LOG_TRACE(...)
+#ifndef LV_LOG_TRACE
+#  if LV_LOG_LEVEL <= LV_LOG_LEVEL_TRACE
+#    define LV_LOG_TRACE(...) _lv_log_add(LV_LOG_LEVEL_TRACE, __FILE__, __LINE__, __func__, __VA_ARGS__)
+#  else
+#    define LV_LOG_TRACE(...) do {}while(0)
+#  endif
 #endif
 
-#if LV_LOG_LEVEL <= LV_LOG_LEVEL_INFO
-#define LV_LOG_INFO(...) _lv_log_add(LV_LOG_LEVEL_INFO, __FILE__, __LINE__, __func__, __VA_ARGS__);
-#else
-#define LV_LOG_INFO(...)
+#ifndef LV_LOG_INFO
+#  if LV_LOG_LEVEL <= LV_LOG_LEVEL_INFO
+#    define LV_LOG_INFO(...) _lv_log_add(LV_LOG_LEVEL_INFO, __FILE__, __LINE__, __func__, __VA_ARGS__)
+#  else
+#    define LV_LOG_INFO(...) do {}while(0)
+#  endif
 #endif
 
-#if LV_LOG_LEVEL <= LV_LOG_LEVEL_WARN
-#define LV_LOG_WARN(...) _lv_log_add(LV_LOG_LEVEL_WARN, __FILE__, __LINE__, __func__, __VA_ARGS__);
-#else
-#define LV_LOG_WARN(...)
+#ifndef LV_LOG_WARN
+#  if LV_LOG_LEVEL <= LV_LOG_LEVEL_WARN
+#    define LV_LOG_WARN(...) _lv_log_add(LV_LOG_LEVEL_WARN, __FILE__, __LINE__, __func__, __VA_ARGS__)
+#  else
+#    define LV_LOG_WARN(...) do {}while(0)
+#  endif
 #endif
 
-#if LV_LOG_LEVEL <= LV_LOG_LEVEL_ERROR
-#define LV_LOG_ERROR(...) _lv_log_add(LV_LOG_LEVEL_ERROR, __FILE__, __LINE__, __func__, __VA_ARGS__);
-#else
-#define LV_LOG_ERROR(...)
+#ifndef LV_LOG_ERROR
+#  if LV_LOG_LEVEL <= LV_LOG_LEVEL_ERROR
+#    define LV_LOG_ERROR(...) _lv_log_add(LV_LOG_LEVEL_ERROR, __FILE__, __LINE__, __func__, __VA_ARGS__)
+#  else
+#    define LV_LOG_ERROR(...) do {}while(0)
+#  endif
 #endif
 
-#if LV_LOG_LEVEL <= LV_LOG_LEVEL_USER
-#define LV_LOG_USER(...) _lv_log_add(LV_LOG_LEVEL_USER, __FILE__, __LINE__, __func__, __VA_ARGS__);
-#else
-#define LV_LOG_USER(...)
+#ifndef LV_LOG_USER
+#  if LV_LOG_LEVEL <= LV_LOG_LEVEL_USER
+#    define LV_LOG_USER(...) _lv_log_add(LV_LOG_LEVEL_USER, __FILE__, __LINE__, __func__, __VA_ARGS__)
+#  else
+#    define LV_LOG_USER(...) do {}while(0)
+#  endif
 #endif
 
 #else /*LV_USE_LOG*/
 
 /*Do nothing if `LV_USE_LOG 0`*/
 #define _lv_log_add(level, file, line, ...)
-#define LV_LOG_TRACE(...)
-#define LV_LOG_INFO(...)
-#define LV_LOG_WARN(...)
-#define LV_LOG_ERROR(...)
-#define LV_LOG_USER(...)
+#define LV_LOG_TRACE(...) do {}while(0)
+#define LV_LOG_INFO(...) do {}while(0)
+#define LV_LOG_WARN(...) do {}while(0)
+#define LV_LOG_ERROR(...) do {}while(0)
+#define LV_LOG_USER(...) do {}while(0)
 #endif /*LV_USE_LOG*/
 
 #ifdef __cplusplus
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_math.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_math.c
index fc107b138..2144a50ca 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_math.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_math.c
@@ -7,7 +7,6 @@
  *      INCLUDES
  *********************/
 #include "lv_math.h"
-#include <stdbool.h>
 
 /*********************
  *      DEFINES
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_math.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_math.h
index 395322484..4b2860a90 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_math.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_math.h
@@ -105,7 +105,7 @@ int64_t lv_pow(int64_t base, int8_t exp);
  * @param max_out max output range
  * @return the mapped number
  */
-int32_t lv_map(int32_t x, int32_t min_in, int32_t max_in, int32_t min, int32_t max);
+int32_t lv_map(int32_t x, int32_t min_in, int32_t max_in, int32_t min_out, int32_t max_out);
 
 /**
  * Get a pseudo random number in the given range
@@ -129,11 +129,12 @@ uint32_t lv_rand(uint32_t min, uint32_t max);
 #define LV_CLAMP(min, val, max) (LV_MAX(min, (LV_MIN(val, max))))
 
 #define LV_ABS(x) ((x) > 0 ? (x) : (-(x)))
+#define LV_UDIV255(x) (((x) * 0x8081U) >> 0x17)
 
-#define LV_IS_SIGNED(t) (((t)(-1)) < ((t) 0))
+#define LV_IS_SIGNED(t) (((t)(-1)) < ((t)0))
 #define LV_UMAX_OF(t) (((0x1ULL << ((sizeof(t) * 8ULL) - 1ULL)) - 1ULL) | (0xFULL << ((sizeof(t) * 8ULL) - 4ULL)))
 #define LV_SMAX_OF(t) (((0x1ULL << ((sizeof(t) * 8ULL) - 1ULL)) - 1ULL) | (0x7ULL << ((sizeof(t) * 8ULL) - 4ULL)))
-#define LV_MAX_OF(t) ((unsigned long) (LV_IS_SIGNED(t) ? LV_SMAX_OF(t) : LV_UMAX_OF(t)))
+#define LV_MAX_OF(t) ((unsigned long)(LV_IS_SIGNED(t) ? LV_SMAX_OF(t) : LV_UMAX_OF(t)))
 
 #ifdef __cplusplus
 } /*extern "C"*/
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_mem.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_mem.c
index 87d532a9a..91d50678b 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_mem.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_mem.c
@@ -11,27 +11,30 @@
 #include "lv_tlsf.h"
 #include "lv_gc.h"
 #include "lv_assert.h"
-#include <string.h>
+#include "lv_log.h"
 
 #if LV_MEM_CUSTOM != 0
     #include LV_MEM_CUSTOM_INCLUDE
 #endif
 
+#ifdef LV_MEM_POOL_INCLUDE
+    #include LV_MEM_POOL_INCLUDE
+#endif
 
 /*********************
  *      DEFINES
  *********************/
 /*memset the allocated memories to 0xaa and freed memories to 0xbb (just for testing purposes)*/
 #ifndef LV_MEM_ADD_JUNK
-#  define LV_MEM_ADD_JUNK  0
+    #define LV_MEM_ADD_JUNK  0
 #endif
 
 #ifdef LV_ARCH_64
-#  define MEM_UNIT         uint64_t
-#  define ALIGN_MASK       0x7
+    #define MEM_UNIT         uint64_t
+    #define ALIGN_MASK       0x7
 #else
-#  define MEM_UNIT         uint32_t
-#  define ALIGN_MASK       0x7
+    #define MEM_UNIT         uint32_t
+    #define ALIGN_MASK       0x3
 #endif
 
 #define ZERO_MEM_SENTINEL  0xa1b2c3d4
@@ -60,9 +63,9 @@ static uint32_t zero_mem = ZERO_MEM_SENTINEL; /*Give the address of this variabl
  *      MACROS
  **********************/
 #if LV_LOG_TRACE_MEM
-#  define MEM_TRACE(...) LV_LOG_TRACE( __VA_ARGS__)
+    #define MEM_TRACE(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
-#  define MEM_TRACE(...)
+    #define MEM_TRACE(...)
 #endif
 
 #define COPY32 *d32 = *s32; d32++; s32++;
@@ -83,16 +86,20 @@ void lv_mem_init(void)
 #if LV_MEM_CUSTOM == 0
 
 #if LV_MEM_ADR == 0
+#ifdef LV_MEM_POOL_ALLOC
+    tlsf = lv_tlsf_create_with_pool((void *)LV_MEM_POOL_ALLOC(LV_MEM_SIZE), LV_MEM_SIZE);
+#else
     /*Allocate a large array to store the dynamically allocated data*/
     static LV_ATTRIBUTE_LARGE_RAM_ARRAY MEM_UNIT work_mem_int[LV_MEM_SIZE / sizeof(MEM_UNIT)];
     tlsf = lv_tlsf_create_with_pool((void *)work_mem_int, LV_MEM_SIZE);
+#endif
 #else
     tlsf = lv_tlsf_create_with_pool((void *)LV_MEM_ADR, LV_MEM_SIZE);
 #endif
 #endif
 
 #if LV_MEM_ADD_JUNK
-    LV_LOG_WARN("LV_MEM_ADD_JUNK is enabled which makes LVGL much slower")
+    LV_LOG_WARN("LV_MEM_ADD_JUNK is enabled which makes LVGL much slower");
 #endif
 }
 
@@ -115,7 +122,7 @@ void lv_mem_deinit(void)
  */
 void * lv_mem_alloc(size_t size)
 {
-    MEM_TRACE("allocating %d bytes", size);
+    MEM_TRACE("allocating %lu bytes", (unsigned long)size);
     if(size == 0) {
         MEM_TRACE("using zero_mem");
         return &zero_mem;
@@ -127,18 +134,19 @@ void * lv_mem_alloc(size_t size)
     void * alloc = LV_MEM_CUSTOM_ALLOC(size);
 #endif
 
-#if LV_MEM_ADD_JUNK
-    if(alloc != NULL) lv_memset(alloc, 0xaa, size);
-#endif
-
     if(alloc == NULL) {
-        LV_LOG_ERROR("couldn't allocate memory (%d bytes)", size);
+        LV_LOG_ERROR("couldn't allocate memory (%lu bytes)", (unsigned long)size);
         lv_mem_monitor_t mon;
         lv_mem_monitor(&mon);
         LV_LOG_ERROR("used: %6d (%3d %%), frag: %3d %%, biggest free: %6d",
-               (int)mon.total_size - mon.free_size, mon.used_pct, mon.frag_pct,
-               (int)mon.free_biggest_size);
+                     (int)(mon.total_size - mon.free_size), mon.used_pct, mon.frag_pct,
+                     (int)mon.free_biggest_size);
     }
+#if LV_MEM_ADD_JUNK
+    else {
+        lv_memset(alloc, 0xaa, size);
+    }
+#endif
 
     MEM_TRACE("allocated at %p", alloc);
     return alloc;
@@ -173,7 +181,7 @@ void lv_mem_free(void * data)
  */
 void * lv_mem_realloc(void * data_p, size_t new_size)
 {
-    MEM_TRACE("reallocating %p with %d size", data_p, new_size);
+    MEM_TRACE("reallocating %p with %lu size", data_p, (unsigned long)new_size);
     if(new_size == 0) {
         MEM_TRACE("using zero_mem");
         lv_mem_free(data_p);
@@ -209,7 +217,7 @@ lv_res_t lv_mem_test(void)
         return LV_RES_INV;
     }
 
-    if (lv_tlsf_check_pool(lv_tlsf_get_pool(tlsf))) {
+    if(lv_tlsf_check_pool(lv_tlsf_get_pool(tlsf))) {
         LV_LOG_WARN("pool failed");
         return LV_RES_INV;
     }
@@ -220,7 +228,7 @@ lv_res_t lv_mem_test(void)
 
 /**
  * Give information about the work memory of dynamic allocation
- * @param mon_p pointer to a dm_mon_p variable,
+ * @param mon_p pointer to a lv_mem_monitor_t variable,
  *              the result of the analysis will be stored here
  */
 void lv_mem_monitor(lv_mem_monitor_t * mon_p)
@@ -277,7 +285,8 @@ void * lv_mem_buf_get(uint32_t size)
 
     if(i_guess >= 0) {
         LV_GC_ROOT(lv_mem_buf[i_guess]).used = 1;
-        MEM_TRACE("returning already allocated buffer (buffer id: %d, address: %p)", i_guess, LV_GC_ROOT(lv_mem_buf[i_guess]).p);
+        MEM_TRACE("returning already allocated buffer (buffer id: %d, address: %p)", i_guess,
+                  LV_GC_ROOT(lv_mem_buf[i_guess]).p);
         return LV_GC_ROOT(lv_mem_buf[i_guess]).p;
     }
 
@@ -317,7 +326,7 @@ void lv_mem_buf_release(void * p)
         }
     }
 
-    LV_LOG_ERROR("p is not a known buffer")
+    LV_LOG_ERROR("p is not a known buffer");
 }
 
 /**
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_mem.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_mem.h
index bf419f8de..0d1817fed 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_mem.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_mem.h
@@ -17,21 +17,14 @@ extern "C" {
 
 #include <stdint.h>
 #include <stddef.h>
-#include "lv_log.h"
-#include "lv_types.h"
-
-#if LV_MEMCPY_MEMSET_STD
 #include <string.h>
-#endif
+
+#include "lv_types.h"
 
 /*********************
  *      DEFINES
  *********************/
 
-#ifndef LV_MEM_BUF_MAX_NUM
-#define LV_MEM_BUF_MAX_NUM    16
-#endif
-
 /**********************
  *      TYPEDEFS
  **********************/
@@ -103,7 +96,7 @@ lv_res_t lv_mem_test(void);
 
 /**
  * Give information about the work memory of dynamic allocation
- * @param mon_p pointer to a dm_mon_p variable,
+ * @param mon_p pointer to a lv_mem_monitor_t variable,
  *              the result of the analysis will be stored here
  */
 void lv_mem_monitor(lv_mem_monitor_t * mon_p);
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_misc.mk b/lib/libesp32_lvgl/lvgl/src/misc/lv_misc.mk
index 0079a8b7b..5e053f877 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_misc.mk
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_misc.mk
@@ -1,4 +1,5 @@
 CSRCS += lv_anim.c
+CSRCS += lv_anim_timeline.c
 CSRCS += lv_area.c
 CSRCS += lv_async.c
 CSRCS += lv_bidi.c
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_printf.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_printf.c
index 852c77c64..ebe8a55c0 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_printf.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_printf.c
@@ -37,7 +37,6 @@
 #if LV_SPRINTF_CUSTOM == 0
 
 #include <stdbool.h>
-#include <stdint.h>
 
 #define PRINTF_DISABLE_SUPPORT_FLOAT    (!LV_SPRINTF_USE_FLOAT)
 
@@ -133,10 +132,10 @@ static inline void _out_buffer(char character, void * buffer, size_t idx, size_t
 // internal null output
 static inline void _out_null(char character, void * buffer, size_t idx, size_t maxlen)
 {
-    (void)character;
-    (void)buffer;
-    (void)idx;
-    (void)maxlen;
+    LV_UNUSED(character);
+    LV_UNUSED(buffer);
+    LV_UNUSED(idx);
+    LV_UNUSED(maxlen);
 }
 
 // internal secure strlen
@@ -699,6 +698,9 @@ static int _vsnprintf(out_fct_type out, char * buffer, const size_t maxlen, cons
                         else
 #endif
                             flags |= FLAGS_LONG;
+
+                        if(*(format + 1) == 'V')
+                            format++;
                     }
                     else if(*format == 'o') {
                         base =  8U;
@@ -747,6 +749,14 @@ static int _vsnprintf(out_fct_type out, char * buffer, const size_t maxlen, cons
                                              width, flags);
                         }
                     }
+                    else if (*format == 'V') {
+                        lv_vaformat_t * vaf = va_arg(va, lv_vaformat_t *);
+                        va_list copy;
+
+                        va_copy(copy, *vaf->va);
+                        idx += _vsnprintf(out, buffer + idx, maxlen - idx, vaf->fmt, copy);
+                        va_end(copy);
+                    }
                     else {
                         // unsigned
                         if(flags & FLAGS_LONG_LONG) {
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_printf.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_printf.h
index c29d18dad..304c5b9cc 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_printf.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_printf.h
@@ -34,6 +34,22 @@
 #ifndef _LV_PRINTF_H_
 #define _LV_PRINTF_H_
 
+#if defined(__has_include)
+#  if __has_include(<inttypes.h>)
+#    include <inttypes.h>
+     /* platform-specific printf format for int32_t, usually "d" or "ld" */
+#    define LV_PRId32 PRId32
+#    define LV_PRIu32 PRIu32
+#  else
+#    define LV_PRId32 "d"
+#    define LV_PRIu32 "u"
+#  endif
+#else
+   /* hope this is correct for ports without __has_include or without inttypes.h */
+#  define LV_PRId32 "d"
+#  define LV_PRIu32 "u"
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -45,6 +61,13 @@ extern "C" {
 #include <stdarg.h>
 #include <stddef.h>
 
+#include "lv_types.h"
+
+typedef struct {
+  const char * fmt;
+  va_list * va;
+} lv_vaformat_t;
+
 /**
  * Tiny snprintf/vsnprintf implementation
  * \param buffer A pointer to the buffer where to store the formatted string
@@ -55,8 +78,8 @@ extern "C" {
  *         null character. A value equal or larger than count indicates truncation. Only when the returned value
  *         is non-negative and less than count, the string has been completely written.
  */
-int  lv_snprintf(char * buffer, size_t count, const char * format, ...);
-int lv_vsnprintf(char * buffer, size_t count, const char * format, va_list va);
+int  lv_snprintf(char * buffer, size_t count, const char * format, ...) LV_FORMAT_ATTRIBUTE(3, 4);
+int lv_vsnprintf(char * buffer, size_t count, const char * format, va_list va) LV_FORMAT_ATTRIBUTE(3, 0);
 
 #else
 #include LV_SPRINTF_INCLUDE
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_style.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_style.c
index 704ccee7c..160c1de53 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_style.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_style.c
@@ -41,7 +41,7 @@ void lv_style_init(lv_style_t * style)
 {
 #if LV_USE_ASSERT_STYLE
     if(style->sentinel == LV_STYLE_SENTINEL_VALUE && style->prop_cnt > 1) {
-        LV_LOG_WARN("Style might be already inited. (Potential memory leak)")
+        LV_LOG_WARN("Style might be already inited. (Potential memory leak)");
     }
 #endif
 
@@ -106,7 +106,8 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_prop_t prop)
                 style->prop_cnt = 1;
                 style->prop1 = i == 0 ? old_props[1] : old_props[0];
                 style->v_p.value1 = i == 0 ? old_values[1] : old_values[0];
-            } else {
+            }
+            else {
                 size_t size = (style->prop_cnt - 1) * (sizeof(lv_style_value_t) + sizeof(uint16_t));
                 uint8_t * new_values_and_props = lv_mem_alloc(size);
                 if(new_values_and_props == NULL) return false;
@@ -118,7 +119,8 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_prop_t prop)
                 lv_style_value_t * new_values = (lv_style_value_t *)new_values_and_props;
 
                 uint32_t j;
-                for(i = j = 0; j <= style->prop_cnt; j++) { /*<=: because prop_cnt already reduced but all the old props. needs to be checked.*/
+                for(i = j = 0; j <= style->prop_cnt;
+                    j++) { /*<=: because prop_cnt already reduced but all the old props. needs to be checked.*/
                     if(old_props[j] != prop) {
                         new_values[i] = old_values[j];
                         new_props[i++] = old_props[j];
@@ -164,7 +166,7 @@ void lv_style_set_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_value_
         props = (uint16_t *)tmp;
         /*Shift all props to make place for the value before them*/
         for(i = style->prop_cnt - 1; i >= 0; i--) {
-            props[i + sizeof(lv_style_value_t) /sizeof(uint16_t)] = props[i];
+            props[i + sizeof(lv_style_value_t) / sizeof(uint16_t)] = props[i];
         }
         style->prop_cnt++;
 
@@ -176,7 +178,8 @@ void lv_style_set_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_value_
         /*Set the new property and value*/
         props[style->prop_cnt - 1] = prop;
         values[style->prop_cnt - 1] = value;
-    } else if(style->prop_cnt == 1) {
+    }
+    else if(style->prop_cnt == 1) {
         if(style->prop1 == prop) {
             style->v_p.value1 = value;
             return;
@@ -195,7 +198,8 @@ void lv_style_set_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_value_
         props[1] = prop;
         values[0] = value_tmp;
         values[1] = value;
-    } else {
+    }
+    else {
         style->prop_cnt = 1;
         style->prop1 = prop;
         style->v_p.value1 = value;
@@ -207,10 +211,11 @@ void lv_style_set_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_value_
 
 lv_res_t lv_style_get_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_value_t * value)
 {
-   return lv_style_get_prop_inlined(style, prop, value);
+    return lv_style_get_prop_inlined(style, prop, value);
 }
 
-void lv_style_transition_dsc_init(lv_style_transition_dsc_t * tr, const lv_style_prop_t props[], lv_anim_path_cb_t path_cb, uint32_t time, uint32_t delay, void * user_data)
+void lv_style_transition_dsc_init(lv_style_transition_dsc_t * tr, const lv_style_prop_t props[],
+                                  lv_anim_path_cb_t path_cb, uint32_t time, uint32_t delay, void * user_data)
 {
     lv_memset_00(tr, sizeof(lv_style_transition_dsc_t));
     tr->props = props;
@@ -234,6 +239,16 @@ lv_style_value_t lv_style_prop_get_default(lv_style_prop_t prop)
         case LV_STYLE_BG_COLOR:
             value.color = lv_color_white();
             break;
+        case LV_STYLE_BG_GRAD_COLOR:
+        case LV_STYLE_BORDER_COLOR:
+        case LV_STYLE_SHADOW_COLOR:
+        case LV_STYLE_OUTLINE_COLOR:
+        case LV_STYLE_ARC_COLOR:
+        case LV_STYLE_LINE_COLOR:
+        case LV_STYLE_TEXT_COLOR:
+        case LV_STYLE_IMG_RECOLOR:
+            value.color = lv_color_black();
+            break;
         case LV_STYLE_OPA:
         case LV_STYLE_BORDER_OPA:
         case LV_STYLE_TEXT_OPA:
@@ -280,6 +295,7 @@ uint8_t _lv_style_get_prop_group(lv_style_prop_t prop)
     if(group > 7) group = 7;    /*The MSB marks all the custom properties*/
     return (uint8_t)group;
 }
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_style.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_style.h
index 0f4ae1f52..9b4d012c8 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_style.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_style.h
@@ -61,6 +61,7 @@ enum {
     LV_BLEND_MODE_NORMAL,     /**< Simply mix according to the opacity value*/
     LV_BLEND_MODE_ADDITIVE,   /**< Add the respective color channels*/
     LV_BLEND_MODE_SUBTRACTIVE,/**< Subtract the foreground from the background*/
+    LV_BLEND_MODE_MULTIPLY,   /**< Multiply the foreground and background*/
 };
 
 typedef uint8_t lv_blend_mode_t;
@@ -110,7 +111,7 @@ typedef union {
     int32_t num;         /**< Number integer number (opacity, enums, booleans or "normal" numbers)*/
     const void * ptr;    /**< Constant pointers  (font, cone text, etc)*/
     lv_color_t color;    /**< Colors*/
-}lv_style_value_t;
+} lv_style_value_t;
 
 /**
  * Enumeration of all built in style properties
@@ -132,16 +133,16 @@ typedef enum {
     LV_STYLE_TRANSFORM_HEIGHT        = 11 | LV_STYLE_PROP_EXT_DRAW,
     LV_STYLE_TRANSLATE_X             = 12 | LV_STYLE_PROP_LAYOUT_REFR | LV_STYLE_PROP_PARENT_LAYOUT_REFR,
     LV_STYLE_TRANSLATE_Y             = 13 | LV_STYLE_PROP_LAYOUT_REFR | LV_STYLE_PROP_PARENT_LAYOUT_REFR,
-    LV_STYLE_TRANSFORM_ZOOM          = 14 | LV_STYLE_PROP_EXT_DRAW,
-    LV_STYLE_TRANSFORM_ANGLE         = 15 | LV_STYLE_PROP_EXT_DRAW,
+    LV_STYLE_TRANSFORM_ZOOM          = 14 | LV_STYLE_PROP_EXT_DRAW | LV_STYLE_PROP_LAYOUT_REFR | LV_STYLE_PROP_PARENT_LAYOUT_REFR,
+    LV_STYLE_TRANSFORM_ANGLE         = 15 | LV_STYLE_PROP_EXT_DRAW | LV_STYLE_PROP_LAYOUT_REFR | LV_STYLE_PROP_PARENT_LAYOUT_REFR,
 
     /*Group 1*/
-    LV_STYLE_PAD_TOP                 = 16 | LV_STYLE_PROP_LAYOUT_REFR,
-    LV_STYLE_PAD_BOTTOM              = 17 | LV_STYLE_PROP_LAYOUT_REFR,
-    LV_STYLE_PAD_LEFT                = 18 | LV_STYLE_PROP_LAYOUT_REFR,
-    LV_STYLE_PAD_RIGHT               = 19 | LV_STYLE_PROP_LAYOUT_REFR,
-    LV_STYLE_PAD_ROW                 = 20 | LV_STYLE_PROP_LAYOUT_REFR,
-    LV_STYLE_PAD_COLUMN              = 21 | LV_STYLE_PROP_LAYOUT_REFR,
+    LV_STYLE_PAD_TOP                 = 16 | LV_STYLE_PROP_EXT_DRAW | LV_STYLE_PROP_LAYOUT_REFR,
+    LV_STYLE_PAD_BOTTOM              = 17 | LV_STYLE_PROP_EXT_DRAW | LV_STYLE_PROP_LAYOUT_REFR,
+    LV_STYLE_PAD_LEFT                = 18 | LV_STYLE_PROP_EXT_DRAW | LV_STYLE_PROP_LAYOUT_REFR,
+    LV_STYLE_PAD_RIGHT               = 19 | LV_STYLE_PROP_EXT_DRAW | LV_STYLE_PROP_LAYOUT_REFR,
+    LV_STYLE_PAD_ROW                 = 20 | LV_STYLE_PROP_EXT_DRAW | LV_STYLE_PROP_LAYOUT_REFR,
+    LV_STYLE_PAD_COLUMN              = 21 | LV_STYLE_PROP_EXT_DRAW | LV_STYLE_PROP_LAYOUT_REFR,
 
     /*Group 2*/
     LV_STYLE_BG_COLOR                = 32,
@@ -153,7 +154,7 @@ typedef enum {
     LV_STYLE_BG_MAIN_STOP            = 36,
     LV_STYLE_BG_GRAD_STOP            = 37,
 
-    LV_STYLE_BG_IMG_SRC              = 38,
+    LV_STYLE_BG_IMG_SRC              = 38 | LV_STYLE_PROP_EXT_DRAW,
     LV_STYLE_BG_IMG_OPA              = 39,
     LV_STYLE_BG_IMG_RECOLOR          = 40,
     LV_STYLE_BG_IMG_RECOLOR_FILTERED = 40 | LV_STYLE_PROP_FILTER,
@@ -229,7 +230,7 @@ typedef enum {
     _LV_STYLE_LAST_BUILT_IN_PROP     = 111,
 
     LV_STYLE_PROP_ANY                = 0xFFFF
-}lv_style_prop_t;
+} lv_style_prop_t;
 
 /**
  * Descriptor for style transitions
@@ -242,7 +243,7 @@ typedef struct {
     lv_anim_path_cb_t path_xcb;     /**< A path for the animation.*/
     uint32_t time;                 /**< Duration of the transition in [ms]*/
     uint32_t delay;                /**< Delay before the transition in [ms]*/
-}lv_style_transition_dsc_t;
+} lv_style_transition_dsc_t;
 
 /**
  * Descriptor of a constant style property.
@@ -269,8 +270,8 @@ typedef struct {
         const lv_style_const_prop_t * const_props;
     } v_p;
 
-    uint16_t prop1 :15;
-    uint16_t is_const :1;
+    uint16_t prop1 : 15;
+    uint16_t is_const : 1;
     uint8_t has_group;
     uint8_t prop_cnt;
 } lv_style_t;
@@ -283,8 +284,8 @@ typedef struct {
 /**
  * Initialize a style
  * @param style pointer to a style to initialize
- * @note Do not call `lv_style_init` on styles that are already have some properties
- *       because this function won't free the used memory just set a default state for the style.
+ * @note Do not call `lv_style_init` on styles that already have some properties
+ *       because this function won't free the used memory, just sets a default state for the style.
  *       In other words be sure to initialize styles only once!
  */
 void lv_style_init(lv_style_t * style);
@@ -323,8 +324,8 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_prop_t prop);
  * This function shouldn't be used directly by the user.
  * Instead use `lv_style_set_<prop_name>()`. E.g. `lv_style_set_bg_color()`
  * @param style pointer to style
- * @param prop the ID of a property (e.g. `LV_STLYE_BG_COLOR`)
- * @param value `lv_style_value_t` variable in which a filed is set according to the type of `prop`
+ * @param prop the ID of a property (e.g. `LV_STYLE_BG_COLOR`)
+ * @param value `lv_style_value_t` variable in which a field is set according to the type of `prop`
  */
 void lv_style_set_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_value_t value);
 
@@ -333,7 +334,7 @@ void lv_style_set_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_value_
  * @param style pointer to a style
  * @param prop  the ID of a property
  * @param value pointer to a `lv_style_value_t` variable to store the value
- * @return LV_RES_INV: the property wsn't found in the style (`value` is unchanged)
+ * @return LV_RES_INV: the property wasn't found in the style (`value` is unchanged)
  *         LV_RES_OK: the property was fond, and `value` is set accordingly
  * @note For performance reasons there are no sanity check on `style`
  */
@@ -345,7 +346,7 @@ lv_res_t lv_style_get_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_va
  * @param style pointer to a style
  * @param prop  the ID of a property
  * @param value pointer to a `lv_style_value_t` variable to store the value
- * @return LV_RES_INV: the property wsn't found in the style (`value` is unchanged)
+ * @return LV_RES_INV: the property wasn't found in the style (`value` is unchanged)
  *         LV_RES_OK: the property was fond, and `value` is set accordingly
  * @note For performance reasons there are no sanity check on `style`
  * @note This function is the same as ::lv_style_get_prop but inlined. Use it only on performance critical places
@@ -353,7 +354,7 @@ lv_res_t lv_style_get_prop(lv_style_t * style, lv_style_prop_t prop, lv_style_va
 static inline lv_res_t lv_style_get_prop_inlined(lv_style_t * style, lv_style_prop_t prop, lv_style_value_t * value)
 {
     if(style->is_const) {
-        const lv_style_const_prop_t *const_prop;
+        const lv_style_const_prop_t * const_prop;
         for(const_prop = style->v_p.const_props; const_prop->prop != LV_STYLE_PROP_INV; const_prop++) {
             if(const_prop->prop == prop) {
                 *value = const_prop->value;
@@ -376,7 +377,8 @@ static inline lv_res_t lv_style_get_prop_inlined(lv_style_t * style, lv_style_pr
                 return LV_RES_OK;
             }
         }
-    } else if(style->prop1 == prop) {
+    }
+    else if(style->prop1 == prop) {
         *value = style->v_p.value1;
         return LV_RES_OK;
     }
@@ -396,7 +398,8 @@ static inline lv_res_t lv_style_get_prop_inlined(lv_style_t * style, lv_style_pr
  *  static lv_style_transition_dsc_t trans1;
  *  lv_style_transition_dsc_init(&trans1, trans_props, NULL, 300, 0, NULL);
  */
-void lv_style_transition_dsc_init(lv_style_transition_dsc_t * tr, const lv_style_prop_t props[], lv_anim_path_cb_t path_cb, uint32_t time, uint32_t delay, void * user_data);
+void lv_style_transition_dsc_init(lv_style_transition_dsc_t * tr, const lv_style_prop_t props[],
+                                  lv_anim_path_cb_t path_cb, uint32_t time, uint32_t delay, void * user_data);
 
 /**
  * Get the default value of a property
@@ -422,29 +425,34 @@ uint8_t _lv_style_get_prop_group(lv_style_prop_t prop);
 
 #include "lv_style_gen.h"
 
-static inline void lv_style_set_pad_all(lv_style_t * style, lv_coord_t value) {
+static inline void lv_style_set_pad_all(lv_style_t * style, lv_coord_t value)
+{
     lv_style_set_pad_left(style, value);
     lv_style_set_pad_right(style, value);
     lv_style_set_pad_top(style, value);
     lv_style_set_pad_bottom(style, value);
 }
 
-static inline void lv_style_set_pad_hor(lv_style_t * style, lv_coord_t value) {
+static inline void lv_style_set_pad_hor(lv_style_t * style, lv_coord_t value)
+{
     lv_style_set_pad_left(style, value);
     lv_style_set_pad_right(style, value);
 }
 
-static inline void lv_style_set_pad_ver(lv_style_t * style, lv_coord_t value) {
+static inline void lv_style_set_pad_ver(lv_style_t * style, lv_coord_t value)
+{
     lv_style_set_pad_top(style, value);
     lv_style_set_pad_bottom(style, value);
 }
 
-static inline void lv_style_set_pad_gap(lv_style_t * style, lv_coord_t value) {
+static inline void lv_style_set_pad_gap(lv_style_t * style, lv_coord_t value)
+{
     lv_style_set_pad_row(style, value);
     lv_style_set_pad_column(style, value);
 }
 
-static inline void lv_style_set_size(lv_style_t * style, lv_coord_t value) {
+static inline void lv_style_set_size(lv_style_t * style, lv_coord_t value)
+{
     lv_style_set_width(style, value);
     lv_style_set_height(style, value);
 }
@@ -460,7 +468,7 @@ static inline void lv_style_set_size(lv_style_t * style, lv_coord_t value) {
 
 #if LV_USE_ASSERT_STYLE
 #  define LV_ASSERT_STYLE(style_p)    LV_ASSERT_MSG(style_p != NULL, "The style is NULL");          \
-                                      LV_ASSERT_MSG(style_p->sentinel == LV_STYLE_SENTINEL_VALUE, "Style is not initialized or corrupted");
+    LV_ASSERT_MSG(style_p->sentinel == LV_STYLE_SENTINEL_VALUE, "Style is not initialized or corrupted");
 #else
 # define LV_ASSERT_STYLE(p)
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_style_gen.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_style_gen.c
index bdcd1d147..f26884e7f 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_style_gen.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_style_gen.c
@@ -632,7 +632,7 @@ void lv_style_set_line_dash_gap(lv_style_t * style, lv_coord_t value)
     lv_style_set_prop(style, LV_STYLE_LINE_DASH_GAP, v);
 }
 
-void lv_style_set_line_rounded(lv_style_t * style, lv_coord_t value)
+void lv_style_set_line_rounded(lv_style_t * style, bool value)
 {
     lv_style_value_t v = {
         .num = (int32_t)value
@@ -672,7 +672,7 @@ void lv_style_set_arc_width(lv_style_t * style, lv_coord_t value)
     lv_style_set_prop(style, LV_STYLE_ARC_WIDTH, v);
 }
 
-void lv_style_set_arc_rounded(lv_style_t * style, lv_coord_t value)
+void lv_style_set_arc_rounded(lv_style_t * style, bool value)
 {
     lv_style_value_t v = {
         .num = (int32_t)value
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_style_gen.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_style_gen.h
index 08afb0476..eeb648ece 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_style_gen.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_style_gen.h
@@ -77,12 +77,12 @@ void lv_style_set_shadow_opa(lv_style_t * style, lv_opa_t value);
 void lv_style_set_line_width(lv_style_t * style, lv_coord_t value);
 void lv_style_set_line_dash_width(lv_style_t * style, lv_coord_t value);
 void lv_style_set_line_dash_gap(lv_style_t * style, lv_coord_t value);
-void lv_style_set_line_rounded(lv_style_t * style, lv_coord_t value);
+void lv_style_set_line_rounded(lv_style_t * style, bool value);
 void lv_style_set_line_color(lv_style_t * style, lv_color_t value);
 void lv_style_set_line_color_filtered(lv_style_t * style, lv_color_t value);
 void lv_style_set_line_opa(lv_style_t * style, lv_opa_t value);
 void lv_style_set_arc_width(lv_style_t * style, lv_coord_t value);
-void lv_style_set_arc_rounded(lv_style_t * style, lv_coord_t value);
+void lv_style_set_arc_rounded(lv_style_t * style, bool value);
 void lv_style_set_arc_color(lv_style_t * style, lv_color_t value);
 void lv_style_set_arc_color_filtered(lv_style_t * style, lv_color_t value);
 void lv_style_set_arc_opa(lv_style_t * style, lv_opa_t value);
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_timer.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_timer.c
index 94dc59163..d8dd55b7a 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_timer.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_timer.c
@@ -6,9 +6,10 @@
  *      INCLUDES
  *********************/
 #include "lv_timer.h"
-#include <stddef.h>
-#include "../misc/lv_assert.h"
 #include "../hal/lv_hal_tick.h"
+#include "lv_assert.h"
+#include "lv_mem.h"
+#include "lv_ll.h"
 #include "lv_gc.h"
 
 /*********************
@@ -39,9 +40,9 @@ static bool timer_created;
  *      MACROS
  **********************/
 #if LV_LOG_TRACE_TIMER
-#  define TIMER_TRACE(...) LV_LOG_TRACE( __VA_ARGS__)
+    #define TIMER_TRACE(...) LV_LOG_TRACE(__VA_ARGS__)
 #else
-#  define TIMER_TRACE(...)
+    #define TIMER_TRACE(...)
 #endif
 
 /**********************
@@ -60,7 +61,7 @@ void _lv_timer_core_init(void)
 }
 
 /**
- * Call it  periodically to handle lv_timers.
+ * Call it periodically to handle lv_timers.
  * @return the time after which it must be called again
  */
 LV_ATTRIBUTE_TIMER_HANDLER uint32_t lv_timer_handler(void)
@@ -69,12 +70,14 @@ LV_ATTRIBUTE_TIMER_HANDLER uint32_t lv_timer_handler(void)
 
     /*Avoid concurrent running of the timer handler*/
     static bool already_running = false;
-    if(already_running) return 1;
+    if(already_running) {
+        TIMER_TRACE("already running, concurrent calls are not allow, returning");
+        return 1;
+    }
     already_running = true;
 
     if(lv_timer_run == false) {
         already_running = false; /*Release mutex*/
-        TIMER_TRACE("already running, concurrent calls are not allow, returning");
         return 1;
     }
 
@@ -85,7 +88,7 @@ LV_ATTRIBUTE_TIMER_HANDLER uint32_t lv_timer_handler(void)
 
     if(handler_start == 0) {
         static uint32_t run_cnt = 0;
-        run_cnt ++;
+        run_cnt++;
         if(run_cnt > 100) {
             run_cnt = 0;
             LV_LOG_WARN("It seems lv_tick_inc() is not called.");
@@ -141,6 +144,7 @@ LV_ATTRIBUTE_TIMER_HANDLER uint32_t lv_timer_handler(void)
     TIMER_TRACE("finished (%d ms until the next timer call)", time_till_next);
     return time_till_next;
 }
+
 /**
  * Create an "empty" timer. It needs to initialized with at least
  * `lv_timer_set_cb` and `lv_timer_set_period`
@@ -154,7 +158,7 @@ lv_timer_t * lv_timer_create_basic(void)
 /**
  * Create a new lv_timer
  * @param timer_xcb a callback which is the timer itself. It will be called periodically.
- *                 (the 'x' in the argument name indicates that its not a fully generic function because it not follows
+ *                 (the 'x' in the argument name indicates that it's not a fully generic function because it not follows
  *                  the `func_name(object, callback, ...)` convention)
  * @param period call period in ms unit
  * @param user_data custom parameter
@@ -168,7 +172,7 @@ lv_timer_t * lv_timer_create(lv_timer_cb_t timer_xcb, uint32_t period, void * us
     LV_ASSERT_MALLOC(new_timer);
     if(new_timer == NULL) return NULL;
 
-    new_timer->period  = period;
+    new_timer->period = period;
     new_timer->timer_cb = timer_xcb;
     new_timer->repeat_count = -1;
     new_timer->paused = 0;
@@ -289,7 +293,7 @@ lv_timer_t * lv_timer_get_next(lv_timer_t * timer)
  **********************/
 
 /**
- * Execute timer if its the priority is appropriate
+ * Execute timer if its remaining time is zero
  * @param timer pointer to lv_timer
  * @return true: execute, false: not executed
  */
@@ -297,12 +301,6 @@ static bool lv_timer_exec(lv_timer_t * timer)
 {
     if(timer->paused) return false;
 
-    if(timer->repeat_count == 0) {
-        TIMER_TRACE("deleting timer with %p callback because the repeat count is over", timer->timer_cb);
-        lv_timer_del(timer);
-        return false;
-    }
-
     bool exec = false;
     if(lv_timer_time_remaining(timer) == 0) {
         /* Decrement the repeat count before executing the timer_cb.
@@ -311,21 +309,20 @@ static bool lv_timer_exec(lv_timer_t * timer)
         int32_t original_repeat_count = timer->repeat_count;
         if(timer->repeat_count > 0) timer->repeat_count--;
         timer->last_run = lv_tick_get();
-        TIMER_TRACE("calling timer callback: %p", timer->timer_cb);
+        TIMER_TRACE("calling timer callback: %p", *((void **)&timer->timer_cb));
         if(timer->timer_cb && original_repeat_count != 0) timer->timer_cb(timer);
-        TIMER_TRACE("timer callback %p finished", timer->timer_cb);
+        TIMER_TRACE("timer callback %p finished", *((void **)&timer->timer_cb));
         LV_ASSERT_MEM_INTEGRITY();
-
-        /*Delete if it was a one shot lv_timer*/
-        if(timer_deleted == false) { /*The timer might be deleted by itself as well*/
-            if(timer->repeat_count == 0) {
-                TIMER_TRACE("deleting timer with %p callback because the repeat count is over", timer->timer_cb);
-                lv_timer_del(timer);
-            }
-        }
         exec = true;
     }
 
+    if(timer_deleted == false) { /*The timer might be deleted by itself as well*/
+        if(timer->repeat_count == 0) { /*The repeat count is over, delete the timer*/
+            TIMER_TRACE("deleting timer with %p callback because the repeat count is over", *((void **)&timer->timer_cb));
+            lv_timer_del(timer);
+        }
+    }
+
     return exec;
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_timer.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_timer.h
index 015543734..ce94c7b04 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_timer.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_timer.h
@@ -16,8 +16,6 @@ extern "C" {
 
 #include <stdint.h>
 #include <stdbool.h>
-#include "lv_mem.h"
-#include "lv_ll.h"
 
 /*********************
  *      DEFINES
@@ -48,7 +46,7 @@ typedef struct _lv_timer_t {
     lv_timer_cb_t timer_cb; /**< Timer function*/
     void * user_data; /**< Custom user data*/
     int32_t repeat_count; /**< 1: One time;  -1 : infinity;  n>0: residual times*/
-    uint32_t paused :1;
+    uint32_t paused : 1;
 } lv_timer_t;
 
 /**********************
@@ -63,7 +61,7 @@ void _lv_timer_core_init(void);
 //! @cond Doxygen_Suppress
 
 /**
- * Call it  periodically to handle lv_timers.
+ * Call it periodically to handle lv_timers.
  * @return time till it needs to be run next (in ms)
  */
 LV_ATTRIBUTE_TIMER_HANDLER uint32_t lv_timer_handler(void);
@@ -80,7 +78,7 @@ lv_timer_t * lv_timer_create_basic(void);
 /**
  * Create a new lv_timer
  * @param timer_xcb a callback to call periodically.
- *                 (the 'x' in the argument name indicates that its not a fully generic function because it not follows
+ *                 (the 'x' in the argument name indicates that it's not a fully generic function because it not follows
  *                  the `func_name(object, callback, ...)` convention)
  * @param period call period in ms unit
  * @param user_data custom parameter
@@ -97,7 +95,6 @@ void lv_timer_del(lv_timer_t * timer);
 /**
  * Pause/resume a timer.
  * @param timer pointer to an lv_timer
- * @param pause true: pause the timer; false: resume
  */
 void lv_timer_pause(lv_timer_t * timer);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_tlsf.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_tlsf.c
index 998f0f055..63d1842d6 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_tlsf.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_tlsf.c
@@ -1,1288 +1,1238 @@
-#include "../lv_conf_internal.h"
-#if LV_MEM_CUSTOM == 0
-
-#include <limits.h>
-#include <stddef.h>
-#include "lv_tlsf.h"
-#include "lv_mem.h"
-#include "lv_log.h"
-#include "lv_assert.h"
-#define printf LV_LOG_ERROR
-
-#define TLSF_MAX_POOL_SIZE LV_MEM_SIZE
-
-#if !defined(_DEBUG)
-#define _DEBUG 0
-#endif
-
-#if defined(__cplusplus)
-#define tlsf_decl inline
-#else
-#define tlsf_decl static
-#endif
-
-/*
-** Architecture-specific bit manipulation routines.
-**
-** TLSF achieves O(1) cost for malloc and free operations by limiting
-** the search for a free block to a free list of guaranteed size
-** adequate to fulfill the request, combined with efficient free list
-** queries using bitmasks and architecture-specific bit-manipulation
-** routines.
-**
-** Most modern processors provide instructions to count leading zeroes
-** in a word, find the lowest and highest set bit, etc. These
-** specific implementations will be used when available, falling back
-** to a reasonably efficient generic implementation.
-**
-** NOTE: TLSF spec relies on ffs/fls returning value 0..31.
-** ffs/fls return 1-32 by default, returning 0 for error.
-*/
-
-/*
-** Detect whether or not we are building for a 32- or 64-bit (LP/LLP)
-** architecture. There is no reliable portable method at compile-time.
-*/
-#if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) \
-	|| defined (_WIN64) || defined (__LP64__) || defined (__LLP64__)
-#define TLSF_64BIT
-#endif
-
-/*
-** Returns one plus the index of the most significant 1-bit of n,
-** or if n is zero, returns zero.
-*/
-#ifdef TLSF_64BIT
-#define TLSF_FLS(n) ((n) & 0xffffffff00000000ull ? 32 + TLSF_FLS32((size_t)(n) >> 32) : TLSF_FLS32(n))
-#else
-#define TLSF_FLS(n) TLSF_FLS32(n)
-#endif
-
-#define TLSF_FLS32(n) ((n) & 0xffff0000 ? 16 + TLSF_FLS16((n) >> 16) : TLSF_FLS16(n))
-#define TLSF_FLS16(n) ((n) & 0xff00     ?  8 + TLSF_FLS8 ((n) >>  8) : TLSF_FLS8 (n))
-#define TLSF_FLS8(n)  ((n) & 0xf0       ?  4 + TLSF_FLS4 ((n) >>  4) : TLSF_FLS4 (n))
-#define TLSF_FLS4(n)  ((n) & 0xc        ?  2 + TLSF_FLS2 ((n) >>  2) : TLSF_FLS2 (n))
-#define TLSF_FLS2(n)  ((n) & 0x2        ?  1 + TLSF_FLS1 ((n) >>  1) : TLSF_FLS1 (n))
-#define TLSF_FLS1(n)  ((n) & 0x1        ?  1 : 0)
-
-/*
-** Returns round up value of log2(n).
-** Note: it is used at compile time.
-*/
-#define TLSF_LOG2_CEIL(n) ((n) & (n - 1) ? TLSF_FLS(n) : TLSF_FLS(n) - 1)
-
-/*
-** gcc 3.4 and above have builtin support, specialized for architecture.
-** Some compilers masquerade as gcc; patchlevel test filters them out.
-*/
-#if defined (__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \
-	&& defined (__GNUC_PATCHLEVEL__)
-
-#if defined (__SNC__)
-/* SNC for Playstation 3. */
-
-tlsf_decl int tlsf_ffs(unsigned int word)
-{
-	const unsigned int reverse = word & (~word + 1);
-	const int bit = 32 - __builtin_clz(reverse);
-	return bit - 1;
-}
-
-#else
-
-tlsf_decl int tlsf_ffs(unsigned int word)
-{
-	return __builtin_ffs(word) - 1;
-}
-
-#endif
-
-tlsf_decl int tlsf_fls(unsigned int word)
-{
-	const int bit = word ? 32 - __builtin_clz(word) : 0;
-	return bit - 1;
-}
-
-#elif defined (_MSC_VER) && (_MSC_VER >= 1400) && (defined (_M_IX86) || defined (_M_X64))
-/* Microsoft Visual C++ support on x86/X64 architectures. */
-
-#include <intrin.h>
-
-#pragma intrinsic(_BitScanReverse)
-#pragma intrinsic(_BitScanForward)
-
-tlsf_decl int tlsf_fls(unsigned int word)
-{
-	unsigned long index;
-	return _BitScanReverse(&index, word) ? index : -1;
-}
-
-tlsf_decl int tlsf_ffs(unsigned int word)
-{
-	unsigned long index;
-	return _BitScanForward(&index, word) ? index : -1;
-}
-
-#elif defined (_MSC_VER) && defined (_M_PPC)
-/* Microsoft Visual C++ support on PowerPC architectures. */
-
-#include <ppcintrinsics.h>
-
-tlsf_decl int tlsf_fls(unsigned int word)
-{
-	const int bit = 32 - _CountLeadingZeros(word);
-	return bit - 1;
-}
-
-tlsf_decl int tlsf_ffs(unsigned int word)
-{
-	const unsigned int reverse = word & (~word + 1);
-	const int bit = 32 - _CountLeadingZeros(reverse);
-	return bit - 1;
-}
-
-#elif defined (__ARMCC_VERSION)
-/* RealView Compilation Tools for ARM */
-
-tlsf_decl int tlsf_ffs(unsigned int word)
-{
-	const unsigned int reverse = word & (~word + 1);
-	const int bit = 32 - __clz(reverse);
-	return bit - 1;
-}
-
-tlsf_decl int tlsf_fls(unsigned int word)
-{
-	const int bit = word ? 32 - __clz(word) : 0;
-	return bit - 1;
-}
-
-#elif defined (__ghs__)
-/* Green Hills support for PowerPC */
-
-#include <ppc_ghs.h>
-
-tlsf_decl int tlsf_ffs(unsigned int word)
-{
-	const unsigned int reverse = word & (~word + 1);
-	const int bit = 32 - __CLZ32(reverse);
-	return bit - 1;
-}
-
-tlsf_decl int tlsf_fls(unsigned int word)
-{
-	const int bit = word ? 32 - __CLZ32(word) : 0;
-	return bit - 1;
-}
-
-#else
-/* Fall back to generic implementation. */
-
-/* Implement ffs in terms of fls. */
-tlsf_decl int tlsf_ffs(unsigned int word)
-{
-	const unsigned int reverse = word & (~word + 1);
-	return TLSF_FLS32(reverse) - 1;
-}
-
-tlsf_decl int tlsf_fls(unsigned int word)
-{
-	return TLSF_FLS32(word) - 1;
-}
-
-#endif
-
-/* Possibly 64-bit version of tlsf_fls. */
-#if defined (TLSF_64BIT)
-tlsf_decl int tlsf_fls_sizet(size_t size)
-{
-	int high = (int)(size >> 32);
-	int bits = 0;
-	if (high)
-	{
-		bits = 32 + tlsf_fls(high);
-	}
-	else
-	{
-		bits = tlsf_fls((int)size & 0xffffffff);
-
-	}
-	return bits;
-}
-#else
-#define tlsf_fls_sizet tlsf_fls
-#endif
-
-#undef tlsf_decl
-
-/*
-** Constants.
-*/
-
-/* Public constants: may be modified. */
-enum tlsf_public
-{
-	/* log2 of number of linear subdivisions of block sizes. Larger
-	** values require more memory in the control structure. Values of
-	** 4 or 5 are typical.
-	*/
-	SL_INDEX_COUNT_LOG2 = 5,
-};
-
-/* Private constants: do not modify. */
-enum tlsf_private
-{
-#if defined (TLSF_64BIT)
-	/* All allocation sizes and addresses are aligned to 8 bytes. */
-	ALIGN_SIZE_LOG2 = 3,
-#else
-	/* All allocation sizes and addresses are aligned to 4 bytes. */
-	ALIGN_SIZE_LOG2 = 2,
-#endif
-	ALIGN_SIZE = (1 << ALIGN_SIZE_LOG2),
-
-	/*
-	** We support allocations of sizes up to (1 << FL_INDEX_MAX) bits.
-	** However, because we linearly subdivide the second-level lists, and
-	** our minimum size granularity is 4 bytes, it doesn't make sense to
-	** create first-level lists for sizes smaller than SL_INDEX_COUNT * 4,
-	** or (1 << (SL_INDEX_COUNT_LOG2 + 2)) bytes, as there we will be
-	** trying to split size ranges into more slots than we have available.
-	** Instead, we calculate the minimum threshold size, and place all
-	** blocks below that size into the 0th first-level list.
-	*/
-
-#if defined (TLSF_MAX_POOL_SIZE)
-	FL_INDEX_MAX = TLSF_LOG2_CEIL(TLSF_MAX_POOL_SIZE),
-#elif defined (TLSF_64BIT)
-	/*
-	** TODO: We can increase this to support larger sizes, at the expense
-	** of more overhead in the TLSF structure.
-	*/
-	FL_INDEX_MAX = 32,
-#else
-	FL_INDEX_MAX = 30,
-#endif
-	SL_INDEX_COUNT = (1 << SL_INDEX_COUNT_LOG2),
-	FL_INDEX_SHIFT = (SL_INDEX_COUNT_LOG2 + ALIGN_SIZE_LOG2),
-	FL_INDEX_COUNT = (FL_INDEX_MAX - FL_INDEX_SHIFT + 1),
-
-	SMALL_BLOCK_SIZE = (1 << FL_INDEX_SHIFT),
-};
-
-/*
-** Cast and min/max macros.
-*/
-
-#define tlsf_cast(t, exp)	((t) (exp))
-#define tlsf_min(a, b)		((a) < (b) ? (a) : (b))
-#define tlsf_max(a, b)		((a) > (b) ? (a) : (b))
-
-/*
-** Set assert macro, if it has not been provided by the user.
-*/
-#define tlsf_assert LV_ASSERT
-
-#if !defined (tlsf_assert)
-#define tlsf_assert assert
-#endif
-
-/*
-** Static assertion mechanism.
-*/
-
-#define _tlsf_glue2(x, y) x ## y
-#define _tlsf_glue(x, y) _tlsf_glue2(x, y)
-#define tlsf_static_assert(exp) \
-	typedef char _tlsf_glue(static_assert, __LINE__) [(exp) ? 1 : -1]
-
-/* This code has been tested on 32- and 64-bit (LP/LLP) architectures. */
-tlsf_static_assert(sizeof(int) * CHAR_BIT == 32);
-tlsf_static_assert(sizeof(size_t) * CHAR_BIT >= 32);
-tlsf_static_assert(sizeof(size_t) * CHAR_BIT <= 64);
-
-/* SL_INDEX_COUNT must be <= number of bits in sl_bitmap's storage type. */
-tlsf_static_assert(sizeof(unsigned int) * CHAR_BIT >= SL_INDEX_COUNT);
-
-/* Ensure we've properly tuned our sizes. */
-tlsf_static_assert(ALIGN_SIZE == SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
-
-/*
-** Data structures and associated constants.
-*/
-
-/*
-** Block header structure.
-**
-** There are several implementation subtleties involved:
-** - The prev_phys_block field is only valid if the previous block is free.
-** - The prev_phys_block field is actually stored at the end of the
-**   previous block. It appears at the beginning of this structure only to
-**   simplify the implementation.
-** - The next_free / prev_free fields are only valid if the block is free.
-*/
-typedef struct block_header_t
-{
-	/* Points to the previous physical block. */
-	struct block_header_t* prev_phys_block;
-
-	/* The size of this block, excluding the block header. */
-	size_t size;
-
-	/* Next and previous free blocks. */
-	struct block_header_t* next_free;
-	struct block_header_t* prev_free;
-} block_header_t;
-
-/*
-** Since block sizes are always at least a multiple of 4, the two least
-** significant bits of the size field are used to store the block status:
-** - bit 0: whether block is busy or free
-** - bit 1: whether previous block is busy or free
-*/
-static const size_t block_header_free_bit = 1 << 0;
-static const size_t block_header_prev_free_bit = 1 << 1;
-
-/*
-** The size of the block header exposed to used blocks is the size field.
-** The prev_phys_block field is stored *inside* the previous free block.
-*/
-static const size_t block_header_overhead = sizeof(size_t);
-
-/* User data starts directly after the size field in a used block. */
-static const size_t block_start_offset =
-	offsetof(block_header_t, size) + sizeof(size_t);
-
-/*
-** A free block must be large enough to store its header minus the size of
-** the prev_phys_block field, and no larger than the number of addressable
-** bits for FL_INDEX.
-*/
-static const size_t block_size_min = 
-	sizeof(block_header_t) - sizeof(block_header_t*);
-static const size_t block_size_max = tlsf_cast(size_t, 1) << FL_INDEX_MAX;
-
-
-/* The TLSF control structure. */
-typedef struct control_t
-{
-	/* Empty lists point at this block to indicate they are free. */
-	block_header_t block_null;
-
-	/* Bitmaps for free lists. */
-	unsigned int fl_bitmap;
-	unsigned int sl_bitmap[FL_INDEX_COUNT];
-
-	/* Head of free lists. */
-	block_header_t* blocks[FL_INDEX_COUNT][SL_INDEX_COUNT];
-} control_t;
-
-/* A type used for casting when doing pointer arithmetic. */
-typedef ptrdiff_t tlsfptr_t;
-
-/*
-** block_header_t member functions.
-*/
-
-static size_t block_size(const block_header_t* block)
-{
-	return block->size & ~(block_header_free_bit | block_header_prev_free_bit);
-}
-
-static void block_set_size(block_header_t* block, size_t size)
-{
-	const size_t oldsize = block->size;
-	block->size = size | (oldsize & (block_header_free_bit | block_header_prev_free_bit));
-}
-
-static int block_is_last(const block_header_t* block)
-{
-	return block_size(block) == 0;
-}
-
-static int block_is_free(const block_header_t* block)
-{
-	return tlsf_cast(int, block->size & block_header_free_bit);
-}
-
-static void block_set_free(block_header_t* block)
-{
-	block->size |= block_header_free_bit;
-}
-
-static void block_set_used(block_header_t* block)
-{
-	block->size &= ~block_header_free_bit;
-}
-
-static int block_is_prev_free(const block_header_t* block)
-{
-	return tlsf_cast(int, block->size & block_header_prev_free_bit);
-}
-
-static void block_set_prev_free(block_header_t* block)
-{
-	block->size |= block_header_prev_free_bit;
-}
-
-static void block_set_prev_used(block_header_t* block)
-{
-	block->size &= ~block_header_prev_free_bit;
-}
-
-static block_header_t* block_from_ptr(const void* ptr)
-{
-	return tlsf_cast(block_header_t*,
-		tlsf_cast(unsigned char*, ptr) - block_start_offset);
-}
-
-static void* block_to_ptr(const block_header_t* block)
-{
-	return tlsf_cast(void*,
-		tlsf_cast(unsigned char*, block) + block_start_offset);
-}
-
-/* Return location of next block after block of given size. */
-static block_header_t* offset_to_block(const void* ptr, size_t size)
-{
-	return tlsf_cast(block_header_t*, tlsf_cast(tlsfptr_t, ptr) + size);
-}
-
-/* Return location of previous block. */
-static block_header_t* block_prev(const block_header_t* block)
-{
-	tlsf_assert(block_is_prev_free(block) && "previous block must be free");
-	return block->prev_phys_block;
-}
-
-/* Return location of next existing block. */
-static block_header_t* block_next(const block_header_t* block)
-{
-	block_header_t* next = offset_to_block(block_to_ptr(block),
-		block_size(block) - block_header_overhead);
-	tlsf_assert(!block_is_last(block));
-	return next;
-}
-
-/* Link a new block with its physical neighbor, return the neighbor. */
-static block_header_t* block_link_next(block_header_t* block)
-{
-	block_header_t* next = block_next(block);
-	next->prev_phys_block = block;
-	return next;
-}
-
-static void block_mark_as_free(block_header_t* block)
-{
-	/* Link the block to the next block, first. */
-	block_header_t* next = block_link_next(block);
-	block_set_prev_free(next);
-	block_set_free(block);
-}
-
-static void block_mark_as_used(block_header_t* block)
-{
-	block_header_t* next = block_next(block);
-	block_set_prev_used(next);
-	block_set_used(block);
-}
-
-static size_t align_up(size_t x, size_t align)
-{
-	tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
-	return (x + (align - 1)) & ~(align - 1);
-}
-
-static size_t align_down(size_t x, size_t align)
-{
-	tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
-	return x - (x & (align - 1));
-}
-
-static void* align_ptr(const void* ptr, size_t align)
-{
-	const tlsfptr_t aligned =
-		(tlsf_cast(tlsfptr_t, ptr) + (align - 1)) & ~(align - 1);
-	tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
-	return tlsf_cast(void*, aligned);
-}
-
-/*
-** Adjust an allocation size to be aligned to word size, and no smaller
-** than internal minimum.
-*/
-static size_t adjust_request_size(size_t size, size_t align)
-{
-	size_t adjust = 0;
-	if (size)
-	{
-		const size_t aligned = align_up(size, align);
-
-		/* aligned sized must not exceed block_size_max or we'll go out of bounds on sl_bitmap */
-		if (aligned < block_size_max) 
-		{
-			adjust = tlsf_max(aligned, block_size_min);
-		}
-	}
-	return adjust;
-}
-
-/*
-** TLSF utility functions. In most cases, these are direct translations of
-** the documentation found in the white paper.
-*/
-
-static void mapping_insert(size_t size, int* fli, int* sli)
-{
-	int fl, sl;
-	if (size < SMALL_BLOCK_SIZE)
-	{
-		/* Store small blocks in first list. */
-		fl = 0;
-		sl = tlsf_cast(int, size) / (SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
-	}
-	else
-	{
-		fl = tlsf_fls_sizet(size);
-		sl = tlsf_cast(int, size >> (fl - SL_INDEX_COUNT_LOG2)) ^ (1 << SL_INDEX_COUNT_LOG2);
-		fl -= (FL_INDEX_SHIFT - 1);
-	}
-	*fli = fl;
-	*sli = sl;
-}
-
-/* This version rounds up to the next block size (for allocations) */
-static void mapping_search(size_t size, int* fli, int* sli)
-{
-	if (size >= SMALL_BLOCK_SIZE)
-	{
-		const size_t round = (1 << (tlsf_fls_sizet(size) - SL_INDEX_COUNT_LOG2)) - 1;
-		size += round;
-	}
-	mapping_insert(size, fli, sli);
-}
-
-static block_header_t* search_suitable_block(control_t* control, int* fli, int* sli)
-{
-	int fl = *fli;
-	int sl = *sli;
-
-	/*
-	** First, search for a block in the list associated with the given
-	** fl/sl index.
-	*/
-	unsigned int sl_map = control->sl_bitmap[fl] & (~0U << sl);
-	if (!sl_map)
-	{
-		/* No block exists. Search in the next largest first-level list. */
-		const unsigned int fl_map = control->fl_bitmap & (~0U << (fl + 1));
-		if (!fl_map)
-		{
-			/* No free blocks available, memory has been exhausted. */
-			return 0;
-		}
-
-		fl = tlsf_ffs(fl_map);
-		*fli = fl;
-		sl_map = control->sl_bitmap[fl];
-	}
-	tlsf_assert(sl_map && "internal error - second level bitmap is null");
-	sl = tlsf_ffs(sl_map);
-	*sli = sl;
-
-	/* Return the first block in the free list. */
-	return control->blocks[fl][sl];
-}
-
-/* Remove a free block from the free list.*/
-static void remove_free_block(control_t* control, block_header_t* block, int fl, int sl)
-{
-	block_header_t* prev = block->prev_free;
-	block_header_t* next = block->next_free;
-	tlsf_assert(prev && "prev_free field can not be null");
-	tlsf_assert(next && "next_free field can not be null");
-	next->prev_free = prev;
-	prev->next_free = next;
-
-	/* If this block is the head of the free list, set new head. */
-	if (control->blocks[fl][sl] == block)
-	{
-		control->blocks[fl][sl] = next;
-
-		/* If the new head is null, clear the bitmap. */
-		if (next == &control->block_null)
-		{
-			control->sl_bitmap[fl] &= ~(1U << sl);
-
-			/* If the second bitmap is now empty, clear the fl bitmap. */
-			if (!control->sl_bitmap[fl])
-			{
-				control->fl_bitmap &= ~(1U << fl);
-			}
-		}
-	}
-}
-
-/* Insert a free block into the free block list. */
-static void insert_free_block(control_t* control, block_header_t* block, int fl, int sl)
-{
-	block_header_t* current = control->blocks[fl][sl];
-	tlsf_assert(current && "free list cannot have a null entry");
-	tlsf_assert(block && "cannot insert a null entry into the free list");
-	block->next_free = current;
-	block->prev_free = &control->block_null;
-	current->prev_free = block;
-
-	tlsf_assert(block_to_ptr(block) == align_ptr(block_to_ptr(block), ALIGN_SIZE)
-		&& "block not aligned properly");
-	/*
-	** Insert the new block at the head of the list, and mark the first-
-	** and second-level bitmaps appropriately.
-	*/
-	control->blocks[fl][sl] = block;
-	control->fl_bitmap |= (1U << fl);
-	control->sl_bitmap[fl] |= (1U << sl);
-}
-
-/* Remove a given block from the free list. */
-static void block_remove(control_t* control, block_header_t* block)
-{
-	int fl, sl;
-	mapping_insert(block_size(block), &fl, &sl);
-	remove_free_block(control, block, fl, sl);
-}
-
-/* Insert a given block into the free list. */
-static void block_insert(control_t* control, block_header_t* block)
-{
-	int fl, sl;
-	mapping_insert(block_size(block), &fl, &sl);
-	insert_free_block(control, block, fl, sl);
-}
-
-static int block_can_split(block_header_t* block, size_t size)
-{
-	return block_size(block) >= sizeof(block_header_t) + size;
-}
-
-/* Split a block into two, the second of which is free. */
-static block_header_t* block_split(block_header_t* block, size_t size)
-{
-	/* Calculate the amount of space left in the remaining block. */
-	block_header_t* remaining =
-		offset_to_block(block_to_ptr(block), size - block_header_overhead);
-
-	const size_t remain_size = block_size(block) - (size + block_header_overhead);
-
-	tlsf_assert(block_to_ptr(remaining) == align_ptr(block_to_ptr(remaining), ALIGN_SIZE)
-		&& "remaining block not aligned properly");
-
-	tlsf_assert(block_size(block) == remain_size + size + block_header_overhead);
-	block_set_size(remaining, remain_size);
-	tlsf_assert(block_size(remaining) >= block_size_min && "block split with invalid size");
-
-	block_set_size(block, size);
-	block_mark_as_free(remaining);
-
-	return remaining;
-}
-
-/* Absorb a free block's storage into an adjacent previous free block. */
-static block_header_t* block_absorb(block_header_t* prev, block_header_t* block)
-{
-	tlsf_assert(!block_is_last(prev) && "previous block can't be last");
-	/* Note: Leaves flags untouched. */
-	prev->size += block_size(block) + block_header_overhead;
-	block_link_next(prev);
-	return prev;
-}
-
-/* Merge a just-freed block with an adjacent previous free block. */
-static block_header_t* block_merge_prev(control_t* control, block_header_t* block)
-{
-	if (block_is_prev_free(block))
-	{
-		block_header_t* prev = block_prev(block);
-		tlsf_assert(prev && "prev physical block can't be null");
-		tlsf_assert(block_is_free(prev) && "prev block is not free though marked as such");
-		block_remove(control, prev);
-		block = block_absorb(prev, block);
-	}
-
-	return block;
-}
-
-/* Merge a just-freed block with an adjacent free block. */
-static block_header_t* block_merge_next(control_t* control, block_header_t* block)
-{
-	block_header_t* next = block_next(block);
-	tlsf_assert(next && "next physical block can't be null");
-
-	if (block_is_free(next))
-	{
-		tlsf_assert(!block_is_last(block) && "previous block can't be last");
-		block_remove(control, next);
-		block = block_absorb(block, next);
-	}
-
-	return block;
-}
-
-/* Trim any trailing block space off the end of a block, return to pool. */
-static void block_trim_free(control_t* control, block_header_t* block, size_t size)
-{
-	tlsf_assert(block_is_free(block) && "block must be free");
-	if (block_can_split(block, size))
-	{
-		block_header_t* remaining_block = block_split(block, size);
-		block_link_next(block);
-		block_set_prev_free(remaining_block);
-		block_insert(control, remaining_block);
-	}
-}
-
-/* Trim any trailing block space off the end of a used block, return to pool. */
-static void block_trim_used(control_t* control, block_header_t* block, size_t size)
-{
-	tlsf_assert(!block_is_free(block) && "block must be used");
-	if (block_can_split(block, size))
-	{
-		/* If the next block is free, we must coalesce. */
-		block_header_t* remaining_block = block_split(block, size);
-		block_set_prev_used(remaining_block);
-
-		remaining_block = block_merge_next(control, remaining_block);
-		block_insert(control, remaining_block);
-	}
-}
-
-static block_header_t* block_trim_free_leading(control_t* control, block_header_t* block, size_t size)
-{
-	block_header_t* remaining_block = block;
-	if (block_can_split(block, size))
-	{
-		/* We want the 2nd block. */
-		remaining_block = block_split(block, size - block_header_overhead);
-		block_set_prev_free(remaining_block);
-
-		block_link_next(block);
-		block_insert(control, block);
-	}
-
-	return remaining_block;
-}
-
-static block_header_t* block_locate_free(control_t* control, size_t size)
-{
-	int fl = 0, sl = 0;
-	block_header_t* block = 0;
-
-	if (size)
-	{
-		mapping_search(size, &fl, &sl);
-		
-		/*
-		** mapping_search can futz with the size, so for excessively large sizes it can sometimes wind up 
-		** with indices that are off the end of the block array.
-		** So, we protect against that here, since this is the only callsite of mapping_search.
-		** Note that we don't need to check sl, since it comes from a modulo operation that guarantees it's always in range.
-		*/
-		if (fl < FL_INDEX_COUNT)
-		{
-			block = search_suitable_block(control, &fl, &sl);
-		}
-	}
-
-	if (block)
-	{
-		tlsf_assert(block_size(block) >= size);
-		remove_free_block(control, block, fl, sl);
-	}
-
-	return block;
-}
-
-static void* block_prepare_used(control_t* control, block_header_t* block, size_t size)
-{
-	void* p = 0;
-	if (block)
-	{
-		tlsf_assert(size && "size must be non-zero");
-		block_trim_free(control, block, size);
-		block_mark_as_used(block);
-		p = block_to_ptr(block);
-	}
-	return p;
-}
-
-/* Clear structure and point all empty lists at the null block. */
-static void control_constructor(control_t* control)
-{
-	int i, j;
-
-	control->block_null.next_free = &control->block_null;
-	control->block_null.prev_free = &control->block_null;
-
-	control->fl_bitmap = 0;
-	for (i = 0; i < FL_INDEX_COUNT; ++i)
-	{
-		control->sl_bitmap[i] = 0;
-		for (j = 0; j < SL_INDEX_COUNT; ++j)
-		{
-			control->blocks[i][j] = &control->block_null;
-		}
-	}
-}
-
-/*
-** Debugging utilities.
-*/
-
-typedef struct integrity_t
-{
-	int prev_status;
-	int status;
-} integrity_t;
-
-#define tlsf_insist(x) { tlsf_assert(x); if (!(x)) { status--; } }
-
-static void integrity_walker(void* ptr, size_t size, int used, void* user)
-{
-	block_header_t* block = block_from_ptr(ptr);
-	integrity_t* integ = tlsf_cast(integrity_t*, user);
-	const int this_prev_status = block_is_prev_free(block) ? 1 : 0;
-	const int this_status = block_is_free(block) ? 1 : 0;
-	const size_t this_block_size = block_size(block);
-
-	int status = 0;
-	(void)used;
-	tlsf_insist(integ->prev_status == this_prev_status && "prev status incorrect");
-	tlsf_insist(size == this_block_size && "block size incorrect");
-
-	integ->prev_status = this_status;
-	integ->status += status;
-}
-
-int lv_tlsf_check(lv_tlsf_t tlsf)
-{
-	int i, j;
-
-	control_t* control = tlsf_cast(control_t*, tlsf);
-	int status = 0;
-
-	/* Check that the free lists and bitmaps are accurate. */
-	for (i = 0; i < FL_INDEX_COUNT; ++i)
-	{
-		for (j = 0; j < SL_INDEX_COUNT; ++j)
-		{
-			const int fl_map = control->fl_bitmap & (1U << i);
-			const int sl_list = control->sl_bitmap[i];
-			const int sl_map = sl_list & (1U << j);
-			const block_header_t* block = control->blocks[i][j];
-
-			/* Check that first- and second-level lists agree. */
-			if (!fl_map)
-			{
-				tlsf_insist(!sl_map && "second-level map must be null");
-			}
-
-			if (!sl_map)
-			{
-				tlsf_insist(block == &control->block_null && "block list must be null");
-				continue;
-			}
-
-			/* Check that there is at least one free block. */
-			tlsf_insist(sl_list && "no free blocks in second-level map");
-			tlsf_insist(block != &control->block_null && "block should not be null");
-
-			while (block != &control->block_null)
-			{
-				int fli, sli;
-				tlsf_insist(block_is_free(block) && "block should be free");
-				tlsf_insist(!block_is_prev_free(block) && "blocks should have coalesced");
-				tlsf_insist(!block_is_free(block_next(block)) && "blocks should have coalesced");
-				tlsf_insist(block_is_prev_free(block_next(block)) && "block should be free");
-				tlsf_insist(block_size(block) >= block_size_min && "block not minimum size");
-
-				mapping_insert(block_size(block), &fli, &sli);
-				tlsf_insist(fli == i && sli == j && "block size indexed in wrong list");
-				block = block->next_free;
-			}
-		}
-	}
-
-	return status;
-}
-
-#undef tlsf_insist
-
-static void default_walker(void* ptr, size_t size, int used, void* user)
-{
-	(void)user;
-	printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, (void*)block_from_ptr(ptr));
-}
-
-void lv_tlsf_walk_pool(lv_pool_t pool, lv_tlsf_walker walker, void* user)
-{
-	lv_tlsf_walker pool_walker = walker ? walker : default_walker;
-	block_header_t* block =
-		offset_to_block(pool, -(int)block_header_overhead);
-
-	while (block && !block_is_last(block))
-	{
-		pool_walker(
-			block_to_ptr(block),
-			block_size(block),
-			!block_is_free(block),
-			user);
-		block = block_next(block);
-	}
-}
-
-size_t lv_tlsf_block_size(void* ptr)
-{
-	size_t size = 0;
-	if (ptr)
-	{
-		const block_header_t* block = block_from_ptr(ptr);
-		size = block_size(block);
-	}
-	return size;
-}
-
-int lv_tlsf_check_pool(lv_pool_t pool)
-{
-	/* Check that the blocks are physically correct. */
-	integrity_t integ = { 0, 0 };
-	lv_tlsf_walk_pool(pool, integrity_walker, &integ);
-
-	return integ.status;
-}
-
-/*
-** Size of the TLSF structures in a given memory block passed to
-** lv_tlsf_create, equal to the size of a control_t
-*/
-size_t lv_tlsf_size(void)
-{
-	return sizeof(control_t);
-}
-
-size_t lv_tlsf_align_size(void)
-{
-	return ALIGN_SIZE;
-}
-
-size_t lv_tlsf_block_size_min(void)
-{
-	return block_size_min;
-}
-
-size_t lv_tlsf_block_size_max(void)
-{
-	return block_size_max;
-}
-
-/*
-** Overhead of the TLSF structures in a given memory block passed to
-** lv_tlsf_add_pool, equal to the overhead of a free block and the
-** sentinel block.
-*/
-size_t lv_tlsf_pool_overhead(void)
-{
-	return 2 * block_header_overhead;
-}
-
-size_t lv_tlsf_alloc_overhead(void)
-{
-	return block_header_overhead;
-}
-
-lv_pool_t lv_tlsf_add_pool(lv_tlsf_t tlsf, void* mem, size_t bytes)
-{
-	block_header_t* block;
-	block_header_t* next;
-
-	const size_t pool_overhead = lv_tlsf_pool_overhead();
-	const size_t pool_bytes = align_down(bytes - pool_overhead, ALIGN_SIZE);
-
-	if (((ptrdiff_t)mem % ALIGN_SIZE) != 0)
-	{
-		printf("lv_tlsf_add_pool: Memory must be aligned by %u bytes.\n",
-			(unsigned int)ALIGN_SIZE);
-		return 0;
-	}
-
-	if (pool_bytes < block_size_min || pool_bytes > block_size_max)
-	{
-#if defined (TLSF_64BIT)
-		printf("lv_tlsf_add_pool: Memory size must be between 0x%x and 0x%x00 bytes.\n", 
-			(unsigned int)(pool_overhead + block_size_min),
-			(unsigned int)((pool_overhead + block_size_max) / 256));
-#else
-		printf("lv_tlsf_add_pool: Memory size must be between %u and %u bytes.\n", 
-			(unsigned int)(pool_overhead + block_size_min),
-			(unsigned int)(pool_overhead + block_size_max));
-#endif
-		return 0;
-	}
-
-	/*
-	** Create the main free block. Offset the start of the block slightly
-	** so that the prev_phys_block field falls outside of the pool -
-	** it will never be used.
-	*/
-	block = offset_to_block(mem, -(tlsfptr_t)block_header_overhead);
-	block_set_size(block, pool_bytes);
-	block_set_free(block);
-	block_set_prev_used(block);
-	block_insert(tlsf_cast(control_t*, tlsf), block);
-
-	/* Split the block to create a zero-size sentinel block. */
-	next = block_link_next(block);
-	block_set_size(next, 0);
-	block_set_used(next);
-	block_set_prev_free(next);
-
-	return mem;
-}
-
-void lv_tlsf_remove_pool(lv_tlsf_t tlsf, lv_pool_t pool)
-{
-	control_t* control = tlsf_cast(control_t*, tlsf);
-	block_header_t* block = offset_to_block(pool, -(int)block_header_overhead);
-
-	int fl = 0, sl = 0;
-
-	tlsf_assert(block_is_free(block) && "block should be free");
-	tlsf_assert(!block_is_free(block_next(block)) && "next block should not be free");
-	tlsf_assert(block_size(block_next(block)) == 0 && "next block size should be zero");
-
-	mapping_insert(block_size(block), &fl, &sl);
-	remove_free_block(control, block, fl, sl);
-}
-
-/*
-** TLSF main interface.
-*/
-
-#if _DEBUG
-int test_ffs_fls()
-{
-	/* Verify ffs/fls work properly. */
-	int rv = 0;
-	rv += (tlsf_ffs(0) == -1) ? 0 : 0x1;
-	rv += (tlsf_fls(0) == -1) ? 0 : 0x2;
-	rv += (tlsf_ffs(1) == 0) ? 0 : 0x4;
-	rv += (tlsf_fls(1) == 0) ? 0 : 0x8;
-	rv += (tlsf_ffs(0x80000000) == 31) ? 0 : 0x10;
-	rv += (tlsf_ffs(0x80008000) == 15) ? 0 : 0x20;
-	rv += (tlsf_fls(0x80000008) == 31) ? 0 : 0x40;
-	rv += (tlsf_fls(0x7FFFFFFF) == 30) ? 0 : 0x80;
-
-#if defined (TLSF_64BIT)
-	rv += (tlsf_fls_sizet(0x80000000) == 31) ? 0 : 0x100;
-	rv += (tlsf_fls_sizet(0x100000000) == 32) ? 0 : 0x200;
-	rv += (tlsf_fls_sizet(0xffffffffffffffff) == 63) ? 0 : 0x400;
-#endif
-
-	if (rv)
-	{
-		printf("test_ffs_fls: %x ffs/fls tests failed.\n", rv);
-	}
-	return rv;
-}
-#endif
-
-lv_tlsf_t lv_tlsf_create(void* mem)
-{
-#if _DEBUG
-	if (test_ffs_fls())
-	{
-		return 0;
-	}
-#endif
-
-	if (((tlsfptr_t)mem % ALIGN_SIZE) != 0)
-	{
-		printf("lv_tlsf_create: Memory must be aligned to %u bytes.\n",
-			(unsigned int)ALIGN_SIZE);
-		return 0;
-	}
-
-	control_constructor(tlsf_cast(control_t*, mem));
-
-	return tlsf_cast(lv_tlsf_t, mem);
-}
-
-lv_tlsf_t lv_tlsf_create_with_pool(void* mem, size_t bytes)
-{
-	lv_tlsf_t tlsf = lv_tlsf_create(mem);
-	lv_tlsf_add_pool(tlsf, (char*)mem + lv_tlsf_size(), bytes - lv_tlsf_size());
-	return tlsf;
-}
-
-void lv_tlsf_destroy(lv_tlsf_t tlsf)
-{
-	/* Nothing to do. */
-	(void)tlsf;
-}
-
-lv_pool_t lv_tlsf_get_pool(lv_tlsf_t tlsf)
-{
-	return tlsf_cast(lv_pool_t, (char*)tlsf + lv_tlsf_size());
-}
-
-void* lv_tlsf_malloc(lv_tlsf_t tlsf, size_t size)
-{
-	control_t* control = tlsf_cast(control_t*, tlsf);
-	const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
-	block_header_t* block = block_locate_free(control, adjust);
-	return block_prepare_used(control, block, adjust);
-}
-
-void* lv_tlsf_memalign(lv_tlsf_t tlsf, size_t align, size_t size)
-{
-	control_t* control = tlsf_cast(control_t*, tlsf);
-	const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
-
-	/*
-	** We must allocate an additional minimum block size bytes so that if
-	** our free block will leave an alignment gap which is smaller, we can
-	** trim a leading free block and release it back to the pool. We must
-	** do this because the previous physical block is in use, therefore
-	** the prev_phys_block field is not valid, and we can't simply adjust
-	** the size of that block.
-	*/
-	const size_t gap_minimum = sizeof(block_header_t);
-	const size_t size_with_gap = adjust_request_size(adjust + align + gap_minimum, align);
-
-	/*
-	** If alignment is less than or equals base alignment, we're done.
-	** If we requested 0 bytes, return null, as lv_tlsf_malloc(0) does.
-	*/
-	const size_t aligned_size = (adjust && align > ALIGN_SIZE) ? size_with_gap : adjust;
-
-	block_header_t* block = block_locate_free(control, aligned_size);
-
-	/* This can't be a static assert. */
-	tlsf_assert(sizeof(block_header_t) == block_size_min + block_header_overhead);
-
-	if (block)
-	{
-		void* ptr = block_to_ptr(block);
-		void* aligned = align_ptr(ptr, align);
-		size_t gap = tlsf_cast(size_t,
-			tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr));
-
-		/* If gap size is too small, offset to next aligned boundary. */
-		if (gap && gap < gap_minimum)
-		{
-			const size_t gap_remain = gap_minimum - gap;
-			const size_t offset = tlsf_max(gap_remain, align);
-			const void* next_aligned = tlsf_cast(void*,
-				tlsf_cast(tlsfptr_t, aligned) + offset);
-
-			aligned = align_ptr(next_aligned, align);
-			gap = tlsf_cast(size_t,
-				tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr));
-		}
-
-		if (gap)
-		{
-			tlsf_assert(gap >= gap_minimum && "gap size too small");
-			block = block_trim_free_leading(control, block, gap);
-		}
-	}
-
-	return block_prepare_used(control, block, adjust);
-}
-
-void lv_tlsf_free(lv_tlsf_t tlsf, void* ptr)
-{
-	/* Don't attempt to free a NULL pointer. */
-	if (ptr)
-	{
-		control_t* control = tlsf_cast(control_t*, tlsf);
-		block_header_t* block = block_from_ptr(ptr);
-		tlsf_assert(!block_is_free(block) && "block already marked as free");
-		block_mark_as_free(block);
-		block = block_merge_prev(control, block);
-		block = block_merge_next(control, block);
-		block_insert(control, block);
-	}
-}
-
-/*
-** The TLSF block information provides us with enough information to
-** provide a reasonably intelligent implementation of realloc, growing or
-** shrinking the currently allocated block as required.
-**
-** This routine handles the somewhat esoteric edge cases of realloc:
-** - a non-zero size with a null pointer will behave like malloc
-** - a zero size with a non-null pointer will behave like free
-** - a request that cannot be satisfied will leave the original buffer
-**   untouched
-** - an extended buffer size will leave the newly-allocated area with
-**   contents undefined
-*/
-void* lv_tlsf_realloc(lv_tlsf_t tlsf, void* ptr, size_t size)
-{
-	control_t* control = tlsf_cast(control_t*, tlsf);
-	void* p = 0;
-
-	/* Zero-size requests are treated as free. */
-	if (ptr && size == 0)
-	{
-		lv_tlsf_free(tlsf, ptr);
-	}
-	/* Requests with NULL pointers are treated as malloc. */
-	else if (!ptr)
-	{
-		p = lv_tlsf_malloc(tlsf, size);
-	}
-	else
-	{
-		block_header_t* block = block_from_ptr(ptr);
-		block_header_t* next = block_next(block);
-
-		const size_t cursize = block_size(block);
-		const size_t combined = cursize + block_size(next) + block_header_overhead;
-		const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
-
-		tlsf_assert(!block_is_free(block) && "block already marked as free");
-
-		/*
-		** If the next block is used, or when combined with the current
-		** block, does not offer enough space, we must reallocate and copy.
-		*/
-		if (adjust > cursize && (!block_is_free(next) || adjust > combined))
-		{
-			p = lv_tlsf_malloc(tlsf, size);
-			if (p)
-			{
-				const size_t minsize = tlsf_min(cursize, size);
-				lv_memcpy(p, ptr, minsize);
-				lv_tlsf_free(tlsf, ptr);
-			}
-		}
-		else
-		{
-			/* Do we need to expand to the next block? */
-			if (adjust > cursize)
-			{
-				block_merge_next(control, block);
-				block_mark_as_used(block);
-			}
-
-			/* Trim the resulting block and return the original pointer. */
-			block_trim_used(control, block, adjust);
-			p = ptr;
-		}
-	}
-
-	return p;
-}
-
-#endif /* LV_MEM_CUSTOM == 0 */
+#include "../lv_conf_internal.h"
+#if LV_MEM_CUSTOM == 0
+
+#include <limits.h>
+#include "lv_tlsf.h"
+#include "lv_mem.h"
+#include "lv_log.h"
+#include "lv_assert.h"
+
+#undef  printf
+#define printf LV_LOG_ERROR
+
+#define TLSF_MAX_POOL_SIZE LV_MEM_SIZE
+
+#if !defined(_DEBUG)
+    #define _DEBUG 0
+#endif
+
+#if defined(__cplusplus)
+    #define tlsf_decl inline
+#else
+    #define tlsf_decl static
+#endif
+
+/*
+** Architecture-specific bit manipulation routines.
+**
+** TLSF achieves O(1) cost for malloc and free operations by limiting
+** the search for a free block to a free list of guaranteed size
+** adequate to fulfill the request, combined with efficient free list
+** queries using bitmasks and architecture-specific bit-manipulation
+** routines.
+**
+** Most modern processors provide instructions to count leading zeroes
+** in a word, find the lowest and highest set bit, etc. These
+** specific implementations will be used when available, falling back
+** to a reasonably efficient generic implementation.
+**
+** NOTE: TLSF spec relies on ffs/fls returning value 0..31.
+** ffs/fls return 1-32 by default, returning 0 for error.
+*/
+
+/*
+** Detect whether or not we are building for a 32- or 64-bit (LP/LLP)
+** architecture. There is no reliable portable method at compile-time.
+*/
+#if defined (__alpha__) || defined (__ia64__) || defined (__x86_64__) \
+    || defined (_WIN64) || defined (__LP64__) || defined (__LLP64__)
+    #define TLSF_64BIT
+#endif
+
+/*
+** Returns one plus the index of the most significant 1-bit of n,
+** or if n is zero, returns zero.
+*/
+#ifdef TLSF_64BIT
+    #define TLSF_FLS(n) ((n) & 0xffffffff00000000ull ? 32 + TLSF_FLS32((size_t)(n) >> 32) : TLSF_FLS32(n))
+#else
+    #define TLSF_FLS(n) TLSF_FLS32(n)
+#endif
+
+#define TLSF_FLS32(n) ((n) & 0xffff0000 ? 16 + TLSF_FLS16((n) >> 16) : TLSF_FLS16(n))
+#define TLSF_FLS16(n) ((n) & 0xff00     ?  8 + TLSF_FLS8 ((n) >>  8) : TLSF_FLS8 (n))
+#define TLSF_FLS8(n)  ((n) & 0xf0       ?  4 + TLSF_FLS4 ((n) >>  4) : TLSF_FLS4 (n))
+#define TLSF_FLS4(n)  ((n) & 0xc        ?  2 + TLSF_FLS2 ((n) >>  2) : TLSF_FLS2 (n))
+#define TLSF_FLS2(n)  ((n) & 0x2        ?  1 + TLSF_FLS1 ((n) >>  1) : TLSF_FLS1 (n))
+#define TLSF_FLS1(n)  ((n) & 0x1        ?  1 : 0)
+
+/*
+** Returns round up value of log2(n).
+** Note: it is used at compile time.
+*/
+#define TLSF_LOG2_CEIL(n) ((n) & (n - 1) ? TLSF_FLS(n) : TLSF_FLS(n) - 1)
+
+/*
+** gcc 3.4 and above have builtin support, specialized for architecture.
+** Some compilers masquerade as gcc; patchlevel test filters them out.
+*/
+#if defined (__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \
+    && defined (__GNUC_PATCHLEVEL__)
+
+#if defined (__SNC__)
+/* SNC for Playstation 3. */
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    const int bit = 32 - __builtin_clz(reverse);
+    return bit - 1;
+}
+
+#else
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    return __builtin_ffs(word) - 1;
+}
+
+#endif
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    const int bit = word ? 32 - __builtin_clz(word) : 0;
+    return bit - 1;
+}
+
+#elif defined (_MSC_VER) && (_MSC_VER >= 1400) && (defined (_M_IX86) || defined (_M_X64))
+/* Microsoft Visual C++ support on x86/X64 architectures. */
+
+#include <intrin.h>
+
+#pragma intrinsic(_BitScanReverse)
+#pragma intrinsic(_BitScanForward)
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    unsigned long index;
+    return _BitScanReverse(&index, word) ? index : -1;
+}
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    unsigned long index;
+    return _BitScanForward(&index, word) ? index : -1;
+}
+
+#elif defined (_MSC_VER) && defined (_M_PPC)
+/* Microsoft Visual C++ support on PowerPC architectures. */
+
+#include <ppcintrinsics.h>
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    const int bit = 32 - _CountLeadingZeros(word);
+    return bit - 1;
+}
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    const int bit = 32 - _CountLeadingZeros(reverse);
+    return bit - 1;
+}
+
+#elif defined (__ARMCC_VERSION)
+/* RealView Compilation Tools for ARM */
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    const int bit = 32 - __clz(reverse);
+    return bit - 1;
+}
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    const int bit = word ? 32 - __clz(word) : 0;
+    return bit - 1;
+}
+
+#elif defined (__ghs__)
+/* Green Hills support for PowerPC */
+
+#include <ppc_ghs.h>
+
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    const int bit = 32 - __CLZ32(reverse);
+    return bit - 1;
+}
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    const int bit = word ? 32 - __CLZ32(word) : 0;
+    return bit - 1;
+}
+
+#else
+/* Fall back to generic implementation. */
+
+/* Implement ffs in terms of fls. */
+tlsf_decl int tlsf_ffs(unsigned int word)
+{
+    const unsigned int reverse = word & (~word + 1);
+    return TLSF_FLS32(reverse) - 1;
+}
+
+tlsf_decl int tlsf_fls(unsigned int word)
+{
+    return TLSF_FLS32(word) - 1;
+}
+
+#endif
+
+/* Possibly 64-bit version of tlsf_fls. */
+#if defined (TLSF_64BIT)
+tlsf_decl int tlsf_fls_sizet(size_t size)
+{
+    int high = (int)(size >> 32);
+    int bits = 0;
+    if(high) {
+        bits = 32 + tlsf_fls(high);
+    }
+    else {
+        bits = tlsf_fls((int)size & 0xffffffff);
+
+    }
+    return bits;
+}
+#else
+#define tlsf_fls_sizet tlsf_fls
+#endif
+
+#undef tlsf_decl
+
+/*
+** Constants.
+*/
+
+/* Public constants: may be modified. */
+enum tlsf_public {
+    /* log2 of number of linear subdivisions of block sizes. Larger
+    ** values require more memory in the control structure. Values of
+    ** 4 or 5 are typical.
+    */
+    SL_INDEX_COUNT_LOG2 = 5,
+};
+
+/* Private constants: do not modify. */
+enum tlsf_private {
+#if defined (TLSF_64BIT)
+    /* All allocation sizes and addresses are aligned to 8 bytes. */
+    ALIGN_SIZE_LOG2 = 3,
+#else
+    /* All allocation sizes and addresses are aligned to 4 bytes. */
+    ALIGN_SIZE_LOG2 = 2,
+#endif
+    ALIGN_SIZE = (1 << ALIGN_SIZE_LOG2),
+
+    /*
+    ** We support allocations of sizes up to (1 << FL_INDEX_MAX) bits.
+    ** However, because we linearly subdivide the second-level lists, and
+    ** our minimum size granularity is 4 bytes, it doesn't make sense to
+    ** create first-level lists for sizes smaller than SL_INDEX_COUNT * 4,
+    ** or (1 << (SL_INDEX_COUNT_LOG2 + 2)) bytes, as there we will be
+    ** trying to split size ranges into more slots than we have available.
+    ** Instead, we calculate the minimum threshold size, and place all
+    ** blocks below that size into the 0th first-level list.
+    */
+
+#if defined (TLSF_MAX_POOL_SIZE)
+    FL_INDEX_MAX = TLSF_LOG2_CEIL(TLSF_MAX_POOL_SIZE),
+#elif defined (TLSF_64BIT)
+    /*
+    ** TODO: We can increase this to support larger sizes, at the expense
+    ** of more overhead in the TLSF structure.
+    */
+    FL_INDEX_MAX = 32,
+#else
+    FL_INDEX_MAX = 30,
+#endif
+    SL_INDEX_COUNT = (1 << SL_INDEX_COUNT_LOG2),
+    FL_INDEX_SHIFT = (SL_INDEX_COUNT_LOG2 + ALIGN_SIZE_LOG2),
+    FL_INDEX_COUNT = (FL_INDEX_MAX - FL_INDEX_SHIFT + 1),
+
+    SMALL_BLOCK_SIZE = (1 << FL_INDEX_SHIFT),
+};
+
+/*
+** Cast and min/max macros.
+*/
+
+#define tlsf_cast(t, exp)   ((t) (exp))
+#define tlsf_min(a, b)      ((a) < (b) ? (a) : (b))
+#define tlsf_max(a, b)      ((a) > (b) ? (a) : (b))
+
+/*
+** Set assert macro, if it has not been provided by the user.
+*/
+#define tlsf_assert LV_ASSERT
+
+#if !defined (tlsf_assert)
+    #define tlsf_assert assert
+#endif
+
+/*
+** Static assertion mechanism.
+*/
+
+#define _tlsf_glue2(x, y) x ## y
+#define _tlsf_glue(x, y) _tlsf_glue2(x, y)
+#define tlsf_static_assert(exp) \
+    typedef char _tlsf_glue(static_assert, __LINE__) [(exp) ? 1 : -1]
+
+/* This code has been tested on 32- and 64-bit (LP/LLP) architectures. */
+tlsf_static_assert(sizeof(int) * CHAR_BIT == 32);
+tlsf_static_assert(sizeof(size_t) * CHAR_BIT >= 32);
+tlsf_static_assert(sizeof(size_t) * CHAR_BIT <= 64);
+
+/* SL_INDEX_COUNT must be <= number of bits in sl_bitmap's storage type. */
+tlsf_static_assert(sizeof(unsigned int) * CHAR_BIT >= SL_INDEX_COUNT);
+
+/* Ensure we've properly tuned our sizes. */
+tlsf_static_assert(ALIGN_SIZE == SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
+
+/*
+** Data structures and associated constants.
+*/
+
+/*
+** Block header structure.
+**
+** There are several implementation subtleties involved:
+** - The prev_phys_block field is only valid if the previous block is free.
+** - The prev_phys_block field is actually stored at the end of the
+**   previous block. It appears at the beginning of this structure only to
+**   simplify the implementation.
+** - The next_free / prev_free fields are only valid if the block is free.
+*/
+typedef struct block_header_t {
+    /* Points to the previous physical block. */
+    struct block_header_t * prev_phys_block;
+
+    /* The size of this block, excluding the block header. */
+    size_t size;
+
+    /* Next and previous free blocks. */
+    struct block_header_t * next_free;
+    struct block_header_t * prev_free;
+} block_header_t;
+
+/*
+** Since block sizes are always at least a multiple of 4, the two least
+** significant bits of the size field are used to store the block status:
+** - bit 0: whether block is busy or free
+** - bit 1: whether previous block is busy or free
+*/
+static const size_t block_header_free_bit = 1 << 0;
+static const size_t block_header_prev_free_bit = 1 << 1;
+
+/*
+** The size of the block header exposed to used blocks is the size field.
+** The prev_phys_block field is stored *inside* the previous free block.
+*/
+static const size_t block_header_overhead = sizeof(size_t);
+
+/* User data starts directly after the size field in a used block. */
+static const size_t block_start_offset =
+    offsetof(block_header_t, size) + sizeof(size_t);
+
+/*
+** A free block must be large enough to store its header minus the size of
+** the prev_phys_block field, and no larger than the number of addressable
+** bits for FL_INDEX.
+*/
+static const size_t block_size_min =
+    sizeof(block_header_t) - sizeof(block_header_t *);
+static const size_t block_size_max = tlsf_cast(size_t, 1) << FL_INDEX_MAX;
+
+
+/* The TLSF control structure. */
+typedef struct control_t {
+    /* Empty lists point at this block to indicate they are free. */
+    block_header_t block_null;
+
+    /* Bitmaps for free lists. */
+    unsigned int fl_bitmap;
+    unsigned int sl_bitmap[FL_INDEX_COUNT];
+
+    /* Head of free lists. */
+    block_header_t * blocks[FL_INDEX_COUNT][SL_INDEX_COUNT];
+} control_t;
+
+/* A type used for casting when doing pointer arithmetic. */
+typedef ptrdiff_t tlsfptr_t;
+
+/*
+** block_header_t member functions.
+*/
+
+static size_t block_size(const block_header_t * block)
+{
+    return block->size & ~(block_header_free_bit | block_header_prev_free_bit);
+}
+
+static void block_set_size(block_header_t * block, size_t size)
+{
+    const size_t oldsize = block->size;
+    block->size = size | (oldsize & (block_header_free_bit | block_header_prev_free_bit));
+}
+
+static int block_is_last(const block_header_t * block)
+{
+    return block_size(block) == 0;
+}
+
+static int block_is_free(const block_header_t * block)
+{
+    return tlsf_cast(int, block->size & block_header_free_bit);
+}
+
+static void block_set_free(block_header_t * block)
+{
+    block->size |= block_header_free_bit;
+}
+
+static void block_set_used(block_header_t * block)
+{
+    block->size &= ~block_header_free_bit;
+}
+
+static int block_is_prev_free(const block_header_t * block)
+{
+    return tlsf_cast(int, block->size & block_header_prev_free_bit);
+}
+
+static void block_set_prev_free(block_header_t * block)
+{
+    block->size |= block_header_prev_free_bit;
+}
+
+static void block_set_prev_used(block_header_t * block)
+{
+    block->size &= ~block_header_prev_free_bit;
+}
+
+static block_header_t * block_from_ptr(const void * ptr)
+{
+    return tlsf_cast(block_header_t *,
+                     tlsf_cast(unsigned char *, ptr) - block_start_offset);
+}
+
+static void * block_to_ptr(const block_header_t * block)
+{
+    return tlsf_cast(void *,
+                     tlsf_cast(unsigned char *, block) + block_start_offset);
+}
+
+/* Return location of next block after block of given size. */
+static block_header_t * offset_to_block(const void * ptr, size_t size)
+{
+    return tlsf_cast(block_header_t *, tlsf_cast(tlsfptr_t, ptr) + size);
+}
+
+/* Return location of previous block. */
+static block_header_t * block_prev(const block_header_t * block)
+{
+    tlsf_assert(block_is_prev_free(block) && "previous block must be free");
+    return block->prev_phys_block;
+}
+
+/* Return location of next existing block. */
+static block_header_t * block_next(const block_header_t * block)
+{
+    block_header_t * next = offset_to_block(block_to_ptr(block),
+                                            block_size(block) - block_header_overhead);
+    tlsf_assert(!block_is_last(block));
+    return next;
+}
+
+/* Link a new block with its physical neighbor, return the neighbor. */
+static block_header_t * block_link_next(block_header_t * block)
+{
+    block_header_t * next = block_next(block);
+    next->prev_phys_block = block;
+    return next;
+}
+
+static void block_mark_as_free(block_header_t * block)
+{
+    /* Link the block to the next block, first. */
+    block_header_t * next = block_link_next(block);
+    block_set_prev_free(next);
+    block_set_free(block);
+}
+
+static void block_mark_as_used(block_header_t * block)
+{
+    block_header_t * next = block_next(block);
+    block_set_prev_used(next);
+    block_set_used(block);
+}
+
+static size_t align_up(size_t x, size_t align)
+{
+    tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
+    return (x + (align - 1)) & ~(align - 1);
+}
+
+static size_t align_down(size_t x, size_t align)
+{
+    tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
+    return x - (x & (align - 1));
+}
+
+static void * align_ptr(const void * ptr, size_t align)
+{
+    const tlsfptr_t aligned =
+        (tlsf_cast(tlsfptr_t, ptr) + (align - 1)) & ~(align - 1);
+    tlsf_assert(0 == (align & (align - 1)) && "must align to a power of two");
+    return tlsf_cast(void *, aligned);
+}
+
+/*
+** Adjust an allocation size to be aligned to word size, and no smaller
+** than internal minimum.
+*/
+static size_t adjust_request_size(size_t size, size_t align)
+{
+    size_t adjust = 0;
+    if(size) {
+        const size_t aligned = align_up(size, align);
+
+        /* aligned sized must not exceed block_size_max or we'll go out of bounds on sl_bitmap */
+        if(aligned < block_size_max) {
+            adjust = tlsf_max(aligned, block_size_min);
+        }
+    }
+    return adjust;
+}
+
+/*
+** TLSF utility functions. In most cases, these are direct translations of
+** the documentation found in the white paper.
+*/
+
+static void mapping_insert(size_t size, int * fli, int * sli)
+{
+    int fl, sl;
+    if(size < SMALL_BLOCK_SIZE) {
+        /* Store small blocks in first list. */
+        fl = 0;
+        sl = tlsf_cast(int, size) / (SMALL_BLOCK_SIZE / SL_INDEX_COUNT);
+    }
+    else {
+        fl = tlsf_fls_sizet(size);
+        sl = tlsf_cast(int, size >> (fl - SL_INDEX_COUNT_LOG2)) ^ (1 << SL_INDEX_COUNT_LOG2);
+        fl -= (FL_INDEX_SHIFT - 1);
+    }
+    *fli = fl;
+    *sli = sl;
+}
+
+/* This version rounds up to the next block size (for allocations) */
+static void mapping_search(size_t size, int * fli, int * sli)
+{
+    if(size >= SMALL_BLOCK_SIZE) {
+        const size_t round = (1 << (tlsf_fls_sizet(size) - SL_INDEX_COUNT_LOG2)) - 1;
+        size += round;
+    }
+    mapping_insert(size, fli, sli);
+}
+
+static block_header_t * search_suitable_block(control_t * control, int * fli, int * sli)
+{
+    int fl = *fli;
+    int sl = *sli;
+
+    /*
+    ** First, search for a block in the list associated with the given
+    ** fl/sl index.
+    */
+    unsigned int sl_map = control->sl_bitmap[fl] & (~0U << sl);
+    if(!sl_map) {
+        /* No block exists. Search in the next largest first-level list. */
+        const unsigned int fl_map = control->fl_bitmap & (~0U << (fl + 1));
+        if(!fl_map) {
+            /* No free blocks available, memory has been exhausted. */
+            return 0;
+        }
+
+        fl = tlsf_ffs(fl_map);
+        *fli = fl;
+        sl_map = control->sl_bitmap[fl];
+    }
+    tlsf_assert(sl_map && "internal error - second level bitmap is null");
+    sl = tlsf_ffs(sl_map);
+    *sli = sl;
+
+    /* Return the first block in the free list. */
+    return control->blocks[fl][sl];
+}
+
+/* Remove a free block from the free list.*/
+static void remove_free_block(control_t * control, block_header_t * block, int fl, int sl)
+{
+    block_header_t * prev = block->prev_free;
+    block_header_t * next = block->next_free;
+    tlsf_assert(prev && "prev_free field can not be null");
+    tlsf_assert(next && "next_free field can not be null");
+    next->prev_free = prev;
+    prev->next_free = next;
+
+    /* If this block is the head of the free list, set new head. */
+    if(control->blocks[fl][sl] == block) {
+        control->blocks[fl][sl] = next;
+
+        /* If the new head is null, clear the bitmap. */
+        if(next == &control->block_null) {
+            control->sl_bitmap[fl] &= ~(1U << sl);
+
+            /* If the second bitmap is now empty, clear the fl bitmap. */
+            if(!control->sl_bitmap[fl]) {
+                control->fl_bitmap &= ~(1U << fl);
+            }
+        }
+    }
+}
+
+/* Insert a free block into the free block list. */
+static void insert_free_block(control_t * control, block_header_t * block, int fl, int sl)
+{
+    block_header_t * current = control->blocks[fl][sl];
+    tlsf_assert(current && "free list cannot have a null entry");
+    tlsf_assert(block && "cannot insert a null entry into the free list");
+    block->next_free = current;
+    block->prev_free = &control->block_null;
+    current->prev_free = block;
+
+    tlsf_assert(block_to_ptr(block) == align_ptr(block_to_ptr(block), ALIGN_SIZE)
+                && "block not aligned properly");
+    /*
+    ** Insert the new block at the head of the list, and mark the first-
+    ** and second-level bitmaps appropriately.
+    */
+    control->blocks[fl][sl] = block;
+    control->fl_bitmap |= (1U << fl);
+    control->sl_bitmap[fl] |= (1U << sl);
+}
+
+/* Remove a given block from the free list. */
+static void block_remove(control_t * control, block_header_t * block)
+{
+    int fl, sl;
+    mapping_insert(block_size(block), &fl, &sl);
+    remove_free_block(control, block, fl, sl);
+}
+
+/* Insert a given block into the free list. */
+static void block_insert(control_t * control, block_header_t * block)
+{
+    int fl, sl;
+    mapping_insert(block_size(block), &fl, &sl);
+    insert_free_block(control, block, fl, sl);
+}
+
+static int block_can_split(block_header_t * block, size_t size)
+{
+    return block_size(block) >= sizeof(block_header_t) + size;
+}
+
+/* Split a block into two, the second of which is free. */
+static block_header_t * block_split(block_header_t * block, size_t size)
+{
+    /* Calculate the amount of space left in the remaining block. */
+    block_header_t * remaining =
+        offset_to_block(block_to_ptr(block), size - block_header_overhead);
+
+    const size_t remain_size = block_size(block) - (size + block_header_overhead);
+
+    tlsf_assert(block_to_ptr(remaining) == align_ptr(block_to_ptr(remaining), ALIGN_SIZE)
+                && "remaining block not aligned properly");
+
+    tlsf_assert(block_size(block) == remain_size + size + block_header_overhead);
+    block_set_size(remaining, remain_size);
+    tlsf_assert(block_size(remaining) >= block_size_min && "block split with invalid size");
+
+    block_set_size(block, size);
+    block_mark_as_free(remaining);
+
+    return remaining;
+}
+
+/* Absorb a free block's storage into an adjacent previous free block. */
+static block_header_t * block_absorb(block_header_t * prev, block_header_t * block)
+{
+    tlsf_assert(!block_is_last(prev) && "previous block can't be last");
+    /* Note: Leaves flags untouched. */
+    prev->size += block_size(block) + block_header_overhead;
+    block_link_next(prev);
+    return prev;
+}
+
+/* Merge a just-freed block with an adjacent previous free block. */
+static block_header_t * block_merge_prev(control_t * control, block_header_t * block)
+{
+    if(block_is_prev_free(block)) {
+        block_header_t * prev = block_prev(block);
+        tlsf_assert(prev && "prev physical block can't be null");
+        tlsf_assert(block_is_free(prev) && "prev block is not free though marked as such");
+        block_remove(control, prev);
+        block = block_absorb(prev, block);
+    }
+
+    return block;
+}
+
+/* Merge a just-freed block with an adjacent free block. */
+static block_header_t * block_merge_next(control_t * control, block_header_t * block)
+{
+    block_header_t * next = block_next(block);
+    tlsf_assert(next && "next physical block can't be null");
+
+    if(block_is_free(next)) {
+        tlsf_assert(!block_is_last(block) && "previous block can't be last");
+        block_remove(control, next);
+        block = block_absorb(block, next);
+    }
+
+    return block;
+}
+
+/* Trim any trailing block space off the end of a block, return to pool. */
+static void block_trim_free(control_t * control, block_header_t * block, size_t size)
+{
+    tlsf_assert(block_is_free(block) && "block must be free");
+    if(block_can_split(block, size)) {
+        block_header_t * remaining_block = block_split(block, size);
+        block_link_next(block);
+        block_set_prev_free(remaining_block);
+        block_insert(control, remaining_block);
+    }
+}
+
+/* Trim any trailing block space off the end of a used block, return to pool. */
+static void block_trim_used(control_t * control, block_header_t * block, size_t size)
+{
+    tlsf_assert(!block_is_free(block) && "block must be used");
+    if(block_can_split(block, size)) {
+        /* If the next block is free, we must coalesce. */
+        block_header_t * remaining_block = block_split(block, size);
+        block_set_prev_used(remaining_block);
+
+        remaining_block = block_merge_next(control, remaining_block);
+        block_insert(control, remaining_block);
+    }
+}
+
+static block_header_t * block_trim_free_leading(control_t * control, block_header_t * block, size_t size)
+{
+    block_header_t * remaining_block = block;
+    if(block_can_split(block, size)) {
+        /* We want the 2nd block. */
+        remaining_block = block_split(block, size - block_header_overhead);
+        block_set_prev_free(remaining_block);
+
+        block_link_next(block);
+        block_insert(control, block);
+    }
+
+    return remaining_block;
+}
+
+static block_header_t * block_locate_free(control_t * control, size_t size)
+{
+    int fl = 0, sl = 0;
+    block_header_t * block = 0;
+
+    if(size) {
+        mapping_search(size, &fl, &sl);
+
+        /*
+        ** mapping_search can futz with the size, so for excessively large sizes it can sometimes wind up
+        ** with indices that are off the end of the block array.
+        ** So, we protect against that here, since this is the only callsite of mapping_search.
+        ** Note that we don't need to check sl, since it comes from a modulo operation that guarantees it's always in range.
+        */
+        if(fl < FL_INDEX_COUNT) {
+            block = search_suitable_block(control, &fl, &sl);
+        }
+    }
+
+    if(block) {
+        tlsf_assert(block_size(block) >= size);
+        remove_free_block(control, block, fl, sl);
+    }
+
+    return block;
+}
+
+static void * block_prepare_used(control_t * control, block_header_t * block, size_t size)
+{
+    void * p = 0;
+    if(block) {
+        tlsf_assert(size && "size must be non-zero");
+        block_trim_free(control, block, size);
+        block_mark_as_used(block);
+        p = block_to_ptr(block);
+    }
+    return p;
+}
+
+/* Clear structure and point all empty lists at the null block. */
+static void control_constructor(control_t * control)
+{
+    int i, j;
+
+    control->block_null.next_free = &control->block_null;
+    control->block_null.prev_free = &control->block_null;
+
+    control->fl_bitmap = 0;
+    for(i = 0; i < FL_INDEX_COUNT; ++i) {
+        control->sl_bitmap[i] = 0;
+        for(j = 0; j < SL_INDEX_COUNT; ++j) {
+            control->blocks[i][j] = &control->block_null;
+        }
+    }
+}
+
+/*
+** Debugging utilities.
+*/
+
+typedef struct integrity_t {
+    int prev_status;
+    int status;
+} integrity_t;
+
+#define tlsf_insist(x) { tlsf_assert(x); if (!(x)) { status--; } }
+
+static void integrity_walker(void * ptr, size_t size, int used, void * user)
+{
+    block_header_t * block = block_from_ptr(ptr);
+    integrity_t * integ = tlsf_cast(integrity_t *, user);
+    const int this_prev_status = block_is_prev_free(block) ? 1 : 0;
+    const int this_status = block_is_free(block) ? 1 : 0;
+    const size_t this_block_size = block_size(block);
+
+    int status = 0;
+    LV_UNUSED(used);
+    tlsf_insist(integ->prev_status == this_prev_status && "prev status incorrect");
+    tlsf_insist(size == this_block_size && "block size incorrect");
+
+    integ->prev_status = this_status;
+    integ->status += status;
+}
+
+int lv_tlsf_check(lv_tlsf_t tlsf)
+{
+    int i, j;
+
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    int status = 0;
+
+    /* Check that the free lists and bitmaps are accurate. */
+    for(i = 0; i < FL_INDEX_COUNT; ++i) {
+        for(j = 0; j < SL_INDEX_COUNT; ++j) {
+            const int fl_map = control->fl_bitmap & (1U << i);
+            const int sl_list = control->sl_bitmap[i];
+            const int sl_map = sl_list & (1U << j);
+            const block_header_t * block = control->blocks[i][j];
+
+            /* Check that first- and second-level lists agree. */
+            if(!fl_map) {
+                tlsf_insist(!sl_map && "second-level map must be null");
+            }
+
+            if(!sl_map) {
+                tlsf_insist(block == &control->block_null && "block list must be null");
+                continue;
+            }
+
+            /* Check that there is at least one free block. */
+            tlsf_insist(sl_list && "no free blocks in second-level map");
+            tlsf_insist(block != &control->block_null && "block should not be null");
+
+            while(block != &control->block_null) {
+                int fli, sli;
+                tlsf_insist(block_is_free(block) && "block should be free");
+                tlsf_insist(!block_is_prev_free(block) && "blocks should have coalesced");
+                tlsf_insist(!block_is_free(block_next(block)) && "blocks should have coalesced");
+                tlsf_insist(block_is_prev_free(block_next(block)) && "block should be free");
+                tlsf_insist(block_size(block) >= block_size_min && "block not minimum size");
+
+                mapping_insert(block_size(block), &fli, &sli);
+                tlsf_insist(fli == i && sli == j && "block size indexed in wrong list");
+                block = block->next_free;
+            }
+        }
+    }
+
+    return status;
+}
+
+#undef tlsf_insist
+
+static void default_walker(void * ptr, size_t size, int used, void * user)
+{
+    LV_UNUSED(user);
+    printf("\t%p %s size: %x (%p)\n", ptr, used ? "used" : "free", (unsigned int)size, (void *)block_from_ptr(ptr));
+}
+
+void lv_tlsf_walk_pool(lv_pool_t pool, lv_tlsf_walker walker, void * user)
+{
+    lv_tlsf_walker pool_walker = walker ? walker : default_walker;
+    block_header_t * block =
+        offset_to_block(pool, -(int)block_header_overhead);
+
+    while(block && !block_is_last(block)) {
+        pool_walker(
+            block_to_ptr(block),
+            block_size(block),
+            !block_is_free(block),
+            user);
+        block = block_next(block);
+    }
+}
+
+size_t lv_tlsf_block_size(void * ptr)
+{
+    size_t size = 0;
+    if(ptr) {
+        const block_header_t * block = block_from_ptr(ptr);
+        size = block_size(block);
+    }
+    return size;
+}
+
+int lv_tlsf_check_pool(lv_pool_t pool)
+{
+    /* Check that the blocks are physically correct. */
+    integrity_t integ = { 0, 0 };
+    lv_tlsf_walk_pool(pool, integrity_walker, &integ);
+
+    return integ.status;
+}
+
+/*
+** Size of the TLSF structures in a given memory block passed to
+** lv_tlsf_create, equal to the size of a control_t
+*/
+size_t lv_tlsf_size(void)
+{
+    return sizeof(control_t);
+}
+
+size_t lv_tlsf_align_size(void)
+{
+    return ALIGN_SIZE;
+}
+
+size_t lv_tlsf_block_size_min(void)
+{
+    return block_size_min;
+}
+
+size_t lv_tlsf_block_size_max(void)
+{
+    return block_size_max;
+}
+
+/*
+** Overhead of the TLSF structures in a given memory block passed to
+** lv_tlsf_add_pool, equal to the overhead of a free block and the
+** sentinel block.
+*/
+size_t lv_tlsf_pool_overhead(void)
+{
+    return 2 * block_header_overhead;
+}
+
+size_t lv_tlsf_alloc_overhead(void)
+{
+    return block_header_overhead;
+}
+
+lv_pool_t lv_tlsf_add_pool(lv_tlsf_t tlsf, void * mem, size_t bytes)
+{
+    block_header_t * block;
+    block_header_t * next;
+
+    const size_t pool_overhead = lv_tlsf_pool_overhead();
+    const size_t pool_bytes = align_down(bytes - pool_overhead, ALIGN_SIZE);
+
+    if(((ptrdiff_t)mem % ALIGN_SIZE) != 0) {
+        printf("lv_tlsf_add_pool: Memory must be aligned by %u bytes.\n",
+               (unsigned int)ALIGN_SIZE);
+        return 0;
+    }
+
+    if(pool_bytes < block_size_min || pool_bytes > block_size_max) {
+#if defined (TLSF_64BIT)
+        printf("lv_tlsf_add_pool: Memory size must be between 0x%x and 0x%x00 bytes.\n",
+               (unsigned int)(pool_overhead + block_size_min),
+               (unsigned int)((pool_overhead + block_size_max) / 256));
+#else
+        printf("lv_tlsf_add_pool: Memory size must be between %u and %u bytes.\n",
+               (unsigned int)(pool_overhead + block_size_min),
+               (unsigned int)(pool_overhead + block_size_max));
+#endif
+        return 0;
+    }
+
+    /*
+    ** Create the main free block. Offset the start of the block slightly
+    ** so that the prev_phys_block field falls outside of the pool -
+    ** it will never be used.
+    */
+    block = offset_to_block(mem, -(tlsfptr_t)block_header_overhead);
+    block_set_size(block, pool_bytes);
+    block_set_free(block);
+    block_set_prev_used(block);
+    block_insert(tlsf_cast(control_t *, tlsf), block);
+
+    /* Split the block to create a zero-size sentinel block. */
+    next = block_link_next(block);
+    block_set_size(next, 0);
+    block_set_used(next);
+    block_set_prev_free(next);
+
+    return mem;
+}
+
+void lv_tlsf_remove_pool(lv_tlsf_t tlsf, lv_pool_t pool)
+{
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    block_header_t * block = offset_to_block(pool, -(int)block_header_overhead);
+
+    int fl = 0, sl = 0;
+
+    tlsf_assert(block_is_free(block) && "block should be free");
+    tlsf_assert(!block_is_free(block_next(block)) && "next block should not be free");
+    tlsf_assert(block_size(block_next(block)) == 0 && "next block size should be zero");
+
+    mapping_insert(block_size(block), &fl, &sl);
+    remove_free_block(control, block, fl, sl);
+}
+
+/*
+** TLSF main interface.
+*/
+
+#if _DEBUG
+int test_ffs_fls()
+{
+    /* Verify ffs/fls work properly. */
+    int rv = 0;
+    rv += (tlsf_ffs(0) == -1) ? 0 : 0x1;
+    rv += (tlsf_fls(0) == -1) ? 0 : 0x2;
+    rv += (tlsf_ffs(1) == 0) ? 0 : 0x4;
+    rv += (tlsf_fls(1) == 0) ? 0 : 0x8;
+    rv += (tlsf_ffs(0x80000000) == 31) ? 0 : 0x10;
+    rv += (tlsf_ffs(0x80008000) == 15) ? 0 : 0x20;
+    rv += (tlsf_fls(0x80000008) == 31) ? 0 : 0x40;
+    rv += (tlsf_fls(0x7FFFFFFF) == 30) ? 0 : 0x80;
+
+#if defined (TLSF_64BIT)
+    rv += (tlsf_fls_sizet(0x80000000) == 31) ? 0 : 0x100;
+    rv += (tlsf_fls_sizet(0x100000000) == 32) ? 0 : 0x200;
+    rv += (tlsf_fls_sizet(0xffffffffffffffff) == 63) ? 0 : 0x400;
+#endif
+
+    if(rv) {
+        printf("test_ffs_fls: %x ffs/fls tests failed.\n", rv);
+    }
+    return rv;
+}
+#endif
+
+lv_tlsf_t lv_tlsf_create(void * mem)
+{
+#if _DEBUG
+    if(test_ffs_fls()) {
+        return 0;
+    }
+#endif
+
+    if(((tlsfptr_t)mem % ALIGN_SIZE) != 0) {
+        printf("lv_tlsf_create: Memory must be aligned to %u bytes.\n",
+               (unsigned int)ALIGN_SIZE);
+        return 0;
+    }
+
+    control_constructor(tlsf_cast(control_t *, mem));
+
+    return tlsf_cast(lv_tlsf_t, mem);
+}
+
+lv_tlsf_t lv_tlsf_create_with_pool(void * mem, size_t bytes)
+{
+    lv_tlsf_t tlsf = lv_tlsf_create(mem);
+    lv_tlsf_add_pool(tlsf, (char *)mem + lv_tlsf_size(), bytes - lv_tlsf_size());
+    return tlsf;
+}
+
+void lv_tlsf_destroy(lv_tlsf_t tlsf)
+{
+    /* Nothing to do. */
+    LV_UNUSED(tlsf);
+}
+
+lv_pool_t lv_tlsf_get_pool(lv_tlsf_t tlsf)
+{
+    return tlsf_cast(lv_pool_t, (char *)tlsf + lv_tlsf_size());
+}
+
+void * lv_tlsf_malloc(lv_tlsf_t tlsf, size_t size)
+{
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
+    block_header_t * block = block_locate_free(control, adjust);
+    return block_prepare_used(control, block, adjust);
+}
+
+void * lv_tlsf_memalign(lv_tlsf_t tlsf, size_t align, size_t size)
+{
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
+
+    /*
+    ** We must allocate an additional minimum block size bytes so that if
+    ** our free block will leave an alignment gap which is smaller, we can
+    ** trim a leading free block and release it back to the pool. We must
+    ** do this because the previous physical block is in use, therefore
+    ** the prev_phys_block field is not valid, and we can't simply adjust
+    ** the size of that block.
+    */
+    const size_t gap_minimum = sizeof(block_header_t);
+    const size_t size_with_gap = adjust_request_size(adjust + align + gap_minimum, align);
+
+    /*
+    ** If alignment is less than or equals base alignment, we're done.
+    ** If we requested 0 bytes, return null, as lv_tlsf_malloc(0) does.
+    */
+    const size_t aligned_size = (adjust && align > ALIGN_SIZE) ? size_with_gap : adjust;
+
+    block_header_t * block = block_locate_free(control, aligned_size);
+
+    /* This can't be a static assert. */
+    tlsf_assert(sizeof(block_header_t) == block_size_min + block_header_overhead);
+
+    if(block) {
+        void * ptr = block_to_ptr(block);
+        void * aligned = align_ptr(ptr, align);
+        size_t gap = tlsf_cast(size_t,
+                               tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr));
+
+        /* If gap size is too small, offset to next aligned boundary. */
+        if(gap && gap < gap_minimum) {
+            const size_t gap_remain = gap_minimum - gap;
+            const size_t offset = tlsf_max(gap_remain, align);
+            const void * next_aligned = tlsf_cast(void *,
+                                                  tlsf_cast(tlsfptr_t, aligned) + offset);
+
+            aligned = align_ptr(next_aligned, align);
+            gap = tlsf_cast(size_t,
+                            tlsf_cast(tlsfptr_t, aligned) - tlsf_cast(tlsfptr_t, ptr));
+        }
+
+        if(gap) {
+            tlsf_assert(gap >= gap_minimum && "gap size too small");
+            block = block_trim_free_leading(control, block, gap);
+        }
+    }
+
+    return block_prepare_used(control, block, adjust);
+}
+
+void lv_tlsf_free(lv_tlsf_t tlsf, void * ptr)
+{
+    /* Don't attempt to free a NULL pointer. */
+    if(ptr) {
+        control_t * control = tlsf_cast(control_t *, tlsf);
+        block_header_t * block = block_from_ptr(ptr);
+        tlsf_assert(!block_is_free(block) && "block already marked as free");
+        block_mark_as_free(block);
+        block = block_merge_prev(control, block);
+        block = block_merge_next(control, block);
+        block_insert(control, block);
+    }
+}
+
+/*
+** The TLSF block information provides us with enough information to
+** provide a reasonably intelligent implementation of realloc, growing or
+** shrinking the currently allocated block as required.
+**
+** This routine handles the somewhat esoteric edge cases of realloc:
+** - a non-zero size with a null pointer will behave like malloc
+** - a zero size with a non-null pointer will behave like free
+** - a request that cannot be satisfied will leave the original buffer
+**   untouched
+** - an extended buffer size will leave the newly-allocated area with
+**   contents undefined
+*/
+void * lv_tlsf_realloc(lv_tlsf_t tlsf, void * ptr, size_t size)
+{
+    control_t * control = tlsf_cast(control_t *, tlsf);
+    void * p = 0;
+
+    /* Zero-size requests are treated as free. */
+    if(ptr && size == 0) {
+        lv_tlsf_free(tlsf, ptr);
+    }
+    /* Requests with NULL pointers are treated as malloc. */
+    else if(!ptr) {
+        p = lv_tlsf_malloc(tlsf, size);
+    }
+    else {
+        block_header_t * block = block_from_ptr(ptr);
+        block_header_t * next = block_next(block);
+
+        const size_t cursize = block_size(block);
+        const size_t combined = cursize + block_size(next) + block_header_overhead;
+        const size_t adjust = adjust_request_size(size, ALIGN_SIZE);
+
+        tlsf_assert(!block_is_free(block) && "block already marked as free");
+
+        /*
+        ** If the next block is used, or when combined with the current
+        ** block, does not offer enough space, we must reallocate and copy.
+        */
+        if(adjust > cursize && (!block_is_free(next) || adjust > combined)) {
+            p = lv_tlsf_malloc(tlsf, size);
+            if(p) {
+                const size_t minsize = tlsf_min(cursize, size);
+                lv_memcpy(p, ptr, minsize);
+                lv_tlsf_free(tlsf, ptr);
+            }
+        }
+        else {
+            /* Do we need to expand to the next block? */
+            if(adjust > cursize) {
+                block_merge_next(control, block);
+                block_mark_as_used(block);
+            }
+
+            /* Trim the resulting block and return the original pointer. */
+            block_trim_used(control, block, adjust);
+            p = ptr;
+        }
+    }
+
+    return p;
+}
+
+#endif /* LV_MEM_CUSTOM == 0 */
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_tlsf.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_tlsf.h
index 0510dbfa2..77424ab83 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_tlsf.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_tlsf.h
@@ -1,95 +1,95 @@
-#include "../lv_conf_internal.h"
-#if LV_MEM_CUSTOM == 0
-
-#ifndef INCLUDED_tlsf
-#define INCLUDED_tlsf
-
-/*
-** Two Level Segregated Fit memory allocator, version 3.1.
-** Written by Matthew Conte
-**	http://tlsf.baisoku.org
-**
-** Based on the original documentation by Miguel Masmano:
-**	http://www.gii.upv.es/tlsf/main/docs
-**
-** This implementation was written to the specification
-** of the document, therefore no GPL restrictions apply.
-** 
-** Copyright (c) 2006-2016, Matthew Conte
-** All rights reserved.
-** 
-** Redistribution and use in source and binary forms, with or without
-** modification, are permitted provided that the following conditions are met:
-**     * Redistributions of source code must retain the above copyright
-**       notice, this list of conditions and the following disclaimer.
-**     * Redistributions in binary form must reproduce the above copyright
-**       notice, this list of conditions and the following disclaimer in the
-**       documentation and/or other materials provided with the distribution.
-**     * Neither the name of the copyright holder nor the
-**       names of its contributors may be used to endorse or promote products
-**       derived from this software without specific prior written permission.
-** 
-** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-** DISCLAIMED. IN NO EVENT SHALL MATTHEW CONTE BE LIABLE FOR ANY
-** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#include <stddef.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/* lv_tlsf_t: a TLSF structure. Can contain 1 to N pools. */
-/* lv_pool_t: a block of memory that TLSF can manage. */
-typedef void* lv_tlsf_t;
-typedef void* lv_pool_t;
-
-/* Create/destroy a memory pool. */
-lv_tlsf_t lv_tlsf_create(void* mem);
-lv_tlsf_t lv_tlsf_create_with_pool(void* mem, size_t bytes);
-void lv_tlsf_destroy(lv_tlsf_t tlsf);
-lv_pool_t lv_tlsf_get_pool(lv_tlsf_t tlsf);
-
-/* Add/remove memory pools. */
-lv_pool_t lv_tlsf_add_pool(lv_tlsf_t tlsf, void* mem, size_t bytes);
-void lv_tlsf_remove_pool(lv_tlsf_t tlsf, lv_pool_t pool);
-
-/* malloc/memalign/realloc/free replacements. */
-void* lv_tlsf_malloc(lv_tlsf_t tlsf, size_t bytes);
-void* lv_tlsf_memalign(lv_tlsf_t tlsf, size_t align, size_t bytes);
-void* lv_tlsf_realloc(lv_tlsf_t tlsf, void* ptr, size_t size);
-void lv_tlsf_free(lv_tlsf_t tlsf, void* ptr);
-
-/* Returns internal block size, not original request size */
-size_t lv_tlsf_block_size(void* ptr);
-
-/* Overheads/limits of internal structures. */
-size_t lv_tlsf_size(void);
-size_t lv_tlsf_align_size(void);
-size_t lv_tlsf_block_size_min(void);
-size_t lv_tlsf_block_size_max(void);
-size_t lv_tlsf_pool_overhead(void);
-size_t lv_tlsf_alloc_overhead(void);
-
-/* Debugging. */
-typedef void (*lv_tlsf_walker)(void* ptr, size_t size, int used, void* user);
-void lv_tlsf_walk_pool(lv_pool_t pool, lv_tlsf_walker walker, void* user);
-/* Returns nonzero if any internal consistency check fails. */
-int lv_tlsf_check(lv_tlsf_t tlsf);
-int lv_tlsf_check_pool(lv_pool_t pool);
-
-#if defined(__cplusplus)
-};
-#endif
-
-#endif
-
-#endif /* LV_MEM_CUSTOM == 0 */
+#include "../lv_conf_internal.h"
+#if LV_MEM_CUSTOM == 0
+
+#ifndef LV_TLSF_H
+#define LV_TLSF_H
+
+/*
+** Two Level Segregated Fit memory allocator, version 3.1.
+** Written by Matthew Conte
+**  http://tlsf.baisoku.org
+**
+** Based on the original documentation by Miguel Masmano:
+**  http://www.gii.upv.es/tlsf/main/docs
+**
+** This implementation was written to the specification
+** of the document, therefore no GPL restrictions apply.
+**
+** Copyright (c) 2006-2016, Matthew Conte
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are met:
+**     * Redistributions of source code must retain the above copyright
+**       notice, this list of conditions and the following disclaimer.
+**     * Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution.
+**     * Neither the name of the copyright holder nor the
+**       names of its contributors may be used to endorse or promote products
+**       derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+** DISCLAIMED. IN NO EVENT SHALL MATTHEW CONTE BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stddef.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* lv_tlsf_t: a TLSF structure. Can contain 1 to N pools. */
+/* lv_pool_t: a block of memory that TLSF can manage. */
+typedef void * lv_tlsf_t;
+typedef void * lv_pool_t;
+
+/* Create/destroy a memory pool. */
+lv_tlsf_t lv_tlsf_create(void * mem);
+lv_tlsf_t lv_tlsf_create_with_pool(void * mem, size_t bytes);
+void lv_tlsf_destroy(lv_tlsf_t tlsf);
+lv_pool_t lv_tlsf_get_pool(lv_tlsf_t tlsf);
+
+/* Add/remove memory pools. */
+lv_pool_t lv_tlsf_add_pool(lv_tlsf_t tlsf, void * mem, size_t bytes);
+void lv_tlsf_remove_pool(lv_tlsf_t tlsf, lv_pool_t pool);
+
+/* malloc/memalign/realloc/free replacements. */
+void * lv_tlsf_malloc(lv_tlsf_t tlsf, size_t bytes);
+void * lv_tlsf_memalign(lv_tlsf_t tlsf, size_t align, size_t bytes);
+void * lv_tlsf_realloc(lv_tlsf_t tlsf, void * ptr, size_t size);
+void lv_tlsf_free(lv_tlsf_t tlsf, void * ptr);
+
+/* Returns internal block size, not original request size */
+size_t lv_tlsf_block_size(void * ptr);
+
+/* Overheads/limits of internal structures. */
+size_t lv_tlsf_size(void);
+size_t lv_tlsf_align_size(void);
+size_t lv_tlsf_block_size_min(void);
+size_t lv_tlsf_block_size_max(void);
+size_t lv_tlsf_pool_overhead(void);
+size_t lv_tlsf_alloc_overhead(void);
+
+/* Debugging. */
+typedef void (*lv_tlsf_walker)(void * ptr, size_t size, int used, void * user);
+void lv_tlsf_walk_pool(lv_pool_t pool, lv_tlsf_walker walker, void * user);
+/* Returns nonzero if any internal consistency check fails. */
+int lv_tlsf_check(lv_tlsf_t tlsf);
+int lv_tlsf_check_pool(lv_pool_t pool);
+
+#if defined(__cplusplus)
+};
+#endif
+
+#endif /*LV_TLSF_H*/
+
+#endif /* LV_MEM_CUSTOM == 0 */
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_txt.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_txt.c
index 0b524ea23..b8c31e5b7 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_txt.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_txt.c
@@ -78,23 +78,18 @@
  *      MACROS
  **********************/
 
+#define LV_IS_ASCII(value)              ((value & 0x80U) == 0x00U)
+#define LV_IS_2BYTES_UTF8_CODE(value)   ((value & 0xE0U) == 0xC0U)
+#define LV_IS_3BYTES_UTF8_CODE(value)   ((value & 0xF0U) == 0xE0U)
+#define LV_IS_4BYTES_UTF8_CODE(value)   ((value & 0xF8U) == 0xF0U)
+#define LV_IS_INVALID_UTF8_CODE(value)  ((value & 0xC0U) != 0x80U)
+
 /**********************
  *   GLOBAL FUNCTIONS
  **********************/
 
-/**
- * Get size of a text
- * @param size_res pointer to a 'point_t' variable to store the result
- * @param text pointer to a text
- * @param font pointer to font of the text
- * @param letter_space letter space of the text
- * @param txt.line_space line space of the text
- * @param flags settings for the text from ::lv_text_flag_t
- * @param max_width max with of the text (break the lines to fit this size) Set CORD_MAX to avoid
- * line breaks
- */
 void lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t * font, lv_coord_t letter_space,
-                      lv_coord_t line_space, lv_coord_t max_width, lv_text_flag_t flag)
+                     lv_coord_t line_space, lv_coord_t max_width, lv_text_flag_t flag)
 {
     size_res->x = 0;
     size_res->y = 0;
@@ -123,7 +118,7 @@ void lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t *
 
         /*Calculate the longest line*/
         lv_coord_t act_line_length = lv_txt_get_width(&text[line_start], new_line_start - line_start, font, letter_space,
-                                                       flag);
+                                                      flag);
 
         size_res->x = LV_MAX(act_line_length, size_res->x);
         line_start  = new_line_start;
@@ -204,7 +199,7 @@ static uint32_t lv_txt_get_next_word(const char * txt, const lv_font_t * font,
                 i = i_next;
                 i_next = i_next_next;
                 letter = letter_next;
-                continue;   /*Skip the letter is it is part of a command*/
+                continue;   /*Skip the letter if it is part of a command*/
             }
         }
 
@@ -280,22 +275,11 @@ static uint32_t lv_txt_get_next_word(const char * txt, const lv_font_t * font,
 #endif
 }
 
-/**
- * Get the next line of text. Check line length and break chars too.
- *
- * A line of txt includes the \n character.
- *
- * @param txt a '\0' terminated string
- * @param font pointer to a font
- * @param letter_space letter space
- * @param max_width max with of the text (break the lines to fit this size) Set CORD_MAX to avoid line breaks
- * @param flags settings for the text from 'txt_flag_type' enum
- * @return the index of the first char of the new line (in byte index not letter index. With UTF-8 they are different)
- */
 uint32_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font,
                                lv_coord_t letter_space, lv_coord_t max_width, lv_text_flag_t flag)
 {
     if(txt == NULL) return 0;
+    if(txt[0] == '\0') return 0;
     if(font == NULL) return 0;
 
     /*If max_width doesn't mater simply find the new line character
@@ -342,18 +326,8 @@ uint32_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font,
     return i;
 }
 
-/**
- * Give the length of a text with a given font
- * @param txt a '\0' terminate string
- * @param length length of 'txt' in byte count and not characters (Á is 1 character but 2 bytes in
- * UTF-8)
- * @param font pointer to a font
- * @param letter_space letter space
- * @param flags settings for the text from 'txt_flag_t' enum
- * @return length of a char_num long text
- */
 lv_coord_t lv_txt_get_width(const char * txt, uint32_t length, const lv_font_t * font, lv_coord_t letter_space,
-                             lv_text_flag_t flag)
+                            lv_text_flag_t flag)
 {
     if(txt == NULL) return 0;
     if(font == NULL) return 0;
@@ -391,14 +365,6 @@ lv_coord_t lv_txt_get_width(const char * txt, uint32_t length, const lv_font_t *
     return width;
 }
 
-/**
- * Check next character in a string and decide if the character is part of the command or not
- * @param state pointer to a txt_cmd_state_t variable which stores the current state of command
- * processing (Inited to TXT_CMD_STATE_WAIT )
- * @param c the current character
- * @return true: the character is part of a command and should not be written,
- *         false: the character should be written
- */
 bool _lv_txt_is_cmd(lv_text_cmd_state_t * state, uint32_t c)
 {
     bool ret = false;
@@ -430,15 +396,10 @@ bool _lv_txt_is_cmd(lv_text_cmd_state_t * state, uint32_t c)
     return ret;
 }
 
-/**
- * Insert a string into an other
- * @param txt_buf the original text (must be big enough for the result text)
- * @param pos position to insert. Expressed in character index and not byte index (Different in
- * UTF-8) 0: before the original text, 1: after the first char etc.
- * @param ins_txt text to insert
- */
 void _lv_txt_ins(char * txt_buf, uint32_t pos, const char * ins_txt)
 {
+    if(txt_buf == NULL || ins_txt == NULL) return;
+
     size_t old_len = strlen(txt_buf);
     size_t ins_len = strlen(ins_txt);
     if(ins_len == 0) return;
@@ -456,15 +417,9 @@ void _lv_txt_ins(char * txt_buf, uint32_t pos, const char * ins_txt)
     lv_memcpy_small(txt_buf + pos, ins_txt, ins_len);
 }
 
-/**
- * Delete a part of a string
- * @param txt string to modify
- * @param pos position where to start the deleting (0: before the first char, 1: after the first
- * char etc.)
- * @param len number of characters to delete
- */
 void _lv_txt_cut(char * txt, uint32_t pos, uint32_t len)
 {
+    if(txt == NULL) return;
 
     size_t old_len = strlen(txt);
 
@@ -478,12 +433,7 @@ void _lv_txt_cut(char * txt, uint32_t pos, uint32_t len)
     }
 }
 
-/**
- * return a new formatted text. Memory will be allocated to store the text.
- * @param fmt `printf`-like format
- * @return pointer to the allocated text string.
- */
-LV_FORMAT_ATTRIBUTE(1, 0) char * _lv_txt_set_text_vfmt(const char * fmt, va_list ap)
+char * _lv_txt_set_text_vfmt(const char * fmt, va_list ap)
 {
     /*Allocate space for the new text by using trick from C99 standard section 7.19.6.12*/
     va_list ap_copy;
@@ -526,7 +476,7 @@ LV_FORMAT_ATTRIBUTE(1, 0) char * _lv_txt_set_text_vfmt(const char * fmt, va_list
     return text;
 }
 
-void _lv_txt_encoded_letter_next_2(const char * txt, uint32_t * letter, uint32_t * letter_next, uint32_t *ofs)
+void _lv_txt_encoded_letter_next_2(const char * txt, uint32_t * letter, uint32_t * letter_next, uint32_t * ofs)
 {
     *letter = _lv_txt_encoded_next(txt, ofs);
     *letter_next = *letter != '\0' ? _lv_txt_encoded_next(&txt[*ofs], NULL) : 0;
@@ -540,19 +490,19 @@ void _lv_txt_encoded_letter_next_2(const char * txt, uint32_t * letter, uint32_t
 /**
  * Give the size of an UTF-8 coded character
  * @param str pointer to a character in a string
- * @return length of the UTF-8 character (1,2,3 or 4). O on invalid code
+ * @return length of the UTF-8 character (1,2,3 or 4), 0 on invalid code.
  */
 static uint8_t lv_txt_utf8_size(const char * str)
 {
-    if((str[0] & 0x80) == 0)
+    if(LV_IS_ASCII(str[0]))
         return 1;
-    else if((str[0] & 0xE0) == 0xC0)
+    else if(LV_IS_2BYTES_UTF8_CODE(str[0]))
         return 2;
-    else if((str[0] & 0xF0) == 0xE0)
+    else if(LV_IS_3BYTES_UTF8_CODE(str[0]))
         return 3;
-    else if((str[0] & 0xF8) == 0xF0)
+    else if(LV_IS_4BYTES_UTF8_CODE(str[0]))
         return 4;
-    return 0; /*If the char was invalid tell it's 1 byte long*/
+    return 0;
 }
 
 /**
@@ -638,47 +588,47 @@ static uint32_t lv_txt_utf8_next(const char * txt, uint32_t * i)
     if(i == NULL) i = &i_tmp;
 
     /*Normal ASCII*/
-    if((txt[*i] & 0x80) == 0) {
+    if(LV_IS_ASCII(txt[*i])) {
         result = txt[*i];
         (*i)++;
     }
     /*Real UTF-8 decode*/
     else {
         /*2 bytes UTF-8 code*/
-        if((txt[*i] & 0xE0) == 0xC0) {
+        if(LV_IS_2BYTES_UTF8_CODE(txt[*i])) {
             result = (uint32_t)(txt[*i] & 0x1F) << 6;
             (*i)++;
-            if((txt[*i] & 0xC0) != 0x80) return 0; /*Invalid UTF-8 code*/
+            if(LV_IS_INVALID_UTF8_CODE(txt[*i])) return 0;
             result += (txt[*i] & 0x3F);
             (*i)++;
         }
         /*3 bytes UTF-8 code*/
-        else if((txt[*i] & 0xF0) == 0xE0) {
+        else if(LV_IS_3BYTES_UTF8_CODE(txt[*i])) {
             result = (uint32_t)(txt[*i] & 0x0F) << 12;
             (*i)++;
 
-            if((txt[*i] & 0xC0) != 0x80) return 0; /*Invalid UTF-8 code*/
+            if(LV_IS_INVALID_UTF8_CODE(txt[*i])) return 0;
             result += (uint32_t)(txt[*i] & 0x3F) << 6;
             (*i)++;
 
-            if((txt[*i] & 0xC0) != 0x80) return 0; /*Invalid UTF-8 code*/
+            if(LV_IS_INVALID_UTF8_CODE(txt[*i])) return 0;
             result += (txt[*i] & 0x3F);
             (*i)++;
         }
         /*4 bytes UTF-8 code*/
-        else if((txt[*i] & 0xF8) == 0xF0) {
+        else if(LV_IS_4BYTES_UTF8_CODE(txt[*i])) {
             result = (uint32_t)(txt[*i] & 0x07) << 18;
             (*i)++;
 
-            if((txt[*i] & 0xC0) != 0x80) return 0; /*Invalid UTF-8 code*/
+            if(LV_IS_INVALID_UTF8_CODE(txt[*i])) return 0;
             result += (uint32_t)(txt[*i] & 0x3F) << 12;
             (*i)++;
 
-            if((txt[*i] & 0xC0) != 0x80) return 0; /*Invalid UTF-8 code*/
+            if(LV_IS_INVALID_UTF8_CODE(txt[*i])) return 0;
             result += (uint32_t)(txt[*i] & 0x3F) << 6;
             (*i)++;
 
-            if((txt[*i] & 0xC0) != 0x80) return 0; /*Invalid UTF-8 code*/
+            if(LV_IS_INVALID_UTF8_CODE(txt[*i])) return 0;
             result += txt[*i] & 0x3F;
             (*i)++;
         }
@@ -735,7 +685,8 @@ static uint32_t lv_txt_utf8_get_byte_id(const char * txt, uint32_t utf8_id)
     uint32_t byte_cnt = 0;
     for(i = 0; i < utf8_id && txt[byte_cnt] != '\0'; i++) {
         uint8_t c_size = _lv_txt_encoded_size(&txt[byte_cnt]);
-        byte_cnt += c_size > 0 ? c_size : 1;
+        /* If the char was invalid tell it's 1 byte long*/
+        byte_cnt += c_size ? c_size : 1;
     }
 
     return byte_cnt;
@@ -792,7 +743,7 @@ static uint32_t lv_txt_utf8_get_length(const char * txt)
  */
 static uint8_t lv_txt_iso8859_1_size(const char * str)
 {
-    (void)str; /*Unused*/
+    LV_UNUSED(str); /*Unused*/
     return 1;
 }
 
@@ -862,7 +813,7 @@ static uint32_t lv_txt_iso8859_1_prev(const char * txt, uint32_t * i)
  */
 static uint32_t lv_txt_iso8859_1_get_byte_id(const char * txt, uint32_t utf8_id)
 {
-    (void)txt;      /*Unused*/
+    LV_UNUSED(txt); /*Unused*/
     return utf8_id; /*In Non encoded no difference*/
 }
 
@@ -875,7 +826,7 @@ static uint32_t lv_txt_iso8859_1_get_byte_id(const char * txt, uint32_t utf8_id)
  */
 static uint32_t lv_txt_iso8859_1_get_char_id(const char * txt, uint32_t byte_id)
 {
-    (void)txt;      /*Unused*/
+    LV_UNUSED(txt); /*Unused*/
     return byte_id; /*In Non encoded no difference*/
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_txt.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_txt.h
index f44c27d75..4d3b8453a 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_txt.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_txt.h
@@ -81,7 +81,7 @@ typedef uint8_t lv_text_align_t;
  * line breaks
  */
 void lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t * font, lv_coord_t letter_space,
-                      lv_coord_t line_space, lv_coord_t max_width, lv_text_flag_t flag);
+                     lv_coord_t line_space, lv_coord_t max_width, lv_text_flag_t flag);
 
 /**
  * Get the next line of text. Check line length and break chars too.
@@ -108,7 +108,7 @@ uint32_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font, lv_coor
  * @return length of a char_num long text
  */
 lv_coord_t lv_txt_get_width(const char * txt, uint32_t length, const lv_font_t * font, lv_coord_t letter_space,
-                             lv_text_flag_t flag);
+                            lv_text_flag_t flag);
 
 /**
  * Check next character in a string and decide if the character is part of the command or not
@@ -122,15 +122,15 @@ bool _lv_txt_is_cmd(lv_text_cmd_state_t * state, uint32_t c);
 
 /**
  * Insert a string into an other
- * @param txt_buf the original text (must be big enough for the result text)
+ * @param txt_buf the original text (must be big enough for the result text and NULL terminated)
  * @param pos position to insert (0: before the original text, 1: after the first char etc.)
- * @param ins_txt text to insert
+ * @param ins_txt text to insert, must be '\0' terminated
  */
 void _lv_txt_ins(char * txt_buf, uint32_t pos, const char * ins_txt);
 
 /**
  * Delete a part of a string
- * @param txt string to modify
+ * @param txt string to modify, must be '\0' terminated and should point to a heap or stack frame, not read-only memory.
  * @param pos position where to start the deleting (0: before the first char, 1: after the first
  * char etc.)
  * @param len number of characters to delete
@@ -153,7 +153,7 @@ char * _lv_txt_set_text_vfmt(const char * fmt, va_list ap) LV_FORMAT_ATTRIBUTE(1
  *                After the call it will point to the next encoded char in 'txt'.
  *                NULL to use txt[0] as index
  */
-void _lv_txt_encoded_letter_next_2(const char * txt, uint32_t * letter, uint32_t * letter_next, uint32_t *ofs);
+void _lv_txt_encoded_letter_next_2(const char * txt, uint32_t * letter, uint32_t * letter_next, uint32_t * ofs);
 
 /**
  * Test if char is break char or not (a text can broken here or not)
@@ -166,7 +166,7 @@ static inline bool _lv_txt_is_break_char(uint32_t letter)
     bool ret = false;
 
     /* each chinese character can be break */
-    if (letter >= 0x4E00 && letter <= 0x9FA5) {
+    if(letter >= 0x4E00 && letter <= 0x9FA5) {
         return true;
     }
 
@@ -226,7 +226,7 @@ extern uint32_t (*_lv_txt_encoded_next)(const char *, uint32_t *);
 extern uint32_t (*_lv_txt_encoded_prev)(const char *, uint32_t *);
 
 /**
- * Convert a letter index (in an the encoded text) to byte index.
+ * Convert a letter index (in the encoded text) to byte index.
  * E.g. in UTF-8 "AÁRT" index of 'R' is 2 but start at byte 3 because 'Á' is 2 bytes long
  * @param txt a '\0' terminated UTF-8 string
  * @param enc_id letter index
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_txt_ap.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_txt_ap.c
index 2341a34e6..54faf8b4f 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_txt_ap.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_txt_ap.c
@@ -38,6 +38,7 @@ typedef struct {
 #if LV_USE_ARABIC_PERSIAN_CHARS == 1
 static uint32_t lv_ap_get_char_index(uint16_t c);
 static uint32_t lv_txt_lam_alef(uint32_t ch_curr, uint32_t ch_next);
+static bool lv_txt_is_arabic_vowel(uint16_t c);
 
 /**********************
  *  STATIC VARIABLES
@@ -166,6 +167,16 @@ void _lv_txt_ap_proc(const char * txt, char * txt_out)
         index_current = lv_ap_get_char_index(ch_enc[i]);
         idx_next = lv_ap_get_char_index(ch_enc[i + 1]);
 
+        if(lv_txt_is_arabic_vowel(ch_enc[i])) {  // Current character is a vowel
+            ch_fin[j] = ch_enc[i];
+            i++;
+            j++;
+            continue;   // Skip this character
+        }
+        else if(lv_txt_is_arabic_vowel(ch_enc[i + 1])) {    // Next character is a vowel
+            idx_next = lv_ap_get_char_index(ch_enc[i + 2]); // Skip the vowel character to join with the character after it
+        }
+
         if(index_current == LV_UNDEF_ARABIC_PERSIAN_CHARS) {
             ch_fin[j] = ch_enc[i];
             j++;
@@ -282,4 +293,9 @@ static uint32_t lv_txt_lam_alef(uint32_t ch_curr, uint32_t ch_next)
     return 0;
 }
 
+static bool lv_txt_is_arabic_vowel(uint16_t c)
+{
+    return (c >= 0x064B) && (c <= 0x0652);
+}
+
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_types.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_types.h
index 9a32423e6..172f21c43 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_types.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_types.h
@@ -13,15 +13,12 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
+#include <stdint.h>
 
 /*********************
  *      DEFINES
  *********************/
 
-#if defined(__cplusplus) || __STDC_VERSION__ >= 199901L  // If c99 or newer, use stdint.h to determine arch size
-#include <stdint.h>
-#endif
-
 // If __UINTPTR_MAX__ or UINTPTR_MAX are available, use them to determine arch size
 #if defined(__UINTPTR_MAX__) && __UINTPTR_MAX__ > 0xFFFFFFFF
 #define LV_ARCH_64
@@ -44,7 +41,7 @@ extern "C" {
  */
 enum {
     LV_RES_INV = 0, /*Typically indicates that the object is deleted (become invalid) in the action
-                       function or an operation was failed*/
+                      function or an operation was failed*/
     LV_RES_OK,      /*The object is valid (no deleted) after the action*/
 };
 typedef uint8_t lv_res_t;
@@ -72,7 +69,7 @@ typedef uint32_t lv_uintptr_t;
  *      MACROS
  **********************/
 
-#define LV_UNUSED(x) ((void) x)
+#define LV_UNUSED(x) ((void)x)
 
 #define _LV_CONCAT(x, y) x ## y
 #define LV_CONCAT(x, y) _LV_CONCAT(x, y)
@@ -80,14 +77,18 @@ typedef uint32_t lv_uintptr_t;
 #define _LV_CONCAT3(x, y, z) x ## y ## z
 #define LV_CONCAT3(x, y, z) _LV_CONCAT3(x, y, z)
 
-#if (defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)) && !defined(PYCPARSER)
-#define LV_FORMAT_ATTRIBUTE(fmtstr, vararg) __attribute__ ((format(printf, fmtstr, vararg)))
+#if defined(PYCPARSER)
+#define LV_FORMAT_ATTRIBUTE(fmtstr, vararg)
+#elif defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 4) || __GNUC__ > 4)
+#define LV_FORMAT_ATTRIBUTE(fmtstr, vararg) __attribute__((format(gnu_printf, fmtstr, vararg)))
+#elif (defined(__clang__) || defined(__GNUC__) || defined(__GNUG__))
+#define LV_FORMAT_ATTRIBUTE(fmtstr, vararg) __attribute__((format(printf, fmtstr, vararg)))
 #else
 #define LV_FORMAT_ATTRIBUTE(fmtstr, vararg)
 #endif
 
 #ifdef __cplusplus
-} /*extern "C"*/
+} /*extern "C"*/ 
 #endif
 
 #endif /*LV_TYPES_H*/
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_utils.c b/lib/libesp32_lvgl/lvgl/src/misc/lv_utils.c
index 7f73ba18b..f097ad937 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_utils.c
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_utils.c
@@ -6,12 +6,9 @@
 /*********************
  *      INCLUDES
  *********************/
-#include <stdbool.h>
+#include <stddef.h>
 
 #include "lv_utils.h"
-#include "lv_math.h"
-#include "lv_printf.h"
-#include "lv_txt.h"
 
 /*********************
  *      DEFINES
diff --git a/lib/libesp32_lvgl/lvgl/src/misc/lv_utils.h b/lib/libesp32_lvgl/lvgl/src/misc/lv_utils.h
index c798f1b15..5d17d7698 100644
--- a/lib/libesp32_lvgl/lvgl/src/misc/lv_utils.h
+++ b/lib/libesp32_lvgl/lvgl/src/misc/lv_utils.h
@@ -14,7 +14,6 @@ extern "C" {
  *      INCLUDES
  *********************/
 #include <stdint.h>
-#include <stddef.h>
 
 /*********************
  *      DEFINES
@@ -30,8 +29,8 @@ extern "C" {
 
 /** Searches base[0] to base[n - 1] for an item that matches *key.
  *
- * @note The function cmp must return negative if its first
- *  argument (the search key) is less that its second (a table entry),
+ * @note The function cmp must return negative if it's first
+ *  argument (the search key) is less that it's second (a table entry),
  *  zero if equal, and positive if greater.
  *
  *  @note Items in the array must be in ascending order.
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.c
index 2b7bc8a35..08cfe03f5 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.c
@@ -57,14 +57,9 @@ const lv_obj_class_t lv_arc_class  = {
  *   GLOBAL FUNCTIONS
  **********************/
 
-/**
- * Create a arc object
- * @param par pointer to an object, it will be the parent of the new arc
- * @return pointer to the created arc
- */
 lv_obj_t * lv_arc_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -82,11 +77,6 @@ lv_obj_t * lv_arc_create(lv_obj_t * parent)
  * Setter functions
  *====================*/
 
-/**
- * Set the start angle of an arc. 0 deg: right, 90 bottom, etc.
- * @param arc pointer to an arc object
- * @param start the start angle [0..360]
- */
 void lv_arc_set_start_angle(lv_obj_t * obj, uint16_t start)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
@@ -94,87 +84,44 @@ void lv_arc_set_start_angle(lv_obj_t * obj, uint16_t start)
 
     if(start > 360) start -= 360;
 
-    /*Too large move, the whole arc need to be invalidated anyway*/
-    if(LV_ABS(start -arc->indic_angle_start) >= 180) {
-        lv_obj_invalidate(obj);
-    }
-    /*Only a smaller incremental move*/
-    else if(arc->indic_angle_start >arc->indic_angle_end && start >arc->indic_angle_end) {
-        inv_arc_area(obj, LV_MIN(arc->indic_angle_start, start), LV_MAX(arc->indic_angle_start, start),
-                     LV_PART_INDICATOR);
-    }
-    /*Only a smaller incremental move*/
-    else  if(arc->indic_angle_start <arc->indic_angle_end && start <arc->indic_angle_end) {
-        inv_arc_area(obj, LV_MIN(arc->indic_angle_start, start), LV_MAX(arc->indic_angle_start, start),
-                     LV_PART_INDICATOR);
-    }
-    /*Crossing the start angle makes the whole arc change*/
-    else {
-        lv_obj_invalidate(obj);
-    }
+    int16_t old_delta =  arc->indic_angle_end - arc->indic_angle_start;
+    int16_t new_delta =  arc->indic_angle_end - start;
 
-   arc->indic_angle_start = start;
+    if(old_delta < 0) old_delta = 360 + old_delta;
+    if(new_delta < 0) new_delta = 360 + new_delta;
+
+    if(LV_ABS(new_delta - old_delta) > 180)  lv_obj_invalidate(obj);
+    else if(new_delta < old_delta) inv_arc_area(obj, arc->indic_angle_start, start, LV_PART_INDICATOR);
+    else if(old_delta < new_delta) inv_arc_area(obj, start, arc->indic_angle_start, LV_PART_INDICATOR);
+
+    arc->indic_angle_start = start;
 }
 
-/**
- * Set the start angle of an arc. 0 deg: right, 90 bottom, etc.
- * @param arc pointer to an arc object
- * @param start the start angle [0..360]
- */
 void lv_arc_set_end_angle(lv_obj_t * obj, uint16_t end)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_arc_t * arc = (lv_arc_t *)obj;
+    if(end > 360) end -= 360;
 
-    if(end > (arc->indic_angle_start + 360)) end =arc->indic_angle_start + 360;
+    int16_t old_delta =  arc->indic_angle_end - arc->indic_angle_start;
+    int16_t new_delta =  end - arc->indic_angle_start;
 
-    /*Too large move, the whole arc need to be invalidated anyway*/
-    if(LV_ABS(end -arc->indic_angle_end) >= 180) {
-        lv_obj_invalidate(obj);
-    }
-    /*Only a smaller incremental move*/
-    else if(arc->indic_angle_end >arc->indic_angle_start && end >arc->indic_angle_start) {
-        inv_arc_area(obj, LV_MIN(arc->indic_angle_end, end), LV_MAX(arc->indic_angle_end, end), LV_PART_INDICATOR);
-    }
-    /*Only a smaller incremental move*/
-    else  if(arc->indic_angle_end <arc->indic_angle_start && end <arc->indic_angle_start) {
-        inv_arc_area(obj, LV_MIN(arc->indic_angle_end, end), LV_MAX(arc->indic_angle_end, end), LV_PART_INDICATOR);
-    }
-    /*Crossing the end angle makes the whole arc change*/
-    else {
-        lv_obj_invalidate(obj);
-    }
+    if(old_delta < 0) old_delta = 360 + old_delta;
+    if(new_delta < 0) new_delta = 360 + new_delta;
 
-   arc->indic_angle_end = end;
+    if(LV_ABS(new_delta - old_delta) > 180)  lv_obj_invalidate(obj);
+    else if(new_delta < old_delta) inv_arc_area(obj, end, arc->indic_angle_end, LV_PART_INDICATOR);
+    else if(old_delta < new_delta) inv_arc_area(obj, arc->indic_angle_end, end, LV_PART_INDICATOR);
+
+    arc->indic_angle_end = end;
 }
 
-/**
- * Set the start and end angles
- * @param arc pointer to an arc object
- * @param start the start angle
- * @param end the end angle
- */
 void lv_arc_set_angles(lv_obj_t * obj, uint16_t start, uint16_t end)
 {
-    LV_ASSERT_OBJ(obj, MY_CLASS);
-    lv_arc_t * arc = (lv_arc_t *)obj;
-
-    if(start > 360) start -= 360;
-    if(end > (start + 360)) end = start + 360;
-
-    inv_arc_area(obj,arc->indic_angle_start,arc->indic_angle_end, LV_PART_INDICATOR);
-
-    arc->indic_angle_start = start;
-    arc->indic_angle_end = end;
-
-    inv_arc_area(obj,arc->indic_angle_start,arc->indic_angle_end, LV_PART_INDICATOR);
+    lv_arc_set_end_angle(obj, end);
+    lv_arc_set_start_angle(obj, start);
 }
 
-/**
- * Set the start angle of an arc background. 0 deg: right, 90 bottom, etc.
- * @param arc pointer to an arc object
- * @param start the start angle
- */
 void lv_arc_set_bg_start_angle(lv_obj_t * obj, uint16_t start)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
@@ -182,121 +129,71 @@ void lv_arc_set_bg_start_angle(lv_obj_t * obj, uint16_t start)
 
     if(start > 360) start -= 360;
 
-    /*Too large move, the whole arc need to be invalidated anyway*/
-    if(LV_ABS(start -arc->bg_angle_start) >= 180) {
-        lv_obj_invalidate(obj);
-    }
-    /*Only a smaller incremental move*/
-    else if(arc->bg_angle_start >arc->bg_angle_end && start >arc->bg_angle_end) {
-        inv_arc_area(obj, LV_MIN(arc->bg_angle_start, start), LV_MAX(arc->bg_angle_start, start), LV_PART_MAIN);
-    }
-    /*Only a smaller incremental move*/
-    else  if(arc->bg_angle_start <arc->bg_angle_end && start <arc->bg_angle_end) {
-        inv_arc_area(obj, LV_MIN(arc->bg_angle_start, start), LV_MAX(arc->bg_angle_start, start), LV_PART_MAIN);
-    }
-    /*Crossing the start angle makes the whole arc change*/
-    else {
-        lv_obj_invalidate(obj);
-    }
+    int16_t old_delta =  arc->bg_angle_end - arc->bg_angle_start;
+    int16_t new_delta =  arc->bg_angle_end - start;
 
-   arc->bg_angle_start = start;
+    if(old_delta < 0) old_delta = 360 + old_delta;
+    if(new_delta < 0) new_delta = 360 + new_delta;
+
+    if(LV_ABS(new_delta - old_delta) > 180)  lv_obj_invalidate(obj);
+    else if(new_delta < old_delta) inv_arc_area(obj, arc->bg_angle_start, start, LV_PART_MAIN);
+    else if(old_delta < new_delta) inv_arc_area(obj, start, arc->bg_angle_start, LV_PART_MAIN);
+
+    arc->bg_angle_start = start;
 
     value_update(obj);
 }
 
-/**
- * Set the start angle of an arc background. 0 deg: right, 90 bottom etc.
- * @param arc pointer to an arc object
- * @param end the end angle
- */
 void lv_arc_set_bg_end_angle(lv_obj_t * obj, uint16_t end)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
+    if(end > 360) end -= 360;
 
-    if(end > (arc->bg_angle_start + 360)) end =arc->bg_angle_start + 360;
+    int16_t old_delta =  arc->bg_angle_end - arc->bg_angle_start;
+    int16_t new_delta =  end - arc->bg_angle_start;
 
-    /*Too large move, the whole arc need to be invalidated anyway*/
-    if(LV_ABS(end -arc->bg_angle_end) >= 180) {
-        lv_obj_invalidate(obj);
-    }
-    /*Only a smaller incremental move*/
-    else if(arc->bg_angle_end >arc->bg_angle_start && end >arc->bg_angle_start) {
-        inv_arc_area(obj, LV_MIN(arc->bg_angle_end, end), LV_MAX(arc->bg_angle_end, end), LV_PART_MAIN);
-    }
-    /*Only a smaller incremental move*/
-    else  if(arc->bg_angle_end <arc->bg_angle_start && end <arc->bg_angle_start) {
-        inv_arc_area(obj, LV_MIN(arc->bg_angle_end, end), LV_MAX(arc->bg_angle_end, end), LV_PART_MAIN);
-    }
-    /*Crossing the end angle makes the whole arc change*/
-    else {
-        lv_obj_invalidate(obj);
-    }
+    if(old_delta < 0) old_delta = 360 + old_delta;
+    if(new_delta < 0) new_delta = 360 + new_delta;
+
+    if(LV_ABS(new_delta - old_delta) > 180)  lv_obj_invalidate(obj);
+    else if(new_delta < old_delta) inv_arc_area(obj, end, arc->bg_angle_end, LV_PART_MAIN);
+    else if(old_delta < new_delta) inv_arc_area(obj, arc->bg_angle_end, end, LV_PART_MAIN);
+
+    arc->bg_angle_end = end;
 
     value_update(obj);
-
-   arc->bg_angle_end = end;
 }
 
-/**
- * Set the start and end angles of the arc background
- * @param arc pointer to an arc object
- * @param start the start angle
- * @param end the end angle
- */
 void lv_arc_set_bg_angles(lv_obj_t * obj, uint16_t start, uint16_t end)
 {
-
-    LV_ASSERT_OBJ(obj, MY_CLASS);
-    lv_arc_t * arc = (lv_arc_t *)obj;
-
-    if(start > 360) start -= 360;
-    if(end > (start + 360)) end = start + 360;
-
-    inv_arc_area(obj,arc->bg_angle_start,arc->bg_angle_end, LV_PART_MAIN);
-
-   arc->bg_angle_start = start;
-   arc->bg_angle_end = end;
-
-    inv_arc_area(obj,arc->bg_angle_start,arc->bg_angle_end, LV_PART_MAIN);
-
-    value_update(obj);
+    lv_arc_set_bg_end_angle(obj, end);
+    lv_arc_set_bg_start_angle(obj, start);
 }
 
-/**
- * Set the rotation for the whole arc
- * @param arc pointer to an arc object
- * @param rotation rotation angle
- */
 void lv_arc_set_rotation(lv_obj_t * obj, uint16_t rotation)
 {
-
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
-   arc->rotation = rotation;
+    arc->rotation = rotation;
 
     lv_obj_invalidate(obj);
 }
 
-/**
- * Set the type of arc.
- * @param arc pointer to arc object
- * @param type arc type
- */
 void lv_arc_set_mode(lv_obj_t * obj, lv_arc_mode_t type)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
-    int16_t val =arc->value;
+    int16_t val = arc->value;
 
-   arc->type = type;
-   arc->value = -1; /** Force set_value handling*/
+    arc->type = type;
+    arc->value = -1; /** Force set_value handling*/
 
-    int16_t bg_midpoint, bg_end =arc->bg_angle_end;
-    if(arc->bg_angle_end <arc->bg_angle_start) bg_end =arc->bg_angle_end + 360;
+    int16_t bg_midpoint, bg_end = arc->bg_angle_end;
+    if(arc->bg_angle_end < arc->bg_angle_start) bg_end = arc->bg_angle_end + 360;
 
     switch(arc->type) {
         case LV_ARC_MODE_SYMMETRICAL:
@@ -305,20 +202,15 @@ void lv_arc_set_mode(lv_obj_t * obj, lv_arc_mode_t type)
             lv_arc_set_end_angle(obj, bg_midpoint);
             break;
         case LV_ARC_MODE_REVERSE:
-            lv_arc_set_end_angle(obj,arc->bg_angle_end);
+            lv_arc_set_end_angle(obj, arc->bg_angle_end);
             break;
         default: /** LV_ARC_TYPE_NORMAL*/
-            lv_arc_set_start_angle(obj,arc->bg_angle_start);
+            lv_arc_set_start_angle(obj, arc->bg_angle_start);
     }
 
     lv_arc_set_value(obj, val);
 }
 
-/**
- * Set a new value on the arc
- * @param arc pointer to a arc object
- * @param value new value
- */
 void lv_arc_set_value(lv_obj_t * obj, int16_t value)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
@@ -327,156 +219,95 @@ void lv_arc_set_value(lv_obj_t * obj, int16_t value)
     if(arc->value == value) return;
 
     int16_t new_value;
-    new_value = value >arc->max_value ?arc->max_value : value;
-    new_value = new_value <arc->min_value ?arc->min_value : new_value;
+    new_value = value > arc->max_value ? arc->max_value : value;
+    new_value = new_value < arc->min_value ? arc->min_value : new_value;
 
     if(arc->value == new_value) return;
-   arc->value = new_value;
+    arc->value = new_value;
 
     value_update(obj);
 }
 
-/**
- * Set minimum and the maximum values of a arc
- * @param arc pointer to the arc object
- * @param min minimum value
- * @param max maximum value
- */
 void lv_arc_set_range(lv_obj_t * obj, int16_t min, int16_t max)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
-    if(arc->min_value == min &&arc->max_value == max) return;
+    if(arc->min_value == min && arc->max_value == max) return;
 
-   arc->min_value = min;
-   arc->max_value = max;
+    arc->min_value = min;
+    arc->max_value = max;
 
     if(arc->value < min) {
-       arc->value = min;
+        arc->value = min;
     }
     if(arc->value > max) {
-       arc->value = max;
+        arc->value = max;
     }
 
     value_update(obj); /*value has changed relative to the new range*/
 }
 
-/**
- * Set the threshold of arc knob increments
- * position.
- * @param arc pointer to a arc object
- * @param threshold increment threshold
- */
 void lv_arc_set_change_rate(lv_obj_t * obj, uint16_t rate)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
-   arc->chg_rate = rate;
+    arc->chg_rate = rate;
 }
 
 /*=====================
  * Getter functions
  *====================*/
 
-/**
- * Get the start angle of an arc.
- * @param arc pointer to an arc object
- * @return the start angle [0..360]
- */
 uint16_t lv_arc_get_angle_start(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    return ((lv_arc_t*) obj)->indic_angle_start;
+    return ((lv_arc_t *) obj)->indic_angle_start;
 }
 
-/**
- * Get the end angle of an arc.
- * @param arc pointer to an arc object
- * @return the end angle [0..360]
- */
- uint16_t lv_arc_get_angle_end(lv_obj_t * obj)
+uint16_t lv_arc_get_angle_end(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    return ((lv_arc_t*) obj)->indic_angle_end;
+    return ((lv_arc_t *) obj)->indic_angle_end;
 }
 
-/**
- * Get the start angle of an arc background.
- * @param arc pointer to an arc object
- * @return the start angle [0..360]
- */
 uint16_t lv_arc_get_bg_angle_start(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    return ((lv_arc_t*) obj)->bg_angle_start;
+    return ((lv_arc_t *) obj)->bg_angle_start;
 }
 
-/**
- * Get the end angle of an arc background.
- * @param arc pointer to an arc object
- * @return the end angle [0..360]
- */
 uint16_t lv_arc_get_bg_angle_end(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    return ((lv_arc_t*) obj)->bg_angle_end;
+    return ((lv_arc_t *) obj)->bg_angle_end;
 }
 
-
-/**
- * Get the value of a arc
- * @param arc pointer to a arc object
- * @return the value of the arc
- */
 int16_t lv_arc_get_value(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    return ((lv_arc_t*) obj)->value;
+    return ((lv_arc_t *) obj)->value;
 }
 
-/**
- * Get the minimum value of a arc
- * @param arc pointer to a arc object
- * @return the minimum value of the arc
- */
 int16_t lv_arc_get_min_value(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    return ((lv_arc_t*) obj)->min_value;
+    return ((lv_arc_t *) obj)->min_value;
 }
 
-/**
- * Get the maximum value of a arc
- * @param arc pointer to a arc object
- * @return the maximum value of the arc
- */
 int16_t lv_arc_get_max_value(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    return ((lv_arc_t*) obj)->max_value;
+    return ((lv_arc_t *) obj)->max_value;
 }
 
-/**
- * Get whether the arc is type or not.
- * @param arc pointer to a arc object
- * @return arc type
- */
 lv_arc_mode_t lv_arc_get_mode(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
-    return ((lv_arc_t*) obj)->type;
+    return ((lv_arc_t *) obj)->type;
 }
 
-/*=====================
- * Other functions
- *====================*/
-
-/*
- * New object specific "other" functions come here
- */
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -488,25 +319,25 @@ static void lv_arc_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 
     lv_arc_t * arc = (lv_arc_t *)obj;
 
-   /*Initialize the allocated 'ext'*/
-   arc->rotation = 0;
-   arc->bg_angle_start = 135;
-   arc->bg_angle_end   = 45;
-   arc->indic_angle_start = 135;
-   arc->indic_angle_end   = 270;
-   arc->type = LV_ARC_MODE_NORMAL;
-   arc->value = VALUE_UNSET;
-   arc->min_close = 1;
-   arc->min_value = 0;
-   arc->max_value = 100;
-   arc->dragging = false;
-   arc->chg_rate = 720;
-   arc->last_tick = lv_tick_get();
-   arc->last_angle =arc->indic_angle_end;
+    /*Initialize the allocated 'ext'*/
+    arc->rotation = 0;
+    arc->bg_angle_start = 135;
+    arc->bg_angle_end   = 45;
+    arc->indic_angle_start = 135;
+    arc->indic_angle_end   = 270;
+    arc->type = LV_ARC_MODE_NORMAL;
+    arc->value = VALUE_UNSET;
+    arc->min_close = 1;
+    arc->min_value = 0;
+    arc->max_value = 100;
+    arc->dragging = false;
+    arc->chg_rate = 720;
+    arc->last_tick = lv_tick_get();
+    arc->last_angle = arc->indic_angle_end;
 
-   lv_obj_add_flag(obj, LV_OBJ_FLAG_CLICKABLE);
-   lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLL_CHAIN);
-   lv_obj_set_ext_click_area(obj, LV_DPI_DEF / 10);
+    lv_obj_add_flag(obj, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLL_CHAIN);
+    lv_obj_set_ext_click_area(obj, LV_DPI_DEF / 10);
 
 
     LV_TRACE_OBJ_CREATE("finished");
@@ -548,10 +379,19 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
         if(arc->dragging == false) {
             lv_coord_t indic_width = lv_obj_get_style_arc_width(obj, LV_PART_INDICATOR);
             r -=  indic_width;
-            r -= r / 2; /*Add some more sensitive area*/
+            /*Add some more sensitive area if there is no advanced git testing.
+             * (Advanced hit testing is more precise)*/
+            if(lv_obj_has_flag(obj, LV_OBJ_FLAG_ADV_HITTEST)) {
+                r -= indic_width;
+
+            } else {
+                r -= LV_MAX(r / 4, indic_width);
+            }
+            if(r < 1) r = 1;
+
             if(p.x * p.x + p.y * p.y > r * r) {
-               arc->dragging = true;
-               arc->last_tick = lv_tick_get(); /*Capture timestamp at dragging start*/
+                arc->dragging = true;
+                arc->last_tick = lv_tick_get(); /*Capture timestamp at dragging start*/
             }
         }
 
@@ -563,25 +403,25 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
 
         /*Calculate the angle of the pressed point*/
         int16_t angle;
-        int16_t bg_end =arc->bg_angle_end;
-        if(arc->bg_angle_end <arc->bg_angle_start) {
-            bg_end =arc->bg_angle_end + 360;
+        int16_t bg_end = arc->bg_angle_end;
+        if(arc->bg_angle_end < arc->bg_angle_start) {
+            bg_end = arc->bg_angle_end + 360;
         }
 
         angle = lv_atan2(p.y, p.x);
-        angle -=arc->rotation;
-        angle -=arc->bg_angle_start;   /*Make the angle relative to the start angle*/
+        angle -= arc->rotation;
+        angle -= arc->bg_angle_start;  /*Make the angle relative to the start angle*/
 
         if(angle < 0) angle += 360;
 
-        int16_t deg_range = bg_end -arc->bg_angle_start;
+        int16_t deg_range = bg_end - arc->bg_angle_start;
 
-        int16_t last_angle_rel =arc->last_angle -arc->bg_angle_start;
+        int16_t last_angle_rel = arc->last_angle - arc->bg_angle_start;
         int16_t delta_angle = angle - last_angle_rel;
 
         /*Do not allow big jumps.
-         *It's mainly to avoid jumping to the opposite end if the "dead" range between min. an max. is crossed.
-         *Check which was closer on the last valid press (arc->min_close) and prefer that end*/
+         *It's mainly to avoid jumping to the opposite end if the "dead" range between min. and max. is crossed.
+         *Check which end was closer on the last valid press (arc->min_close) and prefer that end*/
         if(LV_ABS(delta_angle) > 280) {
             if(arc->min_close) angle = 0;
             else angle = deg_range;
@@ -606,17 +446,17 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
         angle = last_angle_rel + delta_angle; /*Apply the limited angle change*/
 
         /*Rounding for symmetry*/
-        int32_t round = ((bg_end -arc->bg_angle_start) * 8) / (arc->max_value -arc->min_value);
+        int32_t round = ((bg_end - arc->bg_angle_start) * 8) / (arc->max_value - arc->min_value);
         round = (round + 4) >> 4;
         angle += round;
 
-        angle +=arc->bg_angle_start;   /*Make the angle absolute again*/
+        angle += arc->bg_angle_start;  /*Make the angle absolute again*/
 
         /*Set the new value*/
-        int16_t old_value =arc->value;
-        int16_t new_value = lv_map(angle,arc->bg_angle_start, bg_end,arc->min_value,arc->max_value);
+        int16_t old_value = arc->value;
+        int16_t new_value = lv_map(angle, arc->bg_angle_start, bg_end, arc->min_value, arc->max_value);
         if(new_value != lv_arc_get_value(obj)) {
-           arc->last_tick = lv_tick_get(); /*Cache timestamp for the next iteration*/
+            arc->last_tick = lv_tick_get(); /*Cache timestamp for the next iteration*/
             lv_arc_set_value(obj, new_value); /*set_value caches the last_angle for the next iteration*/
             if(new_value != old_value) {
                 res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, NULL);
@@ -624,13 +464,13 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
             }
         }
 
-        /*Don1't let the elapsed time to big while sitting on an end point*/
-        if(new_value ==arc->min_value || new_value ==arc->max_value) {
-           arc->last_tick = lv_tick_get(); /*Cache timestamp for the next iteration*/
+        /*Don't let the elapsed time become too big while sitting on an end point*/
+        if(new_value == arc->min_value || new_value == arc->max_value) {
+            arc->last_tick = lv_tick_get(); /*Cache timestamp for the next iteration*/
         }
     }
     else if(code == LV_EVENT_RELEASED || code == LV_EVENT_PRESS_LOST) {
-       arc->dragging = false;
+        arc->dragging = false;
 
         /*Leave edit mode if released. (No need to wait for LONG_PRESS)*/
         lv_group_t * g             = lv_obj_get_group(obj);
@@ -644,7 +484,7 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
     else if(code == LV_EVENT_KEY) {
         char c = *((char *)lv_event_get_param(e));
 
-        int16_t old_value =arc->value;
+        int16_t old_value = arc->value;
         if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
             lv_arc_set_value(obj, lv_arc_get_value(obj) + 1);
         }
@@ -652,11 +492,36 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
             lv_arc_set_value(obj, lv_arc_get_value(obj) - 1);
         }
 
-        if(old_value !=arc->value) {
+        if(old_value != arc->value) {
             res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, NULL);
             if(res != LV_RES_OK) return;
         }
     }
+    else if(code == LV_EVENT_HIT_TEST) {
+        lv_hit_test_info_t * info = lv_event_get_param(e);;
+
+        lv_point_t p;
+        lv_coord_t r;
+        get_center(obj, &p, &r);
+
+        lv_coord_t ext_click_area = 0;
+        if(obj->spec_attr) ext_click_area = obj->spec_attr->ext_click_pad;
+
+        lv_coord_t w = lv_obj_get_style_arc_width(obj, LV_PART_MAIN);
+        r -= w + ext_click_area;
+
+        lv_area_t a;
+        /*Invalid if clicked inside*/
+        lv_area_set(&a, p.x - r, p.y - r, p.x + r, p.y + r);
+        if(_lv_area_is_point_on(&a, info->point, LV_RADIUS_CIRCLE)) {
+            info->res = false;
+             return;
+        }
+
+        /*Valid if no clicked outside*/
+        lv_area_increase(&a, w + ext_click_area * 2, w + ext_click_area * 2);
+        info->res = _lv_area_is_point_on(&a, info->point, LV_RADIUS_CIRCLE);
+    }
     else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
         lv_coord_t bg_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN);
         lv_coord_t bg_right = lv_obj_get_style_pad_right(obj, LV_PART_MAIN);
@@ -672,7 +537,8 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
 
         lv_coord_t * s = lv_event_get_param(e);
         *s = LV_MAX(*s, knob_pad - bg_pad);
-    } else if(code == LV_EVENT_DRAW_MAIN) {
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
         lv_arc_draw(e);
     }
 }
@@ -688,8 +554,8 @@ static void lv_arc_draw(lv_event_t * e)
     lv_coord_t arc_r;
     get_center(obj, &center, &arc_r);
 
-    lv_obj_draw_part_dsc_t obj_draw_dsc;
-    lv_obj_draw_dsc_init(&obj_draw_dsc, clip_area);
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
 
     /*Draw the background arc*/
     lv_draw_arc_dsc_t arc_dsc;
@@ -697,17 +563,19 @@ static void lv_arc_draw(lv_event_t * e)
         lv_draw_arc_dsc_init(&arc_dsc);
         lv_obj_init_draw_arc_dsc(obj, LV_PART_MAIN, &arc_dsc);
 
-        obj_draw_dsc.part = LV_PART_MAIN;
-        obj_draw_dsc.p1 = &center;
-        obj_draw_dsc.radius = arc_r;
-        obj_draw_dsc.arc_dsc = &arc_dsc;
-        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &obj_draw_dsc);
+        part_draw_dsc.part = LV_PART_MAIN;
+        part_draw_dsc.class_p = MY_CLASS;
+        part_draw_dsc.type = LV_ARC_DRAW_PART_BACKGROUND;
+        part_draw_dsc.p1 = &center;
+        part_draw_dsc.radius = arc_r;
+        part_draw_dsc.arc_dsc = &arc_dsc;
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
-        lv_draw_arc(center.x, center.y, arc_r, arc->bg_angle_start + arc->rotation,
-                   arc->bg_angle_end + arc->rotation, clip_area,
+        lv_draw_arc(center.x, center.y, part_draw_dsc.radius, arc->bg_angle_start + arc->rotation,
+                    arc->bg_angle_end + arc->rotation, clip_area,
                     &arc_dsc);
 
-        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &obj_draw_dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
     }
 
     /*make the indicator arc smaller or larger according to its greatest padding value*/
@@ -721,17 +589,20 @@ static void lv_arc_draw(lv_event_t * e)
         lv_draw_arc_dsc_init(&arc_dsc);
         lv_obj_init_draw_arc_dsc(obj, LV_PART_INDICATOR, &arc_dsc);
 
-        obj_draw_dsc.part = LV_PART_INDICATOR;
-        obj_draw_dsc.p1 = &center;
-        obj_draw_dsc.radius = indic_r;
-        obj_draw_dsc.arc_dsc = &arc_dsc;
-        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &obj_draw_dsc);
+        part_draw_dsc.part = LV_PART_INDICATOR;
+        part_draw_dsc.class_p = MY_CLASS;
+        part_draw_dsc.type = LV_ARC_DRAW_PART_FOREGROUND;
+        part_draw_dsc.p1 = &center;
+        part_draw_dsc.radius = indic_r;
+        part_draw_dsc.arc_dsc = &arc_dsc;
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
-        lv_draw_arc(center.x, center.y, indic_r, arc->indic_angle_start +arc->rotation,
-                   arc->indic_angle_end + arc->rotation, clip_area,
+        if(arc_dsc.width > part_draw_dsc.radius) arc_dsc.width = part_draw_dsc.radius;
+        lv_draw_arc(center.x, center.y, part_draw_dsc.radius, arc->indic_angle_start + arc->rotation,
+                    arc->indic_angle_end + arc->rotation, clip_area,
                     &arc_dsc);
 
-        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &obj_draw_dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
     }
 
     lv_area_t knob_area;
@@ -741,14 +612,16 @@ static void lv_arc_draw(lv_event_t * e)
     lv_draw_rect_dsc_init(&knob_rect_dsc);
     lv_obj_init_draw_rect_dsc(obj, LV_PART_KNOB, &knob_rect_dsc);
 
-    obj_draw_dsc.part = LV_PART_KNOB;
-    obj_draw_dsc.draw_area = &knob_area;
-    obj_draw_dsc.rect_dsc = &knob_rect_dsc;
-    lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &obj_draw_dsc);
+    part_draw_dsc.part = LV_PART_KNOB;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_ARC_DRAW_PART_KNOB;
+    part_draw_dsc.draw_area = &knob_area;
+    part_draw_dsc.rect_dsc = &knob_rect_dsc;
+    lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
     lv_draw_rect(&knob_area, clip_area, &knob_rect_dsc);
 
-    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &obj_draw_dsc);
+    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
 }
 
 static void inv_arc_area(lv_obj_t * obj, uint16_t start_angle, uint16_t end_angle, lv_part_t part)
@@ -756,18 +629,14 @@ static void inv_arc_area(lv_obj_t * obj, uint16_t start_angle, uint16_t end_angl
     LV_ASSERT_OBJ(obj, MY_CLASS);
     lv_arc_t * arc = (lv_arc_t *)obj;
 
+    if(start_angle == end_angle) return;
+
+    if(start_angle > 360) start_angle -= 360;
+    if(end_angle > 360) end_angle -= 360;
+
     /*Skip this complicated invalidation if the arc is not visible*/
     if(lv_obj_is_visible(obj) == false) return;
 
-    start_angle +=arc->rotation;
-    end_angle +=arc->rotation;
-
-    if(start_angle >= 360) start_angle -= 360;
-    if(end_angle >= 360) end_angle -= 360;
-
-    uint8_t start_quarter = start_angle / 90;
-    uint8_t end_quarter = end_angle / 90;
-
     lv_coord_t left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN);
     lv_coord_t right = lv_obj_get_style_pad_right(obj, LV_PART_MAIN);
     lv_coord_t top = lv_obj_get_style_pad_top(obj, LV_PART_MAIN);
@@ -777,10 +646,6 @@ static void inv_arc_area(lv_obj_t * obj, uint16_t start_angle, uint16_t end_angl
     lv_coord_t y       = obj->coords.y1 + rout + top;
     lv_coord_t w = lv_obj_get_style_arc_width(obj, part);
     lv_coord_t rounded = lv_obj_get_style_arc_rounded(obj, part);
-    lv_coord_t rin       = rout - w;
-    lv_coord_t extra_area = 0;
-
-    extra_area = rounded ? w / 2 + 2 : 0;
 
     if(part == LV_PART_INDICATOR) {
         lv_coord_t knob_extra_size = lv_obj_calculate_ext_draw_size(obj, LV_PART_KNOB);
@@ -792,86 +657,19 @@ static void inv_arc_area(lv_obj_t * obj, uint16_t start_angle, uint16_t end_angl
 
         knob_extra_size += LV_MAX4(knob_left, knob_right, knob_top, knob_bottom);
 
-        extra_area = LV_MAX(extra_area, w / 2 + 2 + knob_extra_size);
+        w += knob_extra_size * 2 + 2;
+        rout += knob_extra_size + 2;
     }
 
+    start_angle += arc->rotation;
+    end_angle += arc->rotation;
+
+    if(start_angle > 360) start_angle -= 360;
+    if(end_angle > 360) end_angle -= 360;
+
     lv_area_t inv_area;
-
-    if(start_quarter == end_quarter && start_angle <= end_angle) {
-        if(start_quarter == 0) {
-            inv_area.y1 = y + ((lv_trigo_sin(start_angle) * rin) >> LV_TRIGO_SHIFT) - extra_area;
-            inv_area.x2 = x + ((lv_trigo_sin(start_angle + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
-
-            inv_area.y2 = y + ((lv_trigo_sin(end_angle) * rout) >> LV_TRIGO_SHIFT) + extra_area;
-            inv_area.x1 = x + ((lv_trigo_sin(end_angle + 90) * rin) >> LV_TRIGO_SHIFT) - extra_area;
-
-            lv_obj_invalidate_area(obj, &inv_area);
-        }
-        else if(start_quarter == 1) {
-            inv_area.y2 = y + ((lv_trigo_sin(start_angle) * rout) >> LV_TRIGO_SHIFT) + extra_area;
-            inv_area.x2 = x + ((lv_trigo_sin(start_angle + 90) * rin) >> LV_TRIGO_SHIFT) + extra_area;
-
-            inv_area.y1 = y + ((lv_trigo_sin(end_angle) * rin) >> LV_TRIGO_SHIFT) - extra_area;
-            inv_area.x1 = x + ((lv_trigo_sin(end_angle + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
-
-            lv_obj_invalidate_area(obj, &inv_area);
-        }
-        else if(start_quarter == 2) {
-            inv_area.x1 = x + ((lv_trigo_sin(start_angle + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
-            inv_area.y2 = y + ((lv_trigo_sin(start_angle) * rin) >> LV_TRIGO_SHIFT) + extra_area;
-
-            inv_area.y1 = y + ((lv_trigo_sin(end_angle) * rout) >> LV_TRIGO_SHIFT) - extra_area;
-            inv_area.x2 = x + ((lv_trigo_sin(end_angle + 90) * rin) >> LV_TRIGO_SHIFT) + extra_area;
-
-            lv_obj_invalidate_area(obj, &inv_area);
-        }
-        else if(start_quarter == 3) {
-            /*Small arc here*/
-            inv_area.x1 = x + ((lv_trigo_sin(start_angle + 90) * rin) >> LV_TRIGO_SHIFT) - extra_area;
-            inv_area.y1 = y + ((lv_trigo_sin(start_angle) * rout) >> LV_TRIGO_SHIFT) - extra_area;
-
-            inv_area.x2 = x + ((lv_trigo_sin(end_angle + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
-            inv_area.y2 = y + ((lv_trigo_sin(end_angle) * rin) >> LV_TRIGO_SHIFT) + extra_area;
-
-            lv_obj_invalidate_area(obj, &inv_area);
-        }
-    }
-    else if(start_quarter == 0 && end_quarter == 1) {
-        inv_area.x1 = x + ((lv_trigo_sin(end_angle + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
-        inv_area.y1 = y + ((LV_MIN(lv_trigo_sin(end_angle),
-                                        lv_trigo_sin(start_angle))  * rin) >> LV_TRIGO_SHIFT) - extra_area;
-        inv_area.x2 = x + ((lv_trigo_sin(start_angle + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
-        inv_area.y2 = y + rout + extra_area;
-        lv_obj_invalidate_area(obj, &inv_area);
-    }
-    else if(start_quarter == 1 && end_quarter == 2) {
-        inv_area.x1 = x - rout - extra_area;
-        inv_area.y1 = y + ((lv_trigo_sin(end_angle) * rout) >> LV_TRIGO_SHIFT) - extra_area;
-        inv_area.x2 = x + ((LV_MAX(lv_trigo_sin(start_angle + 90),
-                                        lv_trigo_sin(end_angle + 90)) * rin) >> LV_TRIGO_SHIFT) + extra_area;
-        inv_area.y2 = y + ((lv_trigo_sin(start_angle) * rout) >> LV_TRIGO_SHIFT) + extra_area;
-        lv_obj_invalidate_area(obj, &inv_area);
-    }
-    else if(start_quarter == 2 && end_quarter == 3) {
-        inv_area.x1 = x + ((lv_trigo_sin(start_angle + 90) * rout) >> LV_TRIGO_SHIFT) - extra_area;
-        inv_area.y1 = y - rout - extra_area;
-        inv_area.x2 = x + ((lv_trigo_sin(end_angle + 90) * rout) >> LV_TRIGO_SHIFT) + extra_area;
-        inv_area.y2 = y + (LV_MAX(lv_trigo_sin(end_angle) * rin,
-                                       lv_trigo_sin(start_angle) * rin) >> LV_TRIGO_SHIFT) + extra_area;
-        lv_obj_invalidate_area(obj, &inv_area);
-    }
-    else if(start_quarter == 3 && end_quarter == 0) {
-        inv_area.x1 = x + ((LV_MIN(lv_trigo_sin(end_angle + 90),
-                                        lv_trigo_sin(start_angle + 90)) * rin) >> LV_TRIGO_SHIFT) - extra_area;
-        inv_area.y1 = y + ((lv_trigo_sin(start_angle) * rout) >> LV_TRIGO_SHIFT) - extra_area;
-        inv_area.x2 = x + rout + extra_area;
-        inv_area.y2 = y + ((lv_trigo_sin(end_angle) * rout) >> LV_TRIGO_SHIFT) + extra_area;
-
-        lv_obj_invalidate_area(obj, &inv_area);
-    }
-    else {
-        lv_obj_invalidate(obj);
-    }
+    lv_draw_arc_get_area(x, y, rout, start_angle, end_angle, w, rounded, &inv_area);
+    lv_obj_invalidate_area(obj, &inv_area);
 }
 
 static void get_center(lv_obj_t * obj, lv_point_t * center, lv_coord_t * arc_r)
@@ -882,7 +680,7 @@ static void get_center(lv_obj_t * obj, lv_point_t * center, lv_coord_t * arc_r)
     lv_coord_t bottom_bg = lv_obj_get_style_pad_bottom(obj, LV_PART_MAIN);
 
     lv_coord_t r = (LV_MIN(lv_obj_get_width(obj) - left_bg - right_bg,
-                                lv_obj_get_height(obj) - top_bg - bottom_bg)) / 2;
+                           lv_obj_get_height(obj) - top_bg - bottom_bg)) / 2;
 
     *arc_r = r;
     center->x = obj->coords.x1 + r + left_bg;
@@ -901,17 +699,17 @@ static void get_knob_area(lv_obj_t * obj, const lv_point_t * center, lv_coord_t
     lv_coord_t indic_width_half = indic_width / 2;
     r -= indic_width_half;
 
-    uint16_t angle =arc->rotation;
+    uint16_t angle = arc->rotation;
     if(arc->type == LV_ARC_MODE_NORMAL) {
-        angle +=arc->indic_angle_end;
+        angle += arc->indic_angle_end;
     }
     else if(arc->type == LV_ARC_MODE_REVERSE) {
-        angle +=arc->indic_angle_start;
+        angle += arc->indic_angle_start;
     }
     else if(arc->type == LV_ARC_MODE_SYMMETRICAL) {
-        int32_t range_midpoint = (int32_t)(arc->min_value +arc->max_value) / 2;
-        if(arc->value < range_midpoint) angle +=arc->indic_angle_start;
-        else angle +=arc->indic_angle_end;
+        int32_t range_midpoint = (int32_t)(arc->min_value + arc->max_value) / 2;
+        if(arc->value < range_midpoint) angle += arc->indic_angle_start;
+        else angle += arc->indic_angle_end;
     }
     lv_coord_t knob_x = (r * lv_trigo_sin(angle + 90)) >> LV_TRIGO_SHIFT;
     lv_coord_t knob_y = (r * lv_trigo_sin(angle)) >> LV_TRIGO_SHIFT;
@@ -929,7 +727,7 @@ static void get_knob_area(lv_obj_t * obj, const lv_point_t * center, lv_coord_t
 
 /**
  * Used internally to update arc angles after a value change
- * @param arc pointer to a arc object
+ * @param arc pointer to an arc object
  */
 static void value_update(lv_obj_t * obj)
 {
@@ -939,36 +737,39 @@ static void value_update(lv_obj_t * obj)
     /*If the value is still not set to any value do not update*/
     if(arc->value == VALUE_UNSET) return;
 
-    int16_t bg_midpoint, range_midpoint, bg_end =arc->bg_angle_end;
-    if(arc->bg_angle_end <arc->bg_angle_start) bg_end =arc->bg_angle_end + 360;
+    int16_t bg_midpoint, range_midpoint, bg_end = arc->bg_angle_end;
+    if(arc->bg_angle_end < arc->bg_angle_start) bg_end = arc->bg_angle_end + 360;
 
     int16_t angle;
     switch(arc->type) {
         case LV_ARC_MODE_SYMMETRICAL:
             bg_midpoint = (arc->bg_angle_start + bg_end) / 2;
-            range_midpoint = (int32_t)(arc->min_value +arc->max_value) / 2;
+            range_midpoint = (int32_t)(arc->min_value + arc->max_value) / 2;
 
             if(arc->value < range_midpoint) {
-                angle = lv_map(arc->value,arc->min_value, range_midpoint,arc->bg_angle_start, bg_midpoint);
+                angle = lv_map(arc->value, arc->min_value, range_midpoint, arc->bg_angle_start, bg_midpoint);
                 lv_arc_set_start_angle(obj, angle);
                 lv_arc_set_end_angle(obj, bg_midpoint);
             }
             else {
-                angle = lv_map(arc->value, range_midpoint,arc->max_value, bg_midpoint, bg_end);
+                angle = lv_map(arc->value, range_midpoint, arc->max_value, bg_midpoint, bg_end);
                 lv_arc_set_start_angle(obj, bg_midpoint);
                 lv_arc_set_end_angle(obj, angle);
             }
             break;
         case LV_ARC_MODE_REVERSE:
-            angle = lv_map(arc->value,arc->min_value,arc->max_value,arc->bg_angle_start, bg_end);
-            lv_arc_set_start_angle(obj, angle);
+            angle = lv_map(arc->value, arc->min_value, arc->max_value, arc->bg_angle_start, bg_end);
+            lv_arc_set_angles(obj, angle, arc->bg_angle_end);
             break;
-        default: /** LV_ARC_TYPE_NORMAL*/
-            angle = lv_map(arc->value,arc->min_value,arc->max_value,arc->bg_angle_start, bg_end);
-            lv_arc_set_end_angle(obj, angle);
-            lv_arc_set_start_angle(obj,arc->bg_angle_start);
+        case LV_ARC_MODE_NORMAL:
+            angle = lv_map(arc->value, arc->min_value, arc->max_value, arc->bg_angle_start, bg_end);
+            lv_arc_set_angles(obj, arc->bg_angle_start, angle);
+            break;
+        default:
+            LV_LOG_WARN("Invalid mode: %d", arc->type);
+            return;
     }
-   arc->last_angle = angle; /*Cache angle for slew rate limiting*/
+    arc->last_angle = angle; /*Cache angle for slew rate limiting*/
 }
 
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.h
index 6fbc9b761..db9b786a1 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.h
@@ -41,25 +41,35 @@ typedef struct {
     uint16_t indic_angle_end;
     uint16_t bg_angle_start;
     uint16_t bg_angle_end;
-    int16_t value;			 	/*Current value of the arc*/
-    int16_t min_value; 			/*Minimum value of the arc*/
-    int16_t max_value; 			/*Maximum value of the arc*/
+    int16_t value;              /*Current value of the arc*/
+    int16_t min_value;          /*Minimum value of the arc*/
+    int16_t max_value;          /*Maximum value of the arc*/
     uint16_t dragging    : 1;
     uint16_t type        : 2;
-    uint16_t min_close   : 1;  	/*1: the last pressed angle was closer to minimum end*/
-    uint16_t chg_rate; 			/*Drag angle rate of change of the arc (degrees/sec)*/
-    uint32_t last_tick; 		/*Last dragging event timestamp of the arc*/
-    int16_t last_angle; 		/*Last dragging angle of the arc*/
-}lv_arc_t;
+    uint16_t min_close   : 1;   /*1: the last pressed angle was closer to minimum end*/
+    uint16_t chg_rate;          /*Drag angle rate of change of the arc (degrees/sec)*/
+    uint32_t last_tick;         /*Last dragging event timestamp of the arc*/
+    int16_t last_angle;         /*Last dragging angle of the arc*/
+} lv_arc_t;
 
 extern const lv_obj_class_t lv_arc_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_arc_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_ARC_DRAW_PART_BACKGROUND,    /**< The background arc*/
+    LV_ARC_DRAW_PART_FOREGROUND,    /**< The foreground arc*/
+    LV_ARC_DRAW_PART_KNOB,          /**< The knob*/
+} lv_arc_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
 /**
- * Create a arc objects
+ * Create an arc object
  * @param par pointer to an object, it will be the parent of the new arc
  * @return pointer to the created arc
  */
@@ -75,81 +85,81 @@ lv_obj_t * lv_arc_create(lv_obj_t * parent);
 
 /**
  * Set the start angle of an arc. 0 deg: right, 90 bottom, etc.
- * @param arc 	pointer to an arc object
+ * @param arc   pointer to an arc object
  * @param start the start angle
  */
 void lv_arc_set_start_angle(lv_obj_t * arc, uint16_t start);
 
 /**
  * Set the end angle of an arc. 0 deg: right, 90 bottom, etc.
- * @param arc 	pointer to an arc object
- * @param end 	the end angle
+ * @param arc   pointer to an arc object
+ * @param end   the end angle
  */
 void lv_arc_set_end_angle(lv_obj_t * arc, uint16_t end);
 
 /**
  * Set the start and end angles
- * @param arc 	pointer to an arc object
+ * @param arc   pointer to an arc object
  * @param start the start angle
- * @param end 	the end angle
+ * @param end   the end angle
  */
 void lv_arc_set_angles(lv_obj_t * arc, uint16_t start, uint16_t end);
 
 /**
  * Set the start angle of an arc background. 0 deg: right, 90 bottom, etc.
- * @param arc 	pointer to an arc object
+ * @param arc   pointer to an arc object
  * @param start the start angle
  */
 void lv_arc_set_bg_start_angle(lv_obj_t * arc, uint16_t start);
 
 /**
  * Set the start angle of an arc background. 0 deg: right, 90 bottom etc.
- * @param arc 	pointer to an arc object
- * @param end 	the end angle
+ * @param arc   pointer to an arc object
+ * @param end   the end angle
  */
 void lv_arc_set_bg_end_angle(lv_obj_t * arc, uint16_t end);
 
 /**
  * Set the start and end angles of the arc background
- * @param arc 	pointer to an arc object
+ * @param arc   pointer to an arc object
  * @param start the start angle
- * @param end 	the end angle
+ * @param end   the end angle
  */
 void lv_arc_set_bg_angles(lv_obj_t * arc, uint16_t start, uint16_t end);
 
 /**
  * Set the rotation for the whole arc
- * @param arc 		pointer to an arc object
- * @param rotation 	rotation angle
+ * @param arc       pointer to an arc object
+ * @param rotation  rotation angle
  */
 void lv_arc_set_rotation(lv_obj_t * arc, uint16_t rotation);
 
 /**
  * Set the type of arc.
- * @param arc 	pointer to arc object
- * @param mode 	arc's mode
+ * @param arc   pointer to arc object
+ * @param mode  arc's mode
  */
 void lv_arc_set_mode(lv_obj_t * arc, lv_arc_mode_t type);
 
 /**
  * Set a new value on the arc
- * @param arc 	pointer to a arc object
+ * @param arc   pointer to an arc object
  * @param value new value
  */
 void lv_arc_set_value(lv_obj_t * arc, int16_t value);
 
 /**
- * Set minimum and the maximum values of a arc
- * @param arc 	pointer to the arc object
- * @param min 	minimum value
- * @param max 	maximum value
+ * Set minimum and the maximum values of an arc
+ * @param arc   pointer to the arc object
+ * @param min   minimum value
+ * @param max   maximum value
  */
 void lv_arc_set_range(lv_obj_t * arc, int16_t min, int16_t max);
 
 /**
- * Set a change rate to limit the speed how fast the arc should reache the pressed point.
- * @param arc 		pointer to a arc object
- * @param rate 		the change rate
+ * Set a change rate to limit the speed how fast the arc should reach the pressed point.
+ * @param arc       pointer to an arc object
+ * @param rate      the change rate
  */
 void lv_arc_set_change_rate(lv_obj_t * arc, uint16_t rate);
 
@@ -159,57 +169,57 @@ void lv_arc_set_change_rate(lv_obj_t * arc, uint16_t rate);
 
 /**
  * Get the start angle of an arc.
- * @param arc 	pointer to an arc object
- * @return 		the start angle [0..360]
+ * @param arc   pointer to an arc object
+ * @return      the start angle [0..360]
  */
 uint16_t lv_arc_get_angle_start(lv_obj_t * obj);
 
 /**
  * Get the end angle of an arc.
- * @param arc 	pointer to an arc object
- * @return 		the end angle [0..360]
+ * @param arc   pointer to an arc object
+ * @return      the end angle [0..360]
  */
 uint16_t lv_arc_get_angle_end(lv_obj_t * obj);
 
 /**
  * Get the start angle of an arc background.
- * @param arc 	pointer to an arc object
- * @return the 	start angle [0..360]
+ * @param arc   pointer to an arc object
+ * @return the  start angle [0..360]
  */
 uint16_t lv_arc_get_bg_angle_start(lv_obj_t * obj);
 
 /**
  * Get the end angle of an arc background.
- * @param arc 	pointer to an arc object
- * @return 		the end angle [0..360]
+ * @param arc   pointer to an arc object
+ * @return      the end angle [0..360]
  */
 uint16_t lv_arc_get_bg_angle_end(lv_obj_t * obj);
 
 /**
- * Get the value of a arc
- * @param arc 		pointer to a arc object
- * @return the 		value of the arc
+ * Get the value of an arc
+ * @param arc       pointer to an arc object
+ * @return the      value of the arc
  */
 int16_t lv_arc_get_value(const lv_obj_t * obj);
 
 /**
- * Get the minimum value of a arc
- * @param arc 	pointer to a arc object
- * @return 		the minimum value of the arc
+ * Get the minimum value of an arc
+ * @param arc   pointer to an arc object
+ * @return      the minimum value of the arc
  */
 int16_t lv_arc_get_min_value(const lv_obj_t * obj);
 
 /**
- * Get the maximum value of a arc
- * @param arc 	pointer to a arc object
- * @return 		the maximum value of the arc
+ * Get the maximum value of an arc
+ * @param arc   pointer to an arc object
+ * @return      the maximum value of the arc
  */
 int16_t lv_arc_get_max_value(const lv_obj_t * obj);
 
 /**
  * Get whether the arc is type or not.
- * @param arc 		pointer to a arc object
- * @return 			arc's mode
+ * @param arc       pointer to an arc object
+ * @return          arc's mode
  */
 lv_arc_mode_t lv_arc_get_mode(const lv_obj_t * obj);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_bar.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_bar.c
index 793be15ce..5037f4288 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_bar.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_bar.c
@@ -19,7 +19,7 @@
  *********************/
 #define MY_CLASS &lv_bar_class
 
-/** hor. pad and ver. pad cannot make the indicator smaller then this [px]*/
+/** hor. pad and ver. pad cannot make the indicator smaller than this [px]*/
 #define LV_BAR_SIZE_MIN  4
 
 #define LV_BAR_IS_ANIMATING(anim_struct) (((anim_struct).anim_state) != LV_BAR_ANIM_STATE_INV)
@@ -77,7 +77,7 @@ const lv_obj_class_t lv_bar_class = {
 
 lv_obj_t * lv_bar_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -95,7 +95,7 @@ void lv_bar_set_value(lv_obj_t * obj, int32_t value, lv_anim_enable_t anim)
     if(bar->cur_value == value) return;
 
     value = LV_CLAMP(bar->min_value, value, bar->max_value);
-    value = value < bar->start_value ? bar->start_value : value; /*Can't be smaller then the left value*/
+    value = value < bar->start_value ? bar->start_value : value; /*Can't be smaller than the left value*/
 
     if(bar->cur_value == value) return;
     lv_bar_set_value_with_anim(obj, value, &bar->cur_value, &bar->cur_value_anim, anim);
@@ -108,7 +108,7 @@ void lv_bar_set_start_value(lv_obj_t * obj, int32_t value, lv_anim_enable_t anim
     lv_bar_t * bar = (lv_bar_t *)obj;
 
     value = LV_CLAMP(bar->min_value, value, bar->max_value);
-    value = value > bar->cur_value ? bar->cur_value : value; /*Can't be greater then the right value*/
+    value = value > bar->cur_value ? bar->cur_value : value; /*Can't be greater than the right value*/
 
     if(bar->start_value == value) return;
     lv_bar_set_value_with_anim(obj, value, &bar->start_value, &bar->start_value_anim, anim);
@@ -310,8 +310,7 @@ static void draw_indic(lv_event_t * e)
 
         anim_start_value_x += anim_start_value_start_x;
     }
-    else
-    {
+    else {
         anim_start_value_x = (int32_t)((int32_t)anim_length * (bar->start_value - bar->min_value)) / range;
     }
 
@@ -325,8 +324,7 @@ static void draw_indic(lv_event_t * e)
                                                       bar->cur_value_anim.anim_state) /
                                                      LV_BAR_ANIM_STATE_END);
     }
-    else
-    {
+    else {
         anim_cur_value_x = (int32_t)((int32_t)anim_length * (bar->cur_value - bar->min_value)) / range;
     }
 
@@ -382,13 +380,15 @@ static void draw_indic(lv_event_t * e)
     /*Do not draw a zero length indicator but at least call the draw part events*/
     if(!sym && indic_length_calc(&bar->indic_area) <= 1) {
 
-        lv_obj_draw_part_dsc_t obj_draw_dsc;
-        lv_obj_draw_dsc_init(&obj_draw_dsc, clip_area);
-        obj_draw_dsc.part = LV_PART_INDICATOR;
-        obj_draw_dsc.draw_area = &bar->indic_area;
+        lv_obj_draw_part_dsc_t part_draw_dsc;
+        lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+        part_draw_dsc.part = LV_PART_INDICATOR;
+        part_draw_dsc.class_p = MY_CLASS;
+        part_draw_dsc.type = LV_BAR_DRAW_PART_INDICATOR;
+        part_draw_dsc.draw_area = &bar->indic_area;
 
-        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &obj_draw_dsc);
-        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &obj_draw_dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
         return;
     }
 
@@ -403,13 +403,15 @@ static void draw_indic(lv_event_t * e)
     lv_draw_rect_dsc_init(&draw_rect_dsc);
     lv_obj_init_draw_rect_dsc(obj, LV_PART_INDICATOR, &draw_rect_dsc);
 
-    lv_obj_draw_part_dsc_t obj_draw_dsc;
-    lv_obj_draw_dsc_init(&obj_draw_dsc, clip_area);
-    obj_draw_dsc.part = LV_PART_INDICATOR;
-    obj_draw_dsc.rect_dsc = &draw_rect_dsc;
-	obj_draw_dsc.draw_area = &bar->indic_area;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.part = LV_PART_INDICATOR;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_BAR_DRAW_PART_INDICATOR;
+    part_draw_dsc.rect_dsc = &draw_rect_dsc;
+    part_draw_dsc.draw_area = &bar->indic_area;
 
-	lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &obj_draw_dsc);
+    lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
     /*Draw only the shadow if the indicator is long enough.
      *The radius of the bg and the indicator can make a strange shape where
@@ -482,11 +484,13 @@ static void draw_indic(lv_event_t * e)
     lv_draw_rect(&bar->indic_area, clip_area, &draw_rect_dsc);
 
 #if LV_DRAW_COMPLEX
+    lv_draw_mask_free_param(&mask_indic_param);
+    lv_draw_mask_free_param(&mask_bg_param);
     lv_draw_mask_remove_id(mask_indic_id);
     lv_draw_mask_remove_id(mask_bg_id);
 #endif
 
-    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &obj_draw_dsc);
+    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
 }
 
 static void lv_bar_event(const lv_obj_class_t * class_p, lv_event_t * e)
@@ -520,10 +524,12 @@ static void lv_bar_event(const lv_obj_class_t * class_p, lv_event_t * e)
         if(pad < 0) {
             *s = LV_MAX(*s, -pad);
         }
-    } else if(code == LV_EVENT_PRESSED || code == LV_EVENT_RELEASED) {
+    }
+    else if(code == LV_EVENT_PRESSED || code == LV_EVENT_RELEASED) {
         lv_bar_t * bar = (lv_bar_t *)obj;
         lv_obj_invalidate_area(obj, &bar->indic_area);
-    } else if(code == LV_EVENT_DRAW_MAIN) {
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
         draw_indic(e);
     }
 }
@@ -554,7 +560,7 @@ static void lv_bar_set_value_with_anim(lv_obj_t * obj, int32_t new_value, int32_
 {
     if(en == LV_ANIM_OFF) {
         *value_ptr = new_value;
-        lv_obj_invalidate((lv_obj_t*)obj);
+        lv_obj_invalidate((lv_obj_t *)obj);
     }
     else {
         /*No animation in progress -> simply set the values*/
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_bar.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_bar.h
index cb3f99d20..b839b1453 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_bar.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_bar.h
@@ -54,10 +54,18 @@ typedef struct {
     _lv_bar_anim_t cur_value_anim;
     _lv_bar_anim_t start_value_anim;
     lv_bar_mode_t mode : 2;     /**< Type of bar*/
-}lv_bar_t;
+} lv_bar_t;
 
 extern const lv_obj_class_t lv_bar_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_bar_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_BAR_DRAW_PART_INDICATOR,    /**< The indicator*/
+} lv_bar_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_btn.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_btn.c
index 3605ccc7d..5676dc7a4 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_btn.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_btn.c
@@ -48,7 +48,7 @@ const lv_obj_class_t lv_btn_class  = {
 
 lv_obj_t * lv_btn_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_btn.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_btn.h
index 8a5af5102..1d471f975 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_btn.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_btn.h
@@ -28,7 +28,7 @@ extern "C" {
 
 typedef struct {
     lv_obj_t obj;
-}lv_btn_t;
+} lv_btn_t;
 
 extern const lv_obj_class_t lv_btn_class;
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.c
index dd33ade13..0108a8ec5 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.c
@@ -43,14 +43,15 @@ static bool button_is_checked(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_repeat_disabled(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_inactive(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_click_trig(lv_btnmatrix_ctrl_t ctrl_bits);
+static bool button_is_popover(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_checkable(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_is_recolor(lv_btnmatrix_ctrl_t ctrl_bits);
 static bool button_get_checked(lv_btnmatrix_ctrl_t ctrl_bits);
-static bool button_is_recolor(lv_btnmatrix_ctrl_t ctrl_bits);
 static uint16_t get_button_from_point(lv_obj_t * obj, lv_point_t * p);
 static void allocate_btn_areas_and_controls(const lv_obj_t * obj, const char ** map);
 static void invalidate_button_area(const lv_obj_t * obj, uint16_t btn_idx);
 static void make_one_button_checked(lv_obj_t * obj, uint16_t btn_idx);
+static bool has_popovers_in_top_row(lv_obj_t * obj);
 
 /**********************
  *  STATIC VARIABLES
@@ -58,16 +59,16 @@ static void make_one_button_checked(lv_obj_t * obj, uint16_t btn_idx);
 static const char * lv_btnmatrix_def_map[] = {"Btn1", "Btn2", "Btn3", "\n", "Btn4", "Btn5", ""};
 
 const lv_obj_class_t lv_btnmatrix_class = {
-        .constructor_cb = lv_btnmatrix_constructor,
-        .destructor_cb = lv_btnmatrix_destructor,
-        .event_cb = lv_btnmatrix_event,
-        .width_def = LV_DPI_DEF * 2,
-        .height_def = LV_DPI_DEF,
-        .instance_size = sizeof(lv_btnmatrix_t),
-        .editable = LV_OBJ_CLASS_EDITABLE_TRUE,
-        .group_def = LV_OBJ_CLASS_GROUP_DEF_TRUE,
-        .base_class = &lv_obj_class
-    };
+    .constructor_cb = lv_btnmatrix_constructor,
+    .destructor_cb = lv_btnmatrix_destructor,
+    .event_cb = lv_btnmatrix_event,
+    .width_def = LV_DPI_DEF * 2,
+    .height_def = LV_DPI_DEF,
+    .instance_size = sizeof(lv_btnmatrix_t),
+    .editable = LV_OBJ_CLASS_EDITABLE_TRUE,
+    .group_def = LV_OBJ_CLASS_GROUP_DEF_TRUE,
+    .base_class = &lv_obj_class
+};
 
 /**********************
  *      MACROS
@@ -79,7 +80,7 @@ const lv_obj_class_t lv_btnmatrix_class = {
 
 lv_obj_t * lv_btnmatrix_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -94,7 +95,7 @@ void lv_btnmatrix_set_map(lv_obj_t * obj, const char * map[])
     LV_ASSERT_OBJ(obj, MY_CLASS);
     if(map == NULL) return;
 
-    lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;;
+    lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;
 
     /*Analyze the map and create the required number of buttons*/
     allocate_btn_areas_and_controls(obj, map);
@@ -111,15 +112,8 @@ void lv_btnmatrix_set_map(lv_obj_t * obj, const char * map[])
     lv_coord_t max_w            = lv_obj_get_content_width(obj);
     lv_coord_t max_h            = lv_obj_get_content_height(obj);
 
-    /*Count the lines to calculate button height*/
-    uint8_t row_cnt = 1;
-    uint32_t i;
-    for(i = 0; map[i] && map[i][0] != '\0'; i++) {
-        if(strcmp(map[i], "\n") == 0) row_cnt++;
-    }
-
     /*Calculate the position of each row*/
-    lv_coord_t max_h_no_gap = max_h - (prow * (row_cnt - 1));
+    lv_coord_t max_h_no_gap = max_h - (prow * (btnm->row_cnt - 1));
 
     /*Count the units and the buttons in a line
      *(A button can be 1,2,3... unit wide)*/
@@ -129,7 +123,7 @@ void lv_btnmatrix_set_map(lv_obj_t * obj, const char * map[])
 
     /*Count the units and the buttons in a line*/
     uint32_t row;
-    for(row = 0; row < row_cnt; row++) {
+    for(row = 0; row < btnm->row_cnt; row++) {
         uint16_t unit_cnt = 0;           /*Number of units in a row*/
         uint16_t btn_cnt = 0;            /*Number of buttons in a row*/
         /*Count the buttons and units in this row*/
@@ -144,8 +138,8 @@ void lv_btnmatrix_set_map(lv_obj_t * obj, const char * map[])
             continue;
         }
 
-        lv_coord_t row_y1 = ptop + (max_h_no_gap * row) / row_cnt + row * prow;
-        lv_coord_t row_y2 = ptop + (max_h_no_gap * (row + 1)) / row_cnt + row * prow - 1;
+        lv_coord_t row_y1 = ptop + (max_h_no_gap * row) / btnm->row_cnt + row * prow;
+        lv_coord_t row_y2 = ptop + (max_h_no_gap * (row + 1)) / btnm->row_cnt + row * prow - 1;
 
         /*Set the button size and positions*/
         lv_coord_t max_w_no_gap = max_w - (pcol * (btn_cnt - 1));
@@ -180,6 +174,10 @@ void lv_btnmatrix_set_map(lv_obj_t * obj, const char * map[])
         map_row = &map_row[btn_cnt + 1];       /*Set the map to the next line*/
     }
 
+    /*Popovers in the top row will draw outside the widget and the extended draw size depends on
+     *the row height which may have changed when setting the new map*/
+    lv_obj_refresh_ext_draw_size(obj);
+
     lv_obj_invalidate(obj);
 }
 
@@ -220,9 +218,13 @@ void lv_btnmatrix_set_btn_ctrl(lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctr
 
     btnm->ctrl_bits[btn_id] |= ctrl;
     invalidate_button_area(obj, btn_id);
+
+    if (ctrl & LV_BTNMATRIX_CTRL_POPOVER) {
+        lv_obj_refresh_ext_draw_size(obj);
+    }
 }
 
-void lv_btnmatrix_clear_btn_ctrl(const lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl)
+void lv_btnmatrix_clear_btn_ctrl(lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
@@ -232,6 +234,10 @@ void lv_btnmatrix_clear_btn_ctrl(const lv_obj_t * obj, uint16_t btn_id, lv_btnma
 
     btnm->ctrl_bits[btn_id] &= (~ctrl);
     invalidate_button_area(obj, btn_id);
+
+    if (ctrl & LV_BTNMATRIX_CTRL_POPOVER) {
+        lv_obj_refresh_ext_draw_size(obj);
+    }
 }
 
 void lv_btnmatrix_set_btn_ctrl_all(lv_obj_t * obj, lv_btnmatrix_ctrl_t ctrl)
@@ -331,7 +337,7 @@ bool lv_btnmatrix_has_btn_ctrl(lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctr
     lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;;
     if(btn_id >= btnm->btn_cnt) return false;
 
-    return (btnm->ctrl_bits[btn_id] & ctrl) ? true : false;
+    return ((btnm->ctrl_bits[btn_id] & ctrl) == ctrl) ? true : false;
 }
 
 bool lv_btnmatrix_get_one_checked(const lv_obj_t * obj)
@@ -353,6 +359,7 @@ static void lv_btnmatrix_constructor(const lv_obj_class_t * class_p, lv_obj_t *
     LV_TRACE_OBJ_CREATE("begin");
     lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;
     btnm->btn_cnt        = 0;
+    btnm->row_cnt        = 0;
     btnm->btn_id_sel     = LV_BTNMATRIX_BTN_NONE;
     btnm->button_areas   = NULL;
     btnm->ctrl_bits      = NULL;
@@ -361,7 +368,7 @@ static void lv_btnmatrix_constructor(const lv_obj_class_t * class_p, lv_obj_t *
 
     lv_btnmatrix_set_map(obj, lv_btnmatrix_def_map);
 
-    LV_TRACE_OBJ_CREATE("finshed");
+    LV_TRACE_OBJ_CREATE("finished");
 }
 
 static void lv_btnmatrix_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
@@ -373,7 +380,7 @@ static void lv_btnmatrix_destructor(const lv_obj_class_t * class_p, lv_obj_t * o
     lv_mem_free(btnm->ctrl_bits);
     btnm->button_areas = NULL;
     btnm->ctrl_bits = NULL;
-    LV_TRACE_OBJ_CREATE("finshed");
+    LV_TRACE_OBJ_CREATE("finished");
 }
 
 static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
@@ -391,6 +398,15 @@ static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
     lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;
     lv_point_t p;
 
+    if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
+        lv_coord_t * s = lv_event_get_param(e);
+        if (has_popovers_in_top_row(obj)) {
+            /*reserve one row worth of extra space to account for popovers in the top row*/
+            *s = btnm->row_cnt > 0 ? lv_obj_get_content_height(obj) / btnm->row_cnt : 0;
+        } else {
+            *s = 0;
+        }
+    }
     if(code == LV_EVENT_STYLE_CHANGED) {
         lv_btnmatrix_set_map(obj, btnm->map_p);
     }
@@ -419,6 +435,7 @@ static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
 
         if(btnm->btn_id_sel != LV_BTNMATRIX_BTN_NONE) {
             if(button_is_click_trig(btnm->ctrl_bits[btnm->btn_id_sel]) == false &&
+               button_is_popover(btnm->ctrl_bits[btnm->btn_id_sel]) == false &&
                button_is_inactive(btnm->ctrl_bits[btnm->btn_id_sel]) == false &&
                button_is_hidden(btnm->ctrl_bits[btnm->btn_id_sel]) == false) {
                 uint32_t b = btnm->btn_id_sel;
@@ -451,7 +468,8 @@ static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
                button_is_hidden(btnm->ctrl_bits[btn_pr]) == false) {
                 invalidate_button_area(obj, btn_pr);
                 /*Send VALUE_CHANGED for the newly pressed button*/
-                if(button_is_click_trig(btnm->ctrl_bits[btn_pr]) == false) {
+                if(button_is_click_trig(btnm->ctrl_bits[btn_pr]) == false &&
+                   button_is_popover(btnm->ctrl_bits[btnm->btn_id_sel]) == false) {
                     uint32_t b = btn_pr;
                     res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, &b);
                     if(res != LV_RES_OK) return;
@@ -474,7 +492,8 @@ static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
             }
 
 
-            if(button_is_click_trig(btnm->ctrl_bits[btnm->btn_id_sel]) == true &&
+            if((button_is_click_trig(btnm->ctrl_bits[btnm->btn_id_sel]) == true ||
+                button_is_popover(btnm->ctrl_bits[btnm->btn_id_sel]) == true) &&
                button_is_inactive(btnm->ctrl_bits[btnm->btn_id_sel]) == false &&
                button_is_hidden(btnm->ctrl_bits[btnm->btn_id_sel]) == false) {
                 uint32_t b = btnm->btn_id_sel;
@@ -519,16 +538,19 @@ static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
         bool editing = lv_group_get_editing(lv_obj_get_group(obj));
         /*Focus the first button if there is not selected button*/
         if(btnm->btn_id_sel == LV_BTNMATRIX_BTN_NONE) {
-            if (indev_type == LV_INDEV_TYPE_KEYPAD || (indev_type == LV_INDEV_TYPE_ENCODER && editing)) {
+            if(indev_type == LV_INDEV_TYPE_KEYPAD || (indev_type == LV_INDEV_TYPE_ENCODER && editing)) {
                 uint32_t b = 0;
                 if(btnm->one_check) {
-                    while(button_is_hidden(btnm->ctrl_bits[b]) || button_is_inactive(btnm->ctrl_bits[b]) || button_is_checked(btnm->ctrl_bits[b]) == false) b++;
-                } else {
+                    while(button_is_hidden(btnm->ctrl_bits[b]) || button_is_inactive(btnm->ctrl_bits[b]) ||
+                          button_is_checked(btnm->ctrl_bits[b]) == false) b++;
+                }
+                else {
                     while(button_is_hidden(btnm->ctrl_bits[b]) || button_is_inactive(btnm->ctrl_bits[b])) b++;
                 }
 
                 btnm->btn_id_sel = b;
-            } else {
+            }
+            else {
                 btnm->btn_id_sel = LV_BTNMATRIX_BTN_NONE;
             }
         }
@@ -620,7 +642,8 @@ static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
         }
 
         invalidate_button_area(obj, btnm->btn_id_sel);
-    } else if(code == LV_EVENT_DRAW_MAIN) {
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
         draw_main(e);
     }
 
@@ -649,7 +672,6 @@ static void draw_main(lv_event_t * e)
     lv_draw_rect_dsc_t draw_rect_dsc_def;
     lv_draw_label_dsc_t draw_label_dsc_def;
 
-
     lv_state_t state_ori = obj->state;
     obj->state = LV_STATE_DEFAULT;
     obj->skip_trans = 1;
@@ -670,11 +692,13 @@ static void draw_main(lv_event_t * e)
     char * txt_ap = lv_mem_buf_get(txt_ap_size);
 #endif
 
-    lv_obj_draw_part_dsc_t dsc;
-    lv_obj_draw_dsc_init(&dsc, clip_area);
-    dsc.part = LV_PART_ITEMS;
-    dsc.rect_dsc = &draw_rect_dsc_act;
-    dsc.label_dsc = &draw_label_dsc_act;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.part = LV_PART_ITEMS;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_BTNMATRIX_DRAW_PART_BTN;
+    part_draw_dsc.rect_dsc = &draw_rect_dsc_act;
+    part_draw_dsc.label_dsc = &draw_label_dsc_act;
 
     for(btn_i = 0; btn_i < btnm->btn_cnt; btn_i++, txt_i++) {
         /*Search the next valid text in the map*/
@@ -688,8 +712,9 @@ static void draw_main(lv_event_t * e)
         /*Get the state of the button*/
         lv_state_t btn_state = LV_STATE_DEFAULT;
         if(button_get_checked(btnm->ctrl_bits[btn_i])) btn_state |= LV_STATE_CHECKED;
+
         if(button_is_inactive(btnm->ctrl_bits[btn_i])) btn_state |= LV_STATE_DISABLED;
-        if(btn_i == btnm->btn_id_sel) {
+        else if(btn_i == btnm->btn_id_sel) {
             if(state_ori & LV_STATE_PRESSED) btn_state |= LV_STATE_PRESSED;
             if(state_ori & LV_STATE_FOCUSED) btn_state |= LV_STATE_FOCUSED;
             if(state_ori & LV_STATE_FOCUS_KEY) btn_state |= LV_STATE_FOCUS_KEY;
@@ -725,9 +750,9 @@ static void draw_main(lv_event_t * e)
         else draw_label_dsc_act.flag &= ~LV_TEXT_FLAG_RECOLOR;
 
 
-        dsc.draw_area = &btn_area;
-        dsc.id = btn_i;
-        lv_event_send(obj,LV_EVENT_DRAW_PART_BEGIN, &dsc);
+        part_draw_dsc.draw_area = &btn_area;
+        part_draw_dsc.id = btn_i;
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
         /*Remove borders on the edges if `LV_BORDER_SIDE_INTERNAL`*/
         if(draw_rect_dsc_act.border_side & LV_BORDER_SIDE_INTERNAL) {
@@ -738,6 +763,13 @@ static void draw_main(lv_event_t * e)
             if(btn_area.y2 == obj->coords.y2 - pbottom) draw_rect_dsc_act.border_side &= ~LV_BORDER_SIDE_BOTTOM;
         }
 
+        lv_coord_t btn_height = lv_area_get_height(&btn_area);
+
+        if ((btn_state & LV_STATE_PRESSED) && (btnm->ctrl_bits[btn_i] & LV_BTNMATRIX_CTRL_POPOVER)) {
+            /*Push up the upper boundary of the btn area to create the popover*/
+            btn_area.y1 -= btn_height;
+        }
+
         /*Draw the background*/
         lv_draw_rect(&btn_area, clip_area, &draw_rect_dsc_act);
 
@@ -757,17 +789,23 @@ static void draw_main(lv_event_t * e)
 #endif
         lv_point_t txt_size;
         lv_txt_get_size(&txt_size, txt, font, letter_space,
-                line_space, lv_area_get_width(&area_obj), draw_label_dsc_act.flag);
+                        line_space, lv_area_get_width(&area_obj), draw_label_dsc_act.flag);
 
         btn_area.x1 += (lv_area_get_width(&btn_area) - txt_size.x) / 2;
         btn_area.y1 += (lv_area_get_height(&btn_area) - txt_size.y) / 2;
         btn_area.x2 = btn_area.x1 + txt_size.x;
         btn_area.y2 = btn_area.y1 + txt_size.y;
 
+        if ((btn_state & LV_STATE_PRESSED) && (btnm->ctrl_bits[btn_i] & LV_BTNMATRIX_CTRL_POPOVER)) {
+            /*Push up the button text into the popover*/
+            btn_area.y1 -= btn_height / 2;
+            btn_area.y2 -= btn_height / 2;
+        }
+
         /*Draw the text*/
         lv_draw_label(&btn_area, clip_area, &draw_label_dsc_act, txt, NULL);
 
-        lv_event_send(obj,LV_EVENT_DRAW_PART_END, &dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
     }
 
     obj->skip_trans = 0;
@@ -782,18 +820,20 @@ static void draw_main(lv_event_t * e)
  */
 static void allocate_btn_areas_and_controls(const lv_obj_t * obj, const char ** map)
 {
+    lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;
+    btnm->row_cnt = 1;
     /*Count the buttons in the map*/
     uint16_t btn_cnt = 0;
     uint16_t i       = 0;
     while(map[i] && map[i][0] != '\0') {
         if(strcmp(map[i], "\n") != 0) { /*Do not count line breaks*/
             btn_cnt++;
+        } else {
+            btnm->row_cnt++;
         }
         i++;
     }
 
-    lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;;
-
     /*Do not allocate memory for the same amount of buttons*/
     if(btn_cnt == btnm->btn_cnt) return;
 
@@ -853,6 +893,11 @@ static bool button_is_click_trig(lv_btnmatrix_ctrl_t ctrl_bits)
     return (ctrl_bits & LV_BTNMATRIX_CTRL_CLICK_TRIG) ? true : false;
 }
 
+static bool button_is_popover(lv_btnmatrix_ctrl_t ctrl_bits)
+{
+    return (ctrl_bits & LV_BTNMATRIX_CTRL_POPOVER) ? true : false;
+}
+
 static bool button_is_checkable(lv_btnmatrix_ctrl_t ctrl_bits)
 {
     return (ctrl_bits & LV_BTNMATRIX_CTRL_CHECKABLE) ? true : false;
@@ -909,11 +954,11 @@ static uint16_t get_button_from_point(lv_obj_t * obj, lv_point_t * p)
         else btn_area.y1 += obj_cords.y1 - prow;
 
         if(btn_area.x2 >= w - pright - 2) btn_area.x2 += obj_cords.x1 + LV_MIN(pright,
-                                                                                         BTN_EXTRA_CLICK_AREA_MAX);  /*-2 for rounding error*/
+                                                                                   BTN_EXTRA_CLICK_AREA_MAX);  /*-2 for rounding error*/
         else btn_area.x2 += obj_cords.x1 + pcol;
 
         if(btn_area.y2 >= h - pbottom - 2) btn_area.y2 += obj_cords.y1 + LV_MIN(pbottom,
-                                                                                          BTN_EXTRA_CLICK_AREA_MAX); /*-2 for rounding error*/
+                                                                                    BTN_EXTRA_CLICK_AREA_MAX); /*-2 for rounding error*/
         else btn_area.y2 += obj_cords.y1 + prow;
 
         if(_lv_area_is_point_on(&btn_area, p, 0) != false) {
@@ -938,7 +983,7 @@ static void invalidate_button_area(const lv_obj_t * obj, uint16_t btn_idx)
     lv_obj_get_coords(obj, &obj_area);
 
     /*The buttons might have outline and shadow so make the invalidation larger with the gaps between the buttons.
-     *It assumes that the outline or shadow is smaller then the gaps*/
+     *It assumes that the outline or shadow is smaller than the gaps*/
     lv_coord_t row_gap = lv_obj_get_style_pad_row(obj, LV_PART_MAIN);
     lv_coord_t col_gap = lv_obj_get_style_pad_column(obj, LV_PART_MAIN);
 
@@ -953,6 +998,11 @@ static void invalidate_button_area(const lv_obj_t * obj, uint16_t btn_idx)
     btn_area.x2 += obj_area.x1 + row_gap;
     btn_area.y2 += obj_area.y1 + col_gap;
 
+    if ((btn_idx == btnm->btn_id_sel) && (btnm->ctrl_bits[btn_idx] & LV_BTNMATRIX_CTRL_POPOVER)) {
+        /*Push up the upper boundary of the btn area to also invalidate the popover*/
+        btn_area.y1 -= lv_area_get_height(&btn_area);
+    }
+
     lv_obj_invalidate_area(obj, &btn_area);
 }
 
@@ -972,4 +1022,30 @@ static void make_one_button_checked(lv_obj_t * obj, uint16_t btn_idx)
     if(was_toggled) lv_btnmatrix_set_btn_ctrl(obj, btn_idx, LV_BTNMATRIX_CTRL_CHECKED);
 }
 
+/**
+ * Check if any of the buttons in the first row has the LV_BTNMATRIX_CTRL_POPOVER control flag set.
+ * @param obj Button matrix object
+ * @return true if at least one button has the flag, false otherwise
+ */
+static bool has_popovers_in_top_row(lv_obj_t * obj)
+{
+    lv_btnmatrix_t * btnm = (lv_btnmatrix_t *)obj;
+
+    if (btnm->row_cnt <= 0) {
+        return false;
+    }
+
+    const char ** map_row = btnm->map_p;
+    uint16_t btn_cnt = 0;
+
+    while (map_row[btn_cnt] && strcmp(map_row[btn_cnt], "\n") != 0 && map_row[btn_cnt][0] != '\0') {
+        if (button_is_popover(btnm->ctrl_bits[btn_cnt])) {
+            return true;
+        }
+        btn_cnt++;
+    }
+
+    return false;
+}
+
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.h
index c13493d2d..351bce31e 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.h
@@ -39,6 +39,7 @@ enum {
     LV_BTNMATRIX_CTRL_CHECKABLE  = 0x0040, /**< The button can be toggled.*/
     LV_BTNMATRIX_CTRL_CHECKED    = 0x0080, /**< Button is currently toggled (e.g. checked).*/
     LV_BTNMATRIX_CTRL_CLICK_TRIG = 0x0100, /**< 1: Send LV_EVENT_VALUE_CHANGE on CLICK, 0: Send LV_EVENT_VALUE_CHANGE on PRESS*/
+    LV_BTNMATRIX_CTRL_POPOVER    = 0x0200, /**< Show a popover when pressing this key*/
     LV_BTNMATRIX_CTRL_RECOLOR    = 0x1000, /**< Enable text recoloring with `#color`*/
     _LV_BTNMATRIX_CTRL_RESERVED  = 0x2000, /**< Reserved for later use*/
     LV_BTNMATRIX_CTRL_CUSTOM_1   = 0x4000, /**< Custom free to use flag*/
@@ -47,7 +48,8 @@ enum {
 
 typedef uint16_t lv_btnmatrix_ctrl_t;
 
-typedef bool (*lv_btnmatrix_btn_draw_cb_t)(lv_obj_t * btnm, uint32_t btn_id, const lv_area_t * draw_area, const lv_area_t * clip_area);
+typedef bool (*lv_btnmatrix_btn_draw_cb_t)(lv_obj_t * btnm, uint32_t btn_id, const lv_area_t * draw_area,
+                                           const lv_area_t * clip_area);
 
 /*Data of button matrix*/
 typedef struct {
@@ -56,12 +58,21 @@ typedef struct {
     lv_area_t * button_areas;                         /*Array of areas of buttons*/
     lv_btnmatrix_ctrl_t * ctrl_bits;                       /*Array of control bytes*/
     uint16_t btn_cnt;                                 /*Number of button in 'map_p'(Handled by the library)*/
+    uint16_t row_cnt;                                 /*Number of rows in 'map_p'(Handled by the library)*/
     uint16_t btn_id_sel;    /*Index of the active button (being pressed/released etc) or LV_BTNMATRIX_BTN_NONE*/
     uint8_t one_check : 1;  /*Single button toggled at once*/
 } lv_btnmatrix_t;
 
 extern const lv_obj_class_t lv_btnmatrix_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_btnmatrix_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_BTNMATRIX_DRAW_PART_BTN,    /**< The rectangle and label of buttons*/
+} lv_btnmatrix_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
@@ -121,7 +132,7 @@ void lv_btnmatrix_set_btn_ctrl(lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctr
  * @param btn_id    0 based index of the button to modify. (Not counting new lines)
  * @param ctrl      OR-ed attributs. E.g. `LV_BTNMATRIX_CTRL_NO_REPEAT | LV_BTNMATRIX_CTRL_CHECKABLE`
  */
-void lv_btnmatrix_clear_btn_ctrl(const lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl);
+void lv_btnmatrix_clear_btn_ctrl(lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctrl_t ctrl);
 
 /**
  * Set attributes of all buttons of a button matrix
@@ -151,10 +162,10 @@ void lv_btnmatrix_set_btn_width(lv_obj_t * obj, uint16_t btn_id, uint8_t width);
 
 /**
  * Make the button matrix like a selector widget (only one button may be checked at a time).
- * `LV_BTNMATRIX_CTRL_CHECKABLE` must be enabled on the buttons to be selected useing
+ * `LV_BTNMATRIX_CTRL_CHECKABLE` must be enabled on the buttons to be selected using
  *  `lv_btnmatrix_set_ctrl()` or `lv_btnmatrix_set_btn_ctrl_all()`.
  * @param obj       pointer to a button matrix object
- * @param           en:  whether "one check" mode is enabled
+ * @param en        whether "one check" mode is enabled
  */
 void lv_btnmatrix_set_one_checked(lv_obj_t * obj, bool en);
 
@@ -201,7 +212,6 @@ bool lv_btnmatrix_has_btn_ctrl(lv_obj_t * obj, uint16_t btn_id, lv_btnmatrix_ctr
  */
 bool lv_btnmatrix_get_one_checked(const lv_obj_t * obj);
 
-
 /**********************
  *      MACROS
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_canvas.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_canvas.c
index 5101276fa..d5efc402d 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_canvas.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_canvas.c
@@ -27,31 +27,14 @@
  *  STATIC PROTOTYPES
  **********************/
 static void lv_canvas_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
-static void set_set_px_cb(lv_disp_drv_t * disp_drv, lv_img_cf_t cf);
-
-static void set_px_true_color_alpha(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x,
-                                    lv_coord_t y,
-                                    lv_color_t color, lv_opa_t opa);
-
-static void set_px_cb_alpha1(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
-                             lv_color_t color, lv_opa_t opa);
-
-static void set_px_cb_alpha2(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
-                             lv_color_t color, lv_opa_t opa);
-
-static void set_px_cb_alpha4(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
-                             lv_color_t color, lv_opa_t opa);
-
-static void set_px_cb_alpha8(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
-                             lv_color_t color, lv_opa_t opa);
-
-static void set_px_alpha_generic(lv_img_dsc_t * d, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa);
+static void lv_canvas_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
 
 /**********************
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_canvas_class = {
     .constructor_cb = lv_canvas_constructor,
+    .destructor_cb = lv_canvas_destructor,
     .instance_size = sizeof(lv_canvas_t),
     .base_class = &lv_img_class
 };
@@ -66,7 +49,7 @@ const lv_obj_class_t lv_canvas_class = {
 
 lv_obj_t * lv_canvas_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -91,7 +74,7 @@ void lv_canvas_set_buffer(lv_obj_t * obj, void * buf, lv_coord_t w, lv_coord_t h
     lv_img_set_src(obj, &canvas->dsc);
 }
 
-void lv_canvas_set_px(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_color_t c)
+void lv_canvas_set_px_color(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_color_t c)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
@@ -101,6 +84,16 @@ void lv_canvas_set_px(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_color_t c)
     lv_obj_invalidate(obj);
 }
 
+void lv_canvas_set_px_opa(lv_obj_t * obj, lv_coord_t x, lv_coord_t y, lv_opa_t opa)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_canvas_t * canvas = (lv_canvas_t *)obj;
+
+    lv_img_buf_set_px_alpha(&canvas->dsc, x, y, opa);
+    lv_obj_invalidate(obj);
+}
+
 void lv_canvas_set_palette(lv_obj_t * obj, uint8_t id, lv_color_t c)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
@@ -595,7 +588,7 @@ void lv_canvas_draw_rect(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord
     disp.driver->hor_res = dsc->header.w;
     disp.driver->ver_res = dsc->header.h;
 
-    set_set_px_cb(disp.driver, dsc->header.cf);
+    lv_disp_drv_use_generic_set_px_cb(disp.driver, dsc->header.cf);
 
     /*Disable anti-aliasing if drawing with transparent color to chroma keyed canvas*/
     lv_color_t ctransp = LV_COLOR_CHROMA_KEY;
@@ -656,7 +649,7 @@ void lv_canvas_draw_text(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord
     disp.driver->hor_res = dsc->header.w;
     disp.driver->ver_res = dsc->header.h;
 
-    set_set_px_cb(disp.driver, dsc->header.cf);
+    lv_disp_drv_use_generic_set_px_cb(disp.driver, dsc->header.cf);
 
     lv_disp_t * refr_ori = _lv_refr_get_disp_refreshing();
     _lv_refr_set_disp_refreshing(&disp);
@@ -717,7 +710,7 @@ void lv_canvas_draw_img(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, const voi
     disp.driver->hor_res = dsc->header.w;
     disp.driver->ver_res = dsc->header.h;
 
-    set_set_px_cb(disp.driver, dsc->header.cf);
+    lv_disp_drv_use_generic_set_px_cb(disp.driver, dsc->header.cf);
 
     lv_disp_t * refr_ori = _lv_refr_get_disp_refreshing();
     _lv_refr_set_disp_refreshing(&disp);
@@ -764,7 +757,7 @@ void lv_canvas_draw_line(lv_obj_t * canvas, const lv_point_t points[], uint32_t
     disp.driver->hor_res = dsc->header.w;
     disp.driver->ver_res = dsc->header.h;
 
-    set_set_px_cb(disp.driver, dsc->header.cf);
+    lv_disp_drv_use_generic_set_px_cb(disp.driver, dsc->header.cf);
 
     /*Disable anti-aliasing if drawing with transparent color to chroma keyed canvas*/
     lv_color_t ctransp = LV_COLOR_CHROMA_KEY;
@@ -822,7 +815,7 @@ void lv_canvas_draw_polygon(lv_obj_t * canvas, const lv_point_t points[], uint32
     disp.driver->hor_res = dsc->header.w;
     disp.driver->ver_res = dsc->header.h;
 
-    set_set_px_cb(disp.driver, dsc->header.cf);
+    lv_disp_drv_use_generic_set_px_cb(disp.driver, dsc->header.cf);
 
     /*Disable anti-aliasing if drawing with transparent color to chroma keyed canvas*/
     lv_color_t ctransp = LV_COLOR_CHROMA_KEY;
@@ -878,7 +871,7 @@ void lv_canvas_draw_arc(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_coord_
     disp.driver->hor_res = dsc->header.w;
     disp.driver->ver_res = dsc->header.h;
 
-    set_set_px_cb(disp.driver, dsc->header.cf);
+    lv_disp_drv_use_generic_set_px_cb(disp.driver, dsc->header.cf);
 
     /*Disable anti-aliasing if drawing with transparent color to chroma keyed canvas*/
     lv_color_t ctransp = LV_COLOR_CHROMA_KEY;
@@ -930,123 +923,13 @@ static void lv_canvas_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj
     LV_TRACE_OBJ_CREATE("finished");
 }
 
-static void set_set_px_cb(lv_disp_drv_t * disp_drv, lv_img_cf_t cf)
+static void lv_canvas_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 {
-    switch(cf) {
-        case LV_IMG_CF_TRUE_COLOR_ALPHA:
-            disp_drv->set_px_cb = set_px_true_color_alpha;
-            break;
-        case LV_IMG_CF_ALPHA_1BIT:
-            disp_drv->set_px_cb = set_px_cb_alpha1;
-            break;
-        case LV_IMG_CF_ALPHA_2BIT:
-            disp_drv->set_px_cb = set_px_cb_alpha2;
-            break;
-        case LV_IMG_CF_ALPHA_4BIT:
-            disp_drv->set_px_cb = set_px_cb_alpha4;
-            break;
-        case LV_IMG_CF_ALPHA_8BIT:
-            disp_drv->set_px_cb = set_px_cb_alpha8;
-            break;
-        default:
-            disp_drv->set_px_cb = NULL;
-    }
-}
+    LV_UNUSED(class_p);
+    LV_TRACE_OBJ_CREATE("begin");
 
-static void set_px_cb_alpha1(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
-                             lv_color_t color, lv_opa_t opa)
-{
-    (void) disp_drv; /*Unused*/
-
-    if(opa <= LV_OPA_MIN) return;
-    lv_img_dsc_t d;
-    d.data = buf;
-    d.header.w = buf_w;
-    d.header.cf = LV_IMG_CF_ALPHA_1BIT;
-
-    set_px_alpha_generic(&d, x, y, color, opa);
-}
-
-static void set_px_cb_alpha2(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
-                             lv_color_t color, lv_opa_t opa)
-{
-    (void) disp_drv; /*Unused*/
-
-    if(opa <= LV_OPA_MIN) return;
-    lv_img_dsc_t d;
-    d.data = buf;
-    d.header.w = buf_w;
-    d.header.cf = LV_IMG_CF_ALPHA_2BIT;
-
-    set_px_alpha_generic(&d, x, y, color, opa);
-}
-
-static void set_px_cb_alpha4(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
-                             lv_color_t color, lv_opa_t opa)
-{
-    (void) disp_drv; /*Unused*/
-
-    if(opa <= LV_OPA_MIN) return;
-    lv_img_dsc_t d;
-    d.data = buf;
-    d.header.w = buf_w;
-    d.header.cf = LV_IMG_CF_ALPHA_4BIT;
-
-    set_px_alpha_generic(&d, x, y, color, opa);
-}
-
-static void set_px_cb_alpha8(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x, lv_coord_t y,
-                             lv_color_t color, lv_opa_t opa)
-{
-    (void) disp_drv; /*Unused*/
-
-    if(opa <= LV_OPA_MIN) return;
-    lv_img_dsc_t d;
-    d.data = buf;
-    d.header.w = buf_w;
-    d.header.cf = LV_IMG_CF_ALPHA_8BIT;
-
-    set_px_alpha_generic(&d, x, y, color, opa);
-}
-
-static void set_px_alpha_generic(lv_img_dsc_t * d, lv_coord_t x, lv_coord_t y, lv_color_t color, lv_opa_t opa)
-{
-    d->header.always_zero = 0;
-    d->header.h = 1;    /*Doesn't matter*/
-
-    uint8_t br = lv_color_brightness(color);
-    if(opa < LV_OPA_MAX) {
-        uint8_t bg = lv_img_buf_get_px_alpha(d, x, y);
-        br = (uint16_t)((uint16_t)br * opa + (bg * (255 - opa))) >> 8;
-    }
-
-    lv_img_buf_set_px_alpha(d, x, y, br);
-}
-
-static void set_px_true_color_alpha(lv_disp_drv_t * disp_drv, uint8_t * buf, lv_coord_t buf_w, lv_coord_t x,
-                                    lv_coord_t y,
-                                    lv_color_t color, lv_opa_t opa)
-{
-    (void) disp_drv; /*Unused*/
-
-    if(opa <= LV_OPA_MIN) return;
-    lv_img_dsc_t d;
-    d.data = buf;
-    d.header.always_zero = 0;
-    d.header.h = 1;    /*Doesn't matter*/;
-    d.header.w = buf_w;
-    d.header.cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
-
-    lv_color_t bg_color = lv_img_buf_get_px_color(&d, x, y, lv_color_black());
-    lv_opa_t bg_opa = lv_img_buf_get_px_alpha(&d, x, y);
-
-    lv_opa_t res_opa;
-    lv_color_t res_color;
-
-    lv_color_mix_with_alpha(bg_color, bg_opa, color, opa, &res_color, &res_opa);
-
-    lv_img_buf_set_px_alpha(&d, x, y, res_opa);
-    lv_img_buf_set_px_color(&d, x, y, res_color);
+    lv_canvas_t * canvas = (lv_canvas_t *)obj;
+    lv_img_cache_invalidate_src(&canvas->dsc);
 }
 
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_canvas.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_canvas.h
index bc0eadd1d..71f051614 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_canvas.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_canvas.h
@@ -70,9 +70,27 @@ void lv_canvas_set_buffer(lv_obj_t * canvas, void * buf, lv_coord_t w, lv_coord_
  * @param canvas
  * @param x x coordinate of the point to set
  * @param y x coordinate of the point to set
- * @param c color of the point
+ * @param c color of the pixel
  */
-void lv_canvas_set_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t c);
+void lv_canvas_set_px_color(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t c);
+
+/**
+ * DEPRECATED: added only for backward compatibility
+ */
+static inline void lv_canvas_set_px(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_color_t c)
+{
+    lv_canvas_set_px_color(canvas, x, y, c);
+}
+
+/**
+ * Set the opacity of a pixel on the canvas
+ * @param canvas
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param opa opacity of the pixel (0..255)
+ */
+void lv_canvas_set_px_opa(lv_obj_t * canvas, lv_coord_t x, lv_coord_t y, lv_opa_t opa);
+
 
 /**
  * Set the palette color of a canvas with index format. Valid only for `LV_IMG_CF_INDEXED1/2/4/8`
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.c
index 651d14114..2128f2d13 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.c
@@ -55,7 +55,7 @@ const lv_obj_class_t lv_checkbox_class = {
 
 lv_obj_t * lv_checkbox_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -85,6 +85,7 @@ void lv_checkbox_set_text(lv_obj_t * obj, const char * txt)
     cb->static_txt = 0;
 
     lv_obj_refresh_self_size(obj);
+    lv_obj_invalidate(obj);
 }
 
 void lv_checkbox_set_text_static(lv_obj_t * obj, const char * txt)
@@ -93,10 +94,11 @@ void lv_checkbox_set_text_static(lv_obj_t * obj, const char * txt)
 
     if(!cb->static_txt) lv_mem_free(cb->txt);
 
-    cb->txt = (char*)txt;
+    cb->txt = (char *)txt;
     cb->static_txt = 1;
 
     lv_obj_refresh_self_size(obj);
+    lv_obj_invalidate(obj);
 }
 
 /*=====================
@@ -154,10 +156,10 @@ static void lv_checkbox_event(const lv_obj_class_t * class_p, lv_event_t * e)
     lv_event_code_t code = lv_event_get_code(e);
     lv_obj_t * obj = lv_event_get_target(e);
 
-    if (code == LV_EVENT_PRESSED || code == LV_EVENT_RELEASED) {
-       lv_obj_invalidate(obj);
+    if(code == LV_EVENT_PRESSED || code == LV_EVENT_RELEASED) {
+        lv_obj_invalidate(obj);
     }
-    else if (code == LV_EVENT_GET_SELF_SIZE) {
+    else if(code == LV_EVENT_GET_SELF_SIZE) {
         lv_point_t * p = lv_event_get_param(e);
         lv_checkbox_t * cb = (lv_checkbox_t *)obj;
 
@@ -182,7 +184,7 @@ static void lv_checkbox_event(const lv_obj_class_t * class_p, lv_event_t * e)
         p->y = LV_MAX(marker_size.y, txt_size.y);
     }
     else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
-        lv_coord_t *s = lv_event_get_param(e);
+        lv_coord_t * s = lv_event_get_param(e);
         lv_coord_t m = lv_obj_calculate_ext_draw_size(obj, LV_PART_INDICATOR);
         *s = LV_MAX(*s, m);
     }
@@ -192,7 +194,8 @@ static void lv_checkbox_event(const lv_obj_class_t * class_p, lv_event_t * e)
         if(res != LV_RES_OK) return;
 
         lv_obj_invalidate(obj);
-    } else if(code == LV_EVENT_DRAW_MAIN) {
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
         lv_checkbox_draw(e);
     }
 }
@@ -206,8 +209,9 @@ static void lv_checkbox_draw(lv_event_t * e)
     const lv_font_t * font = lv_obj_get_style_text_font(obj, LV_PART_MAIN);
     lv_coord_t font_h = lv_font_get_line_height(font);
 
-    lv_coord_t bg_topp = lv_obj_get_style_pad_top(obj, LV_PART_MAIN);
-    lv_coord_t bg_leftp = lv_obj_get_style_pad_left(obj, LV_PART_MAIN);
+    lv_coord_t bg_border = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
+    lv_coord_t bg_topp = lv_obj_get_style_pad_top(obj, LV_PART_MAIN) + bg_border;
+    lv_coord_t bg_leftp = lv_obj_get_style_pad_left(obj, LV_PART_MAIN) + bg_border;
     lv_coord_t bg_colp = lv_obj_get_style_pad_column(obj, LV_PART_MAIN);
 
     lv_coord_t marker_leftp = lv_obj_get_style_pad_left(obj, LV_PART_INDICATOR);
@@ -234,15 +238,17 @@ static void lv_checkbox_draw(lv_event_t * e)
     marker_area_transf.y1 -= transf_h;
     marker_area_transf.y2 += transf_h;
 
-    lv_obj_draw_part_dsc_t obj_draw_dsc;
-    lv_obj_draw_dsc_init(&obj_draw_dsc, clip_area);
-    obj_draw_dsc.rect_dsc = &indic_dsc;
-    obj_draw_dsc.draw_area = &marker_area_transf;
-    obj_draw_dsc.part = LV_PART_INDICATOR;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.rect_dsc = &indic_dsc;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_CHECKBOX_DRAW_PART_BOX;
+    part_draw_dsc.draw_area = &marker_area_transf;
+    part_draw_dsc.part = LV_PART_INDICATOR;
 
-    lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &obj_draw_dsc);
+    lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
     lv_draw_rect(&marker_area_transf, clip_area, &indic_dsc);
-    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &obj_draw_dsc);
+    lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
 
     lv_coord_t line_space = lv_obj_get_style_text_line_space(obj, LV_PART_MAIN);
     lv_coord_t letter_space = lv_obj_get_style_text_letter_space(obj, LV_PART_MAIN);
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.h
index a1027a021..772f500d5 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.h
@@ -29,11 +29,19 @@ extern "C" {
 typedef struct {
     lv_obj_t obj;
     char * txt;
-    uint32_t static_txt :1;
-}lv_checkbox_t;
+    uint32_t static_txt : 1;
+} lv_checkbox_t;
 
 extern const lv_obj_class_t lv_checkbox_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_checkbox_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_CHECKBOX_DRAW_PART_BOX,    /**< The tick box*/
+} lv_checkbox_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
@@ -61,7 +69,7 @@ void lv_checkbox_set_text(lv_obj_t * obj, const char * txt);
  * Set the text of a check box. `txt` must not be deallocated during the life
  * of this checkbox.
  * @param cb    pointer to a check box
- * @param txt   the text of the check box. NULL to refresh with the current text.
+ * @param txt   the text of the check box.
  */
 void lv_checkbox_set_text_static(lv_obj_t * obj, const char * txt);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.c
index b5b9aa234..627bcf63e 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.c
@@ -49,8 +49,9 @@ static void draw_list(lv_event_t * e);
 
 static void draw_box(lv_obj_t * dropdown_obj, const lv_area_t * clip_area, uint16_t id, lv_state_t state);
 static void draw_box_label(lv_obj_t * dropdown_obj, const lv_area_t * clip_area, uint16_t id, lv_state_t state);
+static lv_res_t btn_release_handler(lv_obj_t * obj);
 static lv_res_t list_release_handler(lv_obj_t * list_obj);
-static void page_press_handler(lv_obj_t * page);
+static void list_press_handler(lv_obj_t * page);
 static uint16_t get_id_on_point(lv_obj_t * dropdown_obj, lv_coord_t y);
 static void position_to_selected(lv_obj_t * obj);
 static lv_obj_t * get_label(const lv_obj_t * obj);
@@ -89,7 +90,7 @@ const lv_obj_class_t lv_dropdownlist_class = {
 
 lv_obj_t * lv_dropdown_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_dropdown_class, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -152,6 +153,9 @@ void lv_dropdown_set_options(lv_obj_t * obj, const char * options)
 
     /*Now the text is dynamically allocated*/
     dropdown->static_txt = 0;
+
+    lv_obj_invalidate(obj);
+    if(dropdown->list) lv_obj_invalidate(dropdown->list);
 }
 
 void lv_dropdown_set_options_static(lv_obj_t * obj, const char * options)
@@ -178,6 +182,9 @@ void lv_dropdown_set_options_static(lv_obj_t * obj, const char * options)
 
     dropdown->static_txt = 1;
     dropdown->options = (char *)options;
+
+    lv_obj_invalidate(obj);
+    if(dropdown->list) lv_obj_invalidate(dropdown->list);
 }
 
 void lv_dropdown_add_option(lv_obj_t * obj, const char * option, uint32_t pos)
@@ -248,6 +255,7 @@ void lv_dropdown_add_option(lv_obj_t * obj, const char * option, uint32_t pos)
     dropdown->option_cnt++;
 
     lv_obj_invalidate(obj);
+    if(dropdown->list) lv_obj_invalidate(dropdown->list);
 }
 
 void lv_dropdown_clear_options(lv_obj_t * obj)
@@ -264,6 +272,7 @@ void lv_dropdown_clear_options(lv_obj_t * obj)
     dropdown->option_cnt = 0;
 
     lv_obj_invalidate(obj);
+    if(dropdown->list) lv_obj_invalidate(dropdown->list);
 }
 
 void lv_dropdown_set_selected(lv_obj_t * obj, uint16_t sel_opt)
@@ -335,7 +344,7 @@ const char * lv_dropdown_get_options(const lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
     lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
-    return dropdown->options;
+    return dropdown->options == NULL ? "" : dropdown->options;
 }
 
 uint16_t lv_dropdown_get_selected(const lv_obj_t * obj)
@@ -373,7 +382,7 @@ void lv_dropdown_get_selected_str(const lv_obj_t * obj, char * buf, uint32_t buf
     uint32_t c;
     for(c = 0; i < txt_len && dropdown->options[i] != '\n'; c++, i++) {
         if(buf_size && c >= buf_size - 1) {
-            LV_LOG_WARN("lv_dropdown_get_selected_str: the buffer was too small")
+            LV_LOG_WARN("lv_dropdown_get_selected_str: the buffer was too small");
             break;
         }
         buf[c] = dropdown->options[i];
@@ -415,13 +424,16 @@ void lv_dropdown_open(lv_obj_t * dropdown_obj)
 
     if(dropdown->list == NULL) {
         lv_obj_t * list_obj = lv_dropdown_list_create(lv_obj_get_screen(dropdown_obj));
-        ((lv_dropdown_list_t*) list_obj)->dropdown = dropdown_obj;
+        ((lv_dropdown_list_t *) list_obj)->dropdown = dropdown_obj;
         dropdown->list = list_obj;
         lv_obj_clear_flag(dropdown->list, LV_OBJ_FLAG_CLICK_FOCUSABLE);
         lv_obj_add_flag(dropdown->list, LV_OBJ_FLAG_IGNORE_LAYOUT);
         lv_obj_update_layout(dropdown->list);
     }
 
+    /*To allow styling the list*/
+    lv_event_send(dropdown_obj, LV_EVENT_READY, NULL);
+
     lv_obj_t * label = get_label(dropdown_obj);
     lv_label_set_text_static(label, dropdown->options);
     lv_obj_set_width(dropdown->list, LV_SIZE_CONTENT);
@@ -489,23 +501,19 @@ void lv_dropdown_open(lv_obj_t * dropdown_obj)
         }
     }
 
-    lv_text_align_t align = lv_obj_get_style_text_align(label, LV_PART_MAIN);
-    if(align == LV_TEXT_ALIGN_AUTO) {
-       if(lv_obj_get_style_base_dir(label, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_TEXT_ALIGN_RIGHT;
-       else align = LV_TEXT_ALIGN_LEFT;
-    }
+    lv_text_align_t align = lv_obj_calculate_style_text_align(label, LV_PART_MAIN, dropdown->options);
 
     switch(align) {
-    default:
-    case LV_TEXT_ALIGN_LEFT:
-        lv_obj_set_x(label, 0);
-        break;
-    case LV_TEXT_ALIGN_RIGHT:
-        lv_obj_set_x(label, lv_obj_get_content_width(dropdown->list) - lv_obj_get_width(label));
-        break;
-    case LV_TEXT_ALIGN_CENTER:
-        lv_obj_set_x(label, lv_obj_get_content_width(dropdown->list) / 2 - lv_obj_get_width(label) / 2);
-        break;
+        default:
+        case LV_TEXT_ALIGN_LEFT:
+            lv_obj_align(label, LV_ALIGN_TOP_LEFT, 0, 0);
+            break;
+        case LV_TEXT_ALIGN_RIGHT:
+            lv_obj_align(label, LV_ALIGN_TOP_RIGHT, 0, 0);
+            break;
+        case LV_TEXT_ALIGN_CENTER:
+            lv_obj_align(label, LV_ALIGN_CENTER, 0, 0);
+            break;
 
     }
 }
@@ -517,6 +525,8 @@ void lv_dropdown_close(lv_obj_t * obj)
 
     dropdown->pr_opt_id = LV_DROPDOWN_PR_NONE;
     if(dropdown->list) lv_obj_del(dropdown->list);
+
+    lv_event_send(obj, LV_EVENT_CANCEL, NULL);
 }
 
 /**********************
@@ -525,7 +535,7 @@ void lv_dropdown_close(lv_obj_t * obj)
 
 static lv_obj_t * lv_dropdown_list_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(&lv_dropdownlist_class, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -615,40 +625,22 @@ static void lv_dropdown_event(const lv_obj_class_t * class_p, lv_event_t * e)
         /*Encoders need special handling*/
         if(indev_type == LV_INDEV_TYPE_ENCODER) {
             /*Open the list if editing*/
-            if(editing) lv_dropdown_open(obj);
+            if(editing) {
+                lv_dropdown_open(obj);
+            }
             /*Close the list if navigating*/
-            else
+            else {
+                dropdown->sel_opt_id = dropdown->sel_opt_id_orig;
                 lv_dropdown_close(obj);
+            }
         }
     }
     else if(code == LV_EVENT_DEFOCUSED || code == LV_EVENT_LEAVE) {
         lv_dropdown_close(obj);
     }
     else if(code == LV_EVENT_RELEASED) {
-        lv_indev_t * indev = lv_indev_get_act();
-        if(lv_indev_get_scroll_obj(indev) == NULL) {
-            if(dropdown->list) {
-                lv_dropdown_close(obj);
-                if(dropdown->sel_opt_id_orig != dropdown->sel_opt_id) {
-                    dropdown->sel_opt_id_orig = dropdown->sel_opt_id;
-                    uint32_t id  = dropdown->sel_opt_id; /*Just to use uint32_t in event data*/
-                    res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, &id);
-                    if(res != LV_RES_OK) return;
-                    lv_obj_invalidate(obj);
-                }
-                lv_indev_type_t indev_type = lv_indev_get_type(indev);
-                if(indev_type == LV_INDEV_TYPE_ENCODER) {
-                    lv_group_set_editing(lv_obj_get_group(obj), false);
-                }
-            }
-            else {
-                lv_dropdown_open(obj);
-            }
-        }
-        else {
-            dropdown->sel_opt_id = dropdown->sel_opt_id_orig;
-            lv_obj_invalidate(obj);
-        }
+        res = btn_release_handler(obj);
+        if(res != LV_RES_OK) return;
     }
     else if(code == LV_EVENT_STYLE_CHANGED) {
         lv_obj_refresh_self_size(obj);
@@ -686,6 +678,15 @@ static void lv_dropdown_event(const lv_obj_class_t * class_p, lv_event_t * e)
             dropdown->sel_opt_id = dropdown->sel_opt_id_orig;
             lv_dropdown_close(obj);
         }
+        else if(c == LV_KEY_ENTER) {
+            /* Handle the ENTER key only if it was send by an other object.
+             * Do no process it if ENTER is sent by the dropdown becasue it's handled in LV_EVENT_RELEASED */
+            lv_obj_t * indev_obj = lv_indev_get_obj_act();
+            if(indev_obj != obj) {
+                res = btn_release_handler(obj);
+                if(res != LV_RES_OK) return;
+            }
+        }
     }
     else if(code == LV_EVENT_DRAW_MAIN) {
         draw_main(e);
@@ -714,7 +715,7 @@ static void lv_dropdown_list_event(const lv_obj_class_t * class_p, lv_event_t *
         }
     }
     else if(code == LV_EVENT_PRESSED) {
-        page_press_handler(list);
+        list_press_handler(list);
     }
     else if(code == LV_EVENT_SCROLL_BEGIN) {
         dropdown->pr_opt_id = LV_DROPDOWN_PR_NONE;
@@ -762,16 +763,19 @@ static void draw_main(lv_event_t * e)
         lv_coord_t symbol_h;
         if(symbol_type == LV_IMG_SRC_SYMBOL) {
             lv_point_t size;
-            lv_txt_get_size(&size, dropdown->symbol, symbol_dsc.font, symbol_dsc.letter_space, symbol_dsc.line_space, LV_COORD_MAX, symbol_dsc.flag);
+            lv_txt_get_size(&size, dropdown->symbol, symbol_dsc.font, symbol_dsc.letter_space, symbol_dsc.line_space, LV_COORD_MAX,
+                            symbol_dsc.flag);
             symbol_w = size.x;
             symbol_h = size.y;
-        } else {
+        }
+        else {
             lv_img_header_t header;
             lv_res_t res = lv_img_decoder_get_info(dropdown->symbol, &header);
             if(res == LV_RES_OK) {
                 symbol_w = header.w;
                 symbol_h = header.h;
-            } else {
+            }
+            else {
                 symbol_w = -1;
                 symbol_h = -1;
             }
@@ -781,7 +785,8 @@ static void draw_main(lv_event_t * e)
         if(symbol_to_left) {
             symbol_area.x1 = obj->coords.x1 + left;
             symbol_area.x2 = symbol_area.x1 + symbol_w - 1;
-        } else {
+        }
+        else {
             symbol_area.x1 = obj->coords.x2 - right - symbol_w;
             symbol_area.x2 = symbol_area.x1 + symbol_w - 1;
         }
@@ -790,7 +795,8 @@ static void draw_main(lv_event_t * e)
             symbol_area.y1 = obj->coords.y1 + top;
             symbol_area.y2 = symbol_area.y1 + symbol_h - 1;
             lv_draw_label(&symbol_area, clip_area, &symbol_dsc, dropdown->symbol, NULL);
-        } else {
+        }
+        else {
             symbol_area.y1 = obj->coords.y1 + (lv_obj_get_height(obj) - symbol_h) / 2;
             symbol_area.y2 = symbol_area.y1 + symbol_h - 1;
             lv_draw_img_dsc_t img_dsc;
@@ -808,7 +814,8 @@ static void draw_main(lv_event_t * e)
     lv_obj_init_draw_label_dsc(obj, LV_PART_MAIN, &label_dsc);
 
     lv_point_t size;
-    lv_txt_get_size(&size, opt_txt, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX, label_dsc.flag);
+    lv_txt_get_size(&size, opt_txt, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
+                    label_dsc.flag);
 
     lv_area_t txt_area;
     txt_area.y1 = obj->coords.y1 + top;
@@ -823,7 +830,8 @@ static void draw_main(lv_event_t * e)
         if(symbol_to_left) {
             txt_area.x1 = obj->coords.x2 - right - size.x;
             txt_area.x2 = txt_area.x1 + size.x;
-        } else {
+        }
+        else {
             txt_area.x1 = obj->coords.x1 + left;
             txt_area.x2 = txt_area.x1 + size.x;
         }
@@ -855,13 +863,15 @@ static void draw_list(lv_event_t * e)
                 if(dropdown->pr_opt_id == dropdown->sel_opt_id) {
                     draw_box(dropdown_obj, &clip_area_core, dropdown->pr_opt_id, LV_STATE_CHECKED | LV_STATE_PRESSED);
                     draw_box_label(dropdown_obj, &clip_area_core, dropdown->pr_opt_id, LV_STATE_CHECKED | LV_STATE_PRESSED);
-                } else {
+                }
+                else {
                     draw_box(dropdown_obj, &clip_area_core, dropdown->pr_opt_id, LV_STATE_PRESSED);
                     draw_box_label(dropdown_obj, &clip_area_core, dropdown->pr_opt_id, LV_STATE_PRESSED);
                     draw_box(dropdown_obj, &clip_area_core, dropdown->sel_opt_id, LV_STATE_CHECKED);
                     draw_box_label(dropdown_obj, &clip_area_core, dropdown->sel_opt_id, LV_STATE_CHECKED);
                 }
-            } else {
+            }
+            else {
                 draw_box(dropdown_obj, &clip_area_core, dropdown->pr_opt_id, LV_STATE_PRESSED);
                 draw_box_label(dropdown_obj, &clip_area_core, dropdown->pr_opt_id, LV_STATE_PRESSED);
             }
@@ -924,7 +934,8 @@ static void draw_box_label(lv_obj_t * dropdown_obj, const lv_area_t * clip_area,
     lv_draw_label_dsc_init(&label_dsc);
     lv_obj_init_draw_label_dsc(list_obj, LV_PART_SELECTED, &label_dsc);
 
-    label_dsc.line_space = lv_obj_get_style_text_line_space(list_obj, LV_PART_SELECTED);  /*Line space should come from the list*/
+    label_dsc.line_space = lv_obj_get_style_text_line_space(list_obj,
+                                                            LV_PART_SELECTED);  /*Line space should come from the list*/
 
     lv_obj_t * label = get_label(dropdown_obj);
     if(label == NULL) return;
@@ -949,6 +960,38 @@ static void draw_box_label(lv_obj_t * dropdown_obj, const lv_area_t * clip_area,
     list_obj->skip_trans = 0;
 }
 
+
+static lv_res_t btn_release_handler(lv_obj_t * obj)
+{
+    lv_dropdown_t * dropdown = (lv_dropdown_t *)obj;
+    lv_indev_t * indev = lv_indev_get_act();
+    if(lv_indev_get_scroll_obj(indev) == NULL) {
+        if(dropdown->list) {
+            lv_dropdown_close(obj);
+            if(dropdown->sel_opt_id_orig != dropdown->sel_opt_id) {
+                dropdown->sel_opt_id_orig = dropdown->sel_opt_id;
+                lv_res_t res;
+                uint32_t id  = dropdown->sel_opt_id; /*Just to use uint32_t in event data*/
+                res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, &id);
+                if(res != LV_RES_OK) return res;
+                lv_obj_invalidate(obj);
+            }
+            lv_indev_type_t indev_type = lv_indev_get_type(indev);
+            if(indev_type == LV_INDEV_TYPE_ENCODER) {
+                lv_group_set_editing(lv_obj_get_group(obj), false);
+            }
+        }
+        else {
+            lv_dropdown_open(obj);
+        }
+    }
+    else {
+        dropdown->sel_opt_id = dropdown->sel_opt_id_orig;
+        lv_obj_invalidate(obj);
+    }
+    return LV_RES_OK;
+}
+
 /**
  * Called when a drop down list is released to open it or set new option
  * @param list pointer to the drop down list's list
@@ -956,7 +999,7 @@ static void draw_box_label(lv_obj_t * dropdown_obj, const lv_area_t * clip_area,
  */
 static lv_res_t list_release_handler(lv_obj_t * list_obj)
 {
-    lv_dropdown_list_t * list = (lv_dropdown_list_t*) list_obj;
+    lv_dropdown_list_t * list = (lv_dropdown_list_t *) list_obj;
     lv_obj_t * dropdown_obj = list->dropdown;
     lv_dropdown_t * dropdown = (lv_dropdown_t *)dropdown_obj;
 
@@ -990,9 +1033,9 @@ static lv_res_t list_release_handler(lv_obj_t * list_obj)
     return LV_RES_OK;
 }
 
-static void page_press_handler(lv_obj_t * list_obj)
+static void list_press_handler(lv_obj_t * list_obj)
 {
-    lv_dropdown_list_t * list = (lv_dropdown_list_t*) list_obj;
+    lv_dropdown_list_t * list = (lv_dropdown_list_t *) list_obj;
     lv_obj_t * dropdown_obj = list->dropdown;
     lv_dropdown_t * dropdown = (lv_dropdown_t *)dropdown_obj;
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.h
index 9cf81a047..402a37ce5 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.h
@@ -45,15 +45,15 @@ typedef struct {
     uint16_t sel_opt_id;            /**< Index of the currently selected option*/
     uint16_t sel_opt_id_orig;       /**< Store the original index on focus*/
     uint16_t pr_opt_id;             /**< Index of the currently pressed option*/
-    lv_dir_t dir              :4;   /**< Direction in which the list should open*/
-    uint8_t static_txt        :1;   /**< 1: Only a pointer is saved in `options`*/
-    uint8_t selected_highlight:1;   /**< 1: Make the selected option highlighted in the list*/
-}lv_dropdown_t;
+    lv_dir_t dir              : 4;  /**< Direction in which the list should open*/
+    uint8_t static_txt        : 1;  /**< 1: Only a pointer is saved in `options`*/
+    uint8_t selected_highlight: 1;  /**< 1: Make the selected option highlighted in the list*/
+} lv_dropdown_t;
 
 typedef struct {
-  lv_obj_t obj;
-  lv_obj_t * dropdown;
-}lv_dropdown_list_t;
+    lv_obj_t obj;
+    lv_obj_t * dropdown;
+} lv_dropdown_list_t;
 
 extern const  lv_obj_class_t lv_dropdown_class;
 extern const  lv_obj_class_t lv_dropdownlist_class;
@@ -78,7 +78,7 @@ lv_obj_t * lv_dropdown_create(lv_obj_t * parent);
  * If set to `NULL` the selected option's text will be displayed on the button.
  * If set to a specific text then that text will be shown regardless the selected option.
  * @param obj       pointer to a drop-down list object
- * @param txt       the text as a string (Only it's pointer is saved)
+ * @param txt       the text as a string (Only its pointer is saved)
  */
 void lv_dropdown_set_text(lv_obj_t * obj, const char * txt);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_img.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_img.c
index 950a58769..126e8805b 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_img.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_img.c
@@ -37,14 +37,14 @@ static void draw_img(lv_event_t * e);
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_img_class = {
-         .constructor_cb = lv_img_constructor,
-         .destructor_cb = lv_img_destructor,
-         .event_cb = lv_img_event,
-         .width_def = LV_SIZE_CONTENT,
-         .height_def = LV_SIZE_CONTENT,
-         .instance_size = sizeof(lv_img_t),
-         .base_class = &lv_obj_class
-     };
+    .constructor_cb = lv_img_constructor,
+    .destructor_cb = lv_img_destructor,
+    .event_cb = lv_img_event,
+    .width_def = LV_SIZE_CONTENT,
+    .height_def = LV_SIZE_CONTENT,
+    .instance_size = sizeof(lv_img_t),
+    .base_class = &lv_obj_class
+};
 
 /**********************
  *      MACROS
@@ -56,7 +56,7 @@ const lv_obj_class_t lv_img_class = {
 
 lv_obj_t * lv_img_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -95,7 +95,7 @@ void lv_img_set_src(lv_obj_t * obj, const void * src)
     if(src_type == LV_IMG_SRC_UNKNOWN) {
         LV_LOG_WARN("lv_img_set_src: unknown image type");
         if(img->src_type == LV_IMG_SRC_SYMBOL || img->src_type == LV_IMG_SRC_FILE) {
-            lv_mem_free((void*)img->src);
+            lv_mem_free((void *)img->src);
         }
         img->src      = NULL;
         img->src_type = LV_IMG_SRC_UNKNOWN;
@@ -109,7 +109,7 @@ void lv_img_set_src(lv_obj_t * obj, const void * src)
     if(src_type == LV_IMG_SRC_VARIABLE) {
         /*If memory was allocated because of the previous `src_type` then free it*/
         if(img->src_type == LV_IMG_SRC_FILE || img->src_type == LV_IMG_SRC_SYMBOL) {
-            lv_mem_free((void*)img->src);
+            lv_mem_free((void *)img->src);
         }
         img->src = src;
     }
@@ -129,7 +129,7 @@ void lv_img_set_src(lv_obj_t * obj, const void * src)
             strcpy(new_str, src);
             img->src = new_str;
 
-            if(old_src) lv_mem_free((void*)old_src);
+            if(old_src) lv_mem_free((void *)old_src);
         }
     }
 
@@ -163,7 +163,7 @@ void lv_img_set_offset_x(lv_obj_t * obj, lv_coord_t x)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     x = x % img->w;
 
@@ -175,7 +175,7 @@ void lv_img_set_offset_y(lv_obj_t * obj, lv_coord_t y)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     y = y % img->h;
 
@@ -187,11 +187,11 @@ void lv_img_set_angle(lv_obj_t * obj, int16_t angle)
 {
     if(angle < 0 || angle >= 3600) angle = angle % 3600;
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
     if(angle == img->angle) return;
 
     lv_coord_t transf_zoom = lv_obj_get_style_transform_zoom(obj, LV_PART_MAIN);
-    transf_zoom = (transf_zoom * img->zoom) >> 8;
+    transf_zoom = ((int32_t)transf_zoom * img->zoom) >> 8;
 
     lv_coord_t transf_angle = lv_obj_get_style_transform_angle(obj, LV_PART_MAIN);
 
@@ -222,7 +222,7 @@ void lv_img_set_pivot(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     if(img->pivot.x == x && img->pivot.y == y) return;
 
     lv_coord_t transf_zoom = lv_obj_get_style_transform_zoom(obj, LV_PART_MAIN);
-    transf_zoom = (transf_zoom * img->zoom) >> 8;
+    transf_zoom = ((int32_t)transf_zoom * img->zoom) >> 8;
 
     lv_coord_t transf_angle = lv_obj_get_style_transform_angle(obj, LV_PART_MAIN);
     transf_angle += img->angle;
@@ -251,7 +251,7 @@ void lv_img_set_pivot(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
 
 void lv_img_set_zoom(lv_obj_t * obj, uint16_t zoom)
 {
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
     if(zoom == img->zoom) return;
 
     if(zoom == 0) zoom = 1;
@@ -264,7 +264,7 @@ void lv_img_set_zoom(lv_obj_t * obj, uint16_t zoom)
     lv_coord_t w = lv_obj_get_width(obj);
     lv_coord_t h = lv_obj_get_height(obj);
     lv_area_t a;
-    _lv_img_buf_get_transformed_area(&a, w, h, transf_angle, (transf_zoom * img->zoom) >> 8, &img->pivot);
+    _lv_img_buf_get_transformed_area(&a, w, h, transf_angle, ((int32_t)transf_zoom * img->zoom) >> 8, &img->pivot);
     a.x1 += obj->coords.x1 - 1;
     a.y1 += obj->coords.y1 - 1;
     a.x2 += obj->coords.x1 + 1;
@@ -274,7 +274,7 @@ void lv_img_set_zoom(lv_obj_t * obj, uint16_t zoom)
     img->zoom = zoom;
     lv_obj_refresh_ext_draw_size(obj);
 
-    _lv_img_buf_get_transformed_area(&a, w, h, transf_angle, (transf_zoom * img->zoom) >> 8, &img->pivot);
+    _lv_img_buf_get_transformed_area(&a, w, h, transf_angle, ((int32_t)transf_zoom * img->zoom) >> 8, &img->pivot);
     a.x1 += obj->coords.x1 - 1;
     a.y1 += obj->coords.y1 - 1;
     a.x2 += obj->coords.x1 + 1;
@@ -284,13 +284,23 @@ void lv_img_set_zoom(lv_obj_t * obj, uint16_t zoom)
 
 void lv_img_set_antialias(lv_obj_t * obj, bool antialias)
 {
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
     if(antialias == img->antialias) return;
 
     img->antialias = antialias;
     lv_obj_invalidate(obj);
 }
 
+void lv_img_set_size_mode(lv_obj_t * obj, lv_img_size_mode_t mode)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_img_t * img = (lv_img_t *)obj;
+    if(mode == img->obj_size_mode) return;
+
+    img->obj_size_mode = mode;
+    lv_obj_invalidate(obj);
+}
+
 /*=====================
  * Getter functions
  *====================*/
@@ -299,7 +309,7 @@ const void * lv_img_get_src(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     return img->src;
 }
@@ -308,7 +318,7 @@ lv_coord_t lv_img_get_offset_x(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     return img->offset.x;
 }
@@ -317,7 +327,7 @@ lv_coord_t lv_img_get_offset_y(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     return img->offset.y;
 }
@@ -326,7 +336,7 @@ uint16_t lv_img_get_angle(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     return img->angle;
 }
@@ -335,7 +345,7 @@ void lv_img_get_pivot(lv_obj_t * obj, lv_point_t * pivot)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     *pivot = img->pivot;
 }
@@ -344,7 +354,7 @@ uint16_t lv_img_get_zoom(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     return img->zoom;
 }
@@ -353,11 +363,18 @@ bool lv_img_get_antialias(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-   lv_img_t * img = (lv_img_t *)obj;
+    lv_img_t * img = (lv_img_t *)obj;
 
     return img->antialias ? true : false;
 }
 
+lv_img_size_mode_t lv_img_get_size_mode(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_img_t * img = (lv_img_t *)obj;
+    return img->obj_size_mode;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -381,6 +398,7 @@ static void lv_img_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
     img->offset.y  = 0;
     img->pivot.x = 0;
     img->pivot.y = 0;
+    img->obj_size_mode = LV_IMG_SIZE_MODE_VIRTUAL;
 
     lv_obj_clear_flag(obj, LV_OBJ_FLAG_CLICKABLE);
     lv_obj_add_flag(obj, LV_OBJ_FLAG_ADV_HITTEST);
@@ -393,12 +411,30 @@ static void lv_img_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
     LV_UNUSED(class_p);
     lv_img_t * img = (lv_img_t *)obj;
     if(img->src_type == LV_IMG_SRC_FILE || img->src_type == LV_IMG_SRC_SYMBOL) {
-        lv_mem_free((void*)img->src);
+        lv_mem_free((void *)img->src);
         img->src      = NULL;
         img->src_type = LV_IMG_SRC_UNKNOWN;
     }
 }
 
+static lv_point_t lv_img_get_transformed_size(lv_obj_t * obj)
+{
+    lv_img_t * img = (lv_img_t *)obj;
+
+    int32_t zoom_final = lv_obj_get_style_transform_zoom(obj, LV_PART_MAIN);
+    zoom_final = (zoom_final * img->zoom) >> 8;
+    int32_t angle_final = lv_obj_get_style_transform_angle(obj, LV_PART_MAIN);
+    angle_final += img->angle;
+
+    lv_area_t area_transform;
+    _lv_img_buf_get_transformed_area(&area_transform, img->w, img->h,
+                                     angle_final, zoom_final, &img->pivot);
+
+    return (lv_point_t) {
+        lv_area_get_width(&area_transform), lv_area_get_height(&area_transform)
+    };
+}
+
 static void lv_img_event(const lv_obj_class_t * class_p, lv_event_t * e)
 {
     LV_UNUSED(class_p);
@@ -419,7 +455,8 @@ static void lv_img_event(const lv_obj_class_t * class_p, lv_event_t * e)
         /*Refresh the file name to refresh the symbol text size*/
         if(img->src_type == LV_IMG_SRC_SYMBOL) {
             lv_img_set_src(obj, img->src);
-        } else {
+        }
+        else {
             /*With transformation it might change*/
             lv_obj_refresh_ext_draw_size(obj);
         }
@@ -428,7 +465,7 @@ static void lv_img_event(const lv_obj_class_t * class_p, lv_event_t * e)
 
         lv_coord_t * s = lv_event_get_param(e);
         lv_coord_t transf_zoom = lv_obj_get_style_transform_zoom(obj, LV_PART_MAIN);
-        transf_zoom = (transf_zoom * img->zoom) >> 8;
+        transf_zoom = ((int32_t)transf_zoom * img->zoom) >> 8;
 
         lv_coord_t transf_angle = lv_obj_get_style_transform_angle(obj, LV_PART_MAIN);
         transf_angle += img->angle;
@@ -455,9 +492,9 @@ static void lv_img_event(const lv_obj_class_t * class_p, lv_event_t * e)
         angle += img->angle;
 
         /*If the object is exactly image sized (not cropped, not mosaic) and transformed
-         *perform hit test on it's transformed area*/
+         *perform hit test on its transformed area*/
         if(img->w == lv_obj_get_width(obj) && img->h == lv_obj_get_height(obj) &&
-                (zoom != LV_IMG_ZOOM_NONE || angle != 0 || img->pivot.x != img->w / 2 || img->pivot.y != img->h / 2)) {
+           (zoom != LV_IMG_ZOOM_NONE || angle != 0 || img->pivot.x != img->w / 2 || img->pivot.y != img->h / 2)) {
 
             lv_coord_t w = lv_obj_get_width(obj);
             lv_coord_t h = lv_obj_get_height(obj);
@@ -477,9 +514,14 @@ static void lv_img_event(const lv_obj_class_t * class_p, lv_event_t * e)
         }
     }
     else if(code == LV_EVENT_GET_SELF_SIZE) {
-        lv_point_t * p = lv_event_get_param(e);;
-        p->x = img->w;
-        p->y = img->h;
+        lv_point_t * p = lv_event_get_param(e);
+        if(img->obj_size_mode == LV_IMG_SIZE_MODE_REAL) {
+            *p = lv_img_get_transformed_size(obj);
+        }
+        else {
+            p->x = img->w;
+            p->y = img->h;
+        }
     }
     else if(code == LV_EVENT_DRAW_MAIN || code == LV_EVENT_DRAW_POST || code == LV_EVENT_COVER_CHECK) {
         draw_img(e);
@@ -564,14 +606,21 @@ static void draw_img(lv_event_t * e)
         bg_pivot.x = img->pivot.x + pleft;
         bg_pivot.y = img->pivot.y + ptop;
         lv_area_t bg_coords;
-        _lv_img_buf_get_transformed_area(&bg_coords, obj_w, obj_h,
-                angle_final, zoom_final, &bg_pivot);
 
-        /*Modify the coordinates to draw the background for the rotated and scaled coordinates*/
-        bg_coords.x1 += obj->coords.x1;
-        bg_coords.y1 += obj->coords.y1;
-        bg_coords.x2 += obj->coords.x1;
-        bg_coords.y2 += obj->coords.y1;
+        if(img->obj_size_mode == LV_IMG_SIZE_MODE_REAL) {
+            /*Object size equals to transformed image size*/
+            lv_obj_get_coords(obj, &bg_coords);
+        }
+        else {
+            _lv_img_buf_get_transformed_area(&bg_coords, obj_w, obj_h,
+                                             angle_final, zoom_final, &bg_pivot);
+
+            /*Modify the coordinates to draw the background for the rotated and scaled coordinates*/
+            bg_coords.x1 += obj->coords.x1;
+            bg_coords.y1 += obj->coords.y1;
+            bg_coords.x2 += obj->coords.x1;
+            bg_coords.y2 += obj->coords.y1;
+        }
 
         lv_area_t ori_coords;
         lv_area_copy(&ori_coords, &obj->coords);
@@ -590,6 +639,20 @@ static void draw_img(lv_event_t * e)
 
             lv_area_t img_max_area;
             lv_area_copy(&img_max_area, &obj->coords);
+
+            lv_point_t img_size_final = lv_img_get_transformed_size(obj);
+
+            if(img->obj_size_mode == LV_IMG_SIZE_MODE_REAL) {
+                img_max_area.x1 -= ((img->w - img_size_final.x) + 1) / 2;
+                img_max_area.x2 -= ((img->w - img_size_final.x) + 1) / 2;
+                img_max_area.y1 -= ((img->h - img_size_final.y) + 1) / 2;
+                img_max_area.y2 -= ((img->h - img_size_final.y) + 1) / 2;
+            }
+            else {
+                img_max_area.x2 = img_max_area.x1 + lv_area_get_width(&bg_coords) - 1;
+                img_max_area.y2 = img_max_area.y1 + lv_area_get_height(&bg_coords) - 1;
+            }
+
             img_max_area.x1 += pleft;
             img_max_area.y1 += ptop;
             img_max_area.x2 -= pright;
@@ -619,12 +682,12 @@ static void draw_img(lv_event_t * e)
                 if(coords_tmp.y1 > img_max_area.y1) coords_tmp.y1 -= img->h;
                 coords_tmp.y2 = coords_tmp.y1 + img->h - 1;
 
-                for(; coords_tmp.y1 < img_max_area.y2; coords_tmp.y1 += img->h, coords_tmp.y2 += img->h) {
+                for(; coords_tmp.y1 < img_max_area.y2; coords_tmp.y1 += img_size_final.y, coords_tmp.y2 += img_size_final.y) {
                     coords_tmp.x1 = img_max_area.x1 + img->offset.x;
                     if(coords_tmp.x1 > img_max_area.x1) coords_tmp.x1 -= img->w;
                     coords_tmp.x2 = coords_tmp.x1 + img->w - 1;
 
-                    for(; coords_tmp.x1 < img_max_area.x2; coords_tmp.x1 += img->w, coords_tmp.x2 += img->w) {
+                    for(; coords_tmp.x1 < img_max_area.x2; coords_tmp.x1 += img_size_final.x, coords_tmp.x2 += img_size_final.x) {
                         lv_draw_img(&coords_tmp, &img_clip_area, img->src, &img_dsc);
                     }
                 }
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_img.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_img.h
index f731eae91..cf96c717e 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_img.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_img.h
@@ -28,7 +28,10 @@ extern "C" {
 /**********************
  *      TYPEDEFS
  **********************/
-/*Data of image*/
+
+/**
+ * Data of image
+ */
 typedef struct {
     lv_obj_t obj;
     const void * src; /*Image source: Pointer to an array or a file or a symbol*/
@@ -41,10 +44,28 @@ typedef struct {
     uint8_t src_type : 2;  /*See: lv_img_src_t*/
     uint8_t cf : 5;        /*Color format from `lv_img_color_format_t`*/
     uint8_t antialias : 1; /*Apply anti-aliasing in transformations (rotate, zoom)*/
+    uint8_t obj_size_mode: 2; /*Image size mode when image size and object size is different.*/
 } lv_img_t;
 
 extern const lv_obj_class_t lv_img_class;
 
+/**
+ * Image size mode, when image size and object size is different
+ */
+enum {
+    /** Zoom doesn't affect the coordinates of the object,
+     *  however if zoomed in the image is drawn out of the its coordinates.
+     *  The layout's won't change on zoom */
+    LV_IMG_SIZE_MODE_VIRTUAL = 0,
+
+    /** If the object size is set to SIZE_CONTENT, then object size equals zoomed image size.
+     *  It causes layout recalculation.
+     *  If the object size is set explicitly the the image will be cropped if zoomed in.*/
+    LV_IMG_SIZE_MODE_REAL,
+};
+
+typedef uint8_t lv_img_size_mode_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
@@ -117,12 +138,19 @@ void lv_img_set_zoom(lv_obj_t * obj, uint16_t zoom);
 
 /**
  * Enable/disable anti-aliasing for the transformations (rotate, zoom) or not.
- * The qualitiy is better with anti-aliasing looks better but slower.
+ * The quality is better with anti-aliasing looks better but slower.
  * @param obj       pointer to an image object
  * @param antialias true: anti-aliased; false: not anti-aliased
  */
 void lv_img_set_antialias(lv_obj_t * obj, bool antialias);
 
+/**
+ * Set the image object size mode.
+ *
+ * @param obj       pointer to an image object
+ * @param mode      the new size mode.
+ */
+void lv_img_set_size_mode(lv_obj_t * obj, lv_img_size_mode_t mode);
 /*=====================
  * Getter functions
  *====================*/
@@ -176,6 +204,13 @@ uint16_t lv_img_get_zoom(lv_obj_t * obj);
  */
 bool lv_img_get_antialias(lv_obj_t * obj);
 
+/**
+ * Get the size mode of the image
+ * @param obj       pointer to an image object
+ * @return          element of @ref lv_img_size_mode_t
+ */
+lv_img_size_mode_t lv_img_get_size_mode(lv_obj_t * obj);
+
 /**********************
  *      MACROS
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_label.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_label.c
index c71b74ada..39161fb88 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_label.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_label.c
@@ -72,7 +72,7 @@ const lv_obj_class_t lv_label_class = {
 
 lv_obj_t * lv_label_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -144,7 +144,7 @@ void lv_label_set_text(lv_obj_t * obj, const char * text)
     lv_label_refr_text(obj);
 }
 
-LV_FORMAT_ATTRIBUTE(2, 3) void lv_label_set_text_fmt(lv_obj_t * obj, const char * fmt, ...)
+void lv_label_set_text_fmt(lv_obj_t * obj, const char * fmt, ...)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
     LV_ASSERT_NULL(fmt);
@@ -238,8 +238,8 @@ void lv_label_set_text_sel_start(lv_obj_t * obj, uint32_t index)
     label->sel_start   = index;
     lv_obj_invalidate(obj);
 #else
-    (void)obj;    /*Unused*/
-    (void)index;    /*Unused*/
+    LV_UNUSED(obj);    /*Unused*/
+    LV_UNUSED(index);  /*Unused*/
 #endif
 }
 
@@ -252,8 +252,8 @@ void lv_label_set_text_sel_end(lv_obj_t * obj, uint32_t index)
     label->sel_end     = index;
     lv_obj_invalidate(obj);
 #else
-    (void)obj;    /*Unused*/
-    (void)index;    /*Unused*/
+    LV_UNUSED(obj);   /*Unused*/
+    LV_UNUSED(index); /*Unused*/
 #endif
 }
 
@@ -288,12 +288,9 @@ void lv_label_get_letter_pos(const lv_obj_t * obj, uint32_t char_id, lv_point_t
     LV_ASSERT_OBJ(obj, MY_CLASS);
     LV_ASSERT_NULL(pos);
 
+    lv_label_t * label = (lv_label_t *)obj;
     const char * txt         = lv_label_get_text(obj);
-    lv_text_align_t align = lv_obj_get_style_text_align(obj, LV_PART_MAIN);
-    if(align == LV_TEXT_ALIGN_AUTO) {
-       if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_TEXT_ALIGN_RIGHT;
-       else align = LV_TEXT_ALIGN_LEFT;
-    }
+    lv_text_align_t align = lv_obj_calculate_style_text_align(obj, LV_PART_MAIN, txt);
 
     if(txt[0] == '\0') {
         pos->y = 0;
@@ -314,7 +311,6 @@ void lv_label_get_letter_pos(const lv_obj_t * obj, uint32_t char_id, lv_point_t
     lv_area_t txt_coords;
     lv_obj_get_content_coords(obj, &txt_coords);
 
-    lv_label_t * label = (lv_label_t *)obj;
     uint32_t line_start      = 0;
     uint32_t new_line_start  = 0;
     lv_coord_t max_w         = lv_area_get_width(&txt_coords);
@@ -352,10 +348,13 @@ void lv_label_get_letter_pos(const lv_obj_t * obj, uint32_t char_id, lv_point_t
     const char * bidi_txt;
     uint32_t visual_byte_pos;
 #if LV_USE_BIDI
+    lv_base_dir_t base_dir = lv_obj_get_style_base_dir(obj, LV_PART_MAIN);
+    if(base_dir == LV_BASE_DIR_AUTO) base_dir = _lv_bidi_detect_base_dir(txt);
+
     char * mutable_bidi_txt = NULL;
     /*Handle Bidi*/
     if(new_line_start == byte_id) {
-        visual_byte_pos = byte_id - line_start;
+        visual_byte_pos = base_dir == LV_BASE_DIR_RTL ? 0 : byte_id - line_start;
         bidi_txt =  &txt[line_start];
     }
     else {
@@ -363,7 +362,7 @@ void lv_label_get_letter_pos(const lv_obj_t * obj, uint32_t char_id, lv_point_t
 
         bool is_rtl;
         uint32_t visual_char_pos = _lv_bidi_get_visual_pos(&txt[line_start], &mutable_bidi_txt, new_line_start - line_start,
-                                    lv_obj_get_style_base_dir(obj, LV_PART_MAIN), line_char_id, &is_rtl);
+                                                           base_dir, line_char_id, &is_rtl);
         bidi_txt = mutable_bidi_txt;
         if(is_rtl) visual_char_pos++;
 
@@ -427,11 +426,7 @@ uint32_t lv_label_get_letter_on(const lv_obj_t * obj, lv_point_t * pos_in)
     if(label->expand != 0) flag |= LV_TEXT_FLAG_EXPAND;
     if(lv_obj_get_style_width(obj, LV_PART_MAIN) == LV_SIZE_CONTENT && !obj->w_layout) flag |= LV_TEXT_FLAG_FIT;
 
-    lv_text_align_t align = lv_obj_get_style_text_align(obj, LV_PART_MAIN);
-    if(align == LV_TEXT_ALIGN_AUTO) {
-       if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_TEXT_ALIGN_RIGHT;
-       else align = LV_TEXT_ALIGN_LEFT;
-    }
+    lv_text_align_t align = lv_obj_calculate_style_text_align(obj, LV_PART_MAIN, label->text);
 
     /*Search the line of the index letter*/;
     while(txt[line_start] != '\0') {
@@ -489,7 +484,7 @@ uint32_t lv_label_get_letter_on(const lv_obj_t * obj, lv_point_t * pos_in)
             /*Handle the recolor command*/
             if((flag & LV_TEXT_FLAG_RECOLOR) != 0) {
                 if(_lv_txt_is_cmd(&cmd_state, bidi_txt[i]) != false) {
-                    continue; /*Skip the letter is it is part of a command*/
+                    continue; /*Skip the letter if it is part of a command*/
                 }
             }
 
@@ -509,7 +504,7 @@ uint32_t lv_label_get_letter_on(const lv_obj_t * obj, lv_point_t * pos_in)
 #if LV_USE_BIDI
     /*Handle Bidi*/
     uint32_t cid = _lv_txt_encoded_get_char_id(bidi_txt, i);
-    if(txt[line_start + cid] == '\0') {
+    if(txt[line_start + i] == '\0') {
         logical_pos = i;
     }
     else {
@@ -518,7 +513,7 @@ uint32_t lv_label_get_letter_on(const lv_obj_t * obj, lv_point_t * pos_in)
                                                txt_len, lv_obj_get_style_base_dir(obj, LV_PART_MAIN), cid, &is_rtl);
         if(is_rtl) logical_pos++;
     }
-	lv_mem_buf_release(bidi_txt);
+    lv_mem_buf_release(bidi_txt);
 #else
     logical_pos = _lv_txt_encoded_get_char_id(bidi_txt, i);
 #endif
@@ -534,7 +529,7 @@ bool lv_label_is_char_under_pos(const lv_obj_t * obj, lv_point_t * pos)
     lv_area_t txt_coords;
     lv_obj_get_content_coords(obj, &txt_coords);
     const char * txt         = lv_label_get_text(obj);
-    lv_label_t * label     = (lv_label_t*)obj;
+    lv_label_t * label     = (lv_label_t *)obj;
     uint32_t line_start      = 0;
     uint32_t new_line_start  = 0;
     lv_coord_t max_w         = lv_area_get_width(&txt_coords);
@@ -542,11 +537,7 @@ bool lv_label_is_char_under_pos(const lv_obj_t * obj, lv_point_t * pos)
     lv_coord_t line_space = lv_obj_get_style_text_line_space(obj, LV_PART_MAIN);
     lv_coord_t letter_space = lv_obj_get_style_text_letter_space(obj, LV_PART_MAIN);
     lv_coord_t letter_height    = lv_font_get_line_height(font);
-    lv_text_align_t align = lv_obj_get_style_text_align(obj, LV_PART_MAIN);
-    if(align == LV_TEXT_ALIGN_AUTO) {
-       if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_TEXT_ALIGN_RIGHT;
-       else align = LV_TEXT_ALIGN_LEFT;
-    }
+    lv_text_align_t align = lv_obj_calculate_style_text_align(obj, LV_PART_MAIN, label->text);
 
     lv_coord_t y             = 0;
     lv_text_flag_t flag       = LV_TEXT_FLAG_NONE;
@@ -595,7 +586,7 @@ bool lv_label_is_char_under_pos(const lv_obj_t * obj, lv_point_t * pos)
             /*Handle the recolor command*/
             if((flag & LV_TEXT_FLAG_RECOLOR) != 0) {
                 if(_lv_txt_is_cmd(&cmd_state, txt[i]) != false) {
-                    continue; /*Skip the letter is it is part of a command*/
+                    continue; /*Skip the letter if it is part of a command*/
                 }
             }
             last_x = x;
@@ -622,7 +613,7 @@ uint32_t lv_label_get_text_selection_start(const lv_obj_t * obj)
     return label->sel_start;
 
 #else
-    (void)obj;    /*Unused*/
+    LV_UNUSED(obj); /*Unused*/
     return LV_LABEL_TEXT_SELECTION_OFF;
 #endif
 }
@@ -635,7 +626,7 @@ uint32_t lv_label_get_text_selection_end(const lv_obj_t * obj)
     lv_label_t * label = (lv_label_t *)obj;
     return label->sel_end;
 #else
-    (void)obj; /*Unused*/
+    LV_UNUSED(obj); /*Unused*/
     return LV_LABEL_TEXT_SELECTION_OFF;
 #endif
 }
@@ -668,18 +659,7 @@ void lv_label_ins_text(lv_obj_t * obj, uint32_t pos, const char * txt)
         pos = _lv_txt_get_encoded_length(label->text);
     }
 
-#if LV_USE_BIDI
-    char * bidi_buf = lv_mem_buf_get(ins_len + 1);
-    LV_ASSERT_MALLOC(bidi_buf);
-    if(bidi_buf == NULL) return;
-
-    _lv_bidi_process(txt, bidi_buf, lv_obj_get_style_base_dir(obj, LV_PART_MAIN));
-    _lv_txt_ins(label->text, pos, bidi_buf);
-
-    lv_mem_buf_release(bidi_buf);
-#else
     _lv_txt_ins(label->text, pos, txt);
-#endif
     lv_label_set_text(obj, NULL);
 }
 
@@ -701,7 +681,6 @@ void lv_label_cut_text(lv_obj_t * obj, uint32_t pos, uint32_t cnt)
     lv_label_refr_text(obj);
 }
 
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -770,6 +749,15 @@ static void lv_label_event(const lv_obj_class_t * class_p, lv_event_t * e)
         lv_label_revert_dots(obj);
         lv_label_refr_text(obj);
     }
+    else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
+        /* Italic or other non-typical letters can be drawn of out of the object.
+         * It happens if box_w + ofs_x > adw_w in the glyph.
+         * To avoid this add some extra draw area.
+         * font_h / 4 is an empirical value. */
+        const lv_font_t * font = lv_obj_get_style_text_font(obj, LV_PART_MAIN);
+        lv_coord_t font_h = lv_font_get_line_height(font);
+        lv_event_set_ext_draw_size(e, font_h / 4);
+    }
     else if(code == LV_EVENT_SIZE_CHANGED) {
         lv_label_revert_dots(obj);
         lv_label_refr_text(obj);
@@ -809,11 +797,6 @@ static void draw_main(lv_event_t * e)
     lv_area_t txt_coords;
     lv_obj_get_content_coords(obj, &txt_coords);
 
-    lv_text_align_t align = lv_obj_get_style_text_align(obj, LV_PART_MAIN);
-    if(align == LV_TEXT_ALIGN_AUTO) {
-       if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_TEXT_ALIGN_RIGHT;
-       else align = LV_TEXT_ALIGN_LEFT;
-    }
     lv_text_flag_t flag = LV_TEXT_FLAG_NONE;
     if(label->recolor != 0) flag |= LV_TEXT_FLAG_RECOLOR;
     if(label->expand != 0) flag |= LV_TEXT_FLAG_EXPAND;
@@ -827,6 +810,7 @@ static void draw_main(lv_event_t * e)
 
     label_draw_dsc.flag = flag;
     lv_obj_init_draw_label_dsc(obj, LV_PART_MAIN, &label_draw_dsc);
+    lv_bidi_calculate_align(&label_draw_dsc.align, &label_draw_dsc.bidi_dir, label->text);
 
     label_draw_dsc.sel_start = lv_label_get_text_selection_start(obj);
     label_draw_dsc.sel_end = lv_label_get_text_selection_end(obj);
@@ -838,10 +822,10 @@ static void draw_main(lv_event_t * e)
     /* In SROLL and SROLL_CIRC mode the CENTER and RIGHT are pointless so remove them.
      * (In addition they will result misalignment is this case)*/
     if((label->long_mode == LV_LABEL_LONG_SCROLL || label->long_mode == LV_LABEL_LONG_SCROLL_CIRCULAR) &&
-       (align == LV_TEXT_ALIGN_CENTER || align == LV_TEXT_ALIGN_RIGHT)) {
+       (label_draw_dsc.align == LV_TEXT_ALIGN_CENTER || label_draw_dsc.align == LV_TEXT_ALIGN_RIGHT)) {
         lv_point_t size;
         lv_txt_get_size(&size, label->text, label_draw_dsc.font, label_draw_dsc.letter_space, label_draw_dsc.line_space,
-                         LV_COORD_MAX, flag);
+                        LV_COORD_MAX, flag);
         if(size.x > lv_area_get_width(&txt_coords)) {
             label_draw_dsc.align = LV_TEXT_ALIGN_LEFT;
         }
@@ -866,14 +850,18 @@ static void draw_main(lv_event_t * e)
         txt_coords.y2 = obj->coords.y2;
     }
 
-    lv_draw_label(&txt_coords, &txt_clip, &label_draw_dsc, label->text, hint);
+    if(label->long_mode == LV_LABEL_LONG_SCROLL || label->long_mode == LV_LABEL_LONG_SCROLL_CIRCULAR) {
+        lv_draw_label(&txt_coords, &txt_clip, &label_draw_dsc, label->text, hint);
+    } else {
+        lv_draw_label(&txt_coords, clip_area, &label_draw_dsc, label->text, hint);
+    }
 
     if(label->long_mode == LV_LABEL_LONG_SCROLL_CIRCULAR) {
         lv_point_t size;
         lv_txt_get_size(&size, label->text, label_draw_dsc.font, label_draw_dsc.letter_space, label_draw_dsc.line_space,
-                         LV_COORD_MAX, flag);
+                        LV_COORD_MAX, flag);
 
-        /*Draw the text again on label to the original to make an circular effect */
+        /*Draw the text again on label to the original to make a circular effect */
         if(size.x > lv_area_get_width(&txt_coords)) {
             label_draw_dsc.ofs_x = label->offset.x + size.x +
                                    lv_font_get_glyph_width(label_draw_dsc.font, ' ', ' ') * LV_LABEL_WAIT_CHAR_COUNT;
@@ -882,7 +870,7 @@ static void draw_main(lv_event_t * e)
             lv_draw_label(&txt_coords, &txt_clip, &label_draw_dsc, label->text, hint);
         }
 
-        /*Draw the text again below the original to make an circular effect */
+        /*Draw the text again below the original to make a circular effect */
         if(size.y > lv_area_get_height(&txt_coords)) {
             label_draw_dsc.ofs_x = label->offset.x;
             label_draw_dsc.ofs_y = label->offset.y + size.y + lv_font_get_line_height(label_draw_dsc.font);
@@ -893,7 +881,7 @@ static void draw_main(lv_event_t * e)
 }
 
 /**
- * Refresh the label with its text stored in its labelended data
+ * Refresh the label with its text stored in its extended data
  * @param label pointer to a label object
  */
 static void lv_label_refr_text(lv_obj_t * obj)
@@ -939,7 +927,7 @@ static void lv_label_refr_text(lv_obj_t * obj)
             int32_t start, end;
             lv_base_dir_t base_dir = lv_obj_get_style_base_dir(obj, LV_PART_MAIN);
 
-            if (base_dir == LV_BASE_DIR_AUTO)
+            if(base_dir == LV_BASE_DIR_AUTO)
                 base_dir = _lv_bidi_detect_base_dir(label->text);
 
             if(base_dir == LV_BASE_DIR_RTL) {
@@ -1038,7 +1026,7 @@ static void lv_label_refr_text(lv_obj_t * obj)
             int32_t start, end;
             lv_base_dir_t base_dir = lv_obj_get_style_base_dir(obj, LV_PART_MAIN);
 
-            if (base_dir == LV_BASE_DIR_AUTO)
+            if(base_dir == LV_BASE_DIR_AUTO)
                 base_dir = _lv_bidi_detect_base_dir(label->text);
 
             if(base_dir == LV_BASE_DIR_RTL) {
@@ -1131,10 +1119,13 @@ static void lv_label_refr_text(lv_obj_t * obj)
             /*Save letters under the dots and replace them with dots*/
             uint32_t byte_id_ori = byte_id;
             uint32_t i;
-            uint8_t len          = 0;
+            uint8_t len = 0;
             for(i = 0; i <= LV_LABEL_DOT_NUM; i++) {
                 len += _lv_txt_encoded_size(&label->text[byte_id]);
                 _lv_txt_encoded_next(label->text, &byte_id);
+                if (len > LV_LABEL_DOT_NUM || byte_id > txt_len) {
+                    break;
+                }
             }
 
             if(lv_label_set_dot_tmp(obj, &label->text[byte_id_ori], len)) {
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_label.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_label.h
index aac7d0b8c..b9a0e5013 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_label.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_label.h
@@ -64,7 +64,8 @@ typedef struct {
 #endif
 
 #if LV_LABEL_TEXT_SELECTION
-    uint32_t sel_start; uint32_t sel_end;
+    uint32_t sel_start;
+    uint32_t sel_end;
 #endif
 
     lv_point_t offset; /*Text draw position offset*/
@@ -73,7 +74,7 @@ typedef struct {
     uint8_t recolor : 1;                /*Enable in-line letter re-coloring*/
     uint8_t expand : 1;                 /*Ignore real width (used by the library with LV_LABEL_LONG_SROLL)*/
     uint8_t dot_tmp_alloc : 1; /*1: dot_tmp has been allocated;.0: dot_tmp directly holds up to 4 bytes of characters*/
-}lv_label_t;
+} lv_label_t;
 
 extern const lv_obj_class_t lv_label_class;
 
@@ -83,7 +84,7 @@ extern const lv_obj_class_t lv_label_class;
 
 /**
  * Create a label objects
- * @param parent    pointer to an object, it will be the parent of the new labely.
+ * @param parent    pointer to an object, it will be the parent of the new label.
  * @return          pointer to the created button
  */
 lv_obj_t * lv_label_create(lv_obj_t * parent);
@@ -109,7 +110,7 @@ void lv_label_set_text_fmt(lv_obj_t * obj, const char * fmt, ...) LV_FORMAT_ATTR
 
 /**
  * Set a static text. It will not be saved by the label so the 'text' variable
- * has to be 'alive' while the label exist.
+ * has to be 'alive' while the label exists.
  * @param label         pointer to a label object
  * @param text          pointer to a text. NULL to refresh with the current text.
  */
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_line.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_line.c
index 016882986..e73e6e89e 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_line.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_line.c
@@ -53,7 +53,7 @@ const lv_obj_class_t lv_line_class = {
 
 lv_obj_t * lv_line_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -159,7 +159,8 @@ static void lv_line_event(const lv_obj_class_t * class_p, lv_event_t * e)
             p->x = w;
             p->y = h;
         }
-    } else if(code == LV_EVENT_DRAW_MAIN) {
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
         lv_line_t * line = (lv_line_t *)obj;
         const lv_area_t * clip_area = lv_event_get_param(e);
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_objx_templ.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_objx_templ.c
index c7ef2a578..91565466a 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_objx_templ.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_objx_templ.c
@@ -5,7 +5,7 @@
 
 /**
  * TODO Remove these instructions
- * Search an replace: templ -> object short name with lower case(e.g. btn, label etc)
+ * Search and replace: templ -> object short name with lower case(e.g. btn, label etc)
  *                    TEMPL -> object short name with upper case (e.g. BTN, LABEL etc.)
  *
  * You can remove the defined() clause from the #if statement below. This exists because
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_objx_templ.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_objx_templ.h
index 9084f81c1..b7149bca8 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_objx_templ.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_objx_templ.h
@@ -5,7 +5,7 @@
 
 /**
  * TODO Remove these instructions
- * Search an replace: templ -> object short name with lower case(e.g. btn, label etc)
+ * Search and replace: templ -> object short name with lower case(e.g. btn, label etc)
  *                    TEMPL -> object short name with upper case (e.g. BTN, LABEL etc.)
  *
  */
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_roller.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_roller.c
index 05bc450fd..fa558782d 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_roller.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_roller.c
@@ -46,21 +46,21 @@ static void set_y_anim(void * obj, int32_t v);
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_roller_class = {
-        .constructor_cb = lv_roller_constructor,
-        .event_cb = lv_roller_event,
-        .width_def = LV_SIZE_CONTENT,
-        .height_def = LV_DPI_DEF,
-        .instance_size = sizeof(lv_roller_t),
-        .editable = LV_OBJ_CLASS_EDITABLE_TRUE,
-        .group_def = LV_OBJ_CLASS_GROUP_DEF_TRUE,
-        .base_class = &lv_obj_class
+    .constructor_cb = lv_roller_constructor,
+    .event_cb = lv_roller_event,
+    .width_def = LV_SIZE_CONTENT,
+    .height_def = LV_DPI_DEF,
+    .instance_size = sizeof(lv_roller_t),
+    .editable = LV_OBJ_CLASS_EDITABLE_TRUE,
+    .group_def = LV_OBJ_CLASS_GROUP_DEF_TRUE,
+    .base_class = &lv_obj_class
 };
 
 const lv_obj_class_t lv_roller_label_class  = {
-        .event_cb = lv_roller_label_event,
-        .instance_size = sizeof(lv_label_t),
-        .base_class = &lv_label_class
-    };
+    .event_cb = lv_roller_label_event,
+    .instance_size = sizeof(lv_label_t),
+    .base_class = &lv_label_class
+};
 
 /**********************
  *      MACROS
@@ -77,7 +77,7 @@ const lv_obj_class_t lv_roller_label_class  = {
  */
 lv_obj_t * lv_roller_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -98,7 +98,7 @@ void lv_roller_set_options(lv_obj_t * obj, const char * options, lv_roller_mode_
     LV_ASSERT_OBJ(obj, MY_CLASS);
     LV_ASSERT_NULL(options);
 
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
     lv_obj_t * label = get_label(obj);
 
     roller->sel_opt_id     = 0;
@@ -157,7 +157,7 @@ void lv_roller_set_selected(lv_obj_t * obj, uint16_t sel_opt, lv_anim_enable_t a
      *if moving to the next option with an animation which was just deleted in the PRESS Call the ancestor's event handler
      *nothing will continue the animation.*/
 
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
 
     /*In infinite mode interpret the new ID relative to the currently visible "page"*/
     if(roller->mode == LV_ROLLER_MODE_INFINITE) {
@@ -208,7 +208,7 @@ uint16_t lv_roller_get_selected(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
     if(roller->mode == LV_ROLLER_MODE_INFINITE) {
         uint16_t real_id_cnt = roller->option_cnt / LV_ROLLER_INF_PAGES;
         return roller->sel_opt_id % real_id_cnt;
@@ -228,7 +228,7 @@ void lv_roller_get_selected_str(const lv_obj_t * obj, char * buf, uint32_t buf_s
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
     lv_obj_t * label = get_label(obj);
     uint32_t i;
     uint16_t line        = 0;
@@ -242,7 +242,7 @@ void lv_roller_get_selected_str(const lv_obj_t * obj, char * buf, uint32_t buf_s
     uint32_t c;
     for(c = 0; i < txt_len && opt_txt[i] != '\n'; c++, i++) {
         if(buf_size && c >= buf_size - 1) {
-            LV_LOG_WARN("lv_dropdown_get_selected_str: the buffer was too small")
+            LV_LOG_WARN("lv_dropdown_get_selected_str: the buffer was too small");
             break;
         }
         buf[c] = opt_txt[i];
@@ -274,7 +274,7 @@ uint16_t lv_roller_get_option_cnt(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
     if(roller->mode == LV_ROLLER_MODE_INFINITE) {
         return roller->option_cnt / LV_ROLLER_INF_PAGES;
     }
@@ -291,7 +291,7 @@ uint16_t lv_roller_get_option_cnt(const lv_obj_t * obj)
 static void lv_roller_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
 {
     LV_UNUSED(class_p);
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
 
     roller->mode = LV_ROLLER_MODE_NORMAL;
     roller->option_cnt = 0;
@@ -301,7 +301,7 @@ static void lv_roller_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj
     lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLLABLE);
     lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLL_CHAIN);
 
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * label = lv_obj_class_create_obj(&lv_roller_label_class, obj);
     lv_obj_class_init_obj(label);
     lv_roller_set_options(obj, "Option 1\nOption 2\nOption 3\nOption 4\nOption 5", LV_ROLLER_MODE_NORMAL);
@@ -321,7 +321,7 @@ static void lv_roller_event(const lv_obj_class_t * class_p, lv_event_t * e)
 
     lv_event_code_t code = lv_event_get_code(e);
     lv_obj_t * obj = lv_event_get_target(e);
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
 
     if(code == LV_EVENT_GET_SELF_SIZE) {
         lv_point_t * p = lv_event_get_param(e);
@@ -478,12 +478,12 @@ static void draw_main(lv_event_t * e)
             /*Get the size of the "selected text"*/
             lv_point_t res_p;
             lv_txt_get_size(&res_p, lv_label_get_text(label), label_dsc.font, label_dsc.letter_space, label_dsc.line_space,
-                             lv_obj_get_width(obj), LV_TEXT_FLAG_EXPAND);
+                            lv_obj_get_width(obj), LV_TEXT_FLAG_EXPAND);
 
             /*Move the selected label proportionally with the background label*/
             lv_coord_t roller_h = lv_obj_get_height(obj);
             int32_t label_y_prop = label->coords.y1 - (roller_h / 2 +
-                    obj->coords.y1); /*label offset from the middle line of the roller*/
+                                                       obj->coords.y1); /*label offset from the middle line of the roller*/
             label_y_prop = (label_y_prop * 16384) / lv_obj_get_height(
                                label); /*Proportional position from the middle line (upscaled by << 14)*/
 
@@ -575,25 +575,21 @@ static void refr_position(lv_obj_t * obj, lv_anim_enable_t anim_en)
     lv_obj_t * label = get_label(obj);
     if(label == NULL) return;
 
-    lv_text_align_t align = lv_obj_get_style_text_align(label, LV_PART_MAIN);
-    if(align == LV_TEXT_ALIGN_AUTO) {
-        if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_TEXT_ALIGN_RIGHT;
-        else align = LV_TEXT_ALIGN_LEFT;
-    }
+    lv_text_align_t align = lv_obj_calculate_style_text_align(label, LV_PART_MAIN, lv_label_get_text(label));
 
     switch(align) {
-    case LV_TEXT_ALIGN_CENTER:
-        lv_obj_set_x(label, (lv_obj_get_content_width(obj) - lv_obj_get_width(label)) / 2);
-        break;
-    case LV_TEXT_ALIGN_RIGHT:
-        lv_obj_set_x(label, lv_obj_get_content_width(obj) - lv_obj_get_width(label));
-        break;
-    case LV_TEXT_ALIGN_LEFT:
-        lv_obj_set_x(label, 0);
-        break;
+        case LV_TEXT_ALIGN_CENTER:
+            lv_obj_set_x(label, (lv_obj_get_content_width(obj) - lv_obj_get_width(label)) / 2);
+            break;
+        case LV_TEXT_ALIGN_RIGHT:
+            lv_obj_set_x(label, lv_obj_get_content_width(obj) - lv_obj_get_width(label));
+            break;
+        case LV_TEXT_ALIGN_LEFT:
+            lv_obj_set_x(label, 0);
+            break;
     }
 
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
     const lv_font_t * font = lv_obj_get_style_text_font(obj, LV_PART_MAIN);
     lv_coord_t line_space = lv_obj_get_style_text_line_space(obj, LV_PART_MAIN);
     lv_coord_t font_h              = lv_font_get_line_height(font);
@@ -635,7 +631,7 @@ static lv_res_t release_handler(lv_obj_t * obj)
     if(label == NULL) return LV_RES_OK;
 
     lv_indev_t * indev = lv_indev_get_act();
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
 
     /*Leave edit mode once a new option is selected*/
     lv_indev_type_t indev_type = lv_indev_get_type(indev);
@@ -674,7 +670,8 @@ static lv_res_t release_handler(lv_obj_t * obj)
                 if(letter == '\n' && i_prev != letter_i) new_opt++;
                 i_prev = i;
             }
-        } else {
+        }
+        else {
             /*If dragged then align the list to have an element in the middle*/
             const lv_font_t * font = lv_obj_get_style_text_font(obj, LV_PART_MAIN);
             lv_coord_t line_space = lv_obj_get_style_text_line_space(obj, LV_PART_MAIN);
@@ -707,7 +704,7 @@ static lv_res_t release_handler(lv_obj_t * obj)
  */
 static void inf_normalize(lv_obj_t * obj)
 {
-    lv_roller_t * roller = (lv_roller_t*)obj;
+    lv_roller_t * roller = (lv_roller_t *)obj;
 
     if(roller->mode == LV_ROLLER_MODE_INFINITE) {
         uint16_t real_id_cnt = roller->option_cnt / LV_ROLLER_INF_PAGES;
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_roller.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_roller.h
index 24202734b..1520c4a57 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_roller.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_roller.h
@@ -37,13 +37,13 @@ enum {
 typedef uint8_t lv_roller_mode_t;
 
 typedef struct {
-  lv_obj_t obj;
-  uint16_t option_cnt;          /**< Number of options*/
-  uint16_t sel_opt_id;          /**< Index of the current option*/
-  uint16_t sel_opt_id_ori;      /**< Store the original index on focus*/
-  lv_roller_mode_t mode : 1;
-  uint32_t moved : 1;
-}lv_roller_t;
+    lv_obj_t obj;
+    uint16_t option_cnt;          /**< Number of options*/
+    uint16_t sel_opt_id;          /**< Index of the current option*/
+    uint16_t sel_opt_id_ori;      /**< Store the original index on focus*/
+    lv_roller_mode_t mode : 1;
+    uint32_t moved : 1;
+} lv_roller_t;
 
 extern const lv_obj_class_t lv_roller_class;
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_slider.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_slider.c
index 327fbb2ef..79b43719f 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_slider.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_slider.c
@@ -58,7 +58,7 @@ const lv_obj_class_t lv_slider_class = {
 
 lv_obj_t * lv_slider_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -134,11 +134,11 @@ static void lv_slider_event(const lv_obj_class_t * class_p, lv_event_t * e)
             lv_coord_t dist_left, dist_right;
             if(hor) {
                 if((base_dir != LV_BASE_DIR_RTL && p.x > slider->right_knob_area.x2) || (base_dir == LV_BASE_DIR_RTL &&
-                                                                                      p.x < slider->right_knob_area.x1)) {
+                                                                                         p.x < slider->right_knob_area.x1)) {
                     slider->value_to_set = &slider->bar.cur_value;
                 }
                 else if((base_dir != LV_BASE_DIR_RTL && p.x < slider->left_knob_area.x1) || (base_dir == LV_BASE_DIR_RTL &&
-                                                                                          p.x > slider->left_knob_area.x2)) {
+                                                                                             p.x > slider->left_knob_area.x2)) {
                     slider->value_to_set = &slider->bar.start_value;
                 }
                 else {
@@ -277,7 +277,7 @@ static void lv_slider_event(const lv_obj_class_t * class_p, lv_event_t * e)
     }
     else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
         lv_coord_t knob_left = lv_obj_get_style_pad_left(obj, LV_PART_KNOB);
-        lv_coord_t knob_right = lv_obj_get_style_pad_right(obj,LV_PART_KNOB);
+        lv_coord_t knob_right = lv_obj_get_style_pad_right(obj, LV_PART_KNOB);
         lv_coord_t knob_top = lv_obj_get_style_pad_top(obj, LV_PART_KNOB);
         lv_coord_t knob_bottom = lv_obj_get_style_pad_bottom(obj, LV_PART_KNOB);
 
@@ -313,7 +313,8 @@ static void lv_slider_event(const lv_obj_class_t * class_p, lv_event_t * e)
             res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, NULL);
             if(res != LV_RES_OK) return;
         }
-    } else if(code == LV_EVENT_DRAW_MAIN) {
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
         draw_knob(e);
     }
 }
@@ -370,25 +371,28 @@ static void draw_knob(lv_event_t * e)
     position_knob(obj, &knob_area, knob_size, hor);
     lv_area_copy(&slider->right_knob_area, &knob_area);
 
-    lv_obj_draw_part_dsc_t dsc;
-    lv_obj_draw_dsc_init(&dsc, clip_area);
-    dsc.part = LV_PART_KNOB;
-    dsc.id = 0;
-    dsc.draw_area = &slider->right_knob_area;
-    dsc.rect_dsc = &knob_rect_dsc;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, clip_area);
+    part_draw_dsc.part = LV_PART_KNOB;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_SLIDER_DRAW_PART_KNOB;
+    part_draw_dsc.id = 0;
+    part_draw_dsc.draw_area = &slider->right_knob_area;
+    part_draw_dsc.rect_dsc = &knob_rect_dsc;
 
     if(lv_slider_get_mode(obj) != LV_SLIDER_MODE_RANGE) {
-        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
         lv_draw_rect(&slider->right_knob_area, clip_area, &knob_rect_dsc);
-        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
-    } else {
-        /*Save the draw dsc. because it can be modified in the event*/
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
+    }
+    else {
+        /*Save the draw part_draw_dsc. because it can be modified in the event*/
         lv_draw_rect_dsc_t knob_rect_dsc_tmp;
         lv_memcpy(&knob_rect_dsc_tmp, &knob_rect_dsc, sizeof(lv_draw_rect_dsc_t));
 
-        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
         lv_draw_rect(&slider->right_knob_area, clip_area, &knob_rect_dsc);
-        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
 
         /*Draw a second knob for the start_value side*/
         if(hor) {
@@ -401,13 +405,14 @@ static void draw_knob(lv_event_t * e)
         lv_area_copy(&slider->left_knob_area, &knob_area);
 
         lv_memcpy(&knob_rect_dsc, &knob_rect_dsc_tmp, sizeof(lv_draw_rect_dsc_t));
-        dsc.draw_area = &slider->left_knob_area;
-        dsc.rect_dsc = &knob_rect_dsc;
-        dsc.id = 1;
+        part_draw_dsc.type = LV_SLIDER_DRAW_PART_KNOB_LEFT;
+        part_draw_dsc.draw_area = &slider->left_knob_area;
+        part_draw_dsc.rect_dsc = &knob_rect_dsc;
+        part_draw_dsc.id = 1;
 
-        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
         lv_draw_rect(&slider->left_knob_area, clip_area, &knob_rect_dsc);
-        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+        lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
     }
 }
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_slider.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_slider.h
index 2cf44d4c1..28b7543db 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_slider.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_slider.h
@@ -47,10 +47,19 @@ typedef struct {
     int32_t * value_to_set; /*Which bar value to set*/
     uint8_t dragging : 1;       /*1: the slider is being dragged*/
     uint8_t left_knob_focus : 1; /*1: with encoder now the right knob can be adjusted*/
-}lv_slider_t;
+} lv_slider_t;
 
 extern const lv_obj_class_t lv_slider_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_slider_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_SLIDER_DRAW_PART_KNOB,           /**< The main (right) knob's rectangle*/
+    LV_SLIDER_DRAW_PART_KNOB_LEFT,      /**< The left knob's rectangle*/
+} lv_slider_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_switch.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_switch.c
index 0a4b55bcf..7bc89512c 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_switch.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_switch.c
@@ -10,13 +10,9 @@
 
 #if LV_USE_SWITCH != 0
 
-/*Testing of dependencies*/
-#if LV_USE_SLIDER == 0
-    #error "lv_sw: lv_slider is required. Enable it in lv_conf.h (LV_USE_SLIDER 1)"
-#endif
-
 #include "../misc/lv_assert.h"
 #include "../misc/lv_math.h"
+#include "../misc/lv_anim.h"
 #include "../core/lv_indev.h"
 #include "../core/lv_disp.h"
 #include "lv_img.h"
@@ -26,6 +22,17 @@
  *********************/
 #define MY_CLASS &lv_switch_class
 
+#define LV_SWITCH_IS_ANIMATING(sw) (((sw)->anim_state) != LV_SWITCH_ANIM_STATE_INV)
+
+/** Switch animation start value. (Not the real value of the switch just indicates process animation)*/
+#define LV_SWITCH_ANIM_STATE_START 0
+
+/** Switch animation end value.  (Not the real value of the switch just indicates process animation)*/
+#define LV_SWITCH_ANIM_STATE_END   256
+
+/** Mark no animation is in progress*/
+#define LV_SWITCH_ANIM_STATE_INV   -1
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -34,16 +41,21 @@
  *  STATIC PROTOTYPES
  **********************/
 static void lv_switch_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
+static void lv_switch_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
 static void lv_switch_event(const lv_obj_class_t * class_p, lv_event_t * e);
 static void draw_main(lv_event_t * e);
 
+static void lv_switch_anim_exec_cb(void * sw, int32_t value);
+static void lv_switch_trigger_anim(lv_obj_t * obj);
+static void lv_switch_anim_ready(lv_anim_t * a);
 /**********************
  *  STATIC VARIABLES
  **********************/
 const lv_obj_class_t lv_switch_class = {
     .constructor_cb = lv_switch_constructor,
+    .destructor_cb = lv_switch_destructor,
     .event_cb = lv_switch_event,
-    .width_def =  (4 * LV_DPI_DEF) / 10,
+    .width_def = (4 * LV_DPI_DEF) / 10,
     .height_def = (4 * LV_DPI_DEF) / 17,
     .group_def = LV_OBJ_CLASS_GROUP_DEF_TRUE,
     .instance_size = sizeof(lv_switch_t),
@@ -60,7 +72,7 @@ const lv_obj_class_t lv_switch_class = {
 
 lv_obj_t * lv_switch_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -75,13 +87,24 @@ static void lv_switch_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj
     LV_UNUSED(class_p);
     LV_TRACE_OBJ_CREATE("begin");
 
-   lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLLABLE);
-   lv_obj_add_flag(obj, LV_OBJ_FLAG_CHECKABLE);
-   lv_obj_add_flag(obj, LV_OBJ_FLAG_SCROLL_ON_FOCUS);
+    lv_switch_t * sw = (lv_switch_t *)obj;
 
-   LV_TRACE_OBJ_CREATE("finished");
+    sw->anim_state = LV_SWITCH_ANIM_STATE_INV;
+
+    lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_add_flag(obj, LV_OBJ_FLAG_CHECKABLE);
+    lv_obj_add_flag(obj, LV_OBJ_FLAG_SCROLL_ON_FOCUS);
+
+    LV_TRACE_OBJ_CREATE("finished");
 }
 
+static void lv_switch_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
+{
+    LV_UNUSED(class_p);
+    lv_switch_t * sw = (lv_switch_t *)obj;
+
+    lv_anim_del(sw, NULL);
+}
 
 static void lv_switch_event(const lv_obj_class_t * class_p, lv_event_t * e)
 {
@@ -111,7 +134,8 @@ static void lv_switch_event(const lv_obj_class_t * class_p, lv_event_t * e)
         *s = LV_MAX(*s, knob_size);
         *s = LV_MAX(*s, lv_obj_calculate_ext_draw_size(obj, LV_PART_INDICATOR));
     }
-    else if(code == LV_EVENT_CLICKED) {
+    else if(code == LV_EVENT_VALUE_CHANGED) {
+        lv_switch_trigger_anim(obj);
         lv_obj_invalidate(obj);
     }
     else if(code == LV_EVENT_DRAW_MAIN) {
@@ -122,6 +146,8 @@ static void lv_switch_event(const lv_obj_class_t * class_p, lv_event_t * e)
 static void draw_main(lv_event_t * e)
 {
     lv_obj_t * obj = lv_event_get_target(e);
+    lv_switch_t * sw = (lv_switch_t *)obj;
+
     const lv_area_t * clip_area = lv_event_get_param(e);
     lv_base_dir_t base_dir = lv_obj_get_style_base_dir(obj, LV_PART_MAIN);
 
@@ -131,38 +157,47 @@ static void draw_main(lv_event_t * e)
     lv_coord_t bg_top = lv_obj_get_style_pad_top(obj,       LV_PART_MAIN);
     lv_coord_t bg_bottom = lv_obj_get_style_pad_bottom(obj, LV_PART_MAIN);
 
-    bool chk = lv_obj_get_state(obj) & LV_STATE_CHECKED;
-    /*Draw the indicator in checked state*/
-    if(chk) {
-        /*Respect the background's padding*/
-        lv_area_t indic_area;
-        lv_area_copy(&indic_area, &obj->coords);
-        indic_area.x1 += bg_left;
-        indic_area.x2 -= bg_right;
-        indic_area.y1 += bg_top;
-        indic_area.y2 -= bg_bottom;
+    /*Draw the indicator*/
+    /*Respect the background's padding*/
+    lv_area_t indic_area;
+    lv_area_copy(&indic_area, &obj->coords);
+    indic_area.x1 += bg_left;
+    indic_area.x2 -= bg_right;
+    indic_area.y1 += bg_top;
+    indic_area.y2 -= bg_bottom;
 
-        lv_draw_rect_dsc_t draw_indic_dsc;
-        lv_draw_rect_dsc_init(&draw_indic_dsc);
-        lv_obj_init_draw_rect_dsc(obj, LV_PART_INDICATOR, &draw_indic_dsc);
-        lv_draw_rect(&indic_area, clip_area, &draw_indic_dsc);
-    }
+    lv_draw_rect_dsc_t draw_indic_dsc;
+    lv_draw_rect_dsc_init(&draw_indic_dsc);
+    lv_obj_init_draw_rect_dsc(obj, LV_PART_INDICATOR, &draw_indic_dsc);
+    lv_draw_rect(&indic_area, clip_area, &draw_indic_dsc);
 
     /*Draw the knob*/
     lv_coord_t objh = lv_obj_get_height(obj);
     lv_coord_t knob_size = objh;
     lv_area_t knob_area;
 
-    /*Left*/
-    if((base_dir != LV_BASE_DIR_RTL && !chk) || (base_dir == LV_BASE_DIR_RTL && chk)) {
-        knob_area.x1 = obj->coords.x1 + bg_left;
-        knob_area.x2 = knob_area.x1 + knob_size;
+    lv_coord_t anim_length = obj->coords.x2 - bg_right - obj->coords.x1 - bg_left - knob_size;
+
+    lv_coord_t anim_value_x;
+
+    bool chk = lv_obj_get_state(obj) & LV_STATE_CHECKED;
+
+    if(LV_SWITCH_IS_ANIMATING(sw)) {
+        /* Use the animation's coordinate */
+        anim_value_x = (anim_length * sw->anim_state) / LV_SWITCH_ANIM_STATE_END;
     }
     else {
-        knob_area.x2 = obj->coords.x2 - bg_right;
-        knob_area.x1 = knob_area.x2 - knob_size;
+        /* Use LV_STATE_CHECKED to decide the coordinate */
+        anim_value_x = chk ? anim_length : 0;
     }
 
+    if(base_dir == LV_BASE_DIR_RTL) {
+        anim_value_x = anim_length - anim_value_x;
+    }
+
+    knob_area.x1 = obj->coords.x1 + bg_left + anim_value_x;
+    knob_area.x2 = knob_area.x1 + knob_size;
+
     knob_area.y1 = obj->coords.y1 + bg_top;
     knob_area.y2 = obj->coords.y2 - bg_bottom;
 
@@ -182,7 +217,66 @@ static void draw_main(lv_event_t * e)
     lv_obj_init_draw_rect_dsc(obj, LV_PART_KNOB, &knob_rect_dsc);
 
     lv_draw_rect(&knob_area, clip_area, &knob_rect_dsc);
-
 }
 
+static void lv_switch_anim_exec_cb(void * var, int32_t value)
+{
+    lv_switch_t * sw = var;
+    sw->anim_state = value;
+    lv_obj_invalidate((lv_obj_t *)sw);
+}
+
+/**
+ * Resets the switch's animation state to "no animation in progress".
+ */
+static void lv_switch_anim_ready(lv_anim_t * a)
+{
+    lv_switch_t * sw = a->var;
+    sw->anim_state = LV_SWITCH_ANIM_STATE_INV;
+    lv_obj_invalidate((lv_obj_t *)sw);
+}
+
+/**
+ * Starts an animation for the switch knob. if the anim_time style property is greater than 0
+ * @param obj the switch to animate
+ */
+static void lv_switch_trigger_anim(lv_obj_t * obj)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_switch_t * sw = (lv_switch_t *)obj;
+
+    uint32_t anim_dur_full = lv_obj_get_style_anim_time(obj, LV_PART_MAIN);
+
+    if(anim_dur_full > 0) {
+        bool chk = lv_obj_get_state(obj) & LV_STATE_CHECKED;
+        int32_t anim_start;
+        int32_t anim_end;
+        /*No animation in progress -> simply set the values*/
+        if(sw->anim_state == LV_SWITCH_ANIM_STATE_INV) {
+            anim_start = chk ? LV_SWITCH_ANIM_STATE_START : LV_SWITCH_ANIM_STATE_END;
+            anim_end   = chk ? LV_SWITCH_ANIM_STATE_END : LV_SWITCH_ANIM_STATE_START;
+        }
+        /*Animation in progress. Start from the animation end value*/
+        else {
+            anim_start = sw->anim_state;
+            anim_end   = chk ? LV_SWITCH_ANIM_STATE_END : LV_SWITCH_ANIM_STATE_START;
+        }
+        /*Calculate actual animation duration*/
+        uint32_t anim_dur = (anim_dur_full * LV_ABS(anim_start - anim_end)) / LV_SWITCH_ANIM_STATE_END;
+
+        /*Stop the previous animation if it exists*/
+        lv_anim_del(sw, NULL);
+
+        lv_anim_t a;
+        lv_anim_init(&a);
+        lv_anim_set_var(&a, sw);
+        lv_anim_set_exec_cb(&a, lv_switch_anim_exec_cb);
+        lv_anim_set_values(&a, anim_start, anim_end);
+        lv_anim_set_ready_cb(&a, lv_switch_anim_ready);
+        lv_anim_set_time(&a, anim_dur);
+        lv_anim_start(&a);
+    }
+}
+
+
 #endif
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_switch.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_switch.h
index 8ff92afb9..7d573f2af 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_switch.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_switch.h
@@ -17,11 +17,6 @@ extern "C" {
 
 #if LV_USE_SWITCH != 0
 
-/*Testing of dependencies*/
-#if LV_USE_SLIDER == 0
-#error "lv_switch: lv_slider is required. Enable it in lv_conf.h (LV_USE_SLIDER  1)"
-#endif
-
 #include "../core/lv_obj.h"
 
 /*********************
@@ -34,7 +29,8 @@ extern "C" {
 
 typedef struct {
     lv_obj_t obj;
-}lv_switch_t;
+    int32_t anim_state;
+} lv_switch_t;
 
 extern const lv_obj_class_t lv_switch_class;
 
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_table.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_table.c
index 283540cf5..a07c3249b 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_table.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_table.c
@@ -63,7 +63,7 @@ const lv_obj_class_t lv_table_class  = {
 
 lv_obj_t * lv_table_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -131,7 +131,7 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint16_t row, uint16_t col, con
     lv_table_cell_ctrl_t ctrl = 0;
 
     /*Save the control byte*/
-    if(table->cell_data[cell]) ctrl= table->cell_data[cell][0];
+    if(table->cell_data[cell]) ctrl = table->cell_data[cell][0];
 
     va_list ap, ap2;
     va_start(ap, fmt);
@@ -191,7 +191,7 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint16_t row, uint16_t col, con
     const lv_font_t * font = lv_obj_get_style_text_font(obj, LV_PART_ITEMS);
 
     lv_coord_t h = get_row_height(obj, row, font, letter_space, line_space,
-                                       cell_left, cell_right, cell_top, cell_bottom);
+                                  cell_left, cell_right, cell_top, cell_bottom);
 
 
     lv_coord_t minh = lv_obj_get_style_min_height(obj, LV_PART_ITEMS);
@@ -251,13 +251,13 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt)
 
     /*Free the unused cells*/
     if(old_col_cnt > col_cnt) {
-       uint16_t old_cell_cnt = old_col_cnt * table->row_cnt;
-       uint32_t new_cell_cnt = table->col_cnt * table->row_cnt;
-       uint32_t i;
-       for(i = new_cell_cnt; i < old_cell_cnt; i++) {
-           lv_mem_free(table->cell_data[i]);
-       }
-   }
+        uint16_t old_cell_cnt = old_col_cnt * table->row_cnt;
+        uint32_t new_cell_cnt = table->col_cnt * table->row_cnt;
+        uint32_t i;
+        for(i = new_cell_cnt; i < old_cell_cnt; i++) {
+            lv_mem_free(table->cell_data[i]);
+        }
+    }
 
     char ** new_cell_data = lv_mem_alloc(table->row_cnt * table->col_cnt * sizeof(char *));
     LV_ASSERT_MALLOC(new_cell_data);
@@ -282,7 +282,8 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt)
         old_col_start = row * old_col_cnt;
         new_col_start = row * col_cnt;
 
-        lv_memcpy_small(&new_cell_data[new_col_start], &table->cell_data[old_col_start], sizeof(new_cell_data[0]) * min_col_cnt);
+        lv_memcpy_small(&new_cell_data[new_col_start], &table->cell_data[old_col_start],
+                        sizeof(new_cell_data[0]) * min_col_cnt);
     }
 
     lv_mem_free(table->cell_data);
@@ -491,8 +492,8 @@ static void lv_table_event(const lv_obj_class_t * class_p, lv_event_t * e)
         lv_coord_t h = 0;
         for(i = 0; i < table->row_cnt; i++) h += table->row_h[i];
 
-        p->x = w;
-        p->y = h;
+        p->x = w - 1;
+        p->y = h - 1;
     }
     else if(code == LV_EVENT_PRESSED || code == LV_EVENT_PRESSING) {
         uint16_t col;
@@ -502,8 +503,8 @@ static void lv_table_event(const lv_obj_class_t * class_p, lv_event_t * e)
         if(pr_res == LV_RES_OK && (table->col_act != col || table->row_act != row)) {
             table->col_act = col;
             table->row_act = row;
+            lv_obj_invalidate(obj);
         }
-        lv_obj_invalidate(obj);
     }
     else if(code == LV_EVENT_RELEASED) {
         lv_obj_invalidate(obj);
@@ -522,7 +523,8 @@ static void lv_table_event(const lv_obj_class_t * class_p, lv_event_t * e)
     }
     else if(code == LV_EVENT_FOCUSED) {
         lv_obj_invalidate(obj);
-    } else if(code == LV_EVENT_KEY) {
+    }
+    else if(code == LV_EVENT_KEY) {
         int32_t c = *((int32_t *)lv_event_get_param(e));
         int32_t col = table->col_act;
         int32_t row = table->row_act;
@@ -546,21 +548,25 @@ static void lv_table_event(const lv_obj_class_t * class_p, lv_event_t * e)
             if(row < table->row_cnt - 1) {
                 col = 0;
                 row++;
-            } else {
+            }
+            else {
                 col = table->col_cnt - 1;
             }
-        } else if (col < 0) {
+        }
+        else if(col < 0) {
             if(row != 0) {
                 col = table->col_cnt - 1;
                 row--;
-            } else {
+            }
+            else {
                 col = 0;
             }
         }
 
         if(row >= table->row_cnt) {
             row = table->row_cnt - 1;
-        } else if(row < 0) {
+        }
+        else if(row < 0) {
             row = 0;
         }
 
@@ -572,7 +578,8 @@ static void lv_table_event(const lv_obj_class_t * class_p, lv_event_t * e)
             res = lv_event_send(obj, LV_EVENT_VALUE_CHANGED, NULL);
             if(res != LV_RES_OK) return;
         }
-    } else if(code == LV_EVENT_DRAW_MAIN) {
+    }
+    else if(code == LV_EVENT_DRAW_MAIN) {
         draw_main(e);
     }
 }
@@ -582,13 +589,16 @@ static void draw_main(lv_event_t * e)
 {
     lv_obj_t * obj = lv_event_get_target(e);
     lv_table_t * table = (lv_table_t *)obj;
-    const lv_area_t * clip_area = lv_event_get_param(e);
+    const lv_area_t * clip_area_ori = lv_event_get_param(e);
+    lv_area_t clip_area;
+    if(!_lv_area_intersect(&clip_area, &obj->coords, clip_area_ori)) return;
 
     lv_point_t txt_size;
     lv_area_t cell_area;
     lv_area_t txt_area;
     lv_text_flag_t txt_flags;
 
+    lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_MAIN);
     lv_coord_t bg_top = lv_obj_get_style_pad_top(obj, LV_PART_MAIN);
     lv_coord_t bg_bottom = lv_obj_get_style_pad_bottom(obj, LV_PART_MAIN);
     lv_coord_t bg_left = lv_obj_get_style_pad_left(obj, LV_PART_MAIN);
@@ -618,16 +628,18 @@ static void draw_main(lv_event_t * e)
     uint16_t row;
     uint16_t cell = 0;
 
-    cell_area.y2 = obj->coords.y1 + bg_top - 1 - lv_obj_get_scroll_y(obj) ;
+    cell_area.y2 = obj->coords.y1 + bg_top - 1 - lv_obj_get_scroll_y(obj) + border_width;
     lv_coord_t scroll_x = lv_obj_get_scroll_x(obj) ;
     bool rtl = lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL ? true : false;
 
     /*Handle custom drawer*/
-    lv_obj_draw_part_dsc_t dsc;
-    lv_obj_draw_dsc_init(&dsc, clip_area);
-    dsc.part = LV_PART_ITEMS;
-    dsc.rect_dsc = &rect_dsc_act;
-    dsc.label_dsc = &label_dsc_act;
+    lv_obj_draw_part_dsc_t part_draw_dsc;
+    lv_obj_draw_dsc_init(&part_draw_dsc, &clip_area);
+    part_draw_dsc.part = LV_PART_ITEMS;
+    part_draw_dsc.class_p = MY_CLASS;
+    part_draw_dsc.type = LV_TABLE_DRAW_PART_CELL;
+    part_draw_dsc.rect_dsc = &rect_dsc_act;
+    part_draw_dsc.label_dsc = &label_dsc_act;
 
     for(row = 0; row < table->row_cnt; row++) {
         lv_coord_t h_row = table->row_h[row];
@@ -635,10 +647,10 @@ static void draw_main(lv_event_t * e)
         cell_area.y1 = cell_area.y2 + 1;
         cell_area.y2 = cell_area.y1 + h_row - 1;
 
-        if(cell_area.y1 > clip_area->y2) return;
+        if(cell_area.y1 > clip_area.y2) return;
 
-        if(rtl) cell_area.x1 = obj->coords.x2 - bg_right - 1 - scroll_x;
-        else cell_area.x2 = obj->coords.x1 + bg_left - 1 - scroll_x;
+        if(rtl) cell_area.x1 = obj->coords.x2 - bg_right - 1 - scroll_x - border_width;
+        else cell_area.x2 = obj->coords.x1 + bg_left - 1 - scroll_x + border_width;
 
         for(col = 0; col < table->col_cnt; col++) {
             lv_table_cell_ctrl_t ctrl = 0;
@@ -670,7 +682,7 @@ static void draw_main(lv_event_t * e)
                 }
             }
 
-            if(cell_area.y2 < clip_area->y1) {
+            if(cell_area.y2 < clip_area.y1) {
                 cell += col_merge + 1;
                 col += col_merge;
                 continue;
@@ -689,7 +701,7 @@ static void draw_main(lv_event_t * e)
                 cell_area_border.x2 += rect_dsc_def.border_width / 2 + (rect_dsc_def.border_width & 0x1);
             }
             if((rect_dsc_def.border_side & LV_BORDER_SIDE_BOTTOM) &&
-                    cell_area_border.y2 < obj->coords.y2 - bg_bottom - 1) {
+               cell_area_border.y2 < obj->coords.y2 - bg_bottom - 1) {
                 cell_area_border.y2 += rect_dsc_def.border_width / 2 + (rect_dsc_def.border_width & 0x1);
             }
 
@@ -718,11 +730,11 @@ static void draw_main(lv_event_t * e)
                 obj->skip_trans = 0;
             }
 
-            dsc.draw_area = &cell_area_border;
-            dsc.id = row * table->col_cnt + col;
-            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &dsc);
+            part_draw_dsc.draw_area = &cell_area_border;
+            part_draw_dsc.id = row * table->col_cnt + col;
+            lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
-            lv_draw_rect(&cell_area_border, clip_area, &rect_dsc_act);
+            lv_draw_rect(&cell_area_border, &clip_area, &rect_dsc_act);
 
             if(table->cell_data[cell]) {
                 txt_area.x1 = cell_area.x1 + cell_left;
@@ -736,8 +748,8 @@ static void draw_main(lv_event_t * e)
                 else txt_flags = LV_TEXT_FLAG_NONE;
 
                 lv_txt_get_size(&txt_size, table->cell_data[cell] + 1, label_dsc_def.font,
-                        label_dsc_act.letter_space, label_dsc_act.line_space,
-                        lv_area_get_width(&txt_area), txt_flags);
+                                label_dsc_act.letter_space, label_dsc_act.line_space,
+                                lv_area_get_width(&txt_area), txt_flags);
 
                 /*Align the content to the middle if not cropped*/
                 if(!crop) {
@@ -747,13 +759,13 @@ static void draw_main(lv_event_t * e)
 
                 lv_area_t label_mask;
                 bool label_mask_ok;
-                label_mask_ok = _lv_area_intersect(&label_mask, clip_area, &cell_area);
+                label_mask_ok = _lv_area_intersect(&label_mask, &clip_area, &cell_area);
                 if(label_mask_ok) {
                     lv_draw_label(&txt_area, &label_mask, &label_dsc_act, table->cell_data[cell] + 1, NULL);
                 }
             }
 
-            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &dsc);
+            lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
 
             cell += col_merge + 1;
             col += col_merge;
@@ -781,7 +793,7 @@ static void refr_size(lv_obj_t * obj, uint32_t strat_row)
 
     for(i = strat_row; i < table->row_cnt; i++) {
         table->row_h[i] = get_row_height(obj, i, font, letter_space, line_space,
-                                       cell_left, cell_right, cell_top, cell_bottom);
+                                         cell_left, cell_right, cell_top, cell_bottom);
         table->row_h[i] = LV_CLAMP(minh, table->row_h[i], maxh);
     }
 
@@ -827,14 +839,14 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
             /*With text crop assume 1 line*/
             if(ctrl & LV_TABLE_CELL_CTRL_TEXT_CROP) {
                 h_max = LV_MAX(lv_font_get_line_height(font) + cell_top + cell_bottom,
-                                    h_max);
+                               h_max);
             }
             /*Without text crop calculate the height of the text in the cell*/
             else {
                 txt_w -= cell_left + cell_right;
 
                 lv_txt_get_size(&txt_size, table->cell_data[cell] + 1, font,
-                                 letter_space, line_space, txt_w, LV_TEXT_FLAG_NONE);
+                                letter_space, line_space, txt_w, LV_TEXT_FLAG_NONE);
 
                 h_max = LV_MAX(txt_size.y + cell_top + cell_bottom, h_max);
                 cell += col_merge;
@@ -848,7 +860,7 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
 
 static lv_res_t get_pressed_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col)
 {
-   lv_table_t * table = (lv_table_t *)obj;
+    lv_table_t * table = (lv_table_t *)obj;
 
     lv_indev_type_t type = lv_indev_get_type(lv_indev_get_act());
     if(type != LV_INDEV_TYPE_POINTER && type != LV_INDEV_TYPE_BUTTON) {
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_table.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_table.h
index cd87e19b7..910627087 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_table.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_table.h
@@ -60,6 +60,14 @@ typedef struct {
 
 extern const lv_obj_class_t lv_table_class;
 
+/**
+ * `type` field in `lv_obj_draw_part_dsc_t` if `class_p = lv_table_class`
+ * Used in `LV_EVENT_DRAW_PART_BEGIN` and `LV_EVENT_DRAW_PART_END`
+ */
+typedef enum {
+    LV_TABLE_DRAW_PART_CELL,       /**< A cell*/
+} lv_table_draw_part_type_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_textarea.c b/lib/libesp32_lvgl/lvgl/src/widgets/lv_textarea.c
index 0bcbefdf5..6be921b50 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_textarea.c
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_textarea.c
@@ -45,6 +45,7 @@
 static void lv_textarea_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
 static void lv_textarea_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj);
 static void lv_textarea_event(const lv_obj_class_t * class_p, lv_event_t * e);
+static void label_event_cb(lv_event_t * e);
 static void cursor_blink_anim_cb(void * obj, int32_t show);
 static void pwd_char_hider_anim(void * obj, int32_t x);
 static void pwd_char_hider_anim_ready(lv_anim_t * a);
@@ -83,7 +84,7 @@ static const char * ta_insert_replace;
 
 lv_obj_t * lv_textarea_create(lv_obj_t * parent)
 {
-    LV_LOG_INFO("begin")
+    LV_LOG_INFO("begin");
     lv_obj_t * obj = lv_obj_class_create_obj(MY_CLASS, parent);
     lv_obj_class_init_obj(obj);
     return obj;
@@ -97,7 +98,7 @@ void lv_textarea_add_char(lv_obj_t * obj, uint32_t c)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     const char * letter_buf;
 
@@ -172,7 +173,7 @@ void lv_textarea_add_text(lv_obj_t * obj, const char * txt)
     LV_ASSERT_OBJ(obj, MY_CLASS);
     LV_ASSERT_NULL(txt);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     if(ta->pwd_mode != 0) pwd_char_hider(obj); /*Make sure all the current text contains only '*'*/
 
@@ -233,7 +234,7 @@ void lv_textarea_del_char(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     uint32_t cur_pos  = ta->cursor.pos;
 
     if(cur_pos == 0) return;
@@ -247,6 +248,7 @@ void lv_textarea_del_char(lv_obj_t * obj)
 
     /*Delete a character*/
     _lv_txt_cut(label_txt, ta->cursor.pos - 1, 1);
+
     /*Refresh the label*/
     lv_label_set_text(ta->label, label_txt);
     lv_textarea_clear_selection(obj);
@@ -258,8 +260,7 @@ void lv_textarea_del_char(lv_obj_t * obj)
     }
 
     if(ta->pwd_mode != 0) {
-        uint32_t byte_pos = _lv_txt_encoded_get_byte_id(ta->pwd_tmp, ta->cursor.pos - 1);
-        _lv_txt_cut(ta->pwd_tmp, ta->cursor.pos - 1, _lv_txt_encoded_size(&ta->pwd_tmp[byte_pos]));
+        _lv_txt_cut(ta->pwd_tmp, ta->cursor.pos - 1, 1);
 
         ta->pwd_tmp = lv_mem_realloc(ta->pwd_tmp, strlen(ta->pwd_tmp) + 1);
         LV_ASSERT_MALLOC(ta->pwd_tmp);
@@ -291,7 +292,7 @@ void lv_textarea_set_text(lv_obj_t * obj, const char * txt)
     LV_ASSERT_OBJ(obj, MY_CLASS);
     LV_ASSERT_NULL(txt);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     /*Clear the existing selection*/
     lv_textarea_clear_selection(obj);
@@ -351,7 +352,7 @@ void lv_textarea_set_placeholder_text(lv_obj_t * obj, const char * txt)
     LV_ASSERT_OBJ(obj, MY_CLASS);
     LV_ASSERT_NULL(txt);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     size_t txt_len = strlen(txt);
 
@@ -386,7 +387,7 @@ void lv_textarea_set_cursor_pos(lv_obj_t * obj, int32_t pos)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     if((uint32_t)ta->cursor.pos == (uint32_t)pos) return;
 
     uint32_t len = _lv_txt_get_encoded_length(lv_label_get_text(ta->label));
@@ -398,27 +399,24 @@ void lv_textarea_set_cursor_pos(lv_obj_t * obj, int32_t pos)
     ta->cursor.pos = pos;
 
     /*Position the label to make the cursor visible*/
-	lv_point_t cur_pos;
-	const lv_font_t * font = lv_obj_get_style_text_font(obj, LV_PART_MAIN);
-	lv_area_t label_cords;
-	lv_area_t ta_cords;
-	lv_label_get_letter_pos(ta->label, pos, &cur_pos);
-	lv_obj_get_coords(obj, &ta_cords);
-	lv_obj_get_coords(ta->label, &label_cords);
+    lv_obj_update_layout(obj);
 
-	/*The text area needs to have it's final size to see if the cursor is out of the area or not*/
-	lv_obj_update_layout(obj);
+    lv_point_t cur_pos;
+    const lv_font_t * font = lv_obj_get_style_text_font(obj, LV_PART_MAIN);
+    lv_label_get_letter_pos(ta->label, pos, &cur_pos);
 
-	/*Check the top*/
-	lv_coord_t font_h = lv_font_get_line_height(font);
-	if(cur_pos.y < lv_obj_get_scroll_top(obj)) {
-		lv_obj_scroll_to_y(obj, cur_pos.y, LV_ANIM_ON);
-	}
-	/*Check the bottom*/
-	lv_coord_t h = lv_obj_get_content_height(obj);
-	if(cur_pos.y + font_h - lv_obj_get_scroll_top(obj) > h) {
-		lv_obj_scroll_to_y(obj, cur_pos.y - h + font_h, LV_ANIM_ON);
-	}
+    /*The text area needs to have it's final size to see if the cursor is out of the area or not*/
+
+    /*Check the top*/
+    lv_coord_t font_h = lv_font_get_line_height(font);
+    if(cur_pos.y < lv_obj_get_scroll_top(obj)) {
+        lv_obj_scroll_to_y(obj, cur_pos.y, LV_ANIM_ON);
+    }
+    /*Check the bottom*/
+    lv_coord_t h = lv_obj_get_content_height(obj);
+    if(cur_pos.y + font_h - lv_obj_get_scroll_top(obj) > h) {
+        lv_obj_scroll_to_y(obj, cur_pos.y - h + font_h, LV_ANIM_ON);
+    }
 
     /*Check the left*/
     if(cur_pos.x < lv_obj_get_scroll_left(obj)) {
@@ -449,7 +447,7 @@ void lv_textarea_set_password_mode(lv_obj_t * obj, bool en)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(ta->pwd_mode == en) return;
 
     ta->pwd_mode = en == false ? 0 : 1;
@@ -482,12 +480,13 @@ void lv_textarea_set_one_line(lv_obj_t * obj, bool en)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(ta->one_line == en) return;
 
     if(en) {
         ta->one_line = 1;
         lv_obj_set_width(ta->label, LV_SIZE_CONTENT);
+        lv_obj_set_style_min_width(ta->label, lv_pct(100), 0);
 
         lv_obj_set_height(obj, LV_SIZE_CONTENT);
         lv_obj_scroll_to(obj, 0, 0, LV_ANIM_OFF);
@@ -495,6 +494,7 @@ void lv_textarea_set_one_line(lv_obj_t * obj, bool en)
     else {
         ta->one_line = 0;
         lv_obj_set_width(ta->label, lv_pct(100));
+        lv_obj_set_style_min_width(ta->label, 0, 0);
         lv_obj_remove_local_style_prop(obj, LV_STYLE_HEIGHT, LV_PART_MAIN);
         lv_obj_scroll_to(obj, 0, 0, LV_ANIM_OFF);
     }
@@ -504,7 +504,7 @@ void lv_textarea_set_accepted_chars(lv_obj_t * obj, const char * list)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     ta->accepted_chars = list;
 }
@@ -513,7 +513,7 @@ void lv_textarea_set_max_length(lv_obj_t * obj, uint32_t num)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     ta->max_length = num;
 }
@@ -531,14 +531,14 @@ void lv_textarea_set_text_selection(lv_obj_t * obj, bool en)
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
 #if LV_LABEL_TEXT_SELECTION
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     ta->text_sel_en = en;
 
     if(!en) lv_textarea_clear_selection(obj);
 #else
-    (void)obj; /*Unused*/
-    (void)en; /*Unused*/
+    LV_UNUSED(obj); /*Unused*/
+    LV_UNUSED(en);  /*Unused*/
 #endif
 }
 
@@ -552,19 +552,20 @@ void lv_textarea_set_password_show_time(lv_obj_t * obj, uint16_t time)
 
 void lv_textarea_set_align(lv_obj_t * obj, lv_text_align_t align)
 {
+    LV_LOG_WARN("Deprecated: use the normal text_align style property instead");
     lv_obj_set_style_text_align(obj, align, 0);
 
     switch(align) {
-    default:
-    case LV_TEXT_ALIGN_LEFT:
-        lv_obj_align(lv_textarea_get_label(obj), LV_ALIGN_TOP_LEFT, 0, 0);
-        break;
-    case LV_TEXT_ALIGN_RIGHT:
-        lv_obj_align(lv_textarea_get_label(obj), LV_ALIGN_TOP_RIGHT, 0, 0);
-        break;
-    case LV_TEXT_ALIGN_CENTER:
-        lv_obj_align(lv_textarea_get_label(obj), LV_ALIGN_TOP_MID, 0, 0);
-        break;
+        default:
+        case LV_TEXT_ALIGN_LEFT:
+            lv_obj_align(lv_textarea_get_label(obj), LV_ALIGN_TOP_LEFT, 0, 0);
+            break;
+        case LV_TEXT_ALIGN_RIGHT:
+            lv_obj_align(lv_textarea_get_label(obj), LV_ALIGN_TOP_RIGHT, 0, 0);
+            break;
+        case LV_TEXT_ALIGN_CENTER:
+            lv_obj_align(lv_textarea_get_label(obj), LV_ALIGN_TOP_MID, 0, 0);
+            break;
     }
 }
 
@@ -576,7 +577,7 @@ const char * lv_textarea_get_text(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     const char * txt;
     if(ta->pwd_mode == 0) {
@@ -593,7 +594,7 @@ const char * lv_textarea_get_placeholder_text(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(ta->placeholder_txt) return ta->placeholder_txt;
     else return "";
 }
@@ -602,7 +603,7 @@ lv_obj_t * lv_textarea_get_label(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->label;
 }
 
@@ -610,7 +611,7 @@ uint32_t lv_textarea_get_cursor_pos(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->cursor.pos;
 }
 
@@ -618,7 +619,7 @@ bool lv_textarea_get_cursor_click_pos(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->cursor.click_pos ? true : false;
 }
 
@@ -626,7 +627,7 @@ bool lv_textarea_get_password_mode(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->pwd_mode == 0 ? false : true;
 }
 
@@ -634,7 +635,7 @@ bool lv_textarea_get_one_line(const lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->one_line == 0 ? false : true;
 }
 
@@ -642,7 +643,7 @@ const char * lv_textarea_get_accepted_chars(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     return ta->accepted_chars;
 }
@@ -651,7 +652,7 @@ uint32_t lv_textarea_get_max_length(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->max_length;
 }
 
@@ -660,17 +661,17 @@ bool lv_textarea_text_is_selected(const lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
 #if LV_LABEL_TEXT_SELECTION
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
-    if((lv_label_get_text_selection_start(ta->label) == LV_DRAW_LABEL_NO_TXT_SEL ||
-        lv_label_get_text_selection_end(ta->label) == LV_DRAW_LABEL_NO_TXT_SEL)) {
+    if((lv_label_get_text_selection_start(ta->label) != LV_DRAW_LABEL_NO_TXT_SEL ||
+        lv_label_get_text_selection_end(ta->label) != LV_DRAW_LABEL_NO_TXT_SEL)) {
         return true;
     }
     else {
         return false;
     }
 #else
-    (void)obj; /*Unused*/
+    LV_UNUSED(obj); /*Unused*/
     return false;
 #endif
 }
@@ -680,10 +681,10 @@ bool lv_textarea_get_text_selection(lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
 #if LV_LABEL_TEXT_SELECTION
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     return ta->text_sel_en;
 #else
-    (void)obj; /*Unused*/
+    LV_UNUSED(obj); /*Unused*/
     return false;
 #endif
 }
@@ -692,7 +693,7 @@ uint16_t lv_textarea_get_password_show_time(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     return ta->pwd_show_time;
 }
@@ -706,7 +707,7 @@ void lv_textarea_clear_selection(lv_obj_t * obj)
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
 #if LV_LABEL_TEXT_SELECTION
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     if(lv_label_get_text_selection_start(ta->label) != LV_DRAW_LABEL_NO_TXT_SEL ||
        lv_label_get_text_selection_end(ta->label) != LV_DRAW_LABEL_NO_TXT_SEL) {
@@ -714,7 +715,7 @@ void lv_textarea_clear_selection(lv_obj_t * obj)
         lv_label_set_text_sel_end(ta->label, LV_DRAW_LABEL_NO_TXT_SEL);
     }
 #else
-    (void)obj; /*Unused*/
+    LV_UNUSED(obj); /*Unused*/
 #endif
 }
 
@@ -742,7 +743,7 @@ void lv_textarea_cursor_down(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     lv_point_t pos;
 
     /*Get the position of the current letter*/
@@ -771,7 +772,7 @@ void lv_textarea_cursor_up(lv_obj_t * obj)
 {
     LV_ASSERT_OBJ(obj, MY_CLASS);
 
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     lv_point_t pos;
 
     /*Get the position of the current letter*/
@@ -808,7 +809,8 @@ static void lv_textarea_constructor(const lv_obj_class_t * class_p, lv_obj_t * o
     ta->accepted_chars    = NULL;
     ta->max_length        = 0;
     ta->cursor.show      = 1;
-    ta->cursor.pos        = 1;	/*It will be set to zero later (with zero value lv_textarea_set_cursor_pos(obj, 0); woldn't do anything as there is no difference)*/
+    /*It will be set to zero later (with zero value lv_textarea_set_cursor_pos(obj, 0); woldn't do anything as there is no difference)*/
+    ta->cursor.pos        = 1;
     ta->cursor.click_pos  = 1;
     ta->cursor.valid_x    = 0;
     ta->one_line          = 0;
@@ -821,6 +823,7 @@ static void lv_textarea_constructor(const lv_obj_class_t * class_p, lv_obj_t * o
     ta->label = lv_label_create(obj);
     lv_obj_set_width(ta->label, lv_pct(100));
     lv_label_set_text(ta->label, "");
+    lv_obj_add_event_cb(ta->label, label_event_cb, LV_EVENT_ALL, NULL);
     lv_obj_add_flag(obj, LV_OBJ_FLAG_SCROLL_ON_FOCUS);
     lv_textarea_set_cursor_pos(obj, 0);
 
@@ -855,27 +858,10 @@ static void lv_textarea_event(const lv_obj_class_t * class_p, lv_event_t * e)
 
     lv_event_code_t code = lv_event_get_code(e);
     lv_obj_t * obj = lv_event_get_target(e);
-    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
-    if(code == LV_EVENT_STYLE_CHANGED) {
-        if(ta->label) {
-            lv_label_set_text(ta->label, NULL);
-            refr_cursor_area(obj);
-            start_cursor_blink(obj);
-        }
-    }
-    else if(code == LV_EVENT_FOCUSED) {
+    if(code == LV_EVENT_FOCUSED) {
         start_cursor_blink(obj);
     }
-    else if(code == LV_EVENT_SIZE_CHANGED) {
-        /*Set the label width according to the text area width*/
-        if(ta->label) {
-            lv_obj_set_pos(ta->label, 0, 0);
-            lv_label_set_text(ta->label, NULL); /*Refresh the label*/
-
-            refr_cursor_area(obj);
-        }
-    }
     else if(code == LV_EVENT_KEY) {
         uint32_t c = *((uint32_t *)lv_event_get_param(e)); /*uint32_t because can be UTF-8*/
         if(c == LV_KEY_RIGHT)
@@ -912,6 +898,21 @@ static void lv_textarea_event(const lv_obj_class_t * class_p, lv_event_t * e)
     }
 }
 
+static void label_event_cb(lv_event_t * e)
+{
+    lv_event_code_t code = lv_event_get_code(e);
+    lv_obj_t * label = lv_event_get_target(e);
+    lv_obj_t * ta = lv_obj_get_parent(label);
+
+    if(code == LV_EVENT_STYLE_CHANGED || code == LV_EVENT_SIZE_CHANGED) {
+        lv_label_set_text(label, NULL);
+        refr_cursor_area(ta);
+        start_cursor_blink(ta);
+    }
+}
+
+
+
 /**
  * Called to blink the cursor
  * @param ta pointer to a text area
@@ -919,7 +920,7 @@ static void lv_textarea_event(const lv_obj_class_t * class_p, lv_event_t * e)
  */
 static void cursor_blink_anim_cb(void * obj, int32_t show)
 {
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(show != ta->cursor.show) {
         ta->cursor.show = show == 0 ? 0 : 1;
         lv_area_t area_tmp;
@@ -961,7 +962,7 @@ static void pwd_char_hider_anim_ready(lv_anim_t * a)
  */
 static void pwd_char_hider(lv_obj_t * obj)
 {
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(ta->pwd_mode != 0) {
         char * txt  = lv_label_get_text(ta->label);
         int32_t enc_len = _lv_txt_get_encoded_length(txt);
@@ -999,10 +1000,10 @@ static void pwd_char_hider(lv_obj_t * obj)
  */
 static bool char_is_accepted(lv_obj_t * obj, uint32_t c)
 {
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
 
     /*If no restriction accept it*/
-    if(ta->accepted_chars == NULL && ta->max_length == 0) return true;
+    if((ta->accepted_chars == NULL || ta->accepted_chars[0] == '\0') && ta->max_length == 0) return true;
 
     /*Too many characters?*/
     if(ta->max_length > 0 && _lv_txt_get_encoded_length(lv_textarea_get_text(obj)) >= ta->max_length) {
@@ -1032,7 +1033,8 @@ static void start_cursor_blink(lv_obj_t * obj)
     if(blink_time == 0) {
         lv_anim_del(obj, cursor_blink_anim_cb);
         ta->cursor.show = 1;
-    } else {
+    }
+    else {
         lv_anim_t a;
         lv_anim_init(&a);
         lv_anim_set_var(&a, ta);
@@ -1076,14 +1078,11 @@ static void refr_cursor_area(lv_obj_t * obj)
     lv_point_t letter_pos;
     lv_label_get_letter_pos(ta->label, cur_pos, &letter_pos);
 
-    lv_text_align_t align = lv_obj_get_style_text_align(ta->label, LV_PART_MAIN);
-    if(align == LV_TEXT_ALIGN_AUTO) {
-       if(lv_obj_get_style_base_dir(obj, LV_PART_MAIN) == LV_BASE_DIR_RTL) align = LV_TEXT_ALIGN_RIGHT;
-       else align = LV_TEXT_ALIGN_LEFT;
-    }
+    lv_text_align_t align = lv_obj_calculate_style_text_align(ta->label, LV_PART_MAIN, lv_label_get_text(ta->label));
 
     /*If the cursor is out of the text (most right) draw it to the next line*/
-    if(letter_pos.x + ta->label->coords.x1 + letter_w > ta->label->coords.x2 && ta->one_line == 0 && align != LV_TEXT_ALIGN_RIGHT) {
+    if(letter_pos.x + ta->label->coords.x1 + letter_w > ta->label->coords.x2 && ta->one_line == 0 &&
+       align != LV_TEXT_ALIGN_RIGHT) {
         letter_pos.x = 0;
         letter_pos.y += letter_h + line_space;
 
@@ -1104,10 +1103,11 @@ static void refr_cursor_area(lv_obj_t * obj)
     ta->cursor.txt_byte_pos = byte_pos;
 
     /*Calculate the cursor according to its type*/
-    lv_coord_t top = lv_obj_get_style_pad_top(obj, LV_PART_CURSOR);
-    lv_coord_t bottom = lv_obj_get_style_pad_bottom(obj, LV_PART_CURSOR);
-    lv_coord_t left = lv_obj_get_style_pad_left(obj, LV_PART_CURSOR);
-    lv_coord_t right = lv_obj_get_style_pad_right(obj, LV_PART_CURSOR);
+    lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_CURSOR);
+    lv_coord_t top = lv_obj_get_style_pad_top(obj, LV_PART_CURSOR) + border_width;
+    lv_coord_t bottom = lv_obj_get_style_pad_bottom(obj, LV_PART_CURSOR) + border_width;
+    lv_coord_t left = lv_obj_get_style_pad_left(obj, LV_PART_CURSOR) + border_width;
+    lv_coord_t right = lv_obj_get_style_pad_right(obj, LV_PART_CURSOR) + border_width;
 
     lv_area_t cur_area;
     cur_area.x1 = letter_pos.x - left;
@@ -1141,7 +1141,7 @@ static void update_cursor_position_on_click(lv_event_t * e)
 
     lv_event_code_t code = lv_event_get_code(e);
     lv_obj_t * obj = lv_event_get_target(e);
-     lv_textarea_t * ta = (lv_textarea_t *)obj;
+    lv_textarea_t * ta = (lv_textarea_t *)obj;
     if(ta->cursor.click_pos == 0) return;
 
     if(lv_indev_get_type(click_source) == LV_INDEV_TYPE_KEYPAD ||
@@ -1253,7 +1253,7 @@ static void update_cursor_position_on_click(lv_event_t * e)
 static lv_res_t insert_handler(lv_obj_t * obj, const char * txt)
 {
     ta_insert_replace = NULL;
-    lv_event_send(obj, LV_EVENT_INSERT, (char*)txt);
+    lv_event_send(obj, LV_EVENT_INSERT, (char *)txt);
     if(ta_insert_replace) {
         if(ta_insert_replace[0] == '\0') return LV_RES_INV; /*Drop this text*/
 
@@ -1309,6 +1309,7 @@ static void draw_cursor(lv_event_t * e)
     lv_area_t cur_area;
     lv_area_copy(&cur_area, &ta->cursor.area);
 
+
     cur_area.x1 += ta->label->coords.x1;
     cur_area.y1 += ta->label->coords.y1;
     cur_area.x2 += ta->label->coords.x1;
@@ -1316,19 +1317,23 @@ static void draw_cursor(lv_event_t * e)
 
     lv_draw_rect(&cur_area, clip_area, &cur_dsc);
 
+    lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_CURSOR);
+    lv_coord_t left = lv_obj_get_style_pad_left(obj, LV_PART_CURSOR) + border_width;
+    lv_coord_t top = lv_obj_get_style_pad_top(obj, LV_PART_CURSOR) + border_width;
     char letter_buf[8] = {0};
     lv_memcpy(letter_buf, &txt[ta->cursor.txt_byte_pos], _lv_txt_encoded_size(&txt[ta->cursor.txt_byte_pos]));
 
-    if(cur_dsc.bg_opa == LV_OPA_COVER) {
-        lv_coord_t left = lv_obj_get_style_pad_left(obj, LV_PART_CURSOR);
-        lv_coord_t top = lv_obj_get_style_pad_top(obj, LV_PART_CURSOR);
-        lv_coord_t border_width = lv_obj_get_style_border_width(obj, LV_PART_CURSOR);
-        cur_area.x1 += left + border_width;
-        cur_area.y1 += top + border_width;
+    cur_area.x1 += left;
+    cur_area.y1 += top;
 
-        lv_draw_label_dsc_t cur_label_dsc;
-        lv_draw_label_dsc_init(&cur_label_dsc);
-        lv_obj_init_draw_label_dsc(obj, LV_PART_CURSOR, &cur_label_dsc);
+    /*Draw the letter over the cursor only if
+     *the cursor has background or the letter has different color than the original.
+     *Else the original letter is drawn twice which makes it look bolder*/
+    lv_color_t label_color = lv_obj_get_style_text_color(ta->label, 0);
+    lv_draw_label_dsc_t cur_label_dsc;
+    lv_draw_label_dsc_init(&cur_label_dsc);
+    lv_obj_init_draw_label_dsc(obj, LV_PART_CURSOR, &cur_label_dsc);
+    if(cur_dsc.bg_opa > LV_OPA_MIN || cur_label_dsc.color.full != label_color.full) {
         lv_draw_label(&cur_area, clip_area, &cur_label_dsc, letter_buf, NULL);
     }
 }
diff --git a/lib/libesp32_lvgl/lvgl/src/widgets/lv_textarea.h b/lib/libesp32_lvgl/lvgl/src/widgets/lv_textarea.h
index 0964416d4..2ab48f0ab 100644
--- a/lib/libesp32_lvgl/lvgl/src/widgets/lv_textarea.h
+++ b/lib/libesp32_lvgl/lvgl/src/widgets/lv_textarea.h
@@ -199,6 +199,7 @@ void lv_textarea_set_text_selection(lv_obj_t * obj, bool en);
 void lv_textarea_set_password_show_time(lv_obj_t * obj, uint16_t time);
 
 /**
+ * Deprecated: use the normal text_align style property instead
  * Set the label's alignment.
  * It sets where the label is aligned (in one line mode it can be smaller than the text area)
  * and how the lines of the area align in case of multiline text area
diff --git a/tasmota/lvgl_berry/tasmota_lv_conf.h b/tasmota/lvgl_berry/tasmota_lv_conf.h
index 1200e3419..0c6975c40 100644
--- a/tasmota/lvgl_berry/tasmota_lv_conf.h
+++ b/tasmota/lvgl_berry/tasmota_lv_conf.h
@@ -537,6 +537,56 @@ e.g. "stm32f769xx.h" or "stm32f429xx.h"*/
 /*A layout similar to Grid in CSS.*/
 #define LV_USE_GRID     1
 
+/*---------------------
+ * 3rd party libraries
+ *--------------------*/
+
+/*File system interfaces for common APIs
+ *To enable set a driver letter for that API*/
+#define LV_USE_FS_STDIO '\0'        /*Uses fopen, fread, etc*/
+//#define LV_FS_STDIO_PATH "/home/john/"    /*Set the working directory. If commented it will be "./" */
+
+#define LV_USE_FS_POSIX '\0'        /*Uses open, read, etc*/
+//#define LV_FS_POSIX_PATH "/home/john/"    /*Set the working directory. If commented it will be "./" */
+
+#define LV_USE_FS_WIN32 '\0'        /*Uses CreateFile, ReadFile, etc*/
+//#define LV_FS_WIN32_PATH "C:\\Users\\john\\"    /*Set the working directory. If commented it will be ".\\" */
+
+#define LV_USE_FS_FATFS '\0'        /*Uses f_open, f_read, etc*/
+
+/*PNG decoder library*/
+#define LV_USE_PNG 0
+
+/*BMP decoder library*/
+#define LV_USE_BMP 0
+
+/* JPG + split JPG decoder library.
+ * Split JPG is a custom format optimized for embedded systems. */
+#define LV_USE_SJPG 0
+
+/*GIF decoder library*/
+#define LV_USE_GIF 0
+
+/*QR code library*/
+#define LV_USE_QRCODE 0
+
+/*FreeType library*/
+#define LV_USE_FREETYPE 0
+#if LV_USE_FREETYPE
+/*Memory used by FreeType to cache characters [bytes] (-1: no caching)*/
+# define LV_FREETYPE_CACHE_SIZE (16 * 1024)
+#endif
+
+/*Rlottie library*/
+#define LV_USE_RLOTTIE 0
+
+/*-----------
+ * Others
+ *----------*/
+
+/*1: Enable API to take snapshot for object*/
+#define LV_USE_SNAPSHOT 0
+
 /*==================
 * EXAMPLES
 *==================*/