ESP32 LVGL library from v8.3.10 to v8.3.11 (no functional change) (#20183)

* ESP32 LVGL library from v8.3.10 to v8.3.11 (no functional change)

* merge

* parse

* finalize

CHANGELOG.md

@@ -11,6 +11,7 @@ All notable changes to this project will be documented in this file.
 ### Breaking Changed
 
 ### Changed
+- ESP32 LVGL library from v8.3.10 to v8.3.11 (no functional change)
 
 ### Fixed
 

lib/libesp32_lvgl/lv_binding_berry/generate/be_lv_c_mapping.h

@@ -968,12 +968,14 @@ const be_ntv_func_def_t lv_switch_func[] = {
 const be_ntv_func_def_t lv_table_func[] = {
   { "add_cell_ctrl", { (const void*) &lv_table_add_cell_ctrl, "", "(lv.lv_obj)ii(lv.lv_table_cell_ctrl)" } },
   { "clear_cell_ctrl", { (const void*) &lv_table_clear_cell_ctrl, "", "(lv.lv_obj)ii(lv.lv_table_cell_ctrl)" } },
+  { "get_cell_user_data", { (const void*) &lv_table_get_cell_user_data, ".", "(lv.lv_obj)ii" } },
   { "get_cell_value", { (const void*) &lv_table_get_cell_value, "s", "(lv.lv_obj)ii" } },
   { "get_col_cnt", { (const void*) &lv_table_get_col_cnt, "i", "(lv.lv_obj)" } },
   { "get_col_width", { (const void*) &lv_table_get_col_width, "i", "(lv.lv_obj)i" } },
   { "get_row_cnt", { (const void*) &lv_table_get_row_cnt, "i", "(lv.lv_obj)" } },
   { "get_selected_cell", { (const void*) &lv_table_get_selected_cell, "", "(lv.lv_obj)(lv.uint16)(lv.uint16)" } },
   { "has_cell_ctrl", { (const void*) &lv_table_has_cell_ctrl, "b", "(lv.lv_obj)ii(lv.lv_table_cell_ctrl)" } },
+  { "set_cell_user_data", { (const void*) &lv_table_set_cell_user_data, "", "(lv.lv_obj)ii." } },
   { "set_cell_value", { (const void*) &lv_table_set_cell_value, "", "(lv.lv_obj)iis" } },
   { "set_cell_value_fmt", { (const void*) &lv_table_set_cell_value_fmt, "", "(lv.lv_obj)iis[......]" } },
   { "set_col_cnt", { (const void*) &lv_table_set_col_cnt, "", "(lv.lv_obj)i" } },

lib/libesp32_lvgl/lv_binding_berry/generate/be_lvgl_widgets_lib.c

@@ -907,12 +907,14 @@ extern int lvbe_table_set_col_cnt(bvm *vm);
 extern int lvbe_table_set_col_width(bvm *vm);
 extern int lvbe_table_add_cell_ctrl(bvm *vm);
 extern int lvbe_table_clear_cell_ctrl(bvm *vm);
+extern int lvbe_table_set_cell_user_data(bvm *vm);
 extern int lvbe_table_get_cell_value(bvm *vm);
 extern int lvbe_table_get_row_cnt(bvm *vm);
 extern int lvbe_table_get_col_cnt(bvm *vm);
 extern int lvbe_table_get_col_width(bvm *vm);
 extern int lvbe_table_has_cell_ctrl(bvm *vm);
 extern int lvbe_table_get_selected_cell(bvm *vm);
+extern int lvbe_table_get_cell_user_data(bvm *vm);
 
 /* `lv_textarea` external functions definitions */
 extern int lvbe_textarea_create(bvm *vm);

lib/libesp32_lvgl/lv_binding_berry/mapping/lv_funcs.h

@@ -1130,12 +1130,14 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt)
 void lv_table_set_col_width(lv_obj_t * obj, uint16_t col_id, lv_coord_t w)
 void lv_table_add_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl)
 void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl)
+void lv_table_set_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col, void * user_data)
 const char * lv_table_get_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col)
 uint16_t lv_table_get_row_cnt(lv_obj_t * obj)
 uint16_t lv_table_get_col_cnt(lv_obj_t * obj)
 lv_coord_t lv_table_get_col_width(lv_obj_t * obj, uint16_t col)
 bool lv_table_has_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl)
 void lv_table_get_selected_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col)
+void * lv_table_get_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col)
 
 // ../../lvgl/src/widgets/lv_textarea.h
 lv_obj_t * lv_textarea_create(lv_obj_t * parent)

lib/libesp32_lvgl/lv_binding_berry/src/be_lvgl_ctypes_definitions.c

@@ -432,11 +432,10 @@ const be_ctypes_structure_t be_lv_draw_mask_saved = {
 
 const be_ctypes_structure_t be_lv_meter_scale = {
   36,  /* size in bytes */
-  15,  /* number of elements */
+  14,  /* number of elements */
   be_ctypes_instance_mappings,
-  (const be_ctypes_structure_item_t[15]) {
+  (const be_ctypes_structure_item_t[14]) {
     { "angle_range", 30, 0, 0, ctypes_u16, 0 },
-    { "label_color", 18, 0, 0, ctypes_i16, 0 },
     { "label_gap", 16, 0, 0, ctypes_i16, 0 },
     { "max", 24, 0, 0, ctypes_i32, 0 },
     { "min", 20, 0, 0, ctypes_i32, 0 },

lib/libesp32_lvgl/lv_binding_berry/src/embedded/lvgl_ctypes.py

@@ -353,7 +353,6 @@ lv_meter_scale = [            # valid LVGL8.3
     [uint16_t, "tick_major_width"],
 
     [int16_t, "label_gap"],
-    [int16_t, "label_color"],
 
     [int32_t, "min"],
     [int32_t, "max"],

lib/libesp32_lvgl/lvgl/library.json

@@ -1,6 +1,6 @@
 {
 	"name": "lvgl",
-	"version": "8.3.10",
+	"version": "8.3.11",
 	"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": {

lib/libesp32_lvgl/lvgl/library.properties

@@ -1,5 +1,5 @@
 name=lvgl
-version=8.3.10
+version=8.3.11
 author=kisvegabor
 maintainer=kisvegabor,embeddedt,pete-pjb
 sentence=Full-featured Graphics Library for Embedded Systems

lib/libesp32_lvgl/lvgl/lv_conf_template.h

@@ -1,6 +1,6 @@
 /**
  * @file lv_conf.h
- * Configuration file for v8.3.9
+ * Configuration file for v8.3.11
  */
 
 /*
@@ -639,6 +639,13 @@
     #define LV_FS_FATFS_CACHE_SIZE 0    /*>0 to cache this number of bytes in lv_fs_read()*/
 #endif
 
+/*API for LittleFS (library needs to be added separately). Uses lfs_file_open, lfs_file_read, etc*/
+#define LV_USE_FS_LITTLEFS 0
+#if LV_USE_FS_LITTLEFS
+    #define LV_FS_LITTLEFS_LETTER '\0'     /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
+    #define LV_FS_LITTLEFS_CACHE_SIZE 0    /*>0 to cache this number of bytes in lv_fs_read()*/
+#endif
+
 /*PNG decoder library*/
 #define LV_USE_PNG 0
 
@@ -672,6 +679,13 @@
     #endif
 #endif
 
+/*Tiny TTF library*/
+#define LV_USE_TINY_TTF 0
+#if LV_USE_TINY_TTF
+    /*Load TTF data from files*/
+    #define LV_TINY_TTF_FILE_SUPPORT 0
+#endif
+
 /*Rlottie library*/
 #define LV_USE_RLOTTIE 0
 

lib/libesp32_lvgl/lvgl/lvgl.h

@@ -15,7 +15,7 @@ extern "C" {
  ***************************/
 #define LVGL_VERSION_MAJOR 8
 #define LVGL_VERSION_MINOR 3
-#define LVGL_VERSION_PATCH 10
+#define LVGL_VERSION_PATCH 11
 #define LVGL_VERSION_INFO ""
 
 /*********************

lib/libesp32_lvgl/lvgl/src/core/lv_disp.c

@@ -224,9 +224,13 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
     lv_disp_t * d = lv_obj_get_disp(new_scr);
     lv_obj_t * act_scr = lv_scr_act();
 
+    if(act_scr == new_scr || d->scr_to_load == new_scr) {
+        return;
+    }
+
     /*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) {
+    if(d->scr_to_load) {
         scr_load_internal(d->scr_to_load);
         lv_anim_del(d->scr_to_load, NULL);
         lv_obj_set_pos(d->scr_to_load, 0, 0);
@@ -258,7 +262,6 @@ void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t
     lv_obj_remove_local_style_prop(new_scr, LV_STYLE_OPA, 0);
     lv_obj_remove_local_style_prop(lv_scr_act(), LV_STYLE_OPA, 0);
 
-
     /*Shortcut for immediate load*/
     if(time == 0 && delay == 0) {
         scr_load_internal(new_scr);
@@ -478,6 +481,7 @@ static void scr_load_internal(lv_obj_t * scr)
     if(d->act_scr) lv_event_send(scr, LV_EVENT_SCREEN_LOAD_START, NULL);
 
     d->act_scr = scr;
+    d->scr_to_load = NULL;
 
     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);

lib/libesp32_lvgl/lvgl/src/core/lv_obj.c

@@ -149,9 +149,9 @@ void lv_init(void)
     lv_img_cache_set_size(LV_IMG_CACHE_DEF_SIZE);
 #endif
     /*Test if the IDE has UTF-8 encoding*/
-    char * txt = "Á";
+    const char * txt = "Á";
 
-    uint8_t * txt_u8 = (uint8_t *)txt;
+    const 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 have no UTF-8 encoding. Non-ASCII characters won't be displayed.");
     }
@@ -862,6 +862,10 @@ 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_CHILD_DELETED) {
+        obj->readjust_scroll_after_layout = 1;
+        lv_obj_mark_layout_as_dirty(obj);
+    }
     else if(code == LV_EVENT_REFR_EXT_DRAW_SIZE) {
         lv_coord_t d = lv_obj_calculate_ext_draw_size(obj, LV_PART_MAIN);
         lv_event_set_ext_draw_size(e, d);

lib/libesp32_lvgl/lvgl/src/core/lv_obj.h

@@ -183,6 +183,7 @@ typedef struct _lv_obj_t {
     lv_obj_flag_t flags;
     lv_state_t state;
     uint16_t layout_inv : 1;
+    uint16_t readjust_scroll_after_layout : 1;
     uint16_t scr_layout_inv : 1;
     uint16_t skip_trans : 1;
     uint16_t style_cnt  : 6;

lib/libesp32_lvgl/lvgl/src/core/lv_obj_draw.c

@@ -179,12 +179,11 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint32_t part, lv_draw_rect_dsc_t
         }
     }
 #endif
-
     if(opa < LV_OPA_MAX) {
-        draw_dsc->bg_opa = (opa * draw_dsc->shadow_opa) >> 8;
+        draw_dsc->bg_opa = (opa * draw_dsc->bg_opa) >> 8;
-        draw_dsc->bg_img_opa = (opa * draw_dsc->shadow_opa) >> 8;
+        draw_dsc->bg_img_opa = (opa * draw_dsc->bg_img_opa) >> 8;
-        draw_dsc->border_opa = (opa * draw_dsc->shadow_opa) >> 8;
+        draw_dsc->border_opa = (opa * draw_dsc->border_opa) >> 8;
-        draw_dsc->outline_opa = (opa * draw_dsc->shadow_opa) >> 8;
+        draw_dsc->outline_opa = (opa * draw_dsc->outline_opa) >> 8;
         draw_dsc->shadow_opa = (opa * draw_dsc->shadow_opa) >> 8;
     }
 }

lib/libesp32_lvgl/lvgl/src/core/lv_obj_pos.c

@@ -200,7 +200,7 @@ bool lv_obj_refr_size(lv_obj_t * obj)
     /*Invalidate the new area*/
     lv_obj_invalidate(obj);
 
-    lv_obj_readjust_scroll(obj, LV_ANIM_OFF);
+    obj->readjust_scroll_after_layout = 1;
 
     /*If the object was out of the parent invalidate the new scrollbar area too.
      *If it wasn't out of the parent but out now, also invalidate the scrollbars*/
@@ -1137,20 +1137,24 @@ static void layout_update_core(lv_obj_t * obj)
         layout_update_core(child);
     }
 
-    if(obj->layout_inv == 0) return;
+    if(obj->layout_inv) {
+        obj->layout_inv = 0;
+        lv_obj_refr_size(obj);
+        lv_obj_refr_pos(obj);
 
-    obj->layout_inv = 0;
+        if(child_cnt > 0) {
-
+            uint32_t layout_id = lv_obj_get_style_layout(obj, LV_PART_MAIN);
-    lv_obj_refr_size(obj);
+            if(layout_id > 0 && layout_id <= layout_cnt) {
-    lv_obj_refr_pos(obj);
+                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);
-    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);
         }
     }
+
+    if(obj->readjust_scroll_after_layout) {
+        obj->readjust_scroll_after_layout = 0;
+        lv_obj_readjust_scroll(obj, LV_ANIM_OFF);
+    }
 }
 
 static void transform_point(const lv_obj_t * obj, lv_point_t * p, bool inv)

lib/libesp32_lvgl/lvgl/src/core/lv_obj_scroll.h

@@ -290,7 +290,7 @@ void lv_obj_get_scrollbar_area(struct _lv_obj_t * obj, lv_area_t * hor, lv_area_
 void lv_obj_scrollbar_invalidate(struct _lv_obj_t * obj);
 
 /**
- * Checked if the content is scrolled "in" and adjusts it to a normal position.
+ * Checks if the content is scrolled "in" and adjusts it to a normal position.
  * @param obj       pointer to an object
  * @param anim_en   LV_ANIM_ON/OFF
  */

lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.c

@@ -608,8 +608,7 @@ void lv_obj_set_style_opa_layered(struct _lv_obj_t * obj, lv_opa_t value, lv_sty
     lv_obj_set_local_style_prop(obj, LV_STYLE_OPA_LAYERED, v, selector);
 }
 
-void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value,
+void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value, lv_style_selector_t selector)
-                                       lv_style_selector_t selector)
 {
     lv_style_value_t v = {
         .ptr = value
@@ -649,8 +648,7 @@ void lv_obj_set_style_anim_speed(struct _lv_obj_t * obj, uint32_t value, lv_styl
     lv_obj_set_local_style_prop(obj, LV_STYLE_ANIM_SPEED, v, selector);
 }
 
-void lv_obj_set_style_transition(struct _lv_obj_t * obj, const lv_style_transition_dsc_t * value,
+void lv_obj_set_style_transition(struct _lv_obj_t * obj, const lv_style_transition_dsc_t * value, lv_style_selector_t selector)
-                                 lv_style_selector_t selector)
 {
     lv_style_value_t v = {
         .ptr = value

lib/libesp32_lvgl/lvgl/src/core/lv_obj_style_gen.h

@@ -162,8 +162,7 @@ static inline lv_color_t lv_obj_get_style_bg_grad_color(const struct _lv_obj_t *
 
 static inline lv_color_t lv_obj_get_style_bg_grad_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
 {
-    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
+    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_BG_GRAD_COLOR));
-                                                                                           LV_STYLE_BG_GRAD_COLOR));
     return v.color;
 }
 
@@ -217,8 +216,7 @@ static inline lv_color_t lv_obj_get_style_bg_img_recolor(const struct _lv_obj_t
 
 static inline lv_color_t lv_obj_get_style_bg_img_recolor_filtered(const struct _lv_obj_t * obj, uint32_t part)
 {
-    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
+    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_BG_IMG_RECOLOR));
-                                                                                           LV_STYLE_BG_IMG_RECOLOR));
     return v.color;
 }
 
@@ -242,8 +240,7 @@ static inline lv_color_t lv_obj_get_style_border_color(const struct _lv_obj_t *
 
 static inline lv_color_t lv_obj_get_style_border_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
 {
-    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
+    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_BORDER_COLOR));
-                                                                                           LV_STYLE_BORDER_COLOR));
     return v.color;
 }
 
@@ -285,8 +282,7 @@ static inline lv_color_t lv_obj_get_style_outline_color(const struct _lv_obj_t *
 
 static inline lv_color_t lv_obj_get_style_outline_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
 {
-    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
+    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_OUTLINE_COLOR));
-                                                                                           LV_STYLE_OUTLINE_COLOR));
     return v.color;
 }
 
@@ -334,8 +330,7 @@ static inline lv_color_t lv_obj_get_style_shadow_color(const struct _lv_obj_t *
 
 static inline lv_color_t lv_obj_get_style_shadow_color_filtered(const struct _lv_obj_t * obj, uint32_t part)
 {
-    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
+    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_SHADOW_COLOR));
-                                                                                           LV_STYLE_SHADOW_COLOR));
     return v.color;
 }
 
@@ -359,8 +354,7 @@ static inline lv_color_t lv_obj_get_style_img_recolor(const struct _lv_obj_t * o
 
 static inline lv_color_t lv_obj_get_style_img_recolor_filtered(const struct _lv_obj_t * obj, uint32_t part)
 {
-    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part,
+    lv_style_value_t v = _lv_obj_style_apply_color_filter(obj, part, lv_obj_get_style_prop(obj, part, LV_STYLE_IMG_RECOLOR));
-                                                                                           LV_STYLE_IMG_RECOLOR));
     return v.color;
 }
 
@@ -520,8 +514,7 @@ static inline lv_opa_t lv_obj_get_style_opa_layered(const struct _lv_obj_t * obj
     return (lv_opa_t)v.num;
 }
 
-static inline const lv_color_filter_dsc_t * lv_obj_get_style_color_filter_dsc(const struct _lv_obj_t * obj,
+static inline const lv_color_filter_dsc_t * lv_obj_get_style_color_filter_dsc(const struct _lv_obj_t * obj, uint32_t part)
-                                                                              uint32_t part)
 {
     lv_style_value_t v = lv_obj_get_style_prop(obj, part, LV_STYLE_COLOR_FILTER_DSC);
     return (const lv_color_filter_dsc_t *)v.ptr;
@@ -651,14 +644,12 @@ void lv_obj_set_style_radius(struct _lv_obj_t * obj, lv_coord_t value, lv_style_
 void lv_obj_set_style_clip_corner(struct _lv_obj_t * obj, bool value, lv_style_selector_t selector);
 void lv_obj_set_style_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
 void lv_obj_set_style_opa_layered(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
-void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value,
+void lv_obj_set_style_color_filter_dsc(struct _lv_obj_t * obj, const lv_color_filter_dsc_t * value, lv_style_selector_t selector);
-                                       lv_style_selector_t selector);
 void lv_obj_set_style_color_filter_opa(struct _lv_obj_t * obj, lv_opa_t value, lv_style_selector_t selector);
 void lv_obj_set_style_anim(struct _lv_obj_t * obj, const lv_anim_t * value, lv_style_selector_t selector);
 void lv_obj_set_style_anim_time(struct _lv_obj_t * obj, uint32_t value, lv_style_selector_t selector);
 void lv_obj_set_style_anim_speed(struct _lv_obj_t * obj, uint32_t value, lv_style_selector_t selector);
-void lv_obj_set_style_transition(struct _lv_obj_t * obj, const lv_style_transition_dsc_t * value,
+void lv_obj_set_style_transition(struct _lv_obj_t * obj, const lv_style_transition_dsc_t * value, lv_style_selector_t selector);
-                                 lv_style_selector_t selector);
 void lv_obj_set_style_blend_mode(struct _lv_obj_t * obj, lv_blend_mode_t value, lv_style_selector_t selector);
 void lv_obj_set_style_layout(struct _lv_obj_t * obj, uint16_t value, lv_style_selector_t selector);
 void lv_obj_set_style_base_dir(struct _lv_obj_t * obj, lv_base_dir_t value, lv_style_selector_t selector);

lib/libesp32_lvgl/lvgl/src/core/lv_obj_tree.c

@@ -49,9 +49,6 @@ void lv_obj_del(lv_obj_t * obj)
     lv_obj_invalidate(obj);
 
     lv_obj_t * par = lv_obj_get_parent(obj);
-    if(par) {
-        lv_obj_scrollbar_invalidate(par);
-    }
 
     lv_disp_t * disp = NULL;
     bool act_scr_del = false;
@@ -65,8 +62,6 @@ void lv_obj_del(lv_obj_t * obj)
 
     /*Call the ancestor's event handler to the parent to notify it about the child delete*/
     if(par) {
-        lv_obj_update_layout(par);
-        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);
@@ -173,7 +168,6 @@ void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent)
     obj->parent = parent;
 
     /*Notify the original parent because one of its children is lost*/
-    lv_obj_readjust_scroll(old_parent, LV_ANIM_OFF);
     lv_obj_scrollbar_invalidate(old_parent);
     lv_event_send(old_parent, LV_EVENT_CHILD_CHANGED, obj);
     lv_event_send(old_parent, LV_EVENT_CHILD_DELETED, NULL);

lib/libesp32_lvgl/lvgl/src/draw/stm32_dma2d/lv_gpu_stm32_dma2d.c

@@ -34,6 +34,19 @@
     #error "Cannot use DMA2D with LV_COLOR_DEPTH other than 16 or 32"
 #endif
 
+#if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
+    #define LV_STM32_DMA2D_USE_M7_CACHE
+#endif
+
+#if defined (LV_STM32_DMA2D_USE_M7_CACHE)
+    // Cortex-M7 DCache present
+    #define __lv_gpu_stm32_dma2d_clean_cache(address, offset, width, height, pixel_size) _lv_gpu_stm32_dma2d_clean_cache(address, offset, width, height, pixel_size)
+    #define __lv_gpu_stm32_dma2d_invalidate_cache(address, offset, width, height, pixel_size) _lv_gpu_stm32_dma2d_invalidate_cache(address, offset, width, height, pixel_size)
+#else
+    #define __lv_gpu_stm32_dma2d_clean_cache(address, offset, width, height, pixel_size)
+    #define __lv_gpu_stm32_dma2d_invalidate_cache(address, offset, width, height, pixel_size)
+#endif
+
 /**********************
  *  STATIC PROTOTYPES
  **********************/
@@ -61,13 +74,19 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_copy_buffer(const lv_color_t * d
                                                             const lv_area_t * draw_area, const lv_color_t * src_buf, lv_coord_t src_stride, const lv_point_t * src_offset);
 LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_await_dma_transfer_finish(lv_disp_drv_t * disp_drv);
 LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_start_dma_transfer(void);
+
+#if defined (LV_STM32_DMA2D_USE_M7_CACHE)
 LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_invalidate_cache(uint32_t address, lv_coord_t offset,
                                                                 lv_coord_t width, lv_coord_t height, uint8_t pixel_size);
 LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_clean_cache(uint32_t address, lv_coord_t offset, lv_coord_t width,
                                                            lv_coord_t height, uint8_t pixel_size);
-LV_STM32_DMA2D_STATIC bool _lv_gpu_stm32_dwt_init(void);
+#endif
-LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dwt_reset(void);
+
-LV_STM32_DMA2D_STATIC uint32_t _lv_gpu_stm32_dwt_get_us(void);
+#if defined(LV_STM32_DMA2D_TEST)
+    LV_STM32_DMA2D_STATIC bool _lv_gpu_stm32_dwt_init(void);
+    LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dwt_reset(void);
+    LV_STM32_DMA2D_STATIC uint32_t _lv_gpu_stm32_dwt_get_us(void);
+#endif
 
 static bool isDma2dInProgess = false; // indicates whether DMA2D transfer *initiated here* is in progress
 
@@ -77,21 +96,21 @@ static bool isDma2dInProgess = false; // indicates whether DMA2D transfer *initi
 void lv_draw_stm32_dma2d_init(void)
 {
     // Enable DMA2D clock
-#if defined(STM32F4) || defined(STM32F7)
+#if defined(STM32F4) || defined(STM32F7) || defined(STM32U5)
     RCC->AHB1ENR |= RCC_AHB1ENR_DMA2DEN; // enable DMA2D
+    // wait for hardware access to complete
+    __asm volatile("DSB\n");
+    volatile uint32_t temp = RCC->AHB1ENR;
+    LV_UNUSED(temp);
 #elif defined(STM32H7)
     RCC->AHB3ENR |= RCC_AHB3ENR_DMA2DEN;
+    // wait for hardware access to complete
+    __asm volatile("DSB\n");
+    volatile uint32_t temp = RCC->AHB3ENR;
+    LV_UNUSED(temp);
 #else
 # warning "LVGL can't enable the clock of DMA2D"
 #endif
-
-    // Wait for hardware access to complete
-    __asm volatile("DSB\n");
-
-    // Delay after setting peripheral clock
-    volatile uint32_t temp = RCC->AHB1ENR;
-    LV_UNUSED(temp);
-
     // AHB master timer configuration
     DMA2D->AMTCR = 0; // AHB bus guaranteed dead time disabled
 #if defined(LV_STM32_DMA2D_TEST)
@@ -206,7 +225,7 @@ static void lv_draw_stm32_dma2d_blend(lv_draw_ctx_t * draw_ctx, const lv_draw_sw
             // lv_coord_t draw_width = lv_area_get_width(&draw_area);
             // lv_coord_t draw_height = lv_area_get_height(&draw_area);
             // uint32_t dest_address = (uint32_t)(draw_ctx->buf + (dest_stride * draw_area.y1) + draw_area.x1);
-            // _lv_gpu_stm32_dma2d_clean_cache(dest_address, dest_stride - draw_width, draw_width, draw_height, sizeof(lv_color_t));
+            // __lv_gpu_stm32_dma2d_clean_cache(dest_address, dest_stride - draw_width, draw_width, draw_height, sizeof(lv_color_t));
 #endif
         }
     }
@@ -412,7 +431,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_fill(const lv_color_t * de
         DMA2D->BGMAR = (uint32_t)(dest_buf + (dest_stride * draw_area->y1) + draw_area->x1);
         DMA2D->BGOR = dest_stride - draw_width;
         DMA2D->BGCOLR = 0;  // used in A4 and A8 modes only
-        _lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
+        __lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
 
         DMA2D->OPFCCR = LvglColorFormat;
 #if defined(DMA2D_OPFCCR_RBS_Pos)
@@ -500,7 +519,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_map(const lv_color_t * des
     DMA2D->FGMAR = ((uint32_t)src_buf) + srcBpp * ((src_stride * src_offset->y) + src_offset->x);
     DMA2D->FGOR = src_stride - draw_width;
     DMA2D->FGCOLR = 0;  // used in A4 and A8 modes only
-    _lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, srcBpp);
+    __lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, srcBpp);
 
     DMA2D->OPFCCR = LvglColorFormat;
 #if defined(DMA2D_OPFCCR_RBS_Pos)
@@ -519,7 +538,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_map(const lv_color_t * des
         DMA2D->BGMAR = DMA2D->OMAR;
         DMA2D->BGOR = DMA2D->OOR;
         DMA2D->BGCOLR = 0;  // used in A4 and A8 modes only
-        _lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
+        __lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
     }
 
     // PL - pixel per lines (14 bit), NL - number of lines (16 bit)
@@ -556,7 +575,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_paint(const lv_color_t * d
     DMA2D->FGMAR = (uint32_t)(mask_buf + (mask_stride * mask_offset->y) + mask_offset->x);
     DMA2D->FGOR = mask_stride - draw_width;
     DMA2D->FGCOLR = lv_color_to32(color) & 0x00ffffff;  // swap FGCOLR R/B bits if FGPFCCR.RBS (RBS_BIT) bit is set
-    _lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, sizeof(lv_opa_t));
+    __lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, sizeof(lv_opa_t));
 
     DMA2D->BGPFCCR = LvglColorFormat;
 #if defined(DMA2D_BGPFCCR_RBS_Pos)
@@ -565,7 +584,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_blend_paint(const lv_color_t * d
     DMA2D->BGMAR = (uint32_t)(dest_buf + (dest_stride * draw_area->y1) + draw_area->x1);
     DMA2D->BGOR = dest_stride - draw_width;
     DMA2D->BGCOLR = 0;  // used in A4 and A8 modes only
-    _lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
+    __lv_gpu_stm32_dma2d_clean_cache(DMA2D->BGMAR, DMA2D->BGOR, draw_width, draw_height, sizeof(lv_color_t));
 
     DMA2D->OPFCCR = LvglColorFormat;
 #if defined(DMA2D_OPFCCR_RBS_Pos)
@@ -602,7 +621,7 @@ LV_STM32_DMA2D_STATIC void _lv_draw_stm32_dma2d_copy_buffer(const lv_color_t * d
     DMA2D->FGMAR = (uint32_t)(src_buf + (src_stride * src_offset->y) + src_offset->x);
     DMA2D->FGOR = src_stride - draw_width;
     DMA2D->FGCOLR = 0;  // used in A4 and A8 modes only
-    _lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, sizeof(lv_color_t));
+    __lv_gpu_stm32_dma2d_clean_cache(DMA2D->FGMAR, DMA2D->FGOR, draw_width, draw_height, sizeof(lv_color_t));
 
     // Note BG* registers do not need to be set up since BG is not used
 
@@ -627,8 +646,8 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_start_dma_transfer(void)
     DMA2D->IFCR = 0x3FU; // trigger ISR flags reset
     // Note: cleaning output buffer cache is needed only when buffer may be misaligned or adjacent area may have been drawn in sw-fashion, e.g. using lv_draw_sw_blend_basic()
 #if LV_COLOR_DEPTH == 16
-    _lv_gpu_stm32_dma2d_clean_cache(DMA2D->OMAR, DMA2D->OOR, (DMA2D->NLR & DMA2D_NLR_PL_Msk) >> DMA2D_NLR_PL_Pos,
+    __lv_gpu_stm32_dma2d_clean_cache(DMA2D->OMAR, DMA2D->OOR, (DMA2D->NLR & DMA2D_NLR_PL_Msk) >> DMA2D_NLR_PL_Pos,
-                                    (DMA2D->NLR & DMA2D_NLR_NL_Msk) >> DMA2D_NLR_NL_Pos, sizeof(lv_color_t));
+                                     (DMA2D->NLR & DMA2D_NLR_NL_Msk) >> DMA2D_NLR_NL_Pos, sizeof(lv_color_t));
 #endif
     DMA2D->CR |= DMA2D_CR_START;
     // Note: for some reason mask buffer gets damaged during transfer if waiting is postponed
@@ -660,15 +679,16 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_await_dma_transfer_finish(lv_disp
 
     if(isDma2dInProgess) {
         // invalidate output buffer cached memory ONLY after DMA2D transfer
-        //_lv_gpu_stm32_dma2d_invalidate_cache(DMA2D->OMAR, DMA2D->OOR, (DMA2D->NLR & DMA2D_NLR_PL_Msk) >> DMA2D_NLR_PL_Pos, (DMA2D->NLR & DMA2D_NLR_NL_Msk) >> DMA2D_NLR_NL_Pos, sizeof(lv_color_t));
+        //__lv_gpu_stm32_dma2d_invalidate_cache(DMA2D->OMAR, DMA2D->OOR, (DMA2D->NLR & DMA2D_NLR_PL_Msk) >> DMA2D_NLR_PL_Pos, (DMA2D->NLR & DMA2D_NLR_NL_Msk) >> DMA2D_NLR_NL_Pos, sizeof(lv_color_t));
         isDma2dInProgess = false;
     }
 }
 
+#if defined (LV_STM32_DMA2D_USE_M7_CACHE)
+// Cortex-M7 DCache present
 LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_invalidate_cache(uint32_t address, lv_coord_t offset, lv_coord_t width,
                                                                 lv_coord_t height, uint8_t pixel_size)
 {
-#if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
     if(((SCB->CCR) & SCB_CCR_DC_Msk) == 0) return; // L1 data cache is disabled
     uint16_t stride = pixel_size * (width + offset); // in bytes
     uint16_t ll = pixel_size * width; // line length in bytes
@@ -694,13 +714,11 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_invalidate_cache(uint32_t address
 
     __DSB();
     __ISB();
-#endif
 }
 
 LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_clean_cache(uint32_t address, lv_coord_t offset, lv_coord_t width,
                                                            lv_coord_t height, uint8_t pixel_size)
 {
-#if defined (__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1U)
     if(((SCB->CCR) & SCB_CCR_DC_Msk) == 0) return; // L1 data cache is disabled
     uint16_t stride = pixel_size * (width + offset); // in bytes
     uint16_t ll = pixel_size * width; // line length in bytes
@@ -725,9 +743,10 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dma2d_clean_cache(uint32_t address, lv_
 
     __DSB();
     __ISB();
-#endif
 }
+#endif // LV_STM32_DMA2D_USE_M7_CACHE
 
+#if defined(LV_STM32_DMA2D_TEST)
 // initialize µs timer
 LV_STM32_DMA2D_STATIC bool _lv_gpu_stm32_dwt_init(void)
 {
@@ -773,5 +792,5 @@ LV_STM32_DMA2D_STATIC void _lv_gpu_stm32_dwt_reset(void)
 {
     DWT->CYCCNT = 0;
 }
-
+#endif // LV_STM32_DMA2D_TEST
-#endif
+#endif // LV_USE_GPU_STM32_DMA2D

lib/libesp32_lvgl/lvgl/src/draw/sw/lv_draw_sw_letter.c

@@ -103,7 +103,7 @@ void lv_draw_sw_letter(lv_draw_ctx_t * draw_ctx, const lv_draw_label_dsc_t * dsc
         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+%" PRIX32, letter);
+            LV_LOG_WARN("lv_draw_letter: glyph dsc. not found for U+%" LV_PRIX32, letter);
 
 #if LV_USE_FONT_PLACEHOLDER
             /* draw placeholder */

lib/libesp32_lvgl/lvgl/src/draw/sw/lv_draw_sw_transform.c

@@ -273,7 +273,7 @@ static void argb_and_rgb_aa(const uint8_t * src, lv_coord_t src_w, lv_coord_t sr
     int32_t ys_ups_start = ys_ups;
     bool has_alpha;
     int32_t px_size;
-    lv_color_t ck = {0};
+    lv_color_t ck = _LV_COLOR_ZERO_INITIALIZER;
     switch(cf) {
         case LV_IMG_CF_TRUE_COLOR:
             has_alpha = false;

lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fs_littlefs.c

@@ -0,0 +1,332 @@
+/**
+ * @file lv_fs_littlefs.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lvgl.h"
+
+#if LV_USE_FS_LITTLEFS
+#include "lfs.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+#if LV_FS_LITTLEFS_LETTER == '\0'
+    #error "LV_FS_LITTLEFS_LETTER must be an upper case ASCII letter"
+#endif
+
+/**********************
+ *      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
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_fs_littlefs_init(void)
+{
+    /*----------------------------------------------------
+     * Initialize your storage device and File System
+     * -------------------------------------------------*/
+    fs_init();
+
+    /*---------------------------------------------------
+     * Register the file system interface in LVGL
+     *--------------------------------------------------*/
+
+    /*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_FS_LITTLEFS_LETTER;
+    fs_drv.cache_size = LV_FS_LITTLEFS_CACHE_SIZE;
+
+    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_open_cb = fs_dir_open;
+    fs_drv.dir_close_cb = fs_dir_close;
+    fs_drv.dir_read_cb = fs_dir_read;
+
+    /*#if LV_USE_USER_DATA*/
+    fs_drv.user_data = NULL;
+    /*#endif*/
+
+    lv_fs_drv_register(&fs_drv);
+}
+
+/**
+ * Convenience function to attach registered driver to lfs_t structure by driver-label
+ * @param label     the label assigned to the driver when it was registered
+ * @param lfs_p     the pointer to the lfs_t structure initialized by external code/library
+ * @return          pointer to a driver descriptor or NULL on error
+ */
+lv_fs_drv_t * lv_fs_littlefs_set_driver(char label, void * lfs_p)
+{
+    lv_fs_drv_t * drv_p = lv_fs_get_drv(label);
+    if(drv_p != NULL) drv_p->user_data = (lfs_t *) lfs_p;
+    return drv_p;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/*Initialize your Storage device and File system.*/
+static void fs_init(void)
+{
+    /* Initialize the internal flash or SD-card and LittleFS 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 a file descriptor or NULL on error
+ */
+static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
+{
+    lfs_t * lfs_p = drv->user_data;
+    uint32_t flags = 0;
+
+    flags = mode == LV_FS_MODE_RD ? LFS_O_RDONLY
+            : mode == LV_FS_MODE_WR ? LFS_O_WRONLY
+            : mode == (LV_FS_MODE_WR | LV_FS_MODE_RD) ? LFS_O_RDWR : 0;
+
+    lfs_file_t * file_p = lv_mem_alloc(sizeof(lfs_file_t));
+    if(file_p == NULL) return NULL;
+
+    int result = lfs_file_open(lfs_p, file_p, path, flags);
+
+    if(result != LFS_ERR_OK) {
+        lv_mem_free(file_p);
+        return NULL;
+    }
+
+    return file_p;
+}
+
+/**
+ * Close an opened file
+ * @param drv       pointer to a driver where this function belongs
+ * @param file_p    pointer to a file_t variable. (opened with fs_open)
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
+{
+    lfs_t * lfs_p = drv->user_data;
+
+    int result = lfs_file_close(lfs_p, file_p);
+    lv_mem_free(file_p);
+    /*lv_mem_free( lfs_p );*/ /*allocated and freed by outside-code*/
+
+    if(result != LFS_ERR_OK) return LV_FS_RES_UNKNOWN;
+    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_t 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 or  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)
+{
+    lfs_t * lfs_p = drv->user_data;
+
+    lfs_ssize_t result = lfs_file_read(lfs_p, file_p, buf, btr);
+    if(result < 0) return LV_FS_RES_UNKNOWN;
+
+    *br = (uint32_t) result;
+    return 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_t variable
+ * @param buf       pointer to a buffer with the bytes to write
+ * @param btw       Bytes To Write
+ * @param bw        the number of real written bytes (Bytes Written). NULL if unused.
+ * @return          LV_FS_RES_OK: no error 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)
+{
+#ifndef LFS_READONLY
+    lfs_t * lfs_p = drv->user_data;
+
+    lfs_ssize_t result = lfs_file_write(lfs_p, file_p, buf, btw);
+    if(result < 0 || lfs_file_sync(lfs_p, file_p) < 0) return LV_FS_RES_UNKNOWN;
+
+    *bw = (uint32_t) result;
+    return LV_FS_RES_OK;
+#else
+    return LV_FS_RES_NOT_IMP;
+#endif
+}
+
+/**
+ * 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_t variable. (opened with fs_open )
+ * @param pos       the new position of read write pointer
+ * @param whence    tells from where to interpret the `pos`. See @lv_fs_whence_t
+ * @return          LV_FS_RES_OK: no error or  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)
+{
+    lfs_t * lfs_p = drv->user_data;
+
+    int lfs_whence = whence == LV_FS_SEEK_SET ? LFS_SEEK_SET
+                     : whence == LV_FS_SEEK_CUR ? LFS_SEEK_CUR
+                     : whence == LV_FS_SEEK_END ? LFS_SEEK_END : 0;
+
+    lfs_soff_t result = lfs_file_seek(lfs_p, file_p, pos, lfs_whence);
+    if(result < 0) return LV_FS_RES_UNKNOWN;
+
+    /*pos = result;*/ /*not supported by lv_fs*/
+    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_t variable.
+ * @param pos_p     pointer to where to store the result
+ * @return          LV_FS_RES_OK: no error or  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)
+{
+    lfs_t * lfs_p = drv->user_data;
+
+    lfs_soff_t result = lfs_file_tell(lfs_p, file_p);
+    if(result < 0) return LV_FS_RES_UNKNOWN;
+
+    *pos_p = (uint32_t) result;
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Initialize a 'lv_fs_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 the directory read descriptor or NULL on error
+ */
+static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
+{
+    lfs_t * lfs_p = drv->user_data;
+
+    lfs_dir_t * dir_p = lv_mem_alloc(sizeof(lfs_dir_t));
+    if(dir_p == NULL) return NULL;
+
+    int result = lfs_dir_open(lfs_p, dir_p, path);
+    if(result != LFS_ERR_OK) {
+        lv_mem_free(dir_p);
+        return NULL;
+    }
+
+    return dir_p;
+}
+
+/**
+ * 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 rddir_p   pointer to an initialized 'lv_fs_dir_t' variable
+ * @param fn        pointer to a buffer to store the filename
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_read(lv_fs_drv_t * drv, void * rddir_p, char * fn)
+{
+    lfs_t * lfs_p = drv->user_data;
+    struct lfs_info info;
+    int result;
+
+    info.name[0] = '\0';
+
+    do {
+        result = lfs_dir_read(lfs_p, rddir_p, &info);
+        if(result > 0) {
+            if(info.type == LFS_TYPE_DIR) {
+                fn[0] = '/';
+                strcpy(&fn[1], info.name);
+            }
+            else strcpy(fn, info.name);
+        }
+        else if(result == 0) fn[0] = '\0'; /*dir-scan ended*/
+        else return LV_FS_RES_UNKNOWN;
+
+    } while(!strcmp(fn, "/.") || !strcmp(fn, "/.."));
+
+    return LV_FS_RES_OK;
+}
+
+/**
+ * Close the directory reading
+ * @param drv       pointer to a driver where this function belongs
+ * @param rddir_p   pointer to an initialized 'lv_fs_dir_t' variable
+ * @return          LV_FS_RES_OK: no error or  any error from @lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_close(lv_fs_drv_t * drv, void * rddir_p)
+{
+    lfs_t * lfs_p = drv->user_data;
+
+    int result = lfs_dir_close(lfs_p, rddir_p);
+    lv_mem_free(rddir_p);
+
+    if(result != LFS_ERR_OK) return LV_FS_RES_UNKNOWN;
+    return LV_FS_RES_OK;
+}
+
+#else /*LV_USE_FS_LITTLEFS == 0*/
+
+#if defined(LV_FS_LITTLEFS_LETTER) && LV_FS_LITTLEFS_LETTER != '\0'
+    #warning "LV_USE_FS_LITTLEFS is not enabled but LV_FS_LITTLEFS_LETTER is set"
+#endif
+
+#endif /*LV_USE_FS_POSIX*/

lib/libesp32_lvgl/lvgl/src/extra/libs/fsdrv/lv_fsdrv.h

@@ -31,6 +31,11 @@ extern "C" {
 void lv_fs_fatfs_init(void);
 #endif
 
+#if LV_USE_FS_LITTLEFS != '\0'
+void lv_fs_littlefs_init(void);
+lv_fs_drv_t * lv_fs_littlefs_set_driver(char label, void * lfs_p);
+#endif
+
 #if LV_USE_FS_STDIO != '\0'
 void lv_fs_stdio_init(void);
 #endif

lib/libesp32_lvgl/lvgl/src/extra/libs/lv_libs.h

@@ -22,6 +22,7 @@ extern "C" {
 #include "freetype/lv_freetype.h"
 #include "rlottie/lv_rlottie.h"
 #include "ffmpeg/lv_ffmpeg.h"
+#include "tiny_ttf/lv_tiny_ttf.h"
 
 /*********************
  *      DEFINES

lib/libesp32_lvgl/lvgl/src/extra/libs/qrcode/qrcodegen.c

@@ -21,11 +21,11 @@
  *   Software.
  */
 
-#include <assert.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "qrcodegen.h"
+#include "../../../misc/lv_assert.h"
 
 #ifndef QRCODEGEN_TEST
 	#define testable static  // Keep functions private
@@ -127,12 +127,12 @@ static const int PENALTY_N4 = 10;
 // Public function - see documentation comment in header file.
 bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
 		enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl) {
-	
+
 	size_t textLen = strlen(text);
 	if (textLen == 0)
 		return qrcodegen_encodeSegmentsAdvanced(NULL, 0, ecl, minVersion, maxVersion, mask, boostEcl, tempBuffer, qrcode);
 	size_t bufLen = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion);
-	
+
 	struct qrcodegen_Segment seg;
 	if (qrcodegen_isNumeric(text)) {
 		if (qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_NUMERIC, textLen) > bufLen)
@@ -155,7 +155,7 @@ bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode
 		seg.data = tempBuffer;
 	}
 	return qrcodegen_encodeSegmentsAdvanced(&seg, 1, ecl, minVersion, maxVersion, mask, boostEcl, tempBuffer, qrcode);
-	
+
 fail:
 	qrcode[0] = 0;  // Set size to invalid value for safety
 	return false;
@@ -165,7 +165,7 @@ fail:
 // Public function - see documentation comment in header file.
 bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
 		enum qrcodegen_Ecc ecl, int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl) {
-	
+
 	struct qrcodegen_Segment seg;
 	seg.mode = qrcodegen_Mode_BYTE;
 	seg.bitLength = calcSegmentBitLength(seg.mode, dataLen);
@@ -182,7 +182,7 @@ bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcod
 // Appends the given number of low-order bits of the given value to the given byte-based
 // bit buffer, increasing the bit length. Requires 0 <= numBits <= 16 and val < 2^numBits.
 testable void appendBitsToBuffer(unsigned int val, int numBits, uint8_t buffer[], int *bitLen) {
-	assert(0 <= numBits && numBits <= 16 && (unsigned long)val >> numBits == 0);
+	LV_ASSERT(0 <= numBits && numBits <= 16 && (unsigned long)val >> numBits == 0);
 	for (int i = numBits - 1; i >= 0; i--, (*bitLen)++)
 		buffer[*bitLen >> 3] |= ((val >> i) & 1) << (7 - (*bitLen & 7));
 }
@@ -202,10 +202,10 @@ bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
 // Public function - see documentation comment in header file.
 bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
 		int minVersion, int maxVersion, int mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]) {
-	assert(segs != NULL || len == 0);
+	LV_ASSERT(segs != NULL || len == 0);
-	assert(qrcodegen_VERSION_MIN <= minVersion && minVersion <= maxVersion && maxVersion <= qrcodegen_VERSION_MAX);
+	LV_ASSERT(qrcodegen_VERSION_MIN <= minVersion && minVersion <= maxVersion && maxVersion <= qrcodegen_VERSION_MAX);
-	assert(0 <= (int)ecl && (int)ecl <= 3 && -1 <= (int)mask && (int)mask <= 7);
+	LV_ASSERT(0 <= (int)ecl && (int)ecl <= 3 && -1 <= (int)mask && (int)mask <= 7);
-	
+
 	// Find the minimal version number to use
 	int version, dataUsedBits;
 	for (version = minVersion; ; version++) {
@@ -218,14 +218,14 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
 			return false;
 		}
 	}
-	assert(dataUsedBits != -1);
+	LV_ASSERT(dataUsedBits != -1);
-	
+
 	// Increase the error correction level while the data still fits in the current version number
 	for (int i = (int)qrcodegen_Ecc_MEDIUM; i <= (int)qrcodegen_Ecc_HIGH; i++) {  // From low to high
 		if (boostEcl && dataUsedBits <= getNumDataCodewords(version, (enum qrcodegen_Ecc)i) * 8)
 			ecl = (enum qrcodegen_Ecc)i;
 	}
-	
+
 	// Concatenate all segments to create the data bit string
 	memset(qrcode, 0, qrcodegen_BUFFER_LEN_FOR_VERSION(version) * sizeof(qrcode[0]));
 	int bitLen = 0;
@@ -236,29 +236,29 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
 		for (int j = 0; j < seg->bitLength; j++)
 			appendBitsToBuffer((seg->data[j >> 3] >> (7 - (j & 7))) & 1, 1, qrcode, &bitLen);
 	}
-	assert(bitLen == dataUsedBits);
+	LV_ASSERT(bitLen == dataUsedBits);
-	
+
 	// Add terminator and pad up to a byte if applicable
 	int dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
-	assert(bitLen <= dataCapacityBits);
+	LV_ASSERT(bitLen <= dataCapacityBits);
 	int terminatorBits = dataCapacityBits - bitLen;
 	if (terminatorBits > 4)
 		terminatorBits = 4;
 	appendBitsToBuffer(0, terminatorBits, qrcode, &bitLen);
 	appendBitsToBuffer(0, (8 - bitLen % 8) % 8, qrcode, &bitLen);
-	assert(bitLen % 8 == 0);
+	LV_ASSERT(bitLen % 8 == 0);
-	
+
 	// Pad with alternating bytes until data capacity is reached
 	for (uint8_t padByte = 0xEC; bitLen < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
 		appendBitsToBuffer(padByte, 8, qrcode, &bitLen);
-	
+
 	// Draw function and data codeword modules
 	addEccAndInterleave(qrcode, version, ecl, tempBuffer);
 	initializeFunctionModules(version, qrcode);
 	drawCodewords(tempBuffer, getNumRawDataModules(version) / 8, qrcode);
 	drawWhiteFunctionModules(qrcode, version);
 	initializeFunctionModules(version, tempBuffer);
-	
+
 	// Handle masking
 	if (mask == qrcodegen_Mask_AUTO) {  // Automatically choose best mask
 		long minPenalty = LONG_MAX;
@@ -274,7 +274,7 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
 			applyMask(tempBuffer, qrcode, msk);  // Undoes the mask due to XOR
 		}
 	}
-	assert(0 <= (int)mask && (int)mask <= 7);
+	LV_ASSERT(0 <= (int)mask && (int)mask <= 7);
 	applyMask(tempBuffer, qrcode, mask);
 	drawFormatBits(ecl, mask, qrcode);
 	return true;
@@ -290,14 +290,14 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
 // be clobbered by this function. The final answer is stored in result[0 : rawCodewords].
 testable void addEccAndInterleave(uint8_t data[], int version, enum qrcodegen_Ecc ecl, uint8_t result[]) {
 	// Calculate parameter numbers
-	assert(0 <= (int)ecl && (int)ecl < 4 && qrcodegen_VERSION_MIN <= version && version <= qrcodegen_VERSION_MAX);
+	LV_ASSERT(0 <= (int)ecl && (int)ecl < 4 && qrcodegen_VERSION_MIN <= version && version <= qrcodegen_VERSION_MAX);
 	int numBlocks = NUM_ERROR_CORRECTION_BLOCKS[(int)ecl][version];
 	int blockEccLen = ECC_CODEWORDS_PER_BLOCK  [(int)ecl][version];
 	int rawCodewords = getNumRawDataModules(version) / 8;
 	int dataLen = getNumDataCodewords(version, ecl);
 	int numShortBlocks = numBlocks - rawCodewords % numBlocks;
 	int shortBlockDataLen = rawCodewords / numBlocks - blockEccLen;
-	
+
 	// Split data into blocks, calculate ECC, and interleave
 	// (not concatenate) the bytes into a single sequence
 	uint8_t generator[qrcodegen_REED_SOLOMON_DEGREE_MAX];
@@ -323,7 +323,7 @@ testable void addEccAndInterleave(uint8_t data[], int version, enum qrcodegen_Ec
 // for the given version number and error correction level. The result is in the range [9, 2956].
 testable int getNumDataCodewords(int version, enum qrcodegen_Ecc ecl) {
 	int v = version, e = (int)ecl;
-	assert(0 <= e && e < 4);
+	LV_ASSERT(0 <= e && e < 4);
 	return getNumRawDataModules(v) / 8
 		- ECC_CODEWORDS_PER_BLOCK    [e][v]
 		* NUM_ERROR_CORRECTION_BLOCKS[e][v];
@@ -334,7 +334,7 @@ testable int getNumDataCodewords(int version, enum qrcodegen_Ecc ecl) {
 // all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
 // The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
 testable int getNumRawDataModules(int ver) {
-	assert(qrcodegen_VERSION_MIN <= ver && ver <= qrcodegen_VERSION_MAX);
+	LV_ASSERT(qrcodegen_VERSION_MIN <= ver && ver <= qrcodegen_VERSION_MAX);
 	int result = (16 * ver + 128) * ver + 64;
 	if (ver >= 2) {
 		int numAlign = ver / 7 + 2;
@@ -352,10 +352,10 @@ testable int getNumRawDataModules(int ver) {
 // Calculates the Reed-Solomon generator polynomial of the given degree, storing in result[0 : degree].
 testable void calcReedSolomonGenerator(int degree, uint8_t result[]) {
 	// Start with the monomial x^0
-	assert(1 <= degree && degree <= qrcodegen_REED_SOLOMON_DEGREE_MAX);
+	LV_ASSERT(1 <= degree && degree <= qrcodegen_REED_SOLOMON_DEGREE_MAX);
 	memset(result, 0, degree * sizeof(result[0]));
 	result[degree - 1] = 1;
-	
+
 	// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
 	// drop the highest term, and store the rest of the coefficients in order of descending powers.
 	// Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
@@ -376,9 +376,9 @@ testable void calcReedSolomonGenerator(int degree, uint8_t result[]) {
 // polynomials are in big endian and the generator has an implicit leading 1 term, storing the result in result[0 : degree].
 testable void calcReedSolomonRemainder(const uint8_t data[], int dataLen,
 		const uint8_t generator[], int degree, uint8_t result[]) {
-	
+
 	// Perform polynomial division
-	assert(1 <= degree && degree <= qrcodegen_REED_SOLOMON_DEGREE_MAX);
+	LV_ASSERT(1 <= degree && degree <= qrcodegen_REED_SOLOMON_DEGREE_MAX);
 	memset(result, 0, degree * sizeof(result[0]));
 	for (int i = 0; i < dataLen; i++) {
 		uint8_t factor = data[i] ^ result[0];
@@ -415,16 +415,16 @@ testable void initializeFunctionModules(int version, uint8_t qrcode[]) {
 	int qrsize = version * 4 + 17;
 	memset(qrcode, 0, ((qrsize * qrsize + 7) / 8 + 1) * sizeof(qrcode[0]));
 	qrcode[0] = (uint8_t)qrsize;
-	
+
 	// Fill horizontal and vertical timing patterns
 	fillRectangle(6, 0, 1, qrsize, qrcode);
 	fillRectangle(0, 6, qrsize, 1, qrcode);
-	
+
 	// Fill 3 finder patterns (all corners except bottom right) and format bits
 	fillRectangle(0, 0, 9, 9, qrcode);
 	fillRectangle(qrsize - 8, 0, 8, 9, qrcode);
 	fillRectangle(0, qrsize - 8, 9, 8, qrcode);
-	
+
 	// Fill numerous alignment patterns
 	uint8_t alignPatPos[7];
 	int numAlign = getAlignmentPatternPositions(version, alignPatPos);
@@ -435,7 +435,7 @@ testable void initializeFunctionModules(int version, uint8_t qrcode[]) {
 				fillRectangle(alignPatPos[i] - 2, alignPatPos[j] - 2, 5, 5, qrcode);
 		}
 	}
-	
+
 	// Fill version blocks
 	if (version >= 7) {
 		fillRectangle(qrsize - 11, 0, 3, 6, qrcode);
@@ -454,7 +454,7 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
 		setModule(qrcode, 6, i, false);
 		setModule(qrcode, i, 6, false);
 	}
-	
+
 	// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
 	for (int dy = -4; dy <= 4; dy++) {
 		for (int dx = -4; dx <= 4; dx++) {
@@ -468,7 +468,7 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
 			}
 		}
 	}
-	
+
 	// Draw numerous alignment patterns
 	uint8_t alignPatPos[7];
 	int numAlign = getAlignmentPatternPositions(version, alignPatPos);
@@ -482,7 +482,7 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
 			}
 		}
 	}
-	
+
 	// Draw version blocks
 	if (version >= 7) {
 		// Calculate error correction code and pack bits
@@ -490,8 +490,8 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
 		for (int i = 0; i < 12; i++)
 			rem = (rem << 1) ^ ((rem >> 11) * 0x1F25);
 		long bits = (long)version << 12 | rem;  // uint18
-		assert(bits >> 18 == 0);
+		LV_ASSERT(bits >> 18 == 0);
-		
+
 		// Draw two copies
 		for (int i = 0; i < 6; i++) {
 			for (int j = 0; j < 3; j++) {
@@ -510,15 +510,15 @@ static void drawWhiteFunctionModules(uint8_t qrcode[], int version) {
 // the format bits, unlike drawWhiteFunctionModules() which might skip black modules.
 static void drawFormatBits(enum qrcodegen_Ecc ecl, enum qrcodegen_Mask mask, uint8_t qrcode[]) {
 	// Calculate error correction code and pack bits
-	assert(0 <= (int)mask && (int)mask <= 7);
+	LV_ASSERT(0 <= (int)mask && (int)mask <= 7);
 	static const int table[] = {1, 0, 3, 2};
 	int data = table[(int)ecl] << 3 | (int)mask;  // errCorrLvl is uint2, mask is uint3
 	int rem = data;
 	for (int i = 0; i < 10; i++)
 		rem = (rem << 1) ^ ((rem >> 9) * 0x537);
 	int bits = (data << 10 | rem) ^ 0x5412;  // uint15
-	assert(bits >> 15 == 0);
+	LV_ASSERT(bits >> 15 == 0);
-	
+
 	// Draw first copy
 	for (int i = 0; i <= 5; i++)
 		setModule(qrcode, 8, i, getBit(bits, i));
@@ -527,7 +527,7 @@ static void drawFormatBits(enum qrcodegen_Ecc ecl, enum qrcodegen_Mask mask, uin
 	setModule(qrcode, 7, 8, getBit(bits, 8));
 	for (int i = 9; i < 15; i++)
 		setModule(qrcode, 14 - i, 8, getBit(bits, i));
-	
+
 	// Draw second copy
 	int qrsize = qrcodegen_getSize(qrcode);
 	for (int i = 0; i < 8; i++)
@@ -591,7 +591,7 @@ static void drawCodewords(const uint8_t data[], int dataLen, uint8_t qrcode[]) {
 			}
 		}
 	}
-	assert(i == dataLen * 8);
+	LV_ASSERT(i == dataLen * 8);
 }
 
 
@@ -601,7 +601,7 @@ static void drawCodewords(const uint8_t data[], int dataLen, uint8_t qrcode[]) {
 // the same mask value a second time will undo the mask. A final well-formed
 // QR Code needs exactly one (not zero, two, etc.) mask applied.
 static void applyMask(const uint8_t functionModules[], uint8_t qrcode[], enum qrcodegen_Mask mask) {
-	assert(0 <= (int)mask && (int)mask <= 7);  // Disallows qrcodegen_Mask_AUTO
+	LV_ASSERT(0 <= (int)mask && (int)mask <= 7);  // Disallows qrcodegen_Mask_AUTO
 	int qrsize = qrcodegen_getSize(qrcode);
 	for (int y = 0; y < qrsize; y++) {
 		for (int x = 0; x < qrsize; x++) {
@@ -617,7 +617,7 @@ static void applyMask(const uint8_t functionModules[], uint8_t qrcode[], enum qr
 				case 5:  invert = x * y % 2 + x * y % 3 == 0;          break;
 				case 6:  invert = (x * y % 2 + x * y % 3) % 2 == 0;    break;
 				case 7:  invert = ((x + y) % 2 + x * y % 3) % 2 == 0;  break;
-				default:  assert(false);  return;
+				default:  LV_ASSERT(false);  return;
 			}
 			bool val = getModule(qrcode, x, y);
 			setModule(qrcode, x, y, val ^ invert);
@@ -631,7 +631,7 @@ static void applyMask(const uint8_t functionModules[], uint8_t qrcode[], enum qr
 static long getPenaltyScore(const uint8_t qrcode[]) {
 	int qrsize = qrcodegen_getSize(qrcode);
 	long result = 0;
-	
+
 	// Adjacent modules in row having same color, and finder-like patterns
 	for (int y = 0; y < qrsize; y++) {
 		unsigned char runHistory[7] = {0};
@@ -684,7 +684,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
 		if (hasFinderLikePattern(runHistory))
 			result += PENALTY_N3;
 	}
-	
+
 	// 2*2 blocks of modules having same color
 	for (int y = 0; y < qrsize - 1; y++) {
 		for (int x = 0; x < qrsize - 1; x++) {
@@ -695,7 +695,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
 				result += PENALTY_N2;
 		}
 	}
-	
+
 	// Balance of black and white modules
 	int black = 0;
 	for (int y = 0; y < qrsize; y++) {
@@ -737,9 +737,9 @@ static bool hasFinderLikePattern(const unsigned char runHistory[7]) {
 
 // Public function - see documentation comment in header file.
 int qrcodegen_getSize(const uint8_t qrcode[]) {
-	assert(qrcode != NULL);
+	LV_ASSERT(qrcode != NULL);
 	int result = qrcode[0];
-	assert((qrcodegen_VERSION_MIN * 4 + 17) <= result
+	LV_ASSERT((qrcodegen_VERSION_MIN * 4 + 17) <= result
 		&& result <= (qrcodegen_VERSION_MAX * 4 + 17));
 	return result;
 }
@@ -747,7 +747,7 @@ int qrcodegen_getSize(const uint8_t qrcode[]) {
 
 // Public function - see documentation comment in header file.
 bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y) {
-	assert(qrcode != NULL);
+	LV_ASSERT(qrcode != NULL);
 	int qrsize = qrcode[0];
 	return (0 <= x && x < qrsize && 0 <= y && y < qrsize) && getModule(qrcode, x, y);
 }
@@ -756,7 +756,7 @@ bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y) {
 // Gets the module at the given coordinates, which must be in bounds.
 testable bool getModule(const uint8_t qrcode[], int x, int y) {
 	int qrsize = qrcode[0];
-	assert(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
+	LV_ASSERT(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
 	int index = y * qrsize + x;
 	return getBit(qrcode[(index >> 3) + 1], index & 7);
 }
@@ -765,7 +765,7 @@ testable bool getModule(const uint8_t qrcode[], int x, int y) {
 // Sets the module at the given coordinates, which must be in bounds.
 testable void setModule(uint8_t qrcode[], int x, int y, bool isBlack) {
 	int qrsize = qrcode[0];
-	assert(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
+	LV_ASSERT(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
 	int index = y * qrsize + x;
 	int bitIndex = index & 7;
 	int byteIndex = (index >> 3) + 1;
@@ -795,7 +795,7 @@ static bool getBit(int x, int i) {
 
 // Public function - see documentation comment in header file.
 bool qrcodegen_isAlphanumeric(const char *text) {
-	assert(text != NULL);
+	LV_ASSERT(text != NULL);
 	for (; *text != '\0'; text++) {
 		if (strchr(ALPHANUMERIC_CHARSET, *text) == NULL)
 			return false;
@@ -806,7 +806,7 @@ bool qrcodegen_isAlphanumeric(const char *text) {
 
 // Public function - see documentation comment in header file.
 bool qrcodegen_isNumeric(const char *text) {
-	assert(text != NULL);
+	LV_ASSERT(text != NULL);
 	for (; *text != '\0'; text++) {
 		if (*text < '0' || *text > '9')
 			return false;
@@ -820,7 +820,7 @@ size_t qrcodegen_calcSegmentBufferSize(enum qrcodegen_Mode mode, size_t numChars
 	int temp = calcSegmentBitLength(mode, numChars);
 	if (temp == -1)
 		return SIZE_MAX;
-	assert(0 <= temp && temp <= INT16_MAX);
+	LV_ASSERT(0 <= temp && temp <= INT16_MAX);
 	return ((size_t)temp + 7) / 8;
 }
 
@@ -849,10 +849,10 @@ testable int calcSegmentBitLength(enum qrcodegen_Mode mode, size_t numChars) {
 	else if (mode == qrcodegen_Mode_ECI && numChars == 0)
 		result = 3 * 8;
 	else {  // Invalid argument
-		assert(false);
+		LV_ASSERT(false);
 		return -1;
 	}
-	assert(result >= 0);
+	LV_ASSERT(result >= 0);
 	if ((unsigned int)result > (unsigned int)INT16_MAX)
 		return -1;
 	return (int)result;
@@ -861,11 +861,11 @@ testable int calcSegmentBitLength(enum qrcodegen_Mode mode, size_t numChars) {
 
 // Public function - see documentation comment in header file.
 struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, uint8_t buf[]) {
-	assert(data != NULL || len == 0);
+	LV_ASSERT(data != NULL || len == 0);
 	struct qrcodegen_Segment result;
 	result.mode = qrcodegen_Mode_BYTE;
 	result.bitLength = calcSegmentBitLength(result.mode, len);
-	assert(result.bitLength != -1);
+	LV_ASSERT(result.bitLength != -1);
 	result.numChars = (int)len;
 	if (len > 0)
 		memcpy(buf, data, len * sizeof(buf[0]));
@@ -876,22 +876,22 @@ struct qrcodegen_Segment qrcodegen_makeBytes(const uint8_t data[], size_t len, u
 
 // Public function - see documentation comment in header file.
 struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]) {
-	assert(digits != NULL);
+	LV_ASSERT(digits != NULL);
 	struct qrcodegen_Segment result;
 	size_t len = strlen(digits);
 	result.mode = qrcodegen_Mode_NUMERIC;
 	int bitLen = calcSegmentBitLength(result.mode, len);
-	assert(bitLen != -1);
+	LV_ASSERT(bitLen != -1);
 	result.numChars = (int)len;
 	if (bitLen > 0)
 		memset(buf, 0, ((size_t)bitLen + 7) / 8 * sizeof(buf[0]));
 	result.bitLength = 0;
-	
+
 	unsigned int accumData = 0;
 	int accumCount = 0;
 	for (; *digits != '\0'; digits++) {
 		char c = *digits;
-		assert('0' <= c && c <= '9');
+		LV_ASSERT('0' <= c && c <= '9');
 		accumData = accumData * 10 + (unsigned int)(c - '0');
 		accumCount++;
 		if (accumCount == 3) {
@@ -902,7 +902,7 @@ struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]
 	}
 	if (accumCount > 0)  // 1 or 2 digits remaining
 		appendBitsToBuffer(accumData, accumCount * 3 + 1, buf, &result.bitLength);
-	assert(result.bitLength == bitLen);
+	LV_ASSERT(result.bitLength == bitLen);
 	result.data = buf;
 	return result;
 }
@@ -910,22 +910,22 @@ struct qrcodegen_Segment qrcodegen_makeNumeric(const char *digits, uint8_t buf[]
 
 // Public function - see documentation comment in header file.
 struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t buf[]) {
-	assert(text != NULL);
+	LV_ASSERT(text != NULL);
 	struct qrcodegen_Segment result;
 	size_t len = strlen(text);
 	result.mode = qrcodegen_Mode_ALPHANUMERIC;
 	int bitLen = calcSegmentBitLength(result.mode, len);
-	assert(bitLen != -1);
+	LV_ASSERT(bitLen != -1);
 	result.numChars = (int)len;
 	if (bitLen > 0)
 		memset(buf, 0, ((size_t)bitLen + 7) / 8 * sizeof(buf[0]));
 	result.bitLength = 0;
-	
+
 	unsigned int accumData = 0;
 	int accumCount = 0;
 	for (; *text != '\0'; text++) {
 		const char *temp = strchr(ALPHANUMERIC_CHARSET, *text);
-		assert(temp != NULL);
+		LV_ASSERT(temp != NULL);
 		accumData = accumData * 45 + (unsigned int)(temp - ALPHANUMERIC_CHARSET);
 		accumCount++;
 		if (accumCount == 2) {
@@ -936,7 +936,7 @@ struct qrcodegen_Segment qrcodegen_makeAlphanumeric(const char *text, uint8_t bu
 	}
 	if (accumCount > 0)  // 1 character remaining
 		appendBitsToBuffer(accumData, 6, buf, &result.bitLength);
-	assert(result.bitLength == bitLen);
+	LV_ASSERT(result.bitLength == bitLen);
 	result.data = buf;
 	return result;
 }
@@ -949,7 +949,7 @@ struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]) {
 	result.numChars = 0;
 	result.bitLength = 0;
 	if (assignVal < 0) {
-		assert(false);
+		LV_ASSERT(false);
 	} else if (assignVal < (1 << 7)) {
 		memset(buf, 0, 1 * sizeof(buf[0]));
 		appendBitsToBuffer(assignVal, 8, buf, &result.bitLength);
@@ -963,7 +963,7 @@ struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]) {
 		appendBitsToBuffer(assignVal >> 10, 11, buf, &result.bitLength);
 		appendBitsToBuffer(assignVal & 0x3FF, 10, buf, &result.bitLength);
 	} else {
-		assert(false);
+		LV_ASSERT(false);
 	}
 	result.data = buf;
 	return result;
@@ -974,22 +974,22 @@ struct qrcodegen_Segment qrcodegen_makeEci(long assignVal, uint8_t buf[]) {
 // Returns a non-negative number if successful. Otherwise returns -1 if a segment has too
 // many characters to fit its length field, or the total bits exceeds INT16_MAX.
 testable int getTotalBits(const struct qrcodegen_Segment segs[], size_t len, int version) {
-	assert(segs != NULL || len == 0);
+	LV_ASSERT(segs != NULL || len == 0);
 	long result = 0;
 	for (size_t i = 0; i < len; i++) {
 		int numChars  = segs[i].numChars;
 		int bitLength = segs[i].bitLength;
-		assert(0 <= numChars  && numChars  <= INT16_MAX);
+		LV_ASSERT(0 <= numChars  && numChars  <= INT16_MAX);
-		assert(0 <= bitLength && bitLength <= INT16_MAX);
+		LV_ASSERT(0 <= bitLength && bitLength <= INT16_MAX);
 		int ccbits = numCharCountBits(segs[i].mode, version);
-		assert(0 <= ccbits && ccbits <= 16);
+		LV_ASSERT(0 <= ccbits && ccbits <= 16);
 		if (numChars >= (1L << ccbits))
 			return -1;  // The segment's length doesn't fit the field's bit width
 		result += 4L + ccbits + bitLength;
 		if (result > INT16_MAX)
 			return -1;  // The sum might overflow an int type
 	}
-	assert(0 <= result && result <= INT16_MAX);
+	LV_ASSERT(0 <= result && result <= INT16_MAX);
 	return (int)result;
 }
 
@@ -997,7 +997,7 @@ testable int getTotalBits(const struct qrcodegen_Segment segs[], size_t len, int
 // Returns the bit width of the character count field for a segment in the given mode
 // in a QR Code at the given version number. The result is in the range [0, 16].
 static int numCharCountBits(enum qrcodegen_Mode mode, int version) {
-	assert(qrcodegen_VERSION_MIN <= version && version <= qrcodegen_VERSION_MAX);
+	LV_ASSERT(qrcodegen_VERSION_MIN <= version && version <= qrcodegen_VERSION_MAX);
 	int i = (version + 7) / 17;
 	switch (mode) {
 		case qrcodegen_Mode_NUMERIC     : { static const int temp[] = {10, 12, 14}; return temp[i]; }
@@ -1005,7 +1005,7 @@ static int numCharCountBits(enum qrcodegen_Mode mode, int version) {
 		case qrcodegen_Mode_BYTE        : { static const int temp[] = { 8, 16, 16}; return temp[i]; }
 		case qrcodegen_Mode_KANJI       : { static const int temp[] = { 8, 10, 12}; return temp[i]; }
 		case qrcodegen_Mode_ECI         : return 0;
-		default:  assert(false);  return -1;  // Dummy value
+		default:  LV_ASSERT(false);  return -1;  // Dummy value
 	}
 }
 

lib/libesp32_lvgl/lvgl/src/extra/libs/tiny_ttf/lv_tiny_ttf.c

@@ -0,0 +1,284 @@
+#include "lv_tiny_ttf.h"
+
+#if LV_USE_TINY_TTF
+#include <stdio.h>
+#include "../../../misc/lv_lru.h"
+
+#define STB_RECT_PACK_IMPLEMENTATION
+#define STBRP_STATIC
+#define STBTT_STATIC
+#define STB_TRUETYPE_IMPLEMENTATION
+#define STBTT_HEAP_FACTOR_SIZE_32 50
+#define STBTT_HEAP_FACTOR_SIZE_128 20
+#define STBTT_HEAP_FACTOR_SIZE_DEFAULT 10
+#define STBTT_malloc(x, u) ((void)(u), lv_mem_alloc(x))
+#define STBTT_free(x, u) ((void)(u), lv_mem_free(x))
+#define TTF_MALLOC(x) (lv_mem_alloc(x))
+#define TTF_FREE(x) (lv_mem_free(x))
+
+#if LV_TINY_TTF_FILE_SUPPORT
+/* a hydra stream that can be in memory or from a file*/
+typedef struct ttf_cb_stream {
+    lv_fs_file_t * file;
+    const void * data;
+    size_t size;
+    size_t position;
+} ttf_cb_stream_t;
+
+static void ttf_cb_stream_read(ttf_cb_stream_t * stream, void * data, size_t to_read)
+{
+    if(stream->file != NULL) {
+        uint32_t br;
+        lv_fs_read(stream->file, data, to_read, &br);
+    }
+    else {
+        if(to_read + stream->position >= stream->size) {
+            to_read = stream->size - stream->position;
+        }
+        lv_memcpy(data, ((const unsigned char *)stream->data + stream->position), to_read);
+        stream->position += to_read;
+    }
+}
+static void ttf_cb_stream_seek(ttf_cb_stream_t * stream, size_t position)
+{
+    if(stream->file != NULL) {
+        lv_fs_seek(stream->file, position, LV_FS_SEEK_SET);
+    }
+    else {
+        if(position > stream->size) {
+            stream->position = stream->size;
+        }
+        else {
+            stream->position = position;
+        }
+    }
+}
+
+/* for stream support */
+#define STBTT_STREAM_TYPE ttf_cb_stream_t *
+#define STBTT_STREAM_SEEK(s, x) ttf_cb_stream_seek(s, x);
+#define STBTT_STREAM_READ(s, x, y) ttf_cb_stream_read(s, x, y);
+#endif /*LV_TINY_TTF_FILE_SUPPORT*/
+
+#include "stb_rect_pack.h"
+#include "stb_truetype_htcw.h"
+
+typedef struct ttf_font_desc {
+    lv_fs_file_t file;
+#if LV_TINY_TTF_FILE_SUPPORT
+    ttf_cb_stream_t stream;
+#else
+    const uint8_t * stream;
+#endif
+    stbtt_fontinfo info;
+    float scale;
+    int ascent;
+    int descent;
+    lv_lru_t * bitmap_cache;
+} ttf_font_desc_t;
+
+typedef struct ttf_bitmap_cache_key {
+    uint32_t unicode_letter;
+    lv_coord_t line_height;
+} ttf_bitmap_cache_key_t;
+
+static bool ttf_get_glyph_dsc_cb(const lv_font_t * font, lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter,
+                                 uint32_t unicode_letter_next)
+{
+    if(unicode_letter < 0x20 ||
+       unicode_letter == 0xf8ff || /*LV_SYMBOL_DUMMY*/
+       unicode_letter == 0x200c) { /*ZERO WIDTH NON-JOINER*/
+        dsc_out->box_w = 0;
+        dsc_out->adv_w = 0;
+        dsc_out->box_h = 0; /*height of the bitmap in [px]*/
+        dsc_out->ofs_x = 0; /*X offset of the bitmap in [pf]*/
+        dsc_out->ofs_y = 0; /*Y offset of the bitmap in [pf]*/
+        dsc_out->bpp = 0;
+        dsc_out->is_placeholder = false;
+        return true;
+    }
+    ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
+    int g1 = stbtt_FindGlyphIndex(&dsc->info, (int)unicode_letter);
+    if(g1 == 0) {
+        /* Glyph not found */
+        return false;
+    }
+    int x1, y1, x2, y2;
+
+    stbtt_GetGlyphBitmapBox(&dsc->info, g1, dsc->scale, dsc->scale, &x1, &y1, &x2, &y2);
+    int g2 = 0;
+    if(unicode_letter_next != 0) {
+        g2 = stbtt_FindGlyphIndex(&dsc->info, (int)unicode_letter_next);
+    }
+    int advw, lsb;
+    stbtt_GetGlyphHMetrics(&dsc->info, g1, &advw, &lsb);
+    int k = stbtt_GetGlyphKernAdvance(&dsc->info, g1, g2);
+    dsc_out->adv_w = (uint16_t)floor((((float)advw + (float)k) * dsc->scale) +
+                                     0.5f); /*Horizontal space required by the glyph in [px]*/
+
+    dsc_out->adv_w = (uint16_t)floor((((float)advw + (float)k) * dsc->scale) +
+                                     0.5f); /*Horizontal space required by the glyph in [px]*/
+    dsc_out->box_w = (x2 - x1 + 1);         /*width of the bitmap in [px]*/
+    dsc_out->box_h = (y2 - y1 + 1);         /*height of the bitmap in [px]*/
+    dsc_out->ofs_x = x1;                    /*X offset of the bitmap in [pf]*/
+    dsc_out->ofs_y = -y2;                   /*Y offset of the bitmap measured from the as line*/
+    dsc_out->bpp = 8;                       /*Bits per pixel: 1/2/4/8*/
+    dsc_out->is_placeholder = false;
+    return true; /*true: glyph found; false: glyph was not found*/
+}
+
+static const uint8_t * ttf_get_glyph_bitmap_cb(const lv_font_t * font, uint32_t unicode_letter)
+{
+    ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
+    const stbtt_fontinfo * info = (const stbtt_fontinfo *)&dsc->info;
+    int g1 = stbtt_FindGlyphIndex(info, (int)unicode_letter);
+    if(g1 == 0) {
+        /* Glyph not found */
+        return NULL;
+    }
+    int x1, y1, x2, y2;
+    stbtt_GetGlyphBitmapBox(info, g1, dsc->scale, dsc->scale, &x1, &y1, &x2, &y2);
+    int w, h;
+    w = x2 - x1 + 1;
+    h = y2 - y1 + 1;
+    uint32_t stride = w;
+    /*Try to load from cache*/
+    ttf_bitmap_cache_key_t cache_key;
+    lv_memset(&cache_key, 0, sizeof(cache_key)); /*Zero padding*/
+    cache_key.unicode_letter = unicode_letter;
+    cache_key.line_height = font->line_height;
+    uint8_t * buffer = NULL;
+    lv_lru_get(dsc->bitmap_cache, &cache_key, sizeof(cache_key), (void **)&buffer);
+    if(buffer) {
+        return buffer;
+    }
+    LV_LOG_TRACE("cache miss for letter: %u", unicode_letter);
+    /*Prepare space in cache*/
+    size_t szb = h * stride;
+    buffer = lv_mem_alloc(szb);
+    if(!buffer) {
+        LV_LOG_ERROR("failed to allocate cache value");
+        return NULL;
+    }
+    lv_memset(buffer, 0, szb);
+    if(LV_LRU_OK != lv_lru_set(dsc->bitmap_cache, &cache_key, sizeof(cache_key), buffer, szb)) {
+        LV_LOG_ERROR("failed to add cache value");
+        lv_mem_free(buffer);
+        return NULL;
+    }
+    /*Render into cache*/
+    stbtt_MakeGlyphBitmap(info, buffer, w, h, stride, dsc->scale, dsc->scale, g1);
+    return buffer;
+}
+
+static lv_font_t * lv_tiny_ttf_create(const char * path, const void * data, size_t data_size, lv_coord_t font_size,
+                                      size_t cache_size)
+{
+    if((path == NULL && data == NULL) || 0 >= font_size) {
+        LV_LOG_ERROR("tiny_ttf: invalid argument\n");
+        return NULL;
+    }
+    ttf_font_desc_t * dsc = (ttf_font_desc_t *)TTF_MALLOC(sizeof(ttf_font_desc_t));
+    if(dsc == NULL) {
+        LV_LOG_ERROR("tiny_ttf: out of memory\n");
+        return NULL;
+    }
+#if LV_TINY_TTF_FILE_SUPPORT
+    if(path != NULL) {
+        if(LV_FS_RES_OK != lv_fs_open(&dsc->file, path, LV_FS_MODE_RD)) {
+            LV_LOG_ERROR("tiny_ttf: unable to open %s\n", path);
+            goto err_after_dsc;
+        }
+        dsc->stream.file = &dsc->file;
+    }
+    else {
+        dsc->stream.file = NULL;
+        dsc->stream.data = (const uint8_t *)data;
+        dsc->stream.size = data_size;
+        dsc->stream.position = 0;
+    }
+    if(0 == stbtt_InitFont(&dsc->info, &dsc->stream, stbtt_GetFontOffsetForIndex(&dsc->stream, 0))) {
+        LV_LOG_ERROR("tiny_ttf: init failed\n");
+        goto err_after_dsc;
+    }
+
+#else
+    dsc->stream = (const uint8_t *)data;
+    LV_UNUSED(data_size);
+    if(0 == stbtt_InitFont(&dsc->info, dsc->stream, stbtt_GetFontOffsetForIndex(dsc->stream, 0))) {
+        LV_LOG_ERROR("tiny_ttf: init failed\n");
+        goto err_after_dsc;
+    }
+#endif
+
+    dsc->bitmap_cache = lv_lru_create(cache_size, font_size * font_size, lv_mem_free, lv_mem_free);
+    if(dsc->bitmap_cache == NULL) {
+        LV_LOG_ERROR("failed to create lru cache");
+        goto err_after_dsc;
+    }
+
+    lv_font_t * out_font = (lv_font_t *)TTF_MALLOC(sizeof(lv_font_t));
+    if(out_font == NULL) {
+        LV_LOG_ERROR("tiny_ttf: out of memory\n");
+        goto err_after_bitmap_cache;
+    }
+    lv_memset(out_font, 0, sizeof(lv_font_t));
+    out_font->get_glyph_dsc = ttf_get_glyph_dsc_cb;
+    out_font->get_glyph_bitmap = ttf_get_glyph_bitmap_cb;
+    out_font->dsc = dsc;
+    lv_tiny_ttf_set_size(out_font, font_size);
+    return out_font;
+err_after_bitmap_cache:
+    lv_lru_del(dsc->bitmap_cache);
+err_after_dsc:
+    TTF_FREE(dsc);
+    return NULL;
+}
+#if LV_TINY_TTF_FILE_SUPPORT
+lv_font_t * lv_tiny_ttf_create_file_ex(const char * path, lv_coord_t font_size, size_t cache_size)
+{
+    return lv_tiny_ttf_create(path, NULL, 0, font_size, cache_size);
+}
+lv_font_t * lv_tiny_ttf_create_file(const char * path, lv_coord_t font_size)
+{
+    return lv_tiny_ttf_create_file_ex(path, font_size, 4096);
+}
+#endif /*LV_TINY_TTF_FILE_SUPPORT*/
+lv_font_t * lv_tiny_ttf_create_data_ex(const void * data, size_t data_size, lv_coord_t font_size, size_t cache_size)
+{
+    return lv_tiny_ttf_create(NULL, data, data_size, font_size, cache_size);
+}
+lv_font_t * lv_tiny_ttf_create_data(const void * data, size_t data_size, lv_coord_t font_size)
+{
+    return lv_tiny_ttf_create_data_ex(data, data_size, font_size, 4096);
+}
+void lv_tiny_ttf_set_size(lv_font_t * font, lv_coord_t font_size)
+{
+    if(font_size <= 0) {
+        LV_LOG_ERROR("invalid font size: %"PRIx32, font_size);
+        return;
+    }
+    ttf_font_desc_t * dsc = (ttf_font_desc_t *)font->dsc;
+    dsc->scale = stbtt_ScaleForMappingEmToPixels(&dsc->info, font_size);
+    int line_gap = 0;
+    stbtt_GetFontVMetrics(&dsc->info, &dsc->ascent, &dsc->descent, &line_gap);
+    font->line_height = (lv_coord_t)(dsc->scale * (dsc->ascent - dsc->descent + line_gap));
+    font->base_line = (lv_coord_t)(dsc->scale * (line_gap - dsc->descent));
+}
+void lv_tiny_ttf_destroy(lv_font_t * font)
+{
+    if(font != NULL) {
+        if(font->dsc != NULL) {
+            ttf_font_desc_t * ttf = (ttf_font_desc_t *)font->dsc;
+#if LV_TINY_TTF_FILE_SUPPORT
+            if(ttf->stream.file != NULL) {
+                lv_fs_close(&ttf->file);
+            }
+#endif
+            lv_lru_del(ttf->bitmap_cache);
+            TTF_FREE(ttf);
+        }
+        TTF_FREE(font);
+    }
+}
+#endif /*LV_USE_TINY_TTF*/

lib/libesp32_lvgl/lvgl/src/extra/libs/tiny_ttf/lv_tiny_ttf.h

@@ -0,0 +1,62 @@
+/**
+ * @file lv_tiny_ttf.h
+ *
+ */
+
+#ifndef LV_TINY_TTF_H
+#define LV_TINY_TTF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../../lvgl.h"
+
+#if LV_USE_TINY_TTF
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+#if LV_TINY_TTF_FILE_SUPPORT
+/* create a font from the specified file or path with the specified line height.*/
+lv_font_t * lv_tiny_ttf_create_file(const char * path, lv_coord_t font_size);
+
+/* create a font from the specified file or path with the specified line height with the specified cache size.*/
+lv_font_t * lv_tiny_ttf_create_file_ex(const char * path, lv_coord_t font_size, size_t cache_size);
+#endif /*LV_TINY_TTF_FILE_SUPPORT*/
+
+/* create a font from the specified data pointer with the specified line height.*/
+lv_font_t * lv_tiny_ttf_create_data(const void * data, size_t data_size, lv_coord_t font_size);
+
+/* create a font from the specified data pointer with the specified line height and the specified cache size.*/
+lv_font_t * lv_tiny_ttf_create_data_ex(const void * data, size_t data_size, lv_coord_t font_size, size_t cache_size);
+
+/* set the size of the font to a new font_size*/
+void lv_tiny_ttf_set_size(lv_font_t * font, lv_coord_t font_size);
+
+/* destroy a font previously created with lv_tiny_ttf_create_xxxx()*/
+void lv_tiny_ttf_destroy(lv_font_t * font);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /*LV_USE_TINY_TTF*/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_TINY_TTF_H*/

lib/libesp32_lvgl/lvgl/src/extra/libs/tiny_ttf/stb_rect_pack.h

@@ -0,0 +1,637 @@
+// stb_rect_pack.h - v1.01 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Before #including,
+//
+//    #define STB_RECT_PACK_IMPLEMENTATION
+//
+// in the file that you want to have the implementation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//    Fabian Giesen
+//
+// Version history:
+//
+//     1.01  (2021-07-11)  always use large rect mode, expose STBRP__MAXVAL in public section
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
+//     0.99  (2019-02-07)  warning fixes
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+    #define STBRP_DEF static
+#else
+    #define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @cond
+/**
+ *  Tells Doxygen to ignore a duplicate declaration
+ */
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+/// @endcond
+
+typedef int            stbrp_coord;
+
+#define STBRP__MAXVAL  0x7fffffff
+// Mostly for internal use, but this is the maximum supported coordinate value.
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context * context, stbrp_rect * rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect {
+    // reserved for your use:
+    int            id;
+
+    // input:
+    stbrp_coord    w, h;
+
+    // output:
+    stbrp_coord    x, y;
+    int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target(stbrp_context * context, int width, int height, stbrp_node * nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context * context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context * context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum {
+    STBRP_HEURISTIC_Skyline_default = 0,
+    STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+    STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node {
+    stbrp_coord  x, y;
+    stbrp_node * next;
+};
+
+struct stbrp_context {
+    int width;
+    int height;
+    int align;
+    int init_mode;
+    int heuristic;
+    int num_nodes;
+    stbrp_node * active_head;
+    stbrp_node * free_head;
+    stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+    #include <stdlib.h>
+    #define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+    #include <assert.h>
+    #define STBRP_ASSERT assert
+#endif
+
+#ifdef _MSC_VER
+    #define STBRP__NOTUSED(v)  (void)(v)
+    #define STBRP__CDECL       __cdecl
+#else
+    #define STBRP__NOTUSED(v)  (void)sizeof(v)
+    #define STBRP__CDECL
+#endif
+
+enum {
+    STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context * context, int heuristic)
+{
+    switch(context->init_mode) {
+        case STBRP__INIT_skyline:
+            STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+            context->heuristic = heuristic;
+            break;
+        default:
+            STBRP_ASSERT(0);
+    }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context * context, int allow_out_of_mem)
+{
+    if(allow_out_of_mem)
+        // if it's ok to run out of memory, then don't bother aligning them;
+        // this gives better packing, but may fail due to OOM (even though
+        // the rectangles easily fit). @TODO a smarter approach would be to only
+        // quantize once we've hit OOM, then we could get rid of this parameter.
+        context->align = 1;
+    else {
+        // if it's not ok to run out of memory, then quantize the widths
+        // so that num_nodes is always enough nodes.
+        //
+        // I.e. num_nodes * align >= width
+        //                  align >= width / num_nodes
+        //                  align = ceil(width/num_nodes)
+
+        context->align = (context->width + context->num_nodes - 1) / context->num_nodes;
+    }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context * context, int width, int height, stbrp_node * nodes, int num_nodes)
+{
+    int i;
+
+    for(i = 0; i < num_nodes - 1; ++i)
+        nodes[i].next = &nodes[i + 1];
+    nodes[i].next = NULL;
+    context->init_mode = STBRP__INIT_skyline;
+    context->heuristic = STBRP_HEURISTIC_Skyline_default;
+    context->free_head = &nodes[0];
+    context->active_head = &context->extra[0];
+    context->width = width;
+    context->height = height;
+    context->num_nodes = num_nodes;
+    stbrp_setup_allow_out_of_mem(context, 0);
+
+    // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+    context->extra[0].x = 0;
+    context->extra[0].y = 0;
+    context->extra[0].next = &context->extra[1];
+    context->extra[1].x = (stbrp_coord) width;
+    context->extra[1].y = (1 << 30);
+    context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context * c, stbrp_node * first, int x0, int width, int * pwaste)
+{
+    stbrp_node * node = first;
+    int x1 = x0 + width;
+    int min_y, visited_width, waste_area;
+
+    STBRP__NOTUSED(c);
+
+    STBRP_ASSERT(first->x <= x0);
+
+#if 0
+    // skip in case we're past the node
+    while(node->next->x <= x0)
+        ++node;
+#else
+    STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+#endif
+
+    STBRP_ASSERT(node->x <= x0);
+
+    min_y = 0;
+    waste_area = 0;
+    visited_width = 0;
+    while(node->x < x1) {
+        if(node->y > min_y) {
+            // raise min_y higher.
+            // we've accounted for all waste up to min_y,
+            // but we'll now add more waste for everything we've visited
+            waste_area += visited_width * (node->y - min_y);
+            min_y = node->y;
+            // the first time through, visited_width might be reduced
+            if(node->x < x0)
+                visited_width += node->next->x - x0;
+            else
+                visited_width += node->next->x - node->x;
+        }
+        else {
+            // add waste area
+            int under_width = node->next->x - node->x;
+            if(under_width + visited_width > width)
+                under_width = width - visited_width;
+            waste_area += under_width * (min_y - node->y);
+            visited_width += under_width;
+        }
+        node = node->next;
+    }
+
+    *pwaste = waste_area;
+    return min_y;
+}
+
+typedef struct {
+    int x, y;
+    stbrp_node ** prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context * c, int width, int height)
+{
+    int best_waste = (1 << 30), best_x, best_y = (1 << 30);
+    stbrp__findresult fr;
+    stbrp_node ** prev, * node, * tail, ** best = NULL;
+
+    // align to multiple of c->align
+    width = (width + c->align - 1);
+    width -= width % c->align;
+    STBRP_ASSERT(width % c->align == 0);
+
+    // if it can't possibly fit, bail immediately
+    if(width > c->width || height > c->height) {
+        fr.prev_link = NULL;
+        fr.x = fr.y = 0;
+        return fr;
+    }
+
+    node = c->active_head;
+    prev = &c->active_head;
+    while(node->x + width <= c->width) {
+        int y, waste;
+        y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+        if(c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) {  // actually just want to test BL
+            // bottom left
+            if(y < best_y) {
+                best_y = y;
+                best = prev;
+            }
+        }
+        else {
+            // best-fit
+            if(y + height <= c->height) {
+                // can only use it if it first vertically
+                if(y < best_y || (y == best_y && waste < best_waste)) {
+                    best_y = y;
+                    best_waste = waste;
+                    best = prev;
+                }
+            }
+        }
+        prev = &node->next;
+        node = node->next;
+    }
+
+    best_x = (best == NULL) ? 0 : (*best)->x;
+
+    // if doing best-fit (BF), we also have to try aligning right edge to each node position
+    //
+    // e.g, if fitting
+    //
+    //     ____________________
+    //    |____________________|
+    //
+    //            into
+    //
+    //   |                         |
+    //   |             ____________|
+    //   |____________|
+    //
+    // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+    //
+    // This makes BF take about 2x the time
+
+    if(c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+        tail = c->active_head;
+        node = c->active_head;
+        prev = &c->active_head;
+        // find first node that's admissible
+        while(tail->x < width)
+            tail = tail->next;
+        while(tail) {
+            int xpos = tail->x - width;
+            int y, waste;
+            STBRP_ASSERT(xpos >= 0);
+            // find the left position that matches this
+            while(node->next->x <= xpos) {
+                prev = &node->next;
+                node = node->next;
+            }
+            STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+            y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+            if(y + height <= c->height) {
+                if(y <= best_y) {
+                    if(y < best_y || waste < best_waste || (waste == best_waste && xpos < best_x)) {
+                        best_x = xpos;
+                        STBRP_ASSERT(y <= best_y);
+                        best_y = y;
+                        best_waste = waste;
+                        best = prev;
+                    }
+                }
+            }
+            tail = tail->next;
+        }
+    }
+
+    fr.prev_link = best;
+    fr.x = best_x;
+    fr.y = best_y;
+    return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context * context, int width, int height)
+{
+    // find best position according to heuristic
+    stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+    stbrp_node * node, * cur;
+
+    // bail if:
+    //    1. it failed
+    //    2. the best node doesn't fit (we don't always check this)
+    //    3. we're out of memory
+    if(res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+        res.prev_link = NULL;
+        return res;
+    }
+
+    // on success, create new node
+    node = context->free_head;
+    node->x = (stbrp_coord) res.x;
+    node->y = (stbrp_coord)(res.y + height);
+
+    context->free_head = node->next;
+
+    // insert the new node into the right starting point, and
+    // let 'cur' point to the remaining nodes needing to be
+    // stiched back in
+
+    cur = *res.prev_link;
+    if(cur->x < res.x) {
+        // preserve the existing one, so start testing with the next one
+        stbrp_node * next = cur->next;
+        cur->next = node;
+        cur = next;
+    }
+    else {
+        *res.prev_link = node;
+    }
+
+    // from here, traverse cur and free the nodes, until we get to one
+    // that shouldn't be freed
+    while(cur->next && cur->next->x <= res.x + width) {
+        stbrp_node * next = cur->next;
+        // move the current node to the free list
+        cur->next = context->free_head;
+        context->free_head = cur;
+        cur = next;
+    }
+
+    // stitch the list back in
+    node->next = cur;
+
+    if(cur->x < res.x + width)
+        cur->x = (stbrp_coord)(res.x + width);
+
+#ifdef _DEBUG
+    cur = context->active_head;
+    while(cur->x < context->width) {
+        STBRP_ASSERT(cur->x < cur->next->x);
+        cur = cur->next;
+    }
+    STBRP_ASSERT(cur->next == NULL);
+
+    {
+        int count = 0;
+        cur = context->active_head;
+        while(cur) {
+            cur = cur->next;
+            ++count;
+        }
+        cur = context->free_head;
+        while(cur) {
+            cur = cur->next;
+            ++count;
+        }
+        STBRP_ASSERT(count == context->num_nodes + 2);
+    }
+#endif
+
+    return res;
+}
+
+static int STBRP__CDECL rect_height_compare(const void * a, const void * b)
+{
+    const stbrp_rect * p = (const stbrp_rect *) a;
+    const stbrp_rect * q = (const stbrp_rect *) b;
+    if(p->h > q->h)
+        return -1;
+    if(p->h < q->h)
+        return  1;
+    return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+static int STBRP__CDECL rect_original_order(const void * a, const void * b)
+{
+    const stbrp_rect * p = (const stbrp_rect *) a;
+    const stbrp_rect * q = (const stbrp_rect *) b;
+    return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context * context, stbrp_rect * rects, int num_rects)
+{
+    int i, all_rects_packed = 1;
+
+    // we use the 'was_packed' field internally to allow sorting/unsorting
+    for(i = 0; i < num_rects; ++i) {
+        rects[i].was_packed = i;
+    }
+
+    // sort according to heuristic
+    STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+    for(i = 0; i < num_rects; ++i) {
+        if(rects[i].w == 0 || rects[i].h == 0) {
+            rects[i].x = rects[i].y = 0;  // empty rect needs no space
+        }
+        else {
+            stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+            if(fr.prev_link) {
+                rects[i].x = (stbrp_coord) fr.x;
+                rects[i].y = (stbrp_coord) fr.y;
+            }
+            else {
+                rects[i].x = rects[i].y = STBRP__MAXVAL;
+            }
+        }
+    }
+
+    // unsort
+    STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+    // set was_packed flags and all_rects_packed status
+    for(i = 0; i < num_rects; ++i) {
+        rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+        if(!rects[i].was_packed)
+            all_rects_packed = 0;
+    }
+
+    // return the all_rects_packed status
+    return all_rects_packed;
+}
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic pop
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+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:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/

lib/libesp32_lvgl/lvgl/src/extra/lv_extra.c

@@ -50,6 +50,10 @@ void lv_extra_init(void)
     lv_fs_fatfs_init();
 #endif
 
+#if LV_USE_FS_LITTLEFS != '\0'
+    lv_fs_littlefs_init();
+#endif
+
 #if LV_USE_FS_STDIO != '\0'
     lv_fs_stdio_init();
 #endif

lib/libesp32_lvgl/lvgl/src/extra/others/ime/lv_ime_pinyin.c

@@ -562,6 +562,8 @@ static void lv_ime_pinyin_constructor(const lv_obj_class_t * class_p, lv_obj_t *
     lv_memset_00(pinyin_ime->py_num, sizeof(pinyin_ime->py_num));
     lv_memset_00(pinyin_ime->py_pos, sizeof(pinyin_ime->py_pos));
 
+    lv_obj_add_flag(obj, LV_OBJ_FLAG_HIDDEN);
+
     lv_obj_set_size(obj, LV_PCT(100), LV_PCT(55));
     lv_obj_align(obj, LV_ALIGN_BOTTOM_MID, 0, 0);
 
@@ -576,6 +578,7 @@ static void lv_ime_pinyin_constructor(const lv_obj_class_t * class_p, lv_obj_t *
     lv_obj_add_flag(pinyin_ime->cand_panel, LV_OBJ_FLAG_HIDDEN);
 
     lv_btnmatrix_set_one_checked(pinyin_ime->cand_panel, true);
+    lv_obj_clear_flag(pinyin_ime->cand_panel, LV_OBJ_FLAG_CLICK_FOCUSABLE);
 
     /* Set cand_panel style*/
     // Default style

lib/libesp32_lvgl/lvgl/src/extra/widgets/keyboard/lv_keyboard.c

@@ -73,7 +73,7 @@ static const lv_btnmatrix_ctrl_t default_kb_ctrl_uc_map[] = {
 };
 
 static const char * const default_kb_map_spec[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", LV_SYMBOL_BACKSPACE, "\n",
-                                                   "abc", "+", "-", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n",
+                                                   "abc", "+", "&", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n",
                                                    "\\",  "@", "$", "(", ")", "{", "}", "[", "]", ";", "\"", "'", "\n",
                                                    LV_SYMBOL_KEYBOARD, LV_SYMBOL_LEFT, " ", LV_SYMBOL_RIGHT, LV_SYMBOL_OK, ""
                                                   };

lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.c

@@ -360,6 +360,8 @@ static void draw_arcs(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, const lv_area_t
         int32_t end_angle = lv_map(indic->end_value, scale->min, scale->max, scale->rotation,
                                    scale->rotation + scale->angle_range);
 
+        arc_dsc.start_angle = start_angle;
+        arc_dsc.end_angle = end_angle;
         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;
@@ -511,7 +513,8 @@ static void draw_ticks_and_labels(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, cons
                 lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
 
                 lv_point_t label_size;
-                lv_txt_get_size(&label_size, part_draw_dsc.text, label_dsc.font, label_dsc.letter_space, label_dsc.line_space,
+                lv_txt_get_size(&label_size, part_draw_dsc.text, label_dsc_tmp.font, label_dsc_tmp.letter_space,
+                                label_dsc_tmp.line_space,
                                 LV_COORD_MAX, LV_TEXT_FLAG_NONE);
 
                 lv_area_t label_cord;
@@ -569,6 +572,7 @@ static void draw_needles(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, const lv_area
     lv_obj_draw_dsc_init(&part_draw_dsc, draw_ctx);
     part_draw_dsc.class_p = MY_CLASS;
     part_draw_dsc.p1 = &scale_center;
+    part_draw_dsc.part = LV_PART_INDICATOR;
 
     lv_meter_indicator_t * indic;
     _LV_LL_READ_BACK(&meter->indicator_ll, indic) {
@@ -585,12 +589,12 @@ static void draw_needles(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, const lv_area
             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.type = LV_METER_DRAW_PART_NEEDLE_LINE;
             part_draw_dsc.line_dsc = &line_dsc;
             part_draw_dsc.p2 = &p_end;
-
+            part_draw_dsc.p1 = &scale_center;
             lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);
-            lv_draw_line(draw_ctx, &line_dsc, &scale_center, &p_end);
+            lv_draw_line(draw_ctx, &line_dsc, part_draw_dsc.p1, &p_end);
             lv_event_send(obj, LV_EVENT_DRAW_PART_END, &part_draw_dsc);
         }
         else if(indic->type == LV_METER_INDICATOR_TYPE_NEEDLE_IMG) {
@@ -612,7 +616,7 @@ static void draw_needles(lv_obj_t * obj, lv_draw_ctx_t * draw_ctx, const lv_area
             if(angle > 3600) angle -= 3600;
             img_dsc.angle = angle;
 
-            part_draw_dsc.id = LV_METER_DRAW_PART_NEEDLE_IMG;
+            part_draw_dsc.type = LV_METER_DRAW_PART_NEEDLE_IMG;
             part_draw_dsc.img_dsc = &img_dsc;
 
             lv_event_send(obj, LV_EVENT_DRAW_PART_BEGIN, &part_draw_dsc);

lib/libesp32_lvgl/lvgl/src/extra/widgets/meter/lv_meter.h

@@ -42,7 +42,6 @@ typedef struct {
     uint16_t tick_major_width;
 
     int16_t label_gap;
-    int16_t label_color;
 
     int32_t min;
     int32_t max;

lib/libesp32_lvgl/lvgl/src/lv_conf_internal.h

@@ -2099,6 +2099,31 @@
     #endif
 #endif
 
+/*API for LittleFS (library needs to be added separately). Uses lfs_file_open, lfs_file_read, etc*/
+#ifndef LV_USE_FS_LITTLEFS
+    #ifdef CONFIG_LV_USE_FS_LITTLEFS
+        #define LV_USE_FS_LITTLEFS CONFIG_LV_USE_FS_LITTLEFS
+    #else
+        #define LV_USE_FS_LITTLEFS 0
+    #endif
+#endif
+#if LV_USE_FS_LITTLEFS
+    #ifndef LV_FS_LITTLEFS_LETTER
+        #ifdef CONFIG_LV_FS_LITTLEFS_LETTER
+            #define LV_FS_LITTLEFS_LETTER CONFIG_LV_FS_LITTLEFS_LETTER
+        #else
+            #define LV_FS_LITTLEFS_LETTER '\0'     /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/
+        #endif
+    #endif
+    #ifndef LV_FS_LITTLEFS_CACHE_SIZE
+        #ifdef CONFIG_LV_FS_LITTLEFS_CACHE_SIZE
+            #define LV_FS_LITTLEFS_CACHE_SIZE CONFIG_LV_FS_LITTLEFS_CACHE_SIZE
+        #else
+            #define LV_FS_LITTLEFS_CACHE_SIZE 0    /*>0 to cache this number of bytes in lv_fs_read()*/
+        #endif
+    #endif
+#endif
+
 /*PNG decoder library*/
 #ifndef LV_USE_PNG
     #ifdef CONFIG_LV_USE_PNG
@@ -2192,6 +2217,25 @@
     #endif
 #endif
 
+/*Tiny TTF library*/
+#ifndef LV_USE_TINY_TTF
+    #ifdef CONFIG_LV_USE_TINY_TTF
+        #define LV_USE_TINY_TTF CONFIG_LV_USE_TINY_TTF
+    #else
+        #define LV_USE_TINY_TTF 0
+    #endif
+#endif
+#if LV_USE_TINY_TTF
+    /*Load TTF data from files*/
+    #ifndef LV_TINY_TTF_FILE_SUPPORT
+        #ifdef CONFIG_LV_TINY_TTF_FILE_SUPPORT
+            #define LV_TINY_TTF_FILE_SUPPORT CONFIG_LV_TINY_TTF_FILE_SUPPORT
+        #else
+            #define LV_TINY_TTF_FILE_SUPPORT 0
+        #endif
+    #endif
+#endif
+
 /*Rlottie library*/
 #ifndef LV_USE_RLOTTIE
     #ifdef CONFIG_LV_USE_RLOTTIE

lib/libesp32_lvgl/lvgl/src/misc/lv_fs.h

@@ -57,7 +57,6 @@ enum {
 };
 typedef uint8_t lv_fs_mode_t;
 
-
 /**
  * Seek modes.
  */

lib/libesp32_lvgl/lvgl/src/misc/lv_printf.h

@@ -40,14 +40,20 @@
         /* platform-specific printf format for int32_t, usually "d" or "ld" */
         #define LV_PRId32 PRId32
         #define LV_PRIu32 PRIu32
+        #define LV_PRIx32 PRIx32
+        #define LV_PRIX32 PRIX32
     #else
         #define LV_PRId32 "d"
         #define LV_PRIu32 "u"
+        #define LV_PRIx32 "x"
+        #define LV_PRIX32 "X"
     #endif
 #else
     /* hope this is correct for ports without __has_include or without inttypes.h */
     #define LV_PRId32 "d"
     #define LV_PRIu32 "u"
+    #define LV_PRIx32 "x"
+    #define LV_PRIX32 "X"
 #endif
 
 #ifdef __cplusplus

lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.c

@@ -21,6 +21,10 @@
 #define MY_CLASS &lv_arc_class
 
 #define VALUE_UNSET INT16_MIN
+#define CLICK_OUTSIDE_BG_ANGLES ((uint32_t) 0x00U)
+#define CLICK_INSIDE_BG_ANGLES  ((uint32_t) 0x01U)
+#define CLICK_CLOSER_TO_MAX_END ((uint32_t) 0x00U)
+#define CLICK_CLOSER_TO_MIN_END ((uint32_t) 0x01U)
 
 /**********************
  *      TYPEDEFS
@@ -40,6 +44,7 @@ static lv_coord_t get_angle(const lv_obj_t * obj);
 static void get_knob_area(lv_obj_t * arc, const lv_point_t * center, lv_coord_t r, lv_area_t * knob_area);
 static void value_update(lv_obj_t * arc);
 static lv_coord_t knob_get_extra_size(lv_obj_t * obj);
+static bool lv_arc_angle_within_bg_bounds(lv_obj_t * obj, const uint32_t angle, const uint32_t tolerance_deg);
 
 /**********************
  *  STATIC VARIABLES
@@ -399,6 +404,7 @@ static void lv_arc_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
     arc->chg_rate = 720;
     arc->last_tick = lv_tick_get();
     arc->last_angle = arc->indic_angle_end;
+    arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
 
     lv_obj_add_flag(obj, LV_OBJ_FLAG_CLICKABLE);
     lv_obj_clear_flag(obj, LV_OBJ_FLAG_SCROLL_CHAIN | LV_OBJ_FLAG_SCROLLABLE);
@@ -478,29 +484,54 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
         angle -= arc->rotation;
         angle -= arc->bg_angle_start;  /*Make the angle relative to the start angle*/
 
+        /* If we click near the bg_angle_start the angle will be close to 360° instead of an small angle */
         if(angle < 0) angle += 360;
 
-        int16_t deg_range = bg_end - arc->bg_angle_start;
+        const uint32_t circumference = (uint32_t)((2U * r * 314U) / 100U);  /* Equivalent to: 2r * 3.14, avoiding floats */
+        const uint32_t tolerance_deg = (360U * LV_DPX(50U)) / circumference;
+        const uint32_t min_close_prev = (uint32_t) arc->min_close;
 
+        const bool is_angle_within_bg_bounds = lv_arc_angle_within_bg_bounds(obj, (uint32_t) angle, tolerance_deg);
+        if(!is_angle_within_bg_bounds) {
+            return;
+        }
+
+        int16_t deg_range = bg_end - 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.
+        /*Do not allow big jumps (jumps bigger than 280°).
          *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;
         }
-        else {
+        /* Check if click was outside the background arc start and end angles */
-            if(angle < deg_range / 2)arc->min_close = 1;
+        else if(CLICK_OUTSIDE_BG_ANGLES == arc->in_out) {
-            else arc->min_close = 0;
+            if(arc->min_close) angle = -deg_range;
+            else angle = deg_range;
         }
+        else { /* Keep the angle value */ }
+
+        /* Prevent big jumps when the click goes from start to end angle in the invisible
+         * part of the background arc without being released */
+        if(((min_close_prev == CLICK_CLOSER_TO_MIN_END) && (arc->min_close == CLICK_CLOSER_TO_MAX_END))
+           && ((CLICK_OUTSIDE_BG_ANGLES == arc->in_out) && (LV_ABS(delta_angle) > 280))) {
+            angle = 0;
+        }
+        else if(((min_close_prev == CLICK_CLOSER_TO_MAX_END) && (arc->min_close == CLICK_CLOSER_TO_MIN_END))
+                && (CLICK_OUTSIDE_BG_ANGLES == arc->in_out)) {
+            angle = deg_range;
+        }
+        else { /* Keep the angle value */ }
 
         /*Calculate the slew rate limited angle based on change rate (degrees/sec)*/
         delta_angle = angle - last_angle_rel;
+
         uint32_t delta_tick = lv_tick_elaps(arc->last_tick);
-        int16_t delta_angle_max = (arc->chg_rate * delta_tick) / 1000;
+        /* delta_angle_max can never be signed. delta_tick is always signed, same for ch_rate */
+        const uint16_t delta_angle_max = (arc->chg_rate * delta_tick) / 1000;
 
         if(delta_angle > delta_angle_max) {
             delta_angle = delta_angle_max;
@@ -508,6 +539,7 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
         else if(delta_angle < -delta_angle_max) {
             delta_angle = -delta_angle_max;
         }
+        else { /* Nothing to do */ }
 
         angle = last_angle_rel + delta_angle; /*Apply the limited angle change*/
 
@@ -564,7 +596,7 @@ static void lv_arc_event(const lv_obj_class_t * class_p, lv_event_t * e)
         }
     }
     else if(code == LV_EVENT_HIT_TEST) {
-        lv_hit_test_info_t * info = lv_event_get_param(e);;
+        lv_hit_test_info_t * info = lv_event_get_param(e);
 
         lv_point_t p;
         lv_coord_t r;
@@ -868,4 +900,121 @@ static lv_coord_t knob_get_extra_size(lv_obj_t * obj)
     return LV_MAX(knob_shadow_size, knob_outline_size);
 }
 
+/**
+ * Check if angle is within arc background bounds
+ *
+ * In order to avoid unexpected value update of the arc value when the user clicks
+ * outside of the arc background we need to check if the angle (of the clicked point)
+ * is within the bounds of the background.
+ *
+ * A tolerance (extra room) also should be taken into consideration.
+ *
+ * E.g. Arc with start angle of 0° and end angle of 90°, the background is only visible in
+ * that range, from 90° to 360° the background is invisible. Click in 150° should not update
+ * the arc value, click within the arc angle range should.
+ *
+ * IMPORTANT NOTE: angle is always relative to bg_angle_start, e.g. if bg_angle_start is 30
+ * and we click a bit to the left, angle is 10, not the expected 40.
+ *
+ * @param obj   Pointer to lv_arc
+ * @param angle Angle to be checked
+ * @param tolerance_deg Tolerance
+ *
+ * @return true if angle is within arc background bounds, false otherwise
+ */
+static bool lv_arc_angle_within_bg_bounds(lv_obj_t * obj, const uint32_t angle, const uint32_t tolerance_deg)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+    lv_arc_t * arc = (lv_arc_t *)obj;
+
+    uint32_t smaller_angle = 0;
+    uint32_t bigger_angle = 0;
+
+    /* Determine which background angle is smaller and bigger */
+    if(arc->bg_angle_start < arc->bg_angle_end) {
+        bigger_angle = arc->bg_angle_end;
+        smaller_angle = arc->bg_angle_start;
+    }
+    else {
+        bigger_angle = (360 - arc->bg_angle_start) + arc->bg_angle_end;
+        smaller_angle = 0;
+    }
+
+    /* Angle is between both background angles */
+    if((smaller_angle <= angle) && (angle <= bigger_angle)) {
+
+        if(((bigger_angle - smaller_angle) / 2U) >= angle) {
+            arc->min_close = 1;
+        }
+        else {
+            arc->min_close = 0;
+        }
+
+        arc->in_out = CLICK_INSIDE_BG_ANGLES;
+
+        return true;
+    }
+    /* Distance between background start and end angles is less than tolerance,
+     * consider the click inside the arc */
+    else if(((smaller_angle - tolerance_deg) <= 0U) &&
+            (360U - (bigger_angle + (smaller_angle - tolerance_deg)))) {
+
+        arc->min_close = 1;
+        arc->in_out = CLICK_INSIDE_BG_ANGLES;
+        return true;
+    }
+    else { /* Case handled below */ }
+
+    /* Legends:
+     * 0° = angle 0
+     * 360° = angle 360
+     * T: Tolerance
+     * A: Angle
+     * S: Arc background start angle
+     * E: Arc background end angle
+     *
+     * Start angle is bigger or equal to tolerance */
+    if((smaller_angle >= tolerance_deg)
+       /* (360° - T) --- A --- 360° */
+       && ((angle >= (360U - tolerance_deg)) && (angle <= 360U))) {
+
+        arc->min_close = 1;
+        arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
+        return true;
+    }
+    /* Tolerance is bigger than bg start angle */
+    else if((smaller_angle < tolerance_deg)
+            /* (360° - (T - S)) --- A --- 360° */
+            && (((360U - (tolerance_deg - smaller_angle)) <= angle)) && (angle <= 360U)) {
+
+        arc->min_close = 1;
+        arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
+        return true;
+    }
+    /* 360° is bigger than background end angle + tolerance */
+    else if((360U >= (bigger_angle + tolerance_deg))
+            /* E --- A --- (E + T) */
+            && ((bigger_angle <= (angle + smaller_angle)) &&
+                ((angle + smaller_angle) <= (bigger_angle + tolerance_deg)))) {
+
+        arc->min_close = 0;
+        arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
+        return true;
+    }
+    /* Background end angle + tolerance is bigger than 360° and bg_start_angle + tolerance is not near 0° + ((bg_end_angle + tolerance) - 360°)
+     * Here we can assume background is not near 0° because of the first two initial checks */
+    else if((360U < (bigger_angle + tolerance_deg))
+            && (angle <= 0U + ((bigger_angle + tolerance_deg) - 360U)) && (angle > bigger_angle)) {
+
+        arc->min_close = 0;
+        arc->in_out = CLICK_OUTSIDE_BG_ANGLES;
+        return true;
+    }
+    else {
+        /* Nothing to do */
+    }
+
+    return false;
+}
+
 #endif

lib/libesp32_lvgl/lvgl/src/widgets/lv_arc.h

@@ -44,10 +44,11 @@ typedef struct {
     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;
+    uint32_t dragging    : 1;
-    uint16_t type        : 2;
+    uint32_t type        : 2;
-    uint16_t min_close   : 1;   /*1: the last pressed angle was closer to minimum end*/
+    uint32_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 in_out      : 1;   /* 1: The click was within the background arc angles. 0: Click outside */
+    uint32_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;

lib/libesp32_lvgl/lvgl/src/widgets/lv_btnmatrix.c

@@ -448,6 +448,9 @@ static void lv_btnmatrix_event(const lv_obj_class_t * class_p, lv_event_t * e)
                     invalidate_button_area(obj, btnm->btn_id_sel); /*Invalidate the new area*/
                 }
             }
+            else {
+                btnm->btn_id_sel = LV_BTNMATRIX_BTN_NONE;
+            }
         }
 
         if(btnm->btn_id_sel != LV_BTNMATRIX_BTN_NONE) {

lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.c

@@ -74,14 +74,16 @@ void lv_checkbox_set_text(lv_obj_t * obj, const char * txt)
     size_t len = strlen(txt);
 #endif
 
-    if(!cb->static_txt) cb->txt = lv_mem_realloc(cb->txt, len + 1);
+    char * _txt = (char *)cb->txt;
-    else  cb->txt = lv_mem_alloc(len + 1);
+    if(!cb->static_txt) _txt = lv_mem_realloc(_txt, len + 1);
+    else _txt = lv_mem_alloc(len + 1);
 #if LV_USE_ARABIC_PERSIAN_CHARS
-    _lv_txt_ap_proc(txt, cb->txt);
+    _lv_txt_ap_proc(txt, _txt);
 #else
-    strcpy(cb->txt, txt);
+    strcpy(_txt, txt);
 #endif
 
+    cb->txt = _txt;
     cb->static_txt = 0;
 
     lv_obj_refresh_self_size(obj);
@@ -92,7 +94,7 @@ void lv_checkbox_set_text_static(lv_obj_t * obj, const char * txt)
 {
     lv_checkbox_t * cb = (lv_checkbox_t *)obj;
 
-    if(!cb->static_txt) lv_mem_free(cb->txt);
+    if(!cb->static_txt) lv_mem_free((void *)cb->txt);
 
     cb->txt = (char *)txt;
     cb->static_txt = 1;
@@ -138,7 +140,7 @@ static void lv_checkbox_destructor(const lv_obj_class_t * class_p, lv_obj_t * ob
 
     lv_checkbox_t * cb = (lv_checkbox_t *)obj;
     if(!cb->static_txt) {
-        lv_mem_free(cb->txt);
+        lv_mem_free((void *)cb->txt);
         cb->txt = NULL;
     }
     LV_TRACE_OBJ_CREATE("finished");

lib/libesp32_lvgl/lvgl/src/widgets/lv_checkbox.h

@@ -28,7 +28,7 @@ extern "C" {
 
 typedef struct {
     lv_obj_t obj;
-    char * txt;
+    const char * txt;
     uint32_t static_txt : 1;
 } lv_checkbox_t;
 

lib/libesp32_lvgl/lvgl/src/widgets/lv_dropdown.c

@@ -407,14 +407,19 @@ int32_t lv_dropdown_get_option_index(lv_obj_t * obj, const char * option)
     const char * opts = lv_dropdown_get_options(obj);
     uint32_t char_i = 0;
     uint32_t opt_i = 0;
+    uint32_t option_len = strlen(option);
     const char * start = opts;
 
     while(start[char_i] != '\0') {
         for(char_i = 0; (start[char_i] != '\n') && (start[char_i] != '\0'); char_i++);
 
-        if(memcmp(start, option, LV_MIN(strlen(option), char_i)) == 0) return opt_i;
+        if(option_len == char_i && memcmp(start, option, LV_MIN(option_len, char_i)) == 0) {
+            return opt_i;
+        }
+
         start = &start[char_i];
         if(start[0] == '\n') start++;
+        char_i = 0;
         opt_i++;
     }
 

lib/libesp32_lvgl/lvgl/src/widgets/lv_table.c

@@ -40,7 +40,7 @@ static void refr_size_form_row(lv_obj_t * obj, uint32_t start_row);
 static void refr_cell_size(lv_obj_t * obj, uint32_t row, uint32_t col);
 static lv_res_t get_pressed_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col);
 static size_t get_cell_txt_len(const char * txt);
-static void copy_cell_txt(char * dst, const char * txt);
+static void copy_cell_txt(lv_table_cell_t * dst, const char * txt);
 static void get_cell_area(lv_obj_t * obj, uint16_t row, uint16_t col, lv_area_t * area);
 static void scroll_to_selected_cell(lv_obj_t * obj);
 
@@ -98,7 +98,14 @@ void lv_table_set_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col, const c
     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]->ctrl;
+
+#if LV_USE_USER_DATA
+    void * user_data = NULL;
+
+    /*Save the user data*/
+    if(table->cell_data[cell]) user_data = table->cell_data[cell]->user_data;
+#endif
 
     size_t to_allocate = get_cell_txt_len(txt);
 
@@ -108,7 +115,10 @@ void lv_table_set_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col, const c
 
     copy_cell_txt(table->cell_data[cell], txt);
 
-    table->cell_data[cell][0] = ctrl;
+    table->cell_data[cell]->ctrl = ctrl;
+#if LV_USE_USER_DATA
+    table->cell_data[cell]->user_data = user_data;
+#endif
     refr_cell_size(obj, row, col);
 }
 
@@ -131,7 +141,14 @@ 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]->ctrl;
+
+#if LV_USE_USER_DATA
+    void * user_data = NULL;
+
+    /*Save the user_data*/
+    if(table->cell_data[cell]) user_data = table->cell_data[cell]->user_data;
+#endif
 
     va_list ap, ap2;
     va_start(ap, fmt);
@@ -154,32 +171,35 @@ void lv_table_set_cell_value_fmt(lv_obj_t * obj, uint16_t row, uint16_t col, con
 
     /*Get the size of the Arabic text and process it*/
     size_t len_ap = _lv_txt_ap_calc_bytes_cnt(raw_txt);
-    table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], len_ap + 1);
+    table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], sizeof(lv_table_cell_t) + len_ap + 1);
     LV_ASSERT_MALLOC(table->cell_data[cell]);
     if(table->cell_data[cell] == NULL) {
         va_end(ap2);
         return;
     }
-    _lv_txt_ap_proc(raw_txt, &table->cell_data[cell][1]);
+    _lv_txt_ap_proc(raw_txt, table->cell_data[cell]->txt);
 
     lv_mem_buf_release(raw_txt);
 #else
-    table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell], len + 2); /*+1: trailing '\0; +1: format byte*/
+    table->cell_data[cell] = lv_mem_realloc(table->cell_data[cell],
+                                            sizeof(lv_table_cell_t) + len + 1); /*+1: trailing '\0; */
     LV_ASSERT_MALLOC(table->cell_data[cell]);
     if(table->cell_data[cell] == NULL) {
         va_end(ap2);
         return;
     }
 
-    table->cell_data[cell][len + 1] = 0; /*Ensure NULL termination*/
+    table->cell_data[cell]->txt[len] = 0; /*Ensure NULL termination*/
 
-    lv_vsnprintf(&table->cell_data[cell][1], len + 1, fmt, ap2);
+    lv_vsnprintf(table->cell_data[cell]->txt, len + 1, fmt, ap2);
 #endif
 
     va_end(ap2);
 
-    table->cell_data[cell][0] = ctrl;
+    table->cell_data[cell]->ctrl = ctrl;
-
+#if LV_USE_USER_DATA
+    table->cell_data[cell]->user_data = user_data;
+#endif
     refr_cell_size(obj, row, col);
 }
 
@@ -204,11 +224,17 @@ void lv_table_set_row_cnt(lv_obj_t * obj, uint16_t 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++) {
+#if LV_USE_USER_DATA
+            if(table->cell_data[i]->user_data) {
+                lv_mem_free(table->cell_data[i]->user_data);
+                table->cell_data[i]->user_data = NULL;
+            }
+#endif
             lv_mem_free(table->cell_data[i]);
         }
     }
 
-    table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(char *));
+    table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(lv_table_cell_t *));
     LV_ASSERT_MALLOC(table->cell_data);
     if(table->cell_data == NULL) return;
 
@@ -233,7 +259,7 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt)
     uint16_t old_col_cnt = table->col_cnt;
     table->col_cnt         = col_cnt;
 
-    char ** new_cell_data = lv_mem_alloc(table->row_cnt * table->col_cnt * sizeof(char *));
+    lv_table_cell_t ** new_cell_data = lv_mem_alloc(table->row_cnt * table->col_cnt * sizeof(lv_table_cell_t *));
     LV_ASSERT_MALLOC(new_cell_data);
     if(new_cell_data == NULL) return;
     uint32_t new_cell_cnt = table->col_cnt * table->row_cnt;
@@ -256,6 +282,12 @@ void lv_table_set_col_cnt(lv_obj_t * obj, uint16_t col_cnt)
         int32_t i;
         for(i = 0; i < (int32_t)old_col_cnt - col_cnt; i++) {
             uint32_t idx = old_col_start + min_col_cnt + i;
+#if LV_USE_USER_DATA
+            if(table->cell_data[idx]->user_data) {
+                lv_mem_free(table->cell_data[idx]->user_data);
+                table->cell_data[idx]->user_data = NULL;
+            }
+#endif
             lv_mem_free(table->cell_data[idx]);
             table->cell_data[idx] = NULL;
         }
@@ -304,15 +336,18 @@ void lv_table_add_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table
     uint32_t cell = row * table->col_cnt + col;
 
     if(is_cell_empty(table->cell_data[cell])) {
-        table->cell_data[cell]    = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/
+        table->cell_data[cell]    = lv_mem_alloc(sizeof(lv_table_cell_t) + 1); /*+1: trailing '\0 */
         LV_ASSERT_MALLOC(table->cell_data[cell]);
         if(table->cell_data[cell] == NULL) return;
 
-        table->cell_data[cell][0] = 0;
+        table->cell_data[cell]->ctrl = 0;
-        table->cell_data[cell][1] = '\0';
+#if LV_USE_USER_DATA
+        table->cell_data[cell]->user_data = NULL;
+#endif
+        table->cell_data[cell]->txt[0] = '\0';
     }
 
-    table->cell_data[cell][0] |= ctrl;
+    table->cell_data[cell]->ctrl |= ctrl;
 }
 
 void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl)
@@ -328,17 +363,51 @@ void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_tab
     uint32_t cell = row * table->col_cnt + col;
 
     if(is_cell_empty(table->cell_data[cell])) {
-        table->cell_data[cell]    = lv_mem_alloc(2); /*+1: trailing '\0; +1: format byte*/
+        table->cell_data[cell]    = lv_mem_alloc(sizeof(lv_table_cell_t) + 1); /*+1: trailing '\0 */
         LV_ASSERT_MALLOC(table->cell_data[cell]);
         if(table->cell_data[cell] == NULL) return;
 
-        table->cell_data[cell][0] = 0;
+        table->cell_data[cell]->ctrl = 0;
-        table->cell_data[cell][1] = '\0';
+#if LV_USE_USER_DATA
+        table->cell_data[cell]->user_data = NULL;
+#endif
+        table->cell_data[cell]->txt[0] = '\0';
     }
 
-    table->cell_data[cell][0] &= (~ctrl);
+    table->cell_data[cell]->ctrl &= (~ctrl);
 }
 
+#if LV_USE_USER_DATA
+void lv_table_set_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col, void * user_data)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_table_t * table = (lv_table_t *)obj;
+
+    /*Auto expand*/
+    if(col >= table->col_cnt) lv_table_set_col_cnt(obj, col + 1);
+    if(row >= table->row_cnt) lv_table_set_row_cnt(obj, row + 1);
+
+    uint32_t cell = row * table->col_cnt + col;
+
+    if(is_cell_empty(table->cell_data[cell])) {
+        table->cell_data[cell]    = lv_mem_alloc(sizeof(lv_table_cell_t) + 1); /*+1: trailing '\0 */
+        LV_ASSERT_MALLOC(table->cell_data[cell]);
+        if(table->cell_data[cell] == NULL) return;
+
+        table->cell_data[cell]->ctrl = 0;
+        table->cell_data[cell]->user_data = NULL;
+        table->cell_data[cell]->txt[0] = '\0';
+    }
+
+    if(table->cell_data[cell]->user_data) {
+        lv_mem_free(table->cell_data[cell]->user_data);
+    }
+
+    table->cell_data[cell]->user_data = user_data;
+}
+#endif
+
 /*=====================
  * Getter functions
  *====================*/
@@ -356,7 +425,7 @@ const char * lv_table_get_cell_value(lv_obj_t * obj, uint16_t row, uint16_t col)
 
     if(is_cell_empty(table->cell_data[cell])) return "";
 
-    return &table->cell_data[cell][1]; /*Skip the format byte*/
+    return table->cell_data[cell]->txt;
 }
 
 uint16_t lv_table_get_row_cnt(lv_obj_t * obj)
@@ -401,7 +470,7 @@ bool lv_table_has_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table
     uint32_t cell = row * table->col_cnt + col;
 
     if(is_cell_empty(table->cell_data[cell])) return false;
-    else return (table->cell_data[cell][0] & ctrl) == ctrl;
+    else return (table->cell_data[cell]->ctrl & ctrl) == ctrl;
 }
 
 void lv_table_get_selected_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col)
@@ -411,6 +480,24 @@ void lv_table_get_selected_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col)
     *col = table->col_act;
 }
 
+#if LV_USE_USER_DATA
+void * lv_table_get_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col)
+{
+    LV_ASSERT_OBJ(obj, MY_CLASS);
+
+    lv_table_t * table = (lv_table_t *)obj;
+    if(row >= table->row_cnt || col >= table->col_cnt) {
+        LV_LOG_WARN("invalid row or column");
+        return NULL;
+    }
+    uint32_t cell = row * table->col_cnt + col;
+
+    if(is_cell_empty(table->cell_data[cell])) return NULL;
+
+    return table->cell_data[cell]->user_data;
+}
+#endif
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -428,7 +515,7 @@ static void lv_table_constructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
     table->row_h = lv_mem_alloc(table->row_cnt * sizeof(table->row_h[0]));
     table->col_w[0] = LV_DPI_DEF;
     table->row_h[0] = LV_DPI_DEF;
-    table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(char *));
+    table->cell_data = lv_mem_realloc(table->cell_data, table->row_cnt * table->col_cnt * sizeof(lv_table_cell_t *));
     table->cell_data[0] = NULL;
 
     LV_TRACE_OBJ_CREATE("finished");
@@ -442,6 +529,12 @@ static void lv_table_destructor(const lv_obj_class_t * class_p, lv_obj_t * obj)
     uint16_t i;
     for(i = 0; i < table->col_cnt * table->row_cnt; i++) {
         if(table->cell_data[i]) {
+#if LV_USE_USER_DATA
+            if(table->cell_data[i]->user_data) {
+                lv_mem_free(table->cell_data[i]->user_data);
+                table->cell_data[i]->user_data = NULL;
+            }
+#endif
             lv_mem_free(table->cell_data[i]);
             table->cell_data[i] = NULL;
         }
@@ -639,7 +732,7 @@ static void draw_main(lv_event_t * e)
 
         for(col = 0; col < table->col_cnt; col++) {
             lv_table_cell_ctrl_t ctrl = 0;
-            if(table->cell_data[cell]) ctrl = table->cell_data[cell][0];
+            if(table->cell_data[cell]) ctrl = table->cell_data[cell]->ctrl;
 
             if(rtl) {
                 cell_area.x2 = cell_area.x1 - 1;
@@ -652,11 +745,11 @@ static void draw_main(lv_event_t * e)
 
             uint16_t col_merge = 0;
             for(col_merge = 0; col_merge + col < table->col_cnt - 1; col_merge++) {
-                char * next_cell_data = table->cell_data[cell + col_merge];
+                lv_table_cell_t * next_cell_data = table->cell_data[cell + col_merge];
 
                 if(is_cell_empty(next_cell_data)) break;
 
-                lv_table_cell_ctrl_t merge_ctrl = (lv_table_cell_ctrl_t) next_cell_data[0];
+                lv_table_cell_ctrl_t merge_ctrl = (lv_table_cell_ctrl_t) next_cell_data->ctrl;
                 if(merge_ctrl & LV_TABLE_CELL_CTRL_MERGE_RIGHT) {
                     lv_coord_t offset = table->col_w[col + col_merge + 1];
 
@@ -739,7 +832,7 @@ static void draw_main(lv_event_t * e)
                 bool crop = ctrl & LV_TABLE_CELL_CTRL_TEXT_CROP ? true : false;
                 if(crop) txt_flags = LV_TEXT_FLAG_EXPAND;
 
-                lv_txt_get_size(&txt_size, table->cell_data[cell] + 1, label_dsc_def.font,
+                lv_txt_get_size(&txt_size, table->cell_data[cell]->txt, label_dsc_def.font,
                                 label_dsc_act.letter_space, label_dsc_act.line_space,
                                 lv_area_get_width(&txt_area), txt_flags);
 
@@ -754,7 +847,7 @@ static void draw_main(lv_event_t * e)
                 label_mask_ok = _lv_area_intersect(&label_clip_area, &clip_area, &cell_area);
                 if(label_mask_ok) {
                     draw_ctx->clip_area = &label_clip_area;
-                    lv_draw_label(draw_ctx, &label_dsc_act, &txt_area, table->cell_data[cell] + 1, NULL);
+                    lv_draw_label(draw_ctx, &label_dsc_act, &txt_area, table->cell_data[cell]->txt, NULL);
                     draw_ctx->clip_area = &clip_area;
                 }
             }
@@ -845,7 +938,7 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
     uint16_t cell;
     uint16_t col;
     for(cell = row_start, col = 0; cell < row_start + table->col_cnt; cell++, col++) {
-        char * cell_data = table->cell_data[cell];
+        lv_table_cell_t * cell_data = table->cell_data[cell];
 
         if(is_cell_empty(cell_data)) {
             continue;
@@ -858,11 +951,11 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
          * exit the traversal when the current cell control is not LV_TABLE_CELL_CTRL_MERGE_RIGHT */
         uint16_t col_merge = 0;
         for(col_merge = 0; col_merge + col < table->col_cnt - 1; col_merge++) {
-            char * next_cell_data = table->cell_data[cell + col_merge];
+            lv_table_cell_t * next_cell_data = table->cell_data[cell + col_merge];
 
             if(is_cell_empty(next_cell_data)) break;
 
-            lv_table_cell_ctrl_t ctrl = (lv_table_cell_ctrl_t) next_cell_data[0];
+            lv_table_cell_ctrl_t ctrl = (lv_table_cell_ctrl_t) next_cell_data->ctrl;
             if(ctrl & LV_TABLE_CELL_CTRL_MERGE_RIGHT) {
                 txt_w += table->col_w[col + col_merge + 1];
             }
@@ -871,7 +964,7 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
             }
         }
 
-        lv_table_cell_ctrl_t ctrl = (lv_table_cell_ctrl_t) cell_data[0];
+        lv_table_cell_ctrl_t ctrl = (lv_table_cell_ctrl_t) cell_data->ctrl;
 
         /*When cropping the text we can assume the row height is equal to the line height*/
         if(ctrl & LV_TABLE_CELL_CTRL_TEXT_CROP) {
@@ -883,7 +976,7 @@ static lv_coord_t get_row_height(lv_obj_t * obj, uint16_t row_id, const lv_font_
             lv_point_t txt_size;
             txt_w -= cell_left + cell_right;
 
-            lv_txt_get_size(&txt_size, table->cell_data[cell] + 1, font,
+            lv_txt_get_size(&txt_size, table->cell_data[cell]->txt, font,
                             letter_space, line_space, txt_w, LV_TEXT_FLAG_NONE);
 
             h_max = LV_MAX(txt_size.y + cell_top + cell_bottom, h_max);
@@ -953,23 +1046,21 @@ static size_t get_cell_txt_len(const char * txt)
     size_t retval = 0;
 
 #if LV_USE_ARABIC_PERSIAN_CHARS
-    retval = _lv_txt_ap_calc_bytes_cnt(txt) + 1;
+    retval = sizeof(lv_table_cell_t) + _lv_txt_ap_calc_bytes_cnt(txt) + 1;
 #else
-    /* cell_data layout: [ctrl][txt][trailing '\0' terminator]
+    retval = sizeof(lv_table_cell_t) + strlen(txt) + 1;
-     * +2 because of the trailing '\0' and the ctrl */
-    retval = strlen(txt) + 2;
 #endif
 
     return retval;
 }
 
 /* Copy txt into dst skipping the format byte */
-static void copy_cell_txt(char * dst, const char * txt)
+static void copy_cell_txt(lv_table_cell_t * dst, const char * txt)
 {
 #if LV_USE_ARABIC_PERSIAN_CHARS
-    _lv_txt_ap_proc(txt, &dst[1]);
+    _lv_txt_ap_proc(txt, dst->txt);
 #else
-    strcpy(&dst[1], txt);
+    strcpy(dst->txt, txt);
 #endif
 }
 

lib/libesp32_lvgl/lvgl/src/widgets/lv_table.h

@@ -46,12 +46,21 @@ enum {
 
 typedef uint8_t  lv_table_cell_ctrl_t;
 
+/*Data of cell*/
+typedef struct {
+    lv_table_cell_ctrl_t ctrl;
+#if LV_USE_USER_DATA
+    void * user_data; /**< Custom user data*/
+#endif
+    char txt[];
+} lv_table_cell_t;
+
 /*Data of table*/
 typedef struct {
     lv_obj_t obj;
     uint16_t col_cnt;
     uint16_t row_cnt;
-    char ** cell_data;
+    lv_table_cell_t ** cell_data;
     lv_coord_t * row_h;
     lv_coord_t * col_w;
     uint16_t col_act;
@@ -144,6 +153,17 @@ void lv_table_add_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table
  */
 void lv_table_clear_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table_cell_ctrl_t ctrl);
 
+#if LV_USE_USER_DATA
+/**
+ * Add custom user data to the cell.
+ * @param obj       pointer to a Table object
+ * @param row       id of the row [0 .. row_cnt -1]
+ * @param col       id of the column [0 .. col_cnt -1]
+ * @param user_data pointer to the new user_data. It must be allocated by user as it will be freed automatically
+ */
+void lv_table_set_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col, void * user_data);
+#endif
+
 /*=====================
  * Getter functions
  *====================*/
@@ -197,6 +217,16 @@ bool lv_table_has_cell_ctrl(lv_obj_t * obj, uint16_t row, uint16_t col, lv_table
  */
 void lv_table_get_selected_cell(lv_obj_t * obj, uint16_t * row, uint16_t * col);
 
+#if LV_USE_USER_DATA
+/**
+ * Get custom user data to the cell.
+ * @param obj       pointer to a Table object
+ * @param row       id of the row [0 .. row_cnt -1]
+ * @param col       id of the column [0 .. col_cnt -1]
+ */
+void * lv_table_get_cell_user_data(lv_obj_t * obj, uint16_t row, uint16_t col);
+#endif
+
 /**********************
  *      MACROS
  **********************/